diff --git a/README.md b/README.md
index b13ddb71374291f535308339e47c2d19f84c1d8b..940f4416f0f2761321406ab19aa3a2789532ff39 100644
--- a/README.md
+++ b/README.md
@@ -50,8 +50,7 @@ For this it is best to set up a virtual environment. Activate the virtualenviron
 
 Then run:
 ```
-python setup.py clean && python setup.py build --force && python setup.py sdist && pip install -v dist/binarycpython-<version of this package>.tar.gz
-python setup.py clean && pip uninstall binarycpython && rm dist/* && python setup.py build --force && python setup.py sdist && pip install -v dist/binarycpython-<version of this package>.tar.gz
+python setup.py clean && pip uninstall binarycpython && python setup.py build --force && python setup.py sdist && pip install -v dist/binarycpython-<version of this package>.tar.gz
 ```
 This will clean the build directory, remove binarycpython from the venv, remove the dist packages, and then rebuilding and reinstalling the package. You can find the version of this package in setup.py.
 
@@ -59,7 +58,7 @@ This will install this package into the virtual environment. Making changes to t
 
 If this is not the first time you install the package, but rather rebuild it because you make changes in either binary_c or binarycpython, you should ignore the currently installed version, and also skip installing the dependencies again, by executing the following command:
 ```
-python setup.py clean && pip uninstall binarycpython && rm dist/* && python setup.py build --force && python setup.py sdist && pip install --ignore-installed --no-dependencies -v dist/binarycpython-<version of this package>.tar.gz
+python setup.py clean && pip uninstall binarycpython && python setup.py build --force && python setup.py sdist && pip install --ignore-installed --no-dependencies -v dist/binarycpython-<version of this package>.tar.gz
 ```
 
 #### After installation
diff --git a/binarycpython/tests/main.py b/binarycpython/tests/main.py
index abafd95b221ca038e06521ed47a79c4f7198e336..a30a9e42d14aa41f94f234281c10ef317f6ec980 100755
--- a/binarycpython/tests/main.py
+++ b/binarycpython/tests/main.py
@@ -17,7 +17,6 @@ from binarycpython.tests.test_spacing_functions import *
 from binarycpython.tests.test_useful_funcs import *
 from binarycpython.tests.test_grid_options_defaults import *
 from binarycpython.tests.test_stellar_types import *
-from test_notebooks import *
 
 if __name__ == "__main__":
     unittest.main()
diff --git a/binarycpython/tests/main_with_notebooks.py b/binarycpython/tests/main_with_notebooks.py
new file mode 100755
index 0000000000000000000000000000000000000000..abafd95b221ca038e06521ed47a79c4f7198e336
--- /dev/null
+++ b/binarycpython/tests/main_with_notebooks.py
@@ -0,0 +1,23 @@
+#/usr/bin/env python
+"""
+Main file for the tests. This file imports all the combined_test functions from all files.
+"""
+
+import unittest
+
+from binarycpython.tests.test_c_bindings import *
+from binarycpython.tests.test_custom_logging import *
+from binarycpython.tests.test_distributions import *
+from binarycpython.tests.test_functions import *
+from binarycpython.tests.test_grid import *
+from binarycpython.tests.test_hpc_functions import *
+from binarycpython.tests.test_plot_functions import *
+from binarycpython.tests.test_run_system_wrapper import *
+from binarycpython.tests.test_spacing_functions import *
+from binarycpython.tests.test_useful_funcs import *
+from binarycpython.tests.test_grid_options_defaults import *
+from binarycpython.tests.test_stellar_types import *
+from test_notebooks import *
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/binarycpython/utils/functions.py b/binarycpython/utils/functions.py
index 539601288eff8623c04629dff88d94be37ce582f..f16992d31ef71784fb8d5ddc5166e45436f79df1 100644
--- a/binarycpython/utils/functions.py
+++ b/binarycpython/utils/functions.py
@@ -362,7 +362,7 @@ def pad_output_distribution(dist : dict,
     """
     Given a distribution, dist (a dictionary), which should be binned every binwidth (float), fill the distribution with zeros when there is no data. Note: this changes the data in place.
     """
-    
+
     # sorted list of the keys
     skeys = sorted(dist.keys(), key = lambda x: float(x))
 
@@ -472,7 +472,6 @@ def verbose_print(message: str, verbosity: int, minimal_verbosity: int) -> None:
     if verbosity >= minimal_verbosity:
         print(message)
 
-
 def remove_file(file: str, verbosity: int = 0) -> None:
     """
     Function to remove files but with verbosity
diff --git a/binarycpython/utils/grid.py b/binarycpython/utils/grid.py
index c30f45c33910f2abf6527ede10a9ea205cedb6a0..d695262ce35ffa79f238b89731bb05b04e4f0b25 100644
--- a/binarycpython/utils/grid.py
+++ b/binarycpython/utils/grid.py
@@ -32,6 +32,7 @@ import datetime
 import argparse
 import importlib.util
 import multiprocessing
+import resource
 from typing import Union, Any
 from collections import (
     OrderedDict,
@@ -92,6 +93,7 @@ from binarycpython.utils.distribution_functions import (
 
 from binarycpython import _binary_c_bindings
 
+secs_per_day = 86400 # probably needs to go somewhere more sensible
 
 class Population:
     """
@@ -99,7 +101,7 @@ class Population:
     population of systems
     """
 
-    def __init__(self):
+    def __init__(self, **kwargs):
         """
         Initialisation function of the population class
         """
@@ -124,10 +126,13 @@ class Population:
         # Custom options
         self.custom_options = {}
 
+        # Set the options that are passed at creation of the object
+        self.set(**kwargs)
+
         # Load M&s options
         self.grid_options['m&s_options'] = copy.deepcopy(moe_di_stefano_default_options)
 
-        # Write M&S options to a file
+        # Write M&S options to a file. NOTE: not sure why i put this here anymore
         os.makedirs(os.path.join(self.grid_options["tmp_dir"], "moe_distefano"), exist_ok=True)
         with open(os.path.join(os.path.join(self.grid_options["tmp_dir"], "moe_distefano"), "moeopts.dat"), "w") as f:
             f.write(json.dumps(self.grid_options['m&s_options'], indent=4))
@@ -135,13 +140,16 @@ class Population:
         # Argline dict
         self.argline_dict = {}
 
-        # Set main process id
-        self.grid_options["_main_pid"] = os.getpid()
-
         # Set some memory dicts
         self.persistent_data_memory_dict = {}
 
-        #
+        # shared memory used for logging
+        self.shared_memory = {}
+
+        # Set global (OS) process id
+        self.grid_options["_main_pid"] = os.getpid()
+
+        # local process ID
         self.process_ID = 0
 
         # Create location to store results. Users should write to this dictionary.
@@ -163,7 +171,7 @@ class Population:
     # - For a population the bse_options will get copied to a temp_bse_options dict and updated with
     #   all the parameters generated by the grid
 
-    # I will NOT create the argument line by fully writing ALL the defaults and overriding user
+    # I will not create the argument line by fully writing all the defaults and overriding user
     # input, that seems not necessary because by using the get_defaults() function we already
     # know for sure which parameter names are valid for the binary_c version
     # And because binary_c uses internal defaults, its not necessary to explicitly pass them.
@@ -187,8 +195,6 @@ class Population:
             via kwargs all the arguments are either set to binary_c parameters, grid_options or custom_options (see above)
         """
 
-        # Select the params that end with %d
-
         # Go over all the input
         for key in kwargs:
             # Filter out keys for the bse_options
@@ -235,7 +241,7 @@ class Population:
                         key, kwargs[key]
                     ),
                     self.grid_options["verbosity"],
-                    1,
+                    0, # NOTE: setting this to be 0 prevents mistakes being overlooked. 
                 )
                 self.custom_options[key] = kwargs[key]
 
@@ -550,7 +556,6 @@ class Population:
         Returns:
             dictionary containing "bse_options", "grid_options", "custom_options"
         """
-
         options = {
             "bse_options": self.bse_options,
             "grid_options": self.grid_options,
@@ -604,7 +609,6 @@ class Population:
 
         #
         all_info = {}
-
         #
         if include_population_settings:
             population_settings = self.return_population_settings()
@@ -819,6 +823,14 @@ class Population:
         # Reset population ID:
         self.grid_options["_population_id"] = uuid.uuid4().hex
 
+        # set previous logging time
+        self.shared_memory["prev_log_time"] = multiprocessing.Value('d',time.time())
+        # set previous logging system number to 0
+        self.shared_memory["prev_log_system_number"] = multiprocessing.Value('i',0)
+        # array to store memory use per-thread
+        mem = self._mem_use()
+        self.shared_memory["memory_use_per_thread"] = multiprocessing.Array('d',[1.0*mem]*self.grid_options["amt_cores"])
+
     def clean(
         self
     ) -> None:
@@ -836,7 +848,7 @@ class Population:
         """
         Entry point function of the whole object. From here, based on the settings,
         we set up a SLURM or CONDOR grid, or if no setting is given we go straight
-        to evolving the population. 
+        to evolving the population.
 
         There are no direct arguments to this function, rather it is based on the grid_options settings:
             grid_options['slurm']: integer Boolean whether to use a slurm_grid evolution
@@ -935,7 +947,7 @@ class Population:
                 )
             )
 
-        #
+        # finished!
         self.grid_options["_end_time_evolution"] = time.time()
 
         # Log and print some information
@@ -1075,7 +1087,6 @@ class Population:
 
         # Set process name
         setproctitle.setproctitle('binarycpython parent process')
-        setproctitle.setthreadtitle("binarycpython parent thread")
 
         # Set up the manager object that can share info between processes
         manager = multiprocessing.Manager()
@@ -1229,7 +1240,7 @@ class Population:
         name = 'binarycpython population thread {}'.format(ID)
         name_proc = 'binarycpython population process {}'.format(ID)
         setproctitle.setproctitle(name_proc)
-        setproctitle.setthreadtitle(name)
+        # setproctitle.setthreadtitle(name)
 
         # Set to starting up
         with open(
@@ -1285,6 +1296,9 @@ class Population:
         zero_prob_stars_skipped = 0
 
         total_time_calling_binary_c = 0
+        start_grid_time = time.time()
+        next_log_time = self.shared_memory["prev_log_time"].value + self.grid_options["log_dt"]
+        next_mem_update_time = start_grid_time + self.grid_options["log_dt"]
 
         total_mass_run = 0
         total_probability_weighted_mass_run = 0
@@ -1349,11 +1363,31 @@ class Population:
             # )
 
             #
-            verbose_print(
-                "Process {} is handling system {}".format(ID, system_number),
-                self.grid_options["verbosity"],
-                1,
-            )
+
+#            verbose_print(
+#                "Process {} is handling system {}".format(ID, system_number),
+#                self.grid_options["verbosity"],
+#                1,
+#            )
+
+            # save the current time (used often)
+            now = time.time()
+
+            # update memory use stats every log_dt seconds (not every time, this is likely a bit expensive)
+            if now > next_mem_update_time:
+                self.shared_memory["memory_use_per_thread"][ID] = self._mem_use()
+                next_mem_update = now + self.grid_options["log_dt"]
+
+            # calculate the next logging time
+            next_log_time = self.shared_memory["prev_log_time"].value + self.grid_options["log_dt"]
+
+            if now > next_log_time:
+                # we have exceeded the next log time : output and update timers
+                lock = multiprocessing.Lock()
+                self.vb1print(ID,now,system_number)
+                next_log_time = now + self.grid_options["log_dt"]
+                self.shared_memory["prev_log_time"].value = now
+                self.shared_memory["prev_log_system_number"].value = system_number
 
             # In some cases, the whole run crashes. To be able to figure out which system
             # that was on, we log each current system to a file (each thread has one).
@@ -1608,7 +1642,7 @@ class Population:
         # Check if there are actually arguments passed:
         if self.bse_options:
 
-            # Get argument line and 
+            # Get argument line and
             argline = self._return_argline(self.bse_options)
 
             verbose_print("Running {}".format(argline), self.grid_options["verbosity"], 1)
@@ -1623,7 +1657,7 @@ class Population:
                 population=0,
             )
 
-            # Clean up custom logging 
+            # Clean up custom logging
             if clean_up_custom_logging_files:
                 self._clean_up_custom_logging(evol_type="single")
 
@@ -4140,3 +4174,87 @@ eccentricity3=0
         )
 
         return multiplicity_fraction_dict[system_dict['multiplicity']]
+
+    def _trem(self,dt,count,dn,n):
+        """
+        Estimate time remaining (seconds) given a differential time and count (i.e. progress = $count/$n). $dt is the time since the last call, $count is the current progress count, $dn is the number run since the last call, and $n is the total number required.
+        """
+        tpr = dt / max(1,dn)
+        etasecs = tpr * (n - count)
+        (eta,units) = self._conv_time_units(etasecs)
+        return (eta,units,tpr,etasecs)
+
+    def _conv_time_units(self,t):
+        """
+        Converts time (t, in seconds, passing in as the only argument) to seconds, minutes or hours depending on its magnitude. Returns a tuple (t,units).
+        """
+        units='s'; # default to seconds
+        if t > 60:
+            t /= 60;
+            units='m';
+        if t > 60:
+            t /=60;
+            units='h';
+        return (t,units)
+
+    def vb1print(self,ID,now,system_number):
+        """
+        Verbosity-level 1 printing, to keep an eye on a grid.
+        Arguments:
+                 ID : thread ID for debugging (int)
+                 now : the time now as a UNIX-style epoch in seconds (float)
+                 system_number : the system number
+        """
+        # calculate estimated time of arrive (eta and eta_secs), time per run (tpr)
+        localtime = time.localtime(now)
+        dt = now - self.shared_memory["prev_log_time"].value
+        dn = system_number - self.shared_memory["prev_log_system_number"].value
+        (eta,units,tpr,eta_secs) = self._trem(dt,
+                                              system_number,
+                                              dn,
+                                              self.grid_options["_total_starcount"])
+        if eta_secs < secs_per_day:
+            fintime = time.localtime(now + eta_secs)
+            etf = "{hours:02d}:{minutes:02d}:{seconds:02d}".format(hours = fintime.tm_hour,
+                                                                   minutes = fintime.tm_min,
+                                                                   seconds = fintime.tm_sec)
+        else:
+            d = int(eta_secs/secs_per_day)
+            if d == 1:
+                etf = "Tomorrow"
+            else:
+                etf = "In " + d + " days"
+
+        # modulo information
+        if self.grid_options['modulo'] == 1:
+            modulo = '' # usual case
+        else:
+            modulo = '%' + str(self.grid_options['modulo'])
+
+        # add up memory use from each thread
+        mem_use = sum(self.shared_memory["memory_use_per_thread"])
+
+        verbose_print(
+            "{system_number}/{total_starcount}{modulo} {complete:5.1f}% complete {hours:02d}:{minutes:02d}:{seconds:02d} ETA={eta:7.1f}{units} tpr={tpr:2.2e} ETF={etf} mem:{mem_use:.1f}MB".format(
+                system_number = system_number,
+                total_starcount = self.grid_options["_total_starcount"],
+                complete=(100.0*system_number)/(1.0*self.grid_options["_total_starcount"]) if self.grid_options["_total_starcount"] else -1,
+                modulo = modulo,
+                hours = localtime.tm_hour,
+                minutes = localtime.tm_min,
+                seconds = localtime.tm_sec,
+                eta = eta,
+                units = units,
+                tpr = tpr,
+                etf = etf,
+                mem_use = mem_use
+            ),
+            self.grid_options["verbosity"],
+            1
+        )
+
+    def _mem_use(self):
+        """
+        Return current process memory use in MB. (Takes no arguments) Note: this is per-thread only.
+        """
+        return resource.getrusage(resource.RUSAGE_SELF).ru_maxrss / 1024.0
diff --git a/binarycpython/utils/grid_options_defaults.py b/binarycpython/utils/grid_options_defaults.py
index d01f92fcc3786eeada771de7e1a83f597b4ccfbd..9dbcdb705936f0f2776eaf8d8eed9afd2f2e10b7 100644
--- a/binarycpython/utils/grid_options_defaults.py
+++ b/binarycpython/utils/grid_options_defaults.py
@@ -1,14 +1,14 @@
 """
-Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries: 
+Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries:
     - grid_options_defaults_dict: dictionary containing the default values for all the options
     - grid_options_descriptions: dictionary containing the description for these options.
 
 There are several other functions in this module, mostly to generate help texts or documents:
-    - grid_options_help: interactive function for the user to get descriptions for options 
+    - grid_options_help: interactive function for the user to get descriptions for options
     - grid_options_description_checker: function that checks that checks which options have a description.
     - write_grid_options_to_rst_file: function to generate the .rst document for the docs
 
-With this its also possible to automatically generate a document containing all the setting names + descriptions. 
+With this its also possible to automatically generate a document containing all the setting names + descriptions.
 
 All the options starting with _ should not be changed by the user except when you really know what you're doing (which is probably hacking the code :P)
 """
@@ -50,6 +50,7 @@ grid_options_defaults_dict = {
     "log_file": os.path.join(
         temp_dir(), "binary_c_python.log"
     ),  # Set to None to not log to file. The directory will be created
+    "log_dt" : 5, # time between vb=1 logging outputs
     ##########################
     # binary_c files
     ##########################
@@ -534,7 +535,7 @@ moe_di_stefano_default_options = {
         "ecc": [0.0, 0.99],
     },
     # minimum stellar mass
-    "Mmin": float(return_binary_c_version_info(parsed=True)['macros']['BINARY_C_MINIMUM_STELLAR_MASS']), # We take the value that binary_c has set as the default 
+    "Mmin": float(return_binary_c_version_info(parsed=True)['macros']['BINARY_C_MINIMUM_STELLAR_MASS']), # We take the value that binary_c has set as the default
 
     # multiplicity model (as a function of log10M1)
     #
diff --git a/docs/Makefile b/docs/Makefile
index df35e01697db9389c44e32fd672a7608c15c1f7f..ec7d84a15c00bfcddd94607dc68b7bdcbbe7b14d 100644
--- a/docs/Makefile
+++ b/docs/Makefile
@@ -26,7 +26,10 @@ help:
 	cp ../examples/notebook_extra_features.ipynb source/
 	cp ../examples/notebook_api_functionality.ipynb source/
 	cp ../examples/notebook_luminosity_function_single.ipynb source/
-
+	cp ../examples/notebook_luminosity_function_binaries.ipynb source/
+	cp ../examples/notebook_HRD.ipynb source/
+	cp ../examples/notebook_common_envelope_evolution.ipynb source/
+	
 	# Copy the badges
 	cp -r ../badges/ source/
 	
diff --git a/docs/build/doctrees/binary_c_parameters.doctree b/docs/build/doctrees/binary_c_parameters.doctree
index f6338cfabfc2f18737da714694c03fafe5132542..95b8f7090e04fa0459582c8d43f09c730a2d45a3 100644
Binary files a/docs/build/doctrees/binary_c_parameters.doctree and b/docs/build/doctrees/binary_c_parameters.doctree differ
diff --git a/docs/build/doctrees/environment.pickle b/docs/build/doctrees/environment.pickle
index e0ed39a409e8733fee869823a5a3c54d0b789365..61181afdb4f5e62b0fa4b32c33d50998e3a99a0a 100644
Binary files a/docs/build/doctrees/environment.pickle and b/docs/build/doctrees/environment.pickle differ
diff --git a/docs/build/doctrees/example_notebooks.doctree b/docs/build/doctrees/example_notebooks.doctree
index b9bef3c20dc63831463b0ae0c0e0c9848b042660..a352e95a0d22a41b8f80e39ff4308c96db027b27 100644
Binary files a/docs/build/doctrees/example_notebooks.doctree and b/docs/build/doctrees/example_notebooks.doctree differ
diff --git a/docs/build/doctrees/functions.doctree b/docs/build/doctrees/functions.doctree
index 404ea6de34f4477f068902d88dfe218f3316327e..cd805d6b1cd93d5e9d46d6ef07f6497939a92505 100644
Binary files a/docs/build/doctrees/functions.doctree and b/docs/build/doctrees/functions.doctree differ
diff --git a/docs/build/doctrees/grid.doctree b/docs/build/doctrees/grid.doctree
index 36082ca3d96c82d3c7cd14d66b743fc2703a1cc2..e45c1acb9e1a01e68fe24b85a89f17f67c85a0c8 100644
Binary files a/docs/build/doctrees/grid.doctree and b/docs/build/doctrees/grid.doctree differ
diff --git a/docs/build/doctrees/grid_options_descriptions.doctree b/docs/build/doctrees/grid_options_descriptions.doctree
index ef9f5f153be768b3795647b853039c46c3f89296..1e8841878b5416327ae4627ab83e4c39cc365b98 100644
Binary files a/docs/build/doctrees/grid_options_descriptions.doctree and b/docs/build/doctrees/grid_options_descriptions.doctree differ
diff --git a/docs/build/doctrees/index.doctree b/docs/build/doctrees/index.doctree
index d7befe589c22002c2d96c3f547c3035fdae1fab4..05f3ff5a58b6c27b26dbd1fa53daec18af13fac6 100644
Binary files a/docs/build/doctrees/index.doctree and b/docs/build/doctrees/index.doctree differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_HRD.ipynb b/docs/build/doctrees/nbsphinx/notebook_HRD.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..52590f8a2a6abc7245e9ea0c08d274432cd2a1ad
--- /dev/null
+++ b/docs/build/doctrees/nbsphinx/notebook_HRD.ipynb
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Hertzsprung-Russell diagrams\n",
+    "\n",
+    "In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_HRD\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "First we set up a new population object. Our stars evolve to $13.7\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to $13.7\\mathrm{Gyr}$, and stars are not really born with a metallicity of $0.02$. These approximations only affect very low mass stars, so we assume all our stars have mass $M\\geq 1 \\mathrm{M}_\\odot$, and metallicity does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to $M\\leq 10 \\mathrm{M}_\\odot$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    tmp_dir=TMP_DIR,\n",
+    "    verbosity=1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $10\\mathrm{M}_\\odot$ in nine steps (so the masses are integers). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"M_1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        11\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1,2,1)\",\n",
+      "    \"precode\": null,\n",
+      "    \"probdist\": \"1\",\n",
+      "    \"dphasevol\": \"dM_1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"edge\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10} \n",
+    "massrange = (1, 11) \n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\", # == single-star mass\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(1,2,1)\", # space by unit masses\n",
+    "    probdist=\"1\", # dprob/dm1 : we don't care, so just set it to 1\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    "    gridtype=\"edge\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "\n",
+    "We now construct the HRD output.\n",
+    "\n",
+    "We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have $>0.1\\mathrm{M}_\\odot$ of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "Foreach_star(star)\n",
+      "{\n",
+      "    if(star->stellar_type <= TPAGB &&\n",
+      "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+      "    {\n",
+      "         double logTeff = log10(Teff_from_star_struct(star));\n",
+      "         double logL = log10(star->luminosity); \n",
+      "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+      "         Printf(\"HRD%d %30.12e %g %g %g %g\\n\",\n",
+      "                star->starnum, // 0\n",
+      "                stardata->model.time, // 1\n",
+      "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+      "                logTeff, // 3\n",
+      "                logL, // 4\n",
+      "                loggravity // 5\n",
+      "                );\n",
+      "\n",
+      "    }\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "Foreach_star(star)\n",
+    "{\n",
+    "    if(star->stellar_type <= TPAGB &&\n",
+    "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+    "    {\n",
+    "         double logTeff = log10(Teff_from_star_struct(star));\n",
+    "         double logL = log10(star->luminosity); \n",
+    "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+    "         Printf(\"HRD%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                star->starnum, // 0\n",
+    "                stardata->model.time, // 1\n",
+    "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+    "                logTeff, // 3\n",
+    "                logL, // 4\n",
+    "                loggravity // 5\n",
+    "                );\n",
+    "\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"HRD*n*\", where *n* is 0 (primary star) or 1 (secondary star, which doesn't exist in single-star systems), and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14565763dca0> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"logTeff\", \"logL\", \"logg\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        match = re.search('HRD(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            \n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "            # first time setup of the list of tuples\n",
+    "            if(len(self.grid_results['HRD'][nstar][linedata['zams_mass']])==0):\n",
+    "                self.grid_results['HRD'][nstar][linedata['zams_mass']] = []\n",
+    "\n",
+    "            # make the HRD be a list of tuples\n",
+    "            self.grid_results['HRD'][nstar][linedata['zams_mass']].append((linedata['logTeff'],\n",
+    "                                                                           linedata['logL']))\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: verbosity=0 to grid_options\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '20bee5b0c58d49c5bc47eced240685bb', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 10.0, 'total_count': 10, 'start_timestamp': 1631304519.45189, 'end_timestamp': 1631304519.9955394, 'total_mass_run': 55.0, 'total_probability_weighted_mass_run': 55.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    for zams_mass in sorted(hrd[nstar]):\n",
+    "        print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "        # get track data (list of tuples)\n",
+    "        track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "        # convert to Pandas dataframe\n",
+    "        data = pd.DataFrame(data=track, \n",
+    "                            columns = ['logTeff','logL'])\n",
+    "        \n",
+    "        # make seaborn plot\n",
+    "        p = sns.lineplot(data=data,\n",
+    "                         sort=False,\n",
+    "                         x='logTeff',\n",
+    "                         y='logL',\n",
+    "                         estimator=None)\n",
+    "        \n",
+    "        # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "        p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "        \n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "We now have an HRD. It took longer to make the plot than to run the stars with *binary_c*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## Binary stars"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d0fc4e-c72f-444a-93ab-19f52086b86d",
+   "metadata": {},
+   "source": [
+    "Now we put a secondary star of mass $0.5\\mathrm{M}_\\odot$ at a distance of $10\\mathrm{R}_\\odot$ to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "478e8005-e144-4e6f-80c9-0cf368a9bcb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 0.5, # Msun\n",
+    "    separation = 10, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c433e6a-fe22-4494-b1a9-fce9676a9f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3557b6d5-6c54-467c-b7a1-b1903493c441",
+   "metadata": {},
+   "source": [
+    "We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59335030-dd99-4c2f-afff-207a3fcbbb70",
+   "metadata": {},
+   "source": [
+    "If we now set the separation to be longer, say $100\\mathrm{R}_\\odot$, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, $1\\mathrm{M}_\\odot$, so that the interaction is stronger."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dee92b20-ad6b-4c97-80dc-71d3bd937c4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 1, # Msun\n",
+    "    separation = 100, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    "    alpha_ce = 1.0, # make common-envelope evolution quite efficient\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e0ac2573-bc35-43be-8f20-5c85364fde11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f8e061-a65e-47f2-a777-93de0d5045ea",
+   "metadata": {},
+   "source": [
+    "You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the $1\\mathrm{M}_\\odot$ star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698d0a63-11ba-4b3e-a713-35c3e972492f",
+   "metadata": {},
+   "source": [
+    "We can also plot the secondary stars' HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That's because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2b0b7c2b-6e43-48ed-9257-9dfc141b3d28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "star  1\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '1': # choose only secondaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "            \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92c46319-5629-4125-a284-b5d521ed33fc",
+   "metadata": {},
+   "source": [
+    "Remember, all these stars start with a $1\\mathrm{M}_\\odot$ binary, which begins at $\\log_{10}(T_\\mathrm{eff}/\\mathrm{K})\\sim 3.750$, $\\log_{10}L/\\mathrm{L}_\\odot \\sim 0$. The $1\\mathrm{M}_\\odot$-$1\\mathrm{M}_\\odot$ binary evolves like two single stars until they interact up the giant branch at about $\\log_{10} (L/\\mathrm{L}_\\odot) \\sim 2.5$, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the very start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53145356-abbb-4880-996f-dedd80de7540",
+   "metadata": {},
+   "source": [
+    "This is, of course, a very simple introduction to what happens in binaries. We haven't talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/doctrees/nbsphinx/notebook_HRD_14_2.png b/docs/build/doctrees/nbsphinx/notebook_HRD_14_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dfb418a4777bb8325ab533e23e7ca0d29b8c100
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_HRD_14_2.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_HRD_19_2.png b/docs/build/doctrees/nbsphinx/notebook_HRD_19_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5e57f5de5dd5226a46542b5f0539cc9376489b1
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_HRD_19_2.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_HRD_23_2.png b/docs/build/doctrees/nbsphinx/notebook_HRD_23_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..56e92fab6d6075417a4babc662028fba4312c57b
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_HRD_23_2.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_HRD_26_2.png b/docs/build/doctrees/nbsphinx/notebook_HRD_26_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5cb5bf342275e846454020542dbe17904efe96c
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_HRD_26_2.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_api_functionality.ipynb b/docs/build/doctrees/nbsphinx/notebook_api_functionality.ipynb
index d81c31711bfc5d6de3159fd8958df96dd145ded0..020d2dc7cdb1ae9f1214d42e3351b571ff0c943d 100644
--- a/docs/build/doctrees/nbsphinx/notebook_api_functionality.ipynb
+++ b/docs/build/doctrees/nbsphinx/notebook_api_functionality.ipynb
@@ -5,7 +5,7 @@
    "id": "cb9d00f5-9613-471e-a4bb-6181311bf73b",
    "metadata": {},
    "source": [
-    "# Using the API functionality of binarycpython\n",
+    "# Tutorial: Using the API functionality of binary_c-python\n",
     "This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw\n",
     "\n",
     "Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in `src/binary_c_python.c`, and the functions are available via `from binarycpython import _binary_c_bindings`.\n",
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "ded7eaf6-e1ba-46c2-9f6f-9ebcb14a264d",
    "metadata": {},
    "outputs": [
@@ -30,37 +30,69 @@
       "\n",
       "FUNCTIONS\n",
       "    free_persistent_data_memaddr_and_return_json_output(...)\n",
-      "        Frees the persistent_data memory and returns the json output\n",
+      "        Frees the persistent_data memory and returns the json output.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)\n",
       "    \n",
       "    free_store_memaddr(...)\n",
-      "        Frees the store memaddr\n",
+      "        Frees the store memaddr.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the store object\n",
       "    \n",
       "    return_arglines(...)\n",
       "        Return the default args for a binary_c system\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_help(...)\n",
       "        Return the help info for a given parameter\n",
+      "        \n",
+      "        Arguments:\n",
+      "                parameter: parameter name.\n",
       "    \n",
       "    return_help_all(...)\n",
       "        Return an overview of all the parameters, their description, categorized in sections\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_maximum_mass_ratio_for_RLOF(...)\n",
-      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_minimum_orbit_for_RLOF(...)\n",
-      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_persistent_data_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_store_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_version_info(...)\n",
       "        Return the version information of the used binary_c build\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    run_system(...)\n",
-      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things. \n",
+      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.\n",
       "        \n",
       "        Arguments:\n",
       "                argstring: argument string for binary_c\n",
@@ -126,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "10a74d5a-a3d5-4543-a5bc-20d1fe885bb4",
    "metadata": {},
    "outputs": [
@@ -134,8 +166,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<capsule object \"STORE\" at 0x7f163859d0c0>\n",
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
+      "<capsule object \"STORE\" at 0x7fa6a45ed180>\n",
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
       "\n"
      ]
     }
@@ -183,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "318874f6-7acf-49bb-9786-299d4dffc0b3",
    "metadata": {},
    "outputs": [
@@ -217,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "d7e757ae-579c-42a2-a310-f0401b7800e8",
    "metadata": {
     "scrolled": true,
@@ -291,6 +323,9 @@
       "opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)\n",
       "wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0\n",
       "gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)\n",
+      "postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&A 635, A173). : (null)\n",
+      "Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)\n",
+      "Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)\n",
       "mattsson_Orich_tpagbwind : Experimental : turns on Mattsson's TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)\n",
       "magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)\n",
       "magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)\n",
@@ -310,7 +345,9 @@
       "vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)\n",
       "vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)\n",
       "tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers' mass loss formula. (This multiplies the 4e-13 in Reimers' formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)\n",
+      "Tout_Pringle_1992_multiplier : Multiplier for the Tout & Pringle (1992) magnetic wind. (0.0) : (null)\n",
       "artificial_mass_accretion_rate%d : Constant mass accretion rate for star <n>. : (null)\n",
+      "artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type <n>. : (null)\n",
       "artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star <n>. : (null)\n",
       "artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)\n",
       "artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if <0 (default is -1). : (null)\n",
@@ -318,8 +355,7 @@
       "wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge's version of Vink's early-2000s wind (See Lynnette Dray's thesis, or John Eldridge's thesis) : (null)\n",
       "wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)\n",
       "wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)\n",
-      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)\n",
-      "PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore\n",
+      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)\n",
       "sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -331,9 +367,6 @@
       "sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -345,9 +378,6 @@
       "sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_companion_IA_He : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_ELD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_CHAND : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
@@ -368,9 +398,6 @@
       "sn_kick_companion_BH_NS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PPISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PHDIS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)\n",
       "wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)\n",
       "wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)\n",
@@ -443,6 +470,11 @@
       "HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)\n",
       "wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)\n",
       "wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)\n",
+      "colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)\n",
+      "apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)\n",
+      "degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)\n",
+      "degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)\n",
+      "degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)\n",
       "\n",
       "############################################################\n",
       "##### Section Binary\n",
@@ -709,7 +741,6 @@
       "############################################################\n",
       "##### Section Output\n",
       "############################################################\n",
-      "david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions : Ignore\n",
       "cf_amanda_log : Enable logging to compare to Amanda's models. : (null)\n",
       "float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)\n",
       "save_pre_events_stardata : Enable this to save a copy of stardata to stardata->pre_events_stardata just before an event. : (null)\n",
@@ -739,6 +770,7 @@
       "escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)\n",
       "colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. : \n",
       "log_filename : Location of the output logging filename. If set to \"/dev/null\" then there is no logging. : \n",
+      "log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. : \n",
       "stopfile : File which, when it exists, will stop the current binary_c repeat run. : \n",
       "stardata_dump_filename : Location of the stardata dump file. : \n",
       "stardata_load_filename : Location of the stardata file to load. : \n",
@@ -763,8 +795,12 @@
       "MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. : \n",
       "MINT_remesh : Turn on or off MINT's remeshing. : \n",
       "MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) : \n",
+      "MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) : \n",
       "MINT_disable_grid_load_warnings : Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data. : \n",
       "MINT_Kippenhahn : Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. : \n",
+      "MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) : \n",
+      "MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) : \n",
+      "MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) : \n",
       "MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. : \n",
       "MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. : \n",
       "MINT_nuclear_burning : Turn on or off MINT's nuclear burning algorithm. : \n",
@@ -825,7 +861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 5,
    "id": "3d29ca9d-ac66-4f9e-81cf-2edd14a98b79",
    "metadata": {},
    "outputs": [
@@ -854,7 +890,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "e517f561-09c6-419d-ba89-d9cb61e6ebab",
    "metadata": {},
    "outputs": [
@@ -887,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "id": "7da75a95-8831-4346-a584-e042ced75249",
    "metadata": {},
    "outputs": [
diff --git a/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution.ipynb b/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..526320ccf954c1ed86c6d5c641204c4a9345bbe5
--- /dev/null
+++ b/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Common-envelope evolution\n",
+    "\n",
+    "In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.\n",
+    "\n",
+    "First, we import a few required Python modules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_comenv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Setting up the Population object\n",
+    "We set up a new population object. Our stars evolve to $13.7\\text{ }\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. We also set the common-envelope ejection efficiency $\\alpha_\\mathrm{CE}=1$ and the envelope structure parameter $\\lambda=0.5$. More complex options are available in *binary_c*, such as $\\lambda$ based on stellar mass, but this is just a demonstration example so let's keep things simple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: log_dt=10 to grid_options\n",
+      "adding: max_evolution_time=13700 to BSE_options\n",
+      "adding: metallicity=0.02 to BSE_options\n",
+      "adding: alpha_ce=1.0 to BSE_options\n",
+      "adding: lambda_ce=0.5 to BSE_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    # grid options\n",
+    "    tmp_dir = TMP_DIR,\n",
+    "    verbosity = 1,\n",
+    "    log_dt = 10, # log every 10 seconds\n",
+    "\n",
+    "    # binary-star evolution options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    alpha_ce = 1.0,\n",
+    "    lambda_ce = 0.5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $6\\text{ }\\mathrm{M}_\\odot$. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to $10^4\\text{ }\\mathrm{d}$ because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"lnm1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        6\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(math.log(1), math.log(6), 10)\",\n",
+      "    \"precode\": \"M_1=math.exp(lnm1)\",\n",
+      "    \"probdist\": \"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+      "    \"dphasevol\": \"dlnm1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"q\",\n",
+      "    \"longname\": \"Mass ratio\",\n",
+      "    \"valuerange\": [\n",
+      "        \"0.1/M_1\",\n",
+      "        1\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1/M_1, 1, 10)\",\n",
+      "    \"precode\": \"M_2 = q * M_1\",\n",
+      "    \"probdist\": \"flatsections(q, [{'min': 1/M_1, 'max': 1.0, 'height': 1}])\",\n",
+      "    \"dphasevol\": \"dq\",\n",
+      "    \"parameter_name\": \"M_2\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 1\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"log10per\",\n",
+      "    \"longname\": \"log10(Orbital_Period)\",\n",
+      "    \"valuerange\": [\n",
+      "        0.15,\n",
+      "        5.5\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(0.15, 4, 10)\",\n",
+      "    \"precode\": \"orbital_period = 10.0 ** log10per\\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)\",\n",
+      "    \"probdist\": \"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)\",\n",
+      "    \"dphasevol\": \"dlog10per\",\n",
+      "    \"parameter_name\": \"orbital_period\",\n",
+      "    \"condition\": null,\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 2\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10, \"q\" : 10, \"per\": 10} \n",
+    "massrange = [1, 6] \n",
+    "logperrange = [0.15, 4]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Logging and handling the output\n",
+    "\n",
+    "We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "\n",
+      "/*\n",
+      " * Detect when the comenv_count increased \n",
+      " */\n",
+      "if(stardata->model.comenv_count == 1 && \n",
+      "   stardata->previous_stardata->model.comenv_count == 0)\n",
+      "{\n",
+      "   /*\n",
+      "    * We just had this system's first common envelope:\n",
+      "    * output the time at which this happens, \n",
+      "    * the system's probability (proportional to the number of stars),\n",
+      "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+      "    * the current timestep (post-comenv) orbital period (days)\n",
+      "    */\n",
+      "    Printf(\"COMENV %g %g %g %g\\n\",\n",
+      "           stardata->model.time,\n",
+      "           stardata->model.probability,\n",
+      "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+      "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+      "           \n",
+      "    /*\n",
+      "     * We should waste no more CPU time on this system now we have the\n",
+      "     * data we want.\n",
+      "     */\n",
+      "    stardata->model.evolution_stop = TRUE;\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "\n",
+    "/*\n",
+    " * Detect when the comenv_count increased \n",
+    " */\n",
+    "if(stardata->model.comenv_count == 1 && \n",
+    "   stardata->previous_stardata->model.comenv_count == 0)\n",
+    "{\n",
+    "   /*\n",
+    "    * We just had this system's first common envelope:\n",
+    "    * output the time at which this happens, \n",
+    "    * the system's probability (proportional to the number of stars),\n",
+    "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+    "    * the current timestep (post-comenv) orbital period (days)\n",
+    "    */\n",
+    "    Printf(\"COMENV %g %g %g %g\\\\n\",\n",
+    "           stardata->model.time,\n",
+    "           stardata->model.probability,\n",
+    "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+    "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+    "           \n",
+    "    /*\n",
+    "     * We should waste no more CPU time on this system now we have the\n",
+    "     * data we want.\n",
+    "     */\n",
+    "    stardata->model.evolution_stop = TRUE;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"COMENV\" and process the associated data. We set up the parse_data function to do just this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14736bebc040> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "# log-period distribution bin width (dex)\n",
+    "binwidth = 0.5 \n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"probability\", \"pre_comenv_period\", \"post_comenv_period\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "        # choose COMENV lines of output\n",
+    "        if linedata[\"header\"] == \"COMENV\":\n",
+    "            # bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex\n",
+    "            binned_pre_period = bin_data(math.log10(linedata[\"pre_comenv_period\"]), binwidth)\n",
+    "            \n",
+    "            # but check if the post-comenv period is finite and positive: if \n",
+    "            # not, the system has merged and we give it an aritifical period\n",
+    "            # of 10^-100 days (which is very much unphysical)\n",
+    "            if linedata[\"post_comenv_period\"] > 0.0:\n",
+    "                binned_post_period = bin_data(math.log10(linedata[\"post_comenv_period\"]), binwidth)\n",
+    "            else:\n",
+    "                binned_post_period = bin_data(-100,binwidth) # merged!\n",
+    "                \n",
+    "            # make the \"histograms\"\n",
+    "            self.grid_results['pre'][binned_pre_period] += linedata[\"probability\"]\n",
+    "            self.grid_results['post'][binned_post_period] += linedata[\"probability\"]\n",
+    "\n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 1000 stars\n",
+      "with a total probability of 0.0645905996773004\n",
+      "Total starcount for this run will be: 1000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-12T18:07:39.965721.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee47e0>\n",
+      "Process 1 started at 2021-09-12T18:07:39.970949.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n",
+      "Process 2 started at 2021-09-12T18:07:39.978355.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4f30>\n",
+      "Process 3 started at 2021-09-12T18:07:39.983689.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB\n",
+      "322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB\n",
+      "465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB\n",
+      "586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB\n",
+      "682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB\n",
+      "784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB\n",
+      "872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB\n",
+      "963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).\n",
+      "\tRan 222 systems with a total probability of 0.014137215791516371.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).\n",
+      "\tRan 273 systems with a total probability of 0.01877334232598154.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).\n",
+      "\tRan 268 systems with a total probability of 0.016469813170514686.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).\n",
+      "\tRan 237 systems with a total probability of 0.015210228389288167.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'ad303100d719457c83256568f9a9887c', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.06459059967730076, 'total_count': 1000, 'start_timestamp': 1631462859.9342952, 'end_timestamp': 1631462947.4824853, 'total_mass_run': 4680.235689312421, 'total_probability_weighted_mass_run': 0.22611318083528567, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'merged': 0.035263029200000025, 'unmerged': 0.019388724199999995}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Number of stars')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the distributions\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import copy\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "# remove the merged objects\n",
+    "probability = { \"merged\" : 0.0, \"unmerged\" : 0.0}\n",
+    "\n",
+    "# copy the results so we can change the copy\n",
+    "results = copy.deepcopy(population.grid_results)\n",
+    "\n",
+    "for distribution in ['post']:    \n",
+    "    for logper in population.grid_results[distribution]:\n",
+    "        dprob = results[distribution][logper]\n",
+    "        if logper < -90:\n",
+    "            # merged system\n",
+    "            probability[\"merged\"] += dprob\n",
+    "            del results[distribution][logper]\n",
+    "        else:\n",
+    "            # unmerged system\n",
+    "            probability[\"unmerged\"] += dprob\n",
+    "print(probability)\n",
+    "    \n",
+    "# pad the final distribution with zero\n",
+    "for distribution in population.grid_results:    \n",
+    "    pad_output_distribution(results[distribution],\n",
+    "                            binwidth)\n",
+    "    \n",
+    "# make pandas dataframe \n",
+    "plot_data = pd.DataFrame.from_dict(results, orient='columns')\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10} (P_\\mathrm{orb} / \\mathrm{day})$\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "#p.set(xlim=(-5,5)) # might be necessary?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4740c93-d01e-4ca1-8766-c2fb4ddca2e4",
+   "metadata": {},
+   "source": [
+    "You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range $10$ to $1000\\text{ }\\mathrm{d}$, while after CEE the distribution peaks at about $1\\text{ }\\mathrm{d}$. Some of these orbits are very short: $\\log_{10}(-2) = 0.01\\text{ }\\mathrm{d}\\sim10\\text{ }\\mathrm{minutes}$. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57faf043-3809-427a-b378-2355ce8c2691",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Extend the logging to output more data than just the orbital period.\n",
+    "* What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova?\n",
+    "* What are the lifetimes of the systems in close ($<1\\text{ }\\mathrm{d}$) binaries? Are they likely to merge in the life of the Universe?\n",
+    "* How much mass is lost in common-envelope interactions?\n",
+    "* Extend the grid to massive stars. Do you see many NS and BH compact binaries?\n",
+    "* Try different $\\alpha_\\mathrm{CE}$ and $\\lambda_\\mathrm{CE}$ options...\n",
+    "* ... and perhaps increased resolution to obtain smoother curves.\n",
+    "* Why do long-period systems not reach common envelope evolution?"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution_14_2.png b/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution_14_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..47e9c2954323516f1e932e7bf5dc22466d51680a
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_common_envelope_evolution_14_2.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_custom_logging.ipynb b/docs/build/doctrees/nbsphinx/notebook_custom_logging.ipynb
index 05ffbccfc23f0b08e85abed0d467233385520a4b..bfdf2a5c8fe238aec50d8f69c74d11b06491eb5f 100644
--- a/docs/build/doctrees/nbsphinx/notebook_custom_logging.ipynb
+++ b/docs/build/doctrees/nbsphinx/notebook_custom_logging.ipynb
@@ -5,13 +5,13 @@
    "id": "879b596b-d70c-4f90-b668-563b4ad93ffc",
    "metadata": {},
    "source": [
-    "# Using custom logging routines with binarycpython\n",
+    "# Tutorial: Using custom logging routines with binary_c-python\n",
     "In this notebook you'll learn how to use the custom logging functionality"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "696ecbb9-1efd-48f4-a57e-2cf6dfe416f1",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "236cf821-09ac-4237-9b8f-6e36d2edf446",
    "metadata": {},
    "outputs": [
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "feb423d5-5cc3-433c-9801-f8017abbc03a",
    "metadata": {},
    "outputs": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 4,
    "id": "2f5defbf-c623-49ed-a238-fba52a563a58",
    "metadata": {},
    "outputs": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 5,
    "id": "dcd74bbc-478b-43e4-b495-8c456e8d1d88",
    "metadata": {},
    "outputs": [
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 6,
    "id": "77bd09b0-1a94-499d-97db-a1f991c67c12",
    "metadata": {},
    "outputs": [
@@ -203,10 +203,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1\n",
-      "EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2\n"
+      "EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1\n",
+      "EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2\n"
      ]
     }
    ],
@@ -260,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 7,
    "id": "30142286-34ce-433e-82c8-565e2160ff5b",
    "metadata": {},
    "outputs": [
@@ -336,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "id": "6f0edc65-a788-4706-a0c5-2ace030765ec",
    "metadata": {},
    "outputs": [
@@ -344,8 +344,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
-      "EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5\n"
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
+      "EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5\n"
      ]
     }
    ],
@@ -395,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 10,
    "id": "8f58fdf9-3e76-4c18-a1c5-eed0980d4133",
    "metadata": {},
    "outputs": [
@@ -403,8 +403,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1\n",
-      "EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0\n"
+      "EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1\n",
+      "EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458\n"
      ]
     }
    ],
@@ -424,58 +424,27 @@
     "{\n",
     "    if (stardata->model.time < stardata->model.max_evolution_time)\n",
     "    {\n",
-    "        if(stardata->pre_events_stardata != NULL)\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
-    "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->pre_events_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "        Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
+    "            \"%g %g %g %d \" // 2-5\n",
+    "            \"%d %d %g %g \" // 6-9\n",
+    "            \"%g %g\\\\n\", // 10-13\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->pre_events_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[ID_core(stardata->pre_events_stardata->star[0].stellar_type)],           // 9\n",
-    "\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
-    "        else\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
+    "            // \n",
+    "            stardata->model.time, // 1\n",
     "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->previous_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "            stardata->star[0].mass, //2\n",
+    "            stardata->previous_stardata->star[0].mass, //3\n",
+    "            stardata->common.zero_age.mass[0], //4\n",
+    "            stardata->star[0].SN_type, //5\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->previous_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
+    "            stardata->star[0].stellar_type, //6\n",
+    "            stardata->previous_stardata->star[0].stellar_type, //7\n",
+    "            stardata->model.probability, //8\n",
+    "            stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
     "\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_He]    // 11\n",
+    "        );\n",
     "    };\n",
     "    /* Kill the simulation to save time */\n",
     "    stardata->model.max_evolution_time = stardata->model.time - stardata->model.dtm;\n",
@@ -491,6 +460,14 @@
     "# print (abridged) output\n",
     "print(\"\\n\".join(output.splitlines()[-2:]))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "484297c0-accb-4efc-a9c8-dbd2f32b89a6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/build/doctrees/nbsphinx/notebook_extra_features.ipynb b/docs/build/doctrees/nbsphinx/notebook_extra_features.ipynb
index b1a9ddb030195e6aaf0da2cf08eecc67684672a6..076b4098e7c588a68fb91cfe6175c3ee4e36ea78 100644
--- a/docs/build/doctrees/nbsphinx/notebook_extra_features.ipynb
+++ b/docs/build/doctrees/nbsphinx/notebook_extra_features.ipynb
@@ -5,7 +5,7 @@
    "id": "d5c04b77-f0be-4b33-8c03-c72eb846527c",
    "metadata": {},
    "source": [
-    "# Extra features and functionality of binarycpython\n",
+    "# Tutorial: Extra features and functionality of binary_c-python\n",
     "In this notebook we'll go over some of the extra features and functionality that was not covered in the other notebooks.\n",
     "\n",
     "Within the module `binarycpython.utils.functions` there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the `help()`"
diff --git a/docs/build/doctrees/nbsphinx/notebook_individual_systems.ipynb b/docs/build/doctrees/nbsphinx/notebook_individual_systems.ipynb
index 21d49016f3b2826d6f9d5ec87a1f6d8bb18df7af..85aef1e3962a1626f37a9ef36bf5e16f479eb68e 100644
--- a/docs/build/doctrees/nbsphinx/notebook_individual_systems.ipynb
+++ b/docs/build/doctrees/nbsphinx/notebook_individual_systems.ipynb
@@ -5,7 +5,7 @@
    "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
    "metadata": {},
    "source": [
-    "# Running individual systems with binarycpython\n",
+    "# Tutorial: Running individual systems with binary_c-python\n",
     "This notebook will show you how to run single systems and analyze their results.\n",
     "\n",
     "It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc. "
@@ -566,7 +566,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -580,7 +580,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries.ipynb b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c6b5f1e64cc36c684fdf5cefe0fae4b450a1c936
--- /dev/null
+++ b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries.ipynb
@@ -0,0 +1,701 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 4*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "\n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][int(nstar)][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 256 stars\n",
+      "with a total probability of 0.6149734610296649\n",
+      "Total starcount for this run will be: 256\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
+      "\n",
+      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
+      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
+      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
+      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
+      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
+      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
+      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
+      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
+      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "\n",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
+    "\n",
+    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Things to try:\n",
+    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
+    "* Alter the metallicity, does this make much of a difference?\n",
+    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
+    "* How might you go about comparing these computed observations to real stars?\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries_20_1.png b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries_20_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..3da686142c849c7f9646994928eab4d727352c91
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_binaries_20_1.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single.ipynb b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..cdae316f90802fe46611ea17732506c0410aef55
--- /dev/null
+++ b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single.ipynb
@@ -0,0 +1,725 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Zero-age stellar luminosity function\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c. \n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mass\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "   /* Note that we use Printf - with a capital P! */\n",
+    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
+    "          stardata->model.time, // 1\n",
+    "          stardata->common.zero_age.mass[0], // 2\n",
+    "          stardata->star[0].mass, // 3\n",
+    "          stardata->star[0].luminosity, // 4\n",
+    "          stardata->model.probability // 5\n",
+    "      );\n",
+    "};\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "        \n",
+    "        # Check the header and act accordingly\n",
+    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
+    "            \n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 1.0000000000000004\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=2,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'e6c082aabe0849a0811761a06e50476b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631461389.3681686, 'end_timestamp': 1631461391.6702895, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKkAAAJgCAYAAABBdDD4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB8B0lEQVR4nOzdd3iV9cH/8ffJDgkQZtgrJCxFkCVLtoqoVeuEPrZVa59qH7u0ra22ta1af491to+jttVaQNTWUcXBdCBDUVFkhL0JK4yQkHXO749AKmUYIMmdk7xf1+V1He77jE+S20POh+8IRSKRCJIkSZIkSVKAYoIOIEmSJEmSJFlSSZIkSZIkKXCWVJIkSZIkSQqcJZUkSZIkSZICZ0klSZIkSZKkwFlSSZIkSZIkKXCWVJIkSZIkSQpcXNABarLc3P2Ew5GgY9Q6TZqksnNnXtAxFMW8hnSqvIZ0qryGdKq8hnSqvIZ0qryGdKpO5hqKiQnRqFHKMc9bUh1HOByxpKoifl91qryGdKq8hnSqvIZ0qryGdKq8hnSqvIZ0qir7GnK6nyRJkiRJkgJnSSVJkiRJkqTAWVJJkiRJkiQpcJZUkiRJkiRJCpwllSRJkiRJkgLn7n6nqKBgP3l5uyktLQk6StTYti2GcDgcdAxFsWi6hmJj40hNTSM5+djbrEqSJEmSLKlOSUHBfvbtyyUtrRnx8QmEQqGgI0WFuLgYSkqio2BQzRQt11AkEqG4uIjdu7cDWFRJkiRJ0nE43e8U5OXtJi2tGQkJiRZUko4QCoVISEgkLa0ZeXm7g44jSZIkSTWaJdUpKC0tIT4+IegYkmq4+PgEpwRLkiRJ0pewpDpFjqCS9GV8n5AkSZKkL2dJJUmSJEmSpMBZUkm1SCQSCTrCMQWdLejXlyRJkiQdnyWVDjNkSN/j/vfnPz9+xGP+8IcHGTKkL4899oejPuddd/2KIUP68tWvXnDM1/3Nb+5gyJC+3HXXrw47vmjRJ/z4xz9g3LhRjBgxkEsvHcc99/yaTZs2HvfrmDr1XwwZ0pdt23K+/Is+Rd/97g1873s3Vvnr/Kf//BrXrl3DjTdeVyWvddddv+LKKy8u//Nll13I7373mwo/fs6cd/ntb39Z5a9zLEf73gwZ0pennnrylJ9bkiRJklQ54oIOoJrlscf+etTjjz76MJ9++gk9e55x2PGSkhLeeut1MjI6M3Xqv7j++v8mLu7IyyoUCpGTs5UlSxbTs2fPw84VFhby7rvvHPGYBQvmceut32P48FH89Kd3kJKSyqZNG5k06W/ccMPXeeKJp2ndus0pfLWV40c/+mkgaw4NHDiExx77K40aNQZg9uwZfPbZp9Xy2nff/b+kpKRW+P7PPTe5QguHf+Mb15Ofv/9Uoh3V0b43jz32V9LT0yv9tSRJkiRJJ8eSSoc57bTTjzj2z38+z6JFH3PNNdfSr99Zh52bN28Oubm7+M1v7uWmm67nnXdmM3Lk6COeo2XLVhQVFTF79owjSqp5894nNjaW9PQWhx3/+9+f4vTTz+DOO+8uP3bmmX0ZOHAwV1xxMc8+O5Ef/egnp/LlVoqOHTsF8rqNGjWiUaNGgbx2VlbXKnne6iwdj3atS5IkSZKC43Q/HdfSpZ/zyCP306dPP66//r+POP/aa/+iS5dunHFGL7p3P42XX/7nUZ8nFAoxfPgoZs2aecS5mTPfYtiwEUeMwNq1axfhcPiI+zdt2owf/vBW+vUbUOGv42hT8j766EOGDOnLokWfAPDnPz/Of/3XFcycOZ3x47/KyJGD+Pa3v8n69WuZM+dd/uu/rmDUqMHccMM3WLFi+TGfe8iQvrz00j+4++47Oe+8EYwZczZ33PFTcnN3Hfb6b7zxGtdeO4HRo4dwySXn84c/PEhh4YHy87m5udx55+1cdNG5jBw5mG98Yzyvv/5q+fkvTvf7858f58knHyt//T//+XFuv/0nXHbZhUesxfTLX/6M66+/5pjfq71793L33XcyduxIzjtvBP/3fw8f8XP4z2l406a9wde/fjUjRw7mggvG8Otf38GOHdvLvz8LFy7gk08+YsiQvnz00Yfl3/uXX/4nl146jnPPHcYnn3x0xHQ/gOLiIu677x7OPXcY48aN4r77fsf+/fuPmaUi35tDt7843W/bthx+85tfcPHFYxk1ajA33fQtPv54Yfn5LVs2M2RIX95+eyY/+9mtjBkzlLFjR3LvvXdx4MABJEmSJEmnxpJKx7Rv3z5+8YvbaNgwjV/96i5iYg6/XHJzc5k79z3OPfd8AM4//wI++ugDNm7ccNTnGzlyNFu2bGLZsiXlxw4cOMD777/HqFHnHHH/s84axKeffsL3vvcdpk79F5s3byo/d8EFF3P22cMr4as83NatW3jiif/j+uu/wx13/JqNG9dz663f55FH7ueaa67lzjvvJidnC7/5zS+O+zyPPfYIAL/5zT3ceOPNzJnzLn/4wwPl5//858e5665f0avXmdx9931ceeV4Xn75n/z4xz8sL5V+85s7WLt2Nbfcchv33fcQWVlduOuuX/HRRx8e8XoXXngxX/nKpQdf+69ceOHFjBt3IVu3bmHRoo/L77d/fx7vvvs2Y8cefX2wcDjMj370P8ydO4fvfvf73H77r/jss0XMmPHWMb/WTz/9hN/+9pcMHz6S3//+Yf7nf37AwoULuPPO24Gy6ZDdunUnK6sLjz32V7p0+fcorKeeepLvfe9HfP/7t9K9+2lHff7p099i7do1/OIXv+Wb3/wWb745ldtv/+kx81Tke/OfduzYwbe+dQ1Llizmxhu/x5133kNiYhLf//6NLFz4wWH3/d3vfkurVq25557fM378f/Hqqy/xzDNHnyYrSZIkSao4p/tVstWb9/KvOWs4UFQaaI6khFguHNyRTq0anPRz3H33r9i2LYeHH368fN2jL3rrrakAjBlzHgCjRp3Lww8/wCuv/JMbb/zeEfc//fQzaNasOTNnzqBz57Ki4v333yMpKZkzz+x7xP1vuOFG9u/fz9Spr5QXBc2bpzNw4GCuvHI87dp1OOmv7VgKCgr48Y9/Vp7nk08+4h//eI6HHnqUPn36AbBhwwb++McHyc/Pp169ekd9ns6ds/jZz8oWCu/Xr2xE2jvvzAZg7949TJz4NJdcchk33/wjAPr3P4tmzdL55S9vY+7cOQwaNIRPPvmIb3zj+vIyrlevM2nYMI34+PgjXq9583SaNWsO/HsaW5MmTWnWrDlvvjmVXr3OBGDmzOlAhDFjzj1q7nnz3mfp0s/5/e8fYcCAgQD06dOfyy+/8Jjfs0WLPiExMYkJE75OQkICAA0aNGTZsiVEIhE6duxEvXqplJaWHDHF7tJLr2DYsJHHfG6AtLQ0fv/7h0lMTAIgLi6O++77HStWLCczs8txHwtH/978pylTJrJvXx5PPPF0+bTTQYOG8I1vXM2jjz7Ck0/+rfy+gwcP5bvf/T4Affv254MP5vP+++/yrW9950uzSJIkSZKOzZKqkk37cAOLVu0MOgYAyYlx3HBRj5N67LPP/p13332bG2/8Hmec0euo95k69V/06zeA2NhY9u3bB5SNfpo69VW+9a0bjyhTDk35mzlzOjfccBNQNtVv+PBRxMbGHvH8CQkJ/OQnP+f667/N3LlzyqeJvfzyP5k69V/8+tf3MHTo8JP6+o6nR49/j+g5VM59cZRPw4YNAcjL23fMkur00w9fYL5583QOHCgA4PPPF1NUVMTo0YcXRSNGjOK3v43n448XMmjQEHr3Lpualp29nLPOGshZZw3hppuOLP+OJTY2lvPOG8eLL77AD37wYxISEnj99VcZNGgoDRo0POpjFi36mISExPKCCiA5OZmzzhrMZ58tOupjevc+kz/96f+45porGT58FAMHDqZ//7MYOHDwl2bMzMz60vsMHDikvKACGDJkOPfd9zs+/fSTCpVUFfHJJx/Rs+cZh62LFhMTw6hR5/Dkk48dtpj7f/5smzVrzrZt2yolhyRJkiTVZZZUlWxM37YcKCypESOpxvRre1KPXbz4Mx577A+cffYIxo//r6PeZ9mypaxatZJVq1YyduyII86//fbMI0oYKJvy9/zzk1mxYjmtW7dl7tw53H//H46bp0mTplxwwVe44IKvAGVrSf3613dw332/Y8iQYZW6s15sbOxhhcghycnJJ/Q8iYmJh/05FAqVT+Pbt28vUPZ1fVFMTAxpaY3Iy8sD4M477+Zvf/sLM2dOY/bsGcTExNC37wB+/OOf0aJFywrlOP/8C3nmmb8yZ847ZGV15bPPFvH//t8Dx7z/3r17SUtLO+L4f2b9otNO68n//u9DTJkykSlTJvL3vz9F48ZNuOaab3LZZVcdN19y8tFLvi/6z1F8h/Id+j5Vhn379tKuXbsjjjdu3IRIJEJ+fn75saSkw6+PmJgYIpEj106TJEmSJJ0YS6pK1qlVA753+Rlffscaau/ePfzyl7fRokXL8ulqRzN16iukpKRwzz2/P+Lcr399By+//M+jllSnndaT5s3TmTVrBh07dqJBg4b07NnriPt9/vlifvrTH/KLX/z6iB0FzzyzL+PH/xcPP3w/+/btPeaooC8KhUKEw4cXhwUFBV/6uKpQv359AHbu3HHYbnbhcJjc3F3lJUxqaio33ngzN954M+vXr+Xdd9/mqaee5P77/99xi6Yvatu2HT179mLmzOls2rSRxo2b0L//wGPePy0tjd27c4lEIoeVf3v37jnu6wwYMJABAwZy4MABFi78gOefn8yDD97HaaedQdeu3SqU9VgOjdI75NAC9IfKq7Kf7eElUUFBPieifv367Nx55AjInTt3AGXTFw/dliRJkk7E1l35TJyWzRkZTRjd9+QGEkh1hQunq1wkEuG3v/0lubm5/OY3vyM1NfWo9ysqKmLatDcZOnQ4Z57Z94j/xow5j48/Xsj69WuPeGwoFGLkyFG8/fZMZs+ewciRo486Eqpt23YUFOTz/PPPHnWHv/Xr19GsWfMKFVQAKSkpbNuWc9ixTz/9pEKPrWw9epxOQkIC06e/edjxWbNmUFJSQs+eZ7BtWw6XXjqOWbOmA9CuXQcmTPg6ffsOOOLrOORoUyYBxo27iHnz3mfmzOmce+7YY94PoE+ffhQVFfHee2+XHysuLmbBgnnHfMz//d/DfOtb1xCJREhKSmLw4KHcdNP3Acqzxsae/FvNhx8uoLT03wXjoe/JoXW26tVLISfn+D/b433NZc/Vh08/XXTY9zYcDjNz5jS6detevtaWJEmSdCLCkQhPvrqEz9fsYvKMFezZXxR0JKlGcySVyr3wwhTef/89LrvsKgoLi1i8+LMj7pOSksLq1avYt2/vUUdKAZx33jgmT36Gl19+kf/5nx8ccX7UqDE8++wkNm3ayB//+ORRn6NBgwbceOP3uP/+e7nppuu58MJLaNWqNXl5ebzzzizeeOM1fvWruyv8tQ0aNJT33nuHRx55gMGDh/Lpp5/wxhuvVfjxlalBg4ZcffV/8be//YW4uDgGDhzMmjWr+fOfH6dXrzMZMGAQMTExtGjRkgcfvI/9+/fTunUbli1byrx5c/j616876vOmppaN0Jo27Q1OO60nLVu2AmDEiNE8+OB9ZGcv4447fn3cbH379qd//4Hcffev+fa3d5Kens7zzz/L7t25NG3a7KiP6devP5MnP8Ndd/2Kc88dS3FxCZMm/Y20tDR69+5Tnm3Roo9ZuPCDE15Havv2HH75y9u4+OLLWLEimz/96VEuuOAi2rVrD5QtcP73vz/FM888RY8ep/Hee2+zcOHhOyAe63tzyJVXTuCNN17je9/7DtdeewP16qXw4ovPs27dWv73fx86obySJEnSIXMXb2X15rLlPiIR+HDZNkb1afMlj5LqLksqlcvOXgbACy88ywsvPHvU+/TqdSaJiUmkpaXRt2//o94nI6MzmZlZvPHGq3z72zcdcf6003qSnt6CmJjYwxYp/0+XXno57dq154UXnuXxx//Anj17qFcvhe7de/DQQ4+WFyAVMW7cRWzatJHXX3+Vl156gV69+vDb397Ld75z9MKnqn3rW9+hcePG/OMfz/Hiiy/QqFFjvvKVS7n22m8TE1M26uiuu/7fwZ3lHmPPnt00b57OtdfewIQJXz/qcw4dOpypU1/hrrt+xUUXXcIPf/gTAOrVq0fv3meSm5tLx46dvjTb3Xf/L48++jBPPvkohYVFjBo1hosuupT333/3qPfv1+8sfvWru5g48W/87Gc/JhQKccYZvXj44cfKpzZecsllfP75Z9xyy83cfvudR90t8lguvvgy9u3by223/YjExCQuv/wqvvOdG8vPX3PNtezevZtJk/5GSUkJgwYN5qc/vYOf/vSHX/q9OaRp06Y8+uifefTRh7nvvnsIh8N07dqdBx7441F3npQkSZK+TEFhCc/PXnXYsXlLtlpSSccRihxazVlH2Lkzj3D42N+erVvX0aJF+2pMVDvExcVQUuJC09UlPz+fSy4Zy003fZ+LLrok6DiVIhqvId8vapZmzeqzffu+L7+jdAxeQzpVXkM6VV5DNd+UmSt4c8EGANo0S2Xj9rKNf+7974E0SzuxjZmqgteQTtXJXEMxMSGaNDn60kLgmlRSrbVly2b++tc/8YMf3ERSUhLnnDM26EiSJElSnbBl536mf7gRgM5tGnL9Bf/eTGjB0qOvMSvJkkqqtUKhGJ5//ll27drJL395F0lJSUFHkiRJkmq9SCTCpOkrKA1HCAETRmfRtnkqrZumADB/iSWVdCyuSSXVUi1atGDq1BlBx5AkSZLqlE9W7uDzNbsAGNarFe1blK3T2r97Oi++s5qN2/ezcXsebZode8qTVFc5kkqSJEmSpEpQXFLKszNWAJCSFMclZ/9746IB3dPLbzuaSjo6SypJkiRJkirBmws2sH33AQAuHtqJ+vUSys81T0umU6sGQFlJ5R5m0pEsqU6RbyySvozvE5IkSbXfrr0HeHXuWgDaNEtheO9WR9zn0GiqHXsOsHrz3uqMJ0UFS6pTEBsbR3FxUdAxJNVwxcVFxMa6BKAkSVJt9tyslRQVhwEYPzqL2JgjP27379qcUKjs9jyn/ElHsKQ6BampaezevZ2iokJHSkg6QiQSoaiokN27t5OamhZ0HEmSJFWR5etzWbB0GwD9ujana/tGR71fw9REuh0898GybZSGw9WWUYoG/tP+KUhOLttCdM+eHZSWlgScJnrExMQQ9s1YpyCarqHY2Djq129U/n4hSZKk2qU0HGbitLLF0hPiYrhiROfj3n9At3SWrM1l7/4ilq3bTY+OjasjphQVLKlOUXJyih8+T1CzZvXZvn1f0DEUxbyGJEmSVFO888lmNm7PA+D8ge1p0jDpuPfv06UZz7y1nJLSCPOX5FhSSV/gdD9JkiRJkk5CXkEx/3xnNQBNGyZxXv92X/qYeknxnN6pCQALs7dRXFJapRmlaGJJJUmSJEnSSXjx3dXsP1C29MtVozJJiI+t0OPO6tECgILCUj5dtavK8knRxpJKkiRJkqQTtD5nH7M/3gRAjw6N6J3ZtMKPPSOjCYkJZYXW/CVbqySfFI0sqSRJkiRJOgGRSIRJ07KJRCA2JsTVo7MIhUIVfnxCfCxnZjYDYNGqnRQUuhGXBJZUkiRJkiSdkAVLt5G9cQ8Ao/q0oVXTE99Ma0D3dACKS8J8lL29UvNJ0cqSSpIkSZKkCiosKuW5WSsBaFAvnosGdzyp5+neoRGpyfEAzF+aU2n5pGhmSSVJkiRJUgW9Nm8tufsKAfjqsAzqJcWd1PPExcbQr2tzAJasyWVvflGlZZSilSWVJEmSJEkVsC03nzfmrwegY8v6DO7Z8pSe79CUv3AkwofLtp1yPinaWVJJkiRJklQBz85YSUlpBIDxY7KIOYHF0o+mc5uGNG6QCMC8JU75kyypJEmSJEn6Ep+t3sknK3cAMPj0FmS0anjKzxkTCtG/W9loqpUb97Bzz4FTfk4pmllSSZIkSZJ0HCWlYSZPXwFAUkIslw3LqLTnPuvglD+ABS6grjrOkkqSJEmSpOOY/uFGtu7KB+CiwR1pmJpYac/dtnkqLZvUA5zyJ1lSSZIkSZJ0DHvyCnllzhoAWjSux+i+bSr1+UOhUPkC6hu25bFpx/5KfX4pmlhSSZIkSZJ0DC+8vYoDRaUAjB+dSVxs5X+MHvCFKX/zHU2lOsySSpIkSZKko1i1aQ9zPtsKQO/MppzWqUmVvE56o3p0bFkfgAVLcohEIlXyOlJNZ0klSZIkSdJ/CEciTJyWDUBcbAxXjsqs0tcbcHCXv227C1izZV+VvpZUU1lSSZIkSZL0H+Z8uoW1W8vKovMGtKV5WnKVvl6/bumEDt52yp/qKksqSZIkSZK+IP9AMS+8vQqARvUTGXdWhyp/zUb1E+nSLg2ABUtzCIed8qe6x5JKkiRJkqQveGXOWvblFwNwxYjOJCbEVsvrntWjBQB79hexfH1utbymVJNYUkmSJEmSdNCmHfuZsXAjAFlt0+jfrXm1vXafLs2IjSmb9DfPKX+qgyypJEmSJEkCIpEIk6dnUxqOEArB+NGZhEKhL39gJUlJiuf0gzsILly+neKScLW9tlQTWFJJkiRJkgR8lL2DJWvLptkN792adun1qz3DgO5lu/zlF5awePXOan99KUiWVJIkSZKkOq+ouJQpM1cAkJIUxyVDOwWSo1fnpiTGl62BNX+pU/5Ut1hSSZIkSZLqvDcWrGfHngMAXHp2J1KT4wPJkZgQS+/MpgB8smIHB4pKAskhBcGSSpIkSZJUp+3cc4Cpc9cB0LZ5KsN6tQ40z6Epf0UlYT5esSPQLFJ1sqSSJEmSJNVpz81aSdHBRcrHj84kJqb6Fks/mh4dG5OSFAfAfHf5Ux1iSSVJkiRJqrOWrcvlg2XbgLIRTF3aNQo4EcTFxtCva3MAPl+zi335RQEnkqqHJZUkSZIkqU4qDYeZND0bgIT4GC4fnhFwon87NOWvNBzhw+XbA04jVQ9LKkmSJElSnTT7481s3L4fgAsGdqBxg6SAE/1bZts0GtVPBJzyp7rDkkqSJEmSVOfsyy/ixXdWA9AsLYlz+7cNONHhYkIh+ncrm/KXvWE3u/YeCDiRVPUsqSRJkiRJdc6L76wmv7AEgKtGZRIfFxtwoiOd1b1F+e0FS7cFmESqHpZUkiRJkqQ6Zd3Wfbz9yWYATuvYmF6dmwac6OjapaeS3rgeAPOWbA04jVT1LKkkSZIkSXVGJBJh4vRsIkBsTIirR2cSCoWCjnVUoVCIsw4uoL4+J48tO/cHnEiqWpZUkiRJkqQ6Y96SHFZu3APAmL5tadkkJeBEx3dolz9wAXXVfpZUkiRJkqQ6oaCwhOdmrQSgQUoCFw7uEGygCmjRuB7tW9QHykqqSCQScCKp6lhSSZIkSZLqhNfmrmNPXhEAlw/PIDkxLuBEFTOgW9loqpzcAtZu3RdwGqnqWFJJkiRJkmq9nF35vPXBegA6tWrAwNNafMkjao7+3ZpzaNUsp/ypNrOkkiRJkiTVes/OWEFJadlUuQljsoipoYulH03jBklktU0DYMHSHMJhp/ypdrKkkiRJkiTVap+u2sGiVTsBGNKzJR1bNgg40Ykb0KNsyt/uvCKyN+wONoxURSypJEmSJEm1VklpmMnTVwCQnBjLZcMyAk50cvp2aU5sTNnor3lO+VMtZUklSZIkSaq1pn2wgZzcAgC+MqQTDVISAk50clKT4zmtY2MAFi7fRklpOOBEUuWzpJIkSZIk1Uq5+wp55f21ALRsUo+RZ7YONtApGtC9bMrf/gMlLF69K+A0UuWzpJIkSZIk1UovzF5FYVEpAONHZxEXG90fgXtlNiUhruxrmL/UKX+qfaL7/1BJkiRJko5i5cY9zP18KwBnZjWjx8GpctEsKSGOXplNAfh4xfbyAk6qLSypJEmSJEm1SjgcYeL0bADiYmO4cmTngBNVnkNT/oqKw3y8cnvAaaTKZUklSZIkSapV3vtsC+u27gNg7IB2NEtLDjhR5Tm9UxNSkuIAWLBkW8BppMplSSVJkiRJqjX2HyjmhdmrAGjcIJHzB7YPOFHliouNoU+XZgB8tnoneQXFASeSKo8llSRJkiSp1nj53TXlxc2VIzNJjI8NOFHlG9C9BQCl4QgLlzuaSrWHJZUkSZIkqVbYuD2PmR9tAqBruzT6HhxxVNt0aZtGw9QEAOYvcZc/1R6WVJIkSZKkqBeJRJg8fQXhSIRQCMaPziIUCgUdq0rExIQY0K1sAfXl63eTu68w4ERS5bCkkiRJkiRFvYXLt7N0XS4AI3u3oU3z1IATVa1Du/xFgAVLHU2l2sGSSpIkSZIU1QqLS5kycwUAqcnxfGVox4ATVb0OLerTvFHZroVO+VNtYUklSZIkSYpqr89bx869ZVPeLh3WidTk+IATVb1Q6N9T/tZu3UfOrvyAE0mnzpJKkiRJkhS1duwu4PX56wFol57K2T1bBZyo+hya8geOplLtYEklSZIkSYpaU2atpLgkDMCEMVnExNTOxdKPplXTFNodXHtr3pIcIpFIwImkU2NJJUmSJEmKSkvW7mLh8u0AnNUjncw2acEGCsCAHmWjqbbuymd9Tl7AaaRTY0klSZIkSYo6JaVhJk8vWyw9MT6Wy4d3DjhRMPp3dcqfag9LKkmSJElS1Jn18SY27dgPwAWD2tOofmLAiYLRpGESWW0aAjB/aQ5hp/wpillSSZIkSZKiyt78Il56dw0AzRslc06/dgEnCtahBdRz9xWyYsPuYMNIp8CSSpIkSZIUVf759ioKCksAuHpUJvFxdfujbd+uzYk9uGD8/KXbAk4jnby6/X+yJEmSJCmqrNmyl3cXbQGgZ0YTzujcNOBEwatfL4HuHRoD8OGybZSUhgNOJJ0cSypJkiRJUlQIRyJMmp5NBIiNCXHVqMygI9UYZx2c8pdXUMyStbsCTiOdHEsqSZIkSVJUmPf5VlZt2gvAOf3a0qJxvYAT1Ry9MpuWT3uc5y5/ilKWVJIkSZKkGq+gsITnZ60CoGFKAhcM6hBsoBomOTGOXgenPn6cvYPC4tKAE0knzpJKkiRJklTjvfr+WvbsLwLg8hEZJCfGBZyo5jm0y19hcSmLVu4IOI104iypJEmSJEk12pad+3nrgw0AZLRuwMAeLQJOVDOd3qlJeXk33yl/ikKWVJIkSZKkGisSiTB5xgpKwxFCwIQxWYRCoaBj1UjxcTH06dIMgE9X7WT/geKAE0knxpJKkiRJklRjLVq1k8Wry3arG3pGKzq0aBBwoprt0C5/peEIC5dvDziNdGIsqSRJkiRJNVJxSZhnp68AyhYGv3RYp4AT1Xxd2zWiYUoC4JQ/RR9LKkmSJElSjfTWB+vZtrsAgIuHdqRBvYSAE9V8MTEh+nVrDsCydbnszisMOJFUcZZUkiRJkqQaJ3dfIa++vw6A1k1TGNG7dcCJosehXf4iwIKl24INI50ASypJkiRJUo3z/KyVFBaXAjB+dCZxsX58rahOLRvQLC0JcMqfoov/l0uSJEmSapTsDbuZd7Bc6dulGd06NA44UXQJhULlo6nWbNlLTm5+wImkirGkkiRJkiTVGOFwhEnTsgGIj4vhipGdA04UnQZ0b1F+e4GjqRQlLKkkSZIkSTXGO4s2s35bHgDnn9Wepg2TA04UnVo3TaFNs1QA5i3JIRKJBJxI+nKWVJIkSZKkGiGvoJh/vrMagCYNkhg7oF3AiaLbgO5lu/xt2ZnPhoPFn1STWVJJkiRJkmqEl99dQ15BMQBXjuxMQnxswImi24Bu6eW35y91yp9qPksqSZIkSVLgNm7LY+bHGwHo1r4Rfbo0CzhR9Gualkzn1g2BsnWpwk75Uw1nSSVJkiRJClQkEmHitGwiEYgJhRg/OpNQKBR0rFrh0C5/O/cWsmrTnoDTSMdnSSVJkiRJCtQHy7axfMNuAEb2aU3rgwt+69T169qcmIOF3zx3+VMNZ0klSZIkSQpMYVEpz81aCUBqcjwXD+kYcKLapUFKAt07NALgw2XbKCkNB5xIOjZLKkmSJElSYKbOW8euvYUAXDY8g3pJ8QEnqn0OTfnbl1/M0nW5AaeRjs2SSpIkSZIUiO27C3h9/noA2reoz5DTWwacqHY6M6sZcbFlH//nO+VPNZgllSRJkiQpEFNmriyffjZhdBYxMS6WXhWSE+M4o3MTABZmb6eouDTgRNLRWVJJkiRJkqrd52t28VH2dgAG9mhB5zYNA05Uu511cMpfYVEpn67aGXAa6egsqSRJkiRJ1aqkNMyk6dkAJCbEcvmIjIAT1X49M5qQnBgLuMufai5LKkmSJElStZq5cCNbduYDcNHgDqSlJgacqPaLj4vlzKxmAHy6aid5BcUBJ5KOZEklSZIkSao2e/YX8fKcNQCkN67HmL5tA05Udxza5a+kNMy8zzYHnEY6kiWVJEmSJKna/OPtVRQUli3cffWozPJd51T1urVvRIN68QC8/fGmgNNIR/LdQJIkSZJULVZv3st7n24B4IyMJvTMaBJworolNiaGfl3LRlN9umI7e/IKA04kHc6SSpIkSZJU5cKRCBOnlS2WHhcb4qrRmQEnqpsG9CgrqcIR+GDZtoDTSIezpJIkSZIkVbn3P9vKmi17ATi3fzvSG9ULOFHdlNGqAU0bJgEw313+VMNYUkmSJEmSqlT+gRJeeHsVAGmpCYwb2D7gRHVXKBQqX0B91ea9bNtdEHAi6d8sqSRJkiRJVepf769h7/4iAK4Y0ZmkhLiAE9VtA7qll99e4Ggq1SCWVJIkSZKkKrNl536mf7gRgM5tGpaP4lFw2jRPpX2L+gDMX2pJpZrDkkqSJEmSVCUikQiTpq+gNBwhBEwYnUUoFAo6loCze7cBYNP2/WzclhdwGqmMJZUkSZIkqUp8smIHn6/ZBcCwXq3KR+8oeGf3bl1+29FUqiksqSRJkiRJla64pJTJM1YAkJIUxyVndwo4kb6oRZMUMlo1AMp2+YtEIgEnkiypJEmSJElV4I0FG9ix5wAAFw/tRP16CQEn0n86tD7Yjj0HWLV5b8BpJEsqSZIkSVIl27X3AK/NXQtAm2YpDO/dKthAOqp+3dI5tETY/M+d8qfgWVJJkiRJkirVc7NWUlQcBmD86CxiY/zoWRM1TEmge/tGAHywLIfScDjgRKrrfKeQJEmSJFWa5etzWbB0GwD9ujan68ESRDVT/4NT/vbmF7N0XW7AaVTXWVJJkiRJkipFaTjMxGlli6UnxMVwxYjOASfSl+mT1Zy42LJqYP4Sp/wpWJZUkiRJkqRK8fYnm9m4PQ+A8we2p0nDpIAT6cvUS4qjZ0YTAD7K3k5xSWnAiVSXWVJJkiRJkk5ZXkExL76zGoCmDZMYO6BdwIlUUWcdnPJXUFjKp6t2BpxGdZkllSRJkiTplL34zmr2HygB4KpRmcTHxQacSBXVM6MJSQllP695TvlTgCypJEmSJEmnZH3OPmZ/sgmAHh0a0TuzacCJdCIS4mM5M6sZAItW7qSgsCTgRKqrLKkkSZIkSSctEokwaVo2kQjExoS4enQWoVAo6Fg6QQMOTvkrKQ3zUfb2gNOorrKkkiRJkiSdtAVLt5G9cQ8Ao/q0oVXTlIAT6WR0a9+I+vXiAXf5U3AsqSRJkiRJJ+VAUQnPzVoJQIN68Vw0uGPAiXSy4mJj6Nu1OQBL1uayd39RwIlUF1lSSZIkSZJOymtz15G7rxCArw7LoF5SXMCJdCoGdCub8heORPhg2baA06gusqSSJEmSJJ2wbbn5vLlgPQAdW9ZncM+WASfSqercpiFNGiQCMH+pU/5U/SypJEmSJEkn7NkZKykpjQAwfkwWMS6WHvViQiH6HxxNtXLjHnbsKQg4keoaSypJkiRJ0gn5bPVOPlm5A4DBp7cgo1XDgBOpshza5Q/KFsWXqpMllSRJkiSpwkpKw0yevgKApIRYLhuWEXAiVaa2zVNp2aQeAPM+d8qfqpcllSRJkiSpwqZ/uJGtu/IBuGhwRxqmJgacSJUpFApx1sHRVBu357Fpe17AiVSXWFJJkiRJkipkd14hL89ZA0CLxvUY3bdNwIlUFfp/YcqfC6irOllSSZIkSZIq5B+zV1FYVArA+DGZxMX6kbI2Sm9Uj44tGwAwf0kOkUgk4ESqK3xHkSRJkiR9qVWb9jBn8VYAemc25bSOTQJOpKp0aAH17bsPsHrL3oDTqK6wpJIkSZIkHVc4EmHitGwA4mJjuHJUZsCJVNX6d2tO6ODt+Uuc8qfqYUklSZIkSTquOZ9uYe3WfQCcN6AtzdOSA06kqpaWmkjX9o0A+GDpNsJhp/yp6llSSZIkSZKOKf9AMS+8vQqARvUTGXdWh2ADqdocmvK3Z38Ry9bnBpxGdYEllSRJkiTpmF5+by378osBuGJEZxITYgNOpOrSp0szYmPKJv3Nc8qfqoEllSRJkiTpqDbt2M+MhRsByGqbRv9uzQNOpOqUkhRPz4yyBfIXLt9OcUk44ESq7SypJEmSJElHiEQiTJqWTTgSIRSC8aMzCYVCX/5A1SqHpvwVFJbw2eqdAadRbWdJJUmSJEk6wkfZO1i6rmwdouG9W9MuvX7AiRSEMzo3JTG+bIqnu/ypqllSSZIkSZIOU1RcypSZKwBISYrjkqGdAk6koCTGx9I7qykAn6zcQUFhScCJVJtZUkmSJEmSDvPGgvXs2HMAgEvP7kRqcnzAiRSksw5O+SsuCfPJih0Bp1FtZkklSZIkSSq3Y08BU+euA6Bt81SG9WodcCIFrXuHxuVFpbv8qSpZUkmSJEmSyj03axVFB3dxmzAmi5gYF0uv6+JiY+jbtWxnx8/X7GJvflHAiVRbWVJJkiRJkgBYui6XD5dtA8p2dctqmxZsINUYA7qVlVThSISFB68RqbJZUkmSJEmSKA2HmTQ9G4CE+BguH54RcCLVJJlt02hUPxFwlz9VHUsqSZIkSRKzP97Mpu37AbhgYAcaN0gKOJFqkphQiAHdyhZQz964h50HF9aXKpMllSRJkiTVcfvyi3jxndUANEtL4tz+bQNOpJpowMFd/gAWLHM0lSqfJZUkSZIk1XH/fGc1+YUlAFw1KpP4uNiAE6kmapeeSovG9QCY/7kllSqfJZUkSZIk1WHrtu7jnU82A3Bap8b06tw04ESqqUKhEGcdHE21flsem3fsDziRahtLKkmSJEmqoyKRCBOnZRMBYmNCXD0qk1AoFHQs1WBfnPLnAuqqbJZUkiRJklRHzVuSw8pNewAY07ctLZukBJxINV1643p0aFEfgPlLc4hEIgEnUm1iSSVJkiRJdVBBYQnPzVoJQIOUBC4c3CHYQIoah0ZTbcstYO3WfQGnUW1iSSVJkiRJddBrc9exJ68IgMuHZ5CcGBdwIkWL/t3SOTQp1Cl/qkyWVJIkSZJUx+TsyufNBesByGjVgIGntQg4kaJJo/qJdGmXBsCCpTmEw075U+WwpJIkSZKkOmbyjBWUhiOEgPFjsohxsXSdoENT/nbnFbF8w+5gw6jWsKSSJEmSpDpk0codfLpqJwBDerakY8sGASdSNOrTpTmxMWXlplP+VFksqSRJkiSpjiguCfPsjBUAJCfG8tVhGQEnUrRKTY7ntI6NAVi4fBslpeGAE6k2sKSSJEmSpDpi+ocbyMktAOArQzrRICUh4ESKZgN6lE3523+ghMWrdwWcRrWBJZUkSZIk1QG5+wp55f21ALRsUo+RZ7YONpCiXu/OzUiIL6sV5i3ZGnAa1QaWVJIkSZJUB7wweyWFRaUAjB+dRVysHwd1ahITYumd2QyAT1bu4EBRScCJFO18V5IkSZKkWm7Fxt3M/bxsceszs5rR4+BaQtKpGtCtbMpfUXGYT1bsCDiNop0llSRJkiTVYuFwhEnTyhZLj4+L4aqRnQNOpNrktE6NSUmKA9zlT6fOkkqSJEmSarF3P93Mupx9AIwd0I6mackBJ1JtEhcbQ58uzQFYvGYXeQXFASdSNLOkkiRJkqRaav+BYv7x9moAGjdIZOxZ7QNOpNrorO5lU/5KwxE+XL4t4DSKZpZUkiRJklRLvfzumvKRLVeOzCQxPjbgRKqNstqmkZaaAMD8z53yp5NnSSVJkiRJtdDG7XnM/GgTAF3bpdG3S7OAE6m2iokJ0f/gAurZG3aza++BgBMpWllSSZIkSVItE4lEmDQtm3AkQkwoxPjRWYRCoaBjqRYbcHDKXwRYsNQpfzo5llSSJEmSVMssXL6dZet3AzDizNa0aZ4abCDVeh1a1Ce9Udmi/POXOuVPJ8eSSpIkSZJqkcLiUqbMXAFAanI8Fw/tGHAi1QWhUKh8NNW6rfvYuis/4ESKRpZUkiRJklSLvD5vHTv3FgJw6bBOpCTFB5xIdcWhkgpg/hJHU+nEWVJJkiRJUi2xY3cBr89fD0C79FTO7tkq4ESqS1o2SaFdetnU0nlLcohEIgEnUrSxpJIkSZKkWmLKrJUUl4QBmDAmi5gYF0tX9TqrewsAcnblsz4nL+A0ijaWVJIkSZJUCyxZu4uFy7cDcFaPdDLbpAUbSHVS/27Ny2/PW7I1wCSKRpZUkiRJkhTlSkrDTJpetlh6Ynwslw/vHHAi1VWNGySR1TYNgAVLtxF2yp9OgCWVJEmSJEW5WR9tYvOO/QBcOLgDjeonBpxIddmhBdRz9xWyYsPuYMMoqlhSSZIkSVIU27u/iJfeWwNA80bJjOnbNuBEquv6dmlG7MH10NzlTyfCkkqSJEmSotg/31lFQWEJAFePyiQ+zo95Clb9egn06NgYgA+WbaOkNBxwIkUL370kSZIkKUqt2bKXdxdtAaBnRhPO6Nw04ERSmUNT/vYfKOHzNbsCTqNoYUklSZIkSVEoHIkwaVo2ESA2JsRVozKDjiSV653ZlISDo/qc8qeKsqSSJEmSpCg0d/FWVm3eC8A5/dvSonG9gBNJ/5aUEEevzLKRfR+v2EFhUWnAiRQNLKkkSZIkKcrkHyjmhdmrAGiYmsAFAzsEG0g6igHdyqb8FRaX8snKHQGnUTSwpJIkSZKkKDNlWjZ79hcBcMXwziQnxgWcSDrSaZ2aUO/gtemUP1WEJZUkSZIkRZEtO/fzyrtlo6gyWjfgrB7pASeSji4+LoY+XZoB8NnqneQVFAecSDWdJZUkSZIkRYlIJMLkGSsoKY0QAiaMySIUCgUdSzqmsw7u8lcajvBR9vaA06imO+GSqqCgoPx2bm4uEydOZPLkyezevbsyc0mSJEmS/sOilTtZvHoXAEPPaEWHFg0CTiQdX5d2jWiYmgDAvM+3BpxGNV2FJy7v3buXH/zgB+zdu5fnn3+evLw8vvrVr7JlyxYikQj/93//x6RJk2jbtm1V5pUkSZKkOqm4pJTJM7IBSEmO59JhnQJOJH25mJgQ/bumM+3DDSxfv5vcfYU0qp8YdCzVUBUeSfXggw8yf/58hg4dCsALL7zA5s2bufXWW/nb3/5GTEwMDz74YFXllCRJkqQ67a0PNrB99wEAJpzblQb1EgJOJFXMgINT/iLAB8u2BRtGNVqFS6qZM2fyta99jZtvvhmA6dOn06RJE6699lr69+/PhAkTeP/996ssqCRJkiTVVbv2HuBf768FoHXTFM4f1CHQPNKJ6NiyPs3TkgGYv8Qpfzq2CpdUO3fuJDMzE4B9+/bxySefMHjw4PLzjRo1Omy9KkmSJElS5Xhh9iqKisMAjB+dSWyse2ApeoRCIfofHE21Zss+cnLzA06kmqrC72zp6els2LABKBtFVVpayvDhw8vPf/TRR7Rs2bLSA0qSJElSXZa9YTfzluQA0LdLM7p1aBxwIunEHZryBzD/4PUs/acKL5w+YsQInn76afLy8njttddo2LAhI0eOJCcnhz/96U+8/PLL3HjjjVWZVZIkSZLqlHA4wqRpZYulJ8TFcMXIzgEnkk5O66YptG2eyoZtecxfksOFgzoQCoWCjqUapsIjqW699VbGjRvHCy+8QIMGDXjggQdISkoiJyeHiRMncuGFF3LDDTdUZVZJkiRJqlPeXrSZ9dvyADj/rPY0bZgccCLp5B0aTbVlZz4bDl7X0hdVeCTVunXr+M1vfsNvf/vbw4537dqVt99+m+bNm1d6OEmSJEmqq/IKivnn26sAaNIgifMGtAs4kXRq+ndrzguzy67p+UtyaJdeP+BEqmkqPJLqG9/4Br///e+POJ6QkGBBJUmSJEmV7KV3V7P/QAkAV43qTEJ8bMCJpFPTtGEynds0BGD+0hzCkUjAiVTTVLikys/Pp02bNlWZRZIkSZIEbNiWx6yPNwHQrX0jzsxqFnAiqXKcdXDK3669hazcuCfgNKppKlxSff3rX+evf/0rn332WVXmkSRJkqQ6LRIpWyw9EoGYUIjxozNdYFq1Rt+uzYk5eD27y5/+U4XXpFq8eDHbtm3jiiuuICkpibS0NGJiDu+4QqEQ06dPr/SQkiRJklRXfLBsG8s37AZgZJ/WtG6WGmwgqRI1qJdA946NWLx6Fx8s28bVozOJi63w+BnVchUuqQoLCznttNOqMoskSZIk1WmFRaVMmbkSgPr14rl4SMeAE0mVb0C3dBav3kVeQTFL1ubSM6NJ0JFUQ1S4pHrmmWeqMockSZIk1XmvzVtH7r5CAL46LIN6SfEBJ5Iq35lZzfjbm8spLgkzf0mOJZXKVeqYuiVLllTm00mSJElSnbFtdwFvzF8PQIcW9RnSs2XAiaSqkZwYxxkHi6mPVmynsLg04ESqKSo8kqqoqIiHH36Yd999l/z8fMLhcPm50tJS9u/fT15eHkuXLq2SoJIkSZJUm02ZsYKS0rLPWePHZJUvLi3VRgO6t+DD5dspLCrl01U76de1edCRVANUeCTVQw89xJNPPsmePXtITk5m06ZNtGzZkri4OLZu3UpxcTE///nPqzKrJEmSJNVKi9fs5OMVOwAYdFoLOrduGHAiqWr1zGhMcmIsAPM+3xpwGtUUFS6p3njjDfr378/MmTP505/+BMAvfvEL3nzzTR5//HFKSkqIj3e+tCRJkiSdiJLSMJOnrwAgMSGWy4ZnBJxIqnrxcbH0ySobPfXZ6p3kHygOOJFqggqXVDk5OZxzzjnExMSQnp5OkyZN+PjjjwEYNmwYl1xyCc8991yVBZUkSZKk2mjGwo1s2ZkPwEWDO5CWmhhwIql6DOieDkBJaYSFy7cHnEY1QYVLqqSkpMNGSrVr147s7OzyP/fs2ZMNGzZUbjpJkiRJqsX25BXy8ntrAEhvXI8xfdsGnEiqPl3bp9EgJQGA+UtzAk6jmqDCJVW3bt145513yv/cqVOn8pFUUDbSKuTCfpIkSZJUYf94ezUHisp2Nhs/OpO42ErdgF2q0WJjYsoXTF+6Lpc9eYUBJ1LQKvwOOH78eGbMmMH48ePJy8tj3LhxLFmyhNtuu40//elPPPXUU5x++ulVmVWSJEmSao3Vm/fy3mdbAOjVuSmnd2oScCKp+h2a8heJwKJVOwNOo6DFVfSOY8eOJS8vj7/+9a8kJyczaNAgJkyYwMSJEwFo1aoVP/3pT6ssqCRJkiTVFuFIhInTypZPiYsNceWozgEnkoLRqkm98tuHRhWq7qpwSQVw+eWXc/nll5f/+Y477uC6665jz549ZGRkkJCQUOkBJUmSJKm2ef+zrazZsheAc/u3I71RvS95hCTVfhWe7nfNNdcwd+7cI463atWKbt268d577zFu3LhKDSdJkiRJtU3+gRJemL0SgEb1Exk3sH3AiSSpZjjmSKqCggJyc3PL/7xgwQLGjBlD+/ZHvoGGw2HeeecdNm7cWDUpJUmSJKmWeGXOGvbmFwNw+YgMkhJOaIKLJNVaxy2pLr74Yvbt2wdAKBTi7rvv5u677z7q/SORCIMHD66alJIkSZJUC2zesZ8ZC8v+cT+zTUMGdEsPOJEk1RzHLKkaN27M//7v//LZZ58RiUT44x//yJgxY+jSpcsR942JiaFx48ZO95MkSZKkY4hEIkyesYLScIRQCCaMySIUCgUdS5JqjOOOKx02bBjDhg0DYPPmzVx11VWcccYZ1RJMkiRJkmqTT1bs4PM1uwAY1qs17dLrB5xIkmqWCk9+vueee456fMWKFcTExJCRkVFpoSRJkiSpNikuKWXyjBUApCTFccnQjgEnkqSap8K7+wE88cQT3HbbbUDZYuk33HADF110ERdccAHXXXcd+/fvr5KQkiRJkhTN3pi/nh17DgBw8dBO1K+XEHAiSap5KlxSPfnkk9x///3s2LEDgNdff5133nmHc845h5tuuokPP/yQP/7xj1UWVJIkSZKi0a69B3ht7joA2jRLZXjvVgEnkqSaqcLT/V588UXGjBnDI488AsDUqVNJTk7m3nvvJSkpif379/PGG2/w4x//uMrCSpIkSVK0eW7WSopKwgBMGJNJbMwJTWiRpDqjwu+OGzZs4OyzzwaguLiYuXPn0r9/f5KSkgDIyMgoH2UlSZIkSYLl63NZsHQbAP27NadLu0YBJ5KkmqvCJVWDBg3Iy8sDYP78+eTn55eXVgDr16+nadOmlZ9QkiRJkqJQaTjMxGlli6UnxMVwxYjOASeSpJqtwtP9evfuzd///ndat27NY489RlxcHOeccw7FxcXMmjWLyZMnM3r06KrMKkmSJElR4+1PNrNxe9k/9I8b2J7GDZICTiRJNVuFR1L97Gc/IzExkZtvvpmlS5fyox/9iGbNmvHRRx9x880306xZM773ve9VZVZJkiRJigr78ot48Z3VADRtmMR5A9oFnEiSar4Kj6Rq2bIlr7zyCkuWLCE9PZ309HQAunbtyv3338+IESNITk6usqCSJEmSFC1efHcN+w+UAHD1qEzi42IDTiRJNV+FSyqAuLg4evbsedixhg0bcv7551dqKEmSJEmKVuu27uPtjzcB0KNjY3plunavJFWEe59KkiRJUiWJRCJMmp5NBIiNCXH1qExCoVDQsSQpKlhSSZIkSVIlmb80hxUb9wAwqk8bWjVNCTiRJEUPSypJkiRJqgQHikp4ftYqABrUi+eiwR0DTiRJ0eWYJdXs2bPZsWNHdWaRJEmSpKj12tx15O4rBOCrwzOol3RCSwBLUp13zJLqlltuYfbs2eV/vuaaa5g7d251ZJIkSZKkqJKTm8+bC9YD0LFlAwaf3jLgRFIUikSCTqCAHbOkikQiLFy4kIKCAgAWLFjAzp07qy2YJEmSJEWLKTNWUlJa9gF7wpgsYlwsXZJO2DHHn55zzjm8+OKLvPTSS+XHbr31Vm699dZjPlkoFGLJkiWVGlCSJEmSarJPV+3kk5VlS6UMOb0lnVo1CDiRFE0sdPVvxyyp7rzzTnr06EF2djZFRUW8/PLL9OnTh7Zt21ZnPkmSJEmqsUpKw0yesQKA5MRYvjo8I+BEkhS9jllSJSQk8LWvfa38zy+99BJXXnklF154YbUEkyRJkqSabvqHG8nZlQ/ARYM70jAlIeBEkhS9KrzdxLJly8pv79ixg82bNxMfH096ejqNGzeuknCSJEmSVFPtzivk5TlrAGjZpB6j+rQJOJEkRbcT2hN18eLF/PrXv+azzz477PgZZ5zBz3/+c04//fRKDSdJkiRJNdULs1dRWFQKwNWjM4mLPea+VJKkCqhwSbV8+XL+67/+C4ArrriCjIwMwuEwq1ev5l//+hfXXHMNzz33HJmZmVUWVpIkSZJqgpWb9vD+4q0A9M5symkdmwScSJKiX4VLqgcffJCUlBSmTJlC69atDzt34403ctlll/GHP/yBhx56qNJDSpIkSVJNEY5EmDgtG4C42BiuHOU/1EtSZajweNQPP/yQ8ePHH1FQAbRo0YKrr76a+fPnV2q4ylJUVMQ3v/lNZs2aFXQUSZIkSVHuvU+3sG7rPgDOG9CO5mnJASeSpNqhwiVVUVERKSkpxzyfmprKgQMHKiVUZVq2bBkTJkzgo48+CjqKJEmSpCiXf6CYf7y9CoBG9RMZd1b7gBNJUu1R4ZKqW7duvPrqq5SUlBxxrri4mH/9619kZWVVarjKMHnyZG688UZ69uwZdBRJkiRJUe7l99ayL78YgCtHdiYxITbgRJJUe1S4pLr++uv57LPP+NrXvsabb77J8uXLWb58Oa+//jpf+9rX+Pzzz7n22murMutRvfTSS3Tv3v2I//btKxt+e+eddzJixIhqzyVJkiSpdtm0PY8ZCzcC0KVtGv26Ng84kSTVLhVeOH306NHccccd3HfffXz/+98vPx6JREhMTOQnP/kJ5513XlVkPK6LL76Yiy++uNpfV5IkSVLdEYlEmDR9BeFIhFAIxo/JIhQKBR1LkmqVCpdUABMmTGDcuHHMnTuXjRs3EolEaNOmDYMGDSItLa2KIkqSJElSsD7K3s7SdbkAjOjdmrbNUwNOJEm1zwmVVABpaWmMHTu2KrJIkiRJUo1TVFzKszNWApCSFMfFQzsFnEiSaqcKr0lV1ZYuXUqPHj3YunXrEedeffVVxo0bR8+ePRk7diwvvfRS9QeUJEmSVCe9MX89O/eW7WR+6bAMUpPjA04kSbXTCY+kqgqrVq3i29/+9lF3Dpw6dSq33HILX//61xkyZAjTp0/nJz/5CUlJSSe0BtYzzzxTmZElSZIk1QE79hTw2rx1ALRtnsqwM1oFnEiSaq9AS6qSkhKmTJnC73//e+Ljj/6vEQ888ABjx47ltttuA2Do0KHs2bOHhx56qMoXam/SxHnmVaVZs/pBR1CU8xrSqfIa0qnyGtKp8hqKDn+euozikjAAN13ei/T0BgEn+jevIZ2qmnAN7S8oLr+dkppUIzKp4ir751XhkiocDhMTU7mzAxcuXMh9993HddddR3p6Orfffvth5zds2MD69ev54Q9/eNjxc889l9dff50NGzbQtm3bSs30RTt35hEOR6rs+euqZs3qs337vqBjKIp5DelUeQ3pVHkN6VR5DUWHpWt3MefTzQAM6J5O8/oJNebn5jWkU1VTrqH8A/+eUbU/70CNyKSKOZlrKCYmdNwBQRVunb7yla/w9NNPn9CLf5mMjAymT5/Od7/7XWJjY484v3r1agA6dux42PH27dsDsGbNmkrNI0mSJEkApeEwk6avACAxPpYrRnQOOJEk1X4VHkm1du1akpOTK/XFmzZtetzz+/aVNXKpqYe3bCkpKQDk5eVVah5JkiRJApj10SY27dgPwAWD2tOofmLAiSSp9qvwSKohQ4bw1ltvUVRUVJV5DhOJHH+qXWVPP5QkSZKkvflFvPRu2ayN5mnJnNOv6pYYkST9W4VHUnXt2pWnn36aoUOHcvrpp9OkSZMjSqJQKMTdd99daeHq1y9bgGv//v2HHT80gurQeUmSJEmqLC++s5r8wrJ1cq4alUl83JFLk0iqfK4IrQqXVI8++mj57ffee++o96nskurQWlTr16+nS5cu5cfXrVt32HlJkiRJqgxrt+7lnU/KFks/rVNjzujcJOBEUu0WCgWdQDVJhUuqZcuWVWWOo2rfvj1t2rThjTfeYMyYMeXH33rrLTp06ECrVq2qPZMkSZKk2ikSiTBxWjYRIDYmxNWjMgn5CVqSqk2FS6ovCofD7Nq1iwYNGpCQkFDZmQ5z0003cdttt9GwYUOGDx/OjBkzeP3113nggQeq9HUlSZIk1S3zPs9h1aa9AIzp15aWTVICTiRJdcsJlVTr1q3jvvvu47333uPAgQP85S9/AeD+++/nJz/5CX379q30gJdeeilFRUX85S9/4fnnn6dt27bce++9nH/++ZX+WpIkSZLqpoLCEp6bvRKAhikJXDioQ7CBJKkOqnBJtXbtWq644gpCoRBDhw5l2rRpAMTGxrJ69WquvfZa/va3v9GrV6+TCnLppZdy6aWXHvXcVVddxVVXXXVSzytJkiRJX+bVuWvZk1e2k/llwzNITjypSSeSpFMQ8+V3KXP//feTlJTE1KlT+dWvfkUkUrbufv/+/Zk6dSpNmzblD3/4Q5UFlSRJkqSqkLMrn7cWbAAgo1UDBp7WIuBEklQ3VbikmjdvHldffTVNmjQ5YvHA9PR0xo8fz+LFiys9oCRJkiRVpckzVlAajhACxo/JIsbF0iUpEBUuqYqKimjQoMExz8fHx1NYWFgpoSRJkiSpOixauYNPV+0EYEjPlnRseezPPJKkqlXhkqpr167MnDnzqOdKSkp45ZVX6NKlS6UFkyRJkqSqVFwSZvKMFQAkJ8bx1WEZASeSpLqtwiXVt7/9bd5//31uueUW5s2bB8CmTZuYMWMG11xzDUuWLOGb3/xmlQWVJEmSpMo07cMNbMstAODiIR1pkJIQcCJJqtsqvGXFiBEjuOuuu7j77rt57bXXALjjjjuIRCIkJibyk5/8hHPPPbfKgkqSJElSZcndV8i/5qwFoFXTFEac2TrYQJKkipdUAJdeeinnnHMOc+bMYcOGDYTDYVq3bs2gQYNo1KhRVWWUJEmSpEr1wuyVFBaXAnD16EziYis8yUSSVEVOqKQCSE1N5ZxzzmHXrl3ExMRYTkmSJEmKKis27mbu5zkA9MlqRo8OjQNOJEmCEyypVq1axUMPPcR7771HQUHZ3O369eszatQovve979GiRYsqCSlJkiRJlSEcjjBxWjYA8XExXDmyc8CJJEmHVLik+uyzz7jmmmsoLi7m7LPPpl27dkQiEdasWcMrr7zCO++8w+TJk2nXrl1V5pUkSZKkk/bOp5tZn5MHwNgB7WialhxwIknSIRUuqe677z5SU1OZOHHiEUVUdnY211xzDffeey9//OMfKz2kJEmSJJ2q/QeK+efbqwFo0iCRsWe1DziRJOmLKrw64KJFi7jmmmuOOlIqKyuLa665hrlz51ZqOEmSJEmqLC+9u4a8gmIArhyZSWJ8bMCJJElfVOGSqkGDBpSWlh7zfEpKCklJSZUSSpIkSZIq08Ztecz6aBMAXdul0adLs4ATSZL+U4VLqgkTJvDUU0+xcuXKI87l5OTwzDPPcMUVV1RqOEmSJEk6VZFIhEnTswlHIsSEQowfnUUoFAo6liTpPxxzTarbbrvtiGOFhYVcfPHFDB06lI4dOxIKhdi0aRPvvPMOiYmJVRpUkiRJkk7Gh8u3s2z9bgBGnNmaNs1Tgw0kSTqqY5ZUL7744jEfNGvWLGbNmnXYsfz8fB5//HG+//3vV1o4SZIkSToVhcWlTJm5AoDU5HguHtox4ESSpGM5Zkm1bNmy6swhSZIkSZXu9Xnr2LW3EICvDutESlJ8wIkkHUskEnQCBa3Ca1JJkiRJUjTZvruAqfPWA9A+vT5De7YKOJEk6XiOOZLqaF566SXmzJnD9u3bCYfDR5wPhUI8/fTTlRZOkiRJkk7WczNXUlJa9rll/JhMYmJcLF2SarIKl1QPPPAAjz/+OPHx8TRp0oSYGAdhSZIkSaqZPl+7i4XZ2wEY2COdzDZpwQaSJH2pCpdUL774IkOGDOGRRx4hOTm5KjNJkiRJ0kkrKQ0zaVo2AIkJsVw2vHPAiSRJFVHh4VB5eXmce+65FlSSJEmSarSZH21iy858AC4a1IFG9RMDTiRJqogKl1RDhw5l3rx5VZlFkiRJkk7J3v1FvPzeagDSGyUzum/bgBNJkiqqwtP97rjjDr75zW/yox/9iNGjR9OkSRNCoSMXHuzXr1+lBpQkSZKkivrH26soKCwF4OrRmcTHuZauJEWLCpdUmzdvZt++fbz22mtMnTr1iPORSIRQKMTSpUsrNaAkSZIkVcSaLXt579MtAPTMaELPjKYBJ5IknYgKl1S//vWv2bt3L9dddx0dOnQgLq7CD5UkSZKkKhWORJg0LZsIEBsT4upRmUFHkiSdoAo3TStWrOC73/0u3/rWt6oyjyRJkiSdsLmLt7Jq814AzunflvTG9QJOJEk6URWeoN2iRQtiYpzPLUmSJKlmKSgs4fnZqwBIS03gwkEdgg0kSTopFW6drr/+ep5++mlWrlxZlXkkSZIk6YT8a85a9u4vAuDyEZ1JSnBpEkmKRhV+9162bBmhUIiLLrqItm3b0rRpU2JjYw+7TygU4umnn670kJIkSZJ0NFt27mfahxsA6Ny6IWd1Tw84kSTpZFW4pJo1axaxsbG0aNGC4uJitmzZUpW5JEmSJOm4IpEIk6evoDQcIQRMGJNFKBQKOpYk6SRVuKSaOXNmVeaQJEmSpBOyaOVOFq/ZBcDZvVrRvkX9gBNJkk6FK6FLkiRJijrFJaVMnpENQL3EOC45u1PAiSRJp6rCI6muueaaCt3vb3/720mHkSRJkqSKeHPBBrbvPgDAJWd3okG9hIATSZJOVYVLqo0bNx5xLBwOk5ubS2FhIa1btyYzM7NSw0mSJEnSf9q19wCvzl0LQOtmKQzv3SrYQJKkSnHKa1KVlpYyY8YMbr/9dq677rpKCyZJkiRJR/P87FUUFYcBGD86i9gYVzGRpNrglN/NY2NjOeecc7j88su57777KiOTJEmSJB1V9obdzF+SA0Dfrs3p1r5RwIkkSZWl0v7JoUOHDixbtqyynk6SJEmSDhMOR5g4rWyx9IS4GK4YkRFwIklSZaqUkqqoqIhXXnmFJk2aVMbTSZIkSdIR3l60mQ3b8gA4/6z2NG2YHHAiSVJlOuXd/YqKilizZg179+7lf/7nfyotmCRJkiQdkldQzD/fXgVA04ZJnDegXcCJJFWGUCjoBKpJTml3Pyhbk6pTp05ccMEFjB8/vtKCSZIkSdIhL767mv0HSgC4cmQmCfGxASeSJFW2U97dT5IkSZKq0vqcfcz+eBMA3Ts04syspgEnkiRVBfdqlSRJklRjRSIRJk1fQSQCMaEQV4/OIuT8IEmqlY45kuoPf/jDST3hd7/73ZMOI0mSJElf9MGybWRv2A3AqD5taN00JdhAkqQqc8ol1X/+K4YllSRJkqTKUFhUypSZKwGoXy+erwzpEGwgSVKVOmZJNWPGjC99cF5eHg888ACzZ88mLi7umDsASpIkSdKJem3eWnL3FQLw1WEZ1EuKDziRJKkqHbOkat269XEfOHXqVH73u9+xbds2zjzzTH71q1+RlZVV6QElSZIk1T3bcvN5Y/56ADq0qM+Qni0DTiRJqmoV3t3vkA0bNnDnnXcyZ84cGjZsyG9/+1suu+yyqsgmSZIkqY6aMnMlJaURACaMySLGxdIlqdarcElVXFzME088wZ/+9CcKCwu55JJLuPXWW2nUqFFV5pMkSZJUxyxevZOPV+wAYPBpLcho3TDgRJKk6lChkmrevHnceeedrFmzhszMTH75y1/St2/fqs4mSZIkqY4pKQ0zafoKAJISYvnq8IyAE0mSqstxS6pdu3Zx991389prr5GUlMSPfvQjvvnNbxIXd8KzBCVJkiTpS81YuJGtu/IBuGhwR9JSEwNOJEmqLsdsmyZPnsyDDz7I3r17GTlyJLfffjstW7pYoSRJkqSqsSevkJffWwNAi8b1GN23TcCJJEnV6Zgl1Z133ll+e+bMmcycOfNLnywUCrFkyZLKSSZJkiSpTnnh7VUcKCoF4OrRmcTFxgScSJJUnY5ZUl188cWE3EFDkiRJUjVYtXkPcz7bCkCvzk05vVOTgBNJkqrbMUuq3/3ud9WZQ5IkSVIdFY5EmDQtG4C42BBXjeoccCJJUhAcPytJkiQpUHM+28KaLfsAOLd/O5o3qhdwIklSECypJEmSJAUm/0AJ/5i9CoBG9RMZN7B9wIkkSUGxpJIkSZIUmFfmrGFvfjEAl4/IICnhmCuSSJJqOUsqSZIkSYHYvGM/MxZuBCCrTUMGdEsPOJEkKUiWVJIkSZKqXSQSYdL0bErDEUIhGD8my93FJamOs6SSJEmSVO0+XrGDJWtzARjeqzXt0usHnEhS0CJEgo6ggFlSSZIkSapWRcWlPDtjBQApSXFccnangBNJkmoCSypJkiRJ1erNBevZsecAAJec3YnU5PiAE0kKSgin+erfLKkkSZIkVZtdew/w2tx1ALRplsqwXq0CTiRJqiksqSRJkiRVmykzV1JUEgZgwphMYmP8SCJJKuPfCJIkSZKqxbJ1uXywbBsA/bs1p0u7RgEnkiTVJJZUkiRJkqpcaTjMpOnZACTEx3DFiM4BJ5Ik1TSWVJIkSZKq3OyPN7Nx+34Axg3sQOMGSQEnkiTVNJZUkiRJkqrUvvwiXnp3NQBNGyZxXv+2ASeSJNVEllSSJEmSqtSL765h/4ESAK4elUl8XGzAiSRJNZEllSRJkqQqs27rPt7+eBMAPTo2pldm04ATSZJqKksqSZIkSVUiEokwaXo2ESA2JsT40ZmEQqGgY0mSaihLKkmSJElVYv6SHFZs3APA6L5taNkkJeBEkqSazJJKkiRJUqU7UFTCc7NWAtAgJYGLBncMOJEkqaazpJIkSZJU6V6bu47deUUAXDYsg+TEuIATSZJqOksqSZIkSZUqJzefNxesB6BjywYMOr1FwIkkSdHAkkqSJElSpZoyYyUlpREAJozJIsbF0iVJFWBJJUmSJKnSfLpqJ5+s3AHAkJ4t6dSqQcCJJEnRwpJKkiRJUqUoKQ0zeXo2AMmJsXx1WEbAiSRJ0cSSSpIkSVKlmPbhBnJyCwD4yuCONExJCDiRJCmaWFJJkiRJOmW78wp5Zc5aAFo2qcfIPm2CDSRJijqWVJIkSZJO2QuzV1FYVArA+NFZxMX6UUOSdGL8m0OSJEnSKVm5aQ/vL94KQO/MpvTo2DjgRJKkaGRJJUmSJOmkhcMRJk4rWyw9LjaGq0ZlBpxIUtSKBB1AQbOkkiRJknTS3vtsC+u27gNg7IB2NEtLDjiRpKgSCjqAahJLKkmSJEknJf9AMS/MXgVA4waJnD+wfcCJJEnRzJJKkiRJ0kl56b015BUUA3DFiM4kxscGnEiSFM0sqSRJkiSdsE3b85i5cBMAXdqm0a9r84ATSZKinSWVJEmSpBMSiUSYNH0F4UiEUAjGj8kiFHJhGUnSqbGkkiRJknRCFi7fztJ1uQCM7N2Gts1TA04kSaoNLKkkSZIkVVhhcSlTZq4AIDU5nq8M7RhwIklSbWFJJUmSJKnC3pi/np17CwG49OxOpCbHB5xIklRbWFJJkiRJqpAdewqYOm8dAO2ap3L2Ga0CTiRJqk0sqSRJkiRVyHMzV1JcEgbKFkuPiXGxdElS5bGkkiRJkvSllq7dxYfLtwNwVvd0stqmBRtIklTrWFJJkiRJOq7ScJhJ08sWS0+Mj+XyEZ0DTiRJqo0sqSRJkiQd18yPNrFpx34ALhjUnkb1EwNOJEmqjSypJEmSJB3T3vwiXnp3DQDN05I5p1+7gBNJkmorSypJkiRJx/TPt1dTUFgCwFWjM4mP8yOEJKlq+DeMJEmSpKNau3Uv7y7aDMDpnZpwRkaTgBNJkmozSypJkiRJR4hEIkyclk0EiI0JcdWozoRCoaBjSZJqMUsqSZIkSUeY93kOqzbtBWBMv7a0bJIScCJJUm1nSSVJkiTpMAWFJTw3eyUADVMSuHBQh2ADSZLqBEsqSZIkSYd59f217MkrAuDyERkkJ8YFnEiSVBdYUkmSJEkqt3VXPm99sAGAjNYNOKtHi4ATSZLqCksqSZIkSeWenbGC0nCEEDB+dBYxLpYuqZpEgg6gwFlSSZIkSQJg0codfLpqJwBDz2hJx5YNAk4kqbazBtcXWVJJkiRJorgkzOQZKwBITozj0rMzAk4kSaprLKkkSZIk8dYH69mWWwDAxUM70iAlIeBEkqS6xpJKkiRJquNy9xXy6vvrAGjdNIURvVsHnEiSVBdZUkmSJEl13POzV1JYXArA1aMziYv1Y4IkqfrFBR1AkiRJqkq79h5gz/6ioGMcZveBEnJz84OOAcD23QXM+zwHgD5dmtG9Q+OAE0mS6ipLKkmSJNVaS9bu4v4piwhH3Nj8y8THxXDliM5Bx5Ak1WGO45UkSVKtVFIa5pm3si2oKuiCQR1ompYcdAxJUh3mSCpJkiTVStM/3EjOrrIpdef0a0vX9o0CTvRvDRsms2dPQdAxytVLjCOzTcOgY0iS6jhLKkmSJNU6u/MKeXnOGgBaNqnHZcMzatRi4M2a1Wf79n1Bx5AkqUapOX9TS5IkSZXkH7NXUVjkbnWSJEUT/7aWJElSrbJq0x7mLN4KQO/MppzWsUnAiSRJUkVYUkmSJKnWCEciTJyWDUBcbAxXjsoMOJEkSaooSypJkiTVGu99uoW1W8vWejpvQDuau1udJElRw5JKkiRJtUL+gWL+8fYqABrVT2TcWe0DTiRJkk6EJZUkSZJqhZffW8u+/GIArhzZmcSE2IATSZKkE2FJJUmSpKi3acd+ZizcCEBW2zT6dW0ecCJJknSiLKkkSZIU1SKRCJOmZROORAiFYPzoTEKhUNCxJEnSCbKkkiRJUlT7KHsHS9flAjCid2vapdcPOJEkSToZllSSJEmKWkXFpUyZuQKAlKQ4Lh7aKeBEkiTpZFlSSZIkKWq9MX89O/YcAODSYRmkJscHnEiSJJ0sSypJkiRFpR17Cnht3joA2jZPZdgZrQJOJEk6FZFIJOgICpgllSRJkqLSc7NWUVwSBmDCmCxiYlwsXZKijftc6IssqSRJkhR1lq7L5cNl2wAY0D2drLZpwQaSJEmnzJJKkiRJUaU0HGbS9GwAEuNjuWJE54ATSZKkymBJJUmSpKgy66NNbNq+H4ALBrWnUf3EgBNJkqTKYEklSZKkqLE3v4iX3l0DQPO0ZM7p1zbgRJIkqbJYUkmSJClqvPjOavILSwC4alQm8XGxASeSJEmVxZJKkiRJUWHd1n2888lmAE7r1JgzOjcJOJEkSapMllSSJEmq8SKRCBOnZRMBYmNCXD0qk5D7lkuSVKtYUkmSJKnGm7ckh5Wb9gAwpl9bWjZJCTiRJEmqbJZUkiRJqtEKCkt4btZKABqmJHDhoA7BBpIkSVXCkkqSJEk12qtz17InrwiAy4ZnkJwYF3AiSZJUFSypJEmSVGPl7MrnrQUbAMho1YCBp7UIOJEkSaoqllSSJEmqsSbPWEFpOEIIGD8mixgXS5ckqdaypJIkSVKNtGjlDj5dtROAIT1b0rFlg4ATSZKkqmRJJUmSpBqnuCTMszNWAJCcGMdXh2UEnEiSJFU1SypJkiTVONM+3EBObgEAFw/pSIOUhIATSZKkqmZJJUmSpBold18h/5qzFoBWTVMYcWbrYANJkqRqYUklSZKkGuWF2SspLC4F4OrRmcTF+iurJEl1gX/jS5IkqcZYsXE3cz/PAaBPVjN6dGgccCJJklRdLKkkSZJUI4TDESZNK1ssPT4uhitHdg44kSRJqk6WVJIkSaoR3v10M+ty9gEwdkA7mqYlB5xIkiRVJ0sqSZIkBW7/gWL+8fZqAJo0SGTsWe0DTiRJkqqbJZUkSZIC99K7a8grKAbgypGZJMbHBpxIklQ9QkEHUA1iSSVJkqRAbdyWx6yPNgHQtV0afbo0CziRJEkKgiWVJEmSAhOJRJg0PZtwJEJMKMT40VmEQv6ruiRJdZEllSRJkgKzcPl2lq3fDcCIM1vTpnlqsIEkSVJgLKkkSZIUiMLiUqbMXAFAanI8Fw/tGHAiSZIUJEsqSZIkBeL1eevYubcQgK8O60RKUnzAiSRJUpAsqSRJklTttu8uYOq89QC0T6/P0J6tAk4kSZKCZkklSZKkavfczJWUlIYBGD8mk5gYF0uXJKmus6SSJElStfp87S4WZm8HYGCPdDLbpAUbSJIk1QiWVJIkSao2JaVhJk8vWyw9MT6Wy4Z3DjiRJEmqKSypJEmSVG1mfbSJzTv2A3Dh4A40qp8YcCJJklRTWFJJkiSpWuzdX8RL760BIL1RMmP6tg04kSRJqkksqSRJklQt/vH2KgoKSwC4enQm8XH+KipJkv7N3wwkSZJU5dZs2ct7n24BoGdGE3pmNA04kSRJqmksqSRJklSlwpEIk6ZlEwFiY0JcPSoz6EiSJKkGsqSSJElSlZq7eCurNu8F4Jz+bUlvXC/gRJIkqSaypJIkSVKVKSgs4YXZqwBomJrABQM7BBtIkiTVWJZUkiRJqjL/mrOWPfuLALhiRGeSE+MCTiRJkmoqSypJkiRViS079zPtww0AdG7dkLO6pwecSJIk1WSWVJIkSap0kUiEydNXUBqOEAImjMkiFAoFHUuSJNVgllSSJEmqdItW7mTxml0AnN2rFe1b1A84kSRJquksqSRJklSpiktKmTwjG4B6iXFccnangBNJkqRoYEklSZKkSvXWBxvYvvsAABcP7UiDegkBJ5IkRYNIJOgECpollSRJkirNrr0H+Nf7awFo3SyFEWe2DjaQJKlGc7lCfZEllSRJkirN87NXUVQcBmD86CxiY/x1U5IkVYy/NUiSJKlSZG/YzfwlOQD07dqcbu0bBZxIkiRFE0sqSZIknbJwOMLEaWWLpSfExXDFiIyAE0mSpGhjSSVJkqRT9vaizWzYlgfA+We1p2nD5IATSZKkaGNJJUmSpFOSV1DMP99eBUDThkmcN6BdwIkkSVI0sqSSJEnSKXnx3dXsP1ACwJUjM0mIjw04kSRJikaWVJIkSTpp63P2MfvjTQB079CIM7OaBpxIkiRFK0sqSZIknZRIJMKk6SuIRCAmFOLq0VmEQqGgY0mSpChlSSVJkqST8sGybWRv2A3AqD5taN00JdhAkiQpqllSSZIk6YQVFpUyZeZKAOrXi+crQzoEG0iSJEU9SypJkiSdsNfmrSN3XyEAXx2WQb2k+IATSZKkaGdJJUmSpBOybXcBb8xfD0CHFvUZ0rNlwIkkSVJtYEklSZKkEzJlxgpKSsMATBiTRYyLpUuSpEpgSSVJkqQKW7x6Jx+v2AHA4NNakNG6YcCJJElSbWFJJUmSpAopKQ0zafoKAJISYvnq8IyAE0mSpNrEkkqSJEkVMmPhRrbuygfgosEdSUtNDDiRJEmqTSypJEmS9KX25BXy8ntrAGjRuB6j+7YJOJEkSaptLKkkSZL0pV54exUHikoBuHp0JnGx/hopSZIql79dSJIk6bhWbd7DnM+2AtCrc1NO79Qk4ESSJKk2sqSSJEnSMYUjESZNywYgLjbEVaM6B5xIkiTVVpZUkiRJOqY5n21hzZZ9AJzbvx3NG9ULOJEkqbaKBB1AgbOkkiRJ0lHlHyjhH7NXAdCofiLjBrYPOJEkSarNLKkkSZJ0VK/MWcPe/GIALh+RQVJCXMCJJElSbWZJJUmSpCNs3rGfGQs3ApDVpiEDuqUHnEiSJNV2llSSJEk6TCQSYdL0bErDEUIhGD8mi1AoFHQsSZJUy1lSSZIk6TAfr9jBkrW5AAzv1Zp26fUDTiRJkuoCSypJkiSVKyou5dkZKwBISYrjkrM7BZxIkiTVFZZUkiRJKvfmgvXs2HMAgEvO7kRqcnzAiSRJUl1hSSVJkiQAdu09wGtz1wHQplkqw3q1CjiRJEmqSyypJEmSBMCUmSspKgkDMGFMJrEx/qooSZKqj795SJIkiWXrcvlg2TYA+ndrTpd2jQJOJEmS6hpLKkmSpDquNBxm0vRsABLiY7hiROeAE0mSpLrIkkqSJKmOm/3xZjZu3w/AuIEdaNwgKeBEkiSpLrKkkiRJqsP25Rfx0rurAWjaMInz+rcNOJEkSaqrLKkkSZLqsBffXcP+AyUAXD0qk/i42IATSZKkusqSSpIkqY5at3Ufb3+8CYAeHRvTK7NpwIkkSVJdZkklSZJUB0UiESZOzyYCxMaEGD86k1AoFHQsSZJUh1lSSZIk1UHzl+SwcuMeAEb3bUPLJikBJ5IkSXWdJZUkSVIdc6CohOdmrQSgQUoCFw3uGHAiSZIkSypJkqQ657W569idVwTAZcMySE6MCziRJEmSJZUkSVKdkpObz5sL1gPQsWUDBp3eIuBEkiRJZSypJEmS6pBnp6+gpDQCwIQxWcS4WLokSaohLKkkSZLqiE9X7WDRqp0ADOnZkk6tGgScSJKkL4hEgk6ggFlSSZIk1QElpWEmT18BQHJiLF8dlhFwIkmSwAG9+iJLKkmSpDpg2ocbyMktAOArgzvSMCUh4ESSJEmHs6SSJEmq5XbnFfLKnLUAtGxSj5F92gQbSJIk6SgsqSRJkmq5F2avorCoFIDxo7OIi/VXQEmSVPP4G4okSVIttnLjHt5fvBWA3plN6dGxccCJJEmSjs6SSpIkqZYKhyNMnJ4NQFxsDFeNygw4kSRJ0rFZUkmSJNVS7322hXVb9wEwdkA7mqUlB5xIkiTp2CypJEmSaqH8A8W8MHsVAI0bJHL+wPYBJ5IkSTo+SypJkqRa6KX31pBXUAzAFSM6kxgfG3AiSZKk47OkkiRJqmU2bc9j5sJNAHRpm0a/rs0DTiRJkvTlLKkkSZJqkUgkwqTpKwhHIoRCMH5MFqFQKOhYkiRJX8qSSpIkqRZZuHw7S9flAjCydxvaNk8NOJEkSVLFWFJJkiTVEoXFpUyZuQKA1OR4vjK0Y8CJJEmSKs6SSpIkqZZ4Y/56du4tBODSszuRmhwfcCJJkqSKs6SSJEmqBXbsKWDqvHUAtGueytlntAo4kSRJ0omxpJIkSaoFnpu5kuKSMFC2WHpMjIulS5Kk6GJJJUmSFOWWrN3Fh8u3A3BW93Sy2qYFG0iSJOkkWFJJkiRFsZLSMJOnly2Wnhgfy+UjOgecSJIk6eRYUqlO2767gMnTV7B2696go0iqo9bn7GPy9BXk5OYHHUVRatbHm9i0Yz8AFwxqT6P6iQEnkiRJOjmWVKrT/t+kj5j24QZ+/dSHQUeRVEf96q8fMO3DDdz9zMKgoyhKvbNoMwDN05I5p1+7gNNIkiSdPEsq1WmHtumWpKDtyy8OOoKiVGFRKQCd2zQkPs5f7SRJUvTyNxlJkiRJkhS4SNABFDhLKkmSJEmSFIgQoaAjqAaxpJIkSZIkSVLgLKkkSZIkSZIUOEsqSZIkSZIkBc6SSpIkSZIkSYGzpJIkSZIkSVLgLKkkSZIkSZIUOEsqSZIkSZIkBc6SSpIkSZIkSYGzpJIkSZIkSVLgLKkkSZIkSZIUOEsqSZIkSZIkBc6SSpIkSZIkSYGzpJIkSZIkSVLgLKkkSZIkSZIUOEsqSZIkSZIkBc6SSpIkSZIkSYGzpJIkSZIkSVLgLKkkSZIkSZIUOEsqSZIkSZIkBc6SSpIkSZIkSYGLCzpATRYTEwo6Qq1VU763zRsll9+uKZlUMf68dKpqyjXk+1D0qik/ryYNk4iJCdEwNaHGZFLF+PPSqfIa0qmqKdfQod+HUpPja0wmVcyJ/ry+7P6hSCQSOZVAkiRJkiRJ0qlyup8kSZIkSZICZ0klSZIkSZKkwFlSSZIkSZIkKXCWVJIkSZIkSQqcJZUkSZIkSZICZ0klSZIkSZKkwFlSSZIkSZIkKXCWVJIkSZIkSQqcJZUkSZIkSZICZ0mlavPqq68ybtw4evbsydixY3nppZeCjqQotXTpUnr06MHWrVuDjqIoEg6HmTx5MhdeeCG9e/dm9OjR3HPPPeTl5QUdTVEiEonw1FNPce6559KzZ08uuugi/vWvfwUdS1Hsu9/9LmPGjAk6hqJISUkJPXv2pEuXLof917t376CjKYp88MEHXH311ZxxxhkMGTKE3/zmN+zfvz/oWIoC8+fPP+L954v/vfjii6f8GnGVkFP6UlOnTuWWW27h61//OkOGDGH69On85Cc/ISkpifPOOy/oeIoiq1at4tvf/jYlJSVBR1GUefLJJ3nwwQe57rrrGDhwIGvWrOHhhx9m5cqV/PnPfw46nqLA448/zsMPP8z//M//0KtXL9555x1uueUWYmNjOf/884OOpyjz8ssvM23aNNq1axd0FEWRNWvWUFhYyL333kuHDh3Kj8fEOPZAFfPJJ5/wzW9+k5EjR/Loo4+ybt067r//fnbt2sUDDzwQdDzVcD169GDKlCmHHYtEIvz85z8nPz+fYcOGnfJrWFKpWjzwwAOMHTuW2267DYChQ4eyZ88eHnroIUsqVUhJSQlTpkzh97//PfHx8UHHUZSJRCI8+eSTXHnllfzoRz8CYNCgQTRq1Igf/OAHLF26lG7dugWcUjVZcXExf/nLX7j66qv5zne+A8DAgQNZvHgxf//73y2pdEJycnK46667aNGiRdBRFGWWLVtGTEwM5557LsnJyUHHURS677776NWrFw899BChUIhBgwYRDof561//SkFBgdeVjis1NZVevXodduzpp59mzZo1PPvsszRu3PiUX8PKXVVuw4YNrF+/nnPOOeew4+eeey6rV69mw4YNASVTNFm4cCH33Xcf1157LbfcckvQcRRl9u/fz0UXXcQFF1xw2PFOnToBsH79+iBiKYrExsbyzDPPcMMNNxx2PD4+nsLCwoBSKVrdfvvtDB48mIEDBwYdRVFm6dKltGvXziJBJ2XXrl18+OGHXH311YRCofLjEyZMYPr06V5XOmHbt2/noYceKp8+WhksqVTlVq9eDUDHjh0PO96+fXugbNiy9GUyMjKYPn063/3ud4mNjQ06jqJMamoqt99+O3369Dns+PTp0wHo3LlzELEURWJiYujSpQvp6elEIhF27NjBE088wfvvv8+VV14ZdDxFkeeff57PP/+cO+64I+goikLLly8nISGB6667jt69e9OvXz9+8YtfuL6iKiQ7O5tIJELDhg35/ve/T69evejTpw+//OUvOXDgQNDxFIUeeeQRYmJi+P73v19pz+l0P1W5ffv2AWUfEr8oJSUFwL9UVSFNmzYNOoJqmUWLFvHEE08wevRoMjIygo6jKPLWW29x8803AzB8+HAuuuiigBMpWmzatIl77rmHe+65p1KmRKjuWbZsGXl5eVx++eX893//N4sXL+aRRx5hzZo1/O1vfztsdIz0n3bt2gXAT3/6U8aMGcOjjz7K8uXLefDBByksLOR3v/tdwAkVTXbu3MlLL73EtddeS4MGDSrteS2pVOUikchxz7vQo6TqtnDhQv77v/+bNm3a8Nvf/jboOIoy3bt35+9//zvLly/noYce4oYbbuDpp5/2w6GOKxKJ8LOf/Yxhw4Zx7rnnBh1HUeqBBx6gYcOGdOnSBYB+/frRpEkTbr31Vt5//30GDx4ccELVZMXFxQCceeaZ/PKXvwTK1leMRCLce++93HTTTbRt2zbIiIoizz//POFwmGuuuaZSn9d2QFWufv36AEdsa3poBNWh85JUHaZOnco3v/lNWrZsyVNPPUWjRo2CjqQo07ZtW/r168fXvvY1fv7znzN//nw+/vjjoGOphps4cSLLly/nZz/7GSUlJZSUlJT/Q94Xb0vH079///KC6pDhw4cDZaOspOM5NJPl7LPPPuz4kCFDiEQiLF++PIhYilJvvvkmQ4cOrfSRwZZUqnKH1qL6z4WJ161bd9h5Sapqf/3rX/nhD39Ir169mDhxIs2bNw86kqLE7t27eemll8jJyTnsePfu3QHYtm1bELEURd58801yc3MZMmQIPXr0oEePHrz00kusX7+eHj168OKLLwYdUTXczp07ef7554/YdOjQWkL+o4u+TIcOHQAoKio67PihEVaOCFZF5eTksGTJEsaOHVvpz21JpSrXvn172rRpwxtvvHHY8bfeeosOHTrQqlWrgJJJqkuef/55fve73zF27FiefPJJR3HqhITDYX76058yZcqUw47PmTMHgKysrCBiKYrceeedvPDCC4f9N2LECFq0aFF+WzqeUCjEL37xC/7+978fdnzq1KnExsYesTmI9J8yMjJo3bo1U6dOPez4rFmziIuLo3fv3gElU7RZtGgRQJW877gmlarFTTfdxG233UbDhg0ZPnw4M2bM4PXXX+eBBx4IOpqkOmDnzp3cddddtG7dmgkTJrBkyZLDzrdr185FjHVcjRs3Zvz48TzxxBMkJSVx+umns3DhQh5//HEuv/xyOnXqFHRE1XBHu0bS0tJISEjg9NNPDyCRok3jxo2ZMGECzzzzDKmpqfTt25eFCxfy2GOPMWHChPKds6VjCYVC3HLLLfzwhz/klltu4dJLL2Xx4sU8+uijfO1rX/N3IVVYdnY2ycnJtG7dutKf25JK1eLSSy+lqKiIv/zlLzz//PO0bduWe++9l/PPPz/oaJLqgHfffZeCggI2bdrEhAkTjjj///7f/+MrX/lKAMkUTW677TZatmzJCy+8wCOPPEKLFi24+eabue6664KOJqmO+MlPfkJ6ejr/+Mc/eOKJJ0hPT+fmm2/m+uuvDzqaosT5559PQkICf/zjH/n2t79NkyZNuOmmm/j2t78ddDRFkR07dlTqjn5fFIq4SqMkSZIkSZIC5ppUkiRJkiRJCpwllSRJkiRJkgJnSSVJkiRJkqTAWVJJkiRJkiQpcJZUkiRJkiRJCpwllSRJkiRJkgJnSSVJkiRJkqTAWVJJkiRJkiQpcJZUkiQpKsyfP58uXbrwz3/+M+gopywnJ4cBAwawYcOGoKNUmSlTpjBq1Khjnv/pT39Kly5d2LhxY6W+7s9//nPuueeeSn1OSZJUPSypJEmSqtldd93FuHHjaNu2bfmx3bt306VLF66//voAk1WeOXPmMGjQoGp/3ZtuuokpU6awbNmyan9tSZJ0aiypJEmSqtEHH3zAjBkz+Na3vnXY8SVLlgDQo0ePIGJVqnA4zPz58xk4cGC1v3arVq0YN26co6kkSYpCllSSJEnV6KmnnqJPnz60bNnysOOff/45AN27dw8iVqVasmQJe/bsCaSkArj88suZN2+eo6kkSYoyllSSJCmq7dq1izvvvJNhw4Zx2mmnMWzYMO68805yc3OPuO//b++OY6Ks/ziAv+8CptwpeBdTukw4resEzQPsVNaWhDWRcqNjgOicmgMzlpuODWzBnG0WtlY5Q07aKovVnYSJCqTeqgm4ceCcu8PUAd4xLAacosEl3P3+aNx4fBDOfuJFvV8bG/s83+d5Ps/DP+y97/f7OJ1O5OXlIS4uDnFxcdi2bRscDgeSkpKwYcOGSe+1q6sLFosFycnJomMjM6n+DSFVfX09tFotZs2aFZD7L1myBHPmzMHXX38dkPsTERHR3xMU6AaIiIiI/q7+/n5kZWWho6MDr7/+OhYuXAi73Y6Kigo0NjbCZDJBLpcDAPr6+pCdnY2enh5kZmZCrVbDarVi48aN+OOPPx5Jv7/88guGh4fx4osvio7ZbDaEhYUJ9qmaqurr6wM2i2rE0qVL8fPPPwe0ByIiInowDKmIiIhoyjp8+DDa29vx7rvvIjs721fXarXYs2cPDh8+jB07dgAAjEYjbty4gZKSErz22msAgHXr1uGDDz5AeXn5I+nXarUiNDRUFETdvn0bHR0d0Ov1j6SPyeR2u9Hc3BzwDeCfeeYZHD9+HA6H418R/BEREf0XcLkfERERTVk//vgjFAoFMjIyBPWMjAwoFAqcPn3aV7NYLIiIiEBqaqpg7JYtWx5JrwDgcDigUqkgkUgEdbvdDq/X+69Y6me1WuH1epGQkPBQr9vd3Q2j0YiCggLs378fly5dGnf8SDDldDofah9EREQ0eRhSERER0ZTldDoRHR2NoCDh5PCgoCBERUXB4XAIxs6bNw9SqfDfH6VSiZkzZwpqJ0+eRFZWFnQ6HZKSkkT3HRoawt69e/H8888jISEBhYWFcLvdE/brcrl8yw9HG9k0fbwv+zU1NUGn04l+YmNjodVqBWOLi4uh0WjQ0tIius6GDRug0Wjw008/iZ5Zo9EgJyfHV2tra8Obb76JZcuWQafTYdWqVRN+Ne/cuXPQ6XSYNm3auOMeRG1tLQ4ePIgVK1agqKgIWVlZOHfuHD788EN4vd4xzxm9zJOIiIimBoZURERERPcICwvD+vXrfUsF71VaWorz58/j+PHjqKurw7Vr11BSUjLhdaVSKTwej6juz5f9EhIS0NLSIvipqalBeHg43n77bd+4wcFBVFdXIzw8HCaTacxrqdVqHD16VFAzm81Qq9WCWk5ODqKjo3HmzBlYrVYYjUZoNJpxn7GhoQErVqwYd8yD+PXXX9HZ2YmioiLExMRg2rRpUKlUyMnJwUsvvYSKiooxzxt5z4899thD64WIiIgmF0MqIiIimrLmzp2LtrY2DA0NCepDQ0Nob28X7EWkUqnQ0dEhCol6enpw69YtQS0xMRFr1qyBSqUa875msxm5ubmYPXs2FAoF3nrrLVRWVmJ4eHjcfpVKJVwul6hus9kQGhqK6Ojocc8f7c8//0ReXh7i4+ORm5vrq9fU1EAqlaKgoACnTp3CnTt3ROeuXr0ajY2N6O3tBQB0dnbCbrcLvjrY29uLjo4OZGZmQiaTQSqVIioqCmlpafftqa+vD3a7/aGGVHV1ddi0adOYx5YsWYK+vj7R3x+A7z0rlcqH1gsRERFNLoZURERENGUlJyejt7dXNGPou+++Q29vryB0WblyJbq7u1FdXS0Y+6Cbpt+6dQtdXV149tlnfbWYmBjcuXMHnZ2d4577xBNP4PfffxeEWQMDA2hra4NWqxXtVTWeoqIiuN1u7Nu3T1A3mUxISUlBSkoKgoODcfLkSdG5MpkMycnJqKqqAvBX6JaamoqQkBDfGIVCgfnz56OwsBAnTpzA9evXJ+ypoaEBcrkcsbGxfj/HRKZPn+57Ly0tLdDr9Th48KDveGxsLNrb20Xn/fbbbwD+eudEREQ0NfDrfkRERDRlvfHGG6ipqcGePXtgs9mg1Wpht9thNpsRHR0t+MLc1q1bUV1djcLCQly8eBFqtRpWqxUtLS2YNWuW3/ccmZk0eh+rGTNmCI7dz7Jly1BZWYkrV674Qq7W1lYMDw/D7XajrKxMdE5oaCjWr18vqH355ZewWCwwm82YPn26r97W1oampibk5+cjJCQEKSkpMJvNSE9PF13XYDDgnXfewcaNG/H999/j0KFDqKurE4z56quvUF5ejtLSUly7dg2RkZHYuXMnUlJSxny+hoYG6PV60b5f4/noo48gk8lE9dWrV2P58uWCWmtrK1wuF5qbm301mUw25nu/cOEC5s2bx5CKiIhoCmFIRURERFPWjBkzUFFRgU8++QRnz55FZWUllEolMjMzkZeXJ9ikXKFQ4JtvvsH777+Po0ePQiKRQK/X44svvoDBYPB7o++RQKW/vx8RERG+30cfu58XXngBUqkUTU1NvpDKZrMBAC5dujTmF+uWLl0qCKkaGxuxf/9+GI1GPPnkk4KxJpMJarUazz33HAAgLS0N6enpuHLlCp5++mnB2Li4OHi9Xnz66ad4/PHHodFoRCGVUqlEfn4+8vPzcfv2bXz77bfYtWsXNBoN5s+fL+q1vr4emzdvHvcd3OvemW0j1Go1li9fjsHBQV8tPT0dERER0Ol0vtrly5exZs0awbkejwcXLly4b5hGRERE/0wMqYiIiGhK0Ov1uHz5sqiuUChQXFyM4uLiCa8xd+5cHDhwQFDr6+uDy+VCZGSkX33MnDkTkZGRaG1t9W00brPZIJPJ7ruH1ehek5KScOLECV/wlJ2djezsbL/u7XQ6sWPHDuTn50Ov1wuO3b17F8eOHUN/fz8SExMFx8xmMwoKCkTXMxgMKCkp8evdyeVybNmyBWVlZbh69eqYIdWZM2f8eg4A2Ldvn2ip4lhUKhWam5sRFxeHoKAgwRLO/v5+OJ1OhIeHC85paGhAT08PDAaD3/0QERFR4DGkIiIiov+MwcFB0YypkSV2o4Od4eFhDA0N4e7du/B6vXC73ZBIJL49mwwGAw4dOoT4+HgEBwfjwIEDSEtL8+tLcps3b8a6detw/fp1PPXUU373PjAwgO3btyMpKUm0/A8ALBYLbt68iaqqKoSFhfnqP/zwA4xGI3bu3CnYcwoAMjIyoNVqBTOTRty8eRPl5eV49dVXERUVBa/Xi8rKSgwMDCAmJsbvvv9fa9euxXvvvYeBgQHB38jhcODjjz8eM3yrqqpCYmKiYN8wIiIi+udjSEVERET/GVu3boVKpcLChQvh8XjQ2NgIi8UCnU4nmKFz7NgxQfixePFiqFQqnD17FgCQm5sLl8uF1NRUeDwevPLKK9i1a5dfPcTHx2PlypUoKyvD3r17/e69trYWra2taG9vx6lTp0THFy1ahNTUVCxYsEBQz8zMRGlpKU6fPi1a/iaXy+/7Jb7g4GB0d3dj27Zt6OnpQUhICBYsWIDPPvtMtMxwMkkkEhQWFuLIkSMwmUyQSqXweDyIiIjA7t27RfuJORwO1NbW4siRI4+sRyIiIno4JF6v1xvoJoiIiIgehc8//xxVVVXo7OyE2+3G7Nmz8fLLL2P79u2C/asmW1dXF9auXQuz2fxAs6loYgUFBZDL5di9e3egWyEiIqIHxJCKiIiIiIiIiIgCzv/vAxMREREREREREU0ShlRERERERERERBRwDKmIiIiIiIiIiCjgGFIREREREREREVHAMaQiIiIiIiIiIqKAY0hFREREREREREQBx5CKiIiIiIiIiIgCjiEVEREREREREREF3P8AWcJbCPaEpSMAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "                    \n",
+    "\n",
+    "# this saves a lot of typing! \n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
+   "metadata": {},
+   "source": [
+    "## ZAMS Luminosity distribution with the initial mass function\n",
+    "\n",
+    "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars.  So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Update the probability distribution to use the three-part power law IMF \n",
+    "population.update_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.2182216189410787\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
+   "metadata": {},
+   "source": [
+    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it's not smooth - it's spiky! \n",
+    "\n",
+    "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n",
+    "\n",
+    "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## A better-sampled grid\n",
+    "\n",
+    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
+    "\n",
+    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rename the old variable (M_1) because we want it to be called lnM_1 now\n",
+    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
+   "metadata": {},
+   "source": [
+    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
+    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
+    "# because  M * dprob/dM = dprob/dlnM\n",
+    "population.update_grid_variable(\n",
+    "    name=\"lnM_1\",\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    precode=\"M_1=math.exp(lnM_1)\",\n",
+    ")\n",
+    "# print(population.grid_options[\"_grid_variables\"]) # debugging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.9956307907476224\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6",
+   "metadata": {},
+   "source": [
+    "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
+   "metadata": {},
+   "source": [
+    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
+    "\n",
+    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(*L*/L<sub>☉</sub>)=-2. \n",
+    " \n",
+    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
+    "* Different initial distributions: the Kroupa distribution isn't the only one out there\n",
+    "* Change the metallicity and mass ranges\n",
+    "* What about a non-constant star formation rate? This is more of a challenge!\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
+    "* Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_20_1.png b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_20_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b42bb5cf421e2a5877285d72adf7231a14cbbc97
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_20_1.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_25_1.png b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_25_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef91ecc96f464ff3e4d9e1e0e1a2b01a1a9d12e1
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_25_1.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_33_0.png b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_33_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0ffea4ba3f61ecf63a8c5b79dd15de804507881
Binary files /dev/null and b/docs/build/doctrees/nbsphinx/notebook_luminosity_function_single_33_0.png differ
diff --git a/docs/build/doctrees/nbsphinx/notebook_population.ipynb b/docs/build/doctrees/nbsphinx/notebook_population.ipynb
index b6a37baa8d90a2f36c0fd19311548ed49e77f173..a24638c0bd3a15a57bbf611fccb71b2100c75945 100644
--- a/docs/build/doctrees/nbsphinx/notebook_population.ipynb
+++ b/docs/build/doctrees/nbsphinx/notebook_population.ipynb
@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Running populations with binarycpython\n",
+    "# Tutorial: Running populations with binary_c-python\n",
     "This notebook will show you how to evolve a population of stars\n",
     "\n",
     "Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let's go through the functionality of this object step by step and set up some example populations. \n",
@@ -23,9 +23,12 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "from binarycpython.utils.custom_logging_functions import temp_dir\n",
     "from binarycpython.utils.grid import Population\n",
     "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_population\")\n",
+    "\n",
     "# help(Population) # Uncomment to see the public functions of this object"
    ]
   },
@@ -60,7 +63,8 @@
       "adding: max_evolution_time=15000 to BSE_options\n",
       "adding: eccentricity=0.02 to BSE_options\n",
       "adding: amt_cores=2 to grid_options\n",
-      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/example_python_population_result to custom_options >>>>\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_population to grid_options\n",
+      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result to custom_options >>>>\n",
       "<<<< Warning: Key does not match previously known parameter:                     adding: base_filename=example_pop.dat to custom_options >>>>\n",
       "1\n",
       "example_pop.dat\n",
@@ -88,11 +92,12 @@
     "\n",
     "\n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "    \n",
     "    # Custom options # TODO: need to be set in grid_options probably\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -133,13 +138,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Writing settings to /tmp/binary_c_python/example_python_population_result/example_pop_settings.json\n"
+      "Writing settings to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/binary_c_python/example_python_population_result/example_pop_settings.json'"
+       "'/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json'"
       ]
      },
      "execution_count": 3,
@@ -181,7 +186,7 @@
      "text": [
       "Help on method add_grid_variable in module binarycpython.utils.grid:\n",
       "\n",
-      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='edge', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
+      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='centred', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
       "    Function to add grid variables to the grid_options.\n",
       "    \n",
       "    The execution of the grid generation will be through a nested for loop.\n",
@@ -199,25 +204,25 @@
       "        name:\n",
       "            name of parameter. This is evaluated as a parameter and you can use it throughout\n",
       "            the rest of the function\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                name = 'lnm1'\n",
       "        longname:\n",
       "            Long name of parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                longname = 'Primary mass'\n",
       "        range:\n",
       "            Range of values to take. Does not get used really, the spacingfunction is used to\n",
       "            get the values from\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                range = [math.log(m_min), math.log(m_max)]\n",
       "        resolution:\n",
       "            Resolution of the sampled range (amount of samples).\n",
       "            TODO: check if this is used anywhere\n",
       "    \n",
-      "            Examples: \n",
+      "            Examples:\n",
       "                resolution = resolution[\"M_1\"]\n",
       "        spacingfunction:\n",
       "            Function determining how the range is sampled. You can either use a real function,\n",
@@ -230,12 +235,12 @@
       "        precode:\n",
       "            Extra room for some code. This code will be evaluated within the loop of the\n",
       "            sampling function (i.e. a value for lnm1 is chosen already)\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                precode = 'M_1=math.exp(lnm1);'\n",
       "        probdist:\n",
       "            Function determining the probability that gets assigned to the sampled parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                probdist = 'Kroupa2001(M_1)*M_1'\n",
       "        dphasevol:\n",
@@ -249,7 +254,7 @@
       "                condition = 'self.grid_options['binary']==1'\n",
       "        gridtype:\n",
       "            Method on how the value range is sampled. Can be either 'edge' (steps starting at\n",
-      "            the lower edge of the value range) or 'center'\n",
+      "            the lower edge of the value range) or 'centred'\n",
       "            (steps starting at lower edge + 0.5 * stepsize).\n",
       "\n"
      ]
@@ -313,7 +318,7 @@
       "    \"dphasevol\": \"dlnm1\",\n",
       "    \"parameter_name\": \"M_1\",\n",
       "    \"condition\": \"\",\n",
-      "    \"gridtype\": \"edge\",\n",
+      "    \"gridtype\": \"centred\",\n",
       "    \"branchpoint\": 0,\n",
       "    \"grid_variable_number\": 0\n",
       "}\n"
@@ -457,7 +462,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: parse_function=<function parse_function at 0x7ff3bdf79620> to grid_options\n"
+      "adding: parse_function=<function parse_function at 0x7f531bc3b6a8> to grid_options\n"
      ]
     }
    ],
@@ -536,25 +541,25 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
-      "EXAMPLE_COMPACT_OBJECT             2.867655467480e+01 1.33079 9.81391 0.00167028 13\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "EXAMPLE_COMPACT_OBJECT             1.931266944719e+01 1.3933 12.3177 0.00124307 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.439623364590e+01 1.38004 7.81906 0.00224431 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.364277535630e+01 1.47961 15.4603 0.000925128 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.017435498578e+01 1.59052 19.4046 0.000688507 13\n",
-      "EXAMPLE_COMPACT_OBJECT             8.294870923827e+00 1.7197 24.3552 0.000512406 13\n",
-      "EXAMPLE_COMPACT_OBJECT             6.802132608769e+00 1.84162 30.5689 0.000381347 13\n",
-      "EXAMPLE_COMPACT_OBJECT             5.723570798020e+00 1.99471 38.3678 0.00028381 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.933751523833e+00 2.15875 48.1564 0.000211219 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.337250536639e+00 2.35209 60.4424 0.000157195 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.862081089332e+00 2.56776 75.8628 0.000116989 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.449960890183e+00 2.80457 95.2174 8.70668e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.172196856333e+00 3.05193 119.51 6.47976e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.069627290216e+00 3.27563 150 4.82242e-05 14\n",
-      "Population-2a7732d03e594ef4b5dfe9051b41d9c0 finished! The total probability was: 0.05150046619238191. It took a total of 0.7797017097473145s to run 20 systems on 2 cores\n",
+      "EXAMPLE_COMPACT_OBJECT             4.139293101586e+01 1.29427 8.13626 0.00202467 13\n",
+      "EXAMPLE_COMPACT_OBJECT             2.802986496151e+01 1.33699 10.0967 0.00152924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.963621764679e+01 1.39754 12.5294 0.00115504 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.427601421985e+01 1.47745 15.5483 0.000872405 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.094409257247e+01 1.57571 19.2947 0.00065893 13\n",
+      "EXAMPLE_COMPACT_OBJECT             9.181971798545e+00 1.68748 23.9436 0.000497691 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.905335716621e+00 1.77287 29.7128 0.000375908 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.451192744924e+00 1.81495 36.872 0.000283924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396133472739e+00 1.82088 45.7561 0.000214449 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396675941641e+00 1.82123 56.7809 0.000161974 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.404641347602e+00 1.82074 70.4621 0.000122339 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.444217227690e+00 1.81636 87.4397 9.2403e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.453317880232e+00 1.81536 108.508 6.97923e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.450828476484e+00 1.81563 134.653 5.27143e-05 13\n",
+      "Population-f28b5f98d7ef40dcb17fc2481a6d3ced finished! The total probability was: 0.04440288843805411. It took a total of 2.785212755203247s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n"
      ]
     }
@@ -586,7 +591,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'population_name': '2a7732d03e594ef4b5dfe9051b41d9c0', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.05150046619238191, 'total_count': 20, 'start_timestamp': 1628444120.234709, 'end_timestamp': 1628444121.0144107, 'total_mass_run': 730.1048014407228, 'total_probability_weighted_mass_run': 0.2983275843337705, 'zero_prob_stars_skipped': 0}\n"
+      "{'population_name': 'f28b5f98d7ef40dcb17fc2481a6d3ced', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.04440288843805411, 'total_count': 20, 'start_timestamp': 1629459533.935186, 'end_timestamp': 1629459536.7203987, 'total_mass_run': 684.2544031669779, 'total_probability_weighted_mass_run': 0.28134439269236855, 'zero_prob_stars_skipped': 0}\n"
      ]
     }
    ],
@@ -660,42 +665,22 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Saving grid code to grid_options\n",
-      "Writing grid code to /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
-      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
       "Grid code loaded\n",
-      "Writing binary_c calls to /tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
+      "Writing binary_c calls to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
-      "/tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "binary_c M_1 2.0 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.013208238029791246\n",
-      "binary_c M_1 2.5102526289471614 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.009829948023831718\n",
-      "binary_c M_1 3.1506841305680684 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.0073157281034221516\n",
-      "binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.005444573822104362\n"
+      "with a total probability of 0.044402888438054094\n",
+      "/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
+      "binary_c M_1 2.227955577093495 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.010905083645619543\n",
+      "binary_c M_1 2.7647737053496777 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.008236638755149857\n",
+      "binary_c M_1 3.4309362899259503 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.006221155214163634\n",
+      "binary_c M_1 4.257608426597089 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.004698855121516278\n"
      ]
     }
    ],
    "source": [
-    "example_pop.set(verbosity=10)\n",
+    "example_pop.set(verbosity=1)\n",
     "calls_filename = example_pop.write_binary_c_calls_to_file()\n",
     "print(calls_filename)\n",
     "\n",
@@ -725,39 +710,34 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "Population-3680f3882c0a449c944462abffea2447 finished! The total probability was: 0.05150046619238191. It took a total of 0.6246354579925537s to run 20 systems on 2 cores\n",
+      "Population-e45c25448b32440cb7e220f4a3562907 finished! The total probability was: 0.04440288843805411. It took a total of 1.9539172649383545s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass zams_mass probability radius stellar_type\n",
-      "2.867655467480e+01 1.33079 9.81391 0.00167028 1.72498e-05 13\n",
-      "1.931266944719e+01 1.3933 12.3177 0.00124307 1.72498e-05 13\n",
-      "4.439623364590e+01 1.38004 7.81906 0.00224431 1.72498e-05 13\n",
-      "1.364277535630e+01 1.47961 15.4603 0.000925128 1.72498e-05 13\n",
-      "1.017435498578e+01 1.59052 19.4046 0.000688507 1.72498e-05 13\n",
-      "8.294870923827e+00 1.7197 24.3552 0.000512406 1.72498e-05 13\n",
-      "6.802132608769e+00 1.84162 30.5689 0.000381347 1.72498e-05 13\n",
-      "5.723570798020e+00 1.99471 38.3678 0.00028381 1.72498e-05 13\n",
-      "4.933751523833e+00 2.15875 48.1564 0.000211219 1.72498e-05 13\n",
-      "4.337250536639e+00 2.35209 60.4424 0.000157195 9.97286e-06 14\n",
-      "3.862081089332e+00 2.56776 75.8628 0.000116989 1.08873e-05 14\n",
-      "3.449960890183e+00 2.80457 95.2174 8.70668e-05 1.18914e-05 14\n",
-      "3.172196856333e+00 3.05193 119.51 6.47976e-05 1.29402e-05 14\n",
-      "3.069627290216e+00 3.27563 150 4.82242e-05 1.38887e-05 14\n",
+      "4.139293101586e+01 1.29427 8.13626 0.00202467 1.72498e-05 13\n",
+      "2.802986496151e+01 1.33699 10.0967 0.00152924 1.72498e-05 13\n",
+      "1.963621764679e+01 1.39754 12.5294 0.00115504 1.72498e-05 13\n",
+      "1.427601421985e+01 1.47745 15.5483 0.000872405 1.72498e-05 13\n",
+      "1.094409257247e+01 1.57571 19.2947 0.00065893 1.72498e-05 13\n",
+      "9.181971798545e+00 1.68748 23.9436 0.000497691 1.72498e-05 13\n",
+      "7.905335716621e+00 1.77287 29.7128 0.000375908 1.72498e-05 13\n",
+      "7.451192744924e+00 1.81495 36.872 0.000283924 1.72498e-05 13\n",
+      "7.396133472739e+00 1.82088 45.7561 0.000214449 1.72498e-05 13\n",
+      "7.396675941641e+00 1.82123 56.7809 0.000161974 1.72498e-05 13\n",
+      "7.404641347602e+00 1.82074 70.4621 0.000122339 1.72498e-05 13\n",
+      "7.444217227690e+00 1.81636 87.4397 9.2403e-05 1.72498e-05 13\n",
+      "7.453317880232e+00 1.81536 108.508 6.97923e-05 1.72498e-05 13\n",
+      "7.450828476484e+00 1.81563 134.653 5.27143e-05 1.72498e-05 13\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -817,11 +797,12 @@
     "    eccentricity=0.02,  # bse_options\n",
     "    \n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -876,15 +857,15 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -912,96 +893,39 @@
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Grid has handled 125 stars\n",
-      "with a total probability of 0.0862478164626921\n",
-      "Total starcount for this run will be: 125\n",
+      "Grid has handled 27 stars\n",
+      "with a total probability of 0.024868380796643753\n",
+      "Total starcount for this run will be: 27\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Population-d20a4c74d20a43b881c0c9e5def5f76c finished! The total probability was: 0.08624781646269201. It took a total of 8.561265707015991s to run 125 systems on 2 cores\n",
+      "Population-05128ef4c5fe4274a0356c3e99e2f2d2 finished! The total probability was: 0.024868380796643757. It took a total of 9.792905807495117s to run 27 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 stellar_type_2 prev_stellar_type_2 metallicity probability\n",
-      "8.863377990313e+01 1.29444 5.88566 0 2.99283 13 5 15 15 0.02 0.000627913\n",
-      "1.146421815741e+02 0 5.88566 1.33062 4.43925 15 15 13 5 0.02 0.000627913\n",
-      "7.222715508467e+01 1.34922 5.88566 0 5.88566 13 5 15 15 0.02 0.000627913\n",
-      "1.350021848285e+01 1.48488 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171108213270e+01 1.53113 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171086983243e+01 1.53177 17.3205 0 0.1 13 9 15 15 0.02 0.000154349\n",
-      "1.170770599495e+01 1.53176 17.3205 0 4.40513 13 5 15 15 0.02 0.000172877\n",
-      "1.230407246199e+01 1.59499 17.3205 0 4.40513 13 5 15 15 0.02 0.000610573\n",
-      "1.108751340926e+01 1.70319 17.3205 0 8.71025 13 4 15 15 0.02 0.000610573\n",
-      "1.941017702765e+01 1.34903 17.3205 1.65097 8.71025 13 13 13 5 0.02 0.000172877\n",
-      "1.980988739731e+01 1.36979 17.3205 1.60808 8.71025 13 13 13 5 0.02 0.000121486\n",
-      "3.571858031651e+01 1.53174 17.3205 1.30504 8.71025 13 13 13 5 0.02 8.42148e-05\n",
-      "3.459153942631e+01 1.53176 17.3205 1.31004 8.71025 13 13 13 5 0.02 9.8162e-05\n",
-      "1.687368550125e+01 1.34937 17.3205 1.73856 13.0154 13 13 13 8 0.02 0.000172877\n",
-      "1.194842917007e+01 1.78096 17.3205 0 13.0154 13 8 15 15 0.02 0.000610573\n",
-      "1.733614170983e+01 1.53184 17.3205 1.42375 13.0154 13 13 13 5 0.02 9.8162e-05\n",
-      "1.723547465714e+01 1.38403 17.3205 1.71288 13.0154 13 13 13 8 0.02 0.000121486\n",
-      "1.764340254985e+01 1.53174 17.3205 1.41264 13.0154 13 13 13 5 0.02 8.42148e-05\n",
-      "1.170425790780e+01 1.52963 17.3205 0 17.3205 13 5 15 15 0.02 0.000172877\n",
-      "8.922967341481e+00 1.85486 17.3205 0 17.3205 13 8 15 15 0.02 0.000610573\n",
-      "1.232906623449e+01 1.41074 17.3205 1.34281 17.3205 13 13 13 8 0.02 0.000121486\n",
-      "1.170775828562e+01 1.53183 17.3205 1.53183 17.3205 13 5 13 5 0.02 9.8162e-05\n",
-      "1.170770422321e+01 1.53175 17.3205 1.53175 17.3205 13 5 13 5 0.02 8.42148e-05\n",
-      "5.075844624794e+00 2.12303 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.766606588165e+00 2.20484 50.9713 0 0.1 14 8 15 15 0.02 3.79411e-05\n",
-      "4.768305081494e+00 2.18838 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.458869865939e+00 2.29864 50.9713 0 12.8178 14 8 15 15 0.02 0.000150087\n",
-      "1.806014211040e+01 2.10446 50.9713 1.40749 12.8178 13 13 13 5 0.02 2.9863e-05\n",
-      "4.797342083485e+00 2.10328 50.9713 0 12.8178 13 13 15 1 0.02 4.24954e-05\n",
-      "1.721374713429e+01 2.21673 50.9713 1.42212 12.8178 14 14 13 5 0.02 2.41295e-05\n",
-      "4.055645404546e+00 2.47276 50.9713 0 25.5357 14 7 15 15 0.02 0.000150087\n",
-      "1.806123543037e+01 2.21893 50.9713 1.40745 12.8178 14 14 13 5 0.02 2.07011e-05\n",
-      "8.117519147635e+00 2.10433 50.9713 2.21473 25.5357 13 13 14 8 0.02 4.24954e-05\n",
-      "8.315554923168e+00 2.15343 50.9713 2.08519 25.5357 13 13 13 8 0.02 2.9863e-05\n",
-      "7.917420996633e+00 2.21892 50.9713 1.7431 25.5357 14 14 13 8 0.02 2.07011e-05\n",
-      "7.693213405973e+00 2.21805 50.9713 1.78384 25.5357 14 14 13 8 0.02 2.41295e-05\n",
-      "3.753837732894e+00 2.62517 50.9713 0 38.2535 14 7 15 15 0.02 0.000150087\n",
-      "7.087296558990e+00 2.10417 50.9713 2.40935 38.2535 13 13 14 8 0.02 4.24954e-05\n",
-      "7.007109286263e+00 2.15854 50.9713 2.28672 38.2535 13 13 14 8 0.02 2.9863e-05\n",
-      "5.653200958306e+00 2.21878 50.9713 2.0587 38.2535 14 14 13 8 0.02 2.41295e-05\n",
-      "5.733794947644e+00 2.21892 50.9713 1.99255 38.2535 14 14 13 8 0.02 2.07011e-05\n",
-      "3.513216011269e+00 2.76647 50.9713 0 50.9713 14 7 15 15 0.02 0.000150087\n",
-      "4.750574783854e+00 2.27442 50.9713 0 50.9713 14 8 15 15 0.02 4.24954e-05\n",
-      "7.278384712062e+00 1.29678 50.9713 2.09216 50.9713 13 8 13 13 0.02 2.9863e-05\n",
-      "4.765996194699e+00 2.20787 50.9713 2.20787 50.9713 14 8 14 8 0.02 2.07011e-05\n",
-      "4.765535914728e+00 2.21331 50.9713 2.21331 50.9713 14 8 14 8 0.02 2.41295e-05\n",
-      "3.104706358826e+00 3.17639 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.069363482023e+00 3.27572 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.047074050271e+00 3.3836 150 0 37.575 14 7 15 15 0.02 3.68933e-05\n",
-      "5.974759306305e+00 3.23604 150 2.53922 37.575 14 14 14 7 0.02 1.04459e-05\n",
-      "6.074084349384e+00 3.30145 150 2.13876 37.575 14 14 13 8 0.02 7.34071e-06\n",
-      "5.733865371895e+00 3.29994 150 2.00498 37.575 14 14 13 8 0.02 5.93135e-06\n",
-      "3.027099358410e+00 3.53631 150 0 75.05 14 7 15 15 0.02 3.68933e-05\n",
-      "5.807147339697e+00 3.30197 150 1.9791 37.575 14 14 13 8 0.02 5.08861e-06\n",
-      "4.862942347290e+00 3.25294 150 2.97823 75.05 14 14 14 7 0.02 1.04459e-05\n",
-      "4.556479830908e+00 3.29942 150 2.73221 75.05 14 14 14 7 0.02 7.34071e-06\n",
-      "3.853070305680e+00 3.29977 150 2.62486 75.05 14 14 14 7 0.02 5.93135e-06\n",
-      "3.881529045940e+00 3.30149 150 2.55924 75.05 14 14 14 7 0.02 5.08861e-06\n",
-      "3.015033359333e+00 3.64419 150 0 112.525 14 7 15 15 0.02 3.68933e-05\n",
-      "4.126828648362e+00 3.32047 150 0 112.525 14 14 15 3 0.02 1.04459e-05\n",
-      "3.990017992944e+00 3.3032 150 2.94027 112.525 14 14 14 7 0.02 7.34071e-06\n",
-      "3.206771867883e+00 3.07671 150 3.11282 112.525 14 14 14 7 0.02 5.93135e-06\n",
-      "3.006827156705e+00 3.72638 150 0 150 14 7 15 15 0.02 3.68933e-05\n",
-      "3.218786094847e+00 3.30337 150 3.01344 112.525 14 14 14 7 0.02 5.08861e-06\n",
-      "4.527722847382e+00 1.42238 150 0 150 13 5 15 15 0.02 1.04459e-05\n",
-      "3.069567332611e+00 3.27804 150 3.27804 150 14 7 14 7 0.02 5.93135e-06\n",
-      "5.726405299909e+00 1.29746 150 3.22759 150 13 8 14 14 0.02 7.34071e-06\n",
-      "3.069626478211e+00 3.27565 150 3.27565 150 14 7 14 7 0.02 5.08861e-06\n",
+      "1.219029061236e+01 1.60007 17.3205 0 2.97008 13 5 15 15 0.02 0.000498487\n",
+      "1.935920346899e+01 1.29448 17.3205 0 8.71025 13 13 15 2 0.02 0.000498487\n",
+      "2.123795595728e+01 1.30902 17.3205 1.58519 8.71025 13 13 13 5 0.02 0.000287968\n",
+      "3.579099761269e+01 1.52414 17.3205 1.30642 8.71025 13 13 13 5 0.02 0.000220016\n",
+      "1.674063083432e+01 1.29457 17.3205 0 14.4504 13 13 15 2 0.02 0.000498487\n",
+      "1.779197348711e+01 1.3228 17.3205 1.71196 14.4504 13 13 13 8 0.02 0.000287968\n",
+      "1.548740826516e+01 1.52415 17.3205 1.45407 14.4504 13 13 13 5 0.02 0.000220016\n",
+      "1.772169325356e+01 1.81957 73.0434 1.46573 12.2572 13 13 13 5 0.02 4.43422e-05\n",
+      "1.367065500196e+01 1.66003 73.0434 1.79487 12.2572 13 13 13 8 0.02 7.67586e-05\n",
+      "2.021960493499e+01 1.82061 73.0434 1.39205 12.2572 13 13 13 5 0.02 3.38788e-05\n",
+      "9.012246630357e+00 1.81529 73.0434 0 36.5717 13 8 15 15 0.02 7.67586e-05\n",
+      "7.462779538274e+00 1.82255 73.0434 1.81499 36.5717 13 13 13 8 0.02 3.38788e-05\n",
+      "1.030499912298e+01 1.80592 73.0434 1.81066 36.5717 13 13 13 8 0.02 4.43422e-05\n",
+      "4.227002356107e+00 2.43719 73.0434 0 60.8862 14 14 15 1 0.02 7.67586e-05\n",
+      "7.396288708628e+00 1.8216 73.0434 1.8216 60.8862 13 8 13 8 0.02 3.38788e-05\n",
+      "7.394728392218e+00 1.80919 73.0434 1.79091 60.8862 13 13 13 8 0.02 4.43422e-05\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -1067,10 +991,11 @@
     "    \n",
     "    # grid_options\n",
     "    amt_cores=2,  # grid_options\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -1168,14 +1093,14 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -1184,7 +1109,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1198,7 +1123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/doctrees/notebook_HRD.doctree b/docs/build/doctrees/notebook_HRD.doctree
new file mode 100644
index 0000000000000000000000000000000000000000..6f64a3c5cd31d96fdeccc6a59b02ca9e32aa40ca
Binary files /dev/null and b/docs/build/doctrees/notebook_HRD.doctree differ
diff --git a/docs/build/doctrees/notebook_api_functionality.doctree b/docs/build/doctrees/notebook_api_functionality.doctree
index d13dc561967683b55c3d7d9fa7e91bc39cca513f..da47082e008333ce605f738f5db66ba51e9ad68f 100644
Binary files a/docs/build/doctrees/notebook_api_functionality.doctree and b/docs/build/doctrees/notebook_api_functionality.doctree differ
diff --git a/docs/build/doctrees/notebook_common_envelope_evolution.doctree b/docs/build/doctrees/notebook_common_envelope_evolution.doctree
new file mode 100644
index 0000000000000000000000000000000000000000..86fc54029df108db591a1282a405ce75eae79d89
Binary files /dev/null and b/docs/build/doctrees/notebook_common_envelope_evolution.doctree differ
diff --git a/docs/build/doctrees/notebook_custom_logging.doctree b/docs/build/doctrees/notebook_custom_logging.doctree
index 9e84119cc3983c0cb2d071608c44147ef25ddab1..f8ec73a2e9c9a2115110f4693e0e3ffa711efa71 100644
Binary files a/docs/build/doctrees/notebook_custom_logging.doctree and b/docs/build/doctrees/notebook_custom_logging.doctree differ
diff --git a/docs/build/doctrees/notebook_extra_features.doctree b/docs/build/doctrees/notebook_extra_features.doctree
index 05d1f6e901171cf1c74eefc73962b55c4909794b..463041b62f8b3cbc6366138d0f0aea8794ddae17 100644
Binary files a/docs/build/doctrees/notebook_extra_features.doctree and b/docs/build/doctrees/notebook_extra_features.doctree differ
diff --git a/docs/build/doctrees/notebook_individual_systems.doctree b/docs/build/doctrees/notebook_individual_systems.doctree
index 5b53131af30bfd3e41de3be0cd1877012043cac3..3bcfec9f5f8eb1e0c17402dce7f70d85b69179a7 100644
Binary files a/docs/build/doctrees/notebook_individual_systems.doctree and b/docs/build/doctrees/notebook_individual_systems.doctree differ
diff --git a/docs/build/doctrees/notebook_luminosity_function_binaries.doctree b/docs/build/doctrees/notebook_luminosity_function_binaries.doctree
new file mode 100644
index 0000000000000000000000000000000000000000..2ba67e6401857e3f174a1bf75b985b33345d6d90
Binary files /dev/null and b/docs/build/doctrees/notebook_luminosity_function_binaries.doctree differ
diff --git a/docs/build/doctrees/notebook_luminosity_function_single.doctree b/docs/build/doctrees/notebook_luminosity_function_single.doctree
new file mode 100644
index 0000000000000000000000000000000000000000..a0ae888b7eb2f7347491e30447833bdc80ed5f92
Binary files /dev/null and b/docs/build/doctrees/notebook_luminosity_function_single.doctree differ
diff --git a/docs/build/doctrees/notebook_population.doctree b/docs/build/doctrees/notebook_population.doctree
index 8dc7f0c81bcae8dba9df8e55481ed6ade245f1cd..0d4e1c48c112494fe160b72899723d53db3477f4 100644
Binary files a/docs/build/doctrees/notebook_population.doctree and b/docs/build/doctrees/notebook_population.doctree differ
diff --git a/docs/build/doctrees/readme_link.doctree b/docs/build/doctrees/readme_link.doctree
index fd66cbc8cbd1f29cc2332d668bdbc6c429422a30..e0d5b1779a1d966852f4d94e2b0fac30f86115b8 100644
Binary files a/docs/build/doctrees/readme_link.doctree and b/docs/build/doctrees/readme_link.doctree differ
diff --git a/docs/build/html/_images/notebook_HRD_14_2.png b/docs/build/html/_images/notebook_HRD_14_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..6dfb418a4777bb8325ab533e23e7ca0d29b8c100
Binary files /dev/null and b/docs/build/html/_images/notebook_HRD_14_2.png differ
diff --git a/docs/build/html/_images/notebook_HRD_19_2.png b/docs/build/html/_images/notebook_HRD_19_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5e57f5de5dd5226a46542b5f0539cc9376489b1
Binary files /dev/null and b/docs/build/html/_images/notebook_HRD_19_2.png differ
diff --git a/docs/build/html/_images/notebook_HRD_23_2.png b/docs/build/html/_images/notebook_HRD_23_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..56e92fab6d6075417a4babc662028fba4312c57b
Binary files /dev/null and b/docs/build/html/_images/notebook_HRD_23_2.png differ
diff --git a/docs/build/html/_images/notebook_HRD_26_2.png b/docs/build/html/_images/notebook_HRD_26_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..c5cb5bf342275e846454020542dbe17904efe96c
Binary files /dev/null and b/docs/build/html/_images/notebook_HRD_26_2.png differ
diff --git a/docs/build/html/_images/notebook_common_envelope_evolution_14_2.png b/docs/build/html/_images/notebook_common_envelope_evolution_14_2.png
new file mode 100644
index 0000000000000000000000000000000000000000..47e9c2954323516f1e932e7bf5dc22466d51680a
Binary files /dev/null and b/docs/build/html/_images/notebook_common_envelope_evolution_14_2.png differ
diff --git a/docs/build/html/_images/notebook_luminosity_function_binaries_20_1.png b/docs/build/html/_images/notebook_luminosity_function_binaries_20_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..3da686142c849c7f9646994928eab4d727352c91
Binary files /dev/null and b/docs/build/html/_images/notebook_luminosity_function_binaries_20_1.png differ
diff --git a/docs/build/html/_images/notebook_luminosity_function_single_20_1.png b/docs/build/html/_images/notebook_luminosity_function_single_20_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..b42bb5cf421e2a5877285d72adf7231a14cbbc97
Binary files /dev/null and b/docs/build/html/_images/notebook_luminosity_function_single_20_1.png differ
diff --git a/docs/build/html/_images/notebook_luminosity_function_single_25_1.png b/docs/build/html/_images/notebook_luminosity_function_single_25_1.png
new file mode 100644
index 0000000000000000000000000000000000000000..ef91ecc96f464ff3e4d9e1e0e1a2b01a1a9d12e1
Binary files /dev/null and b/docs/build/html/_images/notebook_luminosity_function_single_25_1.png differ
diff --git a/docs/build/html/_images/notebook_luminosity_function_single_33_0.png b/docs/build/html/_images/notebook_luminosity_function_single_33_0.png
new file mode 100644
index 0000000000000000000000000000000000000000..a0ffea4ba3f61ecf63a8c5b79dd15de804507881
Binary files /dev/null and b/docs/build/html/_images/notebook_luminosity_function_single_33_0.png differ
diff --git a/docs/build/html/_modules/binarycpython/utils/custom_logging_functions.html b/docs/build/html/_modules/binarycpython/utils/custom_logging_functions.html
index de6d5f80aa620972a7bfd2adc6f3148ab69e4525..d22fad99c9b5d87d385672275d93ab7b45a53d3b 100644
--- a/docs/build/html/_modules/binarycpython/utils/custom_logging_functions.html
+++ b/docs/build/html/_modules/binarycpython/utils/custom_logging_functions.html
@@ -644,9 +644,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/distribution_functions.html b/docs/build/html/_modules/binarycpython/utils/distribution_functions.html
index 1cddf50cc54dc1cbc277437ad1bac7f22229235b..30d9ff1c98b93f848d446518ffa306675e46a639 100644
--- a/docs/build/html/_modules/binarycpython/utils/distribution_functions.html
+++ b/docs/build/html/_modules/binarycpython/utils/distribution_functions.html
@@ -2482,9 +2482,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/functions.html b/docs/build/html/_modules/binarycpython/utils/functions.html
index 4e1bbc15df334fcc4d699503ff7fcb1cdca18db2..742305585d99fd2e5ece2eeccda993e08f86e74a 100644
--- a/docs/build/html/_modules/binarycpython/utils/functions.html
+++ b/docs/build/html/_modules/binarycpython/utils/functions.html
@@ -187,6 +187,8 @@
 <span class="kn">import</span> <span class="nn">h5py</span>
 <span class="kn">import</span> <span class="nn">numpy</span> <span class="k">as</span> <span class="nn">np</span>
 
+<span class="kn">import</span> <span class="nn">astropy.units</span> <span class="k">as</span> <span class="nn">u</span>
+
 <span class="kn">from</span> <span class="nn">binarycpython</span> <span class="kn">import</span> <span class="n">_binary_c_bindings</span>
 <span class="kn">import</span> <span class="nn">binarycpython.utils.moe_di_stefano_2017_data</span> <span class="k">as</span> <span class="nn">moe_di_stefano_2017_data</span>
 
@@ -195,6 +197,44 @@
 <span class="c1">########################################################</span>
 <span class="c1"># Unsorted</span>
 <span class="c1">########################################################</span>
+<div class="viewcode-block" id="AutoVivificationDict"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.AutoVivificationDict">[docs]</a><span class="k">class</span> <span class="nc">AutoVivificationDict</span><span class="p">(</span><span class="nb">dict</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Implementation of perl&#39;s autovivification feature, by overriding the</span>
+<span class="sd">    get item and the __iadd__ operator (https://docs.python.org/3/reference/datamodel.html?highlight=iadd#object.__iadd__)</span>
+
+<span class="sd">    This allows to set values within a subdict that might not exist yet:</span>
+
+<span class="sd">    Example:</span>
+<span class="sd">        newdict = {}</span>
+<span class="sd">        newdict[&#39;example&#39;][&#39;mass&#39;] += 10</span>
+<span class="sd">        print(newdict)</span>
+<span class="sd">        &gt;&gt;&gt; {&#39;example&#39;: {&#39;mass&#39;: 10}}</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="k">def</span> <span class="fm">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">):</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="k">return</span> <span class="nb">dict</span><span class="o">.</span><span class="fm">__getitem__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">item</span><span class="p">)</span>
+        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+            <span class="n">value</span> <span class="o">=</span> <span class="bp">self</span><span class="p">[</span><span class="n">item</span><span class="p">]</span> <span class="o">=</span> <span class="nb">type</span><span class="p">(</span><span class="bp">self</span><span class="p">)()</span>
+            <span class="k">return</span> <span class="n">value</span>
+
+    <span class="k">def</span> <span class="fm">__iadd__</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">other</span><span class="p">):</span>
+        <span class="c1"># if a value does not exist, assume it is 0.0</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="bp">self</span> <span class="o">+=</span> <span class="n">other</span>
+        <span class="k">except</span><span class="p">:</span>
+            <span class="bp">self</span> <span class="o">=</span> <span class="n">other</span>
+        <span class="k">return</span> <span class="bp">self</span></div>
+
+<div class="viewcode-block" id="bin_data"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.bin_data">[docs]</a><span class="k">def</span> <span class="nf">bin_data</span><span class="p">(</span><span class="n">value</span><span class="p">,</span> <span class="n">binwidth</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Function that bins the data</span>
+
+<span class="sd">    Uses the absolute value of binwidth</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="k">return</span> <span class="p">((</span><span class="mf">0.5</span> <span class="k">if</span> <span class="n">value</span> <span class="o">&gt;</span> <span class="mf">0.0</span> <span class="k">else</span> <span class="o">-</span><span class="mf">0.5</span><span class="p">)</span> <span class="o">+</span> <span class="nb">int</span><span class="p">(</span><span class="n">value</span><span class="o">/</span><span class="nb">abs</span><span class="p">(</span><span class="n">binwidth</span><span class="p">)))</span> <span class="o">*</span> <span class="nb">abs</span><span class="p">(</span><span class="n">binwidth</span><span class="p">)</span></div>
+
 <div class="viewcode-block" id="convert_bytes"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.convert_bytes">[docs]</a><span class="k">def</span> <span class="nf">convert_bytes</span><span class="p">(</span><span class="n">size</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Function to return the size + a magnitude string</span>
@@ -451,6 +491,51 @@
             <span class="k">yield</span> <span class="n">val</span><span class="o">.</span><span class="vm">__name__</span></div>
 
 
+
+<div class="viewcode-block" id="convfloat"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.convfloat">[docs]</a><span class="k">def</span> <span class="nf">convfloat</span><span class="p">(</span><span class="n">x</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Convert scalar x to a float if we can, in which case return the float, otherwise just return x without changing it. Usually, x is a string, but could be anything that float() can handle without failure.</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+    <span class="k">try</span><span class="p">:</span>
+        <span class="n">y</span> <span class="o">=</span> <span class="nb">float</span><span class="p">(</span><span class="n">x</span><span class="p">)</span>
+        <span class="k">return</span> <span class="n">y</span>
+    <span class="k">except</span> <span class="ne">ValueError</span><span class="p">:</span>
+        <span class="k">return</span> <span class="n">x</span></div>
+
+<div class="viewcode-block" id="datalinedict"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.datalinedict">[docs]</a><span class="k">def</span> <span class="nf">datalinedict</span><span class="p">(</span><span class="n">line</span> <span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
+                 <span class="n">parameters</span> <span class="p">:</span> <span class="nb">list</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Convert a line of data to a more convenient dictionary.</span>
+<span class="sd">    Arguments:</span>
+<span class="sd">       line = a line of data as a string</span>
+<span class="sd">       parameters = a list of the parameter names</span>
+
+<span class="sd">    Note: if the parameter is a floating point number, it will be converted to Python&#39;s float type.</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="k">return</span> <span class="p">{</span><span class="n">param</span><span class="p">:</span><span class="n">convfloat</span><span class="p">(</span><span class="n">value</span><span class="p">)</span> <span class="k">for</span> <span class="n">param</span><span class="p">,</span> <span class="n">value</span> <span class="ow">in</span> <span class="nb">zip</span><span class="p">(</span><span class="n">parameters</span><span class="p">,</span> <span class="n">line</span><span class="o">.</span><span class="n">split</span><span class="p">())}</span></div>
+
+<div class="viewcode-block" id="pad_output_distribution"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.pad_output_distribution">[docs]</a><span class="k">def</span> <span class="nf">pad_output_distribution</span><span class="p">(</span><span class="n">dist</span> <span class="p">:</span> <span class="nb">dict</span><span class="p">,</span>
+                            <span class="n">binwidth</span> <span class="p">:</span> <span class="nb">float</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Given a distribution, dist (a dictionary), which should be binned every binwidth (float), fill the distribution with zeros when there is no data. Note: this changes the data in place.</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="c1"># sorted list of the keys</span>
+    <span class="n">skeys</span> <span class="o">=</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">dist</span><span class="o">.</span><span class="n">keys</span><span class="p">(),</span> <span class="n">key</span> <span class="o">=</span> <span class="k">lambda</span> <span class="n">x</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">x</span><span class="p">))</span>
+
+    <span class="c1"># get min and max, offset by the binwidth</span>
+    <span class="n">min_val</span> <span class="o">=</span> <span class="n">skeys</span><span class="p">[</span> <span class="mi">0</span><span class="p">]</span> <span class="o">-</span> <span class="n">binwidth</span>
+    <span class="n">max_val</span> <span class="o">=</span> <span class="n">skeys</span><span class="p">[</span><span class="o">-</span><span class="mi">1</span><span class="p">]</span> <span class="o">+</span> <span class="n">binwidth</span>
+
+    <span class="c1"># pad with zeros</span>
+    <span class="n">x</span> <span class="o">=</span> <span class="n">min_val</span>
+    <span class="k">while</span> <span class="n">x</span> <span class="o">&lt;=</span> <span class="n">max_val</span><span class="p">:</span>
+        <span class="n">dist</span><span class="p">[</span><span class="n">x</span><span class="p">]</span> <span class="o">=</span> <span class="n">dist</span><span class="o">.</span><span class="n">setdefault</span><span class="p">(</span><span class="n">x</span><span class="p">,</span><span class="mf">0.0</span><span class="p">)</span>
+        <span class="n">x</span> <span class="o">+=</span> <span class="n">binwidth</span>
+
+    <span class="k">return</span> <span class="n">dist</span></div>
+
 <div class="viewcode-block" id="catchtime"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.catchtime">[docs]</a><span class="k">class</span> <span class="nc">catchtime</span><span class="p">(</span><span class="nb">object</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Context manager to calculate time spent</span>
@@ -545,7 +630,6 @@
     <span class="k">if</span> <span class="n">verbosity</span> <span class="o">&gt;=</span> <span class="n">minimal_verbosity</span><span class="p">:</span>
         <span class="nb">print</span><span class="p">(</span><span class="n">message</span><span class="p">)</span></div>
 
-
 <div class="viewcode-block" id="remove_file"><a class="viewcode-back" href="../../../functions.html#binarycpython.utils.functions.remove_file">[docs]</a><span class="k">def</span> <span class="nf">remove_file</span><span class="p">(</span><span class="n">file</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span> <span class="n">verbosity</span><span class="p">:</span> <span class="nb">int</span> <span class="o">=</span> <span class="mi">0</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Function to remove files but with verbosity</span>
@@ -1033,7 +1117,7 @@
 
 <span class="sd">    Args:</span>
 <span class="sd">        output: binary_c output string</span>
-<span class="sd">        selected_header: string header of the output (the start of the line that you want to </span>
+<span class="sd">        selected_header: string header of the output (the start of the line that you want to</span>
 <span class="sd">            process)</span>
 
 <span class="sd">    Returns:</span>
@@ -1712,7 +1796,7 @@
 <span class="sd">    &quot;&quot;&quot;</span>
 
     <span class="c1"># Set up new dict</span>
-    <span class="n">new_dict</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span> <span class="c1"># TODO: check if this still works</span>
+    <span class="n">new_dict</span> <span class="o">=</span> <span class="n">OrderedDict</span><span class="p">()</span> <span class="c1"># TODO: check if this still necessary</span>
 
     <span class="c1">#</span>
     <span class="n">keys_1</span> <span class="o">=</span> <span class="n">dict_1</span><span class="o">.</span><span class="n">keys</span><span class="p">()</span>
@@ -1747,19 +1831,17 @@
     <span class="c1"># Go over the common keys:</span>
     <span class="k">for</span> <span class="n">key</span> <span class="ow">in</span> <span class="n">overlapping_keys</span><span class="p">:</span>
 
-        <span class="c1"># See whether the types are actually the same</span>
+        <span class="c1"># If they keys are not the same, it depends on their type whether we still deal with them at all, or just raise an error</span>
         <span class="k">if</span> <span class="ow">not</span> <span class="nb">type</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="ow">is</span> <span class="nb">type</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">]):</span>
-            <span class="c1"># Exceptions:</span>
-            <span class="k">if</span> <span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="ow">in</span> <span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">float64</span><span class="p">])</span> <span class="ow">and</span> <span class="p">(</span>
-                <span class="nb">type</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="ow">in</span> <span class="p">[</span><span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">float64</span><span class="p">]</span>
-            <span class="p">):</span>
+            <span class="c1"># Exceptions: numbers can be added</span>
+            <span class="k">if</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">float64</span><span class="p">))</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="p">(</span><span class="nb">int</span><span class="p">,</span> <span class="nb">float</span><span class="p">,</span> <span class="n">np</span><span class="o">.</span><span class="n">float64</span><span class="p">)):</span>
                 <span class="n">new_dict</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">+</span> <span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
-            <span class="c1"># Exceptions:</span>
-            <span class="k">elif</span> <span class="p">(</span><span class="nb">type</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="ow">in</span> <span class="p">[</span><span class="nb">dict</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">])</span> <span class="ow">and</span> <span class="p">(</span>
-                <span class="nb">type</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">])</span> <span class="ow">in</span> <span class="p">[</span><span class="nb">dict</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">]</span>
-            <span class="p">):</span>
+
+            <span class="c1"># Exceptions: versions of dicts can be merged</span>
+            <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="n">AutoVivificationDict</span><span class="p">)))</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="p">(</span><span class="nb">dict</span><span class="p">,</span> <span class="n">OrderedDict</span><span class="p">,</span> <span class="nb">type</span><span class="p">(</span><span class="n">AutoVivificationDict</span><span class="p">))):</span>
                 <span class="n">new_dict</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">merge_dicts</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
 
+            <span class="c1"># If the above cases have not dealt with it, then we should raise an error</span>
             <span class="k">else</span><span class="p">:</span>
                 <span class="nb">print</span><span class="p">(</span>
                     <span class="s2">&quot;Error key: </span><span class="si">{}</span><span class="s2"> value: </span><span class="si">{}</span><span class="s2"> type: </span><span class="si">{}</span><span class="s2"> and key: </span><span class="si">{}</span><span class="s2"> value: </span><span class="si">{}</span><span class="s2"> type: </span><span class="si">{}</span><span class="s2"> are not of the same type and cannot be merged&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
@@ -1793,6 +1875,10 @@
             <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">list</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">list</span><span class="p">):</span>
                 <span class="n">new_dict</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">+</span> <span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
 
+            <span class="c1"># Astropy quantities (using a dummy type representing the numpy array)</span>
+            <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">type</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">])</span><span class="o">*</span><span class="n">u</span><span class="o">.</span><span class="n">m</span><span class="p">))</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">type</span><span class="p">(</span><span class="n">np</span><span class="o">.</span><span class="n">array</span><span class="p">([</span><span class="mi">1</span><span class="p">])</span><span class="o">*</span><span class="n">u</span><span class="o">.</span><span class="n">m</span><span class="p">)):</span>
+                <span class="n">new_dict</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">+</span> <span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">]</span>
+
             <span class="c1"># dicts</span>
             <span class="k">elif</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">dict</span><span class="p">)</span> <span class="ow">and</span> <span class="nb">isinstance</span><span class="p">(</span><span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="nb">dict</span><span class="p">):</span>
                 <span class="n">new_dict</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">merge_dicts</span><span class="p">(</span><span class="n">dict_1</span><span class="p">[</span><span class="n">key</span><span class="p">],</span> <span class="n">dict_2</span><span class="p">[</span><span class="n">key</span><span class="p">])</span>
@@ -1928,7 +2014,7 @@
 
 <span class="sd">    When the keys of the current dictionary are of mixed type, we first find all the unique types.</span>
 <span class="sd">    Sort that list of type names. Then find the values that fit that type.</span>
-<span class="sd">    Sort those and append them to the sorted keys list. </span>
+<span class="sd">    Sort those and append them to the sorted keys list.</span>
 <span class="sd">    This is done until all the keys are sorted.</span>
 
 <span class="sd">    All objects other than dictionary types are directly return as they are</span>
@@ -1949,7 +2035,7 @@
         <span class="c1"># If there are multiple types, then we loop over them and do a piece wise sort</span>
         <span class="k">if</span> <span class="nb">len</span><span class="p">(</span><span class="n">all_types_keys</span><span class="p">)</span> <span class="o">&gt;</span> <span class="mi">1</span><span class="p">:</span>
             <span class="n">msg</span> <span class="o">=</span> <span class="s2">&quot;Different types in the same dictionary key set&quot;</span>
-            
+
             <span class="c1"># Create a string repr of the type name to sort them afterwards</span>
             <span class="n">str_types</span> <span class="o">=</span> <span class="p">{</span><span class="nb">repr</span><span class="p">(</span><span class="n">el</span><span class="p">):</span><span class="n">el</span> <span class="k">for</span> <span class="n">el</span> <span class="ow">in</span> <span class="n">all_types_keys</span><span class="p">}</span>
 
@@ -2190,9 +2276,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/grid.html b/docs/build/html/_modules/binarycpython/utils/grid.html
index 12c1a2512766f481cb452be0ac338af30d0a7a11..28d95d8881fc89218f0f454a8041f2237a484299 100644
--- a/docs/build/html/_modules/binarycpython/utils/grid.html
+++ b/docs/build/html/_modules/binarycpython/utils/grid.html
@@ -161,9 +161,6 @@
 
 <span class="sd">Here all the functionality of a Population object is defined.</span>
 
-<span class="sd">Useful for the user to understand the functionality,</span>
-<span class="sd">but copying functionality isn&#39;t recommended except if you know what you are doing</span>
-
 <span class="sd">Tasks:</span>
 <span class="sd">    - TODO: add functionality to &#39;on-init&#39; set arguments</span>
 <span class="sd">    - TODO: add functionality to return the initial_abundance_hash</span>
@@ -178,8 +175,7 @@
 <span class="sd">    - TODO: fix the correct object types for the default values of the bse_options</span>
 <span class="sd">    - TODO: uncomment and implement the HPC functionality</span>
 <span class="sd">    - TODO: think of a clean and nice way to unload and remove the custom_logging_info library from memory (and from disk)</span>
-<span class="sd">    - TODO: think of a nice way to remove the loaded grid_code/ generator from memory. </span>
-<span class="sd">    - TODO: Create a designated dict for results</span>
+<span class="sd">    - TODO: think of a nice way to remove the loaded grid_code/ generator from memory.</span>
 <span class="sd">&quot;&quot;&quot;</span>
 
 <span class="kn">import</span> <span class="nn">os</span>
@@ -194,6 +190,7 @@
 <span class="kn">import</span> <span class="nn">argparse</span>
 <span class="kn">import</span> <span class="nn">importlib.util</span>
 <span class="kn">import</span> <span class="nn">multiprocessing</span>
+<span class="kn">import</span> <span class="nn">resource</span>
 <span class="kn">from</span> <span class="nn">typing</span> <span class="kn">import</span> <span class="n">Union</span><span class="p">,</span> <span class="n">Any</span>
 <span class="kn">from</span> <span class="nn">collections</span> <span class="kn">import</span> <span class="p">(</span>
     <span class="n">OrderedDict</span><span class="p">,</span>
@@ -231,9 +228,9 @@
     <span class="n">recursive_change_key_to_string</span><span class="p">,</span>
     <span class="n">multiply_values_dict</span><span class="p">,</span>
     <span class="n">format_ensemble_results</span><span class="p">,</span>
+    <span class="n">AutoVivificationDict</span><span class="p">,</span>
 <span class="p">)</span>
 
-
 <span class="c1"># from binarycpython.utils.hpc_functions import (</span>
 <span class="c1">#     get_condor_version,</span>
 <span class="c1">#     get_slurm_version,</span>
@@ -254,6 +251,7 @@
 
 <span class="kn">from</span> <span class="nn">binarycpython</span> <span class="kn">import</span> <span class="n">_binary_c_bindings</span>
 
+<span class="n">secs_per_day</span> <span class="o">=</span> <span class="mi">86400</span> <span class="c1"># probably needs to go somewhere more sensible</span>
 
 <div class="viewcode-block" id="Population"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population">[docs]</a><span class="k">class</span> <span class="nc">Population</span><span class="p">:</span>
     <span class="sd">&quot;&quot;&quot;</span>
@@ -286,6 +284,9 @@
         <span class="c1"># Custom options</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span> <span class="o">=</span> <span class="p">{}</span>
 
+        <span class="c1"># shared memory used for logging</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span> <span class="o">=</span> <span class="p">{}</span>
+
         <span class="c1"># Load M&amp;s options</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">moe_di_stefano_default_options</span><span class="p">)</span>
 
@@ -307,7 +308,8 @@
         <span class="bp">self</span><span class="o">.</span><span class="n">process_ID</span> <span class="o">=</span> <span class="mi">0</span>
 
         <span class="c1"># Create location to store results. Users should write to this dictionary.</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span> <span class="o">=</span> <span class="p">{}</span>
+        <span class="c1"># The AutoVivificationDict allows for perls method of accessing possibly non-existant subdicts</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span> <span class="o">=</span> <span class="n">AutoVivificationDict</span><span class="p">()</span>
 
         <span class="c1"># Create location where ensemble results are written to</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">grid_ensemble_results</span> <span class="o">=</span> <span class="p">{}</span>
@@ -523,6 +525,64 @@
             <span class="p">):</span>
                 <span class="k">return</span> <span class="n">grid_variable</span>
 
+<div class="viewcode-block" id="Population.update_grid_variable"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.update_grid_variable">[docs]</a>    <span class="k">def</span> <span class="nf">update_grid_variable</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">name</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
+        <span class="o">**</span><span class="n">kwargs</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Function to update the values of a grid variable.</span>
+
+<span class="sd">        Args:</span>
+<span class="sd">            name:</span>
+<span class="sd">                name of the grid variable to be changed.</span>
+<span class="sd">            **kwargs:</span>
+<span class="sd">                key-value pairs to override the existing grid variable data. See add_grid_variable for these names.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="n">grid_variable</span> <span class="o">=</span> <span class="kc">None</span>
+        <span class="k">try</span><span class="p">:</span>
+            <span class="n">grid_variable</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_grid_variables&quot;</span><span class="p">][</span><span class="n">name</span><span class="p">]</span>
+        <span class="k">except</span> <span class="ne">KeyError</span><span class="p">:</span>
+            <span class="n">msg</span> <span class="o">=</span> <span class="s2">&quot;Unknown grid variable </span><span class="si">{}</span><span class="s2"> - please create it with the add_grid_variable() method.&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">name</span><span class="p">)</span>
+            <span class="k">raise</span> <span class="ne">KeyError</span><span class="p">(</span><span class="n">msg</span><span class="p">)</span>
+
+        <span class="k">for</span> <span class="n">key</span><span class="p">,</span><span class="n">value</span> <span class="ow">in</span> <span class="n">kwargs</span><span class="o">.</span><span class="n">items</span><span class="p">():</span>
+            <span class="n">grid_variable</span><span class="p">[</span><span class="n">key</span><span class="p">]</span> <span class="o">=</span> <span class="n">value</span>
+            <span class="n">verbose_print</span><span class="p">(</span>
+                <span class="s2">&quot;Updated grid variable: </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span><span class="n">grid_variable</span><span class="p">,</span> <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">)),</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
+                <span class="mi">1</span><span class="p">,</span>
+            <span class="p">)</span></div>
+
+<div class="viewcode-block" id="Population.rename_grid_variable"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.rename_grid_variable">[docs]</a>    <span class="k">def</span> <span class="nf">rename_grid_variable</span><span class="p">(</span>
+        <span class="bp">self</span><span class="p">,</span>
+        <span class="n">oldname</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
+        <span class="n">newname</span><span class="p">:</span> <span class="nb">str</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Function to rename a grid variable.</span>
+
+<span class="sd">        note: this does NOT alter the order</span>
+<span class="sd">        of the self.grid_options[&quot;_grid_variables&quot;] dictionary.</span>
+
+<span class="sd">        The order in which the grid variables are loaded into the grid is based on their</span>
+<span class="sd">        `grid_variable_number` property</span>
+
+<span class="sd">        Args:</span>
+<span class="sd">            oldname:</span>
+<span class="sd">                old name of the grid variable</span>
+<span class="sd">            newname:</span>
+<span class="sd">                new name of the grid variable</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="k">try</span><span class="p">:</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_grid_variables&quot;</span><span class="p">][</span><span class="n">newname</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_grid_variables&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">pop</span><span class="p">(</span><span class="n">oldname</span><span class="p">)</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_grid_variables&quot;</span><span class="p">][</span><span class="n">newname</span><span class="p">][</span><span class="s2">&quot;name&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">newname</span>
+        <span class="k">except</span><span class="p">:</span>
+            <span class="n">msg</span> <span class="o">=</span> <span class="s2">&quot;Failed to rename grid variable </span><span class="si">{}</span><span class="s2"> to </span><span class="si">{}</span><span class="s2">.&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">oldname</span><span class="p">,</span><span class="n">newname</span><span class="p">)</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="n">msg</span><span class="p">)</span></div>
+
 <div class="viewcode-block" id="Population.add_grid_variable"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.add_grid_variable">[docs]</a>    <span class="k">def</span> <span class="nf">add_grid_variable</span><span class="p">(</span>
         <span class="bp">self</span><span class="p">,</span>
         <span class="n">name</span><span class="p">:</span> <span class="nb">str</span><span class="p">,</span>
@@ -610,8 +670,6 @@
 <span class="sd">                (steps starting at lower edge + 0.5 * stepsize).</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
-        <span class="c1"># TODO: Add check for the grid type input value</span>
-
         <span class="c1"># Add grid_variable</span>
         <span class="n">grid_variable</span> <span class="o">=</span> <span class="p">{</span>
             <span class="s2">&quot;name&quot;</span><span class="p">:</span> <span class="n">name</span><span class="p">,</span>
@@ -655,7 +713,6 @@
 <span class="sd">        Returns:</span>
 <span class="sd">            dictionary containing &quot;bse_options&quot;, &quot;grid_options&quot;, &quot;custom_options&quot;</span>
 <span class="sd">        &quot;&quot;&quot;</span>
-
         <span class="n">options</span> <span class="o">=</span> <span class="p">{</span>
             <span class="s2">&quot;bse_options&quot;</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">bse_options</span><span class="p">,</span>
             <span class="s2">&quot;grid_options&quot;</span><span class="p">:</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">,</span>
@@ -709,7 +766,6 @@
 
         <span class="c1">#</span>
         <span class="n">all_info</span> <span class="o">=</span> <span class="p">{}</span>
-
         <span class="c1">#</span>
         <span class="k">if</span> <span class="n">include_population_settings</span><span class="p">:</span>
             <span class="n">population_settings</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">return_population_settings</span><span class="p">()</span>
@@ -778,37 +834,42 @@
         <span class="n">all_info_cleaned</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">all_info</span><span class="p">)</span>
 
         <span class="k">if</span> <span class="n">use_datadir</span><span class="p">:</span>
-            <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;base_filename&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">):</span>
-                <span class="n">base_name</span> <span class="o">=</span> <span class="s2">&quot;simulation_</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
-                    <span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="o">.</span><span class="n">now</span><span class="p">(),</span> <span class="s2">&quot;%Y%m</span><span class="si">%d</span><span class="s2">_%H%M%S&quot;</span><span class="p">)</span>
-                <span class="p">)</span>
-            <span class="k">else</span><span class="p">:</span>
-                <span class="n">base_name</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">splitext</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;base_filename&quot;</span><span class="p">])[</span><span class="mi">0</span><span class="p">]</span>
+            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;data_dir&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">):</span>
+                <span class="k">if</span> <span class="ow">not</span> <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;base_filename&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">):</span>
+                    <span class="n">base_name</span> <span class="o">=</span> <span class="s2">&quot;simulation_</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
+                        <span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="o">.</span><span class="n">strftime</span><span class="p">(</span><span class="n">datetime</span><span class="o">.</span><span class="n">datetime</span><span class="o">.</span><span class="n">now</span><span class="p">(),</span> <span class="s2">&quot;%Y%m</span><span class="si">%d</span><span class="s2">_%H%M%S&quot;</span><span class="p">)</span>
+                    <span class="p">)</span>
+                <span class="k">else</span><span class="p">:</span>
+                    <span class="n">base_name</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">splitext</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;base_filename&quot;</span><span class="p">])[</span><span class="mi">0</span><span class="p">]</span>
 
-            <span class="n">settings_name</span> <span class="o">=</span> <span class="n">base_name</span> <span class="o">+</span> <span class="s2">&quot;_settings.json&quot;</span>
+                <span class="n">settings_name</span> <span class="o">=</span> <span class="n">base_name</span> <span class="o">+</span> <span class="s2">&quot;_settings.json&quot;</span>
 
-            <span class="c1"># Check directory, make if necessary</span>
-            <span class="n">os</span><span class="o">.</span><span class="n">makedirs</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;data_dir&quot;</span><span class="p">],</span> <span class="n">exist_ok</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
+                <span class="c1"># Check directory, make if necessary</span>
+                <span class="n">os</span><span class="o">.</span><span class="n">makedirs</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;data_dir&quot;</span><span class="p">],</span> <span class="n">exist_ok</span><span class="o">=</span><span class="kc">True</span><span class="p">)</span>
 
-            <span class="n">settings_fullname</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;data_dir&quot;</span><span class="p">],</span> <span class="n">settings_name</span>
-            <span class="p">)</span>
+                <span class="n">settings_fullname</span> <span class="o">=</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">custom_options</span><span class="p">[</span><span class="s2">&quot;data_dir&quot;</span><span class="p">],</span> <span class="n">settings_name</span>
+                <span class="p">)</span>
 
-            <span class="n">verbose_print</span><span class="p">(</span>
-                <span class="s2">&quot;Writing settings to </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">settings_fullname</span><span class="p">),</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
-                <span class="mi">1</span><span class="p">,</span>
-            <span class="p">)</span>
-            <span class="c1"># if not outfile.endswith(&#39;json&#39;):</span>
-            <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">settings_fullname</span><span class="p">,</span> <span class="s2">&quot;w&quot;</span><span class="p">)</span> <span class="k">as</span> <span class="n">file</span><span class="p">:</span>
-                <span class="n">file</span><span class="o">.</span><span class="n">write</span><span class="p">(</span>
-                    <span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span>
-                        <span class="n">all_info_cleaned</span><span class="p">,</span>
-                        <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
-                        <span class="n">default</span><span class="o">=</span><span class="n">binaryc_json_serializer</span><span class="p">,</span>
-                    <span class="p">)</span>
+                <span class="n">verbose_print</span><span class="p">(</span>
+                    <span class="s2">&quot;Writing settings to </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">settings_fullname</span><span class="p">),</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
+                    <span class="mi">1</span><span class="p">,</span>
                 <span class="p">)</span>
-            <span class="k">return</span> <span class="n">settings_fullname</span>
+                <span class="c1"># if not outfile.endswith(&#39;json&#39;):</span>
+                <span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">settings_fullname</span><span class="p">,</span> <span class="s2">&quot;w&quot;</span><span class="p">)</span> <span class="k">as</span> <span class="n">file</span><span class="p">:</span>
+                    <span class="n">file</span><span class="o">.</span><span class="n">write</span><span class="p">(</span>
+                        <span class="n">json</span><span class="o">.</span><span class="n">dumps</span><span class="p">(</span>
+                            <span class="n">all_info_cleaned</span><span class="p">,</span>
+                            <span class="n">indent</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
+                            <span class="n">default</span><span class="o">=</span><span class="n">binaryc_json_serializer</span><span class="p">,</span>
+                        <span class="p">)</span>
+                    <span class="p">)</span>
+                <span class="k">return</span> <span class="n">settings_fullname</span>
+            <span class="k">else</span><span class="p">:</span>
+                <span class="n">msg</span> <span class="o">=</span> <span class="s2">&quot;Exporting all info without passing a value for `outfile` requires custom_options[&#39;data_dir&#39;] to be present. That is not the cause. Either set the `data_dir` or pass a value for `outfile` &quot;</span>
+                <span class="k">raise</span> <span class="ne">ValueError</span>
+
         <span class="k">else</span><span class="p">:</span>
             <span class="n">verbose_print</span><span class="p">(</span>
                 <span class="s2">&quot;Writing settings to </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">outfile</span><span class="p">),</span>
@@ -835,51 +896,61 @@
         <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Function/routine to set all the custom logging so that the function memory pointer</span>
 <span class="sd">        is known to the grid.</span>
+
+<span class="sd">        When the memory adress is loaded and the library file is set we&#39;ll skip rebuilding the library</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
-        <span class="c1"># C_logging_code gets priority of C_autogen_code</span>
-        <span class="n">verbose_print</span><span class="p">(</span>
-            <span class="s2">&quot;Creating and loading custom logging functionality&quot;</span><span class="p">,</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
-            <span class="mi">1</span><span class="p">,</span>
-        <span class="p">)</span>
-        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_logging_code&quot;</span><span class="p">]:</span>
-            <span class="c1"># Generate entire shared lib code around logging lines</span>
-            <span class="n">custom_logging_code</span> <span class="o">=</span> <span class="n">binary_c_log_code</span><span class="p">(</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_logging_code&quot;</span><span class="p">],</span>
-                <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
+        <span class="c1"># Only if the values are the &#39;default&#39; unset values</span>
+        <span class="k">if</span> <span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">]</span> <span class="o">==</span> <span class="o">-</span><span class="mi">1</span> <span class="ow">and</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">]</span> <span class="ow">is</span> <span class="kc">None</span><span class="p">):</span>
+            <span class="n">verbose_print</span><span class="p">(</span>
+                <span class="s2">&quot;Creating and loading custom logging functionality&quot;</span><span class="p">,</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
+                <span class="mi">1</span><span class="p">,</span>
             <span class="p">)</span>
+            <span class="c1"># C_logging_code gets priority of C_autogen_code</span>
+            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_logging_code&quot;</span><span class="p">]:</span>
+                <span class="c1"># Generate entire shared lib code around logging lines</span>
+                <span class="n">custom_logging_code</span> <span class="o">=</span> <span class="n">binary_c_log_code</span><span class="p">(</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_logging_code&quot;</span><span class="p">],</span>
+                    <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
+                <span class="p">)</span>
 
-            <span class="c1"># Load memory address</span>
-            <span class="p">(</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">],</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">],</span>
-            <span class="p">)</span> <span class="o">=</span> <span class="n">create_and_load_logging_function</span><span class="p">(</span>
-                <span class="n">custom_logging_code</span><span class="p">,</span>
-                <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
-                <span class="n">custom_tmp_dir</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;tmp_dir&quot;</span><span class="p">],</span>
-            <span class="p">)</span>
+                <span class="c1"># Load memory address</span>
+                <span class="p">(</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">],</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">],</span>
+                <span class="p">)</span> <span class="o">=</span> <span class="n">create_and_load_logging_function</span><span class="p">(</span>
+                    <span class="n">custom_logging_code</span><span class="p">,</span>
+                    <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
+                    <span class="n">custom_tmp_dir</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;tmp_dir&quot;</span><span class="p">],</span>
+                <span class="p">)</span>
 
-        <span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_auto_logging&quot;</span><span class="p">]:</span>
-            <span class="c1"># Generate real logging code</span>
-            <span class="n">logging_line</span> <span class="o">=</span> <span class="n">autogen_C_logging_code</span><span class="p">(</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_auto_logging&quot;</span><span class="p">],</span>
-                <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
-            <span class="p">)</span>
+            <span class="k">elif</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_auto_logging&quot;</span><span class="p">]:</span>
+                <span class="c1"># Generate real logging code</span>
+                <span class="n">logging_line</span> <span class="o">=</span> <span class="n">autogen_C_logging_code</span><span class="p">(</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;C_auto_logging&quot;</span><span class="p">],</span>
+                    <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
+                <span class="p">)</span>
 
-            <span class="c1"># Generate entire shared lib code around logging lines</span>
-            <span class="n">custom_logging_code</span> <span class="o">=</span> <span class="n">binary_c_log_code</span><span class="p">(</span>
-                <span class="n">logging_line</span><span class="p">,</span> <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
-            <span class="p">)</span>
+                <span class="c1"># Generate entire shared lib code around logging lines</span>
+                <span class="n">custom_logging_code</span> <span class="o">=</span> <span class="n">binary_c_log_code</span><span class="p">(</span>
+                    <span class="n">logging_line</span><span class="p">,</span> <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">)</span>
+                <span class="p">)</span>
 
-            <span class="c1"># Load memory address</span>
-            <span class="p">(</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">],</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">],</span>
-            <span class="p">)</span> <span class="o">=</span> <span class="n">create_and_load_logging_function</span><span class="p">(</span>
-                <span class="n">custom_logging_code</span><span class="p">,</span>
-                <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
-                <span class="n">custom_tmp_dir</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;tmp_dir&quot;</span><span class="p">],</span>
+                <span class="c1"># Load memory address</span>
+                <span class="p">(</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">],</span>
+                    <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">],</span>
+                <span class="p">)</span> <span class="o">=</span> <span class="n">create_and_load_logging_function</span><span class="p">(</span>
+                    <span class="n">custom_logging_code</span><span class="p">,</span>
+                    <span class="n">verbosity</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">]</span><span class="o">-</span><span class="p">(</span><span class="n">_CUSTOM_LOGGING_VERBOSITY_LEVEL</span><span class="o">-</span><span class="mi">1</span><span class="p">),</span>
+                    <span class="n">custom_tmp_dir</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;tmp_dir&quot;</span><span class="p">],</span>
+                <span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">verbose_print</span><span class="p">(</span>
+                <span class="s2">&quot;Custom logging library already loaded. Not setting them again.&quot;</span><span class="p">,</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
+                <span class="mi">1</span><span class="p">,</span>
             <span class="p">)</span>
 
     <span class="c1">###################################################</span>
@@ -893,19 +964,48 @@
     <span class="c1"># Evolution functions</span>
     <span class="c1">###################################################</span>
 
-    <span class="k">def</span> <span class="nf">_pre_run_cleanup</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+    <span class="k">def</span> <span class="nf">_pre_run_cleanup</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Function to clean up some stuff in the grid before a run (like results, ensemble results etc)</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
         <span class="c1"># empty results</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;results&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="p">{}</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span> <span class="o">=</span> <span class="n">AutoVivificationDict</span><span class="p">()</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">grid_ensemble_results</span> <span class="o">=</span> <span class="p">{}</span>
+
+        <span class="c1"># Reset the process ID (should not have a value initially, but can&#39;t hurt if it does)</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">process_ID</span> <span class="o">=</span> <span class="mi">0</span>
+
+        <span class="c1"># Reset population ID:</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_population_id&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">uuid</span><span class="o">.</span><span class="n">uuid4</span><span class="p">()</span><span class="o">.</span><span class="n">hex</span>
+
+        <span class="c1"># set previous logging time</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_time&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">multiprocessing</span><span class="o">.</span><span class="n">Value</span><span class="p">(</span><span class="s1">&#39;d&#39;</span><span class="p">,</span><span class="n">time</span><span class="o">.</span><span class="n">time</span><span class="p">())</span>
+        <span class="c1"># set previous logging system number to 0</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_system_number&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">multiprocessing</span><span class="o">.</span><span class="n">Value</span><span class="p">(</span><span class="s1">&#39;i&#39;</span><span class="p">,</span><span class="mi">0</span><span class="p">)</span>
+        <span class="c1"># array to store memory use per-thread</span>
+        <span class="n">mem</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_mem_use</span><span class="p">()</span>
+        <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;memory_use_per_thread&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">multiprocessing</span><span class="o">.</span><span class="n">Array</span><span class="p">(</span><span class="s1">&#39;d&#39;</span><span class="p">,[</span><span class="mf">1.0</span><span class="o">*</span><span class="n">mem</span><span class="p">]</span><span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;amt_cores&quot;</span><span class="p">])</span>
+
+<div class="viewcode-block" id="Population.clean"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.clean">[docs]</a>    <span class="k">def</span> <span class="nf">clean</span><span class="p">(</span>
+        <span class="bp">self</span>
+    <span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Clean the contents of the population object so it can be reused.</span>
+
+<span class="sd">        Calling _pre_run_cleanup()</span>
+
+<span class="sd">        TODO: decide to deprecate this function</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+
+        <span class="bp">self</span><span class="o">.</span><span class="n">_pre_run_cleanup</span><span class="p">()</span></div>
 
 <div class="viewcode-block" id="Population.evolve"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.evolve">[docs]</a>    <span class="k">def</span> <span class="nf">evolve</span><span class="p">(</span><span class="bp">self</span><span class="p">)</span> <span class="o">-&gt;</span> <span class="kc">None</span><span class="p">:</span>
         <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Entry point function of the whole object. From here, based on the settings,</span>
 <span class="sd">        we set up a SLURM or CONDOR grid, or if no setting is given we go straight</span>
-<span class="sd">        to evolving the population</span>
+<span class="sd">        to evolving the population.</span>
 
 <span class="sd">        There are no direct arguments to this function, rather it is based on the grid_options settings:</span>
 <span class="sd">            grid_options[&#39;slurm&#39;]: integer Boolean whether to use a slurm_grid evolution</span>
@@ -915,7 +1015,9 @@
 <span class="sd">        (that doesn&#39;t mean this cannot be run on a server with many cores)</span>
 
 <span class="sd">        Returns an dictionary containing the analytics of the run</span>
+
 <span class="sd">        TODO: change the way this is done. Slurm &amp; CONDOR should probably do this different</span>
+<span class="sd">        NOTE: SLURM and CONDOR options are not working properly yet</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
         <span class="c1"># Just to make sure we don&#39;t have stuff from a previous run hanging around</span>
@@ -978,9 +1080,6 @@
 <span class="sd">            - TODO: include options for different ways of generating a population here. (i.e. MC or source file)</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
-        <span class="c1"># Reset some settings: population_id, results, ensemble_results etc</span>
-        <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_population_id&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">uuid</span><span class="o">.</span><span class="n">uuid4</span><span class="p">()</span><span class="o">.</span><span class="n">hex</span>
-
         <span class="c1">##</span>
         <span class="c1"># Prepare code/initialise grid.</span>
         <span class="c1"># set custom logging, set up store_memaddr, build grid code. dry run grid code.</span>
@@ -1005,7 +1104,7 @@
                 <span class="p">)</span>
             <span class="p">)</span>
 
-        <span class="c1">#</span>
+        <span class="c1"># finished!</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_end_time_evolution&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="n">time</span><span class="o">.</span><span class="n">time</span><span class="p">()</span>
 
         <span class="c1"># Log and print some information</span>
@@ -1119,7 +1218,7 @@
         <span class="c1"># Send closing signal to workers. When they receive this they will terminate</span>
         <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;verbosity&#39;</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">_LOGGER_VERBOSITY_LEVEL</span><span class="p">:</span>
             <span class="n">stream_logger</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;Signaling stop to processes&quot;</span><span class="p">)</span>  <span class="c1"># DEBUG</span>
-    
+
         <span class="k">for</span> <span class="n">_</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="n">amt_cores</span><span class="p">):</span>
             <span class="n">job_queue</span><span class="o">.</span><span class="n">put</span><span class="p">(</span><span class="s2">&quot;STOP&quot;</span><span class="p">)</span>
 
@@ -1355,6 +1454,9 @@
         <span class="n">zero_prob_stars_skipped</span> <span class="o">=</span> <span class="mi">0</span>
 
         <span class="n">total_time_calling_binary_c</span> <span class="o">=</span> <span class="mi">0</span>
+        <span class="n">start_grid_time</span> <span class="o">=</span> <span class="n">time</span><span class="o">.</span><span class="n">time</span><span class="p">()</span>
+        <span class="n">next_log_time</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_time&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;log_dt&quot;</span><span class="p">]</span>
+        <span class="n">next_mem_update_time</span> <span class="o">=</span> <span class="n">start_grid_time</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;log_dt&quot;</span><span class="p">]</span>
 
         <span class="n">total_mass_run</span> <span class="o">=</span> <span class="mi">0</span>
         <span class="n">total_probability_weighted_mass_run</span> <span class="o">=</span> <span class="mi">0</span>
@@ -1419,11 +1521,31 @@
             <span class="c1"># )</span>
 
             <span class="c1">#</span>
-            <span class="n">verbose_print</span><span class="p">(</span>
-                <span class="s2">&quot;Process </span><span class="si">{}</span><span class="s2"> is handling system </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">ID</span><span class="p">,</span> <span class="n">system_number</span><span class="p">),</span>
-                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
-                <span class="mi">1</span><span class="p">,</span>
-            <span class="p">)</span>
+
+<span class="c1">#            verbose_print(</span>
+<span class="c1">#                &quot;Process {} is handling system {}&quot;.format(ID, system_number),</span>
+<span class="c1">#                self.grid_options[&quot;verbosity&quot;],</span>
+<span class="c1">#                1,</span>
+<span class="c1">#            )</span>
+
+            <span class="c1"># save the current time (used often)</span>
+            <span class="n">now</span> <span class="o">=</span> <span class="n">time</span><span class="o">.</span><span class="n">time</span><span class="p">()</span>
+
+            <span class="c1"># update memory use stats every log_dt seconds (not every time, this is likely a bit expensive)</span>
+            <span class="k">if</span> <span class="n">now</span> <span class="o">&gt;</span> <span class="n">next_mem_update_time</span><span class="p">:</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;memory_use_per_thread&quot;</span><span class="p">][</span><span class="n">ID</span><span class="p">]</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_mem_use</span><span class="p">()</span>
+                <span class="n">next_mem_update</span> <span class="o">=</span> <span class="n">now</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;log_dt&quot;</span><span class="p">]</span>
+
+            <span class="c1"># calculate the next logging time</span>
+            <span class="n">next_log_time</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_time&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;log_dt&quot;</span><span class="p">]</span>
+
+            <span class="k">if</span> <span class="n">now</span> <span class="o">&gt;</span> <span class="n">next_log_time</span><span class="p">:</span>
+                <span class="c1"># we have exceeded the next log time : output and update timers</span>
+                <span class="n">lock</span> <span class="o">=</span> <span class="n">multiprocessing</span><span class="o">.</span><span class="n">Lock</span><span class="p">()</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">vb1print</span><span class="p">(</span><span class="n">ID</span><span class="p">,</span><span class="n">now</span><span class="p">,</span><span class="n">system_number</span><span class="p">)</span>
+                <span class="n">next_log_time</span> <span class="o">=</span> <span class="n">now</span> <span class="o">+</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;log_dt&quot;</span><span class="p">]</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_time&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">now</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_system_number&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span> <span class="o">=</span> <span class="n">system_number</span>
 
             <span class="c1"># In some cases, the whole run crashes. To be able to figure out which system</span>
             <span class="c1"># that was on, we log each current system to a file (each thread has one).</span>
@@ -1511,7 +1633,6 @@
         <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;verbosity&#39;</span><span class="p">]</span> <span class="o">&gt;=</span> <span class="n">_LOGGER_VERBOSITY_LEVEL</span><span class="p">:</span>
             <span class="n">stream_logger</span><span class="o">.</span><span class="n">debug</span><span class="p">(</span><span class="sa">f</span><span class="s2">&quot;Process-</span><span class="si">{</span><span class="bp">self</span><span class="o">.</span><span class="n">process_ID</span><span class="si">}</span><span class="s2"> is finishing.&quot;</span><span class="p">)</span>
 
-
         <span class="c1"># Handle ensemble output: is ensemble==1, then either directly write that data to a file, or combine everything into 1 file.</span>
         <span class="n">ensemble_json</span> <span class="o">=</span> <span class="p">{}</span>  <span class="c1"># Make sure it exists already</span>
         <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">bse_options</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;ensemble&quot;</span><span class="p">,</span> <span class="mi">0</span><span class="p">)</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
@@ -1675,31 +1796,42 @@
         <span class="c1">### Custom logging code:</span>
         <span class="bp">self</span><span class="o">.</span><span class="n">_set_custom_logging</span><span class="p">()</span>
 
-        <span class="c1"># Get argument line</span>
-        <span class="n">argline</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_return_argline</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">bse_options</span><span class="p">)</span>
-        <span class="n">verbose_print</span><span class="p">(</span><span class="s2">&quot;Running </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">argline</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span> <span class="mi">1</span><span class="p">)</span>
 
-        <span class="c1"># Run system</span>
-        <span class="n">out</span> <span class="o">=</span> <span class="n">_binary_c_bindings</span><span class="o">.</span><span class="n">run_system</span><span class="p">(</span>
-            <span class="n">argstring</span><span class="o">=</span><span class="n">argline</span><span class="p">,</span>
-            <span class="n">custom_logging_func_memaddr</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span>
-                <span class="s2">&quot;custom_logging_func_memaddr&quot;</span>
-            <span class="p">],</span>
-            <span class="n">store_memaddr</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_store_memaddr&quot;</span><span class="p">],</span>
-            <span class="n">population</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span>
-        <span class="p">)</span>
+        <span class="c1"># Check if there are actually arguments passed:</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">bse_options</span><span class="p">:</span>
+
+            <span class="c1"># Get argument line and</span>
+            <span class="n">argline</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_return_argline</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">bse_options</span><span class="p">)</span>
+
+            <span class="n">verbose_print</span><span class="p">(</span><span class="s2">&quot;Running </span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">argline</span><span class="p">),</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span> <span class="mi">1</span><span class="p">)</span>
+
+            <span class="c1"># Run system</span>
+            <span class="n">out</span> <span class="o">=</span> <span class="n">_binary_c_bindings</span><span class="o">.</span><span class="n">run_system</span><span class="p">(</span>
+                <span class="n">argstring</span><span class="o">=</span><span class="n">argline</span><span class="p">,</span>
+                <span class="n">custom_logging_func_memaddr</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span>
+                    <span class="s2">&quot;custom_logging_func_memaddr&quot;</span>
+                <span class="p">],</span>
+                <span class="n">store_memaddr</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_store_memaddr&quot;</span><span class="p">],</span>
+                <span class="n">population</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span>
+            <span class="p">)</span>
+
+            <span class="c1"># Clean up custom logging</span>
+            <span class="k">if</span> <span class="n">clean_up_custom_logging_files</span><span class="p">:</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">_clean_up_custom_logging</span><span class="p">(</span><span class="n">evol_type</span><span class="o">=</span><span class="s2">&quot;single&quot;</span><span class="p">)</span>
+
+            <span class="c1"># Parse output and return the result</span>
+            <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;parse_function&quot;</span><span class="p">]:</span>
+                <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;parse_function&quot;</span><span class="p">](</span><span class="bp">self</span><span class="p">,</span> <span class="n">out</span><span class="p">)</span>
+
+            <span class="c1"># Otherwise just return the raw output</span>
+            <span class="k">return</span> <span class="n">out</span>
+
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">msg</span> <span class="o">=</span> <span class="s2">&quot;No actual evolution options passed to the evolve call. Aborting&quot;</span>
+            <span class="k">raise</span> <span class="ne">ValueError</span><span class="p">(</span><span class="n">msg</span><span class="p">)</span></div>
 
-        <span class="c1"># TODO: add call to function that cleans up the temp custom logging dir,</span>
-        <span class="c1">#   and unloads the loaded libraries.</span>
-        <span class="c1"># TODO: make a switch to turn this off</span>
 
-        <span class="k">if</span> <span class="n">clean_up_custom_logging_files</span><span class="p">:</span>
-            <span class="bp">self</span><span class="o">.</span><span class="n">_clean_up_custom_logging</span><span class="p">(</span><span class="n">evol_type</span><span class="o">=</span><span class="s2">&quot;single&quot;</span><span class="p">)</span>
 
-        <span class="c1"># Parse</span>
-        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;parse_function&quot;</span><span class="p">]:</span>
-            <span class="k">return</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;parse_function&quot;</span><span class="p">](</span><span class="bp">self</span><span class="p">,</span> <span class="n">out</span><span class="p">)</span>
-        <span class="k">return</span> <span class="n">out</span></div>
 
     <span class="k">def</span> <span class="nf">_setup</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
         <span class="sd">&quot;&quot;&quot;</span>
@@ -2419,7 +2551,7 @@
             <span class="o">+</span> <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">&quot;</span>
         <span class="p">)</span>
 
-        <span class="c1"># Take into account the multiplicity fraction: </span>
+        <span class="c1"># Take into account the multiplicity fraction:</span>
         <span class="n">code_string</span> <span class="o">+=</span> <span class="p">(</span>
             <span class="n">indent</span> <span class="o">*</span> <span class="p">(</span><span class="n">depth</span> <span class="o">+</span> <span class="mi">1</span><span class="p">)</span>
             <span class="o">+</span> <span class="s2">&quot;</span><span class="se">\n</span><span class="s2">&quot;</span>
@@ -3283,10 +3415,10 @@
                 <span class="mi">1</span><span class="p">,</span>
             <span class="p">)</span>
 
-            <span class="c1"># TODO: Unset custom logging code</span>
+            <span class="c1"># TODO: Explicitly unload the library</span>
 
-            <span class="c1"># TODO: Unset function memory address</span>
-            <span class="c1"># print(self.grid_options[&quot;custom_logging_func_memaddr&quot;])</span>
+            <span class="c1"># Reset the memory adress location</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;custom_logging_func_memaddr&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="o">-</span><span class="mi">1</span>
 
             <span class="c1"># remove shared library files</span>
             <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">]:</span>
@@ -3294,6 +3426,7 @@
                     <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">],</span>
                     <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
                 <span class="p">)</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_custom_logging_shared_library_file&quot;</span><span class="p">]</span> <span class="o">=</span> <span class="kc">None</span>
 
         <span class="k">if</span> <span class="n">evol_type</span> <span class="o">==</span> <span class="s2">&quot;population&quot;</span><span class="p">:</span>
             <span class="n">verbose_print</span><span class="p">(</span>
@@ -3441,7 +3574,7 @@
 <div class="viewcode-block" id="Population.set_moe_di_stefano_settings"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.set_moe_di_stefano_settings">[docs]</a>    <span class="k">def</span> <span class="nf">set_moe_di_stefano_settings</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">options</span><span class="o">=</span><span class="kc">None</span><span class="p">):</span>
         <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">        Function to set user input configurations for the moe &amp; di Stefano methods</span>
-<span class="sd">    </span>
+
 <span class="sd">        If nothing is passed then we just use the default options</span>
 <span class="sd">        &quot;&quot;&quot;</span>
 
@@ -3784,7 +3917,7 @@
                 <span class="n">resolution</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">][</span><span class="s2">&quot;resolutions&quot;</span><span class="p">][</span><span class="s2">&quot;logP&quot;</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span>
                 <span class="n">probdist</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
                 <span class="n">condition</span><span class="o">=</span><span class="s1">&#39;(self.grid_options[&quot;multiplicity&quot;] &gt;= 2)&#39;</span><span class="p">,</span>
-                <span class="n">branchpoint</span><span class="o">=</span><span class="mi">1</span> <span class="k">if</span> <span class="n">max_multiplicity</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="k">else</span> <span class="mi">0</span><span class="p">,</span> <span class="c1"># Signal here to put a branchpoint if we have a max multiplicity higher than 1. </span>
+                <span class="n">branchpoint</span><span class="o">=</span><span class="mi">1</span> <span class="k">if</span> <span class="n">max_multiplicity</span> <span class="o">&gt;</span> <span class="mi">1</span> <span class="k">else</span> <span class="mi">0</span><span class="p">,</span> <span class="c1"># Signal here to put a branchpoint if we have a max multiplicity higher than 1.</span>
                 <span class="n">gridtype</span><span class="o">=</span><span class="s2">&quot;centred&quot;</span><span class="p">,</span>
                 <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;(</span><span class="si">{}</span><span class="s2"> * dlog10per)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">LOG_LN_CONVERTER</span><span class="p">),</span>
                 <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">][</span><span class="s2">&quot;ranges&quot;</span><span class="p">][</span><span class="s2">&quot;logP&quot;</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">][</span><span class="s2">&quot;ranges&quot;</span><span class="p">][</span><span class="s2">&quot;logP&quot;</span><span class="p">][</span><span class="mi">1</span><span class="p">]],</span>
@@ -3799,7 +3932,7 @@
 <span class="s2">&quot;&quot;&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
                     <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">]</span><span class="o">.</span><span class="n">get</span><span class="p">(</span><span class="s2">&quot;Mmin&quot;</span><span class="p">,</span> <span class="mf">0.07</span><span class="p">)</span>
                 <span class="p">),</span>
-            <span class="p">)</span> <span class="c1"># TODO: change the maximum_mass_ratio_for_RLOF </span>
+            <span class="p">)</span> <span class="c1"># TODO: change the maximum_mass_ratio_for_RLOF</span>
 
             <span class="c1"># binaries: mass ratio</span>
             <span class="bp">self</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
@@ -3865,7 +3998,7 @@
                     <span class="n">resolution</span><span class="o">=</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;m&amp;s_options&#39;</span><span class="p">][</span><span class="s2">&quot;resolutions&quot;</span><span class="p">][</span><span class="s2">&quot;logP&quot;</span><span class="p">][</span><span class="mi">1</span><span class="p">],</span>
                     <span class="n">probdist</span><span class="o">=</span><span class="mf">1.0</span><span class="p">,</span>
                     <span class="n">condition</span><span class="o">=</span><span class="s1">&#39;(self.grid_options[&quot;multiplicity&quot;] &gt;= 3)&#39;</span><span class="p">,</span>
-                    <span class="n">branchpoint</span><span class="o">=</span><span class="mi">2</span> <span class="k">if</span> <span class="n">max_multiplicity</span> <span class="o">&gt;</span> <span class="mi">2</span> <span class="k">else</span> <span class="mi">0</span><span class="p">,</span> <span class="c1"># Signal here to put a branchpoint if we have a max multiplicity higher than 1. </span>
+                    <span class="n">branchpoint</span><span class="o">=</span><span class="mi">2</span> <span class="k">if</span> <span class="n">max_multiplicity</span> <span class="o">&gt;</span> <span class="mi">2</span> <span class="k">else</span> <span class="mi">0</span><span class="p">,</span> <span class="c1"># Signal here to put a branchpoint if we have a max multiplicity higher than 1.</span>
                     <span class="n">gridtype</span><span class="o">=</span><span class="s2">&quot;centred&quot;</span><span class="p">,</span>
                     <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;(</span><span class="si">{}</span><span class="s2"> * dlog10per2)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">LOG_LN_CONVERTER</span><span class="p">),</span>
                     <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span>
@@ -4198,7 +4331,91 @@
             <span class="mi">2</span><span class="p">,</span>
         <span class="p">)</span>
 
-        <span class="k">return</span> <span class="n">multiplicity_fraction_dict</span><span class="p">[</span><span class="n">system_dict</span><span class="p">[</span><span class="s1">&#39;multiplicity&#39;</span><span class="p">]]</span></div>
+        <span class="k">return</span> <span class="n">multiplicity_fraction_dict</span><span class="p">[</span><span class="n">system_dict</span><span class="p">[</span><span class="s1">&#39;multiplicity&#39;</span><span class="p">]]</span>
+
+    <span class="k">def</span> <span class="nf">_trem</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">dt</span><span class="p">,</span><span class="n">count</span><span class="p">,</span><span class="n">dn</span><span class="p">,</span><span class="n">n</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Estimate time remaining (seconds) given a differential time and count (i.e. progress = $count/$n). $dt is the time since the last call, $count is the current progress count, $dn is the number run since the last call, and $n is the total number required.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">tpr</span> <span class="o">=</span> <span class="n">dt</span> <span class="o">/</span> <span class="nb">max</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span><span class="n">dn</span><span class="p">)</span>
+        <span class="n">etasecs</span> <span class="o">=</span> <span class="n">tpr</span> <span class="o">*</span> <span class="p">(</span><span class="n">n</span> <span class="o">-</span> <span class="n">count</span><span class="p">)</span>
+        <span class="p">(</span><span class="n">eta</span><span class="p">,</span><span class="n">units</span><span class="p">)</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_conv_time_units</span><span class="p">(</span><span class="n">etasecs</span><span class="p">)</span>
+        <span class="k">return</span> <span class="p">(</span><span class="n">eta</span><span class="p">,</span><span class="n">units</span><span class="p">,</span><span class="n">tpr</span><span class="p">,</span><span class="n">etasecs</span><span class="p">)</span>
+
+    <span class="k">def</span> <span class="nf">_conv_time_units</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">t</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Converts time (t, in seconds, passing in as the only argument) to seconds, minutes or hours depending on its magnitude. Returns a tuple (t,units).</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="n">units</span><span class="o">=</span><span class="s1">&#39;s&#39;</span><span class="p">;</span> <span class="c1"># default to seconds</span>
+        <span class="k">if</span> <span class="n">t</span> <span class="o">&gt;</span> <span class="mi">60</span><span class="p">:</span>
+            <span class="n">t</span> <span class="o">/=</span> <span class="mi">60</span><span class="p">;</span>
+            <span class="n">units</span><span class="o">=</span><span class="s1">&#39;m&#39;</span><span class="p">;</span>
+        <span class="k">if</span> <span class="n">t</span> <span class="o">&gt;</span> <span class="mi">60</span><span class="p">:</span>
+            <span class="n">t</span> <span class="o">/=</span><span class="mi">60</span><span class="p">;</span>
+            <span class="n">units</span><span class="o">=</span><span class="s1">&#39;h&#39;</span><span class="p">;</span>
+        <span class="k">return</span> <span class="p">(</span><span class="n">t</span><span class="p">,</span><span class="n">units</span><span class="p">)</span>
+
+<div class="viewcode-block" id="Population.vb1print"><a class="viewcode-back" href="../../../grid.html#binarycpython.utils.grid.Population.vb1print">[docs]</a>    <span class="k">def</span> <span class="nf">vb1print</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span><span class="n">ID</span><span class="p">,</span><span class="n">now</span><span class="p">,</span><span class="n">system_number</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Verbosity-level 1 printing, to keep an eye on a grid.</span>
+<span class="sd">        Arguments:</span>
+<span class="sd">                 ID : thread ID for debugging (int)</span>
+<span class="sd">                 now : the time now as a UNIX-style epoch in seconds (float)</span>
+<span class="sd">                 system_number : the system number</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="c1"># calculate estimated time of arrive (eta and eta_secs), time per run (tpr)</span>
+        <span class="n">localtime</span> <span class="o">=</span> <span class="n">time</span><span class="o">.</span><span class="n">localtime</span><span class="p">(</span><span class="n">now</span><span class="p">)</span>
+        <span class="n">dt</span> <span class="o">=</span> <span class="n">now</span> <span class="o">-</span> <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_time&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span>
+        <span class="n">dn</span> <span class="o">=</span> <span class="n">system_number</span> <span class="o">-</span> <span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;prev_log_system_number&quot;</span><span class="p">]</span><span class="o">.</span><span class="n">value</span>
+        <span class="p">(</span><span class="n">eta</span><span class="p">,</span><span class="n">units</span><span class="p">,</span><span class="n">tpr</span><span class="p">,</span><span class="n">eta_secs</span><span class="p">)</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">_trem</span><span class="p">(</span><span class="n">dt</span><span class="p">,</span>
+                                              <span class="n">system_number</span><span class="p">,</span>
+                                              <span class="n">dn</span><span class="p">,</span>
+                                              <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_total_starcount&quot;</span><span class="p">])</span>
+        <span class="k">if</span> <span class="n">eta_secs</span> <span class="o">&lt;</span> <span class="n">secs_per_day</span><span class="p">:</span>
+            <span class="n">fintime</span> <span class="o">=</span> <span class="n">time</span><span class="o">.</span><span class="n">localtime</span><span class="p">(</span><span class="n">now</span> <span class="o">+</span> <span class="n">eta_secs</span><span class="p">)</span>
+            <span class="n">etf</span> <span class="o">=</span> <span class="s2">&quot;</span><span class="si">{hours:02d}</span><span class="s2">:</span><span class="si">{minutes:02d}</span><span class="s2">:</span><span class="si">{seconds:02d}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">hours</span> <span class="o">=</span> <span class="n">fintime</span><span class="o">.</span><span class="n">tm_hour</span><span class="p">,</span>
+                                                                   <span class="n">minutes</span> <span class="o">=</span> <span class="n">fintime</span><span class="o">.</span><span class="n">tm_min</span><span class="p">,</span>
+                                                                   <span class="n">seconds</span> <span class="o">=</span> <span class="n">fintime</span><span class="o">.</span><span class="n">tm_sec</span><span class="p">)</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">d</span> <span class="o">=</span> <span class="nb">int</span><span class="p">(</span><span class="n">eta_secs</span><span class="o">/</span><span class="n">secs_per_day</span><span class="p">)</span>
+            <span class="k">if</span> <span class="n">d</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
+                <span class="n">etf</span> <span class="o">=</span> <span class="s2">&quot;Tomorrow&quot;</span>
+            <span class="k">else</span><span class="p">:</span>
+                <span class="n">etf</span> <span class="o">=</span> <span class="s2">&quot;In &quot;</span> <span class="o">+</span> <span class="n">d</span> <span class="o">+</span> <span class="s2">&quot; days&quot;</span>
+
+        <span class="c1"># modulo information</span>
+        <span class="k">if</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;modulo&#39;</span><span class="p">]</span> <span class="o">==</span> <span class="mi">1</span><span class="p">:</span>
+            <span class="n">modulo</span> <span class="o">=</span> <span class="s1">&#39;&#39;</span> <span class="c1"># usual case</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="n">modulo</span> <span class="o">=</span> <span class="s1">&#39;%&#39;</span> <span class="o">+</span> <span class="nb">str</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;modulo&#39;</span><span class="p">])</span>
+
+        <span class="c1"># add up memory use from each thread</span>
+        <span class="n">mem_use</span> <span class="o">=</span> <span class="nb">sum</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">shared_memory</span><span class="p">[</span><span class="s2">&quot;memory_use_per_thread&quot;</span><span class="p">])</span>
+
+        <span class="n">verbose_print</span><span class="p">(</span>
+            <span class="s2">&quot;</span><span class="si">{system_number}</span><span class="s2">/</span><span class="si">{total_starcount}{modulo}</span><span class="s2"> </span><span class="si">{complete:5.1f}% c</span><span class="s2">omplete </span><span class="si">{hours:02d}</span><span class="s2">:</span><span class="si">{minutes:02d}</span><span class="s2">:</span><span class="si">{seconds:02d}</span><span class="s2"> ETA=</span><span class="si">{eta:7.1f}{units}</span><span class="s2"> tpr=</span><span class="si">{tpr:2.2e}</span><span class="s2"> ETF=</span><span class="si">{etf}</span><span class="s2"> mem:</span><span class="si">{mem_use:.1f}</span><span class="s2">MB&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span>
+                <span class="n">system_number</span> <span class="o">=</span> <span class="n">system_number</span><span class="p">,</span>
+                <span class="n">total_starcount</span> <span class="o">=</span> <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_total_starcount&quot;</span><span class="p">],</span>
+                <span class="n">complete</span><span class="o">=</span><span class="p">(</span><span class="mf">100.0</span><span class="o">*</span><span class="n">system_number</span><span class="p">)</span><span class="o">/</span><span class="p">(</span><span class="mf">1.0</span><span class="o">*</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;_total_starcount&quot;</span><span class="p">]),</span>
+                <span class="n">modulo</span> <span class="o">=</span> <span class="n">modulo</span><span class="p">,</span>
+                <span class="n">hours</span> <span class="o">=</span> <span class="n">localtime</span><span class="o">.</span><span class="n">tm_hour</span><span class="p">,</span>
+                <span class="n">minutes</span> <span class="o">=</span> <span class="n">localtime</span><span class="o">.</span><span class="n">tm_min</span><span class="p">,</span>
+                <span class="n">seconds</span> <span class="o">=</span> <span class="n">localtime</span><span class="o">.</span><span class="n">tm_sec</span><span class="p">,</span>
+                <span class="n">eta</span> <span class="o">=</span> <span class="n">eta</span><span class="p">,</span>
+                <span class="n">units</span> <span class="o">=</span> <span class="n">units</span><span class="p">,</span>
+                <span class="n">tpr</span> <span class="o">=</span> <span class="n">tpr</span><span class="p">,</span>
+                <span class="n">etf</span> <span class="o">=</span> <span class="n">etf</span><span class="p">,</span>
+                <span class="n">mem_use</span> <span class="o">=</span> <span class="n">mem_use</span>
+            <span class="p">),</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s2">&quot;verbosity&quot;</span><span class="p">],</span>
+            <span class="mi">1</span>
+        <span class="p">)</span></div>
+
+    <span class="k">def</span> <span class="nf">_mem_use</span><span class="p">(</span><span class="bp">self</span><span class="p">):</span>
+        <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">        Return current process memory use in MB. (Takes no arguments) Note: this is per-thread only.</span>
+<span class="sd">        &quot;&quot;&quot;</span>
+        <span class="k">return</span> <span class="n">resource</span><span class="o">.</span><span class="n">getrusage</span><span class="p">(</span><span class="n">resource</span><span class="o">.</span><span class="n">RUSAGE_SELF</span><span class="p">)</span><span class="o">.</span><span class="n">ru_maxrss</span> <span class="o">/</span> <span class="mf">1024.0</span></div>
 </pre></div>
 
            </div>
@@ -4225,9 +4442,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/grid_options_defaults.html b/docs/build/html/_modules/binarycpython/utils/grid_options_defaults.html
index e0fdf688e80d830f14294c861ce8584003245c68..d727ebca9d1cc066504565325691482cc0e30eef 100644
--- a/docs/build/html/_modules/binarycpython/utils/grid_options_defaults.html
+++ b/docs/build/html/_modules/binarycpython/utils/grid_options_defaults.html
@@ -157,16 +157,16 @@
             
   <h1>Source code for binarycpython.utils.grid_options_defaults</h1><div class="highlight"><pre>
 <span></span><span class="sd">&quot;&quot;&quot;</span>
-<span class="sd">Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries: </span>
+<span class="sd">Module that contains the default options for the population grid code along with the description for these options, in the form of dictionaries:</span>
 <span class="sd">    - grid_options_defaults_dict: dictionary containing the default values for all the options</span>
 <span class="sd">    - grid_options_descriptions: dictionary containing the description for these options.</span>
 
 <span class="sd">There are several other functions in this module, mostly to generate help texts or documents:</span>
-<span class="sd">    - grid_options_help: interactive function for the user to get descriptions for options </span>
+<span class="sd">    - grid_options_help: interactive function for the user to get descriptions for options</span>
 <span class="sd">    - grid_options_description_checker: function that checks that checks which options have a description.</span>
 <span class="sd">    - write_grid_options_to_rst_file: function to generate the .rst document for the docs</span>
 
-<span class="sd">With this its also possible to automatically generate a document containing all the setting names + descriptions. </span>
+<span class="sd">With this its also possible to automatically generate a document containing all the setting names + descriptions.</span>
 
 <span class="sd">All the options starting with _ should not be changed by the user except when you really know what you&#39;re doing (which is probably hacking the code :P)</span>
 <span class="sd">&quot;&quot;&quot;</span>
@@ -208,6 +208,7 @@
     <span class="s2">&quot;log_file&quot;</span><span class="p">:</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
         <span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;binary_c_python.log&quot;</span>
     <span class="p">),</span>  <span class="c1"># Set to None to not log to file. The directory will be created</span>
+    <span class="s2">&quot;log_dt&quot;</span> <span class="p">:</span> <span class="mi">5</span><span class="p">,</span> <span class="c1"># time between vb=1 logging outputs</span>
     <span class="c1">##########################</span>
     <span class="c1"># binary_c files</span>
     <span class="c1">##########################</span>
@@ -633,7 +634,7 @@
     <span class="s2">&quot;_main_pid&quot;</span><span class="p">:</span> <span class="s2">&quot;Main process ID of the master process. Used and set by the population object.&quot;</span><span class="p">,</span>
     <span class="s2">&quot;_store_memaddr&quot;</span><span class="p">:</span> <span class="s2">&quot;Memory address of the store object for binary_c.&quot;</span><span class="p">,</span>
     <span class="s2">&quot;failed_systems_threshold&quot;</span><span class="p">:</span> <span class="s2">&quot;Variable storing the maximum amount of systems that are allowed to fail before logging their command line arguments to failed_systems log files&quot;</span><span class="p">,</span>
-    <span class="s2">&quot;parse_function&quot;</span><span class="p">:</span> <span class="s2">&quot;Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the grid_options[&#39;results&#39;] dictionary, or just output results to a file&quot;</span><span class="p">,</span>
+    <span class="s2">&quot;parse_function&quot;</span><span class="p">:</span> <span class="s2">&quot;Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the self.grid_results dictionary, or just output results to a file&quot;</span><span class="p">,</span>
     <span class="s2">&quot;condor&quot;</span><span class="p">:</span> <span class="s2">&quot;Int flag whether to use a condor type population evolution. Not implemented yet.&quot;</span><span class="p">,</span>  <span class="c1"># TODO: describe this in more detail</span>
     <span class="s2">&quot;slurm&quot;</span><span class="p">:</span> <span class="s2">&quot;Int flag whether to use a Slurm type population evolution.&quot;</span><span class="p">,</span>  <span class="c1"># TODO: describe this in more detail</span>
     <span class="s2">&quot;weight&quot;</span><span class="p">:</span> <span class="s2">&quot;Weight factor for each system. The calculated probability is multiplied by this. If the user wants each system to be repeated several times, then this variable should not be changed, rather change the _repeat variable instead, as that handles the reduction in probability per system. This is useful for systems that have a process with some random element in it.&quot;</span><span class="p">,</span>  <span class="c1"># TODO: add more info here, regarding the evolution splitting.</span>
@@ -692,7 +693,7 @@
         <span class="s2">&quot;ecc&quot;</span><span class="p">:</span> <span class="p">[</span><span class="mf">0.0</span><span class="p">,</span> <span class="mf">0.99</span><span class="p">],</span>
     <span class="p">},</span>
     <span class="c1"># minimum stellar mass</span>
-    <span class="s2">&quot;Mmin&quot;</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">return_binary_c_version_info</span><span class="p">(</span><span class="n">parsed</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="s1">&#39;macros&#39;</span><span class="p">][</span><span class="s1">&#39;BINARY_C_MINIMUM_STELLAR_MASS&#39;</span><span class="p">]),</span> <span class="c1"># We take the value that binary_c has set as the default </span>
+    <span class="s2">&quot;Mmin&quot;</span><span class="p">:</span> <span class="nb">float</span><span class="p">(</span><span class="n">return_binary_c_version_info</span><span class="p">(</span><span class="n">parsed</span><span class="o">=</span><span class="kc">True</span><span class="p">)[</span><span class="s1">&#39;macros&#39;</span><span class="p">][</span><span class="s1">&#39;BINARY_C_MINIMUM_STELLAR_MASS&#39;</span><span class="p">]),</span> <span class="c1"># We take the value that binary_c has set as the default</span>
 
     <span class="c1"># multiplicity model (as a function of log10M1)</span>
     <span class="c1">#</span>
@@ -1007,9 +1008,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/plot_functions.html b/docs/build/html/_modules/binarycpython/utils/plot_functions.html
index 64e1f27cc49100aeb8899ec46a0683297a049887..75f0703e970a81c2f120fc19c7e3c16acbf4aa6c 100644
--- a/docs/build/html/_modules/binarycpython/utils/plot_functions.html
+++ b/docs/build/html/_modules/binarycpython/utils/plot_functions.html
@@ -829,9 +829,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/run_system_wrapper.html b/docs/build/html/_modules/binarycpython/utils/run_system_wrapper.html
index 70d649d6a6419e761f7ef63b8254d2dd9cb7f4ff..7b8a8cdb04a54b765a6e5da1aa93e963bf78660f 100644
--- a/docs/build/html/_modules/binarycpython/utils/run_system_wrapper.html
+++ b/docs/build/html/_modules/binarycpython/utils/run_system_wrapper.html
@@ -298,9 +298,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/spacing_functions.html b/docs/build/html/_modules/binarycpython/utils/spacing_functions.html
index 6fa1aeaec36172e82be9aed794f34c5662439dbf..ca3d72a41c8311bece9a90564db7356129545298 100644
--- a/docs/build/html/_modules/binarycpython/utils/spacing_functions.html
+++ b/docs/build/html/_modules/binarycpython/utils/spacing_functions.html
@@ -209,9 +209,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/binarycpython/utils/useful_funcs.html b/docs/build/html/_modules/binarycpython/utils/useful_funcs.html
index 8a34e232604ac478da7309fb5479c4ed50d77459..975a7c7001f642d9246248da3f2496562ab6f78f 100644
--- a/docs/build/html/_modules/binarycpython/utils/useful_funcs.html
+++ b/docs/build/html/_modules/binarycpython/utils/useful_funcs.html
@@ -566,9 +566,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_modules/index.html b/docs/build/html/_modules/index.html
index 5306f95eff8b15b92a9493147f00b5237bbb31cb..b050c7170f1c8ef67d525360ffd21071db5e3d5c 100644
--- a/docs/build/html/_modules/index.html
+++ b/docs/build/html/_modules/index.html
@@ -189,9 +189,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/_sources/binary_c_parameters.rst.txt b/docs/build/html/_sources/binary_c_parameters.rst.txt
index 9d05193ac3eee376842356a9aea21ccba0d96899..cdce51580c9e3478b29c356fadc3e11bb84ac62b 100644
--- a/docs/build/html/_sources/binary_c_parameters.rst.txt
+++ b/docs/build/html/_sources/binary_c_parameters.rst.txt
@@ -4,7 +4,7 @@ The following chapter contains all the parameters that the current version of bi
 
 
 This information was obtained by the following binary_c build:
-	**binary_c git branch**: branch_david	**binary_c git revision**: 6162:20210825:093caf0e9	**Built on**: Aug 25 2021 18:02:39
+	**binary_c git branch**: newmaster	**binary_c git revision**: 6185:20210910:1621c23a5	**Built on**: Sep 10 2021 15:05:46
 
 
 Section: stars
@@ -424,6 +424,11 @@ Section: stars
 | **Parameter input type**: Float(scanf)
 | **Default value**: NULL
 
+| **Parameter**: artificial_mass_accretion_rate_by_stellar_type%d
+| **Description**: Constant mass accretion rate for stellar type <n>.
+| **Parameter input type**: Float(scanf)
+| **Default value**: NULL
+
 | **Parameter**: artificial_angular_momentum_accretion_rate%d
 | **Description**: Constant angular momentum accretion for star <n>.
 | **Parameter input type**: Float(scanf)
@@ -468,13 +473,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['BH_HURLEY2002 = 0', 'BH_BELCZYNSKI = 1', 'BH_SPERA2015 = 2', 'BH_FRYER12_DELAYED = 3', 'BH_FRYER12_RAPID = 4', 'BH_FRYER12_STARTRACK = 5']
 
-| **Parameter**: PPISN_prescription
-| **Description**: (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019.
-| **Parameter input type**: Integer
-| **Default value**: 1
-| **Macros**: ['PPISN_NONE = 0', 'PPISN_FARMER19 = 1']
-| **Extra**: Ignore
-
 | **Parameter**: sn_kick_distribution_II
 | **Description**: Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Integer
@@ -502,7 +500,7 @@ Section: stars
 | **Parameter**: sn_kick_distribution_GRB_COLLAPSAR
 | **Description**: Set the distribution of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Integer
-| **Default value**: 0
+| **Default value**: 1
 | **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
 
 | **Parameter**: sn_kick_distribution_TZ
@@ -541,24 +539,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
 
-| **Parameter**: sn_kick_distribution_PPISN
-| **Description**: Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 1
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
-| **Parameter**: sn_kick_distribution_PISN
-| **Description**: Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
-| **Parameter**: sn_kick_distribution_PHDIS
-| **Description**: Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
 | **Parameter**: sn_kick_dispersion_II
 | **Description**: Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Float
@@ -582,7 +562,7 @@ Section: stars
 | **Parameter**: sn_kick_dispersion_GRB_COLLAPSAR
 | **Description**: Set the dispersion of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Float
-| **Default value**: 0
+| **Default value**: 190
 
 | **Parameter**: sn_kick_dispersion_TZ
 | **Description**: Set the dispersion of speeds applied to kick newly-born neutron stars and black holes at the death of a Thorne-Zytkow object. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
@@ -614,21 +594,6 @@ Section: stars
 | **Parameter input type**: Float
 | **Default value**: 0
 
-| **Parameter**: sn_kick_dispersion_PPISN
-| **Description**: Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 190
-
-| **Parameter**: sn_kick_dispersion_PISN
-| **Description**: Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 0
-
-| **Parameter**: sn_kick_dispersion_PHDIS
-| **Description**: Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 0
-
 | **Parameter**: sn_kick_companion_IA_He
 | **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
 | **Parameter input type**: Float
@@ -749,24 +714,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
 
-| **Parameter**: sn_kick_companion_PPISN
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
-| **Parameter**: sn_kick_companion_PISN
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
-| **Parameter**: sn_kick_companion_PHDIS
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
 | **Parameter**: wd_sigma
 | **Description**: Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS.
 | **Parameter input type**: Float
@@ -827,22 +774,22 @@ Section: stars
 | **Parameter**: delta_mcmin
 | **Description**: A parameter to reduce the minimum core mass for third dredge up to occur on the TPAGB. As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lambda_min
 | **Description**: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min>0 implies that, once Mc>Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars. See also lambda_multiplier.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lambda_multiplier
 | **Description**: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min>0 implies that, once Mc>Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: minimum_envelope_mass_for_third_dredgeup
 | **Description**: The minimum envelope mass for third dredge up on the TPAGB. Early, solar metallicity models by Straniero et al suggested 0.5Msun is typical. However, circumstantial evidence (Izzard et al 2009) as well as newer models by Stancliffe and Karakas suggest that at low metallicity a value nearer zero is more appropriate.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.5
 
 | **Parameter**: mass_of_pmz
 | **Description**: The mass in the partial mixing zone of a TPAGB star, using the Karakas 2012 tables. Ask Carlo Abate for more details, or see the series of papers Abate et al 2012, 2013, 2014. Requires NUCSYN and USE_TABULAR_INTERSHELL_ABUNDANCES_KARAKAS_2012.
@@ -852,12 +799,12 @@ Section: stars
 | **Parameter**: c13_eff
 | **Description**: The "efficiency" of partial mixing in a TPAGB star intershell region, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: mc13_pocket_multiplier
 | **Description**: Multiplies the mass in the partial mixing zone of a TPAGB star, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: tides_convective_damping
 | **Description**: Tidal convective damping algorithm. 0=TIDES_HURLEY2002 Zahn 197x timescales + Hut, as in Hurley et al (2002), 1 = TIDES_ZAHN1989: Zahn 1989 lambdas + Hut.
@@ -879,7 +826,7 @@ Section: stars
 | **Parameter**: hbbtfac
 | **Description**: A parameter to modulate the temperature at the base of the hot-bottom burning zone in TPAGB stars. (Works only if NUCSYN is defined)
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: wind_multiplier_%d
 | **Description**: Wind multiplier for the stellar type specified by the intger %d. By default these are all 1.0.
@@ -951,7 +898,7 @@ Section: stars
 | **Parameter**: MINT_metallicity
 | **Description**: This sets the metallicity for MINT. It is ignored if set to -1.0, the default, in which case the normal metallicity parameter is used.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -1
 
 | **Parameter**: gaia_Teff_binwidth
 | **Description**: log10(Effective temperature) bin width used to make Gaia-like HRDs
@@ -978,25 +925,25 @@ Section: stars
 | **Parameter**: AGB_core_algorithm
 | **Description**: Algorithm to use for calculating AGB core masses. 0=Hurley et al. 2002 if no NUCSYN, Karakas 2002 if NUCSYN is defined; 1=Hurley et al. 2002 (overshooting models); 1=Karakas 2002 (non-overshooting models).
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_CORE_ALGORITHM_DEFAULT = 0', 'AGB_CORE_ALGORITHM_HURLEY = 1', 'AGB_CORE_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_radius_algorithm
 | **Description**: Algorithm to use for calculating radii on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_RADIUS_ALGORITHM_DEFAULT = 0', 'AGB_RADIUS_ALGORITHM_HURLEY = 1', 'AGB_RADIUS_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_luminosity_algorithm
 | **Description**: Algorithm to use for calculating luminosities on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_LUMINOSITY_ALGORITHM_DEFAULT = 0', 'AGB_LUMINOSITY_ALGORITHM_HURLEY = 1', 'AGB_LUMINOSITY_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_3dup_algorithm
 | **Description**: Algorithm to use for calculating third dredge up efficiency on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_THIRD_DREDGE_UP_ALGORITHM_DEFAULT = 0', 'AGB_THIRD_DREDGE_UP_ALGORITHM_HURLEY = 1', 'AGB_THIRD_DREDGE_UP_ALGORITHM_KARAKAS = 2', 'AGB_THIRD_DREDGE_UP_ALGORITHM_STANCLIFFE = 3']
 
 | **Parameter**: overspin_algorithm
@@ -1136,6 +1083,21 @@ Section: stars
 | **Parameter input type**: True|False
 | **Default value**: False
 
+| **Parameter**: degenerate_core_merger_nucsyn
+| **Description**: If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE)
+| **Parameter input type**: True|False
+| **Default value**: False
+
+| **Parameter**: degenerate_core_helium_merger_ignition
+| **Description**: If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE)
+| **Parameter input type**: True|False
+| **Default value**: True
+
+| **Parameter**: degenerate_core_merger_dredgeup_fraction
+| **Description**: If non-zero, mix this fraction of the degenerate core during a merger.(0.0).
+| **Parameter input type**: Float
+| **Default value**: 0
+
 Section: binary
 ---------------
 
@@ -1308,7 +1270,7 @@ Section: binary
 | **Parameter**: post_ce_objects_have_envelopes
 | **Description**: If TRUE then post-common-envelope objects have thin envelopes. You need this if you are to have post-CE post-AGB stars. Note that this *may* be unstable, i.e. you may end up having many CEEs. The mass in the envelope is controlled by post_ce_adaptive_menv. TRUE by default.
 | **Parameter input type**: True|False
-| **Default value**: True
+| **Default value**: False
 
 | **Parameter**: PN_comenv_transition_time
 | **Description**: post-common envelope transition time in years (1e2).  This is the time taken to move from CEE ejection to Teff > 30e4 K. Hall et al. (2013) suggest ~100 years.
@@ -1478,18 +1440,20 @@ Section: binary
 | **Parameter**: type_Ia_MCh_supernova_algorithm
 | **Description**: Algorithm to be used when calculating type Ia yields from Chandrasekhar-mass exploders. 0 = DD7 (Iwamoto 1999), 1 = Seitenzahl 2013 3D hydro yields (you must also set Seitenzahl2013_model) 
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['TYPE_IA_MCH_SUPERNOVA_ALGORITHM_DD2 = 0', 'TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013 = 1', 'TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013_AUTOMATIC = 2']
 
 | **Parameter**: Seitenzahl2013_model
 | **Description**: Which of Seitenzahl et al. 2013's models to use? One of N1,N3,N5,N10,N20,N40,N100L,N100,N100H,N150,N200,N300C,N1600,N1600C,N100_Z0.5,N100_Z0.1,N100_Z0.01 (defaults to N100).
 | **Parameter input type**: String
-| **Default value**: NULL
+| **Default value**: N100
 | **Extra**: N1
 
 | **Parameter**: type_Ia_sub_MCh_supernova_algorithm
 | **Description**: Algorithm to be used when calculating type Ia yields from sub-Chandrasekhar-mass exploders. (Currently unused.)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['TYPE_IA_SUB_MCH_SUPERNOVA_ALGORITHM_LIVNE_ARNETT_1995 = 0']
 
 | **Parameter**: max_HeWD_mass
 | **Description**: The maximum mass a HeWD can have before it ignites helium (0.7).
@@ -2130,7 +2094,7 @@ Section: nucsyn
 | **Parameter**: NeNaMgAl
 | **Description**: Enables NeNaMgAl reaction network. Requires NUCSYN and NUCSYN_HBB.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: Ignore
 
 | **Parameter**: nucsyn_network%d
@@ -2151,19 +2115,21 @@ Section: nucsyn
 | **Parameter**: nucsyn_metallicity
 | **Description**: This sets the metallicity of the nucleosynthesis algorithms, i.e. the amount (by mass) of matter which is not hydrogen or helium. Usually you'd just set this with the metallicity parameter, but if you want the nucleosynthesis to be outside the range of the stellar evolution algorithm (e.g. Z=0 or Z=0.04) then you need to use nucsyn_metallicity. That said, it's also outside the range of some of the nucleosynthesis algorithms as well, so you have been warned!
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['DEFAULT_TO_METALLICITY = -1']
 
 | **Parameter**: nucsyn_solver
 | **Description**: Choose the solver used in nuclear burning. 0 = KAPS_RENTROP is a Kaps-Rentrop scheme (fast, not great for stiff problems), 1 = LSODA (Adams/BSF switcher), 2 = CVODE library (https://computing.llnl.gov/projects/sundials. Default 0. 
 | **Parameter input type**: Unsigned integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['NUCSYN_SOLVER_KAPS_RENTROP = 0', 'NUCSYN_SOLVER_LSODA = 1', 'NUCSYN_SOLVER_CVODE = 2', 'NUCSYN_SOLVER_NUMBER = 3', 'NUCSYN_SOLVER_KAPS_RENTROP = 0', 'NUCSYN_SOLVER_LSODA = 1', 'NUCSYN_SOLVER_CVODE = 2', 'NUCSYN_SOLVER_NUMBER = 3']
 | **Extra**: 0
 
 | **Parameter**: initial_abundance_mix
 | **Description**: initial abundance mixture: 0=AG89, 1=Karakas 2002, 2=Lodders 2003, 3=Asplund 2005 (not available?), 4=Garcia Berro, 5=Grevesse Noels 1993
 | **Parameter input type**: Unsigned integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['NUCSYN_INIT_ABUND_MIX_AG89 = 0', 'NUCSYN_INIT_ABUND_MIX_KARAKAS2002 = 1', 'NUCSYN_INIT_ABUND_MIX_LODDERS2003 = 2', 'NUCSYN_INIT_ABUND_MIX_ASPLUND2005 = 3', 'NUCSYN_INIT_ABUND_MIX_GARCIABERRO = 4', 'NUCSYN_INIT_ABUND_MIX_GREVESSE_NOELS_1993 = 5', 'NUCSYN_INIT_ABUND_MIX_ASPLUND2009 = 6', 'NUCSYN_INIT_ABUND_MIX_KOBAYASHI2011_ASPLUND2009 = 7', 'NUCSYN_INIT_ABUND_MIX_LODDERS2010 = 8']
 | **Extra**: 0
 
 | **Parameter**: init_abund
@@ -2187,37 +2153,38 @@ Section: nucsyn
 | **Parameter**: init_abunds_only
 | **Description**: If True, outputs only the initial abundances, then exits.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: initial_abunds_only
 | **Description**: If True, outputs only the initial abundances, then exits.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: no_thermohaline_mixing
 | **Description**: If True, disables thermohaline mixing.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: lithium_GB_post_Heflash
 | **Description**: Sets the lithium abundances after the helium flash. Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lithium_GB_post_1DUP
 | **Description**: Sets the lithium abundance after first dredge up. Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lithium_hbb_multiplier
 | **Description**: Multiplies the lithium abundances on the AGB during HBB (based on Karakas/Fishlock et al models).Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: angelou_lithium_decay_function
 | **Description**: Functional form which describes Li7 decay. Requires NUCSYN and NUCSYN_ANGELOU_LITHIUM. Choices are: 0 expoential (see angelou_lithium_decay_time).
 | **Parameter input type**: Integer
 | **Default value**: NULL
+| **Macros**: ['ANGELOU_LITHIUM_DECAY_FUNCTION_EXPONENTIAL = 0']
 
 | **Parameter**: angelou_lithium_LMMS_time
 | **Description**: Time at which lithium manufacture is triggered in a low-mass (convective) main sequence (Myr). Requires NUCSYN and NUCSYN_ANGELOU_LITHIUM. Ignored if 0 (for the start, use 1e-6).
@@ -2337,16 +2304,10 @@ Section: nucsyn
 Section: output
 ---------------
 
-| **Parameter**: david_logging_function
-| **Description**: Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Extra**: Ignore
-
 | **Parameter**: cf_amanda_log
 | **Description**: Enable logging to compare to Amanda's models.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: float_overflow_checks
 | **Description**: Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0)
@@ -2386,7 +2347,7 @@ Section: output
 | **Parameter**: legacy_yields
 | **Description**: Turn on ensemble legacy yield output.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: ensemble_defer
 | **Description**: Defer ensemble output.
@@ -2426,27 +2387,27 @@ Section: output
 | **Parameter**: EMP_logg_maximum
 | **Description**: Maximum logg that EMP stars are allowed to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_minimum_age.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 4
 
 | **Parameter**: EMP_minimum_age
 | **Description**: Minimum age that EMP stars are required to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 10
 
 | **Parameter**: EMP_feh_maximum
 | **Description**: Maximum [Fe/H] that an EMP stars may have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default -2.0.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -2
 
 | **Parameter**: CEMP_cfe_minimum
 | **Description**: Minimum [C/Fe] that CEMP stars are required to have. See Izzard et al 2009. See also NEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 0.7.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.7
 
 | **Parameter**: NEMP_cfe_minimum
 | **Description**: Minimum [N/Fe] that NEMP stars are required to have. See Izzard et al 2009, Pols et al. 2012. See also CEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 1.0.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: thick_disc_start_age
 | **Description**: Lookback time for the start of the thick disc star formation, e.g. 13e3 Myr. Units = Myr.
@@ -2582,99 +2543,99 @@ Section: input
 | **Parameter**: MINT_dir
 | **Description**: Location of MINT algorithm data.
 | **Parameter input type**: String
-| **Default value**: NULL
+| **Default value**: 
 | **Extra**: 
 
 | **Parameter**: MINT_data_cleanup
 | **Description**: Activate checks on incoming data to try to account for problems. Will make data-loading slower, but may fix a few things.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_MS_rejuvenation
 | **Description**: Turn on or off (hydrogen) main-sequence rejuvenation.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_remesh
 | **Description**: Turn on or off MINT's remeshing.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_use_ZAMS_profiles
 | **Description**: Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.)
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_fallback_to_test_data
 | **Description**: If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE)
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_disable_grid_load_warnings
 | **Description**: Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn
 | **Description**: Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
 | **Extra**: 
 
 | **Parameter**: MINT_nshells
 | **Description**: Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 200
 | **Extra**: 
 
 | **Parameter**: MINT_maximum_nshells
 | **Description**: Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 1000
 | **Extra**: 
 
 | **Parameter**: MINT_minimum_nshells
 | **Description**: Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 10
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn_stellar_type
 | **Description**: Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['LOW_MASS_MS = 0', 'MS = 1', 'HG = 2', 'GIANT_BRANCH = 3', 'CHeB = 4', 'EAGB = 5', 'TPAGB = 6', 'HeMS = 7', 'HeHG = 8', 'HeGB = 9', 'HeWD = 10', 'COWD = 11', 'ONeWD = 12', 'NS = 13', 'BH = 14', 'MASSLESS_REMNANT = 15']
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn_companion_stellar_type
 | **Description**: Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['LOW_MASS_MS = 0', 'MS = 1', 'HG = 2', 'GIANT_BRANCH = 3', 'CHeB = 4', 'EAGB = 5', 'TPAGB = 6', 'HeMS = 7', 'HeHG = 8', 'HeGB = 9', 'HeWD = 10', 'COWD = 11', 'ONeWD = 12', 'NS = 13', 'BH = 14', 'MASSLESS_REMNANT = 15']
 | **Extra**: 
 
 | **Parameter**: MINT_nuclear_burning
 | **Description**: Turn on or off MINT's nuclear burning algorithm.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_minimum_shell_mass
 | **Description**: Minimum shell mass in MINT's nuclear burning routines.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1e-06
 | **Extra**: 
 
 | **Parameter**: MINT_maximum_shell_mass
 | **Description**: Maximum shell mass in MINT's nuclear burning routines. :
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.1
 | **Extra**: 
 
 Section: i/o
diff --git a/docs/build/html/_sources/example_notebooks.rst.txt b/docs/build/html/_sources/example_notebooks.rst.txt
index 7e2eef403ef98e8f4cf2785691ed1aadca497439..ce09bb2af89dbf01f6e8e9170d3284c1e8ba08e7 100644
--- a/docs/build/html/_sources/example_notebooks.rst.txt
+++ b/docs/build/html/_sources/example_notebooks.rst.txt
@@ -2,7 +2,7 @@ Example notebooks
 =================
 We have a set of notebooks that explain and show the usage of the binarycpython features. The notebooks are also stored in the examples/ directory in the `repository <https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master/examples>`_
 
-The order of the notebooks below is more or less the recommended order to read.
+The order of the notebooks below is more or less the recommended order to read. The last couple of notebooks are example usecases
 
 .. toctree::
     :maxdepth: 2
@@ -12,4 +12,8 @@ The order of the notebooks below is more or less the recommended order to read.
     notebook_custom_logging.ipynb
     notebook_population.ipynb
     notebook_extra_features.ipynb
-    notebook_api_functionality.ipynb
\ No newline at end of file
+    notebook_api_functionality.ipynb
+    notebook_luminosity_function_single.ipynb
+    notebook_luminosity_function_binaries.ipynb
+    notebook_HRD.ipynb
+    notebook_common_envelope_evolution.ipynb
\ No newline at end of file
diff --git a/docs/build/html/_sources/grid_options_descriptions.rst.txt b/docs/build/html/_sources/grid_options_descriptions.rst.txt
index 319b8d56a6d616f55498ec2c10fbc358a8de8183..84538e2c4a51e19e6c1e6299dcea91c1c5e2d5f2 100644
--- a/docs/build/html/_sources/grid_options_descriptions.rst.txt
+++ b/docs/build/html/_sources/grid_options_descriptions.rst.txt
@@ -1,7 +1,7 @@
 Population grid code options
 ============================
 The following chapter contains all grid code options, along with their descriptions
-There are 1 options that are not described yet.
+There are 2 options that are not described yet.
 
 
 Public options
@@ -35,6 +35,8 @@ The following options are meant to be changed by the user.
 
 | **log_args_dir**: Directory to log the arguments to. Unused
 
+| **log_dt**: No description available yet
+
 | **log_file**: Log file for the population object. Unused
 
 | **log_runtime_systems**: Whether to log the runtime of the systems . Each systems run by the thread is logged to a file and is stored in the tmp_dir. (1 file per thread). Don't use this if you are planning to run a lot of systems. This is mostly for debugging and finding systems that take long to run. Integer, default = 0. if value is 1 then the systems are logged
@@ -47,7 +49,7 @@ The following options are meant to be changed by the user.
 
 | **multiplicity_fraction_function**: Which multiplicity fraction function to use. 0: None, 1: Arenou 2010, 2: Rhagavan 2010, 3: M&S 2017
 
-| **parse_function**: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the grid_options['results'] dictionary, or just output results to a file
+| **parse_function**: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the self.grid_results dictionary, or just output results to a file
 
 | **repeat**: Factor of how many times a system should be repeated. Consider the evolution splitting binary_c argument for supernovae kick repeating.
 
diff --git a/docs/build/html/_sources/notebook_HRD.ipynb.txt b/docs/build/html/_sources/notebook_HRD.ipynb.txt
new file mode 100644
index 0000000000000000000000000000000000000000..52590f8a2a6abc7245e9ea0c08d274432cd2a1ad
--- /dev/null
+++ b/docs/build/html/_sources/notebook_HRD.ipynb.txt
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Hertzsprung-Russell diagrams\n",
+    "\n",
+    "In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_HRD\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "First we set up a new population object. Our stars evolve to $13.7\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to $13.7\\mathrm{Gyr}$, and stars are not really born with a metallicity of $0.02$. These approximations only affect very low mass stars, so we assume all our stars have mass $M\\geq 1 \\mathrm{M}_\\odot$, and metallicity does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to $M\\leq 10 \\mathrm{M}_\\odot$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    tmp_dir=TMP_DIR,\n",
+    "    verbosity=1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $10\\mathrm{M}_\\odot$ in nine steps (so the masses are integers). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"M_1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        11\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1,2,1)\",\n",
+      "    \"precode\": null,\n",
+      "    \"probdist\": \"1\",\n",
+      "    \"dphasevol\": \"dM_1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"edge\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10} \n",
+    "massrange = (1, 11) \n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\", # == single-star mass\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(1,2,1)\", # space by unit masses\n",
+    "    probdist=\"1\", # dprob/dm1 : we don't care, so just set it to 1\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    "    gridtype=\"edge\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "\n",
+    "We now construct the HRD output.\n",
+    "\n",
+    "We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have $>0.1\\mathrm{M}_\\odot$ of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "Foreach_star(star)\n",
+      "{\n",
+      "    if(star->stellar_type <= TPAGB &&\n",
+      "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+      "    {\n",
+      "         double logTeff = log10(Teff_from_star_struct(star));\n",
+      "         double logL = log10(star->luminosity); \n",
+      "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+      "         Printf(\"HRD%d %30.12e %g %g %g %g\\n\",\n",
+      "                star->starnum, // 0\n",
+      "                stardata->model.time, // 1\n",
+      "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+      "                logTeff, // 3\n",
+      "                logL, // 4\n",
+      "                loggravity // 5\n",
+      "                );\n",
+      "\n",
+      "    }\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "Foreach_star(star)\n",
+    "{\n",
+    "    if(star->stellar_type <= TPAGB &&\n",
+    "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+    "    {\n",
+    "         double logTeff = log10(Teff_from_star_struct(star));\n",
+    "         double logL = log10(star->luminosity); \n",
+    "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+    "         Printf(\"HRD%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                star->starnum, // 0\n",
+    "                stardata->model.time, // 1\n",
+    "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+    "                logTeff, // 3\n",
+    "                logL, // 4\n",
+    "                loggravity // 5\n",
+    "                );\n",
+    "\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"HRD*n*\", where *n* is 0 (primary star) or 1 (secondary star, which doesn't exist in single-star systems), and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14565763dca0> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"logTeff\", \"logL\", \"logg\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        match = re.search('HRD(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            \n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "            # first time setup of the list of tuples\n",
+    "            if(len(self.grid_results['HRD'][nstar][linedata['zams_mass']])==0):\n",
+    "                self.grid_results['HRD'][nstar][linedata['zams_mass']] = []\n",
+    "\n",
+    "            # make the HRD be a list of tuples\n",
+    "            self.grid_results['HRD'][nstar][linedata['zams_mass']].append((linedata['logTeff'],\n",
+    "                                                                           linedata['logL']))\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: verbosity=0 to grid_options\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '20bee5b0c58d49c5bc47eced240685bb', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 10.0, 'total_count': 10, 'start_timestamp': 1631304519.45189, 'end_timestamp': 1631304519.9955394, 'total_mass_run': 55.0, 'total_probability_weighted_mass_run': 55.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    for zams_mass in sorted(hrd[nstar]):\n",
+    "        print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "        # get track data (list of tuples)\n",
+    "        track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "        # convert to Pandas dataframe\n",
+    "        data = pd.DataFrame(data=track, \n",
+    "                            columns = ['logTeff','logL'])\n",
+    "        \n",
+    "        # make seaborn plot\n",
+    "        p = sns.lineplot(data=data,\n",
+    "                         sort=False,\n",
+    "                         x='logTeff',\n",
+    "                         y='logL',\n",
+    "                         estimator=None)\n",
+    "        \n",
+    "        # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "        p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "        \n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "We now have an HRD. It took longer to make the plot than to run the stars with *binary_c*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## Binary stars"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d0fc4e-c72f-444a-93ab-19f52086b86d",
+   "metadata": {},
+   "source": [
+    "Now we put a secondary star of mass $0.5\\mathrm{M}_\\odot$ at a distance of $10\\mathrm{R}_\\odot$ to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "478e8005-e144-4e6f-80c9-0cf368a9bcb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 0.5, # Msun\n",
+    "    separation = 10, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c433e6a-fe22-4494-b1a9-fce9676a9f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3557b6d5-6c54-467c-b7a1-b1903493c441",
+   "metadata": {},
+   "source": [
+    "We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59335030-dd99-4c2f-afff-207a3fcbbb70",
+   "metadata": {},
+   "source": [
+    "If we now set the separation to be longer, say $100\\mathrm{R}_\\odot$, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, $1\\mathrm{M}_\\odot$, so that the interaction is stronger."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dee92b20-ad6b-4c97-80dc-71d3bd937c4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 1, # Msun\n",
+    "    separation = 100, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    "    alpha_ce = 1.0, # make common-envelope evolution quite efficient\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e0ac2573-bc35-43be-8f20-5c85364fde11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f8e061-a65e-47f2-a777-93de0d5045ea",
+   "metadata": {},
+   "source": [
+    "You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the $1\\mathrm{M}_\\odot$ star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698d0a63-11ba-4b3e-a713-35c3e972492f",
+   "metadata": {},
+   "source": [
+    "We can also plot the secondary stars' HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That's because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2b0b7c2b-6e43-48ed-9257-9dfc141b3d28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "star  1\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '1': # choose only secondaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "            \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92c46319-5629-4125-a284-b5d521ed33fc",
+   "metadata": {},
+   "source": [
+    "Remember, all these stars start with a $1\\mathrm{M}_\\odot$ binary, which begins at $\\log_{10}(T_\\mathrm{eff}/\\mathrm{K})\\sim 3.750$, $\\log_{10}L/\\mathrm{L}_\\odot \\sim 0$. The $1\\mathrm{M}_\\odot$-$1\\mathrm{M}_\\odot$ binary evolves like two single stars until they interact up the giant branch at about $\\log_{10} (L/\\mathrm{L}_\\odot) \\sim 2.5$, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the very start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53145356-abbb-4880-996f-dedd80de7540",
+   "metadata": {},
+   "source": [
+    "This is, of course, a very simple introduction to what happens in binaries. We haven't talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/_sources/notebook_api_functionality.ipynb.txt b/docs/build/html/_sources/notebook_api_functionality.ipynb.txt
index d81c31711bfc5d6de3159fd8958df96dd145ded0..020d2dc7cdb1ae9f1214d42e3351b571ff0c943d 100644
--- a/docs/build/html/_sources/notebook_api_functionality.ipynb.txt
+++ b/docs/build/html/_sources/notebook_api_functionality.ipynb.txt
@@ -5,7 +5,7 @@
    "id": "cb9d00f5-9613-471e-a4bb-6181311bf73b",
    "metadata": {},
    "source": [
-    "# Using the API functionality of binarycpython\n",
+    "# Tutorial: Using the API functionality of binary_c-python\n",
     "This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw\n",
     "\n",
     "Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in `src/binary_c_python.c`, and the functions are available via `from binarycpython import _binary_c_bindings`.\n",
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "ded7eaf6-e1ba-46c2-9f6f-9ebcb14a264d",
    "metadata": {},
    "outputs": [
@@ -30,37 +30,69 @@
       "\n",
       "FUNCTIONS\n",
       "    free_persistent_data_memaddr_and_return_json_output(...)\n",
-      "        Frees the persistent_data memory and returns the json output\n",
+      "        Frees the persistent_data memory and returns the json output.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)\n",
       "    \n",
       "    free_store_memaddr(...)\n",
-      "        Frees the store memaddr\n",
+      "        Frees the store memaddr.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the store object\n",
       "    \n",
       "    return_arglines(...)\n",
       "        Return the default args for a binary_c system\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_help(...)\n",
       "        Return the help info for a given parameter\n",
+      "        \n",
+      "        Arguments:\n",
+      "                parameter: parameter name.\n",
       "    \n",
       "    return_help_all(...)\n",
       "        Return an overview of all the parameters, their description, categorized in sections\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_maximum_mass_ratio_for_RLOF(...)\n",
-      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_minimum_orbit_for_RLOF(...)\n",
-      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_persistent_data_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_store_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_version_info(...)\n",
       "        Return the version information of the used binary_c build\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    run_system(...)\n",
-      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things. \n",
+      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.\n",
       "        \n",
       "        Arguments:\n",
       "                argstring: argument string for binary_c\n",
@@ -126,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "10a74d5a-a3d5-4543-a5bc-20d1fe885bb4",
    "metadata": {},
    "outputs": [
@@ -134,8 +166,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<capsule object \"STORE\" at 0x7f163859d0c0>\n",
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
+      "<capsule object \"STORE\" at 0x7fa6a45ed180>\n",
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
       "\n"
      ]
     }
@@ -183,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "318874f6-7acf-49bb-9786-299d4dffc0b3",
    "metadata": {},
    "outputs": [
@@ -217,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "d7e757ae-579c-42a2-a310-f0401b7800e8",
    "metadata": {
     "scrolled": true,
@@ -291,6 +323,9 @@
       "opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)\n",
       "wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0\n",
       "gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)\n",
+      "postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&A 635, A173). : (null)\n",
+      "Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)\n",
+      "Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)\n",
       "mattsson_Orich_tpagbwind : Experimental : turns on Mattsson's TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)\n",
       "magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)\n",
       "magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)\n",
@@ -310,7 +345,9 @@
       "vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)\n",
       "vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)\n",
       "tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers' mass loss formula. (This multiplies the 4e-13 in Reimers' formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)\n",
+      "Tout_Pringle_1992_multiplier : Multiplier for the Tout & Pringle (1992) magnetic wind. (0.0) : (null)\n",
       "artificial_mass_accretion_rate%d : Constant mass accretion rate for star <n>. : (null)\n",
+      "artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type <n>. : (null)\n",
       "artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star <n>. : (null)\n",
       "artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)\n",
       "artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if <0 (default is -1). : (null)\n",
@@ -318,8 +355,7 @@
       "wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge's version of Vink's early-2000s wind (See Lynnette Dray's thesis, or John Eldridge's thesis) : (null)\n",
       "wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)\n",
       "wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)\n",
-      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)\n",
-      "PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore\n",
+      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)\n",
       "sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -331,9 +367,6 @@
       "sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -345,9 +378,6 @@
       "sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_companion_IA_He : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_ELD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_CHAND : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
@@ -368,9 +398,6 @@
       "sn_kick_companion_BH_NS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PPISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PHDIS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)\n",
       "wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)\n",
       "wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)\n",
@@ -443,6 +470,11 @@
       "HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)\n",
       "wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)\n",
       "wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)\n",
+      "colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)\n",
+      "apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)\n",
+      "degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)\n",
+      "degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)\n",
+      "degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)\n",
       "\n",
       "############################################################\n",
       "##### Section Binary\n",
@@ -709,7 +741,6 @@
       "############################################################\n",
       "##### Section Output\n",
       "############################################################\n",
-      "david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions : Ignore\n",
       "cf_amanda_log : Enable logging to compare to Amanda's models. : (null)\n",
       "float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)\n",
       "save_pre_events_stardata : Enable this to save a copy of stardata to stardata->pre_events_stardata just before an event. : (null)\n",
@@ -739,6 +770,7 @@
       "escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)\n",
       "colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. : \n",
       "log_filename : Location of the output logging filename. If set to \"/dev/null\" then there is no logging. : \n",
+      "log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. : \n",
       "stopfile : File which, when it exists, will stop the current binary_c repeat run. : \n",
       "stardata_dump_filename : Location of the stardata dump file. : \n",
       "stardata_load_filename : Location of the stardata file to load. : \n",
@@ -763,8 +795,12 @@
       "MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. : \n",
       "MINT_remesh : Turn on or off MINT's remeshing. : \n",
       "MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) : \n",
+      "MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) : \n",
       "MINT_disable_grid_load_warnings : Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data. : \n",
       "MINT_Kippenhahn : Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. : \n",
+      "MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) : \n",
+      "MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) : \n",
+      "MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) : \n",
       "MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. : \n",
       "MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. : \n",
       "MINT_nuclear_burning : Turn on or off MINT's nuclear burning algorithm. : \n",
@@ -825,7 +861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 5,
    "id": "3d29ca9d-ac66-4f9e-81cf-2edd14a98b79",
    "metadata": {},
    "outputs": [
@@ -854,7 +890,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "e517f561-09c6-419d-ba89-d9cb61e6ebab",
    "metadata": {},
    "outputs": [
@@ -887,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "id": "7da75a95-8831-4346-a584-e042ced75249",
    "metadata": {},
    "outputs": [
diff --git a/docs/build/html/_sources/notebook_common_envelope_evolution.ipynb.txt b/docs/build/html/_sources/notebook_common_envelope_evolution.ipynb.txt
new file mode 100644
index 0000000000000000000000000000000000000000..526320ccf954c1ed86c6d5c641204c4a9345bbe5
--- /dev/null
+++ b/docs/build/html/_sources/notebook_common_envelope_evolution.ipynb.txt
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Common-envelope evolution\n",
+    "\n",
+    "In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.\n",
+    "\n",
+    "First, we import a few required Python modules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_comenv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Setting up the Population object\n",
+    "We set up a new population object. Our stars evolve to $13.7\\text{ }\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. We also set the common-envelope ejection efficiency $\\alpha_\\mathrm{CE}=1$ and the envelope structure parameter $\\lambda=0.5$. More complex options are available in *binary_c*, such as $\\lambda$ based on stellar mass, but this is just a demonstration example so let's keep things simple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: log_dt=10 to grid_options\n",
+      "adding: max_evolution_time=13700 to BSE_options\n",
+      "adding: metallicity=0.02 to BSE_options\n",
+      "adding: alpha_ce=1.0 to BSE_options\n",
+      "adding: lambda_ce=0.5 to BSE_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    # grid options\n",
+    "    tmp_dir = TMP_DIR,\n",
+    "    verbosity = 1,\n",
+    "    log_dt = 10, # log every 10 seconds\n",
+    "\n",
+    "    # binary-star evolution options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    alpha_ce = 1.0,\n",
+    "    lambda_ce = 0.5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $6\\text{ }\\mathrm{M}_\\odot$. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to $10^4\\text{ }\\mathrm{d}$ because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"lnm1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        6\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(math.log(1), math.log(6), 10)\",\n",
+      "    \"precode\": \"M_1=math.exp(lnm1)\",\n",
+      "    \"probdist\": \"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+      "    \"dphasevol\": \"dlnm1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"q\",\n",
+      "    \"longname\": \"Mass ratio\",\n",
+      "    \"valuerange\": [\n",
+      "        \"0.1/M_1\",\n",
+      "        1\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1/M_1, 1, 10)\",\n",
+      "    \"precode\": \"M_2 = q * M_1\",\n",
+      "    \"probdist\": \"flatsections(q, [{'min': 1/M_1, 'max': 1.0, 'height': 1}])\",\n",
+      "    \"dphasevol\": \"dq\",\n",
+      "    \"parameter_name\": \"M_2\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 1\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"log10per\",\n",
+      "    \"longname\": \"log10(Orbital_Period)\",\n",
+      "    \"valuerange\": [\n",
+      "        0.15,\n",
+      "        5.5\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(0.15, 4, 10)\",\n",
+      "    \"precode\": \"orbital_period = 10.0 ** log10per\\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)\",\n",
+      "    \"probdist\": \"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)\",\n",
+      "    \"dphasevol\": \"dlog10per\",\n",
+      "    \"parameter_name\": \"orbital_period\",\n",
+      "    \"condition\": null,\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 2\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10, \"q\" : 10, \"per\": 10} \n",
+    "massrange = [1, 6] \n",
+    "logperrange = [0.15, 4]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Logging and handling the output\n",
+    "\n",
+    "We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "\n",
+      "/*\n",
+      " * Detect when the comenv_count increased \n",
+      " */\n",
+      "if(stardata->model.comenv_count == 1 && \n",
+      "   stardata->previous_stardata->model.comenv_count == 0)\n",
+      "{\n",
+      "   /*\n",
+      "    * We just had this system's first common envelope:\n",
+      "    * output the time at which this happens, \n",
+      "    * the system's probability (proportional to the number of stars),\n",
+      "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+      "    * the current timestep (post-comenv) orbital period (days)\n",
+      "    */\n",
+      "    Printf(\"COMENV %g %g %g %g\\n\",\n",
+      "           stardata->model.time,\n",
+      "           stardata->model.probability,\n",
+      "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+      "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+      "           \n",
+      "    /*\n",
+      "     * We should waste no more CPU time on this system now we have the\n",
+      "     * data we want.\n",
+      "     */\n",
+      "    stardata->model.evolution_stop = TRUE;\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "\n",
+    "/*\n",
+    " * Detect when the comenv_count increased \n",
+    " */\n",
+    "if(stardata->model.comenv_count == 1 && \n",
+    "   stardata->previous_stardata->model.comenv_count == 0)\n",
+    "{\n",
+    "   /*\n",
+    "    * We just had this system's first common envelope:\n",
+    "    * output the time at which this happens, \n",
+    "    * the system's probability (proportional to the number of stars),\n",
+    "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+    "    * the current timestep (post-comenv) orbital period (days)\n",
+    "    */\n",
+    "    Printf(\"COMENV %g %g %g %g\\\\n\",\n",
+    "           stardata->model.time,\n",
+    "           stardata->model.probability,\n",
+    "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+    "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+    "           \n",
+    "    /*\n",
+    "     * We should waste no more CPU time on this system now we have the\n",
+    "     * data we want.\n",
+    "     */\n",
+    "    stardata->model.evolution_stop = TRUE;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"COMENV\" and process the associated data. We set up the parse_data function to do just this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14736bebc040> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "# log-period distribution bin width (dex)\n",
+    "binwidth = 0.5 \n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"probability\", \"pre_comenv_period\", \"post_comenv_period\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "        # choose COMENV lines of output\n",
+    "        if linedata[\"header\"] == \"COMENV\":\n",
+    "            # bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex\n",
+    "            binned_pre_period = bin_data(math.log10(linedata[\"pre_comenv_period\"]), binwidth)\n",
+    "            \n",
+    "            # but check if the post-comenv period is finite and positive: if \n",
+    "            # not, the system has merged and we give it an aritifical period\n",
+    "            # of 10^-100 days (which is very much unphysical)\n",
+    "            if linedata[\"post_comenv_period\"] > 0.0:\n",
+    "                binned_post_period = bin_data(math.log10(linedata[\"post_comenv_period\"]), binwidth)\n",
+    "            else:\n",
+    "                binned_post_period = bin_data(-100,binwidth) # merged!\n",
+    "                \n",
+    "            # make the \"histograms\"\n",
+    "            self.grid_results['pre'][binned_pre_period] += linedata[\"probability\"]\n",
+    "            self.grid_results['post'][binned_post_period] += linedata[\"probability\"]\n",
+    "\n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 1000 stars\n",
+      "with a total probability of 0.0645905996773004\n",
+      "Total starcount for this run will be: 1000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-12T18:07:39.965721.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee47e0>\n",
+      "Process 1 started at 2021-09-12T18:07:39.970949.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n",
+      "Process 2 started at 2021-09-12T18:07:39.978355.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4f30>\n",
+      "Process 3 started at 2021-09-12T18:07:39.983689.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB\n",
+      "322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB\n",
+      "465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB\n",
+      "586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB\n",
+      "682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB\n",
+      "784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB\n",
+      "872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB\n",
+      "963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).\n",
+      "\tRan 222 systems with a total probability of 0.014137215791516371.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).\n",
+      "\tRan 273 systems with a total probability of 0.01877334232598154.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).\n",
+      "\tRan 268 systems with a total probability of 0.016469813170514686.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).\n",
+      "\tRan 237 systems with a total probability of 0.015210228389288167.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'ad303100d719457c83256568f9a9887c', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.06459059967730076, 'total_count': 1000, 'start_timestamp': 1631462859.9342952, 'end_timestamp': 1631462947.4824853, 'total_mass_run': 4680.235689312421, 'total_probability_weighted_mass_run': 0.22611318083528567, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'merged': 0.035263029200000025, 'unmerged': 0.019388724199999995}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Number of stars')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the distributions\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import copy\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "# remove the merged objects\n",
+    "probability = { \"merged\" : 0.0, \"unmerged\" : 0.0}\n",
+    "\n",
+    "# copy the results so we can change the copy\n",
+    "results = copy.deepcopy(population.grid_results)\n",
+    "\n",
+    "for distribution in ['post']:    \n",
+    "    for logper in population.grid_results[distribution]:\n",
+    "        dprob = results[distribution][logper]\n",
+    "        if logper < -90:\n",
+    "            # merged system\n",
+    "            probability[\"merged\"] += dprob\n",
+    "            del results[distribution][logper]\n",
+    "        else:\n",
+    "            # unmerged system\n",
+    "            probability[\"unmerged\"] += dprob\n",
+    "print(probability)\n",
+    "    \n",
+    "# pad the final distribution with zero\n",
+    "for distribution in population.grid_results:    \n",
+    "    pad_output_distribution(results[distribution],\n",
+    "                            binwidth)\n",
+    "    \n",
+    "# make pandas dataframe \n",
+    "plot_data = pd.DataFrame.from_dict(results, orient='columns')\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10} (P_\\mathrm{orb} / \\mathrm{day})$\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "#p.set(xlim=(-5,5)) # might be necessary?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4740c93-d01e-4ca1-8766-c2fb4ddca2e4",
+   "metadata": {},
+   "source": [
+    "You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range $10$ to $1000\\text{ }\\mathrm{d}$, while after CEE the distribution peaks at about $1\\text{ }\\mathrm{d}$. Some of these orbits are very short: $\\log_{10}(-2) = 0.01\\text{ }\\mathrm{d}\\sim10\\text{ }\\mathrm{minutes}$. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57faf043-3809-427a-b378-2355ce8c2691",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Extend the logging to output more data than just the orbital period.\n",
+    "* What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova?\n",
+    "* What are the lifetimes of the systems in close ($<1\\text{ }\\mathrm{d}$) binaries? Are they likely to merge in the life of the Universe?\n",
+    "* How much mass is lost in common-envelope interactions?\n",
+    "* Extend the grid to massive stars. Do you see many NS and BH compact binaries?\n",
+    "* Try different $\\alpha_\\mathrm{CE}$ and $\\lambda_\\mathrm{CE}$ options...\n",
+    "* ... and perhaps increased resolution to obtain smoother curves.\n",
+    "* Why do long-period systems not reach common envelope evolution?"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/_sources/notebook_custom_logging.ipynb.txt b/docs/build/html/_sources/notebook_custom_logging.ipynb.txt
index 05ffbccfc23f0b08e85abed0d467233385520a4b..bfdf2a5c8fe238aec50d8f69c74d11b06491eb5f 100644
--- a/docs/build/html/_sources/notebook_custom_logging.ipynb.txt
+++ b/docs/build/html/_sources/notebook_custom_logging.ipynb.txt
@@ -5,13 +5,13 @@
    "id": "879b596b-d70c-4f90-b668-563b4ad93ffc",
    "metadata": {},
    "source": [
-    "# Using custom logging routines with binarycpython\n",
+    "# Tutorial: Using custom logging routines with binary_c-python\n",
     "In this notebook you'll learn how to use the custom logging functionality"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "696ecbb9-1efd-48f4-a57e-2cf6dfe416f1",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "236cf821-09ac-4237-9b8f-6e36d2edf446",
    "metadata": {},
    "outputs": [
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "feb423d5-5cc3-433c-9801-f8017abbc03a",
    "metadata": {},
    "outputs": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 4,
    "id": "2f5defbf-c623-49ed-a238-fba52a563a58",
    "metadata": {},
    "outputs": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 5,
    "id": "dcd74bbc-478b-43e4-b495-8c456e8d1d88",
    "metadata": {},
    "outputs": [
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 6,
    "id": "77bd09b0-1a94-499d-97db-a1f991c67c12",
    "metadata": {},
    "outputs": [
@@ -203,10 +203,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1\n",
-      "EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2\n"
+      "EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1\n",
+      "EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2\n"
      ]
     }
    ],
@@ -260,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 7,
    "id": "30142286-34ce-433e-82c8-565e2160ff5b",
    "metadata": {},
    "outputs": [
@@ -336,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "id": "6f0edc65-a788-4706-a0c5-2ace030765ec",
    "metadata": {},
    "outputs": [
@@ -344,8 +344,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
-      "EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5\n"
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
+      "EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5\n"
      ]
     }
    ],
@@ -395,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 10,
    "id": "8f58fdf9-3e76-4c18-a1c5-eed0980d4133",
    "metadata": {},
    "outputs": [
@@ -403,8 +403,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1\n",
-      "EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0\n"
+      "EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1\n",
+      "EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458\n"
      ]
     }
    ],
@@ -424,58 +424,27 @@
     "{\n",
     "    if (stardata->model.time < stardata->model.max_evolution_time)\n",
     "    {\n",
-    "        if(stardata->pre_events_stardata != NULL)\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
-    "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->pre_events_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "        Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
+    "            \"%g %g %g %d \" // 2-5\n",
+    "            \"%d %d %g %g \" // 6-9\n",
+    "            \"%g %g\\\\n\", // 10-13\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->pre_events_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[ID_core(stardata->pre_events_stardata->star[0].stellar_type)],           // 9\n",
-    "\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
-    "        else\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
+    "            // \n",
+    "            stardata->model.time, // 1\n",
     "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->previous_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "            stardata->star[0].mass, //2\n",
+    "            stardata->previous_stardata->star[0].mass, //3\n",
+    "            stardata->common.zero_age.mass[0], //4\n",
+    "            stardata->star[0].SN_type, //5\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->previous_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
+    "            stardata->star[0].stellar_type, //6\n",
+    "            stardata->previous_stardata->star[0].stellar_type, //7\n",
+    "            stardata->model.probability, //8\n",
+    "            stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
     "\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_He]    // 11\n",
+    "        );\n",
     "    };\n",
     "    /* Kill the simulation to save time */\n",
     "    stardata->model.max_evolution_time = stardata->model.time - stardata->model.dtm;\n",
@@ -491,6 +460,14 @@
     "# print (abridged) output\n",
     "print(\"\\n\".join(output.splitlines()[-2:]))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "484297c0-accb-4efc-a9c8-dbd2f32b89a6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/build/html/_sources/notebook_extra_features.ipynb.txt b/docs/build/html/_sources/notebook_extra_features.ipynb.txt
index b1a9ddb030195e6aaf0da2cf08eecc67684672a6..076b4098e7c588a68fb91cfe6175c3ee4e36ea78 100644
--- a/docs/build/html/_sources/notebook_extra_features.ipynb.txt
+++ b/docs/build/html/_sources/notebook_extra_features.ipynb.txt
@@ -5,7 +5,7 @@
    "id": "d5c04b77-f0be-4b33-8c03-c72eb846527c",
    "metadata": {},
    "source": [
-    "# Extra features and functionality of binarycpython\n",
+    "# Tutorial: Extra features and functionality of binary_c-python\n",
     "In this notebook we'll go over some of the extra features and functionality that was not covered in the other notebooks.\n",
     "\n",
     "Within the module `binarycpython.utils.functions` there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the `help()`"
diff --git a/docs/build/html/_sources/notebook_individual_systems.ipynb.txt b/docs/build/html/_sources/notebook_individual_systems.ipynb.txt
index 21d49016f3b2826d6f9d5ec87a1f6d8bb18df7af..85aef1e3962a1626f37a9ef36bf5e16f479eb68e 100644
--- a/docs/build/html/_sources/notebook_individual_systems.ipynb.txt
+++ b/docs/build/html/_sources/notebook_individual_systems.ipynb.txt
@@ -5,7 +5,7 @@
    "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
    "metadata": {},
    "source": [
-    "# Running individual systems with binarycpython\n",
+    "# Tutorial: Running individual systems with binary_c-python\n",
     "This notebook will show you how to run single systems and analyze their results.\n",
     "\n",
     "It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc. "
@@ -566,7 +566,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -580,7 +580,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/html/_sources/notebook_luminosity_function_binaries.ipynb.txt b/docs/build/html/_sources/notebook_luminosity_function_binaries.ipynb.txt
new file mode 100644
index 0000000000000000000000000000000000000000..c6b5f1e64cc36c684fdf5cefe0fae4b450a1c936
--- /dev/null
+++ b/docs/build/html/_sources/notebook_luminosity_function_binaries.ipynb.txt
@@ -0,0 +1,701 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 4*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "\n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][int(nstar)][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 256 stars\n",
+      "with a total probability of 0.6149734610296649\n",
+      "Total starcount for this run will be: 256\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
+      "\n",
+      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
+      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
+      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
+      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
+      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
+      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
+      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
+      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
+      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKsAAAJgCAYAAABFgeDFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzdd3hTdRfA8e/NarpbWtpCmWXvsldZhbJRloCoiMgSQVS2r4rIkKkCIqAiQxFERJC995BZ9t6jpVC6Z9b7RyQS2rIhBc7neXg0d57c3LTNyfmdn2KxWCwIIYQQQgghhBBCCJENqBwdgBBCCCGEEEIIIYQQt0mySgghhBBCCCGEEEJkG5KsEkIIIYQQQgghhBDZhiSrhBBCCCGEEEIIIUS2IckqIYQQQgghhBBCCJFtSLJKCCGEEEIIIYQQQmQbkqwSQgghhBBCCCGEENmGxtEBPA9iYpIwmy2ODuOl4ePjRnR0oqPDECJLco+K7E7uUZHdyT0qsju5R0V2J/eoeB7c6z5VqRS8vV2z3FeSVQ/AbLZIsuoZk+stsju5R0V2J/eoyO7kHhXZndyjIruTe1Q8Dx71PpVhgEIIIYQQQgghhBAi25BklRBCCCGEEEIIIYTINiRZJYQQQgghhBBCCCGyDUlWCSGEEEIIIYQQQohsQ5JVQgghhBBCCCGEECLbkNkAhRBCCCGEEC+MlJQkEhNjMZmMj3yMqCgVZrP5CUYlxJMl96jIrlQqNRqNDnd3r8c6jiSrhBBCCCGEEC+ElJQkEhJi8PLKiVarQ1GURzqORqPCaJREgMi+5B4V2ZHFYsFsNpGWlkJMTBQuLmpA/UjHkmGAQgghhBBCiBdCYmIsXl450emcHjlRJYQQ4tEoioJarcHFxR0vL19u3rz5yMeSZJUQQgghhBDihWAyGdFqdY4OQwghXnparRNpaemPvL8kq4QQQgghhBAvDKmoEkIIx3vcn8WSrBJCCCGEEEIIIYQQ2YYkq4QQQgghhBBCCPFEWSwWR4eQJUfH5ujzPw8kWSWEEEIIIYQQ2Vjv3t0JCalk969eveq0a/cq338/kbS0tHvuv3//XkJCKnHwYPizCfgJiIi4luE53/1vxYqlGfb79NOBhIRUYvHiPzM97u1r+f773bI8d69eXQkJqcSMGdPtlm/btpm+fd+jceO6hIbWoH37lkycOIGYmFv3fC4zZkynTp2qD/CsH1/bti0YPXr4MznXne5+jkeOHGLgwA+fyrl69+5O3769bI9DQioxa9ZPD7z/8uV/89133z7182Tl7mtz+15fvXrFYx/7RaJxdABCCCGEEEIIIe6tRImS9O07wPY4PT2N8PD9zJr1E9evRzJs2FdZ7lusWHGmTZtJUFDQswj1ifDx8WXatJkZllssZr766ksiIyMpXryE3bq4uFi2b99KoUKF+fvvRbRs2SbTYyuKwuHDB4mOvomPj6/duqio6xw+fDDDPsuWLWbMmJG0atWWdu06otfrOXfuLHPnzmb79i389NMveHh4PMYzfjJGjRqHq6vbMz9vixYtqVatpu3xsmVLOH/+3DM597RpM/H393/g7efM+ZmyZYPvu12/foOfSg+8u6/N7Xs9T568T/xczzNJVgkhhBBCCCFENufi4kbp0mXsllWoUIkbN6JYtmwJffr0w9fXN9N9XV0z7pvd6XS6TGP+/vuJXLp0kUGDPiUoqLDdujVrVqHT6ejZsw8DBvTl+PGjlChRKsMxihcvwdmzZ9i8eSOtW79mt27jxnUULBjExYsX7JbPnj2TRo2a8vHHg2zLKlasTLlywXTp8ibLli2mY8dOj/GMn4yiRYs75Lx+fv74+T14wuhJelr3dsGCzya5m9W9/rKTYYBCCCGEEEII8ZwqWrQ4FouF69cjAeswsMmTv6FPnx6EhtZkwoQxGYYBzpgxnbfeaseGDevo2LENoaE16NHjHS5dusD27Vt566121K9fk+7dO3P69EnbuUwmE7/8MpO33mpHaGhNGjQI4b333mX//r22bWbMmE7Hjm2YMWM6jRvXo1WrpkyaNIEGDUJITk62i33atO949dVGGI3GB3quW7Zs4rfffqFJk+a0aNEyw/oVK/6mcuVqVK1aHV/fnCxZsijT47i4uFGlSjU2blyXYd369WsJDQ3LsDwmJhqLxZxhedGixend+0OKFy/5QM8BMh+qt2LFUkJCKhEVdR2AkSO/YODAD/nzzwW0adOc+vVr8vHHvYmOvsmyZUto0+YVwsJq0bdvLyIirmV67NvDyzZv3sAnnwwgLKwWTZqEMmbMSFJTU237GI1GFiz4jTfftL6ur732KrNnz8BkMtm2uXr1CoMGfUTTpvWpX78mPXq8w86d22zr7xwGOHLkFyxbtoTIyAjbcM2uXTtlOvSyR493+PTTQRmW3xYZGcknnwygUaM6vPJKI+bP/zXDNncPz1uwYJ7tvm7Zsgnjx48mKSnRdn2uXr3CypXLCAmpRETENVasWEpoaA0WL/6TFi0a0rRpfa5evZJhGCBAYmIiQ4cOoUGDEF59tTHTp0+xu38zGyp4v2uT2TDACxfOM2RIP5o3DyMsrBb9+n3AmTOnbetvv6f3799L3769qF+/Jq+80oipUyfbvW7PM0lWCSGEEEIIIcRz6vLliwAEBuaxLVu4cD6lS5flq6/G06RJs0z3i4yM4Icfvqdr1/f47LMvuXLlEgMGfMjkyV/TqVMXhg0bxfXrEQwf/rltn++/n8icOT/TsmVbJkyYxMCBnxIXF8vnnw+2S35cvXqF3bt3MXz4V/Tp8zEtWrQiNTWVzZs32LYxm82sWbOShg2botHcf8BPRMQ1Ro0aRqFChenff3CG9adPn+T06VM0btwUlUpFo0ZNWb9+jS1JcbfQ0DAOHQq36zcVGRnB8eNHadCgUYbtq1WrwerVK/nkkwGsX7+Gmzdv2tZ16PAmFSpUuu9zeFjh4QdYsWIpH388iI8/HkR4+H769OnBwoW/88EHHzFw4P84duww33wz7p7HGT16BLlzB/LVVxPo2PEtli1bzC+/zLxj/XCmTp1MaGgDxoyZQOPGTZk580fGjh0JWF+rgQM/JDU1lc8++5LRoyfg6enJ4MH9uHr1Sobzde7clZCQ2vj4+DBt2kyqVw+hadMWHDoUTmRkhG27S5cucvToYZo2bZFp3CkpKfTu3Y1z584wcOCnfPTRAJYtW8KRI4eyfK5r165i6tRJtG79GhMmTKZz566sXr2CiRMnANZhkn5+/lSvXpNp02bahoEaDAYWLpzPJ598Tp8+H9m9n+70xx/zMBqNDB8+hlat2vLbb3P49tvx97z+97s2dzt79gzdunXi5s2bDBgwhE8/HUZcXCzvvfduhqGVX3zxP8qXr8C4cRMJC2vE3LmzWbkyYy+355EMAxRCCCGEEEK80M5di2fp9vOkpj9YxYGiwNOYrEuvU9OiZkGCcj9KbyOLXQVHXFwsu3btYPHiRdSr1wAvLy/busDAPPTo8b7t8Z2VT7elpKQwcOAntiRLePh+/vxzARMnTqVixcoAXL58mSlTviU5ORkXFxdu3rxBjx7v06ZNO9txnJx0/O9/Azl//qxtyJ3JZKJPn4/thjaVLFma1atX0KRJcwD27dtDVNR12+N7MRgMfP75YMxmM8OHj8HJSZ9hm+XLl+LtncPWN6lp0xbMnTub1atXZhjqBxASUhu1Ws3mzRttva02bFhLkSLFMu0dNHDgp1gsFrZs2cSWLRsByJMnLzVr1qZDhzfImdPvvs/jYSUnJzF8+Ghy5w4EYPPmjezYsZXff19M/vz5MBrNHDlyiHXrVt/zODVr1qJ37w8BqFSpCnv2/MOOHVvp1u09zp07y6pVy+nVqy8dO74FQOXK1dDr9UydOpn27Tvi6enFxYsXePvtrlSvbr2+JUqUZubMHzJt7h8YmAcvL2+02v+Gt4WFNea7775l9eoVvP32uwCsWrUcHx8fqlatnmncK1YsJSrqOnPm/E6BAgUB633UoUOrLJ9rePh+cuXKTevW7VCpVJQvXxEXFxfi4+MAayWcVqvFy8vb7v60WCx07tw10+TRnQoWLMSIEWNRFIXq1WuSkpLC/Pm/8u67PfD29r7nvlldm4iIFLttZs78Eb3emUmTpuHs7AxYX5P27VsyY8Z0RowYY9v21Vdb07lzV8A6LHjLls1s376N5s1b3jeW7E6SVUIIIYQQQogX2tq9lzl4NtrRYQDg7KSh+ysZ+yjdz759e6hbt5rdMrVaTa1adTJUGhUpUvSBjlmqVGnb/3t75wCsyYDbPD09AUhMTMDFxcXWxD0mJoZLly5y5coltm/fClgTSveKoVmzV5gwYTQ3b97A1zcnq1Yto3jxkgQFFbpvnFOmfMvx48cYPnw0+fLlz7DeYDCwdu1K6tVrQEqK9YN/jhw+FCtWgiVLFmWarHJxcaVq1eps3Ljelqxav34tDRo0zDQGDw8PRo4cR0TENXbu3M7+/Xs4cGAfv/8+l6VLF/PNN1PsrueT4O2dw5aosj6nHHh5edlV/Xh4eJKYmHn12G1lypSze5wzpx9RUVEAHDx4AICwMPtqsoYNmzB16mQOHNhP69avUaBAEGPHjmD37p1UqVKdatVq0KfPxw/8XNzd3alduy5r1qzk7bffxWKxsHr1Cho2bIparc50n0OHDpAnT15bogrA3z+AUqWy7u9UoUIllixZxLvvvknt2vWoXr0mYWGNH6hRepEixe67Td26oXbHqlWrDnPnzubYsSPUrFnrvvs/iIMHDxASUtuWqAJwcXEhJKQ2W7dustv27tfWz8+P1FT75NfzSpJVQgghhBBCiBdaWKW8pKYZs0VlVVjlR5vxq0SJUvTrd7u3j4KTkxO5cuVGr89YZeTs7HLf46nV6kwrlO78gHy3EyeOMWHCaI4fP4Zer6dgwSD8/QMA++tlPbaT3b4NGjRk0qQJrFmzipYt27Blyybee++D+8a5adN6Fi78nXbtXqdevQaZbrN9+xbi4uJYvPhPFi/+M8P6I0cOZ9rAul69MEaOHEpsbCxJSYmcOnWCkSPvPaTOWrXzGq1bv4bZbGbr1k2MGjWMiRPH88MPs+77fB6Gi0vG11Gvz/r1ycrd94hKpbL137pdcXQ7WXnb7cdJSYkoisK3305h1qwZbNmykVWrlqPRaKhdux79+w954FkQmzVrwUcfrebEiWMkJydz/XpklkMArbHF4+WVsVrJx8eH2Ni4TPepX78hZrOZv/5ayKxZPzFjxnRy5cpNz559qF8/Yy+yO93r3r8tRw4fu8d3XqcnJT4+LsN5bp/r7sTk3e9hRVEwm5/CDy8HkGSVEMLhTDcvkvbPAlSeAThVaYuie/hfwkIIIYQQWQnK7UHf18rdf8N/aTQqjMaMzbQdycXF9aGaeD9pSUmJ9OvXh8KFi/HLLwvIn78AKpWKnTu3sWnThvvu7+rqRt26oWzcuBZ/f39MJlOmvaHudPXqFb766kvKlClLr159s9xuxYql5MmTj4EDP7FbbjIZGTToY/7+e1GmyaqQkFqo1Rq2bt1EbGwMpUqVISAgIMN2mzatZ/z4r/j++xl2lV0qlYo6dUIJDz/A8uV/3/sC3MGaULC/v1JSkrPY+ulyd7cmmmJibtkNZYyOtvbk8vT0AsDXNyf9+w+mX79BnDlzio0b1zN37my8vb356KOBD3SuihWr4O8fwIYNa0lOTqZEiZL3nHHP09OLEyeOZ1geF5d5ouq2sLDGhIU1JjExkd27dzF37my+/PJTgoPL23pUPaqEhHi7x7ev051DADO+tg9X6eTu7sGtWxkrQaOjb9pej5eBNFgXQmQDFkwRJzEcW0/Sn59jijrr6ICEEEIIIcQdLl68QFxcHO3bd6RgwSBUKutHyV27dgBkOlPe3Zo1e5UTJ47z118LqVmz9j0rctLT0/nss8FotVqGDfsqyybsN2/e5J9/dhIW1ogKFSrZ/atcuRo1atRi/fo1JCQkZNj39lDATZs2sHHjeurXz3wIYMGChYiLi2PBgnmZrr98+SKFCt1/OOOd571+/brdskOHwh94/ycpOLg8AGvX2ve9ut0Hq2zZYI4dO0KLFg05fvwoiqJQpEgxunfvRVBQIdvshXe7fX/cvaxp0xZs3ryR7du30qRJ1lVVAJUqVebq1ct2M1LGxsZy9OiRLPf54ov/MWRIfwDc3NwIDW1A587vYjKZbAmgzGJ7UP/8s9Pu8caN63FycqJECesQUFdX1wzX5PDhg3aP73f+4OAKbN++1S7JlZKSwvbtWylbNviRY3/eSGWVEMLh1L4FUAeWxHT5EJaEGyQvGYWucit05ZqiKJJTF0IIIYRwtHz5CuDq6sqsWT+hKKBSqdm0ab2touhBqkfKl69IQEBuwsP3M27ct/fcdvr07zh16gQ9evQmKirK1mPpTt7e3mzatP6eVVqNGzdj06b1rF69nLZtO2RYHxragJEjv8BisWQ5zDB//gK8/vqb/PbbL1y/HkHDhk3w8/MnJuYWq1evYP/+vXz77ff3ff631agRwq+/zuKXX2ZRqlRptm3bzL59GZvgPwtBQYVp1KgJP/74PWlpqZQuXYYjRw4zZ87PNGrUhIIFgzAYDDg7OzN8+Od06dKdHDl82Lt3N6dPn6JDhzczPa6bmzu3bt1i587tFClSDF9fa0VTkybNmTXrJ7Ra7X0r6xo1asYff8xn0KCP6dHjfVxcXJg9+2fM5qyH81aqVJnRo0fw3XffUr16TRIS4vn55x/Ily8/QUGFbbGdOnWSAwf2UbLkw/WPO3r0MOPHf0W9eg3Yv38vf/75O++80w03NzcAatSoxZo1qyhevCR58uRl5cqlXL16+Z7X5m7vvNON7t3fpm/f93jjjU4AzJ07h5SUZFsz9ZeBJKuEEM+c6dZljGd2oavc1tag0LnxhxgOrSZtz0Iwm0jfvRDTlaPo63VH5Xr/mTWEEEIIIcTT4+bmxldfTeD77yfx6aeDcHFxpUiRYnz33Q/079+XQ4fCbTPFZcU6g1oNNm/eSJUqmc8Ad9vJkycAa9IqK02aNOfYsSMULlyU/PkLZLpNtWo18PLyZsmSRZkmq2rWtM4KWLJkaVtCJTO9evWlWLGSLFu2mIkTx5OYmIi7uwflypVn+vRZD9zUHqBTpy7Exsby229zMBqN1KhRk8GDP2Pw4AdvWP4kDRkylMDAvCxf/jdz5vyMv38AXbp0p2NHa6JEq9Xy9dffMW3aZCZOnEBiYgJ58uRl4MD/0ahR00yP2aRJc7Zv38KQIf3o3r2X7Vi5cwdSoEBBChYsdN9eV1qtlokTpzFp0gS++WYciqLwyiutyJ07MMuhgM2btyQtLY2//vqTv/76AycnPZUqVaFXr762Ru4dOrzBt9+Op1+/PkycOPWhrlXnzt04duwwAwZ8iJeXFz179rHNogjQp89HGI1GpkyZiFqtpkGDhvTs2Ztx477K8trcnSQtVKgwU6b8xPTp3zFixFBUKhXlypVn2rSZFCpU+KHifZ4pFsvTaB34YomOTnxhmpQ9D3LmdOfGjYxluuLFYDi5ldRtv4ApHaeQt9GVrGe33nTjAikbpmKJs5bPKk5u6Ou+iyZ/eUeEmym5R0V2J/eoyO7kHhVPS2TkRQICMs4W97CyY8+qF4HZbKZjxzbUq9eAHj3ed3Q4z7Xn9R6NiLhG+/YtmTBhEpUrV7v/DuK5FhV1GT+/zCeVUKkUfHzcstxXKquEEM+ExZhG6rZfMJ7aZl2gKFjSMzaSVOcsgGvrYaRun4vx1FYsaYmkrJ6Itkwj9NVff8ZRCyGEEEKIx5WYmMiCBb9x5MhhbtyIonXr1xwdknjGTp06wbZtW9iwYR1BQYWpVKmqo0MS2Zwkq4QQT50p9hqpa7/HHHMFAMXZA31oTzSBmc9oo2j1ONd9F0OeUqRunQ2GFFSuOTLdVgghhBBCZG96vZ4lS/7EYoFPPhlqN+uceDmkp6czf/5c/P39+fzz4bZWIEJkRZJVQoinynBmF6lbZ4EhFQB1rmLo67+HysXrvvtqC1dD7VcIw/GNaMuE2ZbfHr0sv+SEEEIIIbI/jUbDkiWr77+heGGVLl2WNWs2OzoM8RyRZJUQ4qmwGNNJ2zUfw7ENtmW64OboKrVCUantt7VYOHr+FgAFcnng5qy1rVN55MSpaju77Y2ntmG8eAB97S4o+qzHOQshhBBCCCGEeP5IskoI8VSYrh79L1Hl5IpzvR5o8pXNdNv9p24w5a8jtsd+3s4E5fKgYC4PCub2IJ+fGzqtNcFljo0kdfuvYEwj6cZ59PW6o8ld4qk/HyGEEEIIIYQQz4Ykq4QQT4Umf3m0Jepiir6Mc4NeqNx8stz2Zlyq3eOomBSiYlLYdcw6I6BapZAnpxtBuT0onFNDMb8SaK+FY0mKIWXZWHTBzdBVaomikh9pielJqBQVLlpnR4cihBBCCCGEEI9EPtkJIZ4Ii9mIKfK0XZWTU/WOoKhQ1A/+o6ZptfxcuZHI+Yh4EpINAJjMFi5eT+Di9QQ2AlCGOi7OtNDvQYuR9PBlpF4+intYL1QeOZ/sE8uGLBYLt1JjiUyOwtvJk9xuASQZkvly1zgSDUm0KdKC0Ly1ANh3/SBlfEuiU2vvc1QhhBBCCCGEyB4kWSWEeGzmxGhS1n2P+cZ5nFsMRhNQFABFo3voYzWrnh9nJw0Wi4XouFTORcRzPiKe89fiuXA9gXSDGVDYnFyEE6k56ey2hdyaWFTR54me9wn/uDdAKViVgrk8KBDggYv++f4xZ7FYOHjjCJHJUQS65aKMb0lMFhNf7BqD2WImLF9dWhZuiovGGZPFBEBkUhRmi5nFZ1ew/tIWgnOW5t3Sb6JSVA5+NkIIIYQQQghxf8/3pzghhMMZLx0iZeN0SEsCID18BZrGRR/7uIqi4OvljK+XM1VK+ANgMpu5djOZ8xHxnLsWx7lrbnx9sxktnPdRR38CvWKgTuJKdu89yddJNTCjIpePi7X3VS4PgnJ7kCenG1pN9kramC1mWyJp1YX1XEq4SgGPvDTMXw9FUfj91GLi0xOoGlCRMr4l0ag05HT25XpyFJHJUYD1etXPWwetWkOQZwHMFjOX468CcDbuAjGpsfg453DYcxRCCCGEEEKIByXJKiHEI7GYTaTv/Yv08GW2ZdqSoThV6/DUzqlWqcjr50ZePzdql8sNQFq6iYvXK3PsxB6CLixCb0nBgoIZa/InIjqZiOhkdhyJBECjVsjr505Qbg9rE/fcHvh5O6NSlKcW922J6UkkG1Pwc/EF4Nfjf3Di1mmCPPPTpfQbAIRHHeZy4jXSjGk0zF8PgAAXP+LTE0gwJNqO1aZIc7QqDQGu/rZlTQrWtztftzKdmHviD1oXbi6JKiGEEEII8UKwWCwoz+Bv90fh6Ngcff4nSZJVQoiHZk6OJXX9VEwRJ60LNE7oa7+DtnC1Zx6Lk05N0bxekDcMc1Il0vf+RZVybcl5M91agfXvEMKkVCMARpPFOqwwIp71/x7DxUlDwVzuFMz9bwVWLg883ZweOabYtDiuJUZiMBspl7MUAFMOzuBY9EkKeRbg44q9AIhLjycmLZaIJL1t3wDXAFJNaeTQe9mWvVmiHS5aPc6a/5qml/Ipft84XLTOdCvTyfZ429VduOvcbTEJIYQQ4vlx9uwZ5syZwYED+4mPj8PT05Ny5Srw1lvvUKTI41e1P0srVixl1KhhLFq0HD8///vv8ISFhFS65/p33unGu+/2sFv23XffMn/+r7z5Zmd69uydYZ+RI79g5cpl+PsH8OefyzKsBxg+/DNWr15JkybN+d//vrAtP3gwnLlzZ3P06CGSk5Px9s5B5cpV6dSpC4GBebKM81lex969u6NWa5g48funep673f0cL1w4z5gxw5k69ecnfq6RI7/g0KFwfv99MQBt27agUqUqDB782QPtv337VjZsWMtnn335VM+TlcyuTUhIJbp27Unnzl0f69iOIMkqIcRDMV49RuqGaVhS4gFQeedBH9YLtVfuRz6mxfJkYlO5eqOv0wU9UM4LyhX2xXT9DGn715NQriPnYxRbD6yLkYkYTWYAktOMHL0Qw9ELMbZj5fBwsg0dDMrlQf4Ad/S6jD8yz8Se50zseYxmA82DGgGw4NQSDt44gq+zjy0x5KnzALAN2wMo4V0EZ7WeQLdctmVvl2yf4dsQH2fvx742K86vZfn5tWhVWj6s0IMCHvke+5hCCCGEeDbOnDnNe+91oUyZcnz00QC8vLy5cSOKP/6YR48e7zBp0jRKly7j6DCfG9Omzcx0+dSpkzh0KJyyZcvZLTcajaxZs5JChQqzYsVSunbtiUaT8e9CRVG4fj2SY8eOULJkabt1aWlpbN26JcM+u3fvYsCAvtStW5/Bgz/D1dWNq1ev8Ntvc+je/W1++GH2PRNWz0q/foMdUrFTvXoI06bNxNvbOkpg06b1HD586Jmce9Socbi6uj3w9gsWzMNkMt53u86du5KcnPQ4oWUqs2szbdpM/P2ffUL4SZBklRDigRmvHCVl5XhbdklTNAR9yFsomkevQnqaLOnJpGyYjiXhBq43RlGpzrtUaxAMgNFk5uqNJFvl1fmIeK7dTOJ23uxWfBq34m+w71QkWNQoCvjmi0HjG4HeBToVepvAnK7sux7Olqs7cVLraFawIYqiEODix0EgOuUWBpMBrVpLBb+y+LvkJMDVz1aeG5qvdoaYn9YfAXndA1FQcFLrnlhyUAghhBDPxoIFv+HtnYNx4yaiVqtty0NC6vDGG22ZPfsnxo2b6MAIny+ZJfYWLfqDgwcP0KlTFypXth8tsGvXdmJibjF8+Bjef78rW7ZsIjS0QYZj5MqVm/T0dDZtWp8hWbVr1w7UajX+/gF2y3/9dRZlypRj2LBRtmUVKlSievWatGvXkvnz59Kv36DHebpPRMGCQQ45r7e3N97ej//F7aMoWvT+IxkexbNMPj7PSWxJVgkhHpg6dzFUfoUw37yEPuQttMVqOTqk+1BQBxTFmHADS2oCKau/RVuqAU5V26HR6Mgf4E7+AHfqlQ8kMT2JS3GRKMk5OB8Rz/6b+4jQHMSiSSN1bwMsFhUxhlto1ZcgDYbN2YlWpcMnKA28QGXRcjE6mvw+PlQNqEAx78IEuPqhUVl/zJb0KUZJn2IOuxJlfEvydskOFPDIR04XH+DFGtMuhBBCvMhiYm5hsVh/d9/JxcWFDz74mNTUVLvlmzdvZPbsGVy4cA53dw8aNmxCt27vodP9N1PzkSOH+emnqRw7dhSdTkfVqtXp3ftDWwVLVNR1pk+fwr59e0hIiKd48ZJ07dqT8uUrAhARcY3XXnuFkSPHsnr1Svbs2YVGo6Vu3fr07dsPvd7a5sBsNjNnzs/8/fdfxMXFUqVKNcqVK5/hOS5e/Cd///0Xly5dwGy2UKBAATp16kLdutaenCtWLGX8+K/44IN+zJgxHZPJxLvv9uCbb8by+++L7RIAixf/yaRJE1i8eCUeHp73vb7Hjx9l8uSvqVixMl279sywfvnypRQrVoJy5YIpWbI0S5YsyjRZpSgKdevWZ+PGDfTq1ddu3YYNa6hTpx4HDuyzW37r1i08PDwyHMvXNycffzwADw+v+8Z/W2ZD9fbv38sHH/RkypSfKFcumBkzprNp03reeac7P/00lcjICIoUKcb//jeUy5cvM23aZK5du0qhQkUYMGAIRYoUy/TYISGV6N9/CMeOHWHLlk2YTCaqVavBxx8PtN1DAKtWLWfBgt+4dOki7u4e1K/fkG7deuLkZL0/YmJimDRpAvv27SExMZF8+fLTvn1HmjRpDtgPA1y6dDEzZ/5oO/8773Tj/PlznDhxjD/++Nvu79qhQz/h6tUr/PTTnEyvVXx8PN999w1bt27GYrHwyiutMJvNdtvcPTxv7dpV/PrrbC5fvoSLiwtVqlSjV68P8PXNSe/e3QkP32+LbdKkaQB88EFPBgz4hNmzZ5CUlMiYMd+wfPnfdsMAAQyGdMaP/4q1a1eh0WioVy+MXr364OLimmksD3Jt3n23R4ZhgE/qff0sZK8psYQQ2Y7FkGb7f0Wlwbl+L1xaffYcJKpA0TnjXK8b+tAeoLX+YI09vp4Dy4ex7uQyDCYDAJsub2fQtmFMOTydPLm0NK2Wn3oVAkGXgqIy06lFPppVz0+gWwCkuWCKyQlqIwajmcgzOUjZV59bu2rx5U+H6DtpG78tj+D4URUXr6STkGJw5CWwUzmgvC1RtePaHiaH/4jBfP9SZSGEEEI4VrVqNYiIuErPnl1YtOgPLl68YFtXr14D2wd7gDVrVvG//w0gKKgQo0aNp1Ond1iyZBHDhv3Pts2pUyfo06c7ZrOZzz4bxkcfDeTgwQMMHPgRADdv3qRbt04cO3aEXr36MmzYVzg56fnww17s27fHLrbRo0eQO3cgX301gY4d32LZssX88st/w+y+/34SM2f+SIsWLRk1ajweHp5Mm/ad3TH++GM+33wzlrp1Qxk79luGDh2OWq3hiy/+x40b/7VQMBgMLFw4n08++Zw+fT4iLKwxOp2ONWtW2h1v1arl1KhR64ESVQkJCXz++RA8Pb344ouRqFT2H5FjYmLYuXMbjRo1BaBp0+bs37+HK1cuZ3q80NAGRERc5cSJ47Zlqamp7Nixjfr1G2bYvlq1Ghw6FE7fvu+xYsVSrl27alvXvHlLateue9/n8LAiIyP44Yfv6dr1PT777EuuXLnEgAEfMnny13Tq1IVhw0Zx/XoEw4d/fs/jTJs2GYDhw7+iV68P2L59K999941t/YwZ0xk58guCgyswatR42rfvyJIlixg48GNb4nX48M+4cOEc/fsPYfz4iRQtWoyRI79g//69Gc7XokVLXn219b/nnkmLFi1p1qwFkZERHDx4wLZdUlIiW7dutntf3MlsNtOvXx927txO794f8umnX3D48EHWr1+T5XM9dCicESOGUrduKBMmTKJPn4/Yt283w4Z9CliHSZYoUZKiRYsxbdpMihX7rypr1qyf6Nu3Hx9+OCBDxd1t69at4cKF83z++Qjeeacbq1ev4PPPh2QZz4Ncm7s9yff1syCVVUKITFksFgyHV5F+aDUuLT9H5Wb9hsT63+djZrmbKdHsvX6QyLQoXm0xEN22XzmVfJXf3Q1wdQuFU03kL/sKvnfMlBeZFIW7zo187nmp4FeWAFd/gnP741XKkzYUwmxpjgGFvUcibI3aL11PxPTvAMLEFAOHz0Vz+Fy07Zi+nnq72Qfz+bvjpFVniPdZ2R91iLkn/gBg/olFvFWyncNiEUIIIZ4Vw8mtGE5tu+922qIhaErVsT1O3TEXc/Sl++7nVL0jat/8tsfJS7/K9NiP8oVf69btiI6OZv78uXz99RgAvLy8qVq1Gm3bdqBECWuPTIvFwrRpk6lRoxaffjrMtr+fnz9DhvT/tx9TMHPm/Iy3dw7Gj59kq7by8PBg3LhRXLlymSVLFpGQkMgPP8y2DVurUSOEzp1fZ+rUyXbVKjVr1qJ37w8BqFSpCnv2/MOOHVvp1u09EhISWLhwPq+//hbvvNMNgKpVq3Pz5k3++WeH7RgREVfp2LETnTp1sS0LCMjNu+++yeHDh2xVTBaLhc6du1K9eohtu1q16rB69Urb8S9fvsSRI4cYO/bbB7q2o0Z9QVTUdSZNmm5XEXTbmjUrAAgLawxA/fqNmDTpG/7+e1GG6imAMmXKkTOnH5s2rad48RIA7NixDb3emQoVMjZ27969F0lJSaxY8bctYeDn50/16jVp374j+fIVeKDn8TBSUlIYOPATWzzh4fv5888FTJw4lYoVKwNw+fJlpkz5luTkZFxcXDI9TuHCRfnkk6EAVK5srVDbsmUTAPHxccydO5tWrdrywQf9AKhSpRo5c/ozdOgQdu7cTo0aIYSH76dz5662pFxwcAU8Pb3QarUZzufn50/OnH7Af8PbfHx8yZnTj9WrVxAcXAGADRvWARbCwhplGveuXTs4fvwoEyZMpmrV6gBUrFiF115rkeU1O3gwHCcnPW+88fYd7xlPTpw4hsVioWDBIFxc3DCZjBmG3rVu3Y46dUKzPDaAl5cXEyZMslWcaTQaxo8fzenTJ23VbfeS2bW52++/z30i7+tnRZJVQogMLGlJpG76CeNF6zcUqZt+xLnZwGw3ZCzNlI4KBa1aS0TSdZadW01kUhRvl+xAPo883Ey5xdJzqwCoGlCB4q98Qu5/5kLKUQCuHlmB//VL5K3RnpaFmhLg6metngLyuufm3dJvZjinSlHIk9MdpzJQs4y1MbrBaOZyVKJ19sF/+19F3kq27XMzLpWbcansPh51xzFc7WYfzO3rikr1bK5vGZ8SBHkW4HpyFDVyV3km5xRCCCEczZxw87+ZjO9Bncu+T405+tID7WdJT7Z7nNk+dx/7QSmKQvfuvejQ4U3++WcH+/btYf/+vaxevZI1a1bx4YcDaNOmHZcuXSQq6jqdO3fFaPyverpKlepotVr27PmHsmWDOXToICEhte2GBVauXJUFC5YA1uRF2bLl7PorqVQq6tdvyE8/TbNrDl2mjH0z8pw5/YiKsv7Nc/ToYYxGIyEhdey2CQ1tYJesup3MSEhI4OLFC1y9etlWWWM02lep3/3BvVmzV1m/vjdHjx6hVKnSrFq1HB8fH1sS4l7mz/+VrVs306tXX8qVC850mxUrllK5clXUajUJCQmAtRpqxYpldOvWK0NS5fZQwE2b1ttmDdywYQ1169a36zd2m06nY9Cg/9G1aw927tzO/v172b9/L0uWLGLFiqV8+eVX1KpV977P5WGVKvVfhc/tJN2dVT+entaqtMTEhCyTVXe/9n5+/qSmpgBw9OgR0tPTadDAPmFUr159RozQcuDAPmrUCKF8+UrMmDGdU6dOUq1adapVC+H99zMmAbOiVqtp3LgZf/21kI8+GohOp2PlymX3rKw7ePAAOp2T3T3i7OxMtWo1OXz4YKb7lC9fgR9//J5OndpTt259qlevSZUq1aheveZ9Y3yQ2TqrVw+xJaoAQkLqMn78aA4dCn+gZNWDeFLv62dFklVCCDumG+dJWTcFS8JNABT3nDhVzThD3bOUaEgiMikKX+cceDl5Epl0nSkHf+ZWagzdy7xtm3Ev/MYRAK4lRZLPIw+5XK0zX3jq3Ek1paGoNOSv0pH3z23Ba89S3JLSMLvcwsMlB2FudR85Pq1GZa2cyu1Bfetwb5JTDZyPTOD8NWsC61xEPPFJ6QCYLRYuRSVyKSqRzeHXAHDSqskf4E7QvzMQFszlQQ4Pp6dy3bVqLT3Kvk2yIRk/l5wAxKcn4KFzf+LnEkIIIbILlbsv6lz3/9Cncve1f+zzYDPoKjr7D/SZnevuYz8sDw8PwsIa26p8Tp06wfDhnzNlykTCwhoTFxcLwNixIxk7dmSG/W/etP59FxcXm2kV0W0JCfHky5fxeefI4YPFYiE5+b/E3N09bFQqFRaLtfdPfLx19ui7G2T7+Nhfh6tXrzB27Cj27duNVqslX74CFC5cBMjYp8vZ2dnucaVKVfDz82f16uWULFmKNWtW0qhR00wTQ3c6cuQw06Z9R+3a9ejY8a1Mtzlx4jhnz57h7NkzNGlSL8P6zZs3ZEjGgDUZ98cf8zh9+iSBgXnZuXM7X3/9XYbt7uTj40vz5q/SvPmrgLXX1Jdffsb48aMJCanzRP8mVKvVdomR2+6+tvfj5GQ/yZKiKLbXKyHB+trf/VqrVCq8vLxJTEwEYNiwUcyZ8zMbNqxl06b1qFQqKlWqysCBnxAQkIsH0bRpC375ZSbbt2+haNHiHD58kLFjv8ly+/j4eLy8vDIsvzvWO5UuXZZx4yby++9z+f33ufz66yxy5PChU6d3aNu2wz3jc3bOPNl3p7vfj7fju32dnoQn9b5+ViRZJYQA/h32d2w9aTvnw799jDQFKqCv8y6Kk+uzCUIxczLmNDGGaII885PfIy/RKbf4fOdoADoUa0WtwOp46Ny5lRoDwPWkKMhZipzOPvi5+OLnnBM3rTVeD50742oNw0X73y9erVpLySL1seStSuqOX3Gq2ApF9eR/FLrotZQqkINSBay/eCwWCzEJabbKq/MR8ZyPTCAt3QRAmsHEqcuxnLocazuGh6vOOnQwl7utCstVn7Ek+lG4aV1t1+mfiH3MO7mIbmU6UcqBTeCFEEKIp0lbrNYjDcHT13jjkc7n0uLB+83cS1TUdbp1e5tu3XrSvHlLu3VFixanW7defPJJfyIiruHm5gbABx98TNmywRmO5enpBYCbmxuxsTF268xmM7t27aBEiZK4u7sTHR2dYf/oaGuyy8PD0/b/93L7A/etW9F2DdDj4+PszjtgQF90Oid++mkOhQsXRaPRcP78OVavXnHfc6hUKpo0ac7SpYtp2LAJERHXaNIk6+Fct88/dOgQAgJy2YaxZWbFir9xdXXlq68mZFj35ZefsWTJokyTVaVLl8XPz5+NG9dTsGAQHh6emb4eR48eYfDgj/n88y8zzEBYoUIlOnZ8i0mTviYhIf6B+m8pioLZbLJblpKSct/9ngZ3d+uXoNHRN+1ee7PZTEzMLdu94ebmRq9eH9Cr1wdcunSBrVs3M2vWT3z99dh7JpzulDdvPsqWDWbDhnVcvXqFHDl8qFIl68o6Ly8vYmNjMkw2dOd9mZmqVatTtWp1UlNT2bdvD3/8MY9vvx1P6dLlbEM+H9Xtqr3bYmJuAf8lsayvrX2yKCXFvprzfp7U+/pZkWSVEAJLegqpW2ZiPLfbukBR41T1NbRlGj3biirFzI/HrI37mhZoQH6PvHjrvdCqtBjMBiKTrKWnLloXauSqgpeTB0W8CwGgUWkYWm2g/eEUxS5RZbdO74ZzqP1sL+bkWNK2zsapRkdU7jmf7FNTFHJ46MnhoadScet4crPZQkR0Euci4jkfYa3CunIjEZPZ+o1UfFI64WduEn7mv18a/t7O/w0fzO1BPj83tJpH738VmxbHvJOLMJgNzD42jy+rD0Gvcbr/jkIIIYR4Jnx8fFGr1Sxa9AdhYU0yVLNcunQBvV5PYGAenJ2d8fLyJiIignbtOtq2iYi4xujRw+nQ4U1y5cpN2bLB/PPPToxGIxqN9SPh4cMHGTjwQ6ZM+ZHg4Ir8+ecCoqKu4+dnrVQ3m81s2LCWEiVK2g0fvJfSpcvi5OTExo3r7IYVbd++xfb/cXGxXLp0kY8+Gkjx4iVty3ft2mE77/00bdqCOXN+Ztq07yhRoiQFCwZlua3FYmHEiKHExMQwffrPtgTf3dLT01m7djW1atXNtNdUWFhj5s37hUuXLmToK2UdChjK5s0buHjxPKGhDTL9mzpv3nykpCTzxx/zqVixSobm7pcuXSRnTr8HSlQBuLq6cv78Obtlhw6FP9C+T1qpUmXQ6XSsW7faLlG3ceN6jEYjZcuWIyrqOj17dqFPn4+oV68B+fIV4I03CnDkyGEiIq5letysKuaaNXuFb78dz9WrV2jUqMk9K+sqVqzML7/MZNu2zbYhlgaDgd27d9neD3f7/vtJHDiwlx9+mI1er6dmzVr4+fnzzjsdiYq6TvHiJVCrVZhMme5+X3v37sZkMtni3rhxHYCtD5eLiyvXr1+32+fu1/Z+1YRP6n39rEiySoiXnDk2guTV32KJs/7wU1xz4Fz/PdQBRRwQjAZvJy9i0mK5mWr9NkGlqGhftCVuOlfyuOW2bfpGibZP9NQWi5nUjT9iunoU47UT6Gu9jbZwtfvv+BhUKoXAnG4E5nSjVlnrsnSDiUvXE/9NYMVz/lo8UbH/fSN2PSaF6zEp7Dpqfb3UKoW8fm4UvN3APZcHAT4uqB4wyejl5MnbJTsw7+SfdCvdSRJVQgghRDajVqv5+OOB/O9/A+na9S3atGlH/vwFSU1NZc+eXfz55wJ69OhtS7p06/YeX389BpVKoVq1GsTFxfHzzz+QmJhI0aLWCuq33+7Ke+91YeDAj2jTph0pKclMn/495ctXpEyZcgQG5mXVquX07fseXbp0x8XFlb/+ss5COG7cxAeO3cXFhc6du/Ljj1NxctJTvnxFduzYxvbtW23beHvnIFeu3CxcOB9f35y4urqye/dOFiyYB1hn0rufwMA8lCtXnvDw/Xz88aB7brtw4e/s2LGNtm07kJaWzpEjhzNs4+rqyrlzZ0lIiM+0cgqgceNmzJv3C0uW/EWfPh9lWB8aGsaCBfO4evUKU6b8lOkxPDw86NWrL19/PYb33+9KixatyJ07kMTERLZs2ciqVcv54otR933+t9WoUYtt27YwefI31KxZi0OHwlm1avkD7/8keXh48vrrbzFnzs9oNBqqV6/J+fPnmDFjOsHBFahatQYqlYqAgFx8++14kpKSCAzMw4kTx9m1aztvv/1upsd1c7NWbK1du4rSpcuSK5f180G9eg349tvxnDp1gs8++/KesVWqVIUqVaozatSX9OgRjb+/P3/8MZ/Y2Bh8fTP/wrpy5SrMm/cLI0d+QaNGTTAYjPz22xy8vLwoX76iLbaDBw+wb9+eh+4zdePGdYYOHULLlm05ffoUP/44laZNW5Avn3XShho1Qvj111n88sssSpUqzbZtm9m3z37GxKyuzW3t27/xRN7Xz4okq4R42Tm5giENAHXeMujrdUelf7a9i26ZItAEngbgrWId8Hf3wVPnYVtfPXflpx+E2YzKMwDT1aNgSCF1wzSMV46gr/kmijbjmP6nRadVUziPJ4Xz/PcNWmKKwZa4OvdvE/fEFGuzUZPZwoXIBC5EJrAR61THzk5qCgR4UCSPJw0q5cXN+d5DB8v7laF4jsI4a6xVaOfiLpLL1c/2WAghhBCOFRJSh+nTZzFv3hzmzJlJTMwtdDodRYsW58svR1Onzn/9lF59tTWurq789tsc/vprIS4urgQHV6BHj/dtPXmKFy/BxIlT+eGH7/nss8G4u7sRElKHHj16o1Kp8PX1ZerUGUydOonx47/CbDZTvHhJvvlmSqZVRvfy1lvv4OzszIIF8/j997mULl2W3r0/ZPz40bZtRo0az8SJ4xkxYig6nZYCBYIYM+YbJk2awMGDB2jV6v5fUtaoUYtjx45kmVy67dSpEwAsXDifhQvnZ7pNcHAFnJz0eHl5UalS5pPRFCpUmCJFirJq1TJ69Hg/w/pSpcrg7x+ASqW2a2Z+t9atXyNfvvwsXDif6dO/Iy4uDhcXV0qWLMXEiVNtiZAH0azZK1y9eoWVK5exePFCgoMrMmLEGN57L/PEz9PWrdt75MiRgz//XMBffy3E2zsHr77ami5detiqyEaOHPvvTHTTiIuLxc/Pny5duvPGG29nesxateqyYsXfjBz5Ba+80sqWnHRxcaF8+QrExMTcs7LutlGjxjF16iR++mkqaWnp1K8fxiuvtGbHjq2Zbl+5cjW++GIkc+fO4ZNPrBNPlSsXzKRJ02xDHlu1asvRo4fp3/8DPv102D37wt2tZcu2JCTEM2RIP5yc9Lz2Wge7mfc6depCbGwsv/02B6PRSI0aNRk8+DMGD/74vtfmtif5vn4WFMvdHetEBtHRiZjNcpmelZw53blxI+H+G4onxhhxElPESXTlm6Moqvvv8IRN2fY3x9KtU0mPqPY53i6Zl2M/C8YLB0jdPANLmrWZoeLpb6008y1g28bR96jFYuFmXKrd7IMXIxNIN2Ysk8/t60r/DsF4uT1YxdSeyAP8enwBhb2C6FWuC2rVow8xFI7j6HtUiPuRe1Q8LZGRFwkIyP/Yx9FoVBgz+b0qsq8PPuiJj48vQ4eOcHQoz4Tco/aSk5Np1aoJ77//Ia+80srR4Yh/RUVdxs8vb6brVCoFH5+sP/dJZZUQLxlT7DXS9/+NvnYXFI11XLImVzE0DzA7ztOTfZLBmgLlcck5nNSNP2C6dhxL3HWSFw/HqUrbf3t4Pftk3t0URSGnlzM5vZypUsI63txkNnP1RpKtefvpK3FERCdz7WYSo+fuZ0CH8vh43rtCzGKxcCDqEEaLidOx5zgff4nCXgWfxVMSQgghhHgkM2f+yIUL5zhwYB8//jjH0eGIZywi4hqrVi1n164d6PV6GjZs4uiQxBMiySohXiKGMztJ3TILjGmkaZ3R18q8vPZZC9IGs2+btXzWOeTZDbnLisrVG+emA0g/uIL0vYvAbCJt1+8YrxxFX7cb8GyHST4ItUpFPn938vm7Uyc4ELPFwq+rT7Ip/BpRMSmMnruPAa+Xx88766lzFUWhc6nX+eHwHMLy1ZVElRBCCCGyvW3btnD16hX69Pn4sWdkE88fRVHxxx/zcXV1ZejQkej1jv8sIZ4MSVYJ8RKwGNNJ2zkPw/GNtmWK3i3DdK3iP4pKhVP55mgCS5CyfhqWhBuYoy/Bc3K9VIrCW42KodOqWbPnMtHxaXz1b4VVbl/XLPfTqXW8X+5d231xNvYCMakxVAoo/6xCF0IIIYR4YDNm/OLoEIQDBQQEsGLFekeHIZ4CSVYJ8YIzx0eRsnYK5uiLAChObuhDu6PJW9bBkf0nxhRpa7BuMtckO/1oUvsVwrXNl6Rum4O2SA1Uzh733ymbUBSF9qGF0WnVLNtxgbjEdMb8tp9+7YPJ5591ddjtRFV41GFmHpuH2WLGXedOsRyFn1XoQgghhBBCiJeY45uvCCGeGsP5fSQtGmpLVKn8C+PSZli2SlQBxJgj0QaeRRt4FqPZ6OhwMlB0zjiH9kCTt4xtmcVkIGXjj5hirzkwsvtTFIXWtYNoU8c6K0pCsoGxvx3g3LX4++7rqnWFf+fgiE2Le6pxCiGEEEIIIcRt2ad8QQjxxFhMRtJ2/4Hh8GrbMm3ZxjhVaYuikrf9k5C2eyHG09sxnt+DU4030Barna2HVDarXgCdRs289adJTjMyfv4BPnytHEXzemW5TxHvIDqV7ICL1pkSOYo+u2CFEEIIIYQQLzWprBLiBWSOi8Bw9N+x2zpn9A0/QF+tQ7ZNVAVpgknZ3ZiU3Y3Ra7J/U0SLxYKi1gIKGNNJ2zKT1HVTsKQlOTq0ewqrnJe3GxdDAVLTTXz9ezhHz9+65z4V/cvZElXn4y4yJXwGqca0ZxCtEEIIIYQQ4mUlySohXkDqHHlxqtERlW8BXFsPQ1uggqNDeqEoioJTlbY4NxuA4uIFgPH8XpIWfoYx8pRjg7uPOsGBdG1eEpWikG40M3HhQcJP37zvfhfjLzPxwHSO3TrJzKNzMVvMzyBaIYQQQgghxMtIklVCvAAsZhOGs/9g+be/EIC2RD1cXv0UlYefAyN7MLdMEWgCT6MJPJ0te1ZlRRNYEpe2w1HnCwbAknSLlKVfkbb3Lyxmk2ODu4fqpQPo+Wop1CoFo8nClL8Os/v49Xvuk8ctN4W9glApKsr4lkSlyK8PIYQQQgghxNORPccECSEemDkphtQN0zBFnMQpLRldyXrAvzO6qZ+Pt/jtBusARkv2TfJkRqV3x7lRXwzH1pO2az6YjKTvX4Lp6jH0oT1Qufs6OsRMVSruh06r4rtFRzCazEz/+ygGo5maZXJlur1apaZr6Te5lHCFot7WWQFTjWnoNU7PMmwhhBBCCCHES0C+GhfiOWa8eozkRUMxRZwEwHByCxazDM961hRFQVeqAS6thqLyDgTAdOMcltREB0d2b2UL+fLha2XRaVVYLDBj+XE2Hria5fZ6jd6WqLoYf5lhu8ay73r4M4pWCCGEEEKIzN05wiS7cXRsjj7/o5JklRDPIYvZTNq+JaQsH4clJR4ATdFauLQYjKJ6/t7WhbTl72iw/vxW6qhz5MWl1VC0JUNxqtIWdc4Cjg7pvkoWyEG/9sE4O6kB+GX1SVbvvnTPfdJNBqYdmkV8egJzji8gOuXeTdqFEEII8Xh69+5O3769slxfp05VZsyY/gwjenwjR35B+/Ytn8m52rZtwejRw+8ZS0hIpSz/tW3bIsM+586dISSkEq1bN8NkyjgyYP/+vbb99+3bk+l59+7dbdvmTrGxsUyaNIF27V6lXr3qNGkSSt++77F588b7PteQkErMmvXTfbd7XCtWLCUkpBJRUfduJfE03PkcDQYDkyd/w9q1q574eW6/hgcPhgMwY8Z06tSp+sD737gRxcCBHxIZGfFUz5OVzK7Ns3zfPa7nY4yQEMLGnBJP6sYfMF05Yl2g1qEPeQttsVqODewxPJ+5/swpGh36kE5232BYLBbS9/yJJqgyat/8Dowuc0XyeNG/Q3m+/j2cpFQjv284Q7rBRPMaBazDSe+iU2vpVLI90w7Nok3h5vg453BA1EIIIYQQT0bnzl159dU2GZaHh+9j2rTvKFcuOMO65cuXUrBgEBcunGfnzm2EhNTJ9NiKorBx43oqVqycYd369WszLEtNTaVXr3cB6NTpHXLnzkNiYiLr16/hf/8bwAcf9KNdu9cf8hk+edWrhzBt2ky8vZ/934HTps3E398fgJiYW/z++1w++WToUz9vixYtqVat5gNvv3//Xnbs2MZHHw2853bFihVn2rSZBAUFPW6IdjK7Np07dyU5OXvPYH6bJKuEeI4YI0+Run4qlqQYAFSeAejD3kedI6+DI3s8txusAxjNNXFC7eCIHt+dSR7j6R2khy8j/dAqnKq8hrZMGEo2a1BeMJcHgzpWYPz8A8QnG/hr63nSDGba1AnKNGFVIkdRhlUfhJeTJwC3UmPQqrS469yedehCCCGEEI8lMDAPgYF57JZFRkYwf/6v5M9fgH79htitMxqNrFmzktdff5OtWzezZMmiLJNVZcqUY+vWjXz88UBUd4yAMBqNbNmygSJFinL69H+zSW/cuI5Lly6yYMEScucOtC2vXbsu6elpzJgxjTZt2qHROPZvSW9vb7y9vR1y7tKlyzjkvH5+/vj5+T/x47q6uj2z53T3fZ6dZa9PS0KILJlirpGydLQtUaUpVBWXVkOf+0QV/NdgXRt4FtNz1mD9QVhSE0FRgdlI2q55pKz6BnNynKPDyiCPnxuD3qiAt7t1KOaKXReZt+405izGud9OVF1KuMK4vd8x/dAs0k2GZxavEEIIITIXElKJxYv/ZNSoYTRuXI+wsNp89tlgYmL+G7rfu3d3RowYypAh/alfvyYDB34EQFpaKlOmTKRVq6aEhtbgnXc6sm3bZrvjnzhxnL5936NRozqEhdWmb99eHDly2G6bnTu30bNnF8LCatO8eRhjxowgLi4203hHjRpGy5ZNMN/Ve3X06OG0bdvCVrEeHr6f99/vRv36NWnWrD5jxowgISHBbp8zZ07z4Ye9CAurRZs2zVmzZuVDXz+j0chnnw0mLS2N4cPH4OLikuG5xcTcolq1mjRq1IR//tlJZGRkpscKDW1AdHQ0Bw8esFu+d+9uDAZjhkqd269RZn2GOnXqwttvd8VgeLC/t7IaqnfnsMiIiGuEhFRi8+YNDBjQlwYNQmjVqilLlizi5s2bfPLJABo0CKF162YsWPBblsceOfILPv64D8uWLaZDh1bUq1edzp078s8/O+3OfeHCeYYM6Ufz5mGEhdWiX78POHPmtN02CxbMo2PHNoSG1qBlyyaMHz+apKT/esHeHgYYEXGN1q2bAdZ7qG3bFuzYsS3ToZf//LOTkJBKnDt3NsvrtXjxn3To0JrQ0Jr07t2d69ftX9O7h+ddvXqFQYM+omnT+tSvX5MePd5h585ttuszfPjnALz22iuMHPmF7dpPnvwNffr0IDS0JhMmjMkwDPC2jRvX0b59S1s8x48fzTKWB7k2kHEYoNFoZMGC33jzzXaEhtbktddeZfbsGXZDW3v37s7YsSOZM+dnWrduRmhoDd57rwsnThzL8lo+CZKsEuI5ofbObR3qp9LgFNIJfWhPFJ2zo8N64jLW8Dz/dGUb4fLKJyjuOQEwXT5M8p+fYbx8+D57Pnu5fFwZ/EYFfD31AKzbd4U5q05gNmc9WHP7td3EpydwPv4S+6IOPqtQhRBCCHEP06ZNBmD48K/o1esDtm/fynfffWO3zdq1q/D09GTMmG9o374jFouFTz4ZyN9/L+L1199i1KjxFClSjCFD+rN16yYAkpIS6d+/D56eXowYMZZhw0aRmppC//59bAmF5cv/ZsCADwkMzMPw4aPp3r0X27dvpU+fHqSmpmaItXHjZty8ecMuoWMwGNi8eSNhYY1RFIXw8P18+GEvXFxcGD58DL169WXHjm18/HFvjEYjYO0R1Lt3N5KSEvn88+F07dqTqVMnc+NG1ENduylTJnL8+FH69x9CUFChDOtXrFhK0aLFCAoqRP36jdBotCxd+lemxypSpDh58uRl06b1dss3bFhLSEhtnJzs+7VWrlwNtVpN797dmTXrJ44ePWJ7fiVKlKJjx7fQ6/UP9XwexOjRIyhVqgyjR39N4cJF+PrrMXzwQQ+CggoxZsw3lChRkkmTvr5nguLYscPMnz+Xrl17MmrUeNRqNZ9+OpDEROt9cfbsGbp168TNmzcZMGAIn346jLi4WN57713Onz8HWO/JqVMn0br1a0yYMJnOnbuyevUKJk6ckOF8Pj6+jB79NQBvv/0uo0aNo2rV6vj4+LJ69Qq7bVeuXEbx4iUzfT0B/vzzd8aP/4oaNWoyevQESpYszdixI7N8rmazmYEDPyQ1NZXPPvuS0aMn4OnpyeDB/bh69QrVq4fQpUt3AEaOHEfnzl1t+y5cOJ/Spcvy1VfjadKkWabHN5lMjB//Fa+//hZffjmKtLQ0PvigJ1evXskypvtdm8yMHj2cqVMnExragDFjJtC4cVNmzvwxw3PfsGHtv0MaBzB06Eiio6P59NNBGRLMT5IMAxQiGzOnJqDSu9seO9V4A22p+qh98jkwqievkLY8B7Z7AOBU6/ltsH4vav/CuLYZRurWORjP7sKSEk/KygloyzTCqUpbFLXW0SHa5PRyZvAbFRg3P5zrt5LZcjCCdIOZd5uXQJ1JA//XirzCzeRoSvuWoHquSpkcUQghhHC8nRF7+SdiLwAfVuh5z2W7I/disdx/u0dd9iwULlzU1qumcmU4fvwoW7ZsstvGyUlPv36D0Wqtf4fs2bOLf/7ZwYgRY6hbtz4A1arVICEhgSlTJlGrVl3Onz9PbGwsr73WgTJlygGQP38BlixZRHJyMs7OLkyfPoUaNUL47LMvbecqVKgIPXp0Zvnyv2nTpp1dHOXLV8TPz5/169dQvnxFwFoJk5AQT+PG1g/z06d/R4ECQYwZ841tOF3RosXo0uVNNmxYS8OGTViwYB4mk5nx4yfh6ekFQL58BejRo/MDX7fNmzfwxx/zePXV1jRq1DTD+piYW+zYsY3eva2VaO7u7tSqVYdly5bwzjvd0GgyfsSuV68BK1cu48MPB6AoCgaDgS1bNvHpp8M4c+aU3bZFihTliy9G8s034/jpp2n89NM09Ho95cpVoFmzVwgNbfDAz+VhhITUtiVU3Nzc2blzOyVKlKJrV+s9W7hwETZv3sjRo4cpXrxkpsdITEzk55/n2oYvOjs707t3dw4c2EutWnWZOfNH9HpnJk2ahrOz9Uv3ypWr0b59S2bMmM6IEWMID99Prly5ad26HSqVivLlK+Li4kJ8fMZRCTqdjqJFiwHW4W1FixYHrMnPxYsX0q/fIJyc9CQlJbJ16yZ69eqbadwWi4VZs2ZQv35DPvigHwBVqlQjOTmJxYv/zHSfmJhbXLx4gbff7kr16tbquBIlSjNz5g+kpaXZDS0tWrQYuXLltu0bGJiHHj3etz3ev39vpucYOPBT6tSpB1iHk7Zt24KFC3+nb99+mW7/INfmTufOnWXVquX06tWXjh3fAqyvh16vZ+rUybRv35GgIOtM4CaTma+/noyLiysAyclJjBz5BWfPnqFIkaL3jedRSGWVENmQxWIh/chakn7rhzHyv7JYRaN74RJVLxNF54I+tAf6ut1Aa/1GzHB4NcmLR2COvfcsIc9aDg89g9+oQGBO6y+kXceuM23xUYymjN+eaFQa3g9+l3p5QwCISY1lT+SBDNsJIYQQjnQr5RanY89xOvbcfZedinmw7R512cPKrH/k/ba5nUi6zc/Pn9TUFLtlBQoUtCWqAPbu3YNaraZatZoYjUbbv5CQ2ly5comIiGsEBRXCy8ubgQM/Yty4UWzevJEcOXzo1esDcub049Kli9y6FU2DBo3szlWqVGny5MnLgQP7Mo29YcMmbNq0wVZFtH79GooVK0H+/AVITU3l6NEj1KgRgtlstsVVsGAhAgJysWfPPwAcPHiAMmXK2RJVt8/r7x9w3+sH1mFdX331JcWKlaBv3/6ZbnO7Yqd69ZokJCSQkJBA3bqhREffZPv2rZnuExragJs3b3DokLUCfffuXSiKQtWq1TPdvl69BixatJwJEybTocOb5M9fkD17dvH554MZOnRIpkMEH1fJkqVt/58jR44My25f07uHXd7Jx8fXrs9Wzpx+AKSkWKvpDh48QEhIbVuiCsDFxYWQkNqEh1vviwoVKnHp0kXeffdNZs78kRMnjhEW1pi2bTs88HNp1qwFSUlJbNu2BbAOp7NYLISFNcp0+0uXLhITc4tatez7joWGhmV5jhw5fChQIIixY0cwYsRQ1qxZhdlspk+fj7Os3rrtQZI7Go3GLh5PTy/KlCnHoUPh9933Qd2uZLz7ujRs2ASAAwf225YVKlTYlqgCbL277v6Z8iRJZZUQ2YwlPYXULT9jPGcdZ526cTqu7UejqF7ct+vdDdZ1L0CD9awoioK2aE3U/oVJ2TAN843zmKMvYrpxHpVXLkeHZ8fTVcegjhWYMD+ci9cT2HfqBpP/PMz7rUqj09q/Rqp/G8ZfTYzg+4M/E5cWj06to1zOUo4IXQghhMggh3MOingFPdCyot5B3JkPeJh9H2TZw3J2drYNpbqbyWTCZDKh19u3h7h7eJmiKBmSHM7O9r2Y4uPjMJlMNGgQkum5bt68Qa5cufn++x+ZPXsG69evZcmSRTg5OdG4cTP69u1vq4DJkcMnw/7e3jnseg/dqVGjpvz66yz27dtDuXLl2bZtC926vQdAQkI8ZrOZOXN+Zs6cnzPsmydP3n/jjydv3oz9XH18fDM9550MBgOffz4ERVExfPhodDpdptutWLEUk8lEhw6tMqxbsmSRrRLmTkWKFCNv3nxs2rSecuWC2bBhDbVr17VLFN5No9FQtWp1W0Lr5s2bfPvtWNavX0uTJi0ICcn8NXpUd/flAuySSg/i7uGJtyvgLBbrl53x8XFZ3he37+/69RtiNpv566+FzJr1EzNmTCdXrtz07NmH+vWzTh7dKV++ApQpU5bVq1dQv35DVq1aQc2atfHw8Mx0+9v3rJeXfcP4e903iqLw7bdTmDVrBlu2bGTVquVoNBpq165H//5D8PDwyHLfu993mfHy8rZryA/WpvbXrl29774P6vbzvntGx9uP73yvOjnZv7a3k+P3ahXyuF7cT79CPIdM0ZdIWTsFS7y1UaHimgPn0J4vdKIKIMYUgTbQ2uzwRWywnhmVpz8ur/yP9L2LMCfHoS1Sw9EhZcrNWcuA14P55o+DnL0az+Fz0Xz7x0E+aFsWvS7jfWkym0g2JGPBwtnY85KsEkIIkW1Uz1Upw3D1rJbVylsFo9H8SPs+yLKHlSOHDxcunM903Y0bNwDw8cmYBHhYrq5uuLm58e2332e6Pl++/P/+twCffTYck8nE8eNHWbVqBYsXLyRPnnxUq2b9m+bWregM+0dH37Sr1rlTwYJBFC1anI0b15GUlER6epqt4sPV1RVFUXj99TczrXa5nWjx8vLi1q1bGdZnNoTsbpMnf82pUycYPfpru+qgO504cYxz587SvXsvSpcua7du9eoVrFixlGvXrma6f716DVi1ajk9e/Zm27YtDB8+JtNz9OjxDvnzF7AN4bzN19eXQYM+Y9OmDVy4cO6BklX/JRTsK+NTUpLvu+/T4O7ukeV9cWc1XFhYY8LCGpOYmMju3buYO3c2X375KcHB5R8o8QjQrNkrjB8/mgsXznPw4AHGjv0my21vn/vueyerCQFu8/XNSf/+g+nXbxBnzpxi48b1zJ07G29vbz76aOADxZmVxMQELBaLXcVkdHS0bQZGRVEyvK7JyQ/3urq7WxNqMTG3bFVw1vPcBLB7TRxBhgEKkQ1YLBbST2wmefFwW6JKnbcsLm2GofYv7ODoxNOiqDU4VW2Hvu67dsvTT2y2G/7paC56Lf3aB1M8nxcAJy7F8vXvB0lONWbYNp9HHt4t/SatCjejVeHMG0YKIYQQ4uGUL1+Ra9euZtrcesuWDahUKsqVq/DY5wkOrkBiYiJqtZrixUva/h09eoTZs2cACps3b6R58wZER99ErVZTunRZ+vcfjJubO1FR18mfvwA5cviwbt1qu2MfO3aEa9euUrZscJbnb9y4KTt3bmPDhjVUrlzVVuHh4uJKkSLFuHz5kl1cefPm44cfvufo0SMAVKxYmUOHwm0ftgHOnz9332qUDRvWsWjRH7zxxtvUrFkry+2WL1+KXq/ntddep0KFSnb/2rd/A4vFwtKlizPdt169BkRFXWf27BlotToqVqyc6XYBAbnYuHFdpo20L126CFiHZD2I28O2rl//bzbAixcvEBfnmFmpg4MrsH37VlJS/hs6lpKSwvbtW233xRdf/I8hQ6xDMN3c3AgNbUDnzu9iMpkyTXSpVJmPyAgNbYhWq2X8+K/IkcOHKlUyH3IJkDdvPvz8/Nm4cZ3d8qyGdYL1fm7RoiHHjx9FURSKFClG9+69CAoqZJsh8e7KqIeRmppqN+HAzZs3OXToIMHB1p5urq6uWCwWu5ke7x4imNW1uS04uDwAa9fav1dvv3fv9V59Fl7scg0hngMWQxqp2+ZgPL3dukBR0FVqgy64KYrycuSTg7TlObDDWparr/1iNli/lztfZ1PUOdK2zgHM6Cq0RFe+Bcpj/KJ7UvQ6DR++Vo4pfx3h8LlozlyNY9z8A/RrH4ybs30Je2nfEpSmBACxaXEsOr2M9sVa4aq9f8mzEEIIITKqX78hv//+G/3796VTp3coXLgoiYmJ7N+/l8WLF9KhwxsEBDxYX6Z7qVEjhDJlyjFo0Me8/fa75M2bj8OHDzJz5o+EhTXGxcWFsmXLYTZbGDKkP2++2RlXV1fWr19DcnISderUQ6VS0b37e4wePYLhwz8nLKwxN25E8dNPU8mXLz9NmjTP8vwNGjRiypSJbN26mf/9b5jdum7d3mPQoI8YOfIL6tdviMGQzq+/zubcuTP07v0hAO3avc6yZUv4+OPedOnSHaPRyA8/fI9Gk/Vwu6io64wZM5y8efNRo0YIR45kPltz0aLFWLduNTVr1sp0eFxQUCGKFi3O8uV/8+67PTKsL1KkKPny5ee33+bQvPmrqNWZJxK6d+/FgQP76N79bV577XVKlSqDWq3m+PGjzJv3KzVq1KJy5WpZPp87VahQCScnJyZNmkDXrj1JTk5ixozpWQ6He9reeacb3bu/Td++7/HGG50AmDt3Dikpybbm7pUqVWb06BF89923//YFi+fnn38gX778tmbfd7pddbdv327y5y9IqVLWyj0XFxfq1q3PypXL6NjxrSyvN1irlN57rw/Dhn3K2LEjqVu3PkeOHGLx4oVZ7lOkSDGcnZ0ZPvxzunTpTo4cPuzdu5vTp0/RocObgLVRPVib9levHkL+/AUe+FpptVpGjvyCnj37oNVqmTFjOm5ubrRr9zoA1auHMHnyN4wePZyOHTtx/XokM2f+aNdXKqtrc1tQUGEaNWrCjz9+T1paKqVLl+HIkcPMmfMzjRo1oWDBxxu+/LgkWSWEA5mTYkhZMQ5zzDUAFGdP9PV7osldwsGRCUcxx0WCooDZQvq+vzBdPYo+tAcqt8cv7X9cOq2a3q3LMP3vo+w/dYOLkQmM+W0//dsH4+mWMckYmxbH+L1TiEmLJS49nt7B3dC+4ENahRBCiKdBo9Hw3Xc/MHv2DP76ayFRUdfRarXkzZufAQM+oVmzV57IeVQqFRMmTOLHH6cxc+aPxMXF4ufnT6dOXejUqQtg7Wfz9dff8cMP3zN69HBSU1MJCirEiBFjCQ62Vnc1b94Svd6ZuXNnM2RIP9zdPQgJqU2PHu/fsw9Sjhw+VK5clYMHw6ldu67duurVazJhwiR+/vlH/ve/Aeh0TpQoUYrJk6fbkhienl58//1PTJo0gREjvsDFxZmOHTuxfv3aLM955cplkpKSSEpKolevrllu17NnbxIS4qlfP/Mm3WCdhW7SpAls3bop0yFU9eo1YPZs66xzWQkMzMPPP8/l119nsWbNSn79dRYWi4U8efLRsWMnW7LiQbi7uzNy5DimTfuOTz7pT0BALt55pzurVi1/4GM8SYUKFWbKlJ+YPv07RowY+m9FYHmmTZtpqxZr3rwlaWlp/PXXn/z11x84OempVKkKvXr1zTTh5OzsTIcOb7J48UJ27tzB33+vts3IWKNGCCtXLqNJkxb3jS0srDEqlYpZs35i1arlBAUVZsCAT/jii/9lur1Wq+Xrr79j2rTJTJw4gcTEBPLkycvAgf+zzSJZvnxFKleuyvTpU9i/f989hyLezcvLm65de/L99xOJiYkhOLg8w4ePtlUb5suXn08/Hcbs2TMYMKAv+fMXZNCg//HNN+PueW3uNmTIUAID87J8+d/MmfMz/v4BdOnSnY4dOz1wrE+LYnkaUwm8YKKjE59q4zBhL2dOd27cyHqWiReJxWwkeelozNfPoM5dwpqUcPFydFjP3C/bdrL1/CEAJrbvjLMue1dXPe171BR9idT1U/+bIVDngr72O2iDMi8Xf9ZMZjMzlh1n1zFr2bF/DhcGdAgmh4d940WzxczMo7+xP+oQIbmr0q5oS9T3KUcWT8bL9HNUPJ/kHhVPS2TkRQIC8j/2cTQalV3PKiGyG7lH72/UqGFcvnyRqVMzNuUXz0ZU1GX8/DJOegCgUin4+Lhlua98xS2EAykqDc71e2E4tQ1dcPNsMdzLEWLNkXc0WJdfumqffLi0/oK0HfMwnNgE6cmkrpuCqXgdnKp3RNE6NpmnVqno2rwkOq2KLQcjuH4rmdFz99P/9fL4ef33balKUdGpRHtK+5SgSkAFFEXBZDZJwkoIIYQQQjw1CxbM48KFc6xcuYwRI8Y6OhzxiF7OT8ZCOIg57jrJy8dhTvxvpgmVWw6cKrzy0iaqROYUjRP62p3Rh/UGJ+vYc8OJzST/9QWmmxcdHJ31m5BOjYtTv2IeAG7GpTJm7n4iopPsttOqtVTNVRFFUYhLS2D8vilsv/qPI0IWQgghhBAvgYMH97N27Wpef/1N6tSp5+hwxCOSyiohnhHDuT2kbv4ZDCmkrp+Kc4tBKNK/B7BvsO5UW+fgaLIXbcFKqHMWJHXjD5giTmKOjcB49h/Uvo8/xOFxqRSFjg2K4KRVs2LXRWIS0hgzdz/9OpQnr599Sa/FYmH64VlcSrjC/FPXyOUWQJCn45+DEEIIIYR4sYwcOe7+G4lsT0o5hHjKLCYjqTvmkrpuChis07Sq/As5OKrsTHF0ANmOys0H52aD0FVqjcovCF2l1o4OyUZRFNrUCaJVrYIAxCcbGPvbfs5HxGfY7rUir6BVaagaUJH87nkcEa4QQgghhBDiOSBlHUI8ReaEm6Ss+x7zjXPWBToX9HW7oi1QwbGBZTO3TBFoAk8DYDLXQit59AwUlQqnCq+gC26GckfPJ+OVo4AFTZ7SWe/8tGNTFFrULIhOq+b3DWdISjUyfv4BPnytHEXyeNm2K+iZn8GV++Lv4oeiKKSb0kkxpuLp5OGw2IUQQgghhBDZjySrhHhKjBfDSdn0I6RZe/iochbEuX4vVB45HRxZ9hNj12DdBGgdG1A2dmeiypwcS+rG6VhS4tGWbYxT5bYoasf9WG9UJR86jYpf1pwiJc3EhN/D+aBNWUoWyGHbJsDVH4CE9ESmHZpFuimdjyu+h7Mm62mshRBCiIdhsVhQFKnUFkIIR7JYLI+1v5QvCPGEWcwm0v5ZQMrqb22JKm2p+ri88okkqsQTZb51BYshDQDDoVUkLxmBOS7SoTHVq5CHd5uVQFEg3WDm2z8OcfDMzQzbbbv6DxfiL3EtKZI1Fzc9+0CFEEK8kNRqDQZDuqPDEEKIl57BkIaT06P3I5ZklRBPmCU9GcPpHdYHWj36+u+hr/kWilqqhbISpClPyu7GpOxujE4tDdYflCZPaVxbD0P1b7N1880LJP05FMPJrY/9TcbjqFkmFz1eKYVapWA0mflu0WH2noiy26ZRgXqU9S1FlYAKNCsY5qBIhRBCvGjc3LyIjb1BenqaQ38XCiHEy8hisWAyGUlKSiA29ia+vr6PfCwZBijEE6bSu6Ov/x5pO3/DOfQ9VF4Bjg5JvMBUXgG4vPoZaXsWYji0CoxppG6egebKEfS13kbRuTgkriol/NFp1Hy/+DBGk4WpS47Q1ViS6qWt7weVoqJL6TfQKGoURcFgMnAk+gTl/co4JF4hhBAvBmdnVwDi4m5iMhkf+TgqlQqz2fykwhLiiZN7VGRXKpUarVaHt7cfXl5e3LiR8EjHkWSVEI/JYjZjOLEJbdEQFI21KkiTqxjqVkNRFClefBC3zNJg/XEoag36ah3QBJYiddOPWFLiMZ79h6Soszg3/AC1Tz6HxBVcxJe+bcsx+c9DpBvN/LTsGGlGE3WDAwHQqqy/ghLTk5h+eBbn4i7SqUR7quaq6JB4hRBCvBicnV1tSatHlTOn+yN/wBLiWZB7VLzoXqpPhOnp6bzzzjts3LjR0aGIF4Q5JZ6UlRNI2zaHtJ3z7NZJourBxZgj0AaeRRt4FjPyDdGj0uQtg0vbEajzlgXAknCT1G1zHDoMolTBHHzUrhxOOjUWYM6qk6zdc9lumyRDEpFJ1mGCuyP3y7ANIYQQQgghXnIvzafpEydO8MYbb7B//35HhyJeEMaIkyT/+Tmmq0cBMEWcwJKe4uCoxMtO5eyBc+OP0FVpi8o7EOew3g6fEalYPm8GdCiPi5O1kmre+tMs23HBtt7f1Y/uZd6mWkAlepZ7x+HxCiGEEEIIIRzrpUlWzZs3j169elG2bFlHhyJeAOlH15OybAyW5FgANIWr4dJqKIrO2bGBPacKaSrc0WBdGtE/LkVRcApujkuroahcvBwdDgBBuT0Y2LE8bs7W13fRlnMs2nLWVkVVxDuIt0q2Q6vSYDAbWXj6b2LT4hwZshBCCCGEEMJBXphk1eLFiylZsmSGfwkJ1nG8w4YNo169eg6OUrwo0v75HSxmUGlwCnkbfb0eKFq9o8N6bsmgr6fjdg81AIsxjdQtMzEnxTgsnnz+7gx+owKebta4lu24yPz1Z+yG/aWbDEwJ/4mNl7cx7dAsUo1pjgpXCCGEEEII4SAvTIP1li1b0rJlS0eHIV4WJgMAujIN0ZWUJOjjirmrwbpG/cLk0bMFizGdlJXfYIo4gSniJM4thqBy8XRILLl9XRn8RgXGzztAdHwaa/dexmA08WajYqgUBa1Kg5+LL6djz6FVaTFajICTQ2IVQgghhBBCOIZ8IhTicajUjo7ghSAN1p8ytRaVt3UGPnNcJCkrxmFJTXRYOP7eLgx+oyJ+3tZhs5vCr/Hz8uOYzGYURaF90Va0LNSUD4K74aZ1xWKxSNN1IYQQQgghXiKSrBJCiBecoig41XwDbbFaAJhvXSF5xTgsaUkOi8nHU8/gNyqQ29c6tfiOI5FM//sYRpMZtUpNWP66aNVajGYjc47/zrpLmx0WqxBCCCGEEOLZynbJquPHj1OqVCkiIyMzrFu2bBnNmjWjbNmyNGnShMWLFz/7AIUQT1zQHQ3WtSppsP40KIoKp1rvoClcDQDzzYskr/oGiyHVYTF5uTkxsGN58vm5AbD3RBRTFh3GYDTZtpl7YiG7I/ez+OwKDt444qhQhRBCCCGEEM9QtkpWnT17lh49emA0GjOsW7FiBf379yckJIQpU6ZQpUoVBg0axKpVqx7qHL/88os0WhePzbnZQJybD0JbrLajQxHigSkqFfq63dAUqAiA+foZUlZ9i8WBTcw9XHQM6FieoNweABw8G83EhYdIS7cmrBrkq4NeraegRz6CPAs4LE4hhBBCCCHEs6NYskEjEKPRyO+//86ECRPQarXExsayefNmAgICbNuEhYVRunRpvvnmG9uyDz/8kJMnT7Jy5UpHhC2EeEKmrNzAuuP7AZjfpy9OWqmueposJgORf4wl5az1mjsHBRPw2mAUjeOue3KqgeE//8ORs9EAlCyYg6Fdq+Gi13Lu1iXyeASg0+iwWCwkpCfh4eTmsFiFEEIIIYQQT1e2mA1w3759jB8/nnfffRd/f38+/fRTu/WXL1/m0qVLfPzxx3bLGzVqxMqVK7l8+TJ58+Z9avFFRydiNjs8p/fSyJnTnRs3EhwdhniGriVdQht4FoCoG/HotToHR3RvL8I9qq7TE3XKN5iuHSflXDiRB/9Bk6+cQ2N6v2Vpvlt0mKPnb3Hs/C0Gf7eVj9oF4+7sTVxMGiZzMvNOLuJ0zFn6V+qNu04SVll5Ee5R8WKTe1Rkd3KPiuxO7lHxPLjXfapSKfj4ZP33fLYYBlioUCHWrVtH7969Uaszzq527tw5AAoWLGi3PH/+/ACcP3/+6QcphBAvEEWjw7nRh6hzFUNft6vDE1UATlo1H7QpS/kivgCcj0hg7G8HiE9KB2DP9QPsjNjDzdRb/HFqiSNDFUIIIYQQQjxF2SJZ5evri4+PT5brExKsmTg3N/usm6urdRapxETHTcEuXk4JP3Qm4YfOpO1d5OhQXgiF7mywrs4WBZ8vBUXrZO29VjTE0aHYaDUq3mtZmiol/AC4ciORMb/tJyYhjaoBFakaUJF87nloW/QVB0cqhBBCCCGEeFqyRbLqfu7XVkulei6ehnghKY4OQIjHoij2Pz8NZ3eTuv3X+/7cfZo0ahXdW5QipEwuACKikxk9dx/Rcal0LN6GDyv0xEPnjsVi4cSt0w6LUwghhBBCCPF0PBdZHnd3dwCSkpLslt+uqLq9XgjxfLplvoYm8DSawNOYzCZHh/PSMpzfS+qGqRiOriNt13yHJqxUKoXOTYsTWiEQgBuxqYz+bT/Rsek4qXWYzCbmnVzE5PAf2Xh5m8PiFEIIIYQQQjx5z0Wy6navqkuXLtktv3jxot16IcTzKcYciTbwLNrAs5iRyQwcRe1XCMU9JwCGw6tJd/AwV5Wi8EZYURpXzQfArfg0Rs/dz9UbiSQYEjl88xgAGy9vJd2U7shQhRBCCCGEEE/Qc5Gsyp8/P3ny5GHVqlV2y9esWUOBAgXInTu3gyITQogXh8rVG5dmA1HcrD0E0w8sJW3/3w6NSVEUXqtbiFdDrF9KxCWlM+a3A8TFqHiv3DsU9ipIv4rvo1Nn7xkkhRBCCCGEEA/uuUhWAbz//vssW7aML7/8ki1btjB06FBWrlxJ3759HR2aEOIxBd3ZYF0lDdYdSeXua01YuXgBkL53EemHVjs0JkVReDWkIK/VKwRAYoqBsfMOkB7vzofle+Lp5IHFYmHTle3cTIl2aKxCCCGEEEKIx/fcJKtat27NsGHD2LZtG++//z579uxhzJgxNG3a1NGhCSGeIEWa1jucytMf52YDUfTWfoBpu+aRfmyDg6OCJlXz80ZYUQBS0oxMmB/OyUuxWCwWFpxazB+nlvD9wZ9JMiQ7OFIhhBBCCCHE48h2JQytW7emdevWma7r0KEDHTp0eMYRCSGetph/G6wDmC11UKF2cERC7Z0b52YDSF42BtKSSNs2B0WtRVuslkPjql8xDzqNilkrT5BmMPHNHwfp3boMTmonANJM6SSkJ+CqdXFonEIIIYQQQohH99xUVgkhXlwx5oj/GqxbzI4OR/xL7ZMPl6b9QesMgOHEFixmx78+tcrlptsrJVEpCgajmUkLD5HXVInG+UPpX/F9Alz9HR2iEEIIIYQQ4jFIskoIIUSW1DkL4tzkY9T5yuHc5GMUVfb4tVGtZAC9WpVGo1YwmS1MXXyUnGnBeOu9ANh4eRt/n11174MIIYQQQgghsqVsNwxQiOeBe/dZjg7hhRKkrsihnTkA0NSVH0vZjSagCJrGH9kts1gsKIpj+4tVKJqTPm3K8t2iwxiMZn78+xgGg5kUr5MsObsSAB+9NzUDqzo0TiGEEEIIIcTDyR5fkQshhHhumFMTSPl7FMZrxx0dCmWCfPjotXI4adVYgJkrT5Aa5Yeb1hVPnTt5PQIdHaIQQgghhBDiIUmySgjhcLf+bbCuCTyNGcf3RBJZs5hNpCwfh+n6aVJWfYsp8rSjQ6J4fm/6dQjG2clalbd4/XWCVU3pX6k3+dzzANbG60IIIYQQQojngySrhHhIFosF47XjGK8dx5xww9HhvBBiLP81WLdYLI4OR9yDolKjK9cUUMCYRvLKrzHduODosCgc6MnA18vj5qwFYO3WBLbsicFisbD5yg6+3DWOmNRYxwYphBBCCCGEeCCSrBLiEaQsG0PKsjEYTm13dChCPHPawtXQ1+lifWBIIXnFOEy3Ljs2KCB/gDsDO5bHw1UHwN/bL/Djxm0sOLWY2LQ4fjryqyRDhRBCCCGEeA5IskoI4XCF1BVJ2d2YlN2NUavUjg5HPABtsVo41XzL+iAtyTo0MPaaY4MC8uR0Y/AbFfB2dwJg124DAeaSuOvcaFf0VYc3hRdCCCGEEELcnySrhBAOJ7Uuzyddqfo4VesAgCUlnpRlYzHHRzk4KgjI4cKQNyqQ00sPwPm9eckf15S8btb+VZcTrkmFlRBCCCGEENmYJKuEEA5n12DdIg3Wnye6so3RVWoNgCU5luRlYzAnRjs4KvD1cmbwGxXJ5eMCKOw5HM8PS4+y5fJOxu6dxIoL6xwdohBCCCGEECILkqwS4qFJRcaTFisN1p9rThVeQRfcHABLchzmGMcPBwTwdndiUMcK5MnpBsDuk9dYdGItZouZtRc3ScN1IYQQQgghsilJVgnxWKT/zZMmV/T5pKvcBl1wM5wbf4gmbxlHh2Pj4apjYMfyFMzlDmYNCUeD0Ro96FWmK956L0eHJ4QQQgghhMiEJKuEEA4XJA3Wn3uKouBU5TU0eUrbLbeYjQ6K6D9uzlr6dyhPkTyeWFLdiN9fnUWrYkhJM3L81imuJUY6OkQhhBBCCCHEHSRZJYQQ4qlIP7Sa5CWjsKSnODoUnJ00fNwumJIFvAGFU5djGb50Ed8f/JnvD/5MbFqco0MUQgghhBBC/EuSVUIIh4s2XZUG6y8Yw/l9pO2ah/nGOVJWfYPFkObokHDSqenbtizlCvkAcDMpHrPFTEJ6IlelukoIIYQQQohsQ5JVQjwCda5iqHMVQ+Xu4+hQXgh3NlgXLwZN/nJo8pcHwBR5ipQ1E7EY0x0cFWg1at5vXYZKxf0wRhTEcK0gzldqEuhUwNGhCSGEEEIIIf4lySohHpKiqHBpMQSXFkPQFg1xdDhCZEuKSoO+QS/U//awMl09Rsq6KVhMju9hpVGr6PFKSaqXyoXxSjGirjozeu5+9lw+xl9nlsuMlEIIIYQQQjiYJKuEEA4nDdZfTIpai3PDPqhzFQPAdOkgqRumYTGbHBwZqFUq3m1egrrBuQG4abnArFOzWXdpM+subXZwdEIIIYQQQrzcJFklhBDiqVE0Tjg3+hCVf2EAjOf3krrpRyxmx/cmUykKbzUqRsPKeTEneWJOdwKzCovB2dGhCSGEEEII8VKTZJUQD8liMZO29y/S9v6F8doJR4fzQrhlviYN1l9gis4Zl8YfofLND4DxzC7Sts3Ckg1ea0VRaB9amOaVi5N+qiJpJyuxbHk6l64nYMoGFWBCCCGEEEK8jCRZJcTDskD6/iWk71+CKfKko6N5IUiD9Ref4uSKS9MBqLzzAGBJSYBsUF0F1oRV69pBtK5SDnNCDhJTDIxZso7Pto/lelKUo8MTQgghhBDipSPJKiGEEM+EonfDudkAtGWboA97H0WtcXRIdppVL8Dr9Yug6JKxBO0izhDDxP0/kW4yODo0IYQQQgghXirZ65OCEOKlFKSuyJFdPgCoQiWH/iJTuXiir9bebpklPQVFlz36RIVVzotOq+K3w1dR5zpHzOn8nMoTT+mCPo4OTQghhBBCiJeGfCoUQgjhMOb4GyT9+Rlp4SscHYpNneBA3g5+BcPRmqRF5WLSwkNsPX5W+qkJIYQQQgjxjEiySoiHZnF0AC+cOxusWyxyfV8WFouFlPXfY0m4SfruBaQfWevokGxqlMlFj0bVUKsUzM63mHf5Z77/Z4GjwxJCCCGEEOKlIMkqIR6L4ugAXggxlmu2BusWSQa+NBRFQV+3K4reHYC0HXNJP77JsUHdoVJxP3q3Lo02/3EUjYHjyftZuHsPpmzSGF4IIYQQQogXlSSrhBBCOIzaOxDnpv1B5wJA2tbZGE7vcHBU/ylXOCdvF38DS7qe9HOlWbEhgf7fb+ObTX9y/uZ1R4cnhBBCCCHEC0mSVUIIhwtSVSJld2NSdjdGpciPpZeN2jc/Lk37gVYPWEjd9COGc3scHZZNtSIF6VOyD85JBQFI0FzljPkfxh2cwFdLVnHobDRms1QECiGEEEII8aTIbIBCCCEcTu1XCOfGH5GyYgKY0kldPw1FrUWTP9jRoQFQIl9Oxr2Xg3+OX2fp+bMkA5g0nD6p4tvjB/HKFU/+gibalK1HHq8cjg5XCCGEEEKI55qUMAjxsBQFXYVX0VV4FXWuYo6O5oVwy3wVTeBptNJg/aWmyVUM50Z9Qa0Bi4mUtd9hvHLE0WHZOOnU1C6Xm3Etu9Gp4LsUsoSgU+sASPY4ySnjP4z652umLD7E8Qu35F4WQgghhBDiEUlllRAPSVFUOFVq5egwXiixRKANPOvoMEQ2oMlTCucGvUlZMxk0OhSds6NDylTVgsWoWrAYyXWMbD96haVROzEBpuhc7Lt0k30nbuJR7ARFcgbStmxd/D08HR2yEEIIIYQQzw1JVgkhhMhWNPmD0TfohcrdF7VvfkeHc08ueg1hFQtQ3zyEbWePczglkYPqFEzaeAyeFziWfoGhy69S0a0OdcsHUii3ByqVFDULIYQQQghxL5KsEkI4XJCqEkd3+aIASqji6HBENqAtWNHuscViwZIci8rV20ER3ZtKpaJ2kVLULgKJoQb+Dt/Lzjg3zLpEDNfzsPPidXadPYtr8UOU9ihP27J1yOHm5uiwhRBCCCGEyJYkWSXEQ7KYTaQsHwuAtlhttEVrOjii55909hH3YrFYSNs5D+PpHTi3GII6R6CjQ7onN2ctHatXp4O5KtvOnOBYgpl9J2+g8ruMSRfPwdTN7J9loWpQIWoFB1A4d/ZMwAkhhBBCCOEokqwS4qFZMEWcBEAdWMrBsbwYYv5tsK4AFks9FEWqq8R/TBEnMBxZA0DK8jG4tPgElVeAg6O6P5VKRe2iJaldFOKS0vl1fyLHk25gTHEmPdGFrYci2BW7Hr13AuVzVKR9cD2cnbSODlsIIYQQQgiHk2SVEMLhYizXbA3WJVEl7qbJXQJdlXak716AJSWe5OVjcWkxBJVHTkeH9sA8XXW8X6sFRnNT9p+9yj/mWMLPRaL2vYZRY2TXtQPs3u5E9dIBVCntSbHc2T8ZJ4QQQgghxNMiySohhBDZnlNwUzCmkb5/CZakW/8lrNxyODq0h6JRqalSJB9ViuTjWkw+5h+K5WzqEYxR+TCnm9gYfpGdbMLpoCe1/OvSvEwldFq1o8MWQgghhBDimZJklRDC4YLUlTm2IyeKAoQ6OhqRXekqtgSTgfSDK7Ak3Pg3YTUYlYuXo0N7JLm9vfi4TjvSja04fPYWmw9GcCLhIIrGSLommhW7z7FxSxrVyvhSrrgrpQOz98yIQgghhBBCPCmSrBLiYUk3cCEcQlEUdFVew2JMx3B0HZa4SFKWj8e5xSBUendHh/fIdBotFYv5U7GYP6ev+/PXMS0Xk89jjs1JEkY2XdjNDuUYTof8eDVva2qWKIBGrXJ02EIIIYQQQjw1kqwS4nFIf6Un4pb5iq3BupRWiXtRFAWnGh3BlI7hxBbMMVdIWT4elxaDUXTOjg7vsRXxz8VA/44YjCYOBN1k04GrnHffAUAK8cxedp6/NlylbFk1ISUKUNQ/t4MjFkIIIYQQ4smTZJUQwuFi72iwLsT9KIoKp5DOWIwGjGd2ovYvBFonR4f1RGk1aqqU8KdKCX+OXPXh7xNbuHbTBCjEJ6ezJ3E7e48k4rGvEO0Lt6ZsYR/UKqm2EkIIIYQQLwZJVgkhhHjuKCoV+rpdMeYpjaZIjRd6FsnSgfkpHfgW6QYTe09GsfbwMaJcEgG4dUPF5EOH8XLXUaB0NK+Uqk4BXz8HRyyEEEIIIcTjkWSVEMLhrA3W/VApiowCFA9MUanRFq1pt8wcG4ni7oOi1jooqqdHp1VTo3QuapTOxf5LBVh2aguRcbkxAvGW65w0/cPYgzsITArhrZr1yZPD2fqeEkIIIYQQ4jkjySohHpZKhXPzQdb/dc/p4GCEELeZblwgecU4NAFF0Ye9j6J6cX/FVchXiAr5CpFa28ju41EsPbeaZAALnD2l4Ytju/D2TyF/oTRal61LHq8cjg5ZCCGEEEKIB/bi/iUvxFOiKCo0uUs4OowXyi3z1X8brCtAPUeHI55TafsWQ1oSxosHSN0wHX1oTxSV2tFhPVV6nYba5XJTu9w77Dx3gq2nj3NOcSYdM4lupzhpjGDUnj2USmpHaPkCFM/n9UIPmRRCCCGEEC8GSVYJIRxOGqyLJ8E5tAfJy8dhvnEO47k9pKp16Ou+i6K8HI3HqwcVp3pQcZLrGDl0IZrfzu/CBJhi/Nh3LoZ9J2LwLHKOov5+tClbBz8PT0eHLIQQQgghRKYkWSWEcDiLowMQLwRF54xL034kLxuDOfoSxtPbSdNocQp5+6WqJnLRa2hRqzBVig5m69mjHEyO54jagFFJIc3zNEfST3Fo9Xkq6MOoVz6QQoEeL9X1EUIIIYQQ2Z8kq4R4SBZjOok/dwdAV7ktTuWbOzii51+QqjLHd0qDdfH4FCdXnJv2J2XZaMwx1zAc3wRqLU7VO750CRmVSkWdImWoUwQS6xtYFh7O9jgXzLokDNfzsDMxkp2nLuBWMpwyXsG0LVsbb1c3R4cthBBCCCGEJKuEeCwv12ffp+4lyyWIp0Tl7IFzs4Ek//0VlvjrGI6sRdE44VSlraNDcxg3Zy0dqlemnbkiG08d5kS8ivBTN1F8r2JyiiU8ZRP756RTtUAxagfnIiiXl6NDFkIIIYQQLzFJVgkhHC7GIg3WxZOlcvHCpflAkv8ehSUxmvTwZSh6d3RlGzk6NIdSqVTUL16O+sUhLjGN3w4kczTpKiajmrQ4d7YcjGDHja0454ymfI6KtA+uh7OT1tFhCyGEEEKIl4wkq4QQDhfzb4N1izSvEk+Qys0Hl+aDSF76FaCgyV/O0SFlK55uTrxXqxlGU2N2n7nEvrQEws/cQJ3zCkanVP6J2s2e73XUKJWbKmW9KRKQ09EhCyGEEEKIl4Qkq4QQQrywVB5+uDQbCGoNKndJtmRGo1ZTo1hBahSDyJh45h68ybm0oxij8mJKM7N+/yW2m3/ByeJOiF8tXilXBa1G7eiwhRBCCCHEC0ySVUIIh7vdYF2tUqC+o6MRLxqVVy67xxazCVPkKTS5SzgoouwrwNuDfnXbk240cPBsNFvDIzkWcxxFl0Y6aawKP8WmrQaql/GnXAlnSuXO5+iQhRBCCCHEC0iSVUIIIV4aFpOR1A3TMJ7fhz60B9rC1RwdUrak02ipXCyAysUCOB3lz6IjFi6lncYUnYsks5ENZ/azXTmA/qA/zfK2oHaJwmjUKkeHLYQQQgghXhCSrBJCONwtabAunhFzXCTGy4cBC6kbfwC1Fm3Bio4OK1sr4peLQaEdMRhNHChwk00HrnLOeQ8AKepofl1xkb83RlG+jI4aJfJQxD+3gyMWQgghhBDPO0lWCSEcLlYarItnRJ0jD86NPyRl5ddgMpC6/nuUhn3R5Cvr6NCyPa1GTZUS/lQp4c/hqz4sPbGZq9FpYFYTn5TOzpjt/HMkGvd9BehQ5DXKFvJBrZJqKyGEEEII8fAkWSWEEOKlosldAueGH5CyeiKYjaSsnYxz44/QBJZ0dGjPjTKB+SkT2Il0g4k9J6JYd/gUUZ7RAMTGWpj852G83Z0oXDqepqUrkd9HmtsLIYQQQogHJ8kqIR6SotHh3n2Wo8N4oUiDdfGsafKWQd+gF6lrvwOTgZTV3+LcdACagCKODu25otOqqVkmFzXL5GLfpTwsP7WFyBg/DECsIZojpm0cDt9EruRqtCpVm5IFc6BSFEeHLYQQQgghsjlJVgkhHE6G/wlH0BaoAKE9SN0wDYzppKycgEuzgaj9ghwd2nOpYr5CVMxXiNTaRv45dp3lZzeQBCiKhQtnNXx99CA+OQ3kK5pMmzJ1yO2Vw9EhCyGEEEKIbEqaSQghHC7m3wbrqlynHR2KeMloC1VFX+dd6wNDKskrJ2BOjnVoTM87vU5DneBARrd6gzcKdCHQUAmt0R2AeOcznDDsZMTesXz3915OXIzBItlqIYQQQghxF6msEuIhWcxmTJEnAVB5+KFy83FwRM+/GMvVfxusy/Ag8expi4ZgMaaTtm0OurJNULl4OTqkF4JKpaJGUHFqBBUnuY6BHUciWXp9D0bAnODN/pPx7D92AO+gyxQOzEGbMrXx8/B0dNhCCCGEECIbkGSVEA/LbCBl2RgAdFXa4RTc1MEBCSEel65kKGq/Qqh98zs6lBeSi15Lg0p5CTUPYMuZo4SnRHNMbcFoMZDidZIjaUYOrTtJJV1T6pQPpFBuDxTpbSWEEEII8dKSZJUQwuGCVFU4scsfjVoarAvHuTtRZYw4icrdV6onnyCVSkXdomWoWxQS6qWz8uBRtsQ5YcGIISqQ7bGRbD92BffSByjjXYY2ZWvj7erm6LCFEEIIIcQzJskqIYQQ4i7GS4dIWTsZxdUblxZDULl6OzqkF467i4521cvT2lyWDScPcjpOTXj8LfCJwKiP5kDKJvb9lkjVPGWpG5ybArk8HB2yEEIIIYR4RiRZJYRwuFuWK9YG64oC1HN0OEJgijgBJgOW+ChSlo/DucVgVM6SLHkaNCo1DUtUoGEJiEtMY96BNI4kn8NktpAW7cOW6Gtsv7YL19wRlM9RidfK1cFFr3N02EIIIYQQ4imSZJUQwuGkwbrIbnRVXsNiSMVwbAPm2GukLB+HS/NBKHoZkvY0ebo50bNWY4ymMHaePseBpBQOnr2Bxu8yBqcEdt3ayu6pOmqUzkWNMr4UDMjh6JCFEEIIIcRTIMkqIYQQ4i6KouBU800sxnSMp7ZhvnWZ5JUTcGk2AEXn4ujwXngatZpaxYtQqzhExSYyJ/wm59OOYIrKS1qaifX7LrMtbT56tZ4a/jVpWbYaWo3a0WELIYQQQognRJJVQgiHC1JV4eSuADRqlTRYF9mGoqjQ1+5CqjEd47ndmG+cJ/nvr9CVbYwmqBKKxsnRIb4U/Lzc6F+3PWmG1oSfucG2Q1Ecv3EWlUsi6SSy9vBxtm41U7NMAOVKOFM8Vx5HhyyEEEIIIR6TJKuEEEKILCgqFfrQ7qSajRgv7Md86zKpm35E2fMnrq+PR1GpHB3iS8NJq6Vqidz8n737jq+yvt8//rrvM7P3IItAWGGEjYAMF0NcoOKubbXVb6utrdWvtcNuW7911M5fbevo0Dpx4qg4cDBk7xVGWAmQPU7OvH9/BKIpogkkuTOu5+PRR3Pusy7IMZy8z+dz3acVZrG9LINnNzayN7iV0OFs6kJB/rNpLYtZjndNBufmzOGMoYObBuAiIiIi0u1oWCUitqu09h8tWDeBM+yOI9KCYTrxnv01AitfILjlXazGWpy5w1sMqsKVBzCj4tVp1UkGZvThuxlX4w+GWJNbzjur97PTtRYAn+sQj7++h1feKWdsUTQTC/swIL2PzYlFREREpC00rBJpMwNHn8EAmLEq920PKliXrs5wuPBMuBT32LmEStZgJrQcfvgXP0L4yC6c+eNwDZmGI2sIhqFVPR3N43Jy2tAMThuawbp9yby0dTEHKmoh5KY6FOC9Q8v5MFRKbCCXKwuuYOSAVExTP2dEREREujoNq0TayHC6ib7gTrtjiIgNDIcTV79xLY5FqkoJl20HIFS8lFDxUoy4NFyDp+AaNAUzNsWOqL1OUU4+RTn5BIJhPtpyiLfW7ORgUhmGAdW1IX733HqS4z0MGu5j1rCR9E1JszuyiIiIiJyAhlUiYrv+xgS2LlPBunRPRkI6Uef9L8EtiwntXgHhEFbtYQIrFhBY+TyOnBG4Bk/F2Xc0hkP/7HY0t8vB6SP6cPqIPny0O52F29+jtKJpFWyFr4Y1gXdYs+Y/9PGNY96wsxian4xpaLWViIiISFeid80i0mXo90XpjgzDxJk9FGf2UCx/PcHtSwhuXUykvAQsi/DedYT3rsORPYzo8263O26vMj5/IOPzB+KbFmLZ5jJe3f4edaYFwJ7dJvdvWEtKCuQNqeaSojPISkiyObGIiIiIgIZVIm1mhUMEVr8EgCNnOM7MgTYn6v6OFawbKliXbs7wxOAefg7u4ecQPrKb4JbFBHcsgYAPZ7+xLW4bLtuBmZSN4Y6yKW3vEeVxcsaobKYVXcaSXSN5q3gl+xuTCWBR7SlmS3A7P/9oKUN8c5k1cgiDchMxND0XERERsY2GVSJtFQkRWPUCAB6XFzSsOmWVHC1Yj+iXQ+k5HKn5OKbk45l4BaFdK3DmjWy+zgoFaHjtAQiHcPaf0FTKnjFAA5IOZpompxcUcnpBIQ3Tgny4oZSXSlcTAixfLGs2NrBm42qS88sYkBvLJSOnkxYbb3dsERERkV5HwyoREZEOZDjduAZObnEsVLIG/PVNX297j9C29zAT++AaPA3noNMxozQg6WjRXhfnjMvlrMi3eXfHBlZtP8RWh0koHKY+YTPr/Y2se2sDYx0XccbobPr3idcwUURERKSTaFglIrbrd7Rg3eU04Ry704h0PGf+WKJmf6uplH3PWrDCRKoO4l/2JP7lz+DsOwrXkKk4ckZgmA674/Zopmly5qAizhwEtWcGeGPtVt6udmABwcNZfHC4lA82HCB++FqGpwzlkhHTSIqJsTu2iIiISI+mYZWIiEgnM0wHzrxROPNGEWmoJrT9A4JbFhOpLgUrTGj3SkK7V+IaPhPv5KvsjttrxEW7uWTSCC6KDOXNLWvZXg3ryquxEg4TjCpjdUMZK58uZ1LmOKaNzCK/j1bAiYiIiHQEDatE2sqy7E7Q41Ra+3Bmb8dUwbr0QmZ0Au6Rc3AVnUu4bEfTaqudyyAUwFUwocVtQ3vX4egzBMPptilt7+A0HcweOobZQ6Gqzs9TqxezriGKiBHEfyidd0oPsHjPKmLzShidMpZLR04jxuOxO7aIiIhIj6FhlcipUH1Ju6jkwNGCddPuKCK2MQwDZ+ZAnJkDsSZfRahkLWZ6QfP1kaqD+F69H9zRuAZMaiplT+1rY+LeITHWww1TZxAKn8X727azttrPup3lONP3EvRUsKzqbZb/ycnpw7KZPDKd/PREuyOLiIiIdHsaVomIiHQxhjsK14CJLY4Ft3/Y9EWggeCmRQQ3LcJM6YtryFRcAyZheNSj1JGcDgdnFA7hjEI4UuXj0dWH2RWoI1yeSbDR4s2V+1hc9xzRXgcT0ycxb+Tkph4+EREREWkzDatExHb9jQlsW5aJWwXrIifkHnMhZkouwS2LCe/bCFhEyvfg/2AP/qVP4uw3rmm1VZ/Bdkft8VITo7jtzMvxBy9m1Y5SPjSPsKl0L46ECvzAm1vW8f77FlOK+jB6aCwDMzLtjiwiIiLSrWhYJSL2Uw2YyOcyHC5c/Sfg6j+BSF05wa3vE9y6GKuuHMJBQjuWENqxBO+06yD9PLvj9goel4tJhblMKsxlx6E+PLOhlr2hzYQP51DXGOT1tZt4J/I+0aszmZk9i7OGFuJ0aLWViIiIyOfRsEqkrRxO3GMuavoyfYDNYXqGSpoK1g3DgQrWRT6fGZuCZ+xFuMdcQHj/pqZS9t2rwABnv7HNt7PCQUJ71+HMG4lh6p/8jjQgPZPvnnU1jYEga3LKeWf1AXYZmzEM8LlLefLNnbz6TiXji+I5bWg6BWlabSUiIiJyInrnKtJGhsOFZ9w8u2P0KJXsV8G6yEkwDBNnznCcOcOxGusIH97ZorsqtHsVjYv+hBEVj3Pg5KZtgolZNibu+bxuFxOHZjJxaCZr9yXz0tZ3OVhdgeWPodof4N0Di3k/VEJsMJsrCq5gVEE6pqmzdYiIiIh8koZVIiIiPYDhjcWZW9TiWGjHUgAsXw3Bda8RXPcaZsYA3EOm4+w/HsPltSNqrzEyJ5+ROfn4g2E+2nyIt9fs4WDKAQwDahr8/P7ZjaTE76BweJBzhg8nLznV7sgiIiIiXYKGVSJiu/6cxrblfXC7VLAu0p68Z/8PoZ0rCG5dTPjgVgAiZTtoLNsBH/4LV8EEXIOnYaYXYBha3dNRPC4HU4r6MKWoD8t3JfPqjvcorYgDoLyunhX+t1mx6lUyAiO5dOhsCvsmYer7ISIiIr2YhlUibWQF/fheux8A19CzcRVMsDmRiMinM5weXINOxzXodCLVpQS3vkdw6/tYvmoINhLcspjglsVEz/sRjrR+dsftFSb0G8SEfoPw+UMs21TGa1uXUusIA7C3xOS+dWtIS3aSO7SCi0dMJyshyebEIiIiIp1PwyqRtrIizSsUnH1H2xymZ6hgrwrWRTqYmZCJZ8J83OMuJrx3XVMpe8lazIRMzNT85ttFao8QqTqAI3s4hqkeuY4S5XFyxuhspo2cx4e7CnmzeBkH69KJABWOndQFNvHzj5YwqPE85owsYmBOgla/iYiISK+hYZWI2E4F6yKdxzAdOPuOxtl3NJGGKqy6ihZDkOCmtwisXYgRk4xr8BRcg6dixqXZmLhnM02TKQVDmVIwlPppQT7cUMorB9YTBKygh3UbgqzbsIqUvAoK+nqZP3IaKbHxdscWERER6VAaVomIiPRSZnQiRCc2X7Ysi+DOj5q+rq8gsOpFAqtewpE9FNfgqTjzx2A43faE7QVivC5mjMvl7Mg3eGf7elbsOMAOh0koHKEufhPr/XWse3cVY7mUM0fn0K9PnFZbiYiISI+kYZWI2K4/p7F9eRYel0MF6yI2MgyDmEt+QnDHMoJbFxM5vAuwCO/fSHj/RvDE4BowCdeQ6ThScu2O22OZpslZg0dy1uCR1JwZ4K11xbxZZWEBoSN9+OBgKR+sP0jisI0MSxvExSOmkhQTY3dsERERkXajYZVIm1l2BxAR6TCGOxr30DNxDz2TcPleglsXE9z+IfjrwV9PcOObBLe8Q+wXfofhjrI7bo8XH+1m7sRCzo/8gDe3rGFrdZj1pfUQU4k/Zh+rGvaxYsEBJqWdzhmjssjLiLM7soiIiMgp07BK5JRo+0V7qGQfzuztYDiA6XbHEZGjHCm5OCZfjWfCfEJ7VhPcspjw/o04+41rMagKHyrGCgVx9BmsbWkdxGk6mD10LLOHQmWtn2dXf8AaXxQRRyP+0j68s28/i3esJ6r/ZqKsJPqHp5ASG0tsrElKbDTJcVEkxrlJiPHgcqofUERERLo2DatExHaVlgrWRboyw+nGVXAaroLTiNQehkikxfX+FQsI79uAkZCBa/BUXIOmNPVhSYdIivPwlWlnEQxN451tW9hYGWZ9cTmO9BIinlrqwg0sX1cOVODM3oazzy4sXyz+jZMBg5iEAPExLlK8ySTFekmM9ZAY5yEp1kNinJvEWA/x0W5MU4NHERERsYeGVSIiItJq/31mQKuxjvDBLU1fV5cRWP4MgY+ew5FbhHvIdBx5RRimw46oPZ7L6WTG0OHMGApHqn38Y00lBxtNwiGIifdSVRfAjKrHMC0sR5hjq4EDyVupSttPZcBD45ozATDjy8ERwmqIxfLHYBoGCbFuEmObhlfHBlqJse6modbRyzFep1bTiYiISLvTsEpEbNfvWMG6WwXrIt2N4Y0l5qr7CW1f0lTKXrkfrAjhkjX4StZgRCXgGnQ6rsHTMBMz7Y7bY6UmRPHt6Ze0OBaxLJbtT2Jr+U6skIOCc4dQVevn/caV1APuSByeGDc19QGcmbtwJB4h0hCLf8MUIpZFTdQ2ao0gew4lENme9qnP63SYTQOtYyuzPrE6K+kTAy6vW285RUREpPX0zkGkrZweos6/AwAzPt3mMCIi9jOj4nEXzcI1YiaRwzsJbllMsHgZBBuxfNUE1i4ktGc10fPv1iqcTmQaBpNyRjEpZ1SL4yNrrmB/3UG8Ti9j5hQRCkf40ZKlVAWgICWb0TMGUVXnZ0lwOT6zAmdDOhF/H+obQ7jyN4AjRKQ6lfCRHELhCEeqfRypbvzMLF63g6S4o8OsWDdZ6XG4HUaLAZf6tEREROQYDatE2sgwHTizCu2O0aM0F6ybKlgX6c4Mw8CRXoAjvQDPpKsI7VxOcOt7hEu34Ro8tcWgKrh7JWZ0EmZaPoahAUVn6hufS9/43ObLTofJDybeSml9GU7TSW5cNpZlsWGpic8HUwcN4tLzpxEIhvnBkvepD9XRPyeZEY4BVNUFWBZ+hnAkjFmVS8O+PALBCIbbhxXwAE3f28ZAmIPlDRwsb2h60o1ln5otNsrVtCrr6IqsFtsPjw671KclIiLS82lYJSK2q0IF6yI9jeHyNJWtD55KpOoghjeu+TorEsb//j+wGqrAHY0jvX/TkCtjAI70/hieGPuC91JRTi/9Evo2XzYMgx9N+l98IR+hSLjpmMMiLz6Lg/VlFGXlM6NvHqFIiPferSJiRZgxdjQXXTadhsYQP1z2U0JWiKFR48m1xlBVF2Bv4078tW5qq1zU1IcIha3jctT5gtT5guw7XHfCrIYBCTHuT6zUUp+WiIhIT6NhlYiIiHQoM7FPi8uRI7uxfNVNFwINhPdtILxvQ4vbm0dXaLkKz9DAwUZRzqjmr12mk5tHfQUAy2oaNAUjQc7IOZ2D9WXkJ+RhGAZBswF/xA/AoOw0zsrNxx8O8J13/4YVYzFn4jlcO/5iikuO8Pqut/FaCXhDafjrnVTW+amq9VNVF6Cqzk9NfYD/HmlZFkevDwC1J8yuPi0REZHuS/86i7SR5a+n7rGbAPBMvBJ30SybE3V/KlgX6V0c6QVNpex7VhM+VEykrJhIdWnz9ZGqg0SqDhIu3Y576JnNx8MV+4nUlOFI748ZnWhDcjnm2AAxyhnFJQMvaHGdx+Hm6iGXcrC+jAGJ/QAoqz+EdXTslBmTgWkahMwGFh96G4ArBs9jVvYkGoI+/r31OQbFZDImfQQp3lRq6gPNw6vKWj9Vdcf+Fzg62PJT3xg6LmNTn1Zjm/u0jq3MSor1kJLgJT8zTgNTERGRTqZhlcip0HtXEZGTYsYk4R56Fgw9CwCrsY7w4Z2Ey4oJHyomfGgnjvT+Le4T2rGEwJqXATDiUpv7sRwZBZgpeRgOV6f/OeR4Uc4oJmdNaHEsMyaD28bexMH6MgoS8wE43HDk4+ujMwAobShj5aG1wFqyYjPJiEkn6Kjh3/v+RZ+YDGYMOoOcuALCR7cmOkwHAIFgmKr6j4dXx1ZnfbxSy09lnZ9AMHJc3uP6tP7LqAGpfH3ecJwObVUXERHpLG0eVvl8PqKimpaEV1ZWsnDhQkzT5NxzzyUxMbG984lIL3CsYN1QwbpIr2V4Y3HmFuHMLQLAsiIQ9Le4TfhQcfPXVu0RQrVHCBUvazpgOjFT+zZtHRwyDUdyTqdll8/ndrjol9C3RS9WYcog7p32E0rrD5EV27RV1BdqJNGTQJW/mj4xTQOs/fWl7K87yP66g5yZOwWAHVW7+OO6h8mITuPawsvJicsiNgYsd5ABOWmYn1Lab1kWPn/4Eyuzjq3UCnx87OjlcOTjzYdrdhzh0Ve3cP15hVphJSIi0klaPayqqanh29/+NjU1NTz99NPU1dVxySWXcPDgQSzL4o9//COPP/44ubm5n/9gIiKfUHmsYD3ssDuKiHQRhmGCO6rFsahZtxA+vKt562D4UDGWr6bpykiIyKFiIoeKceYVwSeGVYEN/8FMzsWR1g/D5enMP4Z8jihnVIsB1rCUIfzi9O/jC/nwOJq+V1EOL4XJgyitP0RmdDoAB+vLCEVC7K87SIwrGoCN5Vt4dNMTOE0n3xv/LTJi0jnUcIQD9aX0iU4nLTqVaK+TaK+TrNQTl/hHLIs6X5DKGj9/f30Luw7W8uGGUhJjPVx6RkEH/m2IiIjIMa0eVv3mN79h2bJl3HDDDQA888wzHDhwgP/93/9l+PDh3H777fzmN7/hvvvu67CwIiIi0nsZLi/OrEKcWYVA00oZq+7IJ7YOFhMpL8GR1q/5PpG6Cvwf/uvoA5iYyTnNWwcd6QUYCRlNgzHpUj5Z7F6YMojClEEtrs+Ny+as3Kkc9pWT6EkAmgZYAOFImGRvEgDrjmxkwY5XAPjVlLuIc8eyvbKY4urdZMZkMDxlCE6z5dth0zCIj3YTH+3mlvkjufsfKzlU6WPh0j0kxLqZMU4fzIqIiHS0Vg+r3nrrLa655hq++c1vAvDmm2+SkpLCddddB8DVV1/NI4880jEpRaRH689p7FiehdftgBl2pxGR7sIwDIy4NMy4NFwDJgJghUMYjo/f3kTK93x8BytCpLyESHkJwc1Nxd54YnCk98eZMxz3CJ0wo7soSMxv7r46ZkLmGFKjkqkJ1OI62l92sK5pgBXriiHOHQvAuiObeGvvezgNB/dP/zkAHx74iK2V2+kTk8HMvmc2byOMj3Zz6+WjuPsfK6mpD/DvN7eTEONmQmFGJ/1JRUREeqdWD6vKy8sZOHAgALW1taxZs4Y5c+Y0X5+UlITP52v/hCJdmror2oP13+clFxE5SZ8cVAE4+44m5uoHCB/aSeTQsRVYuyAcaLqBv57w3vVgOFoMq0Ila4nUVTSVtydlH+3Uk64sMyadzJj0FscuHXQBp2efRn2wvvlYbaAOgPTotOaC9q2V21lRtoZETwKz888G4LntL7O1cgdn503j2/NHcs/jq2gMhPnry5uIi3ZT2Depk/5kIiIivU+rh1UZGRns3bsXaFpVFQ6HOeOMM5qvX7VqFX369Gn3gCLS8x0rWMdwooJ1EWlvZkwSZr+x0G8sAFYkTKRiX9Pg6ugWQkfGgBb3CW5+h9Ce1U0XnB4caf2aBldHz0BoRid09h9DTkKUM4r+n+jEAvjSsCu5fPDc5qEVQLQzikRPQnOpO0BJ7T721R3gya0L+PGkO7jp4hH85qm1hMIWv39uHXdcNYa8jLhO+7OIiIj0Jq0eVp155pk89thj1NXV8corr5CQkMBZZ51FWVkZf/nLX3jhhRf4+te/3pFZRaSHqjL24couBhWsi0gnMEwHjtS+OFL7wtCzgKb+q0+KVB38+ELIT/jgFsIHt3z8GHGpONIL8Iy7GDNBW8K6myhnVIterMsHz+PywfMIR8LNxwYk9udAXSlXF84nzh3LsHz44nkDePil7fj8YR54ei3f/8JYUhOiPuUZRERE5FS0elh1++234/P5eOaZZ8jIyODHP/4xXq+Xbdu28a9//YsLL7ywuXxdREREpDsxjJbbuqMvu5tIdWnzWQfDh4qJVOxr3rds1R4hVHsEz2mXNd/HCjTgX/H8x+XtsSnHPa50bY5PbPc8v/9MzsmbhtfpBWDt4Q28WvUCM6bP4D/v1lFdF+D+J9fyvS+MJTbKZVdkERGRHsmw/vujxBPYvn07AwYMOO5NVyAQoKqqivT09BPcs/srL68jElGpTmdJS4vj8OFau2NIJ3rize38Z8VeojwO/vDtrr8NUK9R6er0Gu0YVrCR8OFdTYOrsmIidRVEX/zj5vdGoX0b8C28t/n2RnRi05bBY2cfTM3HcHlsSt+1dLfXaJW/mp8tvZfGsJ9YVwwjg/N5c3kpAAVZ8dx25Wg8Lq0O7km622tUeh+9RqU7+KzXqWkapKTEnvC+rV5Z9aUvfYl58+Zx2223tTjudrt79KBKREREBMBweXFmFeLMKvzU6yO1R8B0wNGtZFZDFaHdK2H3yqMPYGIm5+IadDruETM7K7a0gwR3PBcVzOHZ7S9y1ZBLGZFaSF2dxdJNpRQfqOH/Pb+Bmy8ZgcM07Y4qIiLSI7R6WNXQ0EBOTk5HZukQjz76KM888wyGYZCXl8fPf/5zkpJ09haRrqSCvU0F66YK1kWk+3IXnoFr4GQi5SXNxe3hQ8VYdeVNN7AiRMr3YDUMa3G/wLrXsIL+ptVXaf0wPDE2pJfPYhgG03ImMSK1kCRvIgDjT7PY4llB1YYRrC0u5++vbeVL5w7R1k8REZF20Oph1Re/+EUeeeQRhg0bxogRIzoyU7tZuXIlzzzzDE8++SQxMTHcd9993Hffffz85z+3O5p0Y1YkRLh0OwBmfAZmbLLNibo/FayLSE9hON04Mga0OLtgpL6S8KGdRI4Orxx9Bre4T2DzO1jVpc2XzcSsj7cOphdgJmVjaMVOl3BsUHW4oZx/bnkSv8tP7PAV1K2ezHvrDpIU52Hu1P72hhQREekBWj2s2rBhA4cOHeKyyy7D6/WSmJiI+V9vnAzD4M0332z3kCcrMTGRu+66i5iYpk8ohw4dylNPPWVzKun2Ao34Xr4HAM/kq3EPn2FzIBER6crMmCTMfmOh39jjrrNCAQzgk82YkaoDRKoOENr2XtMBlxdHWj+853wd0xvXKZnlsyV5ExifOYb39i/hyqEXsGCnjyPVjbz4wW4SYj2cOTrb7ogiIiLdWquHVX6/n+HDh3dklpPy/PPP873vfe+448uWLaOgoICCggIA6urq+OMf/8hVV13V2RFF5HP0syZS/FEOUR4naPYnIr2I4XQTc/mvsBrrCB/a2bx1MHyoGAK+phsFGwkf3t1ie2C4vITA2oU40o+uvkrJw3C0+m2dnCKn6eSKwfOYnDWevLgc+l/ewM+ff4VA7H7++WaY+Gg3Ywen2R1TRESk22r1u5p//OMfHZnjpM2dO5e5c+d+5m3Kysr42te+xpgxY7jyyis7J5iIiIhIKxneWJx5RTjzigCwrAiRqtKmrYNlxWAYGMbHK9rDB7cS2rGU0I6lTQccTszUfJy5RbhHnovhcNnxx+h18uKO9rl66nD2X0skEsBw+/jzi05uu2I0g3ITbc0nIiLSXbVrAcKmTZva8+HaxZYtW7j88ss555xz+MlPfmJ3HBH5FJXsaypYT99udxQRkS7BMEwcSVm4Bk/FO+1LeKd+seUNwiGMT24JDIeIlO0gsOI5Gp7/OZFPdGBJx4t2RdM3vmlwFSnrRyhs8dtn1rH/cJ3NyURERLqnVq+sCgQC/Pa3v+W9996joaGBSCTSfF04HKa+vp66ujo2b97cIUFPxv79+/nSl77ED3/4Q8477zy744jICVRxrGBdW1hERFrDPfJcXEWzsWoPN20bLCsmvG8DkepSIuV7qH/ux3inXItr4GS7o/YKce5YvjHqq2yu2EZ1WiJ/e2UzjVEH+L83d3LXnMtJSYiyO6KIiEi30uqVVQ8++CB//etfqa6uJioqiv3799OnTx+cTielpaUEg0G+//3vn3SQzZs3M2zYMEpLj/8k8OWXX+a8886jqKiIc889l+eff75Vj/noo4/i8/l46KGHuOiii7jooov4zne+c9IZRURERLoKwzAw49NxDZiE9/RriL7057iKzm26MthI4+KHidSV2xuyF3GYDoanFnL6iD7MmpqEu/86Qhmb+Pnbj1DfGLQ7noiISLfS6mUMr732GhMmTODRRx/l8OHDTJ8+nbvuuotBgwbx7rvvctNNN+FynVw/QnFxMTfeeCOhUOi46xYuXMhtt93GF7/4RaZMmcKbb77JHXfcgdfrZfbs2Z/5uN///vdPaYAmIp2jnzWR4uU5RKtgXUTkpBkOJ96Jl+PMLqTx7b/gHjsXMzbF7li90ulFGSxb7sVPHbVlifzumXXcevko3C6H3dFERES6hVYPq8rKyvjyl7+MaZpkZGSQkpLC6tWrGTRoENOnT2fevHk89dRTXH755a1+8lAoxJNPPsl99913wkHXAw88wLnnnsudd94JwNSpU6murubBBx/83GFVe0lJie2U55GPpaV13VNzhxvgWANFbKyXhC6ctbuIinYDYJhGl/7ef1J3ySm9l16jvVja6YSHFGFGxWIYBgCWZdGwYyXRA8Y2H7NbT36NpqUN5nd97uIXz77ElsoYtlVW87s3F3HJ2QMZn11kdzxppZ78GpWeQa9R6Q5O9nXa6mGV1+ttMVDKy8tj27ZtzZeLiop4/fXX2/TkK1eu5N577+X6668nIyODH/zgBy2u37t3LyUlJdx6660tjs+aNYtXX32VvXv3kpub26bnPBnl5XVEIlaHP480SUuL4/DhWrtjnJDV+HFZal1dI4EunLW7ONCwE2f2diKmq0t/74/p6q9REb1GBYD6j/+9Cmx6G//7j+HsOxrv9OsxvPZ+ENdbXqPfPnsO9x9Zy7bD+yl2LOHX773J3AFzmNH3DLujyefoLa9R6b70GpXu4LNep6ZpfObCoFZ3VhUWFrJ48eLmy/3792f16tXNl8vKytr8SV1BQQFvvvkmN998Mw7H8cuid+7cCUC/fv1aHO/bty8Au3btatPzibQL08TRZzCOPoMxYpLsTtMjVBlHC9bTd9gdRUSkx7EiYYIb3gAgtGc19c/eRejgVptT9Q4up4NvXDKCtPQIGBYYsLskbHcsERGRLq/Vw6qrrrqKRYsWcdVVV1FXV8d5553Hpk2buPPOO/nLX/7Co48+yogRI9r05KmpqaSknLhLoba2aQIXG9ty2hYTEwNAXZ1OByydz3BHE33BnURfcCeufuPsjtMjaN2iiEjHMUwH0Rf9AGf+WACs+gp8L/8K/8oXsD5xdmfpGNFeF3dcMJuoPdMI7BnCkg8M3lt7gC0V2ymtL7M7noiISJfU6m2A5557LnV1dTzyyCNERUUxefJkrr76av71r38BkJWVxXe/+912DWdZn/0rrGm2etYmIl1YP2siO1WwLiLSYQxPDN4ZNxPc/Db+JY9DOERg5QLCBzbhPfNGzNhkuyP2aElxHr4zdxq//OdK6gnx97dXETNyKaYJXxx6BSPThtsdUUREpEtp07Rn/vz5LFy4sHnL3g9/+EPeeustFixYwGuvvcaAAQPaNVxcXFMRV319fYvjx1ZUHbteRHqGLtL5KyLSIxmGgXvoWUTP/RFmYhYA4YNbaXj2LkJ71tgbrhfISo3hlvkjcTtNiDtC0ArgDwc+98NZERGR3qjVw6prr72WJUuWHHc8KyuLwsJC3n//fc4777x2DXesq6qkpKTF8T179rS4XqQzWUE//hUL8K9YQPjQTrvj9AiV7MWZvR0rTZ1VIiIdzZGSS/S8H+EaPA0Ay1+H7/XfED6yx+ZkPd+A7ARuvGgYkSN5+LeNwSgdTIajPwA7q3dTH2ywOaGIiEjXcMJtgD6fj8rKyubLy5cvZ8aMGc3l5p8UiURYvHgx+/bta9dwffv2JScnh9dee40ZMz7eG/TGG2+Qn59PVlZWuz6fSGtYIT+BVS8AYETF4Ujvb3Oi7q/K2I8ruxgr3OqdySIicgoMlwfv9OtwZA+l8b1HcRVMxJF6/Hs8aX+jB6Zx7azBPPYaNFTB/U+u5Yb5+fx588NEO6O5YcS15MTpPa6IiPRunzmsmjt3bnPJuWEY3H333dx9992fenvLsjj99NPbPeBNN93EnXfeSUJCAmeccQaLFi3i1Vdf5YEHHmj35xIRERHpTVwDJuJI748RndDieLhiP47kbJtS9XzTR2VTXRfg+fd3UV7TyJ/fX4gvoRFfqJHDvnINq0REpNc74bAqOTmZX//616xfvx7LsvjDH/7AjBkzGDx48HG3NU2T5OTkdt8GCHDxxRcTCAR4+OGHefrpp8nNzeWee+5hzpw57f5cImKPYwXrMV4VrIuIdDYzPr3F5VDpNnwv/QrngEl4p3wBw+W1KVnPdsHp+VTV+XlnzQEqtvajT6GX8UNTGJ3edHbtA3WlZESn4TAdNicVERHpfJ+552b69OlMnz4dgAMHDnDFFVcwcuTIDgly8cUXc/HFF3/qdVdccQVXXHFFhzyviHQB6pYVEekSLMvC/+HjYEUIbf+A+kPFRJ39NW0R7ACGYXDNzMFU1wdYvf0IBzdncdBKJzLA4ojvCPev+iO5sdlcN/xq4tyxdscVERHpVK0uWP/lL3/5qYOq7du3U1xc3K6hRKR3qTRUsC4i0hUYhkHU7G/hyCoEwKoupeH5nxHY8B+dta4DmKbBjRcOY0BO0zbMj7Yc4t+LtvPyzjfwhRrZVlXMrmoV34uISO/T6mEVwEMPPcSdd94JNJWq33DDDVx44YWcf/75XH/99dTX13dISJGuy7A7QI9QZexrKlhP17BKRMRuZnQiUXNuxz3+EjBMiITwf/gvGt/4LVZjnd3xehy3y8E3LymiT0o0AG+u2Eda3WmMyxjFzL5nUpQ2DIAqf7WdMUVERDpVq4dVf/3rX7n//vs5cuQIAK+++iqLFy9m5syZ3HTTTaxYsYI//OEPHRZURERERDqHYZp4Rl9A1AV3YsSmABDas5r6Z+8idHCrzel6ntgoF7deNoqkOA8AC94pYVDkDC7oPwuAQw2H+fmy+3hy6wJCkZCdUUVERDpFq4dVCxYsYMaMGfzlL38BYOHChURFRXHPPfdw8803c9VVV/Haa691WFAR6bn6RSbhWz4bc+Nsu6OIiMgnODMHEnPJT3HmjwXAqq/A9/KvCO3fZHOyniclwcu3LxtJlKepUvbRV7eyaVclAE9sXYAv1Mji/UvYXrXTzpgiIiKdotXDqr179zJt2jQAgsEgS5YsYcKECXi9TWeIKSgoaF51JSIiIiI9g+GJwTvjZjxTrgWHE0f6ABx9jj87tJy6nLRYvnnJCJwOk3DE4g8LNrDrYA3XFl5GXlwOM/LOoDB5EACNIb/NaUVERDpOq4dV8fHx1NU19RQsW7aMhoaG5uEVQElJCampqe2fUKSLMZwe3GMuwj3mIhxp/eyO0yNUGCUqWBcR6cIMw8A99Cyi5/4I79n/g2E6mq9Tj1X7GpyXxA0XDMUA/MEwv3l6LQGfm1vHfI0LC5pWIB9qOMKPlvyK9/YvVfG9iIj0SK0eVo0ePZp//vOfvPHGG9x///04nU5mzpxJMBjkjTfe4IknnuC0007ryKwiXYLh8uAZNw/PuHk40vvbHadHaC5YT9OZRUVEujJHSi7m0Q4rgEhdBfVPfpfGJU9ghYM2JutZxg1J5+qZTSuoahuCPPDkWhoaLUzDJGJFeHjjv6gL1vPvrc9RUrvP5rQiIiLtr9XDqu9973t4PB6++c1vsnnzZr7zne+QlpbGqlWr+OY3v0laWhq33HJLR2YVkZ5OJ1cUEelWGt9/DMtfR3D96zS88Asi1WV2R+oxzhqTw/mT+wJwqMrHb55ei88fwjRM5g+8iHh3HDPyzqBvfC4AEStiZ1wREZF2ZVhtWDscCoXYtGkTGRkZZGRkAFBdXc0HH3zAmWeeSVRUVIcFtVN5eR2RiJZYd5a0tDgOH661O4Z0on++sZW3Vu0nNsrFb2+Zanecz6XXqHR1eo1KZ4nUHMK36E9EDu9qOuDy4p1yLa6Bkz/zfnqNto5lWTzy6hbeX3cQgGH9krnl0iKcDpOaQC2xrhhMw+RQwxH+tO5hrhp8CQOTCmxO3TPoNSpdnV6j0h181uvUNA1SUmJPeN9Wr6wCcDqdFBUVNQ+qABISEpgzZ06PHVSJ/DfLX0/DS7+k4aVfEty90u44IiIitjHj04m+8Pu4io6ezTXYSOPbD+F7569YwUZ7w/UAhmFw7azBFBU0bb3cuKuCRxZuJmJZxLvjMA2TYCTEX9b/nUMNR/jtmr9wuKHc5tQiIiKnrk3DKhEBKxwifHAr4YNbsRqq7Y7TI1Qae3FmbyeStt3uKCIi0kaGw4l34hVEzb4VwxsHQGjb+zQ892PCR/bYnK77czpMvnbRcPr1iQdgycYynn3n445Hl+nkzNypOE0nZ+dOIy065UQPJSIi0m1oWCUitmsuWE9VwbqISHflzCsi+tKf4cgqBCBSXUrD8z8jtGeNvcF6AI/bwbfmF5GRHA3Aq8tKeOOjvc3XT84azx3jvskF/WcBcLihnAdX/Zkjvgpb8oqIiJwqDatEREREpF2Y0YlEzbkd9/hLwDAxvLGYGepQag9x0W5uvWwkCTFuAP69aDvLNn1caJ8Vm4nDdOAPB3ho/WNsqyrm/1b8ltpAnV2RRURETtoJh1XvvPMOR44c6cwsItJL5Ucm4Vs+G8fm2XZHERGRU2SYJp7RFxB1wZ14z/k65tGtgQBWJGRjsu4vLTGKb182Eq/bAcBfX97E5t0tV085DQeDkwcAMLnPBOLcJy6vFRER6apOOKy67bbbeOedd5ovX3vttSxZsqQzMol0cTozpIiIyOdxZg7EmTmo+bIVCtCw4Gf4V72AFQnbmKx7y8uI4xsXj8BhGoQjFr97bj0lZR+faclhOrh04IXcPPIrLbYF/nPz0zSG/HbFFhERaZMTDqssy2LlypX4fD4Ali9fTnm5zi4iIu2vuWA9dYfdUUREpIP4lz9NpHwPgRULOPj4T4jUV9odqdsqzE/mK+cPBaAxEOaBp9ZypMrX8jYpg1psC1xy8CPuXfl7AuGAHZFFRETaxHmiK2bOnMmCBQt4/vnnm4/dfvvt3H777Sd8MMMw2LRpU7sGFJGer/pYwXrIZXcUERHpIK7BUwnvXU+kupTGPRsxSn+I98yv4MwbZXe0bum0oRlU1wf496LtVNcHuO+ptXzvmjHERbtb3C4cCRHvjuNAfSnDUobgdrhP8IgiIiJdxwmHVT/5yU8YNmwY27ZtIxAI8MILLzB27Fhyc3M7M5+I9AbaWSki0uM5UvKIvvgn+D/8J8Gt72H56/C99htcI2bhmXAphkMfWLTVzPG5VNX5eW1ZCWUVDTz4zDpuv2I0nqOdVgDRrmhuGnU9Sw58xMQ+44CmbYGrDq1lRt8zMA2db0lERLqeEw6r3G4311xzTfPl559/nssvv5wLLrigU4KJSO+RH5nErpV5xEa5YKbdaUREpKMYLg/e6deTNGQshxb+Pwg2Elz/OuGDW4k6+2uYCRl2R+x2Lj2jgOo6P0s2lrHzQA1/emEDN188Aqfj4yGUaZicnn0aQPO2wAP1peyqKeGrw7+Aw3Sc6OFFRERsccJh1X/bsmVL89dHjhzhwIEDuFwuMjIySE5O7pBwIl2R4Ykl6vw7ADATMm1O07MYht0JRESkM8QOn0q9tw++RX8icmQ3kSO7qX/uR0SdeSPO/NF2x+tWTMPgy3MKqWkIsnFXBeuKy/n761v58rlDMD7lH9baQB2ho2dlTI9O1aBKRES6pDat+92wYQOXXXYZU6dO5fLLL+fiiy/m9NNP54orrmD9+vUdlVGkSzEcTpxZhTizCjFjkuyO0yOoYF1EpPcxEzKIvugHuIpmNx2IhDBi9QHoyXA6TL4+dzh9M+IAeH/dQRa8t+tTb5salczt477BnPxzuKj/uUDTtsA1hzd0Wl4REZHP0+qVVVu3buULX/gCAJdddhkFBQVEIhF27tzJSy+9xLXXXstTTz3FwIEDOyysiPRMVUcL1iMqWBcR6VUMhxPvxCtwZhVi+WpwpPZtvs6yrE9dGSSfLsrj5FuXjeTuf6zgcFUjL3+4m8RYN2eNyTnuttGuKM7r37Tv/pPbAmf1PYsL+s/S37uIiNiu1cOq3/zmN8TExPDkk0+SnZ3d4rqvf/3rXHrppfz+97/nwQcfbPeQIiIiItJzOfNGtrhsWRaNbz+EI70A17CzNTxppYQYN7dePoq7/7GS2oYg/3pjGwkxbsYOTj/hfUrry6horAIgZIX0dy0iIl1Cq7cBrlixgquuuuq4QRVAZmYmV155JcuWLWvXcCJdUaShitqHvkTtQ18isOktu+P0CP0ik/Atn41zy2y7o4iISBcQ3PIuoR1L8H/4Txrf+C1WY53dkbqNjKRovjV/JB6XAwv484ub2FpSecLb943P5Y7x32Bq9qTmbYFHfOXsqz3QSYlFRESO1+phVSAQICYm5oTXx8bG0tjY2C6hRLoPffrYHiy7A4iISJdiJmVjxKYAENqzmvpn7yJ0cKvNqbqPfn3iuWnecBymQSgc4bfPrmff4RMP/NKj07hi8DwcpgN/OMCf1z3GvSv/wIrS1Z2YWkRE5GOtHlYVFhby8ssvEwqFjrsuGAzy0ksvMWjQoHYNJyK9Q5UK1kVE5BOcmQOJueSnOPPHAmDVV+B7+Vf4V72AFYnYnK57GN4/hS/PGQKAzx/igafWUlHz+R8sb6vcwcH6MoKRICW1+zs6poiIyKdq9bDqK1/5CuvXr+eaa67h9ddfZ+vWrWzdupVXX32Va665ho0bN3Ldddd1ZFYR6aGqjL1NBesaVomIyFGGJwbvjJvxTLkWHE6wLAIrFuB75f+I1J94W5t8bPLwPsw/owCAylo/9z25hjpf8DPvMyJ1KDeNvJ7R6UVcVNC0LbDcV0ltQFsxRUSk87S6YP2cc87hhz/8Iffeey/f+ta3mo9bloXH4+GOO+5g9mz1zYiIiIhI+zAMA/fQs3BkDKRx0R+JVB0kfHALDc/8EO+ZN+DMK7I7Ypc3+7Q8Kuv8vLliHwfLG/jts+u47fJRuF2OE96nMGUQhSlNOyb84QB/Xv8oDUEfXx3xBfrG53ZWdBER6cVaPawCuPrqqznvvPNYsmQJ+/btw7IscnJymDx5MomJiR0UUaSLsdSw1N7yI5PZvbIv8dEumGl3GhER6WocKblEz/sx/g//SXDre1j+Oqygz+5Y3YJhGFxx9kCq6wJ8tOUQO/ZV8+cXN/L1ecNxmJ+/yWJ56Ur21x0EYPWh9RpWiYhIp2jTsAogMTGRc889tyOyiHQ/Or2ziIhIpzBcHrzTr8eRPYzw4V24Ck6zO1K3YRoGXzl/KLUNAbaUVLF6+xH+9cY2vjBrMMbnvJeZkjWRUCTMxvItXNB/FgDV/lpiXFE4zTb/KiEiItIqre6sEhHpKJWU4MzeTlidVSIi8jlcAybinXRli2OBda8R3P6hTYm6B5fT5OaLi8hJiwXgnTUHeOnD3Z97P8MwODN3Cl8feR0O00EgHOAPa//Kg6sfotpf08GpRUSkt9KwSkRsV2UeK1gvtjuKiIh0M6HS7fiXPUXj2w/he+evWMHPP+NdbxXtdfLty0aSEu8F4Pn3drF47YFW3dc0mn5t+M+ed9hfd5Cd1bt5f//SDssqIiK9m4ZVIiIiItJ9hQIYnpimL7e9T8NzPyZ8ZI/NobqupDgPt14+ktgoFwCPvbaF1dsPt/r+M/ueyaQ+4xmUNIDZ+WcD4As1YqnTU0RE2lGrh1WRSKQjc4h0G2ZMEnE3PErcDY/iLjzD7jg9Qr/wZHzLZ+PaqjOKiohI2zhzhhF9yU9xZBUCEKkupeGFnxHY8KYGKCfQJyWGWy4twu00sSz48wsb2bG/ulX3dTlcXD3kUr5W9OXmbYEPrPoT/9ryDMFwsIOTi4hIb9HqYdVFF13EY4891pFZRERERETazIxJImrO7bjHXQyGCeEQ/g//SeMbv8VqrLM7XpdUkJ3A/8wdjmkYBEIRHnx6LQfL61t1X8MwcDuaVma9UPwq++sOsuTgR7y3f0lHRhYRkV6k1cOq3bt3ExUV1ZFZRKSXqjT2NhWsp2y3O4qIiHRThmniGXMhURfciRGTDEBoz2rqn72LUOk2m9N1TaMGpHLt7MEA1DeGuP/JNVTW+tv0GDP7nkn/hL4MTOzP9JzTAQhHwu2eVUREepdWD6umTJnCG2+8QSAQ6Mg8Il2eFQ4SOrCZ0IHNROor7Y7TI6hgXURE2oszcyAxl/wUZ/5YAKz6CsIl62xO1XVNG5nFvKn9ACiv8fPAU2toaGz9dr4ETzy3jL6RG0Zc27wt8N6Vf+Dtve9rG6aIiJw0Z2tvOGTIEB577DGmTp3KiBEjSElJwTRbzroMw+Duu+9u95AiXYnlq8X38j0AeKZ9GfeQ6TYnEhERkU8yvLF4Z9xMcNNbhHatwD1urt2RurTzJ+dTVRfg7dX72Xe4nt89u55bLx+Jy+lo1f2dphOn2fRrxVPbXqCkdh8ltfuIcUUzIXNMR0YXEZEeqtXDqj/96U/NX7///vufehsNq0TkZOSHJ7NnZT4JMW6YaXcaERHpCQzDwD3sbFxDz8IwjObjoZJ1QARn3ijbsnU1hmFw9YxBVNcHWLXtMFv3VvGXlzfzPxcNw/zE311rTM2eyJaK7aRGJTM2fSQAlmW1+B6IiIh8nlYPq7Zs2dKROURERERE2t0nhySRugoa334Iy1+Ha8QsPBPmYzha/Xa4RzNNgxsuGMp9T65h+75qVmw5xBMxbq46Z2CbBk1943O5Y/w3AZq3Bf6/dY8yI+8MClMGdVR8ERHpYVrdWfVJkUiEI0eOqL9KRNpFVXPB+g67o4iISA8WqTqAFQkBEFz/Og0v/JxIdZnNqboOt8vBNy8tIjs1BoBFK/fx6rKSNj9OnDuWOHcsAI9veY6tlTv4w9q/saVCJ1IREZHWadOwas+ePXzjG99g7NixTJ06lZUrV7JkyRLmz5/PihUrOiqjiPRwxwrWw6kaVomISMdx5gwn5uKfYKbmAxA5spv6535EcMcSe4N1ITFeF9++bCRJcR4AnnmnmA/WHzzpxxuWMhiX6WJAYj8GJvYH4FDDEZWvi4jIZ2r1sGr37t3Mnz+f5cuXM3Xq1ObjDoeDnTt3ct1117FmzZqOyCgiPZzeroqISGcxEzKIvugHuIpmNx0INtL41p/xvfM3rKDf3nBdRHK8l1svG0m0p2mL5CMLt7CuuPykHmt85mhuH3cz1w+/BofpoC5Yzy+W3cfPlt3HhiOb2zO2iIj0IK0eVt1///14vV4WLlzIj3/84+ZPQyZMmMDChQtJTU3l97//fYcFFZGeKz80Gd/y2bi3zrY7ioiI9AKGw4l34hVEzf42hjcOgNC292h47keEy9u+7a0nyk6L5ZuXFuF0mEQsiz8+v55dB2tO7rFi+zRvC1xZtpaQFaas4RBuhxuAmkAtK8rWEAgH2y2/iIh0b60eVi1dupQrr7ySlJSU40oWMzIyuOqqq9iwYUO7BxSRXkQnChIRkU7kzBtJ9CU/xZFVCECkupTAyhdsTtV1DMpN5MYLh2EYEAhG+M3TaymraDilxxyVNpy5BXMoTB7EgMR+ACwvXcUjGx/nex/8jHJfZXtEFxGRbq7Vw6pAIEB8fPwJr3e5XPj9WjotIm1XZZaoYF1ERGxhxiQRNed23OMuxohNwTPtS3ZH6lLGDk7jmpmDAahtCHLfk2uorjv59/wJnnhm9D2Dm0d9BdNo+lVk3eGNAMS740n2JgLw/v6lvLb7LSobq04pv4iIdE+tHlYNGTKEt95661OvC4VCvPjiiwwePLjdgol0WQ4njj6DcfQZjBmdYHeaHqHK3NdUsK5hlYiI2MAwTTxjLiTmsrsxj24LBAhXHSBUsqbXl4GfOTqbCybnA3CkupEHnl6Lzx9qt8f/xugbuH74NVzQfxaGYWBZFv/Z8w4v7XyNh9Y/1ny73v59EBHpTZytveGNN97I17/+dW677TbOPvtsAPbv38+iRYv429/+xqZNm/jNb37TUTlFugwzKp7oC+60O4aIiIi0M8Ppaf7aCgVofPNPRCr2YqYX4Bk3D0f2sOPqMHqLuVP7UVXn5711Bykpq+MPC9bzrfkjcTradHLxT+UynYxJL2q+XBOoa+6zmpA5FoCIFeEXyx+gf3xfpuVMJjcu65SfV0REuq5WD6vOPPNMfvGLX3D33XfzyiuvAPDDH/4Qy7LweDzccccdzJo1q8OCikjPlR+aRMnKfBJi3TDT7jQiIiIQPryLSO1hACKHivEtvBdH5iDc4y7GmTXE5nSdzzAMrp09mJr6AGuLy9m0u5KHX9nMVy4YitnOA7wETxzfm/Bt9tbtJ8WbDMDWih2U1pdRWl9GfnwuuXFZhCNhqvw1pEQltevzi4iI/Vo9rAK4+OKLmTlzJh988AF79+4lEomQnZ3N5MmTSUrSPxIiIiIi0jM4+wwm9sp7Cax7jcCG/0DIT7h0G76Xf4UjqxDPuItxZA60O2ancpgm/zN3OPc+sZriAzUs3VRGYqyHy84a0O7PZRgGeXE5zZejXF5GpA5le2UxYzKaVmFtKN/CQ+sfY1BiAVcXXkpqVEq75xAREXu0aVgFEBsby8yZM6moqMA0TQ2ppNexAg0E1r0OgDN/NI7UfHsD9QBV5l6c2bsIOz3AFLvjiIiIAGB4Y/FMuBTXiJkE1i4kuPEtCAcIH9hMw4u/wJE7As/4S3Gk9rU7aqfxuBx889IifvnPVZRWNPDa8hISYt3MmpDXoc+bH5/H/xR9CX84gOfoFsFlB1cAsKd2L3Hupq6xXdV7CEVCFCT2ay5wFxGR7qdNw6ri4mIefPBB3n//fXw+HwBxcXGcffbZ3HLLLWRmZnZISJGuxAr4CKxqOq21GZuiYVU7qDL3NhWshzyff2MREZFOZkbF4514Be6i2QTWvEJw89sQDhHeu57IgEm9algFEBft5tbLRvKLf66kui7Ak2/tICHWzcShHf+7wLFBFcB5/WeSEpWMaZjNx1/Z9R82V2wjLy6H/x33jV7bMSYi0t21eli1fv16rr32WoLBINOmTSMvLw/Lsti1axcvvvgiixcv5oknniAvr2M/VRERERERsYMZnYh38tW4R84hsPplwmXbcBZMbL7eCvmJ1BzCkZxrY8rOkZoYxbfnj+Sex1fh84f528ubiYt2Myw/udMyZMf24ZKBFzRfbgj62FG1E2haiXVsUPXM9hfJjunD6PQReJ3eTssnIiInr9XDqnvvvZfY2Fj+9a9/HTeQ2rZtG9deey333HMPf/jDH9o9pIj0bPmhyZSs7EeiCtZFRKQbMGOS8E75AlYkjGF+vNUsuPEt/MuexNl/Au6xc3Ek9ewz1uVlxHHzxUU88NQaQmGL3z+3nu9eNYa+mXG25Il2RfHzyd9nxaE1DEzsD8DhhnLe3vs+AGUNh5k7YA4AlmVp1ZWISBfW6o3ca9eu5dprr/3UlVODBg3i2muvZcmSJe0aTkRERESkqzJMR/PXViREYN1rAIR2Lqfhme/je+vPRKpL7YrXKQr7JvGV84diAP5AmAeeXsvhKp9teWLdMZyRczrZsX0AOOw7Qpw7FoAJmWMAOFBXyl1LfsXLO1+n2l9rW1YRETmxVg+r4uPjCYfDJ7w+JiYGr1fLakWk7SqNEpzZ2wml7LA7ioiIyEkxTCfRF96Jc8AkwADLIrRjCfVPfQ/fO38jUnPY7ogdZkJhBlec03RmxJr6APc/uYaahoDNqZoMTRnMLyZ/n2+NvpGs2KZOrWWlK6lorOTV3YsIhJty1gbq8IUa7YwqIiKf0Oph1dVXX82jjz7Kjh3H/zJZVlbGP/7xDy677LJ2DScivUNzwXpKsd1RRERETpqZkEnUWTcSPf8XOPtPaDpoRQhte4/6J79L4+JHidSV2xuyg8wYl8u5E5t2YJRV+njw6bU0BkI2p2riMB0MTCpovpwd24e+8bkUJPQjLToFgFd3v8md7/+Mxzb9m4gVsSuqiIgcdcLOqjvvvPO4Y36/n7lz5zJ16lT69euHYRjs37+fxYsX4/HoLF4iIiIiIo6kLKLO+TrhigsIrHie0O6VYIUJbnmHSH050ed+x+6IHeLS6QVU1QZYsrGUXQdr+dPzG/nGJSNwOlr9+XinmJA5hgmZY/AfXVUVjIRYUbqGYCRIbaAO02jKu+bQevrEZpIRnWZnXBGRXumEw6oFCxac8E5vv/02b7/9dotjDQ0N/PnPf+Zb3/pWu4UTkd4hP3Q6e1f1JynOo4J1ERHpMRzJuUTN/AbhI7vxr1hAuGQtntEXtriNFQpgON02JWxfhmHw5TlDqG0IsGFXBet3lvPYq1u47rzCLllm7nE0/b07DJMvDruSZQdXMCp9BACNIT//2PwUjWE/M/LOaC5mFxGRznHCYdWWLVs6M4eIiIiISI/kSM0neva3CVcdwJH48RkCI3UV1D/7Q1yDp+EeeS5mVLyNKduH02Hy9XnD+b/HV7O7tJYPNpSSGOfhkukFn39nm5iGybCUwQxLGdx8bNOhbTSG/QD0S2ja3ugL+fj31gVMyBxLYfLA5hVYIiLS/vQTVqSNDHcU7jEX4R5zEWZqX7vj9AhV5tGC9WQVrIuISM/1yUEVQGD1S+CvJ7juVeqfuB3/8mewGutsStd+vG4n35o/kvTEKABeWbKHRSv32ZyqbcZkjeCu025jTv45DEsZAsCqsnWsKFvDH9f+ja2VTe9Z1G8lItIxTriy6tM8//zzfPDBBxw+fJhI5PgfzIZh8Nhjj7VbOJGuyHBH4xk3z+4YPcqxgvVQUN13IiLSezgLTiNSuZ9w6TYI+QmseZnAxkW4R8zEXTQLwx1td8STFh/j5tbLR3L3P1ZS0xDk8f9sIyHGzbgh6XZHa7WMmHTO6/9xP0FtsA6X6STaGc3gpAEAvLvvQz4qXc3EPmM5Pes0HKbDrrgiIj1Kq4dVDzzwAH/+859xuVykpKRgmlqUJSIiIiJyspxZQ3BccCfh/Rvxr3iOyKGdEPQRWPUCgQ3/wV00G/fwGRjuKLujnpT0pGi+ddlI7nl8Nf5AmIde2khslIshfZPsjnZSZuefzfScyRxqONK8BXDZwRXsrTtAfbCeqdmTADjiqyDJk6DBlYjIKWj1sGrBggVMmTKF3/3ud0RFdc9/MEWka+r7yYL1WXanERER6TyGYeDMGY4jexjhvevwr1hA5MhuCDQQWPEcwU1vEXPFPRjO7rn6OD8znpvmDefBp9cRClvc++81JMd7SIn3khzvJSXB0/T/xy7He/C627T5o1NFOaPoG58LQDgSZnhqIXXBBk7rMxbDMLAsiz+ufZiGUAOz+p7FmblTbE4sItI9tfpfgrq6OmbNmqVBlfR6kYYqGhf9CQD3yPNw5hXZnEhERES6O8MwcOaNxJFbRGjPagIrFhCp2Iszb1S3HVQdM7xfCtfNKeQvL28iYlkcqW7kSHXjCW8f43V+YnjlJTmhabh17FhCrBuzC5xd0GE6OL//LOb0m0EoEgZgT+1eyhoOARCKhICmXqslBz5iZNpwYt0xtuUVEelOWj2smjp1KkuXLmX+/PkdmUek6wsHCR/cCoA1SJ+WtYemgvXdhJxe4HS744iIiNjGMAxc+WNw9h1FaNdKHOn9W1zfuPhhzOQ8XIXTMRwum1K23aThmaQkeFlbfISKGj/lNY1U1DRSWevHslretr4xRH1jHSWHPr1s3mEaJMW1XJ31yWFWcievzjINE7ejaVtgZnQ61wyZz7LSlUzIHAPAjqpdPL71WZ7c9jw3jLiW4amFnZZNRKS7avVP8R/+8Id8+ctf5jvf+Q7nnHMOKSkpGJ/yicb48ePbNaCI9HzVzQXrXrujiIiIdAmGYeLq3/J9dbhsB8EtiwEIrF2Ie/QFuAZPxXB03W1znzQoN5FBuYktjoUjEapqA5TXNDYPsMpr/Ef/v5Hy6kYaA+H/uk8bV2clHBtkeTp8dZbX6WVS1ngmZX38vVt/ZFPz1/kJeQBsq9zBuiObmJg5jpy4rOMeR0Skt2v1v2wHDhygtraWV155hYULFx53vWVZGIbB5s2b2zWgiIiIiIiAFfRjxKVh1R7Gqq/A//5jBNa+gmf0hTgHnY7RDQu9HabZNExKOPEHVg2Nof8aZjW22+qs1IRjq7Ga+rKODbPi4tuv+mTegPMoSh3K/vpSYl1N2wDf37+MlYfW8v7+Zfxqyl14nR4iVqS5uF1EpLdr9bDqpz/9KTU1NVx//fXk5+fjdHaPT3BEpOvrG1TBuoiIyOdx5gwj5vJfEtz2AYFVL2LVlWPVHqFx8cMYa17BM+ZCnAMmYfSws3ZHe51Ee2PJTY/91OtD4QhVdf4WA6zyGj/l1U1fH6lpxH8Sq7Nio1wty+BPcnWWaZgMTCpgYFIB0PQhvy/c9Lyj0kbgPdpJ9rcN/yRiWUzJPo1hKUNa9XcjItJTtXritH37dm6++Wa++tWvdmQeka7P+vybyMnpAl2pIiIiXZphOnEPmY5r4OkEty4msPolrPpKrJoyGt/5C+aal/GecxOO5By7o3Yap8MkNSGK1IRPXw1lWRY+f6hpgHVsmFXdcoVWVd3xq7PqfEHqfEFKyk68OuuTw6tPrs5KSfCSHOfF4z5+tZthGNw08nrKfRWErQgANYFa1h3ZRMSKEOeOaR5WHWo4TFpU6qfWr4iI9GStHlZlZmZi9rBPaUROmd44tItjBetBlwrWRUREWsNwOHEPPQvXoCkEt7xLYPXLWL5qIr4azNgUu+N1KYZhEO11Ee11tW51VnUjjWGLvQerm/uzTrQ663BVI4er2rY6KyXh2AqtGJJi3EcfK8zEzLGsOrSOiX3GAVDZWMVPl95Ln5gM5g+6kEFJA9rpb0REpOtr9bDqK1/5Cr/73e+YPn06AwboB6WItJ9qhwrWRURETobhdOMePgPXkOkEN70FTjeG++MVRqF9GyEcwJE3SqtzPkOL1Vm5kJYWx+HDtc3XH1uddaS68b+2G7bn6qxhTIorYu8uFw0J5Wz2fYSFxYH6UqKcTd/Tcl8lJbX7GJ5aiMtULYuI9Fyt/gm3ZcsWDMPgwgsvJDc3l9TUVByOlstaDcPgsccea/eQIiIiIiJyYobTjbtodotjViSCf8m/iFQewEzrh2fcPBw5IzS0OgnHVmfleV3kZcR96m1C4QhVtf7jCuCPbT8sr27EH2z96izDHcaRMhBXfC1/fWYfqfHl1CVsYJ+5Bo/h5bqCr5GbkkLC0dVZIiI9SauHVW+//TYOh4PMzEyCwSAHDx7syFwi0ovkBSezd1V/kuM9dkcRERHpMSLVB4nUVzV9fXgXvlfvx8wYgGfsPBzZQzW0amdOh0lqYhSpiSfuzmrwh44Wv7dcnXVswFVV62+uR7UCUYQOFhA6CHupZ29ZPZ7hxZjR4Kv1cP/jTWdhHzTA5JqzishJTu6kP6mISMdr9bDqrbfe6sgcIt2GEZ1A1Pl3AGAm9rE5jYiIiMincyRlE3vlrwmsf4PA+tch2EikbAe+hb/G0Wcw7rHzcGbprHOdxTAMYrwuYtqwOuvIf2833HY6gdiDWOGjv8Y5A+yJ+ZBfLn+bi3IuYebwok78E4mIdBxtdBZpI8PpxplVaHeMHqWpYH0PIacK1kVERNqT4YnBM24e7uEzCKx7jcCG/0DIT/jgVnwv/wpH9lA8E+bjSOtnd1ShbauzymsaWVj8NgfcTVsIn/5oBaX73Fx+9kA8ruPPQigi0p20elh17bXXtup2f//73086jIj0TipYFxER6ViGNxbPhEtxjZhJYO1CghsXQThIeP8mItVlGlZ1E/+9OmvUgPk8tjKOj/ZsI1zWl3fKDrCpdC9fnTWWgj7aFigi3Verh1X79u077lgkEqGyshK/3092djYDBw5s13AiIiIiItJ+zKh4vBOvwF00m8CaVwiXbsfZf0Lz9VawsWl4ldrXxpTSWoZh8KVx53LegOn81beZ7aWHqc74kPtWLuXs1IuYd9oITHWTiUg3dMqdVeFwmEWLFvGDH/yA66+/vt2CiXRVkZpD1P/7fwHwnvEVXIOm2Jyo++sbPJ19qwpIUcG6iIhIpzCjE/FOvhorEsEwzebjgY2LCCx/Gmf+WNzj5uJIzrUxpbRWWmI0d1w1hgfee5Kd4Uagkdc2r2D3ngjXn1dIYqzeY4lI92J+/k0+m8PhYObMmcyfP5977723PTKJdCP6pEpERES6r08OqqxIiOD6NwAI7V5JwzN34Xvzj4SrDtgVT9rANA2+NXU+45Mn4ajJIlzWl427Kvjh399h1bZDdscTEWmTUx5WHZOfn8+WLVva6+FEpBdpKljfTjBph91RREREei3DdBJ90fdxDpoChgFYhHYup+Hp7+N7689Eqsvsjiifw2E6+NKoefxy9teZNKwPOAOE+n3AQ5se5m+vr8EfDNsdUUSkVdplWBUIBHjxxRdJSUlpj4cTkV6muWA9eafdUURERHo1Mz6dqDO+Qsz8X+IcMAkwwLII7VhC/VN34nvnb0RqDtsdUz5HjNfNVy8YyqgpFZieRhzxFSzdv4afPvoRJWW1dscTEflcp3w2wEAgwK5du6ipqeEb3/hGuwUTERERERF7mImZRJ11I+HR5xNY+TyhnR+BFSG07T0sXzXR595qd0Rphf8ZfymPrrfYur8c36FcDtLAzx//gEtOH8qM8bkqXxeRLuuUzgYITZ1V/fv35/zzz+eqq65qt2Ai0nv0DRwrWPfaHUVEREQ+wZGUTdQ5NxEu39s0tNq9Es/YuS1uYwUbMVz6N7wrcjvcfHXkVQSGB3ktYT8vLt2KY8iHPLdnE+t3T+Wrc4pIUPm6iHRBp3w2QBERERER6dkcKblEzfwGkeoyzISM5uORunLqn/4BrsFTcY+agxmdaF9I+VSGYeBxurloSj/2ez9kY00jpqeUrbs2cdfDjVw3p5CRA1Ltjiki0kK7FayLiJysKocK1kVERLqDTw6qAAKrXoKgj+CGN6h/4n9pXPokkUZ1InVV1xbNZVDiQBJCfQkfzqG2IciDC1byzze2ElD5uoh0ISdcWfX73//+pB7w5ptvPukwItI7VTlKmgrWg1F2RxEREZE2cA06nUhNGeEDmyEcILjuVYKb38Y97BzcRbMxvLF2R5RPiHXH8I3R1xOKhFiZXcE/3lyPNehD3juygy2PVfA/F44gJ13fMxGx3ykPq4z/KuXTsEpEREREpHdwZA4k+vw7CB3YTGDFAsKl2yDYSGDNywQ2LsI9YibuolkY7mi7o8pRpmHidriZNCyTNYH/sKHSh5m5h7LiBH76mJ/5ZxZwztic437PExHpTCccVi1atOhz71xXV8cDDzzAO++8g9PpPOEZA0V6EjM+nbgbHrU7Ro/SNzCF/asGkJqgclYREZHuyJlViOOCIYT3b8S/4jkih3ZC0Edg1QsEN79NzJW/xnCqyLurmT/kPKrWVxCo91BS0QfLivDEoi1s2FnBdecVkhDjtjuiiPRSJxxWZWdnf+YdFy5cyK9+9SsOHTrEmDFj+PGPf8ygQYPaPaCIiIiIiHR9hmHgzBmOI3sY4b3r8K9YQOTIbpz9xmlQ1UWlRiVz29ivE7bClAxo5KFX1lCft5jNh3K462/VXH/eUIoKVL4uIp2v1WcDPGbv3r385Cc/4YMPPiAhIYGf//znXHrppR2RTUR6iSrHHpzZJQRdUcBku+OIiIjIKTAMA2feSBy5RYT2rMaRmt/iev+qF3HmjsCR1s+egNKCy+HChYtBuV4KJu5hQ0UDZt426rfH8JunQ5wzNof5ZxbgcjrsjioivUirh1XBYJCHHnqIv/zlL/j9fubNm8ftt99OUlJSR+YT6XKskJ/woZ0AmIlZmNEJNifq/qode3FlFxNUwbqIiEiPYRgGrvwxLY6F9m0ksOI5AisX4BoxG8+4eRhObTXrKs4vOIeDDQeJtpIpqe9DIxHeXFnClpJKbrhwGDlpKl8Xkc7RqmHV0qVL+clPfsKuXbsYOHAgP/rRjxg3blxHZxPpkqz6Snwv3wOA98wbMAdqJdAps+wOICIiIp0hUl0KpgMiYYLrXiW0exXeaV/GmTXE7mgC5MZl893x38QwTGqHWfy/l1ZxMGkRBw/246eP+rj8rAGcNSZb5esi0uE+c1hVUVHB3XffzSuvvILX6+U73/kOX/7yl3E627x7UETkhPICU9i/WgXrIiIiPZ172Nk4+gym8d2HiRzeiVVThu/lX+EqPBPPaZdhuLXK2m7RrqYzN0YlQlrRNsrK63AXrMe/xcO//hNh/c5yrptTSLzK10WkA5knuuKJJ57g3HPP5ZVXXuGss85i4cKFfPWrX9WgSkRERERETpojOYfoi36AZ+KV4GgaeAQ3v039098nVLLW5nTySWfmTiHWFcOA2CEkkgXAuuIj3PXwcjbsLLc5nYj0ZCecPP3kJz9p/vqtt97irbfe+twHMwyDTZs2tU8yEek1VLAuIiLSuximibtoFs780TQufoTwgc1Y9RX4XnsAV+GZeKd+0e6IAgxJHsh3x9+C1+nFKnLw8Otr2Wi+Rt2+gdz/VIAZ43K59Iz+Kl8XkXZ3wmHV3LlztRdZRDpFjQrWRUREeiUzPp2o8/6X4NbF+Jf8G4I+zOQcu2PJJyR5EwGwHBZG37WYFTW4B63Ev2ki/1kBm/dUcuNFw8hOjbE3qIj0KCccVv3qV7/qzBwiIiIiItILGYaBe8h0nLlFBDe9hWvomc3XWVYEy1eDGZ1oX0ABmr5PEzLHsKNqJwXxA6mIz2V3fS37Dtfx00c/4vKzBnDmaJWvi0j7UAGViNguL3C6CtZFRER6OTMmCc/4S1ocC256G//yZ/BMvBzXkOkahNhsfOZocuKySPQk4Brp5tn3N/N25UsESwbzzze2sWFnBV+aM4T4aJWvi8ipOWHBuoiIiIiIiF2sxjr8y5+GoA//e4/ie+X/iNQcsjtWr9cnJoMopxfThCOJS3HEV+AdugwjqpY1O47wo78tZ8Mula+LyKnRsEpEbFflKMGZvZ1g0g67o4iIiEgXYXhjiTr7axgxyQCED2ym/ukfEFj3GlYkYnM6MTAYnDQA0zAZkVrImL79AaiuD3D/k2v596LtBEP6PonIydE2QJG2crhx9BkMgBEVb3OYnqHaUaKCdRERETmOM28kMfN/gX/50wQ3vQXhAP6l/yZYvBzv9OtwqIzdNoZhcE7edPon9KVPTCbekR4W5e/iuZ0L8O8ZzBsf7WXLnkpuuHAYWSpfF5E20soqkTYyY5OJvuBOoi+4E2fOcLvjiIiIiPRohjsK75RribrgToyEDAAih3fS8NyP8K98Hiscsjlh79Y/IZ8opxcLi63G2xiJZUSNWILhaaDkUFP5+tur92NZlt1RRaQb0bBKRGzXNzAF3/LZxOyaZXcUERER6aKcfQYTc8nPcI+cA4YBkTCBlc8TPlRsdzQBLMuiT3TTMLEofTCzRw3BAAKhCP94fSu/f249tQ0Be0OKSLehbYAiYjt9ziYiIiKtYTjdeE67DGf/8TS++zCOtHycR+sZxF4O08HFA89nYFJ/BiT2J8rpZUDfaB5Z8yx1OweyevsRdh5czlfOH8qw/GS744pIF6eVVSJtFGmsxb9iAf4VCwhX7LU7To9Q7diDM3s7gUQVrIuIiMjnc6T1I/riH+GZfHWL4/41rxA6sNmmVAIwInUoUU4vESvCh7WvEk7cS9yopeBqpLouwH3/XsNTb+0gFFb5uoicmFZWibRVYx2BVS8AYCb2wZGca3Og7q/asfdowXq03VFERESkmzBMJ5gf/zoTLt1OYPkzgIVryBl4Jl6G4dZ7C7uEI2GinU0nzxme0Z9BZ4/kiUXbCQQjvLa8hE17KrjxwmH0SVH5uogcT8MqERERERHp9iK1h8HpglCA4JZ3CJWswTv1izj7jrY7Wq/kcrj40tArGZI8iFFpw4lyesnL8vCHDxdQsa0vJWV1/OSRj7jinIFMH5mFYRh2RxaRLkTbAEXEdnlHC9ZjVbAuIiIiJ8k1cDIxl/4CR/YwAKyGKnyvP4hv0Z+I+GpsTtc7GYbBpD7jmrcFvnrwRXzx20kZtxLDGSAQivD317byhwUbqPMF7Y4rIl2IhlUiIiIiItIjmPFpRM25De+068DdtAUtVLyMhqe+R3DHEixLp3WxSyAcIBQJATAoLZvvXDKexFg3AKu2Heauvy1j0+4KOyOKSBeiYZWI2E4F6yIiItJeDMPANWQaMfPvxpk/BgDLX0fjW3+m8c0/aGBlE6/Ty82jvsK8AedxTeFlDO2XwnevHUHeiFIgQtXR8vWn31b5uohoWCUiXUC1owRXdjGBxGK7o4iIiEgPYcYk4Z3xDbzn3IQRFd90LK2/upFsZBom5+RNb94W+MyuZzkctYbcyRtxuyNYwKvLSvjFP1ZSWtFgd1wRsZGGVSLSdei9o4iIiLQjwzBw9R9PzPy7cY+5CHfRx/2YlmURqSu3MV3v1hD0Ue1v6hLLSUrirmsnkpcRC8Ce0lp+/MhyFq89oJVwIr2UhlUiYrs8/9SmgvXdKlgXERGR9md4Y/GMm4dhOpqPhbZ/SP2T3yWwdiFWJGxjut4p1h3Dd8bexKy+Z3FN4WVkpcbyrSuGUjShDrAIBCM8+uoW/vi8ytdFeqMeP6x68MEHOffcc5kzZw6/+tWviES0/1lEREREpDezgn78S56AcBD/sqdoeOHnhMv32h2r13E7XFxYMLt5W+Dj255iO+8z7IxdxMc1DRZXbj3Mjx5ezuY9lTanFZHO1KOHVe+++y4ffPABL774Ii+99BJr1qxh0aJFdseS7s4b27SMfMxFmMnZdqfpEapUsC4iIiKdyHB58M78BkZCJgCRw7toeO7H+Fc8hxXWKh471ARqKa0vAyA+xs1PvzSR0QNTAais9XPvE6t55p1ila+L9BJOuwN0pOnTpzN58mRcLhcVFRXU1taSkJBgdyzp5kxvHJ5x8+yO0aPUOEtwZe8kEIixO4qIiIj0Es4+g4m55KcEVr1IYO1CsMIEVr1IaNcKGi/6Brj72B2xV0n0JHDH+Ft4aefrXFRwLlFOD1++oIDE1RV88B4EQhEWLt3Dpt0V3HjhMDKSo+2OLCIdqNuvrHr++ecZOnTocf+rra0FwOVy8Ze//IWzzz6b1NRURo0aZW9gETmOajNFRETEDobTjWfCpUTPuwszJQ+ASOUBDjz6PRo/fBwr6Lc5Ye8S44rmisHzmrcF/n3zkyytX8iEGYfJSW8aTu0ureXHj3zEeypfF+nRuv2wau7cuWzatOm4/8XFxTXf5qtf/SrLly8nNTWVX//61zamFZFPc6xgPW7PTLujiIiISC/kSM0net5duMdfCg4nYBHc8AbhA5vtjtZrHfFVsLumBICw6eMHXxjPzPG5APiDYR55dQt/emEj9Y3atinSE3X7YdVn2bZtG5s2bQKaVlidf/75bNmyxeZU0t1Fao/Q8NIvaXjpl4T2b7I7joiIiIi0A8N04hl9PtGX/BRPzhCc/cfj7DvK7li9Vnp0Kt8dfwvjMkZxTeFluF0OLpiWzeUXJpIQ4wZgxZZD/Ojh5WwtUfm6SE/To4dVO3fu5Ac/+AGBQIBwOMzChQsZP3683bGkm7NCAcIHtxI+uBWrsdbuOD1C9dGCdb8K1kVERMRmjsQssq79Gd5p17U4Hlj3GsHdq2xK1Tsle5P48rCrmrcFPrbp37xU+iRnzG5g5IAUACpq/Pzf46t59l2Vr4v0JF1mWLV582aGDRtGaWnpcde9/PLLnHfeeRQVFXHuuefy/PPPt+oxZ8+ezfTp05k7dy5z584lNjaW//mf/2nn5CJyqqqdJbiyiwkk7LQ7ioiIiAiGYWK4o5ovh4/swb/saRrf+C2+N/9IpKHaxnS908H6MrZVFmNhcaixlG9cPIIvzByEy2liAa8s2cMv/7mKssoGu6OKSDvoEmcDLC4u5sYbbyQUCh133cKFC7ntttv44he/yJQpU3jzzTe544478Hq9zJ49+3Mf+5ZbbuGWW27piNgiIiIiItILWPWV4PaCv57QzuWE9m/EO+kqnAMnYxiG3fF6hezYPtw+7mZeKH6VawrnY5omp41IJiE1h+f/U8G+w3XsOljDjx/5iGtmDGLy8Ex9b0S6McOy8RQKoVCIJ598kvvuuw+Xy0VVVRXvvvsumZmZzbeZMWMGw4cP54EHHmg+9q1vfYutW7fy6quv2hFbernAkX3s+3PTADR93q3EDj3d5kTd36//sYLFa/aTlRrDn+88x+44IiIiIscJ1VVS/vrfqN+ypPlYVMFo0s69EWdCmo3JeqeIFeH/3vsT6w9t5UsjL2P3pgReXPzxKv2po7L5+qUjiY1y2ZhSRE6WrSurVq5cyb333sv1119PRkYGP/jBD1pcv3fvXkpKSrj11ltbHJ81axavvvoqe/fuJTc3t8NzlpfXEYnotKidJS0tjsOHu24XVLiyrvnrmhofvi6ctbto9DedxSUcjnTp7/0xXf01KqLXqHR1eo1KV/fpr1En5rQb8eaOxf/+37F8NfiKV1Py52/hmTAf19AzMYwu07LS4+2s3sPqgxuxsFi+dy1fnfQFCjLj+Nsrm6mpD/Demv1s2nmEr14wjEG5iXbHbXf6OSrdwWe9Tk3TICUl9oT3tfWnaUFBAW+++SY333wzDofjuOt37myajPfr16/F8b59+wKwa9eujg8p8pm0tLg9VDuPFawX2x1FRERE5DO5+o0j5rJf4hw0telAsBH/B//A98qvsSIq+O4s/RP68s3RN1CQkM8XCudjGAYFuVF8++qBFBU0la+X1/i55/FVPLd4p8rXRboZW4dVqamppKSknPD62tqmCVxsbMtpW0xMDAB1dXXH3UdEup+a5oJ1DatERESk6zM8MUSdcT1Rc27DiG36fcaRMQDD1MqqzjQoqYBvj/kaUc6o5rMF/n7DHznnTDdXzxiE02FiWfDyh7v51b9WcUjl6yLdRpf+afp5dVqm/jEQERERERGbOHOGEzP/F7jHzcM95sIW10VqDtuUqnc5VqK+tXIHG8q30BDyseTgCs4em8NdXxpHdlrTQoedB2r40SMf8eGGg5/7e6aI2K9LT3vi4uIAqK+vb3H82IqqY9eLSPeW2zgV3/LZxJXMsjuKiIiISJsYLi+eMRdhOD4u8g7uWkH9k9/F/9GzWKGAjel6j8LkQVw37Gpy47K5pvBSAJITTW69qpBzxuYA4A+E+evLm3nopU00NB5/JnoR6TpsLVj/PMe6qkpKShg8eHDz8T179rS4XqQzmbGpRJ1/R9PXSdk2pxERERGRrsSKhPB/+DhYYQKrXyK0awXeadfhyBxod7Qeb2zGSEanj8A0zOZtgfvrSvnKadcwvP9IHn5lEzUNQZZtKmPHvmpuuHAoA3MS7Y4tIp+iS6+s6tu3Lzk5Obz22mstjr/xxhvk5+eTlZVlUzLpzQyXB2dWIc6sQsyoeLvj9AjNBesJO+yOIiIiInJKDNNJ1KxbMFOaTgoVqTpIw4t30/jBP7GCjTan6/nMo2dkXHt4IxvKt1Dpr+KtkvcoKkjhJ9efxoj+x8rXG/nVv1bx/Hs7CasYX6TL6dLDKoCbbrqJl19+mZ/+9KcsXryYH/3oR7z66qvccsstdkcTkXZSfbRgPaiCdREREekBHKl9iZ53F+4J88HhBCyCG9+k/unvE9q3we54vcKotOFcOvBCMmMyuHLIxQC43GG+dvEQrjpnYHP5+osfNJWvH67y2ZxYRD6pS28DBLj44osJBAI8/PDDPP300+Tm5nLPPfcwZ84cu6OJiIiIiIh8KsN04Bl1Hq78sTQufphw6TasunJ8C+/FOWgK3olXYHhjP/+B5KQYhsGZuVOYlj0Jh+k4ui3wCSoaq/jqiC8wJG8cf35xI/uP1FO8v4YfPbycL8wazKRhmXZHFxHAsHQqhM9VXl5HJKK/ps6SlhbH4cO1dsc4oXDFfhqe+T4A3rO/jqtggs2Jur//98IGlm8+RGZyNHffMNHuOJ+rq79GRfQala5Or1Hp6tr7NWpZEYKb3sa//Gk4uhXQe9aNuAZMarfnkM+27OBK/r75SQAmZI7hi0OvIBAM8/TbxSxata/5dhOHZfDlcwtxObv2JiT9HJXu4LNep6ZpkJJy4oF9l19ZJdKlGXYHEBEREZGuzjBM3MPOxtl3FI3vPQoYOAu6/gd0Pcm4jFGUNhxizeH1XDboIgAiRpArzilgeP9kHl64mdqGIEs3ljEsP5nTR/SxObFI76ZhlYjYrqlgfR9+dwygN24iIiLSM5mxKUTNvhVCfgzj4089AxvebDqJz6ApLY5L+3GYDi4qOJfZ+WfjcbiJWBEe2fg4/nCA64ZfzfeuGcudDy0FoDEQtjmtiGhYJSK2q3buwZW9m0BAvQ0iIiLSsxmGAS5v8+VI1UH8y/4N4RCO4mV4p34RMy7NxoQ9m8fhBuCDA8vYUL4FgJd3vsGFfS+0M5aI/JeuvRFXRERERESkB4s0VGN4mj6wC+/bQP3TPyCw4T9YVsTmZD3baZljOS1zLOlRqcwbcPTkXUYYUFexSFeglVUibaZ/wNpbrm8apauH0Ccl2u4oIiIiIp3KmTWEmPm/wL/0SYJbF0PIj//DfxEqXo5n+pdxJGbZHbFHcjvcfKHwMhpCPqKcUdQE/LgHrsEKOwhbBXbHE+n1tLJK5JSoU0BERERETo3hicE7/TqizvtfjKNbAMNl22l45i78q1/CioRsTtgzGYZBjKvpw9IPSpfgSDyMM6WUzf5lNicTEQ2rRMR2TQXr2/HHF9sdRURERMQ2zuyhxFz6c1wjZgEGREIEPnqWhud/jhUO2h2vRxuTOopIfRzhmmRynUPsjiPS62kboIjYrsbVVLDuV8G6iIiI9HKGy4N30pW4+o+ncfHDRCoP4MgciOFw2R2tR4txxeDfMh7CLuJzku2OI9LraWWViNhOLWAiIiIiLTkyBhB98U/wnHYZnvGXtrguUl1qU6oeLuwGDIJWgOe2v8zKsjV2JxLptbSySqSNHMk5xN3wqN0xepRc3zRWqGBdREREpAXD4cI9ck6LY6F9G/AtvA/X0LPwTLgUwx1lU7qeyuK9+ueorj1MgjuOoSlDiHJ67Q4l0utoZZWIiIiIiEg3YFkR/B8+DlgENy2i/unvE9z5EZYVsTtaD2JQ4B4JQEpUMg3BBpvziPROWlklIrZrKljfh98dC0y0O46IiIhIl2QYJlGzbqFx8cOED27Fqq+g8c0/YCZl4x59Ac7+EzBMrUc4VXmuIYwbmM2I1EJMQ3+fInbQf3kibWQFGwkd2EzowGYivhq74/QITQXrxfgTdDZAERERkc9iJmQQdf4deKZcC54YACKV+2l86/9R//T3CG57HysStjllN2cYjEwbhmmYBMIB3tu/FMtSy6pIZ9LKKpE2itQexvfyPQB4z7kJs/94mxOJiIiISG9iGCbuoWfhGjCJwKa3CK57DauxFqu6lMZ3/oqjeDnR595qd8xub1/tAf68/jEqGitxmy5O6zPW7kgivYZWVomI7XIbpuJbPpv4vTPtjiIiIiLSbRjuKDyjziPmynvxTLwSIzoRAFfBaS1up1VBn88wjj+WEpVMKBICYOWhtZ2cSKR308oqEekyjE97lyAiIiIin8lweXAXzcI19ExCxctwDvi4A9QK+ml44ee4Bp2Oq/BMDJfHxqTdS5TTy2WD5lIbqGNK9mmffwcRaTcaVomI7ZoK1vfT6IkF9EZARERE5GQYTjeuwVNbHAtufptIxV78S/9NYM0ruIpm4R56NoY7yqaU3cvo9BHNXwfDQeqC9SR5E+0LJNJLaFgl0lZaRd3umgrW9+APxNodRURERKRHMeJSMRMyiVSXYjXWElj+DIG1r+IePhP38HMwjpa0y2fbVL6Vp7Y9T4wrhu+M/brOEijSwfRfmMip0LY1EREREenCXP3GET3/brxnfw0zKafpoL+ewMoF1D1+G/6PniXSWGtvyK7mUz6c3lZZzGFfObtrSlh1aF3nZxLpZbSySkRsl+ubxoo1h8lK1Sd7IiIiIu3NME1cBafh7D+e0O7VBFa9SKR8DwR9BFa/RGD9G8Rc9kvM2GS7o3ZZs/PPZkP5Zk7POo3RaSM+/w4icko0rBIR22lnpYiIiEjHMwwTV7+xOPPHEN67Fv+qF4kc2okjo0CDqs/hdXr43oRvN2//i1gRbQUU6UAaVomI7WpUsC4iIiLSaQzDwJk3CkfuSML7Nx3XW9W45AkIBXCPOg8zLtWmlJ2rNeUex4ZT2yqLeXrbC1xdeCn58XkdG0ykl9KwSqSNDJcHR5/BTV9742xO0zN8XLCuv08RERGRzmIYBs6cYS2OReorCW5cBJEQwS2LcQ2ajHvU+ZgJGTal7FpqArX8Yc1fCVlhnty6gNvHfUMrrEQ6gIZVIm1kxqcTfcGddscQEREREWl/oQCO7KGE964DK0xw63sEt72Ps2Ai7tEX4EjKsjuhreLdcZyTN5239r7H6PQiLMtq3bIsEWkTDatExHY5vmmsXHOYbBWsi4iIiNjKTMgg+txbCR/eTWD1i4R2rwLLIrRjCaEdS3H2H4d79IU4UnLtjtphPq9PdVb+WZyefRrJ3qROySPSG2m9ooiIiIiIiLTgSMsnauY3ib7kZzj7T6Bp+ZBFaOdHNDz7QwKb3rI7om3cDnfzoGpn9R5e2917/y5EOopWVom0UaShiuCmtwFwFpzW65dCt4ePC9bjUMG6iIiISNfhSMkl6pyvE648QGD1S4SKlwImztwRdkez3bv7PuSpbc8DMDCxPwWJ+bbmEelJNKwSaSOroZrAqhcAMFPzNKxqB8cK1htVsC4iIiLSJTmSsog660YiY+cSLt2GGZfWfF34UDH+5c/gHnMRzqwhNqY8FW0vnhqWMhiX6cQCyhoOaVgl0o40rBIREREREZFWMRMyjjszoH/Vi4QPbMZ3YDOOzEG4x1yII3sYhtGzm8dTo1L4QuHl9I3PITUqxe44Ij2KhlUiYruchqMF62kqWBcRERHpTiwrgpmQSdixGcIBwqXb8C28FzO9P57RF+LIG9mjh1ZjM0Y2f72nZi+JnkQSPNotIHKqNKwSERERERGRk2IYJt5JV+IeOYfg+tcJbFwEIT+RQzvxvf4bzJS+uMdcgDN/DIbRTc7vZX3e+QBbCkfCPL39Rd7fv5RxGaP40rArOyiYSO/RTX5aiEhPVu3ajTN7O41xxXZHEREREZGTYEYn4DntMmKvug/36AvAFQVApHwPjf/5Pb5Xfo3VxiFQd+EwHdQEarGwWHVoHeW+SrsjiXR7WlklIrZrKlgvwa+CdREREZFuzfDG4hl/Ce6i2QQ2vklg/Rvgr8eRPbRHbwe8ZMAFRKwwcwvOIyUqye44It2ehlUiIiIiIiLSrgxPDJ4xF+EePpPg5ndwFU5vvs6yIvhefxBn/hhcA0/HcNj/a+mpztFSopL4n6IvN1/2hXxEOaNOMZVI72X/TwUR6fVyGqazas1hclSwLiIiItKjGO4o3CPPbXEstGsl4ZK1hEvWElj5Au5Rc3ANnobhdNuUsv34Qo28susNlh5cyfcnfJskb6LdkUS6JXVWiYiIiIiISKcyYpIBsOor8H/wT+r//b8E1r2OFfLbnOzU7KnZy9t738cX8rFgxyt2xxHptrSySqSNjOgE3GMuAsBM7GNzmp6hxrUbZ/YBGj1xwGl2xxERERGRDuTqPx5n39EEt39AYPXLWLWHsRqq8C99gsCal3EVzcY99CwMtz3b6E6lBn5I8kDGpBdR7a9lVv5Z7ZZJpLfRsEqkjczoRDzj5tkdo0c5VrDeGIi3O4qIiIiIdALD4cQ9ZDquQVMI7ViKf/VLWNWlWI21BJY/TWDtQqIv/D6OpCy7o7bZ1UPm43G4e3ShvEhH07BKREREREREbGGYDlyDTsc5YBKhncsJrH6JSOV+zKh4zIRMu+OdFK/TA4A/HOC13YuIcUVzTt70z7mXiHyShlUiYrvs+mmsXnNEBesiIiIivZRhmrgGTMRZMIHQ7tUYDheG+XHFcmDDf4jUVeAumo0ZnWBj0tb764Z/sKl8Ky7Txei0IlKikuyOJNJtaFgl0kaRqlIa33sEAPf4S3FmDrQ5UU+ipdIiIiIivZlhmLj6jW1xzAr6Cax6EauxluDGRbgKp+MeOQczpmsPf2bmncGm8q1kxWYSjATsjiPSrWhYJdJGVqiR8MGtTRca6+wN00PUuPYcLViPBybYHUdEREREuhDLV4OZ2IdwaS2EAwQ3/IfgprdxDZnWNLSKS7U74qcamFTAN0fdwMCk/piG+fl3EJFm+i9GRGxX696DK7uYxvhiu6OIiIiISBdjxqcRfeH3iDr/uziyhzYdjIQIbnqL+n/fQeO7DxOpLmu357NO5XSA/2Vw8gBMwyQQDrKoZDHBcLD9HlykB9PKKhEREREREenynFlDcGYNIVy2A/+qFwnvXQdWmODWxQS3vYfntCtwF82yO+Zxjvgq+N3qhzjSWIE/7GdOvxl2RxLp8rSySkRsl10/Dd/y2STun2l3FBERERHp4hwZA4g+91ai5/0IZ9/RTQctC0dGgb3BTiDJk4DX6QVgU/k2IlbE5kQiXZ9WVom0VTsuCxYRERERkZPjSOtH1KxbCJfvJbRnNY6MAc3XRWqP4F/6b9yjz8eRmm9fSMBhOrh88DxKavcxLXuS+qtEWkHDKpFToZPXtYsa126c2Qdp9KpgXURERETaxpGSiyMlt8WxwNqFhHatILRrBY7cIjxjLmwxzPpvRge/r++f0Jf+CX0BCEVClPsqyIhJ79gnFenGNKwSEdvVuPfgyt5LYyDe7igiIiIi0s1ZxxrSDQdYYcJ719Gwdx2O7GG4x1yIs89g27Jtqyzm31ufIxgJ8cPTvoPb4bYti0hXpvWHIiIiIiIi0mMYhoF3yrXEXPErXIVngtm0RiO8fyO+l35Jw4t3E9q34eOhVicqazhEWcNhKhoreW//0k5/fpHuQiurRMR2OfXTWb3mCLnpsXZHEREREZEewoxLwzv1i7jHXEhg7UKCm9+BcJBw6TZ8C+/F0WcwUeffgdGJHVKnZ53GyrK1DE8t5Iyc0zvteUW6Gw2rRNrITMgg6vw7mr5OzrE5jYiIiIiIfBYzJgnv5KtxjzqfwLrXCG56C0J+zMQ+nTqoAjANk1tG34hxtCQrHAljGmbzZRFpomGVSBsZ7iicWYV2x+hRqo8WrPtUsC4iIiIiHcSMTsA78XLco+YQXP8GriHTWlx/SfQydgQzgRMXsbeHY4OpHVW7eHLrAub0m8Ho9BEd+pwi3Y2GVSJiu9rmgvUEu6OIiIiISA9neuPwjL+kxTHr0E6mebcyzbuVTTW5QF6HZgiEA/xl/d+pC9bzzPYXKUwehNfp6dDnFOlOVLAuIiIiIiIivZpVubf5a0+gssOfz+1wc1HBubhMJ1OyJuIwHR3+nCLdiVZWibRR+PAuGhb8BICoWbfg7Dva5kTdX3bddNbsOEKeCtZFRERExAZm37GEl/yjU59zYp9xFCYPIsmb2KnPK9IdaGWVyClREaKIiIiISM9idcqzmIbZPKjaXVPCU9tewLI657lFujqtrBIR29W4VbAuIiIiIr3TyrI1PLLxCSws+sfnMS5TOzdENKwSEdsdK1j3qWBdREREROzWyaubCpMHE+uKwRfyUROo7dTnFumqNKwSERERERGR3s2wr94j2hXFl4ZdSbI3kfToNNtyiHQlGlaJtJX2kbe75oL1DBWsi4iIiEjvMyR5YPPXe2sP4DIdZMZk2JhIxF4qWBc5FepXFxERERGRdmBZFs9uf4l7PnqQx7c8q7J16dW0skpEbKeCdRERERGxldPNyw1NxeY50bm2RDCObkW0sNhVU8Le2v3kxefYkkXEbhpWiYjtat27cWXvU8G6iIiIiNjCcLr5T+MIAOZHZ9uWY06/GVT6q5mTfw5ZsZm25RCxm4ZVIiIiIiIiIl1AlNPLV4Zf03y5NlBHnFu9rtL7aFgl0kaO9P7E3fCo3TF6lKza6awtLlfBuoiIiIjYoqtV0TaG/Czc/R/e3fch3xn7dfLitB1QehcVrItIl2F0ubcJIiIiItIbWAEf34p7lW/FvUpq1Qa741Dlr+advR8QioR4etuLKluXXkcrq0TEdk0F66X4vAnAeLvjiIiIiEhvY4Xp5zoMQHGozuYwkBmTzlm5U9lRtYvLBs1tLl8X6S00rBJpIyvgI3xkNwCO5FwMr7aunapazx4VrIuIiIiIfMJ5/WfiMExMQxuipPfRq16kjSJVB/G9fA++l+8hfKjY7jgiIiIiItIDuUwnpmESCAd4aefrPLXtBbsjiXQarawSEdtlHy1Y75sRZ3cUEREREZEu5cmtz7O0dAUGBhMyR5Mfn2d3JJEOp5VVImI71UWKiIiISNfRtd6dzso/E6fhICcuC4eh9SbSO+iVLiK2qz1WsB6lgnURERER6XxducA8PTqNb4/9GnlxOeqvkl5Dr3SRNutan7T0BE0F68X4YnfaHUVEREREpMvJj8/DNEyCkRBv7H6b6sYauyOJdCitrBI5JV33ExgREREREWk7q4t+Nl0XrOe+FX/gkO8I1ZEq5vefZ3ckkQ6jYZWI2C6rdjrrisvpm6mCdRERERGRTxPjjCY9OpVDviPsqiwhEA7gdrjtjiXSITSsEhERERERkd7N5eWBmtkATBoy1OYwn84wDOYPuojBhwdw6ejZVJQ32B1JpMOos0pEbNdUsL4dX2yx3VFEREREpBcyTAe7Q+nsDqUTcMXbHeeEUqNSOCtvGg7TQTgSpqR2n92RRDqEVlaJtJXLi6PPYAAMb4zNYXqGWs9uXNn78QUS7Y4iIiIiIr1S9+qi3XqkmD989A+qGqu5a+JtJHi67oBN5GRoWCXSRo6kbKIvuNPuGCIiIiIi0k4sy8JB+OiFiL1hWqEh6KO0vgyARXsXc/GA821OJNK+NKwSEdtl1Z7BuuJy8lWwLiIiIiJ2CPq4P/lfABSXzwL625vnc4zuM5zxGWPIisngrLypdscRaXcaVomIiIiIiIh0M18adkXz1xEr0rQ6zHTYmEik/ahgXaSNInXl+FcswL9iAZHqMrvj9Ag17l04s7fToIJ1EREREZE22Vm9h3s++i1v73vf7igi7UYrq0TayKqvJLDqBQAcGQMwEzJsTtT91Xr2qGBdRERERKSNIlaEf21+mtKGQxzadYSx6SNJ8ibaHUvklGlllYiIiIiIiPRqRvc6GWAz0zCZP+giXKaTc/KmE+PS2cqlZ9DKKhGxXVbNGazfWU6/PipYFxERERFpiyHJA/np5DuJd+u9tPQcWlklIiIiIiIicpRl2Z2g7Y4Nqkpq9vHIxscJRkI2JxI5NVpZJSK2q/XswpldRkNUAjDe7jgiIiIiIt3Olort/H7NX7GwyIrJZFb+WXZHEjlpWlklIrar9ezGlV1MQ+wuu6OIiIiIiHRLAxP7kxmTjsNwELbCdscROSVaWSUiIiIiIiK9Xsg6tpaje7atO0wH1xZejtvhJjMm3e44IqdEwyoRsV2fmjP4/+3de1yUdd7/8fcMB+WgIAipiCJWhKdELfJUapqCli2rt5rttmmtuta93uaamHfawZ+62pqlaWmn3S1vFzNKEzXNrbbU8pC7hloqR/O0IAqInGZ+f7hMTniARL4z8Ho+Hj0es99rmHkLVy6953t9rn1HchmwDgAAACMs3r564vSDkqSEjpGKMZzn52rVuKXj8dGCYzpfVqy2gRHmAgE/E2UVABfinp9iAQAAAK7koyObtCHjEwU1bKIZt0+Wl4eX6UhAtVBWAdVk8Wsi7y5DJUnWxmyvrQn5DdL/M2A9UFI303EAAABQj7nhzQAr8fXylc1uU+750/o+74jaBUeZjgRUC2UVUE1W/2A16PYL0zHqlIIG6fIK+0HnSpqYjgIAAIB6yG4rV5TnD5KkhiVNJEUYzXOt7gzrrmOFx3VXy54K829uOg5QbZRVAAAAAID6raxEv2u8WZJ06KxVctupVRd4WD30wC3DHP/79Pk8BTYIkMXC2A24B8oqAMb9OGC9sekoAAAAQJ1RXF6iDelbtCXzM43t8KBuDWlvOhJQJZRVQDWV52ar+Iu/SJIaxI6QR2ik4UR1QF0YDAAAAAC4mJLyEv3j6HaV28v13vdr1SH4FnlYPUzHAq6KsgqoJntJkcqPHfzP43OG09QN+Q3S5Bl2UkW+gWLAOgAAAGpbXb06rpG3v+5rO0jbftipEVH3U1TBbVBWATCuoEGGvBozYB0AAADmWex1a9t/zxax6tkiVlaLVZJkt9uZXQWXZzUdAAAAAAAAo+pweWO1WGW1WFVaXqr1aR/r1X+9LXsdK+RQ97CzCoBxzc/20b60XDVvwYB1AAAA4HpISd+ijRmfSJL2nPqXuoR2MpwIuDx2VgEAAAAAUMf1a9Vbfl6+CvNvriYNAkzHAa6InVUAjDv7nwHr5xiwDgAAAFwX/l5+mhQzXjf4hjBoHS6PsgqAcQUN0uXV+JjOlQSZjgIAAIB6yGLx0IHS5pKkcq+6u+uohX8zSVKZrUyfZH2uDsHRjjXAlVBWAQAAAADqNYunt5bmD5Ak3R/QxnCa66vUVqZ5Xy/SscITSs05qN/HjOPugHA5zKwCYFzzs31V9NUghZzsbzoKAAAAUKd5WT11c5O2kqT8kgLllxYYTgRUxs4qoJo8gsLkM+TJ/zwON5wGAAAAAKpnSJuBauoTrDvDusvTSi0A18NZCVSTxdtXni2iTceoU/L/M2C9kAHrAAAAMMBeXqYhPrslSQGFVkl1+1JAXy8f9QvvLUkqt5XryJl03fSf3VaAK6CsAmAcA9YBAABglK1cA3z2SZIOFdWfgeNZ+Uf1l/1/07HCE5p22+8V5t/cdCRAEjOrAAAAAAD1XT2dL261WHWs8IRsdps+zvi76TiAAzurgGoqO3ZQRWvnSJJ84v8gz5btDSdyf83P9NG36afVIqyx6SgAAACo7+ymA9SeMP/muqdVH3laPdW/1V2m4wAOlFXAteAWrwAAAADc2L1tBzke2+w2ldnK5O3hbTARwGWAAFzAhQHr36vQ97DpKAAAAKjn6uvH0RlnszR/52K9f+gj01EAyioA5hU0TJdX2GGd80szHQUAAAD1UX1tqC7y4eENyszP1udHtyszP9t0HNRz9aas+vOf/6yEhATTMQAAAAAAcDnDbx6qBh7eGti6r5r5hpqOg3quXsysSk1N1fLlyxUSEmI6CoBLaHamr1IZsA4AAABD2FglNfML1fM9npKvl4/pKEDd31lVWFiop59+WpMnTzYdBcBVWPg1AQAAAIbVo5sBVlJRVGXn/6Cle99UQWmh4USor9x+Z1VycrKmT59eaX3Hjh1q1KiRZs2apTFjxig4ONhAOgBVUdAgTZ5hp1To20RSV9NxAAAAUN9YPbTuXIwkqZlvK8NhzDpacExzv14ku+z68HCKHrhlmOlIqIfcvqy6//77df/991/y2Jo1a+Tl5aX4+Hjt2LGjdoMBqLKChunyCjiuwhJKZQAAANQ+i9VTH5/vKEka6htuOI1ZLfya6Zagm3Tw9CE19Gwou90ui4UrIFC73L6supK1a9fq5MmTGjp0qM6dO6eTJ0/qN7/5jd566y3T0QAAAAAAcDkWi0Ujo36hkvJStfBvZjoO6qk6XVa9+eabjsc7duzQvHnzKKpwzTybR6nRb98yHaNOqRiwHhYWYDoKAAAAUO819fnxiofjhSd0qihHHZu2M5gIza0RoQAAHqBJREFU9Y3LDFjfv3+/2rdvr+PHj1c6tm7dOg0ePFidOnVSXFyckpOTaz8ggOvGXp+nWAIAAMA4e3mpJjVK0aRGKWqWt9d0HJexJfMzzf5qod5OXaX8kgLTcVCPuERZdfjwYY0bN05lZWWVjq1fv15TpkxRr169tGTJEt1+++168skntWHDhmq9R2xsrNasWVNTkQHUoIKGafIM+16FfodNRwEAAEA9ZJHUxuuU2nidkndpvuk4LiPUt6lsdpvOl53X/tzvTMdBPWL0MsCysjKtWrVKL7zwgry8vC75nIULFyouLk6JiYmSpN69e+vMmTNatGiRBg0aVCs5g4P9a+V98KOQkEamI1xW+flClZxIkyR5h0bIw4fz41qd882QV8AxFZUGu/TP/mLukhP1F+coXB3nKFwd52j9YistVsW+IW9vT7f4+ddGxn4hsTpRelyxLWMUGVS/75KIn+fnnqdGy6pdu3ZpwYIFGjt2rG644QbNmDHD6XhWVpYyMzM1efJkp/WBAwcqJSVFWVlZCg+//ndqyMkpkM3GdUq1JSSkkU6dct1PM8p+OKCidXMlST5DnpRni2jDidxfxb9fNrtc+mdfwdXPUYBzFK6OcxSujnO0/rGXlTgel5SUufzPvzbP0f7N+0nlF35P/3dRjpo0CJSH1aNW3hvu7UrnqdVqueLGIKOXAbZt21abN2/WY489Jg+Pyif7kSNHJElt2rRxWm/durUkKS0t7fqHBHDdNcvrq6KvBin03/1NRwEAAADwE6XlpVp3ZKOe275Anx790nQc1ANGy6qmTZsqODj4ssfz8y80cP7+zm2bn5+fJKmggAFvAAAAAICaxFU1l7LzxDcqs5drfdrHOl923nQc1HEuMWD9cuxXuUWY1erS8QFUkWPAuu8R01EAAAAA/ISXh5eG33y/wv1baOKtY9XQs6HpSKjjjM6suppGjS4M4iosLHRar9hRVXEcqF180lLTChqmyyvguM6V5JmOAgAAAOAS2gdHKTroJlktFzaN2Ow2x2Ogprn0mVUxqyozM9NpPSMjw+k4AAAAAAC4vqwWq0ptZdqQ/onm71ysMluZ6Uioo1y6rGrdurVatmypDRs2OK1v2rRJERERatGihaFkAGoSA9YBAAAA97Dth6+09sgGZeZna2vWP0zHQR3l0pcBStLEiROVmJiogIAA9enTR1u2bFFKSooWLlxoOhoAAAAAoC7w8NTCs4MkSbfdeIvhMK6tR4vb9ffsL2W1WNQmoLXpOKijXL6sSkhIUElJid544w0lJSUpPDxc8+bNU3x8vOloAGrIhQHrp1ToGySpq+k4AAAAqGcsFqvSy0IlSZ28GhtO49o8rZ6aeOsYBTYIkIfVw3Qc1FEuU1YlJCQoISHhksdGjhypkSNH1nIi4NIs3r7yaB7leIxrV9AwTV4BJ1TIgHUAAADA5QX7BEmSym3l2pr9D7X0b6Fbgm4ynAp1icuUVYC78GjaWr73JpqOAQAAAKCG2O12eapcdkl2m810HLdgt9u1cPcypZ3NUKhPU02PnSwvKxUDagZnEgDjbjjdVwcy8xTeMsB0FAAAANRHtnK9EPSOJOlQTl9JN5rN4wYsFotiQjsq7WyGZJFOn89TqG9T07FQR1BWAQAAAACAauvTsqe8rF7q3uI2dlWhRllNBwDcje3sKRXvfF/FO9+XLf+U6Th1woUB69+rwPeI6SgAAAAAqsjD6qE7W3aXl9VTNrtN//p3qulIqCOoPoFqshX8WyW7P5AkebSIlrVRiOFE7q/QJ11egSdUWHzGdBQAAAAA1XS88KTe+vZdZRX8oAmdHlaHptGmI8HNsbMKAAAAAAD8bL5ePvr3+VxJ0idZnxtOg7qAnVUAjHMMWA8PNB0FAAAA9ZzddAA31Ni7ke5vG6+84rO6p3Vf03FQB1BWAQAAAACAa9Ir7A7HY5vdpvNlxfL18jGYCO6MsgqoLjuftdS0CwPW/60Cn2BJXUzHAQAAAPAzZeZna9XBZPl5+WpCp4dlsVhMR4IboqwCrgV/8daIQp80eQWeVGEJA9YBAAAAd/Z59jaln82UJO3L2a+OTdsZTgR3xIB1AAAAAEC9V2a3qsxu5QPpa3Rf2zg18vbXgFZ9dFNgW9Nx4KbYWQXAuBtO92PAOgAAAIyxeHhqSt6DstulIdERDKa4Bo28/fVM92lq4OFtOgrcGGUVAOMYAwYAAADXwS+n16qBh7eOF57QqaIcWWRRh6bRpiPBzVBWAdVkbRQi7y5DLzz2Dzacpm4o8LkwYL2QAesAAAAwxCKL7BRVNWb7sV36OPPv8rR6alGf/2c6DtwMZRVQTdbGIWrQ7RemY9QpDFgHAACASXa7TVGeR2WzSz4ljU3HAeo9yioAAAAAQP1mt2t8o82SpENnyyR1M5unDugT3lNdQjtJzKvHz0BZBcC4G3L76WBWnloxYB0AAACoEwIbBCiwQYDpGHBTlFVANZWfSlfx9pWSpAY9HpRHcLjhRAAAAADgWhiwjmtBWQVUk724UOXHDl54XFpkOE3dUDFgvYAB6wAAADCMEes1Y8fx3dqUsVWeFg8t6jvHdBy4GcoqAMb9OGD9rOkoAAAAAADDKKsAAAAAAECNuqtlD8WEdGTAOn4WyioAxoXm9tN3WXlq3SrQdBQAAAAANYAB67gWlFUAAAAAAKBGVQxYl6SOTdsZTgN3YzUdAAAKfY7IM+x7FfgcMR0FAAAAQA3YcXy3lv3zLS3/119MR4EbYmcVAOMKfdLlFXhSBQxYBwAAgBEWHSxtLrukEq9A02GAeo+yCgAAAABQr1msVr1aeI/KbXYNbtzadJw6gQHruBaUVQCMC83pq++yzzBgHQAAAKgjGLCOa0FZBVSTR0iEfIY8eeFxUEvDaQAAAADA9TBgHdeCsgqoJksDP3m2iDYdo04p9EmTZ1iOCnyCJXUxHQcAAAD1jN1uU3zD3bLb7WpSaJPU1nQkt/fV8T3amPGJrBarXu4713QcuBnKKgDGFfqmyavJKQasAwAAwJj+Df8lSTpUFGw4CQDKKgDG2U0HAAAAAFCj7mzZXZ1DOpiOATdFWQVUU1n2PhWtXyBJ8rnvKXk2u8lwIvcXmtNP32efUUTrJqajAAAAAKgBDFjHtaCsAq4Bd2EFAAAAgMoYsI5rQVkFwLhCnyPyDMtVfsOmkmJMxwEAAABwjRiwjmtBWQXAuELfdHk1OaXCknzTUQAAAAAAhlFWAQAAAACAGsWAdVwLyqoqsFqZTFTbXPl77uHdQJ4BIRcee3m7dFZ3EVUar/TMs7oxLMBtvp/ukhP1F+coXB3nKFwd52j9YrdbHL/jN2jk7xY/f1fPGOQTqCCfQNMxYNjlztOrnb8Wu93OXeMBAAAAAADgEqymAwAAAAAAAAAVKKsAAAAAAADgMiirAAAAAAAA4DIoqwAAAAAAAOAyKKsAAAAAAADgMiirAAAAAAAA4DIoqwAAAAAAAOAyKKsAAAAAAADgMiirAAAAAAAA4DIoq+AWjh07pq5du+qVV14xHQVwOHXqlGbMmKG+ffsqJiZGCQkJSklJMR0L9di6des0ePBgderUSXFxcUpOTjYdCXCw2WxauXKl7r33XsXExKh///6aM2eOCgoKTEcDLumxxx7TgAEDTMcAKvn66681atQo3XrrrerVq5eee+45FRYWmo4FOKxcuVJxcXHq3Lmz7r33Xn344YfVfg3P65ALqFF2u13Tp0/nl1m4lJKSEj3yyCPKz8/Xf//3fys0NFQbN27UpEmTVF5eriFDhpiOiHpm/fr1mjJlih566CH16tVLmzdv1pNPPqmGDRtq0KBBpuMBWrFihV588UWNHTtW3bt3V1paml566SUdOnRIr7/+uul4gJMPPvhAH3/8sVq1amU6CuDkm2++0cMPP6x+/fpp6dKlysjI0J/+9Cfl5uZq4cKFpuMBWrVqlWbNmqUxY8aod+/e+vTTT/WHP/xBXl5eiouLq/LrUFbB5b377rs6cuSI6RiAk88++0wHDhxQUlKSOnXqJEnq2bOnfvjhBy1fvpyyCrVu4cKFiouLU2JioiSpd+/eOnPmjBYtWkRZBePsdrtWrFihESNG6IknnpAk9ejRQ02aNNH//M//aP/+/YqOjjacErjgxIkTmj17tpo1a2Y6ClDJggUL1LlzZy1atEgWi0U9evSQzWbTm2++qaKiIvn4+JiOiHru/fffV2xsrJ588klJF/7/ft++fXr33XerVVZxGSBcWlZWlhYsWKDnnnvOdBTAiZ+fn0aMGKGOHTs6rUdGRiozM9NQKtRXWVlZyszM1D333OO0PnDgQB05ckRZWVmGkgEXFBYW6r777qtU5EdGRkoSf2/CpcyYMUM9e/ZU9+7dTUcBnOTm5mrnzp0aNWqULBaLY3306NHavHkzRRVcQnFxsfz8/JzWAgMDlZeXV63XoayCy7LZbJo2bZri4uJ05513mo4DOOnevbueffZZp18USktL9emnn+qmm24ymAz1UcXu0zZt2jitt27dWpKUlpZW65mAi/n7+2vGjBnq2rWr0/rmzZslSTfeeKOJWEAlSUlJ+vbbb/W///u/pqMAlXz33Xey2+0KCAjQpEmT1LlzZ3Xt2lUzZ87U+fPnTccDJEm//vWv9fnnnyslJUUFBQXasGGD/v73v2vo0KHVeh0uA0StKysrU1JS0mWPh4aG6u6779bbb7+t7OxsLVu2rBbTAVU/R39q/vz5Sk9P15IlS65nPKCS/Px8SRcKgYtVfKrFzD+4or179+q1115T//791bZtW9NxAB09elRz5szRnDlzFBQUZDoOUElubq4kadq0aRowYICWLl2qgwcP6sUXX1RxcbHmzp1rOCEgDR48WNu3b9ekSZMca7/4xS/0yCOPVOt1KKtQ64qLizVr1qzLHr/99tsVERGhF198US+99JIaNWpUe+EAVe0cvbisstvtmj9/vt5++22NHTtW/fv3r4WUwI/sdvsVj1utbKSGa9m1a5fGjx+vli1b6vnnnzcdB3Dc0Oeuu+7SwIEDTccBLqm0tFSS1KVLF82cOVPShd3+drtd8+bN08SJExUeHm4yIqAJEyZoz549SkxMVLt27bR371698sorjl3WVUVZhVrn5+engwcPXvZ4eXm5Ro0apUGDBqlnz54qKytzHLPZbCorK5OnJ6curp+rnaMXKykp0bRp0/TRRx9p7Nixmjp16nVOB1RWUer/9LbVFTuqKP3hStavX69p06YpIiJCK1asUJMmTUxHAvTOO+/o4MGDWrt2reN3z4oPAsrKyuTh4eF06T9gQsWO6Z+OSOnVq5fmzp2rgwcPUlbBqN27d+sf//iH5syZo4SEBEkXPuhv3Lixnn76af3Xf/2Xbr755iq9Fh+1wuUcO3ZMe/fuVXJystq3b+/4R5Jefvllx2PAtIKCAj388MNKSUnR9OnTKapgTMWsqp8Oqc7IyHA6Dpj25ptvavLkyercubPeeecdhYaGmo4ESJI2btyo06dPq1evXo7fPZOTk5WZman27dvr/fffNx0RUEREhKQLH5ZerGLHFYUqTPvhhx8kXdj9d7Fu3bpJkg4dOlTl12J7ClxOaGioVq9eXWl92LBhGjVqlH75y18aSAU4Ky8v14QJE7R3714tXLhQgwYNMh0J9Vjr1q3VsmVLbdiwQQMGDHCsb9q0SREREWrRooXBdMAFSUlJmjt3ruLj4zVv3jx5e3ubjgQ4PPPMM5V2py5ZskT79+/X4sWL1bJlS0PJgB+1bdtWYWFhWr9+vR544AHH+tatW+Xp6amYmBiD6YAfPyDdtWuXo1yVpG+++UaSFBYWVuXXoqyCy/H29lbHjh0veSw0NPSyx4Da9H//93/66quvNGLECDVr1szxF7B04VOtW2+91Vw41EsTJ05UYmKiAgIC1KdPH23ZskUpKSlauHCh6WiAcnJyNHv2bIWFhWn06NFKTU11Ot6qVSsGWsOoyMjISmuBgYFX/L0UqG0Wi0VTpkzR5MmTNWXKFCUkJGjfvn1aunSpHnzwQf4ehXHt27dX//79NXv2bOXn5ys6Olr79u3TkiVLdOedd1brv5EoqwDgZ9i4caMkadWqVVq1apXTMQ8Pj0r/IQZcbwkJCSopKdEbb7yhpKQkhYeHa968eYqPjzcdDdDnn3+uoqIiHT16VKNHj650/I9//GO1b2kNAPVRfHy8vL29tWTJEo0bN07BwcGaOHGixo0bZzoaIElauHChFi9erLfeeks5OTkKCwvTmDFj9Nvf/rZar2OxX+0WQgAAAAAAAEAtYcA6AAAAAAAAXAZlFQAAAAAAAFwGZRUAAAAAAABcBmUVAAAAAAAAXAZlFQAAAAAAAFwGZRUAAAAAAABcBmUVAAAAAAAAXAZlFQAAAAAAAFwGZRUAAHArO3bsUFRUlNasWWM6yjU7ceKEYmNjlZWVZTrKdbNq1Srdfffdlz0+bdo0RUVFKTs7u0bf96mnntKcOXNq9DUBAEDtoKwCAAAwZPbs2Ro8eLDCw8Mda3l5eYqKitIjjzxiMFnN+eKLL9SjR49af9+JEydq1apVOnDgQK2/NwAAuDaUVQAAAAZ8/fXX2rJlix599FGn9dTUVElS+/btTcSqUTabTTt27FD37t1r/b1btGihwYMHs7sKAAA3RFkFAABgwFtvvaWuXbuqefPmTuvffvutJKldu3YmYtWo1NRUnTlzxkhZJUnDhw/X9u3b2V0FAICboawCAAB1Qm5urp555hnddddd6tChg+666y4988wzOn36dKXnZmdn6/HHH1eXLl3UpUsXTZgwQVlZWerXr59+9atfXfesx44d09atW9W/f/9Kxyp2VtWFsurLL79UdHS0mjRpYuT9O3furGbNmumdd94x8v4AAODn8TQdAAAA4Frl5+dr1KhRysjI0C9/+Uu1a9dO+/fv18qVK7V9+3YlJSXJ399fknT69GmNHj1aOTk5GjlypCIjI7Vr1y499NBDOnfuXK3k/fzzz1VeXq4+ffpUOpaamqqAgACnOVbu6ssvvzS2q6rCbbfdps8++8xoBgAAUD2UVQAAwO2tWLFC6enpevrppzV69GjHenR0tJ599lmtWLFCkyZNkiQtX75cx48f1/z583XfffdJkh544AH98Y9/1Ouvv14reXft2iVfX99KhVRBQYEyMjIUGxtbKzmup+LiYu3evdv4oPibb75Za9euVVZWVp0oAAEAqA+4DBAAALi9jz/+WEFBQRoxYoTT+ogRIxQUFKTNmzc71rZu3aqQkBANGTLE6bljx46tlaySlJWVpbCwMFksFqf1/fv3y26314lLAHft2iW73a5u3brV6OueOnVKy5cvV2JiohYsWKB9+/Zd8fkVBVV2dnaN5gAAANcPZRUAAHB72dnZatOmjTw9nTeNe3p6KiIiQllZWU7Pbd26taxW51+DgoOD1bhxY6e19evXa9SoUYqJiVG/fv0qvW9ZWZmef/553X777erWrZumT5+u4uLiq+bNy8tzXJZ4sYrh6le6E+DOnTsVExNT6Z8OHTooOjra6bmzZs1SVFSU9uzZU+l1fvWrXykqKkqffvpppT9zVFSUxo0b51hLS0vT7373O91xxx2KiYnRgAEDrnqXvS+++EIxMTFq2LDhFZ9XHRs3btQrr7yiHj16aObMmRo1apS++OILvfDCC7Lb7Zf8mosv/wQAAO6BsgoAAOAyAgIC9OCDDzouIfypZcuWaceOHVq7dq02bdqkw4cPa/78+Vd9XavVKpvNVmm9KncC7Natm/bs2eP0z4YNGxQYGKjf//73juedP39e69atU2BgoJKSki75WpGRkXrvvfec1lavXq3IyEintXHjxqlNmzbasmWLdu3apeXLlysqKuqKf8Zt27apR48eV3xOdXz33Xc6evSoZs6cqfbt26thw4YKCwvTuHHjdPfdd2vlypWX/LqK77OHh0eNZQEAANcXZRUAAHB74eHhSktLU1lZmdN6WVmZ0tPTnWYVhYWFKSMjo1JZlJOTo7Nnzzqt9ezZU4MHD1ZYWNgl33f16tUaP368brjhBgUFBemxxx7TmjVrVF5efsW8wcHBysvLq7SempoqX19ftWnT5opff7GSkhI9/vjj6tq1q8aPH+9Y37Bhg6xWqxITE5WSkqLCwsJKXxsXF6ft27crNzdXknT06FHt37/f6S6Fubm5ysjI0MiRI+Xn5yer1aqIiAglJCRcNtPp06e1f//+Gi2rNm3apIcffviSxzp37qzTp09X+vlLcnyfg4ODaywLAAC4viirAACA2+vfv79yc3Mr7SD629/+ptzcXKfypW/fvjp16pTWrVvn9NzqDlc/e/asjh07pltuucWx1r59exUWFuro0aNX/NoWLVro5MmTTqVWUVGR0tLSFB0dXWmW1ZXMnDlTxcXFmjt3rtN6UlKS4uPjFR8fLy8vL61fv77S1/r5+al///5KTk6WdKF8GzJkiLy9vR3PCQoKUtu2bTV9+nR99NFHyszMvGqmbdu2yd/fXx06dKjyn+NqfHx8HN+XPXv2KDY2Vq+88orjeIcOHZSenl7p606cOCHpwvccAAC4B+4GCAAA3N4jjzyiDRs26Nlnn1Vqaqqio6O1f/9+rV69Wm3atHG6I92jjz6qdevWafr06frnP/+pyMhI7dq1S3v27FGTJk2q/J4VO5UunnPVqFEjp2OXc8cdd2jNmjX6/vvvHWXXgQMHVF5eruLiYr322muVvsbX11cPPvig09qf//xnbd26VatXr5aPj49jPS0tTTt37tTUqVPl7e2t+Ph4rV69WsOHD6/0usOGDdOMGTP00EMP6f3339err76qTZs2OT3nL3/5i15//XUtW7ZMhw8fVvPmzfXEE08oPj7+kn++bdu2KTY2ttJcsCtZuHCh/Pz8Kq3HxcWpe/fuTmsHDhxQXl6edu/e7Vjz8/O75Pf9m2++UevWrSmrAABwI5RVAADA7TVq1EgrV67USy+9pE8++URr1qxRcHCwRo4cqccff9xpmHlQUJDeffddzZs3T++9954sFotiY2P19ttva9iwYVUeCF5RrOTn5yskJMTx+OJjl9O7d29ZrVbt3LnTUValpqZKkvbt23fJO9zddtttTmXV9u3btWDBAi1fvlwtW7Z0em5SUpIiIyN16623SpISEhI0fPhwff/997rpppucntulSxfZ7Xa9/PLLatq0qaKioiqVVcHBwZo6daqmTp2qgoICrVq1SlOmTFFUVJTatm1bKeuXX36pMWPGXPF78FM/3elWITIyUt27d9f58+cda8OHD1dISIhiYmIcawcPHtTgwYOdvtZms+mbb765bKkGAABcE2UVAABwK7GxsTp48GCl9aCgIM2aNUuzZs266muEh4dr8eLFTmunT59WXl6emjdvXqUcjRs3VvPmzXXgwAHHQPLU1FT5+flddsbVxVn79eunjz76yFFAjR49WqNHj67Se2dnZ2vSpEmaOnWqYmNjnY6Vlpbqgw8+UH5+vnr27Ol0bPXq1UpMTKz0esOGDdP8+fOr9L3z9/fX2LFj9dprr+nQoUOXLKu2bNlSpT+HJM2dO7fSJYyXEhYWpt27d6tLly7y9PR0urQzPz9f2dnZCgwMdPqabdu2KScnR8OGDatyHgAAYB5lFQAAqHfOnz9faQdVxaV3Fxc85eXlKisrU2lpqex2u4qLi2WxWBwznYYNG6ZXX31VXbt2lZeXlxYvXqyEhIQq3XluzJgxeuCBB5SZmalWrVpVOXtRUZEmTpyofv36VbosUJK2bt2qM2fOKDk5WQEBAY71Dz/8UMuXL9cTTzzhNJNKkkaMGKHo6GinnUoVzpw5o9dff1333nuvIiIiZLfbtWbNGhUVFal9+/ZVzn2thg4dqtmzZ6uoqMjpZ5SVlaVFixZdsoRLTk5Wz549neaKAQAA10dZBQAA6p1HH31UYWFhateunWw2m7Zv366tW7cqJibGacfOBx984FSCdOrUSWFhYfrkk08kSePHj1deXp6GDBkim82mgQMHasqUKVXK0LVrV/Xt21evvfaann/++Spn37hxow4cOKD09HSlpKRUOt6xY0cNGTJEN954o9P6yJEjtWzZMm3evLnSZXH+/v6XvXOfl5eXTp06pQkTJignJ0fe3t668cYbtXTp0kqXH15PFotF06dP11//+lclJSXJarXKZrMpJCRETz31VKV5Y1lZWdq4caP++te/1lpGAABQMyx2u91uOgQAAEBteuONN5ScnKyjR4+quLhYN9xwg+655x5NnDjRab7V9Xbs2DENHTpUq1evrtbuKlxdYmKi/P399dRTT5mOAgAAqomyCgAAAAAAAC6j6vcTBgAAAAAAAK4zyioAAAAAAAC4DMoqAAAAAAAAuAzKKgAAAAAAALgMyioAAAAAAAC4DMoqAAAAAAAAuAzKKgAAAAAAALgMyioAAAAAAAC4jP8PZvIiM81U440AAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "\n",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
+    "\n",
+    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Things to try:\n",
+    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
+    "* Alter the metallicity, does this make much of a difference?\n",
+    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
+    "* How might you go about comparing these computed observations to real stars?\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/_sources/notebook_luminosity_function_single.ipynb.txt b/docs/build/html/_sources/notebook_luminosity_function_single.ipynb.txt
new file mode 100644
index 0000000000000000000000000000000000000000..cdae316f90802fe46611ea17732506c0410aef55
--- /dev/null
+++ b/docs/build/html/_sources/notebook_luminosity_function_single.ipynb.txt
@@ -0,0 +1,725 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Zero-age stellar luminosity function\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c. \n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mass\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "   /* Note that we use Printf - with a capital P! */\n",
+    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
+    "          stardata->model.time, // 1\n",
+    "          stardata->common.zero_age.mass[0], // 2\n",
+    "          stardata->star[0].mass, // 3\n",
+    "          stardata->star[0].luminosity, // 4\n",
+    "          stardata->model.probability // 5\n",
+    "      );\n",
+    "};\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "        \n",
+    "        # Check the header and act accordingly\n",
+    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
+    "            \n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 1.0000000000000004\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=2,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'e6c082aabe0849a0811761a06e50476b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631461389.3681686, 'end_timestamp': 1631461391.6702895, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "                    \n",
+    "\n",
+    "# this saves a lot of typing! \n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
+   "metadata": {},
+   "source": [
+    "## ZAMS Luminosity distribution with the initial mass function\n",
+    "\n",
+    "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars.  So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Update the probability distribution to use the three-part power law IMF \n",
+    "population.update_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.2182216189410787\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
+   "metadata": {},
+   "source": [
+    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it's not smooth - it's spiky! \n",
+    "\n",
+    "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n",
+    "\n",
+    "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## A better-sampled grid\n",
+    "\n",
+    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
+    "\n",
+    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rename the old variable (M_1) because we want it to be called lnM_1 now\n",
+    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
+   "metadata": {},
+   "source": [
+    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
+    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
+    "# because  M * dprob/dM = dprob/dlnM\n",
+    "population.update_grid_variable(\n",
+    "    name=\"lnM_1\",\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    precode=\"M_1=math.exp(lnM_1)\",\n",
+    ")\n",
+    "# print(population.grid_options[\"_grid_variables\"]) # debugging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.9956307907476224\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6",
+   "metadata": {},
+   "source": [
+    "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
+   "metadata": {},
+   "source": [
+    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
+    "\n",
+    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(*L*/L<sub>☉</sub>)=-2. \n",
+    " \n",
+    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
+    "* Different initial distributions: the Kroupa distribution isn't the only one out there\n",
+    "* Change the metallicity and mass ranges\n",
+    "* What about a non-constant star formation rate? This is more of a challenge!\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
+    "* Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/_sources/notebook_population.ipynb.txt b/docs/build/html/_sources/notebook_population.ipynb.txt
index b6a37baa8d90a2f36c0fd19311548ed49e77f173..a24638c0bd3a15a57bbf611fccb71b2100c75945 100644
--- a/docs/build/html/_sources/notebook_population.ipynb.txt
+++ b/docs/build/html/_sources/notebook_population.ipynb.txt
@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Running populations with binarycpython\n",
+    "# Tutorial: Running populations with binary_c-python\n",
     "This notebook will show you how to evolve a population of stars\n",
     "\n",
     "Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let's go through the functionality of this object step by step and set up some example populations. \n",
@@ -23,9 +23,12 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "from binarycpython.utils.custom_logging_functions import temp_dir\n",
     "from binarycpython.utils.grid import Population\n",
     "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_population\")\n",
+    "\n",
     "# help(Population) # Uncomment to see the public functions of this object"
    ]
   },
@@ -60,7 +63,8 @@
       "adding: max_evolution_time=15000 to BSE_options\n",
       "adding: eccentricity=0.02 to BSE_options\n",
       "adding: amt_cores=2 to grid_options\n",
-      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/example_python_population_result to custom_options >>>>\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_population to grid_options\n",
+      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result to custom_options >>>>\n",
       "<<<< Warning: Key does not match previously known parameter:                     adding: base_filename=example_pop.dat to custom_options >>>>\n",
       "1\n",
       "example_pop.dat\n",
@@ -88,11 +92,12 @@
     "\n",
     "\n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "    \n",
     "    # Custom options # TODO: need to be set in grid_options probably\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -133,13 +138,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Writing settings to /tmp/binary_c_python/example_python_population_result/example_pop_settings.json\n"
+      "Writing settings to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/binary_c_python/example_python_population_result/example_pop_settings.json'"
+       "'/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json'"
       ]
      },
      "execution_count": 3,
@@ -181,7 +186,7 @@
      "text": [
       "Help on method add_grid_variable in module binarycpython.utils.grid:\n",
       "\n",
-      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='edge', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
+      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='centred', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
       "    Function to add grid variables to the grid_options.\n",
       "    \n",
       "    The execution of the grid generation will be through a nested for loop.\n",
@@ -199,25 +204,25 @@
       "        name:\n",
       "            name of parameter. This is evaluated as a parameter and you can use it throughout\n",
       "            the rest of the function\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                name = 'lnm1'\n",
       "        longname:\n",
       "            Long name of parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                longname = 'Primary mass'\n",
       "        range:\n",
       "            Range of values to take. Does not get used really, the spacingfunction is used to\n",
       "            get the values from\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                range = [math.log(m_min), math.log(m_max)]\n",
       "        resolution:\n",
       "            Resolution of the sampled range (amount of samples).\n",
       "            TODO: check if this is used anywhere\n",
       "    \n",
-      "            Examples: \n",
+      "            Examples:\n",
       "                resolution = resolution[\"M_1\"]\n",
       "        spacingfunction:\n",
       "            Function determining how the range is sampled. You can either use a real function,\n",
@@ -230,12 +235,12 @@
       "        precode:\n",
       "            Extra room for some code. This code will be evaluated within the loop of the\n",
       "            sampling function (i.e. a value for lnm1 is chosen already)\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                precode = 'M_1=math.exp(lnm1);'\n",
       "        probdist:\n",
       "            Function determining the probability that gets assigned to the sampled parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                probdist = 'Kroupa2001(M_1)*M_1'\n",
       "        dphasevol:\n",
@@ -249,7 +254,7 @@
       "                condition = 'self.grid_options['binary']==1'\n",
       "        gridtype:\n",
       "            Method on how the value range is sampled. Can be either 'edge' (steps starting at\n",
-      "            the lower edge of the value range) or 'center'\n",
+      "            the lower edge of the value range) or 'centred'\n",
       "            (steps starting at lower edge + 0.5 * stepsize).\n",
       "\n"
      ]
@@ -313,7 +318,7 @@
       "    \"dphasevol\": \"dlnm1\",\n",
       "    \"parameter_name\": \"M_1\",\n",
       "    \"condition\": \"\",\n",
-      "    \"gridtype\": \"edge\",\n",
+      "    \"gridtype\": \"centred\",\n",
       "    \"branchpoint\": 0,\n",
       "    \"grid_variable_number\": 0\n",
       "}\n"
@@ -457,7 +462,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: parse_function=<function parse_function at 0x7ff3bdf79620> to grid_options\n"
+      "adding: parse_function=<function parse_function at 0x7f531bc3b6a8> to grid_options\n"
      ]
     }
    ],
@@ -536,25 +541,25 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
-      "EXAMPLE_COMPACT_OBJECT             2.867655467480e+01 1.33079 9.81391 0.00167028 13\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "EXAMPLE_COMPACT_OBJECT             1.931266944719e+01 1.3933 12.3177 0.00124307 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.439623364590e+01 1.38004 7.81906 0.00224431 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.364277535630e+01 1.47961 15.4603 0.000925128 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.017435498578e+01 1.59052 19.4046 0.000688507 13\n",
-      "EXAMPLE_COMPACT_OBJECT             8.294870923827e+00 1.7197 24.3552 0.000512406 13\n",
-      "EXAMPLE_COMPACT_OBJECT             6.802132608769e+00 1.84162 30.5689 0.000381347 13\n",
-      "EXAMPLE_COMPACT_OBJECT             5.723570798020e+00 1.99471 38.3678 0.00028381 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.933751523833e+00 2.15875 48.1564 0.000211219 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.337250536639e+00 2.35209 60.4424 0.000157195 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.862081089332e+00 2.56776 75.8628 0.000116989 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.449960890183e+00 2.80457 95.2174 8.70668e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.172196856333e+00 3.05193 119.51 6.47976e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.069627290216e+00 3.27563 150 4.82242e-05 14\n",
-      "Population-2a7732d03e594ef4b5dfe9051b41d9c0 finished! The total probability was: 0.05150046619238191. It took a total of 0.7797017097473145s to run 20 systems on 2 cores\n",
+      "EXAMPLE_COMPACT_OBJECT             4.139293101586e+01 1.29427 8.13626 0.00202467 13\n",
+      "EXAMPLE_COMPACT_OBJECT             2.802986496151e+01 1.33699 10.0967 0.00152924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.963621764679e+01 1.39754 12.5294 0.00115504 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.427601421985e+01 1.47745 15.5483 0.000872405 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.094409257247e+01 1.57571 19.2947 0.00065893 13\n",
+      "EXAMPLE_COMPACT_OBJECT             9.181971798545e+00 1.68748 23.9436 0.000497691 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.905335716621e+00 1.77287 29.7128 0.000375908 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.451192744924e+00 1.81495 36.872 0.000283924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396133472739e+00 1.82088 45.7561 0.000214449 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396675941641e+00 1.82123 56.7809 0.000161974 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.404641347602e+00 1.82074 70.4621 0.000122339 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.444217227690e+00 1.81636 87.4397 9.2403e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.453317880232e+00 1.81536 108.508 6.97923e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.450828476484e+00 1.81563 134.653 5.27143e-05 13\n",
+      "Population-f28b5f98d7ef40dcb17fc2481a6d3ced finished! The total probability was: 0.04440288843805411. It took a total of 2.785212755203247s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n"
      ]
     }
@@ -586,7 +591,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'population_name': '2a7732d03e594ef4b5dfe9051b41d9c0', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.05150046619238191, 'total_count': 20, 'start_timestamp': 1628444120.234709, 'end_timestamp': 1628444121.0144107, 'total_mass_run': 730.1048014407228, 'total_probability_weighted_mass_run': 0.2983275843337705, 'zero_prob_stars_skipped': 0}\n"
+      "{'population_name': 'f28b5f98d7ef40dcb17fc2481a6d3ced', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.04440288843805411, 'total_count': 20, 'start_timestamp': 1629459533.935186, 'end_timestamp': 1629459536.7203987, 'total_mass_run': 684.2544031669779, 'total_probability_weighted_mass_run': 0.28134439269236855, 'zero_prob_stars_skipped': 0}\n"
      ]
     }
    ],
@@ -660,42 +665,22 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Saving grid code to grid_options\n",
-      "Writing grid code to /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
-      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
       "Grid code loaded\n",
-      "Writing binary_c calls to /tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
+      "Writing binary_c calls to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
-      "/tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "binary_c M_1 2.0 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.013208238029791246\n",
-      "binary_c M_1 2.5102526289471614 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.009829948023831718\n",
-      "binary_c M_1 3.1506841305680684 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.0073157281034221516\n",
-      "binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.005444573822104362\n"
+      "with a total probability of 0.044402888438054094\n",
+      "/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
+      "binary_c M_1 2.227955577093495 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.010905083645619543\n",
+      "binary_c M_1 2.7647737053496777 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.008236638755149857\n",
+      "binary_c M_1 3.4309362899259503 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.006221155214163634\n",
+      "binary_c M_1 4.257608426597089 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.004698855121516278\n"
      ]
     }
    ],
    "source": [
-    "example_pop.set(verbosity=10)\n",
+    "example_pop.set(verbosity=1)\n",
     "calls_filename = example_pop.write_binary_c_calls_to_file()\n",
     "print(calls_filename)\n",
     "\n",
@@ -725,39 +710,34 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "Population-3680f3882c0a449c944462abffea2447 finished! The total probability was: 0.05150046619238191. It took a total of 0.6246354579925537s to run 20 systems on 2 cores\n",
+      "Population-e45c25448b32440cb7e220f4a3562907 finished! The total probability was: 0.04440288843805411. It took a total of 1.9539172649383545s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass zams_mass probability radius stellar_type\n",
-      "2.867655467480e+01 1.33079 9.81391 0.00167028 1.72498e-05 13\n",
-      "1.931266944719e+01 1.3933 12.3177 0.00124307 1.72498e-05 13\n",
-      "4.439623364590e+01 1.38004 7.81906 0.00224431 1.72498e-05 13\n",
-      "1.364277535630e+01 1.47961 15.4603 0.000925128 1.72498e-05 13\n",
-      "1.017435498578e+01 1.59052 19.4046 0.000688507 1.72498e-05 13\n",
-      "8.294870923827e+00 1.7197 24.3552 0.000512406 1.72498e-05 13\n",
-      "6.802132608769e+00 1.84162 30.5689 0.000381347 1.72498e-05 13\n",
-      "5.723570798020e+00 1.99471 38.3678 0.00028381 1.72498e-05 13\n",
-      "4.933751523833e+00 2.15875 48.1564 0.000211219 1.72498e-05 13\n",
-      "4.337250536639e+00 2.35209 60.4424 0.000157195 9.97286e-06 14\n",
-      "3.862081089332e+00 2.56776 75.8628 0.000116989 1.08873e-05 14\n",
-      "3.449960890183e+00 2.80457 95.2174 8.70668e-05 1.18914e-05 14\n",
-      "3.172196856333e+00 3.05193 119.51 6.47976e-05 1.29402e-05 14\n",
-      "3.069627290216e+00 3.27563 150 4.82242e-05 1.38887e-05 14\n",
+      "4.139293101586e+01 1.29427 8.13626 0.00202467 1.72498e-05 13\n",
+      "2.802986496151e+01 1.33699 10.0967 0.00152924 1.72498e-05 13\n",
+      "1.963621764679e+01 1.39754 12.5294 0.00115504 1.72498e-05 13\n",
+      "1.427601421985e+01 1.47745 15.5483 0.000872405 1.72498e-05 13\n",
+      "1.094409257247e+01 1.57571 19.2947 0.00065893 1.72498e-05 13\n",
+      "9.181971798545e+00 1.68748 23.9436 0.000497691 1.72498e-05 13\n",
+      "7.905335716621e+00 1.77287 29.7128 0.000375908 1.72498e-05 13\n",
+      "7.451192744924e+00 1.81495 36.872 0.000283924 1.72498e-05 13\n",
+      "7.396133472739e+00 1.82088 45.7561 0.000214449 1.72498e-05 13\n",
+      "7.396675941641e+00 1.82123 56.7809 0.000161974 1.72498e-05 13\n",
+      "7.404641347602e+00 1.82074 70.4621 0.000122339 1.72498e-05 13\n",
+      "7.444217227690e+00 1.81636 87.4397 9.2403e-05 1.72498e-05 13\n",
+      "7.453317880232e+00 1.81536 108.508 6.97923e-05 1.72498e-05 13\n",
+      "7.450828476484e+00 1.81563 134.653 5.27143e-05 1.72498e-05 13\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -817,11 +797,12 @@
     "    eccentricity=0.02,  # bse_options\n",
     "    \n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -876,15 +857,15 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -912,96 +893,39 @@
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Grid has handled 125 stars\n",
-      "with a total probability of 0.0862478164626921\n",
-      "Total starcount for this run will be: 125\n",
+      "Grid has handled 27 stars\n",
+      "with a total probability of 0.024868380796643753\n",
+      "Total starcount for this run will be: 27\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Population-d20a4c74d20a43b881c0c9e5def5f76c finished! The total probability was: 0.08624781646269201. It took a total of 8.561265707015991s to run 125 systems on 2 cores\n",
+      "Population-05128ef4c5fe4274a0356c3e99e2f2d2 finished! The total probability was: 0.024868380796643757. It took a total of 9.792905807495117s to run 27 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 stellar_type_2 prev_stellar_type_2 metallicity probability\n",
-      "8.863377990313e+01 1.29444 5.88566 0 2.99283 13 5 15 15 0.02 0.000627913\n",
-      "1.146421815741e+02 0 5.88566 1.33062 4.43925 15 15 13 5 0.02 0.000627913\n",
-      "7.222715508467e+01 1.34922 5.88566 0 5.88566 13 5 15 15 0.02 0.000627913\n",
-      "1.350021848285e+01 1.48488 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171108213270e+01 1.53113 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171086983243e+01 1.53177 17.3205 0 0.1 13 9 15 15 0.02 0.000154349\n",
-      "1.170770599495e+01 1.53176 17.3205 0 4.40513 13 5 15 15 0.02 0.000172877\n",
-      "1.230407246199e+01 1.59499 17.3205 0 4.40513 13 5 15 15 0.02 0.000610573\n",
-      "1.108751340926e+01 1.70319 17.3205 0 8.71025 13 4 15 15 0.02 0.000610573\n",
-      "1.941017702765e+01 1.34903 17.3205 1.65097 8.71025 13 13 13 5 0.02 0.000172877\n",
-      "1.980988739731e+01 1.36979 17.3205 1.60808 8.71025 13 13 13 5 0.02 0.000121486\n",
-      "3.571858031651e+01 1.53174 17.3205 1.30504 8.71025 13 13 13 5 0.02 8.42148e-05\n",
-      "3.459153942631e+01 1.53176 17.3205 1.31004 8.71025 13 13 13 5 0.02 9.8162e-05\n",
-      "1.687368550125e+01 1.34937 17.3205 1.73856 13.0154 13 13 13 8 0.02 0.000172877\n",
-      "1.194842917007e+01 1.78096 17.3205 0 13.0154 13 8 15 15 0.02 0.000610573\n",
-      "1.733614170983e+01 1.53184 17.3205 1.42375 13.0154 13 13 13 5 0.02 9.8162e-05\n",
-      "1.723547465714e+01 1.38403 17.3205 1.71288 13.0154 13 13 13 8 0.02 0.000121486\n",
-      "1.764340254985e+01 1.53174 17.3205 1.41264 13.0154 13 13 13 5 0.02 8.42148e-05\n",
-      "1.170425790780e+01 1.52963 17.3205 0 17.3205 13 5 15 15 0.02 0.000172877\n",
-      "8.922967341481e+00 1.85486 17.3205 0 17.3205 13 8 15 15 0.02 0.000610573\n",
-      "1.232906623449e+01 1.41074 17.3205 1.34281 17.3205 13 13 13 8 0.02 0.000121486\n",
-      "1.170775828562e+01 1.53183 17.3205 1.53183 17.3205 13 5 13 5 0.02 9.8162e-05\n",
-      "1.170770422321e+01 1.53175 17.3205 1.53175 17.3205 13 5 13 5 0.02 8.42148e-05\n",
-      "5.075844624794e+00 2.12303 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.766606588165e+00 2.20484 50.9713 0 0.1 14 8 15 15 0.02 3.79411e-05\n",
-      "4.768305081494e+00 2.18838 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.458869865939e+00 2.29864 50.9713 0 12.8178 14 8 15 15 0.02 0.000150087\n",
-      "1.806014211040e+01 2.10446 50.9713 1.40749 12.8178 13 13 13 5 0.02 2.9863e-05\n",
-      "4.797342083485e+00 2.10328 50.9713 0 12.8178 13 13 15 1 0.02 4.24954e-05\n",
-      "1.721374713429e+01 2.21673 50.9713 1.42212 12.8178 14 14 13 5 0.02 2.41295e-05\n",
-      "4.055645404546e+00 2.47276 50.9713 0 25.5357 14 7 15 15 0.02 0.000150087\n",
-      "1.806123543037e+01 2.21893 50.9713 1.40745 12.8178 14 14 13 5 0.02 2.07011e-05\n",
-      "8.117519147635e+00 2.10433 50.9713 2.21473 25.5357 13 13 14 8 0.02 4.24954e-05\n",
-      "8.315554923168e+00 2.15343 50.9713 2.08519 25.5357 13 13 13 8 0.02 2.9863e-05\n",
-      "7.917420996633e+00 2.21892 50.9713 1.7431 25.5357 14 14 13 8 0.02 2.07011e-05\n",
-      "7.693213405973e+00 2.21805 50.9713 1.78384 25.5357 14 14 13 8 0.02 2.41295e-05\n",
-      "3.753837732894e+00 2.62517 50.9713 0 38.2535 14 7 15 15 0.02 0.000150087\n",
-      "7.087296558990e+00 2.10417 50.9713 2.40935 38.2535 13 13 14 8 0.02 4.24954e-05\n",
-      "7.007109286263e+00 2.15854 50.9713 2.28672 38.2535 13 13 14 8 0.02 2.9863e-05\n",
-      "5.653200958306e+00 2.21878 50.9713 2.0587 38.2535 14 14 13 8 0.02 2.41295e-05\n",
-      "5.733794947644e+00 2.21892 50.9713 1.99255 38.2535 14 14 13 8 0.02 2.07011e-05\n",
-      "3.513216011269e+00 2.76647 50.9713 0 50.9713 14 7 15 15 0.02 0.000150087\n",
-      "4.750574783854e+00 2.27442 50.9713 0 50.9713 14 8 15 15 0.02 4.24954e-05\n",
-      "7.278384712062e+00 1.29678 50.9713 2.09216 50.9713 13 8 13 13 0.02 2.9863e-05\n",
-      "4.765996194699e+00 2.20787 50.9713 2.20787 50.9713 14 8 14 8 0.02 2.07011e-05\n",
-      "4.765535914728e+00 2.21331 50.9713 2.21331 50.9713 14 8 14 8 0.02 2.41295e-05\n",
-      "3.104706358826e+00 3.17639 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.069363482023e+00 3.27572 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.047074050271e+00 3.3836 150 0 37.575 14 7 15 15 0.02 3.68933e-05\n",
-      "5.974759306305e+00 3.23604 150 2.53922 37.575 14 14 14 7 0.02 1.04459e-05\n",
-      "6.074084349384e+00 3.30145 150 2.13876 37.575 14 14 13 8 0.02 7.34071e-06\n",
-      "5.733865371895e+00 3.29994 150 2.00498 37.575 14 14 13 8 0.02 5.93135e-06\n",
-      "3.027099358410e+00 3.53631 150 0 75.05 14 7 15 15 0.02 3.68933e-05\n",
-      "5.807147339697e+00 3.30197 150 1.9791 37.575 14 14 13 8 0.02 5.08861e-06\n",
-      "4.862942347290e+00 3.25294 150 2.97823 75.05 14 14 14 7 0.02 1.04459e-05\n",
-      "4.556479830908e+00 3.29942 150 2.73221 75.05 14 14 14 7 0.02 7.34071e-06\n",
-      "3.853070305680e+00 3.29977 150 2.62486 75.05 14 14 14 7 0.02 5.93135e-06\n",
-      "3.881529045940e+00 3.30149 150 2.55924 75.05 14 14 14 7 0.02 5.08861e-06\n",
-      "3.015033359333e+00 3.64419 150 0 112.525 14 7 15 15 0.02 3.68933e-05\n",
-      "4.126828648362e+00 3.32047 150 0 112.525 14 14 15 3 0.02 1.04459e-05\n",
-      "3.990017992944e+00 3.3032 150 2.94027 112.525 14 14 14 7 0.02 7.34071e-06\n",
-      "3.206771867883e+00 3.07671 150 3.11282 112.525 14 14 14 7 0.02 5.93135e-06\n",
-      "3.006827156705e+00 3.72638 150 0 150 14 7 15 15 0.02 3.68933e-05\n",
-      "3.218786094847e+00 3.30337 150 3.01344 112.525 14 14 14 7 0.02 5.08861e-06\n",
-      "4.527722847382e+00 1.42238 150 0 150 13 5 15 15 0.02 1.04459e-05\n",
-      "3.069567332611e+00 3.27804 150 3.27804 150 14 7 14 7 0.02 5.93135e-06\n",
-      "5.726405299909e+00 1.29746 150 3.22759 150 13 8 14 14 0.02 7.34071e-06\n",
-      "3.069626478211e+00 3.27565 150 3.27565 150 14 7 14 7 0.02 5.08861e-06\n",
+      "1.219029061236e+01 1.60007 17.3205 0 2.97008 13 5 15 15 0.02 0.000498487\n",
+      "1.935920346899e+01 1.29448 17.3205 0 8.71025 13 13 15 2 0.02 0.000498487\n",
+      "2.123795595728e+01 1.30902 17.3205 1.58519 8.71025 13 13 13 5 0.02 0.000287968\n",
+      "3.579099761269e+01 1.52414 17.3205 1.30642 8.71025 13 13 13 5 0.02 0.000220016\n",
+      "1.674063083432e+01 1.29457 17.3205 0 14.4504 13 13 15 2 0.02 0.000498487\n",
+      "1.779197348711e+01 1.3228 17.3205 1.71196 14.4504 13 13 13 8 0.02 0.000287968\n",
+      "1.548740826516e+01 1.52415 17.3205 1.45407 14.4504 13 13 13 5 0.02 0.000220016\n",
+      "1.772169325356e+01 1.81957 73.0434 1.46573 12.2572 13 13 13 5 0.02 4.43422e-05\n",
+      "1.367065500196e+01 1.66003 73.0434 1.79487 12.2572 13 13 13 8 0.02 7.67586e-05\n",
+      "2.021960493499e+01 1.82061 73.0434 1.39205 12.2572 13 13 13 5 0.02 3.38788e-05\n",
+      "9.012246630357e+00 1.81529 73.0434 0 36.5717 13 8 15 15 0.02 7.67586e-05\n",
+      "7.462779538274e+00 1.82255 73.0434 1.81499 36.5717 13 13 13 8 0.02 3.38788e-05\n",
+      "1.030499912298e+01 1.80592 73.0434 1.81066 36.5717 13 13 13 8 0.02 4.43422e-05\n",
+      "4.227002356107e+00 2.43719 73.0434 0 60.8862 14 14 15 1 0.02 7.67586e-05\n",
+      "7.396288708628e+00 1.8216 73.0434 1.8216 60.8862 13 8 13 8 0.02 3.38788e-05\n",
+      "7.394728392218e+00 1.80919 73.0434 1.79091 60.8862 13 13 13 8 0.02 4.43422e-05\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -1067,10 +991,11 @@
     "    \n",
     "    # grid_options\n",
     "    amt_cores=2,  # grid_options\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -1168,14 +1093,14 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -1184,7 +1109,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1198,7 +1123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/html/binary_c_parameters.html b/docs/build/html/binary_c_parameters.html
index ecb6bba95e82541b829172e378f1cf7c195befd2..a3432514b634dde608a1e406f446c47d63265d45 100644
--- a/docs/build/html/binary_c_parameters.html
+++ b/docs/build/html/binary_c_parameters.html
@@ -40,7 +40,7 @@
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
     <link rel="next" title="Population grid code options" href="grid_options_descriptions.html" />
-    <link rel="prev" title="Using the API functionality of binarycpython" href="notebook_api_functionality.html" /> 
+    <link rel="prev" title="Example use case: Common-envelope evolution" href="notebook_common_envelope_evolution.html" /> 
 </head>
 
 <body class="wy-body-for-nav">
@@ -197,7 +197,7 @@
 <h1>Binary_c parameters<a class="headerlink" href="#binary-c-parameters" title="Permalink to this headline">¶</a></h1>
 <p>The following chapter contains all the parameters that the current version of binary_c can handle, along with their descriptions and other properties.</p>
 <dl class="simple">
-<dt>This information was obtained by the following binary_c build:</dt><dd><p><strong>binary_c git branch</strong>: branch_david   <strong>binary_c git revision</strong>: 6162:20210825:093caf0e9      <strong>Built on</strong>: Aug 25 2021 18:02:39</p>
+<dt>This information was obtained by the following binary_c build:</dt><dd><p><strong>binary_c git branch</strong>: newmaster      <strong>binary_c git revision</strong>: 6185:20210910:1621c23a5      <strong>Built on</strong>: Sep 10 2021 15:05:46</p>
 </dd>
 </dl>
 <div class="section" id="section-stars">
@@ -695,6 +695,12 @@
 <div class="line"><strong>Default value</strong>: NULL</div>
 </div>
 <div class="line-block">
+<div class="line"><strong>Parameter</strong>: artificial_mass_accretion_rate_by_stellar_type%d</div>
+<div class="line"><strong>Description</strong>: Constant mass accretion rate for stellar type &lt;n&gt;.</div>
+<div class="line"><strong>Parameter input type</strong>: Float(scanf)</div>
+<div class="line"><strong>Default value</strong>: NULL</div>
+</div>
+<div class="line-block">
 <div class="line"><strong>Parameter</strong>: artificial_angular_momentum_accretion_rate%d</div>
 <div class="line"><strong>Description</strong>: Constant angular momentum accretion for star &lt;n&gt;.</div>
 <div class="line"><strong>Parameter input type</strong>: Float(scanf)</div>
@@ -747,14 +753,6 @@
 <div class="line"><strong>Macros</strong>: [‘BH_HURLEY2002 = 0’, ‘BH_BELCZYNSKI = 1’, ‘BH_SPERA2015 = 2’, ‘BH_FRYER12_DELAYED = 3’, ‘BH_FRYER12_RAPID = 4’, ‘BH_FRYER12_STARTRACK = 5’]</div>
 </div>
 <div class="line-block">
-<div class="line"><strong>Parameter</strong>: PPISN_prescription</div>
-<div class="line"><strong>Description</strong>: (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019.</div>
-<div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
-<div class="line"><strong>Macros</strong>: [‘PPISN_NONE = 0’, ‘PPISN_FARMER19 = 1’]</div>
-<div class="line"><strong>Extra</strong>: Ignore</div>
-</div>
-<div class="line-block">
 <div class="line"><strong>Parameter</strong>: sn_kick_distribution_II</div>
 <div class="line"><strong>Description</strong>: Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
@@ -786,7 +784,7 @@
 <div class="line"><strong>Parameter</strong>: sn_kick_distribution_GRB_COLLAPSAR</div>
 <div class="line"><strong>Description</strong>: Set the distribution of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 <div class="line"><strong>Macros</strong>: [‘KICK_VELOCITY_FIXED = 0’, ‘KICK_VELOCITY_MAXWELLIAN = 1’, ‘KICK_VELOCITY_CUSTOM = 2’]</div>
 </div>
 <div class="line-block">
@@ -832,27 +830,6 @@
 <div class="line"><strong>Macros</strong>: [‘KICK_VELOCITY_FIXED = 0’, ‘KICK_VELOCITY_MAXWELLIAN = 1’, ‘KICK_VELOCITY_CUSTOM = 2’]</div>
 </div>
 <div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_distribution_PPISN</div>
-<div class="line"><strong>Description</strong>: Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
-<div class="line"><strong>Macros</strong>: [‘KICK_VELOCITY_FIXED = 0’, ‘KICK_VELOCITY_MAXWELLIAN = 1’, ‘KICK_VELOCITY_CUSTOM = 2’]</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_distribution_PISN</div>
-<div class="line"><strong>Description</strong>: Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Macros</strong>: [‘KICK_VELOCITY_FIXED = 0’, ‘KICK_VELOCITY_MAXWELLIAN = 1’, ‘KICK_VELOCITY_CUSTOM = 2’]</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_distribution_PHDIS</div>
-<div class="line"><strong>Description</strong>: Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Macros</strong>: [‘KICK_VELOCITY_FIXED = 0’, ‘KICK_VELOCITY_MAXWELLIAN = 1’, ‘KICK_VELOCITY_CUSTOM = 2’]</div>
-</div>
-<div class="line-block">
 <div class="line"><strong>Parameter</strong>: sn_kick_dispersion_II</div>
 <div class="line"><strong>Description</strong>: Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
@@ -880,7 +857,7 @@
 <div class="line"><strong>Parameter</strong>: sn_kick_dispersion_GRB_COLLAPSAR</div>
 <div class="line"><strong>Description</strong>: Set the dispersion of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Default value</strong>: 190</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: sn_kick_dispersion_TZ</div>
@@ -919,24 +896,6 @@
 <div class="line"><strong>Default value</strong>: 0</div>
 </div>
 <div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_dispersion_PPISN</div>
-<div class="line"><strong>Description</strong>: Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 190</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_dispersion_PISN</div>
-<div class="line"><strong>Description</strong>: Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_dispersion_PHDIS</div>
-<div class="line"><strong>Description</strong>: Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-</div>
-<div class="line-block">
 <div class="line"><strong>Parameter</strong>: sn_kick_companion_IA_He</div>
 <div class="line"><strong>Description</strong>: Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
@@ -1077,27 +1036,6 @@
 <div class="line"><strong>Macros</strong>: [‘SN_IMPULSE_NONE = 0’, ‘SN_IMPULSE_LIU2015 = 1’, ‘SN_IMPULSE_WHEELER1975 = 2’]</div>
 </div>
 <div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_companion_PPISN</div>
-<div class="line"><strong>Description</strong>: Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Macros</strong>: [‘SN_IMPULSE_NONE = 0’, ‘SN_IMPULSE_LIU2015 = 1’, ‘SN_IMPULSE_WHEELER1975 = 2’]</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_companion_PISN</div>
-<div class="line"><strong>Description</strong>: Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Macros</strong>: [‘SN_IMPULSE_NONE = 0’, ‘SN_IMPULSE_LIU2015 = 1’, ‘SN_IMPULSE_WHEELER1975 = 2’]</div>
-</div>
-<div class="line-block">
-<div class="line"><strong>Parameter</strong>: sn_kick_companion_PHDIS</div>
-<div class="line"><strong>Description</strong>: Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.</div>
-<div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Macros</strong>: [‘SN_IMPULSE_NONE = 0’, ‘SN_IMPULSE_LIU2015 = 1’, ‘SN_IMPULSE_WHEELER1975 = 2’]</div>
-</div>
-<div class="line-block">
 <div class="line"><strong>Parameter</strong>: wd_sigma</div>
 <div class="line"><strong>Description</strong>: Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
@@ -1169,25 +1107,25 @@
 <div class="line"><strong>Parameter</strong>: delta_mcmin</div>
 <div class="line"><strong>Description</strong>: A parameter to reduce the minimum core mass for third dredge up to occur on the TPAGB. As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: lambda_min</div>
 <div class="line"><strong>Description</strong>: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min&gt;0 implies that, once Mc&gt;Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars. See also lambda_multiplier.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: lambda_multiplier</div>
 <div class="line"><strong>Description</strong>: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min&gt;0 implies that, once Mc&gt;Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: minimum_envelope_mass_for_third_dredgeup</div>
 <div class="line"><strong>Description</strong>: The minimum envelope mass for third dredge up on the TPAGB. Early, solar metallicity models by Straniero et al suggested 0.5Msun is typical. However, circumstantial evidence (Izzard et al 2009) as well as newer models by Stancliffe and Karakas suggest that at low metallicity a value nearer zero is more appropriate.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0.5</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: mass_of_pmz</div>
@@ -1199,13 +1137,13 @@
 <div class="line"><strong>Parameter</strong>: c13_eff</div>
 <div class="line"><strong>Description</strong>: The “efficiency” of partial mixing in a TPAGB star intershell region, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: mc13_pocket_multiplier</div>
 <div class="line"><strong>Description</strong>: Multiplies the mass in the partial mixing zone of a TPAGB star, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: tides_convective_damping</div>
@@ -1231,7 +1169,7 @@
 <div class="line"><strong>Parameter</strong>: hbbtfac</div>
 <div class="line"><strong>Description</strong>: A parameter to modulate the temperature at the base of the hot-bottom burning zone in TPAGB stars. (Works only if NUCSYN is defined)</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: wind_multiplier_%d</div>
@@ -1317,7 +1255,7 @@
 <div class="line"><strong>Parameter</strong>: MINT_metallicity</div>
 <div class="line"><strong>Description</strong>: This sets the metallicity for MINT. It is ignored if set to -1.0, the default, in which case the normal metallicity parameter is used.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: -1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: gaia_Teff_binwidth</div>
@@ -1349,28 +1287,28 @@
 <div class="line"><strong>Parameter</strong>: AGB_core_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to use for calculating AGB core masses. 0=Hurley et al. 2002 if no NUCSYN, Karakas 2002 if NUCSYN is defined; 1=Hurley et al. 2002 (overshooting models); 1=Karakas 2002 (non-overshooting models).</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
+<div class="line"><strong>Default value</strong>: 2</div>
 <div class="line"><strong>Macros</strong>: [‘AGB_CORE_ALGORITHM_DEFAULT = 0’, ‘AGB_CORE_ALGORITHM_HURLEY = 1’, ‘AGB_CORE_ALGORITHM_KARAKAS = 2’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: AGB_radius_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to use for calculating radii on the TPAGB.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
+<div class="line"><strong>Default value</strong>: 2</div>
 <div class="line"><strong>Macros</strong>: [‘AGB_RADIUS_ALGORITHM_DEFAULT = 0’, ‘AGB_RADIUS_ALGORITHM_HURLEY = 1’, ‘AGB_RADIUS_ALGORITHM_KARAKAS = 2’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: AGB_luminosity_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to use for calculating luminosities on the TPAGB.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
+<div class="line"><strong>Default value</strong>: 2</div>
 <div class="line"><strong>Macros</strong>: [‘AGB_LUMINOSITY_ALGORITHM_DEFAULT = 0’, ‘AGB_LUMINOSITY_ALGORITHM_HURLEY = 1’, ‘AGB_LUMINOSITY_ALGORITHM_KARAKAS = 2’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: AGB_3dup_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to use for calculating third dredge up efficiency on the TPAGB.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 1</div>
+<div class="line"><strong>Default value</strong>: 2</div>
 <div class="line"><strong>Macros</strong>: [‘AGB_THIRD_DREDGE_UP_ALGORITHM_DEFAULT = 0’, ‘AGB_THIRD_DREDGE_UP_ALGORITHM_HURLEY = 1’, ‘AGB_THIRD_DREDGE_UP_ALGORITHM_KARAKAS = 2’, ‘AGB_THIRD_DREDGE_UP_ALGORITHM_STANCLIFFE = 3’]</div>
 </div>
 <div class="line-block">
@@ -1537,6 +1475,24 @@
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
 <div class="line"><strong>Default value</strong>: False</div>
 </div>
+<div class="line-block">
+<div class="line"><strong>Parameter</strong>: degenerate_core_merger_nucsyn</div>
+<div class="line"><strong>Description</strong>: If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE)</div>
+<div class="line"><strong>Parameter input type</strong>: True|False</div>
+<div class="line"><strong>Default value</strong>: False</div>
+</div>
+<div class="line-block">
+<div class="line"><strong>Parameter</strong>: degenerate_core_helium_merger_ignition</div>
+<div class="line"><strong>Description</strong>: If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE)</div>
+<div class="line"><strong>Parameter input type</strong>: True|False</div>
+<div class="line"><strong>Default value</strong>: True</div>
+</div>
+<div class="line-block">
+<div class="line"><strong>Parameter</strong>: degenerate_core_merger_dredgeup_fraction</div>
+<div class="line"><strong>Description</strong>: If non-zero, mix this fraction of the degenerate core during a merger.(0.0).</div>
+<div class="line"><strong>Parameter input type</strong>: Float</div>
+<div class="line"><strong>Default value</strong>: 0</div>
+</div>
 </div>
 <div class="section" id="section-binary">
 <h2>Section: binary<a class="headerlink" href="#section-binary" title="Permalink to this headline">¶</a></h2>
@@ -1742,7 +1698,7 @@
 <div class="line"><strong>Parameter</strong>: post_ce_objects_have_envelopes</div>
 <div class="line"><strong>Description</strong>: If TRUE then post-common-envelope objects have thin envelopes. You need this if you are to have post-CE post-AGB stars. Note that this <em>may</em> be unstable, i.e. you may end up having many CEEs. The mass in the envelope is controlled by post_ce_adaptive_menv. TRUE by default.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: True</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: PN_comenv_transition_time</div>
@@ -1944,20 +1900,22 @@
 <div class="line"><strong>Parameter</strong>: type_Ia_MCh_supernova_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to be used when calculating type Ia yields from Chandrasekhar-mass exploders. 0 = DD7 (Iwamoto 1999), 1 = Seitenzahl 2013 3D hydro yields (you must also set Seitenzahl2013_model)</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Macros</strong>: [‘TYPE_IA_MCH_SUPERNOVA_ALGORITHM_DD2 = 0’, ‘TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013 = 1’, ‘TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013_AUTOMATIC = 2’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: Seitenzahl2013_model</div>
 <div class="line"><strong>Description</strong>: Which of Seitenzahl et al. 2013’s models to use? One of N1,N3,N5,N10,N20,N40,N100L,N100,N100H,N150,N200,N300C,N1600,N1600C,N100_Z0.5,N100_Z0.1,N100_Z0.01 (defaults to N100).</div>
 <div class="line"><strong>Parameter input type</strong>: String</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: N100</div>
 <div class="line"><strong>Extra</strong>: N1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: type_Ia_sub_MCh_supernova_algorithm</div>
 <div class="line"><strong>Description</strong>: Algorithm to be used when calculating type Ia yields from sub-Chandrasekhar-mass exploders. (Currently unused.)</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Macros</strong>: [‘TYPE_IA_SUB_MCH_SUPERNOVA_ALGORITHM_LIVNE_ARNETT_1995 = 0’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: max_HeWD_mass</div>
@@ -2719,7 +2677,7 @@
 <div class="line"><strong>Parameter</strong>: NeNaMgAl</div>
 <div class="line"><strong>Description</strong>: Enables NeNaMgAl reaction network. Requires NUCSYN and NUCSYN_HBB.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: True</div>
 <div class="line"><strong>Extra</strong>: Ignore</div>
 </div>
 <div class="line-block">
@@ -2744,21 +2702,23 @@
 <div class="line"><strong>Parameter</strong>: nucsyn_metallicity</div>
 <div class="line"><strong>Description</strong>: This sets the metallicity of the nucleosynthesis algorithms, i.e. the amount (by mass) of matter which is not hydrogen or helium. Usually you’d just set this with the metallicity parameter, but if you want the nucleosynthesis to be outside the range of the stellar evolution algorithm (e.g. Z=0 or Z=0.04) then you need to use nucsyn_metallicity. That said, it’s also outside the range of some of the nucleosynthesis algorithms as well, so you have been warned!</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: -1</div>
 <div class="line"><strong>Macros</strong>: [‘DEFAULT_TO_METALLICITY = -1’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: nucsyn_solver</div>
 <div class="line"><strong>Description</strong>: Choose the solver used in nuclear burning. 0 = KAPS_RENTROP is a Kaps-Rentrop scheme (fast, not great for stiff problems), 1 = LSODA (Adams/BSF switcher), 2 = CVODE library (<a class="reference external" href="https://computing.llnl.gov/projects/sundials">https://computing.llnl.gov/projects/sundials</a>. Default 0.</div>
 <div class="line"><strong>Parameter input type</strong>: Unsigned integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Macros</strong>: [‘NUCSYN_SOLVER_KAPS_RENTROP = 0’, ‘NUCSYN_SOLVER_LSODA = 1’, ‘NUCSYN_SOLVER_CVODE = 2’, ‘NUCSYN_SOLVER_NUMBER = 3’, ‘NUCSYN_SOLVER_KAPS_RENTROP = 0’, ‘NUCSYN_SOLVER_LSODA = 1’, ‘NUCSYN_SOLVER_CVODE = 2’, ‘NUCSYN_SOLVER_NUMBER = 3’]</div>
 <div class="line"><strong>Extra</strong>: 0</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: initial_abundance_mix</div>
 <div class="line"><strong>Description</strong>: initial abundance mixture: 0=AG89, 1=Karakas 2002, 2=Lodders 2003, 3=Asplund 2005 (not available?), 4=Garcia Berro, 5=Grevesse Noels 1993</div>
 <div class="line"><strong>Parameter input type</strong>: Unsigned integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
+<div class="line"><strong>Macros</strong>: [‘NUCSYN_INIT_ABUND_MIX_AG89 = 0’, ‘NUCSYN_INIT_ABUND_MIX_KARAKAS2002 = 1’, ‘NUCSYN_INIT_ABUND_MIX_LODDERS2003 = 2’, ‘NUCSYN_INIT_ABUND_MIX_ASPLUND2005 = 3’, ‘NUCSYN_INIT_ABUND_MIX_GARCIABERRO = 4’, ‘NUCSYN_INIT_ABUND_MIX_GREVESSE_NOELS_1993 = 5’, ‘NUCSYN_INIT_ABUND_MIX_ASPLUND2009 = 6’, ‘NUCSYN_INIT_ABUND_MIX_KOBAYASHI2011_ASPLUND2009 = 7’, ‘NUCSYN_INIT_ABUND_MIX_LODDERS2010 = 8’]</div>
 <div class="line"><strong>Extra</strong>: 0</div>
 </div>
 <div class="line-block">
@@ -2786,43 +2746,44 @@
 <div class="line"><strong>Parameter</strong>: init_abunds_only</div>
 <div class="line"><strong>Description</strong>: If True, outputs only the initial abundances, then exits.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: initial_abunds_only</div>
 <div class="line"><strong>Description</strong>: If True, outputs only the initial abundances, then exits.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: no_thermohaline_mixing</div>
 <div class="line"><strong>Description</strong>: If True, disables thermohaline mixing.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: lithium_GB_post_Heflash</div>
 <div class="line"><strong>Description</strong>: Sets the lithium abundances after the helium flash. Requires NUCSYN and LITHIUM_TABLES.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: lithium_GB_post_1DUP</div>
 <div class="line"><strong>Description</strong>: Sets the lithium abundance after first dredge up. Requires NUCSYN and LITHIUM_TABLES.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: lithium_hbb_multiplier</div>
 <div class="line"><strong>Description</strong>: Multiplies the lithium abundances on the AGB during HBB (based on Karakas/Fishlock et al models).Requires NUCSYN and LITHIUM_TABLES.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: angelou_lithium_decay_function</div>
 <div class="line"><strong>Description</strong>: Functional form which describes Li7 decay. Requires NUCSYN and NUCSYN_ANGELOU_LITHIUM. Choices are: 0 expoential (see angelou_lithium_decay_time).</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
 <div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Macros</strong>: [‘ANGELOU_LITHIUM_DECAY_FUNCTION_EXPONENTIAL = 0’]</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: angelou_lithium_LMMS_time</div>
@@ -2966,17 +2927,10 @@
 <div class="section" id="section-output">
 <h2>Section: output<a class="headerlink" href="#section-output" title="Permalink to this headline">¶</a></h2>
 <div class="line-block">
-<div class="line"><strong>Parameter</strong>: david_logging_function</div>
-<div class="line"><strong>Description</strong>: Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, &gt;0 for custom logging functions</div>
-<div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: 0</div>
-<div class="line"><strong>Extra</strong>: Ignore</div>
-</div>
-<div class="line-block">
 <div class="line"><strong>Parameter</strong>: cf_amanda_log</div>
 <div class="line"><strong>Description</strong>: Enable logging to compare to Amanda’s models.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: float_overflow_checks</div>
@@ -3024,7 +2978,7 @@
 <div class="line"><strong>Parameter</strong>: legacy_yields</div>
 <div class="line"><strong>Description</strong>: Turn on ensemble legacy yield output.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: ensemble_defer</div>
@@ -3072,31 +3026,31 @@
 <div class="line"><strong>Parameter</strong>: EMP_logg_maximum</div>
 <div class="line"><strong>Description</strong>: Maximum logg that EMP stars are allowed to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_minimum_age.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 4</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: EMP_minimum_age</div>
 <div class="line"><strong>Description</strong>: Minimum age that EMP stars are required to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 10</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: EMP_feh_maximum</div>
 <div class="line"><strong>Description</strong>: Maximum [Fe/H] that an EMP stars may have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default -2.0.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: -2</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: CEMP_cfe_minimum</div>
 <div class="line"><strong>Description</strong>: Minimum [C/Fe] that CEMP stars are required to have. See Izzard et al 2009. See also NEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 0.7.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0.7</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: NEMP_cfe_minimum</div>
 <div class="line"><strong>Description</strong>: Minimum [N/Fe] that NEMP stars are required to have. See Izzard et al 2009, Pols et al. 2012. See also CEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 1.0.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: thick_disc_start_age</div>
@@ -3256,84 +3210,84 @@
 <div class="line"><strong>Parameter</strong>: MINT_dir</div>
 <div class="line"><strong>Description</strong>: Location of MINT algorithm data.</div>
 <div class="line"><strong>Parameter input type</strong>: String</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>:</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_data_cleanup</div>
 <div class="line"><strong>Description</strong>: Activate checks on incoming data to try to account for problems. Will make data-loading slower, but may fix a few things.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_MS_rejuvenation</div>
 <div class="line"><strong>Description</strong>: Turn on or off (hydrogen) main-sequence rejuvenation.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: True</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_remesh</div>
 <div class="line"><strong>Description</strong>: Turn on or off MINT’s remeshing.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: True</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_use_ZAMS_profiles</div>
 <div class="line"><strong>Description</strong>: Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.)</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: True</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_fallback_to_test_data</div>
 <div class="line"><strong>Description</strong>: If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE)</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_disable_grid_load_warnings</div>
 <div class="line"><strong>Description</strong>: Use this to explicitly disable MINT’s warnings when loading a grid with, e.g., missing or too much data.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_Kippenhahn</div>
 <div class="line"><strong>Description</strong>: Turn on or off MINT’s Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_nshells</div>
 <div class="line"><strong>Description</strong>: Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200)</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 200</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_maximum_nshells</div>
 <div class="line"><strong>Description</strong>: Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000)</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1000</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_minimum_nshells</div>
 <div class="line"><strong>Description</strong>: Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0)</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 10</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_Kippenhahn_stellar_type</div>
 <div class="line"><strong>Description</strong>: Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: -1</div>
 <div class="line"><strong>Macros</strong>: [‘LOW_MASS_MS = 0’, ‘MS = 1’, ‘HG = 2’, ‘GIANT_BRANCH = 3’, ‘CHeB = 4’, ‘EAGB = 5’, ‘TPAGB = 6’, ‘HeMS = 7’, ‘HeHG = 8’, ‘HeGB = 9’, ‘HeWD = 10’, ‘COWD = 11’, ‘ONeWD = 12’, ‘NS = 13’, ‘BH = 14’, ‘MASSLESS_REMNANT = 15’]</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
@@ -3341,7 +3295,7 @@
 <div class="line"><strong>Parameter</strong>: MINT_Kippenhahn_companion_stellar_type</div>
 <div class="line"><strong>Description</strong>: Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output.</div>
 <div class="line"><strong>Parameter input type</strong>: Integer</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: -1</div>
 <div class="line"><strong>Macros</strong>: [‘LOW_MASS_MS = 0’, ‘MS = 1’, ‘HG = 2’, ‘GIANT_BRANCH = 3’, ‘CHeB = 4’, ‘EAGB = 5’, ‘TPAGB = 6’, ‘HeMS = 7’, ‘HeHG = 8’, ‘HeGB = 9’, ‘HeWD = 10’, ‘COWD = 11’, ‘ONeWD = 12’, ‘NS = 13’, ‘BH = 14’, ‘MASSLESS_REMNANT = 15’]</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
@@ -3349,21 +3303,21 @@
 <div class="line"><strong>Parameter</strong>: MINT_nuclear_burning</div>
 <div class="line"><strong>Description</strong>: Turn on or off MINT’s nuclear burning algorithm.</div>
 <div class="line"><strong>Parameter input type</strong>: True|False</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: False</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_minimum_shell_mass</div>
 <div class="line"><strong>Description</strong>: Minimum shell mass in MINT’s nuclear burning routines.</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 1e-06</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>Parameter</strong>: MINT_maximum_shell_mass</div>
 <div class="line"><strong>Description</strong>: Maximum shell mass in MINT’s nuclear burning routines. :</div>
 <div class="line"><strong>Parameter input type</strong>: Float</div>
-<div class="line"><strong>Default value</strong>: NULL</div>
+<div class="line"><strong>Default value</strong>: 0.1</div>
 <div class="line"><strong>Extra</strong>:</div>
 </div>
 </div>
@@ -3532,7 +3486,7 @@
         <a href="grid_options_descriptions.html" class="btn btn-neutral float-right" title="Population grid code options" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="notebook_api_functionality.html" class="btn btn-neutral float-left" title="Using the API functionality of binarycpython" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="notebook_common_envelope_evolution.html" class="btn btn-neutral float-left" title="Example use case: Common-envelope evolution" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   
@@ -3555,9 +3509,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/custom_logging_functions.html b/docs/build/html/custom_logging_functions.html
index c7e8dfe67c5db268fcb3dfffd1615518205a5053..b4b340d1dc0b2b6352080865138464b7a254fa85 100644
--- a/docs/build/html/custom_logging_functions.html
+++ b/docs/build/html/custom_logging_functions.html
@@ -420,9 +420,9 @@ I recommend using this in function in combination with a function that generates
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/distribution_functions.html b/docs/build/html/distribution_functions.html
index 2ab05aaf84cc404d58b9abfc3c3507c2293f811c..566951b34a0961af639a34cfb530289b6d78cf82 100644
--- a/docs/build/html/distribution_functions.html
+++ b/docs/build/html/distribution_functions.html
@@ -911,9 +911,9 @@ and is be given by dp/dlogP ~ (logP)^p for all other binary configurations (defa
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/example_notebooks.html b/docs/build/html/example_notebooks.html
index 57f157057cfb92f6a7a126e21bc85d7bc2ec206a..f4596c160a423df339f7f5d286605a2a0c5aa47e 100644
--- a/docs/build/html/example_notebooks.html
+++ b/docs/build/html/example_notebooks.html
@@ -39,7 +39,7 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Running individual systems with binarycpython" href="notebook_individual_systems.html" />
+    <link rel="next" title="Tutorial: Running individual systems with binary_c-python" href="notebook_individual_systems.html" />
     <link rel="prev" title="useful_funcs module" href="useful_funcs.html" /> 
 </head>
 
@@ -90,11 +90,15 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="current reference internal" href="#">Example notebooks</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -193,22 +197,22 @@
 <div class="section" id="example-notebooks">
 <h1>Example notebooks<a class="headerlink" href="#example-notebooks" title="Permalink to this headline">¶</a></h1>
 <p>We have a set of notebooks that explain and show the usage of the binarycpython features. The notebooks are also stored in the examples/ directory in the <a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master/examples">repository</a></p>
-<p>The order of the notebooks below is more or less the recommended order to read.</p>
+<p>The order of the notebooks below is more or less the recommended order to read. The last couple of notebooks are example usecases</p>
 <div class="toctree-wrapper compound">
 <p class="caption"><span class="caption-text">Contents:</span></p>
 <ul>
-<li class="toctree-l1"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html#Single-system-with-run_wrapper">Single system with run_wrapper</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html#Single-system-via-population-object">Single system via population object</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html#Single-system-via-API-functionality">Single system via API functionality</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html#Usage">Usage</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html#Examples-of-logging-strings">Examples of logging strings</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebook_population.html#Setting-up-the-Population-object">Setting up the Population object</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_population.html#Adding-grid-variables">Adding grid variables</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_population.html#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
@@ -217,7 +221,7 @@
 <li class="toctree-l2"><a class="reference internal" href="notebook_population.html#Full-examples-of-population-scripts">Full examples of population scripts</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html#getting-extra-information-about-binary_c-parameters">getting extra information about binary_c parameters</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html#Build-information-of-binary_c">Build information of binary_c</a></li>
 <li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html#Example-parse-function">Example parse function</a></li>
@@ -225,10 +229,41 @@
 <li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html#Getting-help">Getting help</a></li>
 </ul>
 </li>
-<li class="toctree-l1"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a><ul>
+<li class="toctree-l1"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a><ul>
 <li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html#Example-usage:">Example usage:</a></li>
 </ul>
 </li>
+<li class="toctree-l1"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#Adding-grid-variables">Adding grid variables</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#Evolving-the-grid">Evolving the grid</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#ZAMS-Luminosity-distribution-with-the-initial-mass-function">ZAMS Luminosity distribution with the initial mass function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html#A-better-sampled-grid">A better-sampled grid</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html#Adding-grid-variables">Adding grid variables</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html#Evolving-the-grid">Evolving the grid</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html#Stellar-Grid">Stellar Grid</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html#Evolving-the-grid">Evolving the grid</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html#Binary-stars">Binary stars</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html#Stellar-Grid">Stellar Grid</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html#Logging-and-handling-the-output">Logging and handling the output</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html#Evolving-the-grid">Evolving the grid</a></li>
+</ul>
+</li>
 </ul>
 </div>
 </div>
@@ -241,7 +276,7 @@
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="notebook_individual_systems.html" class="btn btn-neutral float-right" title="Running individual systems with binarycpython" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_individual_systems.html" class="btn btn-neutral float-right" title="Tutorial: Running individual systems with binary_c-python" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
         <a href="useful_funcs.html" class="btn btn-neutral float-left" title="useful_funcs module" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
@@ -267,9 +302,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/functions.html b/docs/build/html/functions.html
index 5974c283c710c64fade409bdde0fbb6d975a3aea..e27f55452a0768903bdc8dabdce9282aa10c51d0 100644
--- a/docs/build/html/functions.html
+++ b/docs/build/html/functions.html
@@ -209,6 +209,20 @@ useful functions for the user</p>
 </ul>
 </dd>
 </dl>
+<dl class="py class">
+<dt id="binarycpython.utils.functions.AutoVivificationDict">
+<em class="property">class </em><code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">AutoVivificationDict</code><a class="reference internal" href="_modules/binarycpython/utils/functions.html#AutoVivificationDict"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.AutoVivificationDict" title="Permalink to this definition">¶</a></dt>
+<dd><p>Bases: <code class="xref py py-class docutils literal notranslate"><span class="pre">dict</span></code></p>
+<p>Implementation of perl’s autovivification feature, by overriding the
+get item and the __iadd__ operator (<a class="reference external" href="https://docs.python.org/3/reference/datamodel.html?highlight=iadd#object.__iadd__">https://docs.python.org/3/reference/datamodel.html?highlight=iadd#object.__iadd__</a>)</p>
+<p>This allows to set values within a subdict that might not exist yet:</p>
+<p class="rubric">Example</p>
+<p>newdict = {}
+newdict[‘example’][‘mass’] += 10
+print(newdict)
+&gt;&gt;&gt; {‘example’: {‘mass’: 10}}</p>
+</dd></dl>
+
 <dl class="py class">
 <dt id="binarycpython.utils.functions.BinaryCEncoder">
 <em class="property">class </em><code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">BinaryCEncoder</code><span class="sig-paren">(</span><em class="sig-param"><span class="o">*</span></em>, <em class="sig-param"><span class="n">skipkeys</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="n">ensure_ascii</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">check_circular</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">allow_nan</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">sort_keys</span><span class="o">=</span><span class="default_value">False</span></em>, <em class="sig-param"><span class="n">indent</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">separators</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">default</span><span class="o">=</span><span class="default_value">None</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#BinaryCEncoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.BinaryCEncoder" title="Permalink to this definition">¶</a></dt>
@@ -241,6 +255,13 @@ useful functions for the user</p>
 
 </dd></dl>
 
+<dl class="py function">
+<dt id="binarycpython.utils.functions.bin_data">
+<code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">bin_data</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">value</span></em>, <em class="sig-param"><span class="n">binwidth</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#bin_data"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.bin_data" title="Permalink to this definition">¶</a></dt>
+<dd><p>Function that bins the data</p>
+<p>Uses the absolute value of binwidth</p>
+</dd></dl>
+
 <dl class="py class">
 <dt id="binarycpython.utils.functions.binarycDecoder">
 <em class="property">class </em><code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">binarycDecoder</code><span class="sig-paren">(</span><em class="sig-param"><span class="o">*</span></em>, <em class="sig-param"><span class="n">object_hook</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">parse_float</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">parse_int</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">parse_constant</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">strict</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">object_pairs_hook</span><span class="o">=</span><span class="default_value">None</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#binarycDecoder"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.binarycDecoder" title="Permalink to this definition">¶</a></dt>
@@ -318,6 +339,12 @@ that we want to export.</p>
 <dd><p>Function to return the size + a magnitude string</p>
 </dd></dl>
 
+<dl class="py function">
+<dt id="binarycpython.utils.functions.convfloat">
+<code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">convfloat</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">x</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#convfloat"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.convfloat" title="Permalink to this definition">¶</a></dt>
+<dd><p>Convert scalar x to a float if we can, in which case return the float, otherwise just return x without changing it. Usually, x is a string, but could be anything that float() can handle without failure.</p>
+</dd></dl>
+
 <dl class="py function">
 <dt id="binarycpython.utils.functions.count_keys_recursive">
 <code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">count_keys_recursive</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">input_dict</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#count_keys_recursive"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.count_keys_recursive" title="Permalink to this definition">¶</a></dt>
@@ -382,6 +409,15 @@ This is done until all the keys are sorted.</p>
 <p>All objects other than dictionary types are directly return as they are</p>
 </dd></dl>
 
+<dl class="py function">
+<dt id="binarycpython.utils.functions.datalinedict">
+<code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">datalinedict</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">line</span></em>, <em class="sig-param"><span class="n">parameters</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#datalinedict"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.datalinedict" title="Permalink to this definition">¶</a></dt>
+<dd><p>Convert a line of data to a more convenient dictionary.
+:param line = a line of data as a string:
+:param parameters = a list of the parameter names:</p>
+<p>Note: if the parameter is a floating point number, it will be converted to Python’s float type.</p>
+</dd></dl>
+
 <dl class="py function">
 <dt id="binarycpython.utils.functions.example_parse_output">
 <code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">example_parse_output</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">output</span></em>, <em class="sig-param"><span class="n">selected_header</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#example_parse_output"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.example_parse_output" title="Permalink to this definition">¶</a></dt>
@@ -736,6 +772,12 @@ it will return the type of what the value would be in the input_dict</p>
 </dl>
 </dd></dl>
 
+<dl class="py function">
+<dt id="binarycpython.utils.functions.pad_output_distribution">
+<code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">pad_output_distribution</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">dist</span></em>, <em class="sig-param"><span class="n">binwidth</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#pad_output_distribution"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.pad_output_distribution" title="Permalink to this definition">¶</a></dt>
+<dd><p>Given a distribution, dist (a dictionary), which should be binned every binwidth (float), fill the distribution with zeros when there is no data. Note: this changes the data in place.</p>
+</dd></dl>
+
 <dl class="py function">
 <dt id="binarycpython.utils.functions.parse_binary_c_version_info">
 <code class="sig-prename descclassname">binarycpython.utils.functions.</code><code class="sig-name descname">parse_binary_c_version_info</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">version_info_string</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/functions.html#parse_binary_c_version_info"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.functions.parse_binary_c_version_info" title="Permalink to this definition">¶</a></dt>
@@ -985,9 +1027,9 @@ of all the binary_c parameters.</p>
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/genindex.html b/docs/build/html/genindex.html
index eae56de59cb0f778be5dce4a5c0c29481ef26acd..0c51efc2fc6eb6e5c1a18aac6ad144c79dbfe851 100644
--- a/docs/build/html/genindex.html
+++ b/docs/build/html/genindex.html
@@ -209,11 +209,13 @@
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="grid.html#binarycpython.utils.grid.Population.add_grid_variable">add_grid_variable() (binarycpython.utils.grid.Population method)</a>
 </li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="distribution_functions.html#binarycpython.utils.distribution_functions.Arenou2010_binary_fraction">Arenou2010_binary_fraction() (in module binarycpython.utils.distribution_functions)</a>
 </li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="custom_logging_functions.html#binarycpython.utils.custom_logging_functions.autogen_C_logging_code">autogen_C_logging_code() (in module binarycpython.utils.custom_logging_functions)</a>
+</li>
+      <li><a href="functions.html#binarycpython.utils.functions.AutoVivificationDict">AutoVivificationDict (class in binarycpython.utils.functions)</a>
 </li>
   </ul></td>
 </tr></table>
@@ -221,6 +223,8 @@
 <h2 id="B">B</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="functions.html#binarycpython.utils.functions.bin_data">bin_data() (in module binarycpython.utils.functions)</a>
+</li>
       <li><a href="custom_logging_functions.html#binarycpython.utils.custom_logging_functions.binary_c_log_code">binary_c_log_code() (in module binarycpython.utils.custom_logging_functions)</a>
 </li>
       <li><a href="custom_logging_functions.html#binarycpython.utils.custom_logging_functions.binary_c_write_log_code">binary_c_write_log_code() (in module binarycpython.utils.custom_logging_functions)</a>
@@ -259,6 +263,8 @@
         <li><a href="grid.html#module-binarycpython.utils.grid">module</a>
 </li>
       </ul></li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
       <li>
     binarycpython.utils.grid_options_defaults
 
@@ -266,8 +272,6 @@
         <li><a href="grid_options_defaults.html#module-binarycpython.utils.grid_options_defaults">module</a>
 </li>
       </ul></li>
-  </ul></td>
-  <td style="width: 33%; vertical-align: top;"><ul>
       <li>
     binarycpython.utils.hpc_functions
 
@@ -335,6 +339,8 @@
       <li><a href="functions.html#binarycpython.utils.functions.Capturing">Capturing (class in binarycpython.utils.functions)</a>
 </li>
       <li><a href="functions.html#binarycpython.utils.functions.catchtime">catchtime (class in binarycpython.utils.functions)</a>
+</li>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.clean">clean() (binarycpython.utils.grid.Population method)</a>
 </li>
       <li><a href="plot_functions.html#binarycpython.utils.plot_functions.color_by_index">color_by_index() (in module binarycpython.utils.plot_functions)</a>
 </li>
@@ -349,6 +355,8 @@
 </li>
       </ul></li>
       <li><a href="functions.html#binarycpython.utils.functions.convert_bytes">convert_bytes() (in module binarycpython.utils.functions)</a>
+</li>
+      <li><a href="functions.html#binarycpython.utils.functions.convfloat">convfloat() (in module binarycpython.utils.functions)</a>
 </li>
       <li><a href="distribution_functions.html#binarycpython.utils.distribution_functions.cosmic_SFH_madau_dickinson2014">cosmic_SFH_madau_dickinson2014() (in module binarycpython.utils.distribution_functions)</a>
 </li>
@@ -368,12 +376,14 @@
 <h2 id="D">D</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
-      <li><a href="functions.html#binarycpython.utils.functions.binarycDecoder.decode">decode() (binarycpython.utils.functions.binarycDecoder method)</a>
+      <li><a href="functions.html#binarycpython.utils.functions.datalinedict">datalinedict() (in module binarycpython.utils.functions)</a>
 </li>
-      <li><a href="functions.html#binarycpython.utils.functions.BinaryCEncoder.default">default() (binarycpython.utils.functions.BinaryCEncoder method)</a>
+      <li><a href="functions.html#binarycpython.utils.functions.binarycDecoder.decode">decode() (binarycpython.utils.functions.binarycDecoder method)</a>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="functions.html#binarycpython.utils.functions.BinaryCEncoder.default">default() (binarycpython.utils.functions.BinaryCEncoder method)</a>
+</li>
       <li><a href="plot_functions.html#binarycpython.utils.plot_functions.dummy">dummy() (in module binarycpython.utils.plot_functions)</a>
 </li>
       <li><a href="distribution_functions.html#binarycpython.utils.distribution_functions.duquennoy1991">duquennoy1991() (in module binarycpython.utils.distribution_functions)</a>
@@ -591,6 +601,8 @@
 <h2 id="P">P</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="functions.html#binarycpython.utils.functions.pad_output_distribution">pad_output_distribution() (in module binarycpython.utils.functions)</a>
+</li>
       <li><a href="functions.html#binarycpython.utils.functions.parse_binary_c_version_info">parse_binary_c_version_info() (in module binarycpython.utils.functions)</a>
 </li>
       <li><a href="grid.html#binarycpython.utils.grid.Population.parse_cmdline">parse_cmdline() (binarycpython.utils.grid.Population method)</a>
@@ -604,11 +616,11 @@
       <li><a href="plot_functions.html#binarycpython.utils.plot_functions.plot_HR_diagram">plot_HR_diagram() (in module binarycpython.utils.plot_functions)</a>
 </li>
       <li><a href="plot_functions.html#binarycpython.utils.plot_functions.plot_masses">plot_masses() (in module binarycpython.utils.plot_functions)</a>
-</li>
-      <li><a href="plot_functions.html#binarycpython.utils.plot_functions.plot_orbit">plot_orbit() (in module binarycpython.utils.plot_functions)</a>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="plot_functions.html#binarycpython.utils.plot_functions.plot_orbit">plot_orbit() (in module binarycpython.utils.plot_functions)</a>
+</li>
       <li><a href="plot_functions.html#binarycpython.utils.plot_functions.plot_system">plot_system() (in module binarycpython.utils.plot_functions)</a>
 </li>
       <li><a href="distribution_functions.html#binarycpython.utils.distribution_functions.poisson">poisson() (in module binarycpython.utils.distribution_functions)</a>
@@ -641,12 +653,14 @@
 </li>
       <li><a href="functions.html#binarycpython.utils.functions.remove_file">remove_file() (in module binarycpython.utils.functions)</a>
 </li>
-      <li><a href="grid.html#binarycpython.utils.grid.Population.return_all_info">return_all_info() (binarycpython.utils.grid.Population method)</a>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.rename_grid_variable">rename_grid_variable() (binarycpython.utils.grid.Population method)</a>
 </li>
-      <li><a href="grid.html#binarycpython.utils.grid.Population.return_binary_c_defaults">return_binary_c_defaults() (binarycpython.utils.grid.Population method)</a>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.return_all_info">return_all_info() (binarycpython.utils.grid.Population method)</a>
 </li>
   </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.return_binary_c_defaults">return_binary_c_defaults() (binarycpython.utils.grid.Population method)</a>
+</li>
       <li><a href="grid.html#binarycpython.utils.grid.Population.return_binary_c_version_info">return_binary_c_version_info() (binarycpython.utils.grid.Population method)</a>
 
       <ul>
@@ -700,12 +714,20 @@
 <table style="width: 100%" class="indextable genindextable"><tr>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="functions.html#binarycpython.utils.functions.update_dicts">update_dicts() (in module binarycpython.utils.functions)</a>
+</li>
+  </ul></td>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.update_grid_variable">update_grid_variable() (binarycpython.utils.grid.Population method)</a>
 </li>
   </ul></td>
 </tr></table>
 
 <h2 id="V">V</h2>
 <table style="width: 100%" class="indextable genindextable"><tr>
+  <td style="width: 33%; vertical-align: top;"><ul>
+      <li><a href="grid.html#binarycpython.utils.grid.Population.vb1print">vb1print() (binarycpython.utils.grid.Population method)</a>
+</li>
+  </ul></td>
   <td style="width: 33%; vertical-align: top;"><ul>
       <li><a href="functions.html#binarycpython.utils.functions.verbose_print">verbose_print() (in module binarycpython.utils.functions)</a>
 </li>
@@ -760,9 +782,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/grid.html b/docs/build/html/grid.html
index 35540c71ac6ac40f27c557475141e40960def4bb..f94395fa76ca654e0dd5fb5b3d7a929f672d58b4 100644
--- a/docs/build/html/grid.html
+++ b/docs/build/html/grid.html
@@ -202,8 +202,6 @@
 <span id="grid-class-module"></span><h1>grid_class module<a class="headerlink" href="#module-binarycpython.utils.grid" title="Permalink to this headline">¶</a></h1>
 <p>Module containing the Population grid class object.</p>
 <p>Here all the functionality of a Population object is defined.</p>
-<p>Useful for the user to understand the functionality,
-but copying functionality isn’t recommended except if you know what you are doing</p>
 <dl class="simple">
 <dt>Tasks:</dt><dd><ul class="simple">
 <li><p>TODO: add functionality to ‘on-init’ set arguments</p></li>
@@ -220,7 +218,6 @@ but copying functionality isn’t recommended except if you know what you are do
 <li><p>TODO: uncomment and implement the HPC functionality</p></li>
 <li><p>TODO: think of a clean and nice way to unload and remove the custom_logging_info library from memory (and from disk)</p></li>
 <li><p>TODO: think of a nice way to remove the loaded grid_code/ generator from memory.</p></li>
-<li><p>TODO: Create a designated dict for results</p></li>
 </ul>
 </dd>
 </dl>
@@ -312,12 +309,25 @@ the lower edge of the value range) or ‘centred’
 </dl>
 </dd></dl>
 
+<dl class="py method">
+<dt id="binarycpython.utils.grid.Population.clean">
+<code class="sig-name descname">clean</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.clean"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.clean" title="Permalink to this definition">¶</a></dt>
+<dd><p>Clean the contents of the population object so it can be reused.</p>
+<p>Calling _pre_run_cleanup()</p>
+<p>TODO: decide to deprecate this function</p>
+<dl class="field-list simple">
+<dt class="field-odd">Return type</dt>
+<dd class="field-odd"><p><code class="xref py py-obj docutils literal notranslate"><span class="pre">None</span></code></p>
+</dd>
+</dl>
+</dd></dl>
+
 <dl class="py method">
 <dt id="binarycpython.utils.grid.Population.evolve">
 <code class="sig-name descname">evolve</code><span class="sig-paren">(</span><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.evolve"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.evolve" title="Permalink to this definition">¶</a></dt>
 <dd><p>Entry point function of the whole object. From here, based on the settings,
 we set up a SLURM or CONDOR grid, or if no setting is given we go straight
-to evolving the population</p>
+to evolving the population.</p>
 <dl class="simple">
 <dt>There are no direct arguments to this function, rather it is based on the grid_options settings:</dt><dd><p>grid_options[‘slurm’]: integer Boolean whether to use a slurm_grid evolution
 grid_options[‘condor’]: integer Boolean whether to use a condor_grid evolution</p>
@@ -325,8 +335,9 @@ grid_options[‘condor’]: integer Boolean whether to use a condor_grid evoluti
 </dl>
 <p>If neither of the above is set, we continue without using HPC routines
 (that doesn’t mean this cannot be run on a server with many cores)</p>
-<p>Returns an dictionary containing the analytics of the run
-TODO: change the way this is done. Slurm &amp; CONDOR should probably do this different</p>
+<p>Returns an dictionary containing the analytics of the run</p>
+<p>TODO: change the way this is done. Slurm &amp; CONDOR should probably do this different
+NOTE: SLURM and CONDOR options are not working properly yet</p>
 <dl class="field-list simple">
 <dt class="field-odd">Return type</dt>
 <dd class="field-odd"><p><code class="xref py py-obj docutils literal notranslate"><span class="pre">None</span></code></p>
@@ -422,6 +433,27 @@ can change to ints.</p>
 </dl>
 </dd></dl>
 
+<dl class="py method">
+<dt id="binarycpython.utils.grid.Population.rename_grid_variable">
+<code class="sig-name descname">rename_grid_variable</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">oldname</span></em>, <em class="sig-param"><span class="n">newname</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.rename_grid_variable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.rename_grid_variable" title="Permalink to this definition">¶</a></dt>
+<dd><p>Function to rename a grid variable.</p>
+<p>note: this does NOT alter the order
+of the self.grid_options[“_grid_variables”] dictionary.</p>
+<p>The order in which the grid variables are loaded into the grid is based on their
+<cite>grid_variable_number</cite> property</p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters</dt>
+<dd class="field-odd"><ul class="simple">
+<li><p><strong>oldname</strong> (<code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code>) – old name of the grid variable</p></li>
+<li><p><strong>newname</strong> (<code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code>) – new name of the grid variable</p></li>
+</ul>
+</dd>
+<dt class="field-even">Return type</dt>
+<dd class="field-even"><p><code class="xref py py-obj docutils literal notranslate"><span class="pre">None</span></code></p>
+</dd>
+</dl>
+</dd></dl>
+
 <dl class="py method">
 <dt id="binarycpython.utils.grid.Population.return_all_info">
 <code class="sig-name descname">return_all_info</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">include_population_settings</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">include_binary_c_defaults</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">include_binary_c_version_info</span><span class="o">=</span><span class="default_value">True</span></em>, <em class="sig-param"><span class="n">include_binary_c_help_all</span><span class="o">=</span><span class="default_value">True</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.return_all_info"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.return_all_info" title="Permalink to this definition">¶</a></dt>
@@ -504,6 +536,32 @@ in the self.grid_options</p>
 <p>If nothing is passed then we just use the default options</p>
 </dd></dl>
 
+<dl class="py method">
+<dt id="binarycpython.utils.grid.Population.update_grid_variable">
+<code class="sig-name descname">update_grid_variable</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">name</span></em>, <em class="sig-param"><span class="o">**</span><span class="n">kwargs</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.update_grid_variable"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.update_grid_variable" title="Permalink to this definition">¶</a></dt>
+<dd><p>Function to update the values of a grid variable.</p>
+<dl class="field-list simple">
+<dt class="field-odd">Parameters</dt>
+<dd class="field-odd"><ul class="simple">
+<li><p><strong>name</strong> (<code class="xref py py-class docutils literal notranslate"><span class="pre">str</span></code>) – name of the grid variable to be changed.</p></li>
+<li><p><strong>**kwargs</strong> – key-value pairs to override the existing grid variable data. See add_grid_variable for these names.</p></li>
+</ul>
+</dd>
+<dt class="field-even">Return type</dt>
+<dd class="field-even"><p><code class="xref py py-obj docutils literal notranslate"><span class="pre">None</span></code></p>
+</dd>
+</dl>
+</dd></dl>
+
+<dl class="py method">
+<dt id="binarycpython.utils.grid.Population.vb1print">
+<code class="sig-name descname">vb1print</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">ID</span></em>, <em class="sig-param"><span class="n">now</span></em>, <em class="sig-param"><span class="n">system_number</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.vb1print"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.vb1print" title="Permalink to this definition">¶</a></dt>
+<dd><p>Verbosity-level 1 printing, to keep an eye on a grid.
+:param ID: thread ID for debugging (int)
+:param now: the time now as a UNIX-style epoch in seconds (float)
+:param system_number: the system number</p>
+</dd></dl>
+
 <dl class="py method">
 <dt id="binarycpython.utils.grid.Population.write_binary_c_calls_to_file">
 <code class="sig-name descname">write_binary_c_calls_to_file</code><span class="sig-paren">(</span><em class="sig-param"><span class="n">output_dir</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">output_filename</span><span class="o">=</span><span class="default_value">None</span></em>, <em class="sig-param"><span class="n">include_defaults</span><span class="o">=</span><span class="default_value">False</span></em><span class="sig-paren">)</span><a class="reference internal" href="_modules/binarycpython/utils/grid.html#Population.write_binary_c_calls_to_file"><span class="viewcode-link">[source]</span></a><a class="headerlink" href="#binarycpython.utils.grid.Population.write_binary_c_calls_to_file" title="Permalink to this definition">¶</a></dt>
@@ -575,9 +633,9 @@ like m1,m2,sep, orb-per, ecc, probability etc.</p>
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/grid_options_defaults.html b/docs/build/html/grid_options_defaults.html
index 151d7f68328cee9ce102edc9cefdd02b8f579452..8bb1e5cb9fdc61bc1ec582d5d5b3778d5656962e 100644
--- a/docs/build/html/grid_options_defaults.html
+++ b/docs/build/html/grid_options_defaults.html
@@ -308,9 +308,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/grid_options_descriptions.html b/docs/build/html/grid_options_descriptions.html
index 65faf9f0740dd366409a5a672072b306f8e0913f..17724a27ef3dadaaaebdbf0bcda15487fc27fb48 100644
--- a/docs/build/html/grid_options_descriptions.html
+++ b/docs/build/html/grid_options_descriptions.html
@@ -190,7 +190,7 @@
 <div class="section" id="population-grid-code-options">
 <h1>Population grid code options<a class="headerlink" href="#population-grid-code-options" title="Permalink to this headline">¶</a></h1>
 <p>The following chapter contains all grid code options, along with their descriptions
-There are 1 options that are not described yet.</p>
+There are 2 options that are not described yet.</p>
 <div class="section" id="public-options">
 <h2>Public options<a class="headerlink" href="#public-options" title="Permalink to this headline">¶</a></h2>
 <p>The following options are meant to be changed by the user.</p>
@@ -234,6 +234,9 @@ There are 1 options that are not described yet.</p>
 <div class="line"><strong>log_args_dir</strong>: Directory to log the arguments to. Unused</div>
 </div>
 <div class="line-block">
+<div class="line"><strong>log_dt</strong>: No description available yet</div>
+</div>
+<div class="line-block">
 <div class="line"><strong>log_file</strong>: Log file for the population object. Unused</div>
 </div>
 <div class="line-block">
@@ -252,7 +255,7 @@ There are 1 options that are not described yet.</p>
 <div class="line"><strong>multiplicity_fraction_function</strong>: Which multiplicity fraction function to use. 0: None, 1: Arenou 2010, 2: Rhagavan 2010, 3: M&amp;S 2017</div>
 </div>
 <div class="line-block">
-<div class="line"><strong>parse_function</strong>: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the grid_options[‘results’] dictionary, or just output results to a file</div>
+<div class="line"><strong>parse_function</strong>: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the self.grid_results dictionary, or just output results to a file</div>
 </div>
 <div class="line-block">
 <div class="line"><strong>repeat</strong>: Factor of how many times a system should be repeated. Consider the evolution splitting binary_c argument for supernovae kick repeating.</div>
@@ -479,9 +482,9 @@ q extrapolation (below 0.15) method
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/hpc_functions.html b/docs/build/html/hpc_functions.html
index eaeff7cea57990585a6573779a0158f00404795a..902834f2638f1c3231a72df5c19940c586f70f0b 100644
--- a/docs/build/html/hpc_functions.html
+++ b/docs/build/html/hpc_functions.html
@@ -239,9 +239,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/index.html b/docs/build/html/index.html
index 66993241b0901cf713f4522449f50cb21f9fe77f..f57caabf75c777fb1c1e600f33df7fe9b7987d3c 100644
--- a/docs/build/html/index.html
+++ b/docs/build/html/index.html
@@ -238,12 +238,13 @@
 <p>For this it is best to set up a virtual environment. Activate the virtualenvironment and enter the cloned version of the repo.</p>
 <p>Then run:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
+<span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">uninstall</span> <span class="n">binarycpython</span> <span class="o">&amp;&amp;</span> <span class="n">rm</span> <span class="n">dist</span><span class="o">/*</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
 </pre></div>
 </div>
-<p>You can find the version of this package in setup.py.</p>
+<p>This will clean the build directory, remove binarycpython from the venv, remove the dist packages, and then rebuilding and reinstalling the package. You can find the version of this package in setup.py.</p>
 <p>This will install this package into the virtual environment. Making changes to the sourcecode can be “installed” into the virtual env with the same command.</p>
 <p>If this is not the first time you install the package, but rather rebuild it because you make changes in either binary_c or binarycpython, you should ignore the currently installed version, and also skip installing the dependencies again, by executing the following command:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">--</span><span class="n">ignore</span><span class="o">-</span><span class="n">installed</span> <span class="o">--</span><span class="n">no</span><span class="o">-</span><span class="n">dependencies</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">uninstall</span> <span class="n">binarycpython</span> <span class="o">&amp;&amp;</span> <span class="n">rm</span> <span class="n">dist</span><span class="o">/*</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">--</span><span class="n">ignore</span><span class="o">-</span><span class="n">installed</span> <span class="o">--</span><span class="n">no</span><span class="o">-</span><span class="n">dependencies</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
 </pre></div>
 </div>
 <div class="section" id="after-installation">
@@ -311,11 +312,15 @@
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul>
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a><ul>
@@ -382,9 +387,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/modules.html b/docs/build/html/modules.html
index 076e1dc8c845801842c00d953e25addd12f23df7..8c5dccc912934e1f6594b134448aae875b7f6cbc 100644
--- a/docs/build/html/modules.html
+++ b/docs/build/html/modules.html
@@ -250,9 +250,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_HRD.html b/docs/build/html/notebook_HRD.html
new file mode 100644
index 0000000000000000000000000000000000000000..e0d4a842f252ca092e7f18ac0928089bacc6a709
--- /dev/null
+++ b/docs/build/html/notebook_HRD.html
@@ -0,0 +1,1176 @@
+
+
+<!DOCTYPE html>
+<html class="writer-html5" lang="en" >
+<head>
+  <meta charset="utf-8">
+  
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  
+  <title>Example use case: Hertzsprung-Russell diagrams &mdash; binary_c-python  documentation</title>
+  
+
+  
+  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
+  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+  
+  
+  
+  
+
+  
+  <!--[if lt IE 9]>
+    <script src="_static/js/html5shiv.min.js"></script>
+  <![endif]-->
+  
+    
+      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+        <script src="_static/jquery.js"></script>
+        <script src="_static/underscore.js"></script>
+        <script src="_static/doctools.js"></script>
+        <script src="_static/language_data.js"></script>
+        <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
+        <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
+        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
+    
+    <script type="text/javascript" src="_static/js/theme.js"></script>
+
+    
+    <link rel="index" title="Index" href="genindex.html" />
+    <link rel="search" title="Search" href="search.html" />
+    <link rel="next" title="Example use case: Common-envelope evolution" href="notebook_common_envelope_evolution.html" />
+    <link rel="prev" title="Zero-age stellar luminosity function in binaries" href="notebook_luminosity_function_binaries.html" /> 
+</head>
+
+<body class="wy-body-for-nav">
+
+   
+  <div class="wy-grid-for-nav">
+    
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
+          
+
+          
+            <a href="index.html" class="icon icon-home" alt="Documentation Home"> binary_c-python
+          
+
+          
+          </a>
+
+          
+            
+            
+          
+
+          
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+
+          
+        </div>
+
+        
+        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
+          
+            
+            
+              
+            
+            
+              <p class="caption"><span class="caption-text">Contents:</span></p>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
+<li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
+<li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Example use case: Hertzsprung-Russell diagrams</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Stellar-Grid">Stellar Grid</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Evolving-the-grid">Evolving the grid</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Binary-stars">Binary stars</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
+<li class="toctree-l1"><a class="reference internal" href="grid_options_descriptions.html">Population grid code options</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python">Visit the GitLab repo</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/issues/new">Submit an issue</a></li>
+</ul>
+
+            
+          
+        </div>
+        
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
+
+      
+      <nav class="wy-nav-top" aria-label="top navigation">
+        
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="index.html">binary_c-python</a>
+        
+      </nav>
+
+
+      <div class="wy-nav-content">
+        
+        <div class="rst-content">
+        
+          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<div role="navigation" aria-label="breadcrumbs navigation">
+
+  <ul class="wy-breadcrumbs">
+    
+      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
+        
+          <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
+        
+      <li>Example use case: Hertzsprung-Russell diagrams</li>
+    
+    
+      <li class="wy-breadcrumbs-aside">
+        
+            
+            <a href="_sources/notebook_HRD.ipynb.txt" rel="nofollow"> View page source</a>
+          
+        
+      </li>
+    
+  </ul>
+
+  
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+            
+  
+<style>
+/* CSS for nbsphinx extension */
+
+/* remove conflicting styling from Sphinx themes */
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt *,
+div.nbinput.container div.input_area pre,
+div.nboutput.container div.output_area pre,
+div.nbinput.container div.input_area .highlight,
+div.nboutput.container div.output_area .highlight {
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}
+
+div.nbinput.container > div[class*=highlight],
+div.nboutput.container > div[class*=highlight] {
+    margin: 0;
+}
+
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt * {
+    background: none;
+}
+
+div.nboutput.container div.output_area .highlight,
+div.nboutput.container div.output_area pre {
+    background: unset;
+}
+
+div.nboutput.container div.output_area div.highlight {
+    color: unset;  /* override Pygments text color */
+}
+
+/* avoid gaps between output lines */
+div.nboutput.container div[class*=highlight] pre {
+    line-height: normal;
+}
+
+/* input/output containers */
+div.nbinput.container,
+div.nboutput.container {
+    display: -webkit-flex;
+    display: flex;
+    align-items: flex-start;
+    margin: 0;
+    width: 100%;
+}
+@media (max-width: 540px) {
+    div.nbinput.container,
+    div.nboutput.container {
+        flex-direction: column;
+    }
+}
+
+/* input container */
+div.nbinput.container {
+    padding-top: 5px;
+}
+
+/* last container */
+div.nblast.container {
+    padding-bottom: 5px;
+}
+
+/* input prompt */
+div.nbinput.container div.prompt pre {
+    color: #307FC1;
+}
+
+/* output prompt */
+div.nboutput.container div.prompt pre {
+    color: #BF5B3D;
+}
+
+/* all prompts */
+div.nbinput.container div.prompt,
+div.nboutput.container div.prompt {
+    width: 4.5ex;
+    padding-top: 5px;
+    position: relative;
+    user-select: none;
+}
+
+div.nbinput.container div.prompt > div,
+div.nboutput.container div.prompt > div {
+    position: absolute;
+    right: 0;
+    margin-right: 0.3ex;
+}
+
+@media (max-width: 540px) {
+    div.nbinput.container div.prompt,
+    div.nboutput.container div.prompt {
+        width: unset;
+        text-align: left;
+        padding: 0.4em;
+    }
+    div.nboutput.container div.prompt.empty {
+        padding: 0;
+    }
+
+    div.nbinput.container div.prompt > div,
+    div.nboutput.container div.prompt > div {
+        position: unset;
+    }
+}
+
+/* disable scrollbars on prompts */
+div.nbinput.container div.prompt pre,
+div.nboutput.container div.prompt pre {
+    overflow: hidden;
+}
+
+/* input/output area */
+div.nbinput.container div.input_area,
+div.nboutput.container div.output_area {
+    -webkit-flex: 1;
+    flex: 1;
+    overflow: auto;
+}
+@media (max-width: 540px) {
+    div.nbinput.container div.input_area,
+    div.nboutput.container div.output_area {
+        width: 100%;
+    }
+}
+
+/* input area */
+div.nbinput.container div.input_area {
+    border: 1px solid #e0e0e0;
+    border-radius: 2px;
+    /*background: #f5f5f5;*/
+}
+
+/* override MathJax center alignment in output cells */
+div.nboutput.container div[class*=MathJax] {
+    text-align: left !important;
+}
+
+/* override sphinx.ext.imgmath center alignment in output cells */
+div.nboutput.container div.math p {
+    text-align: left;
+}
+
+/* standard error */
+div.nboutput.container div.output_area.stderr {
+    background: #fdd;
+}
+
+/* ANSI colors */
+.ansi-black-fg { color: #3E424D; }
+.ansi-black-bg { background-color: #3E424D; }
+.ansi-black-intense-fg { color: #282C36; }
+.ansi-black-intense-bg { background-color: #282C36; }
+.ansi-red-fg { color: #E75C58; }
+.ansi-red-bg { background-color: #E75C58; }
+.ansi-red-intense-fg { color: #B22B31; }
+.ansi-red-intense-bg { background-color: #B22B31; }
+.ansi-green-fg { color: #00A250; }
+.ansi-green-bg { background-color: #00A250; }
+.ansi-green-intense-fg { color: #007427; }
+.ansi-green-intense-bg { background-color: #007427; }
+.ansi-yellow-fg { color: #DDB62B; }
+.ansi-yellow-bg { background-color: #DDB62B; }
+.ansi-yellow-intense-fg { color: #B27D12; }
+.ansi-yellow-intense-bg { background-color: #B27D12; }
+.ansi-blue-fg { color: #208FFB; }
+.ansi-blue-bg { background-color: #208FFB; }
+.ansi-blue-intense-fg { color: #0065CA; }
+.ansi-blue-intense-bg { background-color: #0065CA; }
+.ansi-magenta-fg { color: #D160C4; }
+.ansi-magenta-bg { background-color: #D160C4; }
+.ansi-magenta-intense-fg { color: #A03196; }
+.ansi-magenta-intense-bg { background-color: #A03196; }
+.ansi-cyan-fg { color: #60C6C8; }
+.ansi-cyan-bg { background-color: #60C6C8; }
+.ansi-cyan-intense-fg { color: #258F8F; }
+.ansi-cyan-intense-bg { background-color: #258F8F; }
+.ansi-white-fg { color: #C5C1B4; }
+.ansi-white-bg { background-color: #C5C1B4; }
+.ansi-white-intense-fg { color: #A1A6B2; }
+.ansi-white-intense-bg { background-color: #A1A6B2; }
+
+.ansi-default-inverse-fg { color: #FFFFFF; }
+.ansi-default-inverse-bg { background-color: #000000; }
+
+.ansi-bold { font-weight: bold; }
+.ansi-underline { text-decoration: underline; }
+
+
+div.nbinput.container div.input_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight].math,
+div.nboutput.container div.output_area.rendered_html,
+div.nboutput.container div.output_area > div.output_javascript,
+div.nboutput.container div.output_area:not(.rendered_html) > img{
+    padding: 5px;
+    margin: 0;
+}
+
+/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
+div.nbinput.container div.input_area > div[class^='highlight'],
+div.nboutput.container div.output_area > div[class^='highlight']{
+    overflow-y: hidden;
+}
+
+/* hide copybtn icon on prompts (needed for 'sphinx_copybutton') */
+.prompt a.copybtn {
+    display: none;
+}
+
+/* Some additional styling taken form the Jupyter notebook CSS */
+div.rendered_html table {
+  border: none;
+  border-collapse: collapse;
+  border-spacing: 0;
+  color: black;
+  font-size: 12px;
+  table-layout: fixed;
+}
+div.rendered_html thead {
+  border-bottom: 1px solid black;
+  vertical-align: bottom;
+}
+div.rendered_html tr,
+div.rendered_html th,
+div.rendered_html td {
+  text-align: right;
+  vertical-align: middle;
+  padding: 0.5em 0.5em;
+  line-height: normal;
+  white-space: normal;
+  max-width: none;
+  border: none;
+}
+div.rendered_html th {
+  font-weight: bold;
+}
+div.rendered_html tbody tr:nth-child(odd) {
+  background: #f5f5f5;
+}
+div.rendered_html tbody tr:hover {
+  background: rgba(66, 165, 245, 0.2);
+}
+
+/* CSS overrides for sphinx_rtd_theme */
+
+/* 24px margin */
+.nbinput.nblast.container,
+.nboutput.nblast.container {
+    margin-bottom: 19px;  /* padding has already 5px */
+}
+
+/* ... except between code cells! */
+.nblast.container + .nbinput.container {
+    margin-top: -19px;
+}
+
+.admonition > p:before {
+    margin-right: 4px;  /* make room for the exclamation icon */
+}
+
+/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
+.math {
+    text-align: unset;
+}
+</style>
+<div class="section" id="Example-use-case:-Hertzsprung-Russell-diagrams">
+<h1>Example use case: Hertzsprung-Russell diagrams<a class="headerlink" href="#Example-use-case:-Hertzsprung-Russell-diagrams" title="Permalink to this headline">¶</a></h1>
+<p>In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">os</span>
+<span class="kn">import</span> <span class="nn">math</span>
+<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
+
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
+
+<span class="n">TMP_DIR</span> <span class="o">=</span> <span class="n">temp_dir</span><span class="p">(</span><span class="s2">&quot;notebooks&quot;</span><span class="p">,</span> <span class="s2">&quot;notebook_HRD&quot;</span><span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<div class="section" id="Setting-up-the-Population-object">
+<h2>Setting up the Population object<a class="headerlink" href="#Setting-up-the-Population-object" title="Permalink to this headline">¶</a></h2>
+<p>First we set up a new population object. Our stars evolve to <span class="math notranslate nohighlight">\(13.7\mathrm{Gyr}\)</span>, the age of the Universe, and we assume the metallicity <span class="math notranslate nohighlight">\(Z=0.02\)</span>. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to <span class="math notranslate nohighlight">\(13.7\mathrm{Gyr}\)</span>, and stars are not really born with a metallicity of <span class="math notranslate nohighlight">\(0.02\)</span>. These approximations only affect very low mass stars, so we assume all our stars have mass <span class="math notranslate nohighlight">\(M\geq 1 \mathrm{M}_\odot\)</span>, and metallicity
+does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to <span class="math notranslate nohighlight">\(M\leq 10 \mathrm{M}_\odot\)</span>.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create population object</span>
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+
+<span class="c1"># Setting values can be done via .set(&lt;parameter_name&gt;=&lt;value&gt;)</span>
+<span class="c1"># Values that are known to be binary_c_parameters are loaded into bse_options.</span>
+<span class="c1"># Those that are present in the default grid_options are set in grid_options</span>
+<span class="c1"># All other values that you set are put in a custom_options dict</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># binary_c physics options</span>
+    <span class="n">max_evolution_time</span><span class="o">=</span><span class="mi">13700</span><span class="p">,</span>  <span class="c1"># maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)</span>
+    <span class="n">metallicity</span><span class="o">=</span><span class="mf">0.02</span><span class="p">,</span> <span class="c1"># 0.02 is approximately Solar metallicity</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
+    <span class="n">verbosity</span><span class="o">=</span><span class="mi">1</span>
+<span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="Stellar-Grid">
+<h2>Stellar Grid<a class="headerlink" href="#Stellar-Grid" title="Permalink to this headline">¶</a></h2>
+<p>We now construct a grid of stars, varying the mass from <span class="math notranslate nohighlight">\(1\)</span> to <span class="math notranslate nohighlight">\(10\mathrm{M}_\odot\)</span> in nine steps (so the masses are integers).</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">binarycpython.utils.distribution_functions</span>
+<span class="c1"># Set resolution and mass range that we simulate</span>
+<span class="n">resolution</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;M_1&quot;</span><span class="p">:</span> <span class="mi">10</span><span class="p">}</span>
+<span class="n">massrange</span> <span class="o">=</span> <span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="mi">11</span><span class="p">)</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Primary mass&quot;</span><span class="p">,</span> <span class="c1"># == single-star mass</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="n">massrange</span><span class="p">,</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{res}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">res</span> <span class="o">=</span> <span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(1,2,1)&quot;</span><span class="p">,</span> <span class="c1"># space by unit masses</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;1&quot;</span><span class="p">,</span> <span class="c1"># dprob/dm1 : we don&#39;t care, so just set it to 1</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dM_1&quot;</span><span class="p">,</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+    <span class="n">gridtype</span><span class="o">=</span><span class="s2">&quot;edge&quot;</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Added grid variable: {
+    &#34;name&#34;: &#34;M_1&#34;,
+    &#34;longname&#34;: &#34;Primary mass&#34;,
+    &#34;valuerange&#34;: [
+        1,
+        11
+    ],
+    &#34;resolution&#34;: &#34;10&#34;,
+    &#34;spacingfunc&#34;: &#34;const(1,2,1)&#34;,
+    &#34;precode&#34;: null,
+    &#34;probdist&#34;: &#34;1&#34;,
+    &#34;dphasevol&#34;: &#34;dM_1&#34;,
+    &#34;parameter_name&#34;: &#34;M_1&#34;,
+    &#34;condition&#34;: &#34;&#34;,
+    &#34;gridtype&#34;: &#34;edge&#34;,
+    &#34;branchpoint&#34;: 0,
+    &#34;grid_variable_number&#34;: 0
+}
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Setting-logging-and-handling-the-output">
+<h2>Setting logging and handling the output<a class="headerlink" href="#Setting-logging-and-handling-the-output" title="Permalink to this headline">¶</a></h2>
+<p>We now construct the HRD output.</p>
+<p>We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have <span class="math notranslate nohighlight">\(&gt;0.1\mathrm{M}_\odot\)</span> of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">custom_logging_statement</span> <span class="o">=</span> <span class="s2">&quot;&quot;&quot;</span>
+<span class="s2">Foreach_star(star)</span>
+<span class="s2">{</span>
+<span class="s2">    if(star-&gt;stellar_type &lt;= TPAGB &amp;&amp;</span>
+<span class="s2">       star-&gt;mass - Outermost_core_mass(star) &gt; 0.1)</span>
+<span class="s2">    {</span>
+<span class="s2">         double logTeff = log10(Teff_from_star_struct(star));</span>
+<span class="s2">         double logL = log10(star-&gt;luminosity);</span>
+<span class="s2">         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star-&gt;mass/Pow2(star-&gt;radius*R_SUN));</span>
+<span class="s2">         Printf(&quot;HRD</span><span class="si">%d</span><span class="s2"> </span><span class="si">%30.12e</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;,</span>
+<span class="s2">                star-&gt;starnum, // 0</span>
+<span class="s2">                stardata-&gt;model.time, // 1</span>
+<span class="s2">                stardata-&gt;common.zero_age.mass[0], // 2 : note this is the primary mass</span>
+<span class="s2">                logTeff, // 3</span>
+<span class="s2">                logL, // 4</span>
+<span class="s2">                loggravity // 5</span>
+<span class="s2">                );</span>
+
+<span class="s2">    }</span>
+<span class="s2">}</span>
+<span class="s2">&quot;&quot;&quot;</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">C_logging_code</span><span class="o">=</span><span class="n">custom_logging_statement</span>
+<span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: C_logging_code=
+Foreach_star(star)
+{
+    if(star-&gt;stellar_type &lt;= TPAGB &amp;&amp;
+       star-&gt;mass - Outermost_core_mass(star) &gt; 0.1)
+    {
+         double logTeff = log10(Teff_from_star_struct(star));
+         double logL = log10(star-&gt;luminosity);
+         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star-&gt;mass/Pow2(star-&gt;radius*R_SUN));
+         Printf(&#34;HRD%d %30.12e %g %g %g %g\n&#34;,
+                star-&gt;starnum, // 0
+                stardata-&gt;model.time, // 1
+                stardata-&gt;common.zero_age.mass[0], // 2 : note this is the primary mass
+                logTeff, // 3
+                logL, // 4
+                loggravity // 5
+                );
+
+    }
+}
+ to grid_options
+</pre></div></div>
+</div>
+<p>The parse function must now catch lines that start with “HRD*n*”, where <em>n</em> is 0 (primary star) or 1 (secondary star, which doesn’t exist in single-star systems), and process the associated data.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">datalinedict</span>
+<span class="kn">import</span> <span class="nn">re</span>
+
+<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Parsing function to convert HRD data into something that Python can use</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="c1"># list of the data items</span>
+    <span class="n">parameters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;header&quot;</span><span class="p">,</span> <span class="s2">&quot;time&quot;</span><span class="p">,</span> <span class="s2">&quot;zams_mass&quot;</span><span class="p">,</span> <span class="s2">&quot;logTeff&quot;</span><span class="p">,</span> <span class="s2">&quot;logL&quot;</span><span class="p">,</span> <span class="s2">&quot;logg&quot;</span><span class="p">]</span>
+
+    <span class="c1"># Loop over the output.</span>
+    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">output</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
+
+        <span class="n">match</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">search</span><span class="p">(</span><span class="s1">&#39;HRD(\d)&#39;</span><span class="p">,</span><span class="n">line</span><span class="p">)</span>
+        <span class="k">if</span> <span class="n">match</span><span class="p">:</span>
+            <span class="n">nstar</span> <span class="o">=</span> <span class="n">match</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
+
+            <span class="c1"># obtain the line of data in dictionary form</span>
+            <span class="n">linedata</span> <span class="o">=</span> <span class="n">datalinedict</span><span class="p">(</span><span class="n">line</span><span class="p">,</span><span class="n">parameters</span><span class="p">)</span>
+
+            <span class="c1"># first time setup of the list of tuples</span>
+            <span class="k">if</span><span class="p">(</span><span class="nb">len</span><span class="p">(</span><span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">][</span><span class="n">nstar</span><span class="p">][</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;zams_mass&#39;</span><span class="p">]])</span><span class="o">==</span><span class="mi">0</span><span class="p">):</span>
+                <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">][</span><span class="n">nstar</span><span class="p">][</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;zams_mass&#39;</span><span class="p">]]</span> <span class="o">=</span> <span class="p">[]</span>
+
+            <span class="c1"># make the HRD be a list of tuples</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">][</span><span class="n">nstar</span><span class="p">][</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;zams_mass&#39;</span><span class="p">]]</span><span class="o">.</span><span class="n">append</span><span class="p">((</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;logTeff&#39;</span><span class="p">],</span>
+                                                                           <span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;logL&#39;</span><span class="p">]))</span>
+
+    <span class="c1"># verbose reporting</span>
+    <span class="c1">#print(&quot;parse out results_dictionary=&quot;,self.grid_results)</span>
+
+<span class="c1"># Add the parsing function</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">parse_function</span><span class="o">=</span><span class="n">parse_function</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: parse_function=&lt;function parse_function at 0x14565763dca0&gt; to grid_options
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Evolving-the-grid">
+<h2>Evolving the grid<a class="headerlink" href="#Evolving-the-grid" title="Permalink to this headline">¶</a></h2>
+<p>Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: <code class="docutils literal notranslate"><span class="pre">population.evolve()</span></code></p>
+<p>This will start up the processing of all the systems. We can control how many cores are used by settings <code class="docutils literal notranslate"><span class="pre">amt_cores</span></code>. By setting the <code class="docutils literal notranslate"><span class="pre">verbosity</span></code> of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.</p>
+<p>There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: <a class="reference external" href="https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html">grid options docs</a>, and try</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># set number of threads</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># verbose output is not required</span>
+    <span class="n">verbosity</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span>
+    <span class="c1"># set number of threads (i.e. number of CPU cores we use)</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
+    <span class="p">)</span>
+
+<span class="c1"># Evolve the population - this is the slow, number-crunching step</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1">#print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: verbosity=0 to grid_options
+Generating grid code
+Constructing/adding: M_1
+Grid has handled 10 stars
+with a total probability of 10.0
+Total starcount for this run will be: 10
+Generating grid code
+Constructing/adding: M_1
+Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<p>After the run is complete, some technical report on the run is returned. I stored that in <code class="docutils literal notranslate"><span class="pre">analytics</span></code>. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="nb">print</span><span class="p">(</span><span class="n">analytics</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+{&#39;population_name&#39;: &#39;20bee5b0c58d49c5bc47eced240685bb&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 10.0, &#39;total_count&#39;: 10, &#39;start_timestamp&#39;: 1631304519.45189, &#39;end_timestamp&#39;: 1631304519.9955394, &#39;total_mass_run&#39;: 55.0, &#39;total_probability_weighted_mass_run&#39;: 55.0, &#39;zero_prob_stars_skipped&#39;: 0}
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># make a plot of the luminosity distribution using Seaborn and Pandas</span>
+<span class="kn">import</span> <span class="nn">seaborn</span> <span class="k">as</span> <span class="nn">sns</span>
+<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
+<span class="n">pd</span><span class="o">.</span><span class="n">set_option</span><span class="p">(</span><span class="s2">&quot;display.max_rows&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="s2">&quot;display.max_columns&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">pad_output_distribution</span>
+
+<span class="c1"># set up seaborn for use in the notebook</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;figure.figsize&#39;</span><span class="p">:(</span><span class="mi">20</span><span class="p">,</span><span class="mi">10</span><span class="p">)})</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set_context</span><span class="p">(</span><span class="s2">&quot;notebook&quot;</span><span class="p">,</span>
+                <span class="n">font_scale</span><span class="o">=</span><span class="mf">1.5</span><span class="p">,</span>
+                <span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;lines.linewidth&quot;</span><span class="p">:</span><span class="mf">2.5</span><span class="p">})</span>
+
+<span class="n">hrd</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">]</span>
+<span class="n">pd</span><span class="o">.</span><span class="n">set_option</span><span class="p">(</span><span class="s2">&quot;display.max_rows&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="s2">&quot;display.max_columns&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+
+<span class="k">for</span> <span class="n">nstar</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">):</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;star &quot;</span><span class="p">,</span><span class="n">nstar</span><span class="p">)</span>
+    <span class="k">for</span> <span class="n">zams_mass</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">]):</span>
+        <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;zams mass &quot;</span><span class="p">,</span><span class="n">zams_mass</span><span class="p">)</span>
+
+        <span class="c1"># get track data (list of tuples)</span>
+        <span class="n">track</span> <span class="o">=</span> <span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">][</span><span class="n">zams_mass</span><span class="p">]</span>
+
+        <span class="c1"># convert to Pandas dataframe</span>
+        <span class="n">data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">track</span><span class="p">,</span>
+                            <span class="n">columns</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span><span class="s1">&#39;logL&#39;</span><span class="p">])</span>
+
+        <span class="c1"># make seaborn plot</span>
+        <span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">data</span><span class="p">,</span>
+                         <span class="n">sort</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
+                         <span class="n">x</span><span class="o">=</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span>
+                         <span class="n">y</span><span class="o">=</span><span class="s1">&#39;logL&#39;</span><span class="p">,</span>
+                         <span class="n">estimator</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+
+        <span class="c1"># set mass label at the zero-age main sequence (ZAMS) which is the first data point</span>
+        <span class="n">p</span><span class="o">.</span><span class="n">text</span><span class="p">(</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">],</span><span class="nb">str</span><span class="p">(</span><span class="n">zams_mass</span><span class="p">))</span>
+
+<span class="n">p</span><span class="o">.</span><span class="n">invert_xaxis</span><span class="p">()</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (T_\mathrm</span><span class="si">{eff}</span><span class="s2"> / \mathrm</span><span class="si">{K}</span><span class="s2">)$&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (L/$L$_{☉})$&quot;</span><span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+star  0
+zams mass  1.0
+zams mass  2.0
+zams mass  3.0
+zams mass  4.0
+zams mass  5.0
+zams mass  6.0
+zams mass  7.0
+zams mass  8.0
+zams mass  9.0
+zams mass  10.0
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Text(0, 0.5, &#39;$\\log_{10} (L/$L$_{☉})$&#39;)
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_HRD_14_2.png" src="_images/notebook_HRD_14_2.png" />
+</div>
+</div>
+<p>We now have an HRD. It took longer to make the plot than to run the stars with <em>binary_c</em>!</p>
+</div>
+<div class="section" id="Binary-stars">
+<h2>Binary stars<a class="headerlink" href="#Binary-stars" title="Permalink to this headline">¶</a></h2>
+<p>Now we put a secondary star of mass <span class="math notranslate nohighlight">\(0.5\mathrm{M}_\odot\)</span> at a distance of <span class="math notranslate nohighlight">\(10\mathrm{R}_\odot\)</span> to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[9]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">M_2</span> <span class="o">=</span> <span class="mf">0.5</span><span class="p">,</span> <span class="c1"># Msun</span>
+    <span class="n">separation</span> <span class="o">=</span> <span class="mi">10</span><span class="p">,</span> <span class="c1"># Rsun</span>
+    <span class="n">multiplicity</span> <span class="o">=</span> <span class="mi">2</span><span class="p">,</span> <span class="c1"># binaries</span>
+<span class="p">)</span>
+<span class="n">population</span><span class="o">.</span><span class="n">clean</span><span class="p">()</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Constructing/adding: M_1
+Grid has handled 10 stars
+with a total probability of 10.0
+Total starcount for this run will be: 10
+Generating grid code
+Constructing/adding: M_1
+Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+
+<span></span><span class="n">hrd</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">]</span>
+
+<span class="k">for</span> <span class="n">nstar</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">):</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;star &quot;</span><span class="p">,</span><span class="n">nstar</span><span class="p">)</span>
+
+    <span class="k">if</span> <span class="n">nstar</span> <span class="o">==</span> <span class="s1">&#39;0&#39;</span><span class="p">:</span> <span class="c1"># choose only primaries</span>
+
+        <span class="k">for</span> <span class="n">zams_mass</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">]):</span>
+            <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;zams mass &quot;</span><span class="p">,</span><span class="n">zams_mass</span><span class="p">)</span>
+
+            <span class="c1"># get track data (list of tuples)</span>
+            <span class="n">track</span> <span class="o">=</span> <span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">][</span><span class="n">zams_mass</span><span class="p">]</span>
+
+            <span class="c1"># convert to Pandas dataframe</span>
+            <span class="n">data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">track</span><span class="p">,</span>
+                                <span class="n">columns</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span><span class="s1">&#39;logL&#39;</span><span class="p">])</span>
+
+            <span class="c1"># make seaborn plot</span>
+            <span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">data</span><span class="p">,</span>
+                             <span class="n">sort</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
+                             <span class="n">x</span><span class="o">=</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span>
+                             <span class="n">y</span><span class="o">=</span><span class="s1">&#39;logL&#39;</span><span class="p">,</span>
+                             <span class="n">estimator</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+
+            <span class="c1"># set mass label at the zero-age main sequence (ZAMS) which is the first data point</span>
+            <span class="n">p</span><span class="o">.</span><span class="n">text</span><span class="p">(</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">],</span><span class="nb">str</span><span class="p">(</span><span class="n">zams_mass</span><span class="p">))</span>
+
+<span class="n">p</span><span class="o">.</span><span class="n">invert_xaxis</span><span class="p">()</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (T_\mathrm</span><span class="si">{eff}</span><span class="s2"> / \mathrm</span><span class="si">{K}</span><span class="s2">)$&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (L/$L$_{☉})$&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+star  0
+zams mass  1.0
+zams mass  2.0
+zams mass  3.0
+zams mass  4.0
+zams mass  5.0
+zams mass  6.0
+zams mass  7.0
+zams mass  8.0
+zams mass  9.0
+zams mass  10.0
+star  1
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Text(0, 0.5, &#39;$\\log_{10} (L/$L$_{☉})$&#39;)
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_HRD_19_2.png" src="_images/notebook_HRD_19_2.png" />
+</div>
+</div>
+<p>We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth.</p>
+<p>If we now set the separation to be longer, say <span class="math notranslate nohighlight">\(100\mathrm{R}_\odot\)</span>, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, <span class="math notranslate nohighlight">\(1\mathrm{M}_\odot\)</span>, so that the interaction is stronger.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">M_2</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span> <span class="c1"># Msun</span>
+    <span class="n">separation</span> <span class="o">=</span> <span class="mi">100</span><span class="p">,</span> <span class="c1"># Rsun</span>
+    <span class="n">multiplicity</span> <span class="o">=</span> <span class="mi">2</span><span class="p">,</span> <span class="c1"># binaries</span>
+    <span class="n">alpha_ce</span> <span class="o">=</span> <span class="mf">1.0</span><span class="p">,</span> <span class="c1"># make common-envelope evolution quite efficient</span>
+<span class="p">)</span>
+<span class="n">population</span><span class="o">.</span><span class="n">clean</span><span class="p">()</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Constructing/adding: M_1
+Grid has handled 10 stars
+with a total probability of 10.0
+Total starcount for this run will be: 10
+Generating grid code
+Constructing/adding: M_1
+Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[12]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">hrd</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">]</span>
+
+<span class="k">for</span> <span class="n">nstar</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">):</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;star &quot;</span><span class="p">,</span><span class="n">nstar</span><span class="p">)</span>
+
+    <span class="k">if</span> <span class="n">nstar</span> <span class="o">==</span> <span class="s1">&#39;0&#39;</span><span class="p">:</span> <span class="c1"># choose only primaries</span>
+
+        <span class="k">for</span> <span class="n">zams_mass</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">]):</span>
+            <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;primary zams mass &quot;</span><span class="p">,</span><span class="n">zams_mass</span><span class="p">)</span>
+
+            <span class="c1"># get track data (list of tuples)</span>
+            <span class="n">track</span> <span class="o">=</span> <span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">][</span><span class="n">zams_mass</span><span class="p">]</span>
+
+            <span class="c1"># convert to Pandas dataframe</span>
+            <span class="n">data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">track</span><span class="p">,</span>
+                                <span class="n">columns</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span><span class="s1">&#39;logL&#39;</span><span class="p">])</span>
+
+            <span class="c1"># make seaborn plot</span>
+            <span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">data</span><span class="p">,</span>
+                             <span class="n">sort</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
+                             <span class="n">x</span><span class="o">=</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span>
+                             <span class="n">y</span><span class="o">=</span><span class="s1">&#39;logL&#39;</span><span class="p">,</span>
+                             <span class="n">estimator</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+
+            <span class="c1"># set mass label at the zero-age main sequence (ZAMS) which is the first data point</span>
+            <span class="n">p</span><span class="o">.</span><span class="n">text</span><span class="p">(</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">0</span><span class="p">],</span><span class="n">track</span><span class="p">[</span><span class="mi">0</span><span class="p">][</span><span class="mi">1</span><span class="p">],</span><span class="nb">str</span><span class="p">(</span><span class="n">zams_mass</span><span class="p">))</span>
+
+<span class="n">p</span><span class="o">.</span><span class="n">invert_xaxis</span><span class="p">()</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (T_\mathrm</span><span class="si">{eff}</span><span class="s2"> / \mathrm</span><span class="si">{K}</span><span class="s2">)$&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (L/$L$_{☉})$&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+star  0
+primary zams mass  1.0
+primary zams mass  2.0
+primary zams mass  3.0
+primary zams mass  4.0
+primary zams mass  5.0
+primary zams mass  6.0
+primary zams mass  7.0
+primary zams mass  8.0
+primary zams mass  9.0
+primary zams mass  10.0
+star  1
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[12]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Text(0, 0.5, &#39;$\\log_{10} (L/$L$_{☉})$&#39;)
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_HRD_23_2.png" src="_images/notebook_HRD_23_2.png" />
+</div>
+</div>
+<p>You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the <span class="math notranslate nohighlight">\(1\mathrm{M}_\odot\)</span> star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made.</p>
+<p>We can also plot the secondary stars’ HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That’s because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[13]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">hrd</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;HRD&#39;</span><span class="p">]</span>
+
+<span class="k">for</span> <span class="n">nstar</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">):</span>
+    <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;star &quot;</span><span class="p">,</span><span class="n">nstar</span><span class="p">)</span>
+
+    <span class="k">if</span> <span class="n">nstar</span> <span class="o">==</span> <span class="s1">&#39;1&#39;</span><span class="p">:</span> <span class="c1"># choose only secondaries</span>
+
+        <span class="k">for</span> <span class="n">zams_mass</span> <span class="ow">in</span> <span class="nb">sorted</span><span class="p">(</span><span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">]):</span>
+            <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;primary zams mass &quot;</span><span class="p">,</span><span class="n">zams_mass</span><span class="p">)</span>
+
+            <span class="c1"># get track data (list of tuples)</span>
+            <span class="n">track</span> <span class="o">=</span> <span class="n">hrd</span><span class="p">[</span><span class="n">nstar</span><span class="p">][</span><span class="n">zams_mass</span><span class="p">]</span>
+
+            <span class="c1"># convert to Pandas dataframe</span>
+            <span class="n">data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">track</span><span class="p">,</span>
+                                <span class="n">columns</span> <span class="o">=</span> <span class="p">[</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span><span class="s1">&#39;logL&#39;</span><span class="p">])</span>
+
+            <span class="c1"># make seaborn plot</span>
+            <span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">data</span><span class="p">,</span>
+                             <span class="n">sort</span><span class="o">=</span><span class="kc">False</span><span class="p">,</span>
+                             <span class="n">x</span><span class="o">=</span><span class="s1">&#39;logTeff&#39;</span><span class="p">,</span>
+                             <span class="n">y</span><span class="o">=</span><span class="s1">&#39;logL&#39;</span><span class="p">,</span>
+                             <span class="n">estimator</span><span class="o">=</span><span class="kc">None</span><span class="p">)</span>
+
+
+<span class="n">p</span><span class="o">.</span><span class="n">invert_xaxis</span><span class="p">()</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (T_\mathrm</span><span class="si">{eff}</span><span class="s2"> / \mathrm</span><span class="si">{K}</span><span class="s2">)$&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (L/$L$_{☉})$&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+star  0
+star  1
+primary zams mass  1.0
+primary zams mass  2.0
+primary zams mass  3.0
+primary zams mass  4.0
+primary zams mass  5.0
+primary zams mass  6.0
+primary zams mass  7.0
+primary zams mass  8.0
+primary zams mass  9.0
+primary zams mass  10.0
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[13]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Text(0, 0.5, &#39;$\\log_{10} (L/$L$_{☉})$&#39;)
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_HRD_26_2.png" src="_images/notebook_HRD_26_2.png" />
+</div>
+</div>
+<p>Remember, all these stars start with a <span class="math notranslate nohighlight">\(1\mathrm{M}_\odot\)</span> binary, which begins at <span class="math notranslate nohighlight">\(\log_{10}(T_\mathrm{eff}/\mathrm{K})\sim 3.750\)</span>, <span class="math notranslate nohighlight">\(\log_{10}L/\mathrm{L}_\odot \sim 0\)</span>. The <span class="math notranslate nohighlight">\(1\mathrm{M}_\odot\)</span>-<span class="math notranslate nohighlight">\(1\mathrm{M}_\odot\)</span> binary evolves like two single stars until they interact up the giant branch at about <span class="math notranslate nohighlight">\(\log_{10} (L/\mathrm{L}_\odot) \sim 2.5\)</span>, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the
+very start.</p>
+<p>This is, of course, a very simple introduction to what happens in binaries. We haven’t talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events.</p>
+</div>
+</div>
+
+
+           </div>
+           
+          </div>
+          <footer>
+  
+    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
+      
+        <a href="notebook_common_envelope_evolution.html" class="btn btn-neutral float-right" title="Example use case: Common-envelope evolution" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+      
+      
+        <a href="notebook_luminosity_function_binaries.html" class="btn btn-neutral float-left" title="Zero-age stellar luminosity function in binaries" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+      
+    </div>
+  
+
+  <hr/>
+
+  <div role="contentinfo">
+    <p>
+        
+        &copy; Copyright 2021, David Hendriks, Robert Izzard
+
+    </p>
+  </div>
+    
+    
+    
+    Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a
+    
+    <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
+    
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+<br><br>
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+<br><br>
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
+
+
+
+</footer>
+
+        </div>
+      </div>
+
+    </section>
+
+  </div>
+  
+
+  <script type="text/javascript">
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script>
+
+  
+  
+    
+   
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/build/html/notebook_HRD.ipynb b/docs/build/html/notebook_HRD.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..52590f8a2a6abc7245e9ea0c08d274432cd2a1ad
--- /dev/null
+++ b/docs/build/html/notebook_HRD.ipynb
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Hertzsprung-Russell diagrams\n",
+    "\n",
+    "In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_HRD\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "First we set up a new population object. Our stars evolve to $13.7\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to $13.7\\mathrm{Gyr}$, and stars are not really born with a metallicity of $0.02$. These approximations only affect very low mass stars, so we assume all our stars have mass $M\\geq 1 \\mathrm{M}_\\odot$, and metallicity does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to $M\\leq 10 \\mathrm{M}_\\odot$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    tmp_dir=TMP_DIR,\n",
+    "    verbosity=1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $10\\mathrm{M}_\\odot$ in nine steps (so the masses are integers). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"M_1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        11\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1,2,1)\",\n",
+      "    \"precode\": null,\n",
+      "    \"probdist\": \"1\",\n",
+      "    \"dphasevol\": \"dM_1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"edge\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10} \n",
+    "massrange = (1, 11) \n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\", # == single-star mass\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(1,2,1)\", # space by unit masses\n",
+    "    probdist=\"1\", # dprob/dm1 : we don't care, so just set it to 1\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    "    gridtype=\"edge\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "\n",
+    "We now construct the HRD output.\n",
+    "\n",
+    "We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have $>0.1\\mathrm{M}_\\odot$ of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "Foreach_star(star)\n",
+      "{\n",
+      "    if(star->stellar_type <= TPAGB &&\n",
+      "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+      "    {\n",
+      "         double logTeff = log10(Teff_from_star_struct(star));\n",
+      "         double logL = log10(star->luminosity); \n",
+      "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+      "         Printf(\"HRD%d %30.12e %g %g %g %g\\n\",\n",
+      "                star->starnum, // 0\n",
+      "                stardata->model.time, // 1\n",
+      "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+      "                logTeff, // 3\n",
+      "                logL, // 4\n",
+      "                loggravity // 5\n",
+      "                );\n",
+      "\n",
+      "    }\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "Foreach_star(star)\n",
+    "{\n",
+    "    if(star->stellar_type <= TPAGB &&\n",
+    "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+    "    {\n",
+    "         double logTeff = log10(Teff_from_star_struct(star));\n",
+    "         double logL = log10(star->luminosity); \n",
+    "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+    "         Printf(\"HRD%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                star->starnum, // 0\n",
+    "                stardata->model.time, // 1\n",
+    "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+    "                logTeff, // 3\n",
+    "                logL, // 4\n",
+    "                loggravity // 5\n",
+    "                );\n",
+    "\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"HRD*n*\", where *n* is 0 (primary star) or 1 (secondary star, which doesn't exist in single-star systems), and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14565763dca0> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"logTeff\", \"logL\", \"logg\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        match = re.search('HRD(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            \n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "            # first time setup of the list of tuples\n",
+    "            if(len(self.grid_results['HRD'][nstar][linedata['zams_mass']])==0):\n",
+    "                self.grid_results['HRD'][nstar][linedata['zams_mass']] = []\n",
+    "\n",
+    "            # make the HRD be a list of tuples\n",
+    "            self.grid_results['HRD'][nstar][linedata['zams_mass']].append((linedata['logTeff'],\n",
+    "                                                                           linedata['logL']))\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: verbosity=0 to grid_options\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '20bee5b0c58d49c5bc47eced240685bb', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 10.0, 'total_count': 10, 'start_timestamp': 1631304519.45189, 'end_timestamp': 1631304519.9955394, 'total_mass_run': 55.0, 'total_probability_weighted_mass_run': 55.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    for zams_mass in sorted(hrd[nstar]):\n",
+    "        print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "        # get track data (list of tuples)\n",
+    "        track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "        # convert to Pandas dataframe\n",
+    "        data = pd.DataFrame(data=track, \n",
+    "                            columns = ['logTeff','logL'])\n",
+    "        \n",
+    "        # make seaborn plot\n",
+    "        p = sns.lineplot(data=data,\n",
+    "                         sort=False,\n",
+    "                         x='logTeff',\n",
+    "                         y='logL',\n",
+    "                         estimator=None)\n",
+    "        \n",
+    "        # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "        p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "        \n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "We now have an HRD. It took longer to make the plot than to run the stars with *binary_c*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## Binary stars"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d0fc4e-c72f-444a-93ab-19f52086b86d",
+   "metadata": {},
+   "source": [
+    "Now we put a secondary star of mass $0.5\\mathrm{M}_\\odot$ at a distance of $10\\mathrm{R}_\\odot$ to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "478e8005-e144-4e6f-80c9-0cf368a9bcb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 0.5, # Msun\n",
+    "    separation = 10, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c433e6a-fe22-4494-b1a9-fce9676a9f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3557b6d5-6c54-467c-b7a1-b1903493c441",
+   "metadata": {},
+   "source": [
+    "We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59335030-dd99-4c2f-afff-207a3fcbbb70",
+   "metadata": {},
+   "source": [
+    "If we now set the separation to be longer, say $100\\mathrm{R}_\\odot$, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, $1\\mathrm{M}_\\odot$, so that the interaction is stronger."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dee92b20-ad6b-4c97-80dc-71d3bd937c4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 1, # Msun\n",
+    "    separation = 100, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    "    alpha_ce = 1.0, # make common-envelope evolution quite efficient\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e0ac2573-bc35-43be-8f20-5c85364fde11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJcAAAJgCAYAAAA3ToJzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9d5gc15WnCb8Rka4ys7wFquAt4ehJ0IAECRD0kkjKU602aml6Zts8PW73mZ2d75lnd7anx3RPz6inu9XTWrmWoyjRkyABegcaECRBeI+qAlDepA9zvz8ifWYZlENV4bxiKm6ca+JmoiIj4pfnnKsppRSCIAiCIAiCIAiCIAiCMAH0Sz0BQRAEQRAEQRAEQRAEYe4i4pIgCIIgCIIgCIIgCIIwYURcEgRBEARBEARBEARBECaMiEuCIAiCIAiCIAiCIAjChBFxSRAEQRAEQRAEQRAEQZgwIi4JgiAIgiAIgiAIgiAIE0bEJUEQBEEQBEEQBEEQBGHCeC71BKaD/v4ojqMu9TQmTX19mN7eyKWehiDMauQ8EYTxIeeKIIyNnCeCMDZyngjC+Jhv54qua9TWhkasn5fikuOoeSEuAfPmfQjCdCLniSCMDzlXBGFs5DwRhLGR80QQxsfldK7MKnHJsiyuueYakslkgT0YDPLRRx9dolkJgiAIgiAIgiAIgiAIIzGrxKWTJ0+STCb58z//c5YuXZq167qkhhIEQRAEQRAEQRAEQZiNzCpx6dChQ+i6zt13301FRcWlno4gCIIgCIIgCIIgCIIwBrPKJejgwYMsXrxYhCVBEARBEARBEARBEIQ5wqwSlw4fPozP5+Nb3/oWV199Nddffz3/7t/9OyKR+ZNhXRAEQRAEQRAEQRAEYT4x68LiIpEIX/rSl/iDP/gD9u/fz//4H/+DkydP8qMf/QhN0y71FAVBEARBEARBEARBEIQ8NKXUrFkb77333qO6upo1a9ZkbU899RT/6l/9K77//e9zyy23XMLZCYIgCIIgCIIgCIIgCMXMKs+lG264ocS2detWwPVqGq+41NsbwXFmjWY2YRobK+nuHr7U0xCEWY2cJ4IwPuRcEYSxkfNEEMZGzhNBGB/z7VzRdY36+vDI9TM4l1Hp7e3lscce4+zZswX2RCIBQG1t7aWYliAIgiAIgiAIgiAIgjAKs0Zc0jSNf/fv/h0/+clPCuzPPfcchmFw7bXXXqKZCYIgCIIgCIIgCIIgCCMxa8Li6urqePTRR/nxj39MOBzmuuuu48MPP+Rv//ZvefTRR1myZMmlnqIgCIIgCIIgCIIgCIJQxKwRlwD+9//9f6e5uZnHH3+c733vezQ3N/PHf/zH/P7v//6lnpogCIIgCIIgCIIgCIJQhlklLnm9Xr797W/z7W9/+1JPRRAEQRAEQRAEQRAEQRgHsybnkiAIgiAIgiAIgiAIgjD3EHFJEARBEARBEARBEARBmDAiLgmCIAiCIAiCIAiCIAgTRsQlQRAEQRAEQRAEQRAEYcKIuCQIgiAIgiAIgiAIgiBMGBGXBEEQBEEQBEEQBEEQhAkj4pIgCIIgCIIgCIIgCIIwYURcEgRBEARBEARBEIQpQinFm+f7+YfD7XTGkpd6OoIwI3gu9QQEQRAEQRAEQRAEYT5gOQ6/PtXFvt5hAPb3DbMw6J+RYyulsHvi2D1R8Oh4W6vQg94ZObYgiLgkCIIgCIIgCIIgCJMkatr85FgnpyMJAOr8Xm5orJ6RYzuRFLG3z2Kdi2RtcV3Dv66BwFUtaIYELQnTi4hLgiAIgiAIgiAIgjAJehIpfnCkk76kCcDicIBvrFxA2Dv9j9xmxxDR106D6RRWOIrk/m7MjmFCWxZj1FZM+1yEyxcRlwRBEARBEARBEARhgpwYivGPx84Rt11xZ1NdmEeWNePVp99bKHWin9ibZ0C5+75Vdfg3NqFiJvH3O7F74zj9CYafOUrg2gX4r2hA07Rpn5dw+SHikiAIgiAIgiAIgiBMgL09Q/zm1AXstLhz58I6ti2smxEBJ3m4h/i7He6OrhHcshjf0hp3v9JP+L5VJD6+QPLTC+AoEu93YnUOE7xlEXqF5GISphYJvBQEQRAEQRAEQRCEi8BRihfbe/jVSVdYMjT40rJmtrfWz4iwlDrenxOWvDrhu5bnhKU0mq5RcXUL4XtWood9AFgdwww/dQSzY2ja5yhcXoi4JAiCIAiCIAiCIAjjxHQcfnHiPK+e6wegwtD5vTVtXN1QNSPHT50ZJPbWGXfHqxPesQJPS3jE9p6mEJUPrsa7rAYAlbCI7jpJ7N12lGnPwIyFywEJixMEQRAEQRAEQRCEcRAxLX5y9Bxnou6KcPV+L7+9eiENAd+MHN/sHCb22mk3x5KhEb5zGZ6G4Jj9NJ9BcMtizNZKYu92gOWQOtzrhsnduhhPU2j6Jy/Ma0RcEgRBEARBEARBEIQxuBBP8qOjnfQnLQCWVlbwjZULCHqMGTm+1RUl+sopcBToGqGtS0f1WCpG0zR8K+owGkPE3jqL3RXFGU4ReeEY/vWNBK5qQTMkuEmYGPKXIwiCIAiCIAiCIAijcGwwxt8dbM8KS1fXV/J7qxfOmLBkDySI7j4JlgMaBLcsxts2sTA8o8pP+O4VBK5bALoGCpL7uxl+5ihWX3yKZy5cLoi4JAiCIAiCIAiCIAgj8H73ID842kHCdgDY3lrPF5c149Fn5nHaiZlEdp1Apdz8SBU3tZUk775YNF0jsL6JygdWY9RVuMcZSBB55giJjy+gHDXZaQuXGSIuCYIgCIIgCIIgCEIRjlK8cLaH35zqwlHg0TS+sryFOxfWzciKcADKtInuPomKmgAErmrBv6p+ysY3agOE71+F/8pm0AAFiX3niTx3FHswMWXHEeY/Ii4JgiAIgiAIgiAIQh6m4/Cz4+d5/by7IlzQY/CtNa1cWV85Y3NQjiL62mnsdKiab1Ud/k1NU34cTdeouKqF8P2r0Kv9ANi9cYafPkLiQDdKiReTMDYiLgmCIAiCIAiCIAhCmohp8Q+HOvisPwJAY8DLP7tiEUsqK2ZsDkop4u+2Y3UMA+BpraRic9u0ekx56oNUPrga/7pG12ArEu93Etl5HDuSmrbjCvMDEZcEQRAEQRAEQRAEAehJpPjbg+2cibohYcsqK/iDKxZRF/Bm2zh2ir6zz9F1/GfYVmxa5pHc30XqaB8ARl0FoduXoOnTH4qnGToV1y8kfM8K9LAPAPtClOEnD5M80iteTMKIiLgkCIIgCIIgCIIgXPb0JlL83cF2+pJufqOr6ir53dULqchbEU45Nt0nfk6k5wMSQ0dJRdunfB5Wd5TER+cB0EJeQtuWoXlnZlW6DJ7mMJWfW41vdTq/k+UQf6edyM7jWL3TI6gJcxsRlwRBEARBEARBEITLmohp8f8d6SRquSuybV1Qy5eWF64Ip5Si98yTJCOnAAhULiNQtWJK56Esh9ibZ0HhPq1fV4XjvTTeQprXIHhTG6Hty9AqPIDrxRR55ijRN8/gRCVUTsjhudQTEARBEARBEARBEIRLRcp2+NHRzqzH0tYFtexoayhpN9C5i1j/fgB8oTYaln8VTZs6jyKlFLF323GGkgAcGX6fk7/+BIDG1hWsvPJWFq25Gk2bWR8Rb2sVlZ9fQ/LjCyQP94KjMI/3Y54awL++kcCGphn3rBJmHyIuCYIgCIIgCIIgCJcltlL87Pg52qOuoHN1fSV3tdaXtBvq2sNw1zsAePz1NC7/KrruLWk3GeL7zmEed1en6zcvcCrxabauu+M43R3HOfDeS6y74S7aVl+Nrs+cyKT7PVTc0IpvbQOJD89hnhkEW5H8pIvUkT4CV7fgW1k3I3mhhNmJhMUJgiAIgiAIgiAIlx1KKZ481cXhQTeH0KqqIA8vbS5ZkS3Wf4CBjp0A6J4wTSsexfAEp3QuyRN9pD7pdo9nD/NZ6m1WXLWFdTfuoLE1F3o32NPJO8/9kN0//0u6249P6RzGg1HlJ3THUsL3rMCod1fPUwmL+DvtDD9zBPPc8IzPSZgdiOeSIAiCIAiCIAiCcNnxcmcfH/QMAbAw6OfrKxdgFHneJIZP0XP6NwBouo+mFV/D46+Z0nlYA3Gib55GR8d0kpyqOMhdX/tX+CtC2TZmKsGBd3dy6IPdAPSdP83Lv/wr6hcu49ptX6a2sXVK5zQWnuYw4ftXYZ4cIL73HCpq4vQniL54As+iKiquW4hR5Z/ROQmXFvFcEgRBEARBEARBEC4rPugeZHdnHwC1Pg+/vXohfqPw8TgV76L75C9A2YBOw7Iv4QsumNJ5KMthYOchdOUe+7hnP9c/8lsFwhKA1xfgyts+zyN/9J+54vrt6Lqb46i38yQv/eQ/886zP2So9/yUzm0sNE3Dt7yWqi+sJXB1C3jc92CdHWL4ycPEP+hEpewZnZNw6RDPJUEQBEEQBEEQBOGy4fBAlCdOdQFQYej8zupWKr2Fj8ZWaoju4z9F2W4upvoln6NiqleGU4qBV4/gSbiizGnrIFd+5RG8vsCIfTxeP5u2fI7lG2/iwHsvcerAeyjH4czhDzl75CNWXrWFDTfdiy8wtWF7o6F5dAKbmvGtrCOx9xyp4/3gKJKfdZM63k/gqhZ8qyQf03xHPJcEQRAEQRAEQRCEy4L2SIKfHj+HA3g0jW+uWkhjha+gjWMl6D7+U2zTDZmrWbiNUN2mKZ9L/NAFtA5XvOozz7HgrmupCFePq2+4ppEbdnydHd/41yxcvh7QUMrh6Eev8ez3/2+OffwmjjOzXkN60Evw1sWEH1iF0eSKWyphEX9X8jFdDoi4JAiCIAiCIAiCIMx7ehMpfni0E9NRaMBXV7SwpLKioI1yLLpP/gIz4Xo2hRuup7Lp5imfi9UbI/HeOQCSTgzzCi9Ni1dd9Dg1DQvZ8oV/wo5v/Csa21YCkEpE+XD3L9n54z/n5IH3UMqZ0rmPhac+SPielQRvX4IWclfUy+Rjir58EnsoOaPzEWYGEZcEQRAEQRAEQRCEeU3EtPjBkU6iluvN8+CSRtbVhgvaKKXoPf0EychpACqq11LbdnfJ6nGTRaVsBl48hI6OUg7t4ZOsvvmOSY1Z29TGHV/6I25+4PcIVdUBMNR7nvde+Am7f/7f6O86OxVTHzeapuFbWuPmY7oql4/JlHxM8xbJuSQIgiAIgiAIgiDMW1K2w4+OdtKbNAG4fUEtm5tqStoNdLxIbOAAAP7QIuqXPoSmTa0/hlKKgZcP40m5CblP2wfZ8MDnp+Q4mqaxaPVVLFi2jiN7X+XI3ldJxiP0njvFiz/5zyxcvp4rb/sCVXXNkz7WuOfk0Qlc2YxvVR3xvecwi/MxXd2Cb6XkY5oPiOeSIAiCIAiCIAiCMC+xleLnx8/THnVDsa6ur2RHa31Ju6Gudxju3gOAJ9BAw/KvouveKZ9PfP85tAuuyNVtttN2z+aSleEmi8frY92NO7j/W/8/1l63DU13H/s7T3zGCz/6M/a+8jjJeHRKjzkWetBL6NbFhO9fhdGYl4/pnXQ+pvORGZ2PMPWI55IgCIIgCIIgCIIw71BK8dTpLg4NukLKyqogDy1tLglzi/bvZ6DjJQAMbyVNKx7F8FSUjDdZzO4oyb0X0NCJ2xGc9RU0tC6f8uNk8Pr8XHnb51m2YTOH3t/Fyc/cleWOfvQapw++z4ab7mPFplvQDWPa5lCCo9xXvqk/QXTn8XF1r7ipDf/qUnFQuPSIuCQIgiAIgiAIgiDMO14518f73e6KbwuCfh5duQCPXios9Z5+AgBN99G4/Gt4fONbse1icJIWQ7uOYqDjKIf28Amu2/zolB8HXFGt/VQ/xw/10HMhQiyaorZ+A1dtu4azB1+kt/M4qUSMva/8iqMfv8EV129n6brrpzwEsBypE/3YvfEJ90/sPYdvVd2U58ESJo+IS4IgCIIgCIIgCMK84oPuQXZ19AFQ4/Pw26sW4jcKxZOhrj0MdOx0dzSDxuVfxhdsmfK5KKUYeuUYRsoVRE6YH7Px/oenRcwZHkzw2gtHOHuyv8AeHU7SfgrgSpYtW405/B6xoV6G+y7w3s5/5Oi+N7jmjkdoWLhsyueUj399IyjyknkrnKiJ3R0bV/+K61tFWJqliLgkCIIgCIIgCIIgzBveOt/Ps2d7AKgwdH5ndStVvtyjr1KKwXMvM3ThLSDjsfQVApXTI6zEPzkPF9ycTxeSJ2m76wYCoaopP87RA1289sIRzLxV2Hx+A6XIs2mcPBkEttBU34luHiSVGKb/whl2//wvWbB0HRtuvo+6lsVTPj8Ao9JP8Ka2aRlbuLSIuCQIgiAIgiAIgiDMeRyleOFsD29eGADAr+t8c9VCmip82TZKOfSdeYZo3z4AdE+IphVfxxdcMC1zss5HSO67gIZGzB4iuVqnZdm6KT2G4yjee/0kH717Nmtbs7GZ629dSmV1AHA9mj7ac5bjh7pJxEzAoKt3EbCABY1nSA1/inIszp06wLlTB2hbdRUbb7l/RleWE+Y2Ii4JgiAIgiAIgiAIcxrLcfjVyQt80ueuOlbpNfjt1a0sDPqzbRzHpOfkr0gMHQXA46ulaeU38PhrS8YbGOgnEKggEAhMeE5O3GTolePoaNjK4qTvAJu3fGvC45UjmbDY9dRBzpxwQwD9AQ/bHljLkpWFSa8rqwPctmMVW+5aybGD3bz3+kmGBhKAh3Pdy9Fppq7qBCp1HOXYtB/dR8exT1i2/kbW33QPwcrSz0gQ8hFxSRAEQRAEQRAEQZizJGybnxw9x4lhN1F0Q8DL765updbvzbaxrRjdJ35OKtoOgLdiAU0rvobhDReMpZTiww/3cODAJ1RUBHnkka+j6xefG0k5iuFXTqCn3P0jyQ+48gsPYxhT9wg+PJjg2cc+pb/HzVdU2xDk3kc2UF078kp3mqaxal0Tq9Y1MTQQ57UXjtB+agCHED1DG9FZRn31Mez4cZRyOLH/HU4dfJ9VV93GFTfchb8iNGXzF+YXIi4JgiAIgiAIgiAIc5KhlMUPj3RwLu6qOItDAb65eiFBj5FtY6UG6Tr+j1gJNw9ToHIZDcu+jG74C8aybZu3336NkyePAeD1erlYlOXgDKdIHulBdScA6EweY+GWawnXNE7oPZajtyvCs7/8lGjEfd9LV9az7cG1+Pzjf8Svqqngga9sovv8MJ9+0MnRAxdwVJjuwaswtGU01hwjFT2FY1sc/vBlTnz6Nmuu28bqa7bi9fnHPoBwWSHikiAIgiAIgiAIgjDn6Iqn+MGRDgZSFgBX1IT4yvIWfHmrwqXiF+g+/lNscxiAYM166pd8AU03CsZKpVK8+upLnD/fAUBVVTXbtt1b4rWklELFTJzhFHYkhTOcwokk3e1wCpWwCtpHrH4ii5KsW3fdlL3v9lP97PzNZ6SSbpLujde1csu2FRNaRU3TNJoWVLHtwSo2XreQ914/xdmT/diqmvP91+LRllAbPoydPI+ZSrD/7Wc5uu911t24gxUbb8bwXLwAJ8xPRFwSBEEQBEEQBEEQ5hTHh2L89Ng54rYDwA2NVTy4pAkjT2BJDJ+i++QvULa7Ultl443UtO4oEWFisRi7dz9Pf38vAA0NTdx55z0l+Zas3hixV0/jpL2FxiLhRDmq7+PWbf90wu+zmKMHunj5mUM4jgLgpjuWc+UNbRMSloppWlDFA1/ZRGQowes7j3L6eB+WaqB7uJ6At4vq4GHMeDfJ2DAfvfI4Rz58hXWb72bpFTegG8bYBxDmNSIuCYIgCIIgCIIgCHOCoZTF82d7+LhvOGvb3lrPHQtqCwSW2MBBek79GpTr3VOzcDuVTTeViDCDgwPs2vUc0aibCLytbQm33bYNj6fwUdnsHCb6yimwnJI5aSEvetiHUelDBXQ+3fcCA9FzRNUQd37tj6ckhEwpxcfvtfPOKycA0HWNOx9Yy6p1TZMeu5hwVYB7v7iBM8f7+PTDDs6e7CdhNpMYbMJvtFNdcRgrNUh0qI/3X/wZB/a8yLobdrB0nYhMlzMiLgmCIAiCIAiCIAizGstRvH2hn5c7+0ilvXa8usbnFjdybWN1Qdvh7vfpb38+vadTv+RzhOo2lYzZ3X2B3btfIJVyPZtWrVrLjTfeWhIKlzreT+ytM+AeFv/GJjzNIfSwHz3sRUuH4SmleOfZ/4+zg58AcPXWh6ltWjTp966U4q3dx/n0Azdkz+c3uPuh9bQtnb4V3DRNY8nKepasrKfj9ACvvXCEwf44SXsRXZFWqkPt+LWDWKkI0cFe3n/pZxzYs5MrbtjB0vU3TGnicmFuIP/igiAIgiAIgiAIwqzlyGCUZ85005Mws7b1tWHuW9RQsCKcUorBc68wdOFNADTdS8OyL1NRtaJkzLNnT/H667uxbdez6aqrrmPjxqsLPJuUUiQ/6ybx4TnXoGsEtyzGt7Sm7DxP7H+Hs0f2AbBw+XpWXX37ZN42AJbl8PIzhzh+qBuAUNjH/V/eSH1TeIyeU0frkhq+/K3rOHmkh317ztJzIcJgdDHQSmVFO0HvYczEMNGhPj7Y9XMOvPciV9xwF8vW3ygi02WE/EsLgiAIgiAIgnDZopTKOKS4W5VxUMmzq7z6TE26XX4ble1Zrp8qM07meKponLzjlD2+ayw373J9cmOrMuOUn3fBZ5A3p0rbZnAwXvj5FLXJn8Oocy53rKK5Hx+KcXAgSobGgJcHFzexsjoIwNlIAp+h0RTw0HfmGaJ9HwOge4I0rvg6/uBCijly5CB79ryJUgpN09i8eQurVq0taKOUIvFBJ8kD7gpzeHVCdy7D21Je1BnsPcdHrzwOQCBUxQ13PzrpPEjJhMnzj3/GubODANTWB7n/yxuprA6M0XPq8Xh0Vq1rYsXaRvbv7WDPayexTBiOL2E43kZTfRe6uZ9UYojYUB8f7voFB/e8yLobd7BURKbLAvkXFgRBEARBECZF5uFckXvAzjwwFpTzHqJL2uXVOSVj5B1jtDoKH55zD6iqYN9RGWvhQ3FlymRwKJ7r7765ovc2woOzKh5PFc2hcN65/oUP7/kiRPFnWvi+VMGc8ueQP7fSeaiiOZV+ZvkP+vnzKP4sxhrPyXtflMwj179QlCjtU/JZFx2zsJ8qtBe0K/dZC3MFv65zZ2sdNzXV4NE1bKX4vz44BoChwber90LkMAAeXy2NKx/F668rGEMpxccff8gnn+x1+xkGt9++nba2JYXtbIfYm2cxTw0AoFV4CG9fjlFXUXZutmXyzrM/xLZMQGPzvd/EXzE5z6LIUIJnfvkp/T0xAFraqrj3kQ0EKi7t6my6rrHpujauuHIBB/ed48O3z5CIQ1fvAqCZhtrzeNVBkrEBYsP9fLDrF25Ops13s2z9jei65GSar4i4JAiCIAjCnEUphQM4SuEod2uny4r0VoFDsa1QxMj0VeRvcw+xTvo4qmy7vPbZdukxKbSpIpuTtRVui+c8mjjjlBNZivuVq4PCY5btN05haIb+vQVBuPzQgCvrK7mnrYEqn/v4GrNs/p+PTmTb2Ars4aMYGvgqFtC44usY3lDBOI7j8O67b3DsmCtA+f1+7rzzXhobCxNiq5RN9JVTWOfdBN96tZ/w9uXoYd+Ic9z32hMM9nQCsO7Gu2hevHpS77m3K8Kzj31KdNhdlW75mga2PXgFHo8+Rs+Zw+s12HR9G6s3NLPntZMc2HcO0OnpXwi00Nbaix39JCcyvfRzju59jau2PkTLkrVjDS/MQURcEgRBEAQBcIUO01GkHAfTUZiOg+0obAWWUumyypattJBjK4XlFG5tRbbsZF+4++SViwShTFub8oJRQTk9jiDMVbT0Cy1TdkNotPx9La8dbpLdzH6mHWh55YxdK9ovHU9Lj0fBeIX7xccE0NOTLmiTthTs57fLe58Za6kts5+bAxQeo+S9jmgrPH7h+Hlz0EbuM+Lxy80773MaqU/JsdINy8274DMYz/vViuaXHSf3Xkeac2a/dO6lc9CA2roQA/2xkjkX9yl9v+X+nkvnXNzHq2v4jJyociGe5K/2nyGfB/XdGJpDoHI5Dcu+jG4UCkGmafL667vp6HD7hcOVbN9+L1VVNQXtnJhJZNcJnP4EAEZjkNCdy9ADIz82tx/7hGMfvwFA/YKlrL/p3hHbjoeO0wO88Ov9pJJuLqiN17Zy87YV6Lo2Rs9LQ6DCy+33rOb6LUv55P12Pn6/HcfWae9oBO5gQUsPWvITEtFBBnvP8drj/5MFy9Zz1e1foKqu+VJPX5hCRFwSBEEQhHmAUoqoZdOftBg2LWKWTdx2iKe3qr2HoXgK03FI2a5wlBGQUo4rKtlKlJrpRMd9kNPTD1d6+qFSz9rcB8bCdqXt84WDrGgwnrqSdqDnPaQW12nl6sq1K6rTxxpjzPGL6vI+g3J1hWJG4Thk2uTvFz3M5z/I19eF6O+PZsfOfxAuEB2KHtq1vHZoZY5ZdrzZ+aAoCGPRWBWkIi18zDSHBqL86Ghnge3rxlNUaVGCtRupX/w5tKKwq0Qizssv76SnpwuAurp6tm27l4qKYEE7eyhJ9KUTOBHXW8izqIrQbUvQRvEWig338/7OnwLg9Vdw032/Pamwr2MHu9j9zCEc270eb75jOVfd0HZJvi+UUiRPncQaHMTs7UElk4SvvwFfkadXhmDIx+aty7niygW8uesYZ473ATrnzjeh63eyaOE5Yn17sa0U505+xvnTB1m56VbW33Qv/opQ2TGFuYWIS4IgCIIwR7GV4o1z/ezvj9CdSGHOEjceDfDoGoaWeWUEFFckMDJlMmW3Pr+cbYuGrrsiiF40VkmZ/P6F4k12mxZvMuVy4k2+2KNrxYJJeuyMEJRvKzlenmAkQsKcoDEcwIibYzcUBGHGee1cHzvbewtsv2c8hk+zqGy6mZqF20pEmOHhIXbtep7h4UEAFixoZevWu/B6Cz2brN4Y0V0nUQkLAN+qOio2t6GN4i3kOA7vPvcjUknXi+v6u75KqLp+wu/v4/faefvl44Cb1+iO+9ewev3Me/ZYAwMMvv4qQ3vexbxwvqCu5zePE776GoJrr6Dyhs0Y4dK8UtW1Fdz/pY309UTZt+cshz+9gOPonG5vRaOelvrjJIcPoxyHo/te59TB91l73Z2svHILHl8AxzaxLQvbMrEtkwN7dtJ5Yj+ObeHYNo5TXti88Z7fYum666flMxHGh6bU/PuZsrc3gjNLbrAnQ2NjJd3dw5d6GoIwq5HzRLicebdrgKdOd4/aRgMChk7Y78ULeHUNr66ntxq+bFnP7RvpfU3LiUTprSdbxi3nt0mXRUgR5ipyTRGEsZnp80Qpxc+On2d/f6TA/m3jFxiaQ03r3VQ13VjSr7e3h927nyeRcJP0L1++kptuuh3DKPQsMjuHib5yCiwHAP+mZgJXNY/pLbT/nef57J3n3bE33sz1d311wu/vnZdP8PH77QB4fQb3PLyetqW1ExpvoiQ7Ouh75kmG934I9tieaZ66Ohb8wR9SsXz5qO26zw/z5q5jnG8fyvXVB2msOUQy0j7peefzue/831SEq6d0zMkw364puq5RXz9yonrxXBIEQRCEOUqFUd71flEowMrqIItCARYEfVR6PTQ3Vc2rGxxBEARh/mM5Dn/x6WkGUlbWVk8/XzReQNMN6pc8Qqh2fUm/zs52Xn31JSzL9URcv/5KrrnmhhLBKHVqgNgbZzJLSFJxYyv+tQ1jzqvr7FEOvPsCAFX1LVy99eEJvT/bcnj52UMcO+j+UBQM+bj/yxtpaJ7cSnMXg9ndTc9Tv2H43XdyyysC/sVLqLzhRipWrEQPVKCUQ9dPf0Li2FEArL4+zv75f6DxK1+j5o5Sr7EMjS2VfOHRqzjfPsT+vR0cO9iN5VRzru8GvNoiqoOHccy+Sb+PtlVXEghVTnocYeKI59IsZr4pnYIwHch5IlzOKKXY1zvMa+f66UqkRmzn0TTqgz6Cuk7YYxD2GoS8nmw56DEIGDoVHp0Kw8Cra5IPRrgskWuKIIzNTJ0nUdPmP+w7UWBbqx1nq/Eemu6jcflXCFQuK+l38uQx3nzzFTKPuddffzNXXLGhpF3yUA/xPR3ujq4R3LIY39KaMefVfvRj3n3+x9hWCsPwsv3r/4KaxoUX/f6SCYsXfr2fzjNuyF5NfZD7v7SRqprARY81EayBAXqffYrB11/LeSppGpU33EjNtrsILFteci+gHIf4saNEP9pL/8u7sv0Cy5dTecNNVN18C0YwWHyoArrODfPOKyfoPDOQGRWP1kVTU5zWJbWEKoMYhhfD48XweDA8XnTDg+HxufuGF68/gMfrx+sPYHh8s/aeZb5dU8byXBJxaRYz3/4YBWE6kPNEEFyR6Vw8xad9w5wajtMZS04q/5KuQcAwqDD0rOjkNwz8hhs259N1fIaOT9fwG5n9/DoNf14bQxOxSpgbyDVFEMZmJs6TrniK/7b/dIHtJn0vV+qHMTxhGld8HV+wpaTfwYP7ef/9twHQdZ1bb72TpUsLw7aUUiT2XSD5yQXX4NEJ3bkU74LRvV6UUhx6fxefvPk04Obju37H11m2vjQkbywiQ0mefexT+rqjALS0VXHvIxsIVHgveqyLxY5E6HvhOQZe3oVK5X6YCl97HfWffxj/wvEJZfFjRzn3vb/B6st5HXnq6mn51rcJrlk7al+lFJ1nBjjw8XmOH+zKd5hi4eJqrr15yUWFBaaSFoP9cXfBhnSuRE3X8PoM/H4PHq9+Se5D5ts1RcSlOcx8+2MUhOlAzhNBKMVWit6ESX/SpC/pbmMa9EYSREybqGWTsJ0Zm4+uUSI8efLyPHnS+Z+8Wv5+UVnTRqzzpOu8ImQJk0SuKYIwNtN9nhwfivEPhzsKbHfrb7BMb8fjr6dpxaN4/DUF9Uop9u37gE8//QgAr9fLHXfcTUtLoVCiHEV8TzupI64gogU8hLYvw1M/ureNbZl8sOsXnDrwHgAen5+b7vsdFi4vDckbi77uKM/88lOiw0kAlq1uYPuDa/F4J77K3HhwEgn6d71I/87nceLxrD24fgMNDz1CYGmpF9hY2JEI53/4faIf7c0ZNY2abXfR8NAj6H7/mGP098b44M1T2dDADIuW1XLj7ctobMmJfkopLNMhlbQYHkqQTFhEhpK8vvPomMe5ZdsKNl3fNv43NwXMt2uKiEtzmPn2xygI04GcJ4IwPorPFdNxiKaFpozYlLAcErZNPF2O2649bjkkbAfTcUjaDilHYc/S24fMSnUZscqjuwnIM8nHc+Xcina5JOXly6P1LZfQvGCbtwqeiF6zH7mmCMLYTOd58n73IL851VVge8h4kWatF1+wlZqF23DsBBXVq9E0HXBXbduz502OHj0EQCBQwbZt91JfX5g7SdkOsdfPYKbD0PSwj9BdyzGqRhdAkvEIbz31D3R3uCu5Bavq2PL570woFK7zzADPP/4ZqaSbQ2rDNQu5ZftK9FFWpZssyrIYePUV+p59Cns49+8WWLGShoe/OKaX0ZjjK0Xy9Ckiez+k/6WdKNPNc+VtbKLp0d8iuPYKNM/YqZ57uyJ8/H47xw91Y5m5H8CqagI4jiKVtDFTFhO9/ViwqJovPHrVxDpPkPl2TRFxaQ4z3/4YBWE6kPNEEMbHVJ8rtqNIOQ4pxyFpp8tp4cndukKU6SiSRXVJx7VbjsLML6tcee5fxQvRICtAuSIVhSJWGWGqWOzK1ZUKY6UCWGE5N2Z5UU1W+HORa4ogjM10nCeOUjx/toe3LgwU2L9iPEutNkSgahXKTpCMngWgYekXCdauw7Yt3njjZc6cOQVAOFzJ9u33UVVVuGKYStlEXj6JfcENQ9NrA4S3L0cPjh6GNtR3gTd+83dEBnsAqF+wlFs/9/sEQlUX/R6PH+pm19MHcWz3Cnfj7cu4evOiafvhQSlF5IP36fn1Y5jdOa8g/6JF1D/0CKGNV075sVPnOjn/g++TOH4sZ9Q0arbvoP7Bz4+ZjwkgFknxwdunObjv3JQ907e0VrH1vjXUjuGhNtXMt2uKiEtzmPn2xygI04GcJ4IwPubSuaKU6xllOqqs8GQ6TnqrMFXRfkGdW7aVwnbASo+bsVlKYWfqi+zz4DbiotBhRI+tcsLUSOJVObErXxQr59VVVlTLP84Men3NpfNEmD5yj0fKfSm3nJW9L7JeZW159rJ9cvWFcxh/vcqOX1qvKNeneB559UXtMm2qKgMMDcVL2uXm5KAcE+VYKGW52/yysgrqU7bDM7F1nLXryOcbxhOEtTihuquI9n0C5LxZWtb+ARg1vPLKTi5cOAdAbW0927bdS7BIwHBiJpFdJ3D6EwAYzSHCdy5D840ehnb+9GHefub7mEk3hGzxmmu54e6vY3guPi/SJ++389Zu1/NJ1zW23reGNRuaL3qc8RI7fIjux35B8tTJrM3b1EzDFx4mfN31aLo+bcdWjsPA7pfo+c3jBTmdjKoqGh75MlU33Tyu4w/2x/nk/XYiw0l8fg9+vwev38Dn9+DzGQRDPipCPnx+A5/PwOvz4PUZ0+oFdrHMt2uKiEtzmPn2xygI04GcJ4IwPuRcuTgclROdyglTdr5AlS9MlRGuLEVhn6I2JWMX2CnbZu7f5VwchkZOsMp6feF6gGl5wpVGulz48ugaBqpMncID6JrCo0NlyE8ylsDArTM0lVd22xkoPOmtK3ypvAf/zEN/RnTIeygvsquiNuX6jqfN6OOTEx3K9MuKAiU2lf4vXwwpEkxKRIixBBNKBQ6V17fsPMr1KSdolK8vL+rkCyX5c8jfCjNFVAX4jb2DCKGsLUiMrxjP4ddMKps2M9z1bkGf6pbb8dVcz65dz9Pf3wtAc/MC7rhjBz5fYYibPZQk+tIJnIgrcngXVxO8bTGaMbq4cezjN9n78q9QyhW0Ntx0L+s233PRQrdSindeOcHH77W7x/cZ3P3QOhYtqxuj58RIdnTQ8/gviX7ycdZmVFZS/+Dnqb5t67jC06aKVHcXw3veZfiD90m1n83aAytW0vS1bxBYunTG5nKpmG/3XiIuzWHm2x+jIEwHcp4IwviQc2XqcG+dHPehVzmgHBTprXJwH1gzZSevTZ69oE4V9k+PXzq2yvazHccVnXDFLzstRLlCFiVlW4ENblu0PLuGBThKy9vX0vtaum3h1lF6et/dOuhYyt3a6DhM3y/isxENBwMHPbu1MQps7r6uueVMu/z6AptW2r9sHy1ny7XJ72ujo5CIR+HSo6HpXjTdg6Z5stteVc1Po9cVtGz1RvliXSc+3cAbaKDv7LMF9Q3LvoRttLJr13MMDw8BsGjRUrZsuRNPkXBi9caI7jqJSrj5jXyr66i4sQ1tFM8Wx3HY99pvOPrRawAYhpcb7nmUxWuuueh3bVsOLz93mGMH3BxSwZCP+760oSBB9VRhDfTT8+RvGHrzjayAqvl81O64m9q778OoqJjyY44XpRTDe96h+7FfYg8OuEZNo2LlKoIbNlJz+x0Y4ZEFi7nMfLv3EnFpDjPf/hgFYTqQ80QQxsdcPFeUslF2Cscxs+EUqOLwCnuM0AsrLczYKGVny+VsrpiTvy0sZ/uKd8OoKEVW2rAL5JGMLS19KD0rxdh5wpSdJ43Y6Gkxyyg7ZkEfVTT+CMdXl5X4pfIEKAcjK0gpDC0jVKkSe6ktz46DoSnX26ukLuPtpfDo7lbXSPch6/Gla5qbiAwt/QI0DS1TzrORZ8t5jRTWaxlbmfrcmIXjaSXt8+c0Qj0UzaHwfWjZY5TWawVzLjdmnl3Lm0OZz8H9r7T9WOMVflaUtNEospXM1x2hti5Ef3+sbDv3c9NzIpLuzSbezufwQJQfHu0ssF1dX8nDy5oxNI1ktJ0LR75fUN+y5ttEEl527XqeRMINVVu5cg2bN29BLwqzMs8NE335FFiu55F/UzOBq5pH9Twyk3Heee6HnDt5AIBAsJJbP/9t6hcsHbHPSCQTJjt/c4CO0wMA1NRVcP+XN1FVE7josUbDjsfpf+E5N5F2JgRN06i6dQsNn38IT03tlB5vMjiJOL3PPE3/SzvBtrN2PRCg5q67qb3r7nHlZJpLzMV7r9EQcWkOM9/+GAVhOpDzRBDGx6U+V5RS2OYgZrwb2xzGtmI4VjS9jeE4ybSQlEI5KRw7Ccoee2AhjZ57kNZ0cg/i5fdzD85a+sEvs6/ntdPy2o0yRqY84hh67uG4aMwx51TSp8gGBXatqA1Q2FfTcBR5nlm4Xldpr6xguIL+4QS2KvLmynh+Ka3AG8xS4JTzEsvWq7z9/BBLCsIecyGW0/tXMlvI5PjylMm1lbF5dXe1R2/GnrFp7mqQmbbZdiPZNA2PrueVJYH9ZJns9eSdCwM8faZw2fmtC2q5q7UeTdOI9n1C7+knCupbN/wp3b3DvPLKTsz0amQbNlzF1VdfXyIYpU4NEHvjDJnkeRU3tuJfW7hyXDHRwV7eeOJ7DPa6+ZuqGxay5QvfIVR18eFrxw918+ZLx4hFXbGnubWK+764gUDFxedqGgllWQy8/ip9Tz2JHcn9W4SuvIqGR76Ef2HrlB1rqkmdP0fPr39F5KO9eWGsoAdD1O64m5o7t2EEQ6OMMHe41PdeU81Y4tLMBV0KgiAIgnDZ4Tgm/e07ifV9glLWjB5b0zyge9A0wxUrNKOorKNpRvpXdqPINlo7PS1+pLcF+xkxp7hOy+7nl13hJdcmWy6o0wrGy9XlCyrCVHCpHwRUVowqzcNVrmwV5QGzCuoosjmuqOWMnO/LGsE21Xm+HMBxFCZp1W6GyQhZ3qyQ5QpQ+cKVK0YVilQZ0aqsraCvnieSufteEbWwleK5M9280zVYYH9gcSM3N9cAMNCxi6Gutwvq2zb9H7R3dPL667txHPcP5rrrbmLduo0lx0ge6iG+p8Pd0TWCWxbjW1oz6rx6Ok/y5lP/i2TMPfcXLl/P5vt+G6/v4ryMopEkb7x4jJNHerK2Zasb2PbgWrze0ZOHjxelFJEP36fn149jdl3I2v1Ll9H4pa8QXLN2So4znfhaFrDwn/0RSili+z+l54lfkzx9CicWpfeJX9P/wnNU376V2rvunlWeV8LYiLgkCIIgCMK0Ees/QLR3b9k6Tfeie4IYRhDN8KMbfjTdh2740tv0vu6FbIhFYc6OkbY5UUYQ5g5aOim5h9n1t6uUwqFYrCoSpIqEqTEFrFHaZ1Z8tFThCpD5x54MtlLYtiI5NR/PuPHpGj5dx2+4L5+h49e13H6mTk/XGVqJPdN2rolVSdvh58fPcXgwVmD/6vIWNtVXopSi69iPSUZOZes03Uvbpn/NsWNHeffdN1BKoWkat9yyleXLVxWMo5Qi8fEFkh+nBRePTujOpXgXjJ7f6PShD3lv5z/i2O6PH6uv2cqVt32hJMxuNJRSHPzkPO+8fJxU0hW//AEPt2xfyer1TVN2LYodOUzPr35B4sSJrM3b2ETDI18kfG2pB9dsR9M0Qhs3Edywkei+vfQ+9QTJs2dxEgn6d75A/84XMKqrqbrxJmru3Ia3oXFKjquUwurvp+vHPyB1/hyOaaJME2VZqGQSdJ0F/+SfUXntdWMPJhQg4pIgCIIgCNOGr6IZTfOUeC35ggvxhxbh8dfh9dfj8ddieCvRdLk1EYTZhqZp7qp5hobvUk8GdzVHKys+KSzHyROj3P1ceRSbKhaunFx95hh5Y1vO5Dy4Uo4i5dhErKlx1/LpReJTVpjSikSqnDDlM7QCkSrT16dPnxfkQNLkR0c7OR9PFdh/b3UrK6uDOHaKjv1/gXJy9f7wUhpXfIP9+z/ho4/eA8AwDLZuvYvW1sUF4yiliO/pIHXYXTlOC3gIbV+Gp37k/D1KKT5753k+e/cFt4+uc+2dX2LFplsu6r0N9sd59fkjdJ4ZyNpWXtHILdtXEgxNzdmS7Oyk59ePEd33UdZmhCupe/Bz1Nx+x4yuADcdaJpG+OprCV11DbH9n9L3/LPEjxwGwB4cpP/FF+h/aSehTVdSecNm9EAAlUzipJI4yWS6nCqypYrq88rJJDjOyBNyHM793f8k+Fd/fUkToc9F5vZfonBZkbBsvneoveTCVEyl16DW56XG76HCMApclAvKRe7LxWWvruHVdIxRVpQQBEEQRscXbKFl7XcYuvAWsYEDKMfNlZGKdZKKdZa0140AhrcSwxtG91RieCrQjQB6Zpt9VaB7AmhGwPVsEgThskHXNHyXQOjKhC1ajpMVn8oKU0XClekoUo5D0nZf2bKjSNmF9tRF5I3NiFVTEVvo0TTqAl7q/V7q0q/6gLut9XknfD/cHknwo6OdBYKaV9f4zto2WkMBLHOYzv1/WdCnsnEzNa138cEH73Dw4H4AfD4/27bdQ2Njc0FbZTvE3jqLeXIAAC3kJbxjBUaVf8Q5WWaK91/8KWcOu161Xn8Ftzz4ezQvXjPu9+U4io/fb+f9N05hp5OGhyr93Hb3KpaurB/3OKNhDQzQ+9RvGHzj9cIV4O66m9p7Lu0KcNNBxpMptHET8ePHGH5vD/Hjx0ieOglKEf14H9GP983IXCqvuwE9MLXJ1y8HRFwS5gy9SXNMYQlg2LQZNm3ORKfmuDqMKE4Vx9Jnyp48caq4zVj9DU3yZwiCML/wBhqoX/J5atvuIT50lGTkDMnoWaxEb4lHk2MncOwEZqJ7hNHKoBmu2GQE0D2u+KTpXnTdlw2r04y8csZu5JUzdsPnhtfJ97AgCEVkwxZ1g+l67HRURohSruBkOySd3NYVolTOll+fFqzy+5njFKsspeiKp+gqc6+tA9V+T1Z4Wjwcw2c6WfHJb5QPIdvfF+GXJ85j5YUx1vg8fGtNK/UBH6nYec4f/l5Bn7pFDxCsu4o333yFkyePARAMhti+/T5qivLvKMsh+uoprA43V5JeEyC8fTl6aOQfHOLRId588u/pO38agHBNI1u+8B2q6ppH7FNMz4UIrz5/mO7zkaxt/dUL2bx1GT7/5B+vnUScvheep//FFwpXgLtlC/Wffwhv7fzPQ1SxYiUVK1YCkDx7hv6XdxH54H2ceLx8B01D8/nQfX50vx/N70f3+9DS+7rf75YDfnRfpj7gtsmW3Xa+ha3o/pHFSWFkZLW4WcylTio521BKsbdniMdPdV3qqUwrGowoTuXK+XX5wlZuRZRMIsqyole+2DXHxSw5TwRhfMzGc8VdQW4IK9mLlRzAtiLYZsRdTc4cxjYjOHY86+00k+QEKJ+7lLbudQUozZuX+ymvrHvTOZ+8efmfypSz7fLKc/g7eL4xG88TQZgMjlJ5wpQqEqlywtSwadObMOlNmvQnzQJBaCzCHqPE6+mz/ggHBgp/6a33e/n9tW1U+zzEB4/QfeLnBfWNK76Op2IJr722i87OswBUVVWzffv9hMOFK1Q5SYvo7pPY3W4OJ6MhSGj7MvRRxJ2B7g7eeOJ7xIb73eO1reSWB7+Fv2J8K5NZlsMHb51i37tns4ucVddVsPXe1SxcVDOuMUZDWRaDr79K79NPYg/nrQC36Up3BbjWtkkfYy7jmCmSZ86ApqeFoLQw5POj+Xyz8lo6364pslqcMG/QNI1rG6u5trG6pM50HCKmnX5Zae8li0jedjBlMWhOzUpFFYZOjc+Dz9Cz7s4Zd2gznXxyovqmguyY7noq009mhZMScWqE8EFvgYA1clhhcX9fWuCaSwkoBUGYPjRNw+OrxuOrhlFyrirHzno0OXbc3VpF+5mXFUfZSRzHRDkplJPCcVKgLu77NNt3Jha40wxXvCoRpNxXNpm5ZqTt6a1m5K2Gl9dG96RXuctrm+3jgbz+kgBdEOY3uqYR8BgEGP9qZY5SDJsWvQmTvqT7ypR7kyYJu/D7NGLZRCI2ZyKJEcdsCHj5/TVtVPk8DHW9y0DHiwX1LWu+jaPX8tJLz9LTk/sheevWHaXCUswksusETr97PM+CMKE7lqKNsiJb54nPeOfZH2CZbhr3Zes3c+32L2MY43sc7jw7wKvPH2Gwz/Wc0XWNq25cxLW3LMHjGX/y73IopYjs/YCeX/8K80LRCnBf/DLBtVdMavzpJGmn6I33MZyKMGxGSNkmjrJxlIOjFLqmY2g6um5gZMqakd7qGLqRtWXbZuqy5Vx7fVELhqbjaDoK95lCoaErBy3zv2m6ljnKQSmFQuGktyr9Pl2bQ8pOcWroDJZjo1CEhv0MDcdYU7uShoqpCZeczYi4JMwLvLpOrV+n1j963g2lFClHlRWghlIWPQmT7kSKuD36Q0jcdojHUwQMncaAj+aQj8aAj4aAl4aAj/qAF13T0rH2TlkBysqzF9Rl+mRj+fNj+PP7F449mZVTLKWwbEXchplYE9goELNcL6zy+a9ydSX2tFDV4NjEhpMj99d1DHlgEoQ5jaYbGHoIwzu+X5fLoRw7LTTliU52CuWYOI67zdmK7LYrUClloRwr3dZCKTO7z2TS/CobZduXYkX2QsqIVBnhqpwgpemGK3zlt01vRxTESvqUE8vEm0sQLiW6plHt81Lt87K8TH2wuoIjHf30ZoSnZIq+hElnLDlizqjfX9NGpVen78wzRIpWEF247o9IWl527XyKwcGBgrqDBz/lpptuy+7bw0miL57AibjhYt4l1QS3LEYbITRPKcWRva/y8etP4AbsaFy55XOsue7OcX3PpJIW77x6ggMfncvaGlvCbL13DQ3NI3twjJf40SN0P/YLEieOZ23ehkYaHv4i4euuR7uIVetmgoHkIAd6j3Co7winh87Sm+hncmnupwdd07NCk57earg/ouhaoQhVIBgphUO+iJQrT5Z/fd0fsaRq0aTHmc2IuCRcVmiall7W1Uf9KMHyUdOmJ5GiO5HKCk49iRR9SRM777slYTucjSY4Gy38pUYDav1eGgLeAtGpMeCj0mtMy02zo1Re4sjciijlxKniumyfEfrnJ6TMH2OiZJYATszQk5SuURRiOFpurHyBKj+5exmvrhHCFw0NeTAShFmGphtoegU605MAVSk7LTQVik6F+1ZaoDJxMvUqv12eeJWxp8clM76yc+2UDWoKv0iVnT7eTC/QXg6tUKjSjCIRyigQrrLCWIHAVdin0NOrqF16P+avIhVPFApj2eOJ6CUIACGfh7ZwgLZw7ma63Ipw1zRU0p+02N5aT9ij6Dr6I5LRMwVjtW74FwxHU+za9SSxWGnC1OrqXH4huy9OZNcJVNx1KfWtrqPixja0EZKNO7bNhy8/xolP3wbA8PjYfN83aVu5aVzv89TRHl5/8SjRYfc9eTw6129Zyqbr29AnueBP6lwn3Y8XrgCnh8PUP/B5arbOrhXgTNvk4+79vHPuAw73H5uVYlIxTsZbeRZNNWHNhmvr9DJ7/moFYRYR8hqEvBUsqSx8CLGVoj9ppoWnvG08VbAKhoKsG/GRwVjBGD5dSwtOvpz4VOGjwe/FN8KvLuMhu3KKAVyE6/NEUSpfpCr1vCovThV5a6kyXl2ZslIlwtdErw+OgqRySM5MlCEaXJQ4VZwbq8CrKy83VknIYV5oojzwCMKlRdMMNMMAY2aTgCql0qKQ5XpnKStPkCq1FYhVeSJVfn9K+rh1FI9T0Cctdk3ZnbxyxTVmNt/WhTFb6GnBKuOdZZQRoQq9tSgnZo0oennyxs/3Hsv3ICs3vlwDhEtHZzTBD492Mmy698Jra0J8dXlL9r7WNiN0fvY/cayceGT46gi3fpnO8z28/farJJOlD97NzQtYt24jAFZXlOjuk6iUewz/xiYCV7eM+LefSsR4+5nvc+HMEQAqwtVs+cJ3qG0a23MkFk3x1q5jHDuYW1iidUkNt9+zmurayf1AYQ0O0PvUE+4KcI57Y6p5vbkV4ILBSY0/lcTMGK+1v80r7W8SNQufZ4KeClbWLKc1vICWYCNV/krC3jABjz8d0magoWErJxsmZ2e3btl2nBK7Sm+ddL9cOWe3lZ31JlIq7V1Urkw5TySV19dBUeTllOfVpGc9nfRSW8YbKlt27Y5yOD10Nts+GPBjphy2tG5mUWXrpfmHnEEkofcsZr4lAJvvxC2bnqzglMqWexLjT4pY7fPQmPZycj2d3HK1z3PZ5ylyl//NF7MUpnIIV1XQ1RctL07ZbpuSsMK8/uXqMmLWDGlRU0J5Aaq8OFWaCD6/TXHy9/L9L/e/x7mIXFOEmUApJydIKTsrOuXbynti5cSurAdV1m6XtHf380QwZReJYrl2lwd6odhUIl7le3blt8sXr8p5dnmy2+wYRfbCkEgRuy4HMtcTpRQH+ob45cluzPS97voAXO1JYZlJkskEdqqfhcEPC/r3DPn57EwNSo38d7Ju3Sauu24zAGb7ENFXT5EJHwhct4DA+qYR+w73d/PGE3/HcL+bu6m2eRFbPv8dKsKleVvzUUpxZP8F3tp9nGQi7R3lN7j5zhWs3TSykDUenEScvp0vuCvAZYQ0TaPq5lvdFeDq6iY89lQzlBrm5TNv8HrH2yTtnCdayBPk+parua75apZUtaFrsytkbzYy3+69JKG3IMwQFR6DRWGDReHCeDtHKQZTVkmIXU/cLEkwPpiyGExZHBsqXGbTq2s0+L1sWVDLVfVV0/5eZiPu8r8aHp2CoJbGmhAhc3pkILtEgCryxBpDnCptU1pnOW4eMMtxCkIuLxbTUZioMfOFTRXuv0WRGDWCOJWrGyGssCT5e+kqh5I3SxDmBpqmoxk+wHeppwJkPLucnFhVIkLliVmORVWVj4GBSJGYVeTtlRWvZpPo5aAcZ8Y9vUbG9bzKvsh5Y6l0WaGnt5k2em6LW0+6XXYfAzTdFSU0A6V0FDoKA4XmtlM6oKV96FR6VS9F5vd0pfJt5epy5dLt+Mcr127i4+Xau20K+xTPvXT84nmVjp8bu3S/eKvrGrZtc66invNNK0HTQCmaLhzD7m/ng/QRakJJrlreTz7tPUGOnavE9fMuz803387KlWsASJ3oJ/bmGXc6GlTctAj/qpGFmK6zR3nr6X8glXA9bdpWXcmN9/wWHu/o30lDAwle33mEsydz8122uoEtO1YSCk/cI1VZFoNvvE7vU09gDw9l7aGNm9wV4NpmTw6evkQ/u868xtud72HmrWaxKLyQ7Uu2cmXjBry6yAfCyMhfhyBMA45SxCy7IGl41LKJmjaWo/DqOlU+Dw4q60I8GqajOBdPsbuj77IVly4Fhq5hYBCY/ihDwP27KRWgyoQcFocZjtZGlYYcptJi12TyZmWSwCdmKAm8rrmJ+8sLUCOLUx5dx5fvrVVm9cMCT650+KLkzRKE8ZN5qC19OQX7jlNqU8pJ28v3ybeN1M5xRu5TePxy7TIP4O4rEPASj6fSHvDFbUi/0uKFMvLGoaB96X7xOE56BUOFptmAg4YDCnTNye1rDhoqbVNoKDTNQdcy5fQLB01Trj27BV1T6BquTXfLuTag63llTTF1uYPT+cDyLjP5VxxVxlaMVrS9GJRyQ+IdpeE4WnoLSmkopWE7GTvZsp1uO/o+OVveOGpCs5y7KKC7aQV99YsB0BybhR0HqIz0ZNs018S5YtFgQb++xBKMqhVsagzg9/tJJOJ8+um+gjZ33/0gzc0LAEge6iG+p8Ot0DWCty/Bt3hk76MT+9/lw12/wHHc+5IrbtjBxlvuQxvFw8ZxFPs/7GDP6yex0j9WBkM+tuxYyfI1jeP6PMqhlCLy0V56Hn8M88L5rN2/ZKm7AtwV6yY89lRzIdrFi2de5b3ze3O5ioAV1Uu5e+k21tWtlnsiYVyIuCQIF4GtVHZ1uWHTYjiVV87YUzbDlsVURGZquB5RIY9B2GtwU9Po7rzC3EbPJpyfGTfjTBJ4Nz9WUchg/r4qWsmwOEF8nofWiJ5caeFs4nOFpO0wU6kQM3mzSgSoIo+tcnW+cmGFY/SXvFmCK37Y2LaDbVvYtpPed1/55eJ9VzRxcBwnK6Dkyjl7RtwprVNl2o5vzGJvCWG6mKnwk5wolRWndJUVqbJlPSNcFYpW5dsWj5VXVzJW7tiTQdPA0Fx/J4zp//t0FGmxSs+JWUpPi1p6wb5SerqsYzs6jjKwHcPdKiO773p2uUKm+57GtwUt/fkVb0vbjNYn07543wY+9TXQh+vNE0CxvQpaW67G7/fj8/lxIh8R63274DOqX/IFFtflEml3drbz/vvvFLT5whe+QlVVNUopkp90kdiXFmU8OqE7l+FdUD4cRymHT954mkMf7AZA1w2u2/E1lq27oWz7DH3dUV59/jAXOnNhS2s3tXDzncvxB0ZfgXo04keP0v2rX5A4fixr8zY0Uv/QI1Ref8OsWQGuM3Ke50/t4qOuTwuSdF9Rt5p7lm5jZc2ySzg7YS4i4pIgpHHSwtFgyqI/ZTKYtBhImQykQ9UGUxYxy55UqlJdg1BaLAp5jWw5WLSfKQc9huS2EaaNbBJ4YCaTwBd7XllpD6uRk787o7bJrytOED/R81UBKUeRcmYmX4sGI6xeWLSS4Yh1IyeIz7Qx4ililp0NaZTvlqlBKUU8HiMej5FMujlGMttUKoVlmViWhWma2XL+Nl8gEmYG94FZR9czoq6WfYjWdR2lMm1yr1y//D7pMMDsQ/rI7YuPU7qv5z3cT3Sc8cy33DjaqMcu3Ra2zx2LUerGP55SGW8sG6UctIwXFA4oK+3xlfGMSocZZusy4YpW2jssLwwxExaZTWRfvGKj+5pIUnpdA91QTK0nr4Zu+NGMALoRQDf86W0ALVvO2TLl/PaaNrXX9ohp8eOj5+hIr5LcGPDx26sXUud3hRjl2PSdfYZY38cF/RpXfJ2KqpXZ/UOHPuO9994qaPOVr3wTvz+AUorEB50kD7heUJrfILR9OZ6G8omuLTPJu8/9mI7jnwDgC4S49XO/T2PbihHfh2057H3nDHvfOZPN01tVE+D2e1bTtrR2xH5jkTp/jp7Hf0Xko1yOKT0Uov6Bz1G99U5078QFq6nkQqyb506+xIcXPi4Qla5q3MDdS+5kcVXbJZydMJcRcUm4bHCUYihl0ZtexW2gRDwyJ5zzJujRqfJ6qPR6qPQa7taXK4fTYlHA0MU7Qbhs0bRM7iWmaTH4Qtwk8BStPuiUz39VtEJhSYL4suGHpd5bE3XOUpAdkxlKJZ8RmXxlQgnLhQ8W142UIH6k/vNJzDp3roOjRw/R399LJDKMbc++pNE5AcUVUXRdz9vX0/taXlkvKpf2KT9ebpWczDHdcbUSW+Erv11pfWZ+5frk2pQ/duHxS8cZjfmWfFW4OHI5ulyhyckTnXIvy7WrUntJHzWCfVwilsKxE2AnJixZabq3UIzSC8WonBCVJ1R5KvD4atH0QmGqO57ih0c76Uu6eb2WVVbwjZULqPC47RwrQffJX5KMnCro17z6W/hDuVWy3n33DY4cOVjQ5tFHfw/D8KAcRfyddlLH+tz5B72EdyzHqC7MZ5ohNtzPG0/+PQNd7QBU1TWz5QvfIVwzcjjb+Y4hXn3+MP09bk4mTYNN17dx/ZaleL0TE+OswUF6n36Swddfza0A5/FQs30HdffdjxEMTWjcqaYn3sfzJ3ex5/yHWVFJQ+O65qu5e+kdLAg1X+IZCnMdEZeEeUUmeXZv0qQ3kaI3YabLrqB0sTlmfLpGjd9Ljc/jikdpwShfSAp7PXj0+fPQJAjzBTcJPHh0g/K3pVOPrcqtTDhybqziZO+mKhNymNe/UBBzV1CcKDOdN8vQKMyBpZWKU/neW+XqCkIOx+hvTNP38sBAP7t3Pz8uTyOPx4PX68Xjybw8eDxevF5Pdt8wDHTdwDByr/z90ev0rK1ULJLrkiBcLJrmJgrXMMAITJtPryti2Th2EsdOZF+qaD9TX2hP25yxA8WVY2I7JpgXK5jqeAP1eANNeCua6FRN/OqcQTz9K+zm1jrua6nL3v9ayQG6jv8UK9mTN4ZGy9p/gq/CXdXNcRyef/5Jenu7sy1CoTAPPfRV12PQdoi9cQbztJunSa/yEb5rBXq4fCLuvvNneOPJ75GIukmym5es4eb7fxdfoLyHk5my2fPaST79sCNrq28MsfW+NTQtqLzIz8fFSSTof/EF+nY+X7gC3E03U//5h/HW109o3KmmPzHA86d2886597M5lTQ0rmnaxP3L7qI5NPLKe4JwMYi4JMxJHKXoS5p0xVOcj6e4EE/SFXfFpPEKSBpQ6TUI2r2E1CCVRAlrMcLpbSVRfJhoJuQvvmJ4K/H4atCMAKbuYVD3omledwle3YNWsO9NvzzoBbYy7WQ5T0GY8xiahnEJ8mYV57YqJ04FQn76BmN5bcp4chV5eKWcIi+uSYhZtgLbdkjOkJOPDiVeVd4icaog5LBMXTmvrmg0QdwTQFMOunLQHAdN2TQ3NrNwQSstLQupqqrG7w+gz5K8GoIgzC5cEcuDoXswvBPzalHKQdmpQjHKSeJYrvDk2AkcK22zE6g8YSrzQo0kkjuYiW7MRDdH+yK84jTipD1dbvCdZptxnFhPLb6KJpRj0XvmKRwrmu2te4I0r/pdvAFXXDFNk5///AcF+dkWL17K7bff5YZCmjbRV09jpXMf6bUBwnctR68oH0Z29sg+9rzwY2zLvUFfceWtXHPHI+h6eTnwzIk+Xn/hCMNDrgBkGBrX3rKEq25chDGB67UdjTL45uv073weeyi3Alxww0YaH/ky/kWzYwW4weQQO0+/wlsd72LlrVB5VeMG7l+2g4Xhlks4O2E+IuKSMOuJWzYd0SSdsQQX4ikuxFN0xVPjesgxNI06v5f6gJf6/K3fR7XPg645dOz/TcEFcSxscxj7on8BGgeanhab0mKU7kXTisSocrb0vl7GVq6frnvdX+XkV21BmPNk82YZMFberKkI98nkzSoXPpgRp1J2YRL44lDCketKE8Rbk8ib5TCNebNW3FhiOqIUWsJBP9GHrnpdTy0NvIaOV9fx6To+Q8fn8eD3GAS8XvweI8/rqlAE86YTvZeEHKbtkjdLEC5vNE1H8wTQPRPzzXWT8Vtp0SknPNlmFDPRTSrexbvDVexx1gCgY3O7/j5rnJP0do48rsdXS9Oq38LjqwEgHo/x2GM/KWizadM1XHXVdQA4KZvo7hPYXW6YmtEYJLRtGbq/9DFVKcXB91/i0zefSX8GGldtfZhVV91W9r42ETd5a9dxjnx2IWtraati671rqK0v7+E0GsnOTgZ2v8TQO2+hUqms3b94CQ1f/DKhdesveszpYDgV4aXTr/J6xzuYTu4X8g31a7l/+Q4WV0pOJWF6mNXi0h/+4R9y+PBhXnrppUs9FWGGSFg2HbEkHdEkHdEEHbFkNrZ7NKp9HporfDQFfNQHfFkRyRWQRrv5Nliw9g/o73gRM9GFlexHOalR2k8jykGpZNbNebp/3M8JUGkRagTPKr3EVtSvQLgawXNLvLIEYV6QnzdrJnDzZuWLWcUrE44tTpWshFi0+mFxDq4JZ7zSNJRmYOsGNgUOr67S5QCWgmTGHTYxqc8G3FBDb4HglC9EFXpnZby4PJpWVqwqFrjyx5uJcENBEGYWNweZF3QvhrcwLMx2FE+c7uJDy/XK8evwcGOcVq0eM25jJbuxrXjZcZtX/052vIGBPp566lcF9bfeegfLl68CwImbRHedwO5zvw89C8KE7liKVib3kW2ZfLDrF5w68J7b1ufn5vt/lwXL1pW0VUpx7GA3b+46RiLmfht7fQabty5n/dULLuoHVuU4RPd/wsDuXcQ+219Q52tZQN0DD1J5w+ZZsQJczIyz68xrvNL+Jik79zyztnYVDyzfwbLqJZdwdsLlwKwVl5588kleeuklFi9efKmnIkwjgymLU8NxTkXinB6Ocz4+urBT6TVcEanCT3OFLysoBTwTj4o3vCEalj40Yr1ybGwrgm1GsK0Ijpkr20Vl1MVKQjoeXzWGryodaufPJn4sXL0ks7JJYdJId4WUieH+WmWBXf7mYGrRizypisMEy4lWnqwnl17SLrefiCawUqk8kcwjXlmCME9w82ZpeGYoCTy4D1WF4tQIKxkW5cCKJVNE4jFiiQQJ0yJpW6QsG9NROJqGoxkoXUdpOo6uozQDR9dhEuJ7JtQwMYP5xDPhhsXCVH5YYcazqtwqhp78PFmalid+Fe4Xjyff64IwMyQsm58eP8+xIdeTqMbn4bdXL6S5wg9cjVIOib5X6D5TuNqbP7yM6gW3ZYWlzs52du16rqDNjh0P0NKyEAAnmiLy4gmcdKiad3E1wdsWo5UJU0vGI7z51P+ip+MEAMGqOrZ84TvUNCwsaRsZSvL6ziOcPt6XtS1ZUcdtd68iXDV+Ly87HmforTcZeHkXZteFgrrQxk3UbN9BcN36WfHdZNomr3W8zc5TLxPLE/1W1izjgWV3s6p2+SWcnXA5MSvFpQsXLvAf/sN/oKVF4kDnGxHT4thQjGODMU5G4vQnRxZHqrwGraEArSE/rUF3G/bO/J+spht4fNV4fNWjtlNKYZtDmIkerGQvZqIHM9GLlewZJYzOwUr1Y6X6SXIaTffhDTTg8dfjq2jG62/AE6jH669H08u7B+dEqJFEqZzNydjyVi/Jtclf0aS4jVue+CpWDsrJeWVNJefL2EpDB4tyYqVFKr3Ac6ucR1aurJd4d2X6TVe6T0EQLgWGrmFgEJjCU9s0TZLJBIlEnEQiUVCOJ+LEkkniyRRJ2yJp2qRsB0s5OJqO0g13q+koXc+KVDlbuj4jXKVtORFLz6ufvKA1reGGo+ApEKKKE7qPIE7liVz5+bU8I/T16hr+pEnSdvDoGsYseGgUhJlkIGnyw6OdXEj/2Nsa9PPN1QupTN9/O3aK3tO/Jj54BADDE6ZxxdfwBRcUjHPkyEHeffeNAtvnPvclampqAbAHk0ReOo6Kpr2KVtQSvHkRWhnPyKHe87z+xN8RHewFoH7BUm79/LcJBAu9rZRSfPbROd599QRmyv1+CgS93Lp9JSuvaBy3CJS6cIGBV3Yx9OYbOImch6nmD1B9y63UbNuOr3l2PKM6ymHP+b08e+JF+pMDWfvSqsU8uPxu1tSunBXil3D5MCvFpX/7b/8tt9xyC36/nw8//PBST0eYBLZSnIkkODoY5chgjM5YeXHBo2m0hQMsDQdYFA7QGgxQ5ZuVf54jomlangi1oqDOsZNpwakXM9mDlejFTPZiJXoLvI+UkyIV6yQVKw1mN3w1eP31rvgUqMfrb8AbqEf3hNE95RMeTjVK2WVFKSffVixKFYlfTjkPrBH6TXyeGa+sKXzzI6KPHU6olffIyglXpR5ZI4Yfyk2CIMw5vF4vXq+XcHj8KxI5joNlWZhmCtNMkUqlME0zvW+WsSVIpUwsy8SyLGzbwrIyL7NgdTsFafHJFaHyvamywlWRWFVO4ConXBWPl60fIdHueClc3XBmKE4K74parhg1slilZ9uVs5WIXUWhi+KlJVwqOqIJfnS0k2HTPcmuqAnxleUt+NKeRLYZofv4z0jFzwHgDTTRuOJrBT++KqX48MN3OXDg04KxH3nk64RCYXecvjiRl06gErn7PE9zqKywdP7UQd5+9geYSdcbZ/Haa7lhx9cxiu57+3tjvPb8Ec61D2Ztq9c3c/O2FVQEx75HVkoRO3iAgV0vEv30E8jL6+ptbKJm23aqbtmCUTFTPrSjo5Rif+9Bnjz+POeiOa+q5mATn19xD5saZodHlXD5Meue3h977DE+++wznnnmGf7Tf/pPl3o6wgSwHIfjQ3E+649wYCBKzCq9E/TpGssqK1haWcHScAWtIT+eWRCrPF3ohh9fcCG+YKH7ruvtNOh6O6UFp4znU7G3k50awE4NkBg+XmDXdD/eQD2etPDk9dfjCTTg9deV9XaaDJpmoBkGGP4pHbccOa+skYUqpSzCIYOhweGcwJUVqcr1ywhZVtqLKydsjbxiylg4KCc1Y7m6yotQI4tS+hgeWfnClV7STryyBOFSoes6Pp8Pn6/8MtwXS0asyglPZoH4lCsX2krbJrFtGztludvsy91XIyy24QpaWqGAlS9W5Xla5dtyYpdRJGblxLFytsx4c9VLKz8vVrEwVSx0FefFKhSryq+WWBy6KMnhL28ODUT4+fHzpBz3/L25uYb7FjVk/y7MRA9dx3+KnRoAoKp+NVWtD6Hn3Q86jsMrr+yko+Nswdhf+cpv4/f7UY7CPDVAfE8HKlV4Ttl9pSkajn38BntffhyVvj/bcPN9rLvx7gLRxLYd9u05y4dvnca23bmHq/zcfs9qFi+vG/N9O8kkQ+++zcDul0h1Fv6wG7xiPTXb7yK0cdOsyKeU4cTgaZ449hzHB09mbdW+Ku5ffhebW67DmKSQLwiTYVaJSx0dHfzZn/0Zf/Znf0Zd3dhfCMLswVGKU8Nx9vYO8Vl/lKRd+qC+MOhnVXWQ1dUhFocCkhSUjLdTjbuiRtXKgjrHTma9m/JD7axkX5G3U3JEbyePrzYbVudJC0/eQAO6JzTrf9HITzQ5WraV+sZKHO/kV+9TyhklTNAsFbpKPLDSgtUYnluZ/YnPM+OVNflkwGOjlU36rpf1yBp5lcKClQzL9ROvLEGYdqZarBoJx3FKBKdiEcpxSm3l2hXum7n+5shti8UthVZGuCrytMqzFXpu5TyvCr25ij23isWxqfHSitswQy646FCY5H0cebFGSgBfLnSxQBhLi2eGeGnNCnoTKX5y7BxpXYl1NaECYSkROU3PiV/gpO87QvVXs/Lqr9DTG8uOYZopnn76cSKR3P1YdXUN99//MIamkzzSS3J/F85w+R/iAuubsmXHsdn32hMc/eg1AAzDyw33PMriNdcU9EklLZ5//DM6zwxkbRuvbeXG25fh9Y1+Dpq9PQy8vJvBN17HieVWjNZ8PqpuupmabXfhX9g66hgzzfnoBZ46/gIf93yWtVV4AuxYcgdb227BZ0zvd7sgjIdZIy4ppfg3/+bfcPvtt3P33XdPaqz6+vAUzerS09g4fhf6S0F3LMk77b2809FHT1Eybo+usa6hkmuaa9nYVEWVf2ZCt+YPlUBDiVUph1RigES0i0S0m0S0i2S0m0SsGzM5VNA2k88pwbGyR9ANH6uv/SeEauZ24vzZfp4Uo5TKilGOnRav7Fw5t025Hlm2ieOk8uxWdl9l2pf0zdWpi040n53pzHplpYUr3UiHCqa3ev62oM6HbmT6+AraZMIN8/vk99U047J8qJlr54ogXCwZkSnnpWUXbCduS47Z3rLcH34yYYcFglO+V1W5nFnlcmqVE7BGCUOcrJdW0lEkZ9BLS8O9V/QZOl5Dx6vr+HQtW/Ya6bq0KJVr57bx6bl22f6Glt7m2rltcmOLl1YhKprA0DSctDB7YCDKX+w/zZbFDWzyX6Dn+C/SeTdh4cq7aVm2DU3TsteTSCTCj370g4IxV65cyf333Mfw/i4GPujAGkFUAlj+h5sxAu4jaSoRZ+fP/p7TR9ywumC4ivt+649pWVyYbiIeS/HTn36cFZYam8M88OUrWbS0dtT3Onz4CB2/eYLePe9DXqiwv7GBlvvupfmubXgrZ9d1si82wC8/e4ZXTr6dFc+9uod7Vm3loSvuIewPXeIZCmNxOd17aWok/+UZ5ic/+Qnf/e53efrpp6mtdb8Y/s//8/9k7969PP/88xjG+B8EensjOM6seFuTorGxku7uyXtkTDWOUhwdjPH2hQGODsUK6gwN1lSH2FhXyZqaIAFDXDOnA6UUjhVLr14XTa9WF8VK9pKInMFK9ox7LI+/gYXr/tk0znZ6ma3nyWzC9coq9cjKeFQ5YyR4z8+J5YzkkTUFXlkzi1bikZW/r5fzrCpJ5p7fbhSPLN07K4QsOVcEYWwmc5644dyqyOtqPF5Zo9vG6+ll2U7ZvFdlQw5HFbhKPbfK5+iavJfWpcDQKAgXzM+DVX71w6LQw3Sy+JETypeGLhoas+I6MBJd8RTvdA2wr2eYZJ7oouOwVGtnvXacDUtupLLhSiB3ngwM9PPUU48VjLV+7UbWBZaROthbkFepHNW/tSmbayk62MvrT3yPoV43p1N1w0K2fOE7hKoKo1li0RTP/PwTertdj6MlK+rY8YV1eLyj/y0OvvUGF37w/YJ8ShWr11Cz7S7CV13tpn2YRcTMGC+efpVX29/ETIt7Gho3tlzL/cvvoi4wupAmzA7m272XrmujOvLMGs+lnTt30t/fz6233lpSt379ev7sz/6Mhx9++BLMTMiQsh0+7Bnina4BehKFD5CtQT9XN1RxZV0loTG+3IWRcUWjKFZqENscxs5srSi2GcG2ojjprfvb6OQJ1181JeMIsxdN09EMH8yAy7RSCpTtek2NsnJhsShVmAOrXPhhrl9++CFzxCsLzXC9qUpyYI0mSuXlwSruV5xbKy+XFpepV5YgXGq0dJiXrvvwXgJnbaVUUViijePkhKiMp1WuLidUWZa7b1lWdpsfipjp79bl2WwLy1FYjioQnMaVU6skKXw5z61igcu1MYnvOFuBrRySE021OAEyXlpl82LlrVY4UgL4kfNslQ9VzOTUGq+XVlOFj88vaeKetgb29Q7ydkcH3ZYfB50TajEn1GLePeflBqufaxqqADh/vpMXX3ymYJyrF2xg0bEwSTOXZFqv8uEMFV1rvTrVX9uQvVb1dJ7gzSf/F8l4BICFy9ez+b7fxusLFHQbHkzw9C8+YTCdo2nF2ka2PbgWwxjda2/gld10/eOP3X8Lj4fKG2+iZtt2AouXjOvzmUlM2+S1jrfZeeplYlYuF9XGhiv43PJ7WRieHSvVCUI5Zo3n0okTJ4hGowW2v/7rv+bgwYN897vfpa2tLevRNBbiuTS1JG2Hd7sGeOP8QEFybp+ucU1DFTc0VtMSnP4Ez3OdrHBkDmGnhrDNIaz01k4NYpnD2ObQJBJLA5qB4QljeEMYnjC6N4zhCWF4Q+ieEIYniO4JZrfzIWHzbDlPhEtDoVdWqZjlFCd4HyUnljOOFQ+nStSdXrQyebC8+Hx+LFsvFK3KCFXFqxvmC1elieM9aJMIxRGE2YZcUyaGK2xlhKeM+JQTrkq9uUarS3tiWaW2fC+tlKOwlSofcljOG6tsyOHItuKwxrnppZW/qmH5vFiFCeAV5tAxSHXRo2o4o1pxKPyO9+oaa0I6kU/eJZCIZO3XaKtoc3JeRnptgMDGJhIfX8AZzK0W7WkJE747F+Z2+uAHvPfiT3Fs1ztn9bV3cOWWz6MXJdEe7I/z1M8+JjLkjrV2Uwu337MafYwcrn0vPEfPr37pzqmigtY/+edUrFx1MR/jjOAohz3n9/LsiRfpTw5k7cuqlvCFlfexsmbZpZucMGHm2zVlznguLV++vMRWU1ODz+dj48aNl2BGQk5U6idm5QSPWr+Hm5pquLahigrP3LvQTieOncRK9mOlBrCSfYXb1OAEvSz0tDiUE41KxaMwhieMZvjFY0G4rLg0XlmuAOWUDQssFaWckTyyRljdMOPxNTmvLLMkRNEsXYxnatCMEcIJi0MOC8ML9XIeWSMkhs94fIlXliDMTjRNwzA8GMbMPlq4YYilAlWhaFWcS6t4VUSzqK786onZXFrlksKPlVNrlATwY62GODkvLYVtKxIXdTlpTr/KYzqK/cM2LL2OtrOfEI72caNaTbNynQCMhiCBTU14WqsY/PEnBX19VzQQvMFNlK2Uw/63n+fAnp0AaLrOtXd+mRWbbi45Zl93lKd//gmxqOsBtfG6Vm7ZtmLU64FSit6nnqDv6ScB0MNh2v70XxJYsnTcn8RMoJRif+9Bnjz+POeiOY+v5mATn19xD5sa1st1T5gzzBpxSZg9OErxQfcQL3X0Es3zVGoK+LhzYR0b6sKXdTJEx05iJroxE71p4ag/LSj141ixsQfIR9MxvFV4vFUYviq3XLSdCyu7CcLlgKZpkBZHIMB0S+tZr6wxRKmyqxSWCSf0eBySyUSZXFqT9MpSNsq2USSZiSiTsmGCeTa9rLBVLvzQg14sfhW3E68sYQZwhWvcXDDprVKQXb5LKTfjtlLuWeqUa58pZ+zuviraL21fuB1xLmPacf8v/xiMUE9+/9J+ZEyZviPUQ94YeXZDKYwR6w1QOihf7rMnr03e/LJzAJSucJSDrWxs28HCxlYONjY2Dha5cmbfwsYiiYWNiYWJnS7bWFhY2tjfmO7RtZwQVZL3qjh/VqHnlkfzYmg+jLRITzp0WukGtgampmHpYOkK02NiazoWBs54rnCahqMb3KKuoJ4qPAvC+Dc24WkJg+WUCEsVN7biX+suVGOZKd7b+Y+cPfIRAF5/Bbc8+C2aF68uOUz3+WGe+cUnJOKuZ9O1Ny/m+i1LxxSWeh77Bf0vvgCAUV1N2z//V/hb28Z+XzPImaF2fn3sGY4OnMjaqn1VPLB8Bze2XIsxB73lhMubWS0u/cf/+B8v9RQuO44NxnjubDfn81Z+a65wRaX1tZeXqGRbsbSI1IOZ6MZKb21z/K6NmuHH46vD46/B46vB46vGSAtJHhGOBEEYhaxXFlPjlTWaa7b7EOcUiE0jJm8vG344coL3/H6ZMSfulYU7FibY0+WKlYemF4hNehkPrLLeVlpR6OEIHln57cQrqzxZgcFRKEeB7eTKjgI7LZTYqsCubOWuBuWActw+bj1pscYVXIr3u/xe4rHUCPW44+fv55Vx1Oj7Kj2/jHCUL2YIsxoNMNAwpvDRSSmVJzblRCezwGa5W9suapvK7jOBrw1daYQIECJAbYVN47IT6B5XvPH0t+JvvxobA1sHS9NI6Dafamfp1qNZ4cqwTXbEl9DYtsD1VGp0Vy1zYiZDjx0oOF5o2zK8bW6uJjMZ540nvkd3x3EAwjWNbPnCd6iqK/WWOt8xxLO//IRU0r1mbN66jKs3j77CsXIcuv7xxwy+9or7furqaPsX/xpf8+zJVdQb7+fpEy/w/oWPsrYKT4AdS+5ga9st+GbAG1sQpoNZLS4JM0d/0uTpM90cGsjlvarxebi7rYGN89xTSSmFlewlFT9PKnaOVOw8ZuLCuL2QDG8VHn8tHl+tu/XXuUKSvw7dCMjDgiAIsx7XK8t9dMIIjN1hkrirao3mkZWfvH20xPDlVjMs9MhywwMn6pXloFQS5bg5PqZ7kfaRhKrSVQqL25TzwCrnyZXfZ2q8spRSYDqolI0y7fQ2b99ywFIo2wHLQdmFZXfrgO2gMu1s5fbLCEgzSHLsJkIxGm7oVmabtmkZG4V28uzZNlqm0wj1FNozZa2gX/5xtKyZkY6RnWdpv6k5hlvWRuiX37bgGBS3z81Ho7CfUgrLsTBtC9MyMW2TlGWSTCUYjg0zFBtiODbMcHQY28l9gzmaYpg4vsp+GhYPkElvdLorRHuvRmXNSarCVVSGqvD5fOzd/wFKKSrI8eCOh6ipq0Pz5bxr7L44w08fIZ/wg6vx1Lk9U4kYr/36b+g7fxqAxraV3PLgt/BXhCim88wAz/1qP2bKnfet21ey8brWknb5KNvm/A/+geF33gbA29hE27/813jrG0btN1PEzDgvnn6FV9rfxEqvAKdrOre33sw9y7YR9pZ+DoIwlxBx6TLHUYr3ugd54WwPqfQNnE/X2LqgjltaavDq8yskwBWS+khG20nFz2HGzpGKXxhzxShN8+AJ1OMNNOINNLhbfwMef206RGZsDh36jPfee6vE7vf7qaqqoaqqGr8/gMfj5ixwt0bZ/UKbuy1OfCgIgjBbcVfV8oI+/UtqFXpl5eXBKhGtSkWpnFdWOY+skVY3HH3p7VHnekm8sopzYJXzyPKCraGiChIKFQdSoEwgoYGtoykdHANNGeDoaI4BykhvdVA62kRcLGYCPf1Qr2vohu5Kkel9TdNAx33Q17WcEKG7ioCmF+1rZMvZ9tn9tFiS2c8cA7L1+QKElr+fmaOWN4ei7cXYtTLtJmwXLinj8XFRShGLRRkaGsy+tORRGoPn0TTXie5oZxWdfUHAom+gl76B3rJjBQIV/NZvfYNksvDf3uwYIrrrZIGt6otXoIfcGSZiw7z2+P9koLsDgIXLN3DzA7+L4Sm9Dpw50ccLv/4MO53zdeu9q7niygWjv0fL4tzf/y2RDz8AwLdwIW3//F/jqakZ8/OZbizH4o2Od3n+1C6iZu7H66sbN/K5FffSFJwd4pcgTBYRly5j+hImvz51gRPDuZvYaxoqubutgUrv/PjTUI5FKtZJMno2/WofwyNJwxtowhdsTgtJjXgCDXh8NZP+lfezzz4ua08mk3R3X6C7+0LZ+vGiaVpZ0WkkgaqwnVGmnydPyMr1MQxDhCxBEOYMhV5Z03+8Qq+skUWpQoGrvOdWYZhiefFrxr2ydCCUfl3U8XDFJmVkt5oyAA8aBhqut5X7b5XxvEp7XGkeNM0oDUnUPGiGF93wgO5F033onnSdJy2cGTqaroGREYO0AjGpWByZbyv7CAK434OhUJhQKExLy0IGz73M0IVTbp3uJdR0D2ub6lmYJz6dP99RdqwHHniEqqqqgvMkebiH+LuF7au/tiHr1RSPDPLq43/NUO95ABatvoob7/1m2QTwJ4/08OKTB3BshabBnQ+sZfX6kROMAzipFOf+5rtEP3XzPPkXL6H1T/8Fnsqq8X1A04RSio+6P+XJ48/TE8+Jdcurl/DQygdYXr3kEs5OEKae+aEgCBeFoxR7ugZ5ob0HM+2tVOPz8NDSJlZVz213TKUcUrFOEsMnSAydIBnrGDG3h6Z58FY04atYgC/Ygje4AF+gadyeSBfL5s1b2L37+WkZG9wLmGmamKY5duNJouv6OAWqkT2txiNyGYbkIBEEYW4xk15ZACqzgmFRmKCT75FVLum7yksIP4Ynl5NMorBAn0TKdg3QbFRaxrooSSyTlHkChy8rSI1Y9pLsCxJPOCOsepgfbuiBbM6sXBvJnSXMZpRj03vmKWL9nwKge4I0Lv8a/lBhuNmZM6fo7j6PbbvnaygUZsmS5axZs45gMFjQNv5eB8mDPQW26m9sRDPcHyJjw/288th3iQx0A7Dkiuu54e6vo5dJVn30QBe7nz6IUu6S53d9fh3L14zu1eMkEnR896+IHzoIQGDFSlr/5E8xgpf2mebE4Cl+ffRZTg6dztoaK+r5/Ir7uKpxg3xPTAFuvj0TZSXBTJD69EXMg6+BY6JVNeNddTO+K+9Dm+FVLC9n5JO+zOhNpHj8VBen8ryVbmis5p5F9QSMubkigZUaIj50hMTQCRKRkyi7fMYEw1eNP7Qo+/JWNM3oSkCtrYv45je/k923bYtoNEosFiUajRCNRrLloaEhhocHp20uXq8X27ZxnIk9KDiOQyqVAkYPJ5wKyotQOTEqGAxg24whaI0+hmG4YYVyoRcEYa6haQaaYYDhn7ZjWOcjRF4+iTJt0BzQbZRmQ1DDqPOhVRnoIR2COpofMOyc6FXijZUveI3PPhlyoYbjax/pGbvNWJTPm+UpEqrGY8/Pn1WcLF4ELeHicOwU3Sd+TjJyCgCPv47GFV/H668raHfo0H7ee8/NWaRpGjfeeCurV19RMp5SiuhLJ7DORbI2LeSl6uErXA9BIDLYy6uP/Q+iQ30ALN94M9dt/3LZ++9Dn5znlecOA2B4dO5+aB1LVtSP+p7sWJSOv/pLEsePAVCx9gpa//BP0APTnztwJLpiPTx5/Hn2dX+atYW8Qe5dup0trZvxTNOP2LOVjACElUJZSZSZhOzWtZFvt1J55SSYrs1tk3DrzES2zl11ocxxB8+T+uDX6FWNeFfeNMPv+vLl8vrrnif8+Z//B86ePc13v/u9AntnZwff/e5/46OPPgTg5ptv5Q//8E+pra3FUYp3LgzwYkdv1lup1ufh4WXNrKgKjtp3NmImeogNHCI+eIhUrLNsG0+ggUDl8qyY5PFdWtfYYgzDQ1VVNVVV1SO2MU2zrPjkilLu1rIu3lPJsiyCwRDBYAi/34/fH8i+AoEAfr8fw/Bg2za2bWFZVt7WLtgvto3ULrvc70XizsFmutOsapo2okA1lmdWYQjh2J5ZElYoCMJcwtMSpuqL60gd6SV1rA9nMOnmCRoCNQQKhYNNVsHRNfSgH60ihBH0ogW96BVe9KAHrcKLVmGg+Q00vwfNO7qw7+bMsrP5rygXUliQFytf0Coq53lsFbYpHmtyHsBKWSjbmv4M8HkUCFoF4laecDWSvVjcGkHQQvegp8cQQWvuEe3/NCssAfhDhauuKaXYu/e9bBoHj8fDbbdtp62tdHU2ZTsM/fIAKpETfz1tVYTuXJr9uxju7+KVx/4H8Yj7Y+mqq2/n6q0Pl/272f9hB2+85ApEHq/OfV/cQOuS0Z9B7OFh2v/yv5A843oGhTZuYsE//UN036VZaS2SivL8qV283vEOTlrw8Oge7mi7lR1L7iDorRhjhLmJSkSw2vfj9HfgDPegIr2oVAyViqOSMbASblKvS4AWqMRoWX1Jjn25IuLSHOOZZ57g6ad/w1VXXVNgHxwc4I//+A8wTZNHH/0mtm3zs5/9mOPHj/H//ve/56mOPs5EEtn2m5uqubutAb+hj9r37//+h3i9M+PaPxZWaohY/6dE+z7BTHSX1OueEIHKZQQqlxOoXD7rxKSJ4PV6qa6uobq6pmy9GwqXIhqNpsWnSF45t824Nef3ywhWI2EYBsFgiFAoXLCtr6+mqakF4yI93RzHyROjym2LhaxywlZG0MrVgUMymUoLW3badvEopbAsc0Ji3cWi6/oYAtXInlYX55klN/+CIEwNus8gsKGJwIYm7P44ZmcEuzuK3RvHiRR5sTrKtUVSY+srGmg+I/fye9Lbon2fjuY10Lw+DE8Fmk8Hn4Hm0bNeElNBY2MlXV1DaUGraCXCEu+qMuVsH7uMF9Z8FLSKVzUsDB8sFb1GCjfMKxd5b4mgNTUEQosxPGFsy733i/btI9q3j0DlcoJ1V/PRZ+c4efKE2zZQwbZt91Bf31gyjkrZHPvLtwts/g2NVFy7MLs/0NPJa7/6axIxNy/T2uu3s+nWB8v++3205yzvvuIe1+c3uP/LG2lpHfmHVwBrYID2v/jPpDrdPE/ha69jwbf/AM0z84+2pm3yavtb7Dz9MnEr96x1ffM1PLj8buorZucP9ZPBSQxjHX0H69Re7PNHRvQemjCGF83jB6/f3Xp8aN5Adj9b9gbA40fz+gvq8QbQPH702oVonksjNl6uiLg0R7Btmx/96Pt8//vfK1v/85//I93dXfzwhz9n6dJlAFyxbj3//E//kP/rhz+hefOdANT5vTy8tInlVcFR+65bt4E//dP/jeeff4bPfe6haX53I+PYKWIDB4n1f0Ji+GRJvcffQLBmDRXVa/EFF152Nx2apuHz+fH5/NTW1pVto5QimUyUCFD54lM0GinxLLJtm+HhIYaHh0rG9Hi8LFzYxqJFS2htXUxgHO7Huq7j8/nwTfEvSsXJV5VSOI5d4D01mufVWJ5Zo43hOBO7i3ccB8dJYZozE1Y4vlxYF5fovbi9hBUKwuWDUVuBUVsBuA+eynJwhpLYQ0mcqImKmzixzNbCiZtgjvDwoUAlbVRyEqqIR3dFJq8rQOHNCFH5Wx3ybR7d7WfoaB4tO4aTskCRFTpgZsJrch5apZ5XTomIVRRumG8vK3yNHHo4uTlnBK3E2I2niBEFrfHk1Sr23iqTS6ukn+aZN9c2b0UjC9f/MbGBQ0R6PyAZOQPg5ikdPkGLX0c1VTCUaub2Oz5HZZlk2E7MZOixAwW2ipva8K/Oha/1d53l1V/9T1KJKAAbbrqXdZvvKfkclVJ88NZpPnjT9TwKVHh44CubaGypHPV9mL29tP/X/4TZ5S6EU7n5Jlp+9/fd8OAZxFEOH1zYx1PHX6A/OZC1r65ZwUMr72dxVduMzmcmsAc6Se19GuvE++AU/5iroYVq0Ssb0Pwh8AXR/MECAQiPLy0O+V2bx5cnIKXthg9NPPznLCIuzQGSySTf+c7vcPz4Ue65534+/PD9kja7d7/IVVddmxWHuuIpPgy1UtG0kAt736Zl853c1FzDjtZ6fIY+al+A66+/kcWLl7B794uXRFwyk31Eut8n0rsvu5JNBo+/gVDdRoI1V+ANyNKdY6FpGoFABYFABfX15T8vpRTxeDwtPBWG3WUEqHg8lhWgLMvkzJmTnDlzEk3TaGxsZtGiJSxatISqqpoZfHelZMLbyq1AMtU4jpMXOjiyp9VYItfo7aYmrDCVmomwwlKB6mI9s8YTfihhhYIwu9A8OkZdBUbdyGEfyrRxYhYqYbpiUsrGSdqolJXdz20td5uyx5f523JQloOaAo0j+3OKrrkClKG5wpSRFrAKRCkdPFrObuTVF9i0QruRLud5XLmrGl4iQWuUsEJnRG+rEezjEMEmvMIhs0XQmmAurbIiWDnRa/oELU33EKrbQKhuA2a8m4ELe4j07sPQHfxeh6XNUeAkia7n8DjXEqhakc2PZPcnGH7qcMF4oW3L8LblRKiezpO8/pu/xUy6uV0DoSoq65rLCkvvvnqCfXvaAagIeXnwq1dS3zh6Eu5UVxft/+XPsfrcldeqb9tK0ze+OeNixJH+Y/z62LOcHc6tkNcSauahFfexvn7tvBEkM6hUnOTeJzE/falgoSStsgHPkqvxLLkao2UVmjE7ol2ES4eIS3OAVCpFLBbl3//7P2Pbtrv44hcfLKgfGhqis7ODrVu3YTkOr53r59Vz/dhKEW5bysDBfXx7bRtLK0tv+vL7FrN69VreffetaXtfxSilSAyfYLh7D4mhYwV1uidIsHYDobpN+CoWzLsv7UuNpmkEg0GCwSANDU1l2ziOQywWo6eni/b2U7S3nyWVSqKUoqvrPF1d5/nwwz1UVVWzaNES2tqW0NjYPK+FAF3X0XV9RkJHM2GFY4cOjixQlfPaKtd+IrhhhRPvfzG4YYVjC1RjC1pje2bJd40gTA2a18CoNqB6/InHlVIo00ElLTAdlGm7+9mtA5myZaNS6W2+Pd0e+yIFDUe54hag4mO0nSj5AlZZUarQqyorSpUIVaUCV7bNKCGDWUELD8yQ04craDkjeF6ZWUELxx4ht9YY5XxBK88+FwWt/BxXOUHKKON5NZJ99HDDaDzF2/sGiEYbaKhKsLTFJuCJAor40BHiQ0cwfNWE66/Bb60isftCwRzDD6zCU5+LhOhqP8Ybv/k7LDP3Y1YiOsQ7z/6AxtYVVITdUDelFG++dIz9e92cqaFKP5/72iZq6gpXoSsmdf48Z//Lf8QeGACgZvsOGr/ytRm9Tp+LXuCJY8+yv/dQ1lbpC/PgsrvZvOA6jDIr4M11zGPvknznp6h4RnrX8Cy/Hu+6OzEWrJH7JKEAEZfmAKFQiJ/97Nd4Rogj7unpAsCoquW7n52lK+GG2mjAspYW3tsbo0Er726e6dvYWCoo1Nc3EIlEiEQihMPhKXgn5VFKER88zND5N0jFzxXU+cPLqGy8norqVWja/PvCnkvouk44HCYcDrN06XIcx6Gr6zwnThzj2LHcRXZoaJDPPvuEzz77BIArrtjINdfccNE5moRCMmGFML2x425Y4XiFrPF5Zo00RnEusPHihhU6mOZM5McyLlKgGlmwGm0MXZdcIoJQjKZpaD4DfJO/fihHuSJTRpyyFMp2sl5PmW0o4CUymHA9oSwHbCdXLrCpQpszAfEiX8Ca9DscAV3LildlvacyAlaxKFXgdWXkBCyjSAS7yJxXrqBloGFcAkFr7KTv5XNrTWylw8kKWtjWtKfQunpJ3o5mlEzZTg0yeO4VUK/ibWsj0LEJTXlY+vvXMZB3DT5/+jBvPvk97BHyVgZCbqibUorXXjjCwY/PA1BVE+DBr15JVc3o3nrJzk7a/+ufYw+6ycHr7nuA+ocembHr5mBymGdPvsjbne+h0h+ST/eyffHtbFt8OwHP9K3WealQZoLEmz/GOppzNDBaVuO/+VGMhiWj9BQuZ0RcmgNkvCNGon/YTcy3pz9GS1pYaqnw8dDSZp7/qIb3gEQiXlYgisViAGVz5vj97hflSH0niysqHWLw3GuYia6sXdO9hOo2EW64Hl9FeS8aYXpxHId4PJZ+xYnHYyQScWKxGIlEzhaPx8YUCA4e/JSlS5fT2Ng8Q7MXJkMmvM0VA6f3ZkkpNcLqg2N7WpW2H0n8cu2OM7Fkk45jk0pNf1ghMMGk7SPVl46RTPpwHGdeexMKwkhouobm94z5tVbbWImVl8dvvChHFQlRheJVoVClcvbiNlmbKul30d5X4IpeTtoD7OJ7jw+NUsGpQIjSyntdFZVL6rzpra5NSkQoFLRmTgRQmRxaZb2tSsMKS3JrjRhuOHLo4aRkSjXK/ZymMOvO4hlqof6e7XhrAtDtCkmdJ/bz1tPfx7HLey4/+O1/j6bpOI7i1ecOc3i/6wFVXVfB5752JeHK0f9Nkh0dtP+XP8dO5wCt//xD1D/4+Qm8wYsnaafYfeY1XjrzGik78+O9xk0Lruf+5XdR4x898fhcxe45TXz336AGXRFQC1Tiv/nreFZslh/ChFERcWkOYzuKPd2DPH7MdStVaHg0jTsX1rGlpRaj4Jek8l8EmTwuo39PTP2XSDJyhv6Ol0jFcrHKmhGgqvFGwo03YHjm53Kds4FMmGUmj5KbUymWtcViURKJqYsBWL58FXV1khtLKEXTtKwAMt24+bHKi1ZjJ3ofOfywXLuJ5seaqbDCzOc+XoFqop5ZhmGIkCVcNmi6BrrhJhSfJgoELFuVeF0VClUqK1QVeFgV2FRJvwkJWIq0R9g0CVgjiVdZEcooL05lkryPJGJ5Jy9cjTptzXCTTF8SQaso31VarOroOMWRw5+iawpDh2XLltLY0OB6bBV5YVldQzjxBEq3QbPRzArq7r0NPZBLBXD2yD7eee4HqBF+wHn4f/tzvP4KHEfx8jOHOHrA/TG5tiHI5756JcHw6N7YybNnaf+v/wk74gq+9Q89Qv39D47aZypwlMN75/fy1PEXGEzlFrZZV7+Gh1bcz8Jwy7TP4VKglML8bBfJd3+RTdhttK4jcMd30IM1l3ZywpxAxKU5SsS0+W/7T9ObNDHTSyzWGoo/3rCYhkDuizqZdH9tD4XKJ8irqAgWtMtnrL4TwUz0MtC5m/hgLoxKNyqobLqJysbr0WfwAjxfSaVSRCLDRCLDRKPD2bIb4jg8qRXKfD4/FRVBKioqsttAILN1XxUVFfj9AQmDE2YVrgeoD693ZsIKx1qdcLyhg6MLXxMLmFBKYZrmDIUV6heVtH18olfpGIYhYYXC/GdGBCyVEaXUKKJUXlhgcdig7bhCkz2KwHWxAtZ0ilflhKv8VQV9OprH3VKyAqGRLeNLC1wXESI4HYwkaCml+PTTj9i37yjg3qNt2bKNxYuXloyhbIfIC8fx9MSyNr3KT+XnVrseaGlOHXyf9174R9QIy9B/6U/+Et0wsG2HXU8d5MThHgDqm0I8+NVNVARHvx4nzpym/b/+J5you+pcwyNfpu7e+8bzMUyKI/3H+fWxZwqSdbeFF/LQyvtZW7dq2o9/qVCJCPFX/xf2mX2uQdPxXfcwvivvk9XbhHEj4tIcImk7fNQ7xGDKIp5I0Zt0HwxamhcAsMawCoQlgJ6ebsLhSioqynsCNTe3pNv1lNSN1fdiUI7F4IU3GbrwVtbtVtM8VDbdSFXTLeiemVkZZT7gOA7RaIShoQGGhoaKRKTIhMJ3fD4/wWAo/Qpmy/lCUiBQIYKRIIxBflihzzezYYVjeWYFAgaDg9EJCVoTDyt0SKVSwMRF7fEy0VUIxx9+6I6h67oIWcK8RdO0tIgyfcfICljFnleZsllqH62uuHxxk2FqhauMt1SeAIVXR/MZ6H4Dze9BC3jQ/AZ6phzwoPmMaROmHMfh/fff5vDhA4B7z3fnnXfT1FTqfeMkLYafOIxK5LxoPQvChLYvz84vMtDNRy//lCP79lAuDM/j9fHwH/5nNE3DthxefOIAp465q7s1toR54CubCFSM/geWOHWS9r/4zzjp9B2NX/4atTvuntD7Hy8XYt08cew5Pun5LGur9lXy4Ip7ubHlGnRt/gosVuchEq/8HSraD4AWrqfizj/AaJm/YpowPYi4NMtRStEZS/JB9xD7eodJOg5OOuSi0mtwW0stNzZV89GCVo4cOVzS/+jRw6xde8WI41dWVrJggn3HS3zoGP1nn8dK9WdtoborqV6wFY9vfsYqTwWJRCItIA0yOOhuh4YGGR4evKgHPcMwCIcrCYcrCYUqCYXChEKhPDEpNCNhSYIgTC0XG1bY2FhJ9wRyyUAmrLDYg2q0UMJy9YWJ30cStiYaVmjbdtqba3rzY7kCYnmBaiwhqzCEcGzPLAkrFOYjOQFr6n+wGlW4MsvbS4Wr9MqDeasTjtvbKjNm/OJDnLWM+OQ30AKetPiUsXnQA4XilOYb22PTsizefPNlzpw5BUAoFGbbtnupqaktaetEUwz96mCBzbeyloqbF6FpGrHhAQ7s2cmJ/e+MGAZXv3AZ27/6p+6xTZudvznAmRN9ADQtrOSBL2/CHxj9mhU/cZyOv/wvOHE3RUPj1x6ldttdo/aZDBEzyvMnd/F6xzs4aS8sn+5l+5KtbF98O35jej2eLyXKcUjtfZLUR09B+trrWXYdgdt+F80/dZErwuWDPFHOUjqjCV7rHeS9jj76k4UXKF3TqA94+ZebluJN33hu3Xonv/zlTzl9+hRLliwF4P3393DmzGm+/vXfGvVYk+k7GrYZob99J7GB3C8A3ooW6hbdhz/UNuFx5xumaTIw0Ed/fy/9/X309fUyODgwbg+kjHgUClWmV3OrLBCTAoGA/MouCMKkyCws4fVOoztDmsxqheMTrEZfyXAkr6xMeSIopbAsE2uEVZGmEl3XxxCoRva0urj2ElYozA+mS7gqWW3QdFAp2xWSUnkiVLY+Z8u2TdqjelapZLrNeNEoEaP0Sh9GfQVGXQWmH1599UW6utykzDU1dWzffi/BYKloYA8kGH6y8Idm/8YmAle3kErEOPjeSxzb9wa2PfL33vINN3H9jq8BYJo2Lzy+n/ZTAwC0tFVx/5c24vOPISwdPUrHX/1XnEQCgKZvfJOarXeO+yO5GCzH4vX2t3nu1G7ilitkaWjc2HItD664e94m687gRPpIvPJ32OfS/+6GF/9NX8N7xR1yPRAmjIhLs5DP+iP847FzBTYNWF0d5IbGao74PFR5PVlhCeDrX/8mL7zwLH/yJ/+Ur371UVKpFD/96Y9Ys+YKduzIxSd3dLSzf/8nbNiwidbWtovqezHEBg7Sd/ZZHMt1Z9V0H9UL7qCy8Xq0eexWOhaxWJSenu60kOSKScPDQ2P20zSNysoqqqqqqaqqSW/dckVFhVwEBEGYN+i6js/nw+ebifxYdlmvqskkeS9nc5yJ5cdyHAfHSU0qV954ccM5x+NxdXGJ3ovbS1ihMBcZ72qDY6EsB5W0cBKWKyYlLHc/r6wSNk7SSu/b7op/ZQfDbZOwYDBJ/rdMnCTvaocZxhVNmqoaue2GO6jwl6a6sLqjRJ47VmALXLcQY1UlB959gUMfvoyV94Nn85I1XDhdKERt2vI5rrh+OwBmyua5xz6l8+wgAAsX13DfFzfg9Y0u+MWOHKbjr/4ClUyCptH8W79D9W23j9pnIiil+Lh7P785/hw98d6sfXXNCh5e9QCLKlun/JizDevUR8Rf+1+QdPNZ6TULCWz/pxh1iy7xzIS5johLs5CknftVY0k4wIbaMOtrw9T4R/7FuLa2lr/+6+/x3//7X/AP//B3+P0BtmzZyj/7Z39ScIP+8ccf8f/+v/+ef/Nv/n9ZcWm8fceDY8Xpa3+BWP+nWVtF9Vpq2+7B46u6qLHmOqZp0tfXQ3d3Fz09F+jp6SYWi47ax+PxUFNTR01NHdXVrnhUXV1NOFwl4RGCIAhTSCa8zTBmarVCe0xPq7FErtHzak1NWOFE8vZdDJm8ZGN5Wo2e5L2coGWUhCaKkCXMNtzE4T700PjurzNhfiViVMJOC1Gu3UmLTM5wkiEV410OkcD1Mlqo6rh6cCmpnadJ6RpGTQCjzvVuchIWyU8uFBwzsHkBpyP7OfgPL5KM5+5bG1qXs+6GHbz+m78taH/T/b/D4jXXAJBMWDz32Kec73B/OG1bWss9j6zHO4YnWezgATr+x39DpVKusPQ736L6llvH9RldDKeHzvL40Wc4Pngya2sKNvDQivvZ2LBu3n9fKNskueeXmPtfytq8a2/Hf/PX0TyyqJIweTQ10buQWUxvbwRnJJV/DqCU4lwsyeKWaqzh6b3JA/j4431873t/zaFDB6isrGLLlq1861v/hJqamlH7dXZ28N3v/jc++uhDAG68/kq+cm8ToYB7MdONALWL7iNUu2G638KsIJlMcuHCOc6f7+TChXMMDPSNepMfDldSW1tPbW1ddltZWTXvL2xTzWTyyAjC5YScK5cHmbDCi03aPpbXVjnhay6QEaoyAtZIQlSmrrKyglTKGbGtrhtlBLGc0CU/BAmXku6uC+za9RxmOmx3RaCNdclWtHGm6hxemuCjw88SjwxkbTWNrWy69UFqm9p48u/+bUH7O770RzQtcpM+JxMWz/ziE7rOudeZJSvq2PHQejye0c+J6Gf76fzuX6FMEzSNlm99m6rNN4/zHY+P/sQATx5/gfcv7M3aQp4g9y27iy2tmzH0+b9gjTNwjvjuv8HpPeMavBUEbvsdvCtuvLQTm+fMt3svXdeorw+PWC/i0ixmJv4Y9+79gH/xL/6IcLiSRx75MoZh8Mtf/oyqqir+5m++T1VVeW+jwcEBvvWt38I0Tb74xS8R7T/Mr59+nca6IP/3v7yNcN1q6hY/iMdbOa3zv5RYlsX5853ZV19f6Yp7GYLBEA0NTTQ0NNHY2ERtbf20h3wUoyyH1JFerL44RqUfvdKHHvbllt41dPBo7r6uzRmRa759aQvCdCHnijCVuGGF4xWyRl/JcKwx3ETtc4PcipGF3ljFQlSpeDV628L9wn4iaLkopVDKQTkOjuOgHBvHsVGOg1I5W7Ze2Th2euu4/dw+Tt44eWM4Do4qGiPT3rHzjuEUHFcpla5XhXNRmePk1av84zgFNpVvyxvPyauPB5qwM/feSmEkejES/YSpoMqop8pTT6WnnnrvwpLP78OhnfSY7dn9ytomNtx8H4tWX0VkoIfn/r//p6D93d/8P6hpcMdJxE2e+cUndJ+PALBsVT13fWEdhjGGsPTpJ3T+9X9HWRboOgt+/59QecPUiR0JK8FLp19l99nX///svXeYJWWZv39X1cmhcw6Tcw7MwDAwDAxZREAFJAkCSkYMu/vVVdfd/anrqgRBMpJkkEVRchhyDsPknKdz7j45VdXvjzp9uk+f03E6z3tf17mq6n0rvNXdp6vqU8/zeYhqhiCuSAonlR3PWZPW4DA7Bu1Yo5no7g8JffA4xIygBTl/CvY11yNn5I/wyMY/4+3eqzdxSaTFHeXcccf/Issy9933SCJNbtWqk/n2ty/m8ccf4aabvp92u6ef/gsNDfU8cO/tuPX1xCIuyvOX8et7Pmb9nmy+8a1vjRlxoj/4fD6qqg5TWXmI2trqtDe8kiSRl1dAQUFRQkxKZ5443IQ21BLe3gBAn2xoZcmoRGKSQZE6RKiEECUjmaRO8zIo8X6TlBCs0olXiXWHqOyuQCAQCIaWDhFF4YiNaHpB1/VuPbBSUwfVJDErdblDvGpf7theTfhwHclY28c1XLRXjuxOiDLa0otY6baRZRlZMvw+JQkk9Pg0Po8UF2bahZeOeU2Nxaed2rQYeqK/yzS+jZ6uT40ZvmNd+9uPmSTuGOLK0Y6sNaG67SCbQJJQ7Xmo9jxaon48oUbkwH6m25ckiUsRLcQG7zpaY0Z6nMOdzdwVZzJpznJkWaGx+gBvPn170nGu/LffE4wYdh2hYJQXnt5MY50hLE2Zmcep587uVVjybdxAzX33GMKSolD83etwL102KD8HTdf4uPpzXjjwGt6IL9G+KH8+5009m3xH7qAcZ7SjR4KEPnic2N6PE22WhWdjWXYBkixkAMHgI/6qjmJqaqrZv38f5557fkJYApg4cRIrV57Iq6++2K249OabrzNv9iTs4XW03z4dc8wxlJdX8sGnO/nmJeNHNPB4Wjl4cD+HDu2npaU5pV+SJHJz8ykqKqGoqIT8/MJhqajUX+SMft78a7qRyz80wzGQpV7Eq7hQ1Vmk6iJU+doiRP3hJBErIW6NsSgsgUAgEKTSLp6YTEN/25qf76a+3pMkPHUVr7pWHewsYnUVr5JFr67iVse81k1p976g6zrRaJRodOgrGHYcVIuXLjemkq5hOEynW9aQOvWBhqR3sxxfT+q07/b20X4llyQZKV5Zs30+dSohSV3WaZ+XJGP7ztskbS+l3Z8sK4n9SrKMjoQ3GKHJG8QXMooB6GYnMbMTc4ZCSMvGRxCHyUrb1BCaU2e6tAZJlrFY7RRNnIViMu5jK/ds4sMXHk46z/Nv+A2uzByCDV6CgSgvPL2JpnrDm2na7HzWfHU2ci8vD30b1lN9359AVUFRKLnuRlyLlwzK72FH827+vudFqv21ibaJ7nIumH4O07ImD8oxxgJqw0GCb96L7jFEQ8megW31tZjK54/wyATjGSEuHcU0NNQDMHXqtJS+0tJy3n33berqaiksLErqa6zdQXV1FUvnxLeTFLJK1uDOP5aZM3fzyScfDvnYhxq/38f+/Xs5eHAfLS1NKf12u4PS0gmUlU2gqKhk2FPcBoJ1Zi6mAiexBj+aN4zmjaB5w6it4e4rkQw1mo4eMaK/BjqCQF9WSkRLdYmcap/vEoGVFJnVad104lViXRGFJRAIBOOCwRSzdF0nGg4SCngJBbyEAz6i4SDRSJBIKEg0HCQSNuYj4SDRqFEdUI3FiKkx1JjxkkdHAkk2QokwprokQ6d2Pd6edpn4+olt2tsH+kOSjVAmDK+artfwobiraI+kkiXjpZEsSchy+9QQbBS587yCrBhTRZGR45F2JqVz5Fa7cbwZJf47NylmFLMpsZ4hAClJgpAsKwmRx5iXRmU1ZI+nld27d7Jv3y7C4TBRXWWfVMs+ainMLmJG4VwmTZgUj0BMZs+G9/jy7WeT2r5+8+8wmY173mAgwgtrN9PUEBeW5hSw5pxZvQpL3i8+p+bB+0BVkUwmiq+/CdfCRUd8rjX+Op7b+xLbmnYm2rKtWZw79UyOKVyEPAp/P/1B1+JCbS9FKHRdJ7r1dcKfPgPxSqVK6VxsJ1+L7MgahpEKjmaEuHQUY7cb5UgDgdTHc4/HKB/a3NyUEJc0LUpbzdvs2vg6ANmZNiyOEnInfg2zzcjZzc3Nw+fz4fP5cLm6z8ccjaiqSkXFIfbu3UV1dUVKf3Z2DhMmTKasbCI5ObljMhpGybahZNvS9um6Hq80EkH1hNHaP94wqicCsX68VZVAcpiRO30khxnJqoCqo8c0UDWjJG9M7zSvQUxDV+PTWPK6qAO8XW3fN0NzwwuALCWLV72lEHYVqrpEZ6UTwlBEFJZAIBCMNjRNpbWhitb6KnxtjfjamvC3NhL0txEO+NC0gXtGSfFPv7aRJBSTGVkxBBNZMaGYzEbKm8mMohjzkiIhK2YkxYQkGyIKkgKyYggl8WVdB10CdAlN19F00NHRdYxlzfDf0jQNtfNUVVETlRKNCK0jsXrVIXHMIbyaJ9HZrL13k/ee1u2bt9ZgVzjMyMhi6YJlTGvIobK+gkPU0yQZ/i91jbXUvV+LzWZj6tSZzJgxG7fb8Frd+O4/2LX+raR9ffPW25HjIpTfG+b5tZtpjgtL0+cWcMpX+iAsffYpNQ/dD5qGZDJRctMtOOctOKJz9EZ8vHTgDT6s/hQtnhppVSycPvEUTik/EYsy+rIJ+ktk+1uEP3gcyZGF85v/H5I1vd2GFvISeuch1MObjAZJxrLs61gWnjUqxU/B+EOIS0cxkyZNwel08s47b3HZZVcmLmbhcJjPPvsEgEjECKcNeQ/SXPESsXATwbCRCJdVMI/CGd9J+mdltRqpV6FQcMyIS4FAgF27trF79w7C4VBSX2ZmFpMmTWXSpKlkZmaNzACHCUmSkOxmZLsZU0HyRUvXdfRgDM0TRvW2C0+RxHyK6KOD7o+i+qMk3VIrErLbiuK2IGdYEx/FbUVymHq9oWovyaurekIwynLbaWn0pghV7SKVMW+IVB2iVbtgpadZVxvYPaumG5FYUW1ob3lNMpKSJnKqW/GqIzIrWbzqFJklorAEAoGg3/jamtj8/j+pObCdWDQygD1ImK02LFY75vaPxYpitmIyWTBZrJjMFkxmC4rZgskUX463KyYLJnPyOorJjDyKK191NoHvmmLYfdpg+pTDnpc79n8ktAtjkcjQV2+Gng3hezN2T2cCL8UgurEeyRfDjZ3FuXPQ52dxoGIfhw8fJBaLEQqF2LZtE9u2baKoqBTNU0Xr4a0JUdOdXcBZV/4kcb8f8Ed49s/rE8LSjLmFnPyVmb0KS56PP6L2kQeNtEmzmZKbv49zztwB/6yiapS3Kz/gtYNvE1KN+3cJieNLlvOVyaeTaR0fRYVCn/yV6OZXANADreghX1pxKVazi9Cb96IHWgGQ3HnYT7kOpTA1Q0UgGCqEuHQUYzabueiiS3nkkQf45S//ncsvvwpNU3nwwXsJBoPGSlqIxgN/I9C6LbGdyZoHgCNzWg8q+Oh/OG1qamDHji0cPLg/yevAbLYwZco0pk2bSU5OnogUIS48xSOQTEXJoqGu6+iBKKrHSLPTPOGOyCdvJDnlTtXRWkNorSFSMMnIbgtKhhXZbUXOsBhV7TKsSHZT3E9AArOC1OkllC3fhUkZXDlH1zrEq+6irBL9anrxKjkKK524dSRRWEBYHd4orC5C1RGlEIooLIFAMA746MU/01J3OKlNkmQcGdm4MnOxu7OxOdzYHC6sDjc2RwZWh6tDTLJYj7poAlmW41YCw2Mn0F7VML1fVveiVe/eWt37cB1JdcMhM4Rvv9w2A+92v1ptbZUxkzMTk7eKsrKJnHjedxPX64AvwvNrN9HSZGQ9zJxfyOqzeheW2j58n7pHHzGEJYuF0ltuwzFr9oBORdd1vqzfxD/2vUJzqCXRPit7OhdMP4dSV/GA9jsaCb52J7FDGxLLck45cmZh0jq6rhHZ9CqRz5+N+5OBacoybCde2W2Ek0AwVAhx6Sjnyiuvwefz8uyzf2XdutcAWLnyRC751iXc/8B9hBpeIICRRiVJJjKLT6LUlQf8g3A49S1Oe5vTOXr/mTU01LNp0/qU1Le8vHxmzZrHhAmTh8U0dLwgSRKS04LstEBxF+FJaxeeklPsNE8YzddFeIppaC0htJb0wpOSYYmLTvFopwwrsttyRCH23Z6TLIFFQbIM3dtfXdc7UgS7RE7pMT1NlFVc3Oq6bk/ilqoPzE9ruKKwOhu5dydedY2y6mru3k1/Yh0RhSUQCIaIcCC5vPSU+ccz97gzcLizR2hEgq4kVzUcHgxBS+3W2L2rEJW83J/orI7lI0m9TItsxlYwnVXnX5Vo8vuMVLjWuLA0a0ERq8+a0euLorb33qXuiUcNYclqpfTWH+CYMXNAw9rfdoi/73mBA54OUbfIWcgF077CnJyZ4+qlle/pf02YcQOYpizHfuoNSevoIR/Bdx7sSINTTFhXXIJ59snj6mchGDuIJ+ijHFmWueWWH3LZZVdSUVFBfl4WTvkQDz70ELIskZtlhIg4suaQVXoaJksmksO4mWpsbEzZX2NjAy6XO+HnNJpobDREpaqqDlFJkiQmTpzM7Nnzyc8v7GFrwUCQZAnJZUF2WaAkOTxZ13Q0fyQlxS4hPHVWNWIaanMItTlVePJZFeMY7nbRKZ5y57Yi20bvvzhJkhIV74aSRBRWb+JVtIcoq8T26cQtvX9+XJ1RdXRVHdooLIm+VSHsLG6lRFl1SSFM2i4emSVu4gSCo47jzr6CD194JCEy7d/yEQe2fkzRxNmUTl9A0cRZODNyRniUguHGELSMtDXoZ6XeAaLrekKoCtd48H50EDWmoqGhTMlAnpzZRfDqEKmi0Qi71r+dZACflV/KsSvXJPbv94b559pNtDUbmQ2Ljy1nyqw8wqEYNnv3nkatb79F/V8eB0C22Sj9/g+xT5ve7/NrDDbz/L5XWF+/KdHmMjs5Z8rpHF+8HGUUp4L2F13X8D34naQ2y+KvYl329aQ2tX4/wXX3oPuMwkOSOx/7aTei5E0arqEKBCmM3icvwbDwxhuvkpubx/w5EynPrcXf+BptWpgde+qYXJ6JM6OM7NJTsbk7Sne63W6Ki0vZvXtXyv727NnFrAGGuQ4VHk8b69d/QkXFoUSbLMtMnz6LuXMXjRlvqPGGJEsobsNvidLkPl3T0XyRhNikxqOeNE8EzZ8sPGlhFcJB1KZg6jEsSlxoshiCgc2EdXYecg83QuONRBQWwxSFpSZHTqWmEKYRt3oSrzrvZyBRWDoQ1YYvCkvpo3iVLgpL6UbcahexZJFKKBCMJvJLp3LO1b/gwNZP2LPxPbwt9ei6Ts3B7dQc3A6AKyufgrJpZOWXkplfQlZeCRabY4RHLhhvtFc41Kp86B/U4tIMUcu+vATr7Pxut4uEAjz3p39LeiA87qwrmDj7mMSyzxvm+ac20dZi3GfNml/Ehk8r2PBpBZnZdr713WVpr00tb75Bw9q/ACDb7ZTe9iPsU6b267yCsSCvHXybtyveJ6Yb0Vkm2cQp5Sdy+sSTsZvSF6kZq+hqFN/D1ya12VZ9B/OsVR3r6DrRbW8S/mRtohqcadJSbKuvRrKI/y2CkUWIS0cxatTH2qceJBjw8qsfH4+iGBEUG7bWsWt/Mz/+wXUUzbw67QVj9epTeOaZpzh06CATJ04C4PPPP+Xw4UNccsnlw3ka3RIOh9m8+Ut27dqW8FSSZZlp02Yxf/4inE4hKo1WJFlCiae+dUVXtYTwpHoimAMx/IdbjWinrutGVNTGAGpjR0XEyO4mMr4xZ8gjho4mhjUKK6myoJ5GiOpjCmEPQtiAaI/CYhiisNJFTnURrFLELZOMpyFIJBDuVrxKbC9SCQWCPmMyW5i+eBXTFp1IU81BDm7/jIrdG4iEjOuOr7UBX2tD0jZ2VxZZeSU4s/JwZuQYn8wcnBm5WGwOISILBkR4dxPBTyqNlyqyhGNlOZYp3adoBv0enr//35PaTvr6DRRNnJVY7ioszZhbwM4ttYn+9vautKx7g4an48KSw0nZD36EbdLktOumQ9VUPqz+lJcOvIEv6k+0H1O4iHOnnEmuffxFBOphP77Hbkxqs5/1Q0zl8zvWiQQJvfdnYvs/MxokBeuxF2Kef7r4vyEYFUj6UBiWjDBNTT60gbzhHmXk57tpaPD2vmI/CfsraK1+i7DvMJ9trOKOh79gwex8li0spsVn5YXXNrJ48VL+93/vRFEUqqoq2bp1M/PmLaC0tAyAlpYWrrjiIhRF4eKLLyUSifDUU49TWlrOvfc+HDdrHBk0TWP37h1s2vRFki/U1KkzWLjwGBGpNAbQdR09rKIHomjxjx6MogVjRtW6YBQ9FEMLxvotBkg2ExnfmG08XAsEXdD1uN9UdymEXasQphW30kVxdRK8BhqFNVzInasISqk+VgNOIezYRkRhCUYrg3HvpWkarfWV1B3eRd3hXTTXVRANp38I74rJbMGRkYszIwe7KxO7MwOb0zADN6ZubM4MTObhSbcSjH50XSe8uZ7QxrjoY5Jxrp6EubT7amm+1gZeeuS/ktpOu+RH5BRNSCx3TYWbMjOP/buSLTG+ceUS8ouSj9Py1joannoSANnppOyH/4JtwsQ+n8u2pp08t/clagP1ifbJGRP5+vRzmJzZt/2MNTRvA/61P05qc1zwS5S8jvNVmyoIrrsbvc3wYZKcOdhPvUFUgxvlDNXz/EghyxK5ud0/SwtxaRQzVH+MNTvuJRrqeIv2ycYmXli3n5q6ZrKz8zj99DO5/PKrsNmMUNOXX36BX/3ql/zkJ7/g7LO/mtju8OGD3HXXH9i0aQNWq40VK1Zyww23kp09ckaWbW2tfPTRuzQ0dBjgFRYWc8wxK8jNzRuxcQk60DXdEIraRSN/x3xiORgdeDW1OJLNhBz3e5JdZiSbCcmkYJmcNaRG3QJBX+guCittCmEnoaqvKYRHFIU1HEgki1adzd27ViFMEa86VSHsRrwSUViCgTIU9166rhPwttDWWE1rQzWtjdV4mmrxtzURiw6sxL3JbE0ITcbUjdXhxmpzYrE5sNidxrzdWDZbbELQHYfouk7wsyoiO+O+O1YF55opmPK7T49qqa/k9Sd/m9R29lX/jju7ILHs9xkRS61xYal8cjYVB1qStrn0uuVkZCV7rCZ5LPVTWKry1fD3PS+ys2VPoi3Xls3Xpp7NkoIF4/bvV204SOC5/0hqc17ye2RXbmI5uvM9Qh8+AWoUAKV8PraTv4ts615AFIwOhLg0DhDiUs946z/F37IFq7McR9YcLM6yMf8PW9M0tm/fwqZNXyRKwLpcbpYuPY4JEyaN+fMbSyT8kjp/vPGpP4IeijHQvCHJoiDZTch2E5LNjGQ34c5zElA1o81uQo63i4dKwdFOchSWTnamneZ6b5rKgnoa8aqnKoTjJAqrhxTCnv2vOolbIgpr3DGcDwK6rhMJBfB7mgl4mvF7mvC3NeP3GJ+Qv41w0N/7jvqAJMtY4sKTITrFp0nzDiw2J2arHYvVhtlqx2yxIw9jpTVB39FVjcAHFUQPtgIgOc24TpuCktm9D1F95V7efuaupLZzv/tf2F2ZieWAL8I/125KVIUrKHZTX5P8nfjhL08jEEy2I2h9923qn3gMiKfC/fDH2OLWGT3RFvby4v7X+Ljmc/T4DaJNsXHmpFNYXbYSszJ+fTJjhzcSfPWOpDbXt+9BshpVt/VYmNAHTxDb/YHRKUlYlp6PZfE5SJKIwB8LHG3ikvBcOgpxFxyLu+DYkR7GoNHa2sJHH71DY2NHNNbs2fNYvHg5JpP4Ex8KtHAMrS2cLBz5wqjeCHog2n/xSJaQHWYkhxk5/pEcZmRnp2W7KW0qW06+G3Uc/dMWCAYLSZKMiCBFBitYsu0osdigHycpCkvVjzyFsMt+2sWtAYnSmo4eUSEyhF5Y0CmyKtWwPZFCqHQTmdXV3L2LeCWisMYvkiRhtTux2p3kFJanXUdTVcJBH0G/h3DAmzQNBbyE/R6CAS8hv6fH1Dtd0wgHvIQDXvp7xVRM5rjQFBecrDbMlvjUascSF6HMCUHKJgSqIUaPqvjfPkisxgeAnGnFddoUZGf3thSVezfz4fMPJbWdf8NvkgzmA/4Iz3cSltyZthRh6ZofnIDTZU0Sl1rfe6eTsOSg7Ae9C0sRNcpbFe/z+qG3CKvGvmRJ5oSSYzl78mm4LePbxiKy4x3C7z+a1Oa6+iEkxXh2UVurCb3xJ7SWSgAkewa2NddjKhldhZMEgs6IJ2/BmEXTNLZt28SmTesTht0ZGZkcf/xJFBQUjfDoxj6dK7apbWG0tpAx9YSN6KO+IoHsjKenOZNFo3YxSbKZxJt/gWCMIskSyAqSeYgrEmr6AMSr5CirJP+sNOLWgNNx2/fJgAMze6c9CquvKYRdhaou0VnphDAUEYU12pAVxfBe6hRZ0h2aqhIJB4gE/YRDASIhP+Ggn0jITyQU6HZejUV73K8ai6LGooT8ngGfR1eBypIkUqUKVsnrGe3yOCo3fyRooRj+dfsTVXKVfAfONZORrd0/1u3f8jGfv7E2qe2Cm/4Xs6XDu6tdWGqJC0uKScbbFkra5rs/PjFRAKidtg/eo/7xRwGjKlzZbT/CNmlSt2PRdZ31dRv5x75XaAm3Jtrn5s7igmlfochZ2O2244XwF88R+fKfSW2ua/+c+P8b3fsJofcfhajx81eKZ2Jbcz2yI2uYRyoQ9A8hLgmGlZ07d3DffX9k69bNyLLCokVLuOmmW5kwYVKP21VXV3H33XewYcN6AI45Zhnz588jFDIurJIkMWfOfBYuPEZEK/UTXdfRA1HU5hBqcxC1JZgQkfqa7iLZTMhuS4fHUed5p0W8cRcIBEdERxQWMISeabqudxs51d8UwiTxqos/1hFFYTGEAhakViHsVbzqiMxKEq/SRWG1by+uCUOCrCiG/5Kjfz4ssWgkITRFQgGi4SCRSIhoOEg0HJ8mloNEkpZDqLHUaq1dGRyBypIkPqUVqOJilCUlymp8CFSaL4Lvjf3GPRpgKnXjXD2px2qt2z97nS0fvJjU9o1bfo9i6kg3CwbiwlKn6rpqF9++6/51VYr43PbhB9Q99mfAEJZKb/sRtslTuh3L/rZD/G3PCxz0HE60lTiLuGDaOczOndHtduOJ0LuPEN31XmJZzirGeeGvAdDVKOGP1xLd/lai37LoHCzHnI80xv92BUcH4ilcMGwcPnyQm2/+HjabjSuvvAaAp5/+CzfccA2PPrqWvLz8tNu1tbVyyy3XEY1GueSSy6muruS1115h8+aNnHfeeeTk5HL88avJzy9Iu72gA13T0VpDhoDUHDQEpZYgeljtdVvJoiBnWlEybcY0w4rsthpm2UMYsSAQCATDhSRJYFaQhtjiQ9f0ND5WacSrHvo7i1bpxa0jicICwkOYSihLyZFTaYSqAaUQKl0is0QUVp8wmS1GlTr3wAqyaKraITZFDMEpEheiouFQoi2lv5Ng1Vv0FIAai6DGIkMgUNlT0v4sVrthhG51YLHZsVgdmK12TOaRq4asR1S8r+w17AcA84RMHCdN7FGs/fLtv7Fnw7uJZYvNwde+9/8lpSkGA1GeX7s5SVjqjNNt4fIbjkv5Pnk+/pC6Rx8GXUey2ij9/g+xT5madh9NwWb+ue8V1tdvSrS5zS7OmXI6K4qXoRwlwkngpd+iVm1PLCsTFuI48zYANE8DwXX3oDUeNDqtTuwnfxfThIUjMFKBYGAIcUkwbDzzzFqCwQD33PMAM2bMAmDp0mVce+23+etfn+LGG29Nu93TT/+FhoZ67rzzXioqDqDrhZx66qm8/PLL+P1BrrjiAhRF/CmnQwtGiTUEUBv8xrQp2GsFKclpRsmydYhImVbkTBuSVRE36gKBQDAISLIEFmVIK1fqup6oHphaWVBPE2XVTRXCbsSrhIA1EEN3LZ7mGNWGNgqrcwphd+JVF3+slsw2wqFolxTCVHEr0S+isJAVJeEdNVAMgao9MqprtFSIaDiQHE0VSY2qGg6BSlZMcdHJnhCg2oUnwxDdbghS7eKULT5vtWM6wop9qjecEJYAopUeAu8dwjIjF1OxK2nfuq7z8Ut/pmL3xkRbRm4xZ1z+r8hyR5RTS1OA1/+xneaG9MbxxWWZnHfZopT2hnffp/aRh+LCkpWy7/8Q+9RpKesFYyFeP/Q2b1W8T0wzLBVMsolTyk/k9IknU+mt5kfv/4KIGuG4omO4fM6F/f2xjAl0Xcf/9I/RvY2JNvOcU7CdcAUAsYMbCL7zIEQMgU8umIL91BuTKsYJBGMB8UQuGDaqq6vIyspKCEsAs2fPJTMzk3379na73Ztvvs7UqdPYsmU97cUN582bz6ZNm9mzZ48QluLouo7mjRCr9RGr9aE2BNB8PYSqy5IhIuXYULLtKDl25Gxbjzn7AoFAIBgbSJKUqHg3lCSisFIirtJEYXUXZZXYPp24pff6UqRbVB1dVfsVhRXqfZVkJNJGTqVUIewsbqVEWXVJO1Ti2yqdxLBxHollCFQurPaBmziraqxH8Sk53S9dfwhV7Vmg0tQYIb9nQOKUJMkJEcqYGhFRFpsDuzMDm9Pw1rI5M7A7M7A63ElCkJJjx358OeFt9WhthnVB9FAb0UNtyC4Llhk5WKblINkU3vrrXTRW709sWzRxFqsuuD7xN6RpOhs/reCLDw6idhPlOGNuIWu+Oiul3fPZJ9Q+9EBCWCq99QfYp09PWkfVVD6q+ZwX97+GL9ohXC0tWMhpE1ezt/UAv/vibmoD9Ym+fW0H+v0zHQvouobvwe8ktVmWfwPronPQtRjhz54luvnVRJ953ulYj70wYewtEIwlxF+tYNgoKyvniy8+o6WlhexsI/Ta42nD5/ORl5eXdpsDB/ZSXV3FwoUL0XUdSZKYP38x8+cv5ssvN/LJJx8O5ymMOjR/lFitl2iNISjp/m5uiiRQsm0oeU5M+Q6UXLsRjSTeuAoEAoHgCEhEYTFMUVhqcuRUqniVJjKrJ/Gq834GEoWlA1Ft6KOwoKP6o5JOiOowbm/vTwhc7W2mTtt2FrSStu+yvzEkaCmKCWUAnlOd6RCogkRCQSLhANFQwDBKDweJhoKGN1U47k0VMtoNr6oQPTmi6boW97ZKHyXUFUmSsDrc2J0ZcdEp0xChJmfi1NxYG03ItTGIF2AJfVlLaEMtjWo1ui+c2M+kOctZfsalid9lY52Pt1/eRWOdr9tjL1kxgWNPmpzS7v38M2ofvN8QliwWSm/9AY4ZM5PW2dG0m7/vfZFqf23HGDImsLhgPtW+Wn6//h6iWmphmG9MP7dPP5exhK7F8D10TVKbbfU1mGecgOZrJvTmvah1e4wOsx3bSd/BPGXZCIxUIBgchLgkGDYuueTbfPjh+/zHf/yUm2++DUmSuOeeOzCZTHzjGxclrRuNRtiw4XM++uh9AJxOJ9nZuaxceRI5OYYQlZubh8/nw+fz4XKN73Kl7ei6jtoYIFrhIVrpQWtJ/45Vsioo+U5MBQ5jmmsXvkgCgUAgGJMMZxRWbpaDxjrPkacQ9iCEDZj2SCyG2NS9M+3+WJ0rCiZFVKUTpjoLW50iuNIKW2mEshF88XUkApWuawk/qYQxersQFTKM0BNiVVyUioaDhIM+IqFUvyNd1xNRUi31lWmPaZIslFinUW6fg0vOBB3y5BLyMkoIqF7CuVEmrjoBSZJQYxrrPzrEhk8q0OJCamaOnbbmYNI+TzxtGvOWlqYcy7v+c2oevA90HdlioeSW25KEpRp/HX/f+yLbm3Yl2uwmOyXOQoKxEM/tfanbn93Ni65lVs70bvvHIno0hO/P1yW12c/8AaYJC4hVbiX01v3oIS8Acm459lNvQs4c/5XyBOMbIS4Jho2ioiIuv/wqbr/9t1x55bcAUBSF//qv/0mkyum6TkXFQT7//GP8fh/RqBGJM3nyVL7ylfOTwoOtVqN8aigUHNfikq7pxGq8RA+2Ea30oIdS3/ZgljEVujAVuTAXu5CzjyyvXyAQCASCow1JllCsJmT70Dm663rcb6on8UrVO6oNqp3a2gUsVe8Qstr7E/Od9hffzxEpUcPlj9WZ9lTDXqOwBiJsdUpL7CxsDYKgJUly3HfJAZn988pRY1FCAS9BXxshv4egPz71tRGMC0xBXxvhYHK0UUyPcDi0ncOh7WSa8imzzqLYOgVFMuFQ3DhawfPsdtQ8Bxtq2tjb4EcHJAkWLCtj02fJotVpX5vNtNmpBXJ8mzdS88B9oGlIZjOz//3/ES0xIpu8ER8vH3iDD6o/RdOTxdNQLMS+toOJZVmSMckmIqph22CSTVw3/8pxJyxpQQ/+J25JanOc93PkvEmEv3iOyJfP0/7FNM86CevxlyKZRs4sXiAYLIS4JBg2HnzwXh577GEWLVrCuedegKap/OMff+PnP/83/vu/f8ucOXP54ouPqa2tTmyTnW1cnMvLJyYJS8mMPxFF13VitX6iB1uIHmpLW81NybVjKsvAXOpGyXWIFDeBQCAQCEY5ktQRCYR1eI7Z2RerXXxKRFOpWnLKYY/CVryvq7CV2L5D2DoiJapTqmH74pAjcUTphf0RthL9coePlmIy48zIwZmR0+MwNVUlFPAQ9HkI+Q3hqaW+kv1bPqIt1kBbrIFdgU9YOvtr5EQKjQh3HZSGAMeYzMzOz6BG1ik9cSL/eHZr0r6/cuF8JkxJPb5/+zZq/nQ3qCqSyUTJTbeStXAB1XUtvFv5Ia8efJNgLH0kvR7/7eXasllZcizZtiz+svNZ45wlhWvnXc7s3Bn9/W2NajRPPf6n/yWpzXnhb8DqIPjK7zqqxZks2E74NuYZK0dglALB0CDEJcGw4PV6Wbv2CWbNmsOdd96LEi+BeuqpZ/Cd71zKf//3L7joogsT7RaLlSVLliFJJh599BHC4XDKPtvbnM6BVycZbWj+CJG9LUT2NqeaccsSphI35vIMzKUZyM4hrpU9zAS8rXzy8mME/Z54WWQritmMyWTFZLagxEslJ+bj7S05GQRCmtFu6ryONdHWvTApEAgEAsH4Zjh8sbqia3q3wlTC7L1XYSs1CitZ2EoWygbkmZUYMPHoMfplAH/ExEUoZAldluJT0CQJHdAk0ACV+FTXUXVjGtUUojEb4RYvRZbJqLqKrmSiWuezrUIhFmvFpumUmUwUW03IkoTTJDMN0D6o4MRsJ/sCYWrCMc67fDFFpRkpwwvs3kX13Xeix2KgKBRfdyOOOXP5pOJLHvvybzSFmrs9NVmSmZ87m5WlxzE7Zzr7Wg9yz6aHiWkxZEnm6nmXMi9v9hD9YEcGteEAged+mdTmvPR2NE89oRd/gx5oBUDOKsF26o0oOanphwLBWEaIS4JhobLyMJFIhFNPPT0hILW0NLNt2yby8/PYv38fra2t5OXlMXPmXBYuXILVasPrNXKRGxsbU/bZ2NiAy+XGbrcP67kMNrquE6v0EN7dRKzKm/yKTgJTiRvL5CzM5ZlDWrZ6pKmv2E1D1b4h2besmDoEK5O5k3hlwWTqLFy1C1Lmjv52scrUqT+p3YwkCfFKIBAIBIJ2JFkCWUEaxvdgutYp5bCLWNWzsJWcXpiIxooLW1qiAmIXIUvVkI5UhVJ1iPtotcefS0Df7yrM4FievquHLCtZkiizmSmzmdFtJtxpfDmD+/ZSdeft6JEISBLF115H05Q8Hvjy3qRUt65kW7NYWbKcFSXLyLJmArC/7RD3bn6EqBZFQuLKOd9iYf68Pp/lWCBWsYXgK79PanN9+x4iO94l8vmzEE8ZNE07DtuJVyKZbSMxTIFgSBHikmBYMJuNK1wsFmP//r3s3r2d+nqjioSuG1fmwsJizj77a2RlZSe2c7vdFBeXsnv3rpR97tmzi1mzxu4bDz2qEtnbQnhHA5o3OUpJzrZhnZ6DeXI2su3o+JqWTlvInGMbaK49hK+tiYC3GU1NTQccCJoaI6LG0hpmDgbtglXnaClTijDVnaDVWfRKFq8UU7t4JVIeBQKBQCDoCSke+SOZZKMASlQjHI5f/2OqMR9WiYRjRMIxYzmkdsyHY0QjqvGJGtNYtHcDdgVDrDFJoEiSEYwkGXFiSctJ86DQsdy+rSyBiTTrdtnvYN4XSKEYkb3NmAo6MgFChw5Sdcfv0cMhkCTcV1zK3+z7+PyL/0u/DyTm5s7ihNJjmZs7C7nTS7dDngru2fgwYTWChMQVcy5iaeHCQRv/aCC6+0NC7zyY1Oa89HaCbz+AeniT0SCbsB5/KebZq8V9nWDccnQ8tQpGFFWNYTLJZGRk8Ne//oVIJIDJZPzpxWIxDhw4SEZGJhdeeFmivTOrV5/CM888xaFDB5k4cRIAn3/+KYcPH+KSSy4fzlMZFLRQjPD2BiK7mtAjncQTs4xlcjaW6Tkoufaj7sJjtliZv/IriWVd1wj62vB7mvG3NeFva8LnaSYQnwa9LQlh8khRTGYUkwU1FkWNRXrfoAvGdlEI9q28cH+QJMkQmdqFKFPXFEFrGrGqd0GrvV9WTEfd35pAIBAIxg6aphMORQkFogQDUUJB4xMMxNuCxjQUjBIOxQiHDKFokG4RekXFSFOLAWazjNmiIJkVZLMCZhnZrCCbZBSzgskkGx+zgsncaT5pKmMydemPtykmmYaKXXz4/CPoMQ0ZhbnLTmfqvJVpUgg7vLb8bWG2fFqRJFLNmluAIklIioR1bn7ifMJVlVTe/ju0oFFFrvasZfxJfZtoXTTl3DMtGRxfsozjS5aTY8tO6a/0VnP3xocIqYYn0yWzvs7yoiVD8nsYKcIbXyLyWbLoZj/3pwT++d/oviYAJHc+9tNuRMmbNAIjFAiGD0kfrKezUURTky9RYnMsk5/vpqHBO9LDOCKamhpZt+4lwuEwBw4cYN26dWRnZzN37jxyc/PYsOFLDh8+xM9+9p+cfvpZVFVVsnXrZubNW0BpaRkALS0tXHHFRSiKwsUXX0okEuGppx6ntLSce+99GItlbFRX0EIxwtsaCO9sTCpFLLssWOfkYZmWg5QmLFmQHk1VCfhaMUsBqg5V4vc04W9rxucxhKiQ39Ov/SkmC87MHJzuHGxON1aHG5vDhdVuTCVZQY1FiUXDxKIR1GiEWCw+jUaIRcNp+xPz8XZNTVPtbwSRJLmTj1VyimBvnleKuSPaqjtBS1bE3/RoYTxcUwSCoUZ8T4aXcCiGpzWIzxPG7wvj90bwe+PzvghBf4RQcGium7IsYbEqWKymjo9Fwdz+MSuYOs13TOXkNosJs0VBUaQhf1lTuWcTH7/8aDyyW+KYUy9k6oKeDaFrqzw898SGpLbvfH8l1jSR8ZHaWip++ytUj3EP9cmxeXw6NTlJT0JiYdFslucfw7zc2Shy+ut8jb+OO768D1/UePF20YzzWFV2fF9PdUwQ+vAJotve7GiwOrEu+RrhT/8KmvEC2TRpKbaTvoNkHT8esYK+M96uKbIskZvbfZV2EbkkGFIaGuoSxtvTpk2jvHwiH330EZ9//hkAM2bM4n//9wccd5xxsdm0aQO/+tUv+clPfpEQl7Kzs7nnnge4664/8PDD92O12jjxxNXccMOtY0JY0iIq4S31KaKSku/AOrcAc3mGqPQ2AGRFwZWZS37+JKwZ5Sn9sWiEgLfFiHqKC09+TxO+NiMSKhJKjjJSYxE8TbV4mmrTHs9stccrueQaIlRmLhk5hTgzc3Fm5GK29K3sj6ZpqAnRKUwsGo0LU52FqPgnFkaN9k/Q0rT+pRLqukY0EiIaSV/p5UiRZSUpzS/Z28rSRbhKFrS6pgga25mFWbtAIBCMIXRdx9MaoqneR1O9n9bmAG0tITytQcKhIxOOTGYZu8OCzW7G5jBhs5mx2ExYrArWTqKRNd5msZoS7SazPKYid/dv/YQv3liLruvIssKxZ13OhJk9RwEd3t/MS89sSWq75ocnYE7zMjPSUE/l7/8nISy9v8jJl52EJbfFxYriZawsOZbZEyb2+MBcF2jgrg0PJISlr087Z1wJS7quE3ztjo6UN0DKKETJLSf88VPxBgXrsRdinn/6mPo7EwiOBBG5NIoZD0qnqqrs27cLq9VGSUk5ZvP4qnDWE7qqEdnVRGhzHXq444FfKXBgW1iEqdglLjaDwEC/J9FIKCE4GQKUITr54mJULJJaobAnrHZnXHiKfzIMAcqVmYvDnY1iGp6/fU1VOwlQYWKxaFzE6iJexcJJQpbaR0FL13v3nxhOkszazRZMXczYUwStdBFapi4RWOPUrH08XFMEgqFGfE8Gh7aWIAf3NlF5sIWaijaikb69+JAkcDgtON1WnC4LdqcFu8OMzWHGZjcb852mpqMk4nv3l++w4Z2/A0ak9cpzr6Z4Us++o3t31PPGP3cktX33RyeimFKva9HmJip++2ti8QI6H8938tl8I9JmVvZ0VpYey4K8OZhkIy6hp+9JY7CJ27+8j9ZwGwBfm3IWp086uR9nO7rRNY3A336O1lKZaJPc+SDL6G11xrIzB/upN6AUThupYQpGCePtmiIilwQjiqIozJgxZ6SHMazouk70cBuh9TVJRt1KvgPbIiEqjRbMFhtZ+SVk5Zek9Om6TiQUSBGe2tPuAm3NqGqy90A46Ccc9NNcdzjt8ezOTFxZeUyYfQyT5ywfMrFJVhQsih2sg19FUdd1NDWWFC0Vi0a6RF31JGh1idZKicSKQD8LQA+9WbslKVoqvedVd4JWd2bt1rjPlzBrFwgE44uWRj8fv72fQ/u6L1HvzrSRkWUjM9tORpaNjCw7rgwrTrcVh9OCLKK5k9j+6ets+fBFwIiiXnX+98grmdLzNhtrePfV3Ult3/uXVWl/trHWVip/99uEsGQ77RSicyROs+dyfMlyChx5fR5rS6iVOzc8kBCWzp582vgSlmIRfE/cAtFO0d4mK3qgFeL3hUrZPGynfA/Z5h6ZQQoEI4gQlwSCQUT1hAl+Ukmsxpdok90WbEtLME/IEA+SYwRJkrDanVjtTnIKJ6T067pOKOBNGI0nxCdPU7zSXQu6lhzhE/S3EfS30VC1j+2fvMbsZacyZf6KYYtoGgwMc3FDFLHYHIO+f13XE+boCfEpTfpfnwWtLumHAzNrN441lGbtqRFVndL/UlIH+y5oCbN2gUAwnAT8EZ57cmNSqpvTbaVsUhYFxRnkFTjJyXdisYrHj76g6zpbPnyRHZ+9AYDV7uKkb9xIdn5pj9tt+LSCT97en1g2mWWu+cEJaa8HMa+Hyj/8lmi9EXGTteY08i+8hGsGcO1oC3u5a8MDNIdaADh94smcPenUfu9ntKJHgvgevT61IxaPdJckLEvPx7L4nHEV9SwQ9Afx310gGAR0VSO8tYHQ5jqIp2RKVgXbwkIsM3KRFHGRGU9IkoTdmYHdmUFeyeSUfk3TCPpauwhPzdRX7iXgaSboa+XLt59l+2evM+uYNUxdsBKTefT7hw01kiQlBBKrffCNL3Vdi4tUXbytujFjH2qzdl3X49v2LwWzrySZtZutWG02kJRuPK/aBS1LNybuqYKW3I2Jq0AgODqpPtyaEJYcLgvnXLSAnDyHELkHgK5rbHjnOfZseBcwop9Xf+NGMnKLetzuk3f3s+HjisRyRpaNS763PO3vQPX7qfrD74hUVwOQuWo1+RdfMqDfly/q5+6ND1IfNKKfVpet5NwpZ46b370WaMP/5K3d9kv2DGynXIep9OjK1hAIuiLEJYHgCInV+wl8VIHW1vGAaJmZi21xEbJ4O3dUIsty3Pw7BzDEpkjIT8Dbyq71b3F453oAQn4PG999jh2fr2PpKd+kfMaiERz1+McQW6yYzH0zX+8vo92s3dfL+v2ls1l72vS/Lt5WXSOsUs3ak9uEWbtAMLbIL3IjyxKaphPwRfjk7f0sPq6c4vLMcSMyDAeapvHFuqc5sPUTAJwZOaz+xk24snpOT3v31d1s31iTWC4szeD8yxalF5aCQaru+D3hCiOVP2PFSgouu2JAv6dgLMQ9Gx+m2m8URDm+eDnfmH7uuPmda556/E//S7f9SvFMbGuuR3ZkDd+gBIJRinjyFRw11NRU881vntvjOnfddR9LlhyTtq+lpYV7772Ljz/+kHA4zOJFS/juqkvIbeqIOJGzbDhWlGEqEOVGxzu6rhEO+Aj6PYQCXkIBL2G/Nz4fb/N7CQe8hIM+eqqdEA542fLhi0JcGuPIsoxssWG22IZk/0dq1q7IKgF/cNDM2jVNRQsHiYaDQ3K+imI2qgd2ipbqyYz9aDZrFwhGA5nZdk4/fw5vvbiTSFjl8P5mDu9vJivXwdxFxcycX4jVNnZSwUcCTVX59NUnOLzrSwDc2QWs/saNONzZPW73xj+3s3dHQ2J50rRczvrGvPTHCIepvut2QgeM1DnXMcspvPI7SAMQ9MNqhHs3PcJhr2FufUzhIr4164JxIyypTYcJ/O3n3fZbFp2D5ZjzkUQkr0AAiGpxo5rx5i4/0gSDQd577+2U9nA4zB13/C9ZWdk8+uhaMjIyUtaJRCJcf/3VVFQc5qKLLsEWlnnmn39FQuKPF/wHbqcb28JCrHPyRQrcMDMU3xNNUwn5PQS8rQR9rQR8rQS9bfGpsRzytfU7kqQrsqxgdbiwOTOZuWQ1E2enFzYFgsGgp+/KaDRrH2qUrn5WXZa79bzqVIFQSdnOELKE39XYRdx7HTk+b5j1Hx1i5+ZaNLXje6+YZKbNymf2wmKKyoQPZVfUWJSPXvoz1fu2ApCZV8Lqr9+AzZl6X9qZF5/ZTMX+lsTyrPlFnPyVmWnX1SIRqu66neBOo4qcc9FiSq67EcnUv3iD/Hw31bXN3Lf5UXa27AFgQd5crpl3Gco4EVpi1TsJvvib9J1WJ/aTv4tpwsLhHZRgzDHerimiWpxAEMdut3PGGWentN955++JxWL84hf/nVZYAnj11ZfYtWsHv/vVHcyLlBCr8rLg7HJuevYX/PPAO1z/kx+hZAxNqo1g8ImGg/gSZtxGFbh24SjoayMU8PQYadQTsmLC5nAbH6cbq8ONzZGRWG7vszrcWGzCi0IwOji6zdoH/XR7MWu3JIlSAxG0ZFkR/zsEoxaX28pJZ8xg+YmT2Lmlju0bqvG0hlBjGru21rFrax2uDCvTZhcwfU4BuQXOo/7vORaN8MHzD1J3aBcAOYUTWHXB9T36D+q6znNPbKCuuuPBdf4xpZxw6rT068di1Nx7d0JYcsydR/H3bui3sAQQ01Qe3vaXhLA0O2cG35l36bgRlqIHviD0xt1p++SCKdhPvRHZlTvMoxIIRj9CXBIc1ezbt5e//e2vnHXWOSxcuLjb9date42S/GJmVWQSixkX8QmFZSyZt5j39n/GTUJYGlWoaoyApyVRvc2o6taIr60Zf1vjgMrWy4oJhysLuzsLuyvTmHdlYXdlGOJRXEgyW2xH/U2yQNAVYdY+uHQ1azfS/1LFq2RBy5wwa+9N0BJm7YLBwO6wsPjYchYtL6PqUCvbNlRzcE8Tmqbj84TZ+GkFGz+tIDPbzoQpOZRPyaZ0QhYm89H196eqMd77+700VO0DIK90CqvO+x5mq73bbXRd5+mHvqC1qeN+ZsnxEzh2VWqREYgLS/ffi3/LZgDsM2dRcsPNyOb+pylqusbdnz7KlsbtAEzNnMx351+BWR4fj5WR7W8T/uCxtH3meadhPfYiJGV8nKtAMNiIb4bgqOaBB+7BarVy7bU3dLtOrMHPrm3bWVI6F2KGJ4llWja2pSXMapvP5098gcfj6TbqSTB0hIN+ag7Wcnj/ATzNdXhb6vA01+Nva+xX5JHJbMHuzk6IR0lTVyYOdxYWm3izKhCMVo52s/bBRlaUXtL/kqOpukZjJYteyYKWMGs/+pAkibJJ2ZRNyibgj7B/ZwN7dtRTW+kBoK0lyJb1VWxZX4VikiksyaCo1PgUlmZgs49vn6aGyr0JYQkM36XKvZspn7E4bSVZXdd5/O5PCPg7IjaPPWkyS1ZMSLt/XdOofeQhfBuMYiK2qdMovfn7yNb+/7/UdI2ndv6Nj2u+AGCiu5zrF16FRRn7FW91XSey4XkiXzyX2mm2YTvpasxTlg3/wASCMYQQlwRHLXv37uHDD9/n4osvIy8vtQKHFo4R+rKWtm1V+MMBchxZyBkW7MeVYy42ck1zc42Q2Lq6WiEuDSHhoJ/WhipaG6rwNNfhaa7F21xHOOjv0/aSLONwZ+PKzMOZmYsrMxdn/OPKzBXCkUAg6JGRNms3Ugmj3Zq19yZo9dusXVXR1KE2a0/1vEoyYz8CQUv8Px+9OJwW5i0tZd7SUrxtIfbuqOfwvmZqqzxomo4a06g+3Er14dbENlk5dvKL3eQWuMjNd5JX4MLhGvtiRju5RRMpmTKX6v3bAGiuPcRntYfY8M7fmThrKVPmryC7oBwATdN5+PYPiEU7vtMnnDaN+UtL0+5b13Xqn3wc72dG5TnrxEmU3voDZFv//5fpus7f9rzAxzWfA1DiLOLGRVdjNw3N/8XhRNc1wh8+SXT7Wyl9cm459lNvQs4sHIGRCQRjCyEuCY5a/vGPZ1EUhW9846Kkdl3Xie5vJfhFNXooRjBqvBl2lubgPndmkmG31WpcUEOhobkBP9rQdQ1fa2NCSGqpN6ZBX2uv28qygis7n4zsQtw5Bbiy8nBmGOKR3Z0l0jwEAsGoRVYULIodekiDGSij0axdVaOoapRIqG8vCPqL0tXPytQpBdBs7t7bymylLSeDQFBLI3oJs/bBxp1pY/FxE1h83AQi4RiVB1upONhMbaWH5oaOv43W5iCtzUH2bKtPtNkdZnLynWTlOsjMtpOVYycrx4E704Ysj63fj9lq58Tzvoe3pZ79Wz/h4LZPCQW8RMNB9m76gL2bPiC7sJzJc49j3athoCOS6+SzZzJrQVG3+2567m+0vfcOAJbSMspu+xGKY2C+ei/sf413Kj8EoNhdwM0Lr8VpHnyPvuFG12KE1t1L7OD6lD7zrFVYj78MyTR+xEyBYCgR4pLgqCQcDvHaa6+wcuUqioqKE+2xWh/BL6pRmzrEIqXAuHCai1zdVoITN5oDI+T30FR7iKaagzTVHKK59lCvHiVmq52MnEIycorIyCmkbPIkdMWNMzNXCEgCgUDQhaPZrH0oAq9SzNrTpf+ZkgWrngStztsrZgvKUerlYrGamDIzjykzjUjySDhGXbWHuioPtdUemur8SWlgwUCUqkOtVB1qTdqPLEu4s2xkZdvJjAtOGVk2XBk2XBlWzKPYz8mdXcDCE89l/vFfoXr/VvZt+YjagzsBnZa6ClrqKsg2K0S0MsLaZE46ZyUz5nYfTdP82is0v/wiAOb8fENYcnVf5akn1h1+l9cOGVE9ubZsfr76+2j+sf+3qkfDBF/5PWrt7pQ+2+prMM84YQRGJRCMXcb+fwWBYAB8+eUXBIMBTj55DQBqS5DghlpiFZ7EOpLNhH1ZCaYCE9wO4XCq6BEOG1FNDsfgG9SON3Rdo62ploaKvTRU76e55iB+T3MPW0i4s/PJKigjK7+E7PwysvJLsTmTyxePtxKfAoFAMJYQZu2DiyTLqWbsncSrIxW0xspLGIvVRPnkHMon5yTaAv4IzQ1+Gut8NDX4aWn009ocJBrp8CzTNJ225iBtzUHYl7pfm92MK8OKO9MQm9xx0cmdacWVYcPuGPm0SllRKJu+kLLpC/F7mtm3+WO2fvoeihREklSsyiGsyiH2fbELwiuYOHtZynev7YP3aPy/vwKgZGZR+oMfY8rKGtB4Pq7+nOf2vgRApsXNzYu+S64jmwb/2L730kM+Ai/8Cq2lOqldcuZgP+s2lJzyERqZQDB2EeKS4Kjk448/xGKxsHzGEnxvHiBW2SEqoUhY5+Zjm1eAZFawAC6Xm6amxpT9NDYabXl5+cM08rGDrut4mmqpr9xDfcUeGir3duuRJEkSGbnF5BZPIqewnKz8MjLzitMaWQoEAoHg6GG4zdrdbjMNdS0jZ9auDb1Zu8lkNaoHtntbpfO8ShG00lQg7CJoKSbzkJq1O5wWHE4LZZOyE226rhMMRGltDhiiUouRQtfWEqStOYCqJqdshoJRQsEojXW+tMdQTDIutxWn24LTZcXhMqZOtyUx73BZhi0CymrP5MMPXMBZmKVarMpBLEoN6Dqepho2vPN3Nr3/PGXTFjJl/goKyqfj+3I9dY/9GQDZ4aDsth9iyS8Y0PE3NmzlLzufBcBusnPjomvId+QO1umNGJqvicBz/4kebEtqN01cjO3k7yJZBj9FWSA4GhDikuCoQ4+qbP7iS6YVTEZ/p4bEO0sJLFOysS0uQnYmixozZsxk9+6dKfvavXsXZWXlwsw7TjQSou7wbmoObKfmwDaCvra069kcbnKLJyU+2YUTMFuG5sFBIBAIBILu6GrWnpfvRleyBm3/o9GsPaIGYGgCr7o1azeErE7pfyYzimJCUUzI8Xk5XZtiMkQrxYRiMqEo5kSbYjL620WnkvKspLHouo7PE8bbFsLrCePzhPC2xaeeML62ELFY8s9PjWmGMNXSc06lxWoyBCdnqvjkdFlwxKeKaeBiWzSi8tAfPogvSUT1Ys78xhnk5skc3P4Z+7d8jK+tEU2NcXjXeg7vWo/DkUHWoUZyZLAoFkpv/QHWsoFF4Oxs3sOft/4FHR2LbOaGhd+h1FXc+4ajHLWlmsD//SSl3XrcxZjnnzHikWsCwVhGiEuCowJd1YjV+IgeaiOwv5GDlYc4c9Yqo1OWsEzNxjqvACUjvcBx0kmncPvtv+Xzzz9l2bJjATh06CDr13/GZZddOUxnMToJ+j1U7tlE1d5NNFTuS/uW1uZwk18+nYKyaRSUT8edXSAu3gKBQCAY9wiz9qFHkuRk8clk6lasspjM5GeaKMwx2jVdRlUlolGIRnQiEZ1wGCJhnXBYJxRU0TQZUNCJT3WZWFimNazQ2tjeLgOp9zU2uykhNDndVpxuayIyyhVfttpSTeIj4RgP3/5hUtt5ly6iuDwTgNnLT2PWsjXUV+xl/5aPqNy7CU1VCQQ8BPItVOeZKSqcjEuOYNW0fkeUHfJU8MCWx4jpKoqkcO38K5iSObFf+xiNqPX7CPzjv1LaHef+FKVo+giMSCAYXwhxSTCu0VWN4PoaInubIV62tcHTSEyLUZCdj3V+AdaZuUmRSs3NTXz++adMnTqdadOMC81Xv3oef//7M/zsZ//Kt751OTabjbVrnyQ/v4ALL/zWiJzbSBLwtlK5dxOVuzfSULWfrjefimImv3waxZPmUDRxJu6cQiEmCQQCgUAwiIxls3Y1FkNTY/1OG0w/Ti1h4j6YmACXAvQxA07X5Q4Bqn0alYm1KLS2yLR2Eaja15NkBbPFgsViwWIz0gtrq3xY5I51j18zA1mvo7G6CVkxx4U0E+7sApac8k1mzVjOtsf/RJNDJ2RVQJKorT9I7XP34XBnM3necUyZdxwOd3aP5wBQ66/jnk0PE1YjSEh8e87FzMmdOdAf46ghVrGF4Cu/T2l3Xn4Xsl1kIAgEg4EQlwTjGrUxQGRHJ68kWSKQaQghOcdNwb4kNbz34MED/Nd//Zyrrro2IS5ZLBbuvPNe/vjH23nqqceRZYXFi5dy003fJzMzazhOZcSJRcNU7N7IgW2f0lC5N6Xf7sqidOp8iifPoaB8uvBLEggEAoFgDDPUZu1geF5paiwRgaV2mk/XpqoxtFgMVY3GpzE0NYraPp9YP5oQsNLuI+kYMfoboZUOSdKQ0IBOJvF9fa8WhVgUYvGAL2eXJ7Qt733S+z6yZdBTzyPgbWHbx6+w/ZNXKZu+kGWnX9qtFUFTsIU/bnwIfzQAwMUzz2dp4cI+nsToJbLjHcLvP5rS7rrmYaQxYnIvEIwFJF1P819ojNPU5EPTxv5piSpYR46uagQ/q0KPapjLMzCXZSCN4jK0ow1d12ms3s+BrZ9SsXtDSnUchzub8hmLKZu+kNziiUjS0Bl5dof4nggEfUN8VwSC3hHfk6MPXdfRNDVFcEonYCULVL0IWO376LK/aCRiRHbFjGVNi6FrKtA//6yBcuJ536NkytyUdk/Ey+3r76U+aLyUPXfKmZwx6ZS0+xhL35PQB48T3f5WUpuUWYjzwl+PyH2r4OhiLH1X+oIsS+TmurrtF5FLgnGNpMg4VohSov0lFo1waMcX7Nn4Hm2NySVarQ43E2ctZcLMpeQUTRDpbgKBQCAQCMYskiQlvJnajd2Hm4A/wvNPbaSlyYeESmGJkzXnTAe0bqO4YgE/ja+8SLSlGU2WsE6fjm3WbKO/myguR0YOhRNmpBw/GAtyz8aHE8LSmvJVnD7x5GH+KQwuuq7jf/pf0L0NSe2miYuxnX6zEJYEgiFAiEsCgSCB39PM3o3vs3/Lx0TCgUS7JMuUTJ7H5LnLKZ48F1kR0V8CgUAgEAgER0rAF+GfazfR2hQEFGbML2H1WTOR5e5f3mnhMFV3/J6s/XUAZJywisJvXzWgF34RNcq9mx6l0me8TFxRvIzzp31lzL889D/1Q3R/c1KbedYqrCdeKYQlgWCIEOKSQCDA01TL9s9e5/DO9XTOlLW7Mpm26ESmzFuBzeEewRGOPXRdH/M3ZgKBQCAQCIYOvy/M82s309pkvNCbvbCIk86c0eP9gx6LUXP/nwju2Q2AZDIhWyxE6+uwFBb16/iqpvLw1ifZ13YAgIX58/jWzAvG/P2LrsVShaXZJ2M94XIhLAkEQ4gQlwSCo5iW+kq2f/o6lXs20dnMMq90CjMWn0Tp1AUiSmkAVBxo5o1/7iAaUTFblI6Pucu0a3sf+mRFGvM3fQKBQCAQHO34fWGef2oTrc1BAGYvLOakM6f3LCxpGrV/fgj/5k0dbbEYrW+tQ49FKbziqj4fX9M1ntjxDFubdgAwI3saV835Fso4MLjWA56kZfOcU7CuvFzcPwkEQ4wQlwSCo5CW+kq2fvQS1fu3dWqVKJ+xkFnLTiOnUPhUHQm1VR7CIaNaTDgUS8wPBrIspQhPpk4ClCXebkojaFmsndbttI0iBCuBQCAQCIYNvzfMP9duoi0uLM1ZVMyqM3oRlnSd+rV/wftp+spxtilT+3x8Xdd5ds8LfF63AYCJ7nK+N/8KzIq5H2cxOtF8TQRe/J/EsnnOGqwrLxP3OQLBMCDEJYHgKMLb0sDWj17m8K71iTZJkpk4+xhmLz+NjJzCERzd+GHR8nKsNhMtjQG8bSG8njC+thCx2JFXgtE0fUgEK1NK9JTcSYAydVnuPcJKMcniRk4gEAgEgi74vEbEUltLXFhaXMyq03sWlgCanv8HbW+/mbbPdcwyMk9Y1ecxvHxwHe9WfghAkaOAGxZ+B5tpZMzMBxPN10Tghd8kTLzNc9dgPV4ISwLBcCHEJYHgKCDo97Dtk1fZv+UjdM0QOCRZZvLc45i9/DRcmbkjPMLxhdmisOCYsqQ2XdcJBaN428J420L4PCG8bWFj6jHaBlMw6g+aphMJx4iEB+/4kkS/0wFN7ZFXXfrahS+TEKwEAoFAMIbxecI8v7ZDWJq7uIQTT5/W67WtZd3rNL/wz7R9rqXHUHLdjX0ewzsVH/LygTcAyLZmcdOia3BZnH3efrSSIizNOw3rikvEfYNAMIwIcUkgGMfEohF2f/k22z99AzUWSbRPmLmEecd/BXd2/giO7uhCkiTsDgt2h4WC4vTm6JFwDJ8njLez8NQWSrT5vZG02/WGySxjtZnJzLKRne8kJ8+ByaQQjapEI50+0S7Tru0Rtc/H1HWIhFUi4b5v0xsJwao97a9LOmBq9FUfBC2zEKwEAoFAMPT4PCH++dQmPK0hAOYtKeGE03oXljwffUjD00+l7XMtWUrJ9Tf1eQyf1X7J/+0xRCqX2cnNi68l25bV5+1HK5q3kcCL/yOEJYFghBHikkAwSmhpaeGBB+7hgw/eIxwOM2PGTK677mbmzZvf43bV1VXcffcdbNhgpLodf/wJ3Hjj9/E3HmLje/8k4OmollE0cRYLTvwq2QXCU2k0YrGayMk3kZOf/g2iqmr4vUaUk7fNEJx87dO4AKWpesp2sahGLBrG7w1TXdEGgDvTRmFpBoXFbkomZJFf6EIx9VxBRdd1YjGtW+EpGlWJRVQiXdpjneYjndZrX0dPHXI3xx98wQr6H2HVW58QrAQCgUDQma7C0vylpaw8dWqv1wrfxg3UPvpw2j7X4qWU3HBzn8ewtXEHT+x4BgCbYuOmRddQ6Bj7Lxk1b0NcWGoEwDz/DKzHXSyuwwLBCCDEJYFgFBAI+LnppmtpbGzgwgsvwe3O4O9/f4Zbb72OBx98jClTpqXdrq2tlVtuuY5oNMqll16Bqqo89ZfH2LT+Yy44YSaKbIgFmXklLF59PoUTZg7naQkGGUWRyciyk5FlT9uv6zoBfyQp6qnd76mtNZQodQzEBaoQe7fXAyArEnkFLgpLMigocVNUmoE705Z0cyZJkiGgmBUYpAh6XddRY1qP0VJ97us031fBCuh3VFZf6CpWmSwyFospWYTq5GPV3mcyyymilcViEoKVQCAQjFG8bSGeX9t/YSmwayc1990DWqpfo3PRYkpu7LuwtL/tIA9tfQJN1zDLJq5feBXl7tL+ncgoRPM2GKlwviZACEsCwUgjxCWBYBTw5JOPcfjwIf74x/tZtGgJAGvWnMaFF36Nv/zlcX72s/9Mu93TT/+FhoZ6HnvsaYoK8tjy4UucumQy//xgGzsONbBk9hTmr/wKU+avQB4HpWUFPSNJEk6XFafLCqUZKf2RcIz6Gi911R7qqr3UV3sIBqIAaKpOfY2X+hovxP3ebXYzhSXuhOBUUJyB1Ta4lw1JMszETWYFu2Nw9qnrOqqqx0WjWBfhqV3IinURpToLXLEuy0bbgAQr/+CcE5BWeOo24irNOrGwhs8fSuoTN+ACgUAwdHjbjIglb1tcWDqmlJVreheWwpUVVN99J3os1QvRuWgxpTfd2ucx1PrruG/To0S1GLIkc/W8y5iWNbl/JzIK0TwNBF7sJCwtOBPrsReJ65pAMIIIcUkgGGF0XeeVV15kxYoTEsISQG5uHjfe+H1Mpu6/pm+++TqLFi0h3HyQl1+6j2g4yISCTLLddqraYvzsOz/DYhukJ3bBmMdiNVE2KZuySdmA8bfnbQtTV+2hvtpDXbWHhjpfIrUuFIxyaF8zh/Z1pFZm5zoSYlNhSQY5+U5keXTdyEmShMkkYTLJ2B2DU1ZZ13U0VTfS+jqJVelS/qKR5LS/9r5YGk8rTeu7YmWkN2oEiQ7KOUFcsDrCdECTucOI3WRWRt3fg0AgEIwEnlYjYqldWFqwrJTjT+ldWIo2NVF5x+/RgsGUPueChf0SllrDbdy98WH8MSNy+ZKZX2d+3px+nMXoRPPUGxFLfuP+xLzgLKzHXiiEJYFghBHikkAwwtTUVNPQUM8ll1wBGA+xwWAQh8PBBRd8s9vtPB4P1dVVTMxzsPGd5xLtRZNms2CxmfVfrhfCkqBHJEkiI8tGRpaN6XMKAMPXqaneR12Vl7oaD3VVnkQoP0BLU4CWpgA7t9QChjiRX2QITe1RTk63dUTOZyiRJAnFJGEfRMEKjJ93v9MBe0kTTOe71R0JwSowiIKVSU4yXO8sPPUqVnXTLgQrgUAwltB1nVf+tjUhLBUUu1l+4uRexQ/V56Pqjt+jtram9DnnL6D0ltv6PIZANMg9Gx+mJWzs66tTzmRFybI+bz9a6SosWRaejWX5N4WwJBCMAoS4JBCMMJWVFQBkZ2dzzz138vzzf8fv91NaWsbNN/+AE05YlbKNt6WB1/5mGDyaMUKmXVn5LF59PsWT57K56g58vnfx+Xy4XK7hOxnBmEdRZAqKMygozmA+hh9DMBClPi40tafVtZtqx6IaNRVt1MSNwgGcbmtCaJo6Kx93pm1EzmUsoCgyil3GZh8iwaqT8OSwW2hs9KUVq2K9RF+p/RGsYhqxmEZoECOsFJPcB0FKxmwxdYm4kjttk9wnBCuBQDCURMMdKW31NV4eu/tjps8pYM6iYvIKXSliiBaJUHX3nURqqlP25Zg3n9Jbf9D3Y6tR7t/yKNV+40XQqtLjOWPiyQM8k9GD1lZnmHe3C0uLvoJl2TeEsCQQjBKEuCQQjDBerxeAhx66D5PJxK23/ghZllm79gl+8pMf8fvf/5Fly44FIOT3sO2T19i35UOqG4yHeYvFwoITz2XG4pNQTMYDqtVqRI6EQkEhLgkGjK7rRMIxgoEIiiKTnefEZjeTX+SmtsoQlNL5EPm9YfbvCrN/VyNffnyYb9+8AkXpuRKdYPDoTrDKz3eT0+Ad0D5VVUtKAew25a+zh1W7f1VCxEoWvdRYqkltt8ePaagxjVBwEAUrReoQp6ymDiEqYbhuzFs6CVqmLoJW1z7xdy4QCMCIdj3v8sVsXV/Fzi21BP1RohGV7Rtr2L6xhrwCF7MXFjF9bgFWmxld06h98H5Ce/ek7Msxdx5l3/9hn4+t6RqPbl/L3tYDACzKn883Z5w75gUYra02Liy1AGBZdA6WZV8f8+clEIwnhLgkEIww0WgEAJ/Py1NP/Z2MDMOIeeXKVVx00Xncf/89LFq4kF1fvMWu9W8Ri68PxlP9ghO/yuxlp3azd3HBFaQSi2kE/REC/ggBX5dpl/n+pFilw+m2ihu/cYCiyCiKjNU2uBFWsXbBaRDSAWMRlVh/BCtVRw3GCAVjQHhQzklWpL57V/XR00oIVgLB2MTltnLc6iksO3ESh/c1s2NTDYf3N6Pr0Fjv4/039vLR2/uZMjOPovrNmDesT7lrc8ydR9ltP+rzMXVd5/92/5ONDVsBmJ41hSvnXIwsje3/I1pbrZEKF2gFwLL4q1iOuUDcXwgEo4xRJS7pus5jjz3G2rVrqampYdKkSVx77bV89atfHemhCQRDht1ulJVfterkhLAE4Ha7WXHcCl5/4zX+/qd/By2S6CucOJNpKxfw7Lu3oacRkMJh40HJ6RykevGCMUM0ouLzhvF5Qvg84fh8GL/XmA/4IoRDqdVn+oMkgdVuxm43Y3OYsTvi08SyxWizm8nOc4j0I0FaOgSrwbsV0TT9yA3Xu/T1R7DSVJ2wGjvi71hnZFnqlz9VX/pkRRIPZQLBMKEoMpNn5DF5Rh4+b5hdm2vZsbkWb1sINaaxZ1s9eyjCPuECSj27KfLuxaqGcMye2y9hCeC1Q2/xXtXHAJQ4i/ju/G9jVgbvpcBIYFSF+22HsLTkXCxLzxf/wwSCUcioEpfuv/9+7rrrLm6++WYWLVrEe++9x49+9CMUReHss88e6eEJBENCXp5hpJydnZNo87bUs3fTBzQd3oau6/gDPpw2C9kFZSw48VyKJs5KpNM1Njam7LOxsQGXy50QrgTjA13XCQaieFqDeFrj4pEnWUg6kodam92Mw2XB4Yx/XGYcTmu8zYzDacHmsGC1mYRgJBiVyLKE1WYadMEqXaW/AUVcJUSvfghWmk44NPiClcmsYLF2SgPsIkBZ2lMDUwStuLdVSoSVEKwEgt5wua0sXTmRJcdPoOpQK5vWbaGiIYYuKQQtmezNW8a+3KUUyq0sOW8Vmqb3+Xr7cfXnvLD/NQCyrVncuOhqHOaxfR+o+ZoIvNTJY0kISwLBqGbUiEvRaJRHHnmEb33rW1x//fUArFixgq1bt/Lkk08KcUkwbpkyZSoWi4X9+/dyaOd69m/5iPoKI+e+1RtAkWVKyicz99gzKJu+ACke2ux2uykuLmX37l0p+9yzZxezZs0e1vMQDA6qquFtC+FpDSVEJE9LkLb4cn8eStuxO8y4Mqy43FYcbmsn8ahDSLI7zSL9RiBIgyxLWKwmLNYhEKz6KE7FIhqRSCxZoIpoiflIJNZvwSoSjhEJD55gJUl0GKd3FqKOIMJKMcniIVIwLpEkiWxfBdM/e5SJmKl1T6U6YwZ+aza6JFOr5/Dy/23F6bYya34hsxYUk5HVfXGMHU27eWrX3wBwmhzctOhqsqyZw3U6Q4IWaDUilrzGS1TLwrOFsCQQjHJGjbikKApPPPEEWVlZSe1ms5lAIDAygxIIhphYNExT5W5mTZnAhx++R7m1jdwMBwBt/hAHa1s4dvlyzrjsX9JeTFevPoVnnnmKQ4cOMnHiJAA+//xTDh8+xCWXXD6cpyLoJ+FQlJbGAC1Nxqc1PvW2hdKaZHeHxWrCnWHFlWHFGReQXBm2+NSK023FZBKikUAwmhgKwUrX9bQeVu3CU68iVjfzfT8+RMJqopLkYNAhWPU9HTBhxG5N7muPzDIJwUowCggdPED1vfeApmEhzIS27ZS3bSc4aQEtS77C3h31xKIafm+Y9R8dZv1HhymfnM3shcVMmpaL0um6Xumt5qGtT6DpGibZxPcWXEmRs3AEz+7I0YIegi/+Ft1TB4B53mlYln9TfHcFglHOqBGXZFlm5syZgHGD1NTUxN///nc++ugj/vM//3OERycQDD41B3fw0QuPEIuGWTwxgz0HFJ57fytLZk4kr3giH3yxC5vdya23/RuSJFFVVcnWrZuZN28BpaVlAFxyyRW8+upL3Hrr9Vx88aVEIhGeeupxZs6czemni2i/0UAkHKO5wU9jvY+mBj+tcUEpGOhb1StFkXBn2cnIspGZZcedZSMzy0ZGlh13pg2zRRniMxAIBGMBSerwZhosEoJVXwSpqEo03HM6YPun78cfQsGqkxDVWZzKyLAR07T+CVpmIVgJ+k6kvp6qO29HDycXErDkFzDz338AwMo1U9m7o4Edm2qorzFsECoOtFBxoAWb3czMeYXMWliE5Ipy7+Y/E1LDSEh8e87FTM2aNNynNKjoIR/Bl/4XrbUaAPOs1VhXXCK+YwLBGGDUiEudef3117nlllsAWL16Neeee+4Ij0ggGHxqD+4gFjVuLHKyMrjlqot4+/MdbNq5G31fLQsXLuaGG25NCEmbNm3gV7/6JT/5yS8SbdnZ2dxzzwPcddcfePjh+7FabZx44mpuuOFWLBbLiJ3b0YrPG6axzkdTnc8Qk+r9tLUEe91OliUyc+xk5zrIynGQmW2ISRlZdpxui7ihEggEI0KSYDVI9SF0XScW05IM1yNdhKvOhuvtfd0ZrrfP9zXicygEK+h/hFVvfUKwGp/EPB6qbv8dqteT1C47nUz+9W8TyxariTmLipmzqJjGOh87N9eya2sdkXCMUDDKps8r2fR5JdEMH+S6kXJ8nDfzTJYULBjuUxpU9EiAwMu/Q2uuAMA0YyXWE68Q3wWBYIwg6Xp/EjCGh4qKCmpra9m1axd33nkns2fP5rHHHhP/WATjilDAx471H5KVW0D59LmYzEIMGktEwjGqK1qpOhz/HGrB6+m5nLnFaiKv0EVegfHJL3SRV+giO8eBLPyOBAKBYEC0C1aGj5SRChgJxYhEVKOtfdq5P2leJRoxTNM7rzuid8gSWCwKFosJi9WYmq3GvNVqSrSbrSZjvfjUajNh7rSNxdreZ/RLohjDiKEGg2z92X/g27M3uUOSOP65/+v1OScaVdm5pZYNnx7m4N6m5F2YdBYfM5Elx02guCxzTD4zaeEgNWv/i3CV4SXqnLOSgq/diiSLCG2BYKwwKsWlzvzjH//gX//1X1m7di1Llizp0zZNTT40bVSfVp/Iz3fT0OAd6WEIBKOa4fqeBHwRqitaqa5oo7aijeZGf48PHu4MK7kFLnLbxaRCJ+5M25i84ROMD8Q1RSDonfbvia7rqKreKZ0v1iliSuuSDtjel5xCGIt2icqKjLBgBZjMcs+RVP2MsDJbFHFd6wORhnpqH7yf0P59KX3TH/xzv36Guq7z+Bd/59D2VrIayzBHk42+cwuczF5YzIy5BVht5iMeezoG+3qix8IEX/kDao0hLJkmLcV26vVI8qhMshEI+sx4u/eSZYncXFe3/aPmG9va2so777zDihUrKCzsMKGbM2cOAPX19SM1NIFAcBQSDESpPNhC1aEWqivaaGvuPr3NlWGloNhNYUkG+UVu8gqdQ3ZDJxAIBIKhR5IkTCYJk0nG7hic/+e6rqOpep9S/iKR5PTAnnys+vNCNRbViEU1gvTN968vmMxyvwzXLWn62g3XLfF5eZxEWOm6juejD6h/6i/o4VBKf3+FJYBXD77JZ95PoRxsswKcmflN9m5p4PD+ZnQdmur9fPDGXj5+ax9TZuUze0ExJRNGbzSTHosQfO2uhLCklC/AtkYISwLBWGTUfGs1TePf/u3fuOGGGxJ+SwAffvghADNmzBipoQkEgqMATdOpq/JQcaCZw/tbaKhN/5ZBMckUFrspLMugsDiDghI3Tpd1mEcrEAgEgrGGJEkoJgnFJGOzD94LCFXtVA2wFzP1tIbrabbR1AEIVn0sVNEXTCY5xXDd0kmESvG3sirpBa5O88MtWEVqa2h87m/41n+Rtn/6A4/0W/D5tGY9Lx54HYBcWw7XLb6SDIubGbOK8HnD7NpSy45NtXjbQqiqzp5t9ezZVk9mtp3ZC4uYOa8Ih2v02DDoaozguntQq7YBoJTOxX7aTUjKqHlEFQgE/WDUfHNzcnK45JJLeOCBB7DZbMyfP5/169dz//33881vfpMpU6aM9BAFAsE4IxyKcWhfEwd2N1J5sCWtwavJLFNclklxeSYl5VkUFLuTSgALBAKBQDCSKIqMYh98wSoWNYzP04lVKX3tRuzx+URUVqdt1P4IVjGNWEwjNIgRVopJ7iI8yZgtpqSqf0ggSxKSJCFJhiCIZKSCtPcR75OT+iQkQA8GCB8+RPjQQdQWwxdJypiOpIOEDuhIuk7xNd9l367G+HHix5I7jtkx7eg77K3kb3tfx6ZnYjNZuHTKRURbJZolf2LbabMLmDa7gOrDrezcUkttpWEc3tYS5JN3DvDpuweYNC2X2QuLKZ+SM6IRYrqmEnrzXtTDmwBQimdiP/0WJNPoEb8EAkH/GFWeS9FolEcffZRnn32W6upqioqKuPDCC7n66quR5b4/zAnPJYHg6KG/35OAP8LBPR2CUrr/FXmFLsonZzNhSg6FpRkowmxbMA4Q1xSBoHfE92ToMAQrzfCvSomWao++6tyndVkv1mk9o12NaSN9WmOW/CI3F1yxeEAC05F+T3RNI/T2A8T2fQKAXDAVx9k/QrLYB7xPgWA0Mt6uKWPGcwnAbDZz7bXXcu211470UAQCwTgiGlE5sKeR3VvrqDzYkmKoarEqTJyaS/mUHMonZ+NwirdmAoFAIBAMJooioygyVtvgPX5omt5tal9/0wHVmIau6+g68WnnedC1jrbxQHODj2hEHdTfR1/QdY3Qe3/uEJbyJuI46wdCWBIIxgGjSlwSCASCwULTdCoPtrBnWx37dzcSiya/3bQ7zUyenseUmXmUTMgS0UkCgUAgEIwxZFnCajMNm0ASrqrC88F7tH3yETGvD5DQJQmQUHJycC5ZhmvJUkx5eez/t38x+jHS5ib+8v8Di7VH0aqrqBWORnh29/M0BJuRdDiueBmL8xcY62jGOmDc83TeDh00YwFNw5i2C2O6jqZDcVnGCAhLOuEPniC2+30A5JwyHGf/GMnqHNZxCASCoUGISwKBYFzh84TZsamGHZtr8HsjSX02u4mpswuYPruAwtKMcVONRiAQCAQCwdCgRSN4P/uMtnffIrR/f6JdBmS7DffyY8lYsRLb1GlIkoQWjbD3+u/SudTH1DvuRnF1n0qSDlVTuW/zoxy07AYLnFByLOfNXD1qq771hq7rhD9eS3TH2wDIWcXYv/IvSLb+/VwEAsHoRYhLAoFgzKNpOhUHmtm+oYZD+5qSQtYVk8ykabnMmFdI+eRsEaEkEAgEAoGgV2KtLbS+8zZt776N6k32TLHPnEXmCatwLVmKbO2QkfRYjL3Xfzdp3Sm/v7PfwpKu6/x193Nsb94FwNzcWVw447wxKywBRD7/G9GtRqU7KaMA+1f+BdmeMcKjEggEg4kQlwQCwZglEo7x8bv7+eTd/XjbQkl9+UUu5iwqYeqs/GEP+xYIBAKBQDA2CR08SMvrr+Jd/zmoHVVklcxMMk9YRcbKE7EUFKRsp2sae667Jqlt8v/8DlNmZr/H8Pqht/mw+jMAyt2lfGfupSiy0u/9jBbCG18isvFFACRXLo5z/hXZmT3CoxIIBIONeOISCARjDm9biC3rq9ixqYZIuOPGz2SWmT6ngDmLSigodo/gCAUCgUAgEIwlgvv30fzi8/g3b0pqt02eQtapp+FeugzJlP7RSdd19nz3O0ltE//zV5hz8/o9ji9qN/D8/lcByLZmcf2Cq7CZrL1sNXqJ7HiHyGf/B4DkyDKEJVfuCI9KIBAMBUJcEggEY4aGWi8bP6tk3476pNS3rBw785eWMn1uoYhSEggEAoFA0GeCe/fQ9MI/CWzb2tGoKLiXLiNrzanYp07rcXtd19l38/VJbRP+/RdYS0r6PZYDbYd4YqchxNhNNm5Y+B0yrWM3dSy67zPC7z9mLFid2M/+MXJGatSXQCAYH4inMIFAMChce+0V7NixPaV99epT+O///m2321VXV3H33XewYcN6AI4//gRuuuk2srM7wqXra7x88cFBDu1rTtq2ZEImq06bQVaefUz7EAgEAoFAIBheIg31ND77DL71X3Q0KgqZJ6wi56yzMefl92k/h/7jZ2ihjtT8sh/+C7ZJk/s9nuZQC/dveYyYFkOWZK6ddwUlrqJ+72e0EKvYQujt+wEdTFYcZ/0QJad0pIclEAiGECEuCQSCI0bXdQ4ePMCJJ65m9epTkvqKioq73a6trZVbbrmOaDTKpZdegaqqrF37BPv27eXBBx+jpTHIFx8cShKVJAmmzS5g4fIy8ovc5Oe7aWjwdnsMgUAgEAgEgnbUYJDml16gdd3r6LEYAJLJROaqk8g+82zMOX1P2aq663YiVZWJ5eLrbsAxe06/xxSKhblv86N4Iz4ALpxxHjNzeo6YGs2odXsJvvFH0FSQTdhPvwWlYMpID0sgEAwxQlwSCARHTE1NNcFgkBNPPIkzzji7z9s9/fRfaGio57HHnmZS/C3fnDnzuO22G/ntf99Pjn1+Yl1Zlpi1oIjFx00gI8s26OcgEAgEAoFgfOPbuIG6Jx9DbW1NtLmPW0HeBd/ol6gEUPfEo0n+TAWXXo77mOX9HpOmazy+/WmqfDUArC5byYmlx/V7P6MFtamCwCt/gFgEJAnbmuswlc0d6WEJBIJhQIhLAoHgiDlwYD8AEyf2Lwz8zTdfZ9GipQlhqa7aQ/0BBxnOfL7c+AGnrpifEJWWrJiAO1OISgKBQCAQCPqHFgpS9+TjeD/5ONFmmzqN/IsuwT6l/xE1Tc//g7Z330ks53z1a2SdvGZAY3th/2tsatwGwOycGVww7ZwB7Wc0oHnqCb78O4gEALCdeBXmyceM8KgEAsFwIcQlgUBwxBw4sA+ASZMmARAMBrHb7T1u4/F4qK6uYvXqNdRWefjiw4NU7G8BIDuzjOr6HcxZXMyS44SoNFaJNjRQv/ZJwlWVWMvKjU9pGabsbGS7HdnuMKY2G5Isj/RwBQKBQDAOCVccpvree4jW1wEgOxzkX/gtMlaeMCC/xtZ336bp+X8kljNXnUTe184f0Ng+rVnP64feBqDQUcDV8y5FkZUB7Wuk0fwtBF76X/RgGwDW4y7CPGvVCI9KIBAMJwMSlw4cOMDevXtpampCkiRycnKYPn164sFSIBAcXRw4sA+Hw8kf/3g7b775BsFggJKSUr773Rs49dQz0m7T2FgPQH1llOee2JBol2WJ8gnFHKrewNKVJbhcQlgaq9Q/9QT+LZsBiDU14d+0sddtlIwMzPkFKI648NRJhFI6C1IOR3y5o00IVAKBQCDojG/jBmoevA89HAbAMXceRVddjSkru5ct0+Nd/wX1TzyWWHbMm0/hFVcNaF/72w7y1M5nAXCaHCwpWMAj257i+OLlLC6Y38vWows95CP48u/RvQ0AWBadg2XBWSM8KoFAMNz0WVzat28fa9eu5bXXXqOxsREwTHyBhOqfm5vLWWedxcUXX8zUqVOHYLgCgWA0cuDAfgIBPz6fl3//91/i83n5v/97mv/4j58Si8U488yvJK1fU9HG6/80fAq8rTEKM0BWJGYvLGbJceU89fRWPvgEQqEgLpdrJE5JMAg4Fy5KiEt9RfV4UD2eAR1PstpQHD0IUp1FKVvHsrFeXKBSxuYbY4FAIBAk4/nsE2ofvB90HSSJ3PMuIOesrwz4RURg9y5q7r07sWwpKaHs+z8c0L6agi3cv/kxYrqKLMkszJ/LKwfXAeCL+MaUuKRHwwRevR2txTA2N89ejWXZ10d4VAKBYCToVVw6fPgwv/vd73jjjTew2WwsXbqUiy66iAkTJpCVlYWu67S1tXH48GE2btzIs88+y5NPPslpp53Gj3/8Y8rLy4fjPAQCwQhy7rnno6oaX//6hYm2U089ncsvv4g//ekuTjvtTBRFoepQK198eIjqw600NBsV3iRZYt6SEhYfNwFXhrXLnvsfri4YPWStPoXME08i2tBAuLKCcFUl4coKIpUVRBsaBv14ejhELByClpYB70OyWJDtcQHKkSxMKYn5uCCV1N8RSSWZRMa5QCAQjCT+rVuofegB0HUki4Xi716Pa9HiAe8vXFVF5W9/nViWLBYm/eevBrSvUCzEfZv/jC/qB2BJwQI+qvk80V/qKhnwOIcbXY0SfP0utHrDHsE0ZTnWlVcMKN1QIBCMfXq9Az777LOZMWMGv/71rzn99NNxOBw9rh8IBHjttdd4/PHHOfvss9myZcugDVYgEIxOzjvvGyltVquNM844mz//+UE+fPdLmqvN1FS2dfRbjHS3JStKOfH06UnbhuPh606ncwhHLRgOJEXBUlSEpagI9zHLUvp1XUfz+4k2NRJrbiLaZHxiTY1Em5uJNTWier39O6bJhCk3F9nuQAsG0AJBtGAgUXK6J/RIBDUSQW1r7dcxk45vsSDbbJ2ipxxxoSpZhOoQqVJTAGWzecDHFwgEgqOZaFMjNQ/eB5qGZLFQesttOGbNHvj+mps59IufJrVNu+f+Ae1L0zUe3f401f5awDDw/qJuY6I/25rFZbO/OeCxDie6phF6+wHUKsOMXCmfj+3k74oUdYHgKKZXcenOO+9kzZq+Vz9wOBycf/75nH/++axbt+6IBicQCMYu0YhK0GvcYLzz2nbysycBYDLJzFlczLS5c3nhnd/h9bWmbNvY2IDL5e7VFFww9pEkCcXlQnG5YOKktOuoAT/hykrCFYeNCKiKCiLVVeiRSNr19ViMaF0dssNhmIjPnYe1bALmoiLMOTnoqooWDKIFg6iBQHw+gBYKoQUCqO3L7et0mu/umEnHbxeoBpjeB4ZAJidEqVRBqiPlr0v0VCcRSzKbxdtjgUBwVKHrOnWP/hnNb0QFFX77qiMSltRAgAP/8oOktsyTT6Hh6ae63cY2ZSoZxx6Xtu/5fa+ypXE7AGWuEnY0707q/++VPxnwWIcTXdcJf/AYsf1GxJVcOA37qTchKSJyVyA4mun1P0B/hKWunHrqqQPeViAQjA0aGuq57babWLPmNK688hrqa7zs3FzLnu31bPjSeJvlsudgsSrMWVTMwuXlOJwWAIqLS9m9e1fKPvfs2cWsI7gZFIwvFIcTx4yZOGbMTLTpmka0vi4hNrVPY81NiXW0QIDg7l0EO/+NSRLmgkKs5eWJCnaO2XMw5eT0SYjRY7G44NRZgAqgBoIdIlUXQcpoCyXa2o1lezuO6vWgegcuUKEonVL57NRluomZLCk+VEonEauraCVZLEKgEggEY4bgrp0Edhj3HhknriLj2BUD3peu6+z/wS0p7W1vv9Xzhm++gX3KVMz5+UnNn9R8wRuH3wGMCKVKX3VS/x9P/s2AxzrcNL/9JNGd7wIg55ThOPM2JHNXawOBQHC0IeRlgUBwROTl5ePxePjbs8+iBGfi9xhG//5gC/sqP6ekcAannrOYWfOLsFiT/+WsXn0KzzzzFIcOHWRiPGrl888/5fDhQ1xyyeXDfSqCMYQky1iKirEUFeM+ZnmivdcoJ10nWldLtK4W3xcdHheJKKeyMqxlE7CUlWMtLUW2Jt8sSyYTituN4nYPeOxJkVNdRCg1GEQLpGnrLFwFgujhUO8HUlVUnxfVZ6QV9i5ppUFRkG22JJGqwwQ9jedUGh8qyWoVApVAIBgWPB99ABj/q/MuSE3Z7w9Nz/8jJZ1a7sYeRAsGDeNwwFxYhCknJ6l/b+sBntr5NwDsJhst4dak/ttP+v+QpbGRThbe+DKRz/4BgJRRgP3sHyFZhY2BQCAASW8v+XaEaJrGgQMH8Pv9TJo0iYyMjMHY7YBoavKhaYNyWiNKfr6bhob+eY0IBMOFty3Etg3V7N/dyNbtn/HeF4+S6S5iWvmxxNQweys+Aknj3nsfYcqUKVRVVbJ162bmzVtAaWkZAC0tLVxxxUUoisLFF19KJBLhqacep7S0nHvvfRiLxdLrOMT3RNAbfYlySkuaKCdr+YQ+RzkNJbqmdYmUShagklP+jHY5FiHs8XWsEwolHoaGFFk2qvM5OglS7Z5UDnuycNWNT5VstQofD8GwIK4pY5sD//Zjoo0NOBcspPSW2wa8n9a336T+L08AYMrLY8K//RRTVnbadb2ff0bNA/eCrqNkZDDh//0sKWqpKdjMb7/4I76oH1mS0XQtafvfnPBz3JaxURk3suMdwu8/CoDkyMJx7k+RM/J73kggOIoZb9cUWZbIze3+/9WgRC6tXbuW1tZW5s6di9Pp5IUXXqC6upqrr76anC7KvUAgGB88v3YTnlYjeqK8aD6rjrmKXQffZtPul7HZbCxZupTrrrspEZG0adMGfvWrX/KTn/wiIS5lZ2dzzz0PcNddf+Dhh+/HarVx4omrueGGW/skLAkEfaHXKKfKCsIVh4lUVhKuqhy0KKehPifF6UTph+l91xscXdMMn6l06XyBrlFTXYWsDuGqV4FK09ACfrSAn94t1bs7YSnZJD2NCXpCuHLYDTGrq0hlswuBSiAY58RajWqhluLiAe/D+8Vn1D/1JACKy03Z93/UrbAU2LmD2oeNqnSyzUbp93+YJCwZleEeTVSG6yos/fy4H48ZYSl64AvCHzwGgGxzYTv7R0JYEggESRxx5NLtt9/OmjVrWLBgQVK7z+fjP//zP/npT39KZmbmEQ2yv4jIJYFg6Hnh6U1UHmylsMTN5Bl5TJ6RR1ZOz9UkhwLxPREMJuMxyqmdofiu6LqOHg517zmVJFKlSwEMooWCoGm9H2wQ6CxQpTNBT0n3c6SaqQuBanwjriljm33fvxnV5yVj5YkUXXV1v7cP7NhO1Z1/QI/FkKw2yn/8r9gmTU67briigorf/soQ2RWF0lt/gHPO3ES/pmvcv/kxtjbtSLv9D5bcwNSsSf0e40gQq9lF8OX/BTUGJisll/0HXsvABTyB4GhhvF1ThjRyadu2bTidzhRhCcDlcnHLLbfwpz/9if/3//7fkRxGIBCMQs65aAGaqqOYxIOWYPwwLFFOZWXI4yQyT5IkJJsRFTRQdF1Hj0Q6GaOnq9QXiAtV3fhUBYOgqr0eSwuFjHTAlgEPF8lqQ7bbUtL5UkWqdD5VcYFKUQY+AIFA0C2WsjKCO3cQ2L7VEIhMfX/UCR06SNXddxk+S4pCyY03dyssRZsaqbzj98b/HqDoO9cmCUsAL+5/vVth6TtzLx0zwpLaXEXwtTsNYUlSsJ92E7bSGXjH0QOzQCAYHI5IXHrttdf41re+lVi+77772LBhA7/+9a/JycmhrKyM+vr6Ix6kQCAYfUiShGIaHREZAsFQk65inRoMEtq3l8DOHQR27iB86GBKili6inWK2035v/0US2HRcA1/VCNJEpLVimy1dpt60hsdAlV6E/SkdL5uRCotGEwx7017rHAINRxCbW0d0FgBJIulGxP0rh5UnczSE9FUxjr9eWgWCI4WMpYfR3DnDmItLbS8+QY5Z5zVp+0idXVU3fEHo1iCJFF89XdTxKJ2VJ+Pytt/h9rWCkD+hReTcexxSetsqN/Ca4fSV5U7b+rZLC1c2PeTGkE0XzPBV34PkQAAtpO+g6l8/giPSiAQjFaO6M6ksbGR3NzcxPKjjz5KW1sbGzZsYM2aNQDIInxcIBAIBGMAPRZD9flQvR5iHg+q14Pq8RLzts97UL3xZY+nI2qpn6heL9HGRiEuDSKdBSqysga8Hy0aSYhPKel8gfSCVFchS49Gez2OHomgRiKJh9OBIJnNPZqgd03nS/hU2ewJkUo2j48IOoGgnYzjV9L8+itEa2tp/Puz2CZNxjFzVo/bxFpbqbr9d6heDwD5F1+Ce/mxadfVwmGq7rqdaG0tANmnn0n26WcmrVPtq+XxHX/t9ngf1XzGRzWf9XouTpOTi2aeR7m7tNd1hwI97Cf4yh/Q/c0AWJZ/4l8kOAAAgfVJREFUA/OMlSMyFoFAMDY4InFpypQp7Nu3j9mzZwNG5NLOnTs5+eSTE+tow+SjIBAIBAJBOrRoBLW1jVhrK7HWlvin1fi0taK2tRHzetB8vkE7puxworhcKC4nitOF7HKhOF0oLhfWsnIcs+cM2rEEg4dstiBnWuAIvCK1aBQtFOxepAoG0QKpbZ2Fq74Il3o0ihqNono8Ax6rZDIlCVBJkVOO9CJV1xRAyWweNb5iAoFkMlH07aup+N1vQFWpuvMPFH/3elyLFqddXw34qbzj90QbGwDI+cpXyV5zWtp1dVWl5oF7Ce3fB4D72OPI+8aFSesEogHu3/IYEbX773B9oLGPZ9PIl/WbR0Rc0tUowdf/iNZSCYB5zhosC78y7OMQCARjiyMSl8477zzuvfdefvaznwGwaNEiFi1alOj/+OOPWbJkyRENUCAQCASC7tBCIaLNTcSamog2NRJraTE+ba0JMUnz+4/sIIqC4nJjynCjZGSiuN2Y3BkoGRkobjeKyx0XkgwBSXY6henzUYxsNiObzeDOGPA+9FisIyoqZIhRaX2ogsFufar0cLhPx1G9XlTvEXinKEqqv5TNliJSpab8tYtUDiSLRQhUgkHDPn06RVddTe3DD6JHIlTffSfZZ5xJ7nkXJEXraZEI1X+8k0hlBQCZq1aTe94Fafep6zp1Tz6Gf9NGAByz51J01TVJ/+s1XePP29fSGExfAGJpQe+pcBXeKuqDhvjkNDlYUbysT+c8mOi6RujtB1FrdgJgmrQU6/GXiu+oQCDolSMSl/Ly8jj22GN59NFHufLKK5P6NmzYwJtvvsm///u/H8khBAKBQHAUo/r9RBvqDeGoqZlocyPRpg4xaaDCkWQyoWRlYcrMwpSZ2SEaZWSgxIUjk9uN4s5AdjiEWCQYViSTyRAu3e4B70NX1bRRUR2V+uJtoWBakUoLBgzz895QVVSfF9V3BAKVLPdggp4cNZVspt6e8mdHstrEw68gQcZxxyNbrdQ+/CBaKETLa6/i+/JL8i/6Fs6Fi0DTqLn/TwT37AbAtfQYCi67otu/oabn/4Hn/fcAsE6YSMmNN6X4nr24/3W2N+1K2XZZ4RKumHMhstTzdeSQp4I7vrwPALNs4rqFV1HgyOvvqR8Ruq4T/vhpYvuNtD2laAa2U74nroECgaBPHLEb5Omnn86ePXu45557cDgc6LpOKBSirKxMCEsCgUAg6BFd11F9XqL19UTr64jEp9H6eiL1df0XjyQJJTMTU1Y2pqysTtP4JzMbU3a2EV0kHkQF4xhJURIRdeYB7kPXtIT4lOw51SlSKpC+el9inVAoxeg+BU1D8/uPLMpQktKYoMcFKEdq1FQ6nyrZah348QWjDtfipUz4WSk1999L+PAhog31VN99J7YpU1EyMxNRSPZZsym6pnsBpfXdt2l+4Z8AmPPyKb31tpQKmd0ZeM/OmcHls7/Zq7BUH2jkT5seIaJFkZC4au6lTMmcOICzPjKiW14luvV1AOSsEuyn34JkEt5sAoGgbwxKqZHp06czffr0wdiVQCAQCMYhuqYRbWggUlPd6VNDpLYmUcq5L0gWC+bcPEw5OcY0Nxdzbm5i3pSZJcq8CwSDhCTLKA4nisMJub2vnw5d09DC4W6M0buk83WKnurqSdWrQKXrRjRWIACkT0vqFUliv92OZLN1EqC6eFI5ehGpbHYR5TGKsBQWMeGnP6f1nbdo+udzaIFAwjMJwDpxEqU33WKksqbBt2E99U8+DoDiclN62w8xZWYlrdOdgfcEdxnXzLscRe75muSN+Lhn08P4ooa4etHM81iYn75S3VAS3fsJ4U+M85AcWdjP/iGSzTXs4xAIBGOXQa9j++mnn7Jr1y6uuOKKwd61QCAQCMYAsbY2whWHOz7V1URra/pU5h0whKOCQiwFBZjzCzEX5GPOzcecm4vscomII4FgDCHJMkpcpBkouq6jh0Px1L2uolTn5U6RU2l8quityIyuowYCEAgAzQMer9xJnEoxQbd1pP2lCFed5oVIPnhIikL2mtPIWH4cLetep/WtdWjBIObCQkpv/UFKFFI7wT27qXngPtB1JIuFkltuS6nyGYgGeSCNgXe+PZcbFn4Hm6nnaLiIGuHezX9O+DSdOfEUTixdcQRnm4quqei+ZqB7gVZtriD0zoPGgtmO/awfIrsGqCgLBIKjlkEXl15++WWeeeYZIS4JBALBOEfXNKL19YQPHyLUSUxS29p63VZxZ2ApLsZSXIKlsBBzQSHmggLMefnIFhGCLxAIOpAkCclm71YE6Au6rqNHIoYA1Y0JuhYMYNVV/M1tRlsolCJSoaq9HksLhYx0wJYBDxfJau3BBL0bk3SHA9lmT6QEdvUEOtpR3G7yzv862WeeTXDPLuzTZ3Yreoarq6j64x3o0SjIMiXX34R9ypSkdTRd49Hta2noYuDttri4adE1uC09R/1ousZj25/mkMcwFD+2aCnnTDnjCM4wFT0WIfDi/6DV7+t9ZQDZhP2MW1Byywd1HAKB4OhAXHUEAoFA0CdiXg+h/fsJ7d9nfA7s79XwV8nKwlpaZohIxSVYS4yp4hKh9gKBYPiQJMkQbKxWTFnZ3a6Xn++moSG9Obmu6+jRaDeV+rqk8wXSm6lrwWCfojj1cBg1HEZtbR3oKSNZLGmjohKeVI40bZ2q/Cl2x7gUqBS7HdeCRd32x1pbqbrjD/EUSyj89ndwzl+Qst5L+19nW9POpDarYuHGhVeTZ+896uef+15hY8NWAGZkT+OSWV8f9Mjc8IdP9l1YQsJ28rWYSmYP6hgEAsHRw/i7YggEAoHgiNF1nUh1NcFdOwjuM8SkaEN99xtIEpbiYqzlE7FOmIC1fALW8nJMR1COXSAQCEYTkiQZgo3FAl18d/qDFo0Y4lO7WXqSMXoaz6k0PlV6NNrrcfRIBDUSQW1ro/e10yOZzV0ipZIjp9IZo3cVqWTz2IlG1UIhqu66nVizEY2Ue/7XyVx5Qsp6X9Ru4NUuBt4SElfPu4xyd2mvx/mg6hPWHX4XgCJHAdfOuxyTPLiPZZGd7xLdZVS4kwunYZl9co/rKwVTkbOKelxHIBAIekKISwKBQCAwxKSaGoK7dhDYtZPgrp2o3m5Ki0sSlpJSbFOmYJs0BduECVhKy0Q6m0AgEPQB2WxBzrRAZuaA96HHYp1M0Dv7TXWOlEoTORXoEK70SKT340SjqNEoqscz4LFKJlN6QapdfEqq7tdVyDLmJYtlyP32dFWl5v4/ET58CIDMVSeRc/Y5KevtadnHEzueSWm/cMbXmJs7q9fj7GjazV93/wMAl9nJ9Qu/g8M88JTPdKgNBwl/+AQAkj0D+2k3ITuyBvUYAoFA0BUhLgkEAsFRSrSlhcCWzQR2bCOwa2e3Dw+Ky20ISVOmYp86DeukyUdkzisQCASCI0MymYzI0COIDtVjMbRQqEOASmOCnj4FsL0/hB7uOTW6/Tiq19v9C4u+oCjpq/d1Eam696ly9ChQ6bpO/VNP4N+yGQDHvPkUXHpFyvo1/jru3/I4MT3Ze+uU8hNZVXZ8r6dR7avloa1PoOkaZtnEdQuuJM+eM8AfSnr0kI/gurtBjYEkYzv1RiEsCQSCYaFXcam6urpfO/T7/QMejEAgEAiGDj0WI7h/H/7Nm/Bv3UKksiLteorbjX3mLBwzZ2OfOQtLcbGo0CYQCATjDMlkQnG5jsgDT9e01HS+QJrqfd2IVFrcOL1XVBXN50Pz+QY8VmTZqNbnSBWpwhUVRKoqAbCWT6DkuhtSKva1hT38adMjBGPBpPb5eXM4f9pXej18W9jLnzY9QkgNA3DFnIuZnDlx4OeTBl3XCL79ALq3EQDr8m9iKp45qMcQCASC7uhVXDrllFP69VCh67p4CBEIBIJRghoM4t+8Cd+G9QS2bTXKcXdBdrlwzJyFY+Ys7DNnYykpEf/HBQKBQNArkiyjOJ0oTueA96FrWof/VLu/VKfldCJVik9VKAS63vOBNA0t4EcL+OnOUt2UnUPJLbelVCYMxcLcu/nPNIeSSwCWu0u5au4lyJLc46EjaoT7Nv+ZlnArAF+bchZLClJNwo+UyIYXUCuM6CvTpKWYF5w56McQCASC7uhVXDrvvPPEQ4ZAIBCMIVSfD9/GL/F9uZ7A9m2plYkkCevESTjnL8A5fwG2SZOR5J5vjAUCgUAgGAokWUZxOFEcTui9yFpadE1DC4d7NEFP9aDqJFwFgiguFyXX34Q5O7maoKqpPLLtL1R4q5Las6yZXLfgSqxKz36Dmq7x6PanOew1IqOOL17GaRNXD+xEeyBWsYXIF/8AQMoswrb6GvEMJxAIhpVexaXf/OY3wzEOgUAgEBwBqs+Hd/3neD//jODuXaBpSf2y3Z4Qkxxz52PKEFXcBAKBQDA+kGQZJe7JNJj4owGe2PEM25p2JrVbFQvXL7iKLGvvpuz/2Psymxq2AjAzexoXz7xg0EUfzdtI8K37AB1MFuyn3YxkEd6IAoFgeOmTofdJJ53Eqaeeyqmnnsry5ctRuuQgCwQCgWD40cJh/Js24vnsE8OEVE02GFXcblyLl+BashTHrDlIJlHDQSAQCASCvrC39QCPblubSGVrR0LiO3Mvpcxd0us+3q/6mDcr3gOgyFnINfMuR5EH9zlKV6ME190DYcP31rbqKpSc0kE9hkAgEPSFPj1prFmzhnXr1vGXv/yFzMxMVq1axemnn84JJ5yAXVQMEggEgmFD1zQCO7bj/eRjvF+uT6nUo2Rl4V66DNeSpdinzxDpbgKBQCAQ9ANN13jt4Fu8dOANdFJ9nL4542vMy5vd6362Ne3imd3/BMBtdnHDgqtwmAf/uSn80V/QGg4AYJ67BvO0FYN+DIFAIOgLfRKXfv7zn/Pzn/+czZs388Ybb7Bu3TpeeOEFbDYbK1as4LTTTuPkk08mu0uOskAgEBwt7N27h2uuuZzLL7+Kq6/+Xo/rVldXcffdd7Bhw3oAjj/+BG666bYe/4fG2lpp++B92t5/l1hjY1KfbLfjOmYZGceuwD5jphCUBAKBQCAYAL6In0e3r2VH824AZElG0zvSzE8uO4GTyo7vdT9Vvhoe2fokmq5hlk18b8GV5NpzBn280d0fEN3xjjHWgqlYj/vWoB9DIBAI+kq/ciQWLFjAggUL+OEPf8i+fftYt24d69at46c//SmyLLNkyRJOO+00Tj31VEpKeg8VFQgEgvFALBbjV7/6D2JdjbPT0NbWyi23XEc0GuXSS69AVVXWrn2Cffv28uCDj2E2mxPrtkcptb33Dr6NG5LS3iSTCefCRbiPXYFz/gLkTtsJBAKBQCDoHwfaDvHQ1idpDbcBUOjIx2l2sL/tEADz82ZzwfRzet1PW9jDvZv+TEgNA/DtOd9icuaEQR+v2nSY0PuPASDZ3NhPvRFJEenvAoFg5Bjwf6CpU6cydepUvve971FXV5eIaPrtb3/Lr3/9a2bNmsVtt93GqlWrBnO8AoFAMOp48slHOXBgf5/Wffrpv9DQUM9jjz3NpEmTAZgzZx633XYjr7zyIueeez4xjwfPh+/T9t67RBvqk7a3lJaRddJq3MetMCrrCAQCgUAgGDC6rvNu5Uf8fe+LqLrxEmdJwQKKnIW8fOANAMpdJVw55xJkqefI4LAa4b7Nf074NJ039WwWF8wf/DGH/QTfuBvUKEgStjXXI7sGPzJKIBAI+sOgyNuFhYVcdtllXHbZZbS1tfH222+zbt069uzZI8QlgUAwrtm3by+PPfYw3/721Tz00H29rv/mm6+zaNHShLAEsGzZsUyYMJHXn3+OY6pr8G1YnxylZDbjXraczJNOxjZlqigtLBAIBALBIBBRIzy54/9YX78JAEVSuGD6OWRbM3lwyxMAZFkzuW7hVdhM1h73pekaj25by2FvFQArS5Zz6oSTBn3Muq4ReuchdI/x8slyzNcxlc4Z9OMIBAJBfxn02MnMzEzOO+88zjvvvMHetUAgEIwqjHS4X7Js2bGcccbZvYpLHo+H6uoqVq9ek2hTvV7aPvqA0lCIjZUV+Oh4K2opKSFz1clkrDgexSmilAQCgUAgGCyagi08sOUxKn3VAPz/7d13eFvl/f7x+2jYsiXv2I6z93BCIIORBQmEhL1pgEA6GIVCofClFPh1QSmrtKWQ0LJ3mGWUGQh7Q0ISsshedob3ki1rnd8fshUrduIRx5Lt9+u6ckk65+jooyTHtm4/z+dJi0/VxaMvlN1i09+XzJcpU3HWOF0+5udKjU9p9nyvbnhLPxStkiSNSBuq2cPOPCi/DPIue1v+rUslSbb+YxV32Ent/hoA0BbtHi49++yzWrhwoZ566qn2PjUAxJRnn31SeXnbdMcd9yjQYKTRvhQVhX7LmJmZqeq1P6r8k49V9f1imX6/knx+1QSDqjEMZR15lFKPmS7HkKGMUgIAoJ2tL92kR1Y+rSqfW5I0LG2ILh41R6ZM3b34fnmDPhky9ItRF6hvUvN9ZD/P/1ofbv9MkpTjzNYlh1woq8Xa7nX7d66Vd/F/JUlGcpYc0y6R0cxUPQDoKO0eLrndbn333XftfVoAiCmbNm3UE088omuvvUFZWdnauXNHs8+pLCqWJFW987byFi6M2OdISpJKi9Xz939Sdv8BB6NkAAC6vc/yv9aL614LrwI3vc8UnTnkZJkydf+yh1XiKZUknT74RB3So/npZutLN+qFda9JkpLsLl0x5udKsCW0e92mp0qeDx+UTFOy2pVw/FUy4hnVDCB2sKQAALRSIBDQ7bffojFjDtNpp52532NN01TNurUq/+wT5X/6cej5FeVSaroMm02ucROUcsw0pX7yofTUY7I6XR3wDgAA6F6CZlCvb3xHi7Z9IkmyGVadN/wsTex1uCTpubWvaEPZZknS4dljW9QvqaimRA+vfFpBMyibYdVlY+YqI6H9G2ubpinPp4/LdJdIkuInni9rRvuvQAcAB4JwCQBaacGCp7Vx43o98MAjKisrkyRVVlZIkmprPSorK1Oiaarq669U/vkn8u3eLUmKD5qSpKDLpR7nzlbypMmyJSWHnvfeO5IkJ72VAABoV76gX0+vfiHcuDvJ7tJlY36qQSn9JUmf5n2lz/O/liT1S+qjC0ac0+y0dI/fowd/eEJuX7Uk6bwRZ2tQyoCDU/+aj+TfskSSZBswTvaR0w/K67SWaZp6/fPNWr6xWBefPFJ9MvkFGdCdtShcuuyyyzRq1Cjl5uYqNzdXvXv3Pth1AUDM+uabL+Xz+XTppT9ttG/Bgqe1YMHTunvoSPWw7um3YNhs6nfEkdKWDTInTlL6rBMjnldUVCiXK0kJCe0/lB4AgO6q2leth1Y8pfVlmyRJWYk9dOWhF6tHQoYkaV3pRr20/nVJUnJckn455qeKs9r3e86gGdSTq1/QDvcuSdKxfadqYs6Eg1J/oCRPtV89J0kynOlyHP2LmOnH+O632/S/L7ZIklZuKiFcArq5FoVLn376qT799NPwF7Lk5ORw0FQfOg0YMOBg1gkAMeOqq64Nj1RSMCjPtq3auex73ffJh5qYnKpJKalKqft6GZfTSylTjwmt+JaUpJzPPta6desanXP9+rUaMWJkB74LAAC6thJPqeYvf0y73KERxINSBuiXY34qlz00SriopkSPNJzWdsjcFq0M9+am98Irw+WmD9eZQ05u99rNoD/0M8YH/5ECPkmGHNMvk+GIjQBn2foivfzRRklSRnK8Jo3uGeWKAERbi8Klb775RqtXr9aqVavCt19//bW++uqrcOCUmJiokSNHqra29qAWDADRNrRfP1WvWiX3D8vlXvGDAlWVsnq9kqRMu12j0zOUNOEIpUw9Wo7BQyJ+wzht2rF68cUF2rp1i/rXNe7+7rtvtG3bVl1wwUXReDsAAHQ5u6sLdd/Sh1RWWy5JOizzEP0097zwqCSPvzZiWtv5I87WwLppcvuzeNdSLdz6oSQpOzFTPx91gSztvGKb94d3Vfv18xHb4sadKluvEe36Om21ZWeFHnxjlUxJ8Xarrj7nUCU746JdFoAoa1G4lJKSookTJ2rixInhbW63W2vWrNHKlSu1evVqrV69WkuXLlUgEIiZoZoA0J5q1q9X0Wv/Vc2G9VIgELHPsIWmwCVNOFyDb/h/ssTHKz8/Tyvfe0ejR49R7959JEkXXDBX7777lq655gqdd94ceb1eLVjwlIYPH6mZM0/q8PcEAEBXk1+1U/cve1iV3ipJoRXhzhp6SjgECppBPbUmclrbUS2Y1ra9Ml/P/PiyJCnBlqDLx/xMifb2nc4eKNjUKFiyZA9R3LjT2/V12qrC7dXtzyxRrTcgQ9Jlp+aqb1ZsjKYCEF1tbujtdDo1YcIETZiw5wuxx+PRjz/+qFWrVrVLcQAQSwoWPKXa7dvDj434eCWOzJVr7Dgl5vSS5s5WXK/essTHS5KWL1+q22+/RTff/KdwuJSWlqb58x/Sfff9Q48++qDi4x2aOnWafvWraxQXx2/9AAA4ENsq8jRv2SNy+0Mjkk4ZOFMnDDgu4pffb29epOWFKyVJI9OH6YzBzf9yp8rr1kMrnpIv6JMhQxePnqOsxMx2rd30Vqv6tVsjN8YlKOHYy2VYrE0/qQP5/EHNe3WFCkprJElnTxusscPa9+8AQOdlmKZpRruI9lZcXKVgsPO/rczMJBUWVka7DCCmdeR1Uv7ZJyr/4nM5+g+Qc8yhShg2XBb7/pt+ArGC7ylA87hOOrftlTv0r6UPqsYfCj/OHHKyZvQ7JuKY7wt+0KMrn5EUau792/G/bnb0USAY0Pzlj2pt6YZ9nvdAmaapqod/3mi7Y8avZB90RLu+VluYpqnH3l6jL1aERntNGt1TF588khkrwH50te8pFouhjIx9j1RsduTSV199FTEdrjW+/PJLTZo0qU3PBYBYkzL1GKVMbd8fJgEAwIHb6d6tecseDgdLs4edoaP7RH4Oya/aqadXvyBJclgduvyQlk1r+9+md8PB0visQ3Vc36PbuXqp+uXfN9pmH3F0TARLkrRocV44WBo5IF0/PWEEwRKACM12n7vkkks0d+5cffTRRwrs1WOkKT6fT++//74uvPBCXXbZZe1SJAAAAAA0pbC6WPcvfUhVPrck6dyhpzcKlqp91XrohyflrZvW9ovRFyjbmdXsuZfsXqZF2z6RJPVy9tSckee2e6hSu/RNBUvzI7ZZUnMUP3FOu75OW63eUqIXPgyFa2lJ8brpZ4fLbmvfJuYAOr9mRy69+uqruvPOO3XFFVcoPT1dEydO1JgxY9SvXz+lpKTINE2Vl5dr69atWrZsmb7++mtVVFRo8uTJeu211zrgLQAAAADojqq8bs1f/ojKvaGpJ6cPOlHT+k6OOCZoBvXk6hdU5CmRJJ0yaJZGZTS/8lp+1U49s+YlSaEG3pcd8lPFW9u3P2KgYJO8370cudFik+O4K2TY49v1tdqisKxG/35tpYKmKbvNoqvOOkRpSQ4VenzRLg1AjGk2XBo2bJgee+wxLV26VAsWLNAHH3ygt956q1Fib5qmXC6Xjj/+eJ1//vkaM2bMQSsaAABIq4vXav7yRyO2ZSZkaHjaEPVP7qfkOJeS4lxy2Z1K9kf/QwoAtCdvwKf//PCECmuKJUkz+0/XzAHTGx23cMuHWlm8RpI0pscozew/rdlzu/ca6fTzURcoMzGjXes3fZ7GDbwlxR81W9aMfu36Wm1R6w3o/v+ukNvjlyT97IQRGpiTHOWqAMSqFq8WN3bsWI0dO1aBQECrVq3Shg0bVFJSIsMwlJ6erqFDhyo3N1cWC0MkAQDoCN/sWtJoW2FNsQprivX5jm+afE6GI00uu0tJcc66W5dccU4l2Rvf2q00rAcQm0zT1DNrXtTmiq2SpMOzx+m0QSc0Om5V8Y96a/P7kkINvOfm/kQWY/+fV4JmUE+sei480unUQbM0KmN4O78Dqerxyxtts/Y7VPZRM9r9tVrLNE09+vYa5RVWSZJmHt5XE0f3jHJVAGJZi8OlelarVWPGjGFkEgAAUXbywOP1fcEPCprBFj+n2FOqYk9pi46Nt8bVhU17hVF2Z6NbV5xLdkurf6wAgDb5KO9zLSlYLkkamjpIF448p9HMiqKaYj2x6jmZMhVnsevS0XOVYGu+gfebm97T6pK1kqTDMg/RzP6NR0MdqOo37my0zUhMleOYi2OiUfZbX23V4h8LJEmjBqTp3OmDo1wRgFjHT4EAAHRSWYmZun/6ng8oNX6PdlTt0qbyLVpbukFrSze0KnjaW23Aq9pASfi3981xWB1Nh1D7GBlltVjbXBuA7mtD2Wa9uuEtSVK6I02XHHKRbHuF296ATw+veFrVdavHXTjyXPVyNT/yZlnBCi3c+qEkqaczWxcdhAbe3jUfK7Dzx722GnJMv0yWhOhPO1u+oUivfrpJkpSZ6tAvTx8tK7NTADSj3cIl0zSVl5cnt9stp9OpPn36xETqDgBAd5Fgc2hw6gANTh2g4+t6ipimqbLaclVZy7Qmf7Py3Tu1o2qXdlUXHFDw1BRPwCNPjSfc/6T5ehOaHREVunXJZU8kjAKgKq9bj618RkEzKJth1SWjL5TL7ow4xjRNPb/2FeVV7ZAkHdt3qsZnH9bsuXe6d+upNS9ICoXllx0yVw6bo13rD5btVO1nTzTaHnfYybL1zm3X12qLncVuPfTGKpmS4u1W/frsMXIlMEUaQPMOOFzyer3629/+pldffVVVVVXh7S6XS2eddZauv/56xcW176oKAACgZQzDUJojVcMy+6qvfUB4uz/o1+7qQuVXhcKmHe5dyq/aqbLa8mbPGWeNU3JcUsQfpz1B1X6PqrxVqvS5626rVOV1y5TZ5Hlq/DWq8deoQEUtei9OW6JcTYyIaiqQctoTm+2rAqDzeXHda+GV4c4Zdrr6J/dtdMznO74O96QbkjpQZww+qdnz1vhr9NCKJ1Ub8EqSfjbqPGUnZrZj5ZIZ8Mv94k2NtluyBiluwhnt+lptUe3x6/7/rlBNbUCSdMkpI9Un0xXlqgB0FgccLt16663asGGD7r33XuXm5io5OVkVFRVavXq15s2bp7/85S/6y1/+0h61AgCAdmKz2NTblaPerpyI7dW+au1w764LnXYqv2qXdrp3yROoDR/jDXhVVFOsogYjlKyGVdmJmerl6qmRaUPVy9VTvV05SolPVrW/JhQ2ed3hwCnydk8g5fZV7zOMcvur5fZXa3cL3p8hQ057KIxKqusJ1dRt/cioRHsCYRQQ45YVrgz3WTq0xyhN6XVko2M2l2/VS+v+J0lKiUvSL0Zd2Oyox1Bz8JdVUB0Kuk8eeLwO6dH+o4iqHr2k8Ua7QwnHXi4jyj3rgqapR95crV0l1ZKkUycN0PjhWVGtCUDncsBfxd577z0tXLhQaWlp4W3p6emaMmWKcnNzNWvWLMIlAAA6iUR7ooakDtSQ1IHhbaZpqsRTGgqc3Lu0oyo0yqmgpig8tS5gBkL73Lu0WMvCz02wJaiXs6d6u3qGA6eR6cOUsI+pJkEzKLevWpXeKlX53Pu4DQVVVb5QGNUUU6aqfG5V+dza1YL3bTEsctoSm+kVtSeYSrQlMP0f6EDegFcv14VGTluiZg8/q9E1WOmt0iMrn1HADMhiWHTJIRcpJT6p2XN/nPeFlhWukCSNyhihEwYc1+71ez57ssntjqk/kyU5+iHO219t1bINoXDtsCE9dPrUgc08AwAiHXC4ZBiG/H5/k/v8fj8/eAEA0MkZhqGMhHRlJKRrTOao8HZfwKdd1YWhEU51vZx2VO0MT1mRQlNNNpZv1sbyzRHnTHekhQInZ05d8JSjrIQeslqsSooLTXVriUAwILe/Lozaz4io+u31zX33FjSDqvSFjmsJi2HZT4+oPSOi6ntKJdgc/EwEHIAPtn2q0toySdJpg09oFBoFggE9uvKZ8NTes4eeqkEpA5o97+bybeHm4GnxqZqbO7vdRzH681fLt+ajRtttQyfLPuSodn2ttli5uTjcwDsrLUGXnDJSFr5eAWilAw6XTj31VF1yySW6/PLLNWLECCUnJ6uyslJr1qzRQw89pNNPP7096gQAADHGbrWrb1Iv9U3qFbG9yucOj27aUbVL+e6d2lm1S96gL3xMiadUJZ5SrShaE95mM6zq6cxWL1fPutFOOerl6qmUuOR9BjNWizXc96klAsFAi0ZE1W+v8XuaPE/QDKrCW6mKBkHa/lgNa+PwqcmRUaHHDms8YRRQp8Zfow+2fypJ6u3K0aReRzQ65o1NC7W+LBSQHJ49Vsf0ntTseat8bj1aN9LJalh1cRPNwQ+UWetWzVt3N9puONPlmDynXV+rLYrKavTg66EG3nF2i6468xAlOmjgDaD1Djhcuummm/Tvf/9bd999t3bu3CnDMGSapnJycnTOOefo8ssvb486AQBAJ+GyOzUsbbCGpQ0ObwuaQRXXlNaNcNoTOhVWF4d7LPnNgPKqdoRXeKrntCWGAidXjno7Q7c5zmw5bPGtrs1qsSolPlkp8S1b7tsX9MtdHz7tZ0RUfRjVsDdVQwEzoHJvhcq9FS16XZvF1qIRUfWjvOKtLJ6Cruvz/G/CQe8pA2c2Glm0smiN3t/2saRQ+HTBiLObDWeDZlBPrn4+PBrqzCEna2BKv3at2zRNVT15ZZP7HNMukRGX2K6v11o+f0DzX1sptyc0C+VnJ45QnywaeANomwMOl6xWq6666ipdddVVqqyslNvtltPpVFJSy36DCAAAuj6LYVFmYoYyEzN0WObo8HZvwKdd9Q3EG/Rzajg9ze2v1vqyTeFRCfV6ONLDo5vqg6fMxB7tOqXFbrEpNT5FqfEpLTreF/CFR0I1CqAaBVNueetWptqbP+hXWW15i1bvC9Vpb2aKXmQwFUcYhU7CNE19ufNbSVJPZ7ZG9xgZsb/UU6anVr8gSYq3xumS0Re26P/3e1s/1uritZKksZmHaFqfye1cuVSz8N4mt9tHHy9b7/ZvGN5aCxat19ZdodGXM8b30VG5PaNcEYDOrF2XJUhKSiJUAgAALRZntatfch/1S+4Tsb3SW7Vnxbq60Gmne5d8wT19Hos8JSrylGh50arwNrvFphxntno5c8INxIemDmp2taj2YrfalWZNVZojtUXHewPeiKl4TQdSe6btNXz/DfmCvvBUw5aIs8btNSWviSl69fftTtmtTJNBdGyt3B5exW1izoSI8DgQDOixVc/K7Q819r9gxDnKSsxs9pzrSjfozU0LJUmZCRmaM/Kcdp+G6tuyRIFtyxttt6TmKP6Ic9v1tdriixU79cmy0CjRIb1T9JNjh0S5IgCd3UFd89Lr9erEE0/UBx98cDBfBgAAdDFOe6L6JvVWhiNdg1MHqtpXoyqfW9sq87S+bJPyKneEp9M15Av6ta0yX9sq88PbxmaN0SWjL+zI8lsszhqnjIQ4ZSSkNXusaZqqDXj32yMq4tZbJb8ZaPJc3oBXxYESFXtKWlSnwxofsVpe49u6YKpulJQtysuqo+tYU7wufH9C9mER+97YtFCbyrdKkqb0PqrR/qaU11bqsVULZMqU3WLTJaMvUoItoT1LVtBTKc979zfeYVjkmHapDFt0Rw7mFVTp6YWhUVtJiXZdccZo2azt28QcQPdz0L/z5+fnN38QAADoskKhSK2qfNVy+9yq8rlV5XXX3a9Wla8qdBve5pbbV91keNQWtfvog9TZGIYhhy1eDlu8eiSkN3u8aZryBGr3mpLX1IioPbeBfYRRnkCtPDW1KqopblGtCTbHPntENTVlr6NGlqHzqQ+PshJ7RExP3bvP0jlDTm32XIFgQI+velaV3tC0258MO0N99lqQ4ECZpin3U79ucl/c2FNlzRrUrq/XWjW1fs1/baW8/qAMSZedNkppSa3vXwcAezvgcOm4447b5z7TNFnpBACALsg0TdX4a1ThrVKFt1KV3soG9yO37W8ETVvZLDY5bQlKsCcq0ZYQ+mOvv92zzRXn1LC07jndwzAMJdgcSrA5lKmMZo8P/Zt6mh8R1eA2aAabPFeN36Mav0eFLQyj6v+t9qyat9eIqAYjo5y2RMKobqTIE/o/1NuZE95W6inTU2v29Fm6ePSFLZq6+dbm98O9247sOV4Tcw5v93qbWhlOkuy5xypu/Bnt/nqtYZqmnnjnR+0uCU0jPH3qQI0a0HxQDQAtccDhUklJia677jrl5OQ02ufz+XTdddcd6EsAAIAO5A1465pJV4SbSocfe8rDwVF7BEYWwyKnPVEuu1Muu1NOu1OuusdOe6IS7Yly2hOVEBEgJSqOHkDtzjCM0N+vPaFFfWuCZjAURjXbK2rP7b5Go1X7a1Ttr1GBipqvU6E660dENQqk9hoV5bQntmuTd3Ss+lXiEu2hqWvhPku+uj5Lw89Wdgv+v64q/lELt34oScpxZmv28DPbv8/Sxm8V2LGm0Xb7iGmKn3xh1H/p/sGSPH33Y4EkafSgdJ0yaUBU6wHQtRxwuDRy5EhlZGRoxowZjfZ5vV6ZZvsMaQcAAAfOF/Sr1FOq4rrmz/WBUZm3XGWecpXXVoSb47aFxbAoye5UUlySkuOSlNTgw77L7pQrLjJActgcfPDvpOqDQac9UdktOD5oBut6Z+3dvLzp231NjTRlyu2rlttXrd0t+K9qyJDTntjkqnl7T9VzJBsKmkH+T8YQhzVelapSdV3IFNFnqdeRmtBzbLPnKK+t2GtFuYsU384rJgY9lfJ88ECj7faR0xQ/Za6MKP+f2rqrUi9+tEGSlJ4cr8tOHSULM0wAtKMDDpcuuugipaamNn1ym0133HHHgb4EAABooUAwoLLachV7SlRcUxq69ZSqwl+uXZVFKq+taFMvI4fVodT4ZKXGpyglPllJca5weJTcIEhilAj2xWJY5IoLBYw9nc3HUUEzKLevOqJ5+b5GRlV5q/YZipoyQ8f43C2u02lP3PcUvQZhVJLdqQRbQtRHpHRlWYmZKqwp1pbybY36LJ099LRmnx80g3pq9Qvhf//zhp+lns6sdq+zUZ8li1Xxk+bIPnJ61P9/1NT69e/XV8ofMGUxDF1++mi5Ehj9CaB9HXC4dOKJJ+5zn8Vi0ZlnnnmgLwEAABoImkGVespUUF2kgpoiFVQXhu5XF6qktmyffXD2JcnuUqojpS48Sg2HSHv+JMthcxykdwM0zWJYwiPfWiIQDIQbxO+/V1QoqKrx1zR5nqAZDI2s8lZJLcij6kfrNe4R1XCqnjM8WsphdUQ9bOhMctOHa1XxjyqtLdO/f3hc0p4+Sy2ZHvvBtk/1Y+l6SdIRPcfpiJ7j2r1G96u3Rjw2EpKVMOs3UW/eLYX6LD29cK0KSkP/3886ZpCG9E5p5lkA0HqsEwsAQIzyBnzaXV2gHVW7tNO9OxwkFdYUyx/0t+gchgylxCcrJzlTSdZkZTjSleFIU0ZCutIdaUqNT2bZeHQJVotVKfFJSolPatHx/qA/vHJh/UgoM86nXaUlTYZRnoCnyfMEzaDKvZUq91a26HVthjUieIrsHdV4Jb14a3y3DqOOzBmvd7Ysihh5NmfEuS3qs7S1Yrv+t+ldSVKPhAzNHnZGu9fn+foFBQs37dlgi1PiuX+VxdGy/4cH2+c/7NTXq3dLkkYPTNcJR/aLckUAuqpW/zQ5d+7c/e43DEMOh0M5OTmaMmWKjjvuuG79DREAgOb4g34VVBdphzsUIu2sC5MKa4pbNIUtzmJXZmIPZSVmKjMhQz0c6UpPSFOGI13pjlTZLDZlZiapsLBlH36B7sBmsYVH59Xb33XiC/pV1YIRUfWNzWsD3ibP4zcD4Sb5LWG32PbZIyp822C0VHv3Eoq2BJtDc3Nn6z8/PKGgGdTx/aZpfPahzT7P4/fosVULwj20fjHqgnYdgWmaQdV+86J8P7wbsd31s//IsMTG1OD8IreefX+dJCnFGadLTsmlzxKAg6bV4VJeXp48Ho9KSkokScnJyZKkiooKSVJ6erqCwaA++eQTvfDCCxo3bpwefvhhJSYmtmPZAAB0TjV+j/Iqd2h7Vb62V4b+7K4ubHYqm8WwqEdCurISMpVVFyRlJ/ZQZkIPpcQn0+cIOMjsFpvSHKlKc6S26HhvwKeqvXtERfSKqguj6qbxeYO+Js/jC/pVWlum0tqyFr1unMXexBS9xiOi6hubd4aVF0dljNDvj7hOxZ5SjUwf1qLnvLjudRXVFEuSTht0gvon9223ekxvjWo+fFCBbcsitidd9kS7vcaB8voC+s/rK+X1B2VIuvTUXCU7u1bwCCC2tDpceuqppzR37lxdfPHFuvjii5Weni5JKikp0SOPPKKFCxfqqaeektPp1IMPPqjHH39c8+fP129/+9t2Lx4AgFhW7avRtsq8cIi0vTJfBTX7X2rdkKEeCenq5eypHGe2clyh26zETNmZvgZ0GnFWu9KtaUp3pLXo+NqAN2Jk1J7V8xoGU3sCKd8+psZ6gz6V1K0G2RLx1rh9j4hqYmRUtL4OZTuzlN3CRtzf7vpe3+xaIkkakTZUx/U7ut3qCFYUqGbhvxQszY/Y7rzwX+32Gu3h+Q/WK78wNJXw5En9lTsgPcoVAejqWv3d4Y477tC4ceMahUXp6em64YYbtHv3bt1xxx2aN2+efve732nz5s167733CJcAAF1a0Axql7tAmyu2anP5Nm2u2Kbd7oL9Tmtz2Z3qm9RbvV05oTDJla2eiVmK62LTWgA0L94ap/iEdGUkNB8CmKYZCqMiRj/tCaPqt1U1CKn8ZqDJc9UGvKoNlKjYU9KiOh1WR+SIqCZHRtVP43N2eE+3wupivbD2VUmhr7Fzc2e328hO/4418rw/X2ZtVcT2+Kk/kyUxdppkf/djgT5etkOSNLRPik6fMjDKFQHoDlr91f7rr7/eb1A0YcIE/f3vfw8/njhxor744ou2VQcAQIzy+Gu1qXyLNpVv1ebyrdpSsX2fDX8lKTU+RX2Teqmvq7f6JoX+pMan0JcQQKsZhiGHLV4OW7x6JGQ0e7xpmvIEapvuEVW/ut5e0/f2NVXXE/DIU+MJTzlrToItocFqevu4rQukXPZEWS3WVv1dNBQIBvT46gXyBGolSReN/IlS4pPbfL6GvKs/VO0Xz0p7hXRGvEtxI6e1y2u0h4KyGj3xzhpJktNh0y9PGyVrjPSAAtC1telXCZs2bdrvPtPc81tai8Uih4PliwEAnVt9mLS+bJPWl27U1sq8fX74cljjNSC5nwak9NPA5H7ql9xHyXGxsXIQgO7HMAwl2BxKsDmUpR7NHm+apmr8nn1Oydu7oXmVz73Pr4c1/hrV+GuanRJcz2lLlCvcvLxxGLVnZJRLTntixKikNze/p60V2yVJ0/tM0egeI1v0mvv9uwgGVfv1c/KtfL/pei+Knelw/kBQD76+UjW1oQDsFyePVHoyn8MAdIxWh0uTJk3Sc889p0MPPVQnn3xyxL4333xTzz//vKZPnx7etnr1avXu3btF5w4Gg3rhhRe0YMEC5eXlKSMjQ8cdd5x+/etfy+VytbZUAADarDbg1cayzS0Kk3omZmlASj8NSu6vASn9lOPMpsE2gE7LMAwl2hOUaE9QdmJms8cHzWAojGo0MqrB4wYjo6p87n1OGXb7q+X2V2u3CpuvU4ac9kS57E457U5tKt8iSerj6qXTh5zUqvfcFNPvlefDB+XfsqTJ/Yln/FHGAYy0am+vfLpJm3eGVjucMb6Pxg5t/t8OANpLq8OlG2+8UT/88IOuv/563XXXXerfv78kaevWrSosLFRmZqZ+97vfSZJqa2uVn5+vM844o0XnfuSRR3Tvvffq4osv1sSJE7V582bdd9992rBhgx599NHWlgoAQIuZpqkd7l1aU7JOq4vXamPZ5iZ7lBgy1Depl4amDtbQtEEanDJAiXZWRAXQfVkMi5z2RDlb+LUwaAZV7avZMyKqvnn5XiOi6m/dvuomwyhTZnjkVL04i10/H3XBATceNz1Vql54r4K7N0iSjJRsmeW7w/ttw6bKmjXogF6jPa3ZWqqF32yTJPXLdunc6UOiXBGA7qbVX3V79+6t119/XQ899JA+/vhjLV++PLz9lFNO0aWXXqq0tNCqGPHx8XrqqadadF7TNPXII49o9uzZ+r//+z9JoVFSaWlpuvbaa7VmzRqNHHngQ1sBALFpyZLv9Mgj/9GGDevldDo1ffoMXXrpFUpM3P+HlR078jVv3r1aujT0m+VJk6boqquuDX8v2p9qX7XWlKwPB0rl3opGxzQOkwYq0Z7QtjcJAJDFsISmvsU5JWd2s8cHggFV+2siRkTtWU3PHZ6y5w16dcKA49SzhavK7UuwolDV7/xdZvkuSZI1Z4QCO3+MOCZh2sUH9Brtye3x6ZE3V8uUFGez6JenjZLdxuhZAB2rTZF+amqqbrjhBt1www3tVojb7dZpp52mE088MWL7oEGh3whs27aNcAkAuqglS77TtddeqeHDR+jyy69SQcFuvfTS8/rxx9WaP/9hWfbRjLS8vExXX325fD6f5syZq0AgoOeee1obN27Qww8/Kbvd3ug5xTUl+qFotX4oWq0NZZuanOrWw5Gu3IzhGpk+TENSBxEmAUAUWS1WJdU1/j7YAoWbVfPuP2XWhH7ZYBt8pKxZgyLCJefc+w96Ha3xzHvrVFoZamI++9ghyslwRrkiAN1Rx64Nuh8ul0u///3vG21ftGiRJGnIEIZ2AkBXNX/+v5Sd3VPz5j2k+PhQ89Hs7J76xz/u0jfffKWJEyc3+bznn39WhYUFevLJ5zVgQGip5dzc0br22iv1zjtv6rTTzpRpmtpWmacVdYFSftXORueJs9g1LG2wRmYMV276cGUlNt/wFgDQtfh3rFHNwn9JvtDKn3GHniT7mBPkfvrq8DHxR/9cFkfsLNDw9apd+mZ1aLremMEZmja2Zb1uAaC9tSlcqq6u1iOPPKL3339feXl5kqQ+ffpo5syZuvjii5udwtBSy5cv10MPPaQZM2Zo8ODBLX5eRkbXaf6dmRk737yAWMV10rnV1tYqK6uHTj75RPXps6f56LHHTtU//nGXdu3apszME5p87scfL9IRRxyhww8fE9520kkzdN99A/Xeh28rfkKSvty2WEXVJY2e2yMxXRN6jdGE3mM0MnOI7NbGo5y6Gq4VoHlcJ91T9fol2v3uPyW/V5KhjJm/UMrhJ2nTX88OH2PEJaj31FOiV+ReCkqr9ez76yRJyc44XX/hBKV10OpwXCdAy3Sna6XV4VJZWZnmzJmjjRs3Kj09PTxVbcuWLZo/f77effddPfvss0pNTT2gwpYsWaLLL79cffr00W233daq5xYXVykYbHoFis4kMzNJhYWV0S4DiGlcJ13DnXfeK0kR/5bffrtUkuRypTX5b1xRUaHt27dr6tTp4f273QVaXLBcNakBbV25QuaPkX2X+rp66ZDMURrTY5T6uHJkGIYkqazEI8lzEN5Z7OBaAZrHddI9+TZ9K88HD0pmQDIscky/TN4BR2n76w9GHOe86P6Y+f8RNE3d89xSuT1+SdJPZw2Xv9anwkLfQX9trhOgZbratWKxGPsdyNPqcOm+++7Tpk2b9Ic//EHnnXeerNbQ8puBQEAvvPCCbrvtNs2bN6/JKW4t9fbbb+vGG2/UgAED9Mgjj7SoKSsAoGvYtWunvv9+sebNu1eDBg3W0UdPb/K4oqICSZIzzaX3t36sJbuXaXvVDklSIMFU0ONXwOPX0OzBGp91mMZk5irdwfcTAMAevrWfyfPpY5JpShabEmZcKduAsQpWFMi38r3wcQkn3yDDGjMdRfTet9v147YySdLRh/bS2GGZ+38CABxkrf4K+eGHH+rcc8/VnDlzIrZbrVZdcMEFWrNmjRYtWtTmcOnxxx/XXXfdpSOOOELz589XUlL3GUYGAN1dRUW5zjnnVEmSw+HQb37zW8XHxzc+zlupL7Z8I0l6J+9DZWyMXMUnJTFFhdqu6w65QsP6Dj34hQMAOh3v6g9V+3ndyta2OCXMvEa2PqNkmqbcz+9ZuMiSNUi23rlRqrKxbbsr9d9PNkqSstISdN5x9KYFEH2tDpeKior2u2pbbm6uXn311TYV89JLL+nOO+/USSedpLvuuktxcXFtOg8AoLMydMstt8vn8+nll1/QtddeqVtuuV3Tph2nal+Nlheu1OLdy7S2dIOq6n5jWy8rsYcmZB2m8dmH6X8bXtYGrVR6AiOVAACNeX/8ZE+wFJegxBOuk7Vn6JcRnk8ejTg28fS2z8hobz5/QA+/sVqBoCmLYejSU3PliIudEVUAuq9WfyXq0aOH1qxZs8/9a9asUY8erV9lp7i4WH/961/Vu3dvzZkzR6tXr47Y369fP6Wnp7f6vACAziM5OVnHHTdTkjR9+nG68KKf6J5779La9DytLv5RfjMQPtYSF5qWPSxpkC49/Jfq4+oV7qFUWxtaktnpZDlmAEAk3/ovVfvpE6EHcQlKPPl3smYOkCQFSnfIv+7z8LGJZ/xRhmHp+CL34fXPtyi/yC1JOmVSfw3ulRLligAgpNXh0vTp0/XCCy8oNzdXP/nJT2SxhL7YBoNBvfTSS/rvf/+r2bNnt7qQzz77TDU1NcrPz2805U6S7r77bp1++umtPi8AoHPxBXxaXbJWS3YvV6C/TWVflej7rUtlc4ZGsybZXRqbNUYjhw3Vrx74Vr2NbPVNilx6uaioUC5XkhISEqLxFgAAMcq36Vt5Pn5YkinZHUo88f/CwZJpmqp+6ebwsda+h8iaNSg6hTZh445yvfPNVklS/55JOnXygOgWBAANtDpcuvrqq/Xll1/qlltu0f3336+BAwdKkjZv3qySkhL169dPv/71r1tdyBlnnKEzzjij1c8DAHRuW7du0XXXXaWjTzteqYdn64fC1fIEQiu3+Tw+yZASHYkal3OYJmQfpmGpg2W1hEYt5eT01rp1axudc/36tRoxYt9TuAEA3Y9/69K6VeHMUI+lE66VNXtPvyLP+/Mijk844bqOLnGffP6AHntrTah0q6GLTx4pqyV2RlQBQKvDpbS0NP33v//Vww8/rEWLFmnFihWSpL59++qcc87RpZdeKpdr38vTAQAgSZXeKi0rXKllxStUVF6kN/73iobmHC6LLfTDslkRUNWaYg0bNVJ3H3er7JbG37KmTTtWL764QFu3blH//gMkSd999422bduqCy64qCPfDgAghgV2b1DNogckMyBZbUqY9RvZcobv2V+8Xf4tS8KPE8+5LTzVOha89tlm7SyuliSdNnmg+mTyeQtAbDFM0zSjXUR7Ky6uUjDY+d9WZmaSCgsro10GENO4Tjqnal+Nbv3mb6r0VkmSSpfv0rb/rpazb4pGTxqrdCNVX737sfx+vx544BENGjRE+fl5WrnyB40ePUa9e/cJPa+0VHPnzpbVatV5582R1+vVggVPqXfvvvr3vx9lYYgGuFaA5nGddE3Bsl2qfv02mbVVkmFRwqyrZet3WMQxlQ/9LHzfNugIJcz4VccWuR8b88t1+zNLZJrSgJ5J+n9zx0d11BLXCdAyXe1asVgMZWTsO9hmaQEAQIcLmAH5Aj5JUnJckiafeIS8A4/VJ/97X9+/8oUcjgSNH3+4LrvsV+rXr78kafnypbr99lt0881/CodLaWlpmj//Id133z/06KMPKj7eoalTp+lXv7qGYAkAoGBNharf+XsoWJIUP/WnjYKlmo8fjnjsOO6KjiqvWV5fQI82nA53Si7T4QDEpGZHLr322mttOnE0+ycxcgnoPrhOOq8ST6ncvhr1dvWUJYZW4umquFaA5nGddC2m36vqN+5QsHCzJClu3OmKn3BmxDHByiK5n7s+/Djx7L/ImtG3Q+vcnxc/3KB3v90mSTr7mEE6eeKA6BYkrhOgpbratXLAI5duvPFGGYah1syeMwyD5twAgP1Kd6Qp3ZEW7TIAAF2QaZryfP5kOFiyDZuiuPFnNDquYbBkzRkRU8HShrxyLawLlgbmJOuEI/tFuSIA2Ldmw6WnnnqqI+oAAAAAgHbhW/2B/Ou+kCRZew6T4+ifNWrQXbvktYjHCafc0FHlNcvnD+ixt9fIlGSzWlgdDkDMazZcOuKIIzqiDgAAAAA4YP5d61T75XOSJCMxVY4Zv5Kx14qjZq1b3gbhUsLJN8iIoSnab3y5RbtKQqvDnTl1oHr1cEa5IgDYv9j5CgoAAAAAB8D0VMmz6AHJDEgWmxKOv0qWxNRGx1U9eWX4vuFMk613bgdWuX/bC6r0zteh6XD9s5M084jYmaoHAPtCuAQAAACg0zNNU57PnpBZXSZJip90gazZQxod51v7WcRj53l3d0R5LRIMmnrinR8VCJqyGIZ+duIIpsMB6BT4SgUAAACg0/Ov/0L+zYslSbYB42QfOb3RMabfK88nj4YfO6ZfJsNq77Aam/PBkjxt3lkhSZp1RF/175kU5YoAoGUIlwAAAAB0asGqEnm+eEaSZCSkKP7onzdq4C1J7gX/F/HYPnRSh9TXEkXlNXrl002SpMxUh06bMjDKFQFAyxEuAQAAAOjUar9aIPk8kiTHMRfL4mg84sefv1qmpzL82PXT+R1WX3NM09TTC9ep1heQJP30hBGKt1ujXBUAtBzhEgAAAIBOy799xZ7pcIOPkq3fmEbHmKapmrf29FaKm3CWjPjYWYHtm9W7tWJTsSRp8iE9lTsgPcoVAUDrEC4BAAAA6JTMYECeL58NPbA7FD/xvCaP83z0YMTj+HGnHezSWqyqxqcFi9ZLkpIT7Zp97NAoVwQArUe4BAAAAKBT8q/7Qmb5LklS/PgzZElMbXRMsLpc/g1fhx87f3JnR5XXIq98slFVNT5J0vkzhsmVEDsNxgGgpQiXAAAAAHQ6ZsCv2u9flyQZznTZc49t8jj3M9eE71uyBsuS2rND6muJzTsr9MmyHZKk3AFpOmJkVpQrAoC2IVwCAAAA0On4N34tsyrUpyhu7KkybHGNjvFt+jbiceJpN3dIbS0RNE09+/46mZKsFkNzjh/W5Ap3ANAZEC4BAAAA6HS8qz+UJBkJKbIPn9pov2kG5Vn0QPix45iLZVhiZwW2L37YqU07KiRJMw/vq5yM2GkwDgCtRbgEAAAAoFMJFG1VsGCTJMk+4mgZVlujY2revTficVMBVLS4PT699PFGSVJaUrxOnTwgugUBwAEiXAIAAADQqfg3Lw7ft484ptH+YFWJAtt/CD92nn9Ph9TVUq9+uincxHv2sUPkiGscjgFAZ0K4BAAAAKBT8W9dKkmy9BggS1KPRvvdC64L37f2HtXkMdGybXelPlqaL0ka2T9Nh4+giTeAzo9wCQAAAECnYXqqFCzJkyTZ+h3aaL9v03cRjxNO/L8OqaslgqapZ95bJ9MMNfG+gCbeALoIwiUAAAAAnUageFv4vjVrUMQ+0zTlWTQ//DjUxDt2PvJ8tXKXNuSXS5JmTOij3j1o4g2ga4idr7QAAAAA0Ixg+a7wfUt6n4h9no8ejHgcS028qz0+vfTRBklSiitOp00eGOWKAKD9EC4BAAAA6DRMT2X4vpGQvGe7t1r+DV+HHzvPu7tD62rOa59tVkV1XRPv6UOUEE8TbwBdB+ESAAAAgM7DNPfcN/Z8nKl67rfh+5a0PrIkx06j7O0FVfrg+1CfqOF9U3VkbnaUKwKA9kW4BAAAAKDTMOyOPQ+8NZKkQMl2qdYd3px45h87uqx9Mk1Tz7y3VqYpWQxDc2bSxBtA10O4BAAAAKDTMBqMSAqUbJckVb/8h/A2+yGzZNjiOryufflmzW6tzws18T5ufB/1yXRFuSIAaH9M9AUAAADQaVizh0gyJJnyb1os010asT/+qPOiUldTfP6gXvlkkyQpOdGu06fQxBtA18TIJQAAAACdhiUhWdY+oyRJvrWfyfPRQ+F9juN/HVNTzj76Pk9F5R5J0ulTBynRwe/2AXRNhEsAAAAAOpW4w04J3Ql4I7bbB46PQjVNc3t8euPLLZKknumJmjomJ7oFAcBBRLgEAAAAoFOx9Rohe+6xEdsSf3J7lKpp2ttfbZXb45cknX3MYNmsfPQC0HXxFQ4AAABAp2NJ77vnfkY/WVN7RbGaSMXlHr2/OE+SNKR3isYN6xHligDg4GLSLwAAQCfn2/K9fD9+IktiqiwpPWVJ7SlLSo6M5B4yLPy4h67H9NfKu/R/kiTDma7E038f5YoivfrZJvkDQUnST6YPiak+UABwMPDTBgAAQCfnXfKagsXbFNh7h2GVkZwpS0q2LKk5oeCpLnwyElL4wItOy7tyUXiVuPgJZ8qwxUW5oj227a7UVyt3SZLGD8vUkD4pUa4IAA4+wiUAAIBOLn7Cmapd/JqCJdslM7hnhxmQWb5LgfJdCmxbHvkke0LdCKeeDUY7hf4Y9viOfQNAK5ieKnmXvSlJsqT1lm3o5ChXFOmljzfKlGQxDJ09bXC0ywGADkG4BAAA0MnZ+o+Vrf9Ymf5aBYq2KliwUYGCTQoUbJJZVdz0k3w1ChZuVrBwc6NdhjO9wWinbFlSckKjnVw9ZFho2Ynoql32puStkSTFH3FuTP2fXLW5RKs2l0iSjhnbSz3TE6NcEQB0DMIlAACALsKwxcvWc5jUc1h4W7C6TIGCTQoWbFKgYKMChZsln2e/5zHdJQq4SxTYsSZyh8UmS0pWg9FOOTLqp9nFu5hmh4MuWFkk38pFkiRrznBZ+x0a5Yr2CJqmXvpogyQpPs6q0yYPjHJFANBxCJcAAAC6MEtiqiwDxkkDxkmSzGBQwbKde0Y3FW5UsCRPMs3mTxb0K1i6Q8HSHY33xTsbTa+zpPaUJTk7pvrhoHOrXfyqFPRLqhu1FEOB5jerdmtbQZUk6cQj+ynFyf97AN0H4RIAAEA3Ylgssqb3ljW9t+wjjpYkmb5aBYq27BndVLBJprukdSeudStYsFHBgo17v6KMpIw9gVN96JSaI8OZJsOInSlNiG2B4u3yr/9SkmQbMF7W7CFRrmgPnz+gVz4N/d9PccZp1uH9olwRAHQswiUAAIBuzrDHy5YzXMoZHt4Wmk63sS5w2tSi6XRNM2VWFilQWaRA3srIXda4up5ODVazqxv5ZMQ7D+xNocvxLnlNkikZFsUfcU60y4nwwZJ8FVfUSpJOnzpQ8XHWKFcEAB2LcAkAAACNhKbTjZcGjJdUP51uR0TgFCxt4XQ6SbJYJcMiBXx7tgW8CpZsD61ytxfDkRRuKG7UNRS3pPSUJTlLhpUfYbubQNFW+bcskSTZhk6WJTUnyhXtUVPr19tfb5Uk5WQkauqY2KkNADoK35kBAADQrNB0uj6ypveRRhwjSTJ9HgUKt9Q1DN+oQOEmme7Spk8QDEh2uwxXhoy4RBnxiTLiEmX6ahQs2yWzskjSnqDK9FQqsKtSgV3r9irEkJGUGW4o3nDUk5GYGlM9eNB+vN//L3THsCh+3KnRLWYvH36fp6qaUGh65tRBssbQ6nUA0FEIlwAAANAmht0hW68RsvUaEd4WdJc2GN20UYHCLZI/NF1IPo/M8l1qONbJcGXImjVIlhFHy3AkybDFKeguUbBst4LlO2WW7ZJZW7XnCaYps6JAgYoCBbb/EFmQ3VE3za5Bb6eUutFPcQkH7e8BB1egeFvkqKXkrChXtEdNrV8Lvw2NvOud6dS44ZlRrggAooNwCQAAAO3G4kyTZeAEaeAESXXT6UrzQ4FTYf10uvzwdDqzqlj+qmJp03ehExgWWdL7ypo1SHEjjpEla5CMhGSZ5bsVLN+lYNmu0Gp35bsVrNglBfx7XtznUbBoq4JFWxvVZSSm7tVQvK63U1KmDAv9cWKZd8nroTsxPmrp9MkDZWHkHIBuinAJAAAAB41hscia0VfWjL7SyGmSJNNbo0BR/XS60Agns7os9AQzqGDxVgWLt8q35qPQNnuCrFkDZc0cJGvWYNlHHy9LYorMYFCmuzgUONUHT+WhP2ZVcUQdZnWZAtVlCuz8ca8CrbIkZ8qSmqPinH7yxqWHQygjIZlpdlEWOWppEqOWACBGES4BAACgQxlxCbL1Gilbr5HhbcGqktA0uoJNoRFOhZslvze001ejQP5qBfJX7zmHK0PWrMGhKXVZg2UfcYwMW1x4v+mvVbC8QMHynXuFTzslb82eYsxAOJAq37o0stC4hPC0usjV7LJl2OIPyt8NIkWMWhrLqCUAiFWESwAAAIg6iytdFle67IMOlySZwUDddLq6ZuEFmxQs3aH6pt/10+n8m74NncCwypLRR9YeA2VJzZG113BZewwIjZhqwDRNmZ7Kuql1ocDJrAuXghWFUrDBNDtvjYKFobBrb4Yzfa+G4tmypOSEGpbT0LldBIq3R45aSsmOckV7eLyMWgKAhgiXAAAAEDNMMxhq/F1bLZlmaJSQI0nWnsMUrCpWIG+VArvXN/HEQKN+S/FHzlbcoSdGHGYYhoyEZFkSkqWc4RH7emQkqmDT5rrRTqGG4sHy3QqW7dwzba/+5dwlCrhLFMhfFVmH1SZLcnaDUU4996xm53Ad0N9Nd+P9PpZHLeUzagkAGiBcAgAAQLszgwGZtW6ZniqZtVUyPVVSg/tmbZXM2mqZ3urQba1bprda8laHm30fqGD5rlYdb1isdSOQsqV+e70fb42CFbsbTbELlu+WfJ49Bwb8Cpbmh5qW733+eJeM1J6RwVNKjizJmRFT+lA3amnzYkmxOWrp3W+2SWLUEgDUI1wCAADAfpnBYCgMqqmU6amQWVMh01Mp0+OODIs8e+5H9DVqV4YUlyAj3ikjLlFGfGL4VnGJMmxxCrpLZe3RX/bhR7ffq8YlhKbZ9RgQsd00TZnVZY0aigfLdsmsLJTM4J5ja6tk7t6g4O4Ne53ckOHq0SBw2hNAGc40GUb3m2bXWUYtncaoJQCQRLgEAADQ7ZimKflrQyFRTYXMmkoF60OjiD91YZKnst1GE0mSLNbQKJ54p9QgHDLinKHbuvuKT2wUIikuIabCFsMwZDjTZHGmSQ0alEuSGfArWFkgs36KXcPV7GoqGhxoyqwsVKCyUIHtKyJfwBYX7ue0d2NxIy6xA95hxwuU5DcYtTQxdkct9XBqPKOWAEAS4RIAAECXYZpmaHSMu0xmdehPsLos/DhYt82sqZQC3vZ5UbtDhsMVCosa3jZ53ykj3hV6TjcY7WFYbbKm9pJSe0kaG7HPrHWH+zmFRzuV71KwbHfkv43fq2DxdgWLtzc+f0Jygyl2DUKn5EwZls77Y773h3fq7hmKPyy2Ri19umzHnlFLUxi1BAD1Ou93HQAAgG7E9HtluksUrCqRWVXcdGhUXR652llb2B0yEpJDwYUjKXw/4o8jaU9gZOXHybYw4p2yZg2SNWtQxHbTDMp0l0b0dAoFULtlVhapfrU8STJrKhSoqVBg17q9Tm6RkZzZYHrdnlFPRkJKTAd7QXep/Bu+kiTZBo6XJbVnlCvawx8I6r3FoZAvOz2RUUsA0AA/DQAAAESZGQyGwiF3iYJVxTKr6m4bPDY9lW1/gbgEWRJTZdT/qQ+PEpJlJCTJcNQHR0kybPHt98bQaoZhkeHKkMWVIfUZFbHP9HsVrChoor/TTqnW3eDAoMzy3QqU71ZAyyNfwO7Yq6H4nvDJsDs64B3un3fFe1IwIEmNVvqLtu9+LFBJRa0kadYRfRm1BAANEC4BAAAcZKZpSrXuUDBQWahgRaHMysI996tKJDPQ+hPvHRolpsribHC/frudwKgrMGxxsqb3kTW9T6N9pqcqcopdOHzaHTmazedRsGiLgkVbGp/fmdaoobglNUeGK0OGxXoQ31nde/BWy7fmI0mSNWe4rFmDD/prtpRpmlpY12spOdGuyaNjZ0QVAMQCwiUAAIB2YJqmzJry8BSmYPkumRV7AiT5Wrl6mi1eFleGDFe6LK700GgWZ4NbZxqhEcIMh0vWnkNl7Tk0YrsZDIamUUZMsatbzc5dEnmsu1QBd6kCO9ZEntxilSU5O6KhuFE38slwJLXbNDvv6o8ln0dS7I1aWr21VNsKqiRJx43vI7vt4IdtANCZEC4BAAC0gun3RnxAbzhSpDUBkuFIkpGUKUtSD1mSeshI6rEnPHKlS3GJMd0bB52DYanrv5ScKfWN3Gf6ahWs2L2nv1PZPv4vBwMKlu1QsGyHtHVp5EniEhs0FG+wml1KtgxbXIvrNAM++Va+J0mypPWWte+Ytr7lg6J+hbg4u0XTxzUeOQYA3R3hEgAAiDnffPOVnnzyUa1du0YWi0W5uYfo0kuv0OjRh+z3eTt25GvevHu1dOkSSdKkSVN01VXXKi0trdU1mMGgzMoCBUryFKz7EyjJk1mxWzLN5k9gscmSnFkXIIU+3BvJdfeTMmXEJbS6JqA9GfZ4WTP6yZrRL2J7aBReRURPJ7N+1FNFYeQUTm+1ggWbFCzYtPfZQ6PuGvZ3qh/15EqXYVgijvZv+FpmdZkkKW7MCY32R9O23ZVatTk0ymvqIb3kSrBHuSIAiD2ESwAAIKYsXbpE119/tQYOHKTLLvuVAoGAXn31Zf3615dp/vyHlZs7usnnlZeX6eqrL5fP59OcOXMVCAT03HNPa+PGDXr44Sdlt+/7A6Hp9ypYvE2Bws0KFG0NhUmlOyKXhN8Hw5m+V3Pk0CiOUJ+a2PmADLSUYRgyElNkSUyRcoZH7DODgVC/sLK9ezvtCodDdUfKrCpWoKpYgfxVkS9gtYdGOTVoKO5d/nbotRNTZRsy8eC+wVZa+G1ohTjDkI4/om8zRwNA90S4BAAAYsp99/1dWVnZeuihJ+VwhFavOuGEkzVnzrl66KEHdO+9DzT5vOeff1aFhQV68snnNWDAQElSbu5oXXvtlXrnnTd12mlnSgp9OA6W5ClQsEnBos0KFG5WsCRfMoP7rctIypQ1vY8s6X1kSeu9ZxQGfY/QjRgWq4y6UGhvpremrt/YzsZTRv21ew4M+MKjAfcWd8gsGdbY+YhSUuHRt2t2S5LGD89SViojDgGgKbHzlRsAAHR7FRUV2rBhvc4778JwsCRJ6ekZOuywcfruu6/3+dwPPnhPhx02PhwsSdLhhx+pfn37adHbr2pWH4sCO9cpULAx3DS4SfFOWdP7hkKkupW5LGm9mcYGNMOIS5A1c4CsmQMitpumKbO6LDzFrmFjcbOyMDzN1EhIln3ktI4vfD/eX7xdgWCovhOP7NfM0QDQfREuAQCAmOF0OrVgwX+VkNA4yCkvL5PV2vQKTRUVFdqxI1/Tph0nMxhUsGiL/HkrFMhbpUG2Cn23Nk/exa82fqK9/sPwQFnqbg1XDxppA+3IMAwZzjRZnGlSr5ER+8yAX8GKApmVhbKk942pELfa49cny3ZIkob3TdXAnOQoVwQAsYtwCQAAxAyr1aq+fRuPDtiwYb1WrFiuI45ouhdLQf4WSVJq6Tq5n75aZm1VeF96glVuX1Bub0CuzN6y9Rwma8+hsmQPDk1ri6HGwUB3Y1htsqb1ktJ6RbuURj5Zni+PN9S8/ARGLQHAfhEuAQCAmFZdXa3bbvuTJOnCC38a3h6sqZB/y/fyb/pOJcsWS5LsZdtkZqaHj7Gk9pKjZ6K0uliW0/8sV9/BHVs8gE4pGDT14ZJ8SVJORqIOGZwR5YoAILYRLgEAgJjl8Xh0443XacOGdbroop/rsEMOkW/DV/Kt/VyBHavDvVrM+p4ttjjZBk6Qte8hsvUZLYsrQ7ayByR9K0tCShTfCYDOZPnGIhVXhHqzzRjfRxamygLAfhEuAQCAmFRZWakbbviNVqxYrpOOO1Zzc12qeuYayVsTcZyRkKKk4WOkdzdJ485RwvHnReyvrQ2tUuV0OjusdgCd24dLQivZJcRbNXF045XxAACRCJcAAEDMKS0t0XXXXaX169fppMMG6apeu+VfUxDeb8S7ZBtypGyDj5Q1e4j6Vrmlfy1QcUlxo3MVFRXK5Upqskk4AOxtZ7Fbq7aUSpImj86RI46PTADQHL5SAgCAmOIuL9G1v/qZNmzfoTNHZuiyMYmhHYYha59DZB8+Vbb+h8mw2sPPSUpKUk5Ob61bt7bR+davX6sRI0Y22g4ATfnw+/zw/enjekexEgDoPAiXAABATAi6S+Vb9YHufuARbdhepNNHZuiyw3Mku0P2EccobvQMWZIy9/n8adOO1YsvLtDWrVvUv/8ASdJ3332jbdu26oILLuqgdwGgM/N4/fpixU5J0qiB6crJYDotALQE4RIAAIi62u9fl/f7/2lbiVsfbCiSK86iwTk99KllpKxZw2VUxElffidJmjXrJOXn52nlyh80evQY9e7dR5J0wQVz9e67b+maa67QeefNkdfr1YIFT2n48JGaOfOkaL49AJ3Et2sK5PEGJEnHMmoJAFqMcAkAAESdd/k7UjCgFburJUlV3qD+8eFaSY2nuc2adZKWL1+q22+/RTff/KdwuJSWlqb58x/Sfff9Q48++qDi4x2aOnWafvWraxQXF9eRbwdAJ/XZ8h2SpFRXnMYMzohyNQDQeRAuAQCAqHMcc7ECuzfo3NMP13nZQ5o9/qSTTtVJJ53aaHu/fgN0zz33HYwSAXRx+UVubdxRIUmafEiOrBZLlCsCgM6DcAkAAESdfdDhsg86PNplAOjG6kctSdLUMTlRrAQAOh/ieAAAAADdmj8Q1Jcrd0mSRvRLVVZaYpQrAoDOhXAJAAAAQLe2bH2Rqmp8kqSph/aKcjUA0PkQLgEAAADo1j79ITQlLiHepvHDMqNcDQB0PoRLAAAAALqtkgqPVm0qkSQdNSpbcXZrlCsCgM6HcAkAAABAt/X5ip0y6+4fPYYpcQDQFoRLAAAAALqloGnq8x92SpL6ZbvUv2dSlCsCgM6JcAkAAABAt7Rma6mKyj2SpKmMWgKANiNcAgAAANAtfVE3aslmteioUdlRrgYAOi/CJQAAAADdTq03oO/XF0qSxg3rIafDHuWKAKDzIlwCAAAA0O0s31gkry8oSToyl1FLAHAgCJcAAAAAdDvfrN4tSUqMt2n0wIwoVwMAnRvhEgAAAIBupdrj04pNxZKkccMzZbfxsQgADkTMfhVds2aNRo0apV27dkW7FAAAAABdyJJ1hfIHTEnSkSOZEgcAByomw6WNGzfql7/8pfx+f7RLAQAAANDFfLumQJKUnGjXiP6p0S0GALqAmAqX/H6/nn32WZ177rmqra2NdjkAAAAAupgKt1drtpRKkiaMyJLVElMfiQCgU4qpr6RLlizRPffco1/84he6/vrro10OAAAAgC5m8doCBc3QlLgjmBIHAO3CFu0CGho8eLAWLVqkjIwMvfLKK9EuBwAAAEAX823dKnHpyfEa0iclytUAQNcQU+FSjx492uU8GRmudjlPLMjMTIp2CUDM4zoBWoZrBWge10nXVlRWo3V55ZKkY8b1VXZWcpQr6py4ToCW6U7XSkyFS+2luLhKwaAZ7TIOWGZmkgoLK6NdBhDTuE6AluFaAZrHddL1fbAkL3x/dP9U/r3bgOsEaJmudq1YLMZ+B/LEVM8lAAAAADhYlq4vlCSlJcVrQM/uM6IAAA42wiUAAAAAXV61x6e128okSWOH9pBhGNEtCAC6EMIlAAAAAF3eDxuLFahrnTF2WGaUqwGAroVwCQAAAECX9/36IklSQrxNw/umRrcYAOhiCJcAAAAAdGk+f1ArNhVLkg4dnCGblY9BANCeYvar6llnnaW1a9eqZ8+e0S4FAAAAQCe2Zmupar0BSUyJA4CDIWbDJQAAAABoDys2hkYtWS2GRg9Mj3I1AND1EC4BAAAA6NJWbg6FS0P7pCgh3hblagCg6yFcAgAAANBlFZbVaHdpjSRpFKOWAOCgIFwCAAAA0GWt3FwSvj96YEYUKwGArotwCQAAAECXtbJulbjkRLv6ZruiXA0AdE2ESwAAAAC6JH8gqB+3lUqScgemy2IYUa4IALomwiUAAAAAXdKmHRWqqQ1IEqvEAcBBRLgEAAAAoEtq2G9pFP2WAOCgIVwCAAAA0CWt2hzqt9Qvy6UUZ1yUqwGArotwCQAAAECXU1nt1ZadlZKkUYOYEgcABxPhEgAAAIAuZ/WWUpl190czJQ4ADirCJQAAAABdzqotoX5L8XarhvROiXI1ANC1ES4BAAAA6HLWbS+TJA3tkyK7jY89AHAw8VUWAAAAQJdSVlWrgtIaSdKwvqnRLQYAugHCJQAAAABdSv2oJYlwCQA6AuESAAAAgC5l/fZySZLNamhgTlKUqwGAro9wCQAAAECXsrZu5NKgnGTZbdboFgMA3QDhEgAAAIAuo9rjU35hlSRpKFPiAKBDEC4BAAAA6DLW55XLrLtPvyUA6BiESwAAAAC6jHV5ZZIkw5CG9E6JbjEA0E0QLgEAAADoMjbvqJAk9cl0KSHeFuVqAKB7IFwCAAAA0CUETVNbdlVKEqvEAUAHIlwCAAAA0CXsLqmWxxuQJA3ISY5yNQDQfRAuAQAAAOgStuysDN8f2JNwCQA6CuESAAAAgC5h885QvyWb1aLemc4oVwMA3QfhEgAAAIAuob7fUr9sl2xWPuoAQEfhKy4AAACATi8QDGrb7lC4NKAnzbwBoCMRLgEAAADo9PIL3fL6g5KkgTTzBoAORbgEAAAAoNOrnxInsVIcAHQ0wiUAAAAAnd6Wumbe8XarctITo1wNAHQvhEsAAAAAOr1tBVWSQs28LRYjytUAQPdCuAQAAACgUzNNUzuK3JKkPpmuKFcDAN0P4RIAAACATq20slYeb0CS1KuHM8rVAED3Q7gEAAAAoFOrH7UkSb0y6LcEAB2NcAkAAABApxYRLjEtDgA6HOESAAAAgE4tvy5ccjpsSk60R7kaAOh+CJcAAAAAdGo7ikPhUq8eThkGK8UBQEcjXAIAAADQaYVWiquWJPWmmTcARAXhEgAAAIBOq6zKq5pavyQph3AJAKKCcAkAAABApxXRzJtwCQCignAJAAAAQKcVES5lEC4BQDQQLgEAAADotHbWNfNOiLcp1RUX5WoAoHsiXAIAAADQaRWU1UiSstMSWCkOAKKEcAkAAABAp1VU7pEk9UhNiHIlANB9ES4BAAAA6JSCQVPF9eFSiiPK1QBA90W4BAAAAKBTKquqVSBoSpIyCZcAIGoIlwAAAAB0SvVT4iSmxQFANBEuAQAAAOiUCuuaeUtMiwOAaCJcAgAAANApFTcYuZSRTLgEANFCuAQAAACgUyosD41cSnHGKc5ujXI1ANB92aJdAAAAAAC0RDBoqrjCo10l1dpVXK2128okST1SGbUEANFEuAQAAAAgplR7/KEAqcStXSXV2llcrV0l1dpdUiN/INjo+KzUxChUCQCoR7gEAAAAoMMFgkEVlXu0qy44qg+QdpVUq8LtbdE5HHFW9c1y6YQj+x3kagEA+0O4BAAAAOCgqarx1YVH7vB0tl0l1SoorVEgaDb7fMMIrQTXM92pnIxE9Uyv+5ORqBRnnAzD6IB3AQDYH8IlAAAAAAfEHwiqsKxmzyikuhFIu4qrVVXja9E5EuNt6pmRqJy64Kg+RMpKS5TdxjpEABDLCJcAAAAANMs0TVVW+8JT1xoGSUVlLRuFZDEMZaY61DM9UTkZzogQKSnRzigkAOikCJcAAAAAhPn8QRWUVjcKkXaVVMvt8bfoHK4Ee3jqWk6DaWyZqQmyWRmFBABdDeESAAAA0A2ZpqkdRW6tzyuPCJIKy2tkNj8ISVaLoay0hHBw1DM9UTnpodFIrgT7wX8DAICYQbgEAAAAdBNB09SGvHJ992OBlm8oUlG5p9nnJCfWj0JyRoxG6pHqkNXCKCQAAOESAAAA0KU1DJQWry1QeZW30TE2q6HstMSIUUj1IVKig1FIAID9I1wCAAAAuqCishp99sNOfb5ip0orayP2GYY0vG+qDhvSQ6MHZahneqIsFpppAwDahnAJAAAA6CL8gaCWrS/SJ8t3aPXmEjVsnWQY0oh+aTp8ZJbGDctUcmJc1OoEAHQthEsAAABAJ1dT69dny3fo/cXbVVwROUppYE6yphzSU+OHZynZSaAEAGh/hEsAAABAJ1Xt8endb7fpgyX5qqn1h7cnxts0cXRPHX1oL/XNckWxQgBAd0C4BAAAAHQytb6APlySp7e/3iq3Z0+olJ2eqBOO6KuJo3oqzm6NYoUAgO6EcAkAAADoRJatL9Kz76+NmP42MCdZJ0/sr8OG9pDFoDE3AKBjES4BAAAAnUCF26unF67VknWF4W29ejh19tGDdNjQHjIIlQAAUUK4BAAAAMS4VVtK9Mgbq1Xu9koK9VQ6e9pgHXNoL1kshEoAgOgiXAIAAABilGmaev+77Xrhww0y67ZNGJGlOccPUworvwEAYgThEgAAABCDTNPUCx9u0HvfbZckxdktmnP8ME05JIcpcACAmEK4BAAAAMSg/36yKRwspbri9JtzD1W/7KQoVwUAQGOESwAAAECM+WLFTr399VZJUo8Uh26cM07pyY4oVwUAQNMs0S4AAAAAwB4FZTV6euFaSZIrwa7rzx9LsAQAiGmESwAAAEAMeX7Renn9QUnSL08fpazUhChXBADA/hEuAQAAADEiv8itZRuKJEmTD+mpUQPSo1wRAADNI1wCAAAAYsRH3+dJkgxJp0waENVaAABoKcIlAAAAIEas2lwiSRrRP03ZaYlRrgYAgJYhXAIAAABiQFWNT7tLayRJI/qlRrcYAABagXAJAAAAiAFllbXh+9npjFoCAHQehEsAAABADKjx+sP3Ex22KFYCAEDrEC4BAAAAMSDebg3fr/UGolgJAACtQ7gEAAAAxIBUV3z4fmGZJ4qVAADQOoRLAAAAQAxIdsYpOdEuSdq8syLK1QAA0HKESwAAAECMGN4vTZK0ekuJ/IFglKsBAKBlCJcAAACAGDFmcIYkye3xa+WmkihXAwBAyxAuAQAAADFi/PDMcGPvT5fviHI1AAC0TMyFS2+++aZOPvlkjRkzRieeeKJee+21aJcEAAAAdAhHnE1H5mZLkpZtKNK23ZVRrggAgObFVLj09ttv6/rrr9eUKVM0f/58HXHEEfrd736nd999N9qlAQAAAB3ipKP6yWIYkqRXPt0U5WoAAGieLdoFNPTPf/5TJ554om666SZJ0tSpU1VeXq5//etfOuGEE6JcHQAAAHDwZaUlavIhPfXZDzv1w8Zi/bCxSGMG94h2WQAA7FPMjFzavn27tm3bppkzZ0ZsnzVrljZt2qTt27dHqTIAAACgY511zGAlxId6Ly14f71qfYEoVwQAwL7FTLi0aVNoyO/AgQMjtvfv31+StHnz5g6vCQAAAIiGFGeczpgySJJUUFajlz7aEOWKAADYt5iZFldZGWpW6HK5IrY7nU5JUlVVVYvPlZHhav6gTiIzMynaJQAxj+sEaBmuFaB5sXSdzD5hpJZvKtbqzSX68Pt8TR3XVxNGZke7LCCmrhMglnWnayVmwiXTNPe732Jp+SCr4uIqBYP7P19nkJmZpMJCVggB9ofrBGgZrhWgebF4nfx01nD98bFvVesN6G9PL9YffzZBWWmJ0S4L3VgsXidALOpq14rFYux3IE/MTItLSgolem63O2J7/Yil+v0AAABAd5GZmqCfnzhCklRd69e8V1ao1ntg/Zfuuuuvuuqqy1p07I4d+br55t/qxBOP1YknHqu//OWPKi0tPaDXBwB0PTETLtX3Wtq2bVvE9q1bt0bsBwAAALqTI0Zm64Qj+kmS8grdevSt1Qo2M+p/X9588zW98carLTq2vLxMV199uVatWqE5c+bqvPPm6IsvPtW1114pn8/XptcHAHRNMRMu9e/fX3369NG7774bsf29997TgAED1KtXryhVBgAAAETX2dMGaWT/NEnS4rWFev6D9c22lWgoEAjo8ccf1l13/bXFz3n++WdVWFigf/3r37rwwp/ppz+9WH/5y13asGGd3nnnzVa/BwBA1xUz4ZIkXXnllXrzzTd166236tNPP9Wf/vQnvfPOO7rmmmuiXRoAAAAQNVaLRb86c7R69QgtdrNocZ4Wfru9Rc+tra3VL35xoR599EHNmnWSMjOzWvS8Dz54T4cdNl4DBuyZQXD44UeqX7/++uCD91r/JgAAXVZMhUtnnXWWbrnlFn3++ee68sor9d133+muu+7SSSedFO3SAAAAgKhyOuy69txDlZYUL0l68aMN+mrlrmaf5/V6VV3t1i233KHf//4WWa3WZp9TUVGhHTvyNXz4iEb7hg0bobVr17T+DQAAuqyYWS2u3nnnnafzzjsv2mUAAAAAMScjxaFrzz1Udzy7RDW1AT361ho54qwaOyxzn89xOp167rlXZLO1/Ef/oqICSWpylFNGRg9VVVWpqqpKLte+Vw4CAHQfMTVyCQAAAMD+9cly6eqzx8husyhomvr36yu1cnPxPo+3WCytCpYkqbq6WpLkcDga7YuPD42c8nhqWnVOAEDXRbgEAAAAdDLD+6XpyjNHy2ox5A+YmvffFVq3vazdzl/fLNww9nfUfncCALoRwiUAAACgExozuId+edooGYbk9Qd170vLtXlnRbucOyEhUVKoGfje6rc5nc52eS0AQOdHuAQAAAB0UhNGZOnik0dKkjzegP754nLtLqk+4PNmZ/eUJBUVFTXaV1RUKJcrSQkJCQf8OgCAroFwCQAAAOjEJo3O0YUzh0mSqmp8+vsLy1Re1XjEUWskJSUpJ6e31q1b22jf+vVrNWLEyAM6PwCgayFcAgAAADq5Y8f10amTBkiSiso9uu+/K+QPBA/onNOmHavFi7/R1q1bwtu+++4bbdu2VTNmzDygcwMAuhbCJQAAAKALOGPqQE0ZkyNJ2ryzQi9+uKHFz83Pz9PChW8rPz8vvO2CC+YqOTlF11xzhZ5//hk99dRj+sMffqfhw0dq5syT2r1+AEDnRbgEAAAAdAGGYeiimcM1MCdJkvTJ8h0KBFs2emn58qX6y1/+qOXLl4a3paWlaf78hzRkyFA9+uiDevHF5zR16jTdc899iouLOyjvAQDQORlm/TqjXUhxcZWCwc7/tjIzk1RYWBntMoCYxnUCtAzXCtC8rnKdlFR49Oz769S/Z5JOmzww2uWgi+kq1wlwsHW1a8ViMZSR4drnflsH1gIAAADgIEtPdujXZ4+JdhkAgG6EaXEAAAAAAABoM8IlAAAAAAAAtBnhEgAAAAAAANqMcAkAAAAAAABtRrgEAAAAAACANiNcAgAAAAAAQJsRLgEAAAAAAKDNCJcAAAAAAADQZoRLAAAAAAAAaDPCJQAAAAAAALQZ4RIAAAAAAADajHAJAAAAAAAAbUa4BAAAAAAAgDYjXAIAAAAAAECbES4BAAAAAACgzQiXAAAAAAAA0GaESwAAAAAAAGgzwiUAAAAAAAC0GeESAAAAAAAA2oxwCQAAAAAAAG1GuAQAAAAAAIA2s0W7gIPBYjGiXUK76UrvBThYuE6AluFaAZrHdQI0j+sEaJmudK00914M0zTNDqoFAAAAAAAAXQzT4gAAAAAAANBmhEsAAAAAAABoM8IlAAAAAAAAtBnhEgAAAAAAANqMcAkAAAAAAABtRrgEAAAAAACANiNcAgAAAAAAQJsRLgEAAAAAAKDNCJcAAAAAAADQZoRLMeCqq67S8ccf3+Ljd+7cqfHjx+uBBx44iFUBsaUl10lhYaF+//vfa/r06Ro7dqzOOussvfPOOx1UIRB9LblO3G63brnlFk2ePFljx47VpZdeqi1btnRMgUCUmKapJ554QrNmzdKYMWN02mmn6Y033tjvc0pKSnTTTTdpypQpOuKII/TLX/6SawVdXluulWAwqH//+9867rjjNGbMGJ166ql66623OqhioOO15TppqKt+nrdFu4Du7vXXX9f777+vfv36teh40zR18803q6qq6iBXBsSOllwnXq9Xl1xyiSorK3X11VcrKytLCxcu1G9+8xsFAgGdcsopHVgx0PFa+v3k2muv1YoVK3TDDTfI6XRq3rx5mjt3rt566y0lJSV1ULVAx3rwwQd133336de//rUOO+wwffrpp7r++utltVp10kknNTreNE1deeWV2rZtm377298qNTVV9913n+bOnas33nhDKSkpUXgXwMHX2mtFkm6//Xa98MILuu666zRixAi99dZb+r//+z+5XC4dc8wxHfwOgIOvLddJva78eZ5wKYp2796tv/71r+rZs2eLn7NgwQJt2rTpIFYFxJaWXieffvqpfvzxR7300ksaM2aMJGny5MnasWOHHn74YcIldGktvU4WL16sTz75RA8//LCOPvpoSdKECRN03HHH6bnnntNll13WEeUCHcrn8+mxxx7T+eefryuuuEKSNHHiRK1cuVLPPPNMkx8EtmzZou+//1533XWXzjjjDEnS4MGDNWPGDH344Yc688wzO/ItAB2iLdfKtm3b9Oyzz+rWW2/VueeeG37Oli1b9NlnnxEuoctpy3XSUFf+PE+4FEW///3vNXnyZMXHx2vJkiXNHr99+3bdc889+te//qVLL720AyoEoq+l14nT6dTs2bN1yCGHRGwfNGhQi64voDNr6XXyxRdfyOl0avLkyeFt6enpOvzww/Xpp58SLqFLslqtevrpp5Wamhqx3W63q7q6usnn1NbWSgp9b6lXP1qprKzsoNQJRFtbrpVFixbJ4XCEQ9h6zzzzzEGqEoiutlwn9br653l6LkXJSy+9pFWrVukPf/hDi44PBoO68cYbdeKJJ4Z/2wx0da25TiZOnKhbb71VhmGEt/l8Pn3yyScaOnTowSwTiKrWXCebNm1S//79ZbVaI7b369dPmzdvPlglAlFlsVg0fPhwZWdnyzRNFRUV6aGHHtKXX36p2bNnN/mcESNG6Mgjj9T8+fO1ceNGlZSU6LbbblNiYqJmzJjRwe8A6BhtuVbWrl2rgQMH6ssvv9Rpp52m3NxczZw5U2+//XYHVw90jLZcJ1L3+DzPyKUoyM/P1x133KE77rhD6enpLXrOk08+qby8PP3nP/85yNUBsaEt18ne/va3v2nLli2aP39+O1cHxIbWXidVVVVyuVyNtjudzi459x/Y23vvvaerr75akjRt2jSddtpp+zz2z3/+sy655JLwFIe4uDjNnz9fffv27ZBagWhq6bVSUlKinTt36uabb9Y111yjPn366KWXXtK1116r9PR0HXXUUR1ZNtChWvM9pTt8nmfkUgerb+B1zDHHaNasWS16zsaNG3Xvvffq1ltvpdkquoW2XCd7P//uu+/Wk08+qYsvvpjfMqNLast1YprmPvdZLPxIgK4vNzdXzzzzjP7whz/o+++/12WXXdbkdbFx40bNnj1baWlpmj9/vh599FFNnz5dV199tRYvXhyFyoGO1dJrxefzhUf2/eQnP9GkSZP097//XSNGjNC8efOiUDnQcVrzPaU7fJ5n5FIHe/bZZ7V27Vq98cYb8vv9kvb8sO/3+2W1WiOm9QQCAd1000064YQTNHny5PBzpNDQOr/fL5uNf0Z0La29Thryer268cYb9dZbb+niiy/WDTfc0GF1Ax2pLdeJy+VSXl5eo3O53e4mRzQBXU3fvn3Vt29fHX744XK5XPrd736npUuXaty4cRHHPfHEE5Kkxx57LNxrafLkybrgggt0++2365VXXuno0oEO1dJrxel0ymq1RvTys1gsmjRpkl5++eWOLhvoUC25TrrT53l+TdnBFi5cqNLSUk2ZMkWjRo3SqFGj9Nprr2nbtm0aNWqUXn311Yjjd+7cqeXLl+u1114LHz9q1ChJ0v333x++D3Qlrb1O6lVVVennP/+53nnnHd18880ES+jS2nKdDBw4UNu3b2/0W7WtW7dq4MCBHVU60KHKysr02muvaffu3RHbc3NzJUkFBQWNnrNjxw4NHjw4HCxJkmEYGj9+vDZs2HBwCwaipC3XSv/+/cMfkBvy+Xz7/EUg0Jm19jrpTp/nu0ZE1onccsstcrvdEdvmz5+vNWvWaN68eerTp0/EvqysrCZT/3POOUfnn3++zj777INaLxANrb1OpNBvBa644gotX75c//znP3XCCSd0VLlAVLTlOpkyZYr+85//6Msvvwz/lrmkpESLFy/WL3/5yw6pG+ho9U1Uf/WrX4V7Y0ih1RMladiwYY2eM3DgQL366quqqKhQcnJyePvy5cvVu3fvg180EAVtuVamTp2qRx99VO+88074c4nf79dnn32m8ePHd0zhQAdq7XXSnT7PEy51sEGDBjXalpqaqri4uPAS6iUlJdq2bZuGDBkil8vVaGn1ellZWfvcB3RmbblOnn/+eX377beaPXu2evbsqWXLloWfaxiGDj300I4qH+gQbblODj/8cB1xxBG67rrrdP311ys1NVX333+/kpKSdP7553f0WwA6RHp6ui644AI99NBDcjgcOuSQQ7RkyRI9+OCDOvfcczVo0KBG18rPfvYz/e9//9MvfvELXXbZZXI4HHr99df17bff6p///Ge03xJwULTlWpk4caKOOeYY3XbbbaqurtaAAQO0YMEC5efn6+9//3u03xLQ7tpynXSXz/OESzHo448/1k033aSnnnpKRx55ZLTLAWLS3tfJwoULJUkvvPCCXnjhhYhjrVarVq9eHY0ygahq6vvJvHnzdOedd+ruu+9WMBjU+PHjde+990ZM/wG6mptuukk5OTl6+eWXdf/996tnz566+uqrdfHFF0tqfK306dNHzz33nO655x7ddNNNMgxDw4YN0+OPP65JkyZF+d0AB09rrxVJuu+++/Svf/1LDz30kMrLy5Wbm6vHHntMo0ePjuZbAQ6atlwn3YFh7m/pGAAAAAAAAGA/aOgNAAAAAACANiNcAgAAAAAAQJsRLgEAAAAAAKDNCJcAAAAAAADQZoRLAAAAAAAAaDPCJQAAAAAAALQZ4RIAAAAAAADajHAJAAAAAAAAbUa4BAAAOp1vvvlGw4cP1yuvvBLtUlpl3bp1ys3N1RdffBHtUg7YokWLNHr0aG3ZsiXapQAAgCgjXAIAAOggd955p8aNG6fJkydLktxut0aOHKnhw4e36E9ZWVm71nPrrbdq6tSpMk0zHNg9+uijjY779ttvNX78eE2ZMkU//vijJGnGjBkaNmyY7rnnnnatCQAAdD62aBcAAADQHSxdulRffPGF5s+fH94WCAR05513Rhz33HPPaenSpfrd736njIyM8Pa4uDilpqa2Wz2maWrRokU67rjjZBjGPo/76KOPdM0116hHjx564okn1K9fv/C+uXPn6ne/+53Wr1+voUOHtlttAACgcyFcAgAA6AALFixQWlqajjnmmPC25ORknX766RHHPfnkk4qPj9fcuXNlsx28H9VWrFih3bt3a8aMGfs85o033tCNN96ogQMH6tFHH1V2dnbE/uOPP15//vOf9fzzz+sPf/jDQasVAADENqbFAQCALqOkpES33HKLjjnmGI0ePVrHHHOMbrnlFpWWljY6Ni8vT7/+9a81btw4jRs3TldccYW2b9+uY489VhdddFG71uX3+7Vo0SJNmjRJdrt9n8f5fD6tW7dOw4cPP6jBkiS9//77Sk5O1pFHHtnk/gULFui3v/2tcnNz9cwzzzQKliTJ6XRq/PjxWrhw4UGtFQAAxDZGLgEAgC6hsrJS559/vrZu3aqzzz5bubm5WrNmjZ577jl9/fXXeumll+RyuSRJpaWlmjNnjoqLi3Xeeedp0KBBWrJkiX7605+qurq63WtbtWqVqqurNWbMmP0et2HDBvl8Po0cObLda9jb+++/r6OPPrrJsOvBBx/UP/7xDx111FF64IEH5HQ693mesWPH6vPPP9fGjRs1ePDgg1kyAACIUYRLAACgS3jkkUe0ZcsW/fGPf9ScOXPC20eOHKlbb71VjzzyiH7zm99Ikh5++GHt2rVLf/vb33TaaadJki644ALdfffdTTa0PlAbNmyQJPXt23e/x61evVqSNGrUqHavoaGNGzdq8+bN4b+Php577jlt375dM2bM0D//+U/FxcXt91z172nDhg2ESwAAdFNMiwMAAF3C+++/r/T0dM2ePTti++zZs5Wenq5FixaFt3300UfKzMzUKaecEnHsxRdffFBqKykpkSSlpKTs97j6cKktI5dKSkr0s5/9TOPHj9fll1++z22StGjRIsXHx2vq1KmNzlNYWChJ6tevX7PBkqRwk/Hi4uJW1wwAALoGRi4BAIAuIS8vT6NHj27Uq8hms2nAgAHh4Kb+2DFjxshiifw9W0ZGhpKTkyO2vf3223r66af1448/Ki0tTR9++GHEfr/frzvvvFP/+9//FAwGNXPmTP3pT39SfHx8+Jj9rcbW0OrVq2Wz2TR8+PAWHd/QCy+8oGAwqG+//VZWq3Wf26RQEDdp0qQmp7tdeuml+u677/TYY4/JNE3deOONLXr9lr5HAADQ9TByCQAAYD9SUlJ04YUXNjmFTJL+85//6JtvvtEbb7yh9957Txs3btTf/va3iGPS09MlSWVlZft8nWAwqB9//FGDBg2KCKZaKi8vT0OGDIkIkZratmvXLq1cuVLHHXdck+dJSEjQgw8+qIkTJ+rxxx/X7bffvt/XrX9P9e8RAAB0P4RLAACgS+jbt682b94sv98fsd3v92vLli0R/Y569+6trVu3KhgMRhxbXFysioqKiG2TJ0/WySefrN69ezf5ui+//LIuv/xyZWdnKz09XVdddZVeeeUVBQKB8DFDhw6VJG3dunWf9W/ZskXV1dX77bdUXV2t2267TdOmTdNRRx2l3/zmNyopKdHVV1+t1157TS+++KLGjh2rZ599tsltUmhKnGEY+wyXJMnhcOg///mPJk2apCeffFJ//etf93nstm3bIt4jAADofgiXAABAlzBjxgyVlJTopZdeitj+4osvqqSkRDNmzAhvmz59ugoLC/Xmm29GHNvaZt4VFRXauXOnRowYEd42atQoud1u5efnh7fl5ubK5XJp+fLl+zxXS/ot/b//9/9UUFCgV199VR9//LGcTqduuukm3XfffTr11FP1k5/8REuXLtWcOXOa3CaFpsSNHz++2ZFGDodD//73vzV58mQ99dRTuu2225o8btmyZerRo4cGDRq03/MBAICui55LAACgS7jkkkv07rvv6tZbb9Xq1as1cuRIrVmzRi+//LIGDhyoSy65JHzspZdeqjfffFM333yzfvjhBw0aNEhLlizR0qVLlZaW1uLXdLvdkhTRpykpKSlinyRZrVbNnDlTixYtktfrbbJRdnMrxZWUlOidd97Rl19+Ga7xuuuu06RJk1ReXt6iesvKyrR48WL99re/bdHx9QHTr371Kz399NMyTVN/+MMfwvvdbreWLFmis88+u0XnAwAAXRMjlwAAQJeQlJSk5557TrNnz9Ynn3yiv/71r/rkk0903nnnacGCBXK5XOFj09PTtWDBAk2bNk3//e9/dc8996i6ulpPPvmkTNOUw+Fo0WvWN8SurKwMb6u/v3ez7PPPP18VFRX66KOPmjzXmjVrZBhGxCiohvLy8mSapmbOnKkJEyZowoQJmjVrluLi4rRz584W1fvxxx/L7/dHjOJqTnx8vB544AFNmTJFzzzzjG655RaZpilJeu+991RTU9NohT4AANC9MHIJAAB0OkceeaTWrl3baHt6err+/Oc/689//nOz5+jbt6/mzZsXsa20tFRlZWXKyclpUR3JycnKyckJN+KWQiOQnE5nox5NY8aM0ZQpU/Tkk09q1qxZjc71+OOP7/e1evXqJcMw9PHHH0cEZa3x/vvva8SIEerTp0+jffv6O5VCAVNTUwafeuopHX/88Ro2bFib6gEAAF0DI5cAAEC35PF4Gm176KGHJIWaeNcLBAKqra2Vz+eTaZqqra2V1+sN7z/nnHP04IMPavfu3SopKdG8efN01llnRazQVu/GG2/UsmXL9Pnnn7e63h49emjWrFm65ZZbVFxcLCnUgPzdd99t8TkOO+wwXXfdda1+7aYsWrRI69ev1/XXX98u5wMAAJ0XI5cAAEC3dOmll6p3797Kzc1VMBjU119/rY8++khjx46NmDb2+uuv66abbgo/HjNmjHr37q0PP/xQknT55ZerrKxMp5xyioLBoGbNmrXPwGXo0KHh3kptcfvtt2vevHk699xzVVpaqoyMDE2fPl0nnHBCi99ze5kxY4ZWrlzZbucDAACdl2HWT5oHAADoRh577DG99tprys/PV21trbKzszVz5kxdeeWVbZ52BgAA0B0RLgEAAAAAAKDN6LkEAAAAAACANiNcAgAAAAAAQJsRLgEAAAAAAKDNCJcAAAAAAADQZoRLAAAAAAAAaDPCJQAAAAAAALQZ4RIAAAAAAADajHAJAAAAAAAAbfb/ARCTGxMVS99eAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f8e061-a65e-47f2-a777-93de0d5045ea",
+   "metadata": {},
+   "source": [
+    "You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the $1\\mathrm{M}_\\odot$ star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698d0a63-11ba-4b3e-a713-35c3e972492f",
+   "metadata": {},
+   "source": [
+    "We can also plot the secondary stars' HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That's because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2b0b7c2b-6e43-48ed-9257-9dfc141b3d28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "star  1\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '1': # choose only secondaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "            \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92c46319-5629-4125-a284-b5d521ed33fc",
+   "metadata": {},
+   "source": [
+    "Remember, all these stars start with a $1\\mathrm{M}_\\odot$ binary, which begins at $\\log_{10}(T_\\mathrm{eff}/\\mathrm{K})\\sim 3.750$, $\\log_{10}L/\\mathrm{L}_\\odot \\sim 0$. The $1\\mathrm{M}_\\odot$-$1\\mathrm{M}_\\odot$ binary evolves like two single stars until they interact up the giant branch at about $\\log_{10} (L/\\mathrm{L}_\\odot) \\sim 2.5$, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the very start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53145356-abbb-4880-996f-dedd80de7540",
+   "metadata": {},
+   "source": [
+    "This is, of course, a very simple introduction to what happens in binaries. We haven't talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/notebook_api_functionality.html b/docs/build/html/notebook_api_functionality.html
index c4b2e364a7fb0ec61b3435caa07adf1e6f6bcc52..cdd5ae1fc1192b9ad98e7531f77ac917ff204c55 100644
--- a/docs/build/html/notebook_api_functionality.html
+++ b/docs/build/html/notebook_api_functionality.html
@@ -7,7 +7,7 @@
   
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   
-  <title>Using the API functionality of binarycpython &mdash; binary_c-python  documentation</title>
+  <title>Tutorial: Using the API functionality of binary_c-python &mdash; binary_c-python  documentation</title>
   
 
   
@@ -39,8 +39,8 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Binary_c parameters" href="binary_c_parameters.html" />
-    <link rel="prev" title="Extra features and functionality of binarycpython" href="notebook_extra_features.html" /> 
+    <link rel="next" title="Example use case: Zero-age stellar luminosity function" href="notebook_luminosity_function_single.html" />
+    <link rel="prev" title="Tutorial: Extra features and functionality of binary_c-python" href="notebook_extra_features.html" /> 
 </head>
 
 <body class="wy-body-for-nav">
@@ -90,11 +90,11 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2 current"><a class="current reference internal" href="#">Using the API functionality of binarycpython</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Tutorial: Using the API functionality of binary_c-python</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#Example-usage:">Example usage:</a><ul>
 <li class="toctree-l4"><a class="reference internal" href="#Setting-up,-using-and-freeing-store">Setting up, using and freeing store</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#Getting-information-from-binary_c">Getting information from binary_c</a></li>
@@ -102,6 +102,10 @@
 </li>
 </ul>
 </li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -156,7 +160,7 @@
         
           <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
         
-      <li>Using the API functionality of binarycpython</li>
+      <li>Tutorial: Using the API functionality of binary_c-python</li>
     
     
       <li class="wy-breadcrumbs-aside">
@@ -445,13 +449,13 @@ div.rendered_html tbody tr:hover {
     text-align: unset;
 }
 </style>
-<div class="section" id="Using-the-API-functionality-of-binarycpython">
-<h1>Using the API functionality of binarycpython<a class="headerlink" href="#Using-the-API-functionality-of-binarycpython" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="Tutorial:-Using-the-API-functionality-of-binary_c-python">
+<h1>Tutorial: Using the API functionality of binary_c-python<a class="headerlink" href="#Tutorial:-Using-the-API-functionality-of-binary_c-python" title="Permalink to this headline">¶</a></h1>
 <p>This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw</p>
 <p>Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in <code class="docutils literal notranslate"><span class="pre">src/binary_c_python.c</span></code>, and the functions are available via <code class="docutils literal notranslate"><span class="pre">from</span> <span class="pre">binarycpython</span> <span class="pre">import</span> <span class="pre">_binary_c_bindings</span></code>.</p>
 <p>The following functions are available through the API: (run cell below)</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -472,35 +476,67 @@ NAME
 
 FUNCTIONS
     free_persistent_data_memaddr_and_return_json_output(...)
-        Frees the persistent_data memory and returns the json output
+        Frees the persistent_data memory and returns the json output.
+
+        Arguments:
+                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)
 
     free_store_memaddr(...)
-        Frees the store memaddr
+        Frees the store memaddr.
+
+        Arguments:
+                store capsule: capsule containing the memory adress of the store object
 
     return_arglines(...)
         Return the default args for a binary_c system
 
+        Arguments:
+                No arguments.
+
     return_help(...)
         Return the help info for a given parameter
 
+        Arguments:
+                parameter: parameter name.
+
     return_help_all(...)
         Return an overview of all the parameters, their description, categorized in sections
 
+        Arguments:
+                No arguments.
+
     return_maximum_mass_ratio_for_RLOF(...)
-        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you&#39;re doing
+        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you&#39;re doing.
+
+        Arguments:
+                argstring: argument string for binary_c
+                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null
 
     return_minimum_orbit_for_RLOF(...)
-        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you&#39;re doing
+        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you&#39;re doing.
+
+        Arguments:
+                argstring: argument string for binary_c
+                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null
 
     return_persistent_data_memaddr(...)
         Return the store memory adress that will be passed to run_population
 
+        Arguments:
+                No arguments.
+
     return_store_memaddr(...)
         Return the store memory adress that will be passed to run_population
 
+        Arguments:
+                No arguments.
+
     return_version_info(...)
         Return the version information of the used binary_c build
 
+        Arguments:
+                No arguments.
+
     run_system(...)
         Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.
 
@@ -550,7 +586,7 @@ FILE
 <div class="section" id="Setting-up,-using-and-freeing-store">
 <h3>Setting up, using and freeing store<a class="headerlink" href="#Setting-up,-using-and-freeing-store" title="Permalink to this headline">¶</a></h3>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -583,8 +619,8 @@ FILE
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-&lt;capsule object &#34;STORE&#34; at 0x7f163859d0c0&gt;
-SINGLE_STAR_LIFETIME 10 27.7358
+&lt;capsule object &#34;STORE&#34; at 0x7fa6a45ed180&gt;
+SINGLE_STAR_LIFETIME 10 28.4838
 
 </pre></div></div>
 </div>
@@ -593,7 +629,7 @@ SINGLE_STAR_LIFETIME 10 27.7358
 <h3>Getting information from binary_c<a class="headerlink" href="#Getting-information-from-binary_c" title="Permalink to this headline">¶</a></h3>
 <p>We can get information for a parameter via return_help(parameter_name): This will return an unparsed output</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -619,7 +655,7 @@ Default : 0
 </div>
 <p>We can get information on all available parameters via return_help(parameter_name):</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[16]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -695,6 +731,9 @@ equation_of_state_algorithm : Set the equation of state algorithm. 0 = Paczynski
 opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)
 wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0
 gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)
+postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&amp;A 635, A173). : (null)
+Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)
+Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)
 mattsson_Orich_tpagbwind : Experimental : turns on Mattsson&#39;s TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)
 magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)
 magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)
@@ -714,7 +753,9 @@ superwind_mira_switchon : In the Vassiliadis and Wood (1993) AGB wind prescripti
 vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)
 vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)
 tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers&#39; mass loss formula. (This multiplies the 4e-13 in Reimers&#39; formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)
+Tout_Pringle_1992_multiplier : Multiplier for the Tout &amp; Pringle (1992) magnetic wind. (0.0) : (null)
 artificial_mass_accretion_rate%d : Constant mass accretion rate for star &lt;n&gt;. : (null)
+artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type &lt;n&gt;. : (null)
 artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star &lt;n&gt;. : (null)
 artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)
 artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if &lt;0 (default is -1). : (null)
@@ -722,8 +763,7 @@ artificial_accretion_end_time : Time at which artificial accretion ends. Ignored
 wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge&#39;s version of Vink&#39;s early-2000s wind (See Lynnette Dray&#39;s thesis, or John Eldridge&#39;s thesis) : (null)
 wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)
 wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)
-BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor&#39;s (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)
-PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore
+BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor&#39;s (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)
 sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
@@ -735,9 +775,6 @@ sn_kick_distribution_BH_BH : Set the distribution of speeds applied to black hol
 sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
@@ -749,9 +786,6 @@ sn_kick_dispersion_BH_BH : Set the dispersion of speeds applied to black holes f
 sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
-sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)
 sn_kick_companion_IA_He : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
 sn_kick_companion_IA_ELD : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
 sn_kick_companion_IA_CHAND : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
@@ -772,9 +806,6 @@ sn_kick_companion_BH_BH : Set the speed (if &gt;=0) of, or the algothim (if &lt;
 sn_kick_companion_BH_NS : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
 sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
 sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
-sn_kick_companion_PPISN : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
-sn_kick_companion_PISN : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
-sn_kick_companion_PHDIS : Set the speed (if &gt;=0) of, or the algothim (if &lt;0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)
 wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)
 wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)
 wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)
@@ -847,6 +878,11 @@ PN_fast_wind_mdot_AGB : The envelope mass below which fast wind used during the
 HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)
 wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)
 wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)
+colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)
+apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)
+degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)
+degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)
+degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)
 
 ############################################################
 ##### Section Binary
@@ -1113,7 +1149,6 @@ angelou_lithium_vrotfrac_trigger : Fraction of Keplerian (breakup) equatorial ro
 ############################################################
 ##### Section Output
 ############################################################
-david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, &gt;0 for custom logging functions : Ignore
 cf_amanda_log : Enable logging to compare to Amanda&#39;s models. : (null)
 float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)
 save_pre_events_stardata : Enable this to save a copy of stardata to stardata-&gt;pre_events_stardata just before an event. : (null)
@@ -1143,6 +1178,7 @@ escape_velocity : A parameter used in constructing galactic chemical evolution (
 escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)
 colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. :
 log_filename : Location of the output logging filename. If set to &#34;/dev/null&#34; then there is no logging. :
+log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. :
 stopfile : File which, when it exists, will stop the current binary_c repeat run. :
 stardata_dump_filename : Location of the stardata dump file. :
 stardata_load_filename : Location of the stardata file to load. :
@@ -1167,8 +1203,12 @@ MINT_data_cleanup : Activate checks on incoming data to try to account for probl
 MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. :
 MINT_remesh : Turn on or off MINT&#39;s remeshing. :
 MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) :
+MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) :
 MINT_disable_grid_load_warnings : Use this to explicitly disable MINT&#39;s warnings when loading a grid with, e.g., missing or too much data. :
 MINT_Kippenhahn : Turn on or off MINT&#39;s Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. :
+MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) :
+MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) :
+MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) :
 MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. :
 MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. :
 MINT_nuclear_burning : Turn on or off MINT&#39;s nuclear burning algorithm. :
@@ -1216,7 +1256,7 @@ list_args : Display list of arguments with their default values. Useful for batc
 </div>
 <p>We can get all the parameter names and their default values with return_arglines(): (abridged output)</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[20]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -1237,7 +1277,7 @@ M_1 = 0
 </div>
 <p>Lastly, we can ask binary_c to determine the minimum period or maximum mass for RLOF at the ZAMS: Both of them need an argstring as input</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -1269,7 +1309,7 @@ MINIMUM PERIOD 0.00632092
 </pre></div></div>
 </div>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[46]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -1321,10 +1361,10 @@ MAXIMUM MASS RATIO 0.0141
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="binary_c_parameters.html" class="btn btn-neutral float-right" title="Binary_c parameters" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_luminosity_function_single.html" class="btn btn-neutral float-right" title="Example use case: Zero-age stellar luminosity function" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="notebook_extra_features.html" class="btn btn-neutral float-left" title="Extra features and functionality of binarycpython" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="notebook_extra_features.html" class="btn btn-neutral float-left" title="Tutorial: Extra features and functionality of binary_c-python" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   
@@ -1347,9 +1387,9 @@ MAXIMUM MASS RATIO 0.0141
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_api_functionality.ipynb b/docs/build/html/notebook_api_functionality.ipynb
index d81c31711bfc5d6de3159fd8958df96dd145ded0..020d2dc7cdb1ae9f1214d42e3351b571ff0c943d 100644
--- a/docs/build/html/notebook_api_functionality.ipynb
+++ b/docs/build/html/notebook_api_functionality.ipynb
@@ -5,7 +5,7 @@
    "id": "cb9d00f5-9613-471e-a4bb-6181311bf73b",
    "metadata": {},
    "source": [
-    "# Using the API functionality of binarycpython\n",
+    "# Tutorial: Using the API functionality of binary_c-python\n",
     "This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw\n",
     "\n",
     "Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in `src/binary_c_python.c`, and the functions are available via `from binarycpython import _binary_c_bindings`.\n",
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "ded7eaf6-e1ba-46c2-9f6f-9ebcb14a264d",
    "metadata": {},
    "outputs": [
@@ -30,37 +30,69 @@
       "\n",
       "FUNCTIONS\n",
       "    free_persistent_data_memaddr_and_return_json_output(...)\n",
-      "        Frees the persistent_data memory and returns the json output\n",
+      "        Frees the persistent_data memory and returns the json output.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)\n",
       "    \n",
       "    free_store_memaddr(...)\n",
-      "        Frees the store memaddr\n",
+      "        Frees the store memaddr.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the store object\n",
       "    \n",
       "    return_arglines(...)\n",
       "        Return the default args for a binary_c system\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_help(...)\n",
       "        Return the help info for a given parameter\n",
+      "        \n",
+      "        Arguments:\n",
+      "                parameter: parameter name.\n",
       "    \n",
       "    return_help_all(...)\n",
       "        Return an overview of all the parameters, their description, categorized in sections\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_maximum_mass_ratio_for_RLOF(...)\n",
-      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_minimum_orbit_for_RLOF(...)\n",
-      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_persistent_data_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_store_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_version_info(...)\n",
       "        Return the version information of the used binary_c build\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    run_system(...)\n",
-      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things. \n",
+      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.\n",
       "        \n",
       "        Arguments:\n",
       "                argstring: argument string for binary_c\n",
@@ -126,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "10a74d5a-a3d5-4543-a5bc-20d1fe885bb4",
    "metadata": {},
    "outputs": [
@@ -134,8 +166,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<capsule object \"STORE\" at 0x7f163859d0c0>\n",
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
+      "<capsule object \"STORE\" at 0x7fa6a45ed180>\n",
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
       "\n"
      ]
     }
@@ -183,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "318874f6-7acf-49bb-9786-299d4dffc0b3",
    "metadata": {},
    "outputs": [
@@ -217,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "d7e757ae-579c-42a2-a310-f0401b7800e8",
    "metadata": {
     "scrolled": true,
@@ -291,6 +323,9 @@
       "opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)\n",
       "wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0\n",
       "gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)\n",
+      "postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&A 635, A173). : (null)\n",
+      "Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)\n",
+      "Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)\n",
       "mattsson_Orich_tpagbwind : Experimental : turns on Mattsson's TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)\n",
       "magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)\n",
       "magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)\n",
@@ -310,7 +345,9 @@
       "vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)\n",
       "vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)\n",
       "tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers' mass loss formula. (This multiplies the 4e-13 in Reimers' formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)\n",
+      "Tout_Pringle_1992_multiplier : Multiplier for the Tout & Pringle (1992) magnetic wind. (0.0) : (null)\n",
       "artificial_mass_accretion_rate%d : Constant mass accretion rate for star <n>. : (null)\n",
+      "artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type <n>. : (null)\n",
       "artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star <n>. : (null)\n",
       "artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)\n",
       "artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if <0 (default is -1). : (null)\n",
@@ -318,8 +355,7 @@
       "wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge's version of Vink's early-2000s wind (See Lynnette Dray's thesis, or John Eldridge's thesis) : (null)\n",
       "wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)\n",
       "wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)\n",
-      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)\n",
-      "PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore\n",
+      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)\n",
       "sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -331,9 +367,6 @@
       "sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -345,9 +378,6 @@
       "sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_companion_IA_He : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_ELD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_CHAND : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
@@ -368,9 +398,6 @@
       "sn_kick_companion_BH_NS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PPISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PHDIS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)\n",
       "wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)\n",
       "wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)\n",
@@ -443,6 +470,11 @@
       "HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)\n",
       "wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)\n",
       "wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)\n",
+      "colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)\n",
+      "apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)\n",
+      "degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)\n",
+      "degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)\n",
+      "degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)\n",
       "\n",
       "############################################################\n",
       "##### Section Binary\n",
@@ -709,7 +741,6 @@
       "############################################################\n",
       "##### Section Output\n",
       "############################################################\n",
-      "david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions : Ignore\n",
       "cf_amanda_log : Enable logging to compare to Amanda's models. : (null)\n",
       "float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)\n",
       "save_pre_events_stardata : Enable this to save a copy of stardata to stardata->pre_events_stardata just before an event. : (null)\n",
@@ -739,6 +770,7 @@
       "escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)\n",
       "colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. : \n",
       "log_filename : Location of the output logging filename. If set to \"/dev/null\" then there is no logging. : \n",
+      "log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. : \n",
       "stopfile : File which, when it exists, will stop the current binary_c repeat run. : \n",
       "stardata_dump_filename : Location of the stardata dump file. : \n",
       "stardata_load_filename : Location of the stardata file to load. : \n",
@@ -763,8 +795,12 @@
       "MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. : \n",
       "MINT_remesh : Turn on or off MINT's remeshing. : \n",
       "MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) : \n",
+      "MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) : \n",
       "MINT_disable_grid_load_warnings : Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data. : \n",
       "MINT_Kippenhahn : Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. : \n",
+      "MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) : \n",
+      "MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) : \n",
+      "MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) : \n",
       "MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. : \n",
       "MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. : \n",
       "MINT_nuclear_burning : Turn on or off MINT's nuclear burning algorithm. : \n",
@@ -825,7 +861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 5,
    "id": "3d29ca9d-ac66-4f9e-81cf-2edd14a98b79",
    "metadata": {},
    "outputs": [
@@ -854,7 +890,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "e517f561-09c6-419d-ba89-d9cb61e6ebab",
    "metadata": {},
    "outputs": [
@@ -887,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "id": "7da75a95-8831-4346-a584-e042ced75249",
    "metadata": {},
    "outputs": [
diff --git a/docs/build/html/notebook_common_envelope_evolution.html b/docs/build/html/notebook_common_envelope_evolution.html
new file mode 100644
index 0000000000000000000000000000000000000000..6d041737c22b9e442003f5b8174b938868564e35
--- /dev/null
+++ b/docs/build/html/notebook_common_envelope_evolution.html
@@ -0,0 +1,1132 @@
+
+
+<!DOCTYPE html>
+<html class="writer-html5" lang="en" >
+<head>
+  <meta charset="utf-8">
+  
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  
+  <title>Example use case: Common-envelope evolution &mdash; binary_c-python  documentation</title>
+  
+
+  
+  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
+  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+  
+  
+  
+  
+
+  
+  <!--[if lt IE 9]>
+    <script src="_static/js/html5shiv.min.js"></script>
+  <![endif]-->
+  
+    
+      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+        <script src="_static/jquery.js"></script>
+        <script src="_static/underscore.js"></script>
+        <script src="_static/doctools.js"></script>
+        <script src="_static/language_data.js"></script>
+        <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
+        <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
+        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
+    
+    <script type="text/javascript" src="_static/js/theme.js"></script>
+
+    
+    <link rel="index" title="Index" href="genindex.html" />
+    <link rel="search" title="Search" href="search.html" />
+    <link rel="next" title="Binary_c parameters" href="binary_c_parameters.html" />
+    <link rel="prev" title="Example use case: Hertzsprung-Russell diagrams" href="notebook_HRD.html" /> 
+</head>
+
+<body class="wy-body-for-nav">
+
+   
+  <div class="wy-grid-for-nav">
+    
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
+          
+
+          
+            <a href="index.html" class="icon icon-home" alt="Documentation Home"> binary_c-python
+          
+
+          
+          </a>
+
+          
+            
+            
+          
+
+          
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+
+          
+        </div>
+
+        
+        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
+          
+            
+            
+              
+            
+            
+              <p class="caption"><span class="caption-text">Contents:</span></p>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
+<li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
+<li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Example use case: Common-envelope evolution</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Stellar-Grid">Stellar Grid</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Logging-and-handling-the-output">Logging and handling the output</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Evolving-the-grid">Evolving the grid</a></li>
+</ul>
+</li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
+<li class="toctree-l1"><a class="reference internal" href="grid_options_descriptions.html">Population grid code options</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python">Visit the GitLab repo</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/issues/new">Submit an issue</a></li>
+</ul>
+
+            
+          
+        </div>
+        
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
+
+      
+      <nav class="wy-nav-top" aria-label="top navigation">
+        
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="index.html">binary_c-python</a>
+        
+      </nav>
+
+
+      <div class="wy-nav-content">
+        
+        <div class="rst-content">
+        
+          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<div role="navigation" aria-label="breadcrumbs navigation">
+
+  <ul class="wy-breadcrumbs">
+    
+      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
+        
+          <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
+        
+      <li>Example use case: Common-envelope evolution</li>
+    
+    
+      <li class="wy-breadcrumbs-aside">
+        
+            
+            <a href="_sources/notebook_common_envelope_evolution.ipynb.txt" rel="nofollow"> View page source</a>
+          
+        
+      </li>
+    
+  </ul>
+
+  
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+            
+  
+<style>
+/* CSS for nbsphinx extension */
+
+/* remove conflicting styling from Sphinx themes */
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt *,
+div.nbinput.container div.input_area pre,
+div.nboutput.container div.output_area pre,
+div.nbinput.container div.input_area .highlight,
+div.nboutput.container div.output_area .highlight {
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}
+
+div.nbinput.container > div[class*=highlight],
+div.nboutput.container > div[class*=highlight] {
+    margin: 0;
+}
+
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt * {
+    background: none;
+}
+
+div.nboutput.container div.output_area .highlight,
+div.nboutput.container div.output_area pre {
+    background: unset;
+}
+
+div.nboutput.container div.output_area div.highlight {
+    color: unset;  /* override Pygments text color */
+}
+
+/* avoid gaps between output lines */
+div.nboutput.container div[class*=highlight] pre {
+    line-height: normal;
+}
+
+/* input/output containers */
+div.nbinput.container,
+div.nboutput.container {
+    display: -webkit-flex;
+    display: flex;
+    align-items: flex-start;
+    margin: 0;
+    width: 100%;
+}
+@media (max-width: 540px) {
+    div.nbinput.container,
+    div.nboutput.container {
+        flex-direction: column;
+    }
+}
+
+/* input container */
+div.nbinput.container {
+    padding-top: 5px;
+}
+
+/* last container */
+div.nblast.container {
+    padding-bottom: 5px;
+}
+
+/* input prompt */
+div.nbinput.container div.prompt pre {
+    color: #307FC1;
+}
+
+/* output prompt */
+div.nboutput.container div.prompt pre {
+    color: #BF5B3D;
+}
+
+/* all prompts */
+div.nbinput.container div.prompt,
+div.nboutput.container div.prompt {
+    width: 4.5ex;
+    padding-top: 5px;
+    position: relative;
+    user-select: none;
+}
+
+div.nbinput.container div.prompt > div,
+div.nboutput.container div.prompt > div {
+    position: absolute;
+    right: 0;
+    margin-right: 0.3ex;
+}
+
+@media (max-width: 540px) {
+    div.nbinput.container div.prompt,
+    div.nboutput.container div.prompt {
+        width: unset;
+        text-align: left;
+        padding: 0.4em;
+    }
+    div.nboutput.container div.prompt.empty {
+        padding: 0;
+    }
+
+    div.nbinput.container div.prompt > div,
+    div.nboutput.container div.prompt > div {
+        position: unset;
+    }
+}
+
+/* disable scrollbars on prompts */
+div.nbinput.container div.prompt pre,
+div.nboutput.container div.prompt pre {
+    overflow: hidden;
+}
+
+/* input/output area */
+div.nbinput.container div.input_area,
+div.nboutput.container div.output_area {
+    -webkit-flex: 1;
+    flex: 1;
+    overflow: auto;
+}
+@media (max-width: 540px) {
+    div.nbinput.container div.input_area,
+    div.nboutput.container div.output_area {
+        width: 100%;
+    }
+}
+
+/* input area */
+div.nbinput.container div.input_area {
+    border: 1px solid #e0e0e0;
+    border-radius: 2px;
+    /*background: #f5f5f5;*/
+}
+
+/* override MathJax center alignment in output cells */
+div.nboutput.container div[class*=MathJax] {
+    text-align: left !important;
+}
+
+/* override sphinx.ext.imgmath center alignment in output cells */
+div.nboutput.container div.math p {
+    text-align: left;
+}
+
+/* standard error */
+div.nboutput.container div.output_area.stderr {
+    background: #fdd;
+}
+
+/* ANSI colors */
+.ansi-black-fg { color: #3E424D; }
+.ansi-black-bg { background-color: #3E424D; }
+.ansi-black-intense-fg { color: #282C36; }
+.ansi-black-intense-bg { background-color: #282C36; }
+.ansi-red-fg { color: #E75C58; }
+.ansi-red-bg { background-color: #E75C58; }
+.ansi-red-intense-fg { color: #B22B31; }
+.ansi-red-intense-bg { background-color: #B22B31; }
+.ansi-green-fg { color: #00A250; }
+.ansi-green-bg { background-color: #00A250; }
+.ansi-green-intense-fg { color: #007427; }
+.ansi-green-intense-bg { background-color: #007427; }
+.ansi-yellow-fg { color: #DDB62B; }
+.ansi-yellow-bg { background-color: #DDB62B; }
+.ansi-yellow-intense-fg { color: #B27D12; }
+.ansi-yellow-intense-bg { background-color: #B27D12; }
+.ansi-blue-fg { color: #208FFB; }
+.ansi-blue-bg { background-color: #208FFB; }
+.ansi-blue-intense-fg { color: #0065CA; }
+.ansi-blue-intense-bg { background-color: #0065CA; }
+.ansi-magenta-fg { color: #D160C4; }
+.ansi-magenta-bg { background-color: #D160C4; }
+.ansi-magenta-intense-fg { color: #A03196; }
+.ansi-magenta-intense-bg { background-color: #A03196; }
+.ansi-cyan-fg { color: #60C6C8; }
+.ansi-cyan-bg { background-color: #60C6C8; }
+.ansi-cyan-intense-fg { color: #258F8F; }
+.ansi-cyan-intense-bg { background-color: #258F8F; }
+.ansi-white-fg { color: #C5C1B4; }
+.ansi-white-bg { background-color: #C5C1B4; }
+.ansi-white-intense-fg { color: #A1A6B2; }
+.ansi-white-intense-bg { background-color: #A1A6B2; }
+
+.ansi-default-inverse-fg { color: #FFFFFF; }
+.ansi-default-inverse-bg { background-color: #000000; }
+
+.ansi-bold { font-weight: bold; }
+.ansi-underline { text-decoration: underline; }
+
+
+div.nbinput.container div.input_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight].math,
+div.nboutput.container div.output_area.rendered_html,
+div.nboutput.container div.output_area > div.output_javascript,
+div.nboutput.container div.output_area:not(.rendered_html) > img{
+    padding: 5px;
+    margin: 0;
+}
+
+/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
+div.nbinput.container div.input_area > div[class^='highlight'],
+div.nboutput.container div.output_area > div[class^='highlight']{
+    overflow-y: hidden;
+}
+
+/* hide copybtn icon on prompts (needed for 'sphinx_copybutton') */
+.prompt a.copybtn {
+    display: none;
+}
+
+/* Some additional styling taken form the Jupyter notebook CSS */
+div.rendered_html table {
+  border: none;
+  border-collapse: collapse;
+  border-spacing: 0;
+  color: black;
+  font-size: 12px;
+  table-layout: fixed;
+}
+div.rendered_html thead {
+  border-bottom: 1px solid black;
+  vertical-align: bottom;
+}
+div.rendered_html tr,
+div.rendered_html th,
+div.rendered_html td {
+  text-align: right;
+  vertical-align: middle;
+  padding: 0.5em 0.5em;
+  line-height: normal;
+  white-space: normal;
+  max-width: none;
+  border: none;
+}
+div.rendered_html th {
+  font-weight: bold;
+}
+div.rendered_html tbody tr:nth-child(odd) {
+  background: #f5f5f5;
+}
+div.rendered_html tbody tr:hover {
+  background: rgba(66, 165, 245, 0.2);
+}
+
+/* CSS overrides for sphinx_rtd_theme */
+
+/* 24px margin */
+.nbinput.nblast.container,
+.nboutput.nblast.container {
+    margin-bottom: 19px;  /* padding has already 5px */
+}
+
+/* ... except between code cells! */
+.nblast.container + .nbinput.container {
+    margin-top: -19px;
+}
+
+.admonition > p:before {
+    margin-right: 4px;  /* make room for the exclamation icon */
+}
+
+/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
+.math {
+    text-align: unset;
+}
+</style>
+<div class="section" id="Example-use-case:-Common-envelope-evolution">
+<h1>Example use case: Common-envelope evolution<a class="headerlink" href="#Example-use-case:-Common-envelope-evolution" title="Permalink to this headline">¶</a></h1>
+<p>In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.</p>
+<p>First, we import a few required Python modules.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">os</span>
+<span class="kn">import</span> <span class="nn">math</span>
+<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
+<span class="n">TMP_DIR</span> <span class="o">=</span> <span class="n">temp_dir</span><span class="p">(</span><span class="s2">&quot;notebooks&quot;</span><span class="p">,</span> <span class="s2">&quot;notebook_comenv&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="Setting-up-the-Population-object">
+<h2>Setting up the Population object<a class="headerlink" href="#Setting-up-the-Population-object" title="Permalink to this headline">¶</a></h2>
+<p>We set up a new population object. Our stars evolve to <span class="math notranslate nohighlight">\(13.7\text{ }\mathrm{Gyr}\)</span>, the age of the Universe, and we assume the metallicity <span class="math notranslate nohighlight">\(Z=0.02\)</span>. We also set the common-envelope ejection efficiency <span class="math notranslate nohighlight">\(\alpha_\mathrm{CE}=1\)</span> and the envelope structure parameter <span class="math notranslate nohighlight">\(\lambda=0.5\)</span>. More complex options are available in <em>binary_c</em>, such as <span class="math notranslate nohighlight">\(\lambda\)</span> based on stellar mass, but this is just a demonstration example so let’s keep things simple.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create population object</span>
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># grid options</span>
+    <span class="n">tmp_dir</span> <span class="o">=</span> <span class="n">TMP_DIR</span><span class="p">,</span>
+    <span class="n">verbosity</span> <span class="o">=</span> <span class="mi">1</span><span class="p">,</span>
+    <span class="n">log_dt</span> <span class="o">=</span> <span class="mi">10</span><span class="p">,</span> <span class="c1"># log every 10 seconds</span>
+
+    <span class="c1"># binary-star evolution options</span>
+    <span class="n">max_evolution_time</span><span class="o">=</span><span class="mi">13700</span><span class="p">,</span>  <span class="c1"># maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)</span>
+    <span class="n">metallicity</span><span class="o">=</span><span class="mf">0.02</span><span class="p">,</span> <span class="c1"># 0.02 is approximately Solar metallicity</span>
+    <span class="n">alpha_ce</span> <span class="o">=</span> <span class="mf">1.0</span><span class="p">,</span>
+    <span class="n">lambda_ce</span> <span class="o">=</span> <span class="mf">0.5</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: log_dt=10 to grid_options
+adding: max_evolution_time=13700 to BSE_options
+adding: metallicity=0.02 to BSE_options
+adding: alpha_ce=1.0 to BSE_options
+adding: lambda_ce=0.5 to BSE_options
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Stellar-Grid">
+<h2>Stellar Grid<a class="headerlink" href="#Stellar-Grid" title="Permalink to this headline">¶</a></h2>
+<p>We now construct a grid of stars, varying the mass from <span class="math notranslate nohighlight">\(1\)</span> to <span class="math notranslate nohighlight">\(6\text{ }\mathrm{M}_\odot\)</span>. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to <span class="math notranslate nohighlight">\(10^4\text{ }\mathrm{d}\)</span> because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">binarycpython.utils.distribution_functions</span>
+<span class="c1"># Set resolution and mass range that we simulate</span>
+<span class="n">resolution</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;M_1&quot;</span><span class="p">:</span> <span class="mi">10</span><span class="p">,</span> <span class="s2">&quot;q&quot;</span> <span class="p">:</span> <span class="mi">10</span><span class="p">,</span> <span class="s2">&quot;per&quot;</span><span class="p">:</span> <span class="mi">10</span><span class="p">}</span>
+<span class="n">massrange</span> <span class="o">=</span> <span class="p">[</span><span class="mi">1</span><span class="p">,</span> <span class="mi">6</span><span class="p">]</span>
+<span class="n">logperrange</span> <span class="o">=</span> <span class="p">[</span><span class="mf">0.15</span><span class="p">,</span> <span class="mi">4</span><span class="p">]</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;lnm1&quot;</span><span class="p">,</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Primary mass&quot;</span><span class="p">,</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="n">massrange</span><span class="p">,</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(math.log(</span><span class="si">{min}</span><span class="s2">), math.log(</span><span class="si">{max}</span><span class="s2">), </span><span class="si">{res}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">min</span><span class="o">=</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="nb">max</span><span class="o">=</span><span class="n">massrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="n">res</span><span class="o">=</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;M_1=math.exp(lnm1)&quot;</span><span class="p">,</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1&quot;</span><span class="p">,</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dlnm1&quot;</span><span class="p">,</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+<span class="p">)</span>
+
+<span class="c1"># Mass ratio</span>
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+     <span class="n">name</span><span class="o">=</span><span class="s2">&quot;q&quot;</span><span class="p">,</span>
+     <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Mass ratio&quot;</span><span class="p">,</span>
+     <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span><span class="s2">&quot;0.1/M_1&quot;</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
+     <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s1">&#39;q&#39;</span><span class="p">]),</span>
+     <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(</span><span class="si">{}</span><span class="s2">/M_1, 1, </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">resolution</span><span class="p">[</span><span class="s1">&#39;q&#39;</span><span class="p">]),</span>
+     <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;flatsections(q, [{{&#39;min&#39;: </span><span class="si">{}</span><span class="s2">/M_1, &#39;max&#39;: 1.0, &#39;height&#39;: 1}}])&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">]),</span>
+     <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dq&quot;</span><span class="p">,</span>
+     <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;M_2 = q * M_1&quot;</span><span class="p">,</span>
+     <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_2&quot;</span><span class="p">,</span>
+     <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+ <span class="p">)</span>
+
+<span class="c1"># Orbital period</span>
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;log10per&quot;</span><span class="p">,</span> <span class="c1"># in days</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;log10(Orbital_Period)&quot;</span><span class="p">,</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span><span class="mf">0.15</span><span class="p">,</span> <span class="mf">5.5</span><span class="p">],</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;per&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(</span><span class="si">{}</span><span class="s2">, </span><span class="si">{}</span><span class="s2">, </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;per&quot;</span><span class="p">]),</span>
+    <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;&quot;&quot;orbital_period = 10.0 ** log10per</span>
+<span class="s2">sep = calc_sep_from_period(M_1, M_2, orbital_period)</span>
+<span class="s2">sep_min = calc_sep_from_period(M_1, M_2, 10**</span><span class="si">{}</span><span class="s2">)</span>
+<span class="s2">sep_max = calc_sep_from_period(M_1, M_2, 10**</span><span class="si">{}</span><span class="s2">)&quot;&quot;&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**</span><span class="si">{}</span><span class="s2">), math.log10(10**</span><span class="si">{}</span><span class="s2">), </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="o">-</span><span class="mf">0.55</span><span class="p">),</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;orbital_period&quot;</span><span class="p">,</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dlog10per&quot;</span><span class="p">,</span>
+ <span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Added grid variable: {
+    &#34;name&#34;: &#34;lnm1&#34;,
+    &#34;longname&#34;: &#34;Primary mass&#34;,
+    &#34;valuerange&#34;: [
+        1,
+        6
+    ],
+    &#34;resolution&#34;: &#34;10&#34;,
+    &#34;spacingfunc&#34;: &#34;const(math.log(1), math.log(6), 10)&#34;,
+    &#34;precode&#34;: &#34;M_1=math.exp(lnm1)&#34;,
+    &#34;probdist&#34;: &#34;three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1&#34;,
+    &#34;dphasevol&#34;: &#34;dlnm1&#34;,
+    &#34;parameter_name&#34;: &#34;M_1&#34;,
+    &#34;condition&#34;: &#34;&#34;,
+    &#34;gridtype&#34;: &#34;centred&#34;,
+    &#34;branchpoint&#34;: 0,
+    &#34;grid_variable_number&#34;: 0
+}
+Added grid variable: {
+    &#34;name&#34;: &#34;q&#34;,
+    &#34;longname&#34;: &#34;Mass ratio&#34;,
+    &#34;valuerange&#34;: [
+        &#34;0.1/M_1&#34;,
+        1
+    ],
+    &#34;resolution&#34;: &#34;10&#34;,
+    &#34;spacingfunc&#34;: &#34;const(1/M_1, 1, 10)&#34;,
+    &#34;precode&#34;: &#34;M_2 = q * M_1&#34;,
+    &#34;probdist&#34;: &#34;flatsections(q, [{&#39;min&#39;: 1/M_1, &#39;max&#39;: 1.0, &#39;height&#39;: 1}])&#34;,
+    &#34;dphasevol&#34;: &#34;dq&#34;,
+    &#34;parameter_name&#34;: &#34;M_2&#34;,
+    &#34;condition&#34;: &#34;&#34;,
+    &#34;gridtype&#34;: &#34;centred&#34;,
+    &#34;branchpoint&#34;: 0,
+    &#34;grid_variable_number&#34;: 1
+}
+Added grid variable: {
+    &#34;name&#34;: &#34;log10per&#34;,
+    &#34;longname&#34;: &#34;log10(Orbital_Period)&#34;,
+    &#34;valuerange&#34;: [
+        0.15,
+        5.5
+    ],
+    &#34;resolution&#34;: &#34;10&#34;,
+    &#34;spacingfunc&#34;: &#34;const(0.15, 4, 10)&#34;,
+    &#34;precode&#34;: &#34;orbital_period = 10.0 ** log10per\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)&#34;,
+    &#34;probdist&#34;: &#34;sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)&#34;,
+    &#34;dphasevol&#34;: &#34;dlog10per&#34;,
+    &#34;parameter_name&#34;: &#34;orbital_period&#34;,
+    &#34;condition&#34;: null,
+    &#34;gridtype&#34;: &#34;centred&#34;,
+    &#34;branchpoint&#34;: 0,
+    &#34;grid_variable_number&#34;: 2
+}
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Logging-and-handling-the-output">
+<h2>Logging and handling the output<a class="headerlink" href="#Logging-and-handling-the-output" title="Permalink to this headline">¶</a></h2>
+<p>We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="n">custom_logging_statement</span> <span class="o">=</span> <span class="s2">&quot;&quot;&quot;</span>
+
+<span class="s2">/*</span>
+<span class="s2"> * Detect when the comenv_count increased</span>
+<span class="s2"> */</span>
+<span class="s2">if(stardata-&gt;model.comenv_count == 1 &amp;&amp;</span>
+<span class="s2">   stardata-&gt;previous_stardata-&gt;model.comenv_count == 0)</span>
+<span class="s2">{</span>
+<span class="s2">   /*</span>
+<span class="s2">    * We just had this system&#39;s first common envelope:</span>
+<span class="s2">    * output the time at which this happens,</span>
+<span class="s2">    * the system&#39;s probability (proportional to the number of stars),</span>
+<span class="s2">    * the previous timestep&#39;s (pre-comenv) orbital period (days) and</span>
+<span class="s2">    * the current timestep (post-comenv) orbital period (days)</span>
+<span class="s2">    */</span>
+<span class="s2">    Printf(&quot;COMENV </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;,</span>
+<span class="s2">           stardata-&gt;model.time,</span>
+<span class="s2">           stardata-&gt;model.probability,</span>
+<span class="s2">           stardata-&gt;previous_stardata-&gt;common.orbit.period * YEAR_LENGTH_IN_DAYS,</span>
+<span class="s2">           stardata-&gt;common.orbit.period * YEAR_LENGTH_IN_DAYS);</span>
+
+<span class="s2">    /*</span>
+<span class="s2">     * We should waste no more CPU time on this system now we have the</span>
+<span class="s2">     * data we want.</span>
+<span class="s2">     */</span>
+<span class="s2">    stardata-&gt;model.evolution_stop = TRUE;</span>
+<span class="s2">}</span>
+<span class="s2">&quot;&quot;&quot;</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">C_logging_code</span><span class="o">=</span><span class="n">custom_logging_statement</span>
+<span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: C_logging_code=
+
+/*
+ * Detect when the comenv_count increased
+ */
+if(stardata-&gt;model.comenv_count == 1 &amp;&amp;
+   stardata-&gt;previous_stardata-&gt;model.comenv_count == 0)
+{
+   /*
+    * We just had this system&#39;s first common envelope:
+    * output the time at which this happens,
+    * the system&#39;s probability (proportional to the number of stars),
+    * the previous timestep&#39;s (pre-comenv) orbital period (days) and
+    * the current timestep (post-comenv) orbital period (days)
+    */
+    Printf(&#34;COMENV %g %g %g %g\n&#34;,
+           stardata-&gt;model.time,
+           stardata-&gt;model.probability,
+           stardata-&gt;previous_stardata-&gt;common.orbit.period * YEAR_LENGTH_IN_DAYS,
+           stardata-&gt;common.orbit.period * YEAR_LENGTH_IN_DAYS);
+
+    /*
+     * We should waste no more CPU time on this system now we have the
+     * data we want.
+     */
+    stardata-&gt;model.evolution_stop = TRUE;
+}
+ to grid_options
+</pre></div></div>
+</div>
+<p>The parse function must now catch lines that start with “COMENV” and process the associated data. We set up the parse_data function to do just this.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">bin_data</span><span class="p">,</span><span class="n">datalinedict</span>
+<span class="kn">import</span> <span class="nn">re</span>
+
+<span class="c1"># log-period distribution bin width (dex)</span>
+<span class="n">binwidth</span> <span class="o">=</span> <span class="mf">0.5</span>
+
+<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Parsing function to convert HRD data into something that Python can use</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="c1"># list of the data items</span>
+    <span class="n">parameters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;header&quot;</span><span class="p">,</span> <span class="s2">&quot;time&quot;</span><span class="p">,</span> <span class="s2">&quot;probability&quot;</span><span class="p">,</span> <span class="s2">&quot;pre_comenv_period&quot;</span><span class="p">,</span> <span class="s2">&quot;post_comenv_period&quot;</span><span class="p">]</span>
+
+    <span class="c1"># Loop over the output.</span>
+    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">output</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
+
+        <span class="c1"># obtain the line of data in dictionary form</span>
+        <span class="n">linedata</span> <span class="o">=</span> <span class="n">datalinedict</span><span class="p">(</span><span class="n">line</span><span class="p">,</span><span class="n">parameters</span><span class="p">)</span>
+
+        <span class="c1"># choose COMENV lines of output</span>
+        <span class="k">if</span> <span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;header&quot;</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&quot;COMENV&quot;</span><span class="p">:</span>
+            <span class="c1"># bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex</span>
+            <span class="n">binned_pre_period</span> <span class="o">=</span> <span class="n">bin_data</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;pre_comenv_period&quot;</span><span class="p">]),</span> <span class="n">binwidth</span><span class="p">)</span>
+
+            <span class="c1"># but check if the post-comenv period is finite and positive: if</span>
+            <span class="c1"># not, the system has merged and we give it an aritifical period</span>
+            <span class="c1"># of 10^-100 days (which is very much unphysical)</span>
+            <span class="k">if</span> <span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;post_comenv_period&quot;</span><span class="p">]</span> <span class="o">&gt;</span> <span class="mf">0.0</span><span class="p">:</span>
+                <span class="n">binned_post_period</span> <span class="o">=</span> <span class="n">bin_data</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;post_comenv_period&quot;</span><span class="p">]),</span> <span class="n">binwidth</span><span class="p">)</span>
+            <span class="k">else</span><span class="p">:</span>
+                <span class="n">binned_post_period</span> <span class="o">=</span> <span class="n">bin_data</span><span class="p">(</span><span class="o">-</span><span class="mi">100</span><span class="p">,</span><span class="n">binwidth</span><span class="p">)</span> <span class="c1"># merged!</span>
+
+            <span class="c1"># make the &quot;histograms&quot;</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;pre&#39;</span><span class="p">][</span><span class="n">binned_pre_period</span><span class="p">]</span> <span class="o">+=</span> <span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;probability&quot;</span><span class="p">]</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;post&#39;</span><span class="p">][</span><span class="n">binned_post_period</span><span class="p">]</span> <span class="o">+=</span> <span class="n">linedata</span><span class="p">[</span><span class="s2">&quot;probability&quot;</span><span class="p">]</span>
+
+    <span class="c1"># verbose reporting</span>
+    <span class="c1">#print(&quot;parse out results_dictionary=&quot;,self.grid_results)</span>
+
+<span class="c1"># Add the parsing function</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">parse_function</span><span class="o">=</span><span class="n">parse_function</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: parse_function=&lt;function parse_function at 0x14736bebc040&gt; to grid_options
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Evolving-the-grid">
+<h2>Evolving the grid<a class="headerlink" href="#Evolving-the-grid" title="Permalink to this headline">¶</a></h2>
+<p>Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># set number of threads</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># set number of threads (i.e. number of CPU cores we use)</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
+    <span class="p">)</span>
+
+<span class="c1"># Evolve the population - this is the slow, number-crunching step</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1">#print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: amt_cores=4 to grid_options
+Creating and loading custom logging functionality
+Generating grid code
+Generating grid code
+Constructing/adding: lnm1
+Constructing/adding: q
+Constructing/adding: log10per
+Saving grid code to grid_options
+Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py
+Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py
+Grid code loaded
+Grid has handled 1000 stars
+with a total probability of 0.0645905996773004
+Total starcount for this run will be: 1000
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0
+[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1
+[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2
+[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now
+[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 0 started at 2021-09-12T18:07:39.965721.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x14736bee47e0&gt;
+Process 1 started at 2021-09-12T18:07:39.970949.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x14736bee4870&gt;
+Process 2 started at 2021-09-12T18:07:39.978355.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x14736bee4f30&gt;
+Process 3 started at 2021-09-12T18:07:39.983689.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x14736bee4870&gt;
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Generating grid code
+Constructing/adding: lnm1
+Constructing/adding: q
+Constructing/adding: log10per
+Saving grid code to grid_options
+Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py
+Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py
+Grid code loaded
+163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB
+322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB
+465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB
+586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB
+682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB
+784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB
+872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB
+963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 3 finished:
+        generator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).
+        Ran 222 systems with a total probability of 0.014137215791516371.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.
+[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 1 finished:
+        generator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).
+        Ran 273 systems with a total probability of 0.01877334232598154.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.
+[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 0 finished:
+        generator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).
+        Ran 268 systems with a total probability of 0.016469813170514686.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.
+[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 2 finished:
+        generator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).
+        Ran 237 systems with a total probability of 0.015210228389288167.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<p>After the run is complete, some technical report on the run is returned. I stored that in <code class="docutils literal notranslate"><span class="pre">analytics</span></code>. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="nb">print</span><span class="p">(</span><span class="n">analytics</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+{&#39;population_name&#39;: &#39;ad303100d719457c83256568f9a9887c&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 0.06459059967730076, &#39;total_count&#39;: 1000, &#39;start_timestamp&#39;: 1631462859.9342952, &#39;end_timestamp&#39;: 1631462947.4824853, &#39;total_mass_run&#39;: 4680.235689312421, &#39;total_probability_weighted_mass_run&#39;: 0.22611318083528567, &#39;zero_prob_stars_skipped&#39;: 0}
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># make a plot of the distributions</span>
+<span class="kn">import</span> <span class="nn">seaborn</span> <span class="k">as</span> <span class="nn">sns</span>
+<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
+<span class="kn">import</span> <span class="nn">copy</span>
+<span class="n">pd</span><span class="o">.</span><span class="n">set_option</span><span class="p">(</span><span class="s2">&quot;display.max_rows&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="s2">&quot;display.max_columns&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">pad_output_distribution</span>
+
+<span class="c1"># set up seaborn for use in the notebook</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;figure.figsize&#39;</span><span class="p">:(</span><span class="mi">20</span><span class="p">,</span><span class="mi">10</span><span class="p">)})</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set_context</span><span class="p">(</span><span class="s2">&quot;notebook&quot;</span><span class="p">,</span>
+                <span class="n">font_scale</span><span class="o">=</span><span class="mf">1.5</span><span class="p">,</span>
+                <span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;lines.linewidth&quot;</span><span class="p">:</span><span class="mf">2.5</span><span class="p">})</span>
+
+<span class="n">pd</span><span class="o">.</span><span class="n">set_option</span><span class="p">(</span><span class="s2">&quot;display.max_rows&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">,</span> <span class="s2">&quot;display.max_columns&quot;</span><span class="p">,</span> <span class="kc">None</span><span class="p">)</span>
+
+<span class="c1"># remove the merged objects</span>
+<span class="n">probability</span> <span class="o">=</span> <span class="p">{</span> <span class="s2">&quot;merged&quot;</span> <span class="p">:</span> <span class="mf">0.0</span><span class="p">,</span> <span class="s2">&quot;unmerged&quot;</span> <span class="p">:</span> <span class="mf">0.0</span><span class="p">}</span>
+
+<span class="c1"># copy the results so we can change the copy</span>
+<span class="n">results</span> <span class="o">=</span> <span class="n">copy</span><span class="o">.</span><span class="n">deepcopy</span><span class="p">(</span><span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">)</span>
+
+<span class="k">for</span> <span class="n">distribution</span> <span class="ow">in</span> <span class="p">[</span><span class="s1">&#39;post&#39;</span><span class="p">]:</span>
+    <span class="k">for</span> <span class="n">logper</span> <span class="ow">in</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="n">distribution</span><span class="p">]:</span>
+        <span class="n">dprob</span> <span class="o">=</span> <span class="n">results</span><span class="p">[</span><span class="n">distribution</span><span class="p">][</span><span class="n">logper</span><span class="p">]</span>
+        <span class="k">if</span> <span class="n">logper</span> <span class="o">&lt;</span> <span class="o">-</span><span class="mi">90</span><span class="p">:</span>
+            <span class="c1"># merged system</span>
+            <span class="n">probability</span><span class="p">[</span><span class="s2">&quot;merged&quot;</span><span class="p">]</span> <span class="o">+=</span> <span class="n">dprob</span>
+            <span class="k">del</span> <span class="n">results</span><span class="p">[</span><span class="n">distribution</span><span class="p">][</span><span class="n">logper</span><span class="p">]</span>
+        <span class="k">else</span><span class="p">:</span>
+            <span class="c1"># unmerged system</span>
+            <span class="n">probability</span><span class="p">[</span><span class="s2">&quot;unmerged&quot;</span><span class="p">]</span> <span class="o">+=</span> <span class="n">dprob</span>
+<span class="nb">print</span><span class="p">(</span><span class="n">probability</span><span class="p">)</span>
+
+<span class="c1"># pad the final distribution with zero</span>
+<span class="k">for</span> <span class="n">distribution</span> <span class="ow">in</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">:</span>
+    <span class="n">pad_output_distribution</span><span class="p">(</span><span class="n">results</span><span class="p">[</span><span class="n">distribution</span><span class="p">],</span>
+                            <span class="n">binwidth</span><span class="p">)</span>
+
+<span class="c1"># make pandas dataframe</span>
+<span class="n">plot_data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="o">.</span><span class="n">from_dict</span><span class="p">(</span><span class="n">results</span><span class="p">,</span> <span class="n">orient</span><span class="o">=</span><span class="s1">&#39;columns&#39;</span><span class="p">)</span>
+
+<span class="c1"># make the plot</span>
+<span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">plot_data</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2"> (P_\mathrm</span><span class="si">{orb}</span><span class="s2"> / \mathrm</span><span class="si">{day}</span><span class="s2">)$&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;Number of stars&quot;</span><span class="p">)</span>
+<span class="c1">#p.set(xlim=(-5,5)) # might be necessary?</span>
+
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+{&#39;merged&#39;: 0.035263029200000025, &#39;unmerged&#39;: 0.019388724199999995}
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Text(0, 0.5, &#39;Number of stars&#39;)
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_common_envelope_evolution_14_2.png" src="_images/notebook_common_envelope_evolution_14_2.png" />
+</div>
+</div>
+<p>You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range <span class="math notranslate nohighlight">\(10\)</span> to <span class="math notranslate nohighlight">\(1000\text{ }\mathrm{d}\)</span>, while after CEE the distribution peaks at about <span class="math notranslate nohighlight">\(1\text{ }\mathrm{d}\)</span>. Some of these orbits are very short: <span class="math notranslate nohighlight">\(\log_{10}(-2) = 0.01\text{ }\mathrm{d}\sim10\text{ }\mathrm{minutes}\)</span>. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources.</p>
+<p>Things to try: * Extend the logging to output more data than just the orbital period. * What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova? * What are the lifetimes of the systems in close (<span class="math notranslate nohighlight">\(&lt;1\text{ }\mathrm{d}\)</span>) binaries? Are they likely to merge in the life of the Universe? * How much mass is lost in common-envelope interactions? * Extend the grid to massive stars. Do you see many NS and BH compact binaries? *
+Try different <span class="math notranslate nohighlight">\(\alpha_\mathrm{CE}\)</span> and <span class="math notranslate nohighlight">\(\lambda_\mathrm{CE}\)</span> options… * … and perhaps increased resolution to obtain smoother curves. * Why do long-period systems not reach common envelope evolution?</p>
+</div>
+</div>
+
+
+           </div>
+           
+          </div>
+          <footer>
+  
+    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
+      
+        <a href="binary_c_parameters.html" class="btn btn-neutral float-right" title="Binary_c parameters" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+      
+      
+        <a href="notebook_HRD.html" class="btn btn-neutral float-left" title="Example use case: Hertzsprung-Russell diagrams" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+      
+    </div>
+  
+
+  <hr/>
+
+  <div role="contentinfo">
+    <p>
+        
+        &copy; Copyright 2021, David Hendriks, Robert Izzard
+
+    </p>
+  </div>
+    
+    
+    
+    Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a
+    
+    <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
+    
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+<br><br>
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+<br><br>
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
+
+
+
+</footer>
+
+        </div>
+      </div>
+
+    </section>
+
+  </div>
+  
+
+  <script type="text/javascript">
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script>
+
+  
+  
+    
+   
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/build/html/notebook_common_envelope_evolution.ipynb b/docs/build/html/notebook_common_envelope_evolution.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..526320ccf954c1ed86c6d5c641204c4a9345bbe5
--- /dev/null
+++ b/docs/build/html/notebook_common_envelope_evolution.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Common-envelope evolution\n",
+    "\n",
+    "In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.\n",
+    "\n",
+    "First, we import a few required Python modules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_comenv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Setting up the Population object\n",
+    "We set up a new population object. Our stars evolve to $13.7\\text{ }\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. We also set the common-envelope ejection efficiency $\\alpha_\\mathrm{CE}=1$ and the envelope structure parameter $\\lambda=0.5$. More complex options are available in *binary_c*, such as $\\lambda$ based on stellar mass, but this is just a demonstration example so let's keep things simple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: log_dt=10 to grid_options\n",
+      "adding: max_evolution_time=13700 to BSE_options\n",
+      "adding: metallicity=0.02 to BSE_options\n",
+      "adding: alpha_ce=1.0 to BSE_options\n",
+      "adding: lambda_ce=0.5 to BSE_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    # grid options\n",
+    "    tmp_dir = TMP_DIR,\n",
+    "    verbosity = 1,\n",
+    "    log_dt = 10, # log every 10 seconds\n",
+    "\n",
+    "    # binary-star evolution options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    alpha_ce = 1.0,\n",
+    "    lambda_ce = 0.5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $6\\text{ }\\mathrm{M}_\\odot$. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to $10^4\\text{ }\\mathrm{d}$ because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"lnm1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        6\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(math.log(1), math.log(6), 10)\",\n",
+      "    \"precode\": \"M_1=math.exp(lnm1)\",\n",
+      "    \"probdist\": \"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+      "    \"dphasevol\": \"dlnm1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"q\",\n",
+      "    \"longname\": \"Mass ratio\",\n",
+      "    \"valuerange\": [\n",
+      "        \"0.1/M_1\",\n",
+      "        1\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1/M_1, 1, 10)\",\n",
+      "    \"precode\": \"M_2 = q * M_1\",\n",
+      "    \"probdist\": \"flatsections(q, [{'min': 1/M_1, 'max': 1.0, 'height': 1}])\",\n",
+      "    \"dphasevol\": \"dq\",\n",
+      "    \"parameter_name\": \"M_2\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 1\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"log10per\",\n",
+      "    \"longname\": \"log10(Orbital_Period)\",\n",
+      "    \"valuerange\": [\n",
+      "        0.15,\n",
+      "        5.5\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(0.15, 4, 10)\",\n",
+      "    \"precode\": \"orbital_period = 10.0 ** log10per\\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)\",\n",
+      "    \"probdist\": \"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)\",\n",
+      "    \"dphasevol\": \"dlog10per\",\n",
+      "    \"parameter_name\": \"orbital_period\",\n",
+      "    \"condition\": null,\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 2\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10, \"q\" : 10, \"per\": 10} \n",
+    "massrange = [1, 6] \n",
+    "logperrange = [0.15, 4]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Logging and handling the output\n",
+    "\n",
+    "We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "\n",
+      "/*\n",
+      " * Detect when the comenv_count increased \n",
+      " */\n",
+      "if(stardata->model.comenv_count == 1 && \n",
+      "   stardata->previous_stardata->model.comenv_count == 0)\n",
+      "{\n",
+      "   /*\n",
+      "    * We just had this system's first common envelope:\n",
+      "    * output the time at which this happens, \n",
+      "    * the system's probability (proportional to the number of stars),\n",
+      "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+      "    * the current timestep (post-comenv) orbital period (days)\n",
+      "    */\n",
+      "    Printf(\"COMENV %g %g %g %g\\n\",\n",
+      "           stardata->model.time,\n",
+      "           stardata->model.probability,\n",
+      "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+      "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+      "           \n",
+      "    /*\n",
+      "     * We should waste no more CPU time on this system now we have the\n",
+      "     * data we want.\n",
+      "     */\n",
+      "    stardata->model.evolution_stop = TRUE;\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "\n",
+    "/*\n",
+    " * Detect when the comenv_count increased \n",
+    " */\n",
+    "if(stardata->model.comenv_count == 1 && \n",
+    "   stardata->previous_stardata->model.comenv_count == 0)\n",
+    "{\n",
+    "   /*\n",
+    "    * We just had this system's first common envelope:\n",
+    "    * output the time at which this happens, \n",
+    "    * the system's probability (proportional to the number of stars),\n",
+    "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+    "    * the current timestep (post-comenv) orbital period (days)\n",
+    "    */\n",
+    "    Printf(\"COMENV %g %g %g %g\\\\n\",\n",
+    "           stardata->model.time,\n",
+    "           stardata->model.probability,\n",
+    "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+    "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+    "           \n",
+    "    /*\n",
+    "     * We should waste no more CPU time on this system now we have the\n",
+    "     * data we want.\n",
+    "     */\n",
+    "    stardata->model.evolution_stop = TRUE;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"COMENV\" and process the associated data. We set up the parse_data function to do just this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14736bebc040> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "# log-period distribution bin width (dex)\n",
+    "binwidth = 0.5 \n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"probability\", \"pre_comenv_period\", \"post_comenv_period\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "        # choose COMENV lines of output\n",
+    "        if linedata[\"header\"] == \"COMENV\":\n",
+    "            # bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex\n",
+    "            binned_pre_period = bin_data(math.log10(linedata[\"pre_comenv_period\"]), binwidth)\n",
+    "            \n",
+    "            # but check if the post-comenv period is finite and positive: if \n",
+    "            # not, the system has merged and we give it an aritifical period\n",
+    "            # of 10^-100 days (which is very much unphysical)\n",
+    "            if linedata[\"post_comenv_period\"] > 0.0:\n",
+    "                binned_post_period = bin_data(math.log10(linedata[\"post_comenv_period\"]), binwidth)\n",
+    "            else:\n",
+    "                binned_post_period = bin_data(-100,binwidth) # merged!\n",
+    "                \n",
+    "            # make the \"histograms\"\n",
+    "            self.grid_results['pre'][binned_pre_period] += linedata[\"probability\"]\n",
+    "            self.grid_results['post'][binned_post_period] += linedata[\"probability\"]\n",
+    "\n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 1000 stars\n",
+      "with a total probability of 0.0645905996773004\n",
+      "Total starcount for this run will be: 1000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-12T18:07:39.965721.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee47e0>\n",
+      "Process 1 started at 2021-09-12T18:07:39.970949.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n",
+      "Process 2 started at 2021-09-12T18:07:39.978355.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4f30>\n",
+      "Process 3 started at 2021-09-12T18:07:39.983689.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB\n",
+      "322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB\n",
+      "465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB\n",
+      "586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB\n",
+      "682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB\n",
+      "784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB\n",
+      "872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB\n",
+      "963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).\n",
+      "\tRan 222 systems with a total probability of 0.014137215791516371.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).\n",
+      "\tRan 273 systems with a total probability of 0.01877334232598154.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).\n",
+      "\tRan 268 systems with a total probability of 0.016469813170514686.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).\n",
+      "\tRan 237 systems with a total probability of 0.015210228389288167.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'ad303100d719457c83256568f9a9887c', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.06459059967730076, 'total_count': 1000, 'start_timestamp': 1631462859.9342952, 'end_timestamp': 1631462947.4824853, 'total_mass_run': 4680.235689312421, 'total_probability_weighted_mass_run': 0.22611318083528567, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'merged': 0.035263029200000025, 'unmerged': 0.019388724199999995}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Number of stars')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the distributions\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import copy\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "# remove the merged objects\n",
+    "probability = { \"merged\" : 0.0, \"unmerged\" : 0.0}\n",
+    "\n",
+    "# copy the results so we can change the copy\n",
+    "results = copy.deepcopy(population.grid_results)\n",
+    "\n",
+    "for distribution in ['post']:    \n",
+    "    for logper in population.grid_results[distribution]:\n",
+    "        dprob = results[distribution][logper]\n",
+    "        if logper < -90:\n",
+    "            # merged system\n",
+    "            probability[\"merged\"] += dprob\n",
+    "            del results[distribution][logper]\n",
+    "        else:\n",
+    "            # unmerged system\n",
+    "            probability[\"unmerged\"] += dprob\n",
+    "print(probability)\n",
+    "    \n",
+    "# pad the final distribution with zero\n",
+    "for distribution in population.grid_results:    \n",
+    "    pad_output_distribution(results[distribution],\n",
+    "                            binwidth)\n",
+    "    \n",
+    "# make pandas dataframe \n",
+    "plot_data = pd.DataFrame.from_dict(results, orient='columns')\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10} (P_\\mathrm{orb} / \\mathrm{day})$\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "#p.set(xlim=(-5,5)) # might be necessary?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4740c93-d01e-4ca1-8766-c2fb4ddca2e4",
+   "metadata": {},
+   "source": [
+    "You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range $10$ to $1000\\text{ }\\mathrm{d}$, while after CEE the distribution peaks at about $1\\text{ }\\mathrm{d}$. Some of these orbits are very short: $\\log_{10}(-2) = 0.01\\text{ }\\mathrm{d}\\sim10\\text{ }\\mathrm{minutes}$. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57faf043-3809-427a-b378-2355ce8c2691",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Extend the logging to output more data than just the orbital period.\n",
+    "* What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova?\n",
+    "* What are the lifetimes of the systems in close ($<1\\text{ }\\mathrm{d}$) binaries? Are they likely to merge in the life of the Universe?\n",
+    "* How much mass is lost in common-envelope interactions?\n",
+    "* Extend the grid to massive stars. Do you see many NS and BH compact binaries?\n",
+    "* Try different $\\alpha_\\mathrm{CE}$ and $\\lambda_\\mathrm{CE}$ options...\n",
+    "* ... and perhaps increased resolution to obtain smoother curves.\n",
+    "* Why do long-period systems not reach common envelope evolution?"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/notebook_custom_logging.html b/docs/build/html/notebook_custom_logging.html
index 1c8c66116ae305fa4e1790f093b731392bb1f5e9..aa4d05806f38293ff535db6f8bd31a1278e5428f 100644
--- a/docs/build/html/notebook_custom_logging.html
+++ b/docs/build/html/notebook_custom_logging.html
@@ -7,7 +7,7 @@
   
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   
-  <title>Using custom logging routines with binarycpython &mdash; binary_c-python  documentation</title>
+  <title>Tutorial: Using custom logging routines with binary_c-python &mdash; binary_c-python  documentation</title>
   
 
   
@@ -39,8 +39,8 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Running populations with binarycpython" href="notebook_population.html" />
-    <link rel="prev" title="Running individual systems with binarycpython" href="notebook_individual_systems.html" /> 
+    <link rel="next" title="Tutorial: Running populations with binary_c-python" href="notebook_population.html" />
+    <link rel="prev" title="Tutorial: Running individual systems with binary_c-python" href="notebook_individual_systems.html" /> 
 </head>
 
 <body class="wy-body-for-nav">
@@ -90,8 +90,8 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2 current"><a class="current reference internal" href="#">Using custom logging routines with binarycpython</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Tutorial: Using custom logging routines with binary_c-python</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#Usage">Usage</a><ul>
 <li class="toctree-l4"><a class="reference internal" href="#Using-custom-logging-with-the-population-object">Using custom logging with the population object</a></li>
 <li class="toctree-l4"><a class="reference internal" href="#Using-custom-logging-when-running-directly-from-the-API">Using custom logging when running directly from the API</a></li>
@@ -104,9 +104,13 @@
 </li>
 </ul>
 </li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -161,7 +165,7 @@
         
           <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
         
-      <li>Using custom logging routines with binarycpython</li>
+      <li>Tutorial: Using custom logging routines with binary_c-python</li>
     
     
       <li class="wy-breadcrumbs-aside">
@@ -450,11 +454,11 @@ div.rendered_html tbody tr:hover {
     text-align: unset;
 }
 </style>
-<div class="section" id="Using-custom-logging-routines-with-binarycpython">
-<h1>Using custom logging routines with binarycpython<a class="headerlink" href="#Using-custom-logging-routines-with-binarycpython" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="Tutorial:-Using-custom-logging-routines-with-binary_c-python">
+<h1>Tutorial: Using custom logging routines with binary_c-python<a class="headerlink" href="#Tutorial:-Using-custom-logging-routines-with-binary_c-python" title="Permalink to this headline">¶</a></h1>
 <p>In this notebook you’ll learn how to use the custom logging functionality</p>
 <div class="nbinput nblast docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[37]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -477,7 +481,7 @@ div.rendered_html tbody tr:hover {
 <h2>Usage<a class="headerlink" href="#Usage" title="Permalink to this headline">¶</a></h2>
 <p>There are two methods to create the C-code that will be compiled: - Automatically generate the print statement and use the wrapper to generate the full function string, by using <code class="docutils literal notranslate"><span class="pre">autogen_C_logging_code</span></code> - Create your custom print statement and use the wrapper to generate the full function string, by writing out the print statement. Here the logging statement obviously has to be valid C code</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -501,7 +505,7 @@ Printf(&#34;MY_STELLAR_DATA %g %g\n&#34;,((double)stardata-&gt;model.time),((dou
 </pre></div></div>
 </div>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[30]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -520,7 +524,7 @@ Printf(&#34;MY_STELLAR_DATA time=%g mass=%g\n&#34;, stardata-&gt;model.time, sta
 </pre></div></div>
 </div>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[31]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -557,7 +561,7 @@ void binary_c_API_function custom_output_function(struct stardata_t * stardata)
 </div>
 <p>Combining the above with e.g. run_system() (see notebook_individual_systems for more examples):</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[32]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -590,7 +594,7 @@ MY_STELLAR_DATA time=2e-06 mass=2
 <h3>Using custom logging with the population object<a class="headerlink" href="#Using-custom-logging-with-the-population-object" title="Permalink to this headline">¶</a></h3>
 <p>Custom logging can be used for a whole population by setting the print statement (so not the entire logging script) in <code class="docutils literal notranslate"><span class="pre">C_logging_code</span></code></p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[33]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -638,10 +642,10 @@ MY_STELLAR_DATA time=2e-06 mass=2
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1
-EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2
-EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2
-EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2
+EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1
+EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2
+EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2
+EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2
 </pre></div></div>
 </div>
 </div>
@@ -649,7 +653,7 @@ EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057
 <h3>Using custom logging when running directly from the API<a class="headerlink" href="#Using-custom-logging-when-running-directly-from-the-API" title="Permalink to this headline">¶</a></h3>
 <p>When running a system directly with the API we need to manually load the custom logging into memory (via <code class="docutils literal notranslate"><span class="pre">create_and_load_logging_function</span></code>) and pass the memory address to the binary_c binding via <code class="docutils literal notranslate"><span class="pre">_binary_c_bindings.run_system(argstring,</span> <span class="pre">custom_logging_func_memaddr=custom_logging_memaddr)</span></code></p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[40]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -714,7 +718,7 @@ MY_STELLAR_DATA 2e-06 15
 <h3>Compact object<a class="headerlink" href="#Compact-object" title="Permalink to this headline">¶</a></h3>
 <p>This logging will print the timestep when the star becomes a compact object. After it does, we change the maximum time to be the current time, effectively terminating the evolution</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[42]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -758,8 +762,8 @@ MY_STELLAR_DATA 2e-06 15
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-SINGLE_STAR_LIFETIME 10 27.7358
-EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5
+SINGLE_STAR_LIFETIME 10 28.4838
+EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5
 </pre></div></div>
 </div>
 </div>
@@ -767,7 +771,7 @@ EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.44
 <h3>Logging mass evolution and the supernova<a class="headerlink" href="#Logging-mass-evolution-and-the-supernova" title="Permalink to this headline">¶</a></h3>
 <p>This logging code prints the mass evolution and the moment the star goes supernova</p>
 <div class="nbinput docutils container">
-<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[47]:
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
@@ -786,58 +790,27 @@ EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.44
 <span class="s2">{</span>
 <span class="s2">    if (stardata-&gt;model.time &lt; stardata-&gt;model.max_evolution_time)</span>
 <span class="s2">    {</span>
-<span class="s2">        if(stardata-&gt;pre_events_stardata != NULL)</span>
-<span class="s2">        {</span>
-<span class="s2">            Printf(&quot;EXAMPLE_SN </span><span class="si">%30.12e</span><span class="s2"> &quot; // 1</span>
-<span class="s2">                &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> &quot; // 2-5</span>
-<span class="s2">                &quot;</span><span class="si">%d</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> &quot; // 6-9</span>
-<span class="s2">                &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;, // 10-13</span>
-
-<span class="s2">                //</span>
-<span class="s2">                stardata-&gt;model.time, // 1</span>
-
-<span class="s2">                stardata-&gt;star[0].mass, //2</span>
-<span class="s2">                stardata-&gt;pre_events_stardata-&gt;star[0].mass, //3</span>
-<span class="s2">                stardata-&gt;common.zero_age.mass[0], //4</span>
-<span class="s2">                stardata-&gt;star[0].SN_type, //5</span>
-
-<span class="s2">                stardata-&gt;star[0].stellar_type, //6</span>
-<span class="s2">                stardata-&gt;pre_events_stardata-&gt;star[0].stellar_type, //7</span>
-<span class="s2">                stardata-&gt;model.probability, //8</span>
-<span class="s2">                stardata-&gt;pre_events_stardata-&gt;star[0].core_mass[ID_core(stardata-&gt;pre_events_stardata-&gt;star[0].stellar_type)],           // 9</span>
-
-<span class="s2">                stardata-&gt;pre_events_stardata-&gt;star[0].core_mass[CORE_CO],     // 10</span>
-<span class="s2">                stardata-&gt;pre_events_stardata-&gt;star[0].core_mass[CORE_He],    // 11</span>
-<span class="s2">                stardata-&gt;star[0].fallback, // 12</span>
-<span class="s2">                stardata-&gt;star[0].fallback_mass // 13</span>
-<span class="s2">            );</span>
-<span class="s2">        }</span>
-<span class="s2">        else</span>
-<span class="s2">        {</span>
-<span class="s2">            Printf(&quot;EXAMPLE_SN </span><span class="si">%30.12e</span><span class="s2"> &quot; // 1</span>
-<span class="s2">                &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> &quot; // 2-5</span>
-<span class="s2">                &quot;</span><span class="si">%d</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> &quot; // 6-9</span>
-<span class="s2">                &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;, // 10-13</span>
-
-<span class="s2">                //</span>
-<span class="s2">                stardata-&gt;model.time, // 1</span>
-
-<span class="s2">                stardata-&gt;star[0].mass, //2</span>
-<span class="s2">                stardata-&gt;previous_stardata-&gt;star[0].mass, //3</span>
-<span class="s2">                stardata-&gt;common.zero_age.mass[0], //4</span>
-<span class="s2">                stardata-&gt;star[0].SN_type, //5</span>
-
-<span class="s2">                stardata-&gt;star[0].stellar_type, //6</span>
-<span class="s2">                stardata-&gt;previous_stardata-&gt;star[0].stellar_type, //7</span>
-<span class="s2">                stardata-&gt;model.probability, //8</span>
-<span class="s2">                stardata-&gt;previous_stardata-&gt;star[0].core_mass[ID_core(stardata-&gt;previous_stardata-&gt;star[0].stellar_type)],           // 9</span>
-
-<span class="s2">                stardata-&gt;previous_stardata-&gt;star[0].core_mass[CORE_CO],     // 10</span>
-<span class="s2">                stardata-&gt;previous_stardata-&gt;star[0].core_mass[CORE_He],    // 11</span>
-<span class="s2">                stardata-&gt;star[0].fallback, // 12</span>
-<span class="s2">                stardata-&gt;star[0].fallback_mass // 13</span>
-<span class="s2">            );</span>
-<span class="s2">        }</span>
+<span class="s2">        Printf(&quot;EXAMPLE_SN </span><span class="si">%30.12e</span><span class="s2"> &quot; // 1</span>
+<span class="s2">            &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> &quot; // 2-5</span>
+<span class="s2">            &quot;</span><span class="si">%d</span><span class="s2"> </span><span class="si">%d</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> &quot; // 6-9</span>
+<span class="s2">            &quot;</span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;, // 10-13</span>
+
+<span class="s2">            //</span>
+<span class="s2">            stardata-&gt;model.time, // 1</span>
+
+<span class="s2">            stardata-&gt;star[0].mass, //2</span>
+<span class="s2">            stardata-&gt;previous_stardata-&gt;star[0].mass, //3</span>
+<span class="s2">            stardata-&gt;common.zero_age.mass[0], //4</span>
+<span class="s2">            stardata-&gt;star[0].SN_type, //5</span>
+
+<span class="s2">            stardata-&gt;star[0].stellar_type, //6</span>
+<span class="s2">            stardata-&gt;previous_stardata-&gt;star[0].stellar_type, //7</span>
+<span class="s2">            stardata-&gt;model.probability, //8</span>
+<span class="s2">            stardata-&gt;previous_stardata-&gt;star[0].core_mass[ID_core(stardata-&gt;previous_stardata-&gt;star[0].stellar_type)],           // 9</span>
+
+<span class="s2">            stardata-&gt;previous_stardata-&gt;star[0].core_mass[CORE_CO],     // 10</span>
+<span class="s2">            stardata-&gt;previous_stardata-&gt;star[0].core_mass[CORE_He]    // 11</span>
+<span class="s2">        );</span>
 <span class="s2">    };</span>
 <span class="s2">    /* Kill the simulation to save time */</span>
 <span class="s2">    stardata-&gt;model.max_evolution_time = stardata-&gt;model.time - stardata-&gt;model.dtm;</span>
@@ -860,10 +833,19 @@ EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.44
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1
-EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0
+EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1
+EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458
 </pre></div></div>
 </div>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[ ]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span>
+</pre></div>
+</div>
+</div>
 </div>
 </div>
 </div>
@@ -876,10 +858,10 @@ EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="notebook_population.html" class="btn btn-neutral float-right" title="Running populations with binarycpython" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_population.html" class="btn btn-neutral float-right" title="Tutorial: Running populations with binary_c-python" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="notebook_individual_systems.html" class="btn btn-neutral float-left" title="Running individual systems with binarycpython" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="notebook_individual_systems.html" class="btn btn-neutral float-left" title="Tutorial: Running individual systems with binary_c-python" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   
@@ -902,9 +884,9 @@ EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_custom_logging.ipynb b/docs/build/html/notebook_custom_logging.ipynb
index 05ffbccfc23f0b08e85abed0d467233385520a4b..bfdf2a5c8fe238aec50d8f69c74d11b06491eb5f 100644
--- a/docs/build/html/notebook_custom_logging.ipynb
+++ b/docs/build/html/notebook_custom_logging.ipynb
@@ -5,13 +5,13 @@
    "id": "879b596b-d70c-4f90-b668-563b4ad93ffc",
    "metadata": {},
    "source": [
-    "# Using custom logging routines with binarycpython\n",
+    "# Tutorial: Using custom logging routines with binary_c-python\n",
     "In this notebook you'll learn how to use the custom logging functionality"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "696ecbb9-1efd-48f4-a57e-2cf6dfe416f1",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "236cf821-09ac-4237-9b8f-6e36d2edf446",
    "metadata": {},
    "outputs": [
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "feb423d5-5cc3-433c-9801-f8017abbc03a",
    "metadata": {},
    "outputs": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 4,
    "id": "2f5defbf-c623-49ed-a238-fba52a563a58",
    "metadata": {},
    "outputs": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 5,
    "id": "dcd74bbc-478b-43e4-b495-8c456e8d1d88",
    "metadata": {},
    "outputs": [
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 6,
    "id": "77bd09b0-1a94-499d-97db-a1f991c67c12",
    "metadata": {},
    "outputs": [
@@ -203,10 +203,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1\n",
-      "EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2\n"
+      "EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1\n",
+      "EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2\n"
      ]
     }
    ],
@@ -260,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 7,
    "id": "30142286-34ce-433e-82c8-565e2160ff5b",
    "metadata": {},
    "outputs": [
@@ -336,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "id": "6f0edc65-a788-4706-a0c5-2ace030765ec",
    "metadata": {},
    "outputs": [
@@ -344,8 +344,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
-      "EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5\n"
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
+      "EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5\n"
      ]
     }
    ],
@@ -395,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 10,
    "id": "8f58fdf9-3e76-4c18-a1c5-eed0980d4133",
    "metadata": {},
    "outputs": [
@@ -403,8 +403,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1\n",
-      "EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0\n"
+      "EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1\n",
+      "EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458\n"
      ]
     }
    ],
@@ -424,58 +424,27 @@
     "{\n",
     "    if (stardata->model.time < stardata->model.max_evolution_time)\n",
     "    {\n",
-    "        if(stardata->pre_events_stardata != NULL)\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
-    "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->pre_events_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "        Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
+    "            \"%g %g %g %d \" // 2-5\n",
+    "            \"%d %d %g %g \" // 6-9\n",
+    "            \"%g %g\\\\n\", // 10-13\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->pre_events_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[ID_core(stardata->pre_events_stardata->star[0].stellar_type)],           // 9\n",
-    "\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
-    "        else\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
+    "            // \n",
+    "            stardata->model.time, // 1\n",
     "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->previous_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "            stardata->star[0].mass, //2\n",
+    "            stardata->previous_stardata->star[0].mass, //3\n",
+    "            stardata->common.zero_age.mass[0], //4\n",
+    "            stardata->star[0].SN_type, //5\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->previous_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
+    "            stardata->star[0].stellar_type, //6\n",
+    "            stardata->previous_stardata->star[0].stellar_type, //7\n",
+    "            stardata->model.probability, //8\n",
+    "            stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
     "\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_He]    // 11\n",
+    "        );\n",
     "    };\n",
     "    /* Kill the simulation to save time */\n",
     "    stardata->model.max_evolution_time = stardata->model.time - stardata->model.dtm;\n",
@@ -491,6 +460,14 @@
     "# print (abridged) output\n",
     "print(\"\\n\".join(output.splitlines()[-2:]))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "484297c0-accb-4efc-a9c8-dbd2f32b89a6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/build/html/notebook_extra_features.html b/docs/build/html/notebook_extra_features.html
index bd6f0c339880fd59d4c25aea33c9efb517867483..407cf0316be2ee1d6e76b950855142b3926a22e2 100644
--- a/docs/build/html/notebook_extra_features.html
+++ b/docs/build/html/notebook_extra_features.html
@@ -7,7 +7,7 @@
   
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   
-  <title>Extra features and functionality of binarycpython &mdash; binary_c-python  documentation</title>
+  <title>Tutorial: Extra features and functionality of binary_c-python &mdash; binary_c-python  documentation</title>
   
 
   
@@ -39,8 +39,8 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Using the API functionality of binarycpython" href="notebook_api_functionality.html" />
-    <link rel="prev" title="Running populations with binarycpython" href="notebook_population.html" /> 
+    <link rel="next" title="Tutorial: Using the API functionality of binary_c-python" href="notebook_api_functionality.html" />
+    <link rel="prev" title="Tutorial: Running populations with binary_c-python" href="notebook_population.html" /> 
 </head>
 
 <body class="wy-body-for-nav">
@@ -90,10 +90,10 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2 current"><a class="current reference internal" href="#">Extra features and functionality of binarycpython</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Tutorial: Extra features and functionality of binary_c-python</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#getting-extra-information-about-binary_c-parameters">getting extra information about binary_c parameters</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Build-information-of-binary_c">Build information of binary_c</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Example-parse-function">Example parse function</a></li>
@@ -101,7 +101,11 @@
 <li class="toctree-l3"><a class="reference internal" href="#Getting-help">Getting help</a></li>
 </ul>
 </li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -156,7 +160,7 @@
         
           <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
         
-      <li>Extra features and functionality of binarycpython</li>
+      <li>Tutorial: Extra features and functionality of binary_c-python</li>
     
     
       <li class="wy-breadcrumbs-aside">
@@ -445,8 +449,8 @@ div.rendered_html tbody tr:hover {
     text-align: unset;
 }
 </style>
-<div class="section" id="Extra-features-and-functionality-of-binarycpython">
-<h1>Extra features and functionality of binarycpython<a class="headerlink" href="#Extra-features-and-functionality-of-binarycpython" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="Tutorial:-Extra-features-and-functionality-of-binary_c-python">
+<h1>Tutorial: Extra features and functionality of binary_c-python<a class="headerlink" href="#Tutorial:-Extra-features-and-functionality-of-binary_c-python" title="Permalink to this headline">¶</a></h1>
 <p>In this notebook we’ll go over some of the extra features and functionality that was not covered in the other notebooks.</p>
 <p>Within the module <code class="docutils literal notranslate"><span class="pre">binarycpython.utils.functions</span></code> there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the <code class="docutils literal notranslate"><span class="pre">help()</span></code></p>
 <div class="nbinput nblast docutils container">
@@ -620,10 +624,10 @@ get_defaults(filter_values:bool=False) -&gt; dict
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="notebook_api_functionality.html" class="btn btn-neutral float-right" title="Using the API functionality of binarycpython" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_api_functionality.html" class="btn btn-neutral float-right" title="Tutorial: Using the API functionality of binary_c-python" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="notebook_population.html" class="btn btn-neutral float-left" title="Running populations with binarycpython" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="notebook_population.html" class="btn btn-neutral float-left" title="Tutorial: Running populations with binary_c-python" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   
@@ -646,9 +650,9 @@ get_defaults(filter_values:bool=False) -&gt; dict
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_extra_features.ipynb b/docs/build/html/notebook_extra_features.ipynb
index b1a9ddb030195e6aaf0da2cf08eecc67684672a6..076b4098e7c588a68fb91cfe6175c3ee4e36ea78 100644
--- a/docs/build/html/notebook_extra_features.ipynb
+++ b/docs/build/html/notebook_extra_features.ipynb
@@ -5,7 +5,7 @@
    "id": "d5c04b77-f0be-4b33-8c03-c72eb846527c",
    "metadata": {},
    "source": [
-    "# Extra features and functionality of binarycpython\n",
+    "# Tutorial: Extra features and functionality of binary_c-python\n",
     "In this notebook we'll go over some of the extra features and functionality that was not covered in the other notebooks.\n",
     "\n",
     "Within the module `binarycpython.utils.functions` there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the `help()`"
diff --git a/docs/build/html/notebook_individual_systems.html b/docs/build/html/notebook_individual_systems.html
index f2110d005926fc4d6ef036b02c16691600b1ee71..3c61e7be689f33a7b5060a2c449b21330b924200 100644
--- a/docs/build/html/notebook_individual_systems.html
+++ b/docs/build/html/notebook_individual_systems.html
@@ -7,7 +7,7 @@
   
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   
-  <title>Running individual systems with binarycpython &mdash; binary_c-python  documentation</title>
+  <title>Tutorial: Running individual systems with binary_c-python &mdash; binary_c-python  documentation</title>
   
 
   
@@ -39,7 +39,7 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Using custom logging routines with binarycpython" href="notebook_custom_logging.html" />
+    <link rel="next" title="Tutorial: Using custom logging routines with binary_c-python" href="notebook_custom_logging.html" />
     <link rel="prev" title="Example notebooks" href="example_notebooks.html" /> 
 </head>
 
@@ -90,16 +90,20 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
-<li class="toctree-l2 current"><a class="current reference internal" href="#">Running individual systems with binarycpython</a><ul>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Tutorial: Running individual systems with binary_c-python</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#Single-system-with-run_wrapper">Single system with run_wrapper</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Single-system-via-population-object">Single system via population object</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Single-system-via-API-functionality">Single system via API functionality</a></li>
 </ul>
 </li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Running populations with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -154,7 +158,7 @@
         
           <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
         
-      <li>Running individual systems with binarycpython</li>
+      <li>Tutorial: Running individual systems with binary_c-python</li>
     
     
       <li class="wy-breadcrumbs-aside">
@@ -443,8 +447,8 @@ div.rendered_html tbody tr:hover {
     text-align: unset;
 }
 </style>
-<div class="section" id="Running-individual-systems-with-binarycpython">
-<h1>Running individual systems with binarycpython<a class="headerlink" href="#Running-individual-systems-with-binarycpython" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="Tutorial:-Running-individual-systems-with-binary_c-python">
+<h1>Tutorial: Running individual systems with binary_c-python<a class="headerlink" href="#Tutorial:-Running-individual-systems-with-binary_c-python" title="Permalink to this headline">¶</a></h1>
 <p>This notebook will show you how to run single systems and analyze their results.</p>
 <p>It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc.</p>
 <div class="section" id="Single-system-with-run_wrapper">
@@ -901,7 +905,7 @@ SINGLE_STAR_LIFETIME 15 14.9947
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="notebook_custom_logging.html" class="btn btn-neutral float-right" title="Using custom logging routines with binarycpython" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_custom_logging.html" class="btn btn-neutral float-right" title="Tutorial: Using custom logging routines with binary_c-python" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
         <a href="example_notebooks.html" class="btn btn-neutral float-left" title="Example notebooks" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
@@ -927,9 +931,9 @@ SINGLE_STAR_LIFETIME 15 14.9947
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_individual_systems.ipynb b/docs/build/html/notebook_individual_systems.ipynb
index 21d49016f3b2826d6f9d5ec87a1f6d8bb18df7af..85aef1e3962a1626f37a9ef36bf5e16f479eb68e 100644
--- a/docs/build/html/notebook_individual_systems.ipynb
+++ b/docs/build/html/notebook_individual_systems.ipynb
@@ -5,7 +5,7 @@
    "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
    "metadata": {},
    "source": [
-    "# Running individual systems with binarycpython\n",
+    "# Tutorial: Running individual systems with binary_c-python\n",
     "This notebook will show you how to run single systems and analyze their results.\n",
     "\n",
     "It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc. "
@@ -566,7 +566,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -580,7 +580,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/html/notebook_luminosity_function_binaries.html b/docs/build/html/notebook_luminosity_function_binaries.html
new file mode 100644
index 0000000000000000000000000000000000000000..026d2e78efe298107eede50987367f4e4d47edbe
--- /dev/null
+++ b/docs/build/html/notebook_luminosity_function_binaries.html
@@ -0,0 +1,1102 @@
+
+
+<!DOCTYPE html>
+<html class="writer-html5" lang="en" >
+<head>
+  <meta charset="utf-8">
+  
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  
+  <title>Zero-age stellar luminosity function in binaries &mdash; binary_c-python  documentation</title>
+  
+
+  
+  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
+  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+  
+  
+  
+  
+
+  
+  <!--[if lt IE 9]>
+    <script src="_static/js/html5shiv.min.js"></script>
+  <![endif]-->
+  
+    
+      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+        <script src="_static/jquery.js"></script>
+        <script src="_static/underscore.js"></script>
+        <script src="_static/doctools.js"></script>
+        <script src="_static/language_data.js"></script>
+        <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
+        <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
+        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
+    
+    <script type="text/javascript" src="_static/js/theme.js"></script>
+
+    
+    <link rel="index" title="Index" href="genindex.html" />
+    <link rel="search" title="Search" href="search.html" />
+    <link rel="next" title="Example use case: Hertzsprung-Russell diagrams" href="notebook_HRD.html" />
+    <link rel="prev" title="Example use case: Zero-age stellar luminosity function" href="notebook_luminosity_function_single.html" /> 
+</head>
+
+<body class="wy-body-for-nav">
+
+   
+  <div class="wy-grid-for-nav">
+    
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
+          
+
+          
+            <a href="index.html" class="icon icon-home" alt="Documentation Home"> binary_c-python
+          
+
+          
+          </a>
+
+          
+            
+            
+          
+
+          
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+
+          
+        </div>
+
+        
+        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
+          
+            
+            
+              
+            
+            
+              <p class="caption"><span class="caption-text">Contents:</span></p>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
+<li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
+<li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Zero-age stellar luminosity function in binaries</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Adding-grid-variables">Adding grid variables</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Evolving-the-grid">Evolving the grid</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
+<li class="toctree-l1"><a class="reference internal" href="grid_options_descriptions.html">Population grid code options</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python">Visit the GitLab repo</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/issues/new">Submit an issue</a></li>
+</ul>
+
+            
+          
+        </div>
+        
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
+
+      
+      <nav class="wy-nav-top" aria-label="top navigation">
+        
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="index.html">binary_c-python</a>
+        
+      </nav>
+
+
+      <div class="wy-nav-content">
+        
+        <div class="rst-content">
+        
+          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<div role="navigation" aria-label="breadcrumbs navigation">
+
+  <ul class="wy-breadcrumbs">
+    
+      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
+        
+          <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
+        
+      <li>Zero-age stellar luminosity function in binaries</li>
+    
+    
+      <li class="wy-breadcrumbs-aside">
+        
+            
+            <a href="_sources/notebook_luminosity_function_binaries.ipynb.txt" rel="nofollow"> View page source</a>
+          
+        
+      </li>
+    
+  </ul>
+
+  
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+            
+  
+<style>
+/* CSS for nbsphinx extension */
+
+/* remove conflicting styling from Sphinx themes */
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt *,
+div.nbinput.container div.input_area pre,
+div.nboutput.container div.output_area pre,
+div.nbinput.container div.input_area .highlight,
+div.nboutput.container div.output_area .highlight {
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}
+
+div.nbinput.container > div[class*=highlight],
+div.nboutput.container > div[class*=highlight] {
+    margin: 0;
+}
+
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt * {
+    background: none;
+}
+
+div.nboutput.container div.output_area .highlight,
+div.nboutput.container div.output_area pre {
+    background: unset;
+}
+
+div.nboutput.container div.output_area div.highlight {
+    color: unset;  /* override Pygments text color */
+}
+
+/* avoid gaps between output lines */
+div.nboutput.container div[class*=highlight] pre {
+    line-height: normal;
+}
+
+/* input/output containers */
+div.nbinput.container,
+div.nboutput.container {
+    display: -webkit-flex;
+    display: flex;
+    align-items: flex-start;
+    margin: 0;
+    width: 100%;
+}
+@media (max-width: 540px) {
+    div.nbinput.container,
+    div.nboutput.container {
+        flex-direction: column;
+    }
+}
+
+/* input container */
+div.nbinput.container {
+    padding-top: 5px;
+}
+
+/* last container */
+div.nblast.container {
+    padding-bottom: 5px;
+}
+
+/* input prompt */
+div.nbinput.container div.prompt pre {
+    color: #307FC1;
+}
+
+/* output prompt */
+div.nboutput.container div.prompt pre {
+    color: #BF5B3D;
+}
+
+/* all prompts */
+div.nbinput.container div.prompt,
+div.nboutput.container div.prompt {
+    width: 4.5ex;
+    padding-top: 5px;
+    position: relative;
+    user-select: none;
+}
+
+div.nbinput.container div.prompt > div,
+div.nboutput.container div.prompt > div {
+    position: absolute;
+    right: 0;
+    margin-right: 0.3ex;
+}
+
+@media (max-width: 540px) {
+    div.nbinput.container div.prompt,
+    div.nboutput.container div.prompt {
+        width: unset;
+        text-align: left;
+        padding: 0.4em;
+    }
+    div.nboutput.container div.prompt.empty {
+        padding: 0;
+    }
+
+    div.nbinput.container div.prompt > div,
+    div.nboutput.container div.prompt > div {
+        position: unset;
+    }
+}
+
+/* disable scrollbars on prompts */
+div.nbinput.container div.prompt pre,
+div.nboutput.container div.prompt pre {
+    overflow: hidden;
+}
+
+/* input/output area */
+div.nbinput.container div.input_area,
+div.nboutput.container div.output_area {
+    -webkit-flex: 1;
+    flex: 1;
+    overflow: auto;
+}
+@media (max-width: 540px) {
+    div.nbinput.container div.input_area,
+    div.nboutput.container div.output_area {
+        width: 100%;
+    }
+}
+
+/* input area */
+div.nbinput.container div.input_area {
+    border: 1px solid #e0e0e0;
+    border-radius: 2px;
+    /*background: #f5f5f5;*/
+}
+
+/* override MathJax center alignment in output cells */
+div.nboutput.container div[class*=MathJax] {
+    text-align: left !important;
+}
+
+/* override sphinx.ext.imgmath center alignment in output cells */
+div.nboutput.container div.math p {
+    text-align: left;
+}
+
+/* standard error */
+div.nboutput.container div.output_area.stderr {
+    background: #fdd;
+}
+
+/* ANSI colors */
+.ansi-black-fg { color: #3E424D; }
+.ansi-black-bg { background-color: #3E424D; }
+.ansi-black-intense-fg { color: #282C36; }
+.ansi-black-intense-bg { background-color: #282C36; }
+.ansi-red-fg { color: #E75C58; }
+.ansi-red-bg { background-color: #E75C58; }
+.ansi-red-intense-fg { color: #B22B31; }
+.ansi-red-intense-bg { background-color: #B22B31; }
+.ansi-green-fg { color: #00A250; }
+.ansi-green-bg { background-color: #00A250; }
+.ansi-green-intense-fg { color: #007427; }
+.ansi-green-intense-bg { background-color: #007427; }
+.ansi-yellow-fg { color: #DDB62B; }
+.ansi-yellow-bg { background-color: #DDB62B; }
+.ansi-yellow-intense-fg { color: #B27D12; }
+.ansi-yellow-intense-bg { background-color: #B27D12; }
+.ansi-blue-fg { color: #208FFB; }
+.ansi-blue-bg { background-color: #208FFB; }
+.ansi-blue-intense-fg { color: #0065CA; }
+.ansi-blue-intense-bg { background-color: #0065CA; }
+.ansi-magenta-fg { color: #D160C4; }
+.ansi-magenta-bg { background-color: #D160C4; }
+.ansi-magenta-intense-fg { color: #A03196; }
+.ansi-magenta-intense-bg { background-color: #A03196; }
+.ansi-cyan-fg { color: #60C6C8; }
+.ansi-cyan-bg { background-color: #60C6C8; }
+.ansi-cyan-intense-fg { color: #258F8F; }
+.ansi-cyan-intense-bg { background-color: #258F8F; }
+.ansi-white-fg { color: #C5C1B4; }
+.ansi-white-bg { background-color: #C5C1B4; }
+.ansi-white-intense-fg { color: #A1A6B2; }
+.ansi-white-intense-bg { background-color: #A1A6B2; }
+
+.ansi-default-inverse-fg { color: #FFFFFF; }
+.ansi-default-inverse-bg { background-color: #000000; }
+
+.ansi-bold { font-weight: bold; }
+.ansi-underline { text-decoration: underline; }
+
+
+div.nbinput.container div.input_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight].math,
+div.nboutput.container div.output_area.rendered_html,
+div.nboutput.container div.output_area > div.output_javascript,
+div.nboutput.container div.output_area:not(.rendered_html) > img{
+    padding: 5px;
+    margin: 0;
+}
+
+/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
+div.nbinput.container div.input_area > div[class^='highlight'],
+div.nboutput.container div.output_area > div[class^='highlight']{
+    overflow-y: hidden;
+}
+
+/* hide copybtn icon on prompts (needed for 'sphinx_copybutton') */
+.prompt a.copybtn {
+    display: none;
+}
+
+/* Some additional styling taken form the Jupyter notebook CSS */
+div.rendered_html table {
+  border: none;
+  border-collapse: collapse;
+  border-spacing: 0;
+  color: black;
+  font-size: 12px;
+  table-layout: fixed;
+}
+div.rendered_html thead {
+  border-bottom: 1px solid black;
+  vertical-align: bottom;
+}
+div.rendered_html tr,
+div.rendered_html th,
+div.rendered_html td {
+  text-align: right;
+  vertical-align: middle;
+  padding: 0.5em 0.5em;
+  line-height: normal;
+  white-space: normal;
+  max-width: none;
+  border: none;
+}
+div.rendered_html th {
+  font-weight: bold;
+}
+div.rendered_html tbody tr:nth-child(odd) {
+  background: #f5f5f5;
+}
+div.rendered_html tbody tr:hover {
+  background: rgba(66, 165, 245, 0.2);
+}
+
+/* CSS overrides for sphinx_rtd_theme */
+
+/* 24px margin */
+.nbinput.nblast.container,
+.nboutput.nblast.container {
+    margin-bottom: 19px;  /* padding has already 5px */
+}
+
+/* ... except between code cells! */
+.nblast.container + .nbinput.container {
+    margin-top: -19px;
+}
+
+.admonition > p:before {
+    margin-right: 4px;  /* make room for the exclamation icon */
+}
+
+/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
+.math {
+    text-align: unset;
+}
+</style>
+<div class="section" id="Zero-age-stellar-luminosity-function-in-binaries">
+<h1>Zero-age stellar luminosity function in binaries<a class="headerlink" href="#Zero-age-stellar-luminosity-function-in-binaries" title="Permalink to this headline">¶</a></h1>
+<p>In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c.</p>
+<p>Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.</p>
+<p>We start by loading in some standard Python modules and the binary_c module.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">os</span>
+<span class="kn">import</span> <span class="nn">math</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
+
+<span class="c1"># help(Population) # Uncomment this line to see the public functions of this object</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="Setting-up-the-Population-object">
+<h2>Setting up the Population object<a class="headerlink" href="#Setting-up-the-Population-object" title="Permalink to this headline">¶</a></h2>
+<p>To set up and configure the population object we need to make a new instance of the <code class="docutils literal notranslate"><span class="pre">Population</span></code> object and configure it with the <code class="docutils literal notranslate"><span class="pre">.set()</span></code> function.</p>
+<p>In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create population object</span>
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+
+<span class="c1"># If you want verbosity, set this before other things</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">verbosity</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
+
+<span class="c1"># Setting values can be done via .set(&lt;parameter_name&gt;=&lt;value&gt;)</span>
+<span class="c1"># Values that are known to be binary_c_parameters are loaded into bse_options.</span>
+<span class="c1"># Those that are present in the default grid_options are set in grid_options</span>
+<span class="c1"># All other values that you set are put in a custom_options dict</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># binary_c physics options</span>
+    <span class="n">max_evolution_time</span><span class="o">=</span><span class="mf">0.1</span><span class="p">,</span>  <span class="c1"># maximum stellar evolution time in Myr</span>
+ <span class="p">)</span>
+
+<span class="c1"># We can access the options through</span>
+<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;verbosity is&quot;</span><span class="p">,</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;verbosity&#39;</span><span class="p">])</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: max_evolution_time=0.1 to BSE_options
+verbosity is 1
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Adding-grid-variables">
+<h2>Adding grid variables<a class="headerlink" href="#Adding-grid-variables" title="Permalink to this headline">¶</a></h2>
+<p>The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.</p>
+<p>Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters.</p>
+<p>To add a grid variable to the population object we use <code class="docutils literal notranslate"><span class="pre">population.add_grid_variable</span></code></p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># help(population.add_grid_variable)</span>
+</pre></div>
+</div>
+</div>
+<p>All the distribution functions that we can use are stored in the <code class="docutils literal notranslate"><span class="pre">binarycpython.utils.distribution_functions</span></code> or <code class="docutils literal notranslate"><span class="pre">binarycpython/utils/distribution_functions.py</span></code> on git. If you uncomment the help statement below you can see which functions are available now:</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">binarycpython.utils.distribution_functions</span>
+<span class="c1"># help(binarycpython.utils.distribution_functions)</span>
+</pre></div>
+</div>
+</div>
+<p>First let us set up some global variables that will be useful throughout. * The resolution is the number of stars we simulate in our model population. * The massrange is a list of the min and max masses * The total_probability is the theoretical integral of a probability density function, i.e. 1.0. * The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log<em>L</em> are 0.5dex wide.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Set resolution and mass range that we simulate</span>
+<span class="n">resolution</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;M_1&quot;</span><span class="p">:</span> <span class="mi">40</span><span class="p">}</span> <span class="c1"># start with resolution = 10, and increase later if you want &quot;more accurate&quot; data</span>
+<span class="n">massrange</span> <span class="o">=</span> <span class="p">(</span><span class="mf">0.07</span><span class="p">,</span> <span class="mf">100.0</span><span class="p">)</span> <span class="c1"># we work with stars of mass 0.07 to 100 Msun</span>
+<span class="n">total_probability</span> <span class="o">=</span> <span class="mf">1.0</span> <span class="c1"># theoretical integral of the mass probability density function over all masses</span>
+<span class="c1"># distribution binwidths :</span>
+<span class="c1"># (log10) luminosity distribution</span>
+<span class="n">binwidth</span> <span class="o">=</span> <span class="p">{</span> <span class="s1">&#39;luminosity&#39;</span> <span class="p">:</span> <span class="mf">1.0</span> <span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<p>The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass <em>M</em>_1.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Set up the binary grid in &quot;cubic&quot; M1 - M2=q*M1 - log10 period space</span>
+
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+
+<span class="c1"># resolution on each side of the cube, with more stars for the primary mass</span>
+<span class="n">nres</span> <span class="o">=</span> <span class="mi">10</span>
+<span class="n">resolution</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;M_1&quot;</span><span class="p">:</span> <span class="mi">4</span><span class="o">*</span><span class="n">nres</span><span class="p">,</span>
+              <span class="s2">&quot;q&quot;</span><span class="p">:</span> <span class="n">nres</span><span class="p">,</span>
+              <span class="s2">&quot;per&quot;</span><span class="p">:</span> <span class="n">nres</span><span class="p">}</span>
+
+<span class="n">massrange</span> <span class="o">=</span> <span class="p">[</span><span class="mf">0.07</span><span class="p">,</span><span class="mi">100</span><span class="p">]</span>
+<span class="n">logperrange</span> <span class="o">=</span> <span class="p">[</span><span class="mf">0.15</span><span class="p">,</span> <span class="mf">5.5</span><span class="p">]</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;lnm1&quot;</span><span class="p">,</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Primary mass&quot;</span><span class="p">,</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="n">massrange</span><span class="p">,</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(math.log(</span><span class="si">{min}</span><span class="s2">), math.log(</span><span class="si">{max}</span><span class="s2">), </span><span class="si">{res}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">min</span><span class="o">=</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="nb">max</span><span class="o">=</span><span class="n">massrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="n">res</span><span class="o">=</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;M_1=math.exp(lnm1)&quot;</span><span class="p">,</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1&quot;</span><span class="p">,</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dlnm1&quot;</span><span class="p">,</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+<span class="p">)</span>
+
+<span class="c1"># Mass ratio</span>
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+     <span class="n">name</span><span class="o">=</span><span class="s2">&quot;q&quot;</span><span class="p">,</span>
+     <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Mass ratio&quot;</span><span class="p">,</span>
+     <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span><span class="s2">&quot;0.1/M_1&quot;</span><span class="p">,</span> <span class="mi">1</span><span class="p">],</span>
+     <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s1">&#39;q&#39;</span><span class="p">]),</span>
+     <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(</span><span class="si">{}</span><span class="s2">/M_1, 1, </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">resolution</span><span class="p">[</span><span class="s1">&#39;q&#39;</span><span class="p">]),</span>
+     <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;flatsections(q, [{{&#39;min&#39;: </span><span class="si">{}</span><span class="s2">/M_1, &#39;max&#39;: 1.0, &#39;height&#39;: 1}}])&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">]),</span>
+     <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dq&quot;</span><span class="p">,</span>
+     <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;M_2 = q * M_1&quot;</span><span class="p">,</span>
+     <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_2&quot;</span><span class="p">,</span>
+     <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+ <span class="p">)</span>
+
+<span class="c1"># Orbital period</span>
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;log10per&quot;</span><span class="p">,</span> <span class="c1"># in days</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;log10(Orbital_Period)&quot;</span><span class="p">,</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="p">[</span><span class="mf">0.15</span><span class="p">,</span> <span class="mf">5.5</span><span class="p">],</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;per&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(</span><span class="si">{}</span><span class="s2">, </span><span class="si">{}</span><span class="s2">, </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;per&quot;</span><span class="p">]),</span>
+    <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;&quot;&quot;orbital_period = 10.0 ** log10per</span>
+<span class="s2">sep = calc_sep_from_period(M_1, M_2, orbital_period)</span>
+<span class="s2">sep_min = calc_sep_from_period(M_1, M_2, 10**</span><span class="si">{}</span><span class="s2">)</span>
+<span class="s2">sep_max = calc_sep_from_period(M_1, M_2, 10**</span><span class="si">{}</span><span class="s2">)&quot;&quot;&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**</span><span class="si">{}</span><span class="s2">), math.log10(10**</span><span class="si">{}</span><span class="s2">), </span><span class="si">{}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span><span class="n">logperrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span><span class="o">-</span><span class="mf">0.55</span><span class="p">),</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;orbital_period&quot;</span><span class="p">,</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dlog10per&quot;</span><span class="p">,</span>
+ <span class="p">)</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="Setting-logging-and-handling-the-output">
+<h2>Setting logging and handling the output<a class="headerlink" href="#Setting-logging-and-handling-the-output" title="Permalink to this headline">¶</a></h2>
+<p>By default, binary_c will not output anything (except for ‘SINGLE STAR LIFETIME’). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into <code class="docutils literal notranslate"><span class="pre">binary_c</span></code> (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook <code class="docutils literal notranslate"><span class="pre">notebook_custom_logging.ipynb</span></code>), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes,
+it works perfectly well.</p>
+<p>After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook <code class="docutils literal notranslate"><span class="pre">notebook_individual_systems.ipynb</span></code>).</p>
+<p>In the code below we will set up both the custom logging and a parse function to handle that output.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create custom logging statement</span>
+<span class="c1">#</span>
+<span class="c1"># we check that the model number is zero, i.e. we&#39;re on the first timestep (stars are born on the ZAMS)</span>
+<span class="c1"># we make sure that the stellar type is &lt;= MAIN_SEQUENCE, i.e. the star is a main-sequence star</span>
+<span class="c1"># we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)</span>
+<span class="c1">#</span>
+<span class="c1"># The</span>
+<span class="c1">#</span>
+<span class="c1"># The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn</span>
+<span class="c1">#</span>
+<span class="c1"># where:</span>
+<span class="c1">#</span>
+<span class="c1"># n = PRIMARY    = 0 is star 0 (primary star)</span>
+<span class="c1"># n = SECONDARY  = 1 is star 1 (secondary star)</span>
+<span class="c1"># n = UNRESOLVED = 2 is the unresolved system (both stars added)</span>
+
+<span class="n">PRIMARY</span> <span class="o">=</span> <span class="mi">0</span>
+<span class="n">SECONDARY</span> <span class="o">=</span> <span class="mi">1</span>
+<span class="n">UNRESOLVED</span> <span class="o">=</span> <span class="mi">2</span>
+
+<span class="n">custom_logging_statement</span> <span class="o">=</span> <span class="s2">&quot;&quot;&quot;</span>
+<span class="s2">// select ZAMS</span>
+<span class="s2">if(stardata-&gt;model.model_number == 0 &amp;&amp;</span>
+<span class="s2">   stardata-&gt;model.time == 0)</span>
+<span class="s2">{</span>
+<span class="s2">    // loop over the stars individually (equivalent to a resolved binary)</span>
+<span class="s2">    Foreach_star(star)</span>
+<span class="s2">    {</span>
+<span class="s2">        // select main-sequence stars</span>
+<span class="s2">        if(star-&gt;stellar_type &lt;= MAIN_SEQUENCE)</span>
+<span class="s2">        {</span>
+<span class="s2">            /* Note that we use Printf - with a capital P! */</span>
+<span class="s2">           Printf(&quot;ZERO_AGE_MAIN_SEQUENCE_STAR</span><span class="si">%d</span><span class="s2"> </span><span class="si">%30.12e</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;,</span>
+<span class="s2">                  star-&gt;starnum,</span>
+<span class="s2">                  stardata-&gt;model.time, // 1</span>
+<span class="s2">                  stardata-&gt;common.zero_age.mass[0], // 2</span>
+<span class="s2">                  star-&gt;mass, // 3</span>
+<span class="s2">                  star-&gt;luminosity, // 4</span>
+<span class="s2">                  stardata-&gt;model.probability // 5</span>
+<span class="s2">           );</span>
+<span class="s2">        }</span>
+<span class="s2">    }</span>
+
+<span class="s2">    // unresolved MS-MS binary</span>
+<span class="s2">    if(stardata-&gt;star[0].stellar_type &lt;= MAIN_SEQUENCE &amp;&amp;</span>
+<span class="s2">       stardata-&gt;star[1].stellar_type &lt;= MAIN_SEQUENCE)</span>
+<span class="s2">    {</span>
+<span class="s2">        Printf(&quot;ZERO_AGE_MAIN_SEQUENCE_STAR</span><span class="si">%d</span><span class="s2"> </span><span class="si">%30.12e</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;,</span>
+<span class="s2">                  2,</span>
+<span class="s2">                  stardata-&gt;model.time, // 1</span>
+<span class="s2">                  stardata-&gt;common.zero_age.mass[0] + stardata-&gt;common.zero_age.mass[1], // 2</span>
+<span class="s2">                  stardata-&gt;star[0].mass + stardata-&gt;star[1].mass, // 3</span>
+<span class="s2">                  stardata-&gt;star[0].luminosity + stardata-&gt;star[1].luminosity, // 4</span>
+<span class="s2">                  stardata-&gt;model.probability // 5</span>
+<span class="s2">           );</span>
+<span class="s2">    }</span>
+<span class="s2">}</span>
+<span class="s2">&quot;&quot;&quot;</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">C_logging_code</span><span class="o">=</span><span class="n">custom_logging_statement</span>
+<span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<p>The parse function must now catch lines that start with “ZERO_AGE_MAIN_SEQUENCE_STAR” and process the associated data.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># import the bin_data function so we can construct finite-resolution probability distributions</span>
+<span class="c1"># import the datalinedict to make a dictionary from each line of data from binary_c</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">bin_data</span><span class="p">,</span><span class="n">datalinedict</span>
+<span class="kn">import</span> <span class="nn">re</span>
+
+<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Example parse function</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="c1"># list of the data items</span>
+    <span class="n">parameters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;header&quot;</span><span class="p">,</span> <span class="s2">&quot;time&quot;</span><span class="p">,</span> <span class="s2">&quot;zams_mass&quot;</span><span class="p">,</span> <span class="s2">&quot;mass&quot;</span><span class="p">,</span> <span class="s2">&quot;luminosity&quot;</span><span class="p">,</span> <span class="s2">&quot;probability&quot;</span><span class="p">]</span>
+
+    <span class="c1"># Loop over the output.</span>
+    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">output</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
+
+        <span class="c1"># check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR</span>
+        <span class="n">match</span> <span class="o">=</span> <span class="n">re</span><span class="o">.</span><span class="n">search</span><span class="p">(</span><span class="s1">&#39;ZERO_AGE_MAIN_SEQUENCE_STAR(\d)&#39;</span><span class="p">,</span><span class="n">line</span><span class="p">)</span>
+        <span class="k">if</span> <span class="n">match</span><span class="p">:</span>
+            <span class="n">nstar</span> <span class="o">=</span> <span class="n">match</span><span class="o">.</span><span class="n">group</span><span class="p">(</span><span class="mi">1</span><span class="p">)</span>
+            <span class="c1">#print(&quot;matched star&quot;,nstar)</span>
+
+            <span class="c1"># obtain the line of data in dictionary form</span>
+            <span class="n">linedata</span> <span class="o">=</span> <span class="n">datalinedict</span><span class="p">(</span><span class="n">line</span><span class="p">,</span><span class="n">parameters</span><span class="p">)</span>
+
+            <span class="c1"># bin the log10(luminosity) to the nearest 0.1dex</span>
+            <span class="n">binned_log_luminosity</span> <span class="o">=</span> <span class="n">bin_data</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">]),</span>
+                                             <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+
+            <span class="c1"># append the data to the results_dictionary</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">][</span><span class="nb">int</span><span class="p">(</span><span class="n">nstar</span><span class="p">)][</span><span class="n">binned_log_luminosity</span><span class="p">]</span> <span class="o">+=</span> <span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;probability&#39;</span><span class="p">]</span>
+
+            <span class="c1">#print (self.grid_results)</span>
+
+    <span class="c1"># verbose reporting</span>
+    <span class="c1">#print(&quot;parse out results_dictionary=&quot;,self.grid_results)</span>
+
+<span class="c1"># Add the parsing function</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">parse_function</span><span class="o">=</span><span class="n">parse_function</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="Evolving-the-grid">
+<h2>Evolving the grid<a class="headerlink" href="#Evolving-the-grid" title="Permalink to this headline">¶</a></h2>
+<p>Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: <code class="docutils literal notranslate"><span class="pre">population.evolve()</span></code></p>
+<p>This will start up the processing of all the systems. We can control how many cores are used by settings <code class="docutils literal notranslate"><span class="pre">amt_cores</span></code>. By setting the <code class="docutils literal notranslate"><span class="pre">verbosity</span></code> of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.</p>
+<p>There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: <a class="reference external" href="https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html">grid options docs</a>, and try</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[9]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># set number of threads</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># verbose output is not required</span>
+    <span class="n">verbosity</span><span class="o">=</span><span class="mi">1</span><span class="p">,</span>
+    <span class="c1"># set number of threads (i.e. number of CPU cores we use)</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">4</span><span class="p">,</span>
+    <span class="p">)</span>
+
+<span class="c1"># Evolve the population - this is the slow, number-crunching step</span>
+<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Running the population now, this may take a little while...&quot;</span><span class="p">)</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;Done population run!&quot;</span><span class="p">)</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1"># print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: amt_cores=4 to grid_options
+Running the population now, this may take a little while...
+Creating and loading custom logging functionality
+Generating grid code
+Generating grid code
+Constructing/adding: lnm1
+Constructing/adding: q
+Constructing/adding: log10per
+Saving grid code to grid_options
+Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py
+Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py
+Grid code loaded
+Grid has handled 256 stars
+with a total probability of 0.6149734610296649
+Total starcount for this run will be: 256
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0
+[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1
+[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2
+[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now
+[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 0 started at 2021-09-10T22:26:10.491896.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x154d03cdf510&gt;Process 1 started at 2021-09-10T22:26:10.491948.    Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x154d03cdf480&gt;
+
+Process 2 started at 2021-09-10T22:26:10.496677.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x154d03cdf3f0&gt;
+Process 3 started at 2021-09-10T22:26:10.498669.        Using store memaddr &lt;capsule object &#34;STORE&#34; at 0x154d03cdf180&gt;
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Generating grid code
+Constructing/adding: lnm1
+Constructing/adding: q
+Constructing/adding: log10per
+Saving grid code to grid_options
+Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py
+Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py
+Grid code loaded
+158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB
+199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB
+238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 1 finished:
+        generator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).
+        Ran 61 systems with a total probability of 0.1439494161909395.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.
+[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 3 finished:
+        generator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).
+        Ran 67 systems with a total probability of 0.17251417460118773.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.
+[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 2 finished:
+        generator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).
+        Ran 56 systems with a total probability of 0.14306289954535925.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.
+[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Process 0 finished:
+        generator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).
+        Ran 72 systems with a total probability of 0.1554469706921749.
+        This thread had 0 failing systems with a total probability of 0.
+        Skipped a total of 0 systems because they had 0 probability
+</pre></div></div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area stderr docutils container">
+<div class="highlight"><pre>
+[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores
+There were no errors found in this run.
+Done population run!
+</pre></div></div>
+</div>
+<p>After the run is complete, some technical report on the run is returned. I stored that in <code class="docutils literal notranslate"><span class="pre">analytics</span></code>. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="nb">print</span><span class="p">(</span><span class="n">analytics</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+{&#39;population_name&#39;: &#39;bc3a5f915411445699f8cf6438817ff1&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 0.6149734610296613, &#39;total_count&#39;: 256, &#39;start_timestamp&#39;: 1631305570.458824, &#39;end_timestamp&#39;: 1631305588.062193, &#39;total_mass_run&#39;: 5246.190724478048, &#39;total_probability_weighted_mass_run&#39;: 0.6347400152389439, &#39;zero_prob_stars_skipped&#39;: 0}
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># make a plot of the luminosity distribution using Seaborn and Pandas</span>
+<span class="kn">import</span> <span class="nn">seaborn</span> <span class="k">as</span> <span class="nn">sns</span>
+<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">pad_output_distribution</span>
+
+<span class="c1"># set up seaborn for use in the notebook</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;figure.figsize&#39;</span><span class="p">:(</span><span class="mi">20</span><span class="p">,</span><span class="mi">10</span><span class="p">)})</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set_context</span><span class="p">(</span><span class="s2">&quot;notebook&quot;</span><span class="p">,</span>
+                <span class="n">font_scale</span><span class="o">=</span><span class="mf">1.5</span><span class="p">,</span>
+                <span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;lines.linewidth&quot;</span><span class="p">:</span><span class="mf">2.5</span><span class="p">})</span>
+
+
+<span class="n">titles</span> <span class="o">=</span> <span class="p">{</span> <span class="mi">0</span> <span class="p">:</span> <span class="s2">&quot;Primary&quot;</span><span class="p">,</span>
+           <span class="mi">1</span> <span class="p">:</span> <span class="s2">&quot;Secondary&quot;</span><span class="p">,</span>
+           <span class="mi">2</span> <span class="p">:</span> <span class="s2">&quot;Unresolved&quot;</span> <span class="p">}</span>
+
+<span class="c1"># choose to plot the</span>
+<span class="c1"># PRIMARY, SECONDARY or UNRESOLVED</span>
+<span class="n">nstar</span> <span class="o">=</span> <span class="n">UNRESOLVED</span>
+
+<span class="n">plots</span> <span class="o">=</span> <span class="p">{}</span>
+
+<span class="c1"># pad the distribution with zeros where data is missing</span>
+<span class="k">for</span> <span class="n">n</span> <span class="ow">in</span> <span class="nb">range</span><span class="p">(</span><span class="mi">0</span><span class="p">,</span><span class="mi">3</span><span class="p">):</span>
+    <span class="n">pad_output_distribution</span><span class="p">(</span><span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">][</span><span class="n">n</span><span class="p">],</span>
+                            <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+    <span class="n">plots</span><span class="p">[</span><span class="n">titles</span><span class="p">[</span><span class="n">n</span><span class="p">]</span> <span class="o">+</span> <span class="s1">&#39; ZAMS luminosity distribution&#39;</span><span class="p">]</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">][</span><span class="n">n</span><span class="p">]</span>
+
+<span class="c1"># make pandas dataframe from our sorted dictionary of data</span>
+<span class="n">plot_data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="o">.</span><span class="n">from_dict</span><span class="p">(</span><span class="n">plots</span><span class="p">)</span>
+
+<span class="c1"># make the plot</span>
+<span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">plot_data</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2">$ ($L_\mathrm</span><span class="si">{ZAMS}</span><span class="s2">$ / L$_{☉}$)&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;Number of stars&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">yscale</span><span class="o">=</span><span class="s2">&quot;log&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+[None]
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_luminosity_function_binaries_20_1.png" src="_images/notebook_luminosity_function_binaries_20_1.png" />
+</div>
+</div>
+<p>You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1&lt;1).</p>
+<p>Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time).</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[ ]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span>Things to try:
+* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?
+* Alter the metallicity, does this make much of a difference?
+* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.
+* How might you go about comparing these computed observations to real stars?
+* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?
+</pre></div>
+</div>
+</div>
+</div>
+</div>
+
+
+           </div>
+           
+          </div>
+          <footer>
+  
+    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
+      
+        <a href="notebook_HRD.html" class="btn btn-neutral float-right" title="Example use case: Hertzsprung-Russell diagrams" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+      
+      
+        <a href="notebook_luminosity_function_single.html" class="btn btn-neutral float-left" title="Example use case: Zero-age stellar luminosity function" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+      
+    </div>
+  
+
+  <hr/>
+
+  <div role="contentinfo">
+    <p>
+        
+        &copy; Copyright 2021, David Hendriks, Robert Izzard
+
+    </p>
+  </div>
+    
+    
+    
+    Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a
+    
+    <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
+    
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+<br><br>
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+<br><br>
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
+
+
+
+</footer>
+
+        </div>
+      </div>
+
+    </section>
+
+  </div>
+  
+
+  <script type="text/javascript">
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script>
+
+  
+  
+    
+   
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/build/html/notebook_luminosity_function_binaries.ipynb b/docs/build/html/notebook_luminosity_function_binaries.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c6b5f1e64cc36c684fdf5cefe0fae4b450a1c936
--- /dev/null
+++ b/docs/build/html/notebook_luminosity_function_binaries.ipynb
@@ -0,0 +1,701 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 4*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "\n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][int(nstar)][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 256 stars\n",
+      "with a total probability of 0.6149734610296649\n",
+      "Total starcount for this run will be: 256\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
+      "\n",
+      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
+      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
+      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
+      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
+      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
+      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
+      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
+      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
+      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "\n",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
+    "\n",
+    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Things to try:\n",
+    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
+    "* Alter the metallicity, does this make much of a difference?\n",
+    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
+    "* How might you go about comparing these computed observations to real stars?\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/notebook_luminosity_function_single.html b/docs/build/html/notebook_luminosity_function_single.html
new file mode 100644
index 0000000000000000000000000000000000000000..8f7cb72abb8027dae19b267fa30372a65d718ffb
--- /dev/null
+++ b/docs/build/html/notebook_luminosity_function_single.html
@@ -0,0 +1,1040 @@
+
+
+<!DOCTYPE html>
+<html class="writer-html5" lang="en" >
+<head>
+  <meta charset="utf-8">
+  
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  
+  <title>Example use case: Zero-age stellar luminosity function &mdash; binary_c-python  documentation</title>
+  
+
+  
+  <link rel="stylesheet" href="_static/css/theme.css" type="text/css" />
+  <link rel="stylesheet" href="_static/pygments.css" type="text/css" />
+
+  
+  
+  
+  
+
+  
+  <!--[if lt IE 9]>
+    <script src="_static/js/html5shiv.min.js"></script>
+  <![endif]-->
+  
+    
+      <script type="text/javascript" id="documentation_options" data-url_root="./" src="_static/documentation_options.js"></script>
+        <script src="_static/jquery.js"></script>
+        <script src="_static/underscore.js"></script>
+        <script src="_static/doctools.js"></script>
+        <script src="_static/language_data.js"></script>
+        <script crossorigin="anonymous" integrity="sha256-Ae2Vz/4ePdIu6ZyI/5ZGsYnb+m0JlOmKPjt6XZ9JJkA=" src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.3.4/require.min.js"></script>
+        <script async="async" src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS-MML_HTMLorMML"></script>
+        <script type="text/x-mathjax-config">MathJax.Hub.Config({"tex2jax": {"inlineMath": [["$", "$"], ["\\(", "\\)"]], "processEscapes": true, "ignoreClass": "document", "processClass": "math|output_area"}})</script>
+    
+    <script type="text/javascript" src="_static/js/theme.js"></script>
+
+    
+    <link rel="index" title="Index" href="genindex.html" />
+    <link rel="search" title="Search" href="search.html" />
+    <link rel="next" title="Zero-age stellar luminosity function in binaries" href="notebook_luminosity_function_binaries.html" />
+    <link rel="prev" title="Tutorial: Using the API functionality of binary_c-python" href="notebook_api_functionality.html" /> 
+</head>
+
+<body class="wy-body-for-nav">
+
+   
+  <div class="wy-grid-for-nav">
+    
+    <nav data-toggle="wy-nav-shift" class="wy-nav-side">
+      <div class="wy-side-scroll">
+        <div class="wy-side-nav-search" >
+          
+
+          
+            <a href="index.html" class="icon icon-home" alt="Documentation Home"> binary_c-python
+          
+
+          
+          </a>
+
+          
+            
+            
+          
+
+          
+<div role="search">
+  <form id="rtd-search-form" class="wy-form" action="search.html" method="get">
+    <input type="text" name="q" placeholder="Search docs" />
+    <input type="hidden" name="check_keywords" value="yes" />
+    <input type="hidden" name="area" value="default" />
+  </form>
+</div>
+
+          
+        </div>
+
+        
+        <div class="wy-menu wy-menu-vertical" data-spy="affix" role="navigation" aria-label="main navigation">
+          
+            
+            
+              
+            
+            
+              <p class="caption"><span class="caption-text">Contents:</span></p>
+<ul class="current">
+<li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
+<li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
+<li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_population.html">Tutorial: Running populations with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Example use case: Zero-age stellar luminosity function</a><ul>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-up-the-Population-object">Setting up the Population object</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Adding-grid-variables">Adding grid variables</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#Evolving-the-grid">Evolving the grid</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#ZAMS-Luminosity-distribution-with-the-initial-mass-function">ZAMS Luminosity distribution with the initial mass function</a></li>
+<li class="toctree-l3"><a class="reference internal" href="#A-better-sampled-grid">A better-sampled grid</a></li>
+</ul>
+</li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
+</ul>
+</li>
+<li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
+<li class="toctree-l1"><a class="reference internal" href="grid_options_descriptions.html">Population grid code options</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python">Visit the GitLab repo</a></li>
+<li class="toctree-l1"><a class="reference external" href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/issues/new">Submit an issue</a></li>
+</ul>
+
+            
+          
+        </div>
+        
+      </div>
+    </nav>
+
+    <section data-toggle="wy-nav-shift" class="wy-nav-content-wrap">
+
+      
+      <nav class="wy-nav-top" aria-label="top navigation">
+        
+          <i data-toggle="wy-nav-top" class="fa fa-bars"></i>
+          <a href="index.html">binary_c-python</a>
+        
+      </nav>
+
+
+      <div class="wy-nav-content">
+        
+        <div class="rst-content">
+        
+          
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+<div role="navigation" aria-label="breadcrumbs navigation">
+
+  <ul class="wy-breadcrumbs">
+    
+      <li><a href="index.html" class="icon icon-home"></a> &raquo;</li>
+        
+          <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
+        
+      <li>Example use case: Zero-age stellar luminosity function</li>
+    
+    
+      <li class="wy-breadcrumbs-aside">
+        
+            
+            <a href="_sources/notebook_luminosity_function_single.ipynb.txt" rel="nofollow"> View page source</a>
+          
+        
+      </li>
+    
+  </ul>
+
+  
+  <hr/>
+</div>
+          <div role="main" class="document" itemscope="itemscope" itemtype="http://schema.org/Article">
+           <div itemprop="articleBody">
+            
+  
+<style>
+/* CSS for nbsphinx extension */
+
+/* remove conflicting styling from Sphinx themes */
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt *,
+div.nbinput.container div.input_area pre,
+div.nboutput.container div.output_area pre,
+div.nbinput.container div.input_area .highlight,
+div.nboutput.container div.output_area .highlight {
+    border: none;
+    padding: 0;
+    margin: 0;
+    box-shadow: none;
+}
+
+div.nbinput.container > div[class*=highlight],
+div.nboutput.container > div[class*=highlight] {
+    margin: 0;
+}
+
+div.nbinput.container div.prompt *,
+div.nboutput.container div.prompt * {
+    background: none;
+}
+
+div.nboutput.container div.output_area .highlight,
+div.nboutput.container div.output_area pre {
+    background: unset;
+}
+
+div.nboutput.container div.output_area div.highlight {
+    color: unset;  /* override Pygments text color */
+}
+
+/* avoid gaps between output lines */
+div.nboutput.container div[class*=highlight] pre {
+    line-height: normal;
+}
+
+/* input/output containers */
+div.nbinput.container,
+div.nboutput.container {
+    display: -webkit-flex;
+    display: flex;
+    align-items: flex-start;
+    margin: 0;
+    width: 100%;
+}
+@media (max-width: 540px) {
+    div.nbinput.container,
+    div.nboutput.container {
+        flex-direction: column;
+    }
+}
+
+/* input container */
+div.nbinput.container {
+    padding-top: 5px;
+}
+
+/* last container */
+div.nblast.container {
+    padding-bottom: 5px;
+}
+
+/* input prompt */
+div.nbinput.container div.prompt pre {
+    color: #307FC1;
+}
+
+/* output prompt */
+div.nboutput.container div.prompt pre {
+    color: #BF5B3D;
+}
+
+/* all prompts */
+div.nbinput.container div.prompt,
+div.nboutput.container div.prompt {
+    width: 4.5ex;
+    padding-top: 5px;
+    position: relative;
+    user-select: none;
+}
+
+div.nbinput.container div.prompt > div,
+div.nboutput.container div.prompt > div {
+    position: absolute;
+    right: 0;
+    margin-right: 0.3ex;
+}
+
+@media (max-width: 540px) {
+    div.nbinput.container div.prompt,
+    div.nboutput.container div.prompt {
+        width: unset;
+        text-align: left;
+        padding: 0.4em;
+    }
+    div.nboutput.container div.prompt.empty {
+        padding: 0;
+    }
+
+    div.nbinput.container div.prompt > div,
+    div.nboutput.container div.prompt > div {
+        position: unset;
+    }
+}
+
+/* disable scrollbars on prompts */
+div.nbinput.container div.prompt pre,
+div.nboutput.container div.prompt pre {
+    overflow: hidden;
+}
+
+/* input/output area */
+div.nbinput.container div.input_area,
+div.nboutput.container div.output_area {
+    -webkit-flex: 1;
+    flex: 1;
+    overflow: auto;
+}
+@media (max-width: 540px) {
+    div.nbinput.container div.input_area,
+    div.nboutput.container div.output_area {
+        width: 100%;
+    }
+}
+
+/* input area */
+div.nbinput.container div.input_area {
+    border: 1px solid #e0e0e0;
+    border-radius: 2px;
+    /*background: #f5f5f5;*/
+}
+
+/* override MathJax center alignment in output cells */
+div.nboutput.container div[class*=MathJax] {
+    text-align: left !important;
+}
+
+/* override sphinx.ext.imgmath center alignment in output cells */
+div.nboutput.container div.math p {
+    text-align: left;
+}
+
+/* standard error */
+div.nboutput.container div.output_area.stderr {
+    background: #fdd;
+}
+
+/* ANSI colors */
+.ansi-black-fg { color: #3E424D; }
+.ansi-black-bg { background-color: #3E424D; }
+.ansi-black-intense-fg { color: #282C36; }
+.ansi-black-intense-bg { background-color: #282C36; }
+.ansi-red-fg { color: #E75C58; }
+.ansi-red-bg { background-color: #E75C58; }
+.ansi-red-intense-fg { color: #B22B31; }
+.ansi-red-intense-bg { background-color: #B22B31; }
+.ansi-green-fg { color: #00A250; }
+.ansi-green-bg { background-color: #00A250; }
+.ansi-green-intense-fg { color: #007427; }
+.ansi-green-intense-bg { background-color: #007427; }
+.ansi-yellow-fg { color: #DDB62B; }
+.ansi-yellow-bg { background-color: #DDB62B; }
+.ansi-yellow-intense-fg { color: #B27D12; }
+.ansi-yellow-intense-bg { background-color: #B27D12; }
+.ansi-blue-fg { color: #208FFB; }
+.ansi-blue-bg { background-color: #208FFB; }
+.ansi-blue-intense-fg { color: #0065CA; }
+.ansi-blue-intense-bg { background-color: #0065CA; }
+.ansi-magenta-fg { color: #D160C4; }
+.ansi-magenta-bg { background-color: #D160C4; }
+.ansi-magenta-intense-fg { color: #A03196; }
+.ansi-magenta-intense-bg { background-color: #A03196; }
+.ansi-cyan-fg { color: #60C6C8; }
+.ansi-cyan-bg { background-color: #60C6C8; }
+.ansi-cyan-intense-fg { color: #258F8F; }
+.ansi-cyan-intense-bg { background-color: #258F8F; }
+.ansi-white-fg { color: #C5C1B4; }
+.ansi-white-bg { background-color: #C5C1B4; }
+.ansi-white-intense-fg { color: #A1A6B2; }
+.ansi-white-intense-bg { background-color: #A1A6B2; }
+
+.ansi-default-inverse-fg { color: #FFFFFF; }
+.ansi-default-inverse-bg { background-color: #000000; }
+
+.ansi-bold { font-weight: bold; }
+.ansi-underline { text-decoration: underline; }
+
+
+div.nbinput.container div.input_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight] > pre,
+div.nboutput.container div.output_area div[class*=highlight].math,
+div.nboutput.container div.output_area.rendered_html,
+div.nboutput.container div.output_area > div.output_javascript,
+div.nboutput.container div.output_area:not(.rendered_html) > img{
+    padding: 5px;
+    margin: 0;
+}
+
+/* fix copybtn overflow problem in chromium (needed for 'sphinx_copybutton') */
+div.nbinput.container div.input_area > div[class^='highlight'],
+div.nboutput.container div.output_area > div[class^='highlight']{
+    overflow-y: hidden;
+}
+
+/* hide copybtn icon on prompts (needed for 'sphinx_copybutton') */
+.prompt a.copybtn {
+    display: none;
+}
+
+/* Some additional styling taken form the Jupyter notebook CSS */
+div.rendered_html table {
+  border: none;
+  border-collapse: collapse;
+  border-spacing: 0;
+  color: black;
+  font-size: 12px;
+  table-layout: fixed;
+}
+div.rendered_html thead {
+  border-bottom: 1px solid black;
+  vertical-align: bottom;
+}
+div.rendered_html tr,
+div.rendered_html th,
+div.rendered_html td {
+  text-align: right;
+  vertical-align: middle;
+  padding: 0.5em 0.5em;
+  line-height: normal;
+  white-space: normal;
+  max-width: none;
+  border: none;
+}
+div.rendered_html th {
+  font-weight: bold;
+}
+div.rendered_html tbody tr:nth-child(odd) {
+  background: #f5f5f5;
+}
+div.rendered_html tbody tr:hover {
+  background: rgba(66, 165, 245, 0.2);
+}
+
+/* CSS overrides for sphinx_rtd_theme */
+
+/* 24px margin */
+.nbinput.nblast.container,
+.nboutput.nblast.container {
+    margin-bottom: 19px;  /* padding has already 5px */
+}
+
+/* ... except between code cells! */
+.nblast.container + .nbinput.container {
+    margin-top: -19px;
+}
+
+.admonition > p:before {
+    margin-right: 4px;  /* make room for the exclamation icon */
+}
+
+/* Fix math alignment, see https://github.com/rtfd/sphinx_rtd_theme/pull/686 */
+.math {
+    text-align: unset;
+}
+</style>
+<div class="section" id="Example-use-case:-Zero-age-stellar-luminosity-function">
+<h1>Example use case: Zero-age stellar luminosity function<a class="headerlink" href="#Example-use-case:-Zero-age-stellar-luminosity-function" title="Permalink to this headline">¶</a></h1>
+<p>In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c.</p>
+<p>We start by loading in some standard Python modules and the binary_c module.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[1]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">os</span>
+<span class="kn">import</span> <span class="nn">math</span>
+<span class="kn">import</span> <span class="nn">matplotlib.pyplot</span> <span class="k">as</span> <span class="nn">plt</span>
+
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
+
+<span class="n">TMP_DIR</span> <span class="o">=</span> <span class="n">temp_dir</span><span class="p">(</span><span class="s2">&quot;notebooks&quot;</span><span class="p">,</span> <span class="s2">&quot;notebook_luminosity&quot;</span><span class="p">)</span>
+
+<span class="c1"># help(Population) # Uncomment this line to see the public functions of this object</span>
+</pre></div>
+</div>
+</div>
+<div class="section" id="Setting-up-the-Population-object">
+<h2>Setting up the Population object<a class="headerlink" href="#Setting-up-the-Population-object" title="Permalink to this headline">¶</a></h2>
+<p>To set up and configure the population object we need to make a new instance of the <code class="docutils literal notranslate"><span class="pre">Population</span></code> object and configure it with the <code class="docutils literal notranslate"><span class="pre">.set()</span></code> function.</p>
+<p>In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[2]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create population object</span>
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+
+<span class="c1"># If you want verbosity, set this before other things</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">verbosity</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
+
+<span class="c1"># Setting values can be done via .set(&lt;parameter_name&gt;=&lt;value&gt;)</span>
+<span class="c1"># Values that are known to be binary_c_parameters are loaded into bse_options.</span>
+<span class="c1"># Those that are present in the default grid_options are set in grid_options</span>
+<span class="c1"># All other values that you set are put in a custom_options dict</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># binary_c physics options</span>
+    <span class="n">max_evolution_time</span><span class="o">=</span><span class="mf">0.1</span><span class="p">,</span>  <span class="c1"># maximum stellar evolution time in Myr</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
+<span class="p">)</span>
+
+<span class="c1"># We can access the options through</span>
+<span class="nb">print</span><span class="p">(</span><span class="s2">&quot;verbosity is&quot;</span><span class="p">,</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_options</span><span class="p">[</span><span class="s1">&#39;verbosity&#39;</span><span class="p">])</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+adding: max_evolution_time=0.1 to BSE_options
+adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options
+verbosity is 1
+</pre></div></div>
+</div>
+</div>
+<div class="section" id="Adding-grid-variables">
+<h2>Adding grid variables<a class="headerlink" href="#Adding-grid-variables" title="Permalink to this headline">¶</a></h2>
+<p>The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.</p>
+<p>Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters.</p>
+<p>To add a grid variable to the population object we use <code class="docutils literal notranslate"><span class="pre">population.add_grid_variable</span></code></p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[3]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># help(population.add_grid_variable)</span>
+</pre></div>
+</div>
+</div>
+<p>All the distribution functions that we can use are stored in the <code class="docutils literal notranslate"><span class="pre">binarycpython.utils.distribution_functions</span></code> or <code class="docutils literal notranslate"><span class="pre">binarycpython/utils/distribution_functions.py</span></code> on git. If you uncomment the help statement below you can see which functions are available now:</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[4]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="kn">import</span> <span class="nn">binarycpython.utils.distribution_functions</span>
+<span class="c1"># help(binarycpython.utils.distribution_functions)</span>
+</pre></div>
+</div>
+</div>
+<p>First let us set up some global variables that will be useful throughout. * The resolution is the number of stars we simulate in our model population. * The massrange is a list of the min and max masses * The total_probability is the theoretical integral of a probability density function, i.e. 1.0. * The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log<em>L</em> are 0.5dex wide.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[5]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Set resolution and mass range that we simulate</span>
+<span class="n">resolution</span> <span class="o">=</span> <span class="p">{</span><span class="s2">&quot;M_1&quot;</span><span class="p">:</span> <span class="mi">40</span><span class="p">}</span> <span class="c1"># start with resolution = 10, and increase later if you want &quot;more accurate&quot; data</span>
+<span class="n">massrange</span> <span class="o">=</span> <span class="p">(</span><span class="mf">0.07</span><span class="p">,</span> <span class="mf">100.0</span><span class="p">)</span> <span class="c1"># we work with stars of mass 0.07 to 100 Msun</span>
+<span class="n">total_probability</span> <span class="o">=</span> <span class="mf">1.0</span> <span class="c1"># theoretical integral of the mass probability density function over all masses</span>
+<span class="c1"># distribution binwidths :</span>
+<span class="c1"># (log10) luminosity distribution</span>
+<span class="n">binwidth</span> <span class="o">=</span> <span class="p">{</span> <span class="s1">&#39;luminosity&#39;</span> <span class="p">:</span> <span class="mf">0.5</span> <span class="p">}</span>
+</pre></div>
+</div>
+</div>
+<p>The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass <em>M</em>_1.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[6]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Mass</span>
+<span class="n">population</span> <span class="o">=</span> <span class="n">Population</span><span class="p">()</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
+<span class="p">)</span>
+<span class="n">population</span><span class="o">.</span><span class="n">add_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">longname</span><span class="o">=</span><span class="s2">&quot;Primary mass&quot;</span><span class="p">,</span>
+    <span class="n">valuerange</span><span class="o">=</span><span class="n">massrange</span><span class="p">,</span>
+    <span class="n">resolution</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{res}</span><span class="s2">&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">res</span> <span class="o">=</span> <span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(</span><span class="si">{min}</span><span class="s2">, </span><span class="si">{max}</span><span class="s2">, </span><span class="si">{res}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">min</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">max</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">res</span> <span class="o">=</span> <span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;</span><span class="si">{probtot}</span><span class="s2">/(</span><span class="si">{max}</span><span class="s2"> - </span><span class="si">{min}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="n">probtot</span> <span class="o">=</span> <span class="n">total_probability</span><span class="p">,</span> <span class="nb">min</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">max</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">1</span><span class="p">]),</span> <span class="c1"># dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dM_1&quot;</span><span class="p">,</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">condition</span><span class="o">=</span><span class="s2">&quot;&quot;</span><span class="p">,</span>  <span class="c1"># Impose a condition on this grid variable. Mostly for a check for yourself</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="Setting-logging-and-handling-the-output">
+<h2>Setting logging and handling the output<a class="headerlink" href="#Setting-logging-and-handling-the-output" title="Permalink to this headline">¶</a></h2>
+<p>By default, binary_c will not output anything (except for ‘SINGLE STAR LIFETIME’). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into <code class="docutils literal notranslate"><span class="pre">binary_c</span></code> (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook <code class="docutils literal notranslate"><span class="pre">notebook_custom_logging.ipynb</span></code>), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes,
+it works perfectly well.</p>
+<p>After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook <code class="docutils literal notranslate"><span class="pre">notebook_individual_systems.ipynb</span></code>).</p>
+<p>In the code below we will set up both the custom logging and a parse function to handle that output.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[7]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Create custom logging statement</span>
+<span class="c1">#</span>
+<span class="c1"># we check that the model number is zero, i.e. we&#39;re on the first timestep (stars are born on the ZAMS)</span>
+<span class="c1"># we make sure that the stellar type is &lt;= MAIN_SEQUENCE, i.e. the star is a main-sequence star</span>
+<span class="c1"># we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)</span>
+<span class="c1">#</span>
+<span class="c1"># The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR</span>
+
+<span class="n">custom_logging_statement</span> <span class="o">=</span> <span class="s2">&quot;&quot;&quot;</span>
+<span class="s2">if(stardata-&gt;model.model_number == 0 &amp;&amp;</span>
+<span class="s2">   stardata-&gt;star[0].stellar_type &lt;= MAIN_SEQUENCE &amp;&amp;</span>
+<span class="s2">   stardata-&gt;model.time == 0)</span>
+<span class="s2">{</span>
+<span class="s2">   /* Note that we use Printf - with a capital P! */</span>
+<span class="s2">   Printf(&quot;ZERO_AGE_MAIN_SEQUENCE_STAR </span><span class="si">%30.12e</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="s2"> </span><span class="si">%g</span><span class="se">\\</span><span class="s2">n&quot;,</span>
+<span class="s2">          stardata-&gt;model.time, // 1</span>
+<span class="s2">          stardata-&gt;common.zero_age.mass[0], // 2</span>
+<span class="s2">          stardata-&gt;star[0].mass, // 3</span>
+<span class="s2">          stardata-&gt;star[0].luminosity, // 4</span>
+<span class="s2">          stardata-&gt;model.probability // 5</span>
+<span class="s2">      );</span>
+<span class="s2">};</span>
+<span class="s2">&quot;&quot;&quot;</span>
+
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">C_logging_code</span><span class="o">=</span><span class="n">custom_logging_statement</span>
+<span class="p">)</span>
+
+</pre></div>
+</div>
+</div>
+<p>The parse function must now catch lines that start with “ZERO_AGE_MAIN_SEQUENCE_STAR” and process the associated data.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[8]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># import the bin_data function so we can construct finite-resolution probability distributions</span>
+<span class="c1"># import the datalinedict to make a dictionary from each line of data from binary_c</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">bin_data</span><span class="p">,</span><span class="n">datalinedict</span>
+
+<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+    <span class="sd">&quot;&quot;&quot;</span>
+<span class="sd">    Example parse function</span>
+<span class="sd">    &quot;&quot;&quot;</span>
+
+    <span class="c1"># list of the data items</span>
+    <span class="n">parameters</span> <span class="o">=</span> <span class="p">[</span><span class="s2">&quot;header&quot;</span><span class="p">,</span> <span class="s2">&quot;time&quot;</span><span class="p">,</span> <span class="s2">&quot;zams_mass&quot;</span><span class="p">,</span> <span class="s2">&quot;mass&quot;</span><span class="p">,</span> <span class="s2">&quot;luminosity&quot;</span><span class="p">,</span> <span class="s2">&quot;probability&quot;</span><span class="p">]</span>
+
+    <span class="c1"># Loop over the output.</span>
+    <span class="k">for</span> <span class="n">line</span> <span class="ow">in</span> <span class="n">output</span><span class="o">.</span><span class="n">splitlines</span><span class="p">():</span>
+        <span class="c1"># obtain the line of data in dictionary form</span>
+        <span class="n">linedata</span> <span class="o">=</span> <span class="n">datalinedict</span><span class="p">(</span><span class="n">line</span><span class="p">,</span><span class="n">parameters</span><span class="p">)</span>
+
+        <span class="c1"># Check the header and act accordingly</span>
+        <span class="k">if</span> <span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;header&#39;</span><span class="p">]</span> <span class="o">==</span> <span class="s2">&quot;ZERO_AGE_MAIN_SEQUENCE_STAR&quot;</span><span class="p">:</span>
+
+            <span class="c1"># bin the log10(luminosity) to the nearest 0.1dex</span>
+            <span class="n">binned_log_luminosity</span> <span class="o">=</span> <span class="n">bin_data</span><span class="p">(</span><span class="n">math</span><span class="o">.</span><span class="n">log10</span><span class="p">(</span><span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">]),</span>
+                                             <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+
+            <span class="c1"># append the data to the results_dictionary</span>
+            <span class="bp">self</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">][</span><span class="n">binned_log_luminosity</span><span class="p">]</span> <span class="o">+=</span> <span class="n">linedata</span><span class="p">[</span><span class="s1">&#39;probability&#39;</span><span class="p">]</span>
+
+            <span class="c1">#print (self.grid_results)</span>
+
+    <span class="c1"># verbose reporting</span>
+    <span class="c1">#print(&quot;parse out results_dictionary=&quot;,self.grid_results)</span>
+
+<span class="c1"># Add the parsing function</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="n">parse_function</span><span class="o">=</span><span class="n">parse_function</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+</div>
+<div class="section" id="Evolving-the-grid">
+<h2>Evolving the grid<a class="headerlink" href="#Evolving-the-grid" title="Permalink to this headline">¶</a></h2>
+<p>Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: <code class="docutils literal notranslate"><span class="pre">population.evolve()</span></code></p>
+<p>This will start up the processing of all the systems. We can control how many cores are used by settings <code class="docutils literal notranslate"><span class="pre">amt_cores</span></code>. By setting the <code class="docutils literal notranslate"><span class="pre">verbosity</span></code> of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.</p>
+<p>There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: <a class="reference external" href="https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html">grid options docs</a>, and try</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[9]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># set number of threads</span>
+<span class="n">population</span><span class="o">.</span><span class="n">set</span><span class="p">(</span>
+    <span class="c1"># verbose output is not required</span>
+    <span class="n">verbosity</span><span class="o">=</span><span class="mi">0</span><span class="p">,</span>
+    <span class="c1"># set number of threads (i.e. number of CPU cores we use)</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>
+    <span class="p">)</span>
+
+<span class="c1"># Evolve the population - this is the slow, number-crunching step</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1"># print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Constructing/adding: M_1
+Grid has handled 40 stars
+with a total probability of 1.0000000000000004
+Total starcount for this run will be: 40
+Generating grid code
+Constructing/adding: M_1
+Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<p>After the run is complete, some technical report on the run is returned. I stored that in <code class="docutils literal notranslate"><span class="pre">analytics</span></code>. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[10]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="nb">print</span><span class="p">(</span><span class="n">analytics</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+{&#39;population_name&#39;: &#39;e6c082aabe0849a0811761a06e50476b&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 1.0000000000000002, &#39;total_count&#39;: 40, &#39;start_timestamp&#39;: 1631461389.3681686, &#39;end_timestamp&#39;: 1631461391.6702895, &#39;total_mass_run&#39;: 2001.4, &#39;total_probability_weighted_mass_run&#39;: 50.035000000000004, &#39;zero_prob_stars_skipped&#39;: 0}
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># make a plot of the luminosity distribution using Seaborn and Pandas</span>
+<span class="kn">import</span> <span class="nn">seaborn</span> <span class="k">as</span> <span class="nn">sns</span>
+<span class="kn">import</span> <span class="nn">pandas</span> <span class="k">as</span> <span class="nn">pd</span>
+<span class="kn">from</span> <span class="nn">binarycpython.utils.functions</span> <span class="kn">import</span> <span class="n">pad_output_distribution</span>
+
+<span class="c1"># set up seaborn for use in the notebook</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s1">&#39;figure.figsize&#39;</span><span class="p">:(</span><span class="mi">20</span><span class="p">,</span><span class="mi">10</span><span class="p">)})</span>
+<span class="n">sns</span><span class="o">.</span><span class="n">set_context</span><span class="p">(</span><span class="s2">&quot;notebook&quot;</span><span class="p">,</span>
+                <span class="n">font_scale</span><span class="o">=</span><span class="mf">1.5</span><span class="p">,</span>
+                <span class="n">rc</span><span class="o">=</span><span class="p">{</span><span class="s2">&quot;lines.linewidth&quot;</span><span class="p">:</span><span class="mf">2.5</span><span class="p">})</span>
+
+
+<span class="c1"># this saves a lot of typing!</span>
+<span class="n">ldist</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">]</span>
+
+<span class="c1"># pad the distribution with zeros where data is missing</span>
+<span class="n">pad_output_distribution</span><span class="p">(</span><span class="n">ldist</span><span class="p">,</span>
+                        <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+
+<span class="c1"># make pandas dataframe from our sorted dictionary of data</span>
+<span class="n">plot_data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="o">.</span><span class="n">from_dict</span><span class="p">({</span><span class="s1">&#39;ZAMS luminosity distribution&#39;</span> <span class="p">:</span> <span class="n">ldist</span><span class="p">})</span>
+
+<span class="c1"># make the plot</span>
+<span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">plot_data</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2">$ ($L_\mathrm</span><span class="si">{ZAMS}</span><span class="s2">$ / L$_{☉}$)&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;Number of stars&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">yscale</span><span class="o">=</span><span class="s2">&quot;log&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[11]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+[None]
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_luminosity_function_single_20_1.png" src="_images/notebook_luminosity_function_single_20_1.png" />
+</div>
+</div>
+<p>Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 105.8 L☉! Clearly, this is not very realistic… let’s see what went wrong.</p>
+</div>
+<div class="section" id="ZAMS-Luminosity-distribution-with-the-initial-mass-function">
+<h2>ZAMS Luminosity distribution with the initial mass function<a class="headerlink" href="#ZAMS-Luminosity-distribution-with-the-initial-mass-function" title="Permalink to this headline">¶</a></h2>
+<p>In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars. So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa’s distribution is a three-part power law: we have a function that does this for us (it’s very common to use power laws in astrophysics).</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[12]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Update the probability distribution to use the three-part power law IMF</span>
+<span class="n">population</span><span class="o">.</span><span class="n">update_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)&quot;</span><span class="p">,</span>
+<span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[13]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Clean and re-evolve the population</span>
+<span class="n">population</span><span class="o">.</span><span class="n">clean</span><span class="p">()</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1"># print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Constructing/adding: M_1
+Grid has handled 40 stars
+with a total probability of 0.2182216189410787
+Total starcount for this run will be: 40
+Generating grid code
+Constructing/adding: M_1
+Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[14]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># plot luminosity distribution</span>
+<span class="n">ldist</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">]</span>
+
+<span class="c1"># pad the distribution with zeros where data is missing</span>
+<span class="n">pad_output_distribution</span><span class="p">(</span><span class="n">ldist</span><span class="p">,</span>
+                        <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+
+<span class="c1"># make pandas dataframe from our sorted dictionary of data</span>
+<span class="n">plot_data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="o">.</span><span class="n">from_dict</span><span class="p">({</span><span class="s1">&#39;ZAMS luminosity distribution&#39;</span> <span class="p">:</span> <span class="n">ldist</span><span class="p">})</span>
+
+<span class="c1"># make the plot</span>
+<span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">plot_data</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2">$ ($L_\mathrm</span><span class="si">{ZAMS}</span><span class="s2">$ / L$_{☉}$)&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;Number of stars&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">yscale</span><span class="o">=</span><span class="s2">&quot;log&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[14]:
+</pre></div>
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+[None]
+</pre></div></div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_luminosity_function_single_25_1.png" src="_images/notebook_luminosity_function_single_25_1.png" />
+</div>
+</div>
+<p>This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it’s not smooth - it’s spiky!</p>
+<p>If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor.</p>
+<p>We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let’s try sampling the masses of the stars in a smarter way.</p>
+</div>
+<div class="section" id="A-better-sampled-grid">
+<h2>A better-sampled grid<a class="headerlink" href="#A-better-sampled-grid" title="Permalink to this headline">¶</a></h2>
+<p>The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space.</p>
+<p>To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[15]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Rename the old variable (M_1) because we want it to be called lnM_1 now</span>
+<span class="n">population</span><span class="o">.</span><span class="n">rename_grid_variable</span><span class="p">(</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span><span class="s2">&quot;lnM_1&quot;</span><span class="p">)</span>
+</pre></div>
+</div>
+</div>
+<p>Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass.</p>
+<div class="nbinput nblast docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[16]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># update the sampling, note that the IMF is dprob/dM1, and the phase</span>
+<span class="c1"># space is now sampled in lnM1, so we multiply by M_1 to</span>
+<span class="c1"># because  M * dprob/dM = dprob/dlnM</span>
+<span class="n">population</span><span class="o">.</span><span class="n">update_grid_variable</span><span class="p">(</span>
+    <span class="n">name</span><span class="o">=</span><span class="s2">&quot;lnM_1&quot;</span><span class="p">,</span>
+    <span class="n">spacingfunc</span><span class="o">=</span><span class="s2">&quot;const(math.log(</span><span class="si">{min}</span><span class="s2">), math.log(</span><span class="si">{max}</span><span class="s2">), </span><span class="si">{res}</span><span class="s2">)&quot;</span><span class="o">.</span><span class="n">format</span><span class="p">(</span><span class="nb">min</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">0</span><span class="p">],</span> <span class="nb">max</span> <span class="o">=</span> <span class="n">massrange</span><span class="p">[</span><span class="mi">1</span><span class="p">],</span> <span class="n">res</span> <span class="o">=</span> <span class="n">resolution</span><span class="p">[</span><span class="s2">&quot;M_1&quot;</span><span class="p">]),</span>
+    <span class="n">probdist</span><span class="o">=</span><span class="s2">&quot;three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1&quot;</span><span class="p">,</span>
+    <span class="n">dphasevol</span><span class="o">=</span><span class="s2">&quot;dlnM_1&quot;</span><span class="p">,</span>
+    <span class="n">parameter_name</span><span class="o">=</span><span class="s2">&quot;M_1&quot;</span><span class="p">,</span>
+    <span class="n">precode</span><span class="o">=</span><span class="s2">&quot;M_1=math.exp(lnM_1)&quot;</span><span class="p">,</span>
+<span class="p">)</span>
+<span class="c1"># print(population.grid_options[&quot;_grid_variables&quot;]) # debugging</span>
+</pre></div>
+</div>
+</div>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[17]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># Clean and re-evolve the population</span>
+<span class="n">population</span><span class="o">.</span><span class="n">clean</span><span class="p">()</span>
+<span class="n">analytics</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
+
+<span class="c1"># Show the results (debugging)</span>
+<span class="c1"># print (population.grid_results)</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<div class="highlight"><pre>
+Generating grid code
+Constructing/adding: lnM_1
+Grid has handled 40 stars
+with a total probability of 0.9956307907476224
+Total starcount for this run will be: 40
+Generating grid code
+Constructing/adding: lnM_1
+Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores
+There were no errors found in this run.
+</pre></div></div>
+</div>
+<p>You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality.</p>
+<div class="nbinput docutils container">
+<div class="prompt highlight-none notranslate"><div class="highlight"><pre><span></span>[18]:
+</pre></div>
+</div>
+<div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
+<span></span><span class="c1"># plot luminosity distribution</span>
+<span class="n">ldist</span> <span class="o">=</span> <span class="n">population</span><span class="o">.</span><span class="n">grid_results</span><span class="p">[</span><span class="s1">&#39;luminosity distribution&#39;</span><span class="p">]</span>
+
+<span class="c1"># pad the distribution with zeros where data is missing</span>
+<span class="n">pad_output_distribution</span><span class="p">(</span><span class="n">ldist</span><span class="p">,</span>
+                        <span class="n">binwidth</span><span class="p">[</span><span class="s1">&#39;luminosity&#39;</span><span class="p">])</span>
+
+<span class="c1"># make pandas dataframe from our sorted dictionary of data</span>
+<span class="n">plot_data</span> <span class="o">=</span> <span class="n">pd</span><span class="o">.</span><span class="n">DataFrame</span><span class="o">.</span><span class="n">from_dict</span><span class="p">({</span><span class="s1">&#39;ZAMS luminosity distribution&#39;</span> <span class="p">:</span> <span class="n">ldist</span><span class="p">})</span>
+
+<span class="c1"># make the plot</span>
+<span class="n">p</span> <span class="o">=</span> <span class="n">sns</span><span class="o">.</span><span class="n">lineplot</span><span class="p">(</span><span class="n">data</span><span class="o">=</span><span class="n">plot_data</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_xlabel</span><span class="p">(</span><span class="s2">&quot;$\log_</span><span class="si">{10}</span><span class="s2">$ ($L_\mathrm</span><span class="si">{ZAMS}</span><span class="s2">$ / L$_{☉}$)&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set_ylabel</span><span class="p">(</span><span class="s2">&quot;Number of stars&quot;</span><span class="p">)</span>
+<span class="n">p</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">yscale</span><span class="o">=</span><span class="s2">&quot;log&quot;</span><span class="p">)</span>
+<span class="n">plt</span><span class="o">.</span><span class="n">show</span><span class="p">()</span>
+</pre></div>
+</div>
+</div>
+<div class="nboutput nblast docutils container">
+<div class="prompt empty docutils container">
+</div>
+<div class="output_area docutils container">
+<img alt="_images/notebook_luminosity_function_single_33_0.png" src="_images/notebook_luminosity_function_single_33_0.png" />
+</div>
+</div>
+<p>Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong!</p>
+<p>As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(<em>L</em>/L☉)=-2.</p>
+<p>Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you’ll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO2, etc.</p>
+<p>Things to try: * Change the resolution to make the distributions smoother: what about error bars, how would you do that? * Different initial distributions: the Kroupa distribution isn’t the only one out there * Change the metallicity and mass ranges * What about a non-constant star formation rate? This is more of a challenge! * What about evolved stars? Here we consider only the <em>zero-age</em> main sequnece. What about other main-sequence stars? What about stars in later phases of stellar
+evolution? * Binary stars! (see notebook_luminosity_function_binaries.ipynb)</p>
+</div>
+</div>
+
+
+           </div>
+           
+          </div>
+          <footer>
+  
+    <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
+      
+        <a href="notebook_luminosity_function_binaries.html" class="btn btn-neutral float-right" title="Zero-age stellar luminosity function in binaries" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+      
+      
+        <a href="notebook_api_functionality.html" class="btn btn-neutral float-left" title="Tutorial: Using the API functionality of binary_c-python" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+      
+    </div>
+  
+
+  <hr/>
+
+  <div role="contentinfo">
+    <p>
+        
+        &copy; Copyright 2021, David Hendriks, Robert Izzard
+
+    </p>
+  </div>
+    
+    
+    
+    Built with <a href="http://sphinx-doc.org/">Sphinx</a> using a
+    
+    <a href="https://github.com/rtfd/sphinx_rtd_theme">theme</a>
+    
+    provided by <a href="https://readthedocs.org">Read the Docs</a>.
+<br><br>
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+<br><br>
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
+
+
+
+</footer>
+
+        </div>
+      </div>
+
+    </section>
+
+  </div>
+  
+
+  <script type="text/javascript">
+      jQuery(function () {
+          SphinxRtdTheme.Navigation.enable(true);
+      });
+  </script>
+
+  
+  
+    
+   
+
+</body>
+</html>
\ No newline at end of file
diff --git a/docs/build/html/notebook_luminosity_function_single.ipynb b/docs/build/html/notebook_luminosity_function_single.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..cdae316f90802fe46611ea17732506c0410aef55
--- /dev/null
+++ b/docs/build/html/notebook_luminosity_function_single.ipynb
@@ -0,0 +1,725 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Zero-age stellar luminosity function\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c. \n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mass\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "   /* Note that we use Printf - with a capital P! */\n",
+    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
+    "          stardata->model.time, // 1\n",
+    "          stardata->common.zero_age.mass[0], // 2\n",
+    "          stardata->star[0].mass, // 3\n",
+    "          stardata->star[0].luminosity, // 4\n",
+    "          stardata->model.probability // 5\n",
+    "      );\n",
+    "};\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "        \n",
+    "        # Check the header and act accordingly\n",
+    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
+    "            \n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 1.0000000000000004\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=2,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'e6c082aabe0849a0811761a06e50476b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631461389.3681686, 'end_timestamp': 1631461391.6702895, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "                    \n",
+    "\n",
+    "# this saves a lot of typing! \n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
+   "metadata": {},
+   "source": [
+    "## ZAMS Luminosity distribution with the initial mass function\n",
+    "\n",
+    "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars.  So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Update the probability distribution to use the three-part power law IMF \n",
+    "population.update_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.2182216189410787\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
+   "metadata": {},
+   "source": [
+    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it's not smooth - it's spiky! \n",
+    "\n",
+    "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n",
+    "\n",
+    "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## A better-sampled grid\n",
+    "\n",
+    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
+    "\n",
+    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rename the old variable (M_1) because we want it to be called lnM_1 now\n",
+    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
+   "metadata": {},
+   "source": [
+    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
+    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
+    "# because  M * dprob/dM = dprob/dlnM\n",
+    "population.update_grid_variable(\n",
+    "    name=\"lnM_1\",\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    precode=\"M_1=math.exp(lnM_1)\",\n",
+    ")\n",
+    "# print(population.grid_options[\"_grid_variables\"]) # debugging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.9956307907476224\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6",
+   "metadata": {},
+   "source": [
+    "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
+   "metadata": {},
+   "source": [
+    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
+    "\n",
+    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(*L*/L<sub>☉</sub>)=-2. \n",
+    " \n",
+    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
+    "* Different initial distributions: the Kroupa distribution isn't the only one out there\n",
+    "* Change the metallicity and mass ranges\n",
+    "* What about a non-constant star formation rate? This is more of a challenge!\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
+    "* Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/build/html/notebook_population.html b/docs/build/html/notebook_population.html
index 5336a7fdf7894646019acf4276fba685e69c0b2a..055662c6446d2b0498a9accd3e75ca6953b46f23 100644
--- a/docs/build/html/notebook_population.html
+++ b/docs/build/html/notebook_population.html
@@ -7,7 +7,7 @@
   
   <meta name="viewport" content="width=device-width, initial-scale=1.0">
   
-  <title>Running populations with binarycpython &mdash; binary_c-python  documentation</title>
+  <title>Tutorial: Running populations with binary_c-python &mdash; binary_c-python  documentation</title>
   
 
   
@@ -39,8 +39,8 @@
     
     <link rel="index" title="Index" href="genindex.html" />
     <link rel="search" title="Search" href="search.html" />
-    <link rel="next" title="Extra features and functionality of binarycpython" href="notebook_extra_features.html" />
-    <link rel="prev" title="Using custom logging routines with binarycpython" href="notebook_custom_logging.html" /> 
+    <link rel="next" title="Tutorial: Extra features and functionality of binary_c-python" href="notebook_extra_features.html" />
+    <link rel="prev" title="Tutorial: Using custom logging routines with binary_c-python" href="notebook_custom_logging.html" /> 
 </head>
 
 <body class="wy-body-for-nav">
@@ -90,9 +90,9 @@
 <li class="toctree-l1"><a class="reference internal" href="readme_link.html">Python module for binary_c</a></li>
 <li class="toctree-l1"><a class="reference internal" href="modules.html">Binarycpython code</a></li>
 <li class="toctree-l1 current"><a class="reference internal" href="example_notebooks.html">Example notebooks</a><ul class="current">
-<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Running individual systems with binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Using custom logging routines with binarycpython</a></li>
-<li class="toctree-l2 current"><a class="current reference internal" href="#">Running populations with binarycpython</a><ul>
+<li class="toctree-l2"><a class="reference internal" href="notebook_individual_systems.html">Tutorial: Running individual systems with binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_custom_logging.html">Tutorial: Using custom logging routines with binary_c-python</a></li>
+<li class="toctree-l2 current"><a class="current reference internal" href="#">Tutorial: Running populations with binary_c-python</a><ul>
 <li class="toctree-l3"><a class="reference internal" href="#Setting-up-the-Population-object">Setting up the Population object</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Adding-grid-variables">Adding grid variables</a></li>
 <li class="toctree-l3"><a class="reference internal" href="#Setting-logging-and-handling-the-output">Setting logging and handling the output</a></li>
@@ -101,8 +101,12 @@
 <li class="toctree-l3"><a class="reference internal" href="#Full-examples-of-population-scripts">Full examples of population scripts</a></li>
 </ul>
 </li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Extra features and functionality of binarycpython</a></li>
-<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Using the API functionality of binarycpython</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_extra_features.html">Tutorial: Extra features and functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_api_functionality.html">Tutorial: Using the API functionality of binary_c-python</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_single.html">Example use case: Zero-age stellar luminosity function</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_luminosity_function_binaries.html">Zero-age stellar luminosity function in binaries</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_HRD.html">Example use case: Hertzsprung-Russell diagrams</a></li>
+<li class="toctree-l2"><a class="reference internal" href="notebook_common_envelope_evolution.html">Example use case: Common-envelope evolution</a></li>
 </ul>
 </li>
 <li class="toctree-l1"><a class="reference internal" href="binary_c_parameters.html">Binary_c parameters</a></li>
@@ -157,7 +161,7 @@
         
           <li><a href="example_notebooks.html">Example notebooks</a> &raquo;</li>
         
-      <li>Running populations with binarycpython</li>
+      <li>Tutorial: Running populations with binary_c-python</li>
     
     
       <li class="wy-breadcrumbs-aside">
@@ -446,8 +450,8 @@ div.rendered_html tbody tr:hover {
     text-align: unset;
 }
 </style>
-<div class="section" id="Running-populations-with-binarycpython">
-<h1>Running populations with binarycpython<a class="headerlink" href="#Running-populations-with-binarycpython" title="Permalink to this headline">¶</a></h1>
+<div class="section" id="Tutorial:-Running-populations-with-binary_c-python">
+<h1>Tutorial: Running populations with binary_c-python<a class="headerlink" href="#Tutorial:-Running-populations-with-binary_c-python" title="Permalink to this headline">¶</a></h1>
 <p>This notebook will show you how to evolve a population of stars</p>
 <p>Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let’s go through the functionality of this object step by step and set up some example populations.</p>
 <p>At the bottom of this notebook there are some complete example scripts</p>
@@ -457,9 +461,12 @@ div.rendered_html tbody tr:hover {
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
 <span></span><span class="kn">import</span> <span class="nn">os</span>
+
 <span class="kn">from</span> <span class="nn">binarycpython.utils.custom_logging_functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
 <span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
 
+<span class="n">TMP_DIR</span> <span class="o">=</span> <span class="n">temp_dir</span><span class="p">(</span><span class="s2">&quot;notebooks&quot;</span><span class="p">,</span> <span class="s2">&quot;notebook_population&quot;</span><span class="p">)</span>
+
 <span class="c1"># help(Population) # Uncomment to see the public functions of this object</span>
 </pre></div>
 </div>
@@ -497,11 +504,12 @@ you have set them.</p>
 
 
     <span class="c1"># grid_options</span>
-    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>  <span class="c1"># grid_options</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
 
     <span class="c1"># Custom options # TODO: need to be set in grid_options probably</span>
     <span class="n">data_dir</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
-        <span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span>
+        <span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span>
     <span class="p">),</span>  <span class="c1"># custom_options</span>
     <span class="n">base_filename</span><span class="o">=</span><span class="s2">&quot;example_pop.dat&quot;</span><span class="p">,</span>  <span class="c1"># custom_options</span>
 <span class="p">)</span>
@@ -523,7 +531,8 @@ adding: orbital_period=45000000080 to BSE_options
 adding: max_evolution_time=15000 to BSE_options
 adding: eccentricity=0.02 to BSE_options
 adding: amt_cores=2 to grid_options
-&lt;&lt;&lt;&lt; Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/example_python_population_result to custom_options &gt;&gt;&gt;&gt;
+adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_population to grid_options
+&lt;&lt;&lt;&lt; Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result to custom_options &gt;&gt;&gt;&gt;
 &lt;&lt;&lt;&lt; Warning: Key does not match previously known parameter:                     adding: base_filename=example_pop.dat to custom_options &gt;&gt;&gt;&gt;
 1
 example_pop.dat
@@ -548,7 +557,7 @@ include_binary_c_version_info=False - include_binary_c_help_all (all the help in
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-Writing settings to /tmp/binary_c_python/example_python_population_result/example_pop_settings.json
+Writing settings to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json
 </pre></div></div>
 </div>
 <div class="nboutput nblast docutils container">
@@ -557,7 +566,7 @@ Writing settings to /tmp/binary_c_python/example_python_population_result/exampl
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-&#39;/tmp/binary_c_python/example_python_population_result/example_pop_settings.json&#39;
+&#39;/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json&#39;
 </pre></div></div>
 </div>
 </div>
@@ -584,7 +593,7 @@ Writing settings to /tmp/binary_c_python/example_python_population_result/exampl
 <div class="highlight"><pre>
 Help on method add_grid_variable in module binarycpython.utils.grid:
 
-add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str=&#39;edge&#39;, branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -&gt; None method of binarycpython.utils.grid.Population instance
+add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str=&#39;centred&#39;, branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -&gt; None method of binarycpython.utils.grid.Population instance
     Function to add grid variables to the grid_options.
 
     The execution of the grid generation will be through a nested for loop.
@@ -652,7 +661,7 @@ add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolutio
                 condition = &#39;self.grid_options[&#39;binary&#39;]==1&#39;
         gridtype:
             Method on how the value range is sampled. Can be either &#39;edge&#39; (steps starting at
-            the lower edge of the value range) or &#39;center&#39;
+            the lower edge of the value range) or &#39;centred&#39;
             (steps starting at lower edge + 0.5 * stepsize).
 
 </pre></div></div>
@@ -743,7 +752,7 @@ Added grid variable: {
     &#34;dphasevol&#34;: &#34;dlnm1&#34;,
     &#34;parameter_name&#34;: &#34;M_1&#34;,
     &#34;condition&#34;: &#34;&#34;,
-    &#34;gridtype&#34;: &#34;edge&#34;,
+    &#34;gridtype&#34;: &#34;centred&#34;,
     &#34;branchpoint&#34;: 0,
     &#34;grid_variable_number&#34;: 0
 }
@@ -868,7 +877,7 @@ if(stardata-&gt;star[0].stellar_type &gt;= 13)
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-adding: parse_function=&lt;function parse_function at 0x7ff3bdf79620&gt; to grid_options
+adding: parse_function=&lt;function parse_function at 0x7f531bc3b6a8&gt; to grid_options
 </pre></div></div>
 </div>
 </div>
@@ -900,25 +909,25 @@ adding: verbosity=0 to grid_options
 Generating grid code
 Constructing/adding: lnm1
 Grid has handled 20 stars
-with a total probability of 0.05150046619238192
+with a total probability of 0.044402888438054094
 Total starcount for this run will be: 20
-EXAMPLE_COMPACT_OBJECT             2.867655467480e+01 1.33079 9.81391 0.00167028 13
 Generating grid code
 Constructing/adding: lnm1
-EXAMPLE_COMPACT_OBJECT             1.931266944719e+01 1.3933 12.3177 0.00124307 13
-EXAMPLE_COMPACT_OBJECT             4.439623364590e+01 1.38004 7.81906 0.00224431 13
-EXAMPLE_COMPACT_OBJECT             1.364277535630e+01 1.47961 15.4603 0.000925128 13
-EXAMPLE_COMPACT_OBJECT             1.017435498578e+01 1.59052 19.4046 0.000688507 13
-EXAMPLE_COMPACT_OBJECT             8.294870923827e+00 1.7197 24.3552 0.000512406 13
-EXAMPLE_COMPACT_OBJECT             6.802132608769e+00 1.84162 30.5689 0.000381347 13
-EXAMPLE_COMPACT_OBJECT             5.723570798020e+00 1.99471 38.3678 0.00028381 13
-EXAMPLE_COMPACT_OBJECT             4.933751523833e+00 2.15875 48.1564 0.000211219 13
-EXAMPLE_COMPACT_OBJECT             4.337250536639e+00 2.35209 60.4424 0.000157195 14
-EXAMPLE_COMPACT_OBJECT             3.862081089332e+00 2.56776 75.8628 0.000116989 14
-EXAMPLE_COMPACT_OBJECT             3.449960890183e+00 2.80457 95.2174 8.70668e-05 14
-EXAMPLE_COMPACT_OBJECT             3.172196856333e+00 3.05193 119.51 6.47976e-05 14
-EXAMPLE_COMPACT_OBJECT             3.069627290216e+00 3.27563 150 4.82242e-05 14
-Population-2a7732d03e594ef4b5dfe9051b41d9c0 finished! The total probability was: 0.05150046619238191. It took a total of 0.7797017097473145s to run 20 systems on 2 cores
+EXAMPLE_COMPACT_OBJECT             4.139293101586e+01 1.29427 8.13626 0.00202467 13
+EXAMPLE_COMPACT_OBJECT             2.802986496151e+01 1.33699 10.0967 0.00152924 13
+EXAMPLE_COMPACT_OBJECT             1.963621764679e+01 1.39754 12.5294 0.00115504 13
+EXAMPLE_COMPACT_OBJECT             1.427601421985e+01 1.47745 15.5483 0.000872405 13
+EXAMPLE_COMPACT_OBJECT             1.094409257247e+01 1.57571 19.2947 0.00065893 13
+EXAMPLE_COMPACT_OBJECT             9.181971798545e+00 1.68748 23.9436 0.000497691 13
+EXAMPLE_COMPACT_OBJECT             7.905335716621e+00 1.77287 29.7128 0.000375908 13
+EXAMPLE_COMPACT_OBJECT             7.451192744924e+00 1.81495 36.872 0.000283924 13
+EXAMPLE_COMPACT_OBJECT             7.396133472739e+00 1.82088 45.7561 0.000214449 13
+EXAMPLE_COMPACT_OBJECT             7.396675941641e+00 1.82123 56.7809 0.000161974 13
+EXAMPLE_COMPACT_OBJECT             7.404641347602e+00 1.82074 70.4621 0.000122339 13
+EXAMPLE_COMPACT_OBJECT             7.444217227690e+00 1.81636 87.4397 9.2403e-05 13
+EXAMPLE_COMPACT_OBJECT             7.453317880232e+00 1.81536 108.508 6.97923e-05 13
+EXAMPLE_COMPACT_OBJECT             7.450828476484e+00 1.81563 134.653 5.27143e-05 13
+Population-f28b5f98d7ef40dcb17fc2481a6d3ced finished! The total probability was: 0.04440288843805411. It took a total of 2.785212755203247s to run 20 systems on 2 cores
 There were no errors found in this run.
 </pre></div></div>
 </div>
@@ -937,7 +946,7 @@ There were no errors found in this run.
 </div>
 <div class="output_area docutils container">
 <div class="highlight"><pre>
-{&#39;population_name&#39;: &#39;2a7732d03e594ef4b5dfe9051b41d9c0&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 0.05150046619238191, &#39;total_count&#39;: 20, &#39;start_timestamp&#39;: 1628444120.234709, &#39;end_timestamp&#39;: 1628444121.0144107, &#39;total_mass_run&#39;: 730.1048014407228, &#39;total_probability_weighted_mass_run&#39;: 0.2983275843337705, &#39;zero_prob_stars_skipped&#39;: 0}
+{&#39;population_name&#39;: &#39;f28b5f98d7ef40dcb17fc2481a6d3ced&#39;, &#39;evolution_type&#39;: &#39;grid&#39;, &#39;failed_count&#39;: 0, &#39;failed_prob&#39;: 0, &#39;failed_systems_error_codes&#39;: [], &#39;errors_exceeded&#39;: False, &#39;errors_found&#39;: False, &#39;total_probability&#39;: 0.04440288843805411, &#39;total_count&#39;: 20, &#39;start_timestamp&#39;: 1629459533.935186, &#39;end_timestamp&#39;: 1629459536.7203987, &#39;total_mass_run&#39;: 684.2544031669779, &#39;total_probability_weighted_mass_run&#39;: 0.28134439269236855, &#39;zero_prob_stars_skipped&#39;: 0}
 </pre></div></div>
 </div>
 </div>
@@ -990,7 +999,7 @@ write_binary_c_calls_to_file(output_dir:Union[str, NoneType]=None, output_filena
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
-<span></span><span class="n">example_pop</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">verbosity</span><span class="o">=</span><span class="mi">10</span><span class="p">)</span>
+<span></span><span class="n">example_pop</span><span class="o">.</span><span class="n">set</span><span class="p">(</span><span class="n">verbosity</span><span class="o">=</span><span class="mi">1</span><span class="p">)</span>
 <span class="n">calls_filename</span> <span class="o">=</span> <span class="n">example_pop</span><span class="o">.</span><span class="n">write_binary_c_calls_to_file</span><span class="p">()</span>
 <span class="nb">print</span><span class="p">(</span><span class="n">calls_filename</span><span class="p">)</span>
 
@@ -1008,37 +1017,17 @@ Generating grid code
 Generating grid code
 Constructing/adding: lnm1
 Saving grid code to grid_options
-Writing grid code to /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py
-Loading grid code function from /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py
+Writing grid code to /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py
+Loading grid code function from /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py
 Grid code loaded
-Writing binary_c calls to /tmp/binary_c_python/example_python_population_result/binary_c_calls.txt
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
-_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.
+Writing binary_c calls to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt
 Grid has handled 20 stars
-with a total probability of 0.05150046619238192
-/tmp/binary_c_python/example_python_population_result/binary_c_calls.txt
-binary_c M_1 2.0 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.013208238029791246
-binary_c M_1 2.5102526289471614 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.009829948023831718
-binary_c M_1 3.1506841305680684 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.0073157281034221516
-binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.005444573822104362
+with a total probability of 0.044402888438054094
+/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt
+binary_c M_1 2.227955577093495 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.010905083645619543
+binary_c M_1 2.7647737053496777 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.008236638755149857
+binary_c M_1 3.4309362899259503 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.006221155214163634
+binary_c M_1 4.257608426597089 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.004698855121516278
 </pre></div></div>
 </div>
 </div>
@@ -1050,12 +1039,7 @@ binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbit
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
-<span></span><span class="kn">import</span> <span class="nn">os</span>
-
-<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
-<span class="kn">from</span> <span class="nn">binarycpython.utils.custom_logging_functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
-
-<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+<span></span><span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Example parsing function</span>
 <span class="sd">    &quot;&quot;&quot;</span>
@@ -1114,11 +1098,12 @@ binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbit
     <span class="n">eccentricity</span><span class="o">=</span><span class="mf">0.02</span><span class="p">,</span>  <span class="c1"># bse_options</span>
 
     <span class="c1"># grid_options</span>
-    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>  <span class="c1"># grid_options</span>
+    <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
 
     <span class="c1"># Custom options: the data directory and the output filename</span>
     <span class="n">data_dir</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
-        <span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span>
+        <span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span>
     <span class="p">),</span>  <span class="c1"># custom_options</span>
     <span class="n">base_filename</span><span class="o">=</span><span class="s2">&quot;example_pop.dat&quot;</span><span class="p">,</span>  <span class="c1"># custom_options</span>
 <span class="p">)</span>
@@ -1173,15 +1158,15 @@ binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbit
 <span class="n">example_pop</span><span class="o">.</span><span class="n">export_all_info</span><span class="p">()</span>
 
 <span class="c1"># remove the result file if it exists</span>
-<span class="k">if</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">isfile</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">)):</span>
-    <span class="n">os</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">))</span>
+<span class="k">if</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">isfile</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">)):</span>
+    <span class="n">os</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">))</span>
 
 
 <span class="c1"># Evolve the population</span>
 <span class="n">example_pop</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
 
 <span class="c1">#</span>
-<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">),</span> <span class="s1">&#39;r&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
+<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">),</span> <span class="s1">&#39;r&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
     <span class="n">output</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
 <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\n</span><span class="s2">&quot;</span><span class="p">)</span>
 <span class="nb">print</span><span class="p">(</span><span class="n">output</span><span class="p">)</span>
@@ -1196,29 +1181,29 @@ binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbit
 Generating grid code
 Constructing/adding: lnm1
 Grid has handled 20 stars
-with a total probability of 0.05150046619238192
+with a total probability of 0.044402888438054094
 Total starcount for this run will be: 20
 Generating grid code
 Constructing/adding: lnm1
-Population-3680f3882c0a449c944462abffea2447 finished! The total probability was: 0.05150046619238191. It took a total of 0.6246354579925537s to run 20 systems on 2 cores
+Population-e45c25448b32440cb7e220f4a3562907 finished! The total probability was: 0.04440288843805411. It took a total of 1.9539172649383545s to run 20 systems on 2 cores
 There were no errors found in this run.
 
 
 time mass zams_mass probability radius stellar_type
-2.867655467480e+01 1.33079 9.81391 0.00167028 1.72498e-05 13
-1.931266944719e+01 1.3933 12.3177 0.00124307 1.72498e-05 13
-4.439623364590e+01 1.38004 7.81906 0.00224431 1.72498e-05 13
-1.364277535630e+01 1.47961 15.4603 0.000925128 1.72498e-05 13
-1.017435498578e+01 1.59052 19.4046 0.000688507 1.72498e-05 13
-8.294870923827e+00 1.7197 24.3552 0.000512406 1.72498e-05 13
-6.802132608769e+00 1.84162 30.5689 0.000381347 1.72498e-05 13
-5.723570798020e+00 1.99471 38.3678 0.00028381 1.72498e-05 13
-4.933751523833e+00 2.15875 48.1564 0.000211219 1.72498e-05 13
-4.337250536639e+00 2.35209 60.4424 0.000157195 9.97286e-06 14
-3.862081089332e+00 2.56776 75.8628 0.000116989 1.08873e-05 14
-3.449960890183e+00 2.80457 95.2174 8.70668e-05 1.18914e-05 14
-3.172196856333e+00 3.05193 119.51 6.47976e-05 1.29402e-05 14
-3.069627290216e+00 3.27563 150 4.82242e-05 1.38887e-05 14
+4.139293101586e+01 1.29427 8.13626 0.00202467 1.72498e-05 13
+2.802986496151e+01 1.33699 10.0967 0.00152924 1.72498e-05 13
+1.963621764679e+01 1.39754 12.5294 0.00115504 1.72498e-05 13
+1.427601421985e+01 1.47745 15.5483 0.000872405 1.72498e-05 13
+1.094409257247e+01 1.57571 19.2947 0.00065893 1.72498e-05 13
+9.181971798545e+00 1.68748 23.9436 0.000497691 1.72498e-05 13
+7.905335716621e+00 1.77287 29.7128 0.000375908 1.72498e-05 13
+7.451192744924e+00 1.81495 36.872 0.000283924 1.72498e-05 13
+7.396133472739e+00 1.82088 45.7561 0.000214449 1.72498e-05 13
+7.396675941641e+00 1.82123 56.7809 0.000161974 1.72498e-05 13
+7.404641347602e+00 1.82074 70.4621 0.000122339 1.72498e-05 13
+7.444217227690e+00 1.81636 87.4397 9.2403e-05 1.72498e-05 13
+7.453317880232e+00 1.81536 108.508 6.97923e-05 1.72498e-05 13
+7.450828476484e+00 1.81563 134.653 5.27143e-05 1.72498e-05 13
 
 </pre></div></div>
 </div>
@@ -1228,12 +1213,7 @@ time mass zams_mass probability radius stellar_type
 </pre></div>
 </div>
 <div class="input_area highlight-ipython3 notranslate"><div class="highlight"><pre>
-<span></span><span class="kn">import</span> <span class="nn">os</span>
-
-<span class="kn">from</span> <span class="nn">binarycpython.utils.grid</span> <span class="kn">import</span> <span class="n">Population</span>
-<span class="kn">from</span> <span class="nn">binarycpython.utils.custom_logging_functions</span> <span class="kn">import</span> <span class="n">temp_dir</span>
-
-<span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
+<span></span><span class="k">def</span> <span class="nf">parse_function</span><span class="p">(</span><span class="bp">self</span><span class="p">,</span> <span class="n">output</span><span class="p">):</span>
     <span class="sd">&quot;&quot;&quot;</span>
 <span class="sd">    Example parsing function</span>
 <span class="sd">    &quot;&quot;&quot;</span>
@@ -1298,10 +1278,11 @@ time mass zams_mass probability radius stellar_type
 
     <span class="c1"># grid_options</span>
     <span class="n">amt_cores</span><span class="o">=</span><span class="mi">2</span><span class="p">,</span>  <span class="c1"># grid_options</span>
+    <span class="n">tmp_dir</span><span class="o">=</span><span class="n">TMP_DIR</span><span class="p">,</span>
 
     <span class="c1"># Custom options: the data directory and the output filename</span>
     <span class="n">data_dir</span><span class="o">=</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span>
-        <span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span>
+        <span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span>
     <span class="p">),</span>  <span class="c1"># custom_options</span>
     <span class="n">base_filename</span><span class="o">=</span><span class="s2">&quot;example_pop.dat&quot;</span><span class="p">,</span>  <span class="c1"># custom_options</span>
 <span class="p">)</span>
@@ -1399,14 +1380,14 @@ time mass zams_mass probability radius stellar_type
 <span class="n">example_pop</span><span class="o">.</span><span class="n">export_all_info</span><span class="p">()</span>
 
 <span class="c1"># remove the result file if it exists</span>
-<span class="k">if</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">isfile</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">)):</span>
-    <span class="n">os</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">))</span>
+<span class="k">if</span> <span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">isfile</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">)):</span>
+    <span class="n">os</span><span class="o">.</span><span class="n">remove</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">))</span>
 
 <span class="c1"># Evolve the population</span>
 <span class="n">example_pop</span><span class="o">.</span><span class="n">evolve</span><span class="p">()</span>
 
 <span class="c1">#</span>
-<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">temp_dir</span><span class="p">(),</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">),</span> <span class="s1">&#39;r&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
+<span class="k">with</span> <span class="nb">open</span><span class="p">(</span><span class="n">os</span><span class="o">.</span><span class="n">path</span><span class="o">.</span><span class="n">join</span><span class="p">(</span><span class="n">TMP_DIR</span><span class="p">,</span> <span class="s2">&quot;example_python_population_result&quot;</span><span class="p">,</span> <span class="s2">&quot;example_pop.dat&quot;</span><span class="p">),</span> <span class="s1">&#39;r&#39;</span><span class="p">)</span> <span class="k">as</span> <span class="n">f</span><span class="p">:</span>
     <span class="n">output</span> <span class="o">=</span> <span class="n">f</span><span class="o">.</span><span class="n">read</span><span class="p">()</span>
 <span class="nb">print</span><span class="p">(</span><span class="s2">&quot;</span><span class="se">\n</span><span class="s2">&quot;</span><span class="p">)</span>
 <span class="nb">print</span><span class="p">(</span><span class="n">output</span><span class="p">)</span>
@@ -1422,86 +1403,34 @@ Generating grid code
 Constructing/adding: lnm1
 Constructing/adding: q
 Constructing/adding: log10per
-Grid has handled 125 stars
-with a total probability of 0.0862478164626921
-Total starcount for this run will be: 125
+Grid has handled 27 stars
+with a total probability of 0.024868380796643753
+Total starcount for this run will be: 27
 Generating grid code
 Constructing/adding: lnm1
 Constructing/adding: q
 Constructing/adding: log10per
-Population-d20a4c74d20a43b881c0c9e5def5f76c finished! The total probability was: 0.08624781646269201. It took a total of 8.561265707015991s to run 125 systems on 2 cores
+Population-05128ef4c5fe4274a0356c3e99e2f2d2 finished! The total probability was: 0.024868380796643757. It took a total of 9.792905807495117s to run 27 systems on 2 cores
 There were no errors found in this run.
 
 
 time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 stellar_type_2 prev_stellar_type_2 metallicity probability
-8.863377990313e+01 1.29444 5.88566 0 2.99283 13 5 15 15 0.02 0.000627913
-1.146421815741e+02 0 5.88566 1.33062 4.43925 15 15 13 5 0.02 0.000627913
-7.222715508467e+01 1.34922 5.88566 0 5.88566 13 5 15 15 0.02 0.000627913
-1.350021848285e+01 1.48488 17.3205 0 0.1 13 5 15 15 0.02 0.000154349
-1.171108213270e+01 1.53113 17.3205 0 0.1 13 5 15 15 0.02 0.000154349
-1.171086983243e+01 1.53177 17.3205 0 0.1 13 9 15 15 0.02 0.000154349
-1.170770599495e+01 1.53176 17.3205 0 4.40513 13 5 15 15 0.02 0.000172877
-1.230407246199e+01 1.59499 17.3205 0 4.40513 13 5 15 15 0.02 0.000610573
-1.108751340926e+01 1.70319 17.3205 0 8.71025 13 4 15 15 0.02 0.000610573
-1.941017702765e+01 1.34903 17.3205 1.65097 8.71025 13 13 13 5 0.02 0.000172877
-1.980988739731e+01 1.36979 17.3205 1.60808 8.71025 13 13 13 5 0.02 0.000121486
-3.571858031651e+01 1.53174 17.3205 1.30504 8.71025 13 13 13 5 0.02 8.42148e-05
-3.459153942631e+01 1.53176 17.3205 1.31004 8.71025 13 13 13 5 0.02 9.8162e-05
-1.687368550125e+01 1.34937 17.3205 1.73856 13.0154 13 13 13 8 0.02 0.000172877
-1.194842917007e+01 1.78096 17.3205 0 13.0154 13 8 15 15 0.02 0.000610573
-1.733614170983e+01 1.53184 17.3205 1.42375 13.0154 13 13 13 5 0.02 9.8162e-05
-1.723547465714e+01 1.38403 17.3205 1.71288 13.0154 13 13 13 8 0.02 0.000121486
-1.764340254985e+01 1.53174 17.3205 1.41264 13.0154 13 13 13 5 0.02 8.42148e-05
-1.170425790780e+01 1.52963 17.3205 0 17.3205 13 5 15 15 0.02 0.000172877
-8.922967341481e+00 1.85486 17.3205 0 17.3205 13 8 15 15 0.02 0.000610573
-1.232906623449e+01 1.41074 17.3205 1.34281 17.3205 13 13 13 8 0.02 0.000121486
-1.170775828562e+01 1.53183 17.3205 1.53183 17.3205 13 5 13 5 0.02 9.8162e-05
-1.170770422321e+01 1.53175 17.3205 1.53175 17.3205 13 5 13 5 0.02 8.42148e-05
-5.075844624794e+00 2.12303 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05
-4.766606588165e+00 2.20484 50.9713 0 0.1 14 8 15 15 0.02 3.79411e-05
-4.768305081494e+00 2.18838 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05
-4.458869865939e+00 2.29864 50.9713 0 12.8178 14 8 15 15 0.02 0.000150087
-1.806014211040e+01 2.10446 50.9713 1.40749 12.8178 13 13 13 5 0.02 2.9863e-05
-4.797342083485e+00 2.10328 50.9713 0 12.8178 13 13 15 1 0.02 4.24954e-05
-1.721374713429e+01 2.21673 50.9713 1.42212 12.8178 14 14 13 5 0.02 2.41295e-05
-4.055645404546e+00 2.47276 50.9713 0 25.5357 14 7 15 15 0.02 0.000150087
-1.806123543037e+01 2.21893 50.9713 1.40745 12.8178 14 14 13 5 0.02 2.07011e-05
-8.117519147635e+00 2.10433 50.9713 2.21473 25.5357 13 13 14 8 0.02 4.24954e-05
-8.315554923168e+00 2.15343 50.9713 2.08519 25.5357 13 13 13 8 0.02 2.9863e-05
-7.917420996633e+00 2.21892 50.9713 1.7431 25.5357 14 14 13 8 0.02 2.07011e-05
-7.693213405973e+00 2.21805 50.9713 1.78384 25.5357 14 14 13 8 0.02 2.41295e-05
-3.753837732894e+00 2.62517 50.9713 0 38.2535 14 7 15 15 0.02 0.000150087
-7.087296558990e+00 2.10417 50.9713 2.40935 38.2535 13 13 14 8 0.02 4.24954e-05
-7.007109286263e+00 2.15854 50.9713 2.28672 38.2535 13 13 14 8 0.02 2.9863e-05
-5.653200958306e+00 2.21878 50.9713 2.0587 38.2535 14 14 13 8 0.02 2.41295e-05
-5.733794947644e+00 2.21892 50.9713 1.99255 38.2535 14 14 13 8 0.02 2.07011e-05
-3.513216011269e+00 2.76647 50.9713 0 50.9713 14 7 15 15 0.02 0.000150087
-4.750574783854e+00 2.27442 50.9713 0 50.9713 14 8 15 15 0.02 4.24954e-05
-7.278384712062e+00 1.29678 50.9713 2.09216 50.9713 13 8 13 13 0.02 2.9863e-05
-4.765996194699e+00 2.20787 50.9713 2.20787 50.9713 14 8 14 8 0.02 2.07011e-05
-4.765535914728e+00 2.21331 50.9713 2.21331 50.9713 14 8 14 8 0.02 2.41295e-05
-3.104706358826e+00 3.17639 150 0 0.1 14 7 15 15 0.02 9.32641e-06
-3.069363482023e+00 3.27572 150 0 0.1 14 7 15 15 0.02 9.32641e-06
-3.047074050271e+00 3.3836 150 0 37.575 14 7 15 15 0.02 3.68933e-05
-5.974759306305e+00 3.23604 150 2.53922 37.575 14 14 14 7 0.02 1.04459e-05
-6.074084349384e+00 3.30145 150 2.13876 37.575 14 14 13 8 0.02 7.34071e-06
-5.733865371895e+00 3.29994 150 2.00498 37.575 14 14 13 8 0.02 5.93135e-06
-3.027099358410e+00 3.53631 150 0 75.05 14 7 15 15 0.02 3.68933e-05
-5.807147339697e+00 3.30197 150 1.9791 37.575 14 14 13 8 0.02 5.08861e-06
-4.862942347290e+00 3.25294 150 2.97823 75.05 14 14 14 7 0.02 1.04459e-05
-4.556479830908e+00 3.29942 150 2.73221 75.05 14 14 14 7 0.02 7.34071e-06
-3.853070305680e+00 3.29977 150 2.62486 75.05 14 14 14 7 0.02 5.93135e-06
-3.881529045940e+00 3.30149 150 2.55924 75.05 14 14 14 7 0.02 5.08861e-06
-3.015033359333e+00 3.64419 150 0 112.525 14 7 15 15 0.02 3.68933e-05
-4.126828648362e+00 3.32047 150 0 112.525 14 14 15 3 0.02 1.04459e-05
-3.990017992944e+00 3.3032 150 2.94027 112.525 14 14 14 7 0.02 7.34071e-06
-3.206771867883e+00 3.07671 150 3.11282 112.525 14 14 14 7 0.02 5.93135e-06
-3.006827156705e+00 3.72638 150 0 150 14 7 15 15 0.02 3.68933e-05
-3.218786094847e+00 3.30337 150 3.01344 112.525 14 14 14 7 0.02 5.08861e-06
-4.527722847382e+00 1.42238 150 0 150 13 5 15 15 0.02 1.04459e-05
-3.069567332611e+00 3.27804 150 3.27804 150 14 7 14 7 0.02 5.93135e-06
-5.726405299909e+00 1.29746 150 3.22759 150 13 8 14 14 0.02 7.34071e-06
-3.069626478211e+00 3.27565 150 3.27565 150 14 7 14 7 0.02 5.08861e-06
+1.219029061236e+01 1.60007 17.3205 0 2.97008 13 5 15 15 0.02 0.000498487
+1.935920346899e+01 1.29448 17.3205 0 8.71025 13 13 15 2 0.02 0.000498487
+2.123795595728e+01 1.30902 17.3205 1.58519 8.71025 13 13 13 5 0.02 0.000287968
+3.579099761269e+01 1.52414 17.3205 1.30642 8.71025 13 13 13 5 0.02 0.000220016
+1.674063083432e+01 1.29457 17.3205 0 14.4504 13 13 15 2 0.02 0.000498487
+1.779197348711e+01 1.3228 17.3205 1.71196 14.4504 13 13 13 8 0.02 0.000287968
+1.548740826516e+01 1.52415 17.3205 1.45407 14.4504 13 13 13 5 0.02 0.000220016
+1.772169325356e+01 1.81957 73.0434 1.46573 12.2572 13 13 13 5 0.02 4.43422e-05
+1.367065500196e+01 1.66003 73.0434 1.79487 12.2572 13 13 13 8 0.02 7.67586e-05
+2.021960493499e+01 1.82061 73.0434 1.39205 12.2572 13 13 13 5 0.02 3.38788e-05
+9.012246630357e+00 1.81529 73.0434 0 36.5717 13 8 15 15 0.02 7.67586e-05
+7.462779538274e+00 1.82255 73.0434 1.81499 36.5717 13 13 13 8 0.02 3.38788e-05
+1.030499912298e+01 1.80592 73.0434 1.81066 36.5717 13 13 13 8 0.02 4.43422e-05
+4.227002356107e+00 2.43719 73.0434 0 60.8862 14 14 15 1 0.02 7.67586e-05
+7.396288708628e+00 1.8216 73.0434 1.8216 60.8862 13 8 13 8 0.02 3.38788e-05
+7.394728392218e+00 1.80919 73.0434 1.79091 60.8862 13 13 13 8 0.02 4.43422e-05
 
 </pre></div></div>
 </div>
@@ -1516,10 +1445,10 @@ time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 st
   
     <div class="rst-footer-buttons" role="navigation" aria-label="footer navigation">
       
-        <a href="notebook_extra_features.html" class="btn btn-neutral float-right" title="Extra features and functionality of binarycpython" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
+        <a href="notebook_extra_features.html" class="btn btn-neutral float-right" title="Tutorial: Extra features and functionality of binary_c-python" accesskey="n" rel="next">Next <span class="fa fa-arrow-circle-right"></span></a>
       
       
-        <a href="notebook_custom_logging.html" class="btn btn-neutral float-left" title="Using custom logging routines with binarycpython" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
+        <a href="notebook_custom_logging.html" class="btn btn-neutral float-left" title="Tutorial: Using custom logging routines with binary_c-python" accesskey="p" rel="prev"><span class="fa fa-arrow-circle-left"></span> Previous</a>
       
     </div>
   
@@ -1542,9 +1471,9 @@ time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 st
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/notebook_population.ipynb b/docs/build/html/notebook_population.ipynb
index b6a37baa8d90a2f36c0fd19311548ed49e77f173..a24638c0bd3a15a57bbf611fccb71b2100c75945 100644
--- a/docs/build/html/notebook_population.ipynb
+++ b/docs/build/html/notebook_population.ipynb
@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Running populations with binarycpython\n",
+    "# Tutorial: Running populations with binary_c-python\n",
     "This notebook will show you how to evolve a population of stars\n",
     "\n",
     "Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let's go through the functionality of this object step by step and set up some example populations. \n",
@@ -23,9 +23,12 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "from binarycpython.utils.custom_logging_functions import temp_dir\n",
     "from binarycpython.utils.grid import Population\n",
     "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_population\")\n",
+    "\n",
     "# help(Population) # Uncomment to see the public functions of this object"
    ]
   },
@@ -60,7 +63,8 @@
       "adding: max_evolution_time=15000 to BSE_options\n",
       "adding: eccentricity=0.02 to BSE_options\n",
       "adding: amt_cores=2 to grid_options\n",
-      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/example_python_population_result to custom_options >>>>\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_population to grid_options\n",
+      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result to custom_options >>>>\n",
       "<<<< Warning: Key does not match previously known parameter:                     adding: base_filename=example_pop.dat to custom_options >>>>\n",
       "1\n",
       "example_pop.dat\n",
@@ -88,11 +92,12 @@
     "\n",
     "\n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "    \n",
     "    # Custom options # TODO: need to be set in grid_options probably\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -133,13 +138,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Writing settings to /tmp/binary_c_python/example_python_population_result/example_pop_settings.json\n"
+      "Writing settings to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/binary_c_python/example_python_population_result/example_pop_settings.json'"
+       "'/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json'"
       ]
      },
      "execution_count": 3,
@@ -181,7 +186,7 @@
      "text": [
       "Help on method add_grid_variable in module binarycpython.utils.grid:\n",
       "\n",
-      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='edge', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
+      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='centred', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
       "    Function to add grid variables to the grid_options.\n",
       "    \n",
       "    The execution of the grid generation will be through a nested for loop.\n",
@@ -199,25 +204,25 @@
       "        name:\n",
       "            name of parameter. This is evaluated as a parameter and you can use it throughout\n",
       "            the rest of the function\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                name = 'lnm1'\n",
       "        longname:\n",
       "            Long name of parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                longname = 'Primary mass'\n",
       "        range:\n",
       "            Range of values to take. Does not get used really, the spacingfunction is used to\n",
       "            get the values from\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                range = [math.log(m_min), math.log(m_max)]\n",
       "        resolution:\n",
       "            Resolution of the sampled range (amount of samples).\n",
       "            TODO: check if this is used anywhere\n",
       "    \n",
-      "            Examples: \n",
+      "            Examples:\n",
       "                resolution = resolution[\"M_1\"]\n",
       "        spacingfunction:\n",
       "            Function determining how the range is sampled. You can either use a real function,\n",
@@ -230,12 +235,12 @@
       "        precode:\n",
       "            Extra room for some code. This code will be evaluated within the loop of the\n",
       "            sampling function (i.e. a value for lnm1 is chosen already)\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                precode = 'M_1=math.exp(lnm1);'\n",
       "        probdist:\n",
       "            Function determining the probability that gets assigned to the sampled parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                probdist = 'Kroupa2001(M_1)*M_1'\n",
       "        dphasevol:\n",
@@ -249,7 +254,7 @@
       "                condition = 'self.grid_options['binary']==1'\n",
       "        gridtype:\n",
       "            Method on how the value range is sampled. Can be either 'edge' (steps starting at\n",
-      "            the lower edge of the value range) or 'center'\n",
+      "            the lower edge of the value range) or 'centred'\n",
       "            (steps starting at lower edge + 0.5 * stepsize).\n",
       "\n"
      ]
@@ -313,7 +318,7 @@
       "    \"dphasevol\": \"dlnm1\",\n",
       "    \"parameter_name\": \"M_1\",\n",
       "    \"condition\": \"\",\n",
-      "    \"gridtype\": \"edge\",\n",
+      "    \"gridtype\": \"centred\",\n",
       "    \"branchpoint\": 0,\n",
       "    \"grid_variable_number\": 0\n",
       "}\n"
@@ -457,7 +462,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: parse_function=<function parse_function at 0x7ff3bdf79620> to grid_options\n"
+      "adding: parse_function=<function parse_function at 0x7f531bc3b6a8> to grid_options\n"
      ]
     }
    ],
@@ -536,25 +541,25 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
-      "EXAMPLE_COMPACT_OBJECT             2.867655467480e+01 1.33079 9.81391 0.00167028 13\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "EXAMPLE_COMPACT_OBJECT             1.931266944719e+01 1.3933 12.3177 0.00124307 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.439623364590e+01 1.38004 7.81906 0.00224431 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.364277535630e+01 1.47961 15.4603 0.000925128 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.017435498578e+01 1.59052 19.4046 0.000688507 13\n",
-      "EXAMPLE_COMPACT_OBJECT             8.294870923827e+00 1.7197 24.3552 0.000512406 13\n",
-      "EXAMPLE_COMPACT_OBJECT             6.802132608769e+00 1.84162 30.5689 0.000381347 13\n",
-      "EXAMPLE_COMPACT_OBJECT             5.723570798020e+00 1.99471 38.3678 0.00028381 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.933751523833e+00 2.15875 48.1564 0.000211219 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.337250536639e+00 2.35209 60.4424 0.000157195 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.862081089332e+00 2.56776 75.8628 0.000116989 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.449960890183e+00 2.80457 95.2174 8.70668e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.172196856333e+00 3.05193 119.51 6.47976e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.069627290216e+00 3.27563 150 4.82242e-05 14\n",
-      "Population-2a7732d03e594ef4b5dfe9051b41d9c0 finished! The total probability was: 0.05150046619238191. It took a total of 0.7797017097473145s to run 20 systems on 2 cores\n",
+      "EXAMPLE_COMPACT_OBJECT             4.139293101586e+01 1.29427 8.13626 0.00202467 13\n",
+      "EXAMPLE_COMPACT_OBJECT             2.802986496151e+01 1.33699 10.0967 0.00152924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.963621764679e+01 1.39754 12.5294 0.00115504 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.427601421985e+01 1.47745 15.5483 0.000872405 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.094409257247e+01 1.57571 19.2947 0.00065893 13\n",
+      "EXAMPLE_COMPACT_OBJECT             9.181971798545e+00 1.68748 23.9436 0.000497691 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.905335716621e+00 1.77287 29.7128 0.000375908 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.451192744924e+00 1.81495 36.872 0.000283924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396133472739e+00 1.82088 45.7561 0.000214449 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396675941641e+00 1.82123 56.7809 0.000161974 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.404641347602e+00 1.82074 70.4621 0.000122339 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.444217227690e+00 1.81636 87.4397 9.2403e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.453317880232e+00 1.81536 108.508 6.97923e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.450828476484e+00 1.81563 134.653 5.27143e-05 13\n",
+      "Population-f28b5f98d7ef40dcb17fc2481a6d3ced finished! The total probability was: 0.04440288843805411. It took a total of 2.785212755203247s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n"
      ]
     }
@@ -586,7 +591,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'population_name': '2a7732d03e594ef4b5dfe9051b41d9c0', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.05150046619238191, 'total_count': 20, 'start_timestamp': 1628444120.234709, 'end_timestamp': 1628444121.0144107, 'total_mass_run': 730.1048014407228, 'total_probability_weighted_mass_run': 0.2983275843337705, 'zero_prob_stars_skipped': 0}\n"
+      "{'population_name': 'f28b5f98d7ef40dcb17fc2481a6d3ced', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.04440288843805411, 'total_count': 20, 'start_timestamp': 1629459533.935186, 'end_timestamp': 1629459536.7203987, 'total_mass_run': 684.2544031669779, 'total_probability_weighted_mass_run': 0.28134439269236855, 'zero_prob_stars_skipped': 0}\n"
      ]
     }
    ],
@@ -660,42 +665,22 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Saving grid code to grid_options\n",
-      "Writing grid code to /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
-      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
       "Grid code loaded\n",
-      "Writing binary_c calls to /tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
+      "Writing binary_c calls to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
-      "/tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "binary_c M_1 2.0 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.013208238029791246\n",
-      "binary_c M_1 2.5102526289471614 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.009829948023831718\n",
-      "binary_c M_1 3.1506841305680684 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.0073157281034221516\n",
-      "binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.005444573822104362\n"
+      "with a total probability of 0.044402888438054094\n",
+      "/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
+      "binary_c M_1 2.227955577093495 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.010905083645619543\n",
+      "binary_c M_1 2.7647737053496777 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.008236638755149857\n",
+      "binary_c M_1 3.4309362899259503 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.006221155214163634\n",
+      "binary_c M_1 4.257608426597089 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.004698855121516278\n"
      ]
     }
    ],
    "source": [
-    "example_pop.set(verbosity=10)\n",
+    "example_pop.set(verbosity=1)\n",
     "calls_filename = example_pop.write_binary_c_calls_to_file()\n",
     "print(calls_filename)\n",
     "\n",
@@ -725,39 +710,34 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "Population-3680f3882c0a449c944462abffea2447 finished! The total probability was: 0.05150046619238191. It took a total of 0.6246354579925537s to run 20 systems on 2 cores\n",
+      "Population-e45c25448b32440cb7e220f4a3562907 finished! The total probability was: 0.04440288843805411. It took a total of 1.9539172649383545s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass zams_mass probability radius stellar_type\n",
-      "2.867655467480e+01 1.33079 9.81391 0.00167028 1.72498e-05 13\n",
-      "1.931266944719e+01 1.3933 12.3177 0.00124307 1.72498e-05 13\n",
-      "4.439623364590e+01 1.38004 7.81906 0.00224431 1.72498e-05 13\n",
-      "1.364277535630e+01 1.47961 15.4603 0.000925128 1.72498e-05 13\n",
-      "1.017435498578e+01 1.59052 19.4046 0.000688507 1.72498e-05 13\n",
-      "8.294870923827e+00 1.7197 24.3552 0.000512406 1.72498e-05 13\n",
-      "6.802132608769e+00 1.84162 30.5689 0.000381347 1.72498e-05 13\n",
-      "5.723570798020e+00 1.99471 38.3678 0.00028381 1.72498e-05 13\n",
-      "4.933751523833e+00 2.15875 48.1564 0.000211219 1.72498e-05 13\n",
-      "4.337250536639e+00 2.35209 60.4424 0.000157195 9.97286e-06 14\n",
-      "3.862081089332e+00 2.56776 75.8628 0.000116989 1.08873e-05 14\n",
-      "3.449960890183e+00 2.80457 95.2174 8.70668e-05 1.18914e-05 14\n",
-      "3.172196856333e+00 3.05193 119.51 6.47976e-05 1.29402e-05 14\n",
-      "3.069627290216e+00 3.27563 150 4.82242e-05 1.38887e-05 14\n",
+      "4.139293101586e+01 1.29427 8.13626 0.00202467 1.72498e-05 13\n",
+      "2.802986496151e+01 1.33699 10.0967 0.00152924 1.72498e-05 13\n",
+      "1.963621764679e+01 1.39754 12.5294 0.00115504 1.72498e-05 13\n",
+      "1.427601421985e+01 1.47745 15.5483 0.000872405 1.72498e-05 13\n",
+      "1.094409257247e+01 1.57571 19.2947 0.00065893 1.72498e-05 13\n",
+      "9.181971798545e+00 1.68748 23.9436 0.000497691 1.72498e-05 13\n",
+      "7.905335716621e+00 1.77287 29.7128 0.000375908 1.72498e-05 13\n",
+      "7.451192744924e+00 1.81495 36.872 0.000283924 1.72498e-05 13\n",
+      "7.396133472739e+00 1.82088 45.7561 0.000214449 1.72498e-05 13\n",
+      "7.396675941641e+00 1.82123 56.7809 0.000161974 1.72498e-05 13\n",
+      "7.404641347602e+00 1.82074 70.4621 0.000122339 1.72498e-05 13\n",
+      "7.444217227690e+00 1.81636 87.4397 9.2403e-05 1.72498e-05 13\n",
+      "7.453317880232e+00 1.81536 108.508 6.97923e-05 1.72498e-05 13\n",
+      "7.450828476484e+00 1.81563 134.653 5.27143e-05 1.72498e-05 13\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -817,11 +797,12 @@
     "    eccentricity=0.02,  # bse_options\n",
     "    \n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -876,15 +857,15 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -912,96 +893,39 @@
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Grid has handled 125 stars\n",
-      "with a total probability of 0.0862478164626921\n",
-      "Total starcount for this run will be: 125\n",
+      "Grid has handled 27 stars\n",
+      "with a total probability of 0.024868380796643753\n",
+      "Total starcount for this run will be: 27\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Population-d20a4c74d20a43b881c0c9e5def5f76c finished! The total probability was: 0.08624781646269201. It took a total of 8.561265707015991s to run 125 systems on 2 cores\n",
+      "Population-05128ef4c5fe4274a0356c3e99e2f2d2 finished! The total probability was: 0.024868380796643757. It took a total of 9.792905807495117s to run 27 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 stellar_type_2 prev_stellar_type_2 metallicity probability\n",
-      "8.863377990313e+01 1.29444 5.88566 0 2.99283 13 5 15 15 0.02 0.000627913\n",
-      "1.146421815741e+02 0 5.88566 1.33062 4.43925 15 15 13 5 0.02 0.000627913\n",
-      "7.222715508467e+01 1.34922 5.88566 0 5.88566 13 5 15 15 0.02 0.000627913\n",
-      "1.350021848285e+01 1.48488 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171108213270e+01 1.53113 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171086983243e+01 1.53177 17.3205 0 0.1 13 9 15 15 0.02 0.000154349\n",
-      "1.170770599495e+01 1.53176 17.3205 0 4.40513 13 5 15 15 0.02 0.000172877\n",
-      "1.230407246199e+01 1.59499 17.3205 0 4.40513 13 5 15 15 0.02 0.000610573\n",
-      "1.108751340926e+01 1.70319 17.3205 0 8.71025 13 4 15 15 0.02 0.000610573\n",
-      "1.941017702765e+01 1.34903 17.3205 1.65097 8.71025 13 13 13 5 0.02 0.000172877\n",
-      "1.980988739731e+01 1.36979 17.3205 1.60808 8.71025 13 13 13 5 0.02 0.000121486\n",
-      "3.571858031651e+01 1.53174 17.3205 1.30504 8.71025 13 13 13 5 0.02 8.42148e-05\n",
-      "3.459153942631e+01 1.53176 17.3205 1.31004 8.71025 13 13 13 5 0.02 9.8162e-05\n",
-      "1.687368550125e+01 1.34937 17.3205 1.73856 13.0154 13 13 13 8 0.02 0.000172877\n",
-      "1.194842917007e+01 1.78096 17.3205 0 13.0154 13 8 15 15 0.02 0.000610573\n",
-      "1.733614170983e+01 1.53184 17.3205 1.42375 13.0154 13 13 13 5 0.02 9.8162e-05\n",
-      "1.723547465714e+01 1.38403 17.3205 1.71288 13.0154 13 13 13 8 0.02 0.000121486\n",
-      "1.764340254985e+01 1.53174 17.3205 1.41264 13.0154 13 13 13 5 0.02 8.42148e-05\n",
-      "1.170425790780e+01 1.52963 17.3205 0 17.3205 13 5 15 15 0.02 0.000172877\n",
-      "8.922967341481e+00 1.85486 17.3205 0 17.3205 13 8 15 15 0.02 0.000610573\n",
-      "1.232906623449e+01 1.41074 17.3205 1.34281 17.3205 13 13 13 8 0.02 0.000121486\n",
-      "1.170775828562e+01 1.53183 17.3205 1.53183 17.3205 13 5 13 5 0.02 9.8162e-05\n",
-      "1.170770422321e+01 1.53175 17.3205 1.53175 17.3205 13 5 13 5 0.02 8.42148e-05\n",
-      "5.075844624794e+00 2.12303 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.766606588165e+00 2.20484 50.9713 0 0.1 14 8 15 15 0.02 3.79411e-05\n",
-      "4.768305081494e+00 2.18838 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.458869865939e+00 2.29864 50.9713 0 12.8178 14 8 15 15 0.02 0.000150087\n",
-      "1.806014211040e+01 2.10446 50.9713 1.40749 12.8178 13 13 13 5 0.02 2.9863e-05\n",
-      "4.797342083485e+00 2.10328 50.9713 0 12.8178 13 13 15 1 0.02 4.24954e-05\n",
-      "1.721374713429e+01 2.21673 50.9713 1.42212 12.8178 14 14 13 5 0.02 2.41295e-05\n",
-      "4.055645404546e+00 2.47276 50.9713 0 25.5357 14 7 15 15 0.02 0.000150087\n",
-      "1.806123543037e+01 2.21893 50.9713 1.40745 12.8178 14 14 13 5 0.02 2.07011e-05\n",
-      "8.117519147635e+00 2.10433 50.9713 2.21473 25.5357 13 13 14 8 0.02 4.24954e-05\n",
-      "8.315554923168e+00 2.15343 50.9713 2.08519 25.5357 13 13 13 8 0.02 2.9863e-05\n",
-      "7.917420996633e+00 2.21892 50.9713 1.7431 25.5357 14 14 13 8 0.02 2.07011e-05\n",
-      "7.693213405973e+00 2.21805 50.9713 1.78384 25.5357 14 14 13 8 0.02 2.41295e-05\n",
-      "3.753837732894e+00 2.62517 50.9713 0 38.2535 14 7 15 15 0.02 0.000150087\n",
-      "7.087296558990e+00 2.10417 50.9713 2.40935 38.2535 13 13 14 8 0.02 4.24954e-05\n",
-      "7.007109286263e+00 2.15854 50.9713 2.28672 38.2535 13 13 14 8 0.02 2.9863e-05\n",
-      "5.653200958306e+00 2.21878 50.9713 2.0587 38.2535 14 14 13 8 0.02 2.41295e-05\n",
-      "5.733794947644e+00 2.21892 50.9713 1.99255 38.2535 14 14 13 8 0.02 2.07011e-05\n",
-      "3.513216011269e+00 2.76647 50.9713 0 50.9713 14 7 15 15 0.02 0.000150087\n",
-      "4.750574783854e+00 2.27442 50.9713 0 50.9713 14 8 15 15 0.02 4.24954e-05\n",
-      "7.278384712062e+00 1.29678 50.9713 2.09216 50.9713 13 8 13 13 0.02 2.9863e-05\n",
-      "4.765996194699e+00 2.20787 50.9713 2.20787 50.9713 14 8 14 8 0.02 2.07011e-05\n",
-      "4.765535914728e+00 2.21331 50.9713 2.21331 50.9713 14 8 14 8 0.02 2.41295e-05\n",
-      "3.104706358826e+00 3.17639 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.069363482023e+00 3.27572 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.047074050271e+00 3.3836 150 0 37.575 14 7 15 15 0.02 3.68933e-05\n",
-      "5.974759306305e+00 3.23604 150 2.53922 37.575 14 14 14 7 0.02 1.04459e-05\n",
-      "6.074084349384e+00 3.30145 150 2.13876 37.575 14 14 13 8 0.02 7.34071e-06\n",
-      "5.733865371895e+00 3.29994 150 2.00498 37.575 14 14 13 8 0.02 5.93135e-06\n",
-      "3.027099358410e+00 3.53631 150 0 75.05 14 7 15 15 0.02 3.68933e-05\n",
-      "5.807147339697e+00 3.30197 150 1.9791 37.575 14 14 13 8 0.02 5.08861e-06\n",
-      "4.862942347290e+00 3.25294 150 2.97823 75.05 14 14 14 7 0.02 1.04459e-05\n",
-      "4.556479830908e+00 3.29942 150 2.73221 75.05 14 14 14 7 0.02 7.34071e-06\n",
-      "3.853070305680e+00 3.29977 150 2.62486 75.05 14 14 14 7 0.02 5.93135e-06\n",
-      "3.881529045940e+00 3.30149 150 2.55924 75.05 14 14 14 7 0.02 5.08861e-06\n",
-      "3.015033359333e+00 3.64419 150 0 112.525 14 7 15 15 0.02 3.68933e-05\n",
-      "4.126828648362e+00 3.32047 150 0 112.525 14 14 15 3 0.02 1.04459e-05\n",
-      "3.990017992944e+00 3.3032 150 2.94027 112.525 14 14 14 7 0.02 7.34071e-06\n",
-      "3.206771867883e+00 3.07671 150 3.11282 112.525 14 14 14 7 0.02 5.93135e-06\n",
-      "3.006827156705e+00 3.72638 150 0 150 14 7 15 15 0.02 3.68933e-05\n",
-      "3.218786094847e+00 3.30337 150 3.01344 112.525 14 14 14 7 0.02 5.08861e-06\n",
-      "4.527722847382e+00 1.42238 150 0 150 13 5 15 15 0.02 1.04459e-05\n",
-      "3.069567332611e+00 3.27804 150 3.27804 150 14 7 14 7 0.02 5.93135e-06\n",
-      "5.726405299909e+00 1.29746 150 3.22759 150 13 8 14 14 0.02 7.34071e-06\n",
-      "3.069626478211e+00 3.27565 150 3.27565 150 14 7 14 7 0.02 5.08861e-06\n",
+      "1.219029061236e+01 1.60007 17.3205 0 2.97008 13 5 15 15 0.02 0.000498487\n",
+      "1.935920346899e+01 1.29448 17.3205 0 8.71025 13 13 15 2 0.02 0.000498487\n",
+      "2.123795595728e+01 1.30902 17.3205 1.58519 8.71025 13 13 13 5 0.02 0.000287968\n",
+      "3.579099761269e+01 1.52414 17.3205 1.30642 8.71025 13 13 13 5 0.02 0.000220016\n",
+      "1.674063083432e+01 1.29457 17.3205 0 14.4504 13 13 15 2 0.02 0.000498487\n",
+      "1.779197348711e+01 1.3228 17.3205 1.71196 14.4504 13 13 13 8 0.02 0.000287968\n",
+      "1.548740826516e+01 1.52415 17.3205 1.45407 14.4504 13 13 13 5 0.02 0.000220016\n",
+      "1.772169325356e+01 1.81957 73.0434 1.46573 12.2572 13 13 13 5 0.02 4.43422e-05\n",
+      "1.367065500196e+01 1.66003 73.0434 1.79487 12.2572 13 13 13 8 0.02 7.67586e-05\n",
+      "2.021960493499e+01 1.82061 73.0434 1.39205 12.2572 13 13 13 5 0.02 3.38788e-05\n",
+      "9.012246630357e+00 1.81529 73.0434 0 36.5717 13 8 15 15 0.02 7.67586e-05\n",
+      "7.462779538274e+00 1.82255 73.0434 1.81499 36.5717 13 13 13 8 0.02 3.38788e-05\n",
+      "1.030499912298e+01 1.80592 73.0434 1.81066 36.5717 13 13 13 8 0.02 4.43422e-05\n",
+      "4.227002356107e+00 2.43719 73.0434 0 60.8862 14 14 15 1 0.02 7.67586e-05\n",
+      "7.396288708628e+00 1.8216 73.0434 1.8216 60.8862 13 8 13 8 0.02 3.38788e-05\n",
+      "7.394728392218e+00 1.80919 73.0434 1.79091 60.8862 13 13 13 8 0.02 4.43422e-05\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -1067,10 +991,11 @@
     "    \n",
     "    # grid_options\n",
     "    amt_cores=2,  # grid_options\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -1168,14 +1093,14 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -1184,7 +1109,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1198,7 +1123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/build/html/objects.inv b/docs/build/html/objects.inv
index 8ac1e328102c8f00b236d77c3d126f5b16f1b475..8708d9045129d5de91f91d108c5287531956a6c4 100644
Binary files a/docs/build/html/objects.inv and b/docs/build/html/objects.inv differ
diff --git a/docs/build/html/plot_functions.html b/docs/build/html/plot_functions.html
index 119716b2cf74847f37c7544a4a48cc0430bc41f0..77f66e48c2062fb51262e6b7e28a04e939d7d275 100644
--- a/docs/build/html/plot_functions.html
+++ b/docs/build/html/plot_functions.html
@@ -473,9 +473,9 @@ This is not included in all the plotting routines.</p></li>
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/py-modindex.html b/docs/build/html/py-modindex.html
index cafb1a78624c8c019ed90550f9c2bc0b9a18f918..a99ee8e380d7d79364682d8176112e725ebc94ed 100644
--- a/docs/build/html/py-modindex.html
+++ b/docs/build/html/py-modindex.html
@@ -255,9 +255,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/readme_link.html b/docs/build/html/readme_link.html
index 27d15ae843e9e2f086f0c09aaf359f8e194550cc..e6b51483f7d2c4aaad3ade4e50b88cbb9f15597f 100644
--- a/docs/build/html/readme_link.html
+++ b/docs/build/html/readme_link.html
@@ -252,12 +252,13 @@
 <p>For this it is best to set up a virtual environment. Activate the virtualenvironment and enter the cloned version of the repo.</p>
 <p>Then run:</p>
 <div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
+<span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">uninstall</span> <span class="n">binarycpython</span> <span class="o">&amp;&amp;</span> <span class="n">rm</span> <span class="n">dist</span><span class="o">/*</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
 </pre></div>
 </div>
-<p>You can find the version of this package in setup.py.</p>
+<p>This will clean the build directory, remove binarycpython from the venv, remove the dist packages, and then rebuilding and reinstalling the package. You can find the version of this package in setup.py.</p>
 <p>This will install this package into the virtual environment. Making changes to the sourcecode can be “installed” into the virtual env with the same command.</p>
 <p>If this is not the first time you install the package, but rather rebuild it because you make changes in either binary_c or binarycpython, you should ignore the currently installed version, and also skip installing the dependencies again, by executing the following command:</p>
-<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">--</span><span class="n">ignore</span><span class="o">-</span><span class="n">installed</span> <span class="o">--</span><span class="n">no</span><span class="o">-</span><span class="n">dependencies</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
+<div class="highlight-default notranslate"><div class="highlight"><pre><span></span><span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">clean</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">uninstall</span> <span class="n">binarycpython</span> <span class="o">&amp;&amp;</span> <span class="n">rm</span> <span class="n">dist</span><span class="o">/*</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">build</span> <span class="o">--</span><span class="n">force</span> <span class="o">&amp;&amp;</span> <span class="n">python</span> <span class="n">setup</span><span class="o">.</span><span class="n">py</span> <span class="n">sdist</span> <span class="o">&amp;&amp;</span> <span class="n">pip</span> <span class="n">install</span> <span class="o">--</span><span class="n">ignore</span><span class="o">-</span><span class="n">installed</span> <span class="o">--</span><span class="n">no</span><span class="o">-</span><span class="n">dependencies</span> <span class="o">-</span><span class="n">v</span> <span class="n">dist</span><span class="o">/</span><span class="n">binarycpython</span><span class="o">-&lt;</span><span class="n">version</span> <span class="n">of</span> <span class="n">this</span> <span class="n">package</span><span class="o">&gt;.</span><span class="n">tar</span><span class="o">.</span><span class="n">gz</span>
 </pre></div>
 </div>
 <div class="section" id="after-installation">
@@ -334,9 +335,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/run_system_wrapper.html b/docs/build/html/run_system_wrapper.html
index 98017ad46588089035d4888e94feb4dcb8a35540..02408d8e7a9620f8f624644c5262ded959c80737 100644
--- a/docs/build/html/run_system_wrapper.html
+++ b/docs/build/html/run_system_wrapper.html
@@ -283,9 +283,9 @@ and returns what the parse_function returns</p>
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/search.html b/docs/build/html/search.html
index c131aef39e756d8d23fb95b6292fa5bcaf6278dd..dd2aa26a4a6db931bbcf3e308abbd96c860929cc 100644
--- a/docs/build/html/search.html
+++ b/docs/build/html/search.html
@@ -194,9 +194,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/searchindex.js b/docs/build/html/searchindex.js
index 4d686578bbc3eaf4cf907a9b5ba1fbbf375a5f77..3a63d864a3ae9c77cda703553a6550005b5daf4c 100644
--- a/docs/build/html/searchindex.js
+++ b/docs/build/html/searchindex.js
@@ -1 +1 @@
-Search.setIndex({docnames:["binary_c_parameters","custom_logging_functions","distribution_functions","example_notebooks","functions","grid","grid_options_defaults","grid_options_descriptions","hpc_functions","index","modules","notebook_api_functionality","notebook_custom_logging","notebook_extra_features","notebook_individual_systems","notebook_population","plot_functions","readme_link","run_system_wrapper","spacing_functions","stellar_types","useful_funcs"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":1,"sphinx.ext.todo":2,"sphinx.ext.viewcode":1,nbsphinx:3,sphinx:56},filenames:["binary_c_parameters.rst","custom_logging_functions.rst","distribution_functions.rst","example_notebooks.rst","functions.rst","grid.rst","grid_options_defaults.rst","grid_options_descriptions.rst","hpc_functions.rst","index.rst","modules.rst","notebook_api_functionality.ipynb","notebook_custom_logging.ipynb","notebook_extra_features.ipynb","notebook_individual_systems.ipynb","notebook_population.ipynb","plot_functions.rst","readme_link.rst","run_system_wrapper.rst","spacing_functions.rst","stellar_types.rst","useful_funcs.rst"],objects:{"binarycpython.utils":{custom_logging_functions:[1,0,0,"-"],distribution_functions:[2,0,0,"-"],functions:[4,0,0,"-"],grid:[5,0,0,"-"],grid_options_defaults:[6,0,0,"-"],hpc_functions:[8,0,0,"-"],plot_functions:[16,0,0,"-"],run_system_wrapper:[18,0,0,"-"],spacing_functions:[19,0,0,"-"],stellar_types:[20,0,0,"-"],useful_funcs:[21,0,0,"-"]},"binarycpython.utils.custom_logging_functions":{autogen_C_logging_code:[1,1,1,""],binary_c_log_code:[1,1,1,""],binary_c_write_log_code:[1,1,1,""],compile_shared_lib:[1,1,1,""],create_and_load_logging_function:[1,1,1,""],from_binary_c_config:[1,1,1,""],return_compilation_dict:[1,1,1,""]},"binarycpython.utils.distribution_functions":{"const":[2,1,1,""],Arenou2010_binary_fraction:[2,1,1,""],Izzard2012_period_distribution:[2,1,1,""],Kroupa2001:[2,1,1,""],Moe_di_Stefano_2017_multiplicity_fractions:[2,1,1,""],Moe_di_Stefano_2017_pdf:[2,1,1,""],build_q_table:[2,1,1,""],calc_P_integral:[2,1,1,""],calc_e_integral:[2,1,1,""],calc_total_probdens:[2,1,1,""],calculate_constants_three_part_powerlaw:[2,1,1,""],cosmic_SFH_madau_dickinson2014:[2,1,1,""],duquennoy1991:[2,1,1,""],fill_data:[2,1,1,""],flat:[2,1,1,""],flatsections:[2,1,1,""],gaussian:[2,1,1,""],gaussian_func:[2,1,1,""],gaussian_normalizing_const:[2,1,1,""],get_integration_constant_q:[2,1,1,""],get_max_multiplicity:[2,1,1,""],imf_chabrier2003:[2,1,1,""],imf_scalo1986:[2,1,1,""],imf_scalo1998:[2,1,1,""],imf_tinsley1980:[2,1,1,""],interpolate_in_mass_izzard2012:[2,1,1,""],ktg93:[2,1,1,""],linear_extrapolation_q:[2,1,1,""],merge_multiplicities:[2,1,1,""],normalize_dict:[2,1,1,""],number:[2,1,1,""],poisson:[2,1,1,""],powerlaw:[2,1,1,""],powerlaw_constant:[2,1,1,""],powerlaw_extrapolation_q:[2,1,1,""],prepare_dict:[2,1,1,""],raghavan2010_binary_fraction:[2,1,1,""],sana12:[2,1,1,""],set_opts:[2,1,1,""],three_part_powerlaw:[2,1,1,""]},"binarycpython.utils.functions":{BinaryCEncoder:[4,2,1,""],Capturing:[4,2,1,""],binarycDecoder:[4,2,1,""],binaryc_json_serializer:[4,1,1,""],call_binary_c_config:[4,1,1,""],catchtime:[4,2,1,""],convert_bytes:[4,1,1,""],count_keys_recursive:[4,1,1,""],create_arg_string:[4,1,1,""],create_hdf5:[4,1,1,""],custom_sort_dict:[4,1,1,""],example_parse_output:[4,1,1,""],extract_ensemble_json_from_string:[4,1,1,""],filter_arg_dict:[4,1,1,""],format_ensemble_results:[4,1,1,""],get_arg_keys:[4,1,1,""],get_defaults:[4,1,1,""],get_help:[4,1,1,""],get_help_all:[4,1,1,""],get_help_super:[4,1,1,""],get_moe_di_stefano_dataset:[4,1,1,""],get_size:[4,1,1,""],handle_ensemble_string_to_json:[4,1,1,""],imports:[4,1,1,""],inspect_dict:[4,1,1,""],is_capsule:[4,1,1,""],load_logfile:[4,1,1,""],make_build_text:[4,1,1,""],merge_dicts:[4,1,1,""],multiply_values_dict:[4,1,1,""],output_lines:[4,1,1,""],parse_binary_c_version_info:[4,1,1,""],recursive_change_key_to_float:[4,1,1,""],recursive_change_key_to_string:[4,1,1,""],remove_file:[4,1,1,""],return_binary_c_version_info:[4,1,1,""],subtract_dicts:[4,1,1,""],temp_dir:[4,1,1,""],update_dicts:[4,1,1,""],verbose_print:[4,1,1,""],write_binary_c_parameter_descriptions_to_rst_file:[4,1,1,""]},"binarycpython.utils.functions.BinaryCEncoder":{"default":[4,3,1,""]},"binarycpython.utils.functions.Capturing":{__enter__:[4,3,1,""],__exit__:[4,3,1,""]},"binarycpython.utils.functions.binarycDecoder":{decode:[4,3,1,""]},"binarycpython.utils.functions.catchtime":{__enter__:[4,3,1,""],__exit__:[4,3,1,""]},"binarycpython.utils.grid":{Population:[5,2,1,""]},"binarycpython.utils.grid.Population":{Moe_di_Stefano_2017:[5,3,1,""],add_grid_variable:[5,3,1,""],evolve:[5,3,1,""],evolve_single:[5,3,1,""],export_all_info:[5,3,1,""],parse_cmdline:[5,3,1,""],return_all_info:[5,3,1,""],return_binary_c_defaults:[5,3,1,""],return_binary_c_version_info:[5,3,1,""],return_population_settings:[5,3,1,""],set:[5,3,1,""],set_moe_di_stefano_settings:[5,3,1,""],write_binary_c_calls_to_file:[5,3,1,""]},"binarycpython.utils.grid_options_defaults":{grid_options_description_checker:[6,1,1,""],grid_options_help:[6,1,1,""],print_option_descriptions:[6,1,1,""],write_grid_options_to_rst_file:[6,1,1,""]},"binarycpython.utils.plot_functions":{color_by_index:[16,1,1,""],dummy:[16,1,1,""],parse_function_hr_diagram:[16,1,1,""],parse_function_masses:[16,1,1,""],parse_function_orbit:[16,1,1,""],plot_HR_diagram:[16,1,1,""],plot_masses:[16,1,1,""],plot_orbit:[16,1,1,""],plot_system:[16,1,1,""]},"binarycpython.utils.run_system_wrapper":{run_system:[18,1,1,""]},"binarycpython.utils.spacing_functions":{"const":[19,1,1,""]},"binarycpython.utils.useful_funcs":{calc_period_from_sep:[21,1,1,""],calc_sep_from_period:[21,1,1,""],maximum_mass_ratio_for_RLOF:[21,1,1,""],minimum_period_for_RLOF:[21,1,1,""],minimum_separation_for_RLOF:[21,1,1,""],ragb:[21,1,1,""],roche_lobe:[21,1,1,""],rzams:[21,1,1,""],zams_collision:[21,1,1,""]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:method"},terms:{"000":14,"0000":14,"000000000000e":14,"0001":[11,21],"000116989":15,"000121486":15,"000150087":15,"000154349":15,"000157195":15,"000172877":15,"000211219":15,"00028381":15,"000381347":15,"000512406":15,"000610573":15,"000627913":15,"000688507":15,"0007":2,"000925128":15,"001":[0,11],"00124307":15,"00167028":15,"00224431":15,"00498":15,"005444573822104362":15,"00632092":11,"006827156705e":15,"007109286263e":15,"0073157281034221516":15,"009829948023831718":15,"013208238029791246":15,"01344":15,"0141":11,"0144107":15,"015033359333e":15,"0154":15,"017435498578e":15,"027099358410e":15,"041660877905e":12,"041662558619e":12,"041662560111e":12,"041662564579e":12,"04459e":15,"047074050271e":15,"05150046619238191":15,"05150046619238192":15,"05193":15,"054":2,"055645404546e":15,"0587":15,"069363482023e":15,"069567332611e":15,"069626478211e":15,"069627290216e":15,"07011e":15,"074084349384e":15,"075844624794e":15,"07671":15,"0820":[0,11],"08519":15,"08624781646269201":15,"0862478164626921":15,"087296558990e":15,"08861e":15,"08873e":15,"08msun":[0,11],"0902":[0,11],"09216":15,"093caf0e9":0,"0x7f163859d0c0":11,"0x7f9265091598":[],"0x7fb4d41ebbf8":14,"0x7ff3bdf79620":15,"100":[0,2,11],"1000":[0,7],"10328":15,"10417":15,"10433":15,"10446":15,"104706358826e":15,"1048014407228":15,"1085":14,"108751340926e":15,"11003":14,"112":15,"11282":15,"115":2,"11582":14,"117519147635e":15,"119":15,"120000":0,"12303":15,"12325":14,"12457":14,"12460":14,"12461":14,"12462":[],"125":[0,11,15],"12500":0,"126828648362e":15,"12e":[1,12,14,15],"1300":[],"1301":14,"1302":14,"13461":14,"13462":[],"1357":12,"13876":15,"13e3":[0,11],"1403":2,"14057":12,"14059":12,"14461":14,"14462":[],"146421815741e":15,"150":15,"15000":[0,11,12,14,15],"1506841305680684":15,"15343":15,"1564":15,"15854":15,"15875":15,"15msun":2,"1612":[],"1613":[],"1614":[],"1615":[],"1616":[],"1617":14,"1618":14,"1619":14,"1620":14,"1621":14,"1628444120":15,"1628444121":15,"170425790780e":15,"170770422321e":15,"170770599495e":15,"170775828562e":15,"17089":14,"171086983243e":15,"171108213270e":15,"172196856333e":15,"17639":15,"18838":15,"18914e":15,"190":0,"19314":12,"194842917007e":15,"1951":[0,11],"1972":[0,11],"1975":[0,11],"197x":[0,11],"1980":2,"1983":21,"1986":[0,2,11],"1989":[0,11],"1991":2,"1992":0,"1993":[0,11],"1996":21,"1998":[0,2,11],"1999":[0,11],"1ckzg0p9":[9,17],"1e2":[0,11],"1e9":[0,11],"200":[0,11],"2000":[0,11],"2001":2,"2002":[0,11],"2003":[0,2,11],"2004":[0,11],"2005":[0,11],"2009":[0,11],"2010":[0,2,7,11],"2012":[0,2,11],"2013":[0,11],"2014":[0,2,11],"2015":[0,11],"2016":[0,11],"2017":[0,7,11,15],"2018":[0,1,11],"2019":[0,11],"2020":[0,11],"2021":0,"20210807":[],"20210825":0,"20484":15,"206771867883e":15,"20787":15,"21331":15,"21473":15,"21673":15,"2174":15,"21805":15,"21878":15,"218786094847e":15,"21892":15,"21893":15,"222715508467e":15,"22723621650191106":15,"22759":15,"230407246199e":15,"232906623449e":15,"234709":15,"23604":15,"2383":[],"2424":14,"24954e":15,"25294":15,"2535":15,"255":0,"257":21,"25msun":[0,11],"27442":15,"27563":15,"27565":15,"27572":15,"27804":15,"278384712062e":15,"281":21,"28672":15,"29402e":15,"29444":15,"294870923827e":15,"29678":15,"2969346":2,"29746":15,"2983275843337705":15,"29864":15,"29942":15,"29977":15,"29994":15,"2a7732d03e594ef4b5dfe9051b41d9c0":15,"2msun":[0,11],"3000":[0,11],"30145":15,"30149":15,"30197":15,"3032":15,"30337":15,"30504":15,"30e4":[0,11],"31004":15,"315554923168e":15,"3177":15,"32047":15,"3205":15,"32641e":15,"33062":15,"33079":15,"33524":12,"337250536639e":15,"34071e":15,"34281":15,"34903":15,"34922":15,"34937":15,"350021848285e":15,"35209":15,"3552":15,"364277535630e":15,"3678":15,"3680f3882c0a449c944462abffea2447":15,"36979":15,"36m":11,"38004":15,"38063":12,"3836":15,"38403":15,"38887e":15,"3933":15,"3msun":2,"4000":0,"4046":15,"40513":15,"40745":15,"40749":15,"40935":15,"41074":15,"41264":15,"41295e":15,"42148e":15,"42212":15,"42238":15,"42375":15,"42msun":[0,11],"43925":15,"439623364590e":15,"4424":15,"446":12,"449960890183e":15,"44msun":[0,11],"4500":11,"45000000080":15,"4530":[12,14],"458869865939e":15,"459153942631e":15,"45msun":[0,11],"4603":15,"47276":15,"47961":15,"47976e":15,"4838":14,"48488":15,"4e3":[0,11],"500":[0,11],"5102526289471614":15,"513216011269e":15,"517749":14,"518":14,"522806":[],"523":[],"525":15,"527722847382e":15,"52963":15,"53113":15,"53174":15,"53175":15,"53176":15,"53177":15,"53183":15,"53184":15,"5357":15,"53631":15,"53922":15,"546683":14,"556479830908e":15,"55924":15,"561265707015991":15,"56776":15,"5689":15,"571858031651e":15,"575":15,"577754":[],"59052":15,"59499":15,"5msun":[0,11],"6000":0,"600000":0,"60808":15,"6101":[],"61349":12,"6162":0,"6246354579925537":15,"62486":15,"625":0,"62517":15,"635":0,"64419":15,"65097":15,"653200958306e":15,"67365":[],"687368550125e":15,"68933e":15,"693213405973e":15,"6944":0,"6e1":2,"6e5":[0,11],"6msun":[0,11],"70319":15,"70668e":15,"71025":15,"71288":15,"716":14,"7197":15,"721374713429e":15,"723547465714e":15,"723570798020e":15,"72498e":[12,15],"72638":15,"726405299909e":15,"730":[12,15],"73221":15,"733614170983e":15,"733794947644e":15,"733865371895e":15,"7358":[11,12],"73856":15,"74037":12,"7431":15,"750574783854e":15,"753837732894e":15,"7619":0,"763":2,"764340254985e":15,"765535914728e":15,"765996194699e":15,"76647":15,"766606588165e":15,"768305081494e":15,"773581245005e":12,"774":[],"7797017097473145":15,"78096":15,"78125":0,"783":14,"78384":15,"79411e":15,"795":2,"797342083485e":15,"802132608769e":15,"80457":15,"806014211040e":15,"806123543037e":15,"807147339697e":15,"80msol":2,"81391":15,"8162e":15,"817":14,"8178":15,"81906":15,"82242e":15,"84162":15,"853070305680e":15,"85486":15,"862081089332e":15,"8628":15,"862942347290e":15,"863377990313e":15,"867655467480e":15,"878236827680e":12,"881529045940e":15,"88566":15,"8955":[],"917420996633e":15,"92267":12,"922967341481e":15,"931266944719e":15,"93135e":15,"933751523833e":15,"94027":15,"941017702765e":15,"9458":14,"9514":[],"9545065608702976":15,"9713":15,"97286e":15,"974759306305e":15,"97823":15,"9791":15,"980988739731e":15,"9863e":15,"990017992944e":15,"99198":12,"99255":15,"99283":15,"9947":14,"99471":15,"9983":14,"boolean":[0,4,5,7,11,16,21],"break":[0,11],"case":[0,4,7,11,15],"catch":[4,7,14,15],"char":7,"class":[4,5],"const":[2,5,15,19],"default":[0,1,2,4,5,6,7,11,12,13,15,18],"export":[4,5,15],"float":[0,2,4,11,13,14,19,21],"function":[0,1,2,3,5,6,7,8,9,10,12,16,17,18,19,21],"import":[4,5,11,12,13,14,15],"int":[0,1,2,4,5,6,7,11,15,19,21],"krtickov\u00e1":0,"kub\u00e1t":0,"long":[0,4,5,7,11,15,20],"new":[0,2,4,5,11,14,15],"null":[0,4,11,12,13],"paczy\u0144ski":[0,11],"public":[6,9,15],"return":[1,2,4,5,6,7,11,13,14,15,16,18,19,21],"short":[0,11,20],"super":[0,11],"switch":[0,11],"throw":[9,17],"true":[0,4,5,6,7,11,13,15,16],"try":[0,9,11,14,15,17],"void":12,"while":[0,11],Added:15,Adding:[3,14],And:[6,9,17,21],But:14,Doing:15,For:[0,4,9,11,12,14,16,17],Gas:[0,11],Its:7,NOT:[0,11,18],Not:7,One:[0,11],Pms:16,That:[0,11],The:[0,1,2,3,4,5,7,9,11,12,13,14,15,16,17,18],Then:[4,9,17],There:[2,5,6,7,11,12,13,14,15,16],These:[4,7,11,15,16],Use:[0,5,11,15],Used:[0,7,11,16],Useful:[0,5,6,11,15],Uses:[0,11,19],Using:[3,9],Was:[0,11],Will:[0,4,5,11,15,18],With:6,__arg_begin:11,__attribute__:12,__enter__:4,__exit__:4,_actually_evolve_system:7,_binary_c_bind:[4,11,12,14,21],_binary_c_config_execut:7,_binary_c_dir:7,_binary_c_execut:7,_binary_c_shared_librari:7,_calculate_multiplicity_fract:15,_commandline_input:7,_count:7,_custom_logging_shared_library_fil:7,_end_time_evolut:7,_errors_exceed:7,_errors_found:7,_evolution_type_opt:7,_failed_count:7,_failed_prob:7,_failed_systems_error_cod:7,_generate_grid_cod:7,_grid_vari:7,_loaded_ms_data:7,_main_pid:7,_population_id:7,_probtot:7,_process_run_population_grid:7,_repeat:7,_set:5,_set_ms_grid:7,_start_time_evolut:7,_store_memaddr:7,_system_gener:7,_total_mass_run:7,_total_probability_weighted_mass_run:7,_total_starcount:7,_zero_prob_stars_skip:7,a173:0,abat:[0,11],abbrevi:20,abl:11,about:[3,4,5,6,15,21],abov:[0,2,4,5,11,12,14,15],abridg:[11,12],absolut:[0,11],abund:[0,11],acceler:[0,11],accept:[4,11,15],access:[2,7,12,14,15],accord:[0,2,11],accordingli:[14,15],account:[0,7,11],accret:[0,11],accretion_limit_dynamical_multipli:[0,11],accretion_limit_eddington_lmms_multipli:[0,11],accretion_limit_eddington_steady_multipli:[0,11],accretion_limit_eddington_wd_to_remnant_multipli:[0,11],accretion_limit_thermal_multipli:[0,11],accretor:[0,11,21],act:[0,7,11,15],activ:[0,9,11,17],actual:[0,4,5,7,9,11,12,14,15,16,17],adam:[0,11],adapt:[0,11],add:[0,2,4,5,7,12,14,15,16,19,21],add_grid_vari:[5,15],added:[4,14],adding:[14,15],address:[1,7,11,12,21],admittedli:16,adress:[11,12,21],advis:12,affect:[0,11],after:[0,5,7,11,12,15],ag89:[0,11],again:[4,7,9,13,14,17],against:16,agb:[0,11],agb_3dup_algorithm:[0,11],agb_core_algorithm:[0,11],agb_core_algorithm_default:0,agb_core_algorithm_hurlei:0,agb_core_algorithm_karaka:0,agb_luminosity_algorithm:[0,11],agb_luminosity_algorithm_default:0,agb_luminosity_algorithm_hurlei:0,agb_luminosity_algorithm_karaka:0,agb_radius_algorithm:[0,11],agb_radius_algorithm_default:0,agb_radius_algorithm_hurlei:0,agb_radius_algorithm_karaka:0,agb_third_dredge_up_algorithm_default:0,agb_third_dredge_up_algorithm_hurlei:0,agb_third_dredge_up_algorithm_karaka:0,agb_third_dredge_up_algorithm_stancliff:0,age:[0,11],aging:[0,11],albedo:[0,11],algorithm:[9,11],algothim:[0,11],all:[0,1,2,4,5,6,7,9,10,11,13,14,15,16,17,18],all_info:5,alloc:11,allow:[0,2,4,7,11,12],allow_nan:4,along:[0,6,7],alpha:[0,11],alpha_c:[0,11],alphacb:[0,11],alreadi:[5,15],also:[0,3,4,5,6,9,11,12,15,17,21],altern:[0,7,11],alwai:[0,2,7,11],amanda:[0,11],amax:2,amin:2,amount:[0,4,5,6,7,11,15,19],amp:11,amt_cor:[7,15],analys:18,analyt:[5,15],analyz:14,andrew:[9,17],andronov:[0,11],angelou_lithium_cheb_decay_tim:[0,11],angelou_lithium_cheb_massfrac:[0,11],angelou_lithium_cheb_tim:[0,11],angelou_lithium_decay_funct:[0,11],angelou_lithium_decay_tim:[0,11],angelou_lithium_eagb_decay_tim:[0,11],angelou_lithium_eagb_massfrac:[0,11],angelou_lithium_eagb_tim:[0,11],angelou_lithium_gb_decay_tim:[0,11],angelou_lithium_gb_massfrac:[0,11],angelou_lithium_gb_tim:[0,11],angelou_lithium_hg_decay_tim:[0,11],angelou_lithium_hg_massfrac:[0,11],angelou_lithium_hg_tim:[0,11],angelou_lithium_lmms_decay_tim:[0,11],angelou_lithium_lmms_massfrac:[0,11],angelou_lithium_lmms_tim:[0,11],angelou_lithium_ms_decay_tim:[0,11],angelou_lithium_ms_massfrac:[0,11],angelou_lithium_ms_tim:[0,11],angelou_lithium_tpagb_decay_tim:[0,11],angelou_lithium_tpagb_massfrac:[0,11],angelou_lithium_tpagb_tim:[0,11],angelou_lithium_vrot_trigg:[0,11],angelou_lithium_vrotfrac_trigg:[0,11],angular:[0,11,16],ani:[0,2,4,5,9,11,14,15,17],anoth:[0,11],ansi:[0,11],ansi_colour:0,anyth:[0,7,11,15],anywai:[5,14,15],anywher:[5,15],api:[0,3,4,9],api_log_filename_prefix:[0,11,14],append:[1,4,14],appli:[0,11],apply_darwin_radau_correct:0,appropri:[0,7,11],approxim:[0,11],aren:[2,7],arenou2010_binary_fract:2,arg:[2,4,11,13,15,16],arg_dict:4,argopt:[0,11],argpair:[4,13],argstr:[11,12,14],argument:[0,2,4,5,7,11,14,15,18],argument_of_periastron:[0,11],argument_of_periastron_quadrupl:[0,11],argument_of_periastron_tripl:[0,11],around:[0,11,12,14],arrai:[2,4,7,14],arrow:0,artifici:[0,11],artificial_accretion_end_tim:[0,11],artificial_accretion_ignor:0,artificial_accretion_start_tim:[0,11],artificial_angular_momentum_accretion_r:[0,11],artificial_mass_accretion_r:[0,11],artificial_orbital_angular_momentum_accretion_r:[0,11],arxiv:[0,2,11],ask:[0,11,21],asplund:[0,11],assign:[5,15],assum:[0,11,16],ast871:[0,11],astronomi:[0,11],astropi:[9,16,17],atom:4,attempt:[4,5],aug:0,auto:[1,10],autogen_c_logging_cod:[1,12],automat:[0,1,6,9,11,12,17],avaibl:[9,17],avail:[0,4,7,11,12,15,16],avoid:11,awai:[0,11],axi:[0,11,16],b_1:[0,11],b_2:[0,11],b_3:[0,11],b_4:[0,11],b_inclination1:[0,11],b_inclination2:[0,11],b_inclination3:[0,11],b_inclination4:[0,11],back:[0,4,11],backward:[0,11],bagb:[0,11],barn:[0,11],base:[0,2,4,5,9,11,15,16,17,21],base_filenam:[5,15],basic:[5,15],batchmod:[0,11],beasor:[0,11],becaus:[0,2,5,7,9,11,14,17],becom:[0,1,2,4,11,12],been:[0,5,7,11,13],befor:[0,5,7,9,11,15,17],behaviour:[4,15,18],belczynski:[0,11],below:[0,3,7,11,12,15],berro:[0,11],bertolami:[0,11],best:[5,7,9,17],beta:[0,11],beta_reverse_nova:[0,11],beta_reverse_novae_geometri:0,better:[0,4,5,11,15],between:[0,2,11,19],bewar:[5,15],bh_belczynski:0,bh_fryer12_delai:0,bh_fryer12_rapid:0,bh_fryer12_startrack:0,bh_hurley2002:0,bh_prescript:[0,11],bh_spera2015:0,big:[0,7,11],biinari:15,bin:[0,9,11,17],binari:[2,5,7,9,11,14,15,16,17,21],binary_c2:[9,17],binary_c:[1,2,3,4,5,7,12,14,15,16,18],binary_c_api_funct:12,binary_c_cal:[5,15],binary_c_default:15,binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0:15,binary_c_inline_config:1,binary_c_log_cod:[1,12,14],binary_c_macro:[0,11],binary_c_output:4,binary_c_paramet:[0,11,15],binary_c_python:[4,5,11,14,15],binary_c_task_:[0,11],binary_c_write_log_cod:1,binary_grid:[0,11],binary_star:21,binaryc:[1,4,13,18],binaryc_config:1,binaryc_json_seri:4,binarycdecod:4,binarycencod:4,binarycpython3:11,binarycpython:[1,2,3,4,5,6,9,16,17,18,19,21],binarygrid:15,bind:[0,11,12,14],birth:[0,11],bit:2,bivari:[0,11],black:[0,11],black_hol:0,bloecker:[0,11],blog:1,boltzman:16,boltzmann:[0,11],bondi:[0,11],bondi_hoyle_accretion_factor:[0,11],bool:[4,5,6,13,15,16],born:[0,11],bosswissam:4,both:[0,4,11,15],bottom:[0,11,15],bound:[2,19],boundari:2,brake:[0,11],branch:[0,4,11],branch_david:0,branchpoint:[5,15],breakup:[0,11],broken:[0,11],bse:[0,2,11,12,15],bse_opt:[5,14,15],bsf:[0,11],buffer:[0,11],build:[0,1,3,4,11],build_q_tabl:2,built:[0,1,4,9,13,17],burn:[0,11],busso:[0,11],bye:[0,11],c13_eff:[0,11],c5232be5c:[],c_auto_log:7,c_log:0,c_logging_cod:[7,12,14,15],calc_e_integr:2,calc_p_integr:2,calc_period_from_sep:21,calc_sep_from_period:[15,21],calc_total_probden:2,calcul:[0,2,4,5,7,11,15,21],calculate_constants_three_part_powerlaw:2,call:[0,1,4,5,7,11,13,14,15,16,18],call_binary_c_config:4,calls_filenam:15,can:[0,1,2,4,5,7,9,11,12,13,14,15,16,17,18],cannot:[5,12],canon:7,cap:[0,11],capsul:[1,4,11],captur:[0,4,11],carbon:[0,11],carbon_oxygen_white_dwarf:0,carlo:[0,7,11],carrasco:[0,11],carri:[0,11],cast:[4,13],catchtim:4,categor:11,categori:[11,15],categoris:4,caught:[4,14],caus:21,cbdisc:[0,11],cbdisc_albedo:[0,11],cbdisc_alpha:[0,11],cbdisc_eccentricity_pumping_dermin:0,cbdisc_eccentricity_pumping_method:[0,11],cbdisc_eccentricity_pumping_non:0,cbdisc_end_evolution_after_disc:[0,11],cbdisc_fail_ring_inside_separ:[0,11],cbdisc_gamma:[0,11],cbdisc_init_djdm:[0,11],cbdisc_init_dm:[0,11],cbdisc_inner_edge_strip:[0,11],cbdisc_inner_edge_stripping_timescal:[0,11],cbdisc_kappa:[0,11],cbdisc_mass_loss_constant_r:[0,11],cbdisc_mass_loss_fuv_multipli:[0,11],cbdisc_mass_loss_inner_l2_cross_multipli:[0,11],cbdisc_mass_loss_inner_viscous_accretion_method:[0,11],cbdisc_mass_loss_inner_viscous_accretion_method_equ:0,cbdisc_mass_loss_inner_viscous_accretion_method_gerosa_2015:0,cbdisc_mass_loss_inner_viscous_accretion_method_non:0,cbdisc_mass_loss_inner_viscous_accretion_method_young_clarke_2015:0,cbdisc_mass_loss_inner_viscous_angular_momentum_multipli:[0,11],cbdisc_mass_loss_inner_viscous_multipli:[0,11],cbdisc_mass_loss_ism_pressur:[0,11],cbdisc_mass_loss_ism_ram_pressure_multipli:[0,11],cbdisc_mass_loss_xray_multipli:[0,11],cbdisc_max_lifetim:[0,11],cbdisc_minimum_evaporation_timescal:[0,11],cbdisc_minimum_fr:[0,11],cbdisc_minimum_luminos:[0,11],cbdisc_minimum_mass:[0,11],cbdisc_no_wind_if_cbdisc:[0,11],cbdisc_outer_edge_strip:[0,11],cbdisc_outer_edge_stripping_timescal:[0,11],cbdisc_resonance_damp:[0,11],cbdisc_resonance_multipli:[0,11],cbdisc_torquef:[0,11],cbdisc_viscous_l2_coupl:[0,11],cbdisc_viscous_photoevaporative_coupl:[0,11],cbdisc_viscous_photoevaporative_coupling_inst:[0,11],cbdisc_viscous_photoevaporative_coupling_non:[0,11],cbdisc_viscous_photoevaporative_coupling_visc:[0,11],cee:[0,11],cell:[11,15],cemp:[0,11],cemp_cfe_minimum:[0,11],center:15,centr:5,central_object:[0,11],certain:[7,9,17],cf_amanda_log:[0,11],cflag:[9,17],chabrier:2,chandrasekhar:[0,11],chandrasekhar_mass:[0,11],chang:[0,1,2,4,5,6,7,9,11,12,15,17],chapter:[0,7,10],cheb:[0,11],check:[0,2,4,5,6,11,15,21],check_circular:4,chemic:[0,11],chen:[0,11],child:4,choic:[0,2,11,16],choos:[0,11,12,16],chose:14,chosen:[5,15],circular:[0,11],circumbinari:[0,11],circumstanti:[0,11],claei:[0,11],clark:[0,11],clean:[1,5,9,14,17],clean_up_custom_logging_fil:5,clear:4,clock:4,clone:[9,17],close:[0,11],cloud:[0,11],cls:4,cluster:8,cmdline:5,code:[0,1,5,6,9,11,12,14,15,16,17,18],collaps:[0,11],collapsar:[0,11],collect:21,collid:21,color:16,color_by_index:16,colour:[0,11],colour_log:[0,11],column:[14,15,16],column_nam:14,com:[1,4],combin:[1,4,5,7,12],combine_ensemble_with_thread_join:7,come:[2,9,17,19],comenv_bs:0,comenv_disc_angmom_fract:[0,11],comenv_disc_mass_fract:[0,11],comenv_ejection_spin_method:[0,11],comenv_ejection_spin_method_do_noth:[0,11],comenv_ejection_spin_method_sychron:[0,11],comenv_ejection_spin_method_synchron:0,comenv_merger_spin_method:[0,11],comenv_merger_spin_method_breakup:0,comenv_merger_spin_method_conserve_angmom:[0,11],comenv_merger_spin_method_conserve_omega:[0,11],comenv_merger_spin_method_specif:[0,11],comenv_ms_accret:[0,11],comenv_ms_accretion_fract:[0,11],comenv_ms_accretion_mass:[0,11],comenv_nandez2016:0,comenv_nelemans_tout:0,comenv_ns_accret:[0,11],comenv_ns_accretion_fract:[0,11],comenv_ns_accretion_mass:[0,11],comenv_post_eccentr:[0,11],comenv_prescript:[0,11],comenv_splitmass:[0,11],comenv_undef:0,command:[0,1,5,7,9,11,15,17],commandlin:15,comment:15,commit:4,common:[0,11,12,14,15],compact:15,companion:[0,11],compar:[0,7,11,15],compil:[1,9,12,15,17],compile_shared_lib:1,complet:15,complex:[5,7,12,15,16],compon:[4,16],comput:[0,8,11],condit:[5,12,15],condor:[5,7,8],condor_grid:5,config:[1,4,7,9,17],config_fil:1,configur:[2,5,14,15],conjunct:13,conserv:[0,11],consid:[0,1,2,4,5,7,11,16],constant:[0,2,11,16],construct:[0,1,11,14,15],contain:[0,1,2,4,5,6,7,8,9,10,11,13,14,15,16,17,18,19,20],content:[3,4,9,11],context:4,continu:[5,15],control:[0,11,15],convect:[0,11],converg:[0,11],convert:[2,4,5],convert_byt:4,cool:[0,11],copi:[0,5,11,21],core:[0,5,7,11,15,16],core_co:12,core_h:12,core_helium_burn:0,core_mass:[0,11,12],correct:[0,2,5,14,16,21],correctli:[9,14,16,17],correspond:16,corretor:[0,11],cosmic:2,cosmic_sfh_madau_dickinson2014:2,could:[0,4,11,15],count:[4,7],count_keys_recurs:4,counter:7,coupl:[0,11],cours:16,cover:13,coverag:[9,17],cowd:[0,11],cpu:[0,11],cpython:11,crap_paramet:[0,11],creat:[2,4,5,12,14,15],create_and_load_logging_funct:[1,12],create_arg_str:4,create_hdf5:4,creation:11,critic:[0,11],cross:[0,11],ctype:1,cuntz:[0,11],current:[0,4,9,11,12,17],custom:[0,1,3,4,5,7,9,11,14,15,16,18],custom_log:[5,7,14],custom_logging_cod:[1,12,14,18],custom_logging_func_memaddr:[7,11,12],custom_logging_funct:[7,9,10,12,14,15],custom_logging_info:5,custom_logging_memaddr:12,custom_logging_print_stat:14,custom_logging_stat:15,custom_opt:[5,14,15],custom_output_funct:12,custom_sort_dict:4,custom_tmp_dir:1,customis:16,cvode:[0,11],d20a4c74d20a43b881c0c9e5def5f76c:15,dai:[0,2,11,12,14,15,21],damp:[0,11],darwin:0,dat:[0,4,15],data:[0,4,5,7,11,14,15,18],data_dict:2,data_dir:[4,5,7,15],datadir:[5,15],datafram:[14,16],dataset:[4,15],date:5,david:[0,9,11,17],david_logging_funct:[0,11],dd7:[0,11],deactiv:[0,11],deal:[4,14],death:[0,11],debug:[0,7,11,15],decai:[0,11],decid:[0,4,11,12],decod:4,decreas:[0,11],deeper:[5,15],def:[14,15],default_to_metal:[0,11],defaultdict:4,defer:[0,11],defin:[0,1,2,5,11,16],definit:[1,21],degener:[0,11],degre:[0,11],delai:0,delta_mcmin:[0,11],den:[0,11],densiti:2,depend:[0,2,9,11,16,17],deprec:[0,11],dermin:[0,11],describ:[0,2,7,11],descript:[0,2,4,7,9,10,11,13],design:[5,16],desir:[0,11],destruct:[5,15],detail:[0,4,11,14],detect:[0,11],determin:[0,5,11,12,15,21],deton:[0,11],dev:[0,11],develop:1,deviat:2,dewi:[0,11],dex:[0,11],diagnost:7,diagram:[0,11,16],dickonson:2,dict2:4,dict:[1,2,4,5,6,13,14,15,20],dict_1:4,dict_2:4,dict_kei:[13,14],dictionari:[1,2,3,4,5,6,7,15,16,20],did:[4,9,17],differ:[0,4,5,9,11,15,16,17],dimmer:[0,11],dir:[9,17],direct:[0,5,11],directli:[4,7,14],director:7,directori:[0,3,4,5,7,9,11,15,17],disabl:[0,11,15],disable_debug:[0,11],disable_end_log:[0,11],disable_ev:[0,11],disc:[0,11],disc_legacy_log:[0,11],disc_log2d:[0,11],disc_log:[0,11],disc_log_directori:[0,11],disc_log_dt:[0,11],disc_log_level_non:0,disc_log_level_norm:0,disc_log_level_normal_first_disc_onli:0,disc_log_level_subtimestep:0,disc_log_level_subtimestep_first_disc_onli:0,disc_n_monte_carlo_guess:[0,11],disc_stripping_timescale_infinit:0,disc_stripping_timescale_inst:0,disc_stripping_timescale_orbit:0,disc_stripping_timescale_visc:0,disc_timestep_factor:[0,11],discret:15,discs_circumbinary_from_comenv:[0,11],discs_circumbinary_from_wind:[0,11],disk:[0,5,11],dispers:[0,11],displai:[0,11],dist:[9,17],distefano:2,distribut:[0,2,5,8,11,15],distribution_funct:[9,10,15],divid:8,dlnm1:[5,15],dlog10per:15,dlogp:2,do_dry_run:7,doc:[4,6,9,15,17],doc_fetch:2,docstr:[9,14,16,17],document:[4,6,7,10,15],doe:[0,2,4,5,7,11,12,13,14,15,21],doesn:[5,7],doesnt:6,doing:[0,1,5,6,9,11,17],don:[2,4,7],done:[0,4,5,9,11,15,17],donor:[0,11,21],donor_limit_dynamical_multipli:[0,11],donor_limit_envelope_multipli:[0,11],donor_limit_thermal_multipli:[0,11],donor_rate_algorithm_bs:0,donor_rate_algorithm_claeys2014:0,dont:11,doubl:[12,15],down:15,dphasevol:[5,15],dr2:[0,11],dr3:[0,11],drai:[0,11],dredg:[0,11],drop:14,dry:7,dstep:2,dt_limit:13,dtfac:[0,11],dtlimit:4,dtm:[1,12,15],due:[9,17],dummi:[2,16],dump:[0,4,11,14],dumpvers:[0,11],duquennoi:2,duquennoy1991:2,dure:[0,11],dust:[0,11],dwarf:[0,11],dynam:[0,11],e2_hurley_2002:0,e2_izzard:0,e2_mint:0,e2_prescript:[0,11],each:[0,2,4,5,7,11,15],eagb:[0,11],eagb_wind_beasor_etal_2020:0,eagb_wind_bs:0,eagb_wind_goldman_etal_2017:0,eagbwind:[0,11],eagbwindfac:[0,11],earli:[0,11],early_asymptotic_giant_branch:0,easi:[4,14],easier:[4,15],ecc2:2,ecc3:2,ecc:[2,5,14,15],eccentr:[0,2,11,12,14,15,16,21],eccentric_rlof_model:[0,11],eccentricity_quadrupl:[0,11],eccentricity_tripl:[0,11],echo:[0,11],eddington:[0,11],edg:[0,5,11,15],edit:12,edu:[0,11],effect:[0,2,7,11,12],effective_metal:[0,11],effici:[0,11],egg:[9,17],eggleton:[0,11,21],either:[0,4,5,7,9,11,15,17,18],eject:[0,11],elabor:12,eld:[0,11],eldridg:[0,11],electon:[0,11],electron:[0,11],element:[0,1,4,7,11,13,16],els:12,email:4,emp:[0,11],emp_feh_maximum:[0,11],emp_logg_maximum:[0,11],emp_minimum_ag:[0,11],empti:[4,6,14],enabl:[0,11],encod:4,encount:7,end:[0,2,4,7,11],end_index:2,end_timestamp:15,energi:[0,11],enhanc:[0,11],enlarg:[0,11],enough:2,ensembl:[0,4,7,11,13],ensemble_def:[0,11],ensemble_dictionari:4,ensemble_dt:[0,11],ensemble_factor_in_probability_weighted_mass:7,ensemble_filter_:[0,11],ensemble_filters_off:[0,11],ensemble_json:4,ensemble_legacy_ensembl:[0,11],ensemble_list:5,ensemble_logdt:[0,11],ensemble_logtim:[0,11],ensemble_macro:[0,11],ensemble_output_:7,ensemble_startlogtim:[0,11],ensure_ascii:4,enter:[0,9,11,17],enthalpi:[0,11],entir:[12,14],entri:[4,5],env:[9,11,16,17],envelop:[0,11],equal:[0,4,15],equat:[0,11],equation_of_state_algorithm:[0,11],equation_of_state_paczynski:0,equatori:[0,11],equival:7,errno:[9,17],error:[0,4,7,9,11,15,17],errors_exceed:15,errors_found:15,esa:2,escap:[0,11],escape_fract:[0,11],escape_veloc:[0,11],eta:[0,11],etal:[0,11],etc:[0,4,5,8,9,11,14,15,16,17,18],euler:[0,11],evalu:[2,5,15,21],evan:[0,11],evapor:[0,11],evaporate_escaped_orbiting_object:[0,11],even:13,event:[0,11],everi:[0,9,11,17],everyth:[5,7,14,15],everytim:[9,17],evid:[0,11],evolut:[0,1,5,7,11,14,15,16],evolution_split:[0,11],evolution_splitting_maxdepth:[0,11],evolution_splitting_sn_eccentricity_threshold:[0,11],evolution_splitting_sn_n:[0,11],evolution_typ:[7,15],evolutionari:[0,11,14],evolv:[0,3,5,7,11,12],evolve_popul:15,evolve_singl:[5,12,14],exact:[1,4,7],exactli:[0,11],exampl:[1,2,4,5,14,18],example_above_m:12,example_compact_object:15,example_dco:15,example_df:14,example_head:4,example_log:18,example_log_co:[1,12],example_logging_string_co:12,example_logging_string_post_m:12,example_massloss:[12,14],example_output:14,example_parse_output:4,example_pop:[14,15],example_pop_set:15,example_python_population_result:15,example_sn:12,exce:[0,7,11],except:[4,5,6,7,11,15,16],execut:[0,5,7,9,11,15,17],exist:[0,5,6,11,15],exist_ok:[4,15],exit:[0,4,11],exp:[5,15],expand:[15,18],expect:[9,11,17],experiment:[0,4,11],explain:[3,4],explicitli:[0,1,11],explod:[0,11],explos:[0,11],expoenti:[0,11],expon:[0,11],export_all_info:[5,15],express:[0,11],extend:[0,9,17],extens:11,extern:[0,11],extra:[0,3,5,7,9,11,15,18],extra_text:6,extract:[4,15],extract_ensemble_json_from_str:4,extrapol:[2,7],fabian:[0,11],fabian_imf_log:[0,11],fabian_imf_log_tim:[0,11],fabian_imf_log_timestep:[0,11],factor:[0,2,4,7,11],fade:[0,11],fail:[0,4,7,9,11,17],fail_sil:4,failed_count:15,failed_prob:15,failed_system:7,failed_system_log:7,failed_systems_error_cod:15,failed_systems_threshold:7,failsaf:14,failur:[0,11],fallback:[0,12],fallback_mass:12,fals:[0,4,5,7,11,13,15,16],fancy_parsing_funct:18,far:[0,11],farmer:[0,11],fase:15,fast:[0,11],faster:15,favorit:14,featur:[3,9,15],feed:7,ferguson:[0,11],fetch:14,few:[0,11],field:[0,11],fig:[0,2,11],figur:[7,16],file:[0,1,4,5,6,7,8,9,11,14,15,16,17,18],file_log:[0,11],filehandl:6,filenam:[0,1,4,5,7,11,14,15,18],filenotfounderror:[9,17],filepath:1,fill:14,fill_data:2,filter:[0,4,11,13],filter_arg_dict:4,filter_valu:[4,13],fin:[0,11],find:[4,5,7,9,15,17],finish:[4,15,16],first:[0,2,4,5,9,11,14,15,17,21],first_giant_branch:0,fishlock:[0,11],fit:[0,2,4,5,11,14,21],fix:[0,2,4,5,11,14,15,16],flag:[0,1,4,7,11],flash:[0,11],flat:[2,7],flatsect:[2,15],flaw:5,float_overflow_check:[0,11],flto:[9,17],fold:2,follow:[0,2,4,7,9,11,12,16,17],forc:[0,9,11,17],force_circularization_on_rlof:[0,11],force_corotation_of_primary_and_orbit:[0,11],form:[0,4,5,6,11,15],formal:[0,11],format:[0,2,4,5,11,12,14,15],format_ensemble_result:4,formula:[0,11],forward:[0,11],found:[2,9,15,17],four:[0,11],fpic:1,fraction:[0,2,7,11,15],framework:11,free_persistent_data_memaddr_and_return_json_output:11,free_store_memaddr:11,frequenc:[0,11],friction:[0,11],fring:[0,11],from:[0,2,4,5,7,13,14,15,16,21],from_binary_c_config:1,fryer:0,ftz:[9,17],full:[3,4,7,12],full_path:4,further:[2,15],fuv:[0,11],gaia:[0,2,11],gaia_colour_transform_method:[0,11],gaia_conversion_ubvri_bivariate_jordi2010:[0,11],gaia_conversion_ubvri_riello2020:[0,11],gaia_conversion_ubvri_univariate_evans2018:[0,11],gaia_conversion_ubvri_univariate_jordi2010:[0,11],gaia_conversion_ugriz_bivariate_jordi2010:[0,11],gaia_conversion_ugriz_riello2020:[0,11],gaia_conversion_ugriz_univariate_evans2018:[0,11],gaia_conversion_ugriz_univariate_jordi2010:[0,11],gaia_l_binwidth:[0,11],gaia_teff_binwidth:[0,11],gain:7,galact:[0,11],gallino:[0,11],gamma:[0,11],gap:[0,11],garcia:[0,11],gauss:[0,11],gaussian:2,gaussian_func:2,gaussian_normalizing_const:2,gb_reimers_eta:[0,11],gb_wind_beasor_etal_2020:0,gb_wind_goldman_etal_2017:0,gb_wind_reim:0,gb_wind_schroeder_cuntz_2005:0,gbwind:[0,11],gbwindfac:[0,11],gcc:[1,9,17],gce:[0,11],gener:[0,1,2,4,5,6,7,11,12,14,15,16],general_info:4,generalis:2,geometr:[0,11],gerosa:[0,11],get:[0,2,3,4,5,6,9,12,14,15,17,18,21],get_arg_kei:4,get_default:[4,13],get_help:[4,13],get_help_al:[4,5,13],get_help_sup:[4,13],get_integration_constant_q:2,get_max_multipl:2,get_moe_di_stefano_dataset:4,get_siz:4,giant:[0,11],giant_branch:0,git:[0,4,15],git_branch:4,git_build:4,github:4,gitlab:9,give:[0,2,4,11,21],given:[0,1,2,4,5,7,11,18,21],global:[0,2,11],global_dict:2,gmax:2,gmin:2,gnu:11,goe:[0,4,5,11,12,14,16],gogo:[0,11],going:[9,17],goldman:[0,11],gonna:2,good:[0,7,11,14,15,21],gov:[0,11],gravit:[0,11,15],gravitational_radiation_bs:0,gravitational_radiation_bse_when_no_rlof:0,gravitational_radiation_landau_lifshitz:0,gravitational_radiation_landau_lifshitz_when_no_rlof:0,gravitational_radiation_model:[0,11],gravitational_radiation_modulator_:[0,11],gravitational_radiation_modulator_j:[0,11],gravitational_radiation_non:0,grb:[0,11],great:[0,11],greater:[0,11],grevess:[0,11],grid:[0,3,4,5,9,10,11,12,14],grid_class:[9,10],grid_cod:5,grid_opt:[5,7,14,15],grid_options_default:6,grid_options_defaults_dict:6,grid_options_descript:[6,15],grid_options_description_check:6,grid_options_help:6,grid_vari:[7,15],grid_variable_numb:15,gridcode_filenam:7,gridtyp:[5,15],group:4,gsl:[9,17],gsl_dir:[9,17],guess:[0,2,11],h5py:[9,17],hachisu:[0,11],hachisu_disk_wind:[0,11],hachisu_ignore_qcrit:0,hachisu_qcrit:[0,11],hack:6,had:5,half:[0,11],hall:[0,11],handi:[0,11],handl:[0,3,4,5,7,11,14,18,21],handle_ensemble_string_to_json:4,happen:[0,11],hardcod:[12,15],has:[0,1,4,5,7,11,12,13,15],have:[0,2,3,4,5,6,7,9,11,12,14,15,16,17],hbb:[0,11],hbbtfac:[0,11],hdf5:4,hdf5file:4,header:[1,4,12,14,15],headerlin:15,headlin:7,hegb:0,hehg:0,height:[2,15],helium:[0,11],helium_flash_mass_loss:[0,11],helium_white_dwarf:0,help:[0,3,4,6,11,14,15],help_al:[0,11],hem:0,henc:[0,11],hendrik:[9,17],here:[1,4,5,7,11,12,14,16],hertzsprung:[0,11],hertzsprung_gap:0,hertzstrpung:[0,11],heuvel:[0,11],hewd:[0,11],hewd_hewd_ignition_mass:[0,11],hex:7,high:[0,2,11],higher:[0,2,4,7,9,11,15,17],his:2,histori:2,hold:7,hole:[0,11],home:11,homogen:[0,11],hood:14,hopefulli:[0,11],hot:[0,11],how:[0,4,5,7,11,12,14,15],howev:[0,11,12,15],hoyl:[0,11],hpc:[5,8],hpc_function:[9,10],hr_diagram:16,hrd:[0,11],hrdiag:[0,11],hrdiag_output:[0,11],html:[9,15,17],http:[0,1,2,4,11,15],hurlei:[0,11],hut:[0,11],hybrid:[0,11],hydro:[0,11],hydrogen:[0,11],ibc:[0,11],id_cor:12,idea:[15,16],idum:[0,11],ignit:[0,11],ignor:[0,5,7,9,11,12,14,15,17],iia:[0,11],iloc:14,imf:[0,2,11],imf_chabrier2003:2,imf_scalo1986:2,imf_scalo1998:2,imf_tinsley1980:2,immedi:[0,11],implement:[0,5,7,11],impli:[0,11],impos:15,improv:2,inclin:[0,11],inclination1:[0,11],inclination2:[0,11],inclination3:[0,11],inclination4:[0,11],inclini:[0,11],incliniation_quadrupl:[0,11],incliniation_tripl:[0,11],includ:[0,1,2,4,5,9,11,12,14,15,16,17],include_binary_c_default:[5,15],include_binary_c_help_al:[5,15],include_binary_c_version_info:[5,15],include_default:[5,15],include_popul:15,include_population_set:5,incom:[0,11],increas:[0,11],inde:[0,11],indent:[4,14],index:[0,2,9,11,13,14],indic:[0,2,11],individu:[3,9],individual_nova:[0,11],induc:[0,11],inertia:[0,11],info:[4,5,9,11,13,15,16,17],inform:[0,1,3,4,5,6,12,14,15,16],init:5,init_abund:[0,11],init_abund_dex:[0,11],init_abund_mult:[0,11],init_abunds_onli:[0,11],initi:[0,2,5,11,13,14],initial_abundance_hash:5,initial_abundance_mix:[0,11],initial_abunds_onli:[0,11],initial_mass:14,inner:[0,11],input:[1,2,4,5,7,9,11,13,14,16,21],input_dict:4,insert:[5,15],insid:[0,11],inspect:[4,14,16],inspect_dict:4,inspir:[1,16,21],instabl:[0,11],instanc:[4,14,15],instant:[0,11],instantli:[0,11],instead:[0,4,7,11],integ:[0,5,7,11,21],integr:2,integrals_str:2,interact:[0,6,11],interfac:[4,9,11,17],interfer:[9,17],intern:[0,7,11,13],internal_buff:[0,11],internal_buffering_off:0,internal_buffering_print:0,internal_buffering_stor:0,interpol:[2,5],interpolate_in_mass_izzard2012:2,interpolator_nam:2,intershel:[0,11],interstellar:[0,11],intger:[0,11],intro:[0,11],invers:21,involv:[0,11],inward:[0,11],ipynb:15,is_capsul:4,isfil:15,isn:[4,5],isnt:15,isotop:[0,4,11,13],isotope_hash:5,isotope_list:5,item:1,iter:4,its:[0,4,5,6,9,11,15,16,17,18],itself:[4,7,9,12,14,17],iwamoto:[0,11],izzard2012_period_distribut:2,izzard:[0,9,11,17],jager:[0,11],jaschek:2,jeff:[9,17],jia:[0,11],john:[0,11],join:[11,12,14,15],jordi:[0,11],json:[4,5,7,11,14,15],jsondecod:4,jsonencod:4,jupyt:[9,17],just:[0,2,4,5,7,11,15,21],kap:[0,11],kappa:[0,11],kaps_rentrop:[0,11],karaka:[0,11],keep:[5,15],kei:[1,2,4,5,6,7,13,14,15,16],kelvin:[0,11],keplerian:[0,11],keyword:[16,18],kick:[0,7,11],kick_backward:0,kick_forward:0,kick_inward:0,kick_outward:0,kick_random:0,kick_straight_up:0,kick_velocity_custom:0,kick_velocity_fix:0,kick_velocity_maxwellian:0,kill:[1,12,15],kim:[0,11],kind:[0,11],kippenhahn:[0,11],know:[0,1,5,6,11,13,14],known:[0,2,5,11,14,15,18],kroupa2001:[2,5,15],kroupa:2,krticka:0,ktg93:2,kwarg:[5,16,18],lambda:[0,11],lambda_c:[0,11],lambda_ce_dewi_tauri:0,lambda_ce_klencki_2020:0,lambda_ce_polytrop:0,lambda_ce_wang_2016:0,lambda_enthalpi:[0,11],lambda_ionis:[0,11],lambda_min:[0,11],lambda_mult:[0,11],lambda_multipli:[0,11],lambda_v:2,lamer:[0,11],landau:[0,11],langer:[0,11],larger:[0,11],last:2,lastli:[11,14],latter:[0,11],law:2,law_const:2,lbv:[0,11],ld_library_path:[9,17],lead:[0,11,15,21],learn:12,least:[9,17],leav:[0,11],left:[0,11],legaci:[0,11],legacy_yield:[0,11],len:[14,15],lengthen:[0,11],less:[0,1,2,3,11,14],let:[5,14,15],level:[1,4],li7:[0,11],lib:[9,11,14,17],libbinary_c:7,libcustom_logging_5d7779e8190e4b79b10c7e6a44cb0e7:14,libcustom_logging_8967553693ac4e11a49c42d4eef773e8:14,libcustom_logging_e9c2bec7f15541eb847fc6013e48e7:[],libcustom_logging_eac2dfc438a14e5a9f5be98b1b6b4294:[],libgsl:[9,17],libmemo:[9,17],librari:[0,1,5,7,11,12,18],library_path:[9,17],librinterpol:[9,17],lies:[0,11],lifetim:[0,11,15],lifshitz:[0,11],like:[0,1,4,5,7,9,11,15,16,17,19],limit:[0,11,15,16],line:[1,4,5,7,9,12,14,15,16,17],linear2:7,linear:[0,2,7,11],linear_extrapolation_q:2,linearli:19,linker:1,linspac:19,linux:11,list:[0,1,2,4,7,11,14,15,18,19],list_arg:[0,11],list_of_sub_kei:2,lit:[0,11],lithium:[0,11],lithium_gb_post_1dup:[0,11],lithium_gb_post_heflash:[0,11],lithium_hbb_multipli:[0,11],lithium_t:[0,11],littleton:[0,11],liu:[0,11],llnl:[0,11],lnm1:[5,15],load:[0,1,4,5,7,11,12,14,15,16],load_logfil:4,lobe:[0,11,21],local:2,locat:[0,2,7,9,11,17],lodder:[0,11],log10:[0,2,11,15],log10m1:7,log10p:2,log10per:15,log10pmin:2,log:[0,1,2,3,4,5,7,9,11,14,16,17,18,21],log_arg:7,log_args_dir:7,log_arrow:0,log_every_timestep:[12,14],log_fil:7,log_filenam:[0,11,14,18],log_runtime_system:7,logarithm:2,logensembletim:[0,11],logfil:[4,9,14,17],logg:[0,11],logger:15,logging_dict:1,logging_lin:12,logic:[1,5,7,12],logmass:2,logp:2,logper:2,logperiod:2,long_spectral_typ:2,longer:[0,11],longnam:[5,15],look:[1,4,9,15,17],lookback:[0,11],loon:[0,11],loop:[5,14,15],loos:16,lose:[0,11],loss:[0,11,14],lost:[0,11],lot:[4,7,15,18],low:[0,2,11],low_mass_m:0,low_mass_main_sequ:0,lower:[0,2,5,11,15,19],lsoda:[0,11],lsun:[0,11,16],lugaro:[0,11],luminos:[0,11,16],luminosity_1:16,luminosity_2:16,lynnett:[0,11],m_1:[0,5,11,12,13,14,15,18],m_2:[0,11,12,14,15],m_3:[0,11],m_4:[0,11],m_max:[2,5,15],m_min:[5,15],maccretor:[0,11],machin:[7,9,17],macro:[0,4,11,13],madau:2,maeder:[0,11],magellan:[0,11],magnet:[0,11],magnetic_braking_algorithm:[0,11],magnetic_braking_algorithm_andronov_2003:0,magnetic_braking_algorithm_barnes_2010:0,magnetic_braking_algorithm_hurley_2002:0,magnetic_braking_algorithm_rappaport_1983:0,magnetic_braking_factor:[0,11],magnetic_braking_gamma:[0,11],magnitud:4,mai:[0,11],main:[0,1,7,9,11,12,15,17],main_sequ:[0,11],mainli:8,major:[0,11],make:[0,1,2,4,5,7,9,11,14,15,16,17,18],make_build_text:4,makedir:[4,15],manag:[4,9,17],mani:[0,5,7,11,13,15],manual:12,manufactur:[0,11],map:7,maria:[0,11],mass:[0,1,2,4,5,7,11,13,14,15,16,18,21],mass_1:[15,16],mass_2:[15,16],mass_accretion_for_eld:[0,11],mass_accretor:21,mass_donor:21,mass_evolut:16,mass_for_hestar_ia_low:[0,11],mass_for_hestar_ia_upp:[0,11],mass_of_pmz:[0,11],mass_str:2,massiv:[0,2,11],massless:[0,11],massless_remn:0,master:[7,16],match:[0,4,11,14,15,16],materi:[0,11],math:[5,15],matplotlib:[9,16,17],matter:[0,11],mattsson:[0,11],mattsson_mass_loss:[0,11],mattsson_orich_tpagbwind:[0,11],max:[0,2,11,12,15],max_bound:[2,19],max_evolution_tim:[0,1,11,12,14,15],max_hewd_mass:[0,11],max_model_numb:[0,11],max_multipl:2,max_neutron_star_mass:[0,11],max_queue_s:7,max_stellar_angmom_chang:[0,11],max_stellar_type_1:[0,11],max_stellar_type_2:[0,11],max_stellar_type_3:[0,11],max_stellar_type_4:[0,11],max_tim:14,max_val:2,maximum:[0,2,7,11,12,21],maximum_mass_ratio_for_instant_rlof:[0,11],maximum_mass_ratio_for_rlof:21,maximum_mcbagb_for_degenerate_carbon_ignit:[0,11],maximum_nuclear_burning_timestep:[0,11],maximum_timestep:[0,11],maximum_timestep_factor:[0,11],maxmimum:[0,11],maxwellian:[0,11],mayb:16,mayor:2,mc13_pocket_multipli:[0,11],mch:[0,11],mcmin:[0,11],mdonor:[0,11],mean:[0,2,4,5,7,9,11,17],meant:7,measur:4,medium:[0,11],mega:2,memaddr:[11,12],memori:[1,5,7,11,12,21],menv:[0,11],merg:[0,2,4,7,11],merge_dict:[4,13],merge_multipl:2,merger:[0,11],merger_angular_momentum_factor:[0,11],merger_mass_loss_fract:[0,11],mesa:[9,17],mesasdk_init:[9,17],mesasdk_root:[9,17],messag:4,mestel:[0,11],met:[5,15],metal:[0,2,11,12,14,15,21],method:[0,5,7,11,12,14,15],meynet:[0,11],might:[4,5,9,15,17],milki:[0,11],miller:[0,11],min:[2,12,15],min_bound:[2,19],min_p:2,min_per:2,min_val:2,minimal_verbos:4,minimum:[0,2,4,7,11,21],minimum_co_core_mass_for_carbon_ignit:[0,11],minimum_co_core_mass_for_neon_ignit:[0,11],minimum_donor_menv_for_comenv:[0,11],minimum_envelope_mass_for_third_dredgeup:[0,11],minimum_helium_ignition_core_mass:[0,11],minimum_mcbagb_for_nondegenerate_carbon_ignit:[0,11],minimum_orbital_period_for_instant_rlof:[0,11],minimum_period_for_rlof:21,minimum_separation_for_instant_rlof:[0,11],minimum_separation_for_rlof:21,minimum_time_between_pn:[0,11],minimum_timestep:[0,11],mint:[0,11],mint_data_cleanup:[0,11],mint_dir:[0,11],mint_disable_grid_load_warn:[0,11],mint_fallback_to_test_data:0,mint_hard_max_nshel:0,mint_hard_min_nshel:0,mint_kippenhahn:[0,11],mint_kippenhahn_companion_stellar_typ:[0,11],mint_kippenhahn_stellar_typ:[0,11],mint_maximum_nshel:0,mint_maximum_shell_mass:[0,11],mint_metal:[0,11],mint_minimum_nshel:0,mint_minimum_shell_mass:[0,11],mint_ms_rejuven:[0,11],mint_nshel:0,mint_nuclear_burn:[0,11],mint_remesh:[0,11],mint_use_zams_profil:[0,11],mira:[0,11],misc:[9,11],miscellan:[4,13],miss:[0,4,6,11],mix:[0,4,7,11],mixtur:[0,11],mmax:2,mmin:[2,7],mnra:21,model:[0,1,7,11,12,14,15],modif:3,modifi:[0,11,12],modul:[0,6,7,10,11,13,15],modulo:7,moe:[2,4,5,9,15],moe_di_stefano_2017:5,moe_di_stefano_2017_multiplicity_fract:2,moe_di_stefano_2017_pdf:2,moment:[0,11,12,15,19],momenta:[0,11,16],momentum:[0,11],mont:[0,7,11],monte_carlo_kick:[0,11],more:[0,1,3,4,5,7,9,11,12,13,14,15,16,17,19],most:[4,11],mostli:[4,6,7,15,16,18],move:[0,11],msun:[0,2,11,12,14],much:[0,4,11,15],multi:7,multipl:[0,2,4,7,11,15],multiplc:[0,11],multipli:[0,4,7,11],multiplicity_arrai:2,multiplicity_fraction_funct:7,multiplicity_model:7,multiplicity_modul:7,multiply_values_dict:[4,13],multiprocess:7,must:[0,2,11,14,15],my_stellar_data:[1,12,15],myr:[0,11,14],n100:[0,11],n100_z0:[0,11],n100h:[0,11],n100l:[0,11],n10:[0,11],n150:[0,11],n1600:[0,11],n1600c:[0,11],n200:[0,11],n20:[0,11],n300c:[0,11],n40:[0,11],naked_helium_star_giant_branch:0,naked_helium_star_hertzsprung_gap:0,naked_main_sequence_helium_star:0,name:[1,4,5,6,11,13,15,18,20],natur:[0,11],nauenberg:[0,11],nearer:[0,11],nebula:[0,11],necessari:[4,5,15],need:[0,2,5,9,11,12,14,15,17],neg:[0,4,11],neither:[0,5,11],neleman:[0,11],nelemans_gamma:[0,11],nelemans_max_frac_j_chang:[0,11],nelemans_minq:[0,11],nelemans_n_comenv:[0,11],nelemans_recalc_eccentr:[0,11],nemp:[0,11],nemp_cfe_minimum:[0,11],nemp_nfe_minimum:[0,11],nenamg:[0,11],neon:[0,11],nest:[4,5,15],network:[0,11,13],neutrn:[0,11],neutron:[0,11,15],neutron_star:0,never:[0,11],newer:[0,2,11],newli:[0,11],newopt:2,newton:[0,11],next:[4,15],nice:[1,5,16],nieuwenhuijzen:[0,11],nieuwenhuijzen_windfac:[0,11],nmax:2,no_thermohaline_mix:[0,11],noecho:[0,11],noechonow:[0,11],noel:[0,11],nolowq:7,nomin:[0,11],non:[0,7,11],nonconservative_angmom_gamma:[0,11],none:[0,1,2,4,5,6,7,11,15,21],nonetyp:15,nonzero:7,nor:[0,11],norm:7,normal:[0,4,11],normalis:[2,7],normalize_dict:2,normalize_multipl:7,notabl:15,note:[0,7,11],notebook:[9,11,12,13,14,15,17],notebook_api_funct:14,notebook_custom_log:[14,15],notebook_individual_system:[12,14,15],notebook_popul:14,noteworthi:3,noth:[5,7],notifi:18,nova:[0,11],nova_faml_multipli:[0,11],nova_irradiation_multipli:[0,11],nova_retention_algorithm_claeys2014:0,nova_retention_algorithm_const:0,nova_retention_algorithm_hillman2015:0,nova_retention_fract:[0,11],nova_retention_method:[0,11],nova_timestep_accelerator_index:[0,11],nova_timestep_accelerator_max:[0,11],nova_timestep_accelerator_num:[0,11],now:[0,2,4,11,12,14,15],nuclear:[0,11],nuclear_mass_hash:5,nuclear_mass_list:5,nucleosynthesi:[0,4,11],nucleosynthesis_sourc:[4,13],nucreacmult:[0,11],nucsyn:[9,11],nucsyn_angelou_lithium:[0,11],nucsyn_gce_outflow_check:[0,11],nucsyn_hbb:[0,11],nucsyn_metal:[0,11],nucsyn_network:[0,11],nucsyn_network_error:[0,11],nucsyn_s_process:[0,11],nucsyn_solv:[0,11],nucsyn_third_dredge_up:[0,11],nugi:[0,11],num_ansi_colour:0,number:[0,2,4,5,7,9,11,15,17],numer:4,numpi:[4,9,14,17,19],obj:4,object:[0,3,4,5,7,8,11,16],object_hook:4,object_pairs_hook:4,object_parse_funct:14,obtain:0,obvious:12,occur:[0,11,21],off:[0,11,15],off_m:14,offset:[0,11],ohio:[0,11],old:7,old_solut:[9,17],omega:[0,11],onc:[0,11],one:[0,4,5,7,11,13,15,16],onewd:0,onli:[0,4,5,7,11,12,15,21],onset:[0,11],onto:[0,2,11],opac:[0,11],opacity_algorithm:[0,11],opacity_algorithm_ferguson_op:0,opacity_algorithm_paczynski:0,opacity_algorithm_star:0,opal:[0,11],open:[14,15],opm:2,opt:[2,4,11],option:[0,1,2,4,5,9,10,11,15,17,21],orb:[5,15],orbit:[0,2,11,16,21],orbit_evolut:16,orbital_inclin:[0,11],orbital_inclinationi:[0,11],orbital_period:[0,11,12,14,15,21],orbital_period_quadrupl:[0,11],orbital_period_tripl:[0,11],orbital_phas:[0,11],orbital_phase_quadrupl:[0,11],orbital_phase_tripl:[0,11],orbiting_object:[0,11],orbiting_objects_close_pc_threshold:[0,11],orbiting_objects_log:[0,11],orbiting_objects_tides_multipli:[0,11],orbiting_objects_wind_accretion_multipli:[0,11],order:[3,4,5,15],ordereddict:4,org:[0,2,11],origin:[9,17],other:[0,1,2,4,6,7,9,11,13,14,15,16,17],otherwis:[0,5,6,7,11],out:[4,6,7,12,13],outcom:[0,11],outer:[0,11],outfil:[5,15],outfile_nam:1,outfilenam:15,output:[1,3,4,5,7,9,11,12,13,14,16,17,18,21],output_dict:14,output_dir:[5,14,15],output_fil:[4,6,14],output_filenam:[5,15],output_lin:4,outsid:[0,2,11],outward:[0,11],over:[4,5,13,14,15],overflow:[0,11],overlap:4,overrid:2,overriden:15,overshoot:[0,11],overspin_algorithm:[0,11],overspin_bs:[0,11],overspin_massloss:[0,11],overview:11,own:[5,7,9,12,14,15,17],oxygen:[0,11],oxygen_neon_white_dwarf:0,packag:[4,9,11,15,17,19],paczynski:[0,11],page:[0,9,11,15,17],pair:[0,4,11],panda:[4,9,14,16,17],pane:16,panel:[0,11],paper:[0,11],param_nam:4,paramet:[1,2,3,4,5,6,7,9,11,12,14,15,16,18,19,21],parameter_nam:[4,5,11,13,15],parameter_value_input_typ:[4,13],pars:[3,4,5,14,15,16,18],parse_binary_c_version_info:4,parse_cmdlin:5,parse_const:4,parse_float:4,parse_funct:[5,7,14,15,18],parse_function_hr_diagram:16,parse_function_mass:16,parse_function_orbit:16,parse_int:4,parsec:2,part:[2,5,11,14,15,21],partial:[0,11],particularli:[0,11],pasp:2,pass:[5,7,9,11,12,14,15,16,17,18],path:[4,7,9,14,15,17],patho:[9,17],pdf:[0,2,9,11,17],pend:[0,11],per:[0,4,5,7,11,14,15,21],percentag:[0,11],peret:[0,11],perform:[0,11],perhap:[0,11],periastron:[0,11],pericent:21,period:[0,2,11,12,14,15,16,21],period_str:2,perl:[1,15],persist:11,persistent_data:11,pgo:[0,11],phase:[0,11],phasevol:[0,11,15],phdi:[0,11],photoevapor:[0,11],php:2,physic:15,pick:16,piec:[5,15],pinnsonneault:[0,11],pisn:[0,11],pkg:[9,17],place:[0,11],placehold:16,plai:[0,11],plan:7,planetari:[0,11],plaw2:7,pleas:[0,4,11,15],plot:[0,11,14,16],plot_funct:[9,10],plot_hr_diagram:16,plot_hr_diagram_singl:16,plot_mass:16,plot_orbit:16,plot_system:16,plot_typ:16,pls:5,plu:[0,11],pms:16,pms_mass_1:16,pms_mass_2:16,pn_comenv_transition_tim:[0,11],pn_fast_wind:[0,11],pn_fast_wind_dm_agb:[0,11],pn_fast_wind_dm_gb:[0,11],pn_fast_wind_mdot_agb:[0,11],pn_fast_wind_mdot_gb:[0,11],pn_hall_fading_time_algorithm:[0,11],pn_hall_fading_time_algorithm_maximum:[0,11],pn_hall_fading_time_algorithm_minimum:[0,11],pn_resolv:[0,11],pn_resolve_maximum_envelope_mass:[0,11],pn_resolve_minimum_effective_temperatur:[0,11],pn_resolve_minimum_luminos:[0,11],pne:[0,11],pogg:[0,11],point:[0,2,4,5,9,11,17],poisson:[2,7],pol:[0,11],polytrop:[0,11],pop:12,pop_macro:12,popul:[0,2,3,5,6,8,9,11,17,19],population_id:7,population_nam:15,population_set:5,posit:[0,2,11],possibl:[0,1,2,4,6,9,11,14,17],post:[0,11,12],post_ce_adaptive_menv:[0,11],post_ce_envelope_dm_eagb:[0,11],post_ce_envelope_dm_gb:[0,11],post_ce_envelope_dm_tpagb:[0,11],post_ce_objects_have_envelop:[0,11],post_sn_orbit_bs:0,post_sn_orbit_method:[0,11],post_sn_orbit_tt98:0,postagb_legacy_log:[0,11],postagb_wind_gi:0,postagb_wind_krticka2020:0,postagb_wind_non:0,postagb_wind_use_gi:0,postagbwind:0,potenti:[0,11],power:[0,2,11],powerlaw:2,powerlaw_const:2,powerlaw_extrapolation_q:2,ppisn:[0,11],ppisn_farmer19:0,ppisn_non:0,ppisn_prescript:[0,11],ppn_envelope_mass:[0,11],pragma:12,pre:[0,11,16],pre_events_stardata:[0,11,12],pre_main_sequ:[0,11],pre_main_sequence_fit_lob:[0,11],precis:4,precod:[5,15],predefin:[2,15],predict:7,predictor:[0,11],prefer:[0,5,11],prefix:[0,11],prepar:2,prepare_dict:2,prescrib:0,prescript:[0,11,15],prescrit:[0,11],present:[2,4,5,15],preserv:[0,11],preset:16,pressur:[0,11],prev_stellar_type_1:15,prev_stellar_type_2:15,prevent:[0,7,11],previou:4,previous:[14,15],previous_stardata:[1,12,14,15],primari:[1,2,5,15,21],pringl:0,print:[4,6,7,11,12,13,14,15],print_help:[4,13],print_info:6,print_option_descript:6,print_structur:4,printf:[1,12,14,15],prior:[0,11],privat:[5,6,9],prob_dict:2,probability_weighted_mass:7,probabl:[0,1,2,5,6,7,11,12,15,16],probdist:[5,15],problem:[0,11],process:[0,4,5,7,11,15],profil:[0,11],progenitor:[0,11,15],program:[9,17],project:[0,11],proper:[6,12],properli:[0,11],properti:[0,4,7,16],prot1:[0,11],prot2:[0,11],prot3:[0,11],prot4:[0,11],provid:[0,2,5,7,11,15,18],pseudorandom:[0,11],publicli:12,puls:[0,11,21],pulsat:[0,11],pump:[0,11],purpos:[7,15,16],push_macro:12,put:[1,4,5,7,15,16],py_rinterpol:[9,17],pyenv:[9,11,17],pysiz:4,pytest:[9,17],python3:[9,11,17],python:[4,11,12,15],q_high_extrapolation_method:7,q_interpol:2,q_low_extrapolation_method:7,qcrit_bh:[0,11],qcrit_bs:0,qcrit_cheb:[0,11],qcrit_chen_han_formula:0,qcrit_chen_han_t:0,qcrit_cowd:[0,11],qcrit_degenerate_bh:[0,11],qcrit_degenerate_cheb:[0,11],qcrit_degenerate_cowd:[0,11],qcrit_degenerate_eagb:[0,11],qcrit_degenerate_gb:[0,11],qcrit_degenerate_hegb:[0,11],qcrit_degenerate_hehg:[0,11],qcrit_degenerate_hem:[0,11],qcrit_degenerate_hewd:[0,11],qcrit_degenerate_hg:[0,11],qcrit_degenerate_lmm:[0,11],qcrit_degenerate_m:[0,11],qcrit_degenerate_n:[0,11],qcrit_degenerate_onewd:[0,11],qcrit_degenerate_tpagb:[0,11],qcrit_eagb:[0,11],qcrit_gb:[0,11],qcrit_gb_bs:0,qcrit_gb_chen_han_formula:0,qcrit_gb_chen_han_t:0,qcrit_gb_ge2015:0,qcrit_gb_hjellming_webbink:0,qcrit_gb_q_no_comenv:0,qcrit_gb_temmink2021:0,qcrit_gb_vos2018:0,qcrit_ge2015:0,qcrit_hegb:[0,11],qcrit_hehg:[0,11],qcrit_hem:[0,11],qcrit_hewd:[0,11],qcrit_hg:[0,11],qcrit_hjellming_webbink:0,qcrit_lmm:[0,11],qcrit_m:[0,11],qcrit_n:[0,11],qcrit_onewd:[0,11],qcrit_q_no_comenv:0,qcrit_temmink2021:0,qcrit_tpagb:[0,11],qcrit_vos2018:0,qcrits_:[0,11],qcrits_degenerate_:[0,11],qdata:2,qlimit:2,quad:7,quadrat:[0,11],quadrulpl:[0,11],quadrupl:[0,2,7,11],quantiti:16,queri:14,queue:7,quickli:14,quit:[0,4,11],r_l:21,radau:0,radi:[0,11],radiat:[0,11],radii:[0,11,21],radiu:[0,1,11,12,15,16,21],radius_1:16,radius_2:16,ragb:21,raghavan2010_binary_fract:2,raghavan:2,rai:[0,11],railton:[0,11],rais:[0,4,7,11,15],ram:[0,11],ran:7,random:[0,7,11],random_count:14,random_se:[0,11,14],random_skip:[0,11],random_system:[0,11],random_systems_se:[0,11],rang:[0,2,5,7,11,14,15,19],rapid:0,rapidli:[0,11],rappaport:[0,11],rate:[0,2,11],rather:[0,4,5,7,9,11,12,14,15,17],ratio:[0,2,11,15,21],raw:[4,5,7,11,16,18],raw_output:4,reach:[0,11],reaction:[0,11],read:[3,4,14,15],real:[5,15],realli:[0,5,6,7,11,15],reason:[0,11],rebuild:[0,9,11,17],rebuilt:[9,17],recalcul:[0,11],receiv:4,recogn:15,recombin:[0,11],recommend:[1,3,5],recompil:[9,15,17],recurs:[4,5],recursive_change_key_to_float:4,recursive_change_key_to_str:4,red:[0,11],redhat:1,redshift:2,reduc:[0,11],reduct:7,regardless:16,region:[0,11],regist:15,reignit:[0,11],reimer:[0,11],reinstal:[9,17],reject:[0,11],rejects_in_log:[0,11],rejuven:[0,11],rel:[0,11],relat:[0,11],releas:[4,9,17],reliabl:11,remain:[0,11],remesh:[0,11],remnant:[0,11],remov:[0,4,5,11,14,15],remove_fil:4,renormalis:2,rentrop:[0,11],repeat:[0,7,11],repo:[9,17],report:[0,11,15],repositori:3,repres:7,represent:[4,5,15],reproduc:[0,11],requir:[0,2,4,11,14,15,16,18],reset:[0,11],reset_pref:[0,11],reset_star:[0,11],reset_stars_default:[0,11],resolut:[0,5,7,11,15],resolv:[0,11],reson:[0,11],respect:[0,2,11],rest:[2,5,15],restructuredtext:4,result:[0,1,2,4,5,7,9,11,14,15,17],result_arrai:2,result_dict:2,retain:[0,11],rethink:4,return_all_info:5,return_arglin:11,return_binary_c_default:5,return_binary_c_version_info:[4,5,13],return_compilation_dict:1,return_help:11,return_help_al:[4,11],return_maximum_mass_ratio_for_rlof:[11,21],return_minimum_orbit_for_rlof:[11,21],return_persistent_data_memaddr:11,return_population_set:5,return_store_memaddr:11,return_version_info:[4,11],revap_in:[0,11],revap_out:[0,11],revers:[0,11,16],reverse_tim:[0,11],revis:[0,4],rewrit:5,rhagavan:7,ri0005:15,rich:[0,11],riello:[0,11],rin:[0,11],ring:[0,11],risk:[5,15],ritter:[0,11],rk2:[0,11],rk4:[0,11],rlof:[0,11,21],rlof_angular_momentum_transfer_model:[0,11],rlof_angular_momentum_transfer_model_bs:0,rlof_angular_momentum_transfer_model_conserv:0,rlof_eccentric_as_circular:[0,11],rlof_entry_threshold:[0,11],rlof_f:[0,11],rlof_interpolation_binary_c:0,rlof_interpolation_bs:0,rlof_interpolation_method:[0,11],rlof_mdot_factor:[0,11],rlof_mdot_modul:[0,11],rlof_method:[0,11],rlof_method_adapt:0,rlof_method_adaptive2:0,rlof_method_bs:0,rlof_method_claei:0,rlof_method_ritt:0,rlof_nonconservative_gamma_donor:0,rlof_nonconservative_gamma_isotrop:0,rlof_radiation_correct:[0,11],rlof_transition_objects_escap:[0,11],rob:[0,2,11,21],robert:[9,17],roch:[0,11,21],roche_lob:21,rochelob:21,rol1:14,rol2:14,room:[5,15],root:[9,17],rotat:[0,2,11],rotation:[0,11],rotationally_enhanced_expon:[0,11],rotationally_enhanced_mass_loss:[0,11],rotationally_enhanced_massloss:[0,11],rotationally_enhanced_massloss_angmom:0,rotationally_enhanced_massloss_langer_formula:[0,11],rotationally_enhanced_massloss_langer_formula_and_angmom:0,rotationally_enhanced_massloss_non:0,rout:[0,11],routin:[0,3,5,9,11,16],row:[14,16],rring:[0,11],rssd:2,rst:[4,6],rsun:16,rubric:5,run:[0,1,3,4,5,7,9,11,17,18],run_popul:11,run_system:[11,12,13,14,16,18],run_system_wrapp:[9,10,12,14],run_wrapp:3,run_zero_probability_system:7,runtim:[1,7],russel:[0,11],rzam:21,s_option:7,safe:15,sai:[0,11],said:[0,11],same:[0,4,7,9,11,14,17],sampl:[0,2,5,11,15,19],sample_valu:2,sampler:9,sana12:[2,15],sana:2,save:[0,1,2,11,12,15],save_pre_events_stardata:[0,11],scalo:2,scanf:0,scheme:[0,11],schneider:[0,11],schroeder:[0,11],script:[3,9,12,17],sdb:[0,11],sdist:[9,17],sdo:[0,11],search:9,second:[0,2,4,11,16],secondari:[2,21],section:[2,4,8,9,11,15,17],see:[0,5,9,11,12,13,14,15,16,17],seed:[0,11],seem:[9,16,17],seen:4,segment:19,seitenzahl2013_model:[0,11],seitenzahl:[0,11],select:[0,4,11,14],selected_head:4,selector:[0,11],self:[5,7,14,15],semi:[0,11],sent:[0,11],sentenc:1,sep:[2,5,14,15,21],sep_max:15,sep_min:15,separ:[0,2,4,5,6,11,12,14,15,16,21],separation_quadrupl:[0,11],separation_tripl:[0,11],separta:[0,11],seper:15,sequenc:[0,11,12],seri:[0,11],serialis:[4,5],serv:4,server:5,set:[0,1,2,3,4,5,6,7,9,12,13,14,16,17],set_moe_di_stefano_set:5,set_opt:2,setup:[9,15,17,18],sever:[6,7,13,15,16,18],sfh:2,shara:[0,11],share:[1,7,14,18],shared_lib_filenam:12,shell:[0,11],shellular:0,shorten:[0,11],should:[0,1,2,5,6,7,9,11,14,15,16,17,18],shouldn:[0,4,11],show:[0,3,7,11,14,15,16],show_plot:16,show_stellar_typ:16,shown:[0,11,16],shrinkagb:14,side:15,siess:[0,11],sigma:2,silent:4,sill:[0,11],simplest:14,simpli:[0,11],simul:[0,1,11,12,15],simulation_:5,sinc:[4,16],singl:[0,2,3,5,7,11,15,16],single_star_lifetim:[11,12,14],sit:[0,11],site:11,situat:11,size:[4,7],skip:[0,4,7,9,11,17],skipkei:4,slightli:11,slope:2,slow:[0,11],slower:[0,11],slurm:[5,7,8],slurm_grid:5,small:[0,11],small_envelope_method:[0,11],small_envelope_method_bs:0,small_envelope_method_miller_bertolami:0,smaller:[0,11],sn_impulse_liu2015:0,sn_impulse_non:0,sn_impulse_wheeler1975:0,sn_kick_companion_a:[0,11],sn_kick_companion_aic_bh:[0,11],sn_kick_companion_bh_bh:[0,11],sn_kick_companion_bh_n:[0,11],sn_kick_companion_ecap:[0,11],sn_kick_companion_grb_collapsar:[0,11],sn_kick_companion_hestaria:[0,11],sn_kick_companion_ia_chand:[0,11],sn_kick_companion_ia_chand_co:[0,11],sn_kick_companion_ia_eld:[0,11],sn_kick_companion_ia_h:[0,11],sn_kick_companion_ia_he_co:[0,11],sn_kick_companion_ia_hybrid_hecowd:[0,11],sn_kick_companion_ia_hybrid_hecowd_sublumin:[0,11],sn_kick_companion_ibc:[0,11],sn_kick_companion_ii:[0,11],sn_kick_companion_iia:[0,11],sn_kick_companion_ns_n:[0,11],sn_kick_companion_phdi:[0,11],sn_kick_companion_pisn:[0,11],sn_kick_companion_ppisn:[0,11],sn_kick_companion_tz:[0,11],sn_kick_companion_wdkick:[0,11],sn_kick_dispersion_aic_bh:[0,11],sn_kick_dispersion_bh_bh:[0,11],sn_kick_dispersion_bh_n:[0,11],sn_kick_dispersion_ecap:[0,11],sn_kick_dispersion_grb_collapsar:[0,11],sn_kick_dispersion_ia_hybrid_hecowd:[0,11],sn_kick_dispersion_ia_hybrid_hecowd_sublumin:[0,11],sn_kick_dispersion_ibc:[0,11],sn_kick_dispersion_ii:[0,11],sn_kick_dispersion_ns_n:[0,11],sn_kick_dispersion_phdi:[0,11],sn_kick_dispersion_pisn:[0,11],sn_kick_dispersion_ppisn:[0,11],sn_kick_dispersion_tz:[0,11],sn_kick_distribution_aic_bh:[0,11],sn_kick_distribution_bh_bh:[0,11],sn_kick_distribution_bh_n:[0,11],sn_kick_distribution_ecap:[0,11],sn_kick_distribution_grb_collapsar:[0,11],sn_kick_distribution_ia_hybrid_hecowd:[0,11],sn_kick_distribution_ia_hybrid_hecowd_sublumin:[0,11],sn_kick_distribution_ibc:[0,11],sn_kick_distribution_ii:[0,11],sn_kick_distribution_ns_n:[0,11],sn_kick_distribution_phdi:[0,11],sn_kick_distribution_pisn:[0,11],sn_kick_distribution_ppisn:[0,11],sn_kick_distribution_tz:[0,11],sn_none:12,sn_type:12,sneia:[0,11],snia:[0,11],snippet:[11,14],solar:[0,2,11,13,21],solver:[0,11],solver_forward_eul:0,solver_predictor_corrector:0,solver_rk2:0,solver_rk4:0,some:[0,1,2,5,7,9,11,12,13,14,15,16,17],someth:[0,5,11,14],sometim:13,somewhat:15,soon:19,sort:4,sort_kei:4,sourc:[1,2,4,5,6,7,10,16,18,19,21],source_file_filenam:7,source_list:5,sourcecod:[9,11,12,17],sourcefile_nam:1,space:[0,5,11,15,19],spacing_funct:[9,10],spacingfunc:[5,15],spacingfunct:[5,15],special:[0,11,15],specif:[0,4,11,13,14,16],specifi:[0,7,11],spectral:2,speed:[0,7,11],speedtest:[0,11],spent:4,spera:0,spheric:[0,11],spin:[0,11],spinrat:[0,11],split:[0,7,11,14,15],split_lin:14,splitlin:[11,12,14,15],splitpoint:[0,11],spread:5,sqrt:[0,11],src:[0,9,11,12,17],stabil:[0,11],stabl:[0,11],stancliff:[0,11],standard:[0,2,11],star:[1,2,7,9,11,12,13,14,15,16,21],star_with_no_mass:0,starcount:15,stardata:[0,1,11,12,14,15],stardata_dump_filenam:[0,11],stardata_load_filenam:[0,11],stardata_t:12,start:[0,1,4,5,6,7,11,14,15],start_tim:[0,11],start_timestamp:15,startrack:0,startswith:14,state:[0,11],statement:[1,12,14,15],statist:[0,11],statu:[0,1,11,15],stderr:[0,11],stdout:4,steadi:[0,11],stefan:16,stefano:[4,5,9,15],stellar:[0,2,7,11,16,20],stellar_structure_algorithm:[0,11],stellar_structure_algorithm_external_funct:0,stellar_structure_algorithm_mint:0,stellar_structure_algorithm_modified_bs:0,stellar_structure_algorithm_non:0,stellar_typ:[1,9,10,12,14,15,16],stellar_type_1:[0,11,15,16],stellar_type_2:[0,11,15,16],stellar_type_3:[0,11],stellar_type_4:[0,11],stellar_type_dict:20,stellar_type_dict_short:20,step:[4,5,12,14,15,16,19],stepsiz:[5,15],stick:7,stiff:[0,11],still:[1,7,12],stop:[0,4,11],stopfil:[0,11],storag:[0,11],store:[0,2,3,4,5,7,9,14,15,17,21],store_capsul:11,store_memaddr:[11,21],str:[1,4,5,6,15,16],straight:5,straightforward:15,straniero:[0,11],strength:[0,11],strict:4,string:[0,1,3,4,5,6,7,11,13,14,15,16,18],strip:[0,11,14],stronger:[0,11],struct:[0,11,12],structur:[0,4,7,11,16],stuff:[4,7,14,15,16],style:[0,11],sub:[0,4,11],subdict:4,subject:[0,11],sublumin:[0,11],submit:9,subroutin:8,subsequ:[0,11],subtract:4,subtract_dict:4,succe:[0,11],suggest:[0,9,11,17],suit:[9,17],sum:[0,11],sundial:[0,11],supercrit:[0,11],supernova:[0,7,11],superwind:[0,11],superwind_mira_switchon:[0,11],sure:[2,5,7,9,14,15,16,17,18],surfac:[0,11],surrei:15,surviv:[0,11],survivor:[0,11],switcher:[0,11],symmetr:[0,11],synchron:[0,11],synonym:[0,11],synthesi:[7,9,15,17],system:[0,3,4,5,7,9,11,12,15,16,17,18],system_gener:[5,15],tabl:[0,2,11],take:[0,2,4,5,7,11,15,18],taken:[0,4,11,12],tar:[9,17],target:[1,6],task:[0,2,4,5,6,8,11,15,16,18,19,21],tauri:[0,11],tbse:[0,11],technic:[12,15],teff:[0,2,11],teff_1:16,teff_2:16,teff_postagb_max:0,teff_postagb_min:0,tell:4,temp_dir:[4,14,15],temperatur:[0,2,11,16],termin:[1,9,12,15,17],test:[0,4,5,7,9,11,14,15,17,21],test_data:0,test_func:11,test_logfil:14,test_pop:15,text:[4,6],than:[0,2,4,7,9,11,15,17],thats:15,thei:[0,2,4,5,7,11,15,16],thelog:[0,11],them:[2,4,5,11,15],themselv:[2,4],thermal:[0,2,11,21],thermally_pulsing_asymptotic_giant_branch:0,thermohalin:[0,11],thesi:[0,11],thi:[0,1,2,4,5,6,7,9,10,11,12,13,14,15,16,17,18,19,21],thick:[0,11],thick_disc_end_ag:[0,11],thick_disc_logg_max:[0,11],thick_disc_logg_min:[0,11],thick_disc_start_ag:[0,11],thin:[0,11],thing:[0,2,4,5,6,11,15,18],think:[0,4,5,11],third:[0,2,11],third_dup:[0,11],third_dup_multipli:[0,11],thorn:[0,11],those:[4,5,9,15,17],thread:7,thread_id:7,three:[0,2,11,15],three_part_powerlaw:[2,15],threshold:[0,4,7,11],through:[5,11,14,15,16,18],throughout:[5,15],tidal:[0,11],tidal_strength_factor:[0,11],tide:[0,11],tides_convective_damp:[0,11],tides_hurley2002:[0,11],tides_zahn1989:[0,11],time:[0,1,2,4,5,7,9,11,12,14,15,16,17],timescal:[0,11],timestamp:7,timestep:[0,11,12,14],timestep_limit:[0,11],timestep_log:[0,11],timestep_modul:[0,11],timestep_multipli:[0,11],timestep_solver_factor:[0,11],tinslei:2,titl:6,tmp:[0,4,9,11,14,15,17],tmp_dir:[5,7,14,15],tmp_tabl:2,todo:[0,1,2,4,5,6,7,11,13,15,16,18,19,21],toler:[0,11],too:[0,4,7,9,11,17,18],took:15,top:15,topic:[0,11],torqu:[0,11],total:[0,2,4,5,7,11,15,16],total_count:15,total_mass_run:15,total_prob:15,total_probability_weighted_mass_run:15,tout:[0,11,21],tout_pringle_1992_multipli:0,tpagb:[0,11],tpagb_reimers_eta:[0,11],tpagb_wind_beasor_etal_2020:0,tpagb_wind_bloeck:0,tpagb_wind_goldman_etal_2017:0,tpagb_wind_mattsson:0,tpagb_wind_reim:0,tpagb_wind_rob_cwind:0,tpagb_wind_van_loon:0,tpagb_wind_vw93_karaka:0,tpagb_wind_vw93_karakas_carbon_star:0,tpagb_wind_vw93_orig:0,tpagb_wind_vw93_orig_carbon_star:0,tpagbwind:[0,11],tpagbwindfac:[0,11],traceback:4,track:[7,16],trade:[0,11],transfer:[0,11],transform:[0,4,11],transit:[0,11],treat:[0,11],trigger:[0,11],trio:15,tripl:[0,2,7,11],truli:[0,11],tupl:1,turn:[0,4,11,14,15],two:[0,4,11,12,20,21],txt:[5,14,15,18],type:[0,1,2,4,5,6,7,11,14,15,16,19,20,21],type_chng:14,type_ia_mch_supernova_algorithm:[0,11],type_ia_sub_mch_supernova_algorithm:[0,11],typic:[0,11],ubvri:[0,11],ugriv:[0,11],unavail:0,uncom:[5,14,15],undef:12,under:[14,19],undergo:[0,11],understand:5,undescrib:6,uniform:2,union:[2,4,5,15,19,21],uniqu:[4,5,7,15],unit:[0,11,13,21],univari:[0,11],unknown:18,unless:[1,5,7],unload:5,unpars:11,unrecogn:[9,17],unsign:0,unstabl:[0,11],until:[0,2,4,11],unus:[0,7,11],unweight:15,updat:[2,4,5,9,15,17],update_dict:[4,13],upper:[0,2,11,19],usag:[0,3],use:[0,2,4,5,7,8,9,11,12,13,14,15,16,17,18],use_astropy_valu:16,use_datadir:[5,15],use_fixed_timestep_:[0,11],use_periastron_roche_radiu:[0,11],use_tabular_intershell_abundances_karakas_2012:[0,11],used:[0,1,2,4,5,7,11,12,13,14,15,16],useful:[0,4,5,7,9,11,13,14,15,17,18,21],useful_func:[9,10],user:[1,2,4,5,6,7,12,18],uses:[0,7,11,12,15],using:[0,1,5,9,12,13,14,17],usual:[0,2,7,11,15],util:[1,2,4,5,6,11,12,13,14,15,16,18,19,21],val:2,valid:[0,2,4,11,12],valu:[0,1,2,4,5,6,7,11,13,14,15,16],value_lin:14,valueerror:15,valuerang:[5,15],values_arrai:14,van:[0,11],vandenheuvel_log:[0,11],vari:[0,11,15],variabl:[0,3,4,5,7,11],variant:[0,11],variou:[0,11],vassiliadi:[0,11],veloc:[0,2,11],verbos:[1,2,4,7,9,14,15,17],verbose_print:4,veri:[0,5,11,12,14,15,19],versa:21,version:[0,4,5,9,11,13,15,17],version_info:4,version_info_dict:13,version_info_str:4,version_onli:[0,11],via:[3,5,7,11,12,15,16],vice:21,vink:[0,11],virtual:[9,17],virtualenviron:[9,17],viscos:[0,11],viscou:[0,11],visibl:12,visit:9,volum:[0,11],vrot1:[0,11],vrot2:[0,11],vrot3:[0,11],vrot4:[0,11],vrot_breakup:0,vrot_bs:0,vrot_non_rot:0,vrot_sync:0,vw93:[0,11],vw93_eagb_wind_spe:[0,11],vw93_mira_shift:[0,11],vw93_multipli:[0,11],vw93_tpagb_wind_spe:[0,11],vwind:[0,11],vwind_beta:[0,11],vwind_multipli:[0,11],wai:[0,4,5,7,11,14,16],wang:[0,11],want:[0,2,4,5,6,7,11,12,13,15,16],warmup_cpu:[0,11],warn:[0,11,14,15],wave:[0,11,15],wd_accretion_rate_new_giant_envelope_lower_limit_helium_donor:[0,11],wd_accretion_rate_new_giant_envelope_lower_limit_hydrogen_donor:[0,11],wd_accretion_rate_new_giant_envelope_lower_limit_other_donor:[0,11],wd_accretion_rate_novae_upper_limit_helium_donor:[0,11],wd_accretion_rate_novae_upper_limit_hydrogen_donor:[0,11],wd_accretion_rate_novae_upper_limit_other_donor:[0,11],wd_kick:[0,11],wd_kick_at_every_puls:0,wd_kick_at_given_puls:0,wd_kick_direct:[0,11],wd_kick_end_agb:0,wd_kick_first_rlof:0,wd_kick_pulse_numb:[0,11],wd_kick_when:[0,11],wd_sigma:[0,11],wdwd_merger_algorithm:[0,11],wdwd_merger_algorithm_bs:0,wdwd_merger_algorithm_chen2016:0,wdwd_merger_algorithm_perets2019:0,weight:[0,7,11],well:[0,4,7,9,11,12,14,17],were:[4,15],what:[0,1,2,4,5,6,7,9,11,12,14,15,17,18],whatev:[0,5,9,12,17],wheeler:[0,11],when:[0,1,2,4,5,6,7,9,11,13,14,15,17,18],whenev:[9,17],where:[0,1,2,4,5,6,7,9,11,15,17],whether:[0,2,4,5,6,7,11,13,15,16,21],which:[0,1,2,4,5,6,7,9,11,12,13,14,15,17,18,21],whichev:7,white:[0,11],white_dwarf_cooling_carrasco2014:[0,11],white_dwarf_cooling_mestel:[0,11],white_dwarf_cooling_mestel_modifi:[0,11],white_dwarf_cooling_model:[0,11],white_dwarf_radius_carrasco2014:[0,11],white_dwarf_radius_model:[0,11],white_dwarf_radius_mu:[0,11],white_dwarf_radius_nauenberg1972:[0,11],whole:[5,7,12],width:[0,11],wind:[0,11],wind_algorithm_binary_c_2020:0,wind_algorithm_hurley2002:0,wind_algorithm_non:0,wind_algorithm_schneider2018:0,wind_angmom_loss_bs:0,wind_angmom_loss_lw:0,wind_angmom_loss_lw_hybrid:0,wind_angmom_loss_spherically_symmetr:0,wind_angular_momentum_loss:[0,11],wind_disc_angmom_fract:[0,11],wind_disc_mass_fract:[0,11],wind_djorb_fac:[0,11],wind_gas_to_dust_ratio:[0,11],wind_lbv_luminosity_lower_limit:[0,11],wind_mass_loss:[0,11],wind_multiplier_:[0,11],wind_nieuwenhuijzen_luminosity_lower_limit:[0,11],wind_type_multiplier_:[0,11],within:[0,4,5,9,11,12,13,15,17],without:[2,5,7,12,14],won:[0,11,14],wood:[0,11],work:[0,4,9,11,12,14,16,17],would:[0,4,11,15,16],wouldn:[5,15],wr_wind:[0,11],wr_wind_bs:0,wr_wind_eldridg:0,wr_wind_fac:[0,11],wr_wind_maeder_meynet:0,wr_wind_nugis_lam:0,wrap:[1,12],wrapper:[4,11,12,14,21],write:[1,4,5,6,7,11,12,14,15,18],write_binary_c_calls_to_fil:[5,15],write_binary_c_parameter_descriptions_to_rst_fil:4,write_grid_options_to_rst_fil:6,write_logfil:11,written:[5,6,7,11,14,15,18],written_data:14,wrlof_mass_transf:[0,11],wrlof_method:[0,11],wrlof_non:0,wrlof_q_depend:0,wrlof_quadrat:0,wrong:[9,17],wrwindfac:[0,11],wtts2:[0,11],wtts_log:[0,11],www:[0,2,11],x86_64:11,year:[0,2,11],yet:[0,4,7,11,16],yield:[0,11],you:[0,1,4,5,6,7,9,11,12,14,15,16,17,21],young:[0,11],your:[7,9,12,14,17],yourself:[15,16],zahn:[0,11],zam:[0,2,11,18,21],zams_collis:21,zams_mass:15,zams_mass_1:15,zams_mass_2:15,zero:[0,1,7,11],zero_ag:[12,14,15],zero_prob_stars_skip:15,zone:[0,11],zoom:[0,11],zoomfac_multiplier_decreas:[0,11],zoomfac_multiplier_increas:[0,11],zsolar:2,zytkow:[0,11]},titles:["Binary_c parameters","custom_logging_functions module","distribution_functions module","Example notebooks","functions module","grid_class module","Grid options and descriptions","Population grid code options","hpc_functions module","Welcome to binary_c-python\u2019s documentation!","Binarycpython code","Using the API functionality of binarycpython","Using custom logging routines with binarycpython","Extra features and functionality of binarycpython","Running individual systems with binarycpython","Running populations with binarycpython","plot_functions module","Python module for binary_c","run_system_wrapper module","spacing_functions module","stellar_types module","useful_funcs module"],titleterms:{"function":[4,11,13,14,15],"public":7,Adding:15,Using:[11,12],about:13,after:[9,17],algorithm:0,api:[11,12,14],binari:0,binary_c:[0,9,11,13,17],binarycpython:[10,11,12,13,14,15],build:[9,13,17],code:[7,10],compact:12,custom:12,custom_logging_funct:1,descript:6,dictionari:13,directli:12,distribution_funct:2,document:[9,17],environ:[9,17],evolut:12,evolv:15,exampl:[3,9,11,12,13,15,17],extra:13,faq:[9,17],featur:13,free:11,from:[9,11,12,17],full:15,get:[11,13],grid:[6,7,15],grid_class:5,handl:15,help:13,hpc_function:8,indic:9,individu:14,inform:[11,13],input:0,instal:[9,17],instruct:[9,17],issu:[9,17],log:[12,15],mass:12,misc:0,modif:13,modul:[1,2,4,5,8,9,16,17,18,19,20,21],moe:7,note:[9,17],notebook:3,noteworthi:15,nucsyn:0,object:[12,14,15],option:[6,7],output:[0,15],paramet:[0,13],pars:13,pip:[9,17],plot_funct:16,popul:[7,12,14,15],privat:7,python:[9,17],requir:[9,17],routin:12,run:[12,14,15],run_system_wrapp:18,run_wrapp:14,sampler:7,script:15,section:0,set:[11,15],singl:14,sourc:[9,17],spacing_funct:19,star:0,stefano:7,stellar_typ:20,store:11,string:12,supernova:12,system:14,tabl:9,usag:[9,11,12,17],useful_func:21,using:11,variabl:[9,15,17],via:[9,14,17],welcom:9,when:12}})
\ No newline at end of file
+Search.setIndex({docnames:["binary_c_parameters","custom_logging_functions","distribution_functions","example_notebooks","functions","grid","grid_options_defaults","grid_options_descriptions","hpc_functions","index","modules","notebook_HRD","notebook_api_functionality","notebook_common_envelope_evolution","notebook_custom_logging","notebook_extra_features","notebook_individual_systems","notebook_luminosity_function_binaries","notebook_luminosity_function_single","notebook_population","plot_functions","readme_link","run_system_wrapper","spacing_functions","stellar_types","useful_funcs"],envversion:{"sphinx.domains.c":2,"sphinx.domains.changeset":1,"sphinx.domains.citation":1,"sphinx.domains.cpp":3,"sphinx.domains.index":1,"sphinx.domains.javascript":2,"sphinx.domains.math":2,"sphinx.domains.python":2,"sphinx.domains.rst":2,"sphinx.domains.std":1,"sphinx.ext.todo":2,"sphinx.ext.viewcode":1,nbsphinx:3,sphinx:56},filenames:["binary_c_parameters.rst","custom_logging_functions.rst","distribution_functions.rst","example_notebooks.rst","functions.rst","grid.rst","grid_options_defaults.rst","grid_options_descriptions.rst","hpc_functions.rst","index.rst","modules.rst","notebook_HRD.ipynb","notebook_api_functionality.ipynb","notebook_common_envelope_evolution.ipynb","notebook_custom_logging.ipynb","notebook_extra_features.ipynb","notebook_individual_systems.ipynb","notebook_luminosity_function_binaries.ipynb","notebook_luminosity_function_single.ipynb","notebook_population.ipynb","plot_functions.rst","readme_link.rst","run_system_wrapper.rst","spacing_functions.rst","stellar_types.rst","useful_funcs.rst"],objects:{"binarycpython.utils":{custom_logging_functions:[1,0,0,"-"],distribution_functions:[2,0,0,"-"],functions:[4,0,0,"-"],grid:[5,0,0,"-"],grid_options_defaults:[6,0,0,"-"],hpc_functions:[8,0,0,"-"],plot_functions:[20,0,0,"-"],run_system_wrapper:[22,0,0,"-"],spacing_functions:[23,0,0,"-"],stellar_types:[24,0,0,"-"],useful_funcs:[25,0,0,"-"]},"binarycpython.utils.custom_logging_functions":{autogen_C_logging_code:[1,1,1,""],binary_c_log_code:[1,1,1,""],binary_c_write_log_code:[1,1,1,""],compile_shared_lib:[1,1,1,""],create_and_load_logging_function:[1,1,1,""],from_binary_c_config:[1,1,1,""],return_compilation_dict:[1,1,1,""]},"binarycpython.utils.distribution_functions":{"const":[2,1,1,""],Arenou2010_binary_fraction:[2,1,1,""],Izzard2012_period_distribution:[2,1,1,""],Kroupa2001:[2,1,1,""],Moe_di_Stefano_2017_multiplicity_fractions:[2,1,1,""],Moe_di_Stefano_2017_pdf:[2,1,1,""],build_q_table:[2,1,1,""],calc_P_integral:[2,1,1,""],calc_e_integral:[2,1,1,""],calc_total_probdens:[2,1,1,""],calculate_constants_three_part_powerlaw:[2,1,1,""],cosmic_SFH_madau_dickinson2014:[2,1,1,""],duquennoy1991:[2,1,1,""],fill_data:[2,1,1,""],flat:[2,1,1,""],flatsections:[2,1,1,""],gaussian:[2,1,1,""],gaussian_func:[2,1,1,""],gaussian_normalizing_const:[2,1,1,""],get_integration_constant_q:[2,1,1,""],get_max_multiplicity:[2,1,1,""],imf_chabrier2003:[2,1,1,""],imf_scalo1986:[2,1,1,""],imf_scalo1998:[2,1,1,""],imf_tinsley1980:[2,1,1,""],interpolate_in_mass_izzard2012:[2,1,1,""],ktg93:[2,1,1,""],linear_extrapolation_q:[2,1,1,""],merge_multiplicities:[2,1,1,""],normalize_dict:[2,1,1,""],number:[2,1,1,""],poisson:[2,1,1,""],powerlaw:[2,1,1,""],powerlaw_constant:[2,1,1,""],powerlaw_extrapolation_q:[2,1,1,""],prepare_dict:[2,1,1,""],raghavan2010_binary_fraction:[2,1,1,""],sana12:[2,1,1,""],set_opts:[2,1,1,""],three_part_powerlaw:[2,1,1,""]},"binarycpython.utils.functions":{AutoVivificationDict:[4,2,1,""],BinaryCEncoder:[4,2,1,""],Capturing:[4,2,1,""],bin_data:[4,1,1,""],binarycDecoder:[4,2,1,""],binaryc_json_serializer:[4,1,1,""],call_binary_c_config:[4,1,1,""],catchtime:[4,2,1,""],convert_bytes:[4,1,1,""],convfloat:[4,1,1,""],count_keys_recursive:[4,1,1,""],create_arg_string:[4,1,1,""],create_hdf5:[4,1,1,""],custom_sort_dict:[4,1,1,""],datalinedict:[4,1,1,""],example_parse_output:[4,1,1,""],extract_ensemble_json_from_string:[4,1,1,""],filter_arg_dict:[4,1,1,""],format_ensemble_results:[4,1,1,""],get_arg_keys:[4,1,1,""],get_defaults:[4,1,1,""],get_help:[4,1,1,""],get_help_all:[4,1,1,""],get_help_super:[4,1,1,""],get_moe_di_stefano_dataset:[4,1,1,""],get_size:[4,1,1,""],handle_ensemble_string_to_json:[4,1,1,""],imports:[4,1,1,""],inspect_dict:[4,1,1,""],is_capsule:[4,1,1,""],load_logfile:[4,1,1,""],make_build_text:[4,1,1,""],merge_dicts:[4,1,1,""],multiply_values_dict:[4,1,1,""],output_lines:[4,1,1,""],pad_output_distribution:[4,1,1,""],parse_binary_c_version_info:[4,1,1,""],recursive_change_key_to_float:[4,1,1,""],recursive_change_key_to_string:[4,1,1,""],remove_file:[4,1,1,""],return_binary_c_version_info:[4,1,1,""],subtract_dicts:[4,1,1,""],temp_dir:[4,1,1,""],update_dicts:[4,1,1,""],verbose_print:[4,1,1,""],write_binary_c_parameter_descriptions_to_rst_file:[4,1,1,""]},"binarycpython.utils.functions.BinaryCEncoder":{"default":[4,3,1,""]},"binarycpython.utils.functions.Capturing":{__enter__:[4,3,1,""],__exit__:[4,3,1,""]},"binarycpython.utils.functions.binarycDecoder":{decode:[4,3,1,""]},"binarycpython.utils.functions.catchtime":{__enter__:[4,3,1,""],__exit__:[4,3,1,""]},"binarycpython.utils.grid":{Population:[5,2,1,""]},"binarycpython.utils.grid.Population":{Moe_di_Stefano_2017:[5,3,1,""],add_grid_variable:[5,3,1,""],clean:[5,3,1,""],evolve:[5,3,1,""],evolve_single:[5,3,1,""],export_all_info:[5,3,1,""],parse_cmdline:[5,3,1,""],rename_grid_variable:[5,3,1,""],return_all_info:[5,3,1,""],return_binary_c_defaults:[5,3,1,""],return_binary_c_version_info:[5,3,1,""],return_population_settings:[5,3,1,""],set:[5,3,1,""],set_moe_di_stefano_settings:[5,3,1,""],update_grid_variable:[5,3,1,""],vb1print:[5,3,1,""],write_binary_c_calls_to_file:[5,3,1,""]},"binarycpython.utils.grid_options_defaults":{grid_options_description_checker:[6,1,1,""],grid_options_help:[6,1,1,""],print_option_descriptions:[6,1,1,""],write_grid_options_to_rst_file:[6,1,1,""]},"binarycpython.utils.plot_functions":{color_by_index:[20,1,1,""],dummy:[20,1,1,""],parse_function_hr_diagram:[20,1,1,""],parse_function_masses:[20,1,1,""],parse_function_orbit:[20,1,1,""],plot_HR_diagram:[20,1,1,""],plot_masses:[20,1,1,""],plot_orbit:[20,1,1,""],plot_system:[20,1,1,""]},"binarycpython.utils.run_system_wrapper":{run_system:[22,1,1,""]},"binarycpython.utils.spacing_functions":{"const":[23,1,1,""]},"binarycpython.utils.useful_funcs":{calc_period_from_sep:[25,1,1,""],calc_sep_from_period:[25,1,1,""],maximum_mass_ratio_for_RLOF:[25,1,1,""],minimum_period_for_RLOF:[25,1,1,""],minimum_separation_for_RLOF:[25,1,1,""],ragb:[25,1,1,""],roche_lobe:[25,1,1,""],rzams:[25,1,1,""],zams_collision:[25,1,1,""]}},objnames:{"0":["py","module","Python module"],"1":["py","function","Python function"],"2":["py","class","Python class"],"3":["py","method","Python method"]},objtypes:{"0":"py:module","1":"py:function","2":"py:class","3":"py:method"},terms:{"000":16,"0000":16,"0000000000000002":18,"0000000000000004":18,"000000000000e":16,"0001":[12,25],"000122339":19,"000161974":19,"000214449":19,"000220016":19,"000283924":19,"000287968":19,"000375908":19,"000497691":19,"000498487":19,"00065893":19,"0007":2,"000872405":19,"001":[0,12],"00115504":19,"00152924":19,"00202467":19,"004698855121516278":19,"006221155214163634":19,"00632092":12,"008236638755149857":19,"010905083645619543":19,"012246630357e":19,"0141":12,"014137215791516371":13,"015210228389288167":13,"016469813170514686":13,"01877334232598154":13,"019388724199999995":13,"021960493499e":19,"024868380796643753":19,"024868380796643757":19,"02672934532166":13,"029827":13,"030499912298e":19,"035000000000004":18,"035263029200000025":13,"0434":19,"044142002936e":14,"044402888438054094":19,"04440288843805411":19,"044572277695e":14,"044654032097e":14,"045084306856e":14,"050651207308e":14,"05128ef4c5fe4274a0356c3e99e2f2d2":19,"054":2,"062193":17,"0645905996773004":13,"06459059967730076":13,"066":13,"07e":13,"0820":[0,12],"08msun":[0,12],"0902":[0,12],"0905077457428":13,"094409257247e":19,"0967":19,"0mb":[13,17],"0x14565763dca0":11,"0x14736bebc040":13,"0x14736bee47e0":13,"0x14736bee4870":13,"0x14736bee4f30":13,"0x154d03cdf180":17,"0x154d03cdf3f0":17,"0x154d03cdf480":17,"0x154d03cdf510":17,"0x7f531bc3b6a8":19,"0x7fa6a45ed180":12,"0x7fb4d41ebbf8":16,"100":[0,2,11,12,13,17,18],"1000":[0,7,12,13],"104907512664795":17,"105":18,"108":19,"1085":16,"10t22":17,"11003":16,"115":2,"11582":16,"120000":[0,12],"12325":16,"123795595728e":19,"12457":16,"12460":16,"12461":16,"125":[0,12],"12500":0,"12e":[1,11,13,14,16,17,18,19],"12t18":13,"1301":16,"1302":16,"134":19,"13461":16,"13567":14,"13626":19,"13700":[11,13],"139293101586e":19,"13e3":[0,12],"1403":2,"14306289954535925":17,"1439494161909395":17,"14461":16,"14e":13,"150":[13,17,18,19],"15000":[0,12,14,16,19],"1554469706921749":17,"158":17,"159405":17,"15msun":2,"1617":16,"1618":16,"1619":16,"1620":16,"162050247192383":17,"1621":16,"1621c23a5":0,"1629459533":19,"1629459536":19,"163":13,"1631304519":11,"1631305570":17,"1631305588":17,"1631461389":18,"1631461391":18,"1631462859":13,"1631462947":13,"16e":13,"17089":16,"17251417460118773":17,"174":13,"176660":13,"179":13,"17e":13,"181971798545e":19,"1865":14,"190":0,"190724478048":17,"1951":[0,12],"1972":[0,12],"1975":[0,12],"197x":[0,12],"1980":2,"1983":25,"1986":[0,2,12],"1989":[0,12],"199":17,"1991":2,"1992":[0,12],"1993":[0,12],"1996":25,"1998":[0,2,12],"1999":[0,12],"1bc714cffdb344589ea01692f7e1ebd1":18,"1ckzg0p9":[9,21],"1dex":[17,18],"1e2":[0,12],"1e9":[0,12],"1mb":13,"200":[0,12],"2000":[0,12],"2001":[2,18],"2002":[0,12],"2003":[0,2,12],"2004":[0,12],"2005":[0,12],"2009":[0,12],"2010":[0,2,7,12],"2012":[0,2,12],"2013":[0,12],"2014":[0,2,12],"2015":[0,12],"2016":[0,12],"2017":[0,7,12,19],"2018":[0,1,12],"2019":[0,12],"2020":[0,12],"2021":[0,13,17],"20210910":0,"20bee5b0c58d49c5bc47eced240685bb":11,"21587440567681548":19,"2182216189410787":18,"21822161894107872":18,"219029061236e":19,"219358":17,"222":13,"22611318083528567":13,"226885":13,"227002356107e":19,"227955577093495":19,"22e":17,"233":13,"235689312421":13,"236252":13,"237":13,"238":[13,17],"2403e":19,"24177551269531":13,"2424":16,"243471384048462":17,"2544031669779":19,"255":[0,12],"256":17,"257":25,"2572":19,"257608426597089":19,"25msun":[0,12],"268":13,"27143e":19,"273":13,"27745":13,"281":25,"28134439269236855":19,"28e":17,"292827":17,"29427":19,"29448":19,"29457":19,"2947":19,"2969346":2,"29e":13,"2ea4759ed05544ef8f1b7a887f0f36d2":11,"2mb":13,"2msun":[0,12],"3000":[0,12],"3021209239959717":18,"30642":19,"30902":19,"30e4":[0,12],"3205":19,"322":13,"3228":19,"331928491592407":17,"33469":14,"335742950439453":18,"33699":19,"338":14,"33e":13,"34213":14,"366":13,"367065500196e":19,"3681686":18,"36m":12,"370832":13,"374":13,"38788e":19,"39205":19,"394175":17,"394728392218e":19,"396133472739e":19,"396288708628e":19,"396675941641e":19,"39754":19,"3msun":2,"4000":0,"404641347602e":19,"406228":13,"427601421985e":19,"42msun":[0,12],"4309362899259503":19,"43422e":19,"43719":19,"4397":19,"444217227690e":19,"44msun":[0,12],"4500":12,"45000000080":19,"4504":19,"450828476484e":19,"451192744924e":19,"45189":11,"4530":[14,16],"453317880232e":19,"45407":19,"458824":17,"45msun":[0,12],"4621":19,"462779538274e":19,"465":13,"46573":19,"4680":13,"473":17,"473000":17,"475":17,"475399":17,"476":17,"47745":19,"478":17,"478464":17,"481":17,"482":17,"482470":17,"4824853":13,"4838":[12,14,16],"491896":17,"491948":17,"496677":17,"498669":17,"4e3":[0,12],"4f3ee0143c0548338494d2f1fbacc915":18,"500":[0,12],"508":19,"509":17,"510":17,"5107016563415527":18,"517749":16,"518":16,"51803":14,"52414":19,"52415":19,"5246":17,"5294":19,"538":13,"540":13,"541":13,"543649435043335":11,"546":13,"546683":16,"54819011688232":13,"5483":19,"548740826516e":19,"55458":14,"5717":19,"57443":14,"57571":19,"579099761269e":19,"58519":19,"586":13,"594":13,"59452":14,"5dex":[13,17,18],"5msun":[0,12],"6000":[0,12],"600000":0,"60007":19,"603368997573853":17,"6149734610296613":17,"6149734610296649":17,"6185":0,"625":0,"631":17,"6347400152389439":17,"634804":17,"635":[0,12],"639":17,"653":19,"66003":19,"6702895":18,"674063083432e":19,"67586e":19,"682":13,"684":19,"68748":19,"6944":0,"698":17,"6e1":2,"6e5":[0,12],"6msun":[0,12],"701828":17,"705":17,"71025":19,"71196":19,"7128":19,"716":16,"71662":14,"7203987":19,"7215321063995361":11,"724":14,"72498e":[14,19],"750":11,"7561":19,"7619":0,"763":2,"7647737053496777":19,"769":17,"771291":17,"772169325356e":19,"77287":19,"774":17,"779197348711e":19,"7809":19,"78125":0,"783":16,"784":13,"785212755203247":19,"79091":19,"792905807495117":19,"79487":19,"795":2,"7mb":17,"802986496151e":19,"80592":19,"80919":19,"80msol":2,"81066":19,"81395":14,"81495":19,"81499":19,"81529":19,"81536":19,"81563":19,"81636":19,"817":16,"81957":19,"81e":13,"82061":19,"82074":19,"82088":19,"82123":19,"8216":19,"82255":19,"82909393310547":13,"848380621869e":14,"865":17,"867175":17,"869":17,"872":[13,19],"8862":19,"8mb":13,"905335716621e":19,"9342952":13,"935186":19,"935920346899e":19,"9436":19,"9458":16,"949775":13,"950":13,"953":13,"953039":13,"9539172649383545":19,"958802":13,"959":13,"962":13,"963":13,"963621764679e":19,"964604":13,"965":13,"965721":13,"9686374664306641":11,"97008":19,"970949":13,"978355":13,"979":13,"97923e":19,"982866":13,"983689":13,"985":13,"99191":14,"99192":14,"99194":14,"9947":16,"9955394":11,"9956307907476224":18,"9956307907476225":18,"9983":16,"9mb":[13,17],"boolean":[0,4,5,7,12,20,25],"break":[0,12],"case":[0,3,4,7,9,12,17,19],"catch":[4,7,11,13,16,17,18,19],"char":7,"class":[4,5],"const":[2,5,11,13,17,18,19,23],"default":[0,1,2,4,5,6,7,11,12,14,15,17,18,19,22],"export":[4,5,19],"final":[13,17,18],"float":[0,2,4,5,12,15,16,23,25],"function":[0,1,2,3,5,6,7,8,9,10,11,13,14,20,21,22,23,25],"import":[4,5,11,12,13,14,15,16,17,18,19],"int":[0,1,2,4,5,6,7,12,17,19,23,25],"krtickov\u00e1":[0,12],"kub\u00e1t":[0,12],"long":[0,4,5,7,11,12,13,19,24],"new":[0,2,4,5,11,12,13,16,17,18,19],"null":[0,4,11,12,13,15],"paczy\u0144ski":[0,12],"public":[6,9,17,18,19],"return":[1,2,4,5,6,7,11,12,13,15,16,17,18,19,20,22,23,25],"short":[0,11,12,13,17,18,24],"super":[0,12],"switch":[0,12],"throw":[9,21],"true":[0,4,5,6,7,12,13,15,18,19,20],"try":[0,9,11,12,13,16,17,18,19,21],"void":14,"while":[0,11,12,13,17],Added:[11,13,19],Adding:[3,16],And:[6,9,21,25],Are:13,But:16,Doing:[11,17,18,19],For:[0,4,9,12,14,16,17,18,20,21],Gas:[0,12],Its:7,NOT:[0,5,12,22],Not:[7,13],One:[0,12],Pms:20,Such:13,That:[0,11,12],The:[0,1,2,3,4,5,7,9,11,12,13,14,15,16,17,18,19,20,21,22],Then:[4,9,11,21],There:[2,5,6,7,11,12,13,14,15,16,17,18,19,20],These:[4,7,11,12,17,18,19,20],Use:[0,5,12,19],Used:[0,7,12,20],Useful:[0,6,11,12,13,17,18,19],Uses:[0,4,12,23],Using:[3,9,13,17],Was:[0,12],Will:[0,4,5,12,19,22],With:6,__arg_begin:12,__attribute__:14,__enter__:4,__exit__:4,__iadd__:4,_actually_evolve_system:7,_binary_c_bind:[4,12,14,16,25],_binary_c_config_execut:7,_binary_c_dir:7,_binary_c_execut:7,_binary_c_shared_librari:7,_commandline_input:7,_count:7,_custom_logging_shared_library_fil:7,_end_time_evolut:7,_errors_exceed:7,_errors_found:7,_evolution_type_opt:7,_failed_count:7,_failed_prob:7,_failed_systems_error_cod:7,_generate_grid_cod:7,_grid_vari:[5,7,18],_loaded_ms_data:7,_main_pid:7,_population_id:7,_pre_run_cleanup:5,_probtot:7,_process_run_population_grid:7,_repeat:7,_set:5,_set_ms_grid:7,_start_time_evolut:7,_store_memaddr:7,_system_gener:7,_total_mass_run:7,_total_probability_weighted_mass_run:7,_total_starcount:7,_zero_prob_stars_skip:7,a173:[0,12],abat:[0,12],abbrevi:24,abl:12,about:[3,4,5,6,11,13,17,18,19,25],abov:[0,2,4,5,11,12,14,16,18,19],abridg:[12,14],absolut:[0,4,12],abund:[0,12],acceler:[0,12],accept:[4,19],access:[2,7,14,16,17,18,19],accord:[0,2,11,12],accordingli:[16,18,19],account:[0,7,12],accret:[0,12],accretion_limit_dynamical_multipli:[0,12],accretion_limit_eddington_lmms_multipli:[0,12],accretion_limit_eddington_steady_multipli:[0,12],accretion_limit_eddington_wd_to_remnant_multipli:[0,12],accretion_limit_thermal_multipli:[0,12],accretor:[0,12,25],accur:[17,18],act:[0,7,12,18,19],activ:[0,9,12,21],actual:[0,4,5,7,9,11,12,13,14,16,17,18,19,20,21],ad303100d719457c83256568f9a9887c:13,adam:[0,12],adapt:[0,12,18],add:[0,2,4,5,7,11,12,13,14,16,17,18,19,20,23,25],add_grid_vari:[5,11,13,17,18,19],added:[4,16,17],adding:[11,13,16,17,18,19],address:[1,7,12,14,25],admittedli:20,adress:[12,14,25],advis:14,affect:[0,11,12],after:[0,5,7,11,12,13,14,17,18,19],ag89:[0,12],again:[4,7,9,15,16,21],against:20,agb:[0,11,12],agb_3dup_algorithm:[0,12],agb_core_algorithm:[0,12],agb_core_algorithm_default:0,agb_core_algorithm_hurlei:0,agb_core_algorithm_karaka:0,agb_luminosity_algorithm:[0,12],agb_luminosity_algorithm_default:0,agb_luminosity_algorithm_hurlei:0,agb_luminosity_algorithm_karaka:0,agb_radius_algorithm:[0,12],agb_radius_algorithm_default:0,agb_radius_algorithm_hurlei:0,agb_radius_algorithm_karaka:0,agb_third_dredge_up_algorithm_default:0,agb_third_dredge_up_algorithm_hurlei:0,agb_third_dredge_up_algorithm_karaka:0,agb_third_dredge_up_algorithm_stancliff:0,age:[0,3,9,11,12,13],aging:[0,12],ago:11,albedo:[0,12],algorithm:[9,12],algothim:[0,12],all:[0,1,2,4,5,6,7,9,10,11,12,13,15,16,17,18,19,20,21,22],all_info:5,alloc:12,allow:[0,2,4,7,12,14],allow_nan:4,along:[0,6,7],alpha:[0,12],alpha_:13,alpha_c:[0,11,12,13],alphacb:[0,12],alreadi:[5,19],also:[0,3,4,5,6,9,11,12,13,14,17,18,19,21,25],alter:[5,13,17],altern:[0,7,12],alwai:[0,2,7,12],amanda:[0,12],amax:2,amin:2,amount:[0,4,5,6,7,12,19,23],amp:[11,12,13],amt_cor:[7,11,13,17,18,19],analys:22,analyt:[5,11,13,17,18,19],analyz:16,andrew:[9,21],andronov:[0,12],angelou_lithium_cheb_decay_tim:[0,12],angelou_lithium_cheb_massfrac:[0,12],angelou_lithium_cheb_tim:[0,12],angelou_lithium_decay_funct:[0,12],angelou_lithium_decay_function_exponenti:0,angelou_lithium_decay_tim:[0,12],angelou_lithium_eagb_decay_tim:[0,12],angelou_lithium_eagb_massfrac:[0,12],angelou_lithium_eagb_tim:[0,12],angelou_lithium_gb_decay_tim:[0,12],angelou_lithium_gb_massfrac:[0,12],angelou_lithium_gb_tim:[0,12],angelou_lithium_hg_decay_tim:[0,12],angelou_lithium_hg_massfrac:[0,12],angelou_lithium_hg_tim:[0,12],angelou_lithium_lmms_decay_tim:[0,12],angelou_lithium_lmms_massfrac:[0,12],angelou_lithium_lmms_tim:[0,12],angelou_lithium_ms_decay_tim:[0,12],angelou_lithium_ms_massfrac:[0,12],angelou_lithium_ms_tim:[0,12],angelou_lithium_tpagb_decay_tim:[0,12],angelou_lithium_tpagb_massfrac:[0,12],angelou_lithium_tpagb_tim:[0,12],angelou_lithium_vrot_trigg:[0,12],angelou_lithium_vrotfrac_trigg:[0,12],angular:[0,12,20],ani:[0,2,4,5,9,12,16,19,21],anoth:[0,12],ansi:[0,12],ansi_colour:[0,12],anyth:[0,4,7,12,17,18,19],anywai:[5,16,19],anywher:[5,19],api:[0,3,4,9],api_log_filename_prefix:[0,12,16],append:[1,4,11,16,17,18],appli:[0,12],apply_darwin_radau_correct:[0,12],appropri:[0,7,12],approxim:[0,11,12,13],aren:[2,7],arenou2010_binary_fract:2,arg:[2,4,12,15,19,20],arg_dict:4,argopt:[0,12],argpair:[4,15],argstr:[12,14,16],argument:[0,2,4,5,7,12,16,19,22],argument_of_periastron:[0,12],argument_of_periastron_quadrupl:[0,12],argument_of_periastron_tripl:[0,12],aritif:13,around:[0,12,14,16],arrai:[2,4,7,16],arrow:[0,12],artefact:18,artifici:[0,12],artificial_accretion_end_tim:[0,12],artificial_accretion_ignor:0,artificial_accretion_start_tim:[0,12],artificial_angular_momentum_accretion_r:[0,12],artificial_mass_accretion_r:[0,12],artificial_mass_accretion_rate_by_stellar_typ:[0,12],artificial_orbital_angular_momentum_accretion_r:[0,12],arxiv:[0,2,12],ask:[0,12,25],asplund:[0,12],assign:[5,17,18,19],associ:[11,13,17,18],assum:[0,11,12,13,17,20],ast871:[0,12],astronomi:[0,12],astrophys:[13,18],astropi:[9,20,21],asymptot:11,atom:4,attempt:[4,5],auto:[1,10],autogen_c_logging_cod:[1,14],automat:[0,1,6,9,12,14,21],autovivif:4,autovivificationdict:4,avaibl:[9,21],avail:[0,4,7,12,13,14,17,18,19,20],avoid:[11,12,13],awai:[0,12,17],axi:[0,12,20],b_1:[0,12],b_2:[0,12],b_3:[0,12],b_4:[0,12],b_inclination1:[0,12],b_inclination2:[0,12],b_inclination3:[0,12],b_inclination4:[0,12],back:[0,4,12],backward:[0,12],bagb:[0,12],bar:18,barn:[0,12],base:[0,2,4,5,9,12,13,17,18,19,20,21,25],base_filenam:[5,19],basic:[5,19],batchmod:[0,12],bc3a5f915411445699f8cf6438817ff1:17,beasor:[0,12],becaus:[0,2,5,7,9,11,12,13,16,17,18,21],becom:[0,1,2,4,12,14,18],been:[0,5,7,12,15],befor:[0,5,7,9,11,12,13,17,18,19,21],begin:11,behaviour:[4,11,17,18,19,22],belczynski:[0,12],below:[0,3,7,11,12,13,14,17,18,19],berro:[0,12],bertolami:[0,12],best:[5,7,9,21],beta:[0,12],beta_reverse_nova:[0,12],beta_reverse_novae_geometri:0,better:[0,3,4,5,12,19],between:[0,2,12,23],bewar:[5,19],bh_belczynski:[0,12],bh_fryer12_delai:[0,12],bh_fryer12_rapid:[0,12],bh_fryer12_startrack:[0,12],bh_hurley2002:[0,12],bh_prescript:[0,12],bh_spera2015:[0,12],big:[0,7,12],biinari:19,bin:[0,4,9,12,13,17,18,21],bin_data:[4,13,17,18],binari:[2,3,5,7,9,12,13,16,18,19,20,21,25],binary_c2:[9,21],binary_c:[1,2,3,4,5,7,11,13,17,18,20,22],binary_c_api_funct:14,binary_c_cal:[5,19],binary_c_default:19,binary_c_grid_ad303100d719457c83256568f9a9887c:13,binary_c_grid_bc3a5f915411445699f8cf6438817ff1:17,binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3c:19,binary_c_inline_config:1,binary_c_log_cod:[1,14,16],binary_c_macro:[0,12],binary_c_output:4,binary_c_paramet:[11,17,18,19],binary_c_python:[4,5,12,13,16,17,18,19],binary_c_task_:[0,12],binary_c_write_log_cod:1,binary_grid:[0,12],binary_star:25,binaryc:[1,4,15,22],binaryc_config:1,binaryc_json_seri:4,binarycdecod:4,binarycencod:4,binarycpython3:12,binarycpython:[1,2,3,4,5,6,9,11,12,13,14,15,16,17,18,19,20,21,22,23,25],binarygrid:[17,18,19],bind:[0,12,14,16],binned_log_luminos:[17,18],binned_post_period:13,binned_pre_period:13,binwidth:[4,13,17,18],birth:[0,12],bit:[2,11,17],bivari:[0,12],black:[0,11,12],black_hol:0,bloecker:[0,12],blog:1,boltzman:20,boltzmann:[0,12],bondi:[0,12],bondi_hoyle_accretion_factor:[0,12],bool:[4,5,6,15,19,20],born:[0,11,12,17,18],bosswissam:4,both:[0,4,12,17,18,19],bottom:[0,12,19],bound:[2,23],boundari:2,brake:[0,12],branch:[0,4,11,12],branchpoint:[5,11,13,19],breakup:[0,12],brighten:18,broken:[0,12],bse:[0,2,12,14,19],bse_opt:[5,11,13,16,17,18,19],bsf:[0,12],buffer:[0,12],build:[0,1,3,4,12],build_q_tabl:2,built:[0,1,4,9,15,21],burn:[0,12],busso:[0,12],bye:[0,12],c13_eff:[0,12],c_auto_log:7,c_log:0,c_logging_cod:[7,11,13,14,16,17,18,19],calc_e_integr:2,calc_p_integr:2,calc_period_from_sep:25,calc_sep_from_period:[13,17,19,25],calc_total_probden:2,calcul:[0,2,4,5,7,12,18,19,25],calculate_constants_three_part_powerlaw:2,call:[0,1,4,5,7,12,15,16,18,19,20,22],call_binary_c_config:4,calls_filenam:19,can:[0,1,2,4,5,7,9,11,12,13,14,15,16,17,18,19,20,21,22],candid:13,cannot:[5,11,14],canon:7,cap:[0,12],capit:[17,18],capsul:[1,4,12,13,17],captur:[0,4,12],carbon:[0,11,12],carbon_oxygen_white_dwarf:0,care:[11,17,18],carlo:[0,7,12],carrasco:[0,12],carri:[0,12],cast:[4,15],catchtim:4,categor:12,categori:[12,19],categoris:4,caught:[4,16],caus:[17,25],cbdisc:[0,12],cbdisc_albedo:[0,12],cbdisc_alpha:[0,12],cbdisc_eccentricity_pumping_dermin:0,cbdisc_eccentricity_pumping_method:[0,12],cbdisc_eccentricity_pumping_non:0,cbdisc_end_evolution_after_disc:[0,12],cbdisc_fail_ring_inside_separ:[0,12],cbdisc_gamma:[0,12],cbdisc_init_djdm:[0,12],cbdisc_init_dm:[0,12],cbdisc_inner_edge_strip:[0,12],cbdisc_inner_edge_stripping_timescal:[0,12],cbdisc_kappa:[0,12],cbdisc_mass_loss_constant_r:[0,12],cbdisc_mass_loss_fuv_multipli:[0,12],cbdisc_mass_loss_inner_l2_cross_multipli:[0,12],cbdisc_mass_loss_inner_viscous_accretion_method:[0,12],cbdisc_mass_loss_inner_viscous_accretion_method_equ:0,cbdisc_mass_loss_inner_viscous_accretion_method_gerosa_2015:0,cbdisc_mass_loss_inner_viscous_accretion_method_non:0,cbdisc_mass_loss_inner_viscous_accretion_method_young_clarke_2015:0,cbdisc_mass_loss_inner_viscous_angular_momentum_multipli:[0,12],cbdisc_mass_loss_inner_viscous_multipli:[0,12],cbdisc_mass_loss_ism_pressur:[0,12],cbdisc_mass_loss_ism_ram_pressure_multipli:[0,12],cbdisc_mass_loss_xray_multipli:[0,12],cbdisc_max_lifetim:[0,12],cbdisc_minimum_evaporation_timescal:[0,12],cbdisc_minimum_fr:[0,12],cbdisc_minimum_luminos:[0,12],cbdisc_minimum_mass:[0,12],cbdisc_no_wind_if_cbdisc:[0,12],cbdisc_outer_edge_strip:[0,12],cbdisc_outer_edge_stripping_timescal:[0,12],cbdisc_resonance_damp:[0,12],cbdisc_resonance_multipli:[0,12],cbdisc_torquef:[0,12],cbdisc_viscous_l2_coupl:[0,12],cbdisc_viscous_photoevaporative_coupl:[0,12],cbdisc_viscous_photoevaporative_coupling_inst:[0,12],cbdisc_viscous_photoevaporative_coupling_non:[0,12],cbdisc_viscous_photoevaporative_coupling_visc:[0,12],cee:[0,12,13],cell:[12,17,18,19],cemp:[0,12],cemp_cfe_minimum:[0,12],centr:[5,13,19],central_object:[0,12],certain:[7,9,21],cf_amanda_log:[0,12],cff93424298e4862bb72096e72b98a2d:11,cflag:[9,21],chabrier:2,challeng:18,chandrasekhar:[0,12],chandrasekhar_mass:[0,12],chang:[0,1,2,4,5,6,7,9,11,12,13,14,17,18,19,21],chapter:[0,7,10],cheb:[0,12],check:[0,2,4,5,6,11,12,13,17,18,19,25],check_circular:4,chemic:[0,12],chen:[0,12],child:4,choic:[0,2,12,20],choos:[0,11,12,13,14,17,20],chose:16,chosen:[5,17,18,19],circular:[0,12],circumbinari:[0,12],circumstanti:[0,12],claei:[0,12],clark:[0,12],clean:[1,5,9,11,16,18,21],clean_up_custom_logging_fil:5,clear:[4,18],clearli:18,clock:4,clone:[9,21],close:[0,12,13,18],cloud:[0,12],cls:4,cluster:8,cmdline:5,co2:18,code:[0,1,5,6,9,11,12,13,14,16,17,18,19,20,21,22],collaps:[0,12],collapsar:[0,12],collect:25,collid:25,color:20,color_by_index:20,colour:[0,12],colour_log:[0,12],column:[11,13,16,19,20],column_nam:16,com:[1,4],combin:[1,4,5,7,14],combine_ensemble_with_thread_join:7,come:[2,9,21,23],comenv:13,comenv_bs:0,comenv_count:13,comenv_disc_angmom_fract:[0,12],comenv_disc_mass_fract:[0,12],comenv_ejection_spin_method:[0,12],comenv_ejection_spin_method_do_noth:[0,12],comenv_ejection_spin_method_sychron:[0,12],comenv_ejection_spin_method_synchron:0,comenv_merger_spin_method:[0,12],comenv_merger_spin_method_breakup:0,comenv_merger_spin_method_conserve_angmom:[0,12],comenv_merger_spin_method_conserve_omega:[0,12],comenv_merger_spin_method_specif:[0,12],comenv_ms_accret:[0,12],comenv_ms_accretion_fract:[0,12],comenv_ms_accretion_mass:[0,12],comenv_nandez2016:0,comenv_nelemans_tout:0,comenv_ns_accret:[0,12],comenv_ns_accretion_fract:[0,12],comenv_ns_accretion_mass:[0,12],comenv_post_eccentr:[0,12],comenv_prescript:[0,12],comenv_splitmass:[0,12],comenv_undef:0,command:[0,1,5,7,9,12,19,21],commandlin:19,comment:19,commit:4,common:[0,3,9,11,12,14,16,17,18,19],compact:[13,19],companion:[0,12],compar:[0,7,12,13,17,19],compens:18,compil:[1,9,14,19,21],compile_shared_lib:1,complet:[11,13,17,18,19],complex:[5,7,13,14,19,20],compon:[4,20],comput:[0,8,11,12,17,18],conceptu:17,condit:[5,11,13,14,17,18,19],condor:[5,7,8],condor_grid:5,config:[1,4,7,9,21],config_fil:1,configur:[2,5,11,16,17,18,19],conjunct:15,conserv:[0,12],consid:[0,1,2,4,5,7,12,17,18,20],constant:[0,2,12,18,20],construct:[0,1,11,12,13,16,17,18,19],contain:[0,1,2,4,5,6,7,8,9,10,12,15,16,17,18,19,20,21,22,23,24],content:[3,4,5,9,12],context:4,continu:[5,19],control:[0,11,12,17,18,19],convect:[0,12],conveni:4,converg:[0,12],convert:[2,4,5,11,13],convert_byt:4,convfloat:4,cool:[0,11,12],copi:[0,12,13,18,25],core:[0,5,7,11,12,13,17,18,19,20],core_co:14,core_h:14,core_helium_burn:0,core_mass:[0,12,14],correct:[0,2,5,12,16,20,25],correctli:[9,16,20,21],correspond:20,corretor:[0,12],cosmic:2,cosmic_sfh_madau_dickinson2014:2,cost:[17,18],could:[0,4,12,18,19],count:[4,7,11],count_keys_recurs:4,counter:7,coupl:[0,3,12],cours:[11,20],cover:[15,17,18],coverag:[9,21],cowd:[0,12],cpu:[0,11,12,13,17,18],cpython:12,crap_paramet:[0,12],creat:[2,4,5,11,13,14,16,17,18,19],create_and_load_logging_funct:[1,14],create_arg_str:4,create_hdf5:4,creation:12,critic:[0,12],cross:[0,12],crunch:[11,13,17,18],ctype:1,cube:17,cubic:17,cuntz:[0,12],current:[0,4,9,12,13,14,17,18,21],curv:[13,18],custom:[0,1,3,4,5,7,9,12,13,16,17,18,19,20,22],custom_log:[5,7,16],custom_logging_cod:[1,14,16,22],custom_logging_func_memaddr:[7,12,14],custom_logging_funct:[7,9,10,14,16,19],custom_logging_info:5,custom_logging_memaddr:14,custom_logging_print_stat:16,custom_logging_stat:[11,13,17,18,19],custom_opt:[5,11,16,17,18,19],custom_output_funct:14,custom_sort_dict:4,custom_tmp_dir:1,customis:20,cvode:[0,12],dai:[0,2,12,13,14,16,17,19,25],damp:[0,12],darwin:[0,12],dat:[0,4,19],data:[0,4,5,7,11,12,13,16,17,18,19,22],data_dict:2,data_dir:[4,5,7,19],datadir:[5,19],datafram:[11,13,16,17,18,20],datalinedict:[4,11,13,17,18],datamodel:4,dataset:[4,19],date:5,david:[9,12,21],dd7:[0,12],deactiv:[0,12],deal:[4,16],death:[0,12],debug:[0,5,7,11,12,13,17,18,19],decai:[0,12],decid:[0,4,5,12,14],decod:4,decreas:[0,12],deepcopi:13,deeper:[5,19],def:[11,13,16,17,18,19],default_to_metal:[0,12],defaultdict:4,defer:[0,12],defin:[0,1,2,5,12,20],definit:[1,17,18,25],degener:[0,12],degenerate_core_helium_merger_ignit:[0,12],degenerate_core_merger_dredgeup_fract:[0,12],degenerate_core_merger_nucsyn:[0,12],degner:[0,12],degre:[0,12],del:13,delai:[0,12],delta_mcmin:[0,12],demonstr:13,den:[0,12],densiti:[2,17,18],depend:[0,2,9,11,12,20,21],deprec:[0,5,12],dermin:[0,12],describ:[0,2,7,12],descript:[0,2,4,7,9,10,12,15],design:20,desir:[0,12],destruct:[5,19],detail:[0,4,12,16],detect:[0,12,13],determin:[0,5,12,14,17,18,19,25],deton:[0,12],dev:[0,12],develop:1,deviat:2,dewi:[0,12],dex:[0,12,13],diagnost:7,diagram:[0,3,9,12,20],dickonson:2,dict2:4,dict:[1,2,4,5,6,11,15,16,17,18,19,24],dict_1:4,dict_2:4,dict_kei:[15,16],dictionari:[1,2,3,4,5,6,7,11,13,17,18,19,20,24],did:[4,9,21],differ:[0,4,5,9,11,12,13,17,18,19,20,21],dimmer:[0,12,17],dir:[9,21],direct:[0,5,12],directli:[4,7,16],director:7,directori:[0,3,4,5,7,9,12,19,21],disabl:[0,12,19],disable_debug:[0,12],disable_end_log:[0,12],disable_ev:[0,12],disc:[0,12],disc_legacy_log:[0,12],disc_log2d:[0,12],disc_log:[0,12],disc_log_directori:[0,12],disc_log_dt:[0,12],disc_log_level_non:0,disc_log_level_norm:0,disc_log_level_normal_first_disc_onli:0,disc_log_level_subtimestep:0,disc_log_level_subtimestep_first_disc_onli:0,disc_n_monte_carlo_guess:[0,12],disc_stripping_timescale_infinit:0,disc_stripping_timescale_inst:0,disc_stripping_timescale_orbit:0,disc_stripping_timescale_visc:0,disc_timestep_factor:[0,12],discret:19,discs_circumbinary_from_comenv:[0,12],discs_circumbinary_from_wind:[0,12],disk:[0,5,12],dispers:[0,12],displai:[0,11,12,13],disrupt:[0,12],dist:[4,9,21],distanc:11,distefano:2,distribut:[0,2,3,4,5,8,11,12,13,17,19],distribution_funct:[9,10,11,13,17,18,19],divid:8,dlnm1:[5,13,17,19],dlnm:18,dlnm_1:18,dlog10per:[13,17,19],dlogp:2,dm1:[11,18],dm_1:[11,18],do_dry_run:7,doc:[4,6,9,11,17,18,19,21],doc_fetch:2,docstr:[9,16,20,21],document:[4,6,7,10,17,18,19],doe:[0,2,4,5,7,11,12,14,15,16,17,18,19,25],doesn:[5,7,11],doesnt:6,doing:[0,1,6,9,12,21],don:[2,4,7,11],done:[0,4,5,9,11,12,13,17,18,19,21],donor:[0,12,25],donor_limit_dynamical_multipli:[0,12],donor_limit_envelope_multipli:[0,12],donor_limit_thermal_multipli:[0,12],donor_rate_algorithm_bs:0,donor_rate_algorithm_claeys2014:0,dont:12,doubl:[11,14,19],down:19,dphasevol:[5,11,13,17,18,19],dprob:[11,13,18],dr2:[0,12],dr3:[0,12],drai:[0,12],dredg:[0,12],drop:16,dry:7,dstep:2,dt_limit:15,dtfac:[0,12],dtlimit:4,dtm:[1,14,19],due:[9,21],dummi:[2,20],dump:[0,4,12,16],dumpvers:[0,12],duquennoi:2,duquennoy1991:2,dure:[0,12],dust:[0,12],dwarf:[0,11,12,18],dynam:[0,12],e2_hurley_2002:0,e2_izzard:0,e2_mint:0,e2_prescript:[0,12],e45c25448b32440cb7e220f4a3562907:19,e6c082aabe0849a0811761a06e50476b:18,each:[0,2,4,5,7,12,13,17,18,19],eagb:[0,12],eagb_wind_beasor_etal_2020:0,eagb_wind_bs:0,eagb_wind_goldman_etal_2017:0,eagbwind:[0,12],eagbwindfac:[0,12],earli:[0,12],early_asymptotic_giant_branch:0,easi:[4,16],easier:[4,19],ecc2:2,ecc3:2,ecc:[2,5,16,19],eccentr:[0,2,12,14,16,17,18,19,20,25],eccentric_rlof_model:[0,12],eccentricity_quadrupl:[0,12],eccentricity_tripl:[0,12],echo:[0,12],eddington:[0,12],edg:[0,5,11,12,19],edit:14,edu:[0,12],eff:11,effect:[0,2,7,12,14,17],effective_metal:[0,12],effici:[0,11,12,13],egg:[9,21],eggleton:[0,12,25],either:[0,4,5,7,9,12,17,18,19,21,22],eject:[0,12,13],elabor:14,eld:[0,12],eldridg:[0,12],electon:[0,12],electron:[0,12],element:[0,1,4,7,12,15,20],els:13,email:4,emp:[0,12],emp_feh_maximum:[0,12],emp_logg_maximum:[0,12],emp_minimum_ag:[0,12],empti:[4,6,16],enabl:[0,12],encod:4,encount:7,end:[0,2,4,7,12],end_index:2,end_timestamp:[11,13,17,18,19],energi:[0,12],enhanc:[0,12],enlarg:[0,12],enough:2,ensembl:[0,4,7,12,15],ensemble_def:[0,12],ensemble_dictionari:4,ensemble_dt:[0,12],ensemble_factor_in_probability_weighted_mass:7,ensemble_filter_:[0,12],ensemble_filters_off:[0,12],ensemble_json:4,ensemble_legacy_ensembl:[0,12],ensemble_list:5,ensemble_logdt:[0,12],ensemble_logtim:[0,12],ensemble_macro:[0,12],ensemble_output_:7,ensemble_startlogtim:[0,12],ensure_ascii:4,enter:[0,9,12,21],enthalpi:[0,12],entir:[14,16],entri:[4,5],env:[9,12,20,21],envelop:[0,3,9,11,12],epoch:5,equal:[0,4,12,18,19],equat:[0,12],equation_of_state_algorithm:[0,12],equation_of_state_paczynski:0,equatori:[0,12],equival:[7,17],errno:[9,21],error:[0,4,7,9,11,12,13,17,18,19,21],errors_exceed:[11,13,17,18,19],errors_found:[11,13,17,18,19],esa:2,escap:[0,12],escape_fract:[0,12],escape_veloc:[0,12],estim:11,eta:[0,12,13,17],etal:[0,12],etc:[0,4,5,8,9,12,16,18,19,20,21,22],etf:[13,17],euler:[0,12],evalu:[2,5,19,25],evan:[0,12],evapor:[0,12],evaporate_escaped_orbiting_object:[0,12],even:[15,18],event:[0,11,12],everi:[0,4,9,12,13,21],everyth:[5,7,16,19],everytim:[9,21],evid:[0,12],evolut:[0,1,3,5,7,9,11,12,16,17,18,19,20],evolution_split:[0,12],evolution_splitting_maxdepth:[0,12],evolution_splitting_sn_eccentricity_threshold:[0,12],evolution_splitting_sn_n:[0,12],evolution_stop:13,evolution_typ:[7,11,13,17,18,19],evolutionari:[0,12,16],evolv:[0,3,5,7,12,14],evolve_popul:19,evolve_singl:[5,14,16],exact:[1,4,7],exactli:[0,12,18],exampl:[1,2,4,5,16,17,22],example_above_m:14,example_compact_object:19,example_dco:19,example_df:16,example_head:4,example_log:22,example_log_co:[1,14],example_logging_string_co:14,example_logging_string_post_m:14,example_massloss:[14,16],example_output:16,example_parse_output:4,example_pop:[16,19],example_pop_set:19,example_python_population_result:19,example_sn:14,exce:[0,7,12,17],except:[4,6,7,11,12,17,18,19,20],excit:13,execut:[0,5,7,9,12,19,21],exist:[0,4,5,6,11,12,19],exist_ok:[4,19],exit:[0,4,12],exp:[5,13,17,18,19],expand:[19,22],expect:[9,11,12,13,17,18,21],experiment:[0,4,12],explain:[3,4],explicitli:[0,1,12],explod:[0,12],explos:[0,11,12],expoenti:[0,12],expon:[0,12],export_all_info:[5,19],express:[0,12],extend:[0,9,12,13,21],extens:12,extern:[0,12],extra:[0,3,5,7,9,12,19,22],extra_text:6,extract:[4,19],extract_ensemble_json_from_str:4,extrapol:[2,7],eye:5,f28b5f98d7ef40dcb17fc2481a6d3c:19,fabian:[0,12],fabian_imf_log:[0,12],fabian_imf_log_tim:[0,12],fabian_imf_log_timestep:[0,12],factor:[0,2,4,7,12],fade:[0,12],fail:[0,4,7,9,12,13,17,21],fail_sil:4,failed_count:[11,13,17,18,19],failed_prob:[11,13,17,18,19],failed_system:7,failed_system_log:7,failed_systems_error_cod:[11,13,17,18,19],failed_systems_threshold:7,failsaf:16,failur:[0,4,12],fallback:[0,12],fals:[0,4,5,7,11,12,13,15,17,18,19,20],fancy_parsing_funct:22,far:[0,11,12,18],fase:19,fast:[0,12],faster:[17,18,19],favorit:16,featur:[3,4,9,19],feed:7,ferguson:[0,12],fetch:16,few:[0,12,13],field:[0,12],fig:[0,2,12],figsiz:[11,13,17,18],figur:[7,11,13,17,18,20],file:[0,1,4,5,6,7,8,9,12,16,19,20,21,22],file_log:[0,12],filehandl:6,filenam:[0,1,4,5,7,12,16,19,22],filenotfounderror:[9,21],filepath:1,fill:[4,16],fill_data:2,filter:[0,4,12,15],filter_arg_dict:4,filter_valu:[4,15],fin:[0,12],find:[4,5,7,9,13,19,21],finish:[4,11,13,17,18,19,20],finit:[11,13,17,18],first:[0,2,4,5,9,11,12,13,16,17,18,19,21,25],first_giant_branch:0,fishlock:[0,12],fit:[0,2,4,5,12,16,25],fix:[0,2,4,5,12,16,19,20],flag:[1,4,7],flash:[0,12],flat:[2,7],flatsect:[2,13,17,19],flaw:5,float_overflow_check:[0,12],flto:[9,21],focu:13,fold:2,follow:[0,2,4,7,9,12,14,20,21],font_scal:[11,13,17,18],forc:[0,9,12,21],force_circularization_on_rlof:[0,12],force_corotation_of_primary_and_orbit:[0,12],foreach_star:[11,17],form:[0,4,5,6,11,12,13,17,18,19],formal:[0,12],format:[0,2,4,5,11,12,13,14,16,17,18,19],format_ensemble_result:4,formula:[0,12],forward:[0,12],found:[2,9,11,13,17,18,19,21],four:[0,12],fpic:1,fraction:[0,2,7,12,17],framework:12,free_persistent_data_memaddr_and_return_json_output:12,free_store_memaddr:12,frequenc:[0,12],friction:[0,12],fring:[0,12],from:[0,2,4,5,7,11,13,15,16,17,18,19,20,25],from_binary_c_config:1,from_dict:[13,17,18],fryer:[0,12],ftz:[9,21],full:[3,4,7,14],full_path:4,further:[2,19],fuv:[0,12],gaia:[0,2,12],gaia_colour_transform_method:[0,12],gaia_conversion_ubvri_bivariate_jordi2010:[0,12],gaia_conversion_ubvri_riello2020:[0,12],gaia_conversion_ubvri_univariate_evans2018:[0,12],gaia_conversion_ubvri_univariate_jordi2010:[0,12],gaia_conversion_ugriz_bivariate_jordi2010:[0,12],gaia_conversion_ugriz_riello2020:[0,12],gaia_conversion_ugriz_univariate_evans2018:[0,12],gaia_conversion_ugriz_univariate_jordi2010:[0,12],gaia_l_binwidth:[0,12],gaia_teff_binwidth:[0,12],gain:7,galact:[0,12],gallino:[0,12],gamma:[0,12],gap:[0,12],garcia:[0,12],gauss:[0,12],gaussian:2,gaussian_func:2,gaussian_normalizing_const:2,gb_reimers_eta:[0,12],gb_wind_beasor_etal_2020:0,gb_wind_goldman_etal_2017:0,gb_wind_reim:0,gb_wind_schroeder_cuntz_2005:0,gbwind:[0,12],gbwindfac:[0,12],gcc:[1,9,21],gce:[0,12],gener:[0,1,2,4,5,6,7,11,12,13,14,16,17,18,19,20],general_info:4,generalis:2,geometr:[0,12],geq:11,gerosa:[0,12],get:[0,2,3,4,5,6,9,11,14,16,17,18,19,21,22,25],get_arg_kei:4,get_default:[4,15],get_help:[4,15],get_help_al:[4,5,15],get_help_sup:[4,15],get_integration_constant_q:2,get_max_multipl:2,get_moe_di_stefano_dataset:4,get_siz:4,giant:[0,11,12],giant_branch:0,git:[0,4,17,18,19],git_branch:4,git_build:4,github:4,gitlab:9,give:[0,2,4,12,13,25],given:[0,1,2,4,5,7,12,17,18,22,25],global:[0,2,12,17,18],global_dict:2,gmax:2,gmin:2,gnu:12,goe:[0,4,5,12,14,16,20],gogo:[0,12],going:[9,21],goldman:[0,12],gonna:2,good:[0,7,12,16,17,18,19,25],got:18,gov:[0,12],gravit:[0,11,12,13,19],gravitational_const:11,gravitational_radiation_bs:0,gravitational_radiation_bse_when_no_rlof:0,gravitational_radiation_landau_lifshitz:0,gravitational_radiation_landau_lifshitz_when_no_rlof:0,gravitational_radiation_model:[0,12],gravitational_radiation_modulator_:[0,12],gravitational_radiation_modulator_j:[0,12],gravitational_radiation_non:0,grb:[0,12],great:[0,12,18],greater:[0,12],grevess:[0,12],grid:[0,3,4,5,9,10,12,14,16],grid_class:[9,10],grid_cod:5,grid_opt:[5,11,13,16,17,18,19],grid_options_default:6,grid_options_defaults_dict:6,grid_options_descript:[6,19],grid_options_description_check:6,grid_options_help:6,grid_result:[7,11,13,17,18],grid_vari:[7,19],grid_variable_numb:[5,11,13,19],gridcode_filenam:7,gridtyp:[5,11,13,19],group:[4,11,17],gsl:[9,21],gsl_dir:[9,21],guess:[0,2,12],gyr:[11,13],h5py:[9,21],hachisu:[0,12],hachisu_disk_wind:[0,12],hachisu_ignore_qcrit:0,hachisu_qcrit:[0,12],hack:6,had:[5,13,17,18],half:[0,12],hall:[0,12],handi:[0,12],handl:[0,3,4,5,7,12,16,22,25],handle_ensemble_string_to_json:4,happen:[0,11,12,13],hardcod:[14,17,18,19],has:[0,1,4,5,7,11,12,13,14,15,17,18,19],have:[0,2,3,4,5,6,7,9,11,12,13,14,16,17,18,19,20,21],haven:11,hbb:[0,12],hbbtfac:[0,12],hdf5:4,hdf5file:4,header:[1,4,11,13,14,16,17,18,19],headerlin:19,headlin:7,hegb:0,hehg:0,height:[2,13,17,19],helium:[0,11,12],helium_flash_mass_loss:[0,12],helium_white_dwarf:0,help:[0,3,4,6,12,16,17,18,19],help_al:[0,12],hem:0,henc:[0,12,13,18],hendrik:[9,21],here:[1,4,5,7,11,12,14,16,17,18,20],hertzsprung:[0,3,9,12],hertzsprung_gap:0,hertzstrpung:[0,12],heuvel:[0,12],hewd:[0,12],hewd_hewd_ignition_mass:[0,12],hex:7,high:[0,2,12,18],higher:[0,2,4,7,9,11,12,13,17,18,19,21],highlight:4,his:2,histogram:13,histori:2,hold:7,hole:[0,11,12],home:12,homogen:[0,12],hood:16,hopefulli:[0,12],hot:[0,12],how:[0,4,5,7,11,12,13,14,16,17,18,19],howev:[0,12,14,17,18,19],hoyl:[0,12],hpc:[5,8],hpc_function:[9,10],hr_diagram:20,hrd:[0,11,12,13],hrdiag:[0,12],hrdiag_output:[0,12],html:[4,9,19,21],http:[0,1,2,4,12,19],hurlei:[0,12],hut:[0,12],hybrid:[0,12],hydro:[0,12],hydrogen:[0,11,12],iadd:4,ibc:[0,12],id_cor:14,idea:[19,20],idum:[0,12],ignit:[0,11,12],ignor:[0,5,7,9,12,14,16,19,21],iia:[0,12],iloc:16,imf:[0,2,12,18],imf_chabrier2003:2,imf_scalo1986:2,imf_scalo1998:2,imf_tinsley1980:2,immedi:[0,11,12],implement:[0,4,5,7,12],impli:[0,12],implic:18,impos:[11,13,17,18,19],imposs:13,improv:2,inclin:[0,12],inclination1:[0,12],inclination2:[0,12],inclination3:[0,12],inclination4:[0,12],inclini:[0,12],incliniation_quadrupl:[0,12],incliniation_tripl:[0,12],includ:[0,1,2,4,5,9,11,12,14,16,18,19,20,21],include_binary_c_default:[5,19],include_binary_c_help_al:[5,19],include_binary_c_version_info:[5,19],include_default:[5,19],include_popul:19,include_population_set:5,incom:[0,12],increas:[0,12,13,17,18],inde:[0,12,18],indent:[4,16],index:[0,2,9,12,15,16],indic:[0,2,12],individu:[3,9,17],individual_nova:[0,12],induc:[0,12],inertia:[0,12],info:[4,5,9,12,15,19,20,21],inform:[0,1,3,4,5,6,11,14,16,17,18,19,20],init:5,init_abund:[0,12],init_abund_dex:[0,12],init_abund_mult:[0,12],init_abunds_onli:[0,12],initi:[0,2,3,5,12,15,16],initial_abundance_hash:5,initial_abundance_mix:[0,12],initial_abunds_onli:[0,12],initial_mass:16,inner:[0,12],input:[1,2,4,5,7,9,12,15,16,20,25],input_dict:4,insert:[5,19],insid:[0,12],inspect:[4,16,20],inspect_dict:4,inspir:[1,20,25],instabl:[0,12],instanc:[4,16,17,18,19],instant:[0,12],instantli:[0,12],instead:[0,4,7,12,18],integ:[0,5,7,11,12,25],integr:[2,17,18],integrals_str:2,intens:18,interact:[0,6,11,12,13],interfac:[4,9,12,13,17,21],interfer:[9,21],intermedi:13,intern:[0,7,12,15],internal_buff:[0,12],internal_buffering_off:0,internal_buffering_print:0,internal_buffering_stor:0,interpol:[2,5],interpolate_in_mass_izzard2012:2,interpolator_nam:2,intershel:[0,12],interstellar:[0,12],intger:[0,12],intro:[0,12],introduct:11,invers:25,invert_xaxi:11,involv:[0,12],inward:[0,12],ipynb:[17,18,19],is_capsul:4,isfil:19,isn:[4,18],isnt:19,isotop:[0,4,12,15],isotope_hash:5,isotope_list:5,item:[1,4,11,13,17,18],iter:4,its:[0,4,5,6,9,12,17,18,19,20,21,22],itself:[4,7,9,11,14,16,21],iwamoto:[0,12],izzard2012_period_distribut:2,izzard:[0,9,12,21],jager:[0,12],jaschek:2,jeff:[9,21],jerki:11,jia:[0,12],john:[0,12],join:[12,14,16,19],jordi:[0,12],json:[4,5,7,12,16,19],jsondecod:4,jsonencod:4,jupyt:[9,21],just:[0,2,4,5,7,11,12,13,19,25],kap:[0,12],kappa:[0,12],kaps_rentrop:[0,12],karaka:[0,12],keep:[5,13,19],kei:[1,2,4,5,6,7,15,16,19,20],kelvin:[0,12],keplerian:[0,12],keyword:[20,22],kick:[0,7,12],kick_backward:0,kick_forward:0,kick_inward:0,kick_outward:0,kick_random:0,kick_straight_up:0,kick_velocity_custom:0,kick_velocity_fix:0,kick_velocity_maxwellian:0,kill:[1,14,19],kilonova:11,kim:[0,12],kind:12,kippenhahn:[0,12],know:[0,1,6,12,15,16,18],known:[0,2,5,11,12,16,17,18,19,22],kroupa2001:[2,5,19],kroupa:[2,18],krticka:[0,12],ktg93:2,kwarg:[5,20,22],label:11,lambda:[0,12,13],lambda_:13,lambda_c:[0,12,13],lambda_ce_dewi_tauri:0,lambda_ce_klencki_2020:0,lambda_ce_polytrop:0,lambda_ce_wang_2016:0,lambda_enthalpi:[0,12],lambda_ionis:[0,12],lambda_min:[0,12],lambda_mult:[0,12],lambda_multipli:[0,12],lambda_v:2,lamer:[0,12],landau:[0,12],langer:[0,12],languag:11,larger:[0,11,12],last:[2,3],lastli:[12,16],later:[17,18],latter:[0,12],law:[2,18],law_const:2,lbv:[0,12],ld_library_path:[9,21],ldist:18,lead:[0,11,12,17,18,19,25],learn:14,least:[9,21],leav:[0,12],left:[0,12],legaci:[0,12],legacy_yield:[0,12],len:[11,16,19],lengthen:[0,12],leq:11,less:[0,1,2,3,12,16],let:[5,13,16,17,18,19],level:[1,4,5],li7:[0,12],lib:[9,12,16,21],libbinary_c:7,libcustom_logging_5d7779e8190e4b79b10c7e6a44cb0e7:16,libcustom_logging_8967553693ac4e11a49c42d4eef773e8:16,libgsl:[9,21],libmemo:[9,21],librari:[0,1,5,7,12,14,22],library_path:[9,21],librinterpol:[9,21],lies:[0,12],life:13,lifetim:[0,12,13,17,18,19],lifshitz:[0,12],like:[0,1,4,5,7,9,11,12,13,17,18,19,20,21,23],limit:[0,11,12,13,17,18,19,20],line:[1,4,5,7,9,11,13,14,16,17,18,19,20,21],linear2:7,linear:[0,2,7,12,17,18],linear_extrapolation_q:2,linearli:[18,23],linedata:[11,13,17,18],lineplot:[11,13,17,18],linewidth:[11,13,17,18],linker:1,linspac:23,linux:12,list:[0,1,2,4,7,11,12,13,16,17,18,19,22,23],list_arg:[0,12],list_of_sub_kei:2,lit:[0,12],lithium:[0,12],lithium_gb_post_1dup:[0,12],lithium_gb_post_heflash:[0,12],lithium_hbb_multipli:[0,12],lithium_t:[0,12],littl:[11,13,17],littleton:[0,12],liu:[0,12],llnl:[0,12],lnm1:[5,13,17,18,19],lnm_1:18,load:[0,1,4,5,7,11,12,13,14,16,17,18,19,20],load_logfil:4,lobe:[0,12,13,25],local:2,locat:[0,2,7,9,12,21],lodder:[0,12],log10:[0,2,11,12,13,17,18,19],log10m1:7,log10p:2,log10per:[13,17,19],log10pmin:2,log:[0,1,2,3,4,5,7,9,12,16,20,21,22,25],log_:[11,13,17,18],log_arg:7,log_args_dir:7,log_arrow:[0,12],log_dt:[7,13],log_every_timestep:[14,16],log_fil:7,log_filenam:[0,12,16,22],log_runtime_system:7,logarithm:[2,18],logensembletim:[0,12],logfil:[4,9,16,21],logg:[0,11,12],logger:19,logging_dict:1,logging_lin:14,loggrav:11,logic:[1,5,7,14],logl:11,logmass:2,logp:2,logper:[2,13],logperiod:2,logperrang:[13,17],logteff:11,long_spectral_typ:2,longer:[0,11,12,13],longnam:[5,11,13,17,18,19],look:[1,4,9,11,13,17,18,19,21],lookback:[0,12],loon:[0,12],loop:[5,11,13,16,17,18,19],loos:20,lose:[0,12],loss:[0,12,16,17],lost:[0,12,13],lot:[4,7,11,17,18,19,22],low:[0,2,11,12,13,18],low_mass_m:0,low_mass_main_sequ:0,lower:[0,2,5,12,17,19,23],lsoda:[0,12],lsun:[0,12,20],lugaro:[0,12],luminos:[0,3,9,11,12,20],luminosity_1:20,luminosity_2:20,luminosu:11,lynnett:[0,12],m_1:[0,5,11,12,13,14,15,16,17,18,19,22],m_2:[0,11,12,13,14,16,17,19],m_3:[0,12],m_4:[0,12],m_max:[2,5,19],m_min:[5,19],m_sun:11,maccretor:[0,12],machin:[7,9,13,21],macro:[0,4,12,15],madau:2,made:11,maeder:[0,12],magellan:[0,12],magnet:[0,12],magnetic_braking_algorithm:[0,12],magnetic_braking_algorithm_andronov_2003:0,magnetic_braking_algorithm_barnes_2010:0,magnetic_braking_algorithm_hurley_2002:0,magnetic_braking_algorithm_rappaport_1983:0,magnetic_braking_factor:[0,12],magnetic_braking_gamma:[0,12],magnitud:4,mai:[0,12,13,17],main:[0,1,7,9,11,12,14,17,18,19,21],main_sequ:[0,12,17,18],mainli:8,mainprocess:[13,17],major:[0,12],make:[0,1,2,4,5,7,9,11,12,13,16,17,18,19,20,21,22],make_build_text:4,makedir:[4,19],manag:[4,9,21],mani:[0,5,7,11,12,13,15,17,18,19],manual:14,manufactur:[0,12],map:7,maria:[0,12],mass:[0,1,2,3,4,5,7,11,12,13,15,16,17,19,20,22,25],mass_1:[19,20],mass_2:[19,20],mass_accretion_for_eld:[0,12],mass_accretor:25,mass_donor:25,mass_evolut:20,mass_for_hestar_ia_low:[0,12],mass_for_hestar_ia_upp:[0,12],mass_of_pmz:[0,12],mass_str:2,massiv:[0,2,11,12,13,17],massless:[0,12],massless_remn:0,massrang:[11,13,17,18],master:[7,20],match:[0,4,11,12,16,17,19,20],materi:[0,11,12],math:[5,11,13,17,18,19],mathrm:[11,13,17,18],matplotlib:[9,11,13,18,20,21],matter:[0,12],mattsson:[0,12],mattsson_mass_loss:[0,12],mattsson_orich_tpagbwind:[0,12],max:[0,2,12,13,14,17,18,19],max_bound:[2,23],max_column:[11,13],max_evolution_tim:[0,1,11,12,13,14,16,17,18,19],max_hewd_mass:[0,12],max_model_numb:[0,12],max_multipl:2,max_neutron_star_mass:[0,12],max_queue_s:7,max_row:[11,13],max_stellar_angmom_chang:[0,12],max_stellar_type_1:[0,12],max_stellar_type_2:[0,12],max_stellar_type_3:[0,12],max_stellar_type_4:[0,12],max_tim:16,max_val:2,maximum:[0,2,7,11,12,13,14,17,18,25],maximum_mass_ratio_for_instant_rlof:[0,12],maximum_mass_ratio_for_rlof:25,maximum_mcbagb_for_degenerate_carbon_ignit:[0,12],maximum_nuclear_burning_timestep:[0,12],maximum_timestep:[0,12],maximum_timestep_factor:[0,12],maxmimum:[0,12],maxwellian:[0,12],mayb:20,mayor:2,mc13_pocket_multipli:[0,12],mch:[0,12],mcmin:[0,12],mdonor:[0,12],mean:[0,2,4,5,7,9,12,21],meant:7,measur:4,medium:[0,12],mega:2,mem:[13,17],memaddr:[12,13,14,17],memori:[1,5,7,12,14,25],menv:[0,12],merg:[0,2,4,7,11,12,13],merge_dict:[4,15],merge_multipl:2,merger:[0,12],merger_angular_momentum_factor:[0,12],merger_mass_loss_fract:[0,12],mesa:[9,21],mesasdk_init:[9,21],mesasdk_root:[9,21],messag:4,messi:11,mestel:[0,12],met:[5,19],metal:[0,2,11,12,13,14,16,17,18,19,25],method:[0,5,7,12,14,16,17,18,19],meynet:[0,12],might:[4,5,9,13,17,19,21],milki:[0,12],miller:[0,12],min:[2,13,14,17,18,19],min_bound:[2,23],min_p:2,min_per:2,min_val:2,minimal_verbos:4,minimum:[0,2,4,7,12,25],minimum_co_core_mass_for_carbon_ignit:[0,12],minimum_co_core_mass_for_neon_ignit:[0,12],minimum_donor_menv_for_comenv:[0,12],minimum_envelope_mass_for_third_dredgeup:[0,12],minimum_helium_ignition_core_mass:[0,12],minimum_mcbagb_for_nondegenerate_carbon_ignit:[0,12],minimum_orbital_period_for_instant_rlof:[0,12],minimum_period_for_rlof:25,minimum_separation_for_instant_rlof:[0,12],minimum_separation_for_rlof:25,minimum_time_between_pn:[0,12],minimum_timestep:[0,12],mint:[0,12],mint_data_cleanup:[0,12],mint_dir:[0,12],mint_disable_grid_load_warn:[0,12],mint_fallback_to_test_data:[0,12],mint_hard_max_nshel:[0,12],mint_hard_min_nshel:[0,12],mint_kippenhahn:[0,12],mint_kippenhahn_companion_stellar_typ:[0,12],mint_kippenhahn_stellar_typ:[0,12],mint_maximum_nshel:[0,12],mint_maximum_shell_mass:[0,12],mint_metal:[0,12],mint_minimum_nshel:[0,12],mint_minimum_shell_mass:[0,12],mint_ms_rejuven:[0,12],mint_nshel:[0,12],mint_nuclear_burn:[0,12],mint_remesh:[0,12],mint_use_zams_profil:[0,12],minut:13,mira:[0,12],misc:[9,12],miscellan:[4,15],miss:[0,4,6,12,17,18],mix:[0,4,7,12],mixtur:[0,12,17],mmax:[2,18],mmin:[2,7,18],mnra:25,model:[0,1,7,11,12,13,14,16,17,18,19],model_numb:[17,18],modif:3,modifi:[0,12,14],modul:[0,6,7,10,12,13,15,17,18,19],modulo:7,moe:[2,4,5,9,19],moe_di_stefano_2017:5,moe_di_stefano_2017_multiplicity_fract:2,moe_di_stefano_2017_pdf:2,moment:[0,11,12,14,19,23],momenta:[0,12,20],momentum:[0,12],monoton:18,mont:[0,7,12],monte_carlo_kick:[0,12],more:[0,1,3,4,5,7,9,12,13,14,15,16,17,18,19,20,21,23],most:[4,11,12,13,18],mostli:[4,6,7,11,13,17,18,19,20,22],move:[0,11,12],msun:[0,2,11,12,14,16,17,18],much:[0,4,11,12,13,17,19],multi:7,multipl:[0,2,4,7,11,12],multiplc:[0,12],multipli:[0,4,7,12,18],multiplicity_arrai:2,multiplicity_fraction_funct:7,multiplicity_model:7,multiplicity_modul:7,multiply_values_dict:[4,15],multiprocess:7,must:[0,2,11,12,13,16,17,18,19],my_stellar_data:[1,14,19],myr:[0,11,12,13,16,17,18],n100:[0,12],n100_z0:[0,12],n100h:[0,12],n100l:[0,12],n10:[0,12],n150:[0,12],n1600:[0,12],n1600c:[0,12],n200:[0,12],n20:[0,12],n300c:[0,12],n40:[0,12],naked_helium_star_giant_branch:0,naked_helium_star_hertzsprung_gap:0,naked_main_sequence_helium_star:0,name:[1,4,5,6,11,12,13,15,17,18,19,22,24],narrow:18,natur:[0,12,18],nauenberg:[0,12],nearer:[0,12],nearest:[13,17,18],nebula:[0,12],necessari:[4,5,13,19],need:[0,2,5,9,12,14,16,17,18,19,21],neg:[0,4,12],neither:[0,5,12],neleman:[0,12],nelemans_gamma:[0,12],nelemans_max_frac_j_chang:[0,12],nelemans_minq:[0,12],nelemans_n_comenv:[0,12],nelemans_recalc_eccentr:[0,12],nemp:[0,12],nemp_cfe_minimum:[0,12],nemp_nfe_minimum:[0,12],nenamg:[0,12],neon:[0,11,12],nest:[4,5,19],network:[0,12,15],neutrn:[0,12],neutron:[0,11,12,19],neutron_star:0,never:[0,11,12,18],newdict:4,newer:[0,2,12],newli:[0,12],newmast:0,newnam:5,newopt:2,newton:[0,12],next:[4,17,18,19],nice:[1,5,20],nieuwenhuijzen:[0,12],nieuwenhuijzen_windfac:[0,12],nine:11,nmax:2,no_thermohaline_mix:[0,12],noecho:[0,12],noechonow:[0,12],noel:[0,12],nolowq:7,nomin:[0,12],non:[0,7,12,18],nonconservative_angmom_gamma:[0,12],none:[0,1,2,4,5,6,7,11,12,13,17,18,19,25],nonetyp:19,nonzero:7,nor:[0,12],norm:7,normal:[0,4,12],normalis:[2,7],normalize_dict:2,normalize_multipl:7,notabl:19,note:[0,4,5,7,11,12,17,18],notebook:[9,11,12,13,14,15,16,17,18,19,21],notebook_api_funct:16,notebook_comenv:13,notebook_custom_log:[16,17,18,19],notebook_hrd:11,notebook_individual_system:[14,16,17,18,19],notebook_luminos:18,notebook_luminosity_funct:17,notebook_luminosity_function_binari:18,notebook_popul:[16,19],noteworthi:3,noth:[5,7],notic:18,notifi:22,nova:[0,11,12,13],nova_faml_multipli:[0,12],nova_irradiation_multipli:[0,12],nova_retention_algorithm_claeys2014:0,nova_retention_algorithm_const:0,nova_retention_algorithm_hillman2015:0,nova_retention_fract:[0,12],nova_retention_method:[0,12],nova_timestep_accelerator_index:[0,12],nova_timestep_accelerator_max:[0,12],nova_timestep_accelerator_num:[0,12],now:[0,2,4,5,11,12,13,14,16,17,18,19],nre:17,nsep:13,nsep_max:13,nsep_min:13,nstar:[11,17],nuclear:[0,12],nuclear_mass_hash:5,nuclear_mass_list:5,nucleosynthesi:[0,4,12],nucleosynthesis_sourc:[4,15],nucreacmult:[0,12],nucsyn:[9,12],nucsyn_angelou_lithium:[0,12],nucsyn_gce_outflow_check:[0,12],nucsyn_hbb:[0,12],nucsyn_init_abund_mix_ag89:0,nucsyn_init_abund_mix_asplund2005:0,nucsyn_init_abund_mix_asplund2009:0,nucsyn_init_abund_mix_garciaberro:0,nucsyn_init_abund_mix_grevesse_noels_1993:0,nucsyn_init_abund_mix_karakas2002:0,nucsyn_init_abund_mix_kobayashi2011_asplund2009:0,nucsyn_init_abund_mix_lodders2003:0,nucsyn_init_abund_mix_lodders2010:0,nucsyn_metal:[0,12],nucsyn_network:[0,12],nucsyn_network_error:[0,12],nucsyn_s_process:[0,12],nucsyn_solv:[0,12],nucsyn_solver_cvod:0,nucsyn_solver_kaps_rentrop:0,nucsyn_solver_lsoda:0,nucsyn_solver_numb:0,nucsyn_third_dredge_up:[0,12],nugi:[0,12],num_ansi_colour:[0,12],number:[0,2,4,5,7,9,11,12,13,17,18,19,21],numer:4,numpi:[4,9,16,21,23],obj:4,object:[0,3,4,5,7,8,12,20],object_hook:4,object_pairs_hook:4,object_parse_funct:16,observ:[17,18],obtain:[0,11,13,17,18],obvious:14,occur:[0,12,25],odot:[11,13],off:[0,12,19],off_m:16,offset:[0,12],ohio:[0,12],old:[5,7,18],old_solut:[9,21],oldnam:5,omega:[0,12],onc:[0,12],one:[0,4,5,7,12,15,18,19,20],onewd:0,onli:[0,4,5,7,11,12,14,17,18,19,25],onset:[0,12],onto:[0,2,12],opac:[0,12],opacity_algorithm:[0,12],opacity_algorithm_ferguson_op:0,opacity_algorithm_paczynski:0,opacity_algorithm_star:0,opal:[0,12],open:[16,19],oper:4,opm:2,opt:[2,4,12],option:[0,1,2,4,5,9,10,11,12,13,17,18,19,21,25],orb:[5,13,19],orbit:[0,2,12,13,17,20,25],orbit_evolut:20,orbital_inclin:[0,12],orbital_inclinationi:[0,12],orbital_period:[0,12,13,14,16,17,19,25],orbital_period_quadrupl:[0,12],orbital_period_tripl:[0,12],orbital_phas:[0,12],orbital_phase_quadrupl:[0,12],orbital_phase_tripl:[0,12],orbiting_object:[0,12],orbiting_objects_close_pc_threshold:[0,12],orbiting_objects_log:[0,12],orbiting_objects_tides_multipli:[0,12],orbiting_objects_wind_accretion_multipli:[0,12],order:[3,4,5,19],ordereddict:4,org:[0,2,4,12],orient:13,origin:[9,21],other:[0,1,2,4,6,7,9,11,12,15,16,17,18,19,20,21],otherwis:[0,4,5,6,7,12],our:[11,13,17,18],out:[4,6,7,11,13,14,15,17,18],outcom:[0,12],outer:[0,11,12],outermost_core_mass:11,outfil:[5,19],outfile_nam:1,outfilenam:19,output:[1,3,4,5,7,9,12,14,15,16,20,21,22,25],output_dict:16,output_dir:[5,16,19],output_fil:[4,6,16],output_filenam:[5,19],output_lin:4,outsid:[0,2,12],outward:[0,12],over:[4,5,11,13,15,16,17,18,19],overflow:[0,12,13],overlap:4,overrid:[2,4,5],overriden:19,overshoot:[0,12],overspin_algorithm:[0,12],overspin_bs:[0,12],overspin_massloss:[0,12],overview:12,own:[5,7,9,14,16,19,21],oxygen:[0,11,12],oxygen_neon_white_dwarf:0,packag:[4,9,12,19,21,23],paczynski:[0,12],pad:[13,17,18],pad_output_distribut:[4,11,13,17,18],page:[0,9,12,19,21],pair:[4,5],panda:[4,9,11,13,16,17,18,20,21],pane:20,panel:[0,12],paper:[0,12],param:[4,5],param_nam:4,paramet:[1,2,3,4,5,6,7,9,11,12,13,14,16,17,18,19,20,22,23,25],parameter_nam:[4,5,11,12,13,15,17,18,19],parameter_value_input_typ:[4,15],pars:[3,4,5,11,13,16,17,18,19,20,22],parse_binary_c_version_info:4,parse_cmdlin:5,parse_const:4,parse_data:13,parse_float:4,parse_funct:[5,7,11,13,16,17,18,19,22],parse_function_hr_diagram:20,parse_function_mass:20,parse_function_orbit:20,parse_int:4,parsec:2,part:[2,5,11,12,16,17,18,19,25],partial:[0,12],particularli:[0,12],pasp:2,pass:[5,7,9,12,14,16,19,20,21,22],path:[4,7,9,16,19,21],patho:[9,21],pdf:[0,2,9,12,21],peak:[13,18],pend:[0,12],per:[0,4,5,7,12,13,16,17,19,25],percentag:[0,12],peret:[0,12],perfect:18,perfectli:[17,18],perform:[0,12],perhap:[0,11,12,13],periastron:[0,12],pericent:25,period:[0,2,12,13,14,16,17,18,19,20,25],period_str:2,perl:[1,4,17,18,19],persist:12,persistent_data:12,pgo:[0,12],phase:[0,11,12,13,17,18],phasevol:[0,12,19],photoevapor:[0,12],php:2,physic:[11,17,18,19],pick:20,piec:[5,19],pinnsonneault:[0,12],pkg:[9,21],place:[0,4,12,17],placehold:20,plai:[0,12,18],plan:7,planetari:[0,12],plaw2:7,pleas:[0,4,11,12,17,18,19],plot:[0,11,12,13,16,17,18,20],plot_data:[13,17,18],plot_funct:[9,10],plot_hr_diagram:20,plot_hr_diagram_singl:20,plot_mass:20,plot_orbit:20,plot_system:20,plot_typ:20,pls:5,plt:[11,13,18],plu:[0,12],pms:20,pms_mass_1:20,pms_mass_2:20,pn_comenv_transition_tim:[0,12],pn_fast_wind:[0,12],pn_fast_wind_dm_agb:[0,12],pn_fast_wind_dm_gb:[0,12],pn_fast_wind_mdot_agb:[0,12],pn_fast_wind_mdot_gb:[0,12],pn_hall_fading_time_algorithm:[0,12],pn_hall_fading_time_algorithm_maximum:[0,12],pn_hall_fading_time_algorithm_minimum:[0,12],pn_resolv:[0,12],pn_resolve_maximum_envelope_mass:[0,12],pn_resolve_minimum_effective_temperatur:[0,12],pn_resolve_minimum_luminos:[0,12],pne:[0,12],pogg:[0,12],point:[0,2,4,5,9,11,12,21],poisson:[2,7],pol:[0,12],polytrop:[0,12],poor:18,pop:14,pop_macro:14,popul:[0,2,3,5,6,8,9,12,21,23],population_id:7,population_nam:[11,13,17,18,19],population_set:5,posit:[0,2,12,13],possibl:[0,1,2,4,6,9,11,12,16,21],post:[0,11,12,13,14],post_ce_adaptive_menv:[0,12],post_ce_envelope_dm_eagb:[0,12],post_ce_envelope_dm_gb:[0,12],post_ce_envelope_dm_tpagb:[0,12],post_ce_objects_have_envelop:[0,12],post_comenv_period:13,post_sn_orbit_bs:0,post_sn_orbit_method:[0,12],post_sn_orbit_tt98:0,postagb_legacy_log:[0,12],postagb_wind_gi:0,postagb_wind_krticka2020:[0,12],postagb_wind_non:[0,12],postagb_wind_use_gi:[0,12],postagbwind:[0,12],potenti:[0,12],pow2:11,power:[0,2,12,13,18],powerlaw:2,powerlaw_const:2,powerlaw_extrapolation_q:2,ppn_envelope_mass:[0,12],pragma:14,pre:[0,12,13,20],pre_comenv_period:13,pre_events_stardata:[0,12],pre_main_sequ:[0,12],pre_main_sequence_fit_lob:[0,12],precis:4,precod:[5,11,13,17,18,19],predefin:[2,17,18,19],predict:7,predictor:[0,12],prefer:[0,5,12],prefix:[0,12],prepar:2,prepare_dict:2,prescrib:[0,12],prescript:[0,12,19],prescrit:[0,12],present:[2,4,5,11,17,18,19],preserv:[0,12],preset:20,pressur:[0,12],prev_stellar_type_1:19,prev_stellar_type_2:19,prevent:[0,7,11,12],previou:[4,13,18],previous:[16,19],previous_stardata:[1,13,14,16,19],primari:[1,2,5,11,13,17,18,19,25],prime:13,pringl:[0,12],print:[4,5,6,7,11,12,13,14,15,16,17,18,19],print_help:[4,15],print_info:6,print_option_descript:6,print_structur:4,printf:[1,11,13,14,16,17,18,19],prior:[0,11,12],privat:[5,6,9],prob_dict:2,probability_weighted_mass:7,probabl:[0,1,2,5,6,7,11,12,13,14,17,18,19,20],probdist:[5,11,13,17,18,19],problem:[0,12,17],probtot:18,process:[0,4,5,7,11,12,13,17,18,19],processor:[13,17],produc:11,profil:[0,12],progenitor:[0,12,19],program:[9,11,21],project:[0,12],proper:[6,11,14],properli:[0,5,12],properti:[0,4,5,7,20],proport:13,prot1:[0,12],prot2:[0,12],prot3:[0,12],prot4:[0,12],provid:[0,2,5,7,12,19,22],pseudorandom:[0,12],publicli:14,puls:[0,11,12,25],pump:[0,12],purpos:[7,17,18,19,20],push_macro:14,put:[1,4,5,7,11,17,18,19,20],py_rinterpol:[9,21],pyenv:[9,12,21],pyplot:[11,13,18],pysiz:4,pytest:[9,21],python3:[9,12,21],python:[3,4,11,13,17,18],q_high_extrapolation_method:7,q_interpol:2,q_low_extrapolation_method:7,qcrit_bh:[0,12],qcrit_bs:0,qcrit_cheb:[0,12],qcrit_chen_han_formula:0,qcrit_chen_han_t:0,qcrit_cowd:[0,12],qcrit_degenerate_bh:[0,12],qcrit_degenerate_cheb:[0,12],qcrit_degenerate_cowd:[0,12],qcrit_degenerate_eagb:[0,12],qcrit_degenerate_gb:[0,12],qcrit_degenerate_hegb:[0,12],qcrit_degenerate_hehg:[0,12],qcrit_degenerate_hem:[0,12],qcrit_degenerate_hewd:[0,12],qcrit_degenerate_hg:[0,12],qcrit_degenerate_lmm:[0,12],qcrit_degenerate_m:[0,12],qcrit_degenerate_n:[0,12],qcrit_degenerate_onewd:[0,12],qcrit_degenerate_tpagb:[0,12],qcrit_eagb:[0,12],qcrit_gb:[0,12],qcrit_gb_bs:0,qcrit_gb_chen_han_formula:0,qcrit_gb_chen_han_t:0,qcrit_gb_ge2015:0,qcrit_gb_hjellming_webbink:0,qcrit_gb_q_no_comenv:0,qcrit_gb_temmink2021:0,qcrit_gb_vos2018:0,qcrit_ge2015:0,qcrit_hegb:[0,12],qcrit_hehg:[0,12],qcrit_hem:[0,12],qcrit_hewd:[0,12],qcrit_hg:[0,12],qcrit_hjellming_webbink:0,qcrit_lmm:[0,12],qcrit_m:[0,12],qcrit_n:[0,12],qcrit_onewd:[0,12],qcrit_q_no_comenv:0,qcrit_temmink2021:0,qcrit_tpagb:[0,12],qcrit_vos2018:0,qcrits_:[0,12],qcrits_degenerate_:[0,12],qdata:2,qlimit:2,quad:7,quadrat:[0,12],quadrulpl:[0,12],quadrupl:[0,2,7,12],quantiti:20,queri:16,queue:7,quickli:16,quit:[0,4,11,12],r_l:25,r_sun:11,radau:[0,12],radi:[0,12],radiat:[0,12],radii:[0,12,25],radiu:[0,1,11,12,14,19,20,25],radius_1:20,radius_2:20,ragb:25,raghavan2010_binary_fract:2,raghavan:2,rai:[0,12],railton:[0,12],rais:[0,4,7,12,19],ram:[0,12],ran:[7,13,17],random:[0,7,12],random_count:16,random_se:[0,12,16],random_skip:[0,12],random_system:[0,12],random_systems_se:[0,12],rang:[0,2,5,7,11,12,13,16,17,18,19,23],rapid:[0,12],rapidli:[0,12],rappaport:[0,12],rate:[0,2,12,18],rather:[0,4,5,7,9,12,14,16,19,21],ratio:[0,2,11,12,13,17,18,19,25],raw:[4,5,7,12,20,22],raw_output:4,reach:[0,11,12,13],reaction:[0,12],read:[3,4,16,19],real:[5,11,17,19],realist:18,realiti:18,realli:[0,5,6,7,11,12,19],reason:[0,12,18],rebuild:[0,9,12,21],rebuilt:[9,21],recalcul:[0,12],receiv:4,recogn:19,recombin:[0,12],recommend:[1,3],recompil:[9,17,18,19,21],recurs:[4,5],recursive_change_key_to_float:4,recursive_change_key_to_str:4,red:[0,11,12,18],redhat:1,redshift:2,reduc:[0,12],reduct:7,refer:4,regardless:20,region:[0,12],regist:19,reignit:[0,12],reimer:[0,12],reinstal:[9,21],reject:[0,12],rejects_in_log:[0,12],rejuven:[0,12,17],rel:[0,12],relat:[0,12],releas:[4,9,21],reliabl:12,remain:[0,12],rememb:[11,18],remesh:[0,12],remnant:[0,11,12],remov:[0,4,5,9,12,13,16,19,21],remove_fil:4,renam:[5,18],rename_grid_vari:[5,18],renormalis:2,rentrop:[0,12],repeat:[0,7,12],repo:[9,21],report:[0,11,12,13,17,18,19],repositori:3,repres:7,represent:[4,5,19],reproduc:[0,12],requir:[0,2,4,11,12,13,16,17,18,19,20,22],rerun:11,res:[11,13,17,18],reset:[0,12],reset_pref:[0,12],reset_star:[0,12],reset_stars_default:[0,12],resolut:[0,5,7,11,12,13,17,18,19],resolv:[0,12,17],reson:[0,12],resourc:18,respect:[0,2,12],rest:[2,5,19],restructuredtext:4,result:[0,1,2,4,5,7,9,11,12,13,16,17,18,19,21],result_arrai:2,result_dict:2,results_dictionari:[11,13,17,18],retain:[0,12],rethink:4,return_all_info:5,return_arglin:12,return_binary_c_default:5,return_binary_c_version_info:[4,5,15],return_compilation_dict:1,return_help:12,return_help_al:[4,12],return_maximum_mass_ratio_for_rlof:[12,25],return_minimum_orbit_for_rlof:[12,25],return_persistent_data_memaddr:12,return_population_set:5,return_store_memaddr:12,return_version_info:[4,12],reus:5,revap_in:[0,12],revap_out:[0,12],revers:[0,12,20],reverse_tim:[0,12],revis:[0,4],rewrit:5,rgb:11,rhagavan:7,ri0005:19,rich:[0,12],riello:[0,12],rin:[0,12],ring:[0,12],risk:[5,19],ritter:[0,12],rk2:[0,12],rk4:[0,12],rlof:[0,12,25],rlof_angular_momentum_transfer_model:[0,12],rlof_angular_momentum_transfer_model_bs:0,rlof_angular_momentum_transfer_model_conserv:0,rlof_eccentric_as_circular:[0,12],rlof_entry_threshold:[0,12],rlof_f:[0,12],rlof_interpolation_binary_c:0,rlof_interpolation_bs:0,rlof_interpolation_method:[0,12],rlof_mdot_factor:[0,12],rlof_mdot_modul:[0,12],rlof_method:[0,12],rlof_method_adapt:0,rlof_method_adaptive2:0,rlof_method_bs:0,rlof_method_claei:0,rlof_method_ritt:0,rlof_nonconservative_gamma_donor:0,rlof_nonconservative_gamma_isotrop:0,rlof_radiation_correct:[0,12],rlof_transition_objects_escap:[0,12],rob:[0,2,12,25],robert:[9,21],roch:[0,12,13,25],roche_lob:25,rochelob:25,rol1:16,rol2:16,room:[5,19],root:[9,21],rotat:[0,2,12],rotation:[0,12],rotationally_enhanced_expon:[0,12],rotationally_enhanced_mass_loss:[0,12],rotationally_enhanced_massloss:[0,12],rotationally_enhanced_massloss_angmom:0,rotationally_enhanced_massloss_langer_formula:[0,12],rotationally_enhanced_massloss_langer_formula_and_angmom:0,rotationally_enhanced_massloss_non:0,rough:11,rout:[0,12],routin:[0,3,5,9,12,20],row:[16,20],rring:[0,12],rssd:2,rst:[4,6],rsun:[11,20],rubric:5,run:[0,1,3,4,5,7,9,11,12,13,17,18,21,22],run_popul:12,run_system:[12,14,15,16,20,22],run_system_wrapp:[9,10,14,16],run_wrapp:3,run_zero_probability_system:7,runtim:[1,7],russel:[0,3,9,12],rzam:25,s_option:7,safe:19,sai:[0,11,12],said:[0,12],same:[0,4,7,9,12,16,21],sampl:[0,2,3,5,12,17,19,23],sample_valu:2,sampler:9,sana12:[2,13,17,19],sana:2,save:[0,1,2,12,13,14,17,18,19],save_pre_events_stardata:[0,12],scalar:4,scalo:2,scanf:0,scheme:[0,12],schneider:[0,12],schroeder:[0,12],script:[3,9,14,21],sdb:[0,12],sdist:[9,21],sdo:[0,12],seaborn:[11,13,17,18],search:[9,11,17],second:[0,2,4,5,12,13,20],secondari:[2,11,17,25],section:[2,4,8,9,12,19,21],see:[0,5,9,11,12,13,14,15,16,17,18,19,20,21],seed:[0,12],seem:[9,20,21],seen:4,segment:23,seitenzahl2013_model:[0,12],seitenzahl:[0,12],select:[0,4,12,16,17],selected_head:4,selector:[0,12],self:[5,7,11,13,16,17,18,19],semi:[0,12],sent:[0,12],sentenc:1,sep:[0,2,5,13,16,17,19,25],sep_max:[13,17,19],sep_min:[13,17,19],separ:[0,2,4,5,6,11,12,14,16,19,20,25],separation_quadrupl:[0,12],separation_tripl:[0,12],separta:[0,12],seper:19,sequenc:[0,11,12,14,17,18],sequnec:[17,18],seri:[0,12],serialis:[4,5],serv:4,server:5,set:[0,1,2,3,4,5,6,7,9,14,15,16,20,21],set_context:[11,13,17,18],set_moe_di_stefano_set:5,set_opt:[2,11,13],set_xlabel:[11,13,17,18],set_ylabel:[11,13,17,18],setup:[9,11,19,21,22],sever:[6,7,15,19,20,22],sfh:2,shara:[0,12],share:[1,7,16,22],shared_lib_filenam:14,shell:[0,12],shellular:[0,12],shorten:[0,12],shortli:11,should:[0,1,2,4,5,6,7,9,11,12,13,16,17,18,19,20,21,22],shouldn:[0,4,12],show:[0,3,7,11,12,13,16,17,18,19,20],show_plot:20,show_stellar_typ:20,shown:[0,12,20],shrink:13,shrinkagb:16,side:[17,18,19],siess:[0,12],sigma:2,signal:[13,17],silent:4,sill:[0,12],sim10:13,sim:11,simpl:[11,13,17],simplest:16,simpli:[0,12,18],simul:[0,1,11,12,13,14,17,18,19],simulation_:5,sinc:[4,20],singl:[0,2,3,5,7,11,12,17,18,19,20],single_star_lifetim:[12,14,16],sit:[0,12],site:12,situat:12,size:[4,7],skip:[0,4,7,9,12,13,17,21],skipkei:4,slightli:12,slope:2,slow:[0,11,12,13,17,18],slower:[0,12],slurm:[5,7,8],slurm_grid:5,small:[0,12,18],small_envelope_method:[0,12],small_envelope_method_bs:0,small_envelope_method_miller_bertolami:0,smaller:[0,12],smarter:18,smooth:[11,18],smoother:[13,18],sn_impulse_liu2015:0,sn_impulse_non:0,sn_impulse_wheeler1975:0,sn_kick_companion_a:[0,12],sn_kick_companion_aic_bh:[0,12],sn_kick_companion_bh_bh:[0,12],sn_kick_companion_bh_n:[0,12],sn_kick_companion_ecap:[0,12],sn_kick_companion_grb_collapsar:[0,12],sn_kick_companion_hestaria:[0,12],sn_kick_companion_ia_chand:[0,12],sn_kick_companion_ia_chand_co:[0,12],sn_kick_companion_ia_eld:[0,12],sn_kick_companion_ia_h:[0,12],sn_kick_companion_ia_he_co:[0,12],sn_kick_companion_ia_hybrid_hecowd:[0,12],sn_kick_companion_ia_hybrid_hecowd_sublumin:[0,12],sn_kick_companion_ibc:[0,12],sn_kick_companion_ii:[0,12],sn_kick_companion_iia:[0,12],sn_kick_companion_ns_n:[0,12],sn_kick_companion_tz:[0,12],sn_kick_companion_wdkick:[0,12],sn_kick_dispersion_aic_bh:[0,12],sn_kick_dispersion_bh_bh:[0,12],sn_kick_dispersion_bh_n:[0,12],sn_kick_dispersion_ecap:[0,12],sn_kick_dispersion_grb_collapsar:[0,12],sn_kick_dispersion_ia_hybrid_hecowd:[0,12],sn_kick_dispersion_ia_hybrid_hecowd_sublumin:[0,12],sn_kick_dispersion_ibc:[0,12],sn_kick_dispersion_ii:[0,12],sn_kick_dispersion_ns_n:[0,12],sn_kick_dispersion_tz:[0,12],sn_kick_distribution_aic_bh:[0,12],sn_kick_distribution_bh_bh:[0,12],sn_kick_distribution_bh_n:[0,12],sn_kick_distribution_ecap:[0,12],sn_kick_distribution_grb_collapsar:[0,12],sn_kick_distribution_ia_hybrid_hecowd:[0,12],sn_kick_distribution_ia_hybrid_hecowd_sublumin:[0,12],sn_kick_distribution_ibc:[0,12],sn_kick_distribution_ii:[0,12],sn_kick_distribution_ns_n:[0,12],sn_kick_distribution_tz:[0,12],sn_none:14,sn_type:14,sneia:[0,12],snia:[0,12],snippet:[12,16],sns:[11,13,17,18],solar:[0,2,11,12,13,15,25],solver:[0,12],solver_forward_eul:0,solver_predictor_corrector:0,solver_rk2:0,solver_rk4:0,some:[0,1,2,5,7,9,11,12,13,14,15,16,17,18,19,20,21],someth:[0,5,11,12,13,16,17,18],sometim:15,somewhat:[17,18,19],soon:23,sort:[4,11,17,18],sort_kei:4,sourc:[1,2,4,5,6,7,10,13,20,22,23,25],source_file_filenam:7,source_list:5,sourcecod:[9,12,14,21],sourcefile_nam:1,space:[0,5,11,12,17,18,19,23],spacing_funct:[9,10],spacingfunc:[5,11,13,17,18,19],spacingfunct:[5,19],special:[0,12,19],specif:[0,4,12,15,16,20],specifi:[0,7,12],spectral:2,speed:[0,7,12],speedtest:[0,12],spent:4,spera:[0,12],spheric:[0,12],spiki:18,spin:[0,12],spinrat:[0,12],split:[0,7,12,16,19],split_lin:16,splitlin:[11,12,13,14,16,17,18,19],splitpoint:[0,12],spread:5,sqrt:[0,12],src:[0,9,12,14,21],stabil:[0,12],stabl:[0,12],stancliff:[0,12],standard:[0,2,12,17,18],star:[1,2,3,7,9,12,13,14,15,16,17,18,19,20,25],star_with_no_mass:0,starcount:[11,13,17,18,19],stardata:[0,1,11,12,13,14,16,17,18,19],stardata_dump_filenam:[0,12],stardata_load_filenam:[0,12],stardata_t:14,starnum:[11,17],start:[0,1,4,5,6,7,11,12,13,16,17,18,19],start_tim:[0,12],start_timestamp:[11,13,17,18,19],startrack:[0,12],startswith:16,state:[0,12],statement:[1,14,16,17,18,19],statist:[0,12],statu:[0,1,11,12,13,17,18,19],stderr:[0,12],stdout:4,steadi:[0,12],stefan:20,stefano:[4,5,9,19],stellar:[0,2,3,7,9,12,20,24],stellar_structure_algorithm:[0,12],stellar_structure_algorithm_external_funct:0,stellar_structure_algorithm_mint:0,stellar_structure_algorithm_modified_bs:0,stellar_structure_algorithm_non:0,stellar_typ:[1,9,10,11,14,16,17,18,19,20],stellar_type_1:[0,12,19,20],stellar_type_2:[0,12,19,20],stellar_type_3:[0,12],stellar_type_4:[0,12],stellar_type_dict:24,stellar_type_dict_short:24,step:[4,5,11,13,14,16,17,18,19,20,23],stepsiz:[5,19],stick:7,stiff:[0,12],still:[1,7,14],stop:[0,4,12,13,17],stopfil:[0,12],storag:[0,12],store:[0,2,3,4,5,7,9,11,13,16,17,18,19,21,25],store_capsul:12,store_memaddr:[12,25],str:[1,4,5,6,11,19,20],straight:5,straightforward:[11,17,18,19],straniero:[0,12],strength:[0,12],strict:4,strictli:[17,18],string:[0,1,3,4,5,6,7,12,15,16,17,18,19,20,22],strip:[0,12,16],strong:11,stronger:[0,11,12],struct:[0,12,14],structur:[0,4,7,12,13,20],studi:11,stuff:[4,7,16,19,20],style:[0,5,12],sub:[0,4,12],subdict:4,subject:[0,12],sublumin:[0,12],submit:9,subroutin:8,subsequ:[0,12],subtract:4,subtract_dict:4,succe:[0,12],suddenli:11,suffer:11,suggest:[0,9,12,21],suit:[9,21],sum:[0,12],sundial:[0,12],supercrit:[0,12],supernova:[0,7,12,13],superwind:[0,12],superwind_mira_switchon:[0,12],sure:[2,5,7,9,16,17,18,19,20,21,22],surfac:[0,12],surrei:19,surviv:[0,12],survivor:[0,12],switcher:[0,12],symmetr:[0,12],synchron:[0,12],synonym:[0,12],synthesi:[7,9,17,18,19,21],system:[0,3,4,5,7,9,11,12,13,14,17,18,19,20,21,22],system_gener:[5,19],system_numb:5,system_queue_fil:[13,17],tabl:[0,2,12],take:[0,2,4,5,7,12,13,17,19,22],taken:[0,4,12,14],talk:11,tar:[9,21],target:[1,6],task:[0,2,4,5,6,8,12,19,20,22,23,25],tauri:[0,12],tbse:[0,12],technic:[11,13,14,17,18,19],teff:[0,2,12],teff_1:20,teff_2:20,teff_from_star_struct:11,teff_postagb_max:[0,12],teff_postagb_min:[0,12],tell:4,temp_dir:[4,11,13,16,18,19],temperatur:[0,2,12,20],termin:[1,9,11,14,19,21],test:[0,4,5,7,9,12,16,19,21,25],test_data:[0,12],test_func:12,test_logfil:16,test_pop:19,text:[4,6,11,13],than:[0,2,4,7,9,11,12,13,17,18,19,21],thats:19,thei:[0,2,4,5,7,11,12,13,17,19,20],thelog:[0,12],them:[2,4,5,12,13,19],themselv:[2,4],theoret:[17,18],thermal:[0,2,11,12,25],thermally_pulsing_asymptotic_giant_branch:0,thermohalin:[0,12],thermonuclear:11,thesi:[0,12],thi:[0,1,2,4,5,6,7,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,25],thick:[0,12],thick_disc_end_ag:[0,12],thick_disc_logg_max:[0,12],thick_disc_logg_min:[0,12],thick_disc_start_ag:[0,12],thin:[0,12],thing:[0,2,4,5,6,11,12,13,17,18,19,22],think:[0,4,5,12],third:[0,2,12],third_dup:[0,12],third_dup_multipli:[0,12],thorn:[0,12],those:[4,5,9,11,13,17,18,19,21],thread:[5,7,11,13,17,18],thread_id:7,three:[0,2,12,18,19],three_part_powerlaw:[2,13,17,18,19],threshold:[0,4,7,12],through:[5,11,12,16,17,18,19,20,22],throughout:[5,17,18,19],tidal:[0,12],tidal_strength_factor:[0,12],tide:[0,12],tides_convective_damp:[0,12],tides_hurley2002:[0,12],tides_zahn1989:[0,12],time:[0,1,2,4,5,7,9,11,12,13,14,16,17,18,19,20,21],timescal:[0,12],timestamp:7,timestep:[0,12,13,14,16,17,18],timestep_limit:[0,12],timestep_log:[0,12],timestep_modul:[0,12],timestep_multipli:[0,12],timestep_solver_factor:[0,12],tini:11,tinslei:2,tip:11,titl:[6,17],tmp:[0,4,9,12,13,16,17,18,19,21],tmp_dir:[5,7,11,13,16,18,19],tmp_tabl:2,todo:[0,1,2,4,5,6,7,12,15,19,20,22,23,25],toler:[0,12],too:[0,4,7,9,11,12,18,21,22],took:[11,13,17,18,19],top:19,topic:[0,12],torqu:[0,12],total:[0,2,4,5,7,11,12,13,17,18,19,20],total_count:[11,13,17,18,19],total_mass_run:[11,13,17,18,19],total_prob:[11,13,17,18,19],total_probability_weighted_mass_run:[11,13,17,18,19],tout:[0,12,25],tout_pringle_1992_multipli:[0,12],tpagb:[0,11,12],tpagb_reimers_eta:[0,12],tpagb_wind_beasor_etal_2020:0,tpagb_wind_bloeck:0,tpagb_wind_goldman_etal_2017:0,tpagb_wind_mattsson:0,tpagb_wind_reim:0,tpagb_wind_rob_cwind:0,tpagb_wind_van_loon:0,tpagb_wind_vw93_karaka:0,tpagb_wind_vw93_karakas_carbon_star:0,tpagb_wind_vw93_orig:0,tpagb_wind_vw93_orig_carbon_star:0,tpagbwind:[0,12],tpagbwindfac:[0,12],tpr:[13,17],traceback:4,track:[7,11,20],trade:[0,12],transfer:[0,11,12],transform:[0,4,12],transit:[0,12],treat:[0,12],trigger:[0,12],trio:[17,18,19],tripl:[0,2,7,12],truli:[0,12],tupl:[1,11],turn:[0,4,12,16,19],tutori:[3,9],two:[0,4,11,12,14,24,25],txt:[5,16,19,22],type:[0,1,2,4,5,6,7,12,13,16,17,18,19,20,23,24,25],type_chng:16,type_ia_mch_supernova_algorithm:[0,12],type_ia_mch_supernova_algorithm_dd2:0,type_ia_mch_supernova_algorithm_seitenzahl2013:0,type_ia_mch_supernova_algorithm_seitenzahl2013_automat:0,type_ia_sub_mch_supernova_algorithm:[0,12],type_ia_sub_mch_supernova_algorithm_livne_arnett_1995:0,typic:[0,12],ubvri:[0,12],ugriv:[0,12],unavail:[0,12],uncom:[5,16,17,18,19],unction:12,undef:14,under:[16,23],undergo:13,undescrib:6,uniform:2,uninstal:[9,21],union:[2,4,5,19,23,25],uniqu:[4,5,7,19],unit:[0,11,12,15,25],univari:[0,12],univers:[11,13],unix:5,unknown:22,unless:[1,5,7],unlik:18,unload:5,unmerg:13,unpars:12,unphys:[13,17],unrecogn:[9,21],unresolv:17,unsign:0,unstabl:[0,12],until:[0,2,4,11,12],unus:[0,7,12],unweight:19,updat:[2,4,5,9,18,19,21],update_dict:[4,15],update_grid_vari:[5,18],upper:[0,2,12,23],usag:[0,3],use:[0,2,3,4,5,7,8,9,12,14,15,16,17,19,20,21,22],use_astropy_valu:20,use_datadir:[5,19],use_fixed_timestep_:[0,12],use_periastron_roche_radiu:[0,12],use_tabular_intershell_abundances_karakas_2012:[0,12],usecas:3,used:[0,1,2,4,5,7,11,12,14,15,16,17,18,19,20],useful:[0,4,5,7,9,12,15,16,17,18,19,21,22,25],useful_func:[9,10],user:[1,2,4,5,6,7,14,22],uses:[0,7,12,14,19],using:[0,1,5,9,11,13,14,15,16,17,18,21],usual:[0,2,4,7,11,12,17,18,19],util:[1,2,4,5,6,11,12,13,14,15,16,17,18,19,20,22,23,25],val:2,valid:[0,2,4,12,14],valu:[0,1,2,4,5,6,7,11,12,15,16,17,18,19,20],value_lin:16,valueerror:19,valuerang:[5,11,13,17,18,19],values_arrai:16,van:[0,12],vandenheuvel_log:[0,12],vari:[0,11,12,13,19],variabl:[0,3,4,5,7,11,12,13],variant:[0,12],variou:[0,12],vassiliadi:[0,12],vb1print:5,veloc:[0,2,12],venv:[9,21],verbos:[1,2,4,5,7,9,11,13,16,17,18,19,21],verbose_print:4,veri:[0,5,11,12,13,14,16,18,19,23],versa:25,version:[0,4,5,9,12,15,19,21],version_info:4,version_info_dict:15,version_info_str:4,version_onli:[0,12],via:[3,5,7,11,12,14,17,18,19,20],vice:25,vink:[0,12],virtual:[9,21],virtualenviron:[9,21],viscos:[0,12],viscou:[0,12],visibl:14,visit:9,volum:[0,12],vrot1:[0,12],vrot2:[0,12],vrot3:[0,12],vrot4:[0,12],vrot_breakup:0,vrot_bs:0,vrot_non_rot:0,vrot_sync:0,vw93:[0,12],vw93_eagb_wind_spe:[0,12],vw93_mira_shift:[0,12],vw93_multipli:[0,12],vw93_tpagb_wind_spe:[0,12],vwind:[0,12],vwind_beta:[0,12],vwind_multipli:[0,12],wai:[0,4,5,7,12,16,18,20],wang:[0,12],want:[0,2,4,5,6,7,12,13,14,15,17,18,19,20],warmup_cpu:[0,12],warn:[0,12,16,19],wast:[13,18],wave:[0,11,12,13,19],wd_accretion_rate_new_giant_envelope_lower_limit_helium_donor:[0,12],wd_accretion_rate_new_giant_envelope_lower_limit_hydrogen_donor:[0,12],wd_accretion_rate_new_giant_envelope_lower_limit_other_donor:[0,12],wd_accretion_rate_novae_upper_limit_helium_donor:[0,12],wd_accretion_rate_novae_upper_limit_hydrogen_donor:[0,12],wd_accretion_rate_novae_upper_limit_other_donor:[0,12],wd_kick:[0,12],wd_kick_at_every_puls:0,wd_kick_at_given_puls:0,wd_kick_direct:[0,12],wd_kick_end_agb:0,wd_kick_first_rlof:0,wd_kick_pulse_numb:[0,12],wd_kick_when:[0,12],wd_sigma:[0,12],wdwd_merger_algorithm:[0,12],wdwd_merger_algorithm_bs:0,wdwd_merger_algorithm_chen2016:0,wdwd_merger_algorithm_perets2019:0,weight:[0,7,12,18],weirdli:17,well:[0,4,7,9,12,14,16,17,18,21],went:18,were:[4,11,13,17,18,19],what:[0,1,2,4,6,7,9,11,12,13,14,16,17,18,19,21,22],whatev:[0,5,9,12,14,21],wheeler:[0,12],when:[0,1,2,4,5,6,7,9,11,12,13,15,16,19,21,22],whenev:[9,21],where:[0,1,2,4,5,6,7,9,11,12,17,18,19,21],whether:[0,2,4,5,6,7,12,15,19,20,25],which:[0,1,2,4,5,6,7,9,11,12,13,14,15,16,17,18,19,21,22,25],whichev:7,white:[0,11,12],white_dwarf_cooling_carrasco2014:[0,12],white_dwarf_cooling_mestel:[0,12],white_dwarf_cooling_mestel_modifi:[0,12],white_dwarf_cooling_model:[0,12],white_dwarf_radius_carrasco2014:[0,12],white_dwarf_radius_model:[0,12],white_dwarf_radius_mu:[0,12],white_dwarf_radius_nauenberg1972:[0,12],whole:[0,5,7,12,13,14],why:13,wide:[17,18],width:[0,12,13],wiggl:18,wind:[0,11,12,17],wind_algorithm_binary_c_2020:0,wind_algorithm_hurley2002:0,wind_algorithm_non:0,wind_algorithm_schneider2018:0,wind_angmom_loss_bs:0,wind_angmom_loss_lw:0,wind_angmom_loss_lw_hybrid:0,wind_angmom_loss_spherically_symmetr:0,wind_angular_momentum_loss:[0,12],wind_disc_angmom_fract:[0,12],wind_disc_mass_fract:[0,12],wind_djorb_fac:[0,12],wind_gas_to_dust_ratio:[0,12],wind_lbv_luminosity_lower_limit:[0,12],wind_mass_loss:[0,12],wind_multiplier_:[0,12],wind_nieuwenhuijzen_luminosity_lower_limit:[0,12],wind_type_multiplier_:[0,12],within:[0,4,5,9,12,14,15,19,21],without:[2,4,5,7,14,16,18],won:[0,12,16],wood:[0,12],work:[0,4,5,9,12,14,16,17,18,20,21],would:[0,4,12,18,19,20],wouldn:[5,19],wr_wind:[0,12],wr_wind_bs:0,wr_wind_eldridg:0,wr_wind_fac:[0,12],wr_wind_maeder_meynet:0,wr_wind_nugis_lam:0,wrap:[1,14],wrapper:[4,12,14,16,25],write:[1,4,5,6,7,12,13,14,16,17,19,22],write_binary_c_calls_to_fil:[5,19],write_binary_c_parameter_descriptions_to_rst_fil:4,write_grid_options_to_rst_fil:6,write_logfil:12,written:[5,6,7,12,16,19,22],written_data:16,wrlof_mass_transf:[0,12],wrlof_method:[0,12],wrlof_non:0,wrlof_q_depend:0,wrlof_quadrat:0,wrong:[9,18,21],wrwindfac:[0,12],wtts2:[0,12],wtts_log:[0,12],www:[0,2,12],x86_64:12,xlim:13,year:[0,2,12],year_length_in_dai:13,yet:[0,4,5,7,12,20],yield:[0,12],you:[0,1,4,5,6,7,9,11,12,13,14,16,17,18,19,20,21,25],young:[0,12],your:[7,9,14,16,21],yourself:[11,13,17,18,19,20],yscale:[17,18],zahn:[0,12],zam:[0,2,3,11,12,17,22,25],zams_collis:25,zams_mass:[11,17,18,19],zams_mass_1:19,zams_mass_2:19,zero:[0,1,3,4,7,9,11,12,13],zero_ag:[11,14,16,17,18,19],zero_age_main_sequence_star:[17,18],zero_age_main_sequence_starn:17,zero_prob_stars_skip:[11,13,17,18,19],zone:[0,12],zoom:[0,12],zoomfac_multiplier_decreas:[0,12],zoomfac_multiplier_increas:[0,12],zsolar:2,zytkow:[0,12]},titles:["Binary_c parameters","custom_logging_functions module","distribution_functions module","Example notebooks","functions module","grid_class module","Grid options and descriptions","Population grid code options","hpc_functions module","Welcome to binary_c-python\u2019s documentation!","Binarycpython code","Example use case: Hertzsprung-Russell diagrams","Tutorial: Using the API functionality of binary_c-python","Example use case: Common-envelope evolution","Tutorial: Using custom logging routines with binary_c-python","Tutorial: Extra features and functionality of binary_c-python","Tutorial: Running individual systems with binary_c-python","Zero-age stellar luminosity function in binaries","Example use case: Zero-age stellar luminosity function","Tutorial: Running populations with binary_c-python","plot_functions module","Python module for binary_c","run_system_wrapper module","spacing_functions module","stellar_types module","useful_funcs module"],titleterms:{"case":[11,13,18],"function":[4,12,15,16,17,18,19],"public":7,Adding:[17,18,19],Using:[12,14],about:15,after:[9,21],age:[17,18],algorithm:0,api:[12,14,16],better:18,binari:[0,11,17],binary_c:[0,9,12,14,15,16,19,21],binarycpython:10,build:[9,15,21],code:[7,10],common:13,compact:14,custom:14,custom_logging_funct:1,descript:6,diagram:11,dictionari:15,directli:14,distribut:18,distribution_funct:2,document:[9,21],envelop:13,environ:[9,21],evolut:[13,14],evolv:[11,13,17,18,19],exampl:[3,9,11,12,13,14,15,18,19,21],extra:15,faq:[9,21],featur:15,free:12,from:[9,12,14,21],full:19,get:[12,15],grid:[6,7,11,13,17,18,19],grid_class:5,handl:[11,13,17,18,19],help:15,hertzsprung:11,hpc_function:8,indic:9,individu:16,inform:[12,15],initi:18,input:0,instal:[9,21],instruct:[9,21],issu:[9,21],log:[11,13,14,17,18,19],luminos:[17,18],mass:[14,18],misc:0,modif:15,modul:[1,2,4,5,8,9,20,21,22,23,24,25],moe:7,note:[9,21],notebook:3,noteworthi:19,nucsyn:0,object:[11,13,14,16,17,18,19],option:[6,7],output:[0,11,13,17,18,19],paramet:[0,15],pars:15,pip:[9,21],plot_funct:20,popul:[7,11,13,14,16,17,18,19],privat:7,python:[9,12,14,15,16,19,21],requir:[9,21],routin:14,run:[14,16,19],run_system_wrapp:22,run_wrapp:16,russel:11,sampl:18,sampler:7,script:19,section:0,set:[11,12,13,17,18,19],singl:16,sourc:[9,21],spacing_funct:23,star:[0,11],stefano:7,stellar:[11,13,17,18],stellar_typ:24,store:12,string:14,supernova:14,system:16,tabl:9,tutori:[12,14,15,16,19],usag:[9,12,14,21],use:[11,13,18],useful_func:25,using:12,variabl:[9,17,18,19,21],via:[9,16,21],welcom:9,when:14,zam:18,zero:[17,18]}})
\ No newline at end of file
diff --git a/docs/build/html/spacing_functions.html b/docs/build/html/spacing_functions.html
index f9d19b5a8e9e69d49402301f9a341bad1e041ea8..43bf98fea44cfae8df48880e1dc572e1e4732a5f 100644
--- a/docs/build/html/spacing_functions.html
+++ b/docs/build/html/spacing_functions.html
@@ -262,9 +262,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/stellar_types.html b/docs/build/html/stellar_types.html
index c10033199ab225def092f818d74765b9e9a952e7..c31a11e0d20a28510c2e2c06485f5f472aaa6072 100644
--- a/docs/build/html/stellar_types.html
+++ b/docs/build/html/stellar_types.html
@@ -243,9 +243,9 @@
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/build/html/useful_funcs.html b/docs/build/html/useful_funcs.html
index c2e0dcaca2dd636d72847c8bc6b096160a9eac19..a123310d9429a3a25f964bc783c337c9d96a7c46 100644
--- a/docs/build/html/useful_funcs.html
+++ b/docs/build/html/useful_funcs.html
@@ -441,9 +441,9 @@ determine if two stars collide on the ZAMS</p>
     
     provided by <a href="https://readthedocs.org">Read the Docs</a>.
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 
 
diff --git a/docs/source/_templates/footer.html b/docs/source/_templates/footer.html
index 614d6567ddc50965e7c33fe1117c275bf69b8b88..5ce2068330b83eb6854c4df9e437e480fd83b1ef 100644
--- a/docs/source/_templates/footer.html
+++ b/docs/source/_templates/footer.html
@@ -2,8 +2,8 @@
 
 {%- block extrafooter %}
 <br><br>
-Generated on binarycpython git branch: master git revision cac51a6dc71daeeb943b70d5598350ab43901299 url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
+Generated on binarycpython git branch: master git revision 0886cd4f1d7f43222aac21d6ed91e917b67b20fc url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c-python/-/tree/master">git url</a>.
 <br><br>
-Using binary_c with bit branch branch_david: git revision: "6162:20210825:093caf0e9" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/branch_david">git url</a>.
+Using binary_c with bit branch newmaster: git revision: "6185:20210910:1621c23a5" url: <a href="https://gitlab.eps.surrey.ac.uk/ri0005/binary_c/-/tree/newmaster">git url</a>.
 
 {% endblock %}
\ No newline at end of file
diff --git a/docs/source/binary_c_parameters.rst b/docs/source/binary_c_parameters.rst
index 9d05193ac3eee376842356a9aea21ccba0d96899..cdce51580c9e3478b29c356fadc3e11bb84ac62b 100644
--- a/docs/source/binary_c_parameters.rst
+++ b/docs/source/binary_c_parameters.rst
@@ -4,7 +4,7 @@ The following chapter contains all the parameters that the current version of bi
 
 
 This information was obtained by the following binary_c build:
-	**binary_c git branch**: branch_david	**binary_c git revision**: 6162:20210825:093caf0e9	**Built on**: Aug 25 2021 18:02:39
+	**binary_c git branch**: newmaster	**binary_c git revision**: 6185:20210910:1621c23a5	**Built on**: Sep 10 2021 15:05:46
 
 
 Section: stars
@@ -424,6 +424,11 @@ Section: stars
 | **Parameter input type**: Float(scanf)
 | **Default value**: NULL
 
+| **Parameter**: artificial_mass_accretion_rate_by_stellar_type%d
+| **Description**: Constant mass accretion rate for stellar type <n>.
+| **Parameter input type**: Float(scanf)
+| **Default value**: NULL
+
 | **Parameter**: artificial_angular_momentum_accretion_rate%d
 | **Description**: Constant angular momentum accretion for star <n>.
 | **Parameter input type**: Float(scanf)
@@ -468,13 +473,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['BH_HURLEY2002 = 0', 'BH_BELCZYNSKI = 1', 'BH_SPERA2015 = 2', 'BH_FRYER12_DELAYED = 3', 'BH_FRYER12_RAPID = 4', 'BH_FRYER12_STARTRACK = 5']
 
-| **Parameter**: PPISN_prescription
-| **Description**: (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019.
-| **Parameter input type**: Integer
-| **Default value**: 1
-| **Macros**: ['PPISN_NONE = 0', 'PPISN_FARMER19 = 1']
-| **Extra**: Ignore
-
 | **Parameter**: sn_kick_distribution_II
 | **Description**: Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Integer
@@ -502,7 +500,7 @@ Section: stars
 | **Parameter**: sn_kick_distribution_GRB_COLLAPSAR
 | **Description**: Set the distribution of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Integer
-| **Default value**: 0
+| **Default value**: 1
 | **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
 
 | **Parameter**: sn_kick_distribution_TZ
@@ -541,24 +539,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
 
-| **Parameter**: sn_kick_distribution_PPISN
-| **Description**: Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 1
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
-| **Parameter**: sn_kick_distribution_PISN
-| **Description**: Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
-| **Parameter**: sn_kick_distribution_PHDIS
-| **Description**: Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Macros**: ['KICK_VELOCITY_FIXED = 0', 'KICK_VELOCITY_MAXWELLIAN = 1', 'KICK_VELOCITY_CUSTOM = 2']
-
 | **Parameter**: sn_kick_dispersion_II
 | **Description**: Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Float
@@ -582,7 +562,7 @@ Section: stars
 | **Parameter**: sn_kick_dispersion_GRB_COLLAPSAR
 | **Description**: Set the dispersion of speeds applied to kick newly-born neutron stars and black holes after a type Ib/c core-collapse supernova which is also a collapsar. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
 | **Parameter input type**: Float
-| **Default value**: 0
+| **Default value**: 190
 
 | **Parameter**: sn_kick_dispersion_TZ
 | **Description**: Set the dispersion of speeds applied to kick newly-born neutron stars and black holes at the death of a Thorne-Zytkow object. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
@@ -614,21 +594,6 @@ Section: stars
 | **Parameter input type**: Float
 | **Default value**: 0
 
-| **Parameter**: sn_kick_dispersion_PPISN
-| **Description**: Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 190
-
-| **Parameter**: sn_kick_dispersion_PISN
-| **Description**: Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 0
-
-| **Parameter**: sn_kick_dispersion_PHDIS
-| **Description**: Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c).
-| **Parameter input type**: Float
-| **Default value**: 0
-
 | **Parameter**: sn_kick_companion_IA_He
 | **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
 | **Parameter input type**: Float
@@ -749,24 +714,6 @@ Section: stars
 | **Default value**: 0
 | **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
 
-| **Parameter**: sn_kick_companion_PPISN
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
-| **Parameter**: sn_kick_companion_PISN
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
-| **Parameter**: sn_kick_companion_PHDIS
-| **Description**: Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975.
-| **Parameter input type**: Float
-| **Default value**: 0
-| **Macros**: ['SN_IMPULSE_NONE = 0', 'SN_IMPULSE_LIU2015 = 1', 'SN_IMPULSE_WHEELER1975 = 2']
-
 | **Parameter**: wd_sigma
 | **Description**: Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS.
 | **Parameter input type**: Float
@@ -827,22 +774,22 @@ Section: stars
 | **Parameter**: delta_mcmin
 | **Description**: A parameter to reduce the minimum core mass for third dredge up to occur on the TPAGB. As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lambda_min
 | **Description**: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min>0 implies that, once Mc>Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars. See also lambda_multiplier.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lambda_multiplier
 | **Description**: A parameter to increase the efficiency of third dredge up on the TPAGB. The efficiency is lambda * lambda_mult, and setting lambda_min>0 implies that, once Mc>Mcmin (see delta_mcmin) lambda=Max(lambda(fit to Karakas), lambda_min). As used by Izzard and Tout (2004) to increase the amount of dredge up, hence carbon, in Magellanic cloud stars.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: minimum_envelope_mass_for_third_dredgeup
 | **Description**: The minimum envelope mass for third dredge up on the TPAGB. Early, solar metallicity models by Straniero et al suggested 0.5Msun is typical. However, circumstantial evidence (Izzard et al 2009) as well as newer models by Stancliffe and Karakas suggest that at low metallicity a value nearer zero is more appropriate.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.5
 
 | **Parameter**: mass_of_pmz
 | **Description**: The mass in the partial mixing zone of a TPAGB star, using the Karakas 2012 tables. Ask Carlo Abate for more details, or see the series of papers Abate et al 2012, 2013, 2014. Requires NUCSYN and USE_TABULAR_INTERSHELL_ABUNDANCES_KARAKAS_2012.
@@ -852,12 +799,12 @@ Section: stars
 | **Parameter**: c13_eff
 | **Description**: The "efficiency" of partial mixing in a TPAGB star intershell region, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: mc13_pocket_multiplier
 | **Description**: Multiplies the mass in the partial mixing zone of a TPAGB star, when using the s-process tables of Gallino, Busso, Lugaro et al. as provided by Maria Lugaro for the Izzard et al. 2009 paper. Requires NUCSYN and NUCSYN_S_PROCESS.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: tides_convective_damping
 | **Description**: Tidal convective damping algorithm. 0=TIDES_HURLEY2002 Zahn 197x timescales + Hut, as in Hurley et al (2002), 1 = TIDES_ZAHN1989: Zahn 1989 lambdas + Hut.
@@ -879,7 +826,7 @@ Section: stars
 | **Parameter**: hbbtfac
 | **Description**: A parameter to modulate the temperature at the base of the hot-bottom burning zone in TPAGB stars. (Works only if NUCSYN is defined)
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: wind_multiplier_%d
 | **Description**: Wind multiplier for the stellar type specified by the intger %d. By default these are all 1.0.
@@ -951,7 +898,7 @@ Section: stars
 | **Parameter**: MINT_metallicity
 | **Description**: This sets the metallicity for MINT. It is ignored if set to -1.0, the default, in which case the normal metallicity parameter is used.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -1
 
 | **Parameter**: gaia_Teff_binwidth
 | **Description**: log10(Effective temperature) bin width used to make Gaia-like HRDs
@@ -978,25 +925,25 @@ Section: stars
 | **Parameter**: AGB_core_algorithm
 | **Description**: Algorithm to use for calculating AGB core masses. 0=Hurley et al. 2002 if no NUCSYN, Karakas 2002 if NUCSYN is defined; 1=Hurley et al. 2002 (overshooting models); 1=Karakas 2002 (non-overshooting models).
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_CORE_ALGORITHM_DEFAULT = 0', 'AGB_CORE_ALGORITHM_HURLEY = 1', 'AGB_CORE_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_radius_algorithm
 | **Description**: Algorithm to use for calculating radii on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_RADIUS_ALGORITHM_DEFAULT = 0', 'AGB_RADIUS_ALGORITHM_HURLEY = 1', 'AGB_RADIUS_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_luminosity_algorithm
 | **Description**: Algorithm to use for calculating luminosities on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_LUMINOSITY_ALGORITHM_DEFAULT = 0', 'AGB_LUMINOSITY_ALGORITHM_HURLEY = 1', 'AGB_LUMINOSITY_ALGORITHM_KARAKAS = 2']
 
 | **Parameter**: AGB_3dup_algorithm
 | **Description**: Algorithm to use for calculating third dredge up efficiency on the TPAGB.
 | **Parameter input type**: Integer
-| **Default value**: 1
+| **Default value**: 2
 | **Macros**: ['AGB_THIRD_DREDGE_UP_ALGORITHM_DEFAULT = 0', 'AGB_THIRD_DREDGE_UP_ALGORITHM_HURLEY = 1', 'AGB_THIRD_DREDGE_UP_ALGORITHM_KARAKAS = 2', 'AGB_THIRD_DREDGE_UP_ALGORITHM_STANCLIFFE = 3']
 
 | **Parameter**: overspin_algorithm
@@ -1136,6 +1083,21 @@ Section: stars
 | **Parameter input type**: True|False
 | **Default value**: False
 
+| **Parameter**: degenerate_core_merger_nucsyn
+| **Description**: If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE)
+| **Parameter input type**: True|False
+| **Default value**: False
+
+| **Parameter**: degenerate_core_helium_merger_ignition
+| **Description**: If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE)
+| **Parameter input type**: True|False
+| **Default value**: True
+
+| **Parameter**: degenerate_core_merger_dredgeup_fraction
+| **Description**: If non-zero, mix this fraction of the degenerate core during a merger.(0.0).
+| **Parameter input type**: Float
+| **Default value**: 0
+
 Section: binary
 ---------------
 
@@ -1308,7 +1270,7 @@ Section: binary
 | **Parameter**: post_ce_objects_have_envelopes
 | **Description**: If TRUE then post-common-envelope objects have thin envelopes. You need this if you are to have post-CE post-AGB stars. Note that this *may* be unstable, i.e. you may end up having many CEEs. The mass in the envelope is controlled by post_ce_adaptive_menv. TRUE by default.
 | **Parameter input type**: True|False
-| **Default value**: True
+| **Default value**: False
 
 | **Parameter**: PN_comenv_transition_time
 | **Description**: post-common envelope transition time in years (1e2).  This is the time taken to move from CEE ejection to Teff > 30e4 K. Hall et al. (2013) suggest ~100 years.
@@ -1478,18 +1440,20 @@ Section: binary
 | **Parameter**: type_Ia_MCh_supernova_algorithm
 | **Description**: Algorithm to be used when calculating type Ia yields from Chandrasekhar-mass exploders. 0 = DD7 (Iwamoto 1999), 1 = Seitenzahl 2013 3D hydro yields (you must also set Seitenzahl2013_model) 
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['TYPE_IA_MCH_SUPERNOVA_ALGORITHM_DD2 = 0', 'TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013 = 1', 'TYPE_IA_MCH_SUPERNOVA_ALGORITHM_SEITENZAHL2013_AUTOMATIC = 2']
 
 | **Parameter**: Seitenzahl2013_model
 | **Description**: Which of Seitenzahl et al. 2013's models to use? One of N1,N3,N5,N10,N20,N40,N100L,N100,N100H,N150,N200,N300C,N1600,N1600C,N100_Z0.5,N100_Z0.1,N100_Z0.01 (defaults to N100).
 | **Parameter input type**: String
-| **Default value**: NULL
+| **Default value**: N100
 | **Extra**: N1
 
 | **Parameter**: type_Ia_sub_MCh_supernova_algorithm
 | **Description**: Algorithm to be used when calculating type Ia yields from sub-Chandrasekhar-mass exploders. (Currently unused.)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['TYPE_IA_SUB_MCH_SUPERNOVA_ALGORITHM_LIVNE_ARNETT_1995 = 0']
 
 | **Parameter**: max_HeWD_mass
 | **Description**: The maximum mass a HeWD can have before it ignites helium (0.7).
@@ -2130,7 +2094,7 @@ Section: nucsyn
 | **Parameter**: NeNaMgAl
 | **Description**: Enables NeNaMgAl reaction network. Requires NUCSYN and NUCSYN_HBB.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: Ignore
 
 | **Parameter**: nucsyn_network%d
@@ -2151,19 +2115,21 @@ Section: nucsyn
 | **Parameter**: nucsyn_metallicity
 | **Description**: This sets the metallicity of the nucleosynthesis algorithms, i.e. the amount (by mass) of matter which is not hydrogen or helium. Usually you'd just set this with the metallicity parameter, but if you want the nucleosynthesis to be outside the range of the stellar evolution algorithm (e.g. Z=0 or Z=0.04) then you need to use nucsyn_metallicity. That said, it's also outside the range of some of the nucleosynthesis algorithms as well, so you have been warned!
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['DEFAULT_TO_METALLICITY = -1']
 
 | **Parameter**: nucsyn_solver
 | **Description**: Choose the solver used in nuclear burning. 0 = KAPS_RENTROP is a Kaps-Rentrop scheme (fast, not great for stiff problems), 1 = LSODA (Adams/BSF switcher), 2 = CVODE library (https://computing.llnl.gov/projects/sundials. Default 0. 
 | **Parameter input type**: Unsigned integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['NUCSYN_SOLVER_KAPS_RENTROP = 0', 'NUCSYN_SOLVER_LSODA = 1', 'NUCSYN_SOLVER_CVODE = 2', 'NUCSYN_SOLVER_NUMBER = 3', 'NUCSYN_SOLVER_KAPS_RENTROP = 0', 'NUCSYN_SOLVER_LSODA = 1', 'NUCSYN_SOLVER_CVODE = 2', 'NUCSYN_SOLVER_NUMBER = 3']
 | **Extra**: 0
 
 | **Parameter**: initial_abundance_mix
 | **Description**: initial abundance mixture: 0=AG89, 1=Karakas 2002, 2=Lodders 2003, 3=Asplund 2005 (not available?), 4=Garcia Berro, 5=Grevesse Noels 1993
 | **Parameter input type**: Unsigned integer
-| **Default value**: NULL
+| **Default value**: 0
+| **Macros**: ['NUCSYN_INIT_ABUND_MIX_AG89 = 0', 'NUCSYN_INIT_ABUND_MIX_KARAKAS2002 = 1', 'NUCSYN_INIT_ABUND_MIX_LODDERS2003 = 2', 'NUCSYN_INIT_ABUND_MIX_ASPLUND2005 = 3', 'NUCSYN_INIT_ABUND_MIX_GARCIABERRO = 4', 'NUCSYN_INIT_ABUND_MIX_GREVESSE_NOELS_1993 = 5', 'NUCSYN_INIT_ABUND_MIX_ASPLUND2009 = 6', 'NUCSYN_INIT_ABUND_MIX_KOBAYASHI2011_ASPLUND2009 = 7', 'NUCSYN_INIT_ABUND_MIX_LODDERS2010 = 8']
 | **Extra**: 0
 
 | **Parameter**: init_abund
@@ -2187,37 +2153,38 @@ Section: nucsyn
 | **Parameter**: init_abunds_only
 | **Description**: If True, outputs only the initial abundances, then exits.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: initial_abunds_only
 | **Description**: If True, outputs only the initial abundances, then exits.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: no_thermohaline_mixing
 | **Description**: If True, disables thermohaline mixing.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: lithium_GB_post_Heflash
 | **Description**: Sets the lithium abundances after the helium flash. Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lithium_GB_post_1DUP
 | **Description**: Sets the lithium abundance after first dredge up. Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0
 
 | **Parameter**: lithium_hbb_multiplier
 | **Description**: Multiplies the lithium abundances on the AGB during HBB (based on Karakas/Fishlock et al models).Requires NUCSYN and LITHIUM_TABLES.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: angelou_lithium_decay_function
 | **Description**: Functional form which describes Li7 decay. Requires NUCSYN and NUCSYN_ANGELOU_LITHIUM. Choices are: 0 expoential (see angelou_lithium_decay_time).
 | **Parameter input type**: Integer
 | **Default value**: NULL
+| **Macros**: ['ANGELOU_LITHIUM_DECAY_FUNCTION_EXPONENTIAL = 0']
 
 | **Parameter**: angelou_lithium_LMMS_time
 | **Description**: Time at which lithium manufacture is triggered in a low-mass (convective) main sequence (Myr). Requires NUCSYN and NUCSYN_ANGELOU_LITHIUM. Ignored if 0 (for the start, use 1e-6).
@@ -2337,16 +2304,10 @@ Section: nucsyn
 Section: output
 ---------------
 
-| **Parameter**: david_logging_function
-| **Description**: Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions
-| **Parameter input type**: Integer
-| **Default value**: 0
-| **Extra**: Ignore
-
 | **Parameter**: cf_amanda_log
 | **Description**: Enable logging to compare to Amanda's models.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: float_overflow_checks
 | **Description**: Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0)
@@ -2386,7 +2347,7 @@ Section: output
 | **Parameter**: legacy_yields
 | **Description**: Turn on ensemble legacy yield output.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 
 | **Parameter**: ensemble_defer
 | **Description**: Defer ensemble output.
@@ -2426,27 +2387,27 @@ Section: output
 | **Parameter**: EMP_logg_maximum
 | **Description**: Maximum logg that EMP stars are allowed to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_minimum_age.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 4
 
 | **Parameter**: EMP_minimum_age
 | **Description**: Minimum age that EMP stars are required to have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 10
 
 | **Parameter**: EMP_feh_maximum
 | **Description**: Maximum [Fe/H] that an EMP stars may have. See Izzard et al 2009. See also CEMP_cfe_minimum, NEMP_nfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default -2.0.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: -2
 
 | **Parameter**: CEMP_cfe_minimum
 | **Description**: Minimum [C/Fe] that CEMP stars are required to have. See Izzard et al 2009. See also NEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 0.7.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.7
 
 | **Parameter**: NEMP_cfe_minimum
 | **Description**: Minimum [N/Fe] that NEMP stars are required to have. See Izzard et al 2009, Pols et al. 2012. See also CEMP_cfe_minimum, EMP_logg_maximum, EMP_minimum_age. Default 1.0.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1
 
 | **Parameter**: thick_disc_start_age
 | **Description**: Lookback time for the start of the thick disc star formation, e.g. 13e3 Myr. Units = Myr.
@@ -2582,99 +2543,99 @@ Section: input
 | **Parameter**: MINT_dir
 | **Description**: Location of MINT algorithm data.
 | **Parameter input type**: String
-| **Default value**: NULL
+| **Default value**: 
 | **Extra**: 
 
 | **Parameter**: MINT_data_cleanup
 | **Description**: Activate checks on incoming data to try to account for problems. Will make data-loading slower, but may fix a few things.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_MS_rejuvenation
 | **Description**: Turn on or off (hydrogen) main-sequence rejuvenation.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_remesh
 | **Description**: Turn on or off MINT's remeshing.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_use_ZAMS_profiles
 | **Description**: Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.)
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: True
 | **Extra**: 
 
 | **Parameter**: MINT_fallback_to_test_data
 | **Description**: If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE)
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_disable_grid_load_warnings
 | **Description**: Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn
 | **Description**: Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 0
 | **Extra**: 
 
 | **Parameter**: MINT_nshells
 | **Description**: Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 200
 | **Extra**: 
 
 | **Parameter**: MINT_maximum_nshells
 | **Description**: Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 1000
 | **Extra**: 
 
 | **Parameter**: MINT_minimum_nshells
 | **Description**: Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0)
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: 10
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn_stellar_type
 | **Description**: Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['LOW_MASS_MS = 0', 'MS = 1', 'HG = 2', 'GIANT_BRANCH = 3', 'CHeB = 4', 'EAGB = 5', 'TPAGB = 6', 'HeMS = 7', 'HeHG = 8', 'HeGB = 9', 'HeWD = 10', 'COWD = 11', 'ONeWD = 12', 'NS = 13', 'BH = 14', 'MASSLESS_REMNANT = 15']
 | **Extra**: 
 
 | **Parameter**: MINT_Kippenhahn_companion_stellar_type
 | **Description**: Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output.
 | **Parameter input type**: Integer
-| **Default value**: NULL
+| **Default value**: -1
 | **Macros**: ['LOW_MASS_MS = 0', 'MS = 1', 'HG = 2', 'GIANT_BRANCH = 3', 'CHeB = 4', 'EAGB = 5', 'TPAGB = 6', 'HeMS = 7', 'HeHG = 8', 'HeGB = 9', 'HeWD = 10', 'COWD = 11', 'ONeWD = 12', 'NS = 13', 'BH = 14', 'MASSLESS_REMNANT = 15']
 | **Extra**: 
 
 | **Parameter**: MINT_nuclear_burning
 | **Description**: Turn on or off MINT's nuclear burning algorithm.
 | **Parameter input type**: True|False
-| **Default value**: NULL
+| **Default value**: False
 | **Extra**: 
 
 | **Parameter**: MINT_minimum_shell_mass
 | **Description**: Minimum shell mass in MINT's nuclear burning routines.
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 1e-06
 | **Extra**: 
 
 | **Parameter**: MINT_maximum_shell_mass
 | **Description**: Maximum shell mass in MINT's nuclear burning routines. :
 | **Parameter input type**: Float
-| **Default value**: NULL
+| **Default value**: 0.1
 | **Extra**: 
 
 Section: i/o
diff --git a/docs/source/example_notebooks.rst b/docs/source/example_notebooks.rst
index 2f6090b9feca15ef3ffec2e37096fa867a176ba8..ce09bb2af89dbf01f6e8e9170d3284c1e8ba08e7 100644
--- a/docs/source/example_notebooks.rst
+++ b/docs/source/example_notebooks.rst
@@ -13,4 +13,7 @@ The order of the notebooks below is more or less the recommended order to read.
     notebook_population.ipynb
     notebook_extra_features.ipynb
     notebook_api_functionality.ipynb
-    notebook_luminosity_function_single.ipynb
\ No newline at end of file
+    notebook_luminosity_function_single.ipynb
+    notebook_luminosity_function_binaries.ipynb
+    notebook_HRD.ipynb
+    notebook_common_envelope_evolution.ipynb
\ No newline at end of file
diff --git a/docs/source/grid_options_descriptions.rst b/docs/source/grid_options_descriptions.rst
index 319b8d56a6d616f55498ec2c10fbc358a8de8183..84538e2c4a51e19e6c1e6299dcea91c1c5e2d5f2 100644
--- a/docs/source/grid_options_descriptions.rst
+++ b/docs/source/grid_options_descriptions.rst
@@ -1,7 +1,7 @@
 Population grid code options
 ============================
 The following chapter contains all grid code options, along with their descriptions
-There are 1 options that are not described yet.
+There are 2 options that are not described yet.
 
 
 Public options
@@ -35,6 +35,8 @@ The following options are meant to be changed by the user.
 
 | **log_args_dir**: Directory to log the arguments to. Unused
 
+| **log_dt**: No description available yet
+
 | **log_file**: Log file for the population object. Unused
 
 | **log_runtime_systems**: Whether to log the runtime of the systems . Each systems run by the thread is logged to a file and is stored in the tmp_dir. (1 file per thread). Don't use this if you are planning to run a lot of systems. This is mostly for debugging and finding systems that take long to run. Integer, default = 0. if value is 1 then the systems are logged
@@ -47,7 +49,7 @@ The following options are meant to be changed by the user.
 
 | **multiplicity_fraction_function**: Which multiplicity fraction function to use. 0: None, 1: Arenou 2010, 2: Rhagavan 2010, 3: M&S 2017
 
-| **parse_function**: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the grid_options['results'] dictionary, or just output results to a file
+| **parse_function**: Function that the user can provide to handle the output the binary_c. This function has to take the arguments (self, output). Its best not to return anything in this function, and just store stuff in the self.grid_results dictionary, or just output results to a file
 
 | **repeat**: Factor of how many times a system should be repeated. Consider the evolution splitting binary_c argument for supernovae kick repeating.
 
diff --git a/docs/source/notebook_HRD.ipynb b/docs/source/notebook_HRD.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..52590f8a2a6abc7245e9ea0c08d274432cd2a1ad
--- /dev/null
+++ b/docs/source/notebook_HRD.ipynb
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Hertzsprung-Russell diagrams\n",
+    "\n",
+    "In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_HRD\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "First we set up a new population object. Our stars evolve to $13.7\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to $13.7\\mathrm{Gyr}$, and stars are not really born with a metallicity of $0.02$. These approximations only affect very low mass stars, so we assume all our stars have mass $M\\geq 1 \\mathrm{M}_\\odot$, and metallicity does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to $M\\leq 10 \\mathrm{M}_\\odot$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    tmp_dir=TMP_DIR,\n",
+    "    verbosity=1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $10\\mathrm{M}_\\odot$ in nine steps (so the masses are integers). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"M_1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        11\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1,2,1)\",\n",
+      "    \"precode\": null,\n",
+      "    \"probdist\": \"1\",\n",
+      "    \"dphasevol\": \"dM_1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"edge\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10} \n",
+    "massrange = (1, 11) \n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\", # == single-star mass\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(1,2,1)\", # space by unit masses\n",
+    "    probdist=\"1\", # dprob/dm1 : we don't care, so just set it to 1\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    "    gridtype=\"edge\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "\n",
+    "We now construct the HRD output.\n",
+    "\n",
+    "We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have $>0.1\\mathrm{M}_\\odot$ of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "Foreach_star(star)\n",
+      "{\n",
+      "    if(star->stellar_type <= TPAGB &&\n",
+      "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+      "    {\n",
+      "         double logTeff = log10(Teff_from_star_struct(star));\n",
+      "         double logL = log10(star->luminosity); \n",
+      "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+      "         Printf(\"HRD%d %30.12e %g %g %g %g\\n\",\n",
+      "                star->starnum, // 0\n",
+      "                stardata->model.time, // 1\n",
+      "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+      "                logTeff, // 3\n",
+      "                logL, // 4\n",
+      "                loggravity // 5\n",
+      "                );\n",
+      "\n",
+      "    }\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "Foreach_star(star)\n",
+    "{\n",
+    "    if(star->stellar_type <= TPAGB &&\n",
+    "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+    "    {\n",
+    "         double logTeff = log10(Teff_from_star_struct(star));\n",
+    "         double logL = log10(star->luminosity); \n",
+    "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+    "         Printf(\"HRD%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                star->starnum, // 0\n",
+    "                stardata->model.time, // 1\n",
+    "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+    "                logTeff, // 3\n",
+    "                logL, // 4\n",
+    "                loggravity // 5\n",
+    "                );\n",
+    "\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"HRD*n*\", where *n* is 0 (primary star) or 1 (secondary star, which doesn't exist in single-star systems), and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14565763dca0> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"logTeff\", \"logL\", \"logg\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        match = re.search('HRD(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            \n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "            # first time setup of the list of tuples\n",
+    "            if(len(self.grid_results['HRD'][nstar][linedata['zams_mass']])==0):\n",
+    "                self.grid_results['HRD'][nstar][linedata['zams_mass']] = []\n",
+    "\n",
+    "            # make the HRD be a list of tuples\n",
+    "            self.grid_results['HRD'][nstar][linedata['zams_mass']].append((linedata['logTeff'],\n",
+    "                                                                           linedata['logL']))\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: verbosity=0 to grid_options\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '20bee5b0c58d49c5bc47eced240685bb', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 10.0, 'total_count': 10, 'start_timestamp': 1631304519.45189, 'end_timestamp': 1631304519.9955394, 'total_mass_run': 55.0, 'total_probability_weighted_mass_run': 55.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    for zams_mass in sorted(hrd[nstar]):\n",
+    "        print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "        # get track data (list of tuples)\n",
+    "        track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "        # convert to Pandas dataframe\n",
+    "        data = pd.DataFrame(data=track, \n",
+    "                            columns = ['logTeff','logL'])\n",
+    "        \n",
+    "        # make seaborn plot\n",
+    "        p = sns.lineplot(data=data,\n",
+    "                         sort=False,\n",
+    "                         x='logTeff',\n",
+    "                         y='logL',\n",
+    "                         estimator=None)\n",
+    "        \n",
+    "        # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "        p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "        \n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "We now have an HRD. It took longer to make the plot than to run the stars with *binary_c*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## Binary stars"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d0fc4e-c72f-444a-93ab-19f52086b86d",
+   "metadata": {},
+   "source": [
+    "Now we put a secondary star of mass $0.5\\mathrm{M}_\\odot$ at a distance of $10\\mathrm{R}_\\odot$ to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "478e8005-e144-4e6f-80c9-0cf368a9bcb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 0.5, # Msun\n",
+    "    separation = 10, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c433e6a-fe22-4494-b1a9-fce9676a9f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3557b6d5-6c54-467c-b7a1-b1903493c441",
+   "metadata": {},
+   "source": [
+    "We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59335030-dd99-4c2f-afff-207a3fcbbb70",
+   "metadata": {},
+   "source": [
+    "If we now set the separation to be longer, say $100\\mathrm{R}_\\odot$, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, $1\\mathrm{M}_\\odot$, so that the interaction is stronger."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dee92b20-ad6b-4c97-80dc-71d3bd937c4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 1, # Msun\n",
+    "    separation = 100, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    "    alpha_ce = 1.0, # make common-envelope evolution quite efficient\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e0ac2573-bc35-43be-8f20-5c85364fde11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f8e061-a65e-47f2-a777-93de0d5045ea",
+   "metadata": {},
+   "source": [
+    "You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the $1\\mathrm{M}_\\odot$ star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698d0a63-11ba-4b3e-a713-35c3e972492f",
+   "metadata": {},
+   "source": [
+    "We can also plot the secondary stars' HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That's because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2b0b7c2b-6e43-48ed-9257-9dfc141b3d28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "star  1\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '1': # choose only secondaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "            \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92c46319-5629-4125-a284-b5d521ed33fc",
+   "metadata": {},
+   "source": [
+    "Remember, all these stars start with a $1\\mathrm{M}_\\odot$ binary, which begins at $\\log_{10}(T_\\mathrm{eff}/\\mathrm{K})\\sim 3.750$, $\\log_{10}L/\\mathrm{L}_\\odot \\sim 0$. The $1\\mathrm{M}_\\odot$-$1\\mathrm{M}_\\odot$ binary evolves like two single stars until they interact up the giant branch at about $\\log_{10} (L/\\mathrm{L}_\\odot) \\sim 2.5$, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the very start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53145356-abbb-4880-996f-dedd80de7540",
+   "metadata": {},
+   "source": [
+    "This is, of course, a very simple introduction to what happens in binaries. We haven't talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events. "
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/notebook_api_functionality.ipynb b/docs/source/notebook_api_functionality.ipynb
index d81c31711bfc5d6de3159fd8958df96dd145ded0..020d2dc7cdb1ae9f1214d42e3351b571ff0c943d 100644
--- a/docs/source/notebook_api_functionality.ipynb
+++ b/docs/source/notebook_api_functionality.ipynb
@@ -5,7 +5,7 @@
    "id": "cb9d00f5-9613-471e-a4bb-6181311bf73b",
    "metadata": {},
    "source": [
-    "# Using the API functionality of binarycpython\n",
+    "# Tutorial: Using the API functionality of binary_c-python\n",
     "This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw\n",
     "\n",
     "Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in `src/binary_c_python.c`, and the functions are available via `from binarycpython import _binary_c_bindings`.\n",
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "ded7eaf6-e1ba-46c2-9f6f-9ebcb14a264d",
    "metadata": {},
    "outputs": [
@@ -30,37 +30,69 @@
       "\n",
       "FUNCTIONS\n",
       "    free_persistent_data_memaddr_and_return_json_output(...)\n",
-      "        Frees the persistent_data memory and returns the json output\n",
+      "        Frees the persistent_data memory and returns the json output.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)\n",
       "    \n",
       "    free_store_memaddr(...)\n",
-      "        Frees the store memaddr\n",
+      "        Frees the store memaddr.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the store object\n",
       "    \n",
       "    return_arglines(...)\n",
       "        Return the default args for a binary_c system\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_help(...)\n",
       "        Return the help info for a given parameter\n",
+      "        \n",
+      "        Arguments:\n",
+      "                parameter: parameter name.\n",
       "    \n",
       "    return_help_all(...)\n",
       "        Return an overview of all the parameters, their description, categorized in sections\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_maximum_mass_ratio_for_RLOF(...)\n",
-      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_minimum_orbit_for_RLOF(...)\n",
-      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_persistent_data_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_store_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_version_info(...)\n",
       "        Return the version information of the used binary_c build\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    run_system(...)\n",
-      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things. \n",
+      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.\n",
       "        \n",
       "        Arguments:\n",
       "                argstring: argument string for binary_c\n",
@@ -126,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "10a74d5a-a3d5-4543-a5bc-20d1fe885bb4",
    "metadata": {},
    "outputs": [
@@ -134,8 +166,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<capsule object \"STORE\" at 0x7f163859d0c0>\n",
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
+      "<capsule object \"STORE\" at 0x7fa6a45ed180>\n",
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
       "\n"
      ]
     }
@@ -183,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "318874f6-7acf-49bb-9786-299d4dffc0b3",
    "metadata": {},
    "outputs": [
@@ -217,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "d7e757ae-579c-42a2-a310-f0401b7800e8",
    "metadata": {
     "scrolled": true,
@@ -291,6 +323,9 @@
       "opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)\n",
       "wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0\n",
       "gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)\n",
+      "postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&A 635, A173). : (null)\n",
+      "Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)\n",
+      "Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)\n",
       "mattsson_Orich_tpagbwind : Experimental : turns on Mattsson's TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)\n",
       "magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)\n",
       "magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)\n",
@@ -310,7 +345,9 @@
       "vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)\n",
       "vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)\n",
       "tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers' mass loss formula. (This multiplies the 4e-13 in Reimers' formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)\n",
+      "Tout_Pringle_1992_multiplier : Multiplier for the Tout & Pringle (1992) magnetic wind. (0.0) : (null)\n",
       "artificial_mass_accretion_rate%d : Constant mass accretion rate for star <n>. : (null)\n",
+      "artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type <n>. : (null)\n",
       "artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star <n>. : (null)\n",
       "artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)\n",
       "artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if <0 (default is -1). : (null)\n",
@@ -318,8 +355,7 @@
       "wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge's version of Vink's early-2000s wind (See Lynnette Dray's thesis, or John Eldridge's thesis) : (null)\n",
       "wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)\n",
       "wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)\n",
-      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)\n",
-      "PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore\n",
+      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)\n",
       "sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -331,9 +367,6 @@
       "sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -345,9 +378,6 @@
       "sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_companion_IA_He : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_ELD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_CHAND : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
@@ -368,9 +398,6 @@
       "sn_kick_companion_BH_NS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PPISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PHDIS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)\n",
       "wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)\n",
       "wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)\n",
@@ -443,6 +470,11 @@
       "HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)\n",
       "wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)\n",
       "wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)\n",
+      "colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)\n",
+      "apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)\n",
+      "degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)\n",
+      "degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)\n",
+      "degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)\n",
       "\n",
       "############################################################\n",
       "##### Section Binary\n",
@@ -709,7 +741,6 @@
       "############################################################\n",
       "##### Section Output\n",
       "############################################################\n",
-      "david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions : Ignore\n",
       "cf_amanda_log : Enable logging to compare to Amanda's models. : (null)\n",
       "float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)\n",
       "save_pre_events_stardata : Enable this to save a copy of stardata to stardata->pre_events_stardata just before an event. : (null)\n",
@@ -739,6 +770,7 @@
       "escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)\n",
       "colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. : \n",
       "log_filename : Location of the output logging filename. If set to \"/dev/null\" then there is no logging. : \n",
+      "log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. : \n",
       "stopfile : File which, when it exists, will stop the current binary_c repeat run. : \n",
       "stardata_dump_filename : Location of the stardata dump file. : \n",
       "stardata_load_filename : Location of the stardata file to load. : \n",
@@ -763,8 +795,12 @@
       "MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. : \n",
       "MINT_remesh : Turn on or off MINT's remeshing. : \n",
       "MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) : \n",
+      "MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) : \n",
       "MINT_disable_grid_load_warnings : Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data. : \n",
       "MINT_Kippenhahn : Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. : \n",
+      "MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) : \n",
+      "MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) : \n",
+      "MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) : \n",
       "MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. : \n",
       "MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. : \n",
       "MINT_nuclear_burning : Turn on or off MINT's nuclear burning algorithm. : \n",
@@ -825,7 +861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 5,
    "id": "3d29ca9d-ac66-4f9e-81cf-2edd14a98b79",
    "metadata": {},
    "outputs": [
@@ -854,7 +890,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "e517f561-09c6-419d-ba89-d9cb61e6ebab",
    "metadata": {},
    "outputs": [
@@ -887,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "id": "7da75a95-8831-4346-a584-e042ced75249",
    "metadata": {},
    "outputs": [
diff --git a/docs/source/notebook_common_envelope_evolution.ipynb b/docs/source/notebook_common_envelope_evolution.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..526320ccf954c1ed86c6d5c641204c4a9345bbe5
--- /dev/null
+++ b/docs/source/notebook_common_envelope_evolution.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Common-envelope evolution\n",
+    "\n",
+    "In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.\n",
+    "\n",
+    "First, we import a few required Python modules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_comenv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Setting up the Population object\n",
+    "We set up a new population object. Our stars evolve to $13.7\\text{ }\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. We also set the common-envelope ejection efficiency $\\alpha_\\mathrm{CE}=1$ and the envelope structure parameter $\\lambda=0.5$. More complex options are available in *binary_c*, such as $\\lambda$ based on stellar mass, but this is just a demonstration example so let's keep things simple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: log_dt=10 to grid_options\n",
+      "adding: max_evolution_time=13700 to BSE_options\n",
+      "adding: metallicity=0.02 to BSE_options\n",
+      "adding: alpha_ce=1.0 to BSE_options\n",
+      "adding: lambda_ce=0.5 to BSE_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    # grid options\n",
+    "    tmp_dir = TMP_DIR,\n",
+    "    verbosity = 1,\n",
+    "    log_dt = 10, # log every 10 seconds\n",
+    "\n",
+    "    # binary-star evolution options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    alpha_ce = 1.0,\n",
+    "    lambda_ce = 0.5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $6\\text{ }\\mathrm{M}_\\odot$. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to $10^4\\text{ }\\mathrm{d}$ because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"lnm1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        6\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(math.log(1), math.log(6), 10)\",\n",
+      "    \"precode\": \"M_1=math.exp(lnm1)\",\n",
+      "    \"probdist\": \"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+      "    \"dphasevol\": \"dlnm1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"q\",\n",
+      "    \"longname\": \"Mass ratio\",\n",
+      "    \"valuerange\": [\n",
+      "        \"0.1/M_1\",\n",
+      "        1\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1/M_1, 1, 10)\",\n",
+      "    \"precode\": \"M_2 = q * M_1\",\n",
+      "    \"probdist\": \"flatsections(q, [{'min': 1/M_1, 'max': 1.0, 'height': 1}])\",\n",
+      "    \"dphasevol\": \"dq\",\n",
+      "    \"parameter_name\": \"M_2\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 1\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"log10per\",\n",
+      "    \"longname\": \"log10(Orbital_Period)\",\n",
+      "    \"valuerange\": [\n",
+      "        0.15,\n",
+      "        5.5\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(0.15, 4, 10)\",\n",
+      "    \"precode\": \"orbital_period = 10.0 ** log10per\\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)\",\n",
+      "    \"probdist\": \"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)\",\n",
+      "    \"dphasevol\": \"dlog10per\",\n",
+      "    \"parameter_name\": \"orbital_period\",\n",
+      "    \"condition\": null,\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 2\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10, \"q\" : 10, \"per\": 10} \n",
+    "massrange = [1, 6] \n",
+    "logperrange = [0.15, 4]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Logging and handling the output\n",
+    "\n",
+    "We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "\n",
+      "/*\n",
+      " * Detect when the comenv_count increased \n",
+      " */\n",
+      "if(stardata->model.comenv_count == 1 && \n",
+      "   stardata->previous_stardata->model.comenv_count == 0)\n",
+      "{\n",
+      "   /*\n",
+      "    * We just had this system's first common envelope:\n",
+      "    * output the time at which this happens, \n",
+      "    * the system's probability (proportional to the number of stars),\n",
+      "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+      "    * the current timestep (post-comenv) orbital period (days)\n",
+      "    */\n",
+      "    Printf(\"COMENV %g %g %g %g\\n\",\n",
+      "           stardata->model.time,\n",
+      "           stardata->model.probability,\n",
+      "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+      "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+      "           \n",
+      "    /*\n",
+      "     * We should waste no more CPU time on this system now we have the\n",
+      "     * data we want.\n",
+      "     */\n",
+      "    stardata->model.evolution_stop = TRUE;\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "\n",
+    "/*\n",
+    " * Detect when the comenv_count increased \n",
+    " */\n",
+    "if(stardata->model.comenv_count == 1 && \n",
+    "   stardata->previous_stardata->model.comenv_count == 0)\n",
+    "{\n",
+    "   /*\n",
+    "    * We just had this system's first common envelope:\n",
+    "    * output the time at which this happens, \n",
+    "    * the system's probability (proportional to the number of stars),\n",
+    "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+    "    * the current timestep (post-comenv) orbital period (days)\n",
+    "    */\n",
+    "    Printf(\"COMENV %g %g %g %g\\\\n\",\n",
+    "           stardata->model.time,\n",
+    "           stardata->model.probability,\n",
+    "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+    "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+    "           \n",
+    "    /*\n",
+    "     * We should waste no more CPU time on this system now we have the\n",
+    "     * data we want.\n",
+    "     */\n",
+    "    stardata->model.evolution_stop = TRUE;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"COMENV\" and process the associated data. We set up the parse_data function to do just this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14736bebc040> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "# log-period distribution bin width (dex)\n",
+    "binwidth = 0.5 \n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"probability\", \"pre_comenv_period\", \"post_comenv_period\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "        # choose COMENV lines of output\n",
+    "        if linedata[\"header\"] == \"COMENV\":\n",
+    "            # bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex\n",
+    "            binned_pre_period = bin_data(math.log10(linedata[\"pre_comenv_period\"]), binwidth)\n",
+    "            \n",
+    "            # but check if the post-comenv period is finite and positive: if \n",
+    "            # not, the system has merged and we give it an aritifical period\n",
+    "            # of 10^-100 days (which is very much unphysical)\n",
+    "            if linedata[\"post_comenv_period\"] > 0.0:\n",
+    "                binned_post_period = bin_data(math.log10(linedata[\"post_comenv_period\"]), binwidth)\n",
+    "            else:\n",
+    "                binned_post_period = bin_data(-100,binwidth) # merged!\n",
+    "                \n",
+    "            # make the \"histograms\"\n",
+    "            self.grid_results['pre'][binned_pre_period] += linedata[\"probability\"]\n",
+    "            self.grid_results['post'][binned_post_period] += linedata[\"probability\"]\n",
+    "\n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 1000 stars\n",
+      "with a total probability of 0.0645905996773004\n",
+      "Total starcount for this run will be: 1000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-12T18:07:39.965721.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee47e0>\n",
+      "Process 1 started at 2021-09-12T18:07:39.970949.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n",
+      "Process 2 started at 2021-09-12T18:07:39.978355.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4f30>\n",
+      "Process 3 started at 2021-09-12T18:07:39.983689.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB\n",
+      "322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB\n",
+      "465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB\n",
+      "586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB\n",
+      "682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB\n",
+      "784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB\n",
+      "872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB\n",
+      "963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).\n",
+      "\tRan 222 systems with a total probability of 0.014137215791516371.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).\n",
+      "\tRan 273 systems with a total probability of 0.01877334232598154.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).\n",
+      "\tRan 268 systems with a total probability of 0.016469813170514686.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).\n",
+      "\tRan 237 systems with a total probability of 0.015210228389288167.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'ad303100d719457c83256568f9a9887c', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.06459059967730076, 'total_count': 1000, 'start_timestamp': 1631462859.9342952, 'end_timestamp': 1631462947.4824853, 'total_mass_run': 4680.235689312421, 'total_probability_weighted_mass_run': 0.22611318083528567, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'merged': 0.035263029200000025, 'unmerged': 0.019388724199999995}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Number of stars')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the distributions\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import copy\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "# remove the merged objects\n",
+    "probability = { \"merged\" : 0.0, \"unmerged\" : 0.0}\n",
+    "\n",
+    "# copy the results so we can change the copy\n",
+    "results = copy.deepcopy(population.grid_results)\n",
+    "\n",
+    "for distribution in ['post']:    \n",
+    "    for logper in population.grid_results[distribution]:\n",
+    "        dprob = results[distribution][logper]\n",
+    "        if logper < -90:\n",
+    "            # merged system\n",
+    "            probability[\"merged\"] += dprob\n",
+    "            del results[distribution][logper]\n",
+    "        else:\n",
+    "            # unmerged system\n",
+    "            probability[\"unmerged\"] += dprob\n",
+    "print(probability)\n",
+    "    \n",
+    "# pad the final distribution with zero\n",
+    "for distribution in population.grid_results:    \n",
+    "    pad_output_distribution(results[distribution],\n",
+    "                            binwidth)\n",
+    "    \n",
+    "# make pandas dataframe \n",
+    "plot_data = pd.DataFrame.from_dict(results, orient='columns')\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10} (P_\\mathrm{orb} / \\mathrm{day})$\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "#p.set(xlim=(-5,5)) # might be necessary?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4740c93-d01e-4ca1-8766-c2fb4ddca2e4",
+   "metadata": {},
+   "source": [
+    "You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range $10$ to $1000\\text{ }\\mathrm{d}$, while after CEE the distribution peaks at about $1\\text{ }\\mathrm{d}$. Some of these orbits are very short: $\\log_{10}(-2) = 0.01\\text{ }\\mathrm{d}\\sim10\\text{ }\\mathrm{minutes}$. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57faf043-3809-427a-b378-2355ce8c2691",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Extend the logging to output more data than just the orbital period.\n",
+    "* What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova?\n",
+    "* What are the lifetimes of the systems in close ($<1\\text{ }\\mathrm{d}$) binaries? Are they likely to merge in the life of the Universe?\n",
+    "* How much mass is lost in common-envelope interactions?\n",
+    "* Extend the grid to massive stars. Do you see many NS and BH compact binaries?\n",
+    "* Try different $\\alpha_\\mathrm{CE}$ and $\\lambda_\\mathrm{CE}$ options...\n",
+    "* ... and perhaps increased resolution to obtain smoother curves.\n",
+    "* Why do long-period systems not reach common envelope evolution?"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/notebook_custom_logging.ipynb b/docs/source/notebook_custom_logging.ipynb
index 05ffbccfc23f0b08e85abed0d467233385520a4b..bfdf2a5c8fe238aec50d8f69c74d11b06491eb5f 100644
--- a/docs/source/notebook_custom_logging.ipynb
+++ b/docs/source/notebook_custom_logging.ipynb
@@ -5,13 +5,13 @@
    "id": "879b596b-d70c-4f90-b668-563b4ad93ffc",
    "metadata": {},
    "source": [
-    "# Using custom logging routines with binarycpython\n",
+    "# Tutorial: Using custom logging routines with binary_c-python\n",
     "In this notebook you'll learn how to use the custom logging functionality"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "696ecbb9-1efd-48f4-a57e-2cf6dfe416f1",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "236cf821-09ac-4237-9b8f-6e36d2edf446",
    "metadata": {},
    "outputs": [
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "feb423d5-5cc3-433c-9801-f8017abbc03a",
    "metadata": {},
    "outputs": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 4,
    "id": "2f5defbf-c623-49ed-a238-fba52a563a58",
    "metadata": {},
    "outputs": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 5,
    "id": "dcd74bbc-478b-43e4-b495-8c456e8d1d88",
    "metadata": {},
    "outputs": [
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 6,
    "id": "77bd09b0-1a94-499d-97db-a1f991c67c12",
    "metadata": {},
    "outputs": [
@@ -203,10 +203,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1\n",
-      "EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2\n"
+      "EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1\n",
+      "EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2\n"
      ]
     }
    ],
@@ -260,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 7,
    "id": "30142286-34ce-433e-82c8-565e2160ff5b",
    "metadata": {},
    "outputs": [
@@ -336,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "id": "6f0edc65-a788-4706-a0c5-2ace030765ec",
    "metadata": {},
    "outputs": [
@@ -344,8 +344,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
-      "EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5\n"
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
+      "EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5\n"
      ]
     }
    ],
@@ -395,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 10,
    "id": "8f58fdf9-3e76-4c18-a1c5-eed0980d4133",
    "metadata": {},
    "outputs": [
@@ -403,8 +403,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1\n",
-      "EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0\n"
+      "EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1\n",
+      "EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458\n"
      ]
     }
    ],
@@ -424,58 +424,27 @@
     "{\n",
     "    if (stardata->model.time < stardata->model.max_evolution_time)\n",
     "    {\n",
-    "        if(stardata->pre_events_stardata != NULL)\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
-    "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->pre_events_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "        Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
+    "            \"%g %g %g %d \" // 2-5\n",
+    "            \"%d %d %g %g \" // 6-9\n",
+    "            \"%g %g\\\\n\", // 10-13\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->pre_events_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[ID_core(stardata->pre_events_stardata->star[0].stellar_type)],           // 9\n",
-    "\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
-    "        else\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
+    "            // \n",
+    "            stardata->model.time, // 1\n",
     "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->previous_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "            stardata->star[0].mass, //2\n",
+    "            stardata->previous_stardata->star[0].mass, //3\n",
+    "            stardata->common.zero_age.mass[0], //4\n",
+    "            stardata->star[0].SN_type, //5\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->previous_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
+    "            stardata->star[0].stellar_type, //6\n",
+    "            stardata->previous_stardata->star[0].stellar_type, //7\n",
+    "            stardata->model.probability, //8\n",
+    "            stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
     "\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_He]    // 11\n",
+    "        );\n",
     "    };\n",
     "    /* Kill the simulation to save time */\n",
     "    stardata->model.max_evolution_time = stardata->model.time - stardata->model.dtm;\n",
@@ -491,6 +460,14 @@
     "# print (abridged) output\n",
     "print(\"\\n\".join(output.splitlines()[-2:]))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "484297c0-accb-4efc-a9c8-dbd2f32b89a6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/docs/source/notebook_extra_features.ipynb b/docs/source/notebook_extra_features.ipynb
index b1a9ddb030195e6aaf0da2cf08eecc67684672a6..076b4098e7c588a68fb91cfe6175c3ee4e36ea78 100644
--- a/docs/source/notebook_extra_features.ipynb
+++ b/docs/source/notebook_extra_features.ipynb
@@ -5,7 +5,7 @@
    "id": "d5c04b77-f0be-4b33-8c03-c72eb846527c",
    "metadata": {},
    "source": [
-    "# Extra features and functionality of binarycpython\n",
+    "# Tutorial: Extra features and functionality of binary_c-python\n",
     "In this notebook we'll go over some of the extra features and functionality that was not covered in the other notebooks.\n",
     "\n",
     "Within the module `binarycpython.utils.functions` there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the `help()`"
diff --git a/docs/source/notebook_individual_systems.ipynb b/docs/source/notebook_individual_systems.ipynb
index 21d49016f3b2826d6f9d5ec87a1f6d8bb18df7af..85aef1e3962a1626f37a9ef36bf5e16f479eb68e 100644
--- a/docs/source/notebook_individual_systems.ipynb
+++ b/docs/source/notebook_individual_systems.ipynb
@@ -5,7 +5,7 @@
    "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
    "metadata": {},
    "source": [
-    "# Running individual systems with binarycpython\n",
+    "# Tutorial: Running individual systems with binary_c-python\n",
     "This notebook will show you how to run single systems and analyze their results.\n",
     "\n",
     "It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc. "
@@ -566,7 +566,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -580,7 +580,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/docs/source/notebook_luminosity_function_binaries.ipynb b/docs/source/notebook_luminosity_function_binaries.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..c6b5f1e64cc36c684fdf5cefe0fae4b450a1c936
--- /dev/null
+++ b/docs/source/notebook_luminosity_function_binaries.ipynb
@@ -0,0 +1,701 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 4*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "\n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][int(nstar)][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 256 stars\n",
+      "with a total probability of 0.6149734610296649\n",
+      "Total starcount for this run will be: 256\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
+      "\n",
+      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
+      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
+      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
+      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
+      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
+      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
+      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
+      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
+      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "\n",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
+    "\n",
+    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Things to try:\n",
+    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
+    "* Alter the metallicity, does this make much of a difference?\n",
+    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
+    "* How might you go about comparing these computed observations to real stars?\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/notebook_luminosity_function_single.ipynb b/docs/source/notebook_luminosity_function_single.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..cdae316f90802fe46611ea17732506c0410aef55
--- /dev/null
+++ b/docs/source/notebook_luminosity_function_single.ipynb
@@ -0,0 +1,725 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Zero-age stellar luminosity function\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of single stars using binary_c. \n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_luminosity\")\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 0.5 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Mass\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    tmp_dir=TMP_DIR,\n",
+    ")\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const({min}, {max}, {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"{probtot}/({max} - {min})\".format(probtot = total_probability, min = massrange[0], max = massrange[1]), # dprob/dm1 : all stars are equally likely so this is 1.0 / (Mmax - Mmin)\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "   /* Note that we use Printf - with a capital P! */\n",
+    "   Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR %30.12e %g %g %g %g\\\\n\",\n",
+    "          stardata->model.time, // 1\n",
+    "          stardata->common.zero_age.mass[0], // 2\n",
+    "          stardata->star[0].mass, // 3\n",
+    "          stardata->star[0].luminosity, // 4\n",
+    "          stardata->model.probability // 5\n",
+    "      );\n",
+    "};\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "        \n",
+    "        # Check the header and act accordingly\n",
+    "        if linedata['header'] == \"ZERO_AGE_MAIN_SEQUENCE_STAR\":\n",
+    "            \n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 1.0000000000000004\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=2,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'e6c082aabe0849a0811761a06e50476b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631461389.3681686, 'end_timestamp': 1631461391.6702895, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "                    \n",
+    "\n",
+    "# this saves a lot of typing! \n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
+   "metadata": {},
+   "source": [
+    "## ZAMS Luminosity distribution with the initial mass function\n",
+    "\n",
+    "In the previous example, all the stars in our grid had an equal weighting. This is very unlikely to be true in reality: indeed, we know that low mass stars are far more likely than high mass stars.  So we now include an initial mass function as a three-part power law based on Kroupa (2001). Kroupa's distribution is a three-part power law: we have a function that does this for us (it's very common to use power laws in astrophysics).\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Update the probability distribution to use the three-part power law IMF \n",
+    "population.update_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)\",\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.2182216189410787\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 14,
+   "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 14,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0546f2f3-4732-4841-8ef3-565fbf6b9961",
+   "metadata": {},
+   "source": [
+    "This distribution is peaked at low luminosity, as one expects from observations, but the resolution is clearly not great because it's not smooth - it's spiky! \n",
+    "\n",
+    "If you noticed above, the total probability of the grid was about 0.2. Given that the total probability of a probability distribution function should be 1.0, this shows that our sampling is (very) poor. \n",
+    "\n",
+    "We could simply increase the resolution to compensate, but this is very CPU intensive and a complete waste of time and resources. Instead, let's try sampling the masses of the stars in a smarter way."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "673031c9-7d80-45d4-b209-301c127d3edf",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## A better-sampled grid\n",
+    "\n",
+    "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
+    "\n",
+    "To do this we first rename the mass grid variable so that it is clear we are working in (natural) logarithmic phase space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Rename the old variable (M_1) because we want it to be called lnM_1 now\n",
+    "population.rename_grid_variable(\"M_1\",\"lnM_1\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "532f691c-c1f6-46cc-84f2-970ec1216e40",
+   "metadata": {},
+   "source": [
+    "Next, we change the spacing function so that it works in the log space. We also adapt the probability calculation so that it calculates dprob/dlnM = M * dprob/dM. Finally, we set the precode to compute M_1 because binary_c requires the actual mass, not the logarithm of the mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# update the sampling, note that the IMF is dprob/dM1, and the phase \n",
+    "# space is now sampled in lnM1, so we multiply by M_1 to \n",
+    "# because  M * dprob/dM = dprob/dlnM\n",
+    "population.update_grid_variable(\n",
+    "    name=\"lnM_1\",\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min = massrange[0], max = massrange[1], res = resolution[\"M_1\"]),\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    precode=\"M_1=math.exp(lnM_1)\",\n",
+    ")\n",
+    "# print(population.grid_options[\"_grid_variables\"]) # debugging"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 17,
+   "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Grid has handled 40 stars\n",
+      "with a total probability of 0.9956307907476224\n",
+      "Total starcount for this run will be: 40\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnM_1\n",
+      "Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Clean and re-evolve the population \n",
+    "population.clean()\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "182b1094-5057-4ccf-bac6-9b0e560ad4f6",
+   "metadata": {},
+   "source": [
+    "You should see that the total probability is very close to 1.0, as you would expect for a well-sampled grid. The total will never be exactly 1.0, but that is because we are running a simulation, not a perfect copy of reality."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# plot luminosity distribution\n",
+    "ldist = population.grid_results['luminosity distribution']\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "pad_output_distribution(ldist,\n",
+    "                        binwidth['luminosity'])\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict({'ZAMS luminosity distribution' : ldist})\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "31fe91bb-177d-4e4e-90cf-298a3f8a8b61",
+   "metadata": {},
+   "source": [
+    "Most stars are low mass red dwarfs, with small luminosities. Without the IMF weighting, our model population would have got this completely wrong! \n",
+    "\n",
+    "As you increase the resolution, you will see this curve becomes even smoother. The wiggles in the curve are (usually) sampling artefacts because the curve should monotonically brighten above about log(*L*/L<sub>☉</sub>)=-2. \n",
+    " \n",
+    "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
+    "* Different initial distributions: the Kroupa distribution isn't the only one out there\n",
+    "* Change the metallicity and mass ranges\n",
+    "* What about a non-constant star formation rate? This is more of a challenge!\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
+    "* Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/docs/source/notebook_population.ipynb b/docs/source/notebook_population.ipynb
index 961a3b71a53f33b947392c6778cdddde7aca0349..a24638c0bd3a15a57bbf611fccb71b2100c75945 100644
--- a/docs/source/notebook_population.ipynb
+++ b/docs/source/notebook_population.ipynb
@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Running populations with binarycpython\n",
+    "# Tutorial: Running populations with binary_c-python\n",
     "This notebook will show you how to evolve a population of stars\n",
     "\n",
     "Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let's go through the functionality of this object step by step and set up some example populations. \n",
@@ -23,9 +23,12 @@
    "outputs": [],
    "source": [
     "import os\n",
+    "\n",
     "from binarycpython.utils.custom_logging_functions import temp_dir\n",
     "from binarycpython.utils.grid import Population\n",
     "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_population\")\n",
+    "\n",
     "# help(Population) # Uncomment to see the public functions of this object"
    ]
   },
@@ -60,7 +63,8 @@
       "adding: max_evolution_time=15000 to BSE_options\n",
       "adding: eccentricity=0.02 to BSE_options\n",
       "adding: amt_cores=2 to grid_options\n",
-      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/example_python_population_result to custom_options >>>>\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_population to grid_options\n",
+      "<<<< Warning: Key does not match previously known parameter:                     adding: data_dir=/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result to custom_options >>>>\n",
       "<<<< Warning: Key does not match previously known parameter:                     adding: base_filename=example_pop.dat to custom_options >>>>\n",
       "1\n",
       "example_pop.dat\n",
@@ -88,11 +92,12 @@
     "\n",
     "\n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "    \n",
     "    # Custom options # TODO: need to be set in grid_options probably\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -133,13 +138,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Writing settings to /tmp/binary_c_python/example_python_population_result/example_pop_settings.json\n"
+      "Writing settings to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json\n"
      ]
     },
     {
      "data": {
       "text/plain": [
-       "'/tmp/binary_c_python/example_python_population_result/example_pop_settings.json'"
+       "'/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/example_pop_settings.json'"
       ]
      },
      "execution_count": 3,
@@ -181,7 +186,7 @@
      "text": [
       "Help on method add_grid_variable in module binarycpython.utils.grid:\n",
       "\n",
-      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='edge', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
+      "add_grid_variable(name:str, longname:str, valuerange:Union[list, str], resolution:str, spacingfunc:str, probdist:str, dphasevol:Union[str, int], parameter_name:str, gridtype:str='centred', branchpoint:int=0, precode:Union[str, NoneType]=None, condition:Union[str, NoneType]=None) -> None method of binarycpython.utils.grid.Population instance\n",
       "    Function to add grid variables to the grid_options.\n",
       "    \n",
       "    The execution of the grid generation will be through a nested for loop.\n",
@@ -199,25 +204,25 @@
       "        name:\n",
       "            name of parameter. This is evaluated as a parameter and you can use it throughout\n",
       "            the rest of the function\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                name = 'lnm1'\n",
       "        longname:\n",
       "            Long name of parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                longname = 'Primary mass'\n",
       "        range:\n",
       "            Range of values to take. Does not get used really, the spacingfunction is used to\n",
       "            get the values from\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                range = [math.log(m_min), math.log(m_max)]\n",
       "        resolution:\n",
       "            Resolution of the sampled range (amount of samples).\n",
       "            TODO: check if this is used anywhere\n",
       "    \n",
-      "            Examples: \n",
+      "            Examples:\n",
       "                resolution = resolution[\"M_1\"]\n",
       "        spacingfunction:\n",
       "            Function determining how the range is sampled. You can either use a real function,\n",
@@ -230,12 +235,12 @@
       "        precode:\n",
       "            Extra room for some code. This code will be evaluated within the loop of the\n",
       "            sampling function (i.e. a value for lnm1 is chosen already)\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                precode = 'M_1=math.exp(lnm1);'\n",
       "        probdist:\n",
       "            Function determining the probability that gets assigned to the sampled parameter\n",
-      "            \n",
+      "    \n",
       "            Examples:\n",
       "                probdist = 'Kroupa2001(M_1)*M_1'\n",
       "        dphasevol:\n",
@@ -249,7 +254,7 @@
       "                condition = 'self.grid_options['binary']==1'\n",
       "        gridtype:\n",
       "            Method on how the value range is sampled. Can be either 'edge' (steps starting at\n",
-      "            the lower edge of the value range) or 'center'\n",
+      "            the lower edge of the value range) or 'centred'\n",
       "            (steps starting at lower edge + 0.5 * stepsize).\n",
       "\n"
      ]
@@ -313,7 +318,7 @@
       "    \"dphasevol\": \"dlnm1\",\n",
       "    \"parameter_name\": \"M_1\",\n",
       "    \"condition\": \"\",\n",
-      "    \"gridtype\": \"edge\",\n",
+      "    \"gridtype\": \"centred\",\n",
       "    \"branchpoint\": 0,\n",
       "    \"grid_variable_number\": 0\n",
       "}\n"
@@ -457,7 +462,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: parse_function=<function parse_function at 0x7ff3bdf79620> to grid_options\n"
+      "adding: parse_function=<function parse_function at 0x7f531bc3b6a8> to grid_options\n"
      ]
     }
    ],
@@ -536,25 +541,25 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
-      "EXAMPLE_COMPACT_OBJECT             2.867655467480e+01 1.33079 9.81391 0.00167028 13\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "EXAMPLE_COMPACT_OBJECT             1.931266944719e+01 1.3933 12.3177 0.00124307 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.439623364590e+01 1.38004 7.81906 0.00224431 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.364277535630e+01 1.47961 15.4603 0.000925128 13\n",
-      "EXAMPLE_COMPACT_OBJECT             1.017435498578e+01 1.59052 19.4046 0.000688507 13\n",
-      "EXAMPLE_COMPACT_OBJECT             8.294870923827e+00 1.7197 24.3552 0.000512406 13\n",
-      "EXAMPLE_COMPACT_OBJECT             6.802132608769e+00 1.84162 30.5689 0.000381347 13\n",
-      "EXAMPLE_COMPACT_OBJECT             5.723570798020e+00 1.99471 38.3678 0.00028381 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.933751523833e+00 2.15875 48.1564 0.000211219 13\n",
-      "EXAMPLE_COMPACT_OBJECT             4.337250536639e+00 2.35209 60.4424 0.000157195 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.862081089332e+00 2.56776 75.8628 0.000116989 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.449960890183e+00 2.80457 95.2174 8.70668e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.172196856333e+00 3.05193 119.51 6.47976e-05 14\n",
-      "EXAMPLE_COMPACT_OBJECT             3.069627290216e+00 3.27563 150 4.82242e-05 14\n",
-      "Population-2a7732d03e594ef4b5dfe9051b41d9c0 finished! The total probability was: 0.05150046619238191. It took a total of 0.7797017097473145s to run 20 systems on 2 cores\n",
+      "EXAMPLE_COMPACT_OBJECT             4.139293101586e+01 1.29427 8.13626 0.00202467 13\n",
+      "EXAMPLE_COMPACT_OBJECT             2.802986496151e+01 1.33699 10.0967 0.00152924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.963621764679e+01 1.39754 12.5294 0.00115504 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.427601421985e+01 1.47745 15.5483 0.000872405 13\n",
+      "EXAMPLE_COMPACT_OBJECT             1.094409257247e+01 1.57571 19.2947 0.00065893 13\n",
+      "EXAMPLE_COMPACT_OBJECT             9.181971798545e+00 1.68748 23.9436 0.000497691 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.905335716621e+00 1.77287 29.7128 0.000375908 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.451192744924e+00 1.81495 36.872 0.000283924 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396133472739e+00 1.82088 45.7561 0.000214449 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.396675941641e+00 1.82123 56.7809 0.000161974 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.404641347602e+00 1.82074 70.4621 0.000122339 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.444217227690e+00 1.81636 87.4397 9.2403e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.453317880232e+00 1.81536 108.508 6.97923e-05 13\n",
+      "EXAMPLE_COMPACT_OBJECT             7.450828476484e+00 1.81563 134.653 5.27143e-05 13\n",
+      "Population-f28b5f98d7ef40dcb17fc2481a6d3ced finished! The total probability was: 0.04440288843805411. It took a total of 2.785212755203247s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n"
      ]
     }
@@ -586,7 +591,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'population_name': '2a7732d03e594ef4b5dfe9051b41d9c0', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.05150046619238191, 'total_count': 20, 'start_timestamp': 1628444120.234709, 'end_timestamp': 1628444121.0144107, 'total_mass_run': 730.1048014407228, 'total_probability_weighted_mass_run': 0.2983275843337705, 'zero_prob_stars_skipped': 0}\n"
+      "{'population_name': 'f28b5f98d7ef40dcb17fc2481a6d3ced', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.04440288843805411, 'total_count': 20, 'start_timestamp': 1629459533.935186, 'end_timestamp': 1629459536.7203987, 'total_mass_run': 684.2544031669779, 'total_probability_weighted_mass_run': 0.28134439269236855, 'zero_prob_stars_skipped': 0}\n"
      ]
     }
    ],
@@ -660,42 +665,22 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Saving grid code to grid_options\n",
-      "Writing grid code to /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
-      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_2a7732d03e594ef4b5dfe9051b41d9c0.py\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_population/binary_c_grid_f28b5f98d7ef40dcb17fc2481a6d3ced.py\n",
       "Grid code loaded\n",
-      "Writing binary_c calls to /tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
-      "_calculate_multiplicity_fraction: Chosen not to use any multiplicity fraction.\n",
+      "Writing binary_c calls to /tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
-      "/tmp/binary_c_python/example_python_population_result/binary_c_calls.txt\n",
-      "binary_c M_1 2.0 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.013208238029791246\n",
-      "binary_c M_1 2.5102526289471614 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.009829948023831718\n",
-      "binary_c M_1 3.1506841305680684 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.0073157281034221516\n",
-      "binary_c M_1 3.9545065608702976 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.22723621650191106 probability 0.005444573822104362\n"
+      "with a total probability of 0.044402888438054094\n",
+      "/tmp/binary_c_python/notebooks/notebook_population/example_python_population_result/binary_c_calls.txt\n",
+      "binary_c M_1 2.227955577093495 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.010905083645619543\n",
+      "binary_c M_1 2.7647737053496777 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.008236638755149857\n",
+      "binary_c M_1 3.4309362899259503 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.006221155214163634\n",
+      "binary_c M_1 4.257608426597089 eccentricity 0.02 max_evolution_time 15000 orbital_period 45000000080 phasevol 0.21587440567681548 probability 0.004698855121516278\n"
      ]
     }
    ],
    "source": [
-    "example_pop.set(verbosity=10)\n",
+    "example_pop.set(verbosity=1)\n",
     "calls_filename = example_pop.write_binary_c_calls_to_file()\n",
     "print(calls_filename)\n",
     "\n",
@@ -725,39 +710,34 @@
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Grid has handled 20 stars\n",
-      "with a total probability of 0.05150046619238192\n",
+      "with a total probability of 0.044402888438054094\n",
       "Total starcount for this run will be: 20\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
-      "Population-3680f3882c0a449c944462abffea2447 finished! The total probability was: 0.05150046619238191. It took a total of 0.6246354579925537s to run 20 systems on 2 cores\n",
+      "Population-e45c25448b32440cb7e220f4a3562907 finished! The total probability was: 0.04440288843805411. It took a total of 1.9539172649383545s to run 20 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass zams_mass probability radius stellar_type\n",
-      "2.867655467480e+01 1.33079 9.81391 0.00167028 1.72498e-05 13\n",
-      "1.931266944719e+01 1.3933 12.3177 0.00124307 1.72498e-05 13\n",
-      "4.439623364590e+01 1.38004 7.81906 0.00224431 1.72498e-05 13\n",
-      "1.364277535630e+01 1.47961 15.4603 0.000925128 1.72498e-05 13\n",
-      "1.017435498578e+01 1.59052 19.4046 0.000688507 1.72498e-05 13\n",
-      "8.294870923827e+00 1.7197 24.3552 0.000512406 1.72498e-05 13\n",
-      "6.802132608769e+00 1.84162 30.5689 0.000381347 1.72498e-05 13\n",
-      "5.723570798020e+00 1.99471 38.3678 0.00028381 1.72498e-05 13\n",
-      "4.933751523833e+00 2.15875 48.1564 0.000211219 1.72498e-05 13\n",
-      "4.337250536639e+00 2.35209 60.4424 0.000157195 9.97286e-06 14\n",
-      "3.862081089332e+00 2.56776 75.8628 0.000116989 1.08873e-05 14\n",
-      "3.449960890183e+00 2.80457 95.2174 8.70668e-05 1.18914e-05 14\n",
-      "3.172196856333e+00 3.05193 119.51 6.47976e-05 1.29402e-05 14\n",
-      "3.069627290216e+00 3.27563 150 4.82242e-05 1.38887e-05 14\n",
+      "4.139293101586e+01 1.29427 8.13626 0.00202467 1.72498e-05 13\n",
+      "2.802986496151e+01 1.33699 10.0967 0.00152924 1.72498e-05 13\n",
+      "1.963621764679e+01 1.39754 12.5294 0.00115504 1.72498e-05 13\n",
+      "1.427601421985e+01 1.47745 15.5483 0.000872405 1.72498e-05 13\n",
+      "1.094409257247e+01 1.57571 19.2947 0.00065893 1.72498e-05 13\n",
+      "9.181971798545e+00 1.68748 23.9436 0.000497691 1.72498e-05 13\n",
+      "7.905335716621e+00 1.77287 29.7128 0.000375908 1.72498e-05 13\n",
+      "7.451192744924e+00 1.81495 36.872 0.000283924 1.72498e-05 13\n",
+      "7.396133472739e+00 1.82088 45.7561 0.000214449 1.72498e-05 13\n",
+      "7.396675941641e+00 1.82123 56.7809 0.000161974 1.72498e-05 13\n",
+      "7.404641347602e+00 1.82074 70.4621 0.000122339 1.72498e-05 13\n",
+      "7.444217227690e+00 1.81636 87.4397 9.2403e-05 1.72498e-05 13\n",
+      "7.453317880232e+00 1.81536 108.508 6.97923e-05 1.72498e-05 13\n",
+      "7.450828476484e+00 1.81563 134.653 5.27143e-05 1.72498e-05 13\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -817,11 +797,12 @@
     "    eccentricity=0.02,  # bse_options\n",
     "    \n",
     "    # grid_options\n",
-    "    amt_cores=2,  # grid_options\n",
+    "    amt_cores=2,\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -876,15 +857,15 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
@@ -912,96 +893,39 @@
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Grid has handled 125 stars\n",
-      "with a total probability of 0.0862478164626921\n",
-      "Total starcount for this run will be: 125\n",
+      "Grid has handled 27 stars\n",
+      "with a total probability of 0.024868380796643753\n",
+      "Total starcount for this run will be: 27\n",
       "Generating grid code\n",
       "Constructing/adding: lnm1\n",
       "Constructing/adding: q\n",
       "Constructing/adding: log10per\n",
-      "Population-d20a4c74d20a43b881c0c9e5def5f76c finished! The total probability was: 0.08624781646269201. It took a total of 8.561265707015991s to run 125 systems on 2 cores\n",
+      "Population-05128ef4c5fe4274a0356c3e99e2f2d2 finished! The total probability was: 0.024868380796643757. It took a total of 9.792905807495117s to run 27 systems on 2 cores\n",
       "There were no errors found in this run.\n",
       "\n",
       "\n",
       "time mass_1 zams_mass_1 mass_2 zams_mass_2 stellar_type_1 prev_stellar_type_1 stellar_type_2 prev_stellar_type_2 metallicity probability\n",
-      "8.863377990313e+01 1.29444 5.88566 0 2.99283 13 5 15 15 0.02 0.000627913\n",
-      "1.146421815741e+02 0 5.88566 1.33062 4.43925 15 15 13 5 0.02 0.000627913\n",
-      "7.222715508467e+01 1.34922 5.88566 0 5.88566 13 5 15 15 0.02 0.000627913\n",
-      "1.350021848285e+01 1.48488 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171108213270e+01 1.53113 17.3205 0 0.1 13 5 15 15 0.02 0.000154349\n",
-      "1.171086983243e+01 1.53177 17.3205 0 0.1 13 9 15 15 0.02 0.000154349\n",
-      "1.170770599495e+01 1.53176 17.3205 0 4.40513 13 5 15 15 0.02 0.000172877\n",
-      "1.230407246199e+01 1.59499 17.3205 0 4.40513 13 5 15 15 0.02 0.000610573\n",
-      "1.108751340926e+01 1.70319 17.3205 0 8.71025 13 4 15 15 0.02 0.000610573\n",
-      "1.941017702765e+01 1.34903 17.3205 1.65097 8.71025 13 13 13 5 0.02 0.000172877\n",
-      "1.980988739731e+01 1.36979 17.3205 1.60808 8.71025 13 13 13 5 0.02 0.000121486\n",
-      "3.571858031651e+01 1.53174 17.3205 1.30504 8.71025 13 13 13 5 0.02 8.42148e-05\n",
-      "3.459153942631e+01 1.53176 17.3205 1.31004 8.71025 13 13 13 5 0.02 9.8162e-05\n",
-      "1.687368550125e+01 1.34937 17.3205 1.73856 13.0154 13 13 13 8 0.02 0.000172877\n",
-      "1.194842917007e+01 1.78096 17.3205 0 13.0154 13 8 15 15 0.02 0.000610573\n",
-      "1.733614170983e+01 1.53184 17.3205 1.42375 13.0154 13 13 13 5 0.02 9.8162e-05\n",
-      "1.723547465714e+01 1.38403 17.3205 1.71288 13.0154 13 13 13 8 0.02 0.000121486\n",
-      "1.764340254985e+01 1.53174 17.3205 1.41264 13.0154 13 13 13 5 0.02 8.42148e-05\n",
-      "1.170425790780e+01 1.52963 17.3205 0 17.3205 13 5 15 15 0.02 0.000172877\n",
-      "8.922967341481e+00 1.85486 17.3205 0 17.3205 13 8 15 15 0.02 0.000610573\n",
-      "1.232906623449e+01 1.41074 17.3205 1.34281 17.3205 13 13 13 8 0.02 0.000121486\n",
-      "1.170775828562e+01 1.53183 17.3205 1.53183 17.3205 13 5 13 5 0.02 9.8162e-05\n",
-      "1.170770422321e+01 1.53175 17.3205 1.53175 17.3205 13 5 13 5 0.02 8.42148e-05\n",
-      "5.075844624794e+00 2.12303 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.766606588165e+00 2.20484 50.9713 0 0.1 14 8 15 15 0.02 3.79411e-05\n",
-      "4.768305081494e+00 2.18838 50.9713 0 0.1 13 8 15 15 0.02 3.79411e-05\n",
-      "4.458869865939e+00 2.29864 50.9713 0 12.8178 14 8 15 15 0.02 0.000150087\n",
-      "1.806014211040e+01 2.10446 50.9713 1.40749 12.8178 13 13 13 5 0.02 2.9863e-05\n",
-      "4.797342083485e+00 2.10328 50.9713 0 12.8178 13 13 15 1 0.02 4.24954e-05\n",
-      "1.721374713429e+01 2.21673 50.9713 1.42212 12.8178 14 14 13 5 0.02 2.41295e-05\n",
-      "4.055645404546e+00 2.47276 50.9713 0 25.5357 14 7 15 15 0.02 0.000150087\n",
-      "1.806123543037e+01 2.21893 50.9713 1.40745 12.8178 14 14 13 5 0.02 2.07011e-05\n",
-      "8.117519147635e+00 2.10433 50.9713 2.21473 25.5357 13 13 14 8 0.02 4.24954e-05\n",
-      "8.315554923168e+00 2.15343 50.9713 2.08519 25.5357 13 13 13 8 0.02 2.9863e-05\n",
-      "7.917420996633e+00 2.21892 50.9713 1.7431 25.5357 14 14 13 8 0.02 2.07011e-05\n",
-      "7.693213405973e+00 2.21805 50.9713 1.78384 25.5357 14 14 13 8 0.02 2.41295e-05\n",
-      "3.753837732894e+00 2.62517 50.9713 0 38.2535 14 7 15 15 0.02 0.000150087\n",
-      "7.087296558990e+00 2.10417 50.9713 2.40935 38.2535 13 13 14 8 0.02 4.24954e-05\n",
-      "7.007109286263e+00 2.15854 50.9713 2.28672 38.2535 13 13 14 8 0.02 2.9863e-05\n",
-      "5.653200958306e+00 2.21878 50.9713 2.0587 38.2535 14 14 13 8 0.02 2.41295e-05\n",
-      "5.733794947644e+00 2.21892 50.9713 1.99255 38.2535 14 14 13 8 0.02 2.07011e-05\n",
-      "3.513216011269e+00 2.76647 50.9713 0 50.9713 14 7 15 15 0.02 0.000150087\n",
-      "4.750574783854e+00 2.27442 50.9713 0 50.9713 14 8 15 15 0.02 4.24954e-05\n",
-      "7.278384712062e+00 1.29678 50.9713 2.09216 50.9713 13 8 13 13 0.02 2.9863e-05\n",
-      "4.765996194699e+00 2.20787 50.9713 2.20787 50.9713 14 8 14 8 0.02 2.07011e-05\n",
-      "4.765535914728e+00 2.21331 50.9713 2.21331 50.9713 14 8 14 8 0.02 2.41295e-05\n",
-      "3.104706358826e+00 3.17639 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.069363482023e+00 3.27572 150 0 0.1 14 7 15 15 0.02 9.32641e-06\n",
-      "3.047074050271e+00 3.3836 150 0 37.575 14 7 15 15 0.02 3.68933e-05\n",
-      "5.974759306305e+00 3.23604 150 2.53922 37.575 14 14 14 7 0.02 1.04459e-05\n",
-      "6.074084349384e+00 3.30145 150 2.13876 37.575 14 14 13 8 0.02 7.34071e-06\n",
-      "5.733865371895e+00 3.29994 150 2.00498 37.575 14 14 13 8 0.02 5.93135e-06\n",
-      "3.027099358410e+00 3.53631 150 0 75.05 14 7 15 15 0.02 3.68933e-05\n",
-      "5.807147339697e+00 3.30197 150 1.9791 37.575 14 14 13 8 0.02 5.08861e-06\n",
-      "4.862942347290e+00 3.25294 150 2.97823 75.05 14 14 14 7 0.02 1.04459e-05\n",
-      "4.556479830908e+00 3.29942 150 2.73221 75.05 14 14 14 7 0.02 7.34071e-06\n",
-      "3.853070305680e+00 3.29977 150 2.62486 75.05 14 14 14 7 0.02 5.93135e-06\n",
-      "3.881529045940e+00 3.30149 150 2.55924 75.05 14 14 14 7 0.02 5.08861e-06\n",
-      "3.015033359333e+00 3.64419 150 0 112.525 14 7 15 15 0.02 3.68933e-05\n",
-      "4.126828648362e+00 3.32047 150 0 112.525 14 14 15 3 0.02 1.04459e-05\n",
-      "3.990017992944e+00 3.3032 150 2.94027 112.525 14 14 14 7 0.02 7.34071e-06\n",
-      "3.206771867883e+00 3.07671 150 3.11282 112.525 14 14 14 7 0.02 5.93135e-06\n",
-      "3.006827156705e+00 3.72638 150 0 150 14 7 15 15 0.02 3.68933e-05\n",
-      "3.218786094847e+00 3.30337 150 3.01344 112.525 14 14 14 7 0.02 5.08861e-06\n",
-      "4.527722847382e+00 1.42238 150 0 150 13 5 15 15 0.02 1.04459e-05\n",
-      "3.069567332611e+00 3.27804 150 3.27804 150 14 7 14 7 0.02 5.93135e-06\n",
-      "5.726405299909e+00 1.29746 150 3.22759 150 13 8 14 14 0.02 7.34071e-06\n",
-      "3.069626478211e+00 3.27565 150 3.27565 150 14 7 14 7 0.02 5.08861e-06\n",
+      "1.219029061236e+01 1.60007 17.3205 0 2.97008 13 5 15 15 0.02 0.000498487\n",
+      "1.935920346899e+01 1.29448 17.3205 0 8.71025 13 13 15 2 0.02 0.000498487\n",
+      "2.123795595728e+01 1.30902 17.3205 1.58519 8.71025 13 13 13 5 0.02 0.000287968\n",
+      "3.579099761269e+01 1.52414 17.3205 1.30642 8.71025 13 13 13 5 0.02 0.000220016\n",
+      "1.674063083432e+01 1.29457 17.3205 0 14.4504 13 13 15 2 0.02 0.000498487\n",
+      "1.779197348711e+01 1.3228 17.3205 1.71196 14.4504 13 13 13 8 0.02 0.000287968\n",
+      "1.548740826516e+01 1.52415 17.3205 1.45407 14.4504 13 13 13 5 0.02 0.000220016\n",
+      "1.772169325356e+01 1.81957 73.0434 1.46573 12.2572 13 13 13 5 0.02 4.43422e-05\n",
+      "1.367065500196e+01 1.66003 73.0434 1.79487 12.2572 13 13 13 8 0.02 7.67586e-05\n",
+      "2.021960493499e+01 1.82061 73.0434 1.39205 12.2572 13 13 13 5 0.02 3.38788e-05\n",
+      "9.012246630357e+00 1.81529 73.0434 0 36.5717 13 8 15 15 0.02 7.67586e-05\n",
+      "7.462779538274e+00 1.82255 73.0434 1.81499 36.5717 13 13 13 8 0.02 3.38788e-05\n",
+      "1.030499912298e+01 1.80592 73.0434 1.81066 36.5717 13 13 13 8 0.02 4.43422e-05\n",
+      "4.227002356107e+00 2.43719 73.0434 0 60.8862 14 14 15 1 0.02 7.67586e-05\n",
+      "7.396288708628e+00 1.8216 73.0434 1.8216 60.8862 13 8 13 8 0.02 3.38788e-05\n",
+      "7.394728392218e+00 1.80919 73.0434 1.79091 60.8862 13 13 13 8 0.02 4.43422e-05\n",
       "\n"
      ]
     }
    ],
    "source": [
-    "import os\n",
-    "\n",
-    "from binarycpython.utils.grid import Population\n",
-    "from binarycpython.utils.custom_logging_functions import temp_dir\n",
-    "\n",
     "def parse_function(self, output):\n",
     "    \"\"\"\n",
     "    Example parsing function\n",
@@ -1067,10 +991,11 @@
     "    \n",
     "    # grid_options\n",
     "    amt_cores=2,  # grid_options\n",
+    "    tmp_dir=TMP_DIR,\n",
     "\n",
     "    # Custom options: the data directory and the output filename\n",
     "    data_dir=os.path.join(\n",
-    "        temp_dir(), \"example_python_population_result\"\n",
+    "        TMP_DIR, \"example_python_population_result\"\n",
     "    ),  # custom_options\n",
     "    base_filename=\"example_pop.dat\",  # custom_options\n",
     ")\n",
@@ -1168,14 +1093,14 @@
     "example_pop.export_all_info()\n",
     "\n",
     "# remove the result file if it exists\n",
-    "if os.path.isfile(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\")):\n",
-    "    os.remove(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"))\n",
+    "if os.path.isfile(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\")):\n",
+    "    os.remove(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"))\n",
     "\n",
     "# Evolve the population\n",
     "example_pop.evolve()\n",
     "\n",
     "# \n",
-    "with open(os.path.join(temp_dir(), \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
+    "with open(os.path.join(TMP_DIR, \"example_python_population_result\", \"example_pop.dat\"), 'r') as f:\n",
     "    output = f.read()\n",
     "print(\"\\n\")\n",
     "print(output)"
diff --git a/examples/notebook_BHBH.ipynb b/examples/notebook_BHBH.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..9dcc1fab8158516ccdbd938c187738a6961d9d6f
--- /dev/null
+++ b/examples/notebook_BHBH.ipynb
@@ -0,0 +1,4969 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
+   "metadata": {},
+   "source": [
+    "# Tutorial: Running individual systems with binary_c-python\n",
+    "This notebook will show you how to run single systems and analyze their results.\n",
+    "\n",
+    "It can be useful to have some functions to quickly run a single system to, for example, inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single system, etc. "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "dd5d9ec7-5791-45f1-afbd-225947e2a583",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Single system with run_system_wrapper\n",
+    "\n",
+    "The simplest method to run a single system is to use the run_system wrapper. This function deals with setting up the argument string, makes sure all the required parameters are included and handles setting and cleaning up the custom logging functionality (see notebook_custom_logging).\n",
+    "\n",
+    "As arguments to this function we can add any of the parameters that binary_c itself actually knows, as well as:\n",
+    "- custom_logging_code: string containing a Printf statement that binary_c can use to print information\n",
+    "- log_filename: path of the logfile that binary_c generates\n",
+    "- parse_function: function that handles parsing the output of binary-c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "e32dcdee",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.run_system_wrapper import run_system\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_BHBH\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b2abab48-433d-4936-8434-14804c52c9f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=62725 RANDOM_COUNT=0\n",
+      "     0.0000   60.000    0.000  1  15            -1       -1  -1.00   0.000   0.000  \"INITIAL \"\n",
+      "     6.1193   28.792    0.000  1  15            -1       -1  -1.00   0.000   0.000  \"Start Carbon Star 1\"\n",
+      "     6.6492   26.756    0.000  2  15            -1       -1  -1.00   0.000   0.000  \"OFF_MS\"\n",
+      "     6.6492   26.756    0.000  2  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.6588   26.687    0.000  4  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.2135    9.972    0.000  7  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.2135    9.972    0.000  7  15            -1       -1  -1.00   0.000   0.000  \"End Carbon Star 1\"\n",
+      "     7.3695    9.813    0.000  8  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3967    5.685    0.000 14  15            -1       -1  -1.00   0.000   0.000  Randbuf=39531 - Mers(0)=0.294514 - Mers(1)=0.134143 - Mers(2)=0.710121 - Mers(3)=0.310857 \n",
+      "     7.3967    5.685    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=9.78488 Mc\"CO\"=7.23513 type=8) -> kick 1(190) vk=76.5905 vr=0 omega=1.95317 phi=0.433711 -> vn=76.5905 ; final sep 0 ecc -1 (random count 0) - Runaway v=(-28.5778,64.4801,29.862) |v|=76.5905 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 4.09993, dm(companion) = 0\n",
+      "     7.3967    5.685    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3967    5.685    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000    5.685    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "log_filename = \"log_file\"\n",
+    "output = run_system(M_1=60, \n",
+    "                    BH_prescription='BH_BELCZYNSKI',\n",
+    "                    log_filename=log_filename, \n",
+    "                    api_log_filename_prefix=TMP_DIR)\n",
+    "with open(log_filename, 'r') as f:\n",
+    "    print(f.read())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "937ad254-9672-4675-820b-41744f90b60c",
+   "metadata": {},
+   "source": [
+    "Now we start a binary in a very wide orbit, so the stars do not interact (except by a little wind accretion). This makes a \"14 14\", i.e. BH+BH, pair."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "029fc3f2-f09a-49af-a32b-248505738f2e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=62158 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.009   0.009  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.009   0.009  \"BEG_SYMB\"\n",
+      "     4.3583   42.081   35.930  1   1          3971     8.98y  0.00   0.023   0.014  \"Start tidal lock 1\"\n",
+      "     4.3928   41.632   35.894  1   1        3995.8      9.1y  0.00   0.023   0.014  \"End tidal lock 1\"\n",
+      "     6.1199   28.792   28.776  1   1        5374.9     16.5y  0.00   0.014   0.014  \"Start Carbon Star 1\"\n",
+      "     6.4219   27.615   27.603  1   1        5603.4     17.9y  0.00   0.013   0.013  \"Start tidal lock 2\"\n",
+      "     6.5403   27.157   27.151  1   1        5696.9     18.5y  0.00   0.012   0.012  \"End tidal lock 2\"\n",
+      "     6.6475   26.763   26.731  2   1        5791.5     19.1y  0.00   0.010   0.011  \"TYPE_CHNGE\"\n",
+      "     6.6548   26.730   26.729  2   1        5794.3     19.1y  0.00   0.203   0.010  \"Start tidal lock 2\"\n",
+      "     6.6550   26.728   26.729  2   1        5794.5     19.1y  0.00   0.225   0.010  \"q-inv\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"OFF_MS\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"TYPE_CHNGE\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"End tidal lock 2\"\n",
+      "     6.6556   26.721   26.728  2   2          5796     19.1y  0.00   0.282   0.011  \"Start tidal lock 2\"\n",
+      "     6.6559   26.716   26.727  2   2        5796.6     19.1y  0.00   0.321   0.013  \"End tidal lock 2\"\n",
+      "     6.6571   26.691   26.724  4   2        5798.4     19.2y  0.00   0.546   0.021  \"TYPE_CHNGE\"\n",
+      "     6.6649   26.502   26.683  4   4          5812     19.3y  0.00   0.548   0.543  \"TYPE_CHNGE\"\n",
+      "     7.1021   15.167   15.598  4   4        7342.9       36y  0.00   0.588   0.574  \"Start Carbon Star 2\"\n",
+      "     7.2663   10.178   10.480  4   4        8828.2     57.9y  0.00   0.000   0.460  \"END_SYMB\"\n",
+      "     7.2670   10.171   10.458  7   4        8837.8       58y  0.00   0.000   0.455  \"TYPE_CHNGE\"\n",
+      "     7.2670   10.171   10.458  7   4        8837.8       58y  0.00   0.000   0.455  \"End Carbon Star 1\"\n",
+      "     7.2671   10.171   10.454  4   4        8840.9       58y  0.00   0.000   0.454  \"TYPE_CHNGE\"\n",
+      "     7.2671   10.171   10.454  4   4        8840.9       58y  0.00   0.000   0.454  \"Start Carbon Star 1\"\n",
+      "     7.2672   10.170   10.450  7   4        8840.6       58y  0.00   0.000   0.453  \"TYPE_CHNGE\"\n",
+      "     7.2672   10.170   10.450  7   4        8840.6       58y  0.00   0.000   0.453  \"End Carbon Star 1\"\n",
+      "     7.2673   10.170   10.446  4   4        8843.6     58.1y  0.00   0.000   0.452  \"TYPE_CHNGE\"\n",
+      "     7.2673   10.170   10.446  4   4        8843.6     58.1y  0.00   0.000   0.452  \"Start Carbon Star 1\"\n",
+      "     7.2674   10.169   10.442  7   4        8843.3     58.1y  0.00   0.000   0.451  \"TYPE_CHNGE\"\n",
+      "     7.2674   10.169   10.442  7   4        8843.3     58.1y  0.00   0.000   0.451  \"End Carbon Star 1\"\n",
+      "     7.2676   10.169   10.438  4   4        8846.3     58.1y  0.00   0.000   0.450  \"TYPE_CHNGE\"\n",
+      "     7.2676   10.169   10.438  4   4        8846.3     58.1y  0.00   0.000   0.450  \"Start Carbon Star 1\"\n",
+      "     7.2677   10.168   10.435  7   4          8846     58.1y  0.00   0.000   0.448  \"TYPE_CHNGE\"\n",
+      "     7.2677   10.168   10.435  7   4          8846     58.1y  0.00   0.000   0.448  \"End Carbon Star 1\"\n",
+      "     7.2678   10.168   10.431  4   4        8848.8     58.2y  0.00   0.000   0.447  \"TYPE_CHNGE\"\n",
+      "     7.2678   10.168   10.431  4   4        8848.8     58.2y  0.00   0.000   0.447  \"Start Carbon Star 1\"\n",
+      "     7.2679   10.167   10.427  7   4        8848.6     58.2y  0.00   0.000   0.446  \"TYPE_CHNGE\"\n",
+      "     7.2679   10.167   10.427  7   4        8848.6     58.2y  0.00   0.000   0.446  \"End Carbon Star 1\"\n",
+      "     7.2680   10.167   10.424  4   4        8851.3     58.2y  0.00   0.000   0.445  \"TYPE_CHNGE\"\n",
+      "     7.2680   10.167   10.424  4   4        8851.3     58.2y  0.00   0.000   0.445  \"Start Carbon Star 1\"\n",
+      "     7.2681   10.166   10.420  7   4          8851     58.2y  0.00   0.000   0.444  \"TYPE_CHNGE\"\n",
+      "     7.2681   10.166   10.420  7   4          8851     58.2y  0.00   0.000   0.444  \"End Carbon Star 1\"\n",
+      "     7.2682   10.166   10.417  4   4        8853.7     58.2y  0.00   0.000   0.442  \"TYPE_CHNGE\"\n",
+      "     7.2682   10.166   10.417  4   4        8853.7     58.2y  0.00   0.000   0.442  \"Start Carbon Star 1\"\n",
+      "     7.2683   10.165   10.413  7   4        8853.5     58.2y  0.00   0.000   0.441  \"TYPE_CHNGE\"\n",
+      "     7.2683   10.165   10.413  7   4        8853.5     58.2y  0.00   0.000   0.441  \"End Carbon Star 1\"\n",
+      "     7.2684   10.165   10.410  4   4        8856.1     58.3y  0.00   0.000   0.440  \"TYPE_CHNGE\"\n",
+      "     7.2684   10.165   10.410  4   4        8856.1     58.3y  0.00   0.000   0.440  \"Start Carbon Star 1\"\n",
+      "     7.2685   10.164   10.407  7   4        8855.8     58.3y  0.00   0.000   0.439  \"TYPE_CHNGE\"\n",
+      "     7.2685   10.164   10.407  7   4        8855.8     58.3y  0.00   0.000   0.439  \"End Carbon Star 1\"\n",
+      "     7.2686   10.164   10.404  4   4        8858.4     58.3y  0.00   0.000   0.437  \"TYPE_CHNGE\"\n",
+      "     7.2686   10.164   10.404  4   4        8858.4     58.3y  0.00   0.000   0.437  \"Start Carbon Star 1\"\n",
+      "     7.2687   10.163   10.400  7   4        8858.1     58.3y  0.00   0.000   0.436  \"TYPE_CHNGE\"\n",
+      "     7.2687   10.163   10.400  7   4        8858.1     58.3y  0.00   0.000   0.436  \"End Carbon Star 1\"\n",
+      "     7.2688   10.163   10.397  4   4        8860.6     58.3y  0.00   0.000   0.434  \"TYPE_CHNGE\"\n",
+      "     7.2688   10.163   10.397  4   4        8860.6     58.3y  0.00   0.000   0.434  \"Start Carbon Star 1\"\n",
+      "     7.2689   10.162   10.394  7   4        8860.4     58.3y  0.00   0.000   0.433  \"TYPE_CHNGE\"\n",
+      "     7.2689   10.162   10.394  7   4        8860.4     58.3y  0.00   0.000   0.433  \"End Carbon Star 1\"\n",
+      "     7.2690   10.162   10.391  4   4        8862.8     58.4y  0.00   0.000   0.432  \"TYPE_CHNGE\"\n",
+      "     7.2690   10.162   10.391  4   4        8862.8     58.4y  0.00   0.000   0.432  \"Start Carbon Star 1\"\n",
+      "     7.2691   10.161   10.388  7   4        8862.5     58.4y  0.00   0.000   0.430  \"TYPE_CHNGE\"\n",
+      "     7.2691   10.161   10.388  7   4        8862.5     58.4y  0.00   0.000   0.430  \"End Carbon Star 1\"\n",
+      "     7.2692   10.162   10.385  4   4        8864.9     58.4y  0.00   0.000   0.429  \"TYPE_CHNGE\"\n",
+      "     7.2692   10.162   10.385  4   4        8864.9     58.4y  0.00   0.000   0.429  \"Start Carbon Star 1\"\n",
+      "     7.2693   10.161   10.382  7   4        8864.7     58.4y  0.00   0.000   0.427  \"TYPE_CHNGE\"\n",
+      "     7.2693   10.161   10.382  7   4        8864.7     58.4y  0.00   0.000   0.427  \"End Carbon Star 1\"\n",
+      "     7.2694   10.161   10.379  4   4          8867     58.4y  0.00   0.000   0.425  \"TYPE_CHNGE\"\n",
+      "     7.2694   10.161   10.379  4   4          8867     58.4y  0.00   0.000   0.425  \"Start Carbon Star 1\"\n",
+      "     7.2695   10.160   10.376  7   4        8866.8     58.4y  0.00   0.000   0.424  \"TYPE_CHNGE\"\n",
+      "     7.2695   10.160   10.376  7   4        8866.8     58.4y  0.00   0.000   0.424  \"End Carbon Star 1\"\n",
+      "     7.2696   10.160   10.373  4   4        8869.1     58.4y  0.00   0.000   0.422  \"TYPE_CHNGE\"\n",
+      "     7.2696   10.160   10.373  4   4        8869.1     58.4y  0.00   0.000   0.422  \"Start Carbon Star 1\"\n",
+      "     7.2697   10.159   10.370  7   4        8868.9     58.4y  0.00   0.000   0.420  \"TYPE_CHNGE\"\n",
+      "     7.2697   10.159   10.370  7   4        8868.9     58.4y  0.00   0.000   0.420  \"End Carbon Star 1\"\n",
+      "     7.2698   10.159   10.368  4   4        8871.1     58.5y  0.00   0.000   0.419  \"TYPE_CHNGE\"\n",
+      "     7.2698   10.159   10.368  4   4        8871.1     58.5y  0.00   0.000   0.419  \"Start Carbon Star 1\"\n",
+      "     7.2699   10.158   10.365  7   4        8870.9     58.5y  0.00   0.000   0.417  \"TYPE_CHNGE\"\n",
+      "     7.2699   10.158   10.365  7   4        8870.9     58.5y  0.00   0.000   0.417  \"End Carbon Star 1\"\n",
+      "     7.2700   10.158   10.362  4   4        8873.1     58.5y  0.00   0.000   0.415  \"TYPE_CHNGE\"\n",
+      "     7.2700   10.158   10.362  4   4        8873.1     58.5y  0.00   0.000   0.415  \"Start Carbon Star 1\"\n",
+      "     7.2700   10.157   10.359  7   4        8872.9     58.5y  0.00   0.000   0.413  \"TYPE_CHNGE\"\n",
+      "     7.2700   10.157   10.359  7   4        8872.9     58.5y  0.00   0.000   0.413  \"End Carbon Star 1\"\n",
+      "     7.2701   10.157   10.357  4   4        8875.1     58.5y  0.00   0.000   0.411  \"TYPE_CHNGE\"\n",
+      "     7.2701   10.157   10.357  4   4        8875.1     58.5y  0.00   0.000   0.411  \"Start Carbon Star 1\"\n",
+      "     7.2702   10.156   10.354  7   4        8874.8     58.5y  0.00   0.000   0.409  \"TYPE_CHNGE\"\n",
+      "     7.2702   10.156   10.354  7   4        8874.8     58.5y  0.00   0.000   0.409  \"End Carbon Star 1\"\n",
+      "     7.2703   10.157   10.352  4   4          8877     58.6y  0.00   0.000   0.407  \"TYPE_CHNGE\"\n",
+      "     7.2703   10.157   10.352  4   4          8877     58.6y  0.00   0.000   0.407  \"Start Carbon Star 1\"\n",
+      "     7.2704   10.156   10.349  7   4        8876.7     58.6y  0.00   0.000   0.405  \"TYPE_CHNGE\"\n",
+      "     7.2704   10.156   10.349  7   4        8876.7     58.6y  0.00   0.000   0.405  \"End Carbon Star 1\"\n",
+      "     7.2705   10.156   10.346  4   4        8878.9     58.6y  0.00   0.000   0.403  \"TYPE_CHNGE\"\n",
+      "     7.2705   10.156   10.346  4   4        8878.9     58.6y  0.00   0.000   0.403  \"Start Carbon Star 1\"\n",
+      "     7.2706   10.155   10.344  7   4        8878.6     58.6y  0.00   0.000   0.400  \"TYPE_CHNGE\"\n",
+      "     7.2706   10.155   10.344  7   4        8878.6     58.6y  0.00   0.000   0.400  \"End Carbon Star 1\"\n",
+      "     7.2706   10.155   10.342  4   4        8880.7     58.6y  0.00   0.000   0.398  \"TYPE_CHNGE\"\n",
+      "     7.2706   10.155   10.342  4   4        8880.7     58.6y  0.00   0.000   0.398  \"Start Carbon Star 1\"\n",
+      "     7.2707   10.154   10.339  7   4        8880.5     58.6y  0.00   0.000   0.396  \"TYPE_CHNGE\"\n",
+      "     7.2707   10.154   10.339  7   4        8880.5     58.6y  0.00   0.000   0.396  \"End Carbon Star 1\"\n",
+      "     7.2708   10.154   10.337  4   4        8882.6     58.6y  0.00   0.000   0.393  \"TYPE_CHNGE\"\n",
+      "     7.2708   10.154   10.337  4   4        8882.6     58.6y  0.00   0.000   0.393  \"Start Carbon Star 1\"\n",
+      "     7.2709   10.153   10.334  7   4        8882.3     58.6y  0.00   0.000   0.391  \"TYPE_CHNGE\"\n",
+      "     7.2709   10.153   10.334  7   4        8882.3     58.6y  0.00   0.000   0.391  \"End Carbon Star 1\"\n",
+      "     7.2710   10.153   10.332  4   4        8884.4     58.7y  0.00   0.000   0.388  \"TYPE_CHNGE\"\n",
+      "     7.2710   10.153   10.332  4   4        8884.4     58.7y  0.00   0.000   0.388  \"Start Carbon Star 1\"\n",
+      "     7.2710   10.152   10.330  7   4        8884.2     58.7y  0.00   0.000   0.386  \"TYPE_CHNGE\"\n",
+      "     7.2710   10.152   10.330  7   4        8884.2     58.7y  0.00   0.000   0.386  \"End Carbon Star 1\"\n",
+      "     7.2711   10.152   10.327  4   4        8886.2     58.7y  0.00   0.000   0.383  \"TYPE_CHNGE\"\n",
+      "     7.2711   10.152   10.327  4   4        8886.2     58.7y  0.00   0.000   0.383  \"Start Carbon Star 1\"\n",
+      "     7.2712   10.152   10.325  7   4          8886     58.7y  0.00   0.000   0.380  \"TYPE_CHNGE\"\n",
+      "     7.2712   10.152   10.325  7   4          8886     58.7y  0.00   0.000   0.380  \"End Carbon Star 1\"\n",
+      "     7.2713   10.152   10.323  4   4        8887.9     58.7y  0.00   0.000   0.377  \"TYPE_CHNGE\"\n",
+      "     7.2713   10.152   10.323  4   4        8887.9     58.7y  0.00   0.000   0.377  \"Start Carbon Star 1\"\n",
+      "     7.2714   10.151   10.320  7   4        8887.7     58.7y  0.00   0.000   0.374  \"TYPE_CHNGE\"\n",
+      "     7.2714   10.151   10.320  7   4        8887.7     58.7y  0.00   0.000   0.374  \"End Carbon Star 1\"\n",
+      "     7.2714   10.151   10.318  4   4        8889.7     58.7y  0.00   0.000   0.371  \"TYPE_CHNGE\"\n",
+      "     7.2714   10.151   10.318  4   4        8889.7     58.7y  0.00   0.000   0.371  \"Start Carbon Star 1\"\n",
+      "     7.2715   10.150   10.316  7   4        8889.5     58.7y  0.00   0.000   0.368  \"TYPE_CHNGE\"\n",
+      "     7.2715   10.150   10.316  7   4        8889.5     58.7y  0.00   0.000   0.368  \"End Carbon Star 1\"\n",
+      "     7.2716   10.150   10.314  4   4        8891.4     58.8y  0.00   0.000   0.365  \"TYPE_CHNGE\"\n",
+      "     7.2716   10.150   10.314  4   4        8891.4     58.8y  0.00   0.000   0.365  \"Start Carbon Star 1\"\n",
+      "     7.2717   10.149   10.312  7   4        8891.2     58.8y  0.00   0.000   0.361  \"TYPE_CHNGE\"\n",
+      "     7.2717   10.149   10.312  7   4        8891.2     58.8y  0.00   0.000   0.361  \"End Carbon Star 1\"\n",
+      "     7.2718   10.149   10.310  4   4        8893.1     58.8y  0.00   0.000   0.358  \"TYPE_CHNGE\"\n",
+      "     7.2718   10.149   10.310  4   4        8893.1     58.8y  0.00   0.000   0.358  \"Start Carbon Star 1\"\n",
+      "     7.2718   10.148   10.308  7   4        8892.9     58.8y  0.00   0.000   0.355  \"TYPE_CHNGE\"\n",
+      "     7.2718   10.148   10.308  7   4        8892.9     58.8y  0.00   0.000   0.355  \"End Carbon Star 1\"\n",
+      "     7.2719   10.148   10.306  4   4        8894.8     58.8y  0.00   0.000   0.351  \"TYPE_CHNGE\"\n",
+      "     7.2719   10.148   10.306  4   4        8894.8     58.8y  0.00   0.000   0.351  \"Start Carbon Star 1\"\n",
+      "     7.2720   10.147   10.304  7   4        8894.6     58.8y  0.00   0.000   0.347  \"TYPE_CHNGE\"\n",
+      "     7.2720   10.147   10.304  7   4        8894.6     58.8y  0.00   0.000   0.347  \"End Carbon Star 1\"\n",
+      "     7.2721   10.147   10.302  4   4        8896.5     58.8y  0.00   0.000   0.343  \"TYPE_CHNGE\"\n",
+      "     7.2721   10.147   10.302  4   4        8896.5     58.8y  0.00   0.000   0.343  \"Start Carbon Star 1\"\n",
+      "     7.2721   10.147   10.300  7   4        8896.3     58.8y  0.00   0.000   0.340  \"TYPE_CHNGE\"\n",
+      "     7.2721   10.147   10.300  7   4        8896.3     58.8y  0.00   0.000   0.340  \"End Carbon Star 1\"\n",
+      "     7.2722   10.147   10.298  4   4        8898.2     58.9y  0.00   0.000   0.335  \"TYPE_CHNGE\"\n",
+      "     7.2722   10.147   10.298  4   4        8898.2     58.9y  0.00   0.000   0.335  \"Start Carbon Star 1\"\n",
+      "     7.2723   10.146   10.296  7   4        8897.9     58.9y  0.00   0.000   0.331  \"TYPE_CHNGE\"\n",
+      "     7.2723   10.146   10.296  7   4        8897.9     58.9y  0.00   0.000   0.331  \"End Carbon Star 1\"\n",
+      "     7.2724   10.146   10.294  4   4        8899.8     58.9y  0.00   0.000   0.327  \"TYPE_CHNGE\"\n",
+      "     7.2724   10.146   10.294  4   4        8899.8     58.9y  0.00   0.000   0.327  \"Start Carbon Star 1\"\n",
+      "     7.2724   10.145   10.292  7   4        8899.6     58.9y  0.00   0.000   0.323  \"TYPE_CHNGE\"\n",
+      "     7.2724   10.145   10.292  7   4        8899.6     58.9y  0.00   0.000   0.323  \"End Carbon Star 1\"\n",
+      "     7.2725   10.145   10.290  4   4        8901.5     58.9y  0.00   0.000   0.318  \"TYPE_CHNGE\"\n",
+      "     7.2725   10.145   10.290  4   4        8901.5     58.9y  0.00   0.000   0.318  \"Start Carbon Star 1\"\n",
+      "     7.2726   10.144   10.288  7   4        8901.2     58.9y  0.00   0.000   0.314  \"TYPE_CHNGE\"\n",
+      "     7.2726   10.144   10.288  7   4        8901.2     58.9y  0.00   0.000   0.314  \"End Carbon Star 1\"\n",
+      "     7.2727   10.144   10.286  4   4        8903.1     58.9y  0.00   0.000   0.309  \"TYPE_CHNGE\"\n",
+      "     7.2727   10.144   10.286  4   4        8903.1     58.9y  0.00   0.000   0.309  \"Start Carbon Star 1\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"TYPE_CHNGE\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"BEG_SYMB\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"End Carbon Star 1\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"TYPE_CHNGE\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"END_SYMB\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"Start Carbon Star 1\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"TYPE_CHNGE\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"BEG_SYMB\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"End Carbon Star 1\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"TYPE_CHNGE\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"END_SYMB\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"Start Carbon Star 1\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"TYPE_CHNGE\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"BEG_SYMB\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"End Carbon Star 1\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"TYPE_CHNGE\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"END_SYMB\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"Start Carbon Star 1\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"TYPE_CHNGE\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"BEG_SYMB\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"End Carbon Star 1\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"TYPE_CHNGE\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"END_SYMB\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"Start Carbon Star 1\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"TYPE_CHNGE\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"BEG_SYMB\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"End Carbon Star 1\"\n",
+      "     7.2734   10.139   10.268  7   4        8911.4       59y  0.00   0.000   0.253  \"END_SYMB\"\n",
+      "     7.2773   10.136   10.217  7   4          8934     59.4y  0.00   0.000   0.020  \"BEG_SYMB\"\n",
+      "     7.2800   10.134   10.167  7   7        8949.5     59.6y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.2800   10.134   10.167  7   7        8949.5     59.6y  0.00   0.000   0.000  \"End Carbon Star 2\"\n",
+      "     7.3729   10.039   10.072  8   7        9043.1     60.8y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3781   10.034   10.067  8   8        9047.9     60.9y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  Randbuf=72394 - Mers(0)=0.127356 - Mers(1)=0.2207 - Mers(2)=0.960665 - Mers(3)=0.652228 - Mers(4)=0.464746 \n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=10.0118 Mc\"CO\"=7.4101 type=8) -> kick 1(190) vk=117.249 vr=20.5462 omega=2.92008 phi=0.309368 -> vn=93.808 ; final sep -373.085 ecc -1 (random count 0) - Runaway v=(-101.19,26.6804,7.60009) |v|=104.924 : companion v=(-11.9473,-1.24848,0.141352), |v|=12.0132 ; - , dm(exploder) = 4.16087, dm(companion) = 0\n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  \"DISRUPT \"\n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  \"END_SYMB\"\n",
+      "     7.3995    5.851   10.045 14   8       -373.08     61.1y -1.00   0.000   0.000  \"SN\"\n",
+      "     7.4046    5.851    5.873 14  14       -373.08     61.1y -1.00   0.000   0.000  Mers(5)=0.527983 - Mers(6)=0.23349 - Mers(7)=0.247785 - Mers(8)=0.911948 \n",
+      "     7.4046    5.851    5.873 14  14       -373.08     61.1y -1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=10.0399 Mc\"CO\"=7.43173 type=8) -> kick 1(190) vk=102.19 vr=0 omega=5.72994 phi=-0.528723 -> vn=102.19 ; final sep -373.085 ecc -1 (random count 5) - Runaway v=(74.9985,-47.6126,27.2274) |v|=102.19 : companion v=(-6.31803e-51,-3.61645e-103,6.5939e-104), |v|=6.31803e-51 ; - , dm(exploder) = 4.16716, dm(companion) = 0\n",
+      "     7.4046    5.851    5.873 14  14       -373.08     61.1y -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.4046    5.851    5.873 14  14       -373.08     61.1y -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000    5.851    5.873 14  14       -373.08     61.1y -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "output = run_system(M_1=60, \n",
+    "                    M_2=40,\n",
+    "                    orbital_period=2000, # days\n",
+    "                    BH_prescription='BH_BELCZYNSKI',\n",
+    "                    log_filename=log_filename, \n",
+    "                    wind_mass_loss='WIND_ALGORITHM_BINARY_C_2020',\n",
+    "                    api_log_filename_prefix=TMP_DIR)\n",
+    "with open(log_filename, 'r') as f:\n",
+    "    print(f.read())"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a36dbc9a-73f9-40ab-a54d-2b5555c49f12",
+   "metadata": {},
+   "source": [
+    "So let's write a function to detect BHBH pairs."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "3ee47de3-bef9-4f87-ab69-702b27f7728d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "BHBH system is unbound\n"
+     ]
+    }
+   ],
+   "source": [
+    "\n",
+    "# BHBH detector : returns BHBH system data, or None if not found \n",
+    "def BHBH(filename):\n",
+    "    vb = False # set to True for debugging\n",
+    "    with open(filename, 'r') as f:\n",
+    "        for line in f.readlines():\n",
+    "            data = line.split()\n",
+    "            if vb == True:\n",
+    "                print ('data line ', line)\n",
+    "                print ('length ' + str(len(data)))\n",
+    "            if len(data) >= 10 and data[0] != 'TIME': \n",
+    "                stellar_type1 = int(data[3])\n",
+    "                stellar_type2 = int(data[4])\n",
+    "            \n",
+    "                # remember: stellar type 14 == BH\n",
+    "                if stellar_type1 == 14 and stellar_type2 == 14:\n",
+    "                    # BHBH system\n",
+    "                    if vb == True:\n",
+    "                        print ('FOUND BHBH system')\n",
+    "                        print (line)\n",
+    "                    names = ['time','M1','M2','K1','K2','separation']\n",
+    "                    d = {}\n",
+    "                    for name in names:\n",
+    "                        d[name] = float(data.pop(0))\n",
+    "                        if vb == True:\n",
+    "                            print(data)\n",
+    "                    f.close()\n",
+    "                    return d\n",
+    "\n",
+    "data = BHBH(log_filename)\n",
+    "if data == None or len(data) == 0:\n",
+    "    print(\"Oops: no data found\")\n",
+    "if data['separation'] < 0.0:\n",
+    "    print(\"BHBH system is unbound\")\n",
+    "else:\n",
+    "    print(\"BHBH system is bound\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "8018ef52-093d-45ac-a00b-5fb721db3adb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'M_1': 60, 'M_2': 40, 'orbital_period': 2000, 'BH_prescription': 'BH_FRYER12_RAPID', 'wind_mass_loss': 'WIND_ALGORITHM_BINARY_C_2020'}\n",
+      "system 1 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -512.41}\n",
+      "System 1 has separation -512.41\n",
+      "system 2 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -110.23}\n",
+      "System 2 has separation -110.23\n",
+      "system 3 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -161.63}\n",
+      "System 3 has separation -161.63\n",
+      "system 4 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -212.67}\n",
+      "System 4 has separation -212.67\n",
+      "system 5 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -177.15}\n",
+      "System 5 has separation -177.15\n",
+      "system 6 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -720.06}\n",
+      "System 6 has separation -720.06\n",
+      "system 7 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -108.18}\n",
+      "System 7 has separation -108.18\n",
+      "system 8 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -73.642}\n",
+      "System 8 has separation -73.642\n",
+      "system 9 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -237.24}\n",
+      "System 9 has separation -237.24\n",
+      "system 10 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -166.42}\n",
+      "System 10 has separation -166.42\n",
+      "system 11 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -94.362}\n",
+      "System 11 has separation -94.362\n",
+      "system 12 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -1232.7}\n",
+      "System 12 has separation -1232.7\n",
+      "system 13 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -151.47}\n",
+      "System 13 has separation -151.47\n",
+      "system 14 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -216.78}\n",
+      "System 14 has separation -216.78\n",
+      "system 15 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -415.58}\n",
+      "System 15 has separation -415.58\n",
+      "system 16 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -263.93}\n",
+      "System 16 has separation -263.93\n",
+      "system 17 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -1313.3}\n",
+      "System 17 has separation -1313.3\n",
+      "system 18 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -112.14}\n",
+      "System 18 has separation -112.14\n",
+      "system 19 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -355.42}\n",
+      "System 19 has separation -355.42\n",
+      "system 20 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -132.94}\n",
+      "System 20 has separation -132.94\n",
+      "system 21 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -129.14}\n",
+      "System 21 has separation -129.14\n",
+      "system 22 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -317.18}\n",
+      "System 22 has separation -317.18\n",
+      "system 23 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -260.71}\n",
+      "System 23 has separation -260.71\n",
+      "system 24 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -330.87}\n",
+      "System 24 has separation -330.87\n",
+      "system 25 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -372.38}\n",
+      "System 25 has separation -372.38\n",
+      "system 26 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -195.85}\n",
+      "System 26 has separation -195.85\n",
+      "system 27 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -85.999}\n",
+      "System 27 has separation -85.999\n",
+      "system 28 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -22126.0}\n",
+      "System 28 has separation -22126.0\n",
+      "system 29 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -458.04}\n",
+      "System 29 has separation -458.04\n",
+      "system 30 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -147.38}\n",
+      "System 30 has separation -147.38\n",
+      "system 31 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -719.77}\n",
+      "System 31 has separation -719.77\n",
+      "system 32 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -263.0}\n",
+      "System 32 has separation -263.0\n",
+      "system 33 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -333.01}\n",
+      "System 33 has separation -333.01\n",
+      "system 34 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -138.19}\n",
+      "System 34 has separation -138.19\n",
+      "system 35 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -132.9}\n",
+      "System 35 has separation -132.9\n",
+      "system 36 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -382.2}\n",
+      "System 36 has separation -382.2\n",
+      "system 37 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -5740.8}\n",
+      "System 37 has separation -5740.8\n",
+      "system 38 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -102.8}\n",
+      "System 38 has separation -102.8\n",
+      "system 39 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -153.45}\n",
+      "System 39 has separation -153.45\n",
+      "system 40 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -176.8}\n",
+      "System 40 has separation -176.8\n",
+      "system 41 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -171.17}\n",
+      "System 41 has separation -171.17\n",
+      "system 42 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -212.25}\n",
+      "System 42 has separation -212.25\n",
+      "system 43 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -117.33}\n",
+      "System 43 has separation -117.33\n",
+      "system 44 / 100\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': -64.853}\n",
+      "System 44 has separation -64.853\n",
+      "system 45 / 100\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_26668/3037695552.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     34\u001b[0m             \u001b[0mwind_mass_loss\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'WIND_ALGORITHM_BINARY_C_2020'\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     35\u001b[0m            )\n\u001b[0;32m---> 36\u001b[0;31m \u001b[0msearch_for_BHBH\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
+      "\u001b[0;32m/tmp/ipykernel_26668/3037695552.py\u001b[0m in \u001b[0;36msearch_for_BHBH\u001b[0;34m(maxcount, **opts)\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0mcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcount\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"system {} / {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxcount\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         output = run_system(**opts,\n\u001b[0m\u001b[1;32m      9\u001b[0m                             \u001b[0mlog_filename\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlog_filename\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m                             \u001b[0mapi_log_filename_prefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTMP_DIR\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.9/site-packages/binarycpython/utils/run_system_wrapper.py\u001b[0m in \u001b[0;36mrun_system\u001b[0;34m(**kwargs)\u001b[0m\n\u001b[1;32m    102\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[0;31m# Call binary_c\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m     output = _binary_c_bindings.run_system(\n\u001b[0m\u001b[1;32m    105\u001b[0m         \u001b[0mbinary_c_command\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m         \u001b[0mcustom_logging_func_memaddr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc_memaddr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "def search_for_BHBH(maxcount,**opts):\n",
+    "    print(opts)\n",
+    "    found = False\n",
+    "    count = 0\n",
+    "    while found == False and count < maxcount:\n",
+    "        count = count + 1\n",
+    "        print(\"system {} / {}\".format(count,maxcount))\n",
+    "        output = run_system(**opts,\n",
+    "                            log_filename=log_filename, \n",
+    "                            api_log_filename_prefix=TMP_DIR,\n",
+    "                            )\n",
+    "        data = BHBH(log_filename)\n",
+    "        print (data)\n",
+    "        \n",
+    "        if data == None or len(data) == 0:\n",
+    "            # no BHBH found  \n",
+    "            found = False\n",
+    "        else:\n",
+    "            print(\"System {count} has separation {sep}\".format(count=count,sep=data['separation']))\n",
+    "            if data['separation'] > 0.0:\n",
+    "                # found bound BHBH system\n",
+    "                print('Found bound BHBH system')\n",
+    "                found = True\n",
+    "        \n",
+    "                # show the log file\n",
+    "                with open(log_filename, 'r') as f:\n",
+    "                    print(f.read())\n",
+    "\n",
+    "args = dict(\n",
+    "            M_1=60, \n",
+    "            M_2=40,\n",
+    "            orbital_period=2000, # days\n",
+    "            BH_prescription='BH_FRYER12_RAPID',\n",
+    "            wind_mass_loss='WIND_ALGORITHM_BINARY_C_2020',\n",
+    "           )\n",
+    "search_for_BHBH(100,**args)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4c885143-db79-4fed-b4c4-0bd846e24f7d",
+   "metadata": {},
+   "source": [
+    "How can we help the system become a BHBH merger? We can try turning off SN kicks."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "3085ba82-430e-48f0-bca3-b19231e6109d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'M_1': 60, 'M_2': 40, 'orbital_period': 2000, 'BH_prescription': 'BH_FRYER12_RAPID', 'wind_mass_loss': 'WIND_ALGORITHM_BINARY_C_2020', 'sn_kick_dispersion_II': 0, 'sn_kick_dispersion_IBC': 0, 'sn_kick_dispersion_GRB_COLLAPSAR': 0}\n",
+      "system 1 / 1\n",
+      "{'time': 7.4046, 'M1': 5.851, 'M2': 5.873, 'K1': 14.0, 'K2': 14.0, 'separation': 15566.0}\n",
+      "System 1 has separation 15566.0\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=21216 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.009   0.009  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.009   0.009  \"BEG_SYMB\"\n",
+      "     4.3583   42.081   35.930  1   1          3971     8.98y  0.00   0.023   0.014  \"Start tidal lock 1\"\n",
+      "     4.3928   41.632   35.894  1   1        3995.8      9.1y  0.00   0.023   0.014  \"End tidal lock 1\"\n",
+      "     6.1199   28.792   28.776  1   1        5374.9     16.5y  0.00   0.014   0.014  \"Start Carbon Star 1\"\n",
+      "     6.4219   27.615   27.603  1   1        5603.4     17.9y  0.00   0.013   0.013  \"Start tidal lock 2\"\n",
+      "     6.5403   27.157   27.151  1   1        5696.9     18.5y  0.00   0.012   0.012  \"End tidal lock 2\"\n",
+      "     6.6475   26.763   26.731  2   1        5791.5     19.1y  0.00   0.010   0.011  \"TYPE_CHNGE\"\n",
+      "     6.6548   26.730   26.729  2   1        5794.3     19.1y  0.00   0.203   0.010  \"Start tidal lock 2\"\n",
+      "     6.6550   26.728   26.729  2   1        5794.5     19.1y  0.00   0.225   0.010  \"q-inv\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"OFF_MS\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"TYPE_CHNGE\"\n",
+      "     6.6552   26.725   26.729  2   2        5795.5     19.1y  0.00   0.246   0.010  \"End tidal lock 2\"\n",
+      "     6.6556   26.721   26.728  2   2          5796     19.1y  0.00   0.282   0.011  \"Start tidal lock 2\"\n",
+      "     6.6559   26.716   26.727  2   2        5796.6     19.1y  0.00   0.321   0.013  \"End tidal lock 2\"\n",
+      "     6.6571   26.691   26.724  4   2        5798.4     19.2y  0.00   0.546   0.021  \"TYPE_CHNGE\"\n",
+      "     6.6649   26.502   26.683  4   4          5812     19.3y  0.00   0.548   0.543  \"TYPE_CHNGE\"\n",
+      "     7.1021   15.167   15.598  4   4        7342.9       36y  0.00   0.588   0.574  \"Start Carbon Star 2\"\n",
+      "     7.2663   10.178   10.480  4   4        8828.2     57.9y  0.00   0.000   0.460  \"END_SYMB\"\n",
+      "     7.2670   10.171   10.458  7   4        8837.8       58y  0.00   0.000   0.455  \"TYPE_CHNGE\"\n",
+      "     7.2670   10.171   10.458  7   4        8837.8       58y  0.00   0.000   0.455  \"End Carbon Star 1\"\n",
+      "     7.2671   10.171   10.454  4   4        8840.9       58y  0.00   0.000   0.454  \"TYPE_CHNGE\"\n",
+      "     7.2671   10.171   10.454  4   4        8840.9       58y  0.00   0.000   0.454  \"Start Carbon Star 1\"\n",
+      "     7.2672   10.170   10.450  7   4        8840.6       58y  0.00   0.000   0.453  \"TYPE_CHNGE\"\n",
+      "     7.2672   10.170   10.450  7   4        8840.6       58y  0.00   0.000   0.453  \"End Carbon Star 1\"\n",
+      "     7.2673   10.170   10.446  4   4        8843.6     58.1y  0.00   0.000   0.452  \"TYPE_CHNGE\"\n",
+      "     7.2673   10.170   10.446  4   4        8843.6     58.1y  0.00   0.000   0.452  \"Start Carbon Star 1\"\n",
+      "     7.2674   10.169   10.442  7   4        8843.3     58.1y  0.00   0.000   0.451  \"TYPE_CHNGE\"\n",
+      "     7.2674   10.169   10.442  7   4        8843.3     58.1y  0.00   0.000   0.451  \"End Carbon Star 1\"\n",
+      "     7.2676   10.169   10.438  4   4        8846.3     58.1y  0.00   0.000   0.450  \"TYPE_CHNGE\"\n",
+      "     7.2676   10.169   10.438  4   4        8846.3     58.1y  0.00   0.000   0.450  \"Start Carbon Star 1\"\n",
+      "     7.2677   10.168   10.435  7   4          8846     58.1y  0.00   0.000   0.448  \"TYPE_CHNGE\"\n",
+      "     7.2677   10.168   10.435  7   4          8846     58.1y  0.00   0.000   0.448  \"End Carbon Star 1\"\n",
+      "     7.2678   10.168   10.431  4   4        8848.8     58.2y  0.00   0.000   0.447  \"TYPE_CHNGE\"\n",
+      "     7.2678   10.168   10.431  4   4        8848.8     58.2y  0.00   0.000   0.447  \"Start Carbon Star 1\"\n",
+      "     7.2679   10.167   10.427  7   4        8848.6     58.2y  0.00   0.000   0.446  \"TYPE_CHNGE\"\n",
+      "     7.2679   10.167   10.427  7   4        8848.6     58.2y  0.00   0.000   0.446  \"End Carbon Star 1\"\n",
+      "     7.2680   10.167   10.424  4   4        8851.3     58.2y  0.00   0.000   0.445  \"TYPE_CHNGE\"\n",
+      "     7.2680   10.167   10.424  4   4        8851.3     58.2y  0.00   0.000   0.445  \"Start Carbon Star 1\"\n",
+      "     7.2681   10.166   10.420  7   4          8851     58.2y  0.00   0.000   0.444  \"TYPE_CHNGE\"\n",
+      "     7.2681   10.166   10.420  7   4          8851     58.2y  0.00   0.000   0.444  \"End Carbon Star 1\"\n",
+      "     7.2682   10.166   10.417  4   4        8853.7     58.2y  0.00   0.000   0.442  \"TYPE_CHNGE\"\n",
+      "     7.2682   10.166   10.417  4   4        8853.7     58.2y  0.00   0.000   0.442  \"Start Carbon Star 1\"\n",
+      "     7.2683   10.165   10.413  7   4        8853.5     58.2y  0.00   0.000   0.441  \"TYPE_CHNGE\"\n",
+      "     7.2683   10.165   10.413  7   4        8853.5     58.2y  0.00   0.000   0.441  \"End Carbon Star 1\"\n",
+      "     7.2684   10.165   10.410  4   4        8856.1     58.3y  0.00   0.000   0.440  \"TYPE_CHNGE\"\n",
+      "     7.2684   10.165   10.410  4   4        8856.1     58.3y  0.00   0.000   0.440  \"Start Carbon Star 1\"\n",
+      "     7.2685   10.164   10.407  7   4        8855.8     58.3y  0.00   0.000   0.439  \"TYPE_CHNGE\"\n",
+      "     7.2685   10.164   10.407  7   4        8855.8     58.3y  0.00   0.000   0.439  \"End Carbon Star 1\"\n",
+      "     7.2686   10.164   10.404  4   4        8858.4     58.3y  0.00   0.000   0.437  \"TYPE_CHNGE\"\n",
+      "     7.2686   10.164   10.404  4   4        8858.4     58.3y  0.00   0.000   0.437  \"Start Carbon Star 1\"\n",
+      "     7.2687   10.163   10.400  7   4        8858.1     58.3y  0.00   0.000   0.436  \"TYPE_CHNGE\"\n",
+      "     7.2687   10.163   10.400  7   4        8858.1     58.3y  0.00   0.000   0.436  \"End Carbon Star 1\"\n",
+      "     7.2688   10.163   10.397  4   4        8860.6     58.3y  0.00   0.000   0.434  \"TYPE_CHNGE\"\n",
+      "     7.2688   10.163   10.397  4   4        8860.6     58.3y  0.00   0.000   0.434  \"Start Carbon Star 1\"\n",
+      "     7.2689   10.162   10.394  7   4        8860.4     58.3y  0.00   0.000   0.433  \"TYPE_CHNGE\"\n",
+      "     7.2689   10.162   10.394  7   4        8860.4     58.3y  0.00   0.000   0.433  \"End Carbon Star 1\"\n",
+      "     7.2690   10.162   10.391  4   4        8862.8     58.4y  0.00   0.000   0.432  \"TYPE_CHNGE\"\n",
+      "     7.2690   10.162   10.391  4   4        8862.8     58.4y  0.00   0.000   0.432  \"Start Carbon Star 1\"\n",
+      "     7.2691   10.161   10.388  7   4        8862.5     58.4y  0.00   0.000   0.430  \"TYPE_CHNGE\"\n",
+      "     7.2691   10.161   10.388  7   4        8862.5     58.4y  0.00   0.000   0.430  \"End Carbon Star 1\"\n",
+      "     7.2692   10.162   10.385  4   4        8864.9     58.4y  0.00   0.000   0.429  \"TYPE_CHNGE\"\n",
+      "     7.2692   10.162   10.385  4   4        8864.9     58.4y  0.00   0.000   0.429  \"Start Carbon Star 1\"\n",
+      "     7.2693   10.161   10.382  7   4        8864.7     58.4y  0.00   0.000   0.427  \"TYPE_CHNGE\"\n",
+      "     7.2693   10.161   10.382  7   4        8864.7     58.4y  0.00   0.000   0.427  \"End Carbon Star 1\"\n",
+      "     7.2694   10.161   10.379  4   4          8867     58.4y  0.00   0.000   0.425  \"TYPE_CHNGE\"\n",
+      "     7.2694   10.161   10.379  4   4          8867     58.4y  0.00   0.000   0.425  \"Start Carbon Star 1\"\n",
+      "     7.2695   10.160   10.376  7   4        8866.8     58.4y  0.00   0.000   0.424  \"TYPE_CHNGE\"\n",
+      "     7.2695   10.160   10.376  7   4        8866.8     58.4y  0.00   0.000   0.424  \"End Carbon Star 1\"\n",
+      "     7.2696   10.160   10.373  4   4        8869.1     58.4y  0.00   0.000   0.422  \"TYPE_CHNGE\"\n",
+      "     7.2696   10.160   10.373  4   4        8869.1     58.4y  0.00   0.000   0.422  \"Start Carbon Star 1\"\n",
+      "     7.2697   10.159   10.370  7   4        8868.9     58.4y  0.00   0.000   0.420  \"TYPE_CHNGE\"\n",
+      "     7.2697   10.159   10.370  7   4        8868.9     58.4y  0.00   0.000   0.420  \"End Carbon Star 1\"\n",
+      "     7.2698   10.159   10.368  4   4        8871.1     58.5y  0.00   0.000   0.419  \"TYPE_CHNGE\"\n",
+      "     7.2698   10.159   10.368  4   4        8871.1     58.5y  0.00   0.000   0.419  \"Start Carbon Star 1\"\n",
+      "     7.2699   10.158   10.365  7   4        8870.9     58.5y  0.00   0.000   0.417  \"TYPE_CHNGE\"\n",
+      "     7.2699   10.158   10.365  7   4        8870.9     58.5y  0.00   0.000   0.417  \"End Carbon Star 1\"\n",
+      "     7.2700   10.158   10.362  4   4        8873.1     58.5y  0.00   0.000   0.415  \"TYPE_CHNGE\"\n",
+      "     7.2700   10.158   10.362  4   4        8873.1     58.5y  0.00   0.000   0.415  \"Start Carbon Star 1\"\n",
+      "     7.2700   10.157   10.359  7   4        8872.9     58.5y  0.00   0.000   0.413  \"TYPE_CHNGE\"\n",
+      "     7.2700   10.157   10.359  7   4        8872.9     58.5y  0.00   0.000   0.413  \"End Carbon Star 1\"\n",
+      "     7.2701   10.157   10.357  4   4        8875.1     58.5y  0.00   0.000   0.411  \"TYPE_CHNGE\"\n",
+      "     7.2701   10.157   10.357  4   4        8875.1     58.5y  0.00   0.000   0.411  \"Start Carbon Star 1\"\n",
+      "     7.2702   10.156   10.354  7   4        8874.8     58.5y  0.00   0.000   0.409  \"TYPE_CHNGE\"\n",
+      "     7.2702   10.156   10.354  7   4        8874.8     58.5y  0.00   0.000   0.409  \"End Carbon Star 1\"\n",
+      "     7.2703   10.157   10.352  4   4          8877     58.6y  0.00   0.000   0.407  \"TYPE_CHNGE\"\n",
+      "     7.2703   10.157   10.352  4   4          8877     58.6y  0.00   0.000   0.407  \"Start Carbon Star 1\"\n",
+      "     7.2704   10.156   10.349  7   4        8876.7     58.6y  0.00   0.000   0.405  \"TYPE_CHNGE\"\n",
+      "     7.2704   10.156   10.349  7   4        8876.7     58.6y  0.00   0.000   0.405  \"End Carbon Star 1\"\n",
+      "     7.2705   10.156   10.346  4   4        8878.9     58.6y  0.00   0.000   0.403  \"TYPE_CHNGE\"\n",
+      "     7.2705   10.156   10.346  4   4        8878.9     58.6y  0.00   0.000   0.403  \"Start Carbon Star 1\"\n",
+      "     7.2706   10.155   10.344  7   4        8878.6     58.6y  0.00   0.000   0.400  \"TYPE_CHNGE\"\n",
+      "     7.2706   10.155   10.344  7   4        8878.6     58.6y  0.00   0.000   0.400  \"End Carbon Star 1\"\n",
+      "     7.2706   10.155   10.342  4   4        8880.7     58.6y  0.00   0.000   0.398  \"TYPE_CHNGE\"\n",
+      "     7.2706   10.155   10.342  4   4        8880.7     58.6y  0.00   0.000   0.398  \"Start Carbon Star 1\"\n",
+      "     7.2707   10.154   10.339  7   4        8880.5     58.6y  0.00   0.000   0.396  \"TYPE_CHNGE\"\n",
+      "     7.2707   10.154   10.339  7   4        8880.5     58.6y  0.00   0.000   0.396  \"End Carbon Star 1\"\n",
+      "     7.2708   10.154   10.337  4   4        8882.6     58.6y  0.00   0.000   0.393  \"TYPE_CHNGE\"\n",
+      "     7.2708   10.154   10.337  4   4        8882.6     58.6y  0.00   0.000   0.393  \"Start Carbon Star 1\"\n",
+      "     7.2709   10.153   10.334  7   4        8882.3     58.6y  0.00   0.000   0.391  \"TYPE_CHNGE\"\n",
+      "     7.2709   10.153   10.334  7   4        8882.3     58.6y  0.00   0.000   0.391  \"End Carbon Star 1\"\n",
+      "     7.2710   10.153   10.332  4   4        8884.4     58.7y  0.00   0.000   0.388  \"TYPE_CHNGE\"\n",
+      "     7.2710   10.153   10.332  4   4        8884.4     58.7y  0.00   0.000   0.388  \"Start Carbon Star 1\"\n",
+      "     7.2710   10.152   10.330  7   4        8884.2     58.7y  0.00   0.000   0.386  \"TYPE_CHNGE\"\n",
+      "     7.2710   10.152   10.330  7   4        8884.2     58.7y  0.00   0.000   0.386  \"End Carbon Star 1\"\n",
+      "     7.2711   10.152   10.327  4   4        8886.2     58.7y  0.00   0.000   0.383  \"TYPE_CHNGE\"\n",
+      "     7.2711   10.152   10.327  4   4        8886.2     58.7y  0.00   0.000   0.383  \"Start Carbon Star 1\"\n",
+      "     7.2712   10.152   10.325  7   4          8886     58.7y  0.00   0.000   0.380  \"TYPE_CHNGE\"\n",
+      "     7.2712   10.152   10.325  7   4          8886     58.7y  0.00   0.000   0.380  \"End Carbon Star 1\"\n",
+      "     7.2713   10.152   10.323  4   4        8887.9     58.7y  0.00   0.000   0.377  \"TYPE_CHNGE\"\n",
+      "     7.2713   10.152   10.323  4   4        8887.9     58.7y  0.00   0.000   0.377  \"Start Carbon Star 1\"\n",
+      "     7.2714   10.151   10.320  7   4        8887.7     58.7y  0.00   0.000   0.374  \"TYPE_CHNGE\"\n",
+      "     7.2714   10.151   10.320  7   4        8887.7     58.7y  0.00   0.000   0.374  \"End Carbon Star 1\"\n",
+      "     7.2714   10.151   10.318  4   4        8889.7     58.7y  0.00   0.000   0.371  \"TYPE_CHNGE\"\n",
+      "     7.2714   10.151   10.318  4   4        8889.7     58.7y  0.00   0.000   0.371  \"Start Carbon Star 1\"\n",
+      "     7.2715   10.150   10.316  7   4        8889.5     58.7y  0.00   0.000   0.368  \"TYPE_CHNGE\"\n",
+      "     7.2715   10.150   10.316  7   4        8889.5     58.7y  0.00   0.000   0.368  \"End Carbon Star 1\"\n",
+      "     7.2716   10.150   10.314  4   4        8891.4     58.8y  0.00   0.000   0.365  \"TYPE_CHNGE\"\n",
+      "     7.2716   10.150   10.314  4   4        8891.4     58.8y  0.00   0.000   0.365  \"Start Carbon Star 1\"\n",
+      "     7.2717   10.149   10.312  7   4        8891.2     58.8y  0.00   0.000   0.361  \"TYPE_CHNGE\"\n",
+      "     7.2717   10.149   10.312  7   4        8891.2     58.8y  0.00   0.000   0.361  \"End Carbon Star 1\"\n",
+      "     7.2718   10.149   10.310  4   4        8893.1     58.8y  0.00   0.000   0.358  \"TYPE_CHNGE\"\n",
+      "     7.2718   10.149   10.310  4   4        8893.1     58.8y  0.00   0.000   0.358  \"Start Carbon Star 1\"\n",
+      "     7.2718   10.148   10.308  7   4        8892.9     58.8y  0.00   0.000   0.355  \"TYPE_CHNGE\"\n",
+      "     7.2718   10.148   10.308  7   4        8892.9     58.8y  0.00   0.000   0.355  \"End Carbon Star 1\"\n",
+      "     7.2719   10.148   10.306  4   4        8894.8     58.8y  0.00   0.000   0.351  \"TYPE_CHNGE\"\n",
+      "     7.2719   10.148   10.306  4   4        8894.8     58.8y  0.00   0.000   0.351  \"Start Carbon Star 1\"\n",
+      "     7.2720   10.147   10.304  7   4        8894.6     58.8y  0.00   0.000   0.347  \"TYPE_CHNGE\"\n",
+      "     7.2720   10.147   10.304  7   4        8894.6     58.8y  0.00   0.000   0.347  \"End Carbon Star 1\"\n",
+      "     7.2721   10.147   10.302  4   4        8896.5     58.8y  0.00   0.000   0.343  \"TYPE_CHNGE\"\n",
+      "     7.2721   10.147   10.302  4   4        8896.5     58.8y  0.00   0.000   0.343  \"Start Carbon Star 1\"\n",
+      "     7.2721   10.147   10.300  7   4        8896.3     58.8y  0.00   0.000   0.340  \"TYPE_CHNGE\"\n",
+      "     7.2721   10.147   10.300  7   4        8896.3     58.8y  0.00   0.000   0.340  \"End Carbon Star 1\"\n",
+      "     7.2722   10.147   10.298  4   4        8898.2     58.9y  0.00   0.000   0.335  \"TYPE_CHNGE\"\n",
+      "     7.2722   10.147   10.298  4   4        8898.2     58.9y  0.00   0.000   0.335  \"Start Carbon Star 1\"\n",
+      "     7.2723   10.146   10.296  7   4        8897.9     58.9y  0.00   0.000   0.331  \"TYPE_CHNGE\"\n",
+      "     7.2723   10.146   10.296  7   4        8897.9     58.9y  0.00   0.000   0.331  \"End Carbon Star 1\"\n",
+      "     7.2724   10.146   10.294  4   4        8899.8     58.9y  0.00   0.000   0.327  \"TYPE_CHNGE\"\n",
+      "     7.2724   10.146   10.294  4   4        8899.8     58.9y  0.00   0.000   0.327  \"Start Carbon Star 1\"\n",
+      "     7.2724   10.145   10.292  7   4        8899.6     58.9y  0.00   0.000   0.323  \"TYPE_CHNGE\"\n",
+      "     7.2724   10.145   10.292  7   4        8899.6     58.9y  0.00   0.000   0.323  \"End Carbon Star 1\"\n",
+      "     7.2725   10.145   10.290  4   4        8901.5     58.9y  0.00   0.000   0.318  \"TYPE_CHNGE\"\n",
+      "     7.2725   10.145   10.290  4   4        8901.5     58.9y  0.00   0.000   0.318  \"Start Carbon Star 1\"\n",
+      "     7.2726   10.144   10.288  7   4        8901.2     58.9y  0.00   0.000   0.314  \"TYPE_CHNGE\"\n",
+      "     7.2726   10.144   10.288  7   4        8901.2     58.9y  0.00   0.000   0.314  \"End Carbon Star 1\"\n",
+      "     7.2727   10.144   10.286  4   4        8903.1     58.9y  0.00   0.000   0.309  \"TYPE_CHNGE\"\n",
+      "     7.2727   10.144   10.286  4   4        8903.1     58.9y  0.00   0.000   0.309  \"Start Carbon Star 1\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"TYPE_CHNGE\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"BEG_SYMB\"\n",
+      "     7.2727   10.143   10.284  7   4        8902.9     58.9y  0.00   0.000   0.304  \"End Carbon Star 1\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"TYPE_CHNGE\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"END_SYMB\"\n",
+      "     7.2728   10.143   10.282  4   4        8904.8       59y  0.00   0.000   0.299  \"Start Carbon Star 1\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"TYPE_CHNGE\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"BEG_SYMB\"\n",
+      "     7.2729   10.142   10.281  7   4        8904.5       59y  0.00   0.000   0.294  \"End Carbon Star 1\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"TYPE_CHNGE\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"END_SYMB\"\n",
+      "     7.2730   10.142   10.279  4   4        8906.4       59y  0.00   0.000   0.288  \"Start Carbon Star 1\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"TYPE_CHNGE\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"BEG_SYMB\"\n",
+      "     7.2730   10.141   10.277  7   4        8906.2       59y  0.00   0.000   0.283  \"End Carbon Star 1\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"TYPE_CHNGE\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"END_SYMB\"\n",
+      "     7.2731   10.141   10.275  4   4        8908.1       59y  0.00   0.000   0.277  \"Start Carbon Star 1\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"TYPE_CHNGE\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"BEG_SYMB\"\n",
+      "     7.2732   10.140   10.274  7   4        8907.8       59y  0.00   0.000   0.272  \"End Carbon Star 1\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"TYPE_CHNGE\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"END_SYMB\"\n",
+      "     7.2733   10.140   10.272  4   4        8909.7       59y  0.00   0.000   0.266  \"Start Carbon Star 1\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"TYPE_CHNGE\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"BEG_SYMB\"\n",
+      "     7.2734   10.139   10.270  7   4        8909.4       59y  0.00   0.000   0.260  \"End Carbon Star 1\"\n",
+      "     7.2734   10.139   10.268  7   4        8911.4       59y  0.00   0.000   0.253  \"END_SYMB\"\n",
+      "     7.2773   10.136   10.217  7   4          8934     59.4y  0.00   0.000   0.020  \"BEG_SYMB\"\n",
+      "     7.2800   10.134   10.167  7   7        8949.5     59.6y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.2800   10.134   10.167  7   7        8949.5     59.6y  0.00   0.000   0.000  \"End Carbon Star 2\"\n",
+      "     7.3729   10.039   10.072  8   7        9043.1     60.8y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3781   10.034   10.067  8   8        9047.9     60.9y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3995    5.851   10.045 14   8         12281      108y  0.26   0.000   0.000  Randbuf=41474 - Mers(0)=0.770358 - Mers(1)=0.292407 - Mers(2)=0.886301 - Mers(3)=0.795154 - Mers(4)=0.117081 \n",
+      "     7.3995    5.851   10.045 14   8         12281      108y  0.26   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=10.0118 Mc\"CO\"=7.4101 type=8) -> kick 1(0) vk=0 vr=20.5462 omega=0.735643 phi=0.63144 -> vn=20.5462 ; final sep 12281.5 ecc 0.261755 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 4.16087, dm(companion) = 0\n",
+      "     7.3995    5.851   10.045 14   8         12281      108y  0.26   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.3995    5.851   10.045 14   8         12281      108y  0.26   0.000   0.000  \"SN\"\n",
+      "     7.4011    5.851   10.043 14   8         12280      108y  0.26   0.000   0.000  \"END_SYMB\"\n",
+      "     7.4046    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  Mers(5)=0.544071 - Mers(6)=0.934445 - Mers(7)=0.999129 - Mers(8)=0.655767 - Mers(9)=0.990134 \n",
+      "     7.4046    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=10.0399 Mc\"CO\"=7.43173 type=8) -> kick 1(0) vk=0 vr=12.0992 omega=6.22119 phi=0.316807 -> vn=12.0992 ; final sep 15566.3 ecc 0.0597467 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 4.16716, dm(companion) = 0\n",
+      "     7.4046    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     7.4046    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  \"SN\"\n",
+      "     7.4146    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  \"END_SYMB\"\n",
+      " 15000.0000    5.851    5.873 14  14         15566      180y  0.06   0.000   0.000  \"MAX_TIME\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "args = dict(\n",
+    "            M_1=60, \n",
+    "            M_2=40,\n",
+    "            orbital_period=2000, # days    \n",
+    "            BH_prescription='BH_BELCZYNSKI',\n",
+    "            wind_mass_loss='WIND_ALGORITHM_BINARY_C_2020',\n",
+    "            sn_kick_dispersion_II=0,\n",
+    "            sn_kick_dispersion_IBC=0,\n",
+    "            sn_kick_dispersion_GRB_COLLAPSAR=0,\n",
+    "           )\n",
+    "search_for_BHBH(1,**args)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "558b899e-4201-4f46-8b59-dc65b81b05d1",
+   "metadata": {},
+   "source": [
+    "You should now have found a BHBH system but usually they have very wide orbits. This is caused by mass loss before, and during, the supernova. \n",
+    "\n",
+    "We can reduce the former by setting the wind mass loss to zero. This can be done unphysically by setting wind_mass_loss=0, or you can reduce the massive-star winds by setting the metallicity to be small, e.g. $10^{-3}$. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "d39256ed-d72c-440a-99f3-d86005bd8214",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_FRYER12_RAPID', 'wind_mass_loss': 'WIND_ALGORITHM_BINARY_C_2020', 'sn_kick_dispersion_II': 0, 'sn_kick_dispersion_IBC': 0, 'sn_kick_dispersion_GRB_COLLAPSAR': 0}\n",
+      "system 1 / 1\n",
+      "{'time': 6.5041, 'M1': 17.582, 'M2': 7.798, 'K1': 14.0, 'K2': 14.0, 'separation': 8291.7}\n",
+      "System 1 has separation 8291.7\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=75582 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"BEG_SYMB\"\n",
+      "     3.8674   57.840   39.505  2   1        3185.7     5.78y  0.00   0.017   0.010  \"TYPE_CHNGE\"\n",
+      "     3.8704   57.600   39.509  2   1        3192.2      5.8y  0.00   0.393   0.010  \"Start tidal lock 1\"\n",
+      "     3.8704   57.592   39.509  2   1        3192.4      5.8y  0.00   0.418   0.010  \"End tidal lock 1\"\n",
+      "     3.8706   57.568   39.510  4   1          3193     5.81y  0.00   0.496   0.010  \"TYPE_CHNGE\"\n",
+      "     3.8910   54.510   39.758  4   1        3246.3     6.04y  0.00   1.000   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.9650   42.495   42.571  4   1        3223.5     6.29y  0.00   1.913   0.009  \"q-inv\"\n",
+      "     4.0585   24.961   50.453  4   1        3211.5     6.65y  0.00   0.999   0.007  \"END_RCHE 1!>2\"\n",
+      "     4.0649   24.747   50.479  7   1        3216.1     6.67y  0.00   0.002   0.007  \"TYPE_CHNGE\"\n",
+      "     4.0649   24.747   50.479  7   1        3216.1     6.67y  0.00   0.002   0.007  \"End Carbon Star 1\"\n",
+      "     4.2967   19.576   50.392  7   1        3429.9     7.61y  0.00   0.001   0.007  \"BEG_BSS \"\n",
+      "     4.2996   17.561   50.390 14   1        3564.6     8.19y  0.03   0.000   0.007  Randbuf=10632 - Mers(0)=0.721973 - Mers(1)=0.260253 - Mers(2)=0.508271 - Mers(3)=0.63323 - Mers(4)=0.721907 \n",
+      "     4.2996   17.561   50.390 14   1        3564.6     8.19y  0.03   0.000   0.007  SN kick Ib/c (SN type 11 11, pre-explosion M=19.5117 Mc\"CO\"=14.7326 type=8) -> kick 1(0) vk=0 vr=62.0717 omega=4.53588 phi=0.269717 -> vn=62.0717 ; final sep 3564.57 ecc 0.0287144 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 1.95117, dm(companion) = 0\n",
+      "     4.2996   17.561   50.390 14   1        3564.6     8.19y  0.03   0.000   0.007  \"TYPE_CHNGE\"\n",
+      "     4.2996   17.561   50.390 14   1        3564.6     8.19y  0.03   0.000   0.007  \"SN\"\n",
+      "     4.3096   17.561   50.386 14   1        3564.4     8.19y  0.03   0.000   0.007  \"END_SYMB\"\n",
+      "     5.9074   17.561   49.493 14   2        3612.7     8.41y  0.03   0.000   0.012  \"OFF_MS\"\n",
+      "     5.9074   17.561   49.493 14   2        3612.7     8.41y  0.03   0.000   0.012  \"TYPE_CHNGE\"\n",
+      "     5.9074   17.561   49.493 14   2        3612.7     8.41y  0.03   0.000   0.012  \"END_BSS\"\n",
+      "     5.9113   17.561   49.242 14   4          3636     8.51y  0.03   0.000   0.212  \"TYPE_CHNGE\"\n",
+      "     5.9199   17.562   47.949 14   4        3705.2     8.84y  0.03   0.000   0.210  \"Start tidal lock 2\"\n",
+      "     5.9209   17.562   47.795 14   4        3713.7     8.88y  0.03   0.000   0.210  \"End tidal lock 2\"\n",
+      "     5.9805   17.567   38.862 14   4        4261.6     11.7y  0.03   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.9805   17.567   38.862 14   4        4258.2     11.7y  0.00   0.000   1.001  \"Circularized\"\n",
+      "     6.0513   17.575   28.249 14   4        4931.4     16.2y  0.00   0.000   1.054  \"Start Carbon Star 2\"\n",
+      "     6.0979   17.581   21.257 14   4        5378.6     20.1y  0.00   0.000   1.000  \"END_RCHE 2!>1\"\n",
+      "     6.1143   17.582   20.235 14   7        5443.7     20.7y  0.00   0.000   0.001  \"TYPE_CHNGE\"\n",
+      "     6.1143   17.582   20.235 14   7        5443.7     20.7y  0.00   0.000   0.001  \"End Carbon Star 2\"\n",
+      "     6.2370   17.582   17.497 14   7        5834.6     23.8y  0.00   0.000   0.001  \"q-inv\"\n",
+      "     6.4857   17.582   11.948 14   8        7001.6     34.2y  0.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.5041   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  Mers(5)=0.250315 - Mers(6)=0.00672711 - Mers(7)=0.253933 - Mers(8)=0.722036 - Mers(9)=0.427098 \n",
+      "     6.5041   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=11.5384 Mc\"CO\"=8.88583 type=8) -> kick 1(0) vk=0 vr=28.0368 omega=2.68354 phi=0.460139 -> vn=28.0368 ; final sep 8291.72 ecc 0.147395 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 3.74082, dm(companion) = 0\n",
+      "     6.5041   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.5041   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  \"SN\"\n",
+      "     6.5141   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  \"END_SYMB\"\n",
+      " 15000.0000   17.582    7.798 14  14        8291.7     47.5y  0.15   0.000   0.000  \"MAX_TIME\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "args = dict(\n",
+    "            M_1=60, \n",
+    "            M_2=40,\n",
+    "            metallicity=0.001,\n",
+    "            orbital_period=2000, # days    \n",
+    "            BH_prescription='BH_BELCZYNSKI',\n",
+    "            wind_mass_loss='WIND_ALGORITHM_BINARY_C_2020',\n",
+    "            sn_kick_dispersion_II=0,\n",
+    "            sn_kick_dispersion_IBC=0,\n",
+    "            sn_kick_dispersion_GRB_COLLAPSAR=0,\n",
+    "           )\n",
+    "search_for_BHBH(1,**args)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a2400954-a639-4cf9-abfa-1c64e2b68f63",
+   "metadata": {},
+   "source": [
+    "Oh dear! While the mass loss is reduced, there is now Roche-lobe overflow (RLOF)! This increases the secondary's mass, but that means it *also* has RLOF. We can try making the system wider to prevent this, but we want a shorter period! Instead, let's shorten the initial period to force common-envelope evolution. This will shrink the system. We will also turn off the mass loss to give us the best change of acquiring the system we want, and turn the SN kicks back on (they have less effect in closer, more grvitationally-bound systems). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "c3402504-1ccb-461b-b2e3-f369629400fa",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.0001, 'orbital_period': 2000, 'BH_prescription': 'BH_FRYER12_RAPID', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1, 'lambda_ce': 0.5}\n",
+      "system 1 / 1\n",
+      "{'time': 6.0079, 'M1': 22.355, 'M2': 15.639, 'K1': 14.0, 'K2': 14.0, 'separation': 113.06}\n",
+      "System 1 has separation 113.06\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=14419 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.005  \"INITIAL \"\n",
+      "     3.8571   60.000   40.000  2   1        3101.2     5.48y  0.00   0.014   0.009  \"TYPE_CHNGE\"\n",
+      "     3.8600   60.000   40.000  4   1        3101.2     5.48y  0.00   0.096   0.009  \"TYPE_CHNGE\"\n",
+      "     4.0451   60.000   40.000  4   1        3101.2     5.48y  0.00   0.503   0.010  \"Start tidal lock 1\"\n",
+      "     4.0491   60.000   40.000  4   1        3101.2     5.48y  0.00   0.561   0.010  \"End tidal lock 1\"\n",
+      "     4.0678   60.000   40.000  4   1        3099.3     5.47y  0.00   1.000   0.010  \"BEG_RCHE 1>2\"\n",
+      "     4.0681   60.000   40.000  4   1        3099.1     5.47y  0.00   1.009   0.010  \"BEG_SYMB\"\n",
+      "     4.2094   56.978   43.022  5   1          2884     4.91y  0.00   1.672   0.010  \"TYPE_CHNGE\"\n",
+      "     4.2094   56.978   43.022  5   1          2884     4.91y  0.00   1.672   0.010  Unstable RLOF : q=Mdonor/Maccretor=1.32438 > qc=0.733417 (prescription=float, donor [st=5 M=56.9778 Mc=25.8207 R=1945.85 Rc=1.67126], accretor [st=1 M=43.0222 Mc=0 R=10.1192 Rc=0] sep=2884.02 )\n",
+      "     4.2094   56.978   43.022  5   1          2884     4.91y  0.00   1.672   0.010  COMENV n=0 presc=0 56.9778(Mc\"He\"=25.8207,\"CO\"=25.8207;EAGB)+43.0222(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=25.8207,l1=1.14773e+06,r1=1945.85,rzams=7.21541,convfrac=0.560301,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2884.02 P_in=1793.89 Jtot_in=8.09752e+55 Jorb_in=7.95297e+55 EorbI=7.31037e+47 EbindI=-6.92616e+48 - sepF=30.1221 1:Rc=1.67126~RL=10.1116 2:Rc=10.1193~RL=12.7646 - : Mf1=25.8207(19.6094,9) Mf2=43.0222(0,1) af=30.1221 Jf=4.44174e+54 Jej=7.82682e+55 Eorbf=-6.99926e+49 dE=6.92616e+48 Eej=1.89371e+48 alpha_ej=0.0273415\n",
+      "     4.2095   25.821   43.022  9   1        30.122     2.31d  0.00 647.092   0.793  post-COMENV M=25.8207(Mc\"CO\"=19.6094;HeGB;Menv=19.6094,Mstart=25.8207,Teff=0.407726,age=3102.24) + M=43.0222(Mc;MS;Menv=43.0222,Mstart=43.0222,Teff=3.62709,age=46857.8) a_out=30.1221 P_out=0.00631839 (2.30747 d) Jorb_out=4.44174e+54 R1=6543.21 RL1=10.1116 (R1/RL1 = 647.099) R2=10.1193 RL2=12.7646 (R2/RL2 = 0.792766) SN? 0 0 Single? No : merge in 1.60828 Gyr at t = 1.61249 Gyr, events pending? 1\n",
+      "     4.2095   25.821   43.022  9   1        30.122     2.31d  0.00 647.092   0.793  \"TYPE_CHNGE\"\n",
+      "     4.2095   25.821   43.022  9   1        30.122     2.31d  0.00 647.092   0.793  \"q-inv\"\n",
+      "     4.2095   22.323   43.622 14   1        51.305     5.24d  0.04   0.000   0.473  Randbuf=34102 - Mers(0)=0.705149 - Mers(1)=0.281979 - Mers(2)=0.499352 - Mers(3)=0.921211 - Mers(4)=0.89857 \n",
+      "     4.2095   22.323   43.622 14   1        51.305     5.24d  0.04   0.000   0.473  SN kick Ib/c (SN type 11 11, pre-explosion M=24.803 Mc\"CO\"=19.6094 type=9) -> kick 1(190) vk=0 vr=514.256 omega=5.64588 phi=1.00176 -> vn=514.256 ; final sep 51.3049 ecc 0.0376117 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 2.4803, dm(companion) = 0\n",
+      "     4.2095   22.323   43.622 14   1        51.305     5.24d  0.04   0.000   0.473  \"TYPE_CHNGE\"\n",
+      "     4.2095   22.323   43.622 14   1        51.305     5.24d  0.04   0.000   0.473  \"END_RCHE 1!>2\"\n",
+      "     4.2095   22.323   43.622 14   1        51.305     5.24d  0.04   0.000   0.473  \"SN\"\n",
+      "     4.2095   22.323   43.622 14   1        57.681     6.25d  0.04   0.000   0.396  \"END_SYMB\"\n",
+      "     4.8741   22.323   43.622 14   1         64.16     7.33d  0.04   0.000   0.454  \"BEG_BSS \"\n",
+      "     5.0475   22.323   43.622 14   1        64.432     7.38d  0.04   0.000   0.493  \"Start tidal lock 2\"\n",
+      "     5.5479   22.323   43.622 14   1        64.067     7.31d  0.02   0.000   0.584  \"End tidal lock 2\"\n",
+      "     5.5526   22.323   43.622 14   2        64.096     7.32d  0.02   0.000   0.534  \"OFF_MS\"\n",
+      "     5.5526   22.323   43.622 14   2        64.096     7.32d  0.02   0.000   0.534  \"TYPE_CHNGE\"\n",
+      "     5.5526   22.323   43.622 14   2        64.096     7.32d  0.02   0.000   0.534  \"END_BSS\"\n",
+      "     5.5540   22.323   43.622 14   2        64.097     7.32d  0.02   0.000   0.824  \"Start tidal lock 2\"\n",
+      "     5.5544   22.323   43.622 14   2        64.097     7.32d  0.02   0.000   0.938  \"End tidal lock 2\"\n",
+      "     5.5546   22.323   43.622 14   2        64.096     7.32d  0.02   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.5546   22.323   43.622 14   2         64.07     7.31d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.5546   22.323   43.622 14   2         64.07     7.31d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.5555   22.323   43.622 14   2        64.066     7.31d  0.00   0.000   1.297  \"Start tidal lock 2\"\n",
+      "     5.5574   22.323   43.591 14   4        64.143     7.33d  0.00   0.000   2.329  \"TYPE_CHNGE\"\n",
+      "     5.6650   22.335   38.868 14   4        69.249     8.53d  0.00   0.000   2.386  \"End tidal lock 2\"\n",
+      "     5.8025   22.352   22.338 14   4        95.828     16.2d  0.00   0.000   4.659  \"q-inv\"\n",
+      "     5.8257   22.355   17.376 14   4        107.89     20.6d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8257   22.355   17.376 14   4        107.89     20.6d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8508   22.355   17.376 14   7        107.89     20.6d  0.00   0.000   0.037  \"TYPE_CHNGE\"\n",
+      "     6.0056   22.355   17.376 14   8        107.89     20.6d  0.00   0.000   0.034  \"TYPE_CHNGE\"\n",
+      "     6.0056   22.355   17.376 14   8        107.89     20.6d  0.00   0.000   0.034  \"Start tidal lock 2\"\n",
+      "     6.0079   22.355   15.639 14  14        113.06     22.6d  0.05   0.000   0.000  Mers(5)=0.554134 - Mers(6)=0.428655 - Mers(7)=0.798315 - Mers(8)=0.922564 - Mers(9)=0.621763 \n",
+      "     6.0079   22.355   15.639 14  14        113.06     22.6d  0.05   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=17.3764 Mc\"CO\"=13.0819 type=8) -> kick 1(190) vk=0 vr=265.092 omega=3.90665 phi=1.0068 -> vn=265.092 ; final sep 113.064 ecc 0.0457344 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 1.73764, dm(companion) = 0\n",
+      "     6.0079   22.355   15.639 14  14        113.06     22.6d  0.05   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.0079   22.355   15.639 14  14        113.06     22.6d  0.05   0.000   0.000  \"SN\"\n",
+      "     6.0079   22.355   15.639 14  14        113.06     22.6d  0.05   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   22.355   15.639 14  14        112.83     22.5d  0.05   0.000   0.000  \"MAX_TIME\"\n",
+      "\n"
+     ]
+    }
+   ],
+   "source": [
+    "args = dict(\n",
+    "            M_1=60, \n",
+    "            M_2=40,\n",
+    "            metallicity=0.0001,\n",
+    "            orbital_period=2000, # days    \n",
+    "            BH_prescription='BH_BELCZYNSKI',\n",
+    "            wind_mass_loss='WIND_ALGORITHM_NONE',\n",
+    "            alpha_ce = 0.1,\n",
+    "            lambda_ce = 0.5,\n",
+    "           )\n",
+    "search_for_BHBH(1,**args)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "727e7f48-4ef8-4e8b-906b-176210b4b53f",
+   "metadata": {},
+   "source": [
+    "Note that this system has a far shorter period. Let's run a number of these to see what we find."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "490afee7-04c1-4f27-bb6e-52de3f3e8402",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -103.19}\n",
+      "System 1 has separation -103.19\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.015, 'K1': 14.0, 'K2': 14.0, 'separation': -143.4}\n",
+      "System 5 has separation -143.4\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -92.576}\n",
+      "System 7 has separation -92.576\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -677.44}\n",
+      "System 8 has separation -677.44\n",
+      "system 9 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -50.288}\n",
+      "System 9 has separation -50.288\n",
+      "system 10 / 100\n",
+      "{'time': 6.1845, 'M1': 26.232, 'M2': 18.797, 'K1': 14.0, 'K2': 14.0, 'separation': -851.3}\n",
+      "System 10 has separation -851.3\n",
+      "system 11 / 100\n",
+      "{'time': 6.1831, 'M1': 26.222, 'M2': 18.889, 'K1': 14.0, 'K2': 14.0, 'separation': 117.05}\n",
+      "System 11 has separation 117.05\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=7567 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        67.888     7.49d  0.35   0.000   0.284  Randbuf=22177 - Mers(0)=0.235151 - Mers(1)=0.685023 - Mers(2)=0.644918 - Mers(3)=0.884027 - Mers(4)=0.836938 \n",
+      "     4.1327   26.215   48.508 14   1        67.888     7.49d  0.35   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=354.099 vr=401.272 omega=5.25864 phi=0.875796 -> vn=334.655 ; final sep 67.8878 ecc 0.346447 (random count 0) - Runaway v=(263.383,-30.2748,-160.491) |v|=309.911 : companion v=(-42.9275,-88.3515,-38.8557), |v|=105.634 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        67.888     7.49d  0.35   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        67.888     7.49d  0.35   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        67.888     7.49d  0.35   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        74.872     8.68d  0.35   0.000   0.336  \"END_SYMB\"\n",
+      "     4.4358   26.215   48.508 14   1         81.09     9.78d  0.36   0.000   0.338  \"BEG_BSS \"\n",
+      "     5.6178   26.215   48.508 14   1        73.377     8.42d  0.12   0.000   0.741  \"Start tidal lock 2\"\n",
+      "     5.7389   26.215   48.508 14   1        72.432     8.26d  0.01   0.000   0.676  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        72.481     8.27d  0.01   0.000   0.623  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        72.481     8.27d  0.01   0.000   0.623  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        72.481     8.27d  0.01   0.000   0.623  \"END_BSS\"\n",
+      "     5.7424   26.215   48.508 14   2        72.482     8.27d  0.01   0.000   0.905  \"Start tidal lock 2\"\n",
+      "     5.7425   26.215   48.508 14   2        72.482     8.27d  0.01   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7425   26.215   48.508 14   2        72.471     8.27d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7425   26.215   48.508 14   2        72.471     8.27d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.7431   26.215   48.507 14   2        72.473     8.27d  0.00   0.000   1.521  \"End tidal lock 2\"\n",
+      "     5.7447   26.215   48.362 14   2        72.895     8.35d  0.00   0.000   4.611  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.223 14   2        73.252     8.42d  0.00   0.000   6.087  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.681 14   4        74.297     8.63d  0.00   0.000  10.506  \"TYPE_CHNGE\"\n",
+      "     5.7702   26.219   27.155 14   4        103.04     16.6d  0.00   0.000   8.506  \"Start Carbon Star 2\"\n",
+      "     5.7715   26.219   26.208 14   4        104.91     17.2d  0.00   0.000   8.443  \"q-inv\"\n",
+      "     5.7859   26.222   18.889 14   4        122.08     23.3d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7859   26.222   18.889 14   4        122.08     23.3d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8046   26.222   18.889 14   7        122.07     23.3d  0.00   0.000   0.033  \"TYPE_CHNGE\"\n",
+      "     5.8046   26.222   18.889 14   7        122.07     23.3d  0.00   0.000   0.033  \"Start tidal lock 2\"\n",
+      "     5.8046   26.222   18.889 14   7        122.07     23.3d  0.00   0.000   0.033  \"End Carbon Star 2\"\n",
+      "     6.1817   26.222   18.889 14   7        122.07     23.3d  0.00   0.000   0.032  \"End tidal lock 2\"\n",
+      "     6.1831   26.222   18.889 14  14        117.05     21.8d  0.35   0.000   0.000  Mers(5)=0.296644 - Mers(6)=0.157745 - Mers(7)=0.311941 - Mers(8)=0.207277 - Mers(9)=0.195394 \n",
+      "     6.1831   26.222   18.889 14  14        117.05     21.8d  0.35   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8886 Mc\"CO\"=14.2509 type=8) -> kick 1(190) vk=119.552 vr=265.553 omega=1.2277 phi=-0.625429 -> vn=259.797 ; final sep 117.054 ecc 0.353612 (random count 5) - Runaway v=(-42.9275,-88.3515,-38.8557) |v|=105.634 : companion v=(263.383,-30.2748,-160.491), |v|=309.911 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1831   26.222   18.889 14  14        117.05     21.8d  0.35   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1831   26.222   18.889 14  14        117.05     21.8d  0.35   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.222   18.889 14  14        116.28     21.6d  0.35   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -222.88}\n",
+      "System 1 has separation -222.88\n",
+      "system 2 / 100\n",
+      "{'time': 6.1827, 'M1': 26.222, 'M2': 18.913, 'K1': 14.0, 'K2': 14.0, 'separation': 324.11}\n",
+      "System 2 has separation 324.11\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=47308 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        72.885     8.34d  0.31   0.000   0.284  Randbuf=78406 - Mers(0)=0.908968 - Mers(1)=0.223217 - Mers(2)=0.224314 - Mers(3)=0.144672 - Mers(4)=0.132722 \n",
+      "     4.1327   26.215   48.508 14   1        72.885     8.34d  0.31   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=152.749 vr=401.272 omega=0.833917 phi=-0.790431 -> vn=355.523 ; final sep 72.8855 ecc 0.30664 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        72.885     8.34d  0.31   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        72.885     8.34d  0.31   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        72.885     8.34d  0.31   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        80.009     9.59d  0.31   0.000   0.315  \"END_SYMB\"\n",
+      "     4.4352   26.215   48.508 14   1        85.531     10.6d  0.31   0.000   0.321  \"BEG_BSS \"\n",
+      "     5.7102   26.215   48.508 14   1        80.365     9.65d  0.12   0.000   0.747  \"Start tidal lock 2\"\n",
+      "     5.7153   26.215   48.508 14   1        80.248     9.63d  0.12   0.000   0.744  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        80.266     9.63d  0.10   0.000   0.562  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        80.266     9.63d  0.10   0.000   0.562  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        80.266     9.63d  0.10   0.000   0.562  \"END_BSS\"\n",
+      "     5.7425   26.215   48.508 14   2        80.267     9.63d  0.10   0.000   0.888  \"Start tidal lock 2\"\n",
+      "     5.7427   26.215   48.508 14   2        80.266     9.63d  0.10   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7427   26.215   48.508 14   2        79.421     9.48d  0.00   0.000   1.012  \"BEG_SYMB\"\n",
+      "     5.7427   26.215   48.508 14   2        79.421     9.48d  0.00   0.000   1.012  \"Circularized\"\n",
+      "     5.7435   26.215   48.505 14   2        79.431     9.48d  0.00   0.000   1.805  \"End tidal lock 2\"\n",
+      "     5.7446   26.215   48.409 14   2        79.729     9.54d  0.00   0.000   4.012  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.261 14   2        80.144     9.63d  0.00   0.000   5.716  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.800 14   4        81.149     9.84d  0.00   0.000   9.616  \"TYPE_CHNGE\"\n",
+      "     5.7733   26.219   27.161 14   4        112.78       19d  0.00   0.000   7.973  \"Start Carbon Star 2\"\n",
+      "     5.7747   26.220   26.209 14   4        114.84     19.7d  0.00   0.000   7.946  \"q-inv\"\n",
+      "     5.7898   26.222   18.913 14   4        133.56     26.6d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7898   26.222   18.913 14   4        133.56     26.6d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8086   26.222   18.913 14   7        133.56     26.6d  0.00   0.000   0.030  \"TYPE_CHNGE\"\n",
+      "     5.8086   26.222   18.913 14   7        133.56     26.6d  0.00   0.000   0.030  \"Start tidal lock 2\"\n",
+      "     5.8086   26.222   18.913 14   7        133.56     26.6d  0.00   0.000   0.030  \"End Carbon Star 2\"\n",
+      "     6.1827   26.222   18.913 14  14        324.11      101d  0.80   0.000   0.000  Mers(5)=0.584876 - Mers(6)=0.470906 - Mers(7)=0.414233 - Mers(8)=0.514937 - Mers(9)=0.237819 \n",
+      "     6.1827   26.222   18.913 14  14        324.11      101d  0.80   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9134 Mc\"CO\"=14.27 type=8) -> kick 1(190) vk=215.098 vr=253.954 omega=1.49426 phi=0.0298775 -> vn=320.016 ; final sep 324.112 ecc 0.799558 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1827   26.222   18.913 14  14        324.11      101d  0.80   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1827   26.222   18.913 14  14        324.11      101d  0.80   0.000   0.000  \"SN\"\n",
+      "     6.1827   26.222   18.913 14  14        324.11      101d  0.80   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.222   18.913 14  14        322.31     99.7d  0.80   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -59.535}\n",
+      "System 1 has separation -59.535\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -103.44}\n",
+      "System 2 has separation -103.44\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -87.467}\n",
+      "System 3 has separation -87.467\n",
+      "system 4 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.038, 'K1': 14.0, 'K2': 14.0, 'separation': -70.258}\n",
+      "System 4 has separation -70.258\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -1488.1}\n",
+      "System 5 has separation -1488.1\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -51.72}\n",
+      "System 6 has separation -51.72\n",
+      "system 7 / 100\n",
+      "{'time': 6.2108, 'M1': 26.313, 'M2': 17.51, 'K1': 14.0, 'K2': 14.0, 'separation': 61.89}\n",
+      "System 7 has separation 61.89\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=23402 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         51.51     4.95d  0.72   0.000   0.284  Randbuf=9580 - Mers(0)=0.267008 - Mers(1)=0.783572 - Mers(2)=0.209991 - Mers(3)=0.635214 - Mers(4)=0.801875 \n",
+      "     4.1327   26.215   48.508 14   1         51.51     4.95d  0.72   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=343.463 vr=401.272 omega=5.03833 phi=0.273838 -> vn=212.625 ; final sep 51.51 ecc 0.719293 (random count 0) - Runaway v=(174.601,-111.778,-54.2801) |v|=214.304 : companion v=(-34.9237,-108.882,-18.2185), |v|=115.788 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         51.51     4.95d  0.72   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         51.51     4.95d  0.72   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         51.51     4.95d  0.72   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        59.805      6.2d  0.72   0.000   0.421  \"END_SYMB\"\n",
+      "     4.2007   26.215   48.508 14   1        33.294     2.57d  0.11   0.000   0.770  \"Start tidal lock 2\"\n",
+      "     4.4202   26.215   48.508 14   1        32.874     2.53d  0.00   0.000   0.831  \"BEG_BSS \"\n",
+      "     4.4657   26.215   48.508 14   1        32.851     2.52d  0.00   0.000   0.843  \"Circularized\"\n",
+      "     4.8891   26.215   48.508 14   1        32.552     2.49d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     4.8900   26.215   48.508 14   1        32.552     2.49d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7478   26.309   46.094 14   2        33.922     2.69d  0.00   0.000   1.298  \"OFF_MS\"\n",
+      "     5.7478   26.309   46.094 14   2        33.922     2.69d  0.00   0.000   1.298  \"TYPE_CHNGE\"\n",
+      "     5.7478   26.309   46.094 14   2        33.922     2.69d  0.00   0.000   1.298  \"END_BSS\"\n",
+      "     5.7478   26.309   46.094 14   2        33.922     2.69d  0.00   0.000   1.298  \"End tidal lock 2\"\n",
+      "     5.7505   26.309   45.710 14   2        34.839     2.81d  0.00   0.000   6.626  \"Start tidal lock 2\"\n",
+      "     5.7507   26.309   45.571 14   2        35.011     2.83d  0.00   0.000   7.674  \"End tidal lock 2\"\n",
+      "     5.7522   26.309   43.905 14   4        36.232     3.01d  0.00   0.000  18.144  \"TYPE_CHNGE\"\n",
+      "     5.7624   26.311   27.124 14   4        47.304     5.15d  0.00   0.000  14.697  \"Start Carbon Star 2\"\n",
+      "     5.7630   26.311   26.260 14   4        48.097     5.32d  0.00   0.000  14.482  \"q-inv\"\n",
+      "     5.7727   26.313   17.510 14   4        57.963     7.72d  0.00   0.000   0.995  \"END_RCHE 2!>1\"\n",
+      "     5.7727   26.313   17.510 14   4        57.963     7.72d  0.00   0.000   0.987  \"END_SYMB\"\n",
+      "     5.7890   26.313   17.510 14   7        57.961     7.72d  0.00   0.000   0.067  \"TYPE_CHNGE\"\n",
+      "     5.7890   26.313   17.510 14   7        57.961     7.72d  0.00   0.000   0.067  \"End Carbon Star 2\"\n",
+      "     5.8577   26.313   17.510 14   7        57.961     7.72d  0.00   0.000   0.068  \"Start tidal lock 2\"\n",
+      "     6.1871   26.313   17.510 14   7        57.961     7.72d  0.00   0.000   0.068  \"End tidal lock 2\"\n",
+      "     6.2087   26.313   17.510 14   8        57.961     7.72d  0.00   0.000   0.066  \"TYPE_CHNGE\"\n",
+      "     6.2108   26.313   17.510 14  14         61.89     8.52d  0.53   0.000   0.000  Mers(5)=0.545304 - Mers(6)=0.44499 - Mers(7)=0.336545 - Mers(8)=0.517195 - Mers(9)=0.785792 \n",
+      "     6.2108   26.313   17.510 14  14         61.89     8.52d  0.53   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=17.5099 Mc\"CO\"=13.1851 type=8) -> kick 1(190) vk=212.423 vr=379.844 omega=4.93728 phi=0.0343973 -> vn=391.714 ; final sep 61.8898 ecc 0.531064 (random count 5) - Runaway v=(-34.9237,-108.882,-18.2185) |v|=115.788 : companion v=(174.601,-111.778,-54.2801), |v|=214.304 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.2108   26.313   17.510 14  14         61.89     8.52d  0.53   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.2108   26.313   17.510 14  14         61.89     8.52d  0.53   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.313   17.510 14  14        48.381     5.89d  0.44   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.047, 'K1': 14.0, 'K2': 14.0, 'separation': -62.086}\n",
+      "System 1 has separation -62.086\n",
+      "system 2 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.02, 'K1': 14.0, 'K2': 14.0, 'separation': -58.412}\n",
+      "System 2 has separation -58.412\n",
+      "system 3 / 100\n",
+      "{'time': 6.1834, 'M1': 26.221, 'M2': 18.866, 'K1': 14.0, 'K2': 14.0, 'separation': -36.723}\n",
+      "System 3 has separation -36.723\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -161.98}\n",
+      "System 4 has separation -161.98\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -463.83}\n",
+      "System 5 has separation -463.83\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -520.62}\n",
+      "System 7 has separation -520.62\n",
+      "system 8 / 100\n",
+      "{'time': 6.1818, 'M1': 26.224, 'M2': 18.977, 'K1': 14.0, 'K2': 14.0, 'separation': -44.926}\n",
+      "System 8 has separation -44.926\n",
+      "system 9 / 100\n",
+      "{'time': 6.2486, 'M1': 26.36, 'M2': 16.113, 'K1': 14.0, 'K2': 14.0, 'separation': -140.33}\n",
+      "System 9 has separation -140.33\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1811, 'M1': 26.225, 'M2': 19.032, 'K1': 14.0, 'K2': 14.0, 'separation': 126.27}\n",
+      "System 11 has separation 126.27\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=41887 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        122.32     18.1d  0.31   0.000   0.284  Randbuf=48672 - Mers(0)=0.544718 - Mers(1)=0.608074 - Mers(2)=0.436684 - Mers(3)=0.0218377 - Mers(4)=0.187423 \n",
+      "     4.1327   26.215   48.508 14   1        122.32     18.1d  0.31   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=260.504 vr=401.272 omega=1.17761 phi=-1.27416 -> vn=453.286 ; final sep 122.325 ecc 0.313759 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        122.32     18.1d  0.31   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        122.32     18.1d  0.31   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        122.32     18.1d  0.31   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        131.53     20.2d  0.31   0.000   0.191  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        137.51     21.6d  0.31   0.000   0.203  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        141.18     22.5d  0.32   0.000   0.320  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        141.18     22.5d  0.32   0.000   0.320  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        141.18     22.5d  0.32   0.000   0.320  \"END_BSS\"\n",
+      "     5.7435   26.215   48.508 14   2        141.17     22.5d  0.32   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7435   26.215   48.508 14   2        126.31       19d  0.00   0.000   1.118  \"BEG_SYMB\"\n",
+      "     5.7435   26.215   48.508 14   2        126.31       19d  0.00   0.000   1.118  \"Circularized\"\n",
+      "     5.7458   26.215   48.248 14   2        127.94     19.4d  0.00   0.000   5.842  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.222 14   4        128.07     19.5d  0.00   0.000   6.085  \"TYPE_CHNGE\"\n",
+      "     5.7461   26.215   48.134 14   4        128.43     19.5d  0.00   0.000   6.070  \"End tidal lock 2\"\n",
+      "     5.7944   26.222   27.164 14   4        180.38     38.4d  0.00   0.000   7.349  \"Start Carbon Star 2\"\n",
+      "     5.7959   26.223   26.203 14   4         183.7     39.8d  0.00   0.000   7.604  \"q-inv\"\n",
+      "     5.8092   26.225   19.032 14   4           213     53.5d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8092   26.225   19.032 14   4           213     53.5d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8280   26.225   19.032 14   7        212.99     53.5d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8280   26.225   19.032 14   7        212.99     53.5d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1730   26.225   19.032 14   7        212.99     53.5d  0.00   0.000   0.019  \"Start tidal lock 2\"\n",
+      "     6.1811   26.225   19.032 14  14        126.27     24.4d  0.96   0.000   0.000  Mers(5)=0.516952 - Mers(6)=0.826542 - Mers(7)=0.516366 - Mers(8)=0.533048 - Mers(9)=0.353535 \n",
+      "     6.1811   26.225   19.032 14  14        126.27     24.4d  0.96   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0323 Mc\"CO\"=14.3619 type=8) -> kick 1(190) vk=382.945 vr=201.366 omega=2.22133 phi=0.0661435 -> vn=112.691 ; final sep 126.271 ecc 0.96338 (random count 5) - Runaway v=(-77.4158,67.1761,-4.79028) |v|=102.61 : companion v=(-112.124,171.919,18.0937), |v|=206.047 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1811   26.225   19.032 14  14        126.27     24.4d  0.96   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1811   26.225   19.032 14  14        126.27     24.4d  0.96   0.000   0.000  \"SN\"\n",
+      "     6.1811   26.225   19.032 14  14        126.27     24.4d  0.96   0.000   0.000  \"End tidal lock 2\"\n",
+      "   378.7578   26.225   19.032 14  14       0.12562   0.0184h  0.00   0.002   0.002  Contact reached R/RL = 0.00254461 0.00213787, st 14 14\n",
+      "   378.7578   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.315485 - Mers(11)=0.272318 \n",
+      "   378.7578   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.2573 Mc\"CO\"=45.2573,\"BH\"=45.2573 type=14) -> kick 0(0) vk=0 vr=0 omega=1.71102 phi=-0.377964 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(-112.124,171.919,18.0937) |v|=206.047 : companion v=(-77.4158,67.1761,-4.79028), |v|=102.61 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "   378.7578   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "   378.7578   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "   378.7578   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.257    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -44.099}\n",
+      "System 1 has separation -44.099\n",
+      "system 2 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.984, 'K1': 14.0, 'K2': 14.0, 'separation': -43.084}\n",
+      "System 2 has separation -43.084\n",
+      "system 3 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.997, 'K1': 14.0, 'K2': 14.0, 'separation': -104.5}\n",
+      "System 3 has separation -104.5\n",
+      "system 4 / 100\n",
+      "{'time': 6.1825, 'M1': 26.223, 'M2': 18.929, 'K1': 14.0, 'K2': 14.0, 'separation': 152.41}\n",
+      "System 4 has separation 152.41\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=58258 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        102.08     13.8d  0.56   0.000   0.284  Randbuf=35255 - Mers(0)=0.441008 - Mers(1)=0.621594 - Mers(2)=0.219244 - Mers(3)=0.747345 - Mers(4)=0.202644 \n",
+      "     4.1327   26.215   48.508 14   1        102.08     13.8d  0.56   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=280.536 vr=401.272 omega=1.27325 phi=0.517479 -> vn=427.031 ; final sep 102.085 ecc 0.55702 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        102.08     13.8d  0.56   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        102.08     13.8d  0.56   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        102.08     13.8d  0.56   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        111.74     15.8d  0.56   0.000   0.225  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        118.84     17.4d  0.56   0.000   0.235  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        101.76     13.8d  0.42   0.000   0.443  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        101.76     13.8d  0.42   0.000   0.443  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        101.76     13.8d  0.42   0.000   0.443  \"END_BSS\"\n",
+      "     5.7430   26.215   48.508 14   2         101.7     13.7d  0.42   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7430   26.215   48.508 14   2         83.42     10.2d  0.00   0.000   1.220  \"BEG_SYMB\"\n",
+      "     5.7430   26.215   48.508 14   2         83.42     10.2d  0.00   0.000   1.220  \"Circularized\"\n",
+      "     5.7453   26.215   48.220 14   2        84.801     10.5d  0.00   0.000   6.102  \"Start tidal lock 2\"\n",
+      "     5.7455   26.215   48.100 14   2        85.161     10.6d  0.00   0.000   7.194  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.865 14   4        85.756     10.7d  0.00   0.000   9.097  \"TYPE_CHNGE\"\n",
+      "     5.7755   26.220   27.158 14   4        119.55     20.7d  0.00   0.000   7.690  \"Start Carbon Star 2\"\n",
+      "     5.7770   26.220   26.198 14   4        121.76     21.5d  0.00   0.000   7.691  \"q-inv\"\n",
+      "     5.7923   26.223   18.929 14   4        141.51       29d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7924   26.223   18.929 14   4        141.51       29d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8113   26.223   18.929 14   7        141.51       29d  0.00   0.000   0.028  \"TYPE_CHNGE\"\n",
+      "     5.8113   26.223   18.929 14   7        141.51       29d  0.00   0.000   0.028  \"Start tidal lock 2\"\n",
+      "     5.8113   26.223   18.929 14   7        141.51       29d  0.00   0.000   0.028  \"End Carbon Star 2\"\n",
+      "     6.1825   26.223   18.929 14  14        152.41     32.4d  0.22   0.000   0.000  Mers(5)=0.492945 - Mers(6)=0.0657235 - Mers(7)=0.113089 - Mers(8)=0.186282 - Mers(9)=0.753312 \n",
+      "     6.1825   26.223   18.929 14  14        152.41     32.4d  0.22   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9294 Mc\"CO\"=14.2824 type=8) -> kick 1(190) vk=70.1057 vr=246.757 omega=4.7332 phi=-0.678256 -> vn=255.428 ; final sep 152.41 ecc 0.2248 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1825   26.223   18.929 14  14        152.41     32.4d  0.22   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1825   26.223   18.929 14  14        152.41     32.4d  0.22   0.000   0.000  \"SN\"\n",
+      "     6.1825   26.223   18.929 14  14        152.41     32.4d  0.22   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.223   18.929 14  14        152.19     32.4d  0.22   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -40.433}\n",
+      "System 1 has separation -40.433\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.01, 'K1': 14.0, 'K2': 14.0, 'separation': -123.96}\n",
+      "System 3 has separation -123.96\n",
+      "system 4 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.988, 'K1': 14.0, 'K2': 14.0, 'separation': 801.84}\n",
+      "System 4 has separation 801.84\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=7459 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         108.3     15.1d  0.42   0.000   0.284  Randbuf=15193 - Mers(0)=0.164223 - Mers(1)=0.317691 - Mers(2)=0.350601 - Mers(3)=0.539952 - Mers(4)=0.252083 \n",
+      "     4.1327   26.215   48.508 14   1         108.3     15.1d  0.42   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=166.162 vr=401.272 omega=1.58389 phi=0.0799884 -> vn=436.313 ; final sep 108.297 ecc 0.415353 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         108.3     15.1d  0.42   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         108.3     15.1d  0.42   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         108.3     15.1d  0.42   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        117.35       17d  0.42   0.000   0.215  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        123.38     18.4d  0.42   0.000   0.226  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2         127.6     19.3d  0.42   0.000   0.354  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2         127.6     19.3d  0.42   0.000   0.354  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2         127.6     19.3d  0.42   0.000   0.354  \"END_BSS\"\n",
+      "     5.7433   26.215   48.508 14   2        127.51     19.3d  0.42   0.000   0.974  \"Start tidal lock 2\"\n",
+      "     5.7433   26.215   48.508 14   2        127.49     19.3d  0.42   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7433   26.215   48.508 14   2        104.74     14.4d  0.00   0.000   1.218  \"BEG_SYMB\"\n",
+      "     5.7433   26.215   48.508 14   2        104.74     14.4d  0.00   0.000   1.218  \"End tidal lock 2\"\n",
+      "     5.7433   26.215   48.508 14   2        104.74     14.4d  0.00   0.000   1.218  \"Circularized\"\n",
+      "     5.7453   26.215   48.332 14   2        105.51     14.5d  0.00   0.000   4.957  \"Start tidal lock 2\"\n",
+      "     5.7457   26.215   48.206 14   2        105.97     14.6d  0.00   0.000   6.242  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.085 14   4        106.37     14.7d  0.00   0.000   7.329  \"TYPE_CHNGE\"\n",
+      "     5.7851   26.221   27.148 14   4        149.02     28.8d  0.00   0.000   7.119  \"Start Carbon Star 2\"\n",
+      "     5.7868   26.221   26.202 14   4        151.73     29.9d  0.00   0.000   7.243  \"q-inv\"\n",
+      "     5.8018   26.224   18.988 14   4        176.12     40.3d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8018   26.224   18.988 14   4        176.12     40.3d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8208   26.224   18.988 14   7        176.12     40.3d  0.00   0.000   0.023  \"TYPE_CHNGE\"\n",
+      "     5.8208   26.224   18.988 14   7        176.12     40.3d  0.00   0.000   0.023  \"Start tidal lock 2\"\n",
+      "     5.8208   26.224   18.988 14   7        176.12     40.3d  0.00   0.000   0.023  \"End Carbon Star 2\"\n",
+      "     5.9432   26.224   18.988 14   7        176.12     40.3d  0.00   0.000   0.024  \"End tidal lock 2\"\n",
+      "     6.1268   26.224   18.988 14   7        176.12     40.3d  0.00   0.000   0.024  \"Start tidal lock 2\"\n",
+      "     6.1817   26.224   18.988 14  14        801.84     1.07y  0.80   0.000   0.000  Mers(5)=0.00660564 - Mers(6)=0.4715 - Mers(7)=0.53471 - Mers(8)=0.997044 - Mers(9)=0.57582 \n",
+      "     6.1817   26.224   18.988 14  14        801.84     1.07y  0.80   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9877 Mc\"CO\"=14.3275 type=8) -> kick 1(190) vk=614.896 vr=221.336 omega=3.61798 phi=1.462 -> vn=295.328 ; final sep 801.845 ecc 0.798228 (random count 5) - Runaway v=(-354.452,33.1463,-225.473) |v|=421.394 : companion v=(-139.003,-46.1691,-39.7048), |v|=151.756 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1817   26.224   18.988 14  14        801.84     1.07y  0.80   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1817   26.224   18.988 14  14        801.84     1.07y  0.80   0.000   0.000  \"SN\"\n",
+      "     6.1817   26.224   18.988 14  14        801.84     1.07y  0.80   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.988 14  14        801.73     1.07y  0.80   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -61.465}\n",
+      "System 1 has separation -61.465\n",
+      "system 2 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.851, 'K1': 14.0, 'K2': 14.0, 'separation': -50.425}\n",
+      "System 2 has separation -50.425\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -715.51}\n",
+      "System 3 has separation -715.51\n",
+      "system 4 / 100\n",
+      "{'time': 6.1806, 'M1': 26.226, 'M2': 19.068, 'K1': 14.0, 'K2': 14.0, 'separation': -83.475}\n",
+      "System 4 has separation -83.475\n",
+      "system 5 / 100\n",
+      "{'time': 6.1818, 'M1': 26.224, 'M2': 18.983, 'K1': 14.0, 'K2': 14.0, 'separation': -134.35}\n",
+      "System 5 has separation -134.35\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -118.2}\n",
+      "System 6 has separation -118.2\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -288.33}\n",
+      "System 7 has separation -288.33\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -34.485}\n",
+      "System 8 has separation -34.485\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "{'time': 6.1825, 'M1': 26.223, 'M2': 18.927, 'K1': 14.0, 'K2': 14.0, 'separation': -80.558}\n",
+      "System 10 has separation -80.558\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -84.793}\n",
+      "System 11 has separation -84.793\n",
+      "system 12 / 100\n",
+      "None\n",
+      "system 13 / 100\n",
+      "None\n",
+      "system 14 / 100\n",
+      "{'time': 6.1913, 'M1': 26.273, 'M2': 18.414, 'K1': 14.0, 'K2': 14.0, 'separation': 123.31}\n",
+      "System 14 has separation 123.31\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=16717 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        61.871     6.52d  0.71   0.000   0.284  Randbuf=41879 - Mers(0)=0.296063 - Mers(1)=0.400038 - Mers(2)=0.945387 - Mers(3)=0.258846 - Mers(4)=0.996913 \n",
+      "     4.1327   26.215   48.508 14   1        61.871     6.52d  0.71   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=241.879 vr=401.272 omega=6.26379 phi=-0.503288 -> vn=302.602 ; final sep 61.871 ecc 0.713076 (random count 0) - Runaway v=(237.493,122.196,1.33098) |v|=267.089 : companion v=(2.34571,-68.2584,0.503591), |v|=68.3005 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        61.871     6.52d  0.71   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        61.871     6.52d  0.71   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        61.871     6.52d  0.71   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        70.877     7.99d  0.71   0.000   0.355  \"END_SYMB\"\n",
+      "     4.4231   26.215   48.508 14   1        40.775     3.49d  0.19   0.000   0.670  \"BEG_BSS \"\n",
+      "     4.4581   26.215   48.508 14   1        40.018     3.39d  0.12   0.000   0.690  \"Start tidal lock 2\"\n",
+      "     4.9598   26.215   48.508 14   1        39.243     3.29d  0.00   0.000   0.858  \"Circularized\"\n",
+      "     5.2187   26.215   48.508 14   1        38.942     3.26d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.2195   26.215   48.508 14   1        38.941     3.26d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7430   26.269   47.832 14   2        39.407     3.33d  0.00   0.000   1.138  \"OFF_MS\"\n",
+      "     5.7430   26.269   47.832 14   2        39.407     3.33d  0.00   0.000   1.138  \"TYPE_CHNGE\"\n",
+      "     5.7430   26.269   47.832 14   2        39.407     3.33d  0.00   0.000   1.138  \"END_BSS\"\n",
+      "     5.7430   26.269   47.832 14   2        39.407     3.33d  0.00   0.000   1.138  \"End tidal lock 2\"\n",
+      "     5.7456   26.270   47.460 14   2        40.516     3.48d  0.00   0.000   6.821  \"Start tidal lock 2\"\n",
+      "     5.7459   26.270   47.323 14   2        40.713     3.51d  0.00   0.000   7.949  \"End tidal lock 2\"\n",
+      "     5.7471   26.270   45.899 14   4        41.954      3.7d  0.00   0.000  17.785  \"TYPE_CHNGE\"\n",
+      "     5.7589   26.272   27.121 14   4        56.425     6.71d  0.00   0.000  14.035  \"Start Carbon Star 2\"\n",
+      "     5.7595   26.272   26.263 14   4        57.513     6.97d  0.00   0.000  13.789  \"q-inv\"\n",
+      "     5.7689   26.273   18.414 14   4        67.693     9.65d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7689   26.273   18.414 14   4        67.693     9.65d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.7854   26.273   18.414 14   7        67.692     9.65d  0.00   0.000   0.058  \"TYPE_CHNGE\"\n",
+      "     5.7854   26.273   18.414 14   7        67.692     9.65d  0.00   0.000   0.058  \"End Carbon Star 2\"\n",
+      "     5.9144   26.273   18.414 14   7        67.692     9.65d  0.00   0.000   0.060  \"Start tidal lock 2\"\n",
+      "     6.1501   26.273   18.414 14   7        67.692     9.65d  0.00   0.000   0.060  \"End tidal lock 2\"\n",
+      "     6.1909   26.273   18.414 14   8        67.692     9.65d  0.00   0.000   0.058  \"TYPE_CHNGE\"\n",
+      "     6.1913   26.273   18.414 14  14        123.31     23.7d  0.45   0.000   0.000  Mers(5)=0.84978 - Mers(6)=0.388967 - Mers(7)=0.726 - Mers(8)=0.996221 - Mers(9)=0.28306 \n",
+      "     6.1913   26.273   18.414 14  14        123.31     23.7d  0.45   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.4136 Mc\"CO\"=13.8837 type=8) -> kick 1(190) vk=229.556 vr=354.935 omega=1.77852 phi=1.44778 -> vn=427.55 ; final sep 123.306 ecc 0.454681 (random count 5) - Runaway v=(2.34571,-68.2584,0.503591) |v|=68.3005 : companion v=(237.493,122.196,1.33098), |v|=267.089 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1913   26.273   18.414 14  14        123.31     23.7d  0.45   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1913   26.273   18.414 14  14        123.31     23.7d  0.45   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.273   18.414 14  14        122.24     23.4d  0.45   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.059, 'K1': 14.0, 'K2': 14.0, 'separation': -220.92}\n",
+      "System 1 has separation -220.92\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1853, 'M1': 26.245, 'M2': 18.741, 'K1': 14.0, 'K2': 14.0, 'separation': 75.049}\n",
+      "System 3 has separation 75.049\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=84471 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        57.347     5.82d  0.59   0.000   0.284  Randbuf=47138 - Mers(0)=0.920378 - Mers(1)=0.103649 - Mers(2)=0.260274 - Mers(3)=0.337749 - Mers(4)=0.923231 \n",
+      "     4.1327   26.215   48.508 14   1        57.347     5.82d  0.59   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=176.783 vr=401.272 omega=5.80083 phi=-0.330485 -> vn=270.896 ; final sep 57.3466 ecc 0.594904 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        57.347     5.82d  0.59   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        57.347     5.82d  0.59   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        57.347     5.82d  0.59   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        64.887        7d  0.59   0.000   0.388  \"END_SYMB\"\n",
+      "     4.4939   26.215   48.508 14   1        63.077     6.71d  0.51   0.000   0.443  \"BEG_BSS \"\n",
+      "     4.8795   26.215   48.508 14   1        47.765     4.42d  0.12   0.000   0.679  \"Start tidal lock 2\"\n",
+      "     5.3569   26.215   48.508 14   1        46.659     4.27d  0.00   0.000   0.920  \"Circularized\"\n",
+      "     5.4544   26.215   48.508 14   1        46.465     4.24d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.4553   26.215   48.508 14   1        46.465     4.24d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7419   26.240   48.416 14   1        46.477     4.25d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7419   26.240   48.416 14   2        46.477     4.25d  0.00   0.000   0.970  \"OFF_MS\"\n",
+      "     5.7419   26.240   48.416 14   2        46.477     4.25d  0.00   0.000   0.970  \"TYPE_CHNGE\"\n",
+      "     5.7419   26.240   48.416 14   2        46.477     4.25d  0.00   0.000   0.970  \"END_SYMB\"\n",
+      "     5.7419   26.240   48.416 14   2        46.477     4.25d  0.00   0.000   0.970  \"END_BSS\"\n",
+      "     5.7419   26.240   48.416 14   2        46.477     4.25d  0.00   0.000   0.970  \"End tidal lock 2\"\n",
+      "     5.7420   26.240   48.416 14   2         46.51     4.25d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7420   26.240   48.416 14   2         46.51     4.25d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7447   26.240   48.070 14   2        47.803     4.44d  0.00   0.000   6.647  \"Start tidal lock 2\"\n",
+      "     5.7450   26.240   47.933 14   2        48.032     4.48d  0.00   0.000   7.815  \"End tidal lock 2\"\n",
+      "     5.7460   26.240   46.832 14   4        49.228     4.68d  0.00   0.000  15.791  \"TYPE_CHNGE\"\n",
+      "     5.7602   26.243   27.158 14   4        67.271     8.74d  0.00   0.000  12.341  \"Start Carbon Star 2\"\n",
+      "     5.7610   26.243   26.226 14   4        68.478     9.06d  0.00   0.000  12.150  \"q-inv\"\n",
+      "     5.7713   26.245   18.741 14   4         79.96     12.3d  0.00   0.000   0.994  \"END_RCHE 2!>1\"\n",
+      "     5.7713   26.245   18.741 14   4         79.96     12.3d  0.00   0.000   0.987  \"END_SYMB\"\n",
+      "     5.7885   26.245   18.741 14   7        79.958     12.3d  0.00   0.000   0.050  \"TYPE_CHNGE\"\n",
+      "     5.7885   26.245   18.741 14   7        79.958     12.3d  0.00   0.000   0.050  \"End Carbon Star 2\"\n",
+      "     5.8854   26.245   18.741 14   7        79.958     12.3d  0.00   0.000   0.051  \"Start tidal lock 2\"\n",
+      "     6.1540   26.245   18.741 14   7        79.958     12.3d  0.00   0.000   0.051  \"End tidal lock 2\"\n",
+      "     6.1853   26.245   18.741 14  14        75.049     11.2d  0.84   0.000   0.000  Mers(5)=0.555396 - Mers(6)=0.563527 - Mers(7)=0.661441 - Mers(8)=0.276656 - Mers(9)=0.113152 \n",
+      "     6.1853   26.245   18.741 14  14        75.049     11.2d  0.84   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.7412 Mc\"CO\"=14.1369 type=8) -> kick 1(190) vk=270.706 vr=327.666 omega=0.710956 phi=-0.46306 -> vn=316.767 ; final sep 75.0487 ecc 0.840946 (random count 5) - Runaway v=(184.588,221.113,-47.5552) |v|=291.934 : companion v=(14.6649,-45.034,-22.389), |v|=52.3869 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1853   26.245   18.741 14  14        75.049     11.2d  0.84   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1853   26.245   18.741 14  14        75.049     11.2d  0.84   0.000   0.000  \"SN\"\n",
+      "  4281.8299   26.245   18.741 14  14       0.12636   0.0186h  0.00   0.002   0.002  Contact reached R/RL = 0.00250507 0.00208623, st 14 14\n",
+      "  4281.8299   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.818661 - Mers(11)=0.432552 \n",
+      "  4281.8299   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=44.9858 Mc\"CO\"=44.9858,\"BH\"=44.9858 type=14) -> kick 0(0) vk=0 vr=0 omega=2.7178 phi=0.691017 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(14.6649,-45.034,-22.389) |v|=52.3869 : companion v=(184.588,221.113,-47.5552), |v|=291.934 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "  4281.8299   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "  4281.8299   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "  4281.8299   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   44.986    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -122.21}\n",
+      "System 2 has separation -122.21\n",
+      "system 3 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.056, 'K1': 14.0, 'K2': 14.0, 'separation': -130.45}\n",
+      "System 3 has separation -130.45\n",
+      "system 4 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.985, 'K1': 14.0, 'K2': 14.0, 'separation': 132.07}\n",
+      "System 4 has separation 132.07\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=1958 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        90.407     11.5d  0.14   0.000   0.284  Randbuf=81731 - Mers(0)=0.557138 - Mers(1)=0.0459728 - Mers(2)=0.301837 - Mers(3)=0.563048 - Mers(4)=0.249643 \n",
+      "     4.1327   26.215   48.508 14   1        90.407     11.5d  0.14   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=58.2946 vr=401.272 omega=1.56855 phi=0.126433 -> vn=405.356 ; final sep 90.407 ecc 0.144092 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        90.407     11.5d  0.14   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        90.407     11.5d  0.14   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        90.407     11.5d  0.14   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        98.014       13d  0.14   0.000   0.257  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        103.06       14d  0.14   0.000   0.271  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   0.424  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   0.424  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   0.424  \"END_BSS\"\n",
+      "     5.7427   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   0.766  \"Start tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   0.863  \"End tidal lock 2\"\n",
+      "     5.7431   26.215   48.508 14   2        106.52     14.7d  0.15   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7431   26.215   48.508 14   2        104.25     14.3d  0.00   0.000   1.022  \"BEG_SYMB\"\n",
+      "     5.7431   26.215   48.508 14   2        104.25     14.3d  0.00   0.000   1.022  \"Circularized\"\n",
+      "     5.7459   26.215   48.079 14   4        105.49     14.6d  0.00   0.000   7.391  \"TYPE_CHNGE\"\n",
+      "     5.7846   26.221   27.153 14   4        147.35     28.3d  0.00   0.000   7.127  \"Start Carbon Star 2\"\n",
+      "     5.7863   26.221   26.201 14   4        150.04     29.4d  0.00   0.000   7.245  \"q-inv\"\n",
+      "     5.8013   26.224   18.985 14   4        174.17     39.6d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.8013   26.224   18.985 14   4        174.17     39.6d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8203   26.224   18.985 14   7        174.17     39.6d  0.00   0.000   0.023  \"TYPE_CHNGE\"\n",
+      "     5.8203   26.224   18.985 14   7        174.17     39.6d  0.00   0.000   0.023  \"Start tidal lock 2\"\n",
+      "     5.8203   26.224   18.985 14   7        174.17     39.6d  0.00   0.000   0.023  \"End Carbon Star 2\"\n",
+      "     5.9515   26.224   18.985 14   7        174.17     39.6d  0.00   0.000   0.024  \"End tidal lock 2\"\n",
+      "     6.1220   26.224   18.985 14   7        174.17     39.6d  0.00   0.000   0.024  \"Start tidal lock 2\"\n",
+      "     6.1817   26.224   18.985 14  14        132.07     26.1d  0.38   0.000   0.000  Mers(5)=0.465683 - Mers(6)=0.433521 - Mers(7)=0.20197 - Mers(8)=0.953837 - Mers(9)=0.791753 \n",
+      "     6.1817   26.224   18.985 14  14        132.07     26.1d  0.38   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9849 Mc\"CO\"=14.3253 type=8) -> kick 1(190) vk=236.575 vr=222.562 omega=4.97473 phi=1.13771 -> vn=183.695 ; final sep 132.07 ecc 0.383657 (random count 5) - Runaway v=(109.598,-16.2663,-148.325) |v|=185.14 : companion v=(-34.9265,-57.6423,-42.7571), |v|=79.8164 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1817   26.224   18.985 14  14        132.07     26.1d  0.38   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1817   26.224   18.985 14  14        132.07     26.1d  0.38   0.000   0.000  \"SN\"\n",
+      "     6.1817   26.224   18.985 14  14        132.07     26.1d  0.38   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.985 14  14        131.45       26d  0.38   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -173.88}\n",
+      "System 2 has separation -173.88\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -41.688}\n",
+      "System 3 has separation -41.688\n",
+      "system 4 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.994, 'K1': 14.0, 'K2': 14.0, 'separation': -498.75}\n",
+      "System 4 has separation -498.75\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -44.917}\n",
+      "System 5 has separation -44.917\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -54.625}\n",
+      "System 7 has separation -54.625\n",
+      "system 8 / 100\n",
+      "{'time': 6.1821, 'M1': 26.223, 'M2': 18.958, 'K1': 14.0, 'K2': 14.0, 'separation': 84.739}\n",
+      "System 8 has separation 84.739\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=50068 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        79.937     9.57d  0.11   0.000   0.284  Randbuf=23675 - Mers(0)=0.890807 - Mers(1)=0.0373488 - Mers(2)=0.704746 - Mers(3)=0.0446624 - Mers(4)=0.0614378 \n",
+      "     4.1327   26.215   48.508 14   1        79.937     9.57d  0.11   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=74.6957 vr=401.272 omega=0.386025 phi=-1.14492 -> vn=379.02 ; final sep 79.9375 ecc 0.112058 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        79.937     9.57d  0.11   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        79.937     9.57d  0.11   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        79.937     9.57d  0.11   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        87.069     10.9d  0.11   0.000   0.289  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        91.956     11.8d  0.11   0.000   0.303  \"BEG_BSS \"\n",
+      "     5.5624   26.215   48.508 14   1        95.198     12.4d  0.12   0.000   0.540  \"Start tidal lock 2\"\n",
+      "     5.7321   26.215   48.508 14   1         94.56     12.3d  0.10   0.000   0.569  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2          94.6     12.3d  0.10   0.000   0.477  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2          94.6     12.3d  0.10   0.000   0.477  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2          94.6     12.3d  0.10   0.000   0.477  \"END_BSS\"\n",
+      "     5.7426   26.215   48.508 14   2        94.601     12.3d  0.10   0.000   0.819  \"Start tidal lock 2\"\n",
+      "     5.7428   26.215   48.508 14   2          94.6     12.3d  0.10   0.000   0.917  \"End tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        94.599     12.3d  0.10   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7429   26.215   48.508 14   2          93.7     12.2d  0.00   0.000   1.010  \"BEG_SYMB\"\n",
+      "     5.7429   26.215   48.508 14   2          93.7     12.2d  0.00   0.000   1.010  \"Circularized\"\n",
+      "     5.7435   26.215   48.507 14   2        93.698     12.2d  0.00   0.000   1.582  \"Start tidal lock 2\"\n",
+      "     5.7449   26.215   48.394 14   2        94.053     12.2d  0.00   0.000   4.216  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.982 14   4        95.133     12.5d  0.00   0.000   8.198  \"TYPE_CHNGE\"\n",
+      "     5.7798   26.220   27.137 14   4        132.71     24.2d  0.00   0.000   7.318  \"Start Carbon Star 2\"\n",
+      "     5.7814   26.221   26.216 14   4        135.05     25.1d  0.00   0.000   7.371  \"q-inv\"\n",
+      "     5.7969   26.223   18.958 14   4        156.92     33.9d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7969   26.223   18.958 14   4        156.92     33.9d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8159   26.223   18.958 14   7        156.92     33.9d  0.00   0.000   0.026  \"TYPE_CHNGE\"\n",
+      "     5.8159   26.223   18.958 14   7        156.92     33.9d  0.00   0.000   0.026  \"Start tidal lock 2\"\n",
+      "     5.8159   26.223   18.958 14   7        156.92     33.9d  0.00   0.000   0.026  \"End Carbon Star 2\"\n",
+      "     6.1821   26.223   18.958 14  14        84.739     13.4d  0.95   0.000   0.000  Mers(5)=0.800814 - Mers(6)=0.799511 - Mers(7)=0.0183813 - Mers(8)=0.643482 - Mers(9)=0.687609 \n",
+      "     6.1821   26.223   18.958 14  14        84.739     13.4d  0.95   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9576 Mc\"CO\"=14.3043 type=8) -> kick 1(190) vk=356.223 vr=234.406 omega=4.32037 phi=0.291055 -> vn=90.2484 ; final sep 84.7387 ecc 0.948603 (random count 5) - Runaway v=(-34.2904,-174.065,-61.5609) |v|=187.788 : companion v=(-73.598,-102.142,-23.7897), |v|=128.123 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1821   26.223   18.958 14  14        84.739     13.4d  0.95   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1821   26.223   18.958 14  14        84.739     13.4d  0.95   0.000   0.000  \"SN\"\n",
+      "     6.1821   26.223   18.958 14  14        84.739     13.4d  0.95   0.000   0.000  \"End tidal lock 2\"\n",
+      "   234.5606   26.223   18.958 14  14       0.11213   0.0155h  0.00   0.002   0.002  Contact reached R/RL = 0.00313089 0.0026249, st 14 14\n",
+      "   234.5606   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.794619 - Mers(11)=0.367006 \n",
+      "   234.5606   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.1811 Mc\"CO\"=45.1811,\"BH\"=45.1811 type=14) -> kick 0(0) vk=0 vr=0 omega=2.30596 phi=0.630117 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(-73.598,-102.142,-23.7897) |v|=128.123 : companion v=(-34.2904,-174.065,-61.5609), |v|=187.788 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "   234.5606   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "   234.5606   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "   234.5606   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.181    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.986, 'K1': 14.0, 'K2': 14.0, 'separation': -68.037}\n",
+      "System 1 has separation -68.037\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -115.61}\n",
+      "System 2 has separation -115.61\n",
+      "system 3 / 100\n",
+      "{'time': 6.1828, 'M1': 26.222, 'M2': 18.908, 'K1': 14.0, 'K2': 14.0, 'separation': 97.291}\n",
+      "System 3 has separation 97.291\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=20264 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        73.643     8.47d  0.35   0.000   0.284  Randbuf=16915 - Mers(0)=0.12579 - Mers(1)=0.13859 - Mers(2)=0.629265 - Mers(3)=0.769857 - Mers(4)=0.911868 \n",
+      "     4.1327   26.215   48.508 14   1        73.643     8.47d  0.35   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=295.812 vr=401.272 omega=5.72944 phi=0.570096 -> vn=358.343 ; final sep 73.6433 ecc 0.347379 (random count 0) - Runaway v=(309.206,21.1014,-57.8666) |v|=315.282 : companion v=(-31.1287,-82.1762,-14.1004), |v|=88.9986 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        73.643     8.47d  0.35   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        73.643     8.47d  0.35   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        73.643     8.47d  0.35   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        80.913     9.75d  0.35   0.000   0.311  \"END_SYMB\"\n",
+      "     4.4343   26.215   48.508 14   1        86.691     10.8d  0.35   0.000   0.316  \"BEG_BSS \"\n",
+      "     5.7031   26.215   48.508 14   1        78.975      9.4d  0.13   0.000   0.759  \"Start tidal lock 2\"\n",
+      "     5.7239   26.215   48.508 14   1        78.542     9.33d  0.10   0.000   0.735  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        78.688     9.35d  0.09   0.000   0.573  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        78.688     9.35d  0.09   0.000   0.573  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        78.688     9.35d  0.09   0.000   0.573  \"END_BSS\"\n",
+      "     5.7425   26.215   48.508 14   2        78.688     9.35d  0.09   0.000   0.892  \"Start tidal lock 2\"\n",
+      "     5.7426   26.215   48.508 14   2        78.688     9.35d  0.09   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7426   26.215   48.508 14   2        78.016     9.23d  0.00   0.000   1.009  \"BEG_SYMB\"\n",
+      "     5.7426   26.215   48.508 14   2        78.016     9.23d  0.00   0.000   1.009  \"Circularized\"\n",
+      "     5.7434   26.215   48.506 14   2        78.023     9.23d  0.00   0.000   1.739  \"End tidal lock 2\"\n",
+      "     5.7446   26.215   48.399 14   2        78.348      9.3d  0.00   0.000   4.140  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.253 14   2         78.75     9.38d  0.00   0.000   5.790  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.778 14   4        79.763     9.59d  0.00   0.000   9.783  \"TYPE_CHNGE\"\n",
+      "     5.7727   26.219   27.136 14   4        110.86     18.5d  0.00   0.000   8.067  \"Start Carbon Star 2\"\n",
+      "     5.7741   26.219   26.209 14   4        112.83     19.2d  0.00   0.000   8.034  \"q-inv\"\n",
+      "     5.7890   26.222   18.908 14   4        131.23     25.9d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7891   26.222   18.908 14   4        131.23     25.9d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8078   26.222   18.908 14   7        131.23     25.9d  0.00   0.000   0.031  \"TYPE_CHNGE\"\n",
+      "     5.8078   26.222   18.908 14   7        131.23     25.9d  0.00   0.000   0.031  \"Start tidal lock 2\"\n",
+      "     5.8078   26.222   18.908 14   7        131.23     25.9d  0.00   0.000   0.031  \"End Carbon Star 2\"\n",
+      "     6.1828   26.222   18.908 14  14        97.291     16.5d  0.66   0.000   0.000  Mers(5)=0.526304 - Mers(6)=0.968786 - Mers(7)=0.711322 - Mers(8)=0.790433 - Mers(9)=0.627881 \n",
+      "     6.1828   26.222   18.908 14  14        97.291     16.5d  0.66   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9085 Mc\"CO\"=14.2663 type=8) -> kick 1(190) vk=551.978 vr=256.177 omega=3.94509 phi=0.619792 -> vn=206.714 ; final sep 97.2907 ecc 0.664895 (random count 5) - Runaway v=(-237.822,-290.215,-194.659) |v|=344.389 : companion v=(-127.261,-83.1918,-36.2166), |v|=156.294 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1828   26.222   18.908 14  14        97.291     16.5d  0.66   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1828   26.222   18.908 14  14        97.291     16.5d  0.66   0.000   0.000  \"SN\"\n",
+      "     6.1828   26.222   18.908 14  14        97.291     16.5d  0.66   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.222   18.908 14  14         85.99     13.7d  0.63   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -58.551}\n",
+      "System 1 has separation -58.551\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -258.11}\n",
+      "System 2 has separation -258.11\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -207.88}\n",
+      "System 5 has separation -207.88\n",
+      "system 6 / 100\n",
+      "{'time': 6.1872, 'M1': 26.258, 'M2': 18.63, 'K1': 14.0, 'K2': 14.0, 'separation': 135.33}\n",
+      "System 6 has separation 135.33\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=6659 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        58.767     6.04d  0.65   0.000   0.284  Randbuf=22946 - Mers(0)=0.207625 - Mers(1)=0.465874 - Mers(2)=0.474334 - Mers(3)=0.236615 - Mers(4)=0.929321 \n",
+      "     4.1327   26.215   48.508 14   1        58.767     6.04d  0.65   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=247.333 vr=401.272 omega=5.8391 phi=-0.554796 -> vn=281.774 ; final sep 58.7675 ecc 0.653916 (random count 0) - Runaway v=(238.261,55.972,33.9681) |v|=247.093 : companion v=(-8.0623,-79.0611,11.8934), |v|=80.3562 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        58.767     6.04d  0.65   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        58.767     6.04d  0.65   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        58.767     6.04d  0.65   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        66.889     7.33d  0.65   0.000   0.376  \"END_SYMB\"\n",
+      "     4.4265   26.215   48.508 14   1        54.897     5.45d  0.47   0.000   0.498  \"BEG_BSS \"\n",
+      "     4.6693   26.215   48.508 14   1        43.746     3.88d  0.11   0.000   0.679  \"Start tidal lock 2\"\n",
+      "     5.1815   26.215   48.508 14   1        42.867     3.76d  0.00   0.000   0.887  \"Circularized\"\n",
+      "     5.3474   26.215   48.508 14   1        42.612     3.73d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.3483   26.215   48.508 14   1        42.612     3.73d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7422   26.254   48.228 14   2        42.802     3.76d  0.00   0.000   1.052  \"OFF_MS\"\n",
+      "     5.7422   26.254   48.228 14   2        42.802     3.76d  0.00   0.000   1.052  \"TYPE_CHNGE\"\n",
+      "     5.7422   26.254   48.228 14   2        42.802     3.76d  0.00   0.000   1.052  \"END_BSS\"\n",
+      "     5.7422   26.254   48.228 14   2        42.802     3.76d  0.00   0.000   1.052  \"End tidal lock 2\"\n",
+      "     5.7449   26.254   47.873 14   2         44.01     3.93d  0.00   0.000   6.723  \"Start tidal lock 2\"\n",
+      "     5.7452   26.254   47.737 14   2        44.223     3.96d  0.00   0.000   7.873  \"End tidal lock 2\"\n",
+      "     5.7463   26.254   46.467 14   4        45.459     4.16d  0.00   0.000  16.882  \"TYPE_CHNGE\"\n",
+      "     5.7592   26.256   27.142 14   4        61.786     7.69d  0.00   0.000  13.218  \"Start Carbon Star 2\"\n",
+      "     5.7599   26.256   26.242 14   4        62.861     7.96d  0.00   0.000  13.014  \"q-inv\"\n",
+      "     5.7696   26.258   18.630 14   4        73.603     10.9d  0.00   0.000   0.995  \"END_RCHE 2!>1\"\n",
+      "     5.7697   26.258   18.630 14   4        73.603     10.9d  0.00   0.000   0.988  \"END_SYMB\"\n",
+      "     5.7865   26.258   18.630 14   7        73.601     10.9d  0.00   0.000   0.054  \"TYPE_CHNGE\"\n",
+      "     5.7865   26.258   18.630 14   7        73.601     10.9d  0.00   0.000   0.054  \"End Carbon Star 2\"\n",
+      "     5.9058   26.258   18.630 14   7        73.601     10.9d  0.00   0.000   0.056  \"Start tidal lock 2\"\n",
+      "     6.1488   26.258   18.630 14   7        73.601     10.9d  0.00   0.000   0.055  \"End tidal lock 2\"\n",
+      "     6.1871   26.258   18.630 14   8        73.601     10.9d  0.00   0.000   0.053  \"TYPE_CHNGE\"\n",
+      "     6.1872   26.258   18.630 14  14        135.33     27.2d  0.54   0.000   0.000  Mers(5)=0.983953 - Mers(6)=0.334863 - Mers(7)=0.952341 - Mers(8)=0.557542 - Mers(9)=0.975828 \n",
+      "     6.1872   26.258   18.630 14  14        135.33     27.2d  0.54   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.6301 Mc\"CO\"=14.0511 type=8) -> kick 1(190) vk=294.899 vr=341.153 omega=6.13131 phi=0.115339 -> vn=411.673 ; final sep 135.333 ecc 0.535984 (random count 5) - Runaway v=(341.369,-21.2964,7.90828) |v|=354.196 : companion v=(-41.0994,-72.4298,-0.815588), |v|=83.2821 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1872   26.258   18.630 14  14        135.33     27.2d  0.54   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1872   26.258   18.630 14  14        135.33     27.2d  0.54   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.258   18.630 14  14        133.95     26.8d  0.53   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -38.978}\n",
+      "System 1 has separation -38.978\n",
+      "system 2 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.984, 'K1': 14.0, 'K2': 14.0, 'separation': 1095.9}\n",
+      "System 2 has separation 1095.9\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=56166 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         88.07     11.1d  0.01   0.000   0.284  Randbuf=68190 - Mers(0)=0.444777 - Mers(1)=0.0908102 - Mers(2)=0.51028 - Mers(3)=0.00364866 - Mers(4)=0.969388 \n",
+      "     4.1327   26.215   48.508 14   1         88.07     11.1d  0.01   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=84.4264 vr=401.272 omega=6.09085 phi=-1.44991 -> vn=400.159 ; final sep 88.0696 ecc 0.0073718 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         88.07     11.1d  0.01   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         88.07     11.1d  0.01   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         88.07     11.1d  0.01   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1          95.5     12.5d  0.01   0.000   0.264  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        100.43     13.5d  0.01   0.000   0.278  \"BEG_BSS \"\n",
+      "     5.6489   26.215   48.508 14   1        103.82     14.2d  0.01   0.000   0.542  \"Start tidal lock 2\"\n",
+      "     5.7383   26.215   48.508 14   1        103.85     14.2d  0.01   0.000   0.476  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   0.435  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   0.435  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   0.435  \"END_BSS\"\n",
+      "     5.7426   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   0.746  \"Start tidal lock 2\"\n",
+      "     5.7427   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   0.820  \"End tidal lock 2\"\n",
+      "     5.7430   26.215   48.508 14   2        103.85     14.2d  0.01   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7430   26.215   48.508 14   2        103.84     14.2d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7430   26.215   48.508 14   2        103.84     14.2d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.7459   26.215   48.075 14   4        105.03     14.5d  0.00   0.000   7.423  \"TYPE_CHNGE\"\n",
+      "     5.7844   26.221   27.159 14   4        146.63     28.1d  0.00   0.000   7.131  \"Start Carbon Star 2\"\n",
+      "     5.7860   26.221   26.205 14   4        149.31     29.2d  0.00   0.000   7.246  \"q-inv\"\n",
+      "     5.8011   26.224   18.984 14   4        173.34     39.3d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8011   26.224   18.984 14   4        173.34     39.3d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8208   26.224   18.984 14   7        173.34     39.3d  0.00   0.000   0.023  \"TYPE_CHNGE\"\n",
+      "     5.8208   26.224   18.984 14   7        173.34     39.3d  0.00   0.000   0.023  \"Start tidal lock 2\"\n",
+      "     5.8208   26.224   18.984 14   7        173.34     39.3d  0.00   0.000   0.023  \"End Carbon Star 2\"\n",
+      "     5.9564   26.224   18.984 14   7        173.34     39.3d  0.00   0.000   0.024  \"End tidal lock 2\"\n",
+      "     6.1182   26.224   18.984 14   7        173.34     39.3d  0.00   0.000   0.024  \"Start tidal lock 2\"\n",
+      "     6.1817   26.224   18.984 14  14        1095.9     1.71y  0.88   0.000   0.000  Mers(5)=0.246807 - Mers(6)=0.271729 - Mers(7)=0.514522 - Mers(8)=0.30625 - Mers(9)=0.0417865 \n",
+      "     6.1817   26.224   18.984 14  14        1095.9     1.71y  0.88   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9837 Mc\"CO\"=14.3244 type=8) -> kick 1(190) vk=217.978 vr=223.094 omega=0.262552 phi=-0.397918 -> vn=302.77 ; final sep 1095.86 ecc 0.88405 (random count 5) - Runaway v=(240.289,109.74,-16.8856) |v|=264.702 : companion v=(-21.5589,-41.686,-3.64655), |v|=47.0724 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1817   26.224   18.984 14  14        1095.9     1.71y  0.88   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1817   26.224   18.984 14  14        1095.9     1.71y  0.88   0.000   0.000  \"SN\"\n",
+      "     6.1817   26.224   18.984 14  14        1095.9     1.71y  0.88   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.984 14  14        1095.5     1.71y  0.88   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -681.62}\n",
+      "System 1 has separation -681.62\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -105.08}\n",
+      "System 2 has separation -105.08\n",
+      "system 3 / 100\n",
+      "{'time': 6.1855, 'M1': 26.246, 'M2': 18.733, 'K1': 14.0, 'K2': 14.0, 'separation': 269.89}\n",
+      "System 3 has separation 269.89\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=76653 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        60.711     6.34d  0.63   0.000   0.284  Randbuf=10941 - Mers(0)=0.361066 - Mers(1)=0.26987 - Mers(2)=0.217514 - Mers(3)=0.419145 - Mers(4)=0.123808 \n",
+      "     4.1327   26.215   48.508 14   1        60.711     6.34d  0.63   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=206.433 vr=401.272 omega=0.777909 phi=-0.162423 -> vn=295.238 ; final sep 60.7114 ecc 0.628911 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        60.711     6.34d  0.63   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        60.711     6.34d  0.63   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        60.711     6.34d  0.63   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        68.734     7.63d  0.63   0.000   0.366  \"END_SYMB\"\n",
+      "     4.4694   26.215   48.508 14   1        66.793     7.31d  0.56   0.000   0.415  \"BEG_BSS \"\n",
+      "     4.8806   26.215   48.508 14   1        47.283     4.36d  0.11   0.000   0.686  \"Start tidal lock 2\"\n",
+      "     5.3423   26.215   48.508 14   1        46.267     4.22d  0.00   0.000   0.917  \"Circularized\"\n",
+      "     5.4445   26.215   48.508 14   1        46.068     4.19d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.4454   26.215   48.508 14   1        46.068     4.19d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7420   26.241   48.404 14   2        46.094     4.19d  0.00   0.000   0.978  \"OFF_MS\"\n",
+      "     5.7420   26.241   48.404 14   2        46.094     4.19d  0.00   0.000   0.978  \"TYPE_CHNGE\"\n",
+      "     5.7420   26.241   48.404 14   2        46.094     4.19d  0.00   0.000   0.978  \"END_BSS\"\n",
+      "     5.7420   26.241   48.404 14   2        46.094     4.19d  0.00   0.000   0.978  \"END_RCHE 2!>1\"\n",
+      "     5.7420   26.241   48.404 14   2        46.094     4.19d  0.00   0.000   0.978  \"End tidal lock 2\"\n",
+      "     5.7420   26.241   48.404 14   2        46.111      4.2d  0.00   0.000   0.980  \"END_SYMB\"\n",
+      "     5.7420   26.241   48.404 14   2        46.117      4.2d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7420   26.241   48.404 14   2        46.118      4.2d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7447   26.242   48.055 14   2         47.41     4.39d  0.00   0.000   6.665  \"Start tidal lock 2\"\n",
+      "     5.7450   26.242   47.920 14   2        47.635     4.42d  0.00   0.000   7.819  \"End tidal lock 2\"\n",
+      "     5.7460   26.242   46.802 14   4        48.838     4.62d  0.00   0.000  15.904  \"TYPE_CHNGE\"\n",
+      "     5.7601   26.244   27.150 14   4        66.714     8.63d  0.00   0.000  12.429  \"Start Carbon Star 2\"\n",
+      "     5.7609   26.244   26.217 14   4        67.913     8.95d  0.00   0.000  12.236  \"q-inv\"\n",
+      "     5.7711   26.246   18.733 14   4          79.3     12.2d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7711   26.246   18.733 14   4        79.299     12.2d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.7886   26.246   18.733 14   7        79.298     12.2d  0.00   0.000   0.050  \"TYPE_CHNGE\"\n",
+      "     5.7886   26.246   18.733 14   7        79.298     12.2d  0.00   0.000   0.050  \"End Carbon Star 2\"\n",
+      "     5.8855   26.246   18.733 14   7        79.298     12.2d  0.00   0.000   0.051  \"Start tidal lock 2\"\n",
+      "     6.1498   26.246   18.733 14   7        79.298     12.2d  0.00   0.000   0.051  \"End tidal lock 2\"\n",
+      "     6.1855   26.246   18.733 14  14        269.89     76.6d  0.81   0.000   0.000  Mers(5)=0.340085 - Mers(6)=0.703408 - Mers(7)=0.958901 - Mers(8)=0.805378 - Mers(9)=0.76236 \n",
+      "     6.1855   26.246   18.733 14  14        269.89     76.6d  0.81   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.7333 Mc\"CO\"=14.1308 type=8) -> kick 1(190) vk=297.427 vr=329.003 omega=4.79005 phi=0.657015 -> vn=429.748 ; final sep 269.892 ecc 0.805198 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1855   26.246   18.733 14  14        269.89     76.6d  0.81   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1855   26.246   18.733 14  14        269.89     76.6d  0.81   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.246   18.733 14  14        266.49     75.1d  0.80   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -39.356}\n",
+      "System 2 has separation -39.356\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -119.51}\n",
+      "System 3 has separation -119.51\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -112.9}\n",
+      "System 5 has separation -112.9\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -587.37}\n",
+      "System 7 has separation -587.37\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -41.43}\n",
+      "System 8 has separation -41.43\n",
+      "system 9 / 100\n",
+      "{'time': 6.1826, 'M1': 26.223, 'M2': 18.926, 'K1': 14.0, 'K2': 14.0, 'separation': -31.116}\n",
+      "System 9 has separation -31.116\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -480.98}\n",
+      "System 11 has separation -480.98\n",
+      "system 12 / 100\n",
+      "{'time': 6.1818, 'M1': 26.224, 'M2': 18.977, 'K1': 14.0, 'K2': 14.0, 'separation': 203.04}\n",
+      "System 12 has separation 203.04\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=26444 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        85.918     10.7d  0.06   0.000   0.284  Randbuf=48053 - Mers(0)=0.993937 - Mers(1)=0.0101775 - Mers(2)=0.0795149 - Mers(3)=0.0784984 - Mers(4)=0.188002 \n",
+      "     4.1327   26.215   48.508 14   1        85.918     10.7d  0.06   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=39.8728 vr=401.272 omega=1.18125 phi=-1.00284 -> vn=395.06 ; final sep 85.9178 ecc 0.0588549 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        85.918     10.7d  0.06   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        85.918     10.7d  0.06   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        85.918     10.7d  0.06   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        93.271     12.1d  0.06   0.000   0.270  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        98.181       13d  0.06   0.000   0.284  \"BEG_BSS \"\n",
+      "     5.6219   26.215   48.508 14   1        101.55     13.7d  0.06   0.000   0.538  \"Start tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   1        101.49     13.7d  0.06   0.000   0.457  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   0.445  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   0.445  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   0.445  \"END_BSS\"\n",
+      "     5.7426   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   0.753  \"Start tidal lock 2\"\n",
+      "     5.7428   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   0.843  \"End tidal lock 2\"\n",
+      "     5.7430   26.215   48.508 14   2        101.49     13.7d  0.06   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7430   26.215   48.508 14   2        101.14     13.6d  0.00   0.000   1.004  \"BEG_SYMB\"\n",
+      "     5.7430   26.215   48.508 14   2        101.14     13.6d  0.00   0.000   1.004  \"Circularized\"\n",
+      "     5.7459   26.215   48.053 14   4        102.39     13.9d  0.00   0.000   7.615  \"TYPE_CHNGE\"\n",
+      "     5.7832   26.221   27.146 14   4        142.92     27.1d  0.00   0.000   7.163  \"Start Carbon Star 2\"\n",
+      "     5.7848   26.221   26.206 14   4         145.5     28.1d  0.00   0.000   7.260  \"q-inv\"\n",
+      "     5.8001   26.224   18.977 14   4        168.95     37.8d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.8001   26.224   18.977 14   4        168.95     37.8d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8190   26.224   18.977 14   7        168.95     37.8d  0.00   0.000   0.024  \"TYPE_CHNGE\"\n",
+      "     5.8190   26.224   18.977 14   7        168.95     37.8d  0.00   0.000   0.024  \"Start tidal lock 2\"\n",
+      "     5.8190   26.224   18.977 14   7        168.95     37.8d  0.00   0.000   0.024  \"End Carbon Star 2\"\n",
+      "     5.9809   26.224   18.977 14   7        168.95     37.8d  0.00   0.000   0.025  \"End tidal lock 2\"\n",
+      "     6.1077   26.224   18.977 14   7        168.95     37.8d  0.00   0.000   0.025  \"Start tidal lock 2\"\n",
+      "     6.1818   26.224   18.977 14  14        203.04     49.8d  0.30   0.000   0.000  Mers(5)=0.809955 - Mers(6)=0.0702806 - Mers(7)=0.323565 - Mers(8)=0.23574 - Mers(9)=0.7327 \n",
+      "     6.1818   26.224   18.977 14  14        203.04     49.8d  0.30   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9771 Mc\"CO\"=14.3193 type=8) -> kick 1(190) vk=74.0934 vr=225.956 omega=4.60369 phi=-0.556855 -> vn=244.191 ; final sep 203.043 ecc 0.303178 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1818   26.224   18.977 14  14        203.04     49.8d  0.30   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1818   26.224   18.977 14  14        203.04     49.8d  0.30   0.000   0.000  \"SN\"\n",
+      "     6.1818   26.224   18.977 14  14        203.04     49.8d  0.30   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.977 14  14        202.92     49.8d  0.30   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1826, 'M1': 26.223, 'M2': 18.921, 'K1': 14.0, 'K2': 14.0, 'separation': -65.378}\n",
+      "System 1 has separation -65.378\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -41.082}\n",
+      "System 2 has separation -41.082\n",
+      "system 3 / 100\n",
+      "{'time': 6.1807, 'M1': 26.226, 'M2': 19.061, 'K1': 14.0, 'K2': 14.0, 'separation': 1808.4}\n",
+      "System 3 has separation 1808.4\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=20374 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        162.25     27.7d  0.45   0.000   0.284  Randbuf=18169 - Mers(0)=0.878478 - Mers(1)=0.228654 - Mers(2)=0.532549 - Mers(3)=0.0475214 - Mers(4)=0.507573 \n",
+      "     4.1327   26.215   48.508 14   1        162.25     27.7d  0.45   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=149.17 vr=401.272 omega=3.18918 phi=-1.13128 -> vn=483.893 ; final sep 162.25 ecc 0.454224 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        162.25     27.7d  0.45   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        162.25     27.7d  0.45   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        162.25     27.7d  0.45   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        173.53     30.6d  0.45   0.000   0.145  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        180.82     32.6d  0.45   0.000   0.154  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        183.09     33.2d  0.46   0.000   0.246  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        183.09     33.2d  0.46   0.000   0.246  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        183.09     33.2d  0.46   0.000   0.246  \"END_BSS\"\n",
+      "     5.7438   26.215   48.508 14   2        184.62     33.6d  0.46   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7438   26.215   48.508 14   2        145.96     23.6d  0.00   0.000   1.266  \"BEG_SYMB\"\n",
+      "     5.7438   26.215   48.508 14   2        145.96     23.6d  0.00   0.000   1.266  \"Circularized\"\n",
+      "     5.7459   26.215   48.302 14   4        147.46       24d  0.00   0.000   5.284  \"TYPE_CHNGE\"\n",
+      "     5.7460   26.215   48.269 14   4        147.68     24.1d  0.00   0.000   5.276  \"Start tidal lock 2\"\n",
+      "     5.7463   26.215   48.160 14   4        148.23     24.2d  0.00   0.000   5.258  \"End tidal lock 2\"\n",
+      "     5.8011   26.223   27.165 14   4        208.26     47.6d  0.00   0.000   7.985  \"Start Carbon Star 2\"\n",
+      "     5.8025   26.223   26.220 14   4        212.03     49.4d  0.00   0.000   8.326  \"q-inv\"\n",
+      "     5.8141   26.226   19.061 14   4        245.75     66.3d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.8141   26.226   19.061 14   4        245.75     66.3d  0.00   0.000   0.995  \"END_SYMB\"\n",
+      "     5.8336   26.226   19.061 14   7        245.75     66.3d  0.00   0.000   0.016  \"TYPE_CHNGE\"\n",
+      "     5.8336   26.226   19.061 14   7        245.75     66.3d  0.00   0.000   0.016  \"End Carbon Star 2\"\n",
+      "     6.1807   26.226   19.061 14  14        1808.4     3.62y  0.86   0.000   0.000  Mers(5)=0.909678 - Mers(6)=0.222289 - Mers(7)=0.310135 - Mers(8)=0.288769 - Mers(9)=0.920915 \n",
+      "     6.1807   26.226   19.061 14  14        1808.4     3.62y  0.86   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0615 Mc\"CO\"=14.3845 type=8) -> kick 1(190) vk=192.777 vr=187.527 omega=5.78628 phi=-0.43616 -> vn=256.035 ; final sep 1808.4 ecc 0.864574 (random count 5) - Runaway v=(218.491,-26.6742,32.3455) |v|=222.477 : companion v=(-35.6356,-41.1535,4.70848), |v|=54.6414 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1807   26.226   19.061 14  14        1808.4     3.62y  0.86   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1807   26.226   19.061 14  14        1808.4     3.62y  0.86   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.226   19.061 14  14        1808.4     3.62y  0.86   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -108.69}\n",
+      "System 1 has separation -108.69\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -99.661}\n",
+      "System 2 has separation -99.661\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -161.43}\n",
+      "System 3 has separation -161.43\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1823, 'M1': 26.223, 'M2': 18.942, 'K1': 14.0, 'K2': 14.0, 'separation': -56.426}\n",
+      "System 6 has separation -56.426\n",
+      "system 7 / 100\n",
+      "{'time': 6.1826, 'M1': 26.223, 'M2': 18.922, 'K1': 14.0, 'K2': 14.0, 'separation': -35.461}\n",
+      "System 7 has separation -35.461\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.994, 'K1': 14.0, 'K2': 14.0, 'separation': 150.6}\n",
+      "System 10 has separation 150.6\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=32165 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        92.553     11.9d  0.06   0.000   0.284  Randbuf=16351 - Mers(0)=0.73028 - Mers(1)=0.0886393 - Mers(2)=0.604072 - Mers(3)=0.989634 - Mers(4)=0.75904 \n",
+      "     4.1327   26.215   48.508 14   1        92.553     11.9d  0.06   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=88.1161 vr=401.272 omega=4.76919 phi=1.36682 -> vn=409.842 ; final sep 92.5531 ecc 0.0612441 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        92.553     11.9d  0.06   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        92.553     11.9d  0.06   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        92.553     11.9d  0.06   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        100.18     13.4d  0.06   0.000   0.251  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        105.21     14.5d  0.06   0.000   0.265  \"BEG_BSS \"\n",
+      "     5.7032   26.215   48.508 14   1        108.72     15.2d  0.06   0.000   0.551  \"Start tidal lock 2\"\n",
+      "     5.7272   26.215   48.508 14   1        108.75     15.2d  0.06   0.000   0.519  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   0.415  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   0.415  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   0.415  \"END_BSS\"\n",
+      "     5.7427   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   0.734  \"Start tidal lock 2\"\n",
+      "     5.7428   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   0.815  \"End tidal lock 2\"\n",
+      "     5.7431   26.215   48.508 14   2        108.77     15.2d  0.06   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7431   26.215   48.508 14   2        108.33     15.1d  0.00   0.000   1.005  \"BEG_SYMB\"\n",
+      "     5.7431   26.215   48.508 14   2        108.33     15.1d  0.00   0.000   1.005  \"Circularized\"\n",
+      "     5.7459   26.215   48.110 14   4        109.47     15.4d  0.00   0.000   7.121  \"TYPE_CHNGE\"\n",
+      "     5.7864   26.221   27.163 14   4        152.93       30d  0.00   0.000   7.107  \"Start Carbon Star 2\"\n",
+      "     5.7880   26.221   26.204 14   4        155.75     31.1d  0.00   0.000   7.251  \"q-inv\"\n",
+      "     5.8028   26.224   18.994 14   4        180.76     41.9d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.8029   26.224   18.994 14   4        180.76     41.9d  0.00   0.000   0.995  \"END_SYMB\"\n",
+      "     5.8222   26.224   18.994 14   7        180.76     41.9d  0.00   0.000   0.022  \"TYPE_CHNGE\"\n",
+      "     5.8222   26.224   18.994 14   7        180.76     41.9d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     5.8222   26.224   18.994 14   7        180.76     41.9d  0.00   0.000   0.022  \"End Carbon Star 2\"\n",
+      "     5.9227   26.224   18.994 14   7        180.76     41.9d  0.00   0.000   0.023  \"End tidal lock 2\"\n",
+      "     6.1369   26.224   18.994 14   7        180.76     41.9d  0.00   0.000   0.023  \"Start tidal lock 2\"\n",
+      "     6.1816   26.224   18.994 14  14         150.6     31.8d  0.20   0.000   0.000  Mers(5)=0.887567 - Mers(6)=0.042006 - Mers(7)=0.891927 - Mers(8)=0.0541357 - Mers(9)=0.995708 \n",
+      "     6.1816   26.224   18.994 14  14         150.6     31.8d  0.20   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9942 Mc\"CO\"=14.3325 type=8) -> kick 1(190) vk=84.3435 vr=218.493 omega=6.25622 phi=-1.10115 -> vn=195.394 ; final sep 150.597 ecc 0.200331 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1816   26.224   18.994 14  14         150.6     31.8d  0.20   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1816   26.224   18.994 14  14         150.6     31.8d  0.20   0.000   0.000  \"SN\"\n",
+      "     6.1816   26.224   18.994 14  14         150.6     31.8d  0.20   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.994 14  14        150.38     31.8d  0.20   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1862, 'M1': 26.252, 'M2': 18.69, 'K1': 14.0, 'K2': 14.0, 'separation': 89.423}\n",
+      "System 1 has separation 89.423\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=54738 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        58.337     5.97d  0.63   0.000   0.284  Randbuf=60197 - Mers(0)=0.435262 - Mers(1)=0.169567 - Mers(2)=0.149304 - Mers(3)=0.930537 - Mers(4)=0.857649 \n",
+      "     4.1327   26.215   48.508 14   1        58.337     5.97d  0.63   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=298.104 vr=401.272 omega=5.38877 phi=1.03738 -> vn=278.577 ; final sep 58.3367 ecc 0.63053 (random count 0) - Runaway v=(220.808,34.5258,-123.123) |v|=255.162 : companion v=(-18.4844,-82.5408,-41.6418), |v|=94.2799 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        58.337     5.97d  0.63   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        58.337     5.97d  0.63   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        58.337     5.97d  0.63   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        66.219     7.22d  0.63   0.000   0.380  \"END_SYMB\"\n",
+      "     4.4387   26.215   48.508 14   1        60.504     6.31d  0.52   0.000   0.454  \"BEG_BSS \"\n",
+      "     4.7651   26.215   48.508 14   1        45.536     4.12d  0.12   0.000   0.678  \"Start tidal lock 2\"\n",
+      "     5.2653   26.215   48.508 14   1        44.544     3.98d  0.00   0.000   0.902  \"Circularized\"\n",
+      "     5.3977   26.215   48.508 14   1        44.315     3.95d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.3981   26.215   48.508 14   1        44.315     3.95d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7421   26.247   48.332 14   2        44.415     3.97d  0.00   0.000   1.014  \"OFF_MS\"\n",
+      "     5.7421   26.247   48.332 14   2        44.415     3.97d  0.00   0.000   1.014  \"TYPE_CHNGE\"\n",
+      "     5.7421   26.247   48.332 14   2        44.415     3.97d  0.00   0.000   1.014  \"END_BSS\"\n",
+      "     5.7421   26.247   48.332 14   2        44.415     3.97d  0.00   0.000   1.014  \"End tidal lock 2\"\n",
+      "     5.7448   26.248   47.980 14   2        45.677     4.15d  0.00   0.000   6.698  \"Start tidal lock 2\"\n",
+      "     5.7450   26.248   47.842 14   2        45.899     4.18d  0.00   0.000   7.869  \"End tidal lock 2\"\n",
+      "     5.7461   26.248   46.651 14   4        47.112     4.39d  0.00   0.000  16.407  \"TYPE_CHNGE\"\n",
+      "     5.7596   26.250   27.145 14   4        64.217     8.15d  0.00   0.000  12.828  \"Start Carbon Star 2\"\n",
+      "     5.7603   26.250   26.232 14   4        65.347     8.44d  0.00   0.000  12.630  \"q-inv\"\n",
+      "     5.7703   26.252   18.690 14   4        76.398     11.5d  0.00   0.000   1.000  \"END_RCHE 2!>1\"\n",
+      "     5.7703   26.252   18.690 14   4        76.398     11.5d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.7873   26.252   18.690 14   7        76.396     11.5d  0.00   0.000   0.052  \"TYPE_CHNGE\"\n",
+      "     5.7873   26.252   18.690 14   7        76.396     11.5d  0.00   0.000   0.052  \"End Carbon Star 2\"\n",
+      "     5.8976   26.252   18.690 14   7        76.396     11.5d  0.00   0.000   0.054  \"Start tidal lock 2\"\n",
+      "     6.1490   26.252   18.690 14   7        76.396     11.5d  0.00   0.000   0.053  \"End tidal lock 2\"\n",
+      "     6.1862   26.252   18.690 14  14        89.423     14.6d  0.54   0.000   0.000  Mers(5)=0.234751 - Mers(6)=0.380025 - Mers(7)=0.083539 - Mers(8)=0.503604 - Mers(9)=0.774412 \n",
+      "     6.1862   26.252   18.690 14  14        89.423     14.6d  0.54   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.6898 Mc\"CO\"=14.0972 type=8) -> kick 1(190) vk=188.938 vr=335.053 omega=4.86578 phi=0.00720714 -> vn=358.629 ; final sep 89.4234 ecc 0.535286 (random count 5) - Runaway v=(-18.4844,-82.5408,-41.6418) |v|=94.2799 : companion v=(220.808,34.5258,-123.123), |v|=255.162 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1862   26.252   18.690 14  14        89.423     14.6d  0.54   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1862   26.252   18.690 14  14        89.423     14.6d  0.54   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.252   18.690 14  14        84.604     13.4d  0.52   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1822, 'M1': 26.223, 'M2': 18.952, 'K1': 14.0, 'K2': 14.0, 'separation': -81.832}\n",
+      "System 1 has separation -81.832\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -50.067}\n",
+      "System 3 has separation -50.067\n",
+      "system 4 / 100\n",
+      "{'time': 6.1811, 'M1': 26.225, 'M2': 19.035, 'K1': 14.0, 'K2': 14.0, 'separation': -35.253}\n",
+      "System 4 has separation -35.253\n",
+      "system 5 / 100\n",
+      "{'time': 6.2821, 'M1': 26.394, 'M2': 15.122, 'K1': 14.0, 'K2': 14.0, 'separation': -105.34}\n",
+      "System 5 has separation -105.34\n",
+      "system 6 / 100\n",
+      "{'time': 6.1823, 'M1': 26.223, 'M2': 18.947, 'K1': 14.0, 'K2': 14.0, 'separation': 81.367}\n",
+      "System 6 has separation 81.367\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=32526 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        81.656     9.89d  0.28   0.000   0.284  Randbuf=21738 - Mers(0)=0.944307 - Mers(1)=0.234844 - Mers(2)=0.867951 - Mers(3)=0.737257 - Mers(4)=0.920017 \n",
+      "     4.1327   26.215   48.508 14   1        81.656     9.89d  0.28   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=305.679 vr=401.272 omega=5.78064 phi=0.494413 -> vn=383.939 ; final sep 81.6556 ecc 0.276043 (random count 0) - Runaway v=(333.101,20.265,-49.4756) |v|=337.364 : companion v=(-35.244,-80.9905,-11.0183), |v|=89.0112 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        81.656     9.89d  0.28   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        81.656     9.89d  0.28   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        81.656     9.89d  0.28   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        89.111     11.3d  0.28   0.000   0.283  \"END_SYMB\"\n",
+      "     4.4837   26.215   48.508 14   1        94.381     12.3d  0.28   0.000   0.295  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        94.091     12.2d  0.22   0.000   0.480  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        94.091     12.2d  0.22   0.000   0.480  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        94.091     12.2d  0.22   0.000   0.480  \"END_BSS\"\n",
+      "     5.7428   26.215   48.508 14   2         94.09     12.2d  0.22   0.000   0.933  \"Start tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        94.087     12.2d  0.22   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7429   26.215   48.508 14   2        89.565     11.4d  0.00   0.000   1.051  \"BEG_SYMB\"\n",
+      "     5.7429   26.215   48.508 14   2        89.565     11.4d  0.00   0.000   1.051  \"Circularized\"\n",
+      "     5.7433   26.215   48.508 14   2        89.567     11.4d  0.00   0.000   1.393  \"End tidal lock 2\"\n",
+      "     5.7450   26.215   48.374 14   2         90.05     11.5d  0.00   0.000   4.475  \"Start tidal lock 2\"\n",
+      "     5.7454   26.215   48.239 14   2        90.475     11.5d  0.00   0.000   5.927  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.937 14   4        91.264     11.7d  0.00   0.000   8.546  \"TYPE_CHNGE\"\n",
+      "     5.7780   26.220   27.152 14   4        127.29     22.8d  0.00   0.000   7.444  \"Start Carbon Star 2\"\n",
+      "     5.7796   26.220   26.214 14   4        129.59     23.6d  0.00   0.000   7.476  \"q-inv\"\n",
+      "     5.7951   26.223   18.947 14   4         150.6     31.8d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7951   26.223   18.947 14   4         150.6     31.8d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8140   26.223   18.947 14   7         150.6     31.8d  0.00   0.000   0.027  \"TYPE_CHNGE\"\n",
+      "     5.8140   26.223   18.947 14   7         150.6     31.8d  0.00   0.000   0.027  \"Start tidal lock 2\"\n",
+      "     5.8140   26.223   18.947 14   7         150.6     31.8d  0.00   0.000   0.027  \"End Carbon Star 2\"\n",
+      "     6.1823   26.223   18.947 14  14        81.367     12.6d  0.88   0.000   0.000  Mers(5)=0.0147146 - Mers(6)=0.720972 - Mers(7)=0.378708 - Mers(8)=0.214955 - Mers(9)=0.279645 \n",
+      "     6.1823   26.223   18.947 14  14        81.367     12.6d  0.88   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9465 Mc\"CO\"=14.2957 type=8) -> kick 1(190) vk=304.563 vr=239.241 omega=1.75706 phi=-0.606616 -> vn=92.3865 ; final sep 81.3671 ecc 0.883486 (random count 5) - Runaway v=(-93.8667,46.4295,-49.9581) |v|=145.564 : companion v=(1.60508,85.5996,-95.1442), |v|=127.993 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1823   26.223   18.947 14  14        81.367     12.6d  0.88   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1823   26.223   18.947 14  14        81.367     12.6d  0.88   0.000   0.000  \"SN\"\n",
+      "     6.1823   26.223   18.947 14  14        81.367     12.6d  0.88   0.000   0.000  \"End tidal lock 2\"\n",
+      "  2494.7992   26.223   18.947 14  14       0.11303   0.0157h  0.00   0.002   0.002  Contact reached R/RL = 0.00307837 0.00258006, st 14 14\n",
+      "  2494.7992   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.789451 - Mers(11)=0.0120857 \n",
+      "  2494.7992   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.1697 Mc\"CO\"=45.1697,\"BH\"=45.1697 type=14) -> kick 0(0) vk=0 vr=0 omega=0.0759366 phi=0.617381 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(1.60508,85.5996,-95.1442) |v|=127.993 : companion v=(-93.8667,46.4295,-49.9581), |v|=145.564 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "  2494.7992   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "  2494.7992   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "  2494.7992   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.170    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.022, 'K1': 14.0, 'K2': 14.0, 'separation': -53.365}\n",
+      "System 1 has separation -53.365\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1832, 'M1': 26.222, 'M2': 18.884, 'K1': 14.0, 'K2': 14.0, 'separation': -36.222}\n",
+      "System 3 has separation -36.222\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -37.896}\n",
+      "System 4 has separation -37.896\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1818, 'M1': 26.224, 'M2': 18.982, 'K1': 14.0, 'K2': 14.0, 'separation': -39.411}\n",
+      "System 6 has separation -39.411\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -736.84}\n",
+      "System 7 has separation -736.84\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -113.55}\n",
+      "System 8 has separation -113.55\n",
+      "system 9 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -267.16}\n",
+      "System 9 has separation -267.16\n",
+      "system 10 / 100\n",
+      "{'time': 6.1806, 'M1': 26.226, 'M2': 19.068, 'K1': 14.0, 'K2': 14.0, 'separation': -45.072}\n",
+      "System 10 has separation -45.072\n",
+      "system 11 / 100\n",
+      "None\n",
+      "system 12 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -33.83}\n",
+      "System 12 has separation -33.83\n",
+      "system 13 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.011, 'K1': 14.0, 'K2': 14.0, 'separation': -40.814}\n",
+      "System 13 has separation -40.814\n",
+      "system 14 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.056, 'K1': 14.0, 'K2': 14.0, 'separation': -63.749}\n",
+      "System 14 has separation -63.749\n",
+      "system 15 / 100\n",
+      "None\n",
+      "system 16 / 100\n",
+      "None\n",
+      "system 17 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -163.79}\n",
+      "System 17 has separation -163.79\n",
+      "system 18 / 100\n",
+      "None\n",
+      "system 19 / 100\n",
+      "{'time': 6.2319, 'M1': 26.341, 'M2': 16.686, 'K1': 14.0, 'K2': 14.0, 'separation': -31.604}\n",
+      "System 19 has separation -31.604\n",
+      "system 20 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -340.11}\n",
+      "System 20 has separation -340.11\n",
+      "system 21 / 100\n",
+      "None\n",
+      "system 22 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -74.781}\n",
+      "System 22 has separation -74.781\n",
+      "system 23 / 100\n",
+      "{'time': 6.1821, 'M1': 26.223, 'M2': 18.96, 'K1': 14.0, 'K2': 14.0, 'separation': -90.943}\n",
+      "System 23 has separation -90.943\n",
+      "system 24 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.054, 'K1': 14.0, 'K2': 14.0, 'separation': -29.262}\n",
+      "System 24 has separation -29.262\n",
+      "system 25 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -1547.5}\n",
+      "System 25 has separation -1547.5\n",
+      "system 26 / 100\n",
+      "{'time': 6.2254, 'M1': 26.333, 'M2': 16.925, 'K1': 14.0, 'K2': 14.0, 'separation': 35.28}\n",
+      "System 26 has separation 35.28\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=65328 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        95.586     12.5d  0.87   0.000   0.284  Randbuf=27164 - Mers(0)=0.842379 - Mers(1)=0.721781 - Mers(2)=0.803069 - Mers(3)=0.617927 - Mers(4)=0.122825 \n",
+      "     4.1327   26.215   48.508 14   1        95.586     12.5d  0.87   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=357.843 vr=401.272 omega=0.771729 phi=0.238098 -> vn=415.763 ; final sep 95.586 ecc 0.87195 (random count 0) - Runaway v=(221.95,320.219,32.4586) |v|=390.968 : companion v=(18.6542,-41.9951,14.2666), |v|=48.1155 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        95.586     12.5d  0.87   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        95.586     12.5d  0.87   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        95.586     12.5d  0.87   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        111.66     15.8d  0.87   0.000   0.226  \"END_SYMB\"\n",
+      "     4.2206   26.215   48.508 14   1        29.278     2.12d  0.00   0.000   0.880  \"Circularized\"\n",
+      "     4.2220   26.215   48.508 14   1         30.44     2.25d  0.00   0.000   0.847  \"Start tidal lock 2\"\n",
+      "     4.4183   26.215   48.508 14   1        30.478     2.25d  0.00   0.000   0.895  \"BEG_BSS \"\n",
+      "     4.7181   26.215   48.508 14   1        30.283     2.23d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     4.7190   26.215   48.508 14   1        30.283     2.23d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7523   26.329   44.943 14   2        32.161      2.5d  0.00   0.000   1.352  \"OFF_MS\"\n",
+      "     5.7523   26.329   44.943 14   2        32.161      2.5d  0.00   0.000   1.352  \"TYPE_CHNGE\"\n",
+      "     5.7523   26.329   44.943 14   2        32.161      2.5d  0.00   0.000   1.352  \"END_BSS\"\n",
+      "     5.7523   26.329   44.943 14   2        32.161      2.5d  0.00   0.000   1.352  \"End tidal lock 2\"\n",
+      "     5.7550   26.329   44.557 14   2        33.006     2.61d  0.00   0.000   6.438  \"Start tidal lock 2\"\n",
+      "     5.7553   26.329   44.419 14   2         33.17     2.63d  0.00   0.000   7.432  \"End tidal lock 2\"\n",
+      "     5.7568   26.329   42.711 14   4        34.357     2.81d  0.00   0.000  17.554  \"TYPE_CHNGE\"\n",
+      "     5.7666   26.331   27.078 14   4        44.111     4.64d  0.00   0.000  14.443  \"Start Carbon Star 2\"\n",
+      "     5.7671   26.331   26.296 14   4         44.78     4.78d  0.00   0.000  14.256  \"q-inv\"\n",
+      "     5.7775   26.333   16.925 14   4        54.752     7.13d  0.00   0.000   0.993  \"END_RCHE 2!>1\"\n",
+      "     5.7775   26.333   16.925 14   4        54.752     7.13d  0.00   0.000   0.985  \"END_SYMB\"\n",
+      "     5.7929   26.333   16.925 14   7        54.751     7.13d  0.00   0.000   0.070  \"TYPE_CHNGE\"\n",
+      "     5.7929   26.333   16.925 14   7        54.751     7.13d  0.00   0.000   0.070  \"End Carbon Star 2\"\n",
+      "     5.8022   26.333   16.925 14   7        54.751     7.13d  0.00   0.000   0.070  \"Start tidal lock 2\"\n",
+      "     6.2173   26.333   16.925 14   7        54.751     7.13d  0.00   0.000   0.070  \"End tidal lock 2\"\n",
+      "     6.2223   26.333   16.925 14   8        54.751     7.13d  0.00   0.000   0.069  \"TYPE_CHNGE\"\n",
+      "     6.2254   26.333   16.925 14  14         35.28     3.69d  0.74   0.000   0.000  Mers(5)=0.78651 - Mers(6)=0.641304 - Mers(7)=0.925166 - Mers(8)=0.0127414 - Mers(9)=0.868799 \n",
+      "     6.2254   26.333   16.925 14  14         35.28     3.69d  0.74   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=16.925 Mc\"CO\"=12.733 type=8) -> kick 1(190) vk=272.859 vr=388.297 omega=5.45882 phi=-1.34456 -> vn=259.93 ; final sep 35.2799 ecc 0.742669 (random count 5) - Runaway v=(211.434,34.7207,131.58) |v|=238.352 : companion v=(-4.82138,-78.1867,50.0636), |v|=92.9665 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.2254   26.333   16.925 14  14         35.28     3.69d  0.74   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.2254   26.333   16.925 14  14         35.28     3.69d  0.74   0.000   0.000  \"SN\"\n",
+      "  1086.4937   26.333   16.925 14  14       0.11932   0.0174h  0.00   0.002   0.002  Contact reached R/RL = 0.00264159 0.00207744, st 14 14\n",
+      "  1086.4937   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.700604 - Mers(11)=0.132844 \n",
+      "  1086.4937   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=43.2579 Mc\"CO\"=43.2579,\"BH\"=43.2579 type=14) -> kick 0(0) vk=0 vr=0 omega=0.834686 phi=0.412835 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(-4.82138,-78.1867,50.0636) |v|=92.9665 : companion v=(211.434,34.7207,131.58), |v|=238.352 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "  1086.4937   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "  1086.4937   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "  1086.4937   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   43.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1825, 'M1': 26.223, 'M2': 18.931, 'K1': 14.0, 'K2': 14.0, 'separation': 199.17}\n",
+      "System 1 has separation 199.17\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=84261 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        76.092     8.89d  0.27   0.000   0.284  Randbuf=48159 - Mers(0)=0.266348 - Mers(1)=0.0167844 - Mers(2)=0.675476 - Mers(3)=0.350443 - Mers(4)=0.168363 \n",
+      "     4.1327   26.215   48.508 14   1        76.092     8.89d  0.27   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=93.4041 vr=401.272 omega=1.05785 phi=-0.303765 -> vn=366.935 ; final sep 76.0922 ecc 0.265377 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        76.092     8.89d  0.27   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        76.092     8.89d  0.27   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        76.092     8.89d  0.27   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        83.272     10.2d  0.27   0.000   0.302  \"END_SYMB\"\n",
+      "     4.4450   26.215   48.508 14   1        88.497     11.2d  0.27   0.000   0.311  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        86.716     10.8d  0.16   0.000   0.520  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        86.716     10.8d  0.16   0.000   0.520  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        86.716     10.8d  0.16   0.000   0.520  \"END_BSS\"\n",
+      "     5.7426   26.215   48.508 14   2        86.716     10.8d  0.16   0.000   0.903  \"Start tidal lock 2\"\n",
+      "     5.7428   26.215   48.508 14   2        86.715     10.8d  0.16   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7428   26.215   48.508 14   2        84.525     10.4d  0.00   0.000   1.026  \"BEG_SYMB\"\n",
+      "     5.7428   26.215   48.508 14   2        84.525     10.4d  0.00   0.000   1.026  \"Circularized\"\n",
+      "     5.7435   26.215   48.506 14   2        84.531     10.4d  0.00   0.000   1.674  \"End tidal lock 2\"\n",
+      "     5.7448   26.215   48.401 14   2         84.88     10.5d  0.00   0.000   4.117  \"Start tidal lock 2\"\n",
+      "     5.7452   26.215   48.260 14   2        85.302     10.6d  0.00   0.000   5.725  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.874 14   4        86.225     10.8d  0.00   0.000   9.048  \"TYPE_CHNGE\"\n",
+      "     5.7757   26.220   27.145 14   4        120.07     20.9d  0.00   0.000   7.672  \"Start Carbon Star 2\"\n",
+      "     5.7772   26.220   26.214 14   4        122.22     21.6d  0.00   0.000   7.675  \"q-inv\"\n",
+      "     5.7925   26.223   18.931 14   4        142.09     29.2d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7925   26.223   18.931 14   4        142.09     29.2d  0.00   0.000   0.990  \"END_SYMB\"\n",
+      "     5.8114   26.223   18.931 14   7        142.09     29.2d  0.00   0.000   0.028  \"TYPE_CHNGE\"\n",
+      "     5.8114   26.223   18.931 14   7        142.09     29.2d  0.00   0.000   0.028  \"Start tidal lock 2\"\n",
+      "     5.8114   26.223   18.931 14   7        142.09     29.2d  0.00   0.000   0.028  \"End Carbon Star 2\"\n",
+      "     6.1825   26.223   18.931 14  14        199.17     48.4d  0.75   0.000   0.000  Mers(5)=0.167882 - Mers(6)=0.8882 - Mers(7)=0.777048 - Mers(8)=0.300054 - Mers(9)=0.733903 \n",
+      "     6.1825   26.223   18.931 14  14        199.17     48.4d  0.75   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9305 Mc\"CO\"=14.2833 type=8) -> kick 1(190) vk=398.065 vr=246.254 omega=4.61125 phi=-0.4114 -> vn=279.32 ; final sep 199.173 ecc 0.745754 (random count 5) - Runaway v=(72.5881,-268.755,135.136) |v|=309.451 : companion v=(-81.4181,-68.0269,16.773), |v|=107.415 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1825   26.223   18.931 14  14        199.17     48.4d  0.75   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1825   26.223   18.931 14  14        199.17     48.4d  0.75   0.000   0.000  \"SN\"\n",
+      "     6.1825   26.223   18.931 14  14        199.17     48.4d  0.75   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.223   18.931 14  14        195.77     47.2d  0.74   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.991, 'K1': 14.0, 'K2': 14.0, 'separation': -251.94}\n",
+      "System 1 has separation -251.94\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -73.217}\n",
+      "System 2 has separation -73.217\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -67.67}\n",
+      "System 4 has separation -67.67\n",
+      "system 5 / 100\n",
+      "{'time': 6.1833, 'M1': 26.221, 'M2': 18.875, 'K1': 14.0, 'K2': 14.0, 'separation': -592.8}\n",
+      "System 5 has separation -592.8\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -88.179}\n",
+      "System 6 has separation -88.179\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -167.45}\n",
+      "System 7 has separation -167.45\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -97.538}\n",
+      "System 9 has separation -97.538\n",
+      "system 10 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.049, 'K1': 14.0, 'K2': 14.0, 'separation': -57.337}\n",
+      "System 10 has separation -57.337\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -138.2}\n",
+      "System 11 has separation -138.2\n",
+      "system 12 / 100\n",
+      "{'time': 6.1996, 'M1': 26.293, 'M2': 18.006, 'K1': 14.0, 'K2': 14.0, 'separation': -72.132}\n",
+      "System 12 has separation -72.132\n",
+      "system 13 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -300.6}\n",
+      "System 13 has separation -300.6\n",
+      "system 14 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -653.12}\n",
+      "System 14 has separation -653.12\n",
+      "system 15 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.994, 'K1': 14.0, 'K2': 14.0, 'separation': -70.0}\n",
+      "System 15 has separation -70.0\n",
+      "system 16 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -221.25}\n",
+      "System 16 has separation -221.25\n",
+      "system 17 / 100\n",
+      "None\n",
+      "system 18 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -106.67}\n",
+      "System 18 has separation -106.67\n",
+      "system 19 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.0, 'K1': 14.0, 'K2': 14.0, 'separation': 366.21}\n",
+      "System 19 has separation 366.21\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=43248 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        125.06     18.7d  0.49   0.000   0.284  Randbuf=8346 - Mers(0)=0.530918 - Mers(1)=0.406581 - Mers(2)=0.688832 - Mers(3)=0.61114 - Mers(4)=0.259486 \n",
+      "     4.1327   26.215   48.508 14   1        125.06     18.7d  0.49   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=194.73 vr=401.272 omega=1.6304 phi=0.224152 -> vn=456.087 ; final sep 125.057 ecc 0.4931 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        125.06     18.7d  0.49   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        125.06     18.7d  0.49   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        125.06     18.7d  0.49   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        135.23     21.1d  0.49   0.000   0.186  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        141.92     22.7d  0.49   0.000   0.196  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        147.91     24.1d  0.51   0.000   0.305  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        147.91     24.1d  0.51   0.000   0.305  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        147.91     24.1d  0.51   0.000   0.305  \"END_BSS\"\n",
+      "     5.7435   26.215   48.508 14   2        147.49       24d  0.51   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7435   26.215   48.508 14   2        109.76     15.4d  0.00   0.000   1.345  \"BEG_SYMB\"\n",
+      "     5.7435   26.215   48.508 14   2        109.76     15.4d  0.00   0.000   1.345  \"Circularized\"\n",
+      "     5.7456   26.215   48.241 14   2        111.11     15.7d  0.00   0.000   5.912  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.124 14   4        111.58     15.8d  0.00   0.000   6.986  \"TYPE_CHNGE\"\n",
+      "     5.7459   26.215   48.124 14   4        111.58     15.8d  0.00   0.000   6.986  \"End tidal lock 2\"\n",
+      "     5.7875   26.221   27.145 14   4        156.71     31.1d  0.00   0.000   7.111  \"Start Carbon Star 2\"\n",
+      "     5.7891   26.222   26.221 14   4        159.49     32.2d  0.00   0.000   7.265  \"q-inv\"\n",
+      "     5.8038   26.224   19.000 14   4        185.13     43.4d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.8039   26.224   19.000 14   4        185.13     43.4d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8238   26.224   19.000 14   7        185.13     43.4d  0.00   0.000   0.022  \"TYPE_CHNGE\"\n",
+      "     5.8238   26.224   19.000 14   7        185.13     43.4d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     5.8238   26.224   19.000 14   7        185.13     43.4d  0.00   0.000   0.022  \"End Carbon Star 2\"\n",
+      "     5.9024   26.224   19.000 14   7        185.13     43.4d  0.00   0.000   0.022  \"End tidal lock 2\"\n",
+      "     6.1428   26.224   19.000 14   7        185.13     43.4d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     6.1815   26.224   19.000 14  14        366.21      121d  0.52   0.000   0.000  Mers(5)=0.621971 - Mers(6)=0.369584 - Mers(7)=0.477614 - Mers(8)=0.136246 - Mers(9)=0.914346 \n",
+      "     6.1815   26.224   19.000 14  14        366.21      121d  0.52   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19 Mc\"CO\"=14.337 type=8) -> kick 1(190) vk=202.751 vr=215.908 omega=5.745 phi=-0.814684 -> vn=263.944 ; final sep 366.213 ecc 0.515604 (random count 5) - Runaway v=(221.258,-4.22626,60.479) |v|=229.414 : companion v=(-34.174,-48.5983,10.9601), |v|=60.4134 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1815   26.224   19.000 14  14        366.21      121d  0.52   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1815   26.224   19.000 14  14        366.21      121d  0.52   0.000   0.000  \"SN\"\n",
+      "     6.1815   26.224   19.000 14  14        366.21      121d  0.52   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   19.000 14  14        366.15      121d  0.52   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -121.53}\n",
+      "System 1 has separation -121.53\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -124.76}\n",
+      "System 3 has separation -124.76\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -212.51}\n",
+      "System 4 has separation -212.51\n",
+      "system 5 / 100\n",
+      "{'time': 6.1838, 'M1': 26.221, 'M2': 18.84, 'K1': 14.0, 'K2': 14.0, 'separation': 206.2}\n",
+      "System 5 has separation 206.2\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=45721 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        66.559     7.27d  0.52   0.000   0.284  Randbuf=55402 - Mers(0)=0.809334 - Mers(1)=0.0519603 - Mers(2)=0.268509 - Mers(3)=0.708428 - Mers(4)=0.860273 \n",
+      "     4.1327   26.215   48.508 14   1        66.559     7.27d  0.52   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=200.394 vr=401.272 omega=5.40526 phi=0.429983 -> vn=328.332 ; final sep 66.5593 ecc 0.521095 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        66.559     7.27d  0.52   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        66.559     7.27d  0.52   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        66.559     7.27d  0.52   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1         74.18     8.56d  0.52   0.000   0.339  \"END_SYMB\"\n",
+      "     4.4250   26.215   48.508 14   1         83.31     10.2d  0.54   0.000   0.328  \"BEG_BSS \"\n",
+      "     5.3991   26.215   48.508 14   1        60.751     6.34d  0.12   0.000   0.730  \"Start tidal lock 2\"\n",
+      "     5.6927   26.215   48.508 14   1        59.213      6.1d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.6927   26.215   48.508 14   1        59.213      6.1d  0.00   0.000   1.000  \"Circularized\"\n",
+      "     5.6936   26.215   48.508 14   1        59.211      6.1d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7184   26.215   48.508 14   1        59.213      6.1d  0.00   0.000   1.000  \"END_RCHE 2!>1\"\n",
+      "     5.7188   26.215   48.508 14   1        59.212      6.1d  0.00   0.000   0.998  \"END_SYMB\"\n",
+      "     5.7418   26.215   48.508 14   2        59.749     6.19d  0.00   0.000   0.755  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        59.749     6.19d  0.00   0.000   0.755  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        59.749     6.19d  0.00   0.000   0.755  \"END_BSS\"\n",
+      "     5.7418   26.215   48.508 14   2        59.749     6.19d  0.00   0.000   0.755  \"End tidal lock 2\"\n",
+      "     5.7422   26.215   48.508 14   2        59.751     6.19d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7422   26.215   48.508 14   2        59.751     6.19d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7449   26.215   48.188 14   2        60.634     6.34d  0.00   0.000   6.403  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.063 14   2        60.901     6.39d  0.00   0.000   7.504  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.387 14   4        61.943     6.58d  0.00   0.000  12.613  \"TYPE_CHNGE\"\n",
+      "     5.7650   26.218   27.134 14   4        85.496     12.5d  0.00   0.000   9.941  \"Start Carbon Star 2\"\n",
+      "     5.7660   26.218   26.211 14   4        87.012       13d  0.00   0.000   9.818  \"q-inv\"\n",
+      "     5.7786   26.221   18.840 14   4        101.36     17.6d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7786   26.221   18.840 14   4        101.36     17.6d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.7976   26.221   18.840 14   7        101.36     17.6d  0.00   0.000   0.039  \"TYPE_CHNGE\"\n",
+      "     5.7976   26.221   18.840 14   7        101.36     17.6d  0.00   0.000   0.039  \"End Carbon Star 2\"\n",
+      "     5.8151   26.221   18.840 14   7        101.36     17.6d  0.00   0.000   0.040  \"Start tidal lock 2\"\n",
+      "     6.1708   26.221   18.840 14   7        101.36     17.6d  0.00   0.000   0.039  \"End tidal lock 2\"\n",
+      "     6.1838   26.221   18.840 14  14         206.2     51.1d  0.65   0.000   0.000  Mers(5)=0.0979525 - Mers(6)=0.363304 - Mers(7)=0.134839 - Mers(8)=0.368036 - Mers(9)=0.0199361 \n",
+      "     6.1838   26.221   18.840 14  14         206.2     51.1d  0.65   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8402 Mc\"CO\"=14.2135 type=8) -> kick 1(190) vk=255.368 vr=291.267 omega=0.125262 phi=-0.267092 -> vn=357.731 ; final sep 206.204 ecc 0.649994 (random count 5) - Runaway v=(289.621,110.756,-6.36056) |v|=310.141 : companion v=(-26.0491,-57.4699,-1.48007), |v|=63.1152 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1838   26.221   18.840 14  14         206.2     51.1d  0.65   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1838   26.221   18.840 14  14         206.2     51.1d  0.65   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.221   18.840 14  14        205.19     50.7d  0.65   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1832, 'M1': 26.222, 'M2': 18.879, 'K1': 14.0, 'K2': 14.0, 'separation': -54.006}\n",
+      "System 2 has separation -54.006\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -128.99}\n",
+      "System 5 has separation -128.99\n",
+      "system 6 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.051, 'K1': 14.0, 'K2': 14.0, 'separation': -43.335}\n",
+      "System 6 has separation -43.335\n",
+      "system 7 / 100\n",
+      "{'time': 6.1817, 'M1': 26.224, 'M2': 18.99, 'K1': 14.0, 'K2': 14.0, 'separation': -199.07}\n",
+      "System 7 has separation -199.07\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -173.88}\n",
+      "System 9 has separation -173.88\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -234.94}\n",
+      "System 11 has separation -234.94\n",
+      "system 12 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -33.044}\n",
+      "System 12 has separation -33.044\n",
+      "system 13 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.038, 'K1': 14.0, 'K2': 14.0, 'separation': -51.295}\n",
+      "System 13 has separation -51.295\n",
+      "system 14 / 100\n",
+      "None\n",
+      "system 15 / 100\n",
+      "None\n",
+      "system 16 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.002, 'K1': 14.0, 'K2': 14.0, 'separation': -225.56}\n",
+      "System 16 has separation -225.56\n",
+      "system 17 / 100\n",
+      "None\n",
+      "system 18 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -137.12}\n",
+      "System 18 has separation -137.12\n",
+      "system 19 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.024, 'K1': 14.0, 'K2': 14.0, 'separation': -65.808}\n",
+      "System 19 has separation -65.808\n",
+      "system 20 / 100\n",
+      "None\n",
+      "system 21 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -74.143}\n",
+      "System 21 has separation -74.143\n",
+      "system 22 / 100\n",
+      "None\n",
+      "system 23 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -39.456}\n",
+      "System 23 has separation -39.456\n",
+      "system 24 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -24.787}\n",
+      "System 24 has separation -24.787\n",
+      "system 25 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -129.32}\n",
+      "System 25 has separation -129.32\n",
+      "system 26 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -209.23}\n",
+      "System 26 has separation -209.23\n",
+      "system 27 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -59.775}\n",
+      "System 27 has separation -59.775\n",
+      "system 28 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -47.979}\n",
+      "System 28 has separation -47.979\n",
+      "system 29 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.0, 'K1': 14.0, 'K2': 14.0, 'separation': -315.04}\n",
+      "System 29 has separation -315.04\n",
+      "system 30 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -36.992}\n",
+      "System 30 has separation -36.992\n",
+      "system 31 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -317.86}\n",
+      "System 31 has separation -317.86\n",
+      "system 32 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.995, 'K1': 14.0, 'K2': 14.0, 'separation': -80.214}\n",
+      "System 32 has separation -80.214\n",
+      "system 33 / 100\n",
+      "None\n",
+      "system 34 / 100\n",
+      "{'time': 6.182, 'M1': 26.224, 'M2': 18.966, 'K1': 14.0, 'K2': 14.0, 'separation': 104.88}\n",
+      "System 34 has separation 104.88\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=82905 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         83.03     10.1d  0.13   0.000   0.284  Randbuf=25831 - Mers(0)=0.0524689 - Mers(1)=0.85014 - Mers(2)=0.443676 - Mers(3)=0.33882 - Mers(4)=0.840851 \n",
+      "     4.1327   26.215   48.508 14   1         83.03     10.1d  0.13   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=381.786 vr=401.272 omega=5.28322 phi=-0.328222 -> vn=387.685 ; final sep 83.0298 ecc 0.132655 (random count 0) - Runaway v=(318.823,-135.629,78.3392) |v|=355.219 : companion v=(-60.8143,-91.0476,13.6297), |v|=110.335 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         83.03     10.1d  0.13   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         83.03     10.1d  0.13   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         83.03     10.1d  0.13   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        90.314     11.5d  0.13   0.000   0.279  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1         95.25     12.5d  0.13   0.000   0.293  \"BEG_BSS \"\n",
+      "     5.6281   26.215   48.508 14   1        98.568     13.1d  0.14   0.000   0.558  \"Start tidal lock 2\"\n",
+      "     5.7205   26.215   48.508 14   1        98.084       13d  0.13   0.000   0.599  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2         98.08       13d  0.12   0.000   0.460  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2         98.08       13d  0.12   0.000   0.460  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2         98.08       13d  0.12   0.000   0.460  \"END_BSS\"\n",
+      "     5.7426   26.215   48.508 14   2         98.08       13d  0.12   0.000   0.801  \"Start tidal lock 2\"\n",
+      "     5.7428   26.215   48.508 14   2         98.08       13d  0.12   0.000   0.908  \"End tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        98.078       13d  0.12   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7429   26.215   48.508 14   2        96.588     12.7d  0.00   0.000   1.016  \"BEG_SYMB\"\n",
+      "     5.7429   26.215   48.508 14   2        96.588     12.7d  0.00   0.000   1.016  \"Circularized\"\n",
+      "     5.7437   26.215   48.505 14   2         96.59     12.7d  0.00   0.000   1.750  \"Start tidal lock 2\"\n",
+      "     5.7449   26.215   48.415 14   2        96.878     12.8d  0.00   0.000   3.925  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.011 14   4        97.979       13d  0.00   0.000   7.959  \"TYPE_CHNGE\"\n",
+      "     5.7811   26.220   27.161 14   4        136.68     25.3d  0.00   0.000   7.242  \"Start Carbon Star 2\"\n",
+      "     5.7828   26.221   26.201 14   4        139.21     26.3d  0.00   0.000   7.315  \"q-inv\"\n",
+      "     5.7982   26.224   18.966 14   4        161.66     35.4d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7982   26.224   18.966 14   4        161.66     35.4d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8181   26.224   18.966 14   7        161.66     35.4d  0.00   0.000   0.025  \"TYPE_CHNGE\"\n",
+      "     5.8181   26.224   18.966 14   7        161.66     35.4d  0.00   0.000   0.025  \"Start tidal lock 2\"\n",
+      "     5.8181   26.224   18.966 14   7        161.66     35.4d  0.00   0.000   0.025  \"End Carbon Star 2\"\n",
+      "     6.1820   26.224   18.966 14  14        104.88     18.5d  0.70   0.000   0.000  Mers(5)=0.124072 - Mers(6)=0.64613 - Mers(7)=0.855856 - Mers(8)=0.547534 - Mers(9)=0.753489 \n",
+      "     6.1820   26.224   18.966 14  14        104.88     18.5d  0.70   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9656 Mc\"CO\"=14.3104 type=8) -> kick 1(190) vk=273.917 vr=230.96 omega=4.73431 phi=0.0952125 -> vn=156.401 ; final sep 104.879 ecc 0.700228 (random count 5) - Runaway v=(18.3138,-253.396,-5.71375) |v|=181.638 : companion v=(-52.8856,-79.7448,-4.83933), |v|=95.8099 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1820   26.224   18.966 14  14        104.88     18.5d  0.70   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1820   26.224   18.966 14  14        104.88     18.5d  0.70   0.000   0.000  \"SN\"\n",
+      "     6.1820   26.224   18.966 14  14        104.88     18.5d  0.70   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.966 14  14        91.678     15.1d  0.66   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1825, 'M1': 26.223, 'M2': 18.931, 'K1': 14.0, 'K2': 14.0, 'separation': -182.98}\n",
+      "System 2 has separation -182.98\n",
+      "system 3 / 100\n",
+      "{'time': 6.1834, 'M1': 26.221, 'M2': 18.869, 'K1': 14.0, 'K2': 14.0, 'separation': -62.998}\n",
+      "System 3 has separation -62.998\n",
+      "system 4 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.004, 'K1': 14.0, 'K2': 14.0, 'separation': -33.151}\n",
+      "System 4 has separation -33.151\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -64.564}\n",
+      "System 6 has separation -64.564\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -170.26}\n",
+      "System 7 has separation -170.26\n",
+      "system 8 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.057, 'K1': 14.0, 'K2': 14.0, 'separation': -64.183}\n",
+      "System 8 has separation -64.183\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -80.759}\n",
+      "System 11 has separation -80.759\n",
+      "system 12 / 100\n",
+      "{'time': 6.1831, 'M1': 26.222, 'M2': 18.888, 'K1': 14.0, 'K2': 14.0, 'separation': -36.808}\n",
+      "System 12 has separation -36.808\n",
+      "system 13 / 100\n",
+      "None\n",
+      "system 14 / 100\n",
+      "{'time': 6.1913, 'M1': 26.274, 'M2': 18.412, 'K1': 14.0, 'K2': 14.0, 'separation': -276.33}\n",
+      "System 14 has separation -276.33\n",
+      "system 15 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.992, 'K1': 14.0, 'K2': 14.0, 'separation': -249.3}\n",
+      "System 15 has separation -249.3\n",
+      "system 16 / 100\n",
+      "{'time': 6.1831, 'M1': 26.222, 'M2': 18.89, 'K1': 14.0, 'K2': 14.0, 'separation': 1249.0}\n",
+      "System 16 has separation 1249.0\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=6675 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        107.87       15d  0.67   0.000   0.284  Randbuf=37468 - Mers(0)=0.356052 - Mers(1)=0.848439 - Mers(2)=0.238055 - Mers(3)=0.0479607 - Mers(4)=0.123488 \n",
+      "     4.1327   26.215   48.508 14   1        107.87       15d  0.67   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=371.527 vr=401.272 omega=0.775898 phi=-1.12922 -> vn=435.709 ; final sep 107.866 ecc 0.665768 (random count 0) - Runaway v=(295.322,223.369,-153.93) |v|=401.003 : companion v=(-16.282,-60.6176,-43.943), |v|=76.6197 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        107.87       15d  0.67   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        107.87       15d  0.67   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        107.87       15d  0.67   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        118.93     17.4d  0.67   0.000   0.212  \"END_SYMB\"\n",
+      "     4.4754   26.215   48.508 14   1        127.99     19.4d  0.67   0.000   0.217  \"BEG_BSS \"\n",
+      "     5.7175   26.215   48.508 14   1        73.321     8.41d  0.11   0.000   0.810  \"Start tidal lock 2\"\n",
+      "     5.7320   26.215   48.508 14   1        73.175     8.39d  0.09   0.000   0.736  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        73.301     8.41d  0.08   0.000   0.616  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        73.301     8.41d  0.08   0.000   0.616  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        73.301     8.41d  0.08   0.000   0.616  \"END_BSS\"\n",
+      "     5.7424   26.215   48.508 14   2        73.302     8.41d  0.08   0.000   0.923  \"Start tidal lock 2\"\n",
+      "     5.7425   26.215   48.508 14   2        73.302     8.41d  0.08   0.000   1.001  \"BEG_RCHE 2>1\"\n",
+      "     5.7425   26.215   48.508 14   2        72.779     8.32d  0.00   0.000   1.009  \"BEG_SYMB\"\n",
+      "     5.7425   26.215   48.508 14   2        72.779     8.32d  0.00   0.000   1.009  \"Circularized\"\n",
+      "     5.7430   26.215   48.508 14   2         72.78     8.32d  0.00   0.000   1.390  \"End tidal lock 2\"\n",
+      "     5.7448   26.215   48.342 14   2         73.27     8.41d  0.00   0.000   4.844  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.206 14   2        73.621     8.48d  0.00   0.000   6.246  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.688 14   4        74.642     8.69d  0.00   0.000  10.458  \"TYPE_CHNGE\"\n",
+      "     5.7704   26.219   27.137 14   4        103.56     16.7d  0.00   0.000   8.474  \"Start Carbon Star 2\"\n",
+      "     5.7717   26.219   26.193 14   4        105.44     17.3d  0.00   0.000   8.413  \"q-inv\"\n",
+      "     5.7861   26.222   18.890 14   4        122.65     23.4d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7862   26.222   18.890 14   4        122.65     23.4d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8051   26.222   18.890 14   7        122.65     23.4d  0.00   0.000   0.033  \"TYPE_CHNGE\"\n",
+      "     5.8051   26.222   18.890 14   7        122.65     23.4d  0.00   0.000   0.033  \"Start tidal lock 2\"\n",
+      "     5.8051   26.222   18.890 14   7        122.65     23.4d  0.00   0.000   0.033  \"End Carbon Star 2\"\n",
+      "     6.1822   26.222   18.890 14   7        122.65     23.4d  0.00   0.000   0.032  \"End tidal lock 2\"\n",
+      "     6.1831   26.222   18.890 14  14          1249     2.08y  0.91   0.000   0.000  Mers(5)=0.408992 - Mers(6)=0.0909411 - Mers(7)=0.912871 - Mers(8)=0.254935 - Mers(9)=0.620471 \n",
+      "     6.1831   26.222   18.890 14  14          1249     2.08y  0.91   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8899 Mc\"CO\"=14.2519 type=8) -> kick 1(190) vk=134.58 vr=264.931 omega=3.89853 phi=-0.512239 -> vn=365.355 ; final sep 1248.97 ecc 0.906818 (random count 5) - Runaway v=(-16.282,-60.6176,-43.943) |v|=76.6197 : companion v=(295.322,223.369,-153.93), |v|=401.003 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1831   26.222   18.890 14  14          1249     2.08y  0.91   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1831   26.222   18.890 14  14          1249     2.08y  0.91   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.222   18.890 14  14        1248.5     2.08y  0.91   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1834, 'M1': 26.221, 'M2': 18.868, 'K1': 14.0, 'K2': 14.0, 'separation': -117.07}\n",
+      "System 1 has separation -117.07\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -52.649}\n",
+      "System 2 has separation -52.649\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -178.55}\n",
+      "System 4 has separation -178.55\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.241, 'M2': 18.759, 'K1': 14.0, 'K2': 14.0, 'separation': 43.674}\n",
+      "System 5 has separation 43.674\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=33086 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        57.542     5.85d  0.58   0.000   0.284  Randbuf=55555 - Mers(0)=0.275381 - Mers(1)=0.129266 - Mers(2)=0.144211 - Mers(3)=0.30894 - Mers(4)=0.927656 \n",
+      "     4.1327   26.215   48.508 14   1        57.542     5.85d  0.58   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=177.569 vr=401.272 omega=5.82864 phi=-0.39209 -> vn=272.452 ; final sep 57.5422 ecc 0.583209 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        57.542     5.85d  0.58   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        57.542     5.85d  0.58   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        57.542     5.85d  0.58   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        65.014     7.02d  0.58   0.000   0.387  \"END_SYMB\"\n",
+      "     4.4950   26.215   48.508 14   1        65.624     7.12d  0.52   0.000   0.426  \"BEG_BSS \"\n",
+      "     4.9342   26.215   48.508 14   1        48.824     4.57d  0.12   0.000   0.681  \"Start tidal lock 2\"\n",
+      "     5.3963   26.215   48.508 14   1        47.675     4.41d  0.00   0.000   0.929  \"Circularized\"\n",
+      "     5.4795   26.215   48.508 14   1        47.499     4.39d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.4799   26.215   48.508 14   1        47.498     4.39d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7408   26.237   48.443 14   1          47.5     4.39d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7412   26.237   48.443 14   1          47.5     4.39d  0.00   0.000   0.989  \"END_SYMB\"\n",
+      "     5.7419   26.237   48.443 14   2        47.531     4.39d  0.00   0.000   0.949  \"OFF_MS\"\n",
+      "     5.7419   26.237   48.443 14   2        47.531     4.39d  0.00   0.000   0.949  \"TYPE_CHNGE\"\n",
+      "     5.7419   26.237   48.443 14   2        47.531     4.39d  0.00   0.000   0.949  \"END_BSS\"\n",
+      "     5.7419   26.237   48.443 14   2        47.531     4.39d  0.00   0.000   0.949  \"End tidal lock 2\"\n",
+      "     5.7420   26.237   48.443 14   2        47.534     4.39d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7420   26.237   48.443 14   2        47.534     4.39d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7447   26.237   48.099 14   2        48.833     4.58d  0.00   0.000   6.625  \"Start tidal lock 2\"\n",
+      "     5.7449   26.237   47.966 14   2         49.06     4.62d  0.00   0.000   7.766  \"End tidal lock 2\"\n",
+      "     5.7460   26.237   46.903 14   4        50.252     4.82d  0.00   0.000  15.496  \"TYPE_CHNGE\"\n",
+      "     5.7605   26.239   27.134 14   4         68.78     9.04d  0.00   0.000  12.106  \"Start Carbon Star 2\"\n",
+      "     5.7613   26.240   26.237 14   4        69.965     9.35d  0.00   0.000  11.928  \"q-inv\"\n",
+      "     5.7718   26.241   18.759 14   4        81.682     12.7d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7718   26.241   18.759 14   4        81.682     12.7d  0.00   0.000   0.990  \"END_SYMB\"\n",
+      "     5.7891   26.241   18.759 14   7        81.681     12.7d  0.00   0.000   0.049  \"TYPE_CHNGE\"\n",
+      "     5.7891   26.241   18.759 14   7        81.681     12.7d  0.00   0.000   0.049  \"End Carbon Star 2\"\n",
+      "     5.8772   26.241   18.759 14   7        81.681     12.7d  0.00   0.000   0.050  \"Start tidal lock 2\"\n",
+      "     6.1545   26.241   18.759 14   7        81.681     12.7d  0.00   0.000   0.050  \"End tidal lock 2\"\n",
+      "     6.1851   26.241   18.759 14  14        43.674     4.98d  1.00   0.000   0.000  Mers(5)=0.869416 - Mers(6)=0.0615039 - Mers(7)=0.175475 - Mers(8)=0.683847 - Mers(9)=0.140331 \n",
+      "     6.1851   26.241   18.759 14  14        43.674     4.98d  1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.759 Mc\"CO\"=14.1507 type=8) -> kick 1(190) vk=195.433 vr=324.245 omega=0.881725 phi=0.376527 -> vn=116.792 ; final sep 43.6736 ecc 0.998696 (random count 5) - Runaway v=(44.7939,126.215,22.2544) |v|=135.764 : companion v=(56.8073,10.0514,23.74), |v|=62.3834 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1851   26.241   18.759 14  14        43.674     4.98d  1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1851   26.241   18.759 14  14        43.674     4.98d  1.00   0.000   0.000  \"SN\"\n",
+      "     6.1851   26.241   18.759 14  14        43.674     4.98d  1.00   0.000   0.000  Contact reached R/RL = 0.00396556 0.00330446, st 14 14\n",
+      "     6.1951   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.019827 - Mers(11)=0.905871 \n",
+      "     6.1951   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.0004 Mc\"CO\"=45.0004,\"BH\"=45.0004 type=14) -> kick 0(0) vk=0 vr=0 omega=5.69175 phi=-1.28824 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(56.8073,10.0514,23.74) |v|=62.3834 : companion v=(44.7939,126.215,22.2544), |v|=135.764 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1951   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1951   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "     6.1951   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.000    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.995, 'K1': 14.0, 'K2': 14.0, 'separation': -60.703}\n",
+      "System 1 has separation -60.703\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -35.997}\n",
+      "System 3 has separation -35.997\n",
+      "system 4 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.998, 'K1': 14.0, 'K2': 14.0, 'separation': -48.045}\n",
+      "System 4 has separation -48.045\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "None\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.039, 'K1': 14.0, 'K2': 14.0, 'separation': -91.39}\n",
+      "System 10 has separation -91.39\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -47.414}\n",
+      "System 11 has separation -47.414\n",
+      "system 12 / 100\n",
+      "{'time': 6.1843, 'M1': 26.228, 'M2': 18.807, 'K1': 14.0, 'K2': 14.0, 'separation': 243.89}\n",
+      "System 12 has separation 243.89\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=49829 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        64.758     6.98d  0.59   0.000   0.284  Randbuf=82964 - Mers(0)=0.654356 - Mers(1)=0.259163 - Mers(2)=0.37941 - Mers(3)=0.49775 - Mers(4)=0.144164 \n",
+      "     4.1327   26.215   48.508 14   1        64.758     6.98d  0.59   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=201.468 vr=401.272 omega=0.905812 phi=-0.00449932 -> vn=319.126 ; final sep 64.7577 ecc 0.59037 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        64.758     6.98d  0.59   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        64.758     6.98d  0.59   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        64.758     6.98d  0.59   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        72.722     8.31d  0.59   0.000   0.346  \"END_SYMB\"\n",
+      "     4.4319   26.215   48.508 14   1        81.456     9.85d  0.60   0.000   0.336  \"BEG_BSS \"\n",
+      "     5.1838   26.215   48.508 14   1         53.52     5.25d  0.11   0.000   0.712  \"Start tidal lock 2\"\n",
+      "     5.5465   26.215   48.508 14   1        52.308     5.07d  0.00   0.000   0.967  \"Circularized\"\n",
+      "     5.5787   26.215   48.508 14   1        52.219     5.06d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.5796   26.215   48.508 14   1        52.218     5.06d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7350   26.223   48.499 14   1        52.205     5.05d  0.00   0.000   0.994  \"END_RCHE 2!>1\"\n",
+      "     5.7354   26.223   48.499 14   1        52.216     5.05d  0.00   0.000   0.988  \"END_SYMB\"\n",
+      "     5.7419   26.223   48.499 14   2        52.467     5.09d  0.00   0.000   0.860  \"OFF_MS\"\n",
+      "     5.7419   26.223   48.499 14   2        52.467     5.09d  0.00   0.000   0.860  \"TYPE_CHNGE\"\n",
+      "     5.7419   26.223   48.499 14   2        52.467     5.09d  0.00   0.000   0.860  \"END_BSS\"\n",
+      "     5.7419   26.223   48.499 14   2        52.467     5.09d  0.00   0.000   0.860  \"End tidal lock 2\"\n",
+      "     5.7421   26.223   48.499 14   2        52.469     5.09d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7421   26.223   48.499 14   2        52.469     5.09d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7448   26.223   48.167 14   2        53.574     5.26d  0.00   0.000   6.517  \"Start tidal lock 2\"\n",
+      "     5.7450   26.223   48.033 14   2        53.825     5.31d  0.00   0.000   7.678  \"End tidal lock 2\"\n",
+      "     5.7459   26.223   47.148 14   4        54.959     5.51d  0.00   0.000  14.217  \"TYPE_CHNGE\"\n",
+      "     5.7622   26.226   27.140 14   4        75.519     10.4d  0.00   0.000  11.127  \"Start Carbon Star 2\"\n",
+      "     5.7631   26.226   26.199 14   4        76.884     10.8d  0.00   0.000  10.965  \"q-inv\"\n",
+      "     5.7744   26.228   18.807 14   4        89.605     14.6d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7744   26.228   18.807 14   4        89.605     14.6d  0.00   0.000   0.989  \"END_SYMB\"\n",
+      "     5.7921   26.228   18.807 14   7        89.603     14.6d  0.00   0.000   0.044  \"TYPE_CHNGE\"\n",
+      "     5.7921   26.228   18.807 14   7        89.603     14.6d  0.00   0.000   0.044  \"End Carbon Star 2\"\n",
+      "     5.8492   26.228   18.807 14   7        89.603     14.6d  0.00   0.000   0.045  \"Start tidal lock 2\"\n",
+      "     6.1613   26.228   18.807 14   7        89.603     14.6d  0.00   0.000   0.045  \"End tidal lock 2\"\n",
+      "     6.1843   26.228   18.807 14  14        243.89     65.7d  0.78   0.000   0.000  Mers(5)=0.0820501 - Mers(6)=0.294026 - Mers(7)=0.253191 - Mers(8)=0.608012 - Mers(9)=0.0575427 \n",
+      "     6.1843   26.228   18.807 14  14        243.89     65.7d  0.78   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8069 Mc\"CO\"=14.1878 type=8) -> kick 1(190) vk=290.336 vr=309.698 omega=0.361551 phi=0.217741 -> vn=395.713 ; final sep 243.895 ecc 0.780321 (random count 5) - Runaway v=(299.368,177.818,16.3626) |v|=348.581 : companion v=(-19.936,-55.6026,4.17541), |v|=59.2159 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1843   26.228   18.807 14  14        243.89     65.7d  0.78   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1843   26.228   18.807 14  14        243.89     65.7d  0.78   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.228   18.807 14  14        240.84     64.5d  0.78   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -5488.6}\n",
+      "System 1 has separation -5488.6\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -304.04}\n",
+      "System 2 has separation -304.04\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -402.57}\n",
+      "System 3 has separation -402.57\n",
+      "system 4 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.047, 'K1': 14.0, 'K2': 14.0, 'separation': 340.09}\n",
+      "System 4 has separation 340.09\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=39563 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        152.41     25.2d  0.47   0.000   0.284  Randbuf=10731 - Mers(0)=0.616978 - Mers(1)=0.0571898 - Mers(2)=0.0112954 - Mers(3)=0.493682 - Mers(4)=0.332789 \n",
+      "     4.1327   26.215   48.508 14   1        152.41     25.2d  0.47   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=128.028 vr=401.272 omega=2.09097 phi=-0.012637 -> vn=477.992 ; final sep 152.405 ecc 0.46908 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        152.41     25.2d  0.47   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        152.41     25.2d  0.47   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        152.41     25.2d  0.47   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        163.44       28d  0.47   0.000   0.154  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        170.59     29.8d  0.47   0.000   0.163  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        173.83     30.7d  0.48   0.000   0.260  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        173.83     30.7d  0.48   0.000   0.260  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        173.83     30.7d  0.48   0.000   0.260  \"END_BSS\"\n",
+      "     5.7438   26.215   48.508 14   2        174.85       31d  0.48   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7438   26.215   48.508 14   2         135.4     21.1d  0.00   0.000   1.292  \"BEG_SYMB\"\n",
+      "     5.7438   26.215   48.508 14   2         135.4     21.1d  0.00   0.000   1.292  \"Circularized\"\n",
+      "     5.7459   26.215   48.264 14   4        137.08     21.5d  0.00   0.000   5.684  \"TYPE_CHNGE\"\n",
+      "     5.7459   26.215   48.254 14   4        137.14     21.6d  0.00   0.000   5.682  \"Start tidal lock 2\"\n",
+      "     5.7462   26.215   48.148 14   4        137.64     21.7d  0.00   0.000   5.663  \"End tidal lock 2\"\n",
+      "     5.7977   26.223   27.160 14   4        193.37     42.6d  0.00   0.000   7.611  \"Start Carbon Star 2\"\n",
+      "     5.7992   26.223   26.220 14   4        196.84     44.2d  0.00   0.000   7.904  \"q-inv\"\n",
+      "     5.8116   26.225   19.047 14   4        228.23     59.3d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.8117   26.225   19.047 14   4        228.23     59.3d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8304   26.225   19.047 14   7        228.23     59.3d  0.00   0.000   0.018  \"TYPE_CHNGE\"\n",
+      "     5.8304   26.225   19.047 14   7        228.23     59.3d  0.00   0.000   0.018  \"End Carbon Star 2\"\n",
+      "     6.1809   26.225   19.047 14  14        340.09      108d  0.43   0.000   0.000  Mers(5)=0.55763 - Mers(6)=0.109781 - Mers(7)=0.611216 - Mers(8)=0.15297 - Mers(9)=0.72671 \n",
+      "     6.1809   26.225   19.047 14  14        340.09      108d  0.43   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0468 Mc\"CO\"=14.3732 type=8) -> kick 1(190) vk=93.0098 vr=194.56 omega=4.56606 phi=-0.767113 -> vn=224.284 ; final sep 340.086 ecc 0.431246 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1809   26.225   19.047 14  14        340.09      108d  0.43   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1809   26.225   19.047 14  14        340.09      108d  0.43   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.225   19.047 14  14        340.04      108d  0.43   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1834, 'M1': 26.221, 'M2': 18.866, 'K1': 14.0, 'K2': 14.0, 'separation': 552.88}\n",
+      "System 1 has separation 552.88\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=5897 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        86.481     10.8d  0.61   0.000   0.284  Randbuf=60901 - Mers(0)=0.170103 - Mers(1)=0.568638 - Mers(2)=0.34811 - Mers(3)=0.483177 - Mers(4)=0.194869 \n",
+      "     4.1327   26.215   48.508 14   1        86.481     10.8d  0.61   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=257.293 vr=401.272 omega=1.2244 phi=-0.0336528 -> vn=396.426 ; final sep 86.4811 ecc 0.610431 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        86.481     10.8d  0.61   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        86.481     10.8d  0.61   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        86.481     10.8d  0.61   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        95.828     12.6d  0.61   0.000   0.263  \"END_SYMB\"\n",
+      "     4.4427   26.215   48.508 14   1        104.99     14.4d  0.62   0.000   0.262  \"BEG_BSS \"\n",
+      "     5.5878   26.215   48.508 14   1        66.987     7.35d  0.12   0.000   0.787  \"Start tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        66.307     7.23d  0.00   0.000   0.681  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        66.307     7.23d  0.00   0.000   0.681  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        66.307     7.23d  0.00   0.000   0.681  \"END_BSS\"\n",
+      "     5.7418   26.215   48.508 14   2        66.307     7.23d  0.00   0.000   0.681  \"End tidal lock 2\"\n",
+      "     5.7423   26.215   48.508 14   2        66.308     7.23d  0.00   0.000   0.958  \"Start tidal lock 2\"\n",
+      "     5.7424   26.215   48.508 14   2        66.308     7.23d  0.00   0.000   1.001  \"BEG_RCHE 2>1\"\n",
+      "     5.7424   26.215   48.508 14   2        66.308     7.23d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7424   26.215   48.508 14   2        66.308     7.23d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.7426   26.215   48.508 14   2        66.308     7.23d  0.00   0.000   1.167  \"End tidal lock 2\"\n",
+      "     5.7448   26.215   48.281 14   2        66.945     7.35d  0.00   0.000   5.503  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.149 14   2        67.257     7.41d  0.00   0.000   6.767  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.554 14   4        68.296     7.61d  0.00   0.000  11.434  \"TYPE_CHNGE\"\n",
+      "     5.7676   26.218   27.149 14   4        94.507     14.6d  0.00   0.000   9.116  \"Start Carbon Star 2\"\n",
+      "     5.7688   26.219   26.213 14   4        96.208     15.1d  0.00   0.000   9.023  \"q-inv\"\n",
+      "     5.7824   26.221   18.866 14   4        112.02     20.4d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7824   26.221   18.866 14   4        112.02     20.4d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8013   26.221   18.866 14   7        112.01     20.4d  0.00   0.000   0.036  \"TYPE_CHNGE\"\n",
+      "     5.8013   26.221   18.866 14   7        112.01     20.4d  0.00   0.000   0.036  \"Start tidal lock 2\"\n",
+      "     5.8013   26.221   18.866 14   7        112.01     20.4d  0.00   0.000   0.036  \"End Carbon Star 2\"\n",
+      "     6.1787   26.221   18.866 14   7        112.01     20.4d  0.00   0.000   0.035  \"End tidal lock 2\"\n",
+      "     6.1834   26.221   18.866 14  14        552.88      224d  0.84   0.000   0.000  Mers(5)=0.617468 - Mers(6)=0.30084 - Mers(7)=0.504494 - Mers(8)=0.684495 - Mers(9)=0.701814 \n",
+      "     6.1834   26.221   18.866 14  14        552.88      224d  0.84   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8655 Mc\"CO\"=14.2331 type=8) -> kick 1(190) vk=182.326 vr=277.149 omega=4.40963 phi=0.377922 -> vn=371.565 ; final sep 552.877 ecc 0.839556 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1834   26.221   18.866 14  14        552.88      224d  0.84   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1834   26.221   18.866 14  14        552.88      224d  0.84   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.221   18.866 14  14        552.09      224d  0.84   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -402.64}\n",
+      "System 2 has separation -402.64\n",
+      "system 3 / 100\n",
+      "{'time': 6.1811, 'M1': 26.225, 'M2': 19.035, 'K1': 14.0, 'K2': 14.0, 'separation': 143.36}\n",
+      "System 3 has separation 143.36\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=25589 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        142.95     22.9d  0.47   0.000   0.284  Randbuf=74463 - Mers(0)=0.137403 - Mers(1)=0.921878 - Mers(2)=0.868462 - Mers(3)=0.533179 - Mers(4)=0.836284 \n",
+      "     4.1327   26.215   48.508 14   1        142.95     22.9d  0.47   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=445.776 vr=401.272 omega=5.25452 phi=0.066407 -> vn=471.472 ; final sep 142.948 ecc 0.466016 (random count 0) - Runaway v=(373.282,-222.72,-20.6341) |v|=435.167 : companion v=(-77.4297,-85.5447,-2.54272), |v|=115.411 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        142.95     22.9d  0.47   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        142.95     22.9d  0.47   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        142.95     22.9d  0.47   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        153.62     25.5d  0.47   0.000   0.164  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        160.55     27.3d  0.47   0.000   0.174  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        164.71     28.3d  0.48   0.000   0.274  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        164.71     28.3d  0.48   0.000   0.274  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        164.71     28.3d  0.48   0.000   0.274  \"END_BSS\"\n",
+      "     5.7437   26.215   48.508 14   2        165.21     28.5d  0.47   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7437   26.215   48.508 14   2        127.96     19.4d  0.00   0.000   1.292  \"BEG_SYMB\"\n",
+      "     5.7437   26.215   48.508 14   2        127.96     19.4d  0.00   0.000   1.292  \"Circularized\"\n",
+      "     5.7458   26.215   48.248 14   2        129.68     19.8d  0.00   0.000   5.837  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.231 14   4        129.77     19.8d  0.00   0.000   6.005  \"TYPE_CHNGE\"\n",
+      "     5.7461   26.215   48.134 14   4        130.18     19.9d  0.00   0.000   5.988  \"End tidal lock 2\"\n",
+      "     5.7951   26.222   27.143 14   4         182.9     39.2d  0.00   0.000   7.398  \"Start Carbon Star 2\"\n",
+      "     5.7966   26.223   26.210 14   4        186.17     40.6d  0.00   0.000   7.654  \"q-inv\"\n",
+      "     5.8097   26.225   19.035 14   4        215.88     54.6d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8097   26.225   19.035 14   4        215.88     54.6d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8285   26.225   19.035 14   7        215.87     54.6d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8285   26.225   19.035 14   7        215.87     54.6d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1778   26.225   19.035 14   7        215.87     54.6d  0.00   0.000   0.018  \"Start tidal lock 2\"\n",
+      "     6.1811   26.225   19.035 14  14        143.36     29.5d  0.56   0.000   0.000  Mers(5)=0.761944 - Mers(6)=0.40724 - Mers(7)=0.147277 - Mers(8)=0.419579 - Mers(9)=0.789449 \n",
+      "     6.1811   26.225   19.035 14  14        143.36     29.5d  0.56   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0352 Mc\"CO\"=14.3642 type=8) -> kick 1(190) vk=200.305 vr=200.024 omega=4.96025 phi=-0.161544 -> vn=140.611 ; final sep 143.359 ecc 0.557938 (random count 5) - Runaway v=(21.0104,-188.386,20.3417) |v|=144.189 : companion v=(-35.7826,-64.4647,6.05965), |v|=73.9784 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1811   26.225   19.035 14  14        143.36     29.5d  0.56   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1811   26.225   19.035 14  14        143.36     29.5d  0.56   0.000   0.000  \"SN\"\n",
+      "     6.1811   26.225   19.035 14  14        143.36     29.5d  0.56   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.035 14  14        141.96     29.1d  0.55   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -44.022}\n",
+      "System 1 has separation -44.022\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -162.07}\n",
+      "System 2 has separation -162.07\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -111.96}\n",
+      "System 3 has separation -111.96\n",
+      "system 4 / 100\n",
+      "{'time': 6.2347, 'M1': 26.344, 'M2': 16.585, 'K1': 14.0, 'K2': 14.0, 'separation': -31.696}\n",
+      "System 4 has separation -31.696\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -57.211}\n",
+      "System 5 has separation -57.211\n",
+      "system 6 / 100\n",
+      "{'time': 6.203, 'M1': 26.3, 'M2': 17.85, 'K1': 14.0, 'K2': 14.0, 'separation': -23.811}\n",
+      "System 6 has separation -23.811\n",
+      "system 7 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.849, 'K1': 14.0, 'K2': 14.0, 'separation': 96.658}\n",
+      "System 7 has separation 96.658\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=39465 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        66.546     7.27d  0.49   0.000   0.284  Randbuf=2698 - Mers(0)=0.436175 - Mers(1)=0.224797 - Mers(2)=0.851276 - Mers(3)=0.332598 - Mers(4)=0.859539 \n",
+      "     4.1327   26.215   48.508 14   1        66.546     7.27d  0.49   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=173.676 vr=401.272 omega=5.40064 phi=-0.341397 -> vn=328.265 ; final sep 66.5458 ecc 0.49138 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        66.546     7.27d  0.49   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        66.546     7.27d  0.49   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        66.546     7.27d  0.49   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        74.009     8.53d  0.49   0.000   0.340  \"END_SYMB\"\n",
+      "     4.4295   26.215   48.508 14   1        82.632     10.1d  0.51   0.000   0.331  \"BEG_BSS \"\n",
+      "     5.4510   26.215   48.508 14   1        62.967     6.69d  0.12   0.000   0.736  \"Start tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        62.023     6.54d  0.00   0.000   0.728  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        62.023     6.54d  0.00   0.000   0.728  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        62.023     6.54d  0.00   0.000   0.728  \"END_BSS\"\n",
+      "     5.7418   26.215   48.508 14   2        62.023     6.54d  0.00   0.000   0.728  \"End tidal lock 2\"\n",
+      "     5.7423   26.215   48.508 14   2        62.024     6.54d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7423   26.215   48.508 14   2        62.024     6.54d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7423   26.215   48.508 14   2        62.024     6.54d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.7449   26.215   48.218 14   2        62.821     6.68d  0.00   0.000   6.124  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.088 14   2        63.108     6.74d  0.00   0.000   7.293  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.448 14   4        64.143     6.93d  0.00   0.000  12.178  \"TYPE_CHNGE\"\n",
+      "     5.7659   26.218   27.152 14   4        88.592     13.2d  0.00   0.000   9.633  \"Start Carbon Star 2\"\n",
+      "     5.7670   26.218   26.205 14   4        90.206     13.7d  0.00   0.000   9.518  \"q-inv\"\n",
+      "     5.7799   26.221   18.849 14   4        105.05     18.6d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7799   26.221   18.849 14   4        105.05     18.6d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.7990   26.221   18.849 14   7        105.05     18.6d  0.00   0.000   0.038  \"TYPE_CHNGE\"\n",
+      "     5.7990   26.221   18.849 14   7        105.05     18.6d  0.00   0.000   0.038  \"End Carbon Star 2\"\n",
+      "     5.8034   26.221   18.849 14   7        105.05     18.6d  0.00   0.000   0.038  \"Start tidal lock 2\"\n",
+      "     6.1722   26.221   18.849 14   7        105.05     18.6d  0.00   0.000   0.038  \"End tidal lock 2\"\n",
+      "     6.1837   26.221   18.849 14  14        96.658     16.4d  0.17   0.000   0.000  Mers(5)=0.252172 - Mers(6)=0.0586466 - Mers(7)=0.851227 - Mers(8)=0.0979407 - Mers(9)=0.832735 \n",
+      "     6.1837   26.221   18.849 14  14        96.658     16.4d  0.17   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.849 Mc\"CO\"=14.2203 type=8) -> kick 1(190) vk=78.7391 vr=286.138 omega=5.23223 phi=-0.934191 -> vn=273.439 ; final sep 96.6579 ecc 0.171581 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1837   26.221   18.849 14  14        96.658     16.4d  0.17   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1837   26.221   18.849 14  14        96.658     16.4d  0.17   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.221   18.849 14  14        95.907     16.2d  0.17   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -55.48}\n",
+      "System 1 has separation -55.48\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -21.529}\n",
+      "System 2 has separation -21.529\n",
+      "system 3 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.85, 'K1': 14.0, 'K2': 14.0, 'separation': -85.973}\n",
+      "System 3 has separation -85.973\n",
+      "system 4 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.027, 'K1': 14.0, 'K2': 14.0, 'separation': 138.12}\n",
+      "System 4 has separation 138.12\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=41318 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        120.57     17.7d  0.33   0.000   0.284  Randbuf=675 - Mers(0)=0.983365 - Mers(1)=0.427847 - Mers(2)=0.798786 - Mers(3)=0.964094 - Mers(4)=0.808737 \n",
+      "     4.1327   26.215   48.508 14   1        120.57     17.7d  0.33   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=267.526 vr=401.272 omega=5.08145 phi=1.18951 -> vn=451.408 ; final sep 120.568 ecc 0.331377 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        120.57     17.7d  0.33   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        120.57     17.7d  0.33   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        120.57     17.7d  0.33   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        129.76     19.8d  0.33   0.000   0.194  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        135.75     21.2d  0.33   0.000   0.205  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        139.83     22.2d  0.34   0.000   0.323  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        139.83     22.2d  0.34   0.000   0.323  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        139.83     22.2d  0.34   0.000   0.323  \"END_BSS\"\n",
+      "     5.7435   26.215   48.508 14   2        139.82     22.1d  0.34   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7435   26.215   48.508 14   2        123.33     18.3d  0.00   0.000   1.134  \"BEG_SYMB\"\n",
+      "     5.7435   26.215   48.508 14   2        123.33     18.3d  0.00   0.000   1.134  \"Circularized\"\n",
+      "     5.7458   26.215   48.247 14   2        124.77     18.7d  0.00   0.000   5.846  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.206 14   4        124.96     18.8d  0.00   0.000   6.237  \"TYPE_CHNGE\"\n",
+      "     5.7460   26.215   48.133 14   4        125.25     18.8d  0.00   0.000   6.224  \"End tidal lock 2\"\n",
+      "     5.7932   26.222   27.159 14   4        175.92       37d  0.00   0.000   7.279  \"Start Carbon Star 2\"\n",
+      "     5.7947   26.222   26.211 14   4        179.12     38.3d  0.00   0.000   7.513  \"q-inv\"\n",
+      "     5.8083   26.225   19.027 14   4        207.74     51.5d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.8083   26.225   19.027 14   4        207.74     51.5d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8273   26.225   19.027 14   7        207.74     51.5d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8273   26.225   19.027 14   7        207.74     51.5d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1679   26.225   19.027 14   7        207.74     51.5d  0.00   0.000   0.019  \"Start tidal lock 2\"\n",
+      "     6.1812   26.225   19.027 14  14        138.12     27.9d  0.58   0.000   0.000  Mers(5)=0.196861 - Mers(6)=0.367143 - Mers(7)=0.0922489 - Mers(8)=0.0542312 - Mers(9)=0.812389 \n",
+      "     6.1812   26.225   19.027 14  14        138.12     27.9d  0.58   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0268 Mc\"CO\"=14.3577 type=8) -> kick 1(190) vk=183.357 vr=203.883 omega=5.10439 phi=-1.10073 -> vn=143.581 ; final sep 138.121 ecc 0.581982 (random count 5) - Runaway v=(98.0601,-4.2433,101.355) |v|=141.091 : companion v=(-20.322,-52.6062,36.0692), |v|=66.9431 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1812   26.225   19.027 14  14        138.12     27.9d  0.58   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1812   26.225   19.027 14  14        138.12     27.9d  0.58   0.000   0.000  \"SN\"\n",
+      "     6.1812   26.225   19.027 14  14        138.12     27.9d  0.58   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.027 14  14        136.23     27.4d  0.58   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.021, 'K1': 14.0, 'K2': 14.0, 'separation': -60.499}\n",
+      "System 1 has separation -60.499\n",
+      "system 2 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.009, 'K1': 14.0, 'K2': 14.0, 'separation': -47.896}\n",
+      "System 2 has separation -47.896\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -127.77}\n",
+      "System 3 has separation -127.77\n",
+      "system 4 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.008, 'K1': 14.0, 'K2': 14.0, 'separation': -24.938}\n",
+      "System 4 has separation -24.938\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -110.15}\n",
+      "System 5 has separation -110.15\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "None\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.027, 'K1': 14.0, 'K2': 14.0, 'separation': -392.4}\n",
+      "System 9 has separation -392.4\n",
+      "system 10 / 100\n",
+      "{'time': 6.1854, 'M1': 26.245, 'M2': 18.736, 'K1': 14.0, 'K2': 14.0, 'separation': 41.13}\n",
+      "System 10 has separation 41.13\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=16566 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         60.35     6.28d  0.62   0.000   0.284  Randbuf=63562 - Mers(0)=0.173746 - Mers(1)=0.981758 - Mers(2)=0.51484 - Mers(3)=0.765997 - Mers(4)=0.734007 \n",
+      "     4.1327   26.215   48.508 14   1         60.35     6.28d  0.62   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=538.651 vr=401.272 omega=4.6119 phi=0.560953 -> vn=292.846 ; final sep 60.35 ecc 0.6244 (random count 0) - Runaway v=(110.86,-248.238,-206.617) |v|=341.471 : companion v=(-89.113,-111.09,-42.4207), |v|=148.599 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         60.35     6.28d  0.62   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         60.35     6.28d  0.62   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         60.35     6.28d  0.62   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        68.311     7.56d  0.62   0.000   0.369  \"END_SYMB\"\n",
+      "     4.4720   26.215   48.508 14   1        66.643     7.29d  0.56   0.000   0.416  \"BEG_BSS \"\n",
+      "     4.8841   26.215   48.508 14   1        47.453     4.38d  0.12   0.000   0.684  \"Start tidal lock 2\"\n",
+      "     5.3480   26.215   48.508 14   1        46.402     4.23d  0.00   0.000   0.919  \"Circularized\"\n",
+      "     5.4480   26.215   48.508 14   1        46.207     4.21d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.4489   26.215   48.508 14   1        46.206     4.21d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7420   26.241   48.408 14   2        46.228     4.21d  0.00   0.000   0.975  \"OFF_MS\"\n",
+      "     5.7420   26.241   48.408 14   2        46.228     4.21d  0.00   0.000   0.975  \"TYPE_CHNGE\"\n",
+      "     5.7420   26.241   48.408 14   2        46.228     4.21d  0.00   0.000   0.975  \"END_BSS\"\n",
+      "     5.7420   26.241   48.408 14   2        46.228     4.21d  0.00   0.000   0.975  \"END_RCHE 2!>1\"\n",
+      "     5.7420   26.241   48.408 14   2        46.228     4.21d  0.00   0.000   0.975  \"End tidal lock 2\"\n",
+      "     5.7420   26.241   48.408 14   2        46.247     4.22d  0.00   0.000   0.977  \"END_SYMB\"\n",
+      "     5.7420   26.241   48.408 14   2        46.254     4.22d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7420   26.241   48.408 14   2        46.254     4.22d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7447   26.241   48.061 14   2        47.546      4.4d  0.00   0.000   6.655  \"Start tidal lock 2\"\n",
+      "     5.7450   26.241   47.928 14   2        47.769     4.44d  0.00   0.000   7.797  \"End tidal lock 2\"\n",
+      "     5.7460   26.241   46.812 14   4        48.971     4.64d  0.00   0.000  15.865  \"TYPE_CHNGE\"\n",
+      "     5.7601   26.243   27.151 14   4        66.911     8.67d  0.00   0.000  12.398  \"Start Carbon Star 2\"\n",
+      "     5.7609   26.244   26.218 14   4        68.112     8.99d  0.00   0.000  12.206  \"q-inv\"\n",
+      "     5.7711   26.245   18.736 14   4        79.529     12.2d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7712   26.245   18.736 14   4        79.529     12.2d  0.00   0.000   0.990  \"END_SYMB\"\n",
+      "     5.7883   26.245   18.736 14   7        79.528     12.2d  0.00   0.000   0.050  \"TYPE_CHNGE\"\n",
+      "     5.7883   26.245   18.736 14   7        79.528     12.2d  0.00   0.000   0.050  \"End Carbon Star 2\"\n",
+      "     5.8852   26.245   18.736 14   7        79.528     12.2d  0.00   0.000   0.051  \"Start tidal lock 2\"\n",
+      "     6.1539   26.245   18.736 14   7        79.528     12.2d  0.00   0.000   0.051  \"End tidal lock 2\"\n",
+      "     6.1854   26.245   18.736 14  14         41.13     4.55d  1.00   0.000   0.000  Mers(5)=0.38239 - Mers(6)=0.291183 - Mers(7)=0.177962 - Mers(8)=0.0769031 - Mers(9)=0.106795 \n",
+      "     6.1854   26.245   18.736 14  14         41.13     4.55d  1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.7361 Mc\"CO\"=14.133 type=8) -> kick 1(190) vk=168.5 vr=328.536 omega=0.671011 phi=-1.0088 -> vn=84.6667 ; final sep 41.1297 ecc 0.999036 (random count 5) - Runaway v=(-28.2011,-38.8077,-80.4924) |v|=101.904 : companion v=(50.7254,-11.746,-36.1105), |v|=63.3641 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1854   26.245   18.736 14  14         41.13     4.55d  1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1854   26.245   18.736 14  14         41.13     4.55d  1.00   0.000   0.000  \"SN\"\n",
+      "     6.1854   26.245   18.736 14  14         41.13     4.55d  1.00   0.000   0.000  Contact reached R/RL = 0.0500148 0.0416457, st 14 14\n",
+      "     6.1954   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.498982 - Mers(11)=0.612102 \n",
+      "     6.1954   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=44.9816 Mc\"CO\"=44.9816,\"BH\"=44.9816 type=14) -> kick 0(0) vk=0 vr=0 omega=3.84595 phi=-0.00203571 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(50.7254,-11.746,-36.1105) |v|=63.3641 : companion v=(-28.2011,-38.8077,-80.4924), |v|=101.904 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1954   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1954   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "     6.1954   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   44.982    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -70.111}\n",
+      "System 2 has separation -70.111\n",
+      "system 3 / 100\n",
+      "{'time': 6.183, 'M1': 26.222, 'M2': 18.899, 'K1': 14.0, 'K2': 14.0, 'separation': -41.915}\n",
+      "System 3 has separation -41.915\n",
+      "system 4 / 100\n",
+      "{'time': 6.1828, 'M1': 26.222, 'M2': 18.906, 'K1': 14.0, 'K2': 14.0, 'separation': 128.58}\n",
+      "System 4 has separation 128.58\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=14771 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        76.322     8.93d  0.40   0.000   0.284  Randbuf=16147 - Mers(0)=0.683927 - Mers(1)=0.269846 - Mers(2)=0.259684 - Mers(3)=0.295092 - Mers(4)=0.822367 \n",
+      "     4.1327   26.215   48.508 14   1        76.322     8.93d  0.40   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=166.063 vr=401.272 omega=5.16709 phi=-0.422253 -> vn=367.703 ; final sep 76.3218 ecc 0.398941 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        76.322     8.93d  0.40   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        76.322     8.93d  0.40   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        76.322     8.93d  0.40   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        83.891     10.3d  0.40   0.000   0.300  \"END_SYMB\"\n",
+      "     4.4466   26.215   48.508 14   1        90.041     11.4d  0.41   0.000   0.306  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        78.126     9.25d  0.10   0.000   0.578  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        78.126     9.25d  0.10   0.000   0.578  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        78.126     9.25d  0.10   0.000   0.578  \"END_BSS\"\n",
+      "     5.7425   26.215   48.508 14   2        78.127     9.25d  0.10   0.000   0.900  \"Start tidal lock 2\"\n",
+      "     5.7426   26.215   48.508 14   2        78.126     9.25d  0.10   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7426   26.215   48.508 14   2        77.361     9.12d  0.00   0.000   1.010  \"BEG_SYMB\"\n",
+      "     5.7426   26.215   48.508 14   2        77.361     9.12d  0.00   0.000   1.010  \"Circularized\"\n",
+      "     5.7433   26.215   48.506 14   2        77.366     9.12d  0.00   0.000   1.645  \"End tidal lock 2\"\n",
+      "     5.7447   26.215   48.388 14   2        77.727     9.19d  0.00   0.000   4.288  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.244 14   2        78.123     9.27d  0.00   0.000   5.886  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.768 14   4        79.125     9.48d  0.00   0.000   9.863  \"TYPE_CHNGE\"\n",
+      "     5.7724   26.219   27.152 14   4        109.92     18.3d  0.00   0.000   8.113  \"Start Carbon Star 2\"\n",
+      "     5.7738   26.219   26.194 14   4        111.95     18.9d  0.00   0.000   8.075  \"q-inv\"\n",
+      "     5.7887   26.222   18.906 14   4        130.17     25.6d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7887   26.222   18.906 14   4        130.17     25.6d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8075   26.222   18.906 14   7        130.17     25.6d  0.00   0.000   0.031  \"TYPE_CHNGE\"\n",
+      "     5.8075   26.222   18.906 14   7        130.17     25.6d  0.00   0.000   0.031  \"Start tidal lock 2\"\n",
+      "     5.8075   26.222   18.906 14   7        130.17     25.6d  0.00   0.000   0.031  \"End Carbon Star 2\"\n",
+      "     6.1828   26.222   18.906 14  14        128.58     25.1d  0.07   0.000   0.000  Mers(5)=0.890607 - Mers(6)=0.353912 - Mers(7)=0.17764 - Mers(8)=0.738926 - Mers(9)=0.843218 \n",
+      "     6.1828   26.222   18.906 14  14        128.58     25.1d  0.07   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9062 Mc\"CO\"=14.2645 type=8) -> kick 1(190) vk=247.32 vr=257.211 omega=5.29809 phi=0.498208 -> vn=255.615 ; final sep 128.583 ecc 0.0735899 (random count 5) - Runaway v=(200.988,-86.6225,-77.1882) |v|=232.072 : companion v=(-46.3409,-68.0781,-15.3544), |v|=83.7727 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1828   26.222   18.906 14  14        128.58     25.1d  0.07   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1828   26.222   18.906 14  14        128.58     25.1d  0.07   0.000   0.000  \"SN\"\n",
+      "     6.1828   26.222   18.906 14  14        128.58     25.1d  0.07   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.222   18.906 14  14        128.31     25.1d  0.07   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1821, 'M1': 26.223, 'M2': 18.955, 'K1': 14.0, 'K2': 14.0, 'separation': -134.96}\n",
+      "System 1 has separation -134.96\n",
+      "system 2 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.021, 'K1': 14.0, 'K2': 14.0, 'separation': -160.03}\n",
+      "System 2 has separation -160.03\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.051, 'K1': 14.0, 'K2': 14.0, 'separation': -71.187}\n",
+      "System 5 has separation -71.187\n",
+      "system 6 / 100\n",
+      "{'time': 6.1828, 'M1': 26.222, 'M2': 18.91, 'K1': 14.0, 'K2': 14.0, 'separation': -62.924}\n",
+      "System 6 has separation -62.924\n",
+      "system 7 / 100\n",
+      "None\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -162.68}\n",
+      "System 9 has separation -162.68\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -591.43}\n",
+      "System 11 has separation -591.43\n",
+      "system 12 / 100\n",
+      "None\n",
+      "system 13 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -128.34}\n",
+      "System 13 has separation -128.34\n",
+      "system 14 / 100\n",
+      "{'time': 6.1822, 'M1': 26.223, 'M2': 18.955, 'K1': 14.0, 'K2': 14.0, 'separation': -93.607}\n",
+      "System 14 has separation -93.607\n",
+      "system 15 / 100\n",
+      "None\n",
+      "system 16 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.003, 'K1': 14.0, 'K2': 14.0, 'separation': 499.44}\n",
+      "System 16 has separation 499.44\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=14846 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        100.17     13.4d  0.21   0.000   0.284  Randbuf=74309 - Mers(0)=0.259331 - Mers(1)=0.141143 - Mers(2)=0.622702 - Mers(3)=0.871356 - Mers(4)=0.266268 \n",
+      "     4.1327   26.215   48.508 14   1        100.17     13.4d  0.21   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=111.924 vr=401.272 omega=1.67301 phi=0.837113 -> vn=423.891 ; final sep 100.168 ecc 0.209652 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        100.17     13.4d  0.21   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        100.17     13.4d  0.21   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        100.17     13.4d  0.21   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        108.27     15.1d  0.21   0.000   0.233  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        113.58     16.2d  0.21   0.000   0.245  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        117.59     17.1d  0.22   0.000   0.384  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        117.59     17.1d  0.22   0.000   0.384  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        117.59     17.1d  0.22   0.000   0.384  \"END_BSS\"\n",
+      "     5.7429   26.215   48.508 14   2        117.59     17.1d  0.22   0.000   0.818  \"Start tidal lock 2\"\n",
+      "     5.7431   26.215   48.508 14   2        117.58     17.1d  0.22   0.000   0.922  \"End tidal lock 2\"\n",
+      "     5.7432   26.215   48.508 14   2        117.58     17.1d  0.22   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7432   26.215   48.508 14   2        111.91     15.9d  0.00   0.000   1.051  \"BEG_SYMB\"\n",
+      "     5.7432   26.215   48.508 14   2        111.91     15.9d  0.00   0.000   1.051  \"Circularized\"\n",
+      "     5.7438   26.215   48.506 14   2        111.91     15.9d  0.00   0.000   1.647  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.417 14   2        112.24     15.9d  0.00   0.000   3.894  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.136 14   4        113.17     16.2d  0.00   0.000   6.888  \"TYPE_CHNGE\"\n",
+      "     5.7881   26.221   27.153 14   4        158.38     31.6d  0.00   0.000   7.115  \"Start Carbon Star 2\"\n",
+      "     5.7897   26.222   26.210 14   4        161.25     32.7d  0.00   0.000   7.279  \"q-inv\"\n",
+      "     5.8043   26.224   19.003 14   4        187.12     44.1d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.8043   26.224   19.003 14   4        187.12     44.1d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8239   26.224   19.003 14   7        187.12     44.1d  0.00   0.000   0.022  \"TYPE_CHNGE\"\n",
+      "     5.8239   26.224   19.003 14   7        187.12     44.1d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     5.8239   26.224   19.003 14   7        187.12     44.1d  0.00   0.000   0.022  \"End Carbon Star 2\"\n",
+      "     5.8938   26.224   19.003 14   7        187.12     44.1d  0.00   0.000   0.022  \"End tidal lock 2\"\n",
+      "     6.1473   26.224   19.003 14   7        187.12     44.1d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     6.1815   26.224   19.003 14  14        499.44      192d  0.63   0.000   0.000  Mers(5)=0.223547 - Mers(6)=0.0468071 - Mers(7)=0.590671 - Mers(8)=0.104715 - Mers(9)=0.401664 \n",
+      "     6.1815   26.224   19.003 14  14        499.44      192d  0.63   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0027 Mc\"CO\"=14.339 type=8) -> kick 1(190) vk=93.6339 vr=214.763 omega=2.52373 phi=-0.91174 -> vn=273.799 ; final sep 499.44 ecc 0.632458 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1815   26.224   19.003 14  14        499.44      192d  0.63   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1815   26.224   19.003 14  14        499.44      192d  0.63   0.000   0.000  \"SN\"\n",
+      "     6.1815   26.224   19.003 14  14        499.44      192d  0.63   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   19.003 14  14        499.38      192d  0.63   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -82.397}\n",
+      "System 2 has separation -82.397\n",
+      "system 3 / 100\n",
+      "{'time': 6.1825, 'M1': 26.223, 'M2': 18.93, 'K1': 14.0, 'K2': 14.0, 'separation': -27.981}\n",
+      "System 3 has separation -27.981\n",
+      "system 4 / 100\n",
+      "{'time': 6.1833, 'M1': 26.221, 'M2': 18.872, 'K1': 14.0, 'K2': 14.0, 'separation': -71.061}\n",
+      "System 4 has separation -71.061\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -66.972}\n",
+      "System 5 has separation -66.972\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.851, 'K1': 14.0, 'K2': 14.0, 'separation': 88.347}\n",
+      "System 7 has separation 88.347\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=29865 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        67.934      7.5d  0.50   0.000   0.284  Randbuf=16603 - Mers(0)=0.156888 - Mers(1)=0.375547 - Mers(2)=0.782802 - Mers(3)=0.432846 - Mers(4)=0.94836 \n",
+      "     4.1327   26.215   48.508 14   1        67.934      7.5d  0.50   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=266.049 vr=401.272 omega=5.95872 phi=-0.134715 -> vn=334.871 ; final sep 67.9345 ecc 0.500439 (random count 0) - Runaway v=(285.968,61.2849,7.4396) |v|=292.556 : companion v=(-18.2667,-78.5411,2.13576), |v|=80.6655 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        67.934      7.5d  0.50   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        67.934      7.5d  0.50   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        67.934      7.5d  0.50   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1         75.52     8.79d  0.50   0.000   0.333  \"END_SYMB\"\n",
+      "     4.4263   26.215   48.508 14   1        84.135     10.3d  0.52   0.000   0.325  \"BEG_BSS \"\n",
+      "     5.4686   26.215   48.508 14   1        63.408     6.76d  0.12   0.000   0.742  \"Start tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        62.527     6.62d  0.00   0.000   0.722  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        62.527     6.62d  0.00   0.000   0.722  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        62.527     6.62d  0.00   0.000   0.722  \"END_BSS\"\n",
+      "     5.7418   26.215   48.508 14   2        62.527     6.62d  0.00   0.000   0.722  \"End tidal lock 2\"\n",
+      "     5.7423   26.215   48.508 14   2        62.528     6.62d  0.00   0.000   1.000  \"Start tidal lock 2\"\n",
+      "     5.7423   26.215   48.508 14   2        62.528     6.62d  0.00   0.000   1.001  \"BEG_RCHE 2>1\"\n",
+      "     5.7423   26.215   48.508 14   2        62.528     6.62d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7423   26.215   48.508 14   2        62.528     6.62d  0.00   0.000   1.001  \"Circularized\"\n",
+      "     5.7425   26.215   48.508 14   2        62.529     6.62d  0.00   0.000   1.110  \"End tidal lock 2\"\n",
+      "     5.7449   26.215   48.226 14   2        63.305     6.76d  0.00   0.000   6.048  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.096 14   2        63.595     6.81d  0.00   0.000   7.228  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.462 14   4        64.627     7.01d  0.00   0.000  12.086  \"TYPE_CHNGE\"\n",
+      "     5.7661   26.218   27.146 14   4        89.297     13.4d  0.00   0.000   9.567  \"Start Carbon Star 2\"\n",
+      "     5.7672   26.218   26.201 14   4         90.92     13.9d  0.00   0.000   9.455  \"q-inv\"\n",
+      "     5.7802   26.221   18.851 14   4        105.87     18.8d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.7802   26.221   18.851 14   4        105.87     18.8d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.7985   26.221   18.851 14   7        105.87     18.8d  0.00   0.000   0.038  \"TYPE_CHNGE\"\n",
+      "     5.7985   26.221   18.851 14   7        105.87     18.8d  0.00   0.000   0.038  \"End Carbon Star 2\"\n",
+      "     5.8029   26.221   18.851 14   7        105.87     18.8d  0.00   0.000   0.038  \"Start tidal lock 2\"\n",
+      "     6.1760   26.221   18.851 14   7        105.87     18.8d  0.00   0.000   0.038  \"End tidal lock 2\"\n",
+      "     6.1837   26.221   18.851 14  14        88.347     14.3d  0.42   0.000   0.000  Mers(5)=0.170422 - Mers(6)=0.211753 - Mers(7)=0.282722 - Mers(8)=0.193152 - Mers(9)=0.153213 \n",
+      "     6.1837   26.221   18.851 14  14        88.347     14.3d  0.42   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.851 Mc\"CO\"=14.2218 type=8) -> kick 1(190) vk=149.123 vr=285.037 omega=0.962668 phi=-0.660733 -> vn=255.217 ; final sep 88.3474 ecc 0.420756 (random count 5) - Runaway v=(-18.2667,-78.5411,2.13576) |v|=80.6655 : companion v=(285.968,61.2849,7.4396), |v|=292.556 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1837   26.221   18.851 14  14        88.347     14.3d  0.42   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1837   26.221   18.851 14  14        88.347     14.3d  0.42   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.221   18.851 14  14        85.847     13.7d  0.41   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -327.24}\n",
+      "System 1 has separation -327.24\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -40.906}\n",
+      "System 2 has separation -40.906\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.014, 'K1': 14.0, 'K2': 14.0, 'separation': 164.28}\n",
+      "System 6 has separation 164.28\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=44031 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         106.7     14.8d  0.23   0.000   0.284  Randbuf=34851 - Mers(0)=0.261227 - Mers(1)=0.415156 - Mers(2)=0.116405 - Mers(3)=0.0351282 - Mers(4)=0.781494 \n",
+      "     4.1327   26.215   48.508 14   1         106.7     14.8d  0.23   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=197.05 vr=401.272 omega=4.91027 phi=-1.19372 -> vn=434.052 ; final sep 106.702 ecc 0.234525 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         106.7     14.8d  0.23   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         106.7     14.8d  0.23   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         106.7     14.8d  0.23   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1         115.1     16.5d  0.23   0.000   0.219  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        120.59     17.7d  0.23   0.000   0.231  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        124.63     18.6d  0.25   0.000   0.362  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        124.63     18.6d  0.25   0.000   0.362  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        124.63     18.6d  0.25   0.000   0.362  \"END_BSS\"\n",
+      "     5.7432   26.215   48.508 14   2        124.63     18.6d  0.25   0.000   0.907  \"Start tidal lock 2\"\n",
+      "     5.7433   26.215   48.508 14   2        124.63     18.6d  0.25   0.000   1.001  \"BEG_RCHE 2>1\"\n",
+      "     5.7433   26.215   48.508 14   2        117.08       17d  0.00   0.000   1.065  \"BEG_SYMB\"\n",
+      "     5.7433   26.215   48.508 14   2        117.08       17d  0.00   0.000   1.065  \"Circularized\"\n",
+      "     5.7442   26.215   48.502 14   2        117.11       17d  0.00   0.000   1.991  \"End tidal lock 2\"\n",
+      "     5.7449   26.215   48.455 14   2        117.32       17d  0.00   0.000   3.288  \"Start tidal lock 2\"\n",
+      "     5.7456   26.215   48.308 14   2        117.93     17.2d  0.00   0.000   5.232  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.170 14   4        118.44     17.3d  0.00   0.000   6.581  \"TYPE_CHNGE\"\n",
+      "     5.7904   26.222   27.158 14   4        166.07     33.9d  0.00   0.000   7.162  \"Start Carbon Star 2\"\n",
+      "     5.7920   26.222   26.211 14   4        169.09     35.2d  0.00   0.000   7.358  \"q-inv\"\n",
+      "     5.8061   26.225   19.014 14   4        196.17     47.3d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.8061   26.225   19.014 14   4        196.17     47.3d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8250   26.225   19.014 14   7        196.17     47.3d  0.00   0.000   0.021  \"TYPE_CHNGE\"\n",
+      "     5.8250   26.225   19.014 14   7        196.17     47.3d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     5.8250   26.225   19.014 14   7        196.17     47.3d  0.00   0.000   0.021  \"End Carbon Star 2\"\n",
+      "     5.8556   26.225   19.014 14   7        196.17     47.3d  0.00   0.000   0.021  \"End tidal lock 2\"\n",
+      "     6.1571   26.225   19.014 14   7        196.17     47.3d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     6.1813   26.225   19.014 14  14        164.28     36.3d  0.52   0.000   0.000  Mers(5)=0.0907098 - Mers(6)=0.0813927 - Mers(7)=0.848429 - Mers(8)=0.322576 - Mers(9)=0.829735 \n",
+      "     6.1813   26.225   19.014 14  14        164.28     36.3d  0.52   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0138 Mc\"CO\"=14.3477 type=8) -> kick 1(190) vk=112.321 vr=209.778 omega=5.21338 phi=-0.362751 -> vn=188.314 ; final sep 164.275 ecc 0.517604 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1813   26.225   19.014 14  14        164.28     36.3d  0.52   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1813   26.225   19.014 14  14        164.28     36.3d  0.52   0.000   0.000  \"SN\"\n",
+      "     6.1813   26.225   19.014 14  14        164.28     36.3d  0.52   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.014 14  14        163.58       36d  0.52   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -65.484}\n",
+      "System 1 has separation -65.484\n",
+      "system 2 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.845, 'K1': 14.0, 'K2': 14.0, 'separation': -26.134}\n",
+      "System 2 has separation -26.134\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.1826, 'M1': 26.223, 'M2': 18.921, 'K1': 14.0, 'K2': 14.0, 'separation': -97.324}\n",
+      "System 4 has separation -97.324\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -124.8}\n",
+      "System 6 has separation -124.8\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -59.603}\n",
+      "System 7 has separation -59.603\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "{'time': 6.1815, 'M1': 26.224, 'M2': 19.002, 'K1': 14.0, 'K2': 14.0, 'separation': -97.964}\n",
+      "System 9 has separation -97.964\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "None\n",
+      "system 12 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -68.874}\n",
+      "System 12 has separation -68.874\n",
+      "system 13 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -5968.5}\n",
+      "System 13 has separation -5968.5\n",
+      "system 14 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -65.88}\n",
+      "System 14 has separation -65.88\n",
+      "system 15 / 100\n",
+      "None\n",
+      "system 16 / 100\n",
+      "None\n",
+      "system 17 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -256.96}\n",
+      "System 17 has separation -256.96\n",
+      "system 18 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -102.82}\n",
+      "System 18 has separation -102.82\n",
+      "system 19 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -71.675}\n",
+      "System 19 has separation -71.675\n",
+      "system 20 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.017, 'K1': 14.0, 'K2': 14.0, 'separation': 263.5}\n",
+      "System 20 has separation 263.5\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=27963 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        115.39     16.6d  0.34   0.000   0.284  Randbuf=14077 - Mers(0)=0.862238 - Mers(1)=0.367681 - Mers(2)=0.0358403 - Mers(3)=0.107709 - Mers(4)=0.257618 \n",
+      "     4.1327   26.215   48.508 14   1        115.39     16.6d  0.34   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=181.968 vr=401.272 omega=1.61866 phi=-0.902022 -> vn=445.493 ; final sep 115.392 ecc 0.338543 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        115.39     16.6d  0.34   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        115.39     16.6d  0.34   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        115.39     16.6d  0.34   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        124.42     18.6d  0.34   0.000   0.202  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        130.31     19.9d  0.34   0.000   0.214  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        134.91       21d  0.35   0.000   0.334  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        134.91       21d  0.35   0.000   0.334  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        134.91       21d  0.35   0.000   0.334  \"END_BSS\"\n",
+      "     5.7434   26.215   48.508 14   2        134.88       21d  0.35   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7434   26.215   48.508 14   2        118.14     17.2d  0.00   0.000   1.143  \"BEG_SYMB\"\n",
+      "     5.7434   26.215   48.508 14   2        118.14     17.2d  0.00   0.000   1.143  \"Circularized\"\n",
+      "     5.7455   26.215   48.323 14   2        119.06     17.4d  0.00   0.000   5.057  \"Start tidal lock 2\"\n",
+      "     5.7458   26.215   48.203 14   2        119.56     17.6d  0.00   0.000   6.270  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.177 14   4        119.67     17.6d  0.00   0.000   6.513  \"TYPE_CHNGE\"\n",
+      "     5.7910   26.222   27.154 14   4        168.11     34.5d  0.00   0.000   7.182  \"Start Carbon Star 2\"\n",
+      "     5.7926   26.222   26.212 14   4        171.14     35.8d  0.00   0.000   7.385  \"q-inv\"\n",
+      "     5.8066   26.225   19.017 14   4        198.55     48.2d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8066   26.225   19.017 14   4        198.55     48.2d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8255   26.225   19.017 14   7        198.55     48.2d  0.00   0.000   0.020  \"TYPE_CHNGE\"\n",
+      "     5.8255   26.225   19.017 14   7        198.55     48.2d  0.00   0.000   0.020  \"Start tidal lock 2\"\n",
+      "     5.8255   26.225   19.017 14   7        198.55     48.2d  0.00   0.000   0.020  \"End Carbon Star 2\"\n",
+      "     5.8430   26.225   19.017 14   7        198.55     48.2d  0.00   0.000   0.020  \"End tidal lock 2\"\n",
+      "     6.1619   26.225   19.017 14   7        198.55     48.2d  0.00   0.000   0.020  \"Start tidal lock 2\"\n",
+      "     6.1813   26.225   19.017 14  14         263.5     73.6d  0.41   0.000   0.000  Mers(5)=0.96056 - Mers(6)=0.0879311 - Mers(7)=0.773061 - Mers(8)=0.709096 - Mers(9)=0.734375 \n",
+      "     6.1813   26.225   19.017 14  14         263.5     73.6d  0.41   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0166 Mc\"CO\"=14.3498 type=8) -> kick 1(190) vk=86.6125 vr=208.525 omega=4.61422 phi=0.431455 -> vn=232.81 ; final sep 263.499 ecc 0.408641 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1813   26.225   19.017 14  14         263.5     73.6d  0.41   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1813   26.225   19.017 14  14         263.5     73.6d  0.41   0.000   0.000  \"SN\"\n",
+      "     6.1813   26.225   19.017 14  14         263.5     73.6d  0.41   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.017 14  14        263.41     73.6d  0.41   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -99.327}\n",
+      "System 1 has separation -99.327\n",
+      "system 2 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.049, 'K1': 14.0, 'K2': 14.0, 'separation': -460.63}\n",
+      "System 2 has separation -460.63\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -643.11}\n",
+      "System 3 has separation -643.11\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1811, 'M1': 26.225, 'M2': 19.033, 'K1': 14.0, 'K2': 14.0, 'separation': 410.72}\n",
+      "System 5 has separation 410.72\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=84136 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         132.3     20.4d  0.40   0.000   0.284  Randbuf=55750 - Mers(0)=0.317188 - Mers(1)=0.692999 - Mers(2)=0.484374 - Mers(3)=0.371434 - Mers(4)=0.950259 \n",
+      "     4.1327   26.215   48.508 14   1         132.3     20.4d  0.40   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=340.023 vr=401.272 omega=5.97065 phi=-0.260052 -> vn=462.883 ; final sep 132.304 ecc 0.404303 (random count 0) - Runaway v=(404.527,38.6353,20.2242) |v|=406.871 : companion v=(-43.7608,-75.4786,3.59812), |v|=87.3211 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         132.3     20.4d  0.40   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         132.3     20.4d  0.40   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         132.3     20.4d  0.40   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        142.24     22.7d  0.40   0.000   0.177  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        148.69     24.3d  0.40   0.000   0.188  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        152.77     25.3d  0.42   0.000   0.295  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        152.77     25.3d  0.42   0.000   0.295  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        152.77     25.3d  0.42   0.000   0.295  \"END_BSS\"\n",
+      "     5.7436   26.215   48.508 14   2        153.01     25.4d  0.41   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7436   26.215   48.508 14   2        126.68     19.1d  0.00   0.000   1.208  \"BEG_SYMB\"\n",
+      "     5.7436   26.215   48.508 14   2        126.68     19.1d  0.00   0.000   1.208  \"Circularized\"\n",
+      "     5.7458   26.215   48.247 14   2        128.37     19.5d  0.00   0.000   5.850  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.224 14   4        128.48     19.5d  0.00   0.000   6.066  \"TYPE_CHNGE\"\n",
+      "     5.7461   26.215   48.133 14   4        128.86     19.6d  0.00   0.000   6.049  \"End tidal lock 2\"\n",
+      "     5.7946   26.222   27.146 14   4        181.04     38.6d  0.00   0.000   7.364  \"Start Carbon Star 2\"\n",
+      "     5.7961   26.223   26.209 14   4        184.28       40d  0.00   0.000   7.614  \"q-inv\"\n",
+      "     5.8093   26.225   19.033 14   4         213.7     53.8d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.8093   26.225   19.033 14   4         213.7     53.8d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8281   26.225   19.033 14   7         213.7     53.8d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8281   26.225   19.033 14   7         213.7     53.8d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1731   26.225   19.033 14   7         213.7     53.8d  0.00   0.000   0.019  \"Start tidal lock 2\"\n",
+      "     6.1811   26.225   19.033 14  14        410.72      143d  0.53   0.000   0.000  Mers(5)=0.390494 - Mers(6)=0.322317 - Mers(7)=0.595791 - Mers(8)=0.59093 - Mers(9)=0.846912 \n",
+      "     6.1811   26.225   19.033 14  14        410.72      143d  0.53   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.033 Mc\"CO\"=14.3625 type=8) -> kick 1(190) vk=221.822 vr=201.036 omega=5.3213 phi=0.182878 -> vn=244.547 ; final sep 410.722 ecc 0.525865 (random count 5) - Runaway v=(146.269,-185.516,-24.1095) |v|=221.331 : companion v=(-45.8333,-49.9918,-3.90642), |v|=67.9348 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1811   26.225   19.033 14  14        410.72      143d  0.53   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1811   26.225   19.033 14  14        410.72      143d  0.53   0.000   0.000  \"SN\"\n",
+      "     6.1811   26.225   19.033 14  14        410.72      143d  0.53   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.033 14  14        410.67      143d  0.53   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.182, 'M1': 26.224, 'M2': 18.967, 'K1': 14.0, 'K2': 14.0, 'separation': 144.35}\n",
+      "System 1 has separation 144.35\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=29700 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        86.381     10.8d  0.22   0.000   0.284  Randbuf=83890 - Mers(0)=0.675082 - Mers(1)=0.0679086 - Mers(2)=0.892712 - Mers(3)=0.862001 - Mers(4)=0.797505 \n",
+      "     4.1327   26.215   48.508 14   1        86.381     10.8d  0.22   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=132.071 vr=401.272 omega=5.01087 phi=0.809585 -> vn=396.184 ; final sep 86.3808 ecc 0.221154 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        86.381     10.8d  0.22   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        86.381     10.8d  0.22   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        86.381     10.8d  0.22   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        93.931     12.2d  0.22   0.000   0.268  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        99.053     13.2d  0.22   0.000   0.281  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        101.53     13.7d  0.21   0.000   0.444  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        101.53     13.7d  0.21   0.000   0.444  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        101.53     13.7d  0.21   0.000   0.444  \"END_BSS\"\n",
+      "     5.7428   26.215   48.508 14   2        101.53     13.7d  0.21   0.000   0.852  \"Start tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        101.53     13.7d  0.21   0.000   0.966  \"End tidal lock 2\"\n",
+      "     5.7430   26.215   48.508 14   2        101.52     13.7d  0.21   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7430   26.215   48.508 14   2        97.084     12.8d  0.00   0.000   1.046  \"BEG_SYMB\"\n",
+      "     5.7430   26.215   48.508 14   2        97.084     12.8d  0.00   0.000   1.046  \"Circularized\"\n",
+      "     5.7432   26.215   48.508 14   2        97.083     12.8d  0.00   0.000   1.181  \"Start tidal lock 2\"\n",
+      "     5.7452   26.215   48.341 14   2        97.648     12.9d  0.00   0.000   4.859  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.016 14   4        98.551     13.1d  0.00   0.000   7.913  \"TYPE_CHNGE\"\n",
+      "     5.7814   26.220   27.157 14   4        137.59     25.6d  0.00   0.000   7.228  \"Start Carbon Star 2\"\n",
+      "     5.7831   26.221   26.200 14   4        140.12     26.5d  0.00   0.000   7.305  \"q-inv\"\n",
+      "     5.7984   26.224   18.967 14   4        162.72     35.8d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7985   26.224   18.967 14   4        162.72     35.8d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8179   26.224   18.967 14   7        162.72     35.8d  0.00   0.000   0.025  \"TYPE_CHNGE\"\n",
+      "     5.8179   26.224   18.967 14   7        162.72     35.8d  0.00   0.000   0.025  \"Start tidal lock 2\"\n",
+      "     5.8179   26.224   18.967 14   7        162.72     35.8d  0.00   0.000   0.025  \"End Carbon Star 2\"\n",
+      "     6.0322   26.224   18.967 14   7        162.72     35.8d  0.00   0.000   0.026  \"End tidal lock 2\"\n",
+      "     6.0716   26.224   18.967 14   7        162.72     35.8d  0.00   0.000   0.026  \"Start tidal lock 2\"\n",
+      "     6.1820   26.224   18.967 14  14        144.35     29.9d  0.22   0.000   0.000  Mers(5)=0.679453 - Mers(6)=0.0586744 - Mers(7)=0.604467 - Mers(8)=0.0954058 - Mers(9)=0.85388 \n",
+      "     6.1820   26.224   18.967 14  14        144.35     29.9d  0.22   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9673 Mc\"CO\"=14.3117 type=8) -> kick 1(190) vk=83.8804 vr=230.213 omega=5.36508 phi=-0.942769 -> vn=215.064 ; final sep 144.349 ecc 0.220921 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1820   26.224   18.967 14  14        144.35     29.9d  0.22   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1820   26.224   18.967 14  14        144.35     29.9d  0.22   0.000   0.000  \"SN\"\n",
+      "     6.1820   26.224   18.967 14  14        144.35     29.9d  0.22   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.967 14  14        144.09     29.8d  0.22   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -1401.7}\n",
+      "System 1 has separation -1401.7\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -236.79}\n",
+      "System 2 has separation -236.79\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -51.235}\n",
+      "System 3 has separation -51.235\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -28.145}\n",
+      "System 4 has separation -28.145\n",
+      "system 5 / 100\n",
+      "{'time': 6.1829, 'M1': 26.222, 'M2': 18.902, 'K1': 14.0, 'K2': 14.0, 'separation': 830.24}\n",
+      "System 5 has separation 830.24\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=31095 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        71.769     8.15d  0.35   0.000   0.284  Randbuf=16086 - Mers(0)=0.58482 - Mers(1)=0.887664 - Mers(2)=0.545347 - Mers(3)=0.454506 - Mers(4)=0.810479 \n",
+      "     4.1327   26.215   48.508 14   1        71.769     8.15d  0.35   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=404.807 vr=401.272 omega=5.09239 phi=-0.0911146 -> vn=351.215 ; final sep 71.7686 ecc 0.348724 (random count 0) - Runaway v=(272.041,-191.987,25.6075) |v|=333.948 : companion v=(-65.8715,-98.5634,4.64645), |v|=118.64 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        71.769     8.15d  0.35   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        71.769     8.15d  0.35   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        71.769     8.15d  0.35   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        78.951      9.4d  0.35   0.000   0.319  \"END_SYMB\"\n",
+      "     4.4310   26.215   48.508 14   1        84.844     10.5d  0.36   0.000   0.323  \"BEG_BSS \"\n",
+      "     5.6787   26.215   48.508 14   1        76.997     9.05d  0.12   0.000   0.756  \"Start tidal lock 2\"\n",
+      "     5.7344   26.215   48.508 14   1        76.284     8.93d  0.06   0.000   0.686  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        76.384     8.94d  0.06   0.000   0.591  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        76.384     8.94d  0.06   0.000   0.591  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        76.384     8.94d  0.06   0.000   0.591  \"END_BSS\"\n",
+      "     5.7424   26.215   48.508 14   2        76.385     8.94d  0.06   0.000   0.889  \"Start tidal lock 2\"\n",
+      "     5.7426   26.215   48.508 14   2        76.385     8.94d  0.06   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7426   26.215   48.508 14   2        76.138      8.9d  0.00   0.000   1.004  \"BEG_SYMB\"\n",
+      "     5.7426   26.215   48.508 14   2        76.138      8.9d  0.00   0.000   1.004  \"Circularized\"\n",
+      "     5.7434   26.215   48.506 14   2        76.145      8.9d  0.00   0.000   1.737  \"End tidal lock 2\"\n",
+      "     5.7446   26.215   48.396 14   2        76.472     8.97d  0.00   0.000   4.185  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.251 14   2        76.863     9.04d  0.00   0.000   5.815  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.747 14   4        77.904     9.26d  0.00   0.000  10.018  \"TYPE_CHNGE\"\n",
+      "     5.7718   26.219   27.149 14   4        108.17     17.8d  0.00   0.000   8.206  \"Start Carbon Star 2\"\n",
+      "     5.7732   26.219   26.214 14   4        110.12     18.5d  0.00   0.000   8.162  \"q-inv\"\n",
+      "     5.7880   26.222   18.902 14   4        128.11       25d  0.00   0.000   1.000  \"END_RCHE 2!>1\"\n",
+      "     5.7880   26.222   18.902 14   4        128.11       25d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8068   26.222   18.902 14   7        128.11       25d  0.00   0.000   0.031  \"TYPE_CHNGE\"\n",
+      "     5.8068   26.222   18.902 14   7        128.11       25d  0.00   0.000   0.031  \"Start tidal lock 2\"\n",
+      "     5.8068   26.222   18.902 14   7        128.11       25d  0.00   0.000   0.031  \"End Carbon Star 2\"\n",
+      "     6.1829   26.222   18.902 14  14        830.24     1.13y  0.85   0.000   0.000  Mers(5)=0.224703 - Mers(6)=0.735747 - Mers(7)=0.368141 - Mers(8)=0.890668 - Mers(9)=0.814128 \n",
+      "     6.1829   26.222   18.902 14  14        830.24     1.13y  0.85   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9018 Mc\"CO\"=14.2611 type=8) -> kick 1(190) vk=347.358 vr=259.265 omega=5.11532 phi=0.896805 -> vn=352.228 ; final sep 830.241 ecc 0.850197 (random count 5) - Runaway v=(161.927,-215.597,-207.732) |v|=332.707 : companion v=(-66.0254,-59.3931,-26.8801), |v|=92.7871 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1829   26.222   18.902 14  14        830.24     1.13y  0.85   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1829   26.222   18.902 14  14        830.24     1.13y  0.85   0.000   0.000  \"SN\"\n",
+      "     6.1829   26.222   18.902 14  14        830.24     1.13y  0.85   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.222   18.902 14  14        829.95     1.13y  0.85   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -226.73}\n",
+      "System 1 has separation -226.73\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -268.71}\n",
+      "System 2 has separation -268.71\n",
+      "system 3 / 100\n",
+      "{'time': 6.1854, 'M1': 26.245, 'M2': 18.738, 'K1': 14.0, 'K2': 14.0, 'separation': 322.04}\n",
+      "System 3 has separation 322.04\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=18100 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        75.903     8.86d  0.72   0.000   0.284  Randbuf=58521 - Mers(0)=0.717488 - Mers(1)=0.0127528 - Mers(2)=0.492837 - Mers(3)=0.716174 - Mers(4)=0.0562564 \n",
+      "     4.1327   26.215   48.508 14   1        75.903     8.86d  0.72   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=284.534 vr=401.272 omega=0.353469 phi=0.447095 -> vn=366.298 ; final sep 75.9029 ecc 0.716623 (random count 0) - Runaway v=(261.514,199.241,25.6366) |v|=329.763 : companion v=(2.93407,-59.678,9.1582), |v|=60.4479 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        75.903     8.86d  0.72   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        75.903     8.86d  0.72   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        75.903     8.86d  0.72   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        85.901     10.7d  0.72   0.000   0.293  \"END_SYMB\"\n",
+      "     4.4704   26.215   48.508 14   1        85.998     10.7d  0.68   0.000   0.323  \"BEG_BSS \"\n",
+      "     4.9587   26.215   48.508 14   1        47.466     4.38d  0.11   0.000   0.709  \"Start tidal lock 2\"\n",
+      "     5.3583   26.215   48.508 14   1        46.505     4.25d  0.00   0.000   0.924  \"Circularized\"\n",
+      "     5.4508   26.215   48.508 14   1        46.321     4.22d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.4517   26.215   48.508 14   1        46.321     4.22d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7420   26.240   48.412 14   2         46.34     4.23d  0.00   0.000   0.973  \"OFF_MS\"\n",
+      "     5.7420   26.240   48.412 14   2         46.34     4.23d  0.00   0.000   0.973  \"TYPE_CHNGE\"\n",
+      "     5.7420   26.240   48.412 14   2         46.34     4.23d  0.00   0.000   0.973  \"END_BSS\"\n",
+      "     5.7420   26.240   48.412 14   2         46.34     4.23d  0.00   0.000   0.973  \"END_RCHE 2!>1\"\n",
+      "     5.7420   26.240   48.412 14   2         46.34     4.23d  0.00   0.000   0.973  \"End tidal lock 2\"\n",
+      "     5.7420   26.240   48.412 14   2         46.36     4.23d  0.00   0.000   0.975  \"END_SYMB\"\n",
+      "     5.7420   26.240   48.412 14   2        46.367     4.23d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7420   26.240   48.412 14   2        46.368     4.23d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7447   26.241   48.063 14   2        47.663     4.42d  0.00   0.000   6.666  \"Start tidal lock 2\"\n",
+      "     5.7450   26.241   47.931 14   2        47.885     4.46d  0.00   0.000   7.801  \"End tidal lock 2\"\n",
+      "     5.7460   26.241   46.820 14   4        49.091     4.66d  0.00   0.000  15.830  \"TYPE_CHNGE\"\n",
+      "     5.7602   26.243   27.138 14   4        67.092     8.71d  0.00   0.000  12.369  \"Start Carbon Star 2\"\n",
+      "     5.7609   26.243   26.236 14   4        68.256     9.01d  0.00   0.000  12.184  \"q-inv\"\n",
+      "     5.7712   26.245   18.738 14   4        79.721     12.3d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7712   26.245   18.738 14   4        79.721     12.3d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.7889   26.245   18.738 14   7        79.719     12.3d  0.00   0.000   0.050  \"TYPE_CHNGE\"\n",
+      "     5.7889   26.245   18.738 14   7        79.719     12.3d  0.00   0.000   0.050  \"End Carbon Star 2\"\n",
+      "     5.8858   26.245   18.738 14   7        79.719     12.3d  0.00   0.000   0.051  \"Start tidal lock 2\"\n",
+      "     6.1501   26.245   18.738 14   7        79.719     12.3d  0.00   0.000   0.051  \"End tidal lock 2\"\n",
+      "     6.1854   26.245   18.738 14  14        322.04     99.8d  0.82   0.000   0.000  Mers(5)=0.0659861 - Mers(6)=0.494443 - Mers(7)=0.0766063 - Mers(8)=0.366583 - Mers(9)=0.715904 \n",
+      "     6.1854   26.245   18.738 14  14        322.04     99.8d  0.82   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.7384 Mc\"CO\"=14.1348 type=8) -> kick 1(190) vk=225.249 vr=328.149 omega=4.49816 phi=-0.270107 -> vn=434.405 ; final sep 322.043 ecc 0.818308 (random count 5) - Runaway v=(2.93407,-59.678,9.1582) |v|=60.4479 : companion v=(261.514,199.241,25.6366), |v|=329.763 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1854   26.245   18.738 14  14        322.04     99.8d  0.82   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1854   26.245   18.738 14  14        322.04     99.8d  0.82   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.245   18.738 14  14        319.49     98.6d  0.82   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.2496, 'M1': 26.361, 'M2': 16.081, 'K1': 14.0, 'K2': 14.0, 'separation': 42.564}\n",
+      "System 2 has separation 42.564\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=1797 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        58.522        6d  0.80   0.000   0.284  Randbuf=32351 - Mers(0)=0.898635 - Mers(1)=0.339822 - Mers(2)=0.846803 - Mers(3)=0.286689 - Mers(4)=0.0183162 \n",
+      "     4.1327   26.215   48.508 14   1        58.522        6d  0.80   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=232.489 vr=401.272 omega=0.115084 phi=-0.440755 -> vn=279.964 ; final sep 58.5223 ecc 0.802415 (random count 0) - Runaway v=(207.376,139.09,-6.27194) |v|=249.78 : companion v=(12.7405,-62.1182,-2.7656), |v|=63.4716 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        58.522        6d  0.80   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        58.522        6d  0.80   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        58.522        6d  0.80   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        68.722     7.63d  0.80   0.000   0.366  \"END_SYMB\"\n",
+      "     4.1450   26.215   48.508 14   1        26.921     1.87d  0.00   0.000   0.938  \"Circularized\"\n",
+      "     4.1457   26.215   48.508 14   1        27.888     1.97d  0.00   0.000   0.906  \"Start tidal lock 2\"\n",
+      "     4.4183   26.215   48.508 14   1         27.89     1.97d  0.00   0.000   0.978  \"BEG_BSS \"\n",
+      "     4.4829   26.215   48.508 14   1        27.851     1.97d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     4.4838   26.215   48.508 14   1        27.851     1.97d  0.00   0.000   1.000  \"BEG_SYMB\"\n",
+      "     5.7605   26.357   43.257 14   2        30.411     2.33d  0.00   0.000   1.404  \"OFF_MS\"\n",
+      "     5.7605   26.357   43.257 14   2        30.411     2.33d  0.00   0.000   1.404  \"TYPE_CHNGE\"\n",
+      "     5.7605   26.357   43.257 14   2        30.411     2.33d  0.00   0.000   1.404  \"END_BSS\"\n",
+      "     5.7605   26.357   43.257 14   2        30.411     2.33d  0.00   0.000   1.404  \"End tidal lock 2\"\n",
+      "     5.7634   26.357   42.867 14   2        31.183     2.42d  0.00   0.000   6.178  \"Start tidal lock 2\"\n",
+      "     5.7637   26.357   42.725 14   2        31.343     2.44d  0.00   0.000   7.125  \"End tidal lock 2\"\n",
+      "     5.7653   26.357   41.030 14   4        32.469     2.61d  0.00   0.000  16.324  \"TYPE_CHNGE\"\n",
+      "     5.7746   26.359   27.076 14   4         40.64      4.1d  0.00   0.000  13.749  \"Start Carbon Star 2\"\n",
+      "     5.7752   26.359   26.344 14   4         41.39     4.25d  0.00   0.000  13.532  \"q-inv\"\n",
+      "     5.7868   26.361   16.081 14   4        51.472     6.56d  0.00   0.000   0.993  \"END_RCHE 2!>1\"\n",
+      "     5.7869   26.361   16.081 14   4        51.472     6.56d  0.00   0.000   0.985  \"END_SYMB\"\n",
+      "     5.8027   26.361   16.081 14   7        51.471     6.56d  0.00   0.000   0.073  \"TYPE_CHNGE\"\n",
+      "     5.8027   26.361   16.081 14   7        51.471     6.56d  0.00   0.000   0.073  \"Start tidal lock 2\"\n",
+      "     5.8027   26.361   16.081 14   7        51.471     6.56d  0.00   0.000   0.073  \"End Carbon Star 2\"\n",
+      "     6.2446   26.361   16.081 14   8        51.471     6.56d  0.00   0.000   0.072  \"TYPE_CHNGE\"\n",
+      "     6.2446   26.361   16.081 14   8        51.471     6.56d  0.00   0.000   0.072  \"End tidal lock 2\"\n",
+      "     6.2496   26.361   16.081 14  14        42.564     4.94d  0.35   0.000   0.000  Mers(5)=0.0981467 - Mers(6)=0.0234622 - Mers(7)=0.480289 - Mers(8)=0.49024 - Mers(9)=0.833457 \n",
+      "     6.2496   26.361   16.081 14  14        42.564     4.94d  0.35   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=16.0813 Mc\"CO\"=12.0809 type=8) -> kick 1(190) vk=117.938 vr=396.684 omega=5.23677 phi=-0.0195218 -> vn=352.745 ; final sep 42.5638 ecc 0.351931 (random count 5) - Runaway v=(12.7405,-62.1182,-2.7656) |v|=63.4716 : companion v=(207.376,139.09,-6.27194), |v|=249.78 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.2496   26.361   16.081 14  14        42.564     4.94d  0.35   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.2496   26.361   16.081 14  14        42.564     4.94d  0.35   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.361   16.081 14  14        24.733     2.19d  0.18   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1833, 'M1': 26.221, 'M2': 18.878, 'K1': 14.0, 'K2': 14.0, 'separation': -6131.9}\n",
+      "System 1 has separation -6131.9\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -60.816}\n",
+      "System 3 has separation -60.816\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -7374.9}\n",
+      "System 4 has separation -7374.9\n",
+      "system 5 / 100\n",
+      "{'time': 6.1837, 'M1': 26.221, 'M2': 18.851, 'K1': 14.0, 'K2': 14.0, 'separation': -329.49}\n",
+      "System 5 has separation -329.49\n",
+      "system 6 / 100\n",
+      "None\n",
+      "system 7 / 100\n",
+      "None\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.037, 'K1': 14.0, 'K2': 14.0, 'separation': 190.42}\n",
+      "System 10 has separation 190.42\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=63889 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        125.31     18.8d  0.32   0.000   0.284  Randbuf=45715 - Mers(0)=0.449828 - Mers(1)=0.124664 - Mers(2)=0.314817 - Mers(3)=0.973212 - Mers(4)=0.298449 \n",
+      "     4.1327   26.215   48.508 14   1        125.31     18.8d  0.32   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=181.916 vr=401.272 omega=1.87521 phi=1.24197 -> vn=456.338 ; final sep 125.309 ecc 0.315916 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        125.31     18.8d  0.32   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        125.31     18.8d  0.32   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        125.31     18.8d  0.32   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        134.63     20.9d  0.32   0.000   0.187  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        140.68     22.4d  0.32   0.000   0.198  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        144.08     23.2d  0.33   0.000   0.313  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        144.08     23.2d  0.33   0.000   0.313  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        144.08     23.2d  0.33   0.000   0.313  \"END_BSS\"\n",
+      "     5.7435   26.215   48.508 14   2        144.25     23.2d  0.33   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7435   26.215   48.508 14   2        128.97     19.6d  0.00   0.000   1.119  \"BEG_SYMB\"\n",
+      "     5.7435   26.215   48.508 14   2        128.97     19.6d  0.00   0.000   1.119  \"Circularized\"\n",
+      "     5.7459   26.215   48.250 14   2        130.64       20d  0.00   0.000   5.822  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.235 14   4        130.71     20.1d  0.00   0.000   5.962  \"TYPE_CHNGE\"\n",
+      "     5.7461   26.215   48.137 14   4        131.14     20.2d  0.00   0.000   5.944  \"End tidal lock 2\"\n",
+      "     5.7954   26.222   27.154 14   4        184.22     39.6d  0.00   0.000   7.420  \"Start Carbon Star 2\"\n",
+      "     5.7969   26.223   26.222 14   4        187.51     41.1d  0.00   0.000   7.681  \"q-inv\"\n",
+      "     5.8099   26.225   19.037 14   4        217.47     55.2d  0.00   0.000   1.000  \"END_RCHE 2!>1\"\n",
+      "     5.8100   26.225   19.037 14   4        217.47     55.2d  0.00   0.000   0.995  \"END_SYMB\"\n",
+      "     5.8289   26.225   19.037 14   7        217.47     55.2d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8289   26.225   19.037 14   7        217.47     55.2d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1781   26.225   19.037 14   7        217.47     55.2d  0.00   0.000   0.018  \"Start tidal lock 2\"\n",
+      "     6.1810   26.225   19.037 14  14        190.42     45.2d  0.29   0.000   0.000  Mers(5)=0.97632 - Mers(6)=0.0735303 - Mers(7)=0.3572 - Mers(8)=0.117156 - Mers(9)=0.147557 \n",
+      "     6.1810   26.225   19.037 14  14        190.42     45.2d  0.29   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0367 Mc\"CO\"=14.3654 type=8) -> kick 1(190) vk=93.5651 vr=199.293 omega=0.927126 phi=-0.872111 -> vn=184.597 ; final sep 190.423 ecc 0.294636 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1810   26.225   19.037 14  14        190.42     45.2d  0.29   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1810   26.225   19.037 14  14        190.42     45.2d  0.29   0.000   0.000  \"SN\"\n",
+      "     6.1810   26.225   19.037 14  14        190.42     45.2d  0.29   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.037 14  14        190.28     45.2d  0.29   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "{'time': 6.1854, 'M1': 26.245, 'M2': 18.736, 'K1': 14.0, 'K2': 14.0, 'separation': -210.41}\n",
+      "System 3 has separation -210.41\n",
+      "system 4 / 100\n",
+      "{'time': 6.1836, 'M1': 26.221, 'M2': 18.854, 'K1': 14.0, 'K2': 14.0, 'separation': -25.172}\n",
+      "System 4 has separation -25.172\n",
+      "system 5 / 100\n",
+      "{'time': 6.1818, 'M1': 26.224, 'M2': 18.98, 'K1': 14.0, 'K2': 14.0, 'separation': -47.471}\n",
+      "System 5 has separation -47.471\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -66.04}\n",
+      "System 6 has separation -66.04\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -55.372}\n",
+      "System 7 has separation -55.372\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -266.21}\n",
+      "System 8 has separation -266.21\n",
+      "system 9 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.996, 'K1': 14.0, 'K2': 14.0, 'separation': 250.86}\n",
+      "System 9 has separation 250.86\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=31626 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        94.283     12.3d  0.12   0.000   0.284  Randbuf=12325 - Mers(0)=0.345978 - Mers(1)=0.131951 - Mers(2)=0.885621 - Mers(3)=0.951016 - Mers(4)=0.75217 \n",
+      "     4.1327   26.215   48.508 14   1        94.283     12.3d  0.12   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=101.279 vr=401.272 omega=4.72603 phi=1.12445 -> vn=413.278 ; final sep 94.2834 ecc 0.121801 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        94.283     12.3d  0.12   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        94.283     12.3d  0.12   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        94.283     12.3d  0.12   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        102.02     13.8d  0.12   0.000   0.247  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        107.12     14.9d  0.12   0.000   0.260  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        110.79     15.6d  0.13   0.000   0.407  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        110.79     15.6d  0.13   0.000   0.407  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        110.79     15.6d  0.13   0.000   0.407  \"END_BSS\"\n",
+      "     5.7427   26.215   48.508 14   2        110.79     15.6d  0.13   0.000   0.759  \"Start tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        110.79     15.6d  0.13   0.000   0.845  \"End tidal lock 2\"\n",
+      "     5.7431   26.215   48.508 14   2        110.78     15.6d  0.13   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7431   26.215   48.508 14   2           109     15.2d  0.00   0.000   1.017  \"BEG_SYMB\"\n",
+      "     5.7431   26.215   48.508 14   2           109     15.2d  0.00   0.000   1.017  \"Circularized\"\n",
+      "     5.7459   26.215   48.116 14   4        110.17     15.5d  0.00   0.000   7.076  \"TYPE_CHNGE\"\n",
+      "     5.7867   26.221   27.144 14   4        154.02     30.3d  0.00   0.000   7.109  \"Start Carbon Star 2\"\n",
+      "     5.7883   26.222   26.213 14   4        156.77     31.4d  0.00   0.000   7.253  \"q-inv\"\n",
+      "     5.8031   26.224   18.996 14   4        181.97     42.3d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8032   26.224   18.996 14   4        181.97     42.3d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8221   26.224   18.996 14   7        181.97     42.3d  0.00   0.000   0.022  \"TYPE_CHNGE\"\n",
+      "     5.8221   26.224   18.996 14   7        181.97     42.3d  0.00   0.000   0.022  \"Start tidal lock 2\"\n",
+      "     5.8221   26.224   18.996 14   7        181.97     42.3d  0.00   0.000   0.022  \"End Carbon Star 2\"\n",
+      "     5.9139   26.224   18.996 14   7        181.97     42.3d  0.00   0.000   0.023  \"End tidal lock 2\"\n",
+      "     6.1368   26.224   18.996 14   7        181.97     42.3d  0.00   0.000   0.023  \"Start tidal lock 2\"\n",
+      "     6.1816   26.224   18.996 14  14        250.86     68.4d  0.35   0.000   0.000  Mers(5)=0.282074 - Mers(6)=0.0709522 - Mers(7)=0.215421 - Mers(8)=0.9555 - Mers(9)=0.790007 \n",
+      "     6.1816   26.224   18.996 14  14        250.86     68.4d  0.35   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9959 Mc\"CO\"=14.3338 type=8) -> kick 1(190) vk=138.621 vr=217.766 omega=4.96376 phi=1.1457 -> vn=245.855 ; final sep 250.86 ecc 0.349729 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1816   26.224   18.996 14  14        250.86     68.4d  0.35   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1816   26.224   18.996 14  14        250.86     68.4d  0.35   0.000   0.000  \"SN\"\n",
+      "     6.1816   26.224   18.996 14  14        250.86     68.4d  0.35   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.224   18.996 14  14        250.78     68.4d  0.35   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -175.7}\n",
+      "System 1 has separation -175.7\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -1129.9}\n",
+      "System 2 has separation -1129.9\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -47.425}\n",
+      "System 3 has separation -47.425\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -91.654}\n",
+      "System 5 has separation -91.654\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -337.14}\n",
+      "System 6 has separation -337.14\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -54.006}\n",
+      "System 7 has separation -54.006\n",
+      "system 8 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -131.35}\n",
+      "System 8 has separation -131.35\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -36.357}\n",
+      "System 10 has separation -36.357\n",
+      "system 11 / 100\n",
+      "{'time': 6.1832, 'M1': 26.222, 'M2': 18.88, 'K1': 14.0, 'K2': 14.0, 'separation': -249.64}\n",
+      "System 11 has separation -249.64\n",
+      "system 12 / 100\n",
+      "{'time': 6.1824, 'M1': 26.223, 'M2': 18.937, 'K1': 14.0, 'K2': 14.0, 'separation': -30.593}\n",
+      "System 12 has separation -30.593\n",
+      "system 13 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -55.03}\n",
+      "System 13 has separation -55.03\n",
+      "system 14 / 100\n",
+      "None\n",
+      "system 15 / 100\n",
+      "None\n",
+      "system 16 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -328.25}\n",
+      "System 16 has separation -328.25\n",
+      "system 17 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -25.601}\n",
+      "System 17 has separation -25.601\n",
+      "system 18 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -230.83}\n",
+      "System 18 has separation -230.83\n",
+      "system 19 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -293.99}\n",
+      "System 19 has separation -293.99\n",
+      "system 20 / 100\n",
+      "None\n",
+      "system 21 / 100\n",
+      "None\n",
+      "system 22 / 100\n",
+      "None\n",
+      "system 23 / 100\n",
+      "None\n",
+      "system 24 / 100\n",
+      "{'time': 6.1811, 'M1': 26.225, 'M2': 19.033, 'K1': 14.0, 'K2': 14.0, 'separation': 123.04}\n",
+      "System 24 has separation 123.04\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=38843 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        119.34     17.5d  0.27   0.000   0.284  Randbuf=60747 - Mers(0)=0.811129 - Mers(1)=0.472192 - Mers(2)=0.00476578 - Mers(3)=0.00668026 - Mers(4)=0.776277 \n",
+      "     4.1327   26.215   48.508 14   1        119.34     17.5d  0.27   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=214.827 vr=401.272 omega=4.87749 phi=-1.40715 -> vn=450.059 ; final sep 119.341 ecc 0.26838 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        119.34     17.5d  0.27   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        119.34     17.5d  0.27   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        119.34     17.5d  0.27   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1         128.3     19.5d  0.27   0.000   0.196  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        134.12     20.8d  0.27   0.000   0.208  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        137.52     21.6d  0.28   0.000   0.328  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        137.52     21.6d  0.28   0.000   0.328  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        137.52     21.6d  0.28   0.000   0.328  \"END_BSS\"\n",
+      "     5.7434   26.215   48.508 14   2        137.52     21.6d  0.28   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7434   26.215   48.508 14   2        126.88     19.1d  0.00   0.000   1.085  \"BEG_SYMB\"\n",
+      "     5.7434   26.215   48.508 14   2        126.88     19.1d  0.00   0.000   1.085  \"Circularized\"\n",
+      "     5.7458   26.215   48.248 14   2        128.43     19.5d  0.00   0.000   5.840  \"Start tidal lock 2\"\n",
+      "     5.7459   26.215   48.225 14   4        128.55     19.6d  0.00   0.000   6.062  \"TYPE_CHNGE\"\n",
+      "     5.7461   26.215   48.134 14   4        128.93     19.7d  0.00   0.000   6.046  \"End tidal lock 2\"\n",
+      "     5.7946   26.222   27.155 14   4        181.11     38.6d  0.00   0.000   7.364  \"Start Carbon Star 2\"\n",
+      "     5.7961   26.223   26.217 14   4        184.36       40d  0.00   0.000   7.614  \"q-inv\"\n",
+      "     5.8093   26.225   19.033 14   4        213.82     53.8d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.8094   26.225   19.033 14   4        213.82     53.8d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8287   26.225   19.033 14   7        213.82     53.8d  0.00   0.000   0.019  \"TYPE_CHNGE\"\n",
+      "     5.8287   26.225   19.033 14   7        213.82     53.8d  0.00   0.000   0.019  \"End Carbon Star 2\"\n",
+      "     6.1736   26.225   19.033 14   7        213.82     53.8d  0.00   0.000   0.019  \"Start tidal lock 2\"\n",
+      "     6.1811   26.225   19.033 14  14        123.04     23.5d  0.98   0.000   0.000  Mers(5)=0.248231 - Mers(6)=0.019482 - Mers(7)=0.109998 - Mers(8)=0.230018 - Mers(9)=0.10213 \n",
+      "     6.1811   26.225   19.033 14  14        123.04     23.5d  0.98   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0331 Mc\"CO\"=14.3626 type=8) -> kick 1(190) vk=116.324 vr=200.98 omega=0.641703 phi=-0.570395 -> vn=102.93 ; final sep 123.045 ecc 0.980321 (random count 5) - Runaway v=(56.4877,81.6824,-18.0218) |v|=100.934 : companion v=(26.6331,-16.7493,-14.2062), |v|=34.5207 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1811   26.225   19.033 14  14        123.04     23.5d  0.98   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1811   26.225   19.033 14  14        123.04     23.5d  0.98   0.000   0.000  \"SN\"\n",
+      "     6.1811   26.225   19.033 14  14        123.04     23.5d  0.98   0.000   0.000  \"End tidal lock 2\"\n",
+      "    49.5698   26.225   19.033 14  14       0.12705   0.0187h  0.00   0.002   0.002  Contact reached R/RL = 0.00249796 0.00209872, st 14 14\n",
+      "    49.5698   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.21425 - Mers(11)=0.631711 \n",
+      "    49.5698   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.2582 Mc\"CO\"=45.2582,\"BH\"=45.2582 type=14) -> kick 0(0) vk=0 vr=0 omega=3.96915 phi=-0.608333 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(26.6331,-16.7493,-14.2062) |v|=34.5207 : companion v=(56.4877,81.6824,-18.0218), |v|=100.934 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "    49.5698   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "    49.5698   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "    49.5698   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.258    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1823, 'M1': 26.223, 'M2': 18.948, 'K1': 14.0, 'K2': 14.0, 'separation': 134.49}\n",
+      "System 1 has separation 134.49\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=49377 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        81.857     9.92d  0.27   0.000   0.284  Randbuf=40484 - Mers(0)=0.0525733 - Mers(1)=0.643548 - Mers(2)=0.829997 - Mers(3)=0.954402 - Mers(4)=0.842866 \n",
+      "     4.1327   26.215   48.508 14   1        81.857     9.92d  0.27   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=377.03 vr=401.272 omega=5.29589 phi=1.14041 -> vn=384.498 ; final sep 81.857 ecc 0.271437 (random count 0) - Runaway v=(291.063,18.76,-202.769) |v|=355.226 : companion v=(-45.0387,-81.0835,-44.9536), |v|=103.072 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        81.857     9.92d  0.27   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        81.857     9.92d  0.27   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        81.857     9.92d  0.27   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        89.311     11.3d  0.27   0.000   0.282  \"END_SYMB\"\n",
+      "     4.4851   26.215   48.508 14   1        94.564     12.3d  0.27   0.000   0.295  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        94.534     12.3d  0.22   0.000   0.477  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        94.534     12.3d  0.22   0.000   0.477  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        94.534     12.3d  0.22   0.000   0.477  \"END_BSS\"\n",
+      "     5.7428   26.215   48.508 14   2        94.533     12.3d  0.22   0.000   0.930  \"Start tidal lock 2\"\n",
+      "     5.7429   26.215   48.508 14   2        94.531     12.3d  0.22   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7429   26.215   48.508 14   2        90.004     11.4d  0.00   0.000   1.051  \"BEG_SYMB\"\n",
+      "     5.7429   26.215   48.508 14   2        90.004     11.4d  0.00   0.000   1.051  \"Circularized\"\n",
+      "     5.7433   26.215   48.508 14   2        90.006     11.4d  0.00   0.000   1.435  \"End tidal lock 2\"\n",
+      "     5.7449   26.215   48.381 14   2        90.464     11.5d  0.00   0.000   4.386  \"Start tidal lock 2\"\n",
+      "     5.7454   26.215   48.243 14   2        90.901     11.6d  0.00   0.000   5.891  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.942 14   4        91.684     11.8d  0.00   0.000   8.507  \"TYPE_CHNGE\"\n",
+      "     5.7783   26.220   27.137 14   4        127.93     22.9d  0.00   0.000   7.429  \"Start Carbon Star 2\"\n",
+      "     5.7798   26.220   26.203 14   4        130.23     23.8d  0.00   0.000   7.463  \"q-inv\"\n",
+      "     5.7953   26.223   18.948 14   4        151.31     32.1d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7953   26.223   18.948 14   4        151.31     32.1d  0.00   0.000   0.991  \"END_SYMB\"\n",
+      "     5.8143   26.223   18.948 14   7        151.31     32.1d  0.00   0.000   0.027  \"TYPE_CHNGE\"\n",
+      "     5.8143   26.223   18.948 14   7        151.31     32.1d  0.00   0.000   0.027  \"Start tidal lock 2\"\n",
+      "     5.8143   26.223   18.948 14   7        151.31     32.1d  0.00   0.000   0.027  \"End Carbon Star 2\"\n",
+      "     6.1823   26.223   18.948 14  14        134.49     26.9d  0.40   0.000   0.000  Mers(5)=0.896761 - Mers(6)=0.0895115 - Mers(7)=0.264324 - Mers(8)=0.287811 - Mers(9)=0.184756 \n",
+      "     6.1823   26.223   18.948 14  14        134.49     26.9d  0.40   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9478 Mc\"CO\"=14.2966 type=8) -> kick 1(190) vk=103.262 vr=238.683 omega=1.16086 phi=-0.438276 -> vn=223.256 ; final sep 134.487 ecc 0.401098 (random count 5) - Runaway v=(-45.0387,-81.0835,-44.9536) |v|=103.072 : companion v=(291.063,18.76,-202.769), |v|=355.226 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1823   26.223   18.948 14  14        134.49     26.9d  0.40   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1823   26.223   18.948 14  14        134.49     26.9d  0.40   0.000   0.000  \"SN\"\n",
+      "     6.1823   26.223   18.948 14  14        134.49     26.9d  0.40   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.223   18.948 14  14        133.85     26.7d  0.40   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -2335.9}\n",
+      "System 2 has separation -2335.9\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.1833, 'M1': 26.221, 'M2': 18.873, 'K1': 14.0, 'K2': 14.0, 'separation': -117.63}\n",
+      "System 4 has separation -117.63\n",
+      "system 5 / 100\n",
+      "{'time': 6.1809, 'M1': 26.225, 'M2': 19.045, 'K1': 14.0, 'K2': 14.0, 'separation': -118.52}\n",
+      "System 5 has separation -118.52\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -163.57}\n",
+      "System 6 has separation -163.57\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -525.03}\n",
+      "System 7 has separation -525.03\n",
+      "system 8 / 100\n",
+      "{'time': 6.1832, 'M1': 26.222, 'M2': 18.88, 'K1': 14.0, 'K2': 14.0, 'separation': 166.23}\n",
+      "System 8 has separation 166.23\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=74740 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        126.09       19d  0.74   0.000   0.284  Randbuf=26098 - Mers(0)=0.296001 - Mers(1)=0.775873 - Mers(2)=0.601913 - Mers(3)=0.278587 - Mers(4)=0.0851238 \n",
+      "     4.1327   26.215   48.508 14   1        126.09       19d  0.74   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=354.16 vr=401.272 omega=0.534849 phi=-0.458747 -> vn=457.105 ; final sep 126.086 ecc 0.73634 (random count 0) - Runaway v=(315.871,266.127,-51.7071) |v|=416.259 : companion v=(-6.0371,-56.3506,-15.2568), |v|=58.6907 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        126.09       19d  0.74   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        126.09       19d  0.74   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        126.09       19d  0.74   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        139.29       22d  0.74   0.000   0.181  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        149.84     24.6d  0.74   0.000   0.186  \"BEG_BSS \"\n",
+      "     5.6986   26.215   48.508 14   1        70.753     7.97d  0.12   0.000   0.843  \"Start tidal lock 2\"\n",
+      "     5.7396   26.215   48.508 14   1        70.255     7.89d  0.04   0.000   0.688  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        70.297      7.9d  0.04   0.000   0.642  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        70.297      7.9d  0.04   0.000   0.642  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        70.297      7.9d  0.04   0.000   0.642  \"END_BSS\"\n",
+      "     5.7424   26.215   48.508 14   2        70.298      7.9d  0.04   0.000   0.927  \"Start tidal lock 2\"\n",
+      "     5.7425   26.215   48.508 14   2        70.298      7.9d  0.04   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7425   26.215   48.508 14   2        70.202     7.88d  0.00   0.000   1.002  \"BEG_SYMB\"\n",
+      "     5.7425   26.215   48.508 14   2        70.202     7.88d  0.00   0.000   1.002  \"Circularized\"\n",
+      "     5.7429   26.215   48.508 14   2        70.203     7.88d  0.00   0.000   1.348  \"End tidal lock 2\"\n",
+      "     5.7448   26.215   48.331 14   2        70.714     7.98d  0.00   0.000   4.977  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.194 14   2        71.054     8.04d  0.00   0.000   6.357  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.637 14   4        72.094     8.25d  0.00   0.000  10.829  \"TYPE_CHNGE\"\n",
+      "     5.7693   26.219   27.139 14   4         99.93     15.8d  0.00   0.000   8.712  \"Start Carbon Star 2\"\n",
+      "     5.7705   26.219   26.215 14   4        101.71     16.4d  0.00   0.000   8.639  \"q-inv\"\n",
+      "     5.7846   26.222   18.880 14   4        118.38     22.2d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7847   26.222   18.880 14   4        118.38     22.2d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8039   26.222   18.880 14   7        118.38     22.2d  0.00   0.000   0.034  \"TYPE_CHNGE\"\n",
+      "     5.8039   26.222   18.880 14   7        118.38     22.2d  0.00   0.000   0.034  \"Start tidal lock 2\"\n",
+      "     5.8039   26.222   18.880 14   7        118.38     22.2d  0.00   0.000   0.034  \"End Carbon Star 2\"\n",
+      "     6.1811   26.222   18.880 14   7        118.38     22.2d  0.00   0.000   0.033  \"End tidal lock 2\"\n",
+      "     6.1832   26.222   18.880 14  14        166.23       37d  0.59   0.000   0.000  Mers(5)=0.312727 - Mers(6)=0.939033 - Mers(7)=0.522304 - Mers(8)=0.376859 - Mers(9)=0.273952 \n",
+      "     6.1832   26.222   18.880 14  14        166.23       37d  0.59   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8802 Mc\"CO\"=14.2444 type=8) -> kick 1(190) vk=450.268 vr=269.638 omega=1.72129 phi=-0.248842 -> vn=305.992 ; final sep 166.226 ecc 0.592806 (random count 5) - Runaway v=(-165.799,220.536,10.1759) |v|=320.682 : companion v=(66.4253,111.302,-97.2556), |v|=162.047 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1832   26.222   18.880 14  14        166.23       37d  0.59   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1832   26.222   18.880 14  14        166.23       37d  0.59   0.000   0.000  \"SN\"\n",
+      " 15000.0000   26.222   18.880 14  14        165.06     36.6d  0.59   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.993, 'K1': 14.0, 'K2': 14.0, 'separation': -467.85}\n",
+      "System 2 has separation -467.85\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "None\n",
+      "system 5 / 100\n",
+      "None\n",
+      "system 6 / 100\n",
+      "{'time': 6.1814, 'M1': 26.224, 'M2': 19.006, 'K1': 14.0, 'K2': 14.0, 'separation': -90.431}\n",
+      "System 6 has separation -90.431\n",
+      "system 7 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.039, 'K1': 14.0, 'K2': 14.0, 'separation': -16.026}\n",
+      "System 7 has separation -16.026\n",
+      "system 8 / 100\n",
+      "{'time': 6.1841, 'M1': 26.223, 'M2': 18.819, 'K1': 14.0, 'K2': 14.0, 'separation': -122.49}\n",
+      "System 8 has separation -122.49\n",
+      "system 9 / 100\n",
+      "{'time': 6.184, 'M1': 26.221, 'M2': 18.829, 'K1': 14.0, 'K2': 14.0, 'separation': 73.204}\n",
+      "System 9 has separation 73.204\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=1366 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        61.158     6.41d  0.50   0.000   0.284  Randbuf=38134 - Mers(0)=0.875586 - Mers(1)=0.0311296 - Mers(2)=0.80299 - Mers(3)=0.314795 - Mers(4)=0.911977 \n",
+      "     4.1327   26.215   48.508 14   1        61.158     6.41d  0.50   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=148.479 vr=401.272 omega=5.73012 phi=-0.37945 -> vn=298.13 ; final sep 61.1582 ecc 0.497906 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        61.158     6.41d  0.50   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        61.158     6.41d  0.50   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        61.158     6.41d  0.50   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        68.353     7.57d  0.50   0.000   0.368  \"END_SYMB\"\n",
+      "     4.4251   26.215   48.508 14   1        77.201     9.09d  0.52   0.000   0.354  \"BEG_BSS \"\n",
+      "     5.3017   26.215   48.508 14   1        57.974     5.91d  0.12   0.000   0.711  \"Start tidal lock 2\"\n",
+      "     5.6467   26.215   48.508 14   1        56.472     5.69d  0.00   0.000   0.994  \"Circularized\"\n",
+      "     5.6516   26.215   48.508 14   1        56.456     5.68d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.6524   26.215   48.508 14   1        56.455     5.68d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7273   26.215   48.508 14   1        56.456     5.68d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7278   26.215   48.508 14   1        56.458     5.68d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.7418   26.215   48.508 14   2        56.891     5.75d  0.00   0.000   0.793  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        56.891     5.75d  0.00   0.000   0.793  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        56.891     5.75d  0.00   0.000   0.793  \"END_BSS\"\n",
+      "     5.7418   26.215   48.508 14   2        56.891     5.75d  0.00   0.000   0.793  \"End tidal lock 2\"\n",
+      "     5.7422   26.215   48.508 14   2        56.893     5.75d  0.00   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7422   26.215   48.508 14   2        56.893     5.75d  0.00   0.000   1.001  \"BEG_SYMB\"\n",
+      "     5.7448   26.215   48.186 14   2         57.85     5.91d  0.00   0.000   6.423  \"Start tidal lock 2\"\n",
+      "     5.7451   26.216   48.055 14   2        58.116     5.95d  0.00   0.000   7.570  \"End tidal lock 2\"\n",
+      "     5.7459   26.216   47.303 14   4        59.197     6.15d  0.00   0.000  13.201  \"TYPE_CHNGE\"\n",
+      "     5.7639   26.218   27.142 14   4        81.563     11.7d  0.00   0.000  10.370  \"Start Carbon Star 2\"\n",
+      "     5.7648   26.219   26.212 14   4        83.022     12.1d  0.00   0.000  10.232  \"q-inv\"\n",
+      "     5.7769   26.221   18.829 14   4        96.739     16.4d  0.00   0.000   0.996  \"END_RCHE 2!>1\"\n",
+      "     5.7770   26.221   18.829 14   4        96.739     16.4d  0.00   0.000   0.989  \"END_SYMB\"\n",
+      "     5.7958   26.221   18.829 14   7        96.737     16.4d  0.00   0.000   0.041  \"TYPE_CHNGE\"\n",
+      "     5.7958   26.221   18.829 14   7        96.737     16.4d  0.00   0.000   0.041  \"End Carbon Star 2\"\n",
+      "     5.8266   26.221   18.829 14   7        96.737     16.4d  0.00   0.000   0.042  \"Start tidal lock 2\"\n",
+      "     6.1692   26.221   18.829 14   7        96.737     16.4d  0.00   0.000   0.041  \"End tidal lock 2\"\n",
+      "     6.1840   26.221   18.829 14  14        73.204     10.8d  0.83   0.000   0.000  Mers(5)=0.762637 - Mers(6)=0.152616 - Mers(7)=0.700021 - Mers(8)=0.396255 - Mers(9)=0.0738552 \n",
+      "     6.1840   26.221   18.829 14  14        73.204     10.8d  0.83   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.8288 Mc\"CO\"=14.2046 type=8) -> kick 1(190) vk=202.709 vr=298.108 omega=0.464046 phi=-0.209008 -> vn=245.56 ; final sep 73.2042 ecc 0.828992 (random count 5) - Runaway v=(160.113,152.43,-11.1802) |v|=221.35 : companion v=(15.1941,-45.7263,-5.48941), |v|=48.4962 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1840   26.221   18.829 14  14        73.204     10.8d  0.83   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1840   26.221   18.829 14  14        73.204     10.8d  0.83   0.000   0.000  \"SN\"\n",
+      "  4732.7598   26.221   18.829 14  14       0.11328   0.0158h  0.00   0.002   0.002  Contact reached R/RL = 0.0030537 0.00255085, st 14 14\n",
+      "  4732.7598   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.988635 - Mers(11)=0.305868 \n",
+      "  4732.7598   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.0495 Mc\"CO\"=45.0495,\"BH\"=45.0495 type=14) -> kick 0(0) vk=0 vr=0 omega=1.92183 phi=1.35718 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(15.1941,-45.7263,-5.48941) |v|=48.4962 : companion v=(160.113,152.43,-11.1802), |v|=221.35 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "  4732.7598   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "  4732.7598   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "  4732.7598   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.050    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1813, 'M1': 26.225, 'M2': 19.015, 'K1': 14.0, 'K2': 14.0, 'separation': 200.82}\n",
+      "System 1 has separation 200.82\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=32641 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1         109.7     15.4d  0.28   0.000   0.284  Randbuf=50040 - Mers(0)=0.35975 - Mers(1)=0.303685 - Mers(2)=0.595506 - Mers(3)=0.959708 - Mers(4)=0.185853 \n",
+      "     4.1327   26.215   48.508 14   1         109.7     15.4d  0.28   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=248.606 vr=401.272 omega=1.16775 phi=1.16659 -> vn=438.232 ; final sep 109.695 ecc 0.278726 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1         109.7     15.4d  0.28   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1         109.7     15.4d  0.28   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1         109.7     15.4d  0.28   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        118.32     17.2d  0.28   0.000   0.213  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        123.95     18.5d  0.28   0.000   0.225  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        128.23     19.5d  0.29   0.000   0.352  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        128.23     19.5d  0.29   0.000   0.352  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        128.23     19.5d  0.29   0.000   0.352  \"END_BSS\"\n",
+      "     5.7432   26.215   48.508 14   2        128.22     19.5d  0.29   0.000   0.944  \"Start tidal lock 2\"\n",
+      "     5.7433   26.215   48.508 14   2        128.21     19.4d  0.29   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7433   26.215   48.508 14   2        117.32       17d  0.00   0.000   1.093  \"BEG_SYMB\"\n",
+      "     5.7433   26.215   48.508 14   2        117.32       17d  0.00   0.000   1.093  \"Circularized\"\n",
+      "     5.7436   26.215   48.508 14   2        117.32       17d  0.00   0.000   1.359  \"End tidal lock 2\"\n",
+      "     5.7452   26.215   48.399 14   2        117.83     17.1d  0.00   0.000   4.149  \"Start tidal lock 2\"\n",
+      "     5.7457   26.215   48.267 14   2        118.38     17.3d  0.00   0.000   5.655  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.172 14   4        118.74     17.4d  0.00   0.000   6.564  \"TYPE_CHNGE\"\n",
+      "     5.7905   26.222   27.147 14   4        166.63     34.1d  0.00   0.000   7.169  \"Start Carbon Star 2\"\n",
+      "     5.7921   26.222   26.202 14   4        169.64     35.3d  0.00   0.000   7.367  \"q-inv\"\n",
+      "     5.8062   26.225   19.015 14   4        196.78     47.5d  0.00   0.000   0.997  \"END_RCHE 2!>1\"\n",
+      "     5.8063   26.225   19.015 14   4        196.78     47.5d  0.00   0.000   0.992  \"END_SYMB\"\n",
+      "     5.8261   26.225   19.015 14   7        196.78     47.5d  0.00   0.000   0.021  \"TYPE_CHNGE\"\n",
+      "     5.8261   26.225   19.015 14   7        196.78     47.5d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     5.8261   26.225   19.015 14   7        196.78     47.5d  0.00   0.000   0.021  \"End Carbon Star 2\"\n",
+      "     5.8523   26.225   19.015 14   7        196.78     47.5d  0.00   0.000   0.021  \"End tidal lock 2\"\n",
+      "     6.1581   26.225   19.015 14   7        196.78     47.5d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     6.1813   26.225   19.015 14  14        200.82       49d  0.17   0.000   0.000  Mers(5)=0.604393 - Mers(6)=0.0253496 - Mers(7)=0.961749 - Mers(8)=0.224765 - Mers(9)=0.760948 \n",
+      "     6.1813   26.225   19.015 14  14        200.82       49d  0.17   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0145 Mc\"CO\"=14.3482 type=8) -> kick 1(190) vk=44.0531 vr=209.456 omega=4.78117 phi=-0.582926 -> vn=211.551 ; final sep 200.815 ecc 0.174564 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1813   26.225   19.015 14  14        200.82       49d  0.17   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1813   26.225   19.015 14  14        200.82       49d  0.17   0.000   0.000  \"SN\"\n",
+      "     6.1813   26.225   19.015 14  14        200.82       49d  0.17   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.015 14  14        200.73       49d  0.17   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "{'time': 6.1812, 'M1': 26.225, 'M2': 19.027, 'K1': 14.0, 'K2': 14.0, 'separation': -909.36}\n",
+      "System 2 has separation -909.36\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.012, 'K1': 14.0, 'K2': 14.0, 'separation': -57.687}\n",
+      "System 4 has separation -57.687\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -270.19}\n",
+      "System 5 has separation -270.19\n",
+      "system 6 / 100\n",
+      "{'time': 6.1808, 'M1': 26.225, 'M2': 19.055, 'K1': 14.0, 'K2': 14.0, 'separation': -251.57}\n",
+      "System 6 has separation -251.57\n",
+      "system 7 / 100\n",
+      "{'time': 6.182, 'M1': 26.224, 'M2': 18.965, 'K1': 14.0, 'K2': 14.0, 'separation': -22.904}\n",
+      "System 7 has separation -22.904\n",
+      "system 8 / 100\n",
+      "None\n",
+      "system 9 / 100\n",
+      "None\n",
+      "system 10 / 100\n",
+      "None\n",
+      "system 11 / 100\n",
+      "{'time': 6.1827, 'M1': 26.222, 'M2': 18.912, 'K1': 14.0, 'K2': 14.0, 'separation': 84.322}\n",
+      "System 11 has separation 84.322\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=31282 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        70.672     7.96d  0.26   0.000   0.284  Randbuf=9722 - Mers(0)=0.532901 - Mers(1)=0.0577653 - Mers(2)=0.907642 - Mers(3)=0.119019 - Mers(4)=0.0623708 \n",
+      "     4.1327   26.215   48.508 14   1        70.672     7.96d  0.26   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=110.048 vr=401.272 omega=0.391888 phi=-0.866337 -> vn=346.799 ; final sep 70.6721 ecc 0.264223 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        70.672     7.96d  0.26   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        70.672     7.96d  0.26   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        70.672     7.96d  0.26   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        77.595     9.16d  0.26   0.000   0.325  \"END_SYMB\"\n",
+      "     4.4438   26.215   48.508 14   1        82.992     10.1d  0.27   0.000   0.331  \"BEG_BSS \"\n",
+      "     5.6793   26.215   48.508 14   1        80.259     9.63d  0.13   0.000   0.726  \"Start tidal lock 2\"\n",
+      "     5.7281   26.215   48.508 14   1        79.482     9.49d  0.08   0.000   0.704  \"End tidal lock 2\"\n",
+      "     5.7418   26.215   48.508 14   2        79.626     9.52d  0.08   0.000   0.567  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        79.626     9.52d  0.08   0.000   0.567  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        79.626     9.52d  0.08   0.000   0.567  \"END_BSS\"\n",
+      "     5.7425   26.215   48.508 14   2        79.627     9.52d  0.08   0.000   0.879  \"Start tidal lock 2\"\n",
+      "     5.7427   26.215   48.508 14   2        79.626     9.52d  0.08   0.000   0.999  \"End tidal lock 2\"\n",
+      "     5.7427   26.215   48.508 14   2        79.626     9.52d  0.08   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7427   26.215   48.508 14   2         79.12     9.43d  0.00   0.000   1.007  \"BEG_SYMB\"\n",
+      "     5.7427   26.215   48.508 14   2         79.12     9.43d  0.00   0.000   1.007  \"Start tidal lock 2\"\n",
+      "     5.7427   26.215   48.508 14   2         79.12     9.43d  0.00   0.000   1.007  \"Circularized\"\n",
+      "     5.7436   26.215   48.503 14   2        79.134     9.43d  0.00   0.000   1.937  \"End tidal lock 2\"\n",
+      "     5.7446   26.215   48.421 14   2        79.386     9.48d  0.00   0.000   3.837  \"Start tidal lock 2\"\n",
+      "     5.7451   26.215   48.271 14   2        79.806     9.57d  0.00   0.000   5.616  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.795 14   4        80.836     9.78d  0.00   0.000   9.653  \"TYPE_CHNGE\"\n",
+      "     5.7732   26.219   27.145 14   4        112.36     18.9d  0.00   0.000   7.994  \"Start Carbon Star 2\"\n",
+      "     5.7746   26.220   26.194 14   4        114.41     19.6d  0.00   0.000   7.966  \"q-inv\"\n",
+      "     5.7896   26.222   18.912 14   4        133.02     26.4d  0.00   0.000   0.999  \"END_RCHE 2!>1\"\n",
+      "     5.7896   26.222   18.912 14   4        133.02     26.4d  0.00   0.000   0.994  \"END_SYMB\"\n",
+      "     5.8094   26.222   18.912 14   7        133.02     26.4d  0.00   0.000   0.030  \"TYPE_CHNGE\"\n",
+      "     5.8094   26.222   18.912 14   7        133.02     26.4d  0.00   0.000   0.030  \"Start tidal lock 2\"\n",
+      "     5.8094   26.222   18.912 14   7        133.02     26.4d  0.00   0.000   0.030  \"End Carbon Star 2\"\n",
+      "     6.1827   26.222   18.912 14  14        84.322     13.3d  1.00   0.000   0.000  Mers(5)=0.587056 - Mers(6)=0.880685 - Mers(7)=0.615033 - Mers(8)=0.0635842 - Mers(9)=0.300118 \n",
+      "     6.1827   26.222   18.912 14  14        84.322     13.3d  1.00   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9122 Mc\"CO\"=14.2692 type=8) -> kick 1(190) vk=392.367 vr=254.461 omega=1.8857 phi=-1.06097 -> vn=165.393 ; final sep 84.3218 ecc 0.997013 (random count 5) - Runaway v=(-54.3568,171.949,-128.029) |v|=221.162 : companion v=(-48.4429,7.29775,-142.515), |v|=150.7 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1827   26.222   18.912 14  14        84.322     13.3d  1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1827   26.222   18.912 14  14        84.322     13.3d  1.00   0.000   0.000  \"SN\"\n",
+      "     6.1827   26.222   18.912 14  14        84.322     13.3d  1.00   0.000   0.000  \"End tidal lock 2\"\n",
+      "     6.2012   26.222   18.912 14  14       0.12787   0.0189h  0.13   0.002   0.002  Contact reached R/RL = 0.00250277 0.00209561, st 14 14\n",
+      "     6.2012   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  Mers(10)=0.0609448 - Mers(11)=0.743785 \n",
+      "     6.2012   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  SN kick BH_BH (SN type 17 17, pre-explosion M=45.1346 Mc\"CO\"=45.1346,\"BH\"=45.1346 type=14) -> kick 0(0) vk=0 vr=0 omega=4.67334 phi=-1.0719 -> vn=0 ; final sep 0 ecc -1 (random count 10) - Runaway v=(-48.4429,7.29775,-142.515) |v|=150.7 : companion v=(-54.3568,171.949,-128.029), |v|=221.162 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.2012   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.2012   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"COALESCE\"\n",
+      "     6.2012   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"SN\"\n",
+      " 15000.0000   45.135    0.000 14  15            -1       -1  -1.00   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -55.426}\n",
+      "System 1 has separation -55.426\n",
+      "system 2 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -98.948}\n",
+      "System 2 has separation -98.948\n",
+      "system 3 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -318.43}\n",
+      "System 3 has separation -318.43\n",
+      "system 4 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -118.97}\n",
+      "System 4 has separation -118.97\n",
+      "system 5 / 100\n",
+      "{'time': 6.1816, 'M1': 26.224, 'M2': 18.997, 'K1': 14.0, 'K2': 14.0, 'separation': -29.618}\n",
+      "System 5 has separation -29.618\n",
+      "system 6 / 100\n",
+      "{'time': 6.1821, 'M1': 26.223, 'M2': 18.958, 'K1': 14.0, 'K2': 14.0, 'separation': -230.94}\n",
+      "System 6 has separation -230.94\n",
+      "system 7 / 100\n",
+      "{'time': 6.1822, 'M1': 26.223, 'M2': 18.951, 'K1': 14.0, 'K2': 14.0, 'separation': 167.09}\n",
+      "System 7 has separation 167.09\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=35037 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        88.878     11.2d  0.37   0.000   0.284  Randbuf=21339 - Mers(0)=0.221127 - Mers(1)=0.322291 - Mers(2)=0.486212 - Mers(3)=0.81619 - Mers(4)=0.801722 \n",
+      "     4.1327   26.215   48.508 14   1        88.878     11.2d  0.37   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=201.385 vr=401.272 omega=5.03737 phi=0.684623 -> vn=401.996 ; final sep 88.8782 ecc 0.367778 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        88.878     11.2d  0.37   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        88.878     11.2d  0.37   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        88.878     11.2d  0.37   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        96.916     12.8d  0.37   0.000   0.260  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1        102.56     13.9d  0.37   0.000   0.272  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        101.28     13.7d  0.32   0.000   0.446  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        101.28     13.7d  0.32   0.000   0.446  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        101.28     13.7d  0.32   0.000   0.446  \"END_BSS\"\n",
+      "     5.7430   26.215   48.508 14   2        101.26     13.7d  0.32   0.000   0.991  \"Start tidal lock 2\"\n",
+      "     5.7430   26.215   48.508 14   2        101.26     13.7d  0.32   0.000   1.001  \"BEG_RCHE 2>1\"\n",
+      "     5.7430   26.215   48.508 14   2        90.935     11.6d  0.00   0.000   1.114  \"BEG_SYMB\"\n",
+      "     5.7430   26.215   48.508 14   2        90.935     11.6d  0.00   0.000   1.114  \"End tidal lock 2\"\n",
+      "     5.7430   26.215   48.508 14   2        90.935     11.6d  0.00   0.000   1.114  \"Circularized\"\n",
+      "     5.7452   26.215   48.307 14   2        91.707     11.8d  0.00   0.000   5.232  \"Start tidal lock 2\"\n",
+      "     5.7455   26.215   48.180 14   2        92.117     11.9d  0.00   0.000   6.484  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   47.954 14   4        92.738       12d  0.00   0.000   8.410  \"TYPE_CHNGE\"\n",
+      "     5.7788   26.220   27.144 14   4         129.5     23.4d  0.00   0.000   7.388  \"Start Carbon Star 2\"\n",
+      "     5.7803   26.220   26.214 14   4        131.82     24.2d  0.00   0.000   7.429  \"q-inv\"\n",
+      "     5.7958   26.223   18.951 14   4        153.17     32.7d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.7958   26.223   18.951 14   4        153.17     32.7d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8151   26.223   18.951 14   7        153.17     32.7d  0.00   0.000   0.026  \"TYPE_CHNGE\"\n",
+      "     5.8151   26.223   18.951 14   7        153.17     32.7d  0.00   0.000   0.026  \"Start tidal lock 2\"\n",
+      "     5.8151   26.223   18.951 14   7        153.17     32.7d  0.00   0.000   0.026  \"End Carbon Star 2\"\n",
+      "     6.1822   26.223   18.951 14  14        167.09     37.2d  0.35   0.000   0.000  Mers(5)=0.511555 - Mers(6)=0.0780381 - Mers(7)=0.943979 - Mers(8)=0.857062 - Mers(9)=0.20741 \n",
+      "     6.1822   26.223   18.951 14  14        167.09     37.2d  0.35   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=18.9511 Mc\"CO\"=14.2992 type=8) -> kick 1(190) vk=125.245 vr=237.237 omega=1.3032 phi=0.795373 -> vn=246.918 ; final sep 167.086 ecc 0.351262 (random count 5) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1822   26.223   18.951 14  14        167.09     37.2d  0.35   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1822   26.223   18.951 14  14        167.09     37.2d  0.35   0.000   0.000  \"SN\"\n",
+      "     6.1822   26.223   18.951 14  14        167.09     37.2d  0.35   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.223   18.951 14  14        166.82     37.1d  0.35   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -47.307}\n",
+      "System 1 has separation -47.307\n",
+      "system 2 / 100\n",
+      "{'time': 6.1814, 'M1': 26.225, 'M2': 19.012, 'K1': 14.0, 'K2': 14.0, 'separation': 2352.5}\n",
+      "System 2 has separation 2352.5\n",
+      "Found bound BHBH system\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=75338 RANDOM_COUNT=0\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"INITIAL \"\n",
+      "     0.0000   60.000   40.000  1   1        3101.2     5.48y  0.00   0.006   0.006  \"Start Carbon Star 1\"\n",
+      "     3.7617   60.000   40.000  2   1        3101.2     5.48y  0.00   0.018   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7647   60.000   40.000  2   1        3101.2     5.48y  0.00   0.572   0.010  \"Start tidal lock 1\"\n",
+      "     3.7647   60.000   40.000  4   1        3101.2     5.48y  0.00   0.583   0.010  \"TYPE_CHNGE\"\n",
+      "     3.7721   60.000   40.000  4   1        3101.2     5.48y  0.00   0.633   0.010  \"End tidal lock 1\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_RCHE 1>2\"\n",
+      "     3.7785   60.000   40.000  4   1        3100.8     5.48y  0.00   1.001   0.010  \"BEG_SYMB\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  \"TYPE_CHNGE\"\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  Unstable RLOF : q=Mdonor/Maccretor=1.09665 > qc=0.714712 (prescription=float, donor [st=5 M=52.3048 Mc=27.0276 R=2332.11 Rc=1.71818], accretor [st=1 M=47.6952 Mc=0 R=10.9757 Rc=0] sep=2791.57 )\n",
+      "     4.1326   52.305   47.695  5   1        2791.6     4.68y  0.00   2.159   0.011  COMENV n=0 presc=0 52.3048(Mc\"He\"=27.0276,\"CO\"=27.0276;EAGB)+47.6952(Mc;MS) - LAMBDA(fixed,st=5,m01=60,mc1=27.0276,l1=1.44223e+06,r1=2332.11,rzams=8.33552,convfrac=0.467851,lambda_ion=0.5)=0.5 - alpha=0.1 lambda=0.5 - a_in=2791.57 P_in=1708.33 Jtot_in=8.09706e+55 Jorb_in=7.96557e+55 EorbI=8.76416e+47 EbindI=-4.30388e+48 - sepF=55.7114 1:Rc=1.71818~RL=18.4385 2:Rc=10.9758~RL=23.8926 - : Mf1=27.0276(20.5423,9) Mf2=47.6952(0,1) af=55.7114 Jf=6.72832e+54 Jej=7.63566e+55 Eorbf=-4.39152e+49 dE=4.30388e+48 Eej=1.03996e+48 alpha_ej=0.0241634\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  post-COMENV M=27.0276(Mc\"CO\"=20.5423;HeGB;Menv=20.5423,Mstart=27.0276,Teff=0.397754,age=3084.58) + M=47.6952(Mc;MS;Menv=47.6952,Mstart=47.6952,Teff=2.9071,age=46089.5) a_out=55.7114 P_out=0.0152545 (5.57093 d) Jorb_out=6.72832e+54 R1=6771.28 RL1=18.4385 (R1/RL1 = 367.236) R2=10.9758 RL2=23.8926 (R2/RL2 = 0.459382) SN? 0 0 Single? No : merge in 14.9411 Gyr at t = 14.9452 Gyr, events pending? 1\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"TYPE_CHNGE\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"q-inv\"\n",
+      "     4.1327   27.028   47.695  9   1        55.711     5.57d  0.00 367.232   0.459  \"End Carbon Star 1\"\n",
+      "     4.1327   26.215   48.508 14   1        113.09     16.1d  0.34   0.000   0.284  Randbuf=50699 - Mers(0)=0.383992 - Mers(1)=0.329633 - Mers(2)=0.381873 - Mers(3)=0.148373 - Mers(4)=0.259864 \n",
+      "     4.1327   26.215   48.508 14   1        113.09     16.1d  0.34   0.000   0.284  SN kick Ib/c (SN type 11 11, pre-explosion M=26.2147 Mc\"CO\"=20.5423 type=9) -> kick 1(190) vk=170.057 vr=401.272 omega=1.63278 phi=-0.779965 -> vn=442.661 ; final sep 113.09 ecc 0.343321 (random count 0) - Runaway v=(0,0,0) |v|=0 : companion v=(0,0,0), |v|=0 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     4.1327   26.215   48.508 14   1        113.09     16.1d  0.34   0.000   0.284  \"TYPE_CHNGE\"\n",
+      "     4.1327   26.215   48.508 14   1        113.09     16.1d  0.34   0.000   0.284  \"END_RCHE 1!>2\"\n",
+      "     4.1327   26.215   48.508 14   1        113.09     16.1d  0.34   0.000   0.284  \"SN\"\n",
+      "     4.1327   26.215   48.508 14   1        122.04     18.1d  0.34   0.000   0.206  \"END_SYMB\"\n",
+      "     4.4862   26.215   48.508 14   1         127.9     19.4d  0.34   0.000   0.218  \"BEG_BSS \"\n",
+      "     5.7418   26.215   48.508 14   2        132.67     20.5d  0.36   0.000   0.340  \"OFF_MS\"\n",
+      "     5.7418   26.215   48.508 14   2        132.67     20.5d  0.36   0.000   0.340  \"TYPE_CHNGE\"\n",
+      "     5.7418   26.215   48.508 14   2        132.67     20.5d  0.36   0.000   0.340  \"END_BSS\"\n",
+      "     5.7433   26.215   48.508 14   2        132.64     20.5d  0.36   0.000   0.970  \"Start tidal lock 2\"\n",
+      "     5.7434   26.215   48.508 14   2        132.63     20.5d  0.36   0.000   1.000  \"BEG_RCHE 2>1\"\n",
+      "     5.7434   26.215   48.508 14   2        115.69     16.7d  0.00   0.000   1.147  \"BEG_SYMB\"\n",
+      "     5.7434   26.215   48.508 14   2        115.69     16.7d  0.00   0.000   1.147  \"End tidal lock 2\"\n",
+      "     5.7434   26.215   48.508 14   2        115.69     16.7d  0.00   0.000   1.147  \"Circularized\"\n",
+      "     5.7454   26.215   48.359 14   2        116.39     16.8d  0.00   0.000   4.654  \"Start tidal lock 2\"\n",
+      "     5.7457   26.215   48.233 14   2        116.91       17d  0.00   0.000   5.990  \"End tidal lock 2\"\n",
+      "     5.7459   26.215   48.162 14   4        117.17       17d  0.00   0.000   6.652  \"TYPE_CHNGE\"\n",
+      "     5.7899   26.222   27.157 14   4        164.44     33.4d  0.00   0.000   7.148  \"Start Carbon Star 2\"\n",
+      "     5.7915   26.222   26.206 14   4        167.44     34.6d  0.00   0.000   7.339  \"q-inv\"\n",
+      "     5.8057   26.225   19.012 14   4        194.26     46.6d  0.00   0.000   0.998  \"END_RCHE 2!>1\"\n",
+      "     5.8057   26.225   19.012 14   4        194.26     46.6d  0.00   0.000   0.993  \"END_SYMB\"\n",
+      "     5.8254   26.225   19.012 14   7        194.26     46.6d  0.00   0.000   0.021  \"TYPE_CHNGE\"\n",
+      "     5.8254   26.225   19.012 14   7        194.26     46.6d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     5.8254   26.225   19.012 14   7        194.26     46.6d  0.00   0.000   0.021  \"End Carbon Star 2\"\n",
+      "     5.8603   26.225   19.012 14   7        194.26     46.6d  0.00   0.000   0.021  \"End tidal lock 2\"\n",
+      "     6.1574   26.225   19.012 14   7        194.26     46.6d  0.00   0.000   0.021  \"Start tidal lock 2\"\n",
+      "     6.1814   26.225   19.012 14  14        2352.5     5.38y  0.96   0.000   0.000  Mers(5)=0.0317437 - Mers(6)=0.390641 - Mers(7)=0.74508 - Mers(8)=0.290805 - Mers(9)=0.100226 \n",
+      "     6.1814   26.225   19.012 14  14        2352.5     5.38y  0.96   0.000   0.000  SN kick Ib/c (SN type 11 11, pre-explosion M=19.0115 Mc\"CO\"=14.3459 type=8) -> kick 1(190) vk=227.967 vr=210.804 omega=0.629737 phi=-0.431673 -> vn=291.902 ; final sep 2352.48 ecc 0.957953 (random count 5) - Runaway v=(198.238,168.496,-40.7853) |v|=263.349 : companion v=(-10.1489,-33.7503,-11.1544), |v|=36.9663 ; - , dm(exploder) = 0, dm(companion) = 0\n",
+      "     6.1814   26.225   19.012 14  14        2352.5     5.38y  0.96   0.000   0.000  \"TYPE_CHNGE\"\n",
+      "     6.1814   26.225   19.012 14  14        2352.5     5.38y  0.96   0.000   0.000  \"SN\"\n",
+      "     6.1814   26.225   19.012 14  14        2352.5     5.38y  0.96   0.000   0.000  \"End tidal lock 2\"\n",
+      " 15000.0000   26.225   19.012 14  14        2351.4     5.38y  0.96   0.000   0.000  \"MAX_TIME\"\n",
+      "\n",
+      "{'M_1': 60, 'M_2': 40, 'metallicity': 0.001, 'orbital_period': 2000, 'BH_prescription': 'BH_BELCZYNSKI', 'wind_mass_loss': 'WIND_ALGORITHM_NONE', 'alpha_ce': 0.1}\n",
+      "system 1 / 100\n",
+      "None\n",
+      "system 2 / 100\n",
+      "None\n",
+      "system 3 / 100\n",
+      "None\n",
+      "system 4 / 100\n",
+      "{'time': 6.181, 'M1': 26.225, 'M2': 19.042, 'K1': 14.0, 'K2': 14.0, 'separation': -77.195}\n",
+      "System 4 has separation -77.195\n",
+      "system 5 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -133.98}\n",
+      "System 5 has separation -133.98\n",
+      "system 6 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -215.54}\n",
+      "System 6 has separation -215.54\n",
+      "system 7 / 100\n",
+      "{'time': 6.1851, 'M1': 26.215, 'M2': 48.508, 'K1': 14.0, 'K2': 14.0, 'separation': -66.123}\n",
+      "System 7 has separation -66.123\n",
+      "system 8 / 100\n",
+      "{'time': 6.1823, 'M1': 26.223, 'M2': 18.946, 'K1': 14.0, 'K2': 14.0, 'separation': -229.74}\n",
+      "System 8 has separation -229.74\n",
+      "system 9 / 100\n"
+     ]
+    },
+    {
+     "ename": "KeyboardInterrupt",
+     "evalue": "",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_26668/2128365523.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     11\u001b[0m \u001b[0mfound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     12\u001b[0m \u001b[0;32mwhile\u001b[0m \u001b[0mfound\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;32mFalse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 13\u001b[0;31m     \u001b[0md\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0msearch_for_BHBH\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m**\u001b[0m\u001b[0margs\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     14\u001b[0m     \u001b[0;32mif\u001b[0m \u001b[0md\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0;32mNone\u001b[0m \u001b[0;32mand\u001b[0m \u001b[0md\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m'separation'\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m<\u001b[0m \u001b[0;36m10.0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0mfound\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;32mTrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m/tmp/ipykernel_26668/3037695552.py\u001b[0m in \u001b[0;36msearch_for_BHBH\u001b[0;34m(maxcount, **opts)\u001b[0m\n\u001b[1;32m      6\u001b[0m         \u001b[0mcount\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mcount\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m         \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"system {} / {}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcount\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0mmaxcount\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         output = run_system(**opts,\n\u001b[0m\u001b[1;32m      9\u001b[0m                             \u001b[0mlog_filename\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlog_filename\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     10\u001b[0m                             \u001b[0mapi_log_filename_prefix\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mTMP_DIR\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;32m~/.local/lib/python3.9/site-packages/binarycpython/utils/run_system_wrapper.py\u001b[0m in \u001b[0;36mrun_system\u001b[0;34m(**kwargs)\u001b[0m\n\u001b[1;32m    102\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    103\u001b[0m     \u001b[0;31m# Call binary_c\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 104\u001b[0;31m     output = _binary_c_bindings.run_system(\n\u001b[0m\u001b[1;32m    105\u001b[0m         \u001b[0mbinary_c_command\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m    106\u001b[0m         \u001b[0mcustom_logging_func_memaddr\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mfunc_memaddr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
+     ]
+    }
+   ],
+   "source": [
+    "args = dict(\n",
+    "            M_1=60, \n",
+    "            M_2=40,\n",
+    "            metallicity=0.001,\n",
+    "            orbital_period=2000, # days    \n",
+    "            BH_prescription='BH_BELCZYNSKI',\n",
+    "            wind_mass_loss='WIND_ALGORITHM_NONE',\n",
+    "            alpha_ce=0.1,\n",
+    "           )\n",
+    "\n",
+    "found = False\n",
+    "while found == False:\n",
+    "    d = search_for_BHBH(100,**args)\n",
+    "    if d != None and d['separation'] < 10.0:\n",
+    "        found = True\n",
+    "    \n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "3630cb2a-900e-48a2-a114-8abb7acf56b7",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "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.6.4"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/notebook_HRD.ipynb b/examples/notebook_HRD.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..23202ff3a1af319f4a7c3d9e99e925cc24e10466
--- /dev/null
+++ b/examples/notebook_HRD.ipynb
@@ -0,0 +1,818 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Hertzsprung-Russell diagrams\n",
+    "\n",
+    "In this notebook we compute Hertzsprung-Russell diagrams (HRDs) of single and binary stars.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_HRD\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "First we set up a new population object. Our stars evolve to $13.7\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. These are rough approximations: a real population was born some finite time ago, so cannot possibly evolve to $13.7\\mathrm{Gyr}$, and stars are not really born with a metallicity of $0.02$. These approximations only affect very low mass stars, so we assume all our stars have mass $M\\geq 1 \\mathrm{M}_\\odot$, and metallicity does not change evolution too much except in massive stars through the dependence of their winds on metallicity, so we limit our study to $M\\leq 10 \\mathrm{M}_\\odot$."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    tmp_dir=TMP_DIR,\n",
+    "    verbosity=1\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $10\\mathrm{M}_\\odot$ in nine steps (so the masses are integers). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"M_1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        11\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1,2,1)\",\n",
+      "    \"precode\": null,\n",
+      "    \"probdist\": \"1\",\n",
+      "    \"dphasevol\": \"dM_1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"edge\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10} \n",
+    "massrange = (1, 11) \n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"M_1\",\n",
+    "    longname=\"Primary mass\", # == single-star mass\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{res}\".format(res = resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(1,2,1)\", # space by unit masses\n",
+    "    probdist=\"1\", # dprob/dm1 : we don't care, so just set it to 1\n",
+    "    dphasevol=\"dM_1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    "    gridtype=\"edge\"\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "\n",
+    "We now construct the HRD output.\n",
+    "\n",
+    "We choose stars prior to and including the thermally-pulsing asymptotic giant branch (TPAGB) phase that have $>0.1\\mathrm{M}_\\odot$ of material in their outer hydrogen envelope (remember the core of an evolved star is made of helium or carbon/oxygen/neon). This prevents us showing the post-AGB phase which is a bit messy and we avoid the white-dwarf cooling track."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "Foreach_star(star)\n",
+      "{\n",
+      "    if(star->stellar_type <= TPAGB &&\n",
+      "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+      "    {\n",
+      "         double logTeff = log10(Teff_from_star_struct(star));\n",
+      "         double logL = log10(star->luminosity); \n",
+      "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+      "         Printf(\"HRD%d %30.12e %g %g %g %g\\n\",\n",
+      "                star->starnum, // 0\n",
+      "                stardata->model.time, // 1\n",
+      "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+      "                logTeff, // 3\n",
+      "                logL, // 4\n",
+      "                loggravity // 5\n",
+      "                );\n",
+      "\n",
+      "    }\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "Foreach_star(star)\n",
+    "{\n",
+    "    if(star->stellar_type <= TPAGB &&\n",
+    "       star->mass - Outermost_core_mass(star) > 0.1)\n",
+    "    {\n",
+    "         double logTeff = log10(Teff_from_star_struct(star));\n",
+    "         double logL = log10(star->luminosity); \n",
+    "         double loggravity = log10(TINY+GRAVITATIONAL_CONSTANT*M_SUN*star->mass/Pow2(star->radius*R_SUN));\n",
+    "         Printf(\"HRD%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                star->starnum, // 0\n",
+    "                stardata->model.time, // 1\n",
+    "                stardata->common.zero_age.mass[0], // 2 : note this is the primary mass\n",
+    "                logTeff, // 3\n",
+    "                logL, // 4\n",
+    "                loggravity // 5\n",
+    "                );\n",
+    "\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"HRD*n*\", where *n* is 0 (primary star) or 1 (secondary star, which doesn't exist in single-star systems), and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14565763dca0> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"logTeff\", \"logL\", \"logg\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        match = re.search('HRD(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            \n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "            # first time setup of the list of tuples\n",
+    "            if(len(self.grid_results['HRD'][nstar][linedata['zams_mass']])==0):\n",
+    "                self.grid_results['HRD'][nstar][linedata['zams_mass']] = []\n",
+    "\n",
+    "            # make the HRD be a list of tuples\n",
+    "            self.grid_results['HRD'][nstar][linedata['zams_mass']].append((linedata['logTeff'],\n",
+    "                                                                           linedata['logL']))\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: verbosity=0 to grid_options\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-20bee5b0c58d49c5bc47eced240685bb finished! The total probability was: 10.0. It took a total of 0.543649435043335s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=0,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': '20bee5b0c58d49c5bc47eced240685bb', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 10.0, 'total_count': 10, 'start_timestamp': 1631304519.45189, 'end_timestamp': 1631304519.9955394, 'total_mass_run': 55.0, 'total_probability_weighted_mass_run': 55.0, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    for zams_mass in sorted(hrd[nstar]):\n",
+    "        print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "        # get track data (list of tuples)\n",
+    "        track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "        # convert to Pandas dataframe\n",
+    "        data = pd.DataFrame(data=track, \n",
+    "                            columns = ['logTeff','logL'])\n",
+    "        \n",
+    "        # make seaborn plot\n",
+    "        p = sns.lineplot(data=data,\n",
+    "                         sort=False,\n",
+    "                         x='logTeff',\n",
+    "                         y='logL',\n",
+    "                         estimator=None)\n",
+    "        \n",
+    "        # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "        p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "        \n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "We now have an HRD. It took longer to make the plot than to run the stars with *binary_c*!"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
+   "metadata": {},
+   "source": [
+    "## Binary stars"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "71d0fc4e-c72f-444a-93ab-19f52086b86d",
+   "metadata": {},
+   "source": [
+    "Now we put a secondary star of mass $0.5\\mathrm{M}_\\odot$ at a distance of $10\\mathrm{R}_\\odot$ to see how this changes things. Then we rerun the population. At such short separations, we expect mass transfer to begin on or shortly after the main sequence."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "478e8005-e144-4e6f-80c9-0cf368a9bcb3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-cff93424298e4862bb72096e72b98a2d finished! The total probability was: 10.0. It took a total of 0.9686374664306641s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 0.5, # Msun\n",
+    "    separation = 10, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "9c433e6a-fe22-4494-b1a9-fce9676a9f40",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "zams mass  1.0\n",
+      "zams mass  2.0\n",
+      "zams mass  3.0\n",
+      "zams mass  4.0\n",
+      "zams mass  5.0\n",
+      "zams mass  6.0\n",
+      "zams mass  7.0\n",
+      "zams mass  8.0\n",
+      "zams mass  9.0\n",
+      "zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "3557b6d5-6c54-467c-b7a1-b1903493c441",
+   "metadata": {},
+   "source": [
+    "We plot here the track for the primary star only. You can see immediately where stars merge on the main sequence: the tracks move very suddenly where usually evolution on the main sequence is smooth."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "59335030-dd99-4c2f-afff-207a3fcbbb70",
+   "metadata": {},
+   "source": [
+    "If we now set the separation to be longer, say $100\\mathrm{R}_\\odot$, mass transfer should happen on the giant branch. We also set the secondary mass to be larger, $1\\mathrm{M}_\\odot$, so that the interaction is stronger."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "dee92b20-ad6b-4c97-80dc-71d3bd937c4e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Grid has handled 10 stars\n",
+      "with a total probability of 10.0\n",
+      "Total starcount for this run will be: 10\n",
+      "Generating grid code\n",
+      "Constructing/adding: M_1\n",
+      "Population-2ea4759ed05544ef8f1b7a887f0f36d2 finished! The total probability was: 10.0. It took a total of 0.7215321063995361s to run 10 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "population.set(\n",
+    "    M_2 = 1, # Msun\n",
+    "    separation = 100, # Rsun\n",
+    "    multiplicity = 2, # binaries\n",
+    "    alpha_ce = 1.0, # make common-envelope evolution quite efficient\n",
+    ")\n",
+    "population.clean()\n",
+    "analytics = population.evolve()  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "e0ac2573-bc35-43be-8f20-5c85364fde11",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n",
+      "star  1\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '0': # choose only primaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "        \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "            # set mass label at the zero-age main sequence (ZAMS) which is the first data point\n",
+    "            p.text(track[0][0],track[0][1],str(zams_mass))\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "16f8e061-a65e-47f2-a777-93de0d5045ea",
+   "metadata": {},
+   "source": [
+    "You now see the interaction in the jerky red-giant tracks where the stars interact. These probably, depending on the mass ratio at the moment of interaction, go through a common-envelope phase. The system can merge (most of the above do) but not all. The interaction is so strong on the RGB of the $1\\mathrm{M}_\\odot$ star that the stellar evolution is terminated before it reaches the RGB tip, so it never ignites helium. This is how helium white dwarfs are probably made."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "698d0a63-11ba-4b3e-a713-35c3e972492f",
+   "metadata": {},
+   "source": [
+    "We can also plot the secondary stars' HRD. Remember, the primary is star 0 in binary_c, while the secondary is star 1. That's because all proper programming languages start counting at 0. We change the parsing function a little so we can separate the plots of the secondaries according to their primary mass."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "2b0b7c2b-6e43-48ed-9257-9dfc141b3d28",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "star  0\n",
+      "star  1\n",
+      "primary zams mass  1.0\n",
+      "primary zams mass  2.0\n",
+      "primary zams mass  3.0\n",
+      "primary zams mass  4.0\n",
+      "primary zams mass  5.0\n",
+      "primary zams mass  6.0\n",
+      "primary zams mass  7.0\n",
+      "primary zams mass  8.0\n",
+      "primary zams mass  9.0\n",
+      "primary zams mass  10.0\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, '$\\\\log_{10} (L/$L$_{☉})$')"
+      ]
+     },
+     "execution_count": 13,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "hrd = population.grid_results['HRD']\n",
+    "\n",
+    "for nstar in sorted(hrd):\n",
+    "    print(\"star \",nstar)\n",
+    "    \n",
+    "    if nstar == '1': # choose only secondaries\n",
+    "\n",
+    "        for zams_mass in sorted(hrd[nstar]):\n",
+    "            print(\"primary zams mass \",zams_mass)\n",
+    "        \n",
+    "            # get track data (list of tuples)\n",
+    "            track = hrd[nstar][zams_mass]\n",
+    "        \n",
+    "            # convert to Pandas dataframe\n",
+    "            data = pd.DataFrame(data=track, \n",
+    "                                columns = ['logTeff','logL'])\n",
+    "            \n",
+    "            # make seaborn plot\n",
+    "            p = sns.lineplot(data=data,\n",
+    "                             sort=False,\n",
+    "                             x='logTeff',\n",
+    "                             y='logL',\n",
+    "                             estimator=None)\n",
+    "\n",
+    "\n",
+    "p.invert_xaxis()\n",
+    "p.set_xlabel(\"$\\log_{10} (T_\\mathrm{eff} / \\mathrm{K})$\")\n",
+    "p.set_ylabel(\"$\\log_{10} (L/$L$_{☉})$\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "92c46319-5629-4125-a284-b5d521ed33fc",
+   "metadata": {},
+   "source": [
+    "Remember, all these stars start with a $1\\mathrm{M}_\\odot$ binary, which begins at $\\log_{10}(T_\\mathrm{eff}/\\mathrm{K})\\sim 3.750$, $\\log_{10}L/\\mathrm{L}_\\odot \\sim 0$. The $1\\mathrm{M}_\\odot$-$1\\mathrm{M}_\\odot$ binary evolves like two single stars until they interact up the giant branch at about $\\log_{10} (L/\\mathrm{L}_\\odot) \\sim 2.5$, the others interact long before they evolve very far on the main sequence: you can just about see their tracks at the very start."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53145356-abbb-4880-996f-dedd80de7540",
+   "metadata": {},
+   "source": [
+    "This is, of course, a very simple introduction to what happens in binaries. We haven't talked about the remnants that are produced by interactions. When the stars do evolve on the giant branch, white dwarfs are made which can go on to suffer novae and (perhaps) thermonuclear explosions. The merging process itself leads to luminosus red novae and, in the case of neutron stars and black holes, kilonovae and gravitational wave events. "
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/notebook_api_functionality.ipynb b/examples/notebook_api_functionality.ipynb
index d81c31711bfc5d6de3159fd8958df96dd145ded0..020d2dc7cdb1ae9f1214d42e3351b571ff0c943d 100644
--- a/examples/notebook_api_functionality.ipynb
+++ b/examples/notebook_api_functionality.ipynb
@@ -5,7 +5,7 @@
    "id": "cb9d00f5-9613-471e-a4bb-6181311bf73b",
    "metadata": {},
    "source": [
-    "# Using the API functionality of binarycpython\n",
+    "# Tutorial: Using the API functionality of binary_c-python\n",
     "This notebook shows how to use the API functions that interface with binary_c. It usually is better to use wrapper functions that internally use these API functions, because most of the output here is very raw\n",
     "\n",
     "Binarycpython uses the Python-C extension framework to interface Python with C. The sourcecode for this is contained in `src/binary_c_python.c`, and the functions are available via `from binarycpython import _binary_c_bindings`.\n",
@@ -15,7 +15,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 1,
    "id": "ded7eaf6-e1ba-46c2-9f6f-9ebcb14a264d",
    "metadata": {},
    "outputs": [
@@ -30,37 +30,69 @@
       "\n",
       "FUNCTIONS\n",
       "    free_persistent_data_memaddr_and_return_json_output(...)\n",
-      "        Frees the persistent_data memory and returns the json output\n",
+      "        Frees the persistent_data memory and returns the json output.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the persistent data object (contains the ensemble)\n",
       "    \n",
       "    free_store_memaddr(...)\n",
-      "        Frees the store memaddr\n",
+      "        Frees the store memaddr.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                store capsule: capsule containing the memory adress of the store object\n",
       "    \n",
       "    return_arglines(...)\n",
       "        Return the default args for a binary_c system\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_help(...)\n",
       "        Return the help info for a given parameter\n",
+      "        \n",
+      "        Arguments:\n",
+      "                parameter: parameter name.\n",
       "    \n",
       "    return_help_all(...)\n",
       "        Return an overview of all the parameters, their description, categorized in sections\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_maximum_mass_ratio_for_RLOF(...)\n",
-      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at zams. Optionally accepts a store_capsule. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the maximum mass ratio for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_minimum_orbit_for_RLOF(...)\n",
-      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at zams. Please use the wrapper functions in utils for this except when you know what you're doing\n",
+      "        Returns a string containing the minimum orbit and separation for which a binary system does not RLOF at ZAMS. Please use the wrapper functions in utils for this except when you know what you're doing.\n",
+      "        \n",
+      "        Arguments:\n",
+      "                argstring: argument string for binary_c\n",
+      "                (opt) store_capsule: capsule containing memory adress for the store object.unction. Default = Null\n",
       "    \n",
       "    return_persistent_data_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_store_memaddr(...)\n",
       "        Return the store memory adress that will be passed to run_population\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    return_version_info(...)\n",
       "        Return the version information of the used binary_c build\n",
+      "        \n",
+      "        Arguments:\n",
+      "                No arguments.\n",
       "    \n",
       "    run_system(...)\n",
-      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things. \n",
+      "        Function to run a system. This is a general function that will be able to handle different kinds of situations: single system run with different settings, population run with different settings, etc. To avoid having too many functions doing slightly different things.\n",
       "        \n",
       "        Arguments:\n",
       "                argstring: argument string for binary_c\n",
@@ -126,7 +158,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 2,
    "id": "10a74d5a-a3d5-4543-a5bc-20d1fe885bb4",
    "metadata": {},
    "outputs": [
@@ -134,8 +166,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "<capsule object \"STORE\" at 0x7f163859d0c0>\n",
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
+      "<capsule object \"STORE\" at 0x7fa6a45ed180>\n",
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
       "\n"
      ]
     }
@@ -183,7 +215,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 3,
    "id": "318874f6-7acf-49bb-9786-299d4dffc0b3",
    "metadata": {},
    "outputs": [
@@ -217,7 +249,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 4,
    "id": "d7e757ae-579c-42a2-a310-f0401b7800e8",
    "metadata": {
     "scrolled": true,
@@ -291,6 +323,9 @@
       "opacity_algorithm : Set the opacity algorithm. 0 = Paczynski, 1 = Ferguson/Opal. : (null)\n",
       "wind_mass_loss : Defines the algorithm used for stellar winds. 0 = none, 1 = Hurley et al. (2002), 2 = Schneider (2018). : 0\n",
       "gbwind : Wind prescription for first red giant branch stars.  0=Reimers (Hurley et al 2000/2002; choose gb_reimers_eta=0.5 for their mass loss rate), 1=Schroeder+Cuntz 2005 (set gb_reimers_eta=1.0 for their mass loss rate). : (null)\n",
+      "postagbwind : Apply special post-(A)GB prescription. Default is POSTAGB_WIND_USE_GIANT which means we just use whatever is prescribed on the giant branch. Other options include: POSTAGB_WIND_NONE = 1 (no wind on the post (A)GB), POSTAGB_WIND_KRTICKA2020 = 2 which uses Krticka, Kubát and Krticková (2020, A&A 635, A173). : (null)\n",
+      "Teff_postAGB_min : The minimum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_max. (6000 K) : (null)\n",
+      "Teff_postAGB_max : The maximum temperature for which we apply post-(A)GB winds. See also Teff_postAGB_min. (120000 K) : (null)\n",
       "mattsson_Orich_tpagbwind : Experimental : turns on Mattsson's TPAGB wind when the star is oxygen rich. Requires MATTSSON_MASS_LOSS. : (null)\n",
       "magnetic_braking_factor : Multiplier for the magnetic braking angular momentum loss rate. : (null)\n",
       "magnetic_braking_gamma : gamma factor in Rappaport style magnetic braking expression. : (null)\n",
@@ -310,7 +345,9 @@
       "vw93_mira_shift : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate depends on the Mira period plus this offset. Requires VW93_MIRA_SHIFT. : (null)\n",
       "vw93_multiplier : In the Vassiliadis and Wood (1993) AGB wind prescription, the wind loss rate is multiplied by this factor. Requires VW93_MULTIPLIER. : (null)\n",
       "tpagb_reimers_eta : TPAGB Reimers wind multiplication factor, cf. eta in Reimers' mass loss formula. (This multiplies the 4e-13 in Reimers' formula, or the 8e-14 in Schroeder and Cuntz.) Note that Reimers is not the default TPAGB wind prescription. See also tpagbwind. : (null)\n",
+      "Tout_Pringle_1992_multiplier : Multiplier for the Tout & Pringle (1992) magnetic wind. (0.0) : (null)\n",
       "artificial_mass_accretion_rate%d : Constant mass accretion rate for star <n>. : (null)\n",
+      "artificial_mass_accretion_rate_by_stellar_type%d : Constant mass accretion rate for stellar type <n>. : (null)\n",
       "artificial_angular_momentum_accretion_rate%d : Constant angular momentum accretion for star <n>. : (null)\n",
       "artificial_orbital_angular_momentum_accretion_rate : Constant angular momentum accretion rate on the orbit. : (null)\n",
       "artificial_accretion_start_time : Time at which artificial accretion stars. Ignored if <0 (default is -1). : (null)\n",
@@ -318,8 +355,7 @@
       "wr_wind : Massive-star (WR) wind prescription. 0 = Hurley et al 2000/2002, 1=Maeder and Meynet, 2=Nugis and Lamers, 3=John Eldridge's version of Vink's early-2000s wind (See Lynnette Dray's thesis, or John Eldridge's thesis) : (null)\n",
       "wr_wind_fac : Massive-star (WR) wind multiplication factor. : (null)\n",
       "wrwindfac : Massive-star (WR) wind multiplication factor. Synonymous with wr_wind_fac (which you should use instead). : (null)\n",
-      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. 0=Hurley et al 2000/2002, 1=Belczynski (early 2000s). : (null)\n",
-      "PPISN_prescription : (Pulsational) Pair-Instability Supernova prescription: Relates initial helium core mass of star to whether the star undergoes PPISN or PISN. Requires PPISN flag to be True (see binary_c_parameters.h). 0=no ppisn, 1=Farmer et al 2019. : Ignore\n",
+      "BH_prescription : Black hole mass prescrition: relates the mass of a newly formed black hole to its progenitor's (CO) core mass. BH_HURLEY2002 = 0 = Hurley et al 2000/2002, BH_BELCZYNSKI = 1 = Belczynski (early 2000s), BH_SPERA2015 = Spera+ 2015, BH_FRYER12_DELAYED = 3 = Fryer et al. (2012) delayed prescription, BH_FRYER12_RAPID = 4 = Fryer et al. (2012) rapid prescription, BH_FRYER12_STARTRACK = 5 = Fryer et al. (2012) startrack prescription. : (null)\n",
       "sn_kick_distribution_II : Set the distribution of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_ECAP : Set the distribution of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_NS_NS : Set the distribution of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -331,9 +367,6 @@
       "sn_kick_distribution_BH_NS : Set the distribution of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD : Set the distribution of speeds applied to any survivor of a hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_distribution_IA_Hybrid_HeCOWD_subluminous : Set the distribution of speeds applied to any survivor of a subluminous hybrid He-COWD SNIa explosion. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PPISN : Set the distribution of speeds applied to PPISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PISN : Set the distribution of speeds applied to PISN supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_distribution_PHDIS : Set the distribution of speeds applied to PHDIS supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_II : Set the dispersion of speeds applied to kick type II core collapse supernova systems. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_ECAP : Set the dispersion of speeds applied to the remnants of electron-capture supernovae. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_NS_NS : Set the dispersion of speeds applied to kick neutron stars and black holes that survive a NS-NS merger. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
@@ -345,9 +378,6 @@
       "sn_kick_dispersion_BH_NS : Set the dispersion of speeds applied to black holes formed by the merger of a neutron star and a black holes. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD : Set the dispersion of speeds applied to the survivor of a SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_dispersion_IA_Hybrid_HeCOWD_subluminous : Set the dispersion of speeds applied to the survivor of a subluminous SNIa explosion of a hybrid He-COWD. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PPISN : Set the dispersion of speeds applied to the survivor of a PPISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PISN : Set the dispersion of speeds applied to the survivor of a PISN supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
-      "sn_kick_dispersion_PHDIS : Set the dispersion of speeds applied to the survivor of a PHDIS supernova. 0=fixed, 1=maxwellian (hurley/BSE), 2=custom function (see monte_carlo_kicks.c). : (null)\n",
       "sn_kick_companion_IA_He : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia He supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_ELD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia ELD (sub-Mch) supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_CHAND : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a Ia Mch supernova occurs. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
@@ -368,9 +398,6 @@
       "sn_kick_companion_BH_NS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the, kick on the companion when a black hole merges with a neutron star. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "sn_kick_companion_IA_Hybrid_HeCOWD_subluminous : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a subluminous hybrid He-COWD type Ia explosion. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PPISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PPISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PISN : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PISN supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
-      "sn_kick_companion_PHDIS : Set the speed (if >=0) of, or the algothim (if <0) used to calculate the kick on the companion, if it survives, in a PHDIS supernova. 0 = none, 1 = Liu+2015, 2 = Wheeler+ 1975. : (null)\n",
       "wd_sigma : Set the speed at which white dwarfs are kicked when they form, in km/s. Default is zero (i.e. no kick). Requires WD_KICKS. : (null)\n",
       "wd_kick_direction : Set the direction of white dwarf kicks. 0 = random, 1 = up, 2 = forward, 3 = backward, 4 = inward, 5 = outward. Requires WD_KICKS. : (null)\n",
       "wd_kick_when : Decide when to kick a white dwarf. 0=at birth, 1=at first RLOF, 2=at given pulse number (see wd_kick_pulse_number), 3 at every pulse Requires WD_KICKS. : (null)\n",
@@ -443,6 +470,11 @@
       "HeWD_HeWD_ignition_mass : HeWD-HeWD mergers above this mass reignite helium. (0.3) : (null)\n",
       "wind_Nieuwenhuijzen_luminosity_lower_limit : Above this luminosity we activate the Nieuwenhuijzen and de Jager wind (4e3 Lsun). : (null)\n",
       "wind_LBV_luminosity_lower_limit : Above this luminosity we activate the LBV wind (6e5 Lsun). : (null)\n",
+      "colour%d : Sets colour %d (0 to NUM_ANSI_COLOURS-1) to the extended ANSI set colour you choose (1-255, 0 means ignore). The colour numbers are defined in src/logging/ansi_colours.h : (null)\n",
+      "apply_Darwin_Radau_correction : Apply Darwin-Radau correction to the moment of inertia to take rotation into account? : (null)\n",
+      "degenerate_core_merger_nucsyn : If TRUE, assume that in a degnerate core merger, energy is generated from nucleosynthesis of the whole core, and that this can disrupt the core. The BSE algorithm (Hurley et al. 2002) assumes this to be TRUE, but binary_c assumes FALSE by default. (FALSE) : (null)\n",
+      "degenerate_core_helium_merger_ignition : If TRUE, assume that when there is a degenerate helium core merger, the star reignites helium. This is required to make R-type carbon stars. (TRUE) : (null)\n",
+      "degenerate_core_merger_dredgeup_fraction : If non-zero, mix this fraction of the degenerate core during a merger.(0.0). : (null)\n",
       "\n",
       "############################################################\n",
       "##### Section Binary\n",
@@ -709,7 +741,6 @@
       "############################################################\n",
       "##### Section Output\n",
       "############################################################\n",
-      "david_logging_function : Function to choose which kind of information gets logged Requires DAVID. Choices are: 0= None, >0 for custom logging functions : Ignore\n",
       "cf_amanda_log : Enable logging to compare to Amanda's models. : (null)\n",
       "float_overflow_checks : Turn on to enable floating-point overflow checks at the end of each timestep, if they are available. 0=off, 1=warn (stderr) on failure, 2=exit on failure (0) : (null)\n",
       "save_pre_events_stardata : Enable this to save a copy of stardata to stardata->pre_events_stardata just before an event. : (null)\n",
@@ -739,6 +770,7 @@
       "escape_fraction : A parameter used in constructing galactic chemical evolution (GCE) models. If the stellar wind velocity exceeds this value, any chemical yield from the wind is ignored, i.e. assumed lost. (km/s) Requires NUCSYN_GCE_OUTFLOW_CHECKS. Default 0.0. See also escape_velocity. : (null)\n",
       "colour_log : If set to True, thelog is coloured with ANSI colour formatting. Requires FILE_LOG to be defined. : \n",
       "log_filename : Location of the output logging filename. If set to \"/dev/null\" then there is no logging. : \n",
+      "log_arrows : Add arrows to the output log to show whether values are increasing or decreasing. : \n",
       "stopfile : File which, when it exists, will stop the current binary_c repeat run. : \n",
       "stardata_dump_filename : Location of the stardata dump file. : \n",
       "stardata_load_filename : Location of the stardata file to load. : \n",
@@ -763,8 +795,12 @@
       "MINT_MS_rejuvenation : Turn on or off (hydrogen) main-sequence rejuvenation. : \n",
       "MINT_remesh : Turn on or off MINT's remeshing. : \n",
       "MINT_use_ZAMS_profiles : Use chemical profiles at the ZAMS if MINT_use_ZAMS_profiles is TRUE, otherwise set homogeneous abundances. (Default is TRUE, so we use the profiles if they are available.) : \n",
+      "MINT_fallback_to_test_data : If TRUE, use the MINT test_data directory as a fallback when data is unavailable. (FALSE) : \n",
       "MINT_disable_grid_load_warnings : Use this to explicitly disable MINT's warnings when loading a grid with, e.g., missing or too much data. : \n",
       "MINT_Kippenhahn : Turn on or off MINT's Kippenhahn diagrams. If 0, off, if 1, output star 1 (index 0), if 2 output star 2 (index 1). Default 0. : \n",
+      "MINT_nshells : Set the initial number of shells MINT uses in each star when doing nuclear burning. Note: remeshing can change this. If MINT_nshells is 0, shellular burning and other routines that require shells will not be available. (200) : \n",
+      "MINT_maximum_nshells : Set the maximum number of shells MINT uses in each star when doing nuclear burning. Note that this will be limited to MINT_HARD_MAX_NSHELLS. (1000) : \n",
+      "MINT_minimum_nshells : Set the minimum number of shells MINT uses in each star when doing nuclear burning. Note that this will be greater than or equal to MINT_HARD_MIN_NSHELLS, which is 0 by default. (0) : \n",
       "MINT_Kippenhahn_stellar_type : Stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for which Kippenhahn plot data should be output. : \n",
       "MINT_Kippenhahn_companion_stellar_type : Companion stellar type selector for Kippenhahn plots. Set to -1 to ignore, otherwise the stellar type number for the companion for which Kippenhahn plot data should be output. : \n",
       "MINT_nuclear_burning : Turn on or off MINT's nuclear burning algorithm. : \n",
@@ -825,7 +861,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 20,
+   "execution_count": 5,
    "id": "3d29ca9d-ac66-4f9e-81cf-2edd14a98b79",
    "metadata": {},
    "outputs": [
@@ -854,7 +890,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "e517f561-09c6-419d-ba89-d9cb61e6ebab",
    "metadata": {},
    "outputs": [
@@ -887,7 +923,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 46,
+   "execution_count": 7,
    "id": "7da75a95-8831-4346-a584-e042ced75249",
    "metadata": {},
    "outputs": [
diff --git a/examples/notebook_common_envelope_evolution.ipynb b/examples/notebook_common_envelope_evolution.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..580dbcfbaa9c5358f10f897c6aa9496d1e2a952f
--- /dev/null
+++ b/examples/notebook_common_envelope_evolution.ipynb
@@ -0,0 +1,708 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "# Example use case: Common-envelope evolution\n",
+    "\n",
+    "In this notebook we look at how common-envelope evolution (CEE) alters binary-star orbits. We construct a population of low- and intermediate-mass binaries and compare their orbital periods before and after CEE. Not all stars evolve into this phase, so we have to run a whole population to find those that do. We then have to construct the pre- and post-CEE distributions and plot them.\n",
+    "\n",
+    "First, we import a few required Python modules. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "import matplotlib.pyplot as plt\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython.utils.grid import Population\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_comenv\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {
+    "tags": []
+   },
+   "source": [
+    "## Setting up the Population object\n",
+    "We set up a new population object. Our stars evolve to $13.7\\text{ }\\mathrm{Gyr}$, the age of the Universe, and we assume the metallicity $Z=0.02$. We also set the common-envelope ejection efficiency $\\alpha_\\mathrm{CE}=1$ and the envelope structure parameter $\\lambda=0.5$. More complex options are available in *binary_c*, such as $\\lambda$ based on stellar mass, but this is just a demonstration example so let's keep things simple."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: log_dt=10 to grid_options\n",
+      "adding: max_evolution_time=13700 to BSE_options\n",
+      "adding: metallicity=0.02 to BSE_options\n",
+      "adding: alpha_ce=1.0 to BSE_options\n",
+      "adding: lambda_ce=0.5 to BSE_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "population.set(\n",
+    "    # grid options\n",
+    "    tmp_dir = TMP_DIR,\n",
+    "    verbosity = 1,\n",
+    "    log_dt = 10, # log every 10 seconds\n",
+    "\n",
+    "    # binary-star evolution options\n",
+    "    max_evolution_time=13700,  # maximum stellar evolution time in Myr (13700 Myr == 13.7 Gyr)\n",
+    "    metallicity=0.02, # 0.02 is approximately Solar metallicity \n",
+    "    alpha_ce = 1.0,\n",
+    "    lambda_ce = 0.5,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Stellar Grid\n",
+    "We now construct a grid of stars, varying the mass from $1$ to $6\\text{ }\\mathrm{M}_\\odot$. We avoid massive stars for now, and focus on the (more common) low- and intermediate-mass stars. We also limit the period range to $10^4\\text{ }\\mathrm{d}$ because systems with longer orbital periods will probably not undergo Roche-lobe overflow and hence common-envelope evolution is impossible."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Added grid variable: {\n",
+      "    \"name\": \"lnm1\",\n",
+      "    \"longname\": \"Primary mass\",\n",
+      "    \"valuerange\": [\n",
+      "        1,\n",
+      "        6\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(math.log(1), math.log(6), 10)\",\n",
+      "    \"precode\": \"M_1=math.exp(lnm1)\",\n",
+      "    \"probdist\": \"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+      "    \"dphasevol\": \"dlnm1\",\n",
+      "    \"parameter_name\": \"M_1\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 0\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"q\",\n",
+      "    \"longname\": \"Mass ratio\",\n",
+      "    \"valuerange\": [\n",
+      "        \"0.1/M_1\",\n",
+      "        1\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(1/M_1, 1, 10)\",\n",
+      "    \"precode\": \"M_2 = q * M_1\",\n",
+      "    \"probdist\": \"flatsections(q, [{'min': 1/M_1, 'max': 1.0, 'height': 1}])\",\n",
+      "    \"dphasevol\": \"dq\",\n",
+      "    \"parameter_name\": \"M_2\",\n",
+      "    \"condition\": \"\",\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 1\n",
+      "}\n",
+      "Added grid variable: {\n",
+      "    \"name\": \"log10per\",\n",
+      "    \"longname\": \"log10(Orbital_Period)\",\n",
+      "    \"valuerange\": [\n",
+      "        0.15,\n",
+      "        5.5\n",
+      "    ],\n",
+      "    \"resolution\": \"10\",\n",
+      "    \"spacingfunc\": \"const(0.15, 4, 10)\",\n",
+      "    \"precode\": \"orbital_period = 10.0 ** log10per\\nsep = calc_sep_from_period(M_1, M_2, orbital_period)\\nsep_min = calc_sep_from_period(M_1, M_2, 10**0.15)\\nsep_max = calc_sep_from_period(M_1, M_2, 10**4)\",\n",
+      "    \"probdist\": \"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**0.15), math.log10(10**4), -0.55)\",\n",
+      "    \"dphasevol\": \"dlog10per\",\n",
+      "    \"parameter_name\": \"orbital_period\",\n",
+      "    \"condition\": null,\n",
+      "    \"gridtype\": \"centred\",\n",
+      "    \"branchpoint\": 0,\n",
+      "    \"grid_variable_number\": 2\n",
+      "}\n"
+     ]
+    }
+   ],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 10, \"q\" : 10, \"per\": 10} \n",
+    "massrange = [1, 6] \n",
+    "logperrange = [0.15, 4]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Logging and handling the output\n",
+    "\n",
+    "We now construct the pre- and post-common envelope evolution data for the first common envelope that forms in each binary. We look at the comenv_count variable, we can see that when it increases from 0 to 1 we have found our object. If this happens, we stop evolution of the system to save CPU time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: C_logging_code=\n",
+      "\n",
+      "/*\n",
+      " * Detect when the comenv_count increased \n",
+      " */\n",
+      "if(stardata->model.comenv_count == 1 && \n",
+      "   stardata->previous_stardata->model.comenv_count == 0)\n",
+      "{\n",
+      "   /*\n",
+      "    * We just had this system's first common envelope:\n",
+      "    * output the time at which this happens, \n",
+      "    * the system's probability (proportional to the number of stars),\n",
+      "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+      "    * the current timestep (post-comenv) orbital period (days)\n",
+      "    */\n",
+      "    Printf(\"COMENV %g %g %g %g\\n\",\n",
+      "           stardata->model.time,\n",
+      "           stardata->model.probability,\n",
+      "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+      "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+      "           \n",
+      "    /*\n",
+      "     * We should waste no more CPU time on this system now we have the\n",
+      "     * data we want.\n",
+      "     */\n",
+      "    stardata->model.evolution_stop = TRUE;\n",
+      "}\n",
+      " to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "custom_logging_statement = \"\"\"\n",
+    "\n",
+    "/*\n",
+    " * Detect when the comenv_count increased \n",
+    " */\n",
+    "if(stardata->model.comenv_count == 1 && \n",
+    "   stardata->previous_stardata->model.comenv_count == 0)\n",
+    "{\n",
+    "   /*\n",
+    "    * We just had this system's first common envelope:\n",
+    "    * output the time at which this happens, \n",
+    "    * the system's probability (proportional to the number of stars),\n",
+    "    * the previous timestep's (pre-comenv) orbital period (days) and\n",
+    "    * the current timestep (post-comenv) orbital period (days)\n",
+    "    */\n",
+    "    Printf(\"COMENV %g %g %g %g\\\\n\",\n",
+    "           stardata->model.time,\n",
+    "           stardata->model.probability,\n",
+    "           stardata->previous_stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS,\n",
+    "           stardata->common.orbit.period * YEAR_LENGTH_IN_DAYS);\n",
+    "           \n",
+    "    /*\n",
+    "     * We should waste no more CPU time on this system now we have the\n",
+    "     * data we want.\n",
+    "     */\n",
+    "    stardata->model.evolution_stop = TRUE;\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"COMENV\" and process the associated data. We set up the parse_data function to do just this."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: parse_function=<function parse_function at 0x14736bebc040> to grid_options\n"
+     ]
+    }
+   ],
+   "source": [
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "# log-period distribution bin width (dex)\n",
+    "binwidth = 0.5 \n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Parsing function to convert HRD data into something that Python can use\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"probability\", \"pre_comenv_period\", \"post_comenv_period\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # obtain the line of data in dictionary form \n",
+    "        linedata = datalinedict(line,parameters)\n",
+    "            \n",
+    "        # choose COMENV lines of output\n",
+    "        if linedata[\"header\"] == \"COMENV\":\n",
+    "            # bin the pre- and post-comenv log10-orbital-periods to nearest 0.5dex\n",
+    "            binned_pre_period = bin_data(math.log10(linedata[\"pre_comenv_period\"]), binwidth)\n",
+    "            \n",
+    "            # but check if the post-comenv period is finite and positive: if \n",
+    "            # not, the system has merged and we give it an aritifical period\n",
+    "            # of 10^-100 days (which is very much unphysical)\n",
+    "            if linedata[\"post_comenv_period\"] > 0.0:\n",
+    "                binned_post_period = bin_data(math.log10(linedata[\"post_comenv_period\"]), binwidth)\n",
+    "            else:\n",
+    "                binned_post_period = bin_data(-100,binwidth) # merged!\n",
+    "                \n",
+    "            # make the \"histograms\"\n",
+    "            self.grid_results['pre'][binned_pre_period] += linedata[\"probability\"]\n",
+    "            self.grid_results['post'][binned_post_period] += linedata[\"probability\"]\n",
+    "\n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now we actually run the population. This may take a little while. You can set amt_cores higher if you have a powerful machine."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 1000 stars\n",
+      "with a total probability of 0.0645905996773004\n",
+      "Total starcount for this run will be: 1000\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:39,950 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-12 18:07:39,953 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-12 18:07:39,959 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-12 18:07:39,962 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-12 18:07:39,965 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-12T18:07:39.965721.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee47e0>\n",
+      "Process 1 started at 2021-09-12T18:07:39.970949.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n",
+      "Process 2 started at 2021-09-12T18:07:39.978355.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4f30>\n",
+      "Process 3 started at 2021-09-12T18:07:39.983689.\tUsing store memaddr <capsule object \"STORE\" at 0x14736bee4870>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:07:40,066 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Loading grid code function from /tmp/binary_c_python/notebooks/notebook_comenv/binary_c_grid_ad303100d719457c83256568f9a9887c.py\n",
+      "Grid code loaded\n",
+      "163/1000  16.3% complete 18:07:49 ETA=   51.5s tpr=6.16e-02 ETF=18:08:41 mem:594.9MB\n",
+      "322/1000  32.2% complete 18:07:59 ETA=   42.9s tpr=6.33e-02 ETF=18:08:42 mem:538.2MB\n",
+      "465/1000  46.5% complete 18:08:09 ETA=   38.1s tpr=7.12e-02 ETF=18:08:47 mem:538.2MB\n",
+      "586/1000  58.6% complete 18:08:19 ETA=   34.3s tpr=8.29e-02 ETF=18:08:54 mem:540.0MB\n",
+      "682/1000  68.2% complete 18:08:30 ETA=   34.0s tpr=1.07e-01 ETF=18:09:04 mem:540.1MB\n",
+      "784/1000  78.4% complete 18:08:40 ETA=   21.2s tpr=9.81e-02 ETF=18:09:01 mem:541.8MB\n",
+      "872/1000  87.2% complete 18:08:50 ETA=   15.0s tpr=1.17e-01 ETF=18:09:05 mem:546.1MB\n",
+      "963/1000  96.3% complete 18:09:00 ETA=    4.2s tpr=1.14e-01 ETF=18:09:04 mem:546.9MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,366 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.964604, done at 2021-09-12T18:09:06.370832 (total: 86.406228s of which 86.24177551269531s interfacing with binary_c).\n",
+      "\tRan 222 systems with a total probability of 0.014137215791516371.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,374 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-12 18:09:06,979 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.953039, done at 2021-09-12T18:09:06.982866 (total: 87.029827s of which 86.82909393310547s interfacing with binary_c).\n",
+      "\tRan 273 systems with a total probability of 0.01877334232598154.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:06,985 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-12 18:09:07,174 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.949775, done at 2021-09-12T18:09:07.176660 (total: 87.226885s of which 87.02672934532166s interfacing with binary_c).\n",
+      "\tRan 268 systems with a total probability of 0.016469813170514686.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,179 DEBUG    Process-2] --- Process-0 is finished.\n",
+      "[2021-09-12 18:09:07,233 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-12T18:07:39.958802, done at 2021-09-12T18:09:07.236252 (total: 87.27745s of which 87.0905077457428s interfacing with binary_c).\n",
+      "\tRan 237 systems with a total probability of 0.015210228389288167.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-12 18:09:07,238 DEBUG    Process-4] --- Process-2 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-ad303100d719457c83256568f9a9887c finished! The total probability was: 0.06459059967730076. It took a total of 87.54819011688232s to run 1000 systems on 4 cores\n",
+      "There were no errors found in this run.\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "analytics = population.evolve()  \n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "#print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging. We check this, and then set about making the plot of the orbital period distributions using Seaborn."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'ad303100d719457c83256568f9a9887c', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.06459059967730076, 'total_count': 1000, 'start_timestamp': 1631462859.9342952, 'end_timestamp': 1631462947.4824853, 'total_mass_run': 4680.235689312421, 'total_probability_weighted_mass_run': 0.22611318083528567, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'merged': 0.035263029200000025, 'unmerged': 0.019388724199999995}\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "Text(0, 0.5, 'Number of stars')"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the distributions\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "import copy\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "\n",
+    "# remove the merged objects\n",
+    "probability = { \"merged\" : 0.0, \"unmerged\" : 0.0}\n",
+    "\n",
+    "# copy the results so we can change the copy\n",
+    "results = copy.deepcopy(population.grid_results)\n",
+    "\n",
+    "for distribution in ['post']:    \n",
+    "    for logper in population.grid_results[distribution]:\n",
+    "        dprob = results[distribution][logper]\n",
+    "        if logper < -90:\n",
+    "            # merged system\n",
+    "            probability[\"merged\"] += dprob\n",
+    "            del results[distribution][logper]\n",
+    "        else:\n",
+    "            # unmerged system\n",
+    "            probability[\"unmerged\"] += dprob\n",
+    "print(probability)\n",
+    "    \n",
+    "# pad the final distribution with zero\n",
+    "for distribution in population.grid_results:    \n",
+    "    pad_output_distribution(results[distribution],\n",
+    "                            binwidth)\n",
+    "    \n",
+    "# make pandas dataframe \n",
+    "plot_data = pd.DataFrame.from_dict(results, orient='columns')\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10} (P_\\mathrm{orb} / \\mathrm{day})$\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "#p.set(xlim=(-5,5)) # might be necessary?\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c4740c93-d01e-4ca1-8766-c2fb4ddca2e4",
+   "metadata": {},
+   "source": [
+    "You can see that common-envelope evolution shrinks stellar orbits, just as we expect. Pre-CEE, most orbits are in the range $10$ to $1000\\text{ }\\mathrm{d}$, while after CEE the distribution peaks at about $1\\text{ }\\mathrm{d}$. Some of these orbits are very short: $\\log_{10}(-2) = 0.01\\text{ }\\mathrm{d}\\sim10\\text{ }\\mathrm{minutes}$. Such systems are prime candidates for exciting astrophysics: novae, type Ia supernovae and gravitational wave sources."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "57faf043-3809-427a-b378-2355ce8c2691",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Extend the logging to output more data than just the orbital period.\n",
+    "* What are the stellar types of the post-common envelope systems? Are they likely to undergo novae or a type-Ia supernova?\n",
+    "* What are the lifetimes of the systems in close ($<1\\text{ }\\mathrm{d}$) binaries? Are they likely to merge in the life of the Universe?\n",
+    "* How much mass is lost in common-envelope interactions?\n",
+    "* Extend the grid to massive stars. Do you see many NS and BH compact binaries?\n",
+    "* Try different $\\alpha_\\mathrm{CE}$ and $\\lambda_\\mathrm{CE}$ options...\n",
+    "* ... and perhaps increased resolution to obtain smoother curves.\n",
+    "* Why do long-period systems not reach common envelope evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/notebook_custom_logging.ipynb b/examples/notebook_custom_logging.ipynb
index 05ffbccfc23f0b08e85abed0d467233385520a4b..bfdf2a5c8fe238aec50d8f69c74d11b06491eb5f 100644
--- a/examples/notebook_custom_logging.ipynb
+++ b/examples/notebook_custom_logging.ipynb
@@ -5,13 +5,13 @@
    "id": "879b596b-d70c-4f90-b668-563b4ad93ffc",
    "metadata": {},
    "source": [
-    "# Using custom logging routines with binarycpython\n",
+    "# Tutorial: Using custom logging routines with binary_c-python\n",
     "In this notebook you'll learn how to use the custom logging functionality"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 1,
    "id": "696ecbb9-1efd-48f4-a57e-2cf6dfe416f1",
    "metadata": {},
    "outputs": [],
@@ -65,7 +65,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 2,
    "id": "236cf821-09ac-4237-9b8f-6e36d2edf446",
    "metadata": {},
    "outputs": [
@@ -90,7 +90,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 3,
    "id": "feb423d5-5cc3-433c-9801-f8017abbc03a",
    "metadata": {},
    "outputs": [
@@ -110,7 +110,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 4,
    "id": "2f5defbf-c623-49ed-a238-fba52a563a58",
    "metadata": {},
    "outputs": [
@@ -155,7 +155,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 5,
    "id": "dcd74bbc-478b-43e4-b495-8c456e8d1d88",
    "metadata": {},
    "outputs": [
@@ -195,7 +195,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 6,
    "id": "77bd09b0-1a94-499d-97db-a1f991c67c12",
    "metadata": {},
    "outputs": [
@@ -203,10 +203,10 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_ABOVE_MS             1.041660877905e+02 4.99198 4.99198 6.1357 6.1357 2 1\n",
-      "EXAMPLE_ABOVE_MS             1.041662558619e+02 4.99198 4.99198 6.14057 6.1357 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662560111e+02 4.99198 4.99198 6.14057 6.14057 2 2\n",
-      "EXAMPLE_ABOVE_MS             1.041662564579e+02 4.99198 4.99198 6.14059 6.14057 2 2\n"
+      "EXAMPLE_ABOVE_MS             1.044142002936e+02 4.99194 4.99194 6.13567 6.13567 2 1\n",
+      "EXAMPLE_ABOVE_MS             1.044572277695e+02 4.99192 4.99194 7.51803 6.13567 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.044654032097e+02 4.99192 4.99192 7.81395 7.51803 2 2\n",
+      "EXAMPLE_ABOVE_MS             1.045084306856e+02 4.99191 4.99192 9.57443 7.81395 2 2\n"
      ]
     }
    ],
@@ -260,7 +260,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 40,
+   "execution_count": 7,
    "id": "30142286-34ce-433e-82c8-565e2160ff5b",
    "metadata": {},
    "outputs": [
@@ -336,7 +336,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 42,
+   "execution_count": 8,
    "id": "6f0edc65-a788-4706-a0c5-2ace030765ec",
    "metadata": {},
    "outputs": [
@@ -344,8 +344,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 10 27.7358\n",
-      "EXAMPLE_LOG_CO             2.773581245005e+01 1.33524 9.19314 1.72498e-05 730.446 13 5\n"
+      "SINGLE_STAR_LIFETIME 10 28.4838\n",
+      "EXAMPLE_LOG_CO             2.848380621869e+01 1.33469 9.1865 1.72498e-05 724.338 13 5\n"
      ]
     }
    ],
@@ -395,7 +395,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 47,
+   "execution_count": 10,
    "id": "8f58fdf9-3e76-4c18-a1c5-eed0980d4133",
    "metadata": {},
    "outputs": [
@@ -403,8 +403,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "EXAMPLE_MASSLOSS             9.878236827680e+00 1.61349 8.38063 20 13 1\n",
-      "EXAMPLE_SN             9.878236827680e+00 1.61349 8.38063 20 12 13 5 1 6.74037 4.92267 6.74037 0 0\n"
+      "EXAMPLE_MASSLOSS             1.050651207308e+01 1.59452 9.34213 20 13 1\n",
+      "EXAMPLE_SN             1.050651207308e+01 1.59452 9.34213 20 12 13 5 1 6.55458 4.71662 6.55458\n"
      ]
     }
    ],
@@ -424,58 +424,27 @@
     "{\n",
     "    if (stardata->model.time < stardata->model.max_evolution_time)\n",
     "    {\n",
-    "        if(stardata->pre_events_stardata != NULL)\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
-    "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->pre_events_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "        Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
+    "            \"%g %g %g %d \" // 2-5\n",
+    "            \"%d %d %g %g \" // 6-9\n",
+    "            \"%g %g\\\\n\", // 10-13\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->pre_events_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[ID_core(stardata->pre_events_stardata->star[0].stellar_type)],           // 9\n",
-    "\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->pre_events_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
-    "        else\n",
-    "        {\n",
-    "            Printf(\"EXAMPLE_SN %30.12e \" // 1\n",
-    "                \"%g %g %g %d \" // 2-5\n",
-    "                \"%d %d %g %g \" // 6-9\n",
-    "                \"%g %g %g %g\\\\n\", // 10-13\n",
-    "\n",
-    "                // \n",
-    "                stardata->model.time, // 1\n",
+    "            // \n",
+    "            stardata->model.time, // 1\n",
     "\n",
-    "                stardata->star[0].mass, //2\n",
-    "                stardata->previous_stardata->star[0].mass, //3\n",
-    "                stardata->common.zero_age.mass[0], //4\n",
-    "                stardata->star[0].SN_type, //5\n",
+    "            stardata->star[0].mass, //2\n",
+    "            stardata->previous_stardata->star[0].mass, //3\n",
+    "            stardata->common.zero_age.mass[0], //4\n",
+    "            stardata->star[0].SN_type, //5\n",
     "\n",
-    "                stardata->star[0].stellar_type, //6\n",
-    "                stardata->previous_stardata->star[0].stellar_type, //7\n",
-    "                stardata->model.probability, //8\n",
-    "                stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
+    "            stardata->star[0].stellar_type, //6\n",
+    "            stardata->previous_stardata->star[0].stellar_type, //7\n",
+    "            stardata->model.probability, //8\n",
+    "            stardata->previous_stardata->star[0].core_mass[ID_core(stardata->previous_stardata->star[0].stellar_type)],           // 9\n",
     "\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
-    "                stardata->previous_stardata->star[0].core_mass[CORE_He],    // 11\n",
-    "                stardata->star[0].fallback, // 12\n",
-    "                stardata->star[0].fallback_mass // 13\n",
-    "            );\n",
-    "        }\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_CO],     // 10\n",
+    "            stardata->previous_stardata->star[0].core_mass[CORE_He]    // 11\n",
+    "        );\n",
     "    };\n",
     "    /* Kill the simulation to save time */\n",
     "    stardata->model.max_evolution_time = stardata->model.time - stardata->model.dtm;\n",
@@ -491,6 +460,14 @@
     "# print (abridged) output\n",
     "print(\"\\n\".join(output.splitlines()[-2:]))"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "484297c0-accb-4efc-a9c8-dbd2f32b89a6",
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
diff --git a/examples/notebook_extra_features.ipynb b/examples/notebook_extra_features.ipynb
index b1a9ddb030195e6aaf0da2cf08eecc67684672a6..076b4098e7c588a68fb91cfe6175c3ee4e36ea78 100644
--- a/examples/notebook_extra_features.ipynb
+++ b/examples/notebook_extra_features.ipynb
@@ -5,7 +5,7 @@
    "id": "d5c04b77-f0be-4b33-8c03-c72eb846527c",
    "metadata": {},
    "source": [
-    "# Extra features and functionality of binarycpython\n",
+    "# Tutorial: Extra features and functionality of binary_c-python\n",
     "In this notebook we'll go over some of the extra features and functionality that was not covered in the other notebooks.\n",
     "\n",
     "Within the module `binarycpython.utils.functions` there are many functions that can be useful when using binarycpython. We can see which functions are in there, again by using the `help()`"
diff --git a/examples/notebook_individual_systems.ipynb b/examples/notebook_individual_systems.ipynb
index 21d49016f3b2826d6f9d5ec87a1f6d8bb18df7af..50c604385e0365b3404fb8d6427b9b9f0c0f7fbf 100644
--- a/examples/notebook_individual_systems.ipynb
+++ b/examples/notebook_individual_systems.ipynb
@@ -5,22 +5,25 @@
    "id": "a544d28c-c2e1-4c6a-b55b-8caec440743f",
    "metadata": {},
    "source": [
-    "# Running individual systems with binarycpython\n",
+    "# Tutorial: Running individual systems with binary_c-python\n",
     "This notebook will show you how to run single systems and analyze their results.\n",
     "\n",
-    "It can be useful to have some functions to quickly run a single system to e.g. inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single star, etc. "
+    "It can be useful to have some functions to quickly run a single system to, for example, inspect what evolutionary steps a specific system goes through, to plot the mass loss evolution of a single system, etc. "
    ]
   },
   {
    "cell_type": "markdown",
    "id": "dd5d9ec7-5791-45f1-afbd-225947e2a583",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "source": [
-    "## Single system with run_wrapper\n",
+    "## Single system with run_system_wrapper\n",
+    "\n",
     "The simplest method to run a single system is to use the run_system wrapper. This function deals with setting up the argument string, makes sure all the required parameters are included and handles setting and cleaning up the custom logging functionality (see notebook_custom_logging).\n",
     "\n",
     "As arguments to this function we can add any of the parameters that binary_c itself actually knows, as well as:\n",
-    "- custom_logging_code: string containing a print statement that binary_c can use to print information\n",
+    "- custom_logging_code: string containing a Printf statement that binary_c can use to print information\n",
     "- log_filename: path of the logfile that binary_c generates\n",
     "- parse_function: function that handles parsing the output of binary-c"
    ]
@@ -86,7 +89,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=17089 RANDOM_COUNT=0\n",
+      "      TIME      M1       M2   K1  K2           SEP      PER    ECC  R1/ROL1 R2/ROL2  TYPE RANDOM_SEED=12122 RANDOM_COUNT=0\n",
       "     0.0000    1.000    0.000  1  15            -1       -1  -1.00   0.000   0.000  \"INITIAL \"\n",
       " 11003.1302    1.000    0.000  2  15            -1       -1  -1.00   0.000   0.000  \"OFF_MS\"\n",
       " 11003.1302    1.000    0.000  2  15            -1       -1  -1.00   0.000   0.000  \"TYPE_CHNGE\"\n",
@@ -225,18 +228,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0        time      mass initial_mass stellar_type\n",
-      "1           0         1            1            1\n",
-      "2           0         1            1            1\n",
-      "3       1e-06         1            1            1\n",
-      "4       2e-06         1            1            1\n",
-      "5       3e-06         1            1            1\n",
-      "...       ...       ...          ...          ...\n",
-      "1617  12461.8  0.546683            1            6\n",
-      "1618  12461.9  0.517749            1           11\n",
-      "1619  13461.9  0.517749            1           11\n",
-      "1620  14461.9  0.517749            1           11\n",
-      "1621    15000  0.517749            1           11\n",
+      "0             time      mass initial_mass stellar_type\n",
+      "1              0.0       1.0          1.0          1.0\n",
+      "2              0.0       1.0          1.0          1.0\n",
+      "3         0.000001       1.0          1.0          1.0\n",
+      "4         0.000002       1.0          1.0          1.0\n",
+      "5         0.000003       1.0          1.0          1.0\n",
+      "...            ...       ...          ...          ...\n",
+      "1617  12461.819616  0.546683          1.0          6.0\n",
+      "1618  12461.945773  0.517749          1.0         11.0\n",
+      "1619  13461.945773  0.517749          1.0         11.0\n",
+      "1620  14461.945773  0.517749          1.0         11.0\n",
+      "1621       15000.0  0.517749          1.0         11.0\n",
       "\n",
       "[1621 rows x 4 columns]\n"
      ]
@@ -358,7 +361,7 @@
       "Creating and loading custom logging functionality\n",
       "Running binary_c M_1 10 api_log_filename_prefix /tmp/binary_c_python/notebooks/notebook_individual_systems\n",
       "Cleaning up the custom logging stuff. type: single\n",
-      "Removed /tmp/binary_c_python/custom_logging/libcustom_logging_8967553693ac4e11a49c42d4eef773e8.so\n",
+      "Removed /tmp/binary_c_python/custom_logging/libcustom_logging_6d4ed30fa6684630885c08523336d45f.so\n",
       "EXAMPLE_MASSLOSS             0.000000000000e+00 10 0 10 1\n",
       "EXAMPLE_MASSLOSS             0.000000000000e+00 10 10 10 1\n",
       "EXAMPLE_MASSLOSS             1.000000000000e-06 10 10 10 1\n",
@@ -460,13 +463,13 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: parse_function=<function object_parse_function at 0x7fb4d41ebbf8> to grid_options\n",
+      "adding: parse_function=<function object_parse_function at 0x14938275de50> to grid_options\n",
       "<<<< Warning: Key does not match previously known parameter:                     adding: output_dir=/tmp/binary_c_python/notebooks/notebook_individual_systems to custom_options >>>>\n",
       "adding: api_log_filename_prefix=/tmp/binary_c_python/notebooks/notebook_individual_systems to BSE_options\n",
       "Creating and loading custom logging functionality\n",
       "Running binary_c M_1 10 api_log_filename_prefix /tmp/binary_c_python/notebooks/notebook_individual_systems\n",
       "Cleaning up the custom logging stuff. type: single\n",
-      "Removed /tmp/binary_c_python/custom_logging/libcustom_logging_5d7779e8190e4b79b10c7e6a44cb0e7e.so\n",
+      "Removed /tmp/binary_c_python/custom_logging/libcustom_logging_3bc2f679982a4df6a2b83d382e83d724.so\n",
       "[['time', 'mass', 'initial_mass', 'stellar_type'], [0.0, 10.0, 0.0, 10.0, 1.0], [0.0, 10.0, 10.0, 10.0, 1.0], [1e-06, 10.0, 10.0, 10.0, 1.0]]\n",
       "dict_keys(['time', 'mass', 'initial_mass', 'stellar_type'])\n"
      ]
@@ -496,7 +499,7 @@
     "## Single system via API functionality\n",
     "It is possible to construct your own functionality to run a single system by directly calling the API function to run a system. Under the hood all the other functions and wrappers actually use this API.\n",
     "\n",
-    "There are less failsafes for this method, so this make sure the input is correct and binary_c knows all the arguments you pass in.\n",
+    "There are fewer failsafes for this method, so this make sure the input is correct and binary_c knows all the arguments you pass in.\n",
     "\n",
     "for more details on this API function see `notebook_api_functions`"
    ]
@@ -519,7 +522,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "SINGLE_STAR_LIFETIME 15 14.9947\n",
+      "SINGLE_STAR_LIFETIME 15 14.9927\n",
       "\n"
      ]
     }
@@ -566,7 +569,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -580,7 +583,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebook_luminosity_function_binaries.ipynb b/examples/notebook_luminosity_function_binaries.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..51f8660853f181f1d7704717aae95f923c826427
--- /dev/null
+++ b/examples/notebook_luminosity_function_binaries.ipynb
@@ -0,0 +1,701 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "bbbaafbb-fd7d-4b73-a970-93506ba35d71",
+   "metadata": {},
+   "source": [
+    "# Example use case: Zero-age stellar luminosity function in binaries\n",
+    "\n",
+    "In this notebook we compute the luminosity function of the zero-age main-sequence by running a population of binary stars using binary_c. \n",
+    "\n",
+    "Before you go through this notebook, you should look at notebook_luminosity_function.ipynb which is for the - conceptually more simple - single stars.\n",
+    "\n",
+    "We start by loading in some standard Python modules and the binary_c module.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "bf6b8673-a2b5-4b50-ad1b-e90671f57470",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "import math\n",
+    "from binarycpython.utils.grid import Population\n",
+    "\n",
+    "# help(Population) # Uncomment this line to see the public functions of this object"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f268eff3-4e08-4f6b-8b59-f22dba4d2074",
+   "metadata": {},
+   "source": [
+    "## Setting up the Population object\n",
+    "To set up and configure the population object we need to make a new instance of the `Population` object and configure it with the `.set()` function.\n",
+    "\n",
+    "In our case, we only need to set the maximum evolution time to something short, because we care only about zero-age main sequence stars which have, by definition, age zero."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "79ab50b7-591f-4883-af09-116d1835a751",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: max_evolution_time=0.1 to BSE_options\n",
+      "verbosity is 1\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Create population object\n",
+    "population = Population()\n",
+    "\n",
+    "# If you want verbosity, set this before other things\n",
+    "population.set(verbosity=1)\n",
+    "\n",
+    "# Setting values can be done via .set(<parameter_name>=<value>)\n",
+    "# Values that are known to be binary_c_parameters are loaded into bse_options.\n",
+    "# Those that are present in the default grid_options are set in grid_options\n",
+    "# All other values that you set are put in a custom_options dict\n",
+    "population.set(\n",
+    "    # binary_c physics options\n",
+    "    max_evolution_time=0.1,  # maximum stellar evolution time in Myr\n",
+    " )\n",
+    "\n",
+    "# We can access the options through \n",
+    "print(\"verbosity is\", population.grid_options['verbosity'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f9a65554-36ab-4a04-96ca-9f1422c307fd",
+   "metadata": {},
+   "source": [
+    "## Adding grid variables\n",
+    "The main purpose of the Population object is to handle the population synthesis side of running a set of stars. The main method to do this with binarycpython, as is the case with Perl binarygrid, is to use grid variables. These are loops over a predefined range of values, where a probability will be assigned to the systems based on the chosen probability distributions.\n",
+    "\n",
+    "Usually we use either 1 mass grid variable, or a trio of mass, mass ratio and period (other notebooks cover these examples). We can, however, also add grid sampling for e.g. eccentricity, metallicity or other parameters. \n",
+    "\n",
+    "To add a grid variable to the population object we use `population.add_grid_variable`"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "68c84521-9ae8-4020-af7a-5334173db969",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# help(population.add_grid_variable)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "bd75cebe-2152-4025-b680-dc020b80889b",
+   "metadata": {},
+   "source": [
+    "All the distribution functions that we can use are stored in the `binarycpython.utils.distribution_functions` or `binarycpython/utils/distribution_functions.py` on git. If you uncomment the help statement below you can see which functions are available now:"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "048db541-3e92-4c5d-a25c-9c5a34b9c857",
+   "metadata": {
+    "scrolled": true,
+    "tags": []
+   },
+   "outputs": [],
+   "source": [
+    "import binarycpython.utils.distribution_functions\n",
+    "# help(binarycpython.utils.distribution_functions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2a9104fc-4136-4e53-8604-f24ad52fbe56",
+   "metadata": {},
+   "source": [
+    "First let us set up some global variables that will be useful throughout. \n",
+    "* The resolution is the number of stars we simulate in our model population.\n",
+    "* The massrange is a list of the min and max masses\n",
+    "* The total_probability is the theoretical integral of a probability density function, i.e. 1.0.\n",
+    "* The binwidth sets the resolution of the final distribution. If set to 0.5, the bins in log*L* are 0.5dex wide."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set resolution and mass range that we simulate\n",
+    "resolution = {\"M_1\": 40} # start with resolution = 10, and increase later if you want \"more accurate\" data\n",
+    "massrange = (0.07, 100.0) # we work with stars of mass 0.07 to 100 Msun\n",
+    "total_probability = 1.0 # theoretical integral of the mass probability density function over all masses    \n",
+    "# distribution binwidths : \n",
+    "# (log10) luminosity distribution\n",
+    "binwidth = { 'luminosity' : 1.0 }"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1b3a007b-5c17-42a7-a981-7e268e6f545c",
+   "metadata": {},
+   "source": [
+    "The next cell contains an example of adding the mass grid variable, sampling the phase space in linear mass *M*_1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "47979841-2c26-4b26-8945-603d013dc93a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Set up the binary grid in \"cubic\" M1 - M2=q*M1 - log10 period space\n",
+    "\n",
+    "population = Population()\n",
+    "\n",
+    "# resolution on each side of the cube, with more stars for the primary mass\n",
+    "nres = 10\n",
+    "resolution = {\"M_1\": 4*nres,\n",
+    "              \"q\": nres,\n",
+    "              \"per\": nres}\n",
+    "\n",
+    "massrange = [0.07,100]\n",
+    "logperrange = [0.15, 5.5]\n",
+    "\n",
+    "population.add_grid_variable(\n",
+    "    name=\"lnm1\",\n",
+    "    longname=\"Primary mass\",\n",
+    "    valuerange=massrange,\n",
+    "    resolution=\"{}\".format(resolution[\"M_1\"]),\n",
+    "    spacingfunc=\"const(math.log({min}), math.log({max}), {res})\".format(min=massrange[0],max=massrange[1],res=resolution[\"M_1\"]),\n",
+    "    precode=\"M_1=math.exp(lnm1)\",\n",
+    "    probdist=\"three_part_powerlaw(M_1, 0.1, 0.5, 1.0, 150, -1.3, -2.3, -2.3)*M_1\",\n",
+    "    dphasevol=\"dlnm1\",\n",
+    "    parameter_name=\"M_1\",\n",
+    "    condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    ")\n",
+    "\n",
+    "# Mass ratio\n",
+    "population.add_grid_variable(\n",
+    "     name=\"q\",\n",
+    "     longname=\"Mass ratio\",\n",
+    "     valuerange=[\"0.1/M_1\", 1],\n",
+    "     resolution=\"{}\".format(resolution['q']),\n",
+    "     spacingfunc=\"const({}/M_1, 1, {})\".format(massrange[0],resolution['q']),\n",
+    "     probdist=\"flatsections(q, [{{'min': {}/M_1, 'max': 1.0, 'height': 1}}])\".format(massrange[0]),\n",
+    "     dphasevol=\"dq\",\n",
+    "     precode=\"M_2 = q * M_1\",\n",
+    "     parameter_name=\"M_2\",\n",
+    "     condition=\"\",  # Impose a condition on this grid variable. Mostly for a check for yourself\n",
+    " )\n",
+    "\n",
+    "# Orbital period\n",
+    "population.add_grid_variable(\n",
+    "    name=\"log10per\", # in days\n",
+    "    longname=\"log10(Orbital_Period)\",\n",
+    "    valuerange=[0.15, 5.5],\n",
+    "    resolution=\"{}\".format(resolution[\"per\"]),\n",
+    "    spacingfunc=\"const({}, {}, {})\".format(logperrange[0],logperrange[1],resolution[\"per\"]),\n",
+    "    precode=\"\"\"orbital_period = 10.0 ** log10per\n",
+    "sep = calc_sep_from_period(M_1, M_2, orbital_period)\n",
+    "sep_min = calc_sep_from_period(M_1, M_2, 10**{})\n",
+    "sep_max = calc_sep_from_period(M_1, M_2, 10**{})\"\"\".format(logperrange[0],logperrange[1]),\n",
+    "    probdist=\"sana12(M_1, M_2, sep, orbital_period, sep_min, sep_max, math.log10(10**{}), math.log10(10**{}), {})\".format(logperrange[0],logperrange[1],-0.55),\n",
+    "    parameter_name=\"orbital_period\",\n",
+    "    dphasevol=\"dlog10per\",\n",
+    " )"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "163f13ae-fec1-4ee8-b9d4-c1b75c19ff39",
+   "metadata": {},
+   "source": [
+    "## Setting logging and handling the output\n",
+    "By default, binary_c will not output anything (except for 'SINGLE STAR LIFETIME'). It is up to us to determine what will be printed. We can either do that by hardcoding the print statements into `binary_c` (see documentation binary_c) or we can use the custom logging functionality of binarycpython (see notebook `notebook_custom_logging.ipynb`), which is faster to set up and requires no recompilation of binary_c, but is somewhat more limited in its functionality. For our current purposes, it works perfectly well.\n",
+    "\n",
+    "After configuring what will be printed, we need to make a function to parse the output. This can be done by setting the parse_function parameter in the population object (see also notebook `notebook_individual_systems.ipynb`). \n",
+    "\n",
+    "In the code below we will set up both the custom logging and a parse function to handle that output."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Create custom logging statement\n",
+    "#\n",
+    "# we check that the model number is zero, i.e. we're on the first timestep (stars are born on the ZAMS)\n",
+    "# we make sure that the stellar type is <= MAIN_SEQUENCE, i.e. the star is a main-sequence star\n",
+    "# we also check that the time is 0.0 (this is not strictly required, but good to show how it is done)\n",
+    "#\n",
+    "# The \n",
+    "#\n",
+    "# The Printf statement does the outputting: note that the header string is ZERO_AGE_MAIN_SEQUENCE_STARn\n",
+    "#\n",
+    "# where:\n",
+    "#\n",
+    "# n = PRIMARY    = 0 is star 0 (primary star)\n",
+    "# n = SECONDARY  = 1 is star 1 (secondary star)\n",
+    "# n = UNRESOLVED = 2 is the unresolved system (both stars added)\n",
+    "\n",
+    "PRIMARY = 0\n",
+    "SECONDARY = 1\n",
+    "UNRESOLVED = 2\n",
+    "\n",
+    "custom_logging_statement = \"\"\"\n",
+    "// select ZAMS\n",
+    "if(stardata->model.model_number == 0 &&\n",
+    "   stardata->model.time == 0)\n",
+    "{\n",
+    "    // loop over the stars individually (equivalent to a resolved binary) \n",
+    "    Foreach_star(star)\n",
+    "    {\n",
+    "        // select main-sequence stars\n",
+    "        if(star->stellar_type <= MAIN_SEQUENCE)\n",
+    "        {\n",
+    "            /* Note that we use Printf - with a capital P! */\n",
+    "           Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  star->starnum,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0], // 2\n",
+    "                  star->mass, // 3\n",
+    "                  star->luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "        }\n",
+    "    }\n",
+    "    \n",
+    "    // unresolved MS-MS binary\n",
+    "    if(stardata->star[0].stellar_type <= MAIN_SEQUENCE &&\n",
+    "       stardata->star[1].stellar_type <= MAIN_SEQUENCE) \n",
+    "    {\n",
+    "        Printf(\"ZERO_AGE_MAIN_SEQUENCE_STAR%d %30.12e %g %g %g %g\\\\n\",\n",
+    "                  2,\n",
+    "                  stardata->model.time, // 1\n",
+    "                  stardata->common.zero_age.mass[0] + stardata->common.zero_age.mass[1], // 2\n",
+    "                  stardata->star[0].mass + stardata->star[1].mass, // 3\n",
+    "                  stardata->star[0].luminosity + stardata->star[1].luminosity, // 4\n",
+    "                  stardata->model.probability // 5\n",
+    "           );\n",
+    "    }\n",
+    "}\n",
+    "\"\"\"\n",
+    "\n",
+    "population.set(\n",
+    "    C_logging_code=custom_logging_statement\n",
+    ")\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ae1f1f0c-1f8b-42d8-b051-cbf8c6b51514",
+   "metadata": {},
+   "source": [
+    "The parse function must now catch lines that start with \"ZERO_AGE_MAIN_SEQUENCE_STAR\" and process the associated data."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "fd197154-a8ce-4865-8929-008d3483101a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# import the bin_data function so we can construct finite-resolution probability distributions\n",
+    "# import the datalinedict to make a dictionary from each line of data from binary_c\n",
+    "from binarycpython.utils.functions import bin_data,datalinedict\n",
+    "import re\n",
+    "\n",
+    "def parse_function(self, output):\n",
+    "    \"\"\"\n",
+    "    Example parse function\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # list of the data items\n",
+    "    parameters = [\"header\", \"time\", \"zams_mass\", \"mass\", \"luminosity\", \"probability\"]\n",
+    "    \n",
+    "    # Loop over the output.\n",
+    "    for line in output.splitlines():\n",
+    "        \n",
+    "        # check if we match a ZERO_AGE_MAIN_SEQUENCE_STAR\n",
+    "        match = re.search('ZERO_AGE_MAIN_SEQUENCE_STAR(\\d)',line) \n",
+    "        if match:\n",
+    "            nstar = match.group(1) \n",
+    "            #print(\"matched star\",nstar)\n",
+    "\n",
+    "            # obtain the line of data in dictionary form \n",
+    "            linedata = datalinedict(line,parameters)\n",
+    "\n",
+    "            # bin the log10(luminosity) to the nearest 0.1dex\n",
+    "            binned_log_luminosity = bin_data(math.log10(linedata['luminosity']),\n",
+    "                                             binwidth['luminosity'])\n",
+    "            \n",
+    "            # append the data to the results_dictionary \n",
+    "            self.grid_results['luminosity distribution'][int(nstar)][binned_log_luminosity] += linedata['probability'] \n",
+    "            \n",
+    "            #print (self.grid_results)\n",
+    "    \n",
+    "    # verbose reporting\n",
+    "    #print(\"parse out results_dictionary=\",self.grid_results)\n",
+    "    \n",
+    "# Add the parsing function\n",
+    "population.set(\n",
+    "    parse_function=parse_function,\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91509ce5-ffe7-4937-aa87-6d7baac9ac04",
+   "metadata": {},
+   "source": [
+    "## Evolving the grid\n",
+    "Now that we configured all the main parts of the population object, we can actually run the population! Doing this is straightforward: `population.evolve()`\n",
+    "\n",
+    "This will start up the processing of all the systems. We can control how many cores are used by settings `amt_cores`. By setting the `verbosity` of the population object to a higher value we can get a lot of verbose information about the run, but for now we will set it to 0.\n",
+    "\n",
+    "There are many grid_options that can lead to different behaviour of the evolution of the grid. Please do have a look at those: [grid options docs](https://ri0005.pages.surrey.ac.uk/binary_c-python/grid_options_descriptions.html), and try  "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "adding: amt_cores=4 to grid_options\n",
+      "Running the population now, this may take a little while...\n",
+      "Creating and loading custom logging functionality\n",
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "Grid has handled 256 stars\n",
+      "with a total probability of 0.6149734610296649\n",
+      "Total starcount for this run will be: 256\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,473 DEBUG    Process-2] --- Setting up processor: process-0\n",
+      "[2021-09-10 22:26:10,475 DEBUG    Process-3] --- Setting up processor: process-1\n",
+      "[2021-09-10 22:26:10,478 DEBUG    Process-4] --- Setting up processor: process-2\n",
+      "[2021-09-10 22:26:10,481 DEBUG    MainProcess] --- setting up the system_queue_filler now\n",
+      "[2021-09-10 22:26:10,482 DEBUG    Process-5] --- Setting up processor: process-3\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 started at 2021-09-10T22:26:10.491896.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf510>Process 1 started at 2021-09-10T22:26:10.491948.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf480>\n",
+      "\n",
+      "Process 2 started at 2021-09-10T22:26:10.496677.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf3f0>\n",
+      "Process 3 started at 2021-09-10T22:26:10.498669.\tUsing store memaddr <capsule object \"STORE\" at 0x154d03cdf180>\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:10,510 DEBUG    MainProcess] --- Signaling stop to processes\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Generating grid code\n",
+      "Generating grid code\n",
+      "Constructing/adding: lnm1\n",
+      "Constructing/adding: q\n",
+      "Constructing/adding: log10per\n",
+      "Saving grid code to grid_options\n",
+      "Writing grid code to /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Loading grid code function from /tmp/binary_c_python/binary_c_grid_bc3a5f915411445699f8cf6438817ff1.py\n",
+      "Grid code loaded\n",
+      "158/256  61.7% complete 22:26:15 ETA=    3.2s tpr=3.22e-02 ETF=22:26:18 mem:509.0MB\n",
+      "199/256  77.7% complete 22:26:20 ETA=    7.3s tpr=1.28e-01 ETF=22:26:27 mem:476.9MB\n",
+      "238/256  93.0% complete 22:26:25 ETA=    2.3s tpr=1.28e-01 ETF=22:26:27 mem:481.7MB\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,631 DEBUG    Process-3] --- Process-1 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 1 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.475399, done at 2021-09-10T22:26:27.634804 (total: 17.159405s of which 17.104907512664795s interfacing with binary_c).\n",
+      "\tRan 61 systems with a total probability of 0.1439494161909395.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,639 DEBUG    Process-3] --- Process-1 is finished.\n",
+      "[2021-09-10 22:26:27,698 DEBUG    Process-5] --- Process-3 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 3 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.482470, done at 2021-09-10T22:26:27.701828 (total: 17.219358s of which 17.162050247192383s interfacing with binary_c).\n",
+      "\tRan 67 systems with a total probability of 0.17251417460118773.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,705 DEBUG    Process-5] --- Process-3 is finished.\n",
+      "[2021-09-10 22:26:27,769 DEBUG    Process-4] --- Process-2 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 2 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.478464, done at 2021-09-10T22:26:27.771291 (total: 17.292827s of which 17.243471384048462s interfacing with binary_c).\n",
+      "\tRan 56 systems with a total probability of 0.14306289954535925.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,774 DEBUG    Process-4] --- Process-2 is finished.\n",
+      "[2021-09-10 22:26:27,865 DEBUG    Process-2] --- Process-0 is finishing.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Process 0 finished:\n",
+      "\tgenerator started at 2021-09-10T22:26:10.473000, done at 2021-09-10T22:26:27.867175 (total: 17.394175s of which 17.331928491592407s interfacing with binary_c).\n",
+      "\tRan 72 systems with a total probability of 0.1554469706921749.\n",
+      "\tThis thread had 0 failing systems with a total probability of 0.\n",
+      "\tSkipped a total of 0 systems because they had 0 probability\n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "[2021-09-10 22:26:27,869 DEBUG    Process-2] --- Process-0 is finished.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Population-bc3a5f915411445699f8cf6438817ff1 finished! The total probability was: 0.6149734610296613. It took a total of 17.603368997573853s to run 256 systems on 4 cores\n",
+      "There were no errors found in this run.\n",
+      "Done population run!\n"
+     ]
+    }
+   ],
+   "source": [
+    "# set number of threads\n",
+    "population.set(\n",
+    "    # verbose output is not required    \n",
+    "    verbosity=1,\n",
+    "    # set number of threads (i.e. number of CPU cores we use)\n",
+    "    amt_cores=4,\n",
+    "    )\n",
+    "\n",
+    "# Evolve the population - this is the slow, number-crunching step\n",
+    "print(\"Running the population now, this may take a little while...\")\n",
+    "analytics = population.evolve()  \n",
+    "print(\"Done population run!\")\n",
+    "\n",
+    "# Show the results (debugging)\n",
+    "# print (population.grid_results)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "91ab45c7-7d31-4543-aee4-127ab58e891f",
+   "metadata": {},
+   "source": [
+    "After the run is complete, some technical report on the run is returned. I stored that in `analytics`. As we can see below, this dictionary is like a status report of the evolution. Useful for e.g. debugging."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "{'population_name': 'bc3a5f915411445699f8cf6438817ff1', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 0.6149734610296613, 'total_count': 256, 'start_timestamp': 1631305570.458824, 'end_timestamp': 1631305588.062193, 'total_mass_run': 5246.190724478048, 'total_probability_weighted_mass_run': 0.6347400152389439, 'zero_prob_stars_skipped': 0}\n"
+     ]
+    }
+   ],
+   "source": [
+    "print(analytics)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# make a plot of the luminosity distribution using Seaborn and Pandas\n",
+    "import seaborn as sns\n",
+    "import pandas as pd\n",
+    "from binarycpython.utils.functions import pad_output_distribution\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "\n",
+    "titles = { 0 : \"Primary\",\n",
+    "           1 : \"Secondary\",\n",
+    "           2 : \"Unresolved\" }\n",
+    "\n",
+    "# choose to plot the \n",
+    "# PRIMARY, SECONDARY or UNRESOLVED\n",
+    "nstar = UNRESOLVED\n",
+    "\n",
+    "plots = {}\n",
+    "\n",
+    "# pad the distribution with zeros where data is missing\n",
+    "for n in range(0,3):\n",
+    "    pad_output_distribution(population.grid_results['luminosity distribution'][n],\n",
+    "                            binwidth['luminosity'])\n",
+    "    plots[titles[n] + ' ZAMS luminosity distribution'] = population.grid_results['luminosity distribution'][n]\n",
+    "\n",
+    "# make pandas dataframe from our sorted dictionary of data\n",
+    "plot_data = pd.DataFrame.from_dict(plots)\n",
+    "\n",
+    "# make the plot\n",
+    "p = sns.lineplot(data=plot_data)\n",
+    "p.set_xlabel(\"$\\log_{10}$ ($L_\\mathrm{ZAMS}$ / L$_{☉}$)\")\n",
+    "p.set_ylabel(\"Number of stars\")\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7d7b275e-be92-4d59-b44d-ef6f24023cc3",
+   "metadata": {},
+   "source": [
+    "You can see that the secondary stars are dimmer than the primaries - which you expect given they are lower in mass (by definition q=M2/M1<1). \n",
+    "\n",
+    "Weirdly, in some places the primary distribution may exceed the unresolved distribution. This is a bit unphysical, but in this case is usually caused by limited resolution. If you increase the number of stars in the grid, this problem should go away (at a cost of more CPU time). "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "99e25a72-54e6-4826-b0e5-4a02460b857d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "Things to try:\n",
+    "* Massive stars: can you see the effects of wind mass loss and rejuvenation in these stars?\n",
+    "* Alter the metallicity, does this make much of a difference?\n",
+    "* Change the binary fraction. Here we assume a 100% binary fraction, but a real population is a mixture of single and binary stars.\n",
+    "* How might you go about comparing these computed observations to real stars?\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?"
+   ]
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/notebook_luminosity_function_single.ipynb b/examples/notebook_luminosity_function_single.ipynb
index fb971b34a58887a38066f2dbb3d056ff4c5dc5b6..acab6b2d0fdbf914eaae70a47b9250c8b6b0977f 100644
--- a/examples/notebook_luminosity_function_single.ipynb
+++ b/examples/notebook_luminosity_function_single.ipynb
@@ -54,8 +54,8 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
       "adding: max_evolution_time=0.1 to BSE_options\n",
+      "adding: tmp_dir=/tmp/binary_c_python/notebooks/notebook_luminosity to grid_options\n",
       "verbosity is 1\n"
      ]
     }
@@ -140,7 +140,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 5,
    "id": "aba3fe4e-18f2-4bb9-8e5c-4c6007ab038b",
    "metadata": {},
    "outputs": [],
@@ -164,7 +164,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 6,
    "id": "47979841-2c26-4b26-8945-603d013dc93a",
    "metadata": {},
    "outputs": [],
@@ -202,7 +202,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 18,
+   "execution_count": 7,
    "id": "0c986215-93b1-4e30-ad79-f7c397e9ff7d",
    "metadata": {},
    "outputs": [],
@@ -246,7 +246,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "fd197154-a8ce-4865-8929-008d3483101a",
    "metadata": {},
    "outputs": [],
@@ -304,7 +304,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "id": "8ea376c1-1e92-45af-8cab-9d7fdca564eb",
    "metadata": {
     "tags": []
@@ -321,9 +321,8 @@
       "Total starcount for this run will be: 40\n",
       "Generating grid code\n",
       "Constructing/adding: M_1\n",
-      "Population-08f8230453084e4ca6a2391d45ce658b finished! The total probability was: 1.0000000000000002. It took a total of 1.5262682437896729s to run 40 systems on 2 cores\n",
-      "There were no errors found in this run.\n",
-      "OrderedDict([('luminosity distribution', OrderedDict([(2.25, 0.025), (3.75, 0.05), (4.25, 0.05), (0.25, 0.025), (3.25, 0.025), (5.25, 0.2), (4.75, 0.1), (5.75, 0.39999999999999997), (6.25, 0.125)]))])\n"
+      "Population-e6c082aabe0849a0811761a06e50476b finished! The total probability was: 1.0000000000000002. It took a total of 2.3021209239959717s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
      ]
     }
    ],
@@ -353,7 +352,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 10,
    "id": "e1f0464b-0424-4022-b34b-5b744bc2c59d",
    "metadata": {},
    "outputs": [
@@ -361,7 +360,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "{'population_name': '08f8230453084e4ca6a2391d45ce658b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631124829.303065, 'end_timestamp': 1631124830.8293333, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
+      "{'population_name': 'e6c082aabe0849a0811761a06e50476b', 'evolution_type': 'grid', 'failed_count': 0, 'failed_prob': 0, 'failed_systems_error_codes': [], 'errors_exceeded': False, 'errors_found': False, 'total_probability': 1.0000000000000002, 'total_count': 40, 'start_timestamp': 1631461389.3681686, 'end_timestamp': 1631461391.6702895, 'total_mass_run': 2001.4, 'total_probability_weighted_mass_run': 50.035000000000004, 'zero_prob_stars_skipped': 0}\n"
      ]
     }
    ],
@@ -371,7 +370,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 11,
    "id": "05c6d132-abee-423e-b1a8-2039c8996fbc",
    "metadata": {},
    "outputs": [
@@ -381,13 +380,13 @@
        "[None]"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 11,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 1440x720 with 1 Axes>"
       ]
@@ -402,8 +401,12 @@
     "import pandas as pd\n",
     "from binarycpython.utils.functions import pad_output_distribution\n",
     "\n",
-    "# set the figure size (for a Jupyter notebook in a web browser) \n",
-    "sns.set( rc = {'figure.figsize':(20,10)} )\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "                    \n",
     "\n",
     "# this saves a lot of typing! \n",
     "ldist = population.grid_results['luminosity distribution']\n",
@@ -430,14 +433,6 @@
     "Does this look like a reasonable stellar luminosity function to you? The implication is that the most likely stellar luminosity is 10<sup>5.8</sup> L<sub>☉</sub>! Clearly, this is not very realistic... let's see what went wrong."
    ]
   },
-  {
-   "cell_type": "markdown",
-   "id": "44586e42-b7cb-4a55-be0a-330b98b20de4",
-   "metadata": {},
-   "source": [
-    "## "
-   ]
-  },
   {
    "cell_type": "markdown",
    "id": "e32c3bbf-390f-45da-ad9c-cc3e7c9449dc",
@@ -450,7 +445,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 12,
    "id": "1f37d2c0-1108-4ab9-a309-20b1e6b6e3fd",
    "metadata": {},
    "outputs": [],
@@ -464,7 +459,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 13,
    "id": "6f4463e8-1935-45f2-8c5f-e7b215f8dc47",
    "metadata": {},
    "outputs": [
@@ -479,9 +474,8 @@
       "Total starcount for this run will be: 40\n",
       "Generating grid code\n",
       "Constructing/adding: M_1\n",
-      "Population-92de7c9221c54206ab4dd10e58e09a34 finished! The total probability was: 0.21822161894107872. It took a total of 1.5900418758392334s to run 40 systems on 2 cores\n",
-      "There were no errors found in this run.\n",
-      "OrderedDict([('luminosity distribution', OrderedDict([(2.25, 0.0164166), (3.25, 0.00515685), (0.25, 0.189097), (3.75, 0.0037453900000000004), (4.25, 0.0014346559999999999), (5.25, 0.0007493004), (4.75, 0.001171479), (5.75, 0.00039801020000000003), (6.25, 5.2369339999999996e-05)]))])\n"
+      "Population-1bc714cffdb344589ea01692f7e1ebd1 finished! The total probability was: 0.21822161894107872. It took a total of 2.335742950439453s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
      ]
     }
    ],
@@ -496,7 +490,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 14,
    "id": "cfe45a9e-1121-43b6-b6b6-4de6f8946a18",
    "metadata": {},
    "outputs": [
@@ -506,13 +500,13 @@
        "[None]"
       ]
      },
-     "execution_count": 13,
+     "execution_count": 14,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKsAAAJgCAYAAABFgeDFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAAB6SklEQVR4nOzdd1iV9f/H8dc5bNlLQETcW3OXe++G0XKUDSsrW7+2bdt+s2zvYcPMtLSlZq7cVjhyTxREURRkKeNwzu8PkiIcRxn3feD5uC6uC+/7Pue8gPtCePG537fF4XA4BAAAAAAAAJiA1egAAAAAAAAAwEmUVQAAAAAAADANyioAAAAAAACYBmUVAAAAAAAATIOyCgAAAAAAAKZBWQUAAAAAAADToKwCAAAAAACAabgbHcAVpKfnyG53GB2jygkN9dPRo9lGx4AL4xxCWXEOoaw4h1BWnEMoK84hlBXnEMrifM8fq9Wi4GDf0+6nrHKC3e6grKogfF5RVpxDKCvOIZQV5xDKinMIZcU5hLLiHEJZVMT5w2WAAAAAAAAAMA3KKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZBQAAAAAAANPgboAAAAAAAKcUFOQrK+uYbLZ82e2FRsdBOTh82Cq73W50DLio/54/Vqub3N095e8fJA8Pz/N+XsoqAAAAAMBZnTiRo6ysdPn5BcrLK0RWq5ssFovRsVBG7u5W2WyUVTg//z5/HA6H7PZC5eWdUHr6Yfn7B8vHx/f8nrc8QwIAAAAAqqbs7AwFBYXJ09Pb6CgATMhiscjNzV01avjL3d1DmZlp511WMbMKAAAAAHBWhYUF8vDwMjoGABfg4eElm63gvB9PWQUAAAAAcAqX/QFwRlm/V1BWAQAAAAAAwDQoqwAAAAAAgEtyOBxGRzgto7MZ/fplQVkFAAAAAKi2unXrcMa3jz9+v9Rj3nrrNXXr1kHvvffWKZ/z+eefVrduHXTFFRef9nWfffYJdevWQc8//3SJ7Rs2rNdDD/2fhg7tq969OysubqhefPEZJSfvP+PHMWfOj+rWrYMOHz509g+6jO6881bdc88dFf46//Xfj3Hv3gTdcceYCnmt559/WtdcM6z431deeYleeulZpx+/YsUyPffcUxX+Oqdzqs9Nt24dNGXKR2V+7srA3QABAAAAANXWe+99esrt7777hv76a71at76gxHabzab58+eqQYOGmjPnR918821ydy/9q7XFYtGhQynasmWTmjdvWWJfXl6eli1bWuoxv/++Wg8+eI969eqrRx55Qr6+fkpO3q+vvvpct956vT744DNFR9cuw0dbPu6//xFD5pd17txN7733qYKDQyRJS5Ys1MaNf1XKa7/wwsvy9fVz+vhvvpmmwkLbWY+74Yabdfx4TlmindKpPjfvvfepIiIiyv21KgJlFQAAAACg2mrZslWpbd99N0MbNqzT6NE3qWPHi0rsW716hdLT0/TssxM1btzNWrp0ifr06VfqOaKiaik/P19LliwsVVatXr1Sbm5uioiILLH9yy+nqFWrCzRhwgvF29q166DOnbvq6quH6euvp+r++x8uy4dbLurVq2/I6wYHBys4ONiQ127cuGmFPG9llo+nOtfNissAAQAAAAD429atm/Xmm6+qffuOuvnm20rt//nnH9WkSTNdcEEbNW/eUt9//90pn8disahXr75avHhRqX2LFs1Xz569S63ISktLk91uL3V8WFi47rvvQXXseKHTH8epLtVbu/ZPdevWQRs2rJckffzx+xo58iotWrRAI0deoT59umjs2BuVmLhXK1Ys03XXXa2+fbvq1ltv0M6d20/73N26ddDs2d/qhRcmaNCg3urfv4eeeOIRpaenlXj9efN+1k03jVK/ft10+eVD9NZbrykvL7d4f3p6uiZMeFyXXjpQffp01Q03jNTcuT8V7//3ZYAff/y+PvroveLX//jj9/X44w/ryisvKTWr6amnHtXNN48+7ecqMzNTL7wwQYMH99GgQb31zjtvlPo6/PfyvF9/nafrrx+hPn266uKL++uZZ57QkSOpxZ+f+PjftX79WnXr1kFr1/5Z/Ln//vvvFBc3VAMH9tT69WtLXQYoSQUF+Zo06UUNHNhTQ4f21aRJL5VYfXWqSwXP9rk5+f6/LwM8fPiQnn32SQ0bNlh9+3bVuHG3aN26+OL9Bw8eULduHfTbb4v06KMPqn//7ho8uI8mTnxeubm5qkiUVQAAAAAASMrKytKTT45XYGCQnn76eVmtJX9lTk9P16pVyzVw4BBJ0pAhF2vt2j+0f3/SKZ+vT59+OngwWdu2bS3elpubq5Url6tv3wGljr/ooi7666/1uuee2zVnzo86cCC5eN/FFw9Tjx69yuGjLOngwQP64IN3dPPNt+uJJ57R/v2JevDBe/Xmm69q9OibNGHCCzp06KCeffbJMz7Pe++9KUl69tkXdccdd2vFimV6663Jxfs//vh9Pf/802rTpp1eeGGSrrlmpL7//js99NB9xeXSs88+ob179+iBB8Zr0qTX1bhxEz3//NNau/bPUq93ySXDdNllcX+/9qe65JJhGjr0EqWkHNSGDeuKj8vJydayZb9p8OBTzw+z2+26//67tGrVCt155716/PGntXHjBi1cOP+0H+tff63Xc889pV69+uiVV97QXXf9n+Ljf9eECY9LKrpMslmz5mrcuInee+9TNWnyz6qsKVM+0j333K97732w1Iq7kxYsmK+9exP05JPP6cYbb9Evv8zRk0+OP20eZz43/3XkyBHdcstobdmySXfccY8mTHhRXl7euvfeOxQf/0eJY1966TnVqhWtF198RSNHXqeffpqtL7449eWz5YXLAAEAAAAA523PgUz9uCJBufmFhubw9nTTJV3rqX6tgPN+jhdeeFqHDx/SG2+8XzwX6d/mz58jSerff5AkqW/fgXrjjcn64YfvdMcd95Q6vlWrCxQeXlNLlixU06bNJEkrVy6Xt7eP2rXrUOr4W2+9Qzk5OZoz54fiwqBmzQh17txV11wzUnXq1D3vj+10Tpw4oYceerQ4z/r1a/Xtt9/o9dffVfv2HSVJSUlJevvt13T8+HHVqFHjlM/TsGFjPfpo0UDxjh2LVqgtXbpEkpSZmaGpUz/T5Zdfqbvvvl+S1KnTRQoPj9BTT43XqlUr1KVLN61fv1Y33HBzcSnXpk07BQYGycPDo9Tr1awZofDwmpL+ubwtNDRM4eE19csvc9SmTTtJ0qJFCyQ51L//wFPmXr16pbZu3axXXnlTF17YWZLUvn0nXXXVJaf9nG3YsF5eXt4aNep6eXp6SpICAgK1bdsWORwO1atXXzVq+Kmw0Fbq0ru4uKvVs2ef0z63JAUFBemVV96Ql5e3JMnd3V2TJr2knTu3q1GjJmd8rHTqz81/TZ8+VVlZ2frgg8+KL0ft0qWbbrhhhN5990199NHnxcd27dpdd955rySpQ4dO+uOPNVq5cpluueX2s2Y5X5RVAAAAAIDz9uufSdqw+6jRMSRJPl7uuvXSFuf12K+//lLLlv2mO+64Rxdc0OaUx8yZ86M6drxQbm5uysrKklS0GmrOnJ90yy13lCpVTl4KuGTJQt12252Sii4B7NWrr9zc3Eo9v6enpx5++DHdfPNYrVq1ovjyse+//05z5vyoZ555Ud279zqvj+9MWrT4Z4XPyZLu36t+AgMDJUnZ2VmnLatatSo5iL5mzQjl5p6QJG3evEn5+fnq169kYdS7d18995yH1q2LV5cu3dS2bdElazt2bNdFF3XWRRd107hxpUvA03Fzc9OgQUM1a9ZM/d//PSRPT0/NnfuTunTproCAwFM+ZsOGdfL09CouqiTJx8dHF13UVRs3bjjlY9q2bacPP3xHo0dfo169+qpz567q1Okide7c9awZGzVqfNZjOnfuVlxUSVK3br00adJL+uuv9U6VVc5Yv36tWre+oMTcNKvVqr59B+ijj94rcdnhf7+24eE1dfjw4XLJcTqUVQAAAACA89a/Q4xy82ymWFnVv2PMeT1206aNeu+9t9SjR2+NHHndKY/Ztm2rdu/epd27d2nw4N6l9v/226JSZYxUdCngjBnTtHPndkVHx2jVqhV69dW3zpgnNDRMF198mS6++DJJRbOmnnnmCU2a9JK6detZrnfic3NzK1GMnOTj43NOz+Pl5VXi3xaLpfjyvqysTElFH9e/Wa1WBQUFKzs7W5I0YcIL+vzzT7Ro0a9asmShrFarOnS4UA899KgiI6OcyjFkyCX64otPtWLFUjVu3FQbN27Q//43+bTHZ2ZmKigoqNT2/2b9t5YtW+vll1/X9OlTNX36VH355RSFhIRq9OgbdeWVw8+Yz8fn1GXfv/13Vd/JfCc/T+UhKytTderUKbU9JCRUDodDx48fL97m7V3y/LBarXI4Ss9WK0+UVYCkH1fu1Z7kDN04tJkCangaHQcAAABwGfVrBeieqy44+4EmlZmZoaeeGq/IyKjiy9hOZc6cH+Tr66sXX3yl1L5nnnlC33//3SnLqpYtW6tmzQgtXrxQ9erVV0BAoFq3blPquM2bN+mRR+7Tk08+U+oOhO3addDIkdfpjTdeVVZW5mlXCf2bxWKR3V6yQDxx4sRZH1cR/P39JUlHjx4pcfc7u92u9PS04jLGz89Pd9xxt+64424lJu7VsmW/acqUj/Tqq/87Y+H0bzExddS6dRstWrRAycn7FRISqk6dOp/2+KCgIB07li6Hw1GiBMzMzDjj61x4YWddeGFn5ebmKj7+D82YMU2vvTZJLVteUHzJ5/k6uWrvpJOD6k+WWEVf25Jl0YkTx3Uu/P39dfRo6RWRR48ekVR0WePJ943AgHVUe5nH8zVr6R5t2H1UU+fvMDoOAAAAgEricDj03HNPKT09Xc8++5L8/PxOeVx+fr5+/fUXde/eS+3adSj11r//IK1bF6/ExL2lHlt0KWAf/fbbIi1ZslB9+vQ75cqomJg6OnHiuGbM+PqUdwRMTNyn8PCaThVVkuTr66vDhw+V2PbXX+udemx5a9GilTw9PbVgwS8lti9evFA2m02tW1+gw4cPKS5uqBYvXiBJqlOnrkaNul4dOlxY6uM46VSXUkrS0KGXavXqlVq0aIEGDhx82uMkqX37jsrPz9fy5b8VbysoKNDvv68+7WPeeecN3XLLaDkcDnl7e6tr1+4aN+5eSSrO6uZ2/nXLn3/+rsLCf4rGk5+Tk3O4atTw1aFDZ/7anuljLnqu9vrrrw0lPrd2u12LFv2qZs2aF8/iMgorq1Dt5f1ruXLCwUwDkwAAAACoTDNnTtfKlct15ZXDlZeXr02bNpY6xtfXV3v27FZWVuYpV05J0qBBQzVt2hf6/vtZuuuu/yu1v0+f/vrmm2lKTt6vt9/+6JTPERAQoDvuuEevvjpR48bdrEsuuVy1akUrOztbS5cu1rx5P+vpp19w+mPr0qW7li9fqjffnKyuXbvrr7/Wa968n51+fHkKCAjUiBHX6fPPP5G7u7s6d+6qhIQ9+vjj99WmTTtdeGEXWa1WRUZG6bXXJiknJ0fR0bW1bdtWrV69QtdfP+aUz+vnV7Ri69df56lly9aKiqolSerdu59ee22SduzYpieeeOaM2Tp06KROnTrrhRee0dixRxUREaEZM77WsWPpCgsLP+VjOnbspGnTvtDzzz+tgQMHq6DApq+++lxBQUFq27Z9cbYNG9YpPv6Pc54zlZp6SE89NV7Dhl2pnTt36MMP39WQIZeoTp1YSUWD0L/8coq++GKKWrRoqeXLf1N8fMk7Jp7uc3PSNdeM0rx5P+uee27XTTfdqho1fDVr1gzt27dXL7/8+jnlrQiUVQAAAACAamnHjm2SpJkzv9bMmV+f8pg2bdrJy8tbQUFB6tCh0ymPadCgoRo1aqx5837S2LHjSu1v0aKVIiIiZbW6lRhm/l9xcVepTp1YzZz5td5//y1lZGSoRg1fNW/eQq+//m5xEeKMoUMvVXLyfs2d+5Nmz56pNm3a67nnJur2209d/FS0W265XSEhIfr22280a9ZMBQeH6LLL4nTTTWNltRatQnr++f/9fSe695SRcUw1a0bopptu1ahR15/yObt376U5c37Q888/rUsvvVz33fewJKlGjRpq27ad0tPTVa9e/bNme+GFl/Xuu2/oo4/eVV5evvr27a9LL43TypXLTnl8x44X6emnn9fUqZ/r0UcfksVi0QUXtNEbb7xXfMnj5Zdfqc2bN+qBB+7W449POOXdJU9n2LArlZWVqfHj75eXl7euump4iTvvjR59k44dO6avvvpcNptNXbp01SOPPKFHHrnvrJ+bk8LCwvTuux/r3Xff0KRJL8put6tp0+aaPPntU96psrJZHCcnnuG0jh7Nlt3Op6m8hYf7KzU16+wHVrDUYyf08HurJElhgd763+1dDE4EZ5nlHILr4hxCWXEOoaw4h1BWlXkOpaTsU2RkbKW8FiqPu7tVNlvFDsuubMePH9fllw/WuHH36tJLLzc6TpV2pvPnTN8zrFaLQkNPfdmtxMoqAAAAAABQBRw8eEDz5v2s1atXytvbWwMGDDY6Es4TZRUAAAAAAHB5FotVM2Z8LV9fXz311PPy9vY2OhLOE2UVAAAAAABweZGRkZozZ6HRMVAOzv9eigAAAAAAAEA5o6wCAAAAAACAaVBWAQAAAACcws3kATijrN8rKKsAAAAAAGfl5uahgoI8o2MAcAEFBXlyd/c478dTVgEAAAAAzsrPL1DHjh1RTk6WCgttrLICUILD4VBhoU05OVk6duyIfH0Dz/u5uBsgAAAAAOCsfHx85e7uoezsY8rJyZDdXmh0JJQDq9Uqu91udAy4qP+eP1armzw8PBUcXFMeHp7n/byUVQAAAAAAp5z8JRRVR3i4v1JTs4yOARdVUecPlwECAAAAAADANCirAAAAAAAAYBqUVQAAAAAAADANyioAAAAAAACYBmUVAAAAAAAATIOyCgAAAAAAAKZBWQUAAAAAAADToKwCAAAAAACAaVBWAQAAAAAAwDQoqwAAAAAAAGAalFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlUq7IqPz9fN954oxYvXmx0FAAAAAAAAJxCtSmrtm3bplGjRmnt2rVGRwEAAAAAAMBpVJuyatq0abrjjjvUunVro6MAAAAAAADgNKpMWTV79mw1b9681FtWVpYkacKECerdu7fBKQEAAAAAAHAm7kYHKC/Dhg3TsGHDjI4BAAAAAACAMqgyK6sAAAAAAADg+iirAAAAAAAAYBqmK6u2bt2qFi1aKCUlpdS+n376SUOHDlXr1q01ePBgzZ49u/IDAgAAAAAAoMKYambV7t27NXbsWNlstlL75syZowceeEDXX3+9unXrpgULFujhhx+Wt7e3Bg0a5PRrfPHFF+UZGQAAAAAAAOXIFGWVzWbT9OnT9corr8jDw+OUx0yePFmDBw/W+PHjJUndu3dXRkaGXn/99XMqq85HaKhfhT5/dRYe7m90BBVa/1lgaHWzmiITnMfXC2XFOYSy4hxCWXEOoaw4h1BWnEMoi4o4f0xRVsXHx2vSpEkaM2aMIiIi9Pjjj5fYn5SUpMTERN13330ltg8cOFBz585VUlKSYmJiKizf0aPZstsdFfb81VV4uL9SU7OMjqG0YyeK37cX2k2RCc4xyzkE18U5hLLiHEJZcQ6hrDiHUFacQyiL8z1/rFbLGRcGmWJmVYMGDbRgwQLdeeedcnNzK7V/z549kqR69eqV2B4bGytJSkhIqPiQAAAAAAAAqHCmWFkVFhZ2xv1ZWUUtnZ9fydbN19dXkpSdnV0xwQAAAAAAAFCpTLGy6mwcjjNfgme1usSHAQAAAAAAgLNwiZbH379oWFdOTk6J7SdXVJ3cD5wPppEBAAAAAGAeLlFWnZxVlZiYWGL7vn37SuwHAAAAAACAa3OJsio2Nla1a9fWvHnzSmyfP3++6tatq1q1ahmUDFWBxegAAAAAAACgmCkGrDtj3LhxGj9+vAIDA9WrVy8tXLhQc+fO1eTJk42OBgAAAAAAgHLiMmVVXFyc8vPz9cknn2jGjBmKiYnRxIkTNWTIEKOjAQAAAAAAoJyYrqyKi4tTXFzcKfcNHz5cw4cPr+REAAAAAAAAqCwuMbMKAAAAAAAA1QNlFQAAAAAAAEyDsgrVnsPoAAAAAAAAoBhlFQAAAAAAAEyDsgrVnsXoAAAAAAAAoBhlFQAAAAAAAEyDsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVqHacxgdAAAAAAAAFKOsAgAAAAAAgGlQVqHasxgdAAAAAAAAFKOsAgAAAAAAgGlQVgEAAAAAAMA0KKsAAAAAAABgGpRVAAAAAAAAMA3KKgAAAAAAAJgGZRWqPYfRAQAAAAAAQDHKKgAAAAAAAJgGZRWqPYvRAQAAAAAAQDHKKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZBQAAAAAAANOgrEK15zA6AAAAAAAAKEZZBQAAAAAAANOgrEK1ZzE6AAAAAAAAKEZZBQAAAAAAANOgrAIAAAAAAIBpUFYBAAAAAADANCirAAAAAAAAYBqUVaj2HEYHAAAAAAAAxSirAAAAAAAAYBqUVQAAAAAAADANyipUexajAwAAAAAAgGKUVQAAAAAAADANyioAAAAAAACYBmUVAAAAAAAATIOyCgAAAAAAAKZBWYVqz2F0AAAAAAAAUIyyCgAAAAAAAKZBWYVqz2J0AAAAAAAAUIyyCgAAAAAAAKZBWQUAAAAAAADToKwCAAAAAACAaVBWAQAAAAAAwDQoq1DtOYwOAAAAAAAAilFWAQAAAAAAwDQoqwAAAAAAAGAalFWo9ixGBwAAAAAAAMUoqwAAAAAAAGAalFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgrVnsPoAAAAAAAAoBhlFQAAAAAAAEyDsgrVnsXoAAAAAAAAoBhlFQAAAAAAAEyDsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVqHacxgdAAAAAAAAFKOsAgAAAAAAgGlQVgEAAAAAAMA0KKtQ7VmMDgAAAAAAAIpRVgEAAAAAAMA0KKsAAAAAAABgGpRVAAAAAAAAMA3KKlR7DqMDAAAAAACAYpRVAAAAAAAAMA3KKgAAAAAAAJgGZRWqPYvRAQAAAAAAQDHKKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZBQAAAAAAANOgrEK15zA6AAAAAAAAKEZZBQAAAAAAANOgrAIAAAAAAIBpUFYBAAAAAADANCirAAAAAAAAYBqUVQAAAAAAADANyioAAAAAAACYBmUV4HAYnQAAAAAAAPyNsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVgEAAAAAAMA0KKsAAAAAAABgGpRVAAAAAAAAMA3KKgAAAAAAAJgGZRWqPYfRAQAAAAAAQDHKKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZBQAAAAAAANOgrAIAwAT2H87W7uQMo2MAAAAAhqOsAgDAYOlZeXryk9/1/Bfx2nMg0+g4AAAAgKEoqwCH0QEAVHcb9xwtfn/J+mQDkwAAAADGo6wCAAAAAACAaVBWAQAAAAAAwDQoqwAAAAAAAGAalFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgrVnsPoAAAAAAAAoBhlFQAAAAAAAEyDsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVgEAAAAAAMA0KKsAAAAAAABgGpRVAAAAAAAAMA3KKlR7DofD6AgAAAAAAOBvlFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgoAAAAAAACmQVkFAAAAAAAA03A3OkBFmzJlimbOnCmLxaI6deroueeeU3BwsNGxAAAAAAAAcApVemVVfHy8Zs6cqenTp+vHH39U/fr19corrxgdCwAAAAAAAKdRpcuqoKAgPfnkk/L19ZUkNW/eXMnJyQanAgAAAAAAwOm4/GWAs2fP1qOPPlpq+5o1a9SgQQM1aNBAkpSdna133nlHI0eOrOyIAAAAAAAAcJLLl1XDhg3TsGHDznjMoUOHdPvtt6tdu3YaMWJE5QQDAAAAAADAOavSlwFK0rZt23TNNdeoX79+mjBhgtFxAAAAAAAAcAYuv7LqTJKTk3XDDTfoiSee0NChQ42OAwAAAAAAgLMwzcqqrVu3qkWLFkpJSSm176efftLQoUPVunVrDR48WLNnz3bqOadMmaITJ07ogw8+0GWXXabLLrtM999/fzknBwAAAAAAQHkxxcqq3bt3a+zYsbLZbKX2zZkzRw888ICuv/56devWTQsWLNDDDz8sb29vDRo06IzP+9hjj+mxxx6rqNgAAAAAAAAoZ4aWVTabTdOnT9crr7wiDw+PUx4zefJkDR48WOPHj5ckde/eXRkZGXr99dfPWlaVl9BQv0p5neooPNzf6AjKtf/zvtXNaopMcB5fL5SVGc4hPz/v4vd9vD1MkQnO4+uFsuIcQllxDqGsOIdQFhVx/hhaVsXHx2vSpEkaM2aMIiIi9Pjjj5fYn5SUpMTERN13330ltg8cOFBz585VUlKSYmJiKjzn0aPZstsdFf461U14uL9SU7OMjqG0tJzi9+2FdlNkgnPMcg7BdZnlHMrOzi1+/0RugSkywTlmOYfgujiHUFacQygrziGUxfmeP1ar5YwLgwydWdWgQQMtWLBAd955p9zc3Ert37NnjySpXr16JbbHxsZKkhISEio+JAAAAAAAACqNoSurwsLCzrg/K6uonfPzK9m2+fr6SpKys7MrJhgAAAAAAAAMYZq7AZ6Kw3HmS++sVlPHBwAAAAAAwDkyddvj7180pCsnJ6fE9pMrqk7uBwAAAAAAQNVg6rLq5KyqxMTEEtv37dtXYj8AAAAAAACqhnMuq06cOFH8fnp6uqZOnapp06bp2LFj5ZlLUtEg9dq1a2vevHklts+fP19169ZVrVq1yv01Uf1wn0cAAAAAAMzD6QHrmZmZ+r//+z9lZmZqxowZys7O1hVXXKGDBw/K4XDonXfe0VdffaWYmJhyDThu3DiNHz9egYGB6tWrlxYuXKi5c+dq8uTJ5fo6AAAAAAAAMJ7TK6tee+01rVmzRt27d5ckzZw5UwcOHNCDDz6ozz//XFarVa+99lq5B4yLi9OECRO0fPlyjRs3Tn/88YcmTpyoIUOGlPtrAQAAAAAAwFhOr6xatGiRrr32Wt19992SpAULFig0NFQ33XSTJGnUqFH69NNPzztIXFyc4uLiTrlv+PDhGj58+Hk/NwAAAAAAAFyD0yurjh49qkaNGkmSsrKytH79enXt2rV4f3BwcIl5VgAAAAAAAMC5crqsioiIUFJSkqSiVVWFhYXq1atX8f61a9cqKiqq3AMCAAAAAACg+nD6MsDevXvrs88+U3Z2tn7++WcFBgaqT58+OnTokD788EN9//33uuOOOyoyKwAAAAAAAKo4p8uqBx98UCdOnNDMmTMVERGhp59+Wt7e3tqxY4emTp2qSy+9VLfeemtFZgUAAAAAAEAV53RZtW/fPj377LN67rnnSmxv2rSpfvvtN9WsWbPcwwGVwuEwOgEAAAAAAPib0zOrbrjhBr3yyiultnt6elJUAQAAAAAAoFw4XVYdP35ctWvXrsgsAAAAAAAAqOacLquuv/56ffrpp9q4cWNF5gEAAAAAAEA15vTMqk2bNunw4cO6+uqr5e3traCgIFmtJbsui8WiBQsWlHtIAAAAAAAAVA9Ol1V5eXlq2bJlRWYBAAAAAABANed0WfXFF19UZA4AAAAAAADA+ZlVztiyZUt5Ph1QKRxGBwAAAAAAAMWcXlmVn5+vN954Q8uWLdPx48dlt9uL9xUWFionJ0fZ2dnaunVrhQQFAAAAAABA1ef0yqrXX39dH330kTIyMuTj46Pk5GRFRUXJ3d1dKSkpKigo0GOPPVaRWQEAAAAAAFDFOV1WzZs3T506ddKiRYv04YcfSpKefPJJ/fLLL3r//fdls9nk4eFRYUEBAAAAAABQ9TldVh06dEgDBgyQ1WpVRESEQkNDtW7dOklSz549dfnll+ubb76psKAAAAAAAACo+pwuq7y9vUusnKpTp4527NhR/O/WrVsrKSmpfNMBAAAAAACgWnG6rGrWrJmWLl1a/O/69esXr6ySilZeWSyW8k0HAAAAAACAasXpsmrkyJFauHChRo4cqezsbA0dOlRbtmzR+PHj9eGHH2rKlClq1apVRWYFKobD6AAAAAAAAOAkd2cPHDx4sLKzs/Xpp5/Kx8dHXbp00ahRozR16lRJUq1atfTII49UWFAAAAAAAABUfU6XVZJ01VVX6aqrrir+9xNPPKExY8YoIyNDDRo0kKenZ7kHBAAAAAAAQPXh9GWAo0eP1qpVq0ptr1Wrlpo1a6bly5dr6NCh5RoOAAAAAAAA1ctpV1adOHFC6enpxf/+/fff1b9/f8XGxpY61m63a+nSpdq/f3/FpAQAAAAAAEC1cMayatiwYcrKypIkWSwWvfDCC3rhhRdOebzD4VDXrl0rJiUAAAAAAACqhdOWVSEhIXr55Ze1ceNGORwOvf322+rfv7+aNGlS6lir1aqQkBAuAwQAAAAAAECZnHHAes+ePdWzZ09J0oEDBzR8+HBdcMEFlRIMAAAAAAAA1Y/TdwN88cUXT7l9586dslqtatCgQbmFAiqTw+gAAPAvFqMDAAAAAAZzuqySpA8++EAJCQl68cUXZbfbddttt2nZsmWSpC5duuiNN96Qr69vhQQFAKA6oEDH+XA4HFq95ZCycvLVpE6wYiL8ZLVQfQIAANfkdFn10Ucf6dVXX1X37t0lSXPnztXSpUs1cOBANWrUSB9++KHefvttPfTQQxUWFgAAAKUlHc7Whz9uKf63n4+HmtcNVvO6IWoeG6ywIB8D0wEAAJwbp8uqWbNmqX///nrzzTclSXPmzJGPj48mTpwob29v5eTkaN68eZRVAAAAlSz7REGpf/++9bB+33pYklQzyKe4vGoaGyw/Hw8jYgIAADjF6bIqKSlJN9xwgySpoKBAq1atUqdOneTt7S1JatCggY4cOVIhIQEAAOCcfu1r61hOvrbuTVNOrk2SdPjYCR1ef0JL1h+QRVJspH/Rqqu6wWpUO1Ae7m7GhgYAAPgXp8uqgIAAZWdnS5LWrFmj48ePq0ePHsX7ExMTFRYWVv4JAQAA4LQOTWuqcUyQ7A6Hkg5la8veNG3Zm6Yd+zNUYLPLIWlvSpb2pmRpzup98nC3qlHtQLWoG6LmdUOYdwUAAAzndFnVtm1bffnll4qOjtZ7770nd3d3DRgwQAUFBVq8eLGmTZumfv36VWRWAAAAOMlqsSg20l+xkf4afFGsCmyF2rU/Q5v3pmvL3jTtS8mSQ1KBza4te9O1ZW+6pN3y8/FQ09jg4ssGazLvCgAAVDKny6pHH31UY8aM0d133y2LxaKHHnpI4eHhWrNmje6++27Vr19f99xzT0VmBSqEw8G9twAAVZ+Hu5ua1Q1Rs7ohkhoo+0SBtu1L15Z9ReXV4fQTkormXf257bD+3FY07yo8yPvvSwZD1Ix5VwAAoBI4XVZFRUXphx9+0JYtWxQREaGIiAhJUtOmTfXqq6+qd+/e8vHhL28AAACuwM/HQx2a1lSHpjUlSUeOnSgurrbsTS8e2p56LFe/rT+g3/6ed1Unwr941VWj2oHy9GDeFQAAKF9Ol1WS5O7urtatW5fYFhgYqCFDhpRrKAAAAFSusCAf9QjyUY8LasnucGj/4Wxt2ZuuzXvTtDPpmPL/nne171CW9h3K0tw1iXJ3K5p3dbK8io3wl9XKvCsAAFA251RWAQAAwHzK+4J2q8WiOhH+qhPhr0EX1imad5WcWbzqam9KphwOyVZo19Z96dq6L13f/rZHvt7uahob/Pew9mCFB/nIwrB2AABwjiirAAAAcEYe7m5qFhusZrHBuqKnlJP797yrv4e1H/p73lVOrk3x21MVvz1VkhQW6F286qppbLACanga+WEAAAAXQVkFAACAc+Lr7aH2TWqqfZO/511lnNDWvf8Ma886XvD39lwt3XBQSzcclCTVqemn5vWKVl01qh0kL+ZdAQCAUzhtWbVkyRK1bNlSYWFhlZkHAAAALiYs0EfdL/BR9//Mu9qyL007ko4pv8AuSUo8nK3Ew9matyZR7m4WNYwOLL7TYN1I5l0BAIAipy2rHnjgAT3yyCO68sorJUmjR4/W7bffrs6dO1daOAAAALiW0vOu7NpzIEOb/75kMOHgyXlXDm1LPKZticf03dI9quHlrmaxwcWXDdYMZt4VAADV1WnLKofDofj4eA0dOlQ+Pj76/fffdfXVV1dmNgAAqh1+NUdV4+FuVZM6wWpSJ1hxPerreG6BtiUeKx7WnpJ2XJJ0PM+m+B2pit9RNO8qNMBLzf4e1N48NkQBvsy7AgCgujhtWTVgwADNmjVLs2fPLt724IMP6sEHHzztk1ksFm3ZsqVcAwIAUJ2U913dALOp4e2hdo3D1a5xuCQpLTNXm/emFc282pumzL/nXR3NzNPyvw5q+V9F865iavoVr7pqXDtIXp7MuwIAoKo6bVk1YcIEtWjRQjt27FB+fr6+//57tW/fXjExMZWZDwAAAGfjwi1nSIC3ureupe6ta8nhcCg5Nado1dW+dG1PPKa8gkJJUtLhbCUdztYvvyfJzXpy3lWwmtcrmnflZrUa/JEAAIDyctqyytPTU9dee23xv2fPnq1rrrlGl1xySaUEAwAAQPVisVhUu6afatf004BOdWQrtGt3ckbxsPaEA1myOxwqtDu0PemYticd06xlCfLxclfTOkF/D2sPVmRIDeZdAQDgwk5bVv3Xtm3bit8/cuSIDhw4IA8PD0VERCgkJKRCwgEAAKD6cnf7Z97V5aqv47k2bU9KLyqv9qbp4NGieVcn8mxat/OI1u08IkkKCfBS89ii4qpZ3RAFMu8KAACX4nRZJUmbNm3SM888o40bN5bYfsEFF+ixxx5Tq1atyjUcAAAAzk1VXlBUw9tdbRuFq22jf+Zdbd2XXjysPSMn/+/teVq+8aCWbyyad1U73PfvVVchalkvRFZrFf4kAQBQBThdVm3fvl3XXXedJOnqq69WgwYNZLfbtWfPHv34448aPXq0vvnmGzVq1KjCwgIAAAAnhQR4q2urKHVtFSWHw6EDR3K0+e9VV/+ed7U/NUf7U3M0/48kNa4dqNsvb8VqKwAATMzpsuq1116Tr6+vpk+frujo6BL77rjjDl155ZV666239Prrr5d7SKAiOVx4KC2Aqof1HsD5sVgsig73U3S4nwZ0jJGt0K49BzKLh7XvSc6U3eHQjv0ZembKH7ozrpXqRQUYHRsAAJyC07dN+fPPPzVy5MhSRZUkRUZGasSIEVqzZk25hgMAoLqhPwfKh7ubVY1jgjSse309em17vXFPd3VuESlJSs/K04tfrtXyvw4anBIAAJyK02VVfn6+fH19T7vfz89Pubm55RIKAAAAKE81vN1188XNNKJfI1ktFtkK7fpkzlZ9OX+7bIV2o+MBAIB/cbqsatasmX766SfZbLZS+woKCvTjjz+qcePG5RoOAAAAZ+dgTZ5TLBaL+neI0YMj2si/hockadHaZE2atq54ODsAADCe02XVzTffrI0bN+raa6/VL7/8ou3bt2v79u2aO3eurr32Wm3evFk33XRTRWYFAAAAyqxJnWA9eX1HxUb6S1LxHKs9BzINTgYAAKRzGLDer18/PfHEE5o0aZLuvffe4u0Oh0NeXl56+OGHNWjQoIrICAAAACdZGNPvlNBAb40f1U5f/LJdKzalKD0rTy9Njdd1A5qo+wW1jI4HAEC15nRZJUmjRo3S0KFDtWrVKu3fv18Oh0O1a9dWly5dFBQUVEERAQAAgPLn6eGmm4Y2U92oAH29cKdshQ59Oneb9qZkaUS/RnJ3c/oiBAAAUI7OqaySpKCgIA0ePLgisgAAAACVymKxqG/72qod7qt3Zm9S1vECLV6XrP2p2bpjWEsF+nkZHREAgGqHPxcBAGAiXMAFGKNJnWA9dUNH1f17jtXO/RmaMOUP7T6QYXAyAACqH8oqAABMhHu6AcYJCfDW+GvbqWurSEnSsex8TZy6Vks3HDA4GQAA1QtlFQAAgKuj5Sw3Hu5uumlIM43q31huVotshQ5NmbtNn/+yXbZCu9HxAACoFpwuq+x2/nMGAABA1XdyjtWDI9oqoIaHJGnJumT976t1OpadZ3A6AACqPqfLqssuu0yfffZZRWYBAAAATKNxTJCevKGj6kUVzbHalZyhZ6b8od3JzLECAKAiOV1W7d27Vz4+PhWZBQAAAGXFlP5yFRLgrUdGtVO3VlGSiuZYvTR1rX5bn2xwMgAAqi6ny6pu3bpp/vz5ys/Pr8g8AAAAgKl4uLvpxiFNde2AojlWhXaHPpu3XZ/P26YCG6MyAAAob+7OHti0aVN99tln6t69u1q1aqXQ0FBZrSW7LovFohdeeKHcQwIVycFUWgAmwqIYwJwsFov6tKut2uF+emf2JmXm5GvJ+gNKSs3WuMtbKcjPy+iIAABUGU6XVe+++27x+8uXLz/lMZRVAACUDfU5YG6NY4L01A0d9fasjdpzIFO7kzM1YcofGjeslRrWDjQ6HgAAVYLTZdW2bdsqMgcAAADgEoL9vfTwyHb6cv52LfvroDKy8zXxq7UaNaCxerWJNjoeAAAuz+mZVf9mt9t15MgR5lcBAACYACvyKp+Hu1U3DG6q6wY2KZ5j9fm87ZoylzlWAACU1TmVVfv27dNdd92l9u3bq3v37oqPj9eqVat01VVX6c8//6yojAAAAIDpWCwW9W4brYdGtlWgr6ckaemGA/rfV2uVnpVncDoAAFyX02XV3r17ddVVV+n3339X9+7di7e7ublpz549uummm7R+/fqKyAgAAAAnMaS/8jWqHaQnb+ioBrUCJEm7D2TqmSl/aOf+Y8YGAwDARTldVr366qvy9vbWnDlz9PTTT8vhKFpw3qlTJ82ZM0dhYWF66623KiwoAAAAYFbB/l56aGQ79bigliQpIydf//tqnRavSy7+uRkAADjH6bJq9erVGjFihEJDQ2WxlPybXUREhEaOHKlNmzaVe0CgovHzIwAAKA8n51iNHvTPHKsvftmuz+YxxwoAgHPhdFmVn5+vgICA0+738PBQXh7X5gMAUBZcwgW4vl5tovXwyHb/mmN1UBOZYwUAgNOcLquaNm2qRYsWnXKfzWbTDz/8oCZNmpRbMAAAqiMWewJVQ8PagUVzrKKL/ti750CmJkz5QzuSjhkbDAAAF+B0WTV27FitXLlSDzzwgFavXi1JSk5O1sKFCzV69Ght2bJFN954Y4UFBQAAwKlxSbs5Bft76aER7dSrTdEcq8ycfL08bZ0Wr93PHCsAAM7A3dkDe/fureeff14vvPCCfv75Z0nSE088IYfDIS8vLz388MMaOHBghQUFAAAAXI2Hu1WjBzVVbKS/vpy/o2iO1fwdSkjJ0nUDGhsdDwAAU3K6rJKkuLg4DRgwQCtWrFBSUpLsdruio6PVpUsXBQcHV1RGAAAAwKX1bBOt6HA/vT1rozKy87X8r4NKTs3RkzdfZHQ0AABM55zKKkny8/PTgAEDlJaWJqvVSkkFAABgJkzpN62G0YF66oaOemfWJu1KzlDCwUz93+TfdNtlLdQ4JsjoeAAAmIbTM6skaffu3br77rvVvn17devWTV26dFGnTp00fvx4paSkVFRGAAAAoEoI8vPSQyPbqnfbaEnSsew8vTxtnRbGM8cKAICTnF5ZtXHjRo0ePVoFBQXq0aOH6tSpI4fDoYSEBP3www9aunSppk2bpjp16lRkXgAAqjQWxQBVn7ubVdcNbFI8x8pWaNfUX3doX0qWrhvYWB7ubkZHBADAUE6XVZMmTZKfn5+mTp1aqpDasWOHRo8erYkTJ+rtt98u95AAAABAVdPjglpq0Shcz3+yRsey87V840ElH8nWuMtbKSTA2+h4AAAYxunLADds2KDRo0efcuVU48aNNXr0aK1atapcwwEAUN1wERBQvTSNDdFTN3RUw9qBkqSEg1l6Zsof2p6YbnAyAACM43RZFRAQoMLCwtPu9/X1lbc3fwECAACofNScrizQz0sPjfhnjlXm8QJN+no9c6wAANWW02XVqFGjNGXKFO3atavUvkOHDumLL77Q1VdfXa7hAAAAgOrg5ByrGwY3lbubRYV2h6b+ukOf/LxVBbbT/8EYAICq6LQzq8aPH19qW15enoYNG6bu3burXr16slgsSk5O1tKlS+Xl5VWhQQEAAHB2Fsb0u7QeF9RS7XA/vT1ro9Kz8rRiU4qSj+TozjjmWAEAqo/TllWzZs067YMWL16sxYsXl9h2/Phxvf/++7r33nvLLRwAAABQ3dSvFaAnr++gd2Zv0s79GdqbkqUJU/7QHcNaqkmdYKPjAQBQ4U5bVm3btq0ycwCGYRQEAAAwm0A/Lz04oq2+XrhTi9YmK+t4gV6etl7X9G2ofu1ry2JhBR0AoOpyemYVAACoePz6CeAkdzerrh3QRDcOaSp3N6vsDoemLdipj3/eqvwC5lgBAKqu066sOpXZs2drxYoVSk1Nld1uL7XfYrHos88+K7dwAABUNyz2BPBf3VsXzbF667uiOVYrT86xuryVQgOZYwUAqHqcLqsmT56s999/Xx4eHgoNDZXVyqIsAAAAM+CS9qqvXlSAnryho96dvUk7ko5p37/mWDWNZY4VAKBqcbqsmjVrlrp166Y333xTPj4+FZkJAAAAwH8E+nrqgeFtNH3RLi2M36/sEwWa9PV6XdOnofp1YI4VAKDqcHp5VHZ2tgYOHEhRBQAAABjE3c2qUf0ba8zQZv/MsVq4Ux/9xBwrAEDV4XRZ1b17d61evboiswAAAKCMWFxTPXRtFaXx17ZTsL+XJGnV5hS98GW8jmScMDgZAABl5/RlgE888YRuvPFG3X///erXr59CQ0NPudS4Y8eO5RoQqGgOxhkDAAAXVC8qQE/9Pcdqe9IxJR7K1jNT/tTtw1qqGXOsAAAuzOmy6sCBA8rKytLPP/+sOXPmlNrvcDhksVi0devWcg0IAEB1wqIYAOciwNdT9w9vo28W7dKCv+dYvfL1el3du4H6d4xhjhUAwCU5XVY988wzyszM1JgxY1S3bl25uzv9UAAAAAAVxN3NqpH9Gys20l+f/7JdBTa7vl60S3sPZen6QU3l5eFmdEQAAM6J043Tzp07deedd+qWW26pyDwAAFRrXJgM4Hx1bRWl6HBfvfXdRqVl5mn15kM6kJqjO+NaKSyImyQBAFyH0wPWIyMjZbU6fTgAAAAqCSUnTqobGaAnb+iopnWCJEmJh7P1zGd/asveNGODAQBwDpxun26++WZ99tln2rVrV0XmAQAAAFAGATWK5lj17xAjSUVzrKav1y+/J8rhoNoEAJif05cBbtu2TRaLRZdeeqliYmIUFhYmN7eS179bLBZ99tln5R4SAAAAgPPcrFaN6NdIdSP9NWXeNhXY7Jq+aJf2pmTphsHMsQIAmJvTZdXixYvl5uamyMhIFRQU6ODBgxWZCwAAAEAZdW4ZqVphvnrru790NDNPa7Yc0oEjRXOswpljBQAwKafLqkWLFlVkDsA4rIYHYCLcZB5AeYuN9NcTN3TUe7M3aVviMSUdztYzU/7QbcNaqkXdEKPjAQBQChPTAQAAgCru5ByrAR2L5ljl5Nr06vT1mreGOVYAAPNxemXV6NGjnTru888/P+8wAABUd/zKCKCiuFmtGt63kWIj/TVlbtEcq28W79K+Q8yxAgCYi9Nl1f79+0tts9vtSk9PV15enqKjo9WoUaNyDQcAAACgfHVuEalaob5667uNOpqZyxwrAIDplHlmVWFhoRYuXKjHH39cY8aMKbdgAAAAcBJL8nCOYiP99eQNHfTe95u1dV968RyrUf0bq2HtQIUGeMtiYYoeAMAYTpdVp+Pm5qYBAwZow4YNmjRpkqZPn14euQAAAABUIP8anrrvmgs0c8lu/fJ7knJybfrgxy2SJG9PN9UK81WtMF9Fn3wL91OQnyclFgCgwpW5rDqpbt26+vLLL8vr6QAAAHAe6BFwLtysVl3Tp2iO1WdztyuvoFCSlJtfqD0HMrXnQGaJ43283BX9rxKrVrivaof5KsCXEgsAUH7KpazKz8/XDz/8oNDQ0PJ4OqBSceUEAACo7i5qHqnW9cOUeChLyUdydOBIjpKP5Cg5NVs5ubbi407k2bQrOUO7kjNKPN7X++8SK9yveCVWrXBfBdTwrOwPBQBQBZT5boD5+flKSEhQZmam7rrrrnILBgBAdcS6BABGqeHtrqaxwWoaG1y8zeFwKDMnv6i4KlFi5ehE3j8lVk6uTTv2Z2jH/pIlln8Nj39WYv1dZNUK85Wfj0elfVwAANdTprsBSkUzq+rXr6+LL75YI0eOLLdgAAAAAIxlsVgU6OelQD8vNa8bUrzd4XDoWHa+ko9k60BqTokyKze/sPi4rOMF2pZ4TNsSj5V43kBfz3/mYYX7KjrMT7XCfFXDu9ymlAAAXFiZ7wYIAADKD5cmA3AFFotFwf5eCvb3Ust6/4wCcTgcSsvM+2cVVmp20ftHc5RfYC8+LiMnXxk5+dq6L73E8wb7e5UY6l4r3Fe1Qn3l40WJBQDVCd/1AQAAXJyDmhMmYbFYFBrordBAb7Vu8E+JZXc4dDQjt3gO1snLCQ8ePa4C2z8lVnpWntKz8rQ5Ia3E84YGeCk63O+fwe5hRSWWl6dbpX1sAIDKc9qy6q233jqvJ7zzzjvPOwwAAACAqsdqsSg8yEfhQT5q0zCseLvd7lBqxgklp/5rJlZqjlLScmQr/KeEPZqZp6OZefpr99HibRZJYUHexZcQniyxokJryNODEgsAXFmZy6r/3qKWsgoAAMA4Fsb0w4VYrRZFBNdQRHANtWscXry90G7X4fSiEuvAv+ZhpaQdV6G9qMRySEo9lqvUY7lav+tI8WMtFqlmkM/fQ93/Hu4e5qfIkBrycLdW9ocIADgPpy2rFi5ceNYHZ2dna/LkyVqyZInc3d1Pe8dAAAAAAHCWm9WqqFBfRYX6lthuK7TrUNrxEncmPHAkR4fSTsju+LvEckiH0k/oUPoJrdv5T4lltVgUEeJTYhVWdLifIoJ95O5GiQUAZnLasio6OvqMD5wzZ45eeuklHT58WO3atdPTTz+txo0bl3tAoMIx5gOAibAmBgBOz93NquhwP0WH+5XYXmCzKyXteNHdCf++lPDAkRwdTj9R/KOe3eHQwaPHdfDoccVvTy1+rJvVosiQGv8psXxVM9hHblZKLAAwwjkPWE9KStKECRO0YsUKBQYG6rnnntOVV15ZEdkAAAAA4Kw83K2KqemnmJolS6z8gkIdPHq8xCqs/anZOpKRW3xMod1RNPj9SI7++Ndj3d0sigz551LC2mG+ql3TT+FBPpX0UQFA9eV0WVVQUKAPPvhAH374ofLy8nT55ZfrwQcfVHBwcEXmAwCgWmGxJwCUH08PN8VG+is20r/E9rz8Qh04+s+lhEUrsbJ1NDOv+BhboUP7U7O1PzW7xGNjavqpa8tIXdQiUgG+npXycQBAdeNUWbV69WpNmDBBCQkJatSokZ566il16NChorMBAAAAQLnz8nRTvagA1YsKKLH9RJ6tqMT6++6EJ1djpWf9U2IlHc7W14t26ZvFu9W6Qai6tIzUBQ3DGN4OAOXojGVVWlqaXnjhBf3888/y9vbW/fffrxtvvFHu7ud89aBhXn/9dc2bN08Wi0U9evTQQw89JCvXngMAgKqEJXlAufDxcleDWoFqUCuwxPbjuQU6cOS4tu5L04pNKTqcXjTQff2uI1q/64h8vd3VqXmEurWKUt1I/1J3TAcAnJvTtk7Tpk3Ta6+9pszMTPXp00ePP/64oqKiKjNbmf32229asWKFfvjhB1mtVo0aNUoLFy5U//79jY4GAAAAwEXU8PZQw9qBalg7UBd3qavdyZlavvGg/th2SCfyCpWTa9PitclavDZZUaE11LVVlDq3iFSwv5fR0QHAJZ22rJowYULx+4sWLdKiRYvO+mQWi0Vbtmwpn2TloGfPnurSpYs8PDyUlpamrKwsBQYGnv2BAAAAAHAKFouluLga2a+R1u08ohWbDmpzQpocDung0eOauWS3vv1tt1rUDVGXVpFq1yhcnh5uRkcHAJdx2rJq2LBhLrF8dfbs2Xr00UdLbV+zZo38/f3l4eGhDz/8UO+8845at26tNm3aVH5ImJqDaycAAABwHjw93HRh8whd2DxC6Vl5Wr05RSs2pejAkRw5HNKmhDRtSkiTj5ebOjatqS4to9SodqBL/J4FAEY6bVn10ksvVWaO8zZs2DANGzbsjMfccsstuuGGG/TII4/o5Zdf1mOPPVY54QAAOEf8+gIArinY30uDL4rVoAvraG9KllZsPKg1Ww4pJ9emE3mFWrrhoJZuOKiawT7q0jJSXVpGKizQx+jYAGBKrjMp/Tzs2LFDNptNzZs3l4eHhy6++GJ98sknRscCAAAAUEVZLJbiOw1e06eR/tp9RCs2pmjjnqMqtDt0OP2EZi9L0OxlCWpaJ0hdW0WpfZNweXtW6V/NAOCcVOnviHv27NEHH3ygr7/+Wm5ubpozZ446duxodCwAAE6LC5MBoOrwcLeqfZOaat+kpjJz8rV6yyGt3HhQiYezJUnbEo9pW+IxfTl/h9o3CVfXlpFqEhssK5cJAqjmTFNWbd26VVdeeaUWLlyoyMjIEvt++uknvfvuu0pKSlJ0dLTGjh171kv/JGnQoEHavn27hg0bJjc3N3Xo0EG33XZbBX0EAAAAxqDkBMwvwNdTAzrGaEDHGCUeytLKTSlavTlFmccLlFdQqJWbUrRyU4pCA7zUuWWUuraMVERIDaNjA4AhTFFW7d69W2PHjpXNZiu1b86cOXrggQd0/fXXq1u3blqwYIEefvhheXt7a9CgQWd97nvuuUf33HNPRcQGAAAAgHNWJ8JfdSL8dWWvBtqUkKaVGw9q/a4jshU6dDQzTz+t3KufVu5Vw+hAdWkVqU5Na6qGt4fRsQGg0hhaVtlsNk2fPl2vvPKKPDxO/c138uTJGjx4sMaPHy9J6t69uzIyMvT66687VVaVh9BQv0p5neooPNzf6AhKzc4vft/qZjVFJjiPrxfKygznkL+/d/H7Pt4epsgE55nh6xWQkl38fkiIrykywXl8vaq3qMhA9e9cT1nH87V0XbIW/ZmoHYnHJEm7kjO0KzlDXy/YqYtaRqlPxxi1aVxTbtaSlwlyDqGsOIdQFhVx/hhaVsXHx2vSpEkaM2aMIiIi9Pjjj5fYn5SUpMTERN13330ltg8cOFBz585VUlKSYmJiKjzn0aPZsttZYF/ewsP9lZqaZXQMpacfL37fXmg3RSY4xyznEFyXWc6hrKzc4vdP5BaYIhOcY5ZzKDPzRPH76ek5SvW0GpgG58Is5xDMoVPjMHVqHKYDR3L+vizwoI5l5yvfZtfS9clauj5ZgX6e6tIiUl1aRSk6zJdzCGXGOYSyON/zx2q1nHFhkKFlVYMGDbRgwQKFhobqu+++K7V/z549kqR69eqV2B4bGytJSkhIqJSyCgCAysJIXQBArTBfXdmrgeJ61NeWfWlauTFF8TtSVWCzKyM7X3PXJGrumkTVjfTXwM511aJOkPx8uEwQQNVhaFkVFhZ2xv1ZWUXtnJ9fybbN19dXkpSdnV3qMQAAAABQFVitFrWsF6qW9UJ1PNemP7cf1oqNB7Vzf4YkaW9Klt6ftVFuVovaNAxTl1aRalU/VO5urK4E4NpMMWD9dByOM196Z7XyTRgAAABA1VfD2109LqilHhfU0uH041q5KUUrNqboaGauCu0Oxe9IVfyOVPnX8NCFzSPUrVWU6kQwhwiAazJ1WeXvX/TNNScnp8T2kyuqTu4HAKCqYEIiAOBsagbX0LDu9XVpt3o6nJmvn5fv1p/bUpVXUKis4wVa8Od+Lfhzv2qH+6lrq0hd1CJSgb6eRscGAKeZuqw6OasqMTFRTZo0Kd6+b9++EvsBAACqs7MsRgdQRVktFrVqGKbIQC+N6m9T/PZUrdyUom370uWQtD81W9MX7dKMxbvVqn6IuraK0gUNw+ThzhUqAMzN1GVVbGysateurXnz5ql///7F2+fPn6+6deuqVq1aBqYDAAAAAHPw9nRX11ZR6toqSkczcrVyc4pWbDyow+knZHc4tGH3UW3YfVS+3u7q1CxCXVtFqV6UvywWbu0BwHxMXVZJ0rhx4zR+/HgFBgaqV69eWrhwoebOnavJkycbHQ0AAAAATCc00FuXdKmrizvHandyplZsOqjftx7WiTybcnJtWrwuWYvXJSsqtIa6tIxUl5ZRCvb3Mjo2ABQzfVkVFxen/Px8ffLJJ5oxY4ZiYmI0ceJEDRkyxOhoAAAAAGBaFotFDWsHqmHtQI3o20jrdx3R8o0HtTkhTQ6HdPDocX372x5999seNa8Xoq4tI9W2cbi8PNyMjg6gmjNNWRUXF6e4uLhT7hs+fLiGDx9eyYkAAKh8XIwBAKgInh5u6tQsQp2aRSg9K0+rt6Ro5cYUJR/JkUPS5oQ0bU5Ik7enmzo2ramuraLUqHYglwkCMIRpyioAAAAAQMUL9vfS4AtjNahTHe1NydLKjSlavSVFObk25eYXatlfB7Xsr4MKD/JW15ZR6tIyUmFBPkbHBlCNUFYBAGAi3NQNAFBZLBaL6kUFqF5UgK7p21Abdh3Vio0HtXHPURXaHUo9lqvZyxM0e3mCmsQEqWurKLVvEi4fL36NBFCx+C4DAADg8qg5AZSNu5tV7ZuEq32TcGXm5GvNlkNasemgEg9lS5K2Jx3T9qRj+vLX7WrfuKa6topU09hgWblMEEAFoKwCAAAAABQL8PVU/44x6t8xRkmHs7Vi40Gt3nJImTn5yi+wa9XmFK3anKLQAC91bhmpri2jFBFSw+jYAKoQyioAAIAqhGHIAMpTTE0/De/bSFf1bqBNe9K0YuNBrd91RLZCh45m5umnlfv008p9ahAdoK4to9SpWYRqePNrJoCy4bsIqj2Hg0snAAAAgDNxs1p1QcMwXdAwTNknCvTH1kNasSlFew5kSpJ2J2dqd3KmZizZpUGd6qh/xxh5e/LrJoDzw3cPAABMhDUxAACz8/PxUO92tdW7XW0dPJqjFRuLLgtMz8rTibxCzVqWoIXx+zW0S131ahMtD3er0ZEBuBjKKgAAAADAeYkK9dWVvRoorkd9bdh9RLOWJmh/arYyjxdo2oKdmv97ki7rVk9dWkbKauVPMgCcQ1kFAAAAACgTq9Wito3CdUHDMP2+9ZBmL03Q4WMndDQzV5/M2aq5a/bp8u711b5JOLP1AJwVZRUAACbCFD0AgCuzWiy6qHmkOjSpqeV/HdQPKxJ0LDtfB48e1zuzN6lupL+u6NlAzesGU1oBOC3KKgAAABfHvUIAmI27m1W92karS8tILVqbrJ9X7VVOrk17U7L0yvT1alonSFf0bKAG0YFGRwVgQky6AwAAAABUCE8PNw26sI4m3tZFl3SpKy8PN0nStsRjev6LeL357V/an5ptcEoAZsPKKgAAgCqEi2oAmFENb3dd3qO++ravrZ9W7dWSdcmyFTq0bucRrd95RBe1iNBl3eurZpCP0VEBmABlFQAAJkLRAACoygJ8PTWyX2MN6BijH1bs1YqNB+VwSKs2H9LvWw+rR5tauqRLXQX5eRkdFYCBuAwQAAAAAFCpwgJ9dNOQZnru5gvVoUm4JKnQ7tDitcl65L1Vmrlkt3JyCwxOCcAorKwCAAAAABgiKtRXd1zeSntTMvXdb3u0KSFN+Ta75qzep8XrkjX4wjrq3yFGXp5uRkcFUIlYWQUAgIlwUzcAQHVUNzJA913TRg+PbKsG0QGSpBN5Nn23dI8efn+VFsbvl63QbnBKAJWFsgoAAAAAYApN6gTr0Wvb6+4rWqt2uK8kKTMnX1N/3aFHP1itFRsPym7nTztAVcdlgAAAAAAA07BYLGrTKEytG4ZqzZZDmr1sj1KP5epIRq4+/nmr5q1J1OU96qttozBZLNyaBKiKKKsAAACqEn5vA1BFWC0WdW4RqY5Na2rZXwf1w4oEZWTnK/lIjt76bqPqRQXoip711bxuiNFRAZQzyipUew5WEQMAAACm5e5mVe+20erSMlKL4vdrzup9ysm1KeFgpiZ9vV7NYoN1Rc8Gql8rwOioAMoJM6sAADARFsUAAHBqXh5uGnxRrCbe1lkXd4mVl0fRHQK37kvXc5//qbe+26jkIzkGpwRQHlhZBQAAAABwGTW8PRTXo4H6to/Rzyv3asn6ZNkKHVq7I1Xrdqaqc4tIDetWT2FBPkZHBXCeKKsAAAAAAC4n0NdTI/s31oBOMfp+eYJWbkqRwyGt3JSiNVsOqVebaF3cta4CfT2NjgrgHHEZIAAAJsIYPQAAzk1YoI/GDG2uZ8ZcqPaNwyVJhXaHFq7dr4ffW6lvf9ut47kFBqcEcC5YWQUAAODiKDkBQIoO89W4uFZKOJip737brc1705VfYNfPq/ZpybpkDb4oVn3b1y6edQXAvFhZBQAAAACoMupFBej+4W314Ii2xXcIzMm1aeaS3XrkvVVatHa/bIV2g1MCOBPKKgAAgCqEO0oCQJFmscF67Lr2uiuulaLDfCVJGTn5+nL+Dj324Wqt2pQiu521qYAZcRkgqj3+ewJgJhQNAACUH4vForaNw3VBwzCt3pKi2csSdCQjV6nHcvXhT1s0Z80+xfWorzYNw2Sx8L8wYBaUVQAAAACAKs1qtahLyyh1ahahpRsO6McVe5WRk6/k1By9+e1GNagVoLieDdQsNtjoqABEWQUAAAAAqCbc3azq0662uraM0oL4JM1dnajjeTbtPpCpl6etU4u6wYrr2UD1ogKMjgpUa5RVAACYCJcmAwBQ8bw83TS0c131ahuteWsS9eufScovsGvz3nRt3vun2jcO1+U96qvW37OuAFQuyioAAAAX53BQcwLA+fD19tAVPRuoX/va+mnlPi1Zn6xCu0PxO1K1dmequrSM1GXd6iks0MfoqEC1QlkFAAAAAKjWAv28NGpAYw3oFKPvlydo1aYUORzSio0pWrPlkHq1idbFXeoqwNfT6KhAtWA1OgAAAADKEXezAoDzFh7ko5svbq5nxnRSu8bhkiRboUML4vfr4fdW6bulu3U812ZwSqDqY2UVwKUTAAAAAP4lOtxPd8a10p4Dmfr2t93aui9deQWF+mnlPi1em6whF8WqT/va8vJwMzoqUCWxsgoAABNhTQwAAOZRv1aAHhzRVg8Mb1N8h8CcXJtmLNmtR95fpcXrkmUrtBucEqh6WFkFAAAAAMAZNK8bomaxwVq744hmLdujA0dylJGdry9+2a5f1iRqWPd66tQ8QlYuxQbKBWUVAAAAAABnYbFY1L5JuNo2CtOqzSn6fnmCjmTk6vCxE/rgxy2as3qf4no00AUNQ2WhtALKhLIKAAATYYoeAADmZrVa1LVVlDo1i9DSDQf048q9yszJ1/7UHL3x7V9qGB2oK3rWV5M6wUZHBVwWM6sAAAAAADhHHu5W9W1fWxPHdlZcj/ry8SpaC7IrOUMTv1qnV6ev176ULINTAq6JlVUAAAAAAJwnL083Xdylrnq3i9bc1Yla8GeS8m12bUpI06aENHVoEq7Le9RXVKiv0VEBl0FZhWqPS24AAFUJU1IAwBi+3h66slcD9etQWz+u3Kul6w+o0O7Qn9tTFb8jVV1bRemyrvUUGuhtdFTA9LgMEAAAE6FoAADAtQX5eem6AU30/K0XqXOLCFkkORzS8r8OavwHq/XX7iNGRwRMj7IKAAAAAIByVjPIR7dc0kITbuqkto3CJEm2QrumzN2m3HybwekAc6OsAgAAAACggtSu6ae7rmit0QObSJKOZefrx5V7jQ0FmBxlFQAAAAAAFaxHm1qqXytAkjT/9ySlpB03OBFgXpRVAACYCDd9wPlwcOIAgOlZLRaN6t9YFkmFdoe+WrBDDr6BA6dEWQUAAAAAQCWoFxWg7hfUkiRt2pOm9bsYtg6cCmUVAABAFWLhlpIAYGpxPeurhpe7JGnagp3KLyg0OBFgPpRVqPZYeAvATOgZAACo2gJqeOryHvUlSUcycjVvTaLBiQDzoawCAAAAAKAS9WpbSzE1/SRJP6/epyPHThicCDAXyioAAAAAACqRm9WqUf0bS5IKbHZNX7TL4ESAuVBWAQAAAABQyRrHBOmiFhGSpPgdqdqckGZwIsA8KKsAADAR5ugBAFB9XNWrobw83SRJXy3YIVuh3eBEgDlQVgEAALg4BzUnALikYH8vXdq1riTp4NHjWvDnfmMDASZBWQUAAAAAgEH6d4hRZEgNSdL3KxJ0LDvP4ESA8SirAP4YDQAAAMAg7m5WjezfSJKUl1+oGYsZtg5QVgEAYCIWowMAAIBK17JeqNo1Dpckrdp8SDuSjhkbCDAYZRUAAAAAAAYb3qehPNyLfkWf+usO2e1cAoLqi7IKAAAAAACDhQX5aMhFsZKkpMPZWrI+2eBEgHEoqwAAAAAAMIHBF9ZRWKC3JGnW0j3KOp5vcCLAGJRVAACYCAv+cV44cQCgSvD0cNOIvkXD1nNybfpu6R6DEwHGoKwCAAAAAMAk2jQKU8t6IZKkpesPKOFgpsGJgMpHWQUAAFCFWCzcUxIAXJnFYtGIfo3kZrXIIemrX3fI7mAJLaoXyipUew6unQBgItQMAAAgKtRXAzrGSJJ2H8jUyo0pBicCKhdlFQAAAAAAJnNxl7oK8vOUJM1cskvHc20GJwIqD2UVAAAAAAAm4+Plrqv7NJQkZR4v0PfLEwxOBFQeyioAAAAAAEzowmYRahwTJElaGL9f+1OzjQ0EVBLKKgAATIQpegAA4CSLxaJR/RvLYpHsDoe++nWHHAxbRzVAWQUAAODi+LUFAKqumJp+6tOutiRpW+Ix/bHtsMGJgIpHWQUAAAAAgIkN615Pfj4ekqTpi3YpL7/Q4ERAxaKsAvhzNACgCrEYHQAAUO58vT10Za8GkqT0rDz9tGqvsYGACkZZBQCAiVA0AACAU+nWOkr1ovwlSb/8nqhDaccNTgRUHMoqAAAAAABMzmqxaFT/JpIkW6FD0xbuNDgRUHEoqwAAAAAAcAH1awWoe+soSdJfu49q/a4jBicCKgZlFQAAAAAALuKKng3k4+UuSZq2YIcKbAxbR9VDWQUAgIlwzwcAAHAmAb6eurx7PUlS6rFczfs9yeBEQPmjrAIAAHB1tJwAUK30bhet2uG+kqSfV+7V0YxcgxMB5YuyCtUeP98DAKoUbikJAFWem9WqUf0bS5LybXZNX8SwdVQtlFUAAJgIPQMAAHBGkzrBurB5hCTpz+2p2rI3zeBEQPmhrAIAAAAAwAVd3buhvDzcJElTf90hW6Hd4ERA+aCsAgAAAADABQX7e+mSrnUlSQePHtei+P3GBgLKCWUVAAAAAAAuqn+HGEWE1JAkzV6eoIzsPIMTAWVHWQUAgIlw0wcAAHAuPNytGtmvkSQpN79QM5bsNjgRUHaUVQAAAC7OQc0JANVaq/qhatsoTJK0clOKdu3PMDgRUDaUVQAAAAAAuLjhfRvJ3a3oV/wvf90uu50/ZMB1UVah2nPwPRwAUIVYjA4AADBEeJCPhlxUR5KUeChbv204YHAi4PxRVgEAYCIUDQAA4HwNvihWoQHekqTvftut7BMFBicCzg9lFQAAAAAAVYCXh5uG920oScrJtem7pXsMTgScH8oqAAAAAACqiHaNw9WibrAk6bd1ydqXkmVwIuDcUVYBAAAAAFBFWCwWjezfWG5Wixz6e9g6g3rhYiirAAAwEX6UBAAAZRUV6qv+HWIkSbuTM7VqU4rBiYBzQ1kFAADg4viDOQDgvy7pWleBfp6SpBlLdutEns3gRIDzKKsA1jEAAKoSC/eUBABIPl7uurp30bD1zJx8fb88weBEgPMoqwAAMBFqBgAAUF4uah6hRrUDJUkL4/cr+UiOwYkA51BWAQAAAABQBVksFo3q31gWi1Rod+irX3fIwbXjcAGUVQAAAAAAVFF1IvzVq220JGnrvnTFb081OBFwdpRVAAAAAABUYZd3ry8/Hw9J0teLdiqvoNDgRMCZUVYBAAAAAFCF+fl46Iqe9SVJaZl5+nnVPoMTAWdGWQUAgIkwRQIAAFSE7q1rKTbSX5I0b80+HU4/bnAi4PQoqwAAAAAAqOKsVouu7d9YkmQrdOjrhbsMTgScHmUVqj1uhgHATCxGB4DL4xwCAJxOg+hAdWsVJUlav+uINuw6YnAi4NQoqwAAAAAAqCau6NVAPl5ukqRpC3eqwMawdZgPZRUAAAAAANVEoK+nhnUrGrZ+OP2EZv+22+BEQGmUVQAAAAAAVCO920UrOsxXkjR9wQ6lZeYanAgoibIKAAAAAIBqxN3NqpF/D1vPyy/UN4sZtg5zoawCAMBEuOcDAACoDM1ig9WpWU1J0u9bD2vrvnSDEwH/oKwCAABwcdzZFgBwPq7u3VBenkXD1r/6dYdshXaDEwFFKKtQ7fHzPQCgKrEYHQAA4DJCArx1Tb+iywGTj+Ro8dpkgxMBRSirAAAwEYoGAABQmYb1bKCawT6SpNnL9ygjJ9/gRABlFQAAAAAA1ZaHu5tG9mskSTqRV6hvl+w2OBFAWQUAAAAAQLXWukGY2jQMkyQt33hQu5MzDE6E6o6yCgAAAACAam5434ZydyuqCL78dYfsdqb7wjiUVQAAAAAAVHM1g2to0IV1JEn7UrK07K8DBidCdUZZBQCAifA3TJwPB2cOAKAcDO0cq9AAL0nSt7/tUfaJAoMTobqirAL4+R4AAAAA5OXhpmv6FA1bzz5RoFnL9hicCNUVZRUAACZiMToAXB8nEQCgDNo3CVez2GBJ0pJ1yUo8lGVwIlRHlFUAAAAAAECSZLFYNLJ/Y7lZLXI4pKm/7pDDweUoqFzVpqz6/PPPFRcXZ3QMAAAAAABMLTrMV33b15Yk7dyfodVbDhmcCNVNtSirtmzZog8//NDoGAAAAAAAuITLutVTgK+nJOmbRbt0Is9mcCJUJ1W+rMrJydGTTz6p++67z+goAAAAAAC4BB8vd13Vq4EkKSMnXz+u2GtsIFQrLl9WzZ49W82bNy/1lpVVNATu6aef1k033aRatWoZnBQAgLNjIgQAADCLzi0j1TA6UJL0659JOng0x+BEqC5cvqwaNmyYtmzZUurN399f3333nTw8PDRkyBCjYwIAAFQcWk4AQAWwWiwa1b+xLJIK7Q6GraPSuHxZdSY//vijNmzYoMsuu0yPP/64du/erRtuuMHoWDAZBz/hAwCqEIssRkcAAFQhsZH+6tk2WpK0ZW+61u5INTgRqgN3owNUpE8//bT4/TVr1mjixImaMmWKcYEAADgLagYAAGA2cT3q64+th5STa9PXC3epZf1QeXm4GR0LVZhpVlZt3bpVLVq0UEpKSql9P/30k4YOHarWrVtr8ODBmj17duUHBAAAAACgGvLz8dAVPYuGrR/NzNXc1fsMToSqzhRl1e7duzV27FjZbKVvhTlnzhw98MAD6tatm95++2116tRJDz/8sObNm3dOr3HhhRfqu+++K6/IAAAAAABUGz0uqKXYCH9J0pzViTp87ITBiVCVGXoZoM1m0/Tp0/XKK6/Iw8PjlMdMnjxZgwcP1vjx4yVJ3bt3V0ZGhl5//XUNGjSoUnKGhvpVyutUR+Hh/kZHUOCh7OL33dyspsgE5/H1QlmZ4Rzy8/Muft/b28MUmeA8M3y9/P3/OYdCQn0VHlzDwDQ4V2Y4h+DaOIdQVs6eQ+OuaqOH3lomW6Fds5Yl6PGbLqzgZHAFFfE9yNCyKj4+XpMmTdKYMWMUERGhxx9/vMT+pKQkJSYm6r777iuxfeDAgZo7d66SkpIUExNT4TmPHs2W3c4Q7vIWHu6v1NQso2MoI/OfvwgUFtpNkQnOMcs5BNdllnMoOzu3+P3c3AJTZIJzzHIOZWX9cw6lHc2RxVZoYBqcC7OcQ3BdnEMoq3M5h8L8PNSlZaRWbkrRms0pWrRmr1rVD63ghDCz8/0eZLVazrgwyNDLABs0aKAFCxbozjvvlJtb6eFse/bskSTVq1evxPbY2FhJUkJCQsWHBACgEvGnEZwPzhsAQGW5qlcDeXsW/f7+1a87VGCzG5wIVZGhZVVYWJhCQ0/fwmZlFbVzfn4l2zZfX19JUnZ2dqnHAOeMn/ABAAAAwCmBfl4a1q1oQcmh9BP69c8kgxOhKjLFgPXTcTjO3CJYraaODwDAObMYHQAuz8JJBACoYH3a11atsKJFJD+u2Kv0rDyDE6GqMXXb4+9fNKQrJyenxPaTK6pO7gcAAAAAAJXD3c2qkf0aSZLyCgr1zeJdBidCVWPqsurkrKrExMQS2/ft21diPwAAAAAAqDzN64aoQ9OakqQ1Ww5pe2K6wYlQlZi6rIqNjVXt2rU1b968Etvnz5+vunXrqlatWgYlAwAAAACgerumd0N5uhfVClN/3aFCO8PWUT7cjQ5wNuPGjdP48eMVGBioXr16aeHChZo7d64mT55sdDQAAAAAAKqt0EBvDe1SV7OW7tH+1BwtXpusfh1ijI6FKsD0ZVVcXJzy8/P1ySefaMaMGYqJidHEiRM1ZMgQo6MBAFDuuEEpAABwJYM6xWj5XweUeixXs5YlqFOzCAX4ehodCy7ONGVVXFyc4uLiTrlv+PDhGj58eCUnAgAAAAAAZ+Lh7qYR/RrrjZl/6USeTd/+tls3DmlmdCy4OFPPrAIqA6sYAAAAAOD8tWkYptYNQiVJy/46qD0HMg1OBFdHWQUAgIlYjA4AAABwHkb0ayR3t6KfZKb+ul12B8sCcP4oqwAAAAAAQJlEBNfQwE51JEkJB7O0/K+DBieCK6OsAgAAAAAAZXZx57oK9veSJM1csls5uQUGJ4KroqwCAAAAAABl5uXppmv6NJQkZZ8o0OxlCQYngquirAIAAAAAAOWiY9OaalonSJK0aO1+JR3ONjYQXBJlFQAAJsIoUpwPB0NsAQAmYbFYNKp/Y1ktFjkc0tT52/l/CueMsgrVHt83AQAAAKD8RIf7qW/72pKkHfsztGbrIYMTwdVQVgEAYCIWowPA5VksnEUAAONd1q2eAmp4SJK+WbRLufk2gxPBlVBWAQAAAACAclXD211X9ioatn4sO18/rtxrbCC4FMoqAAAAAABQ7rq0ilSDWgGSpPm/J+ng0RyDE8FVUFYBAAAAAIByZ7VYNGpAY1kkFdodmrZgJ8PW4RTKKgAAAAAAUCHqRgaoR5takqRNCWlav/OIwYngCiirAAAAAABAhYnrUV++3u6SpGkLdyq/oNDgRDA7yipALEMFALg2/icDAJiZfw1PXd6jviTpSEau5q5JNDgRzI6yCgAAAAAAVKhebaJVp6afJGnO6n06cuyEwYlgZpRVAAAAAACgQlmtRcPWJanAZtfXi3YZnAhmRlkFAAAAAAAqXKPaQercIkKStHZHqjYlHDU4EcyKsgoAAAAAAFSKq3o3lJenmyTpq193ylZoNzgRzIiyCgAAAAAAVIogPy9d1rWeJCkl7bh+/TPJ4EQwI8oqAAAAAABQafp1qK2o0BqSpB9W7FV6Vp7BiWA2lFUAAJiIw+gAcE2cOAAAF+LuZtXIfkXD1vPyCzVjCcPWURJlFao9Bz/gAwAAAEClalEvRO0bh0uSVm8+pB1Jx4wNBFOhrAIAwEQsRgeAy7NwEgEAXMQ1fRvKw72olvhy/g4V2hm2jiKUVQAAAAAAoNKFBfpoaOdYSdL+1GwtWXfA4EQwC8oqAAAAAABgiMEX1lFYoLckadbSPco8nm9wIpgBZRUAAAAAADCEh7ubRvRrJEk6nmfTd7/tMTgRzICyCgAAAAAAGKZNwzC1rB8iSVqx8aBshcyuqu4oqwAAAAAAgGEsFouaxxaVVYV2B2UVKKsAAABcncPoAAAAAOWIsgoAAKAKsRgdAAAAoIwoqwAAAAAAAGAalFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgoAAAAAAJiGg9vcVnuUVQAAmAg/m+G88FM9AACoQiirUO3x4z0AAAAAAOZBWQUAgIlYjA4A12fhLAIAAK6NsgoAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVgEAAAAAAMA0KKsAAAAAAABgGpRVqPYcDofREQAAKBP+JwMAuDpuZot/o6wCAACoQvhZHwAAuDrKKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZBQAAAAAAANOgrAIAAAAAAIBpuBsdwBVYrdxXp6KY4XPr4+WumsE+kqRgfy9TZILz+HqhrMxwDtXw/uf7kL+vpykywXlm+HrV8PYoPofc3a2myATn8fVCWXEOoazMcA75+vzzf5nVyv9lruR8vlZne4zF4XA4zjcQAAAAAAAAUJ64DBAAAAAAAACmQVkFAAAAAAAA06CsAgAAAAAAgGlQVgEAAAAAAMA0KKsAAAAAAABgGpRVAAAAAAAAMA3KKgAAAAAAAJgGZRUAAAAAAABMg7IKAAAAAAAApkFZhUr3008/aejQoWrdurUGDx6s2bNnGx0JLmrr1q1q0aKFUlJSjI4CF2K32zVt2jRdcsklatu2rfr166cXX3xR2dnZRkeDi3A4HJoyZYoGDhyo1q1b69JLL9WPP/5odCy4qDvvvFP9+/c3OgZcjM1mU+vWrdWkSZMSb23btjU6GlzIH3/8oREjRuiCCy5Qt27d9OyzzyonJ8foWHABa9asKfX9599vs2bNKvNruJdDTsBpc+bM0QMPPKDrr79e3bp104IFC/Twww/L29tbgwYNMjoeXMju3bs1duxY2Ww2o6PAxXz00Ud67bXXNGbMGHXu3FkJCQl64403tGvXLn388cdGx4MLeP/99/XGG2/orrvuUps2bbR06VI98MADcnNz05AhQ4yOBxfy/fff69dff1WdOnWMjgIXk5CQoLy8PE2cOFF169Yt3m61shYBzlm/fr1uvPFG9enTR++++6727dunV199VWlpaZo8ebLR8WByLVq00PTp00tsczgceuyxx3T8+HH17NmzzK9BWYVKNXnyZA0ePFjjx4+XJHXv3l0ZGRl6/fXXKavgFJvNpunTp+uVV16Rh4eH0XHgYhwOhz766CNdc801uv/++yVJXbp0UXBwsP7v//5PW7duVbNmzQxOCTMrKCjQJ598ohEjRuj222+XJHXu3FmbNm3Sl19+SVkFpx06dEjPP/+8IiMjjY4CF7Rt2zZZrVYNHDhQPj4+RseBC5o0aZLatGmj119/XRaLRV26dJHdbtenn36qEydOcF7hjPz8/NSmTZsS2z777DMlJCTo66+/VkhISJlfg+odlSYpKUmJiYkaMGBAie0DBw7Unj17lJSUZFAyuJL4+HhNmjRJN910kx544AGj48DF5OTk6NJLL9XFF19cYnv9+vUlSYmJiUbEggtxc3PTF198oVtvvbXEdg8PD+Xl5RmUCq7o8ccfV9euXdW5c2ejo8AFbd26VXXq1KFQwHlJS0vTn3/+qREjRshisRRvHzVqlBYsWMB5hXOWmpqq119/vfiy0vJAWYVKs2fPHklSvXr1SmyPjY2VVLScGTibBg0aaMGCBbrzzjvl5uZmdBy4GD8/Pz3++ONq3759ie0LFiyQJDVs2NCIWHAhVqtVTZo0UUREhBwOh44cOaIPPvhAK1eu1DXXXGN0PLiIGTNmaPPmzXriiSeMjgIXtX37dnl6emrMmDFq27atOnbsqCeffJL5i3DKjh075HA4FBgYqHvvvVdt2rRR+/bt9dRTTyk3N9foeHBBb775pqxWq+69995ye04uA0SlycrKklT0y+K/+fr6ShL/ucIpYWFhRkdAFbNhwwZ98MEH6tevnxo0aGB0HLiQ+fPn6+6775Yk9erVS5deeqnBieAKkpOT9eKLL+rFF18sl8skUD1t27ZN2dnZuuqqq3Tbbbdp06ZNevPNN5WQkKDPP/+8xGoZ4L/S0tIkSY888oj69++vd999V9u3b9drr72mvLw8vfTSSwYnhCs5evSoZs+erZtuukkBAQHl9ryUVag0DofjjPsZCAmgssXHx+u2225T7dq19dxzzxkdBy6mefPm+vLLL7V9+3a9/vrruvXWW/XZZ5/xSyJOy+Fw6NFHH1XPnj01cOBAo+PAhU2ePFmBgYFq0qSJJKljx44KDQ3Vgw8+qJUrV6pr164GJ4SZFRQUSJLatWunp556SlLR/EWHw6GJEydq3LhxiomJMTIiXMiMGTNkt9s1evTocn1e2gFUGn9/f0kqdTvUkyuqTu4HgMowZ84c3XjjjYqKitKUKVMUHBxsdCS4mJiYGHXs2FHXXnutHnvsMa1Zs0br1q0zOhZMbOrUqdq+fbseffRR2Ww22Wy24j/m/ft94Gw6depUXFSd1KtXL0lFq66AMzl5ZUuPHj1KbO/WrZscDoe2b99uRCy4qF9++UXdu3cv99XClFWoNCdnVf13gPG+fftK7AeAivbpp5/qvvvuU5s2bTR16lTVrFnT6EhwEceOHdPs2bN16NChEtubN28uSTp8+LARseAifvnlF6Wnp6tbt25q0aKFWrRoodmzZysxMVEtWrTQrFmzjI4IF3D06FHNmDGj1M2JTs4a4o8vOJu6detKkvLz80tsP7niihXCcNahQ4e0ZcsWDR48uNyfm7IKlSY2Nla1a9fWvHnzSmyfP3++6tatq1q1ahmUDEB1MmPGDL300ksaPHiwPvroI1Z14pzY7XY98sgjmj59eontK1askCQ1btzYiFhwERMmTNDMmTNLvPXu3VuRkZHF7wNnY7FY9OSTT+rLL78ssX3OnDlyc3MrdRMR4L8aNGig6OhozZkzp8T2xYsXy93dXW3btjUoGVzNhg0bJKlCvu8wswqVaty4cRo/frwCAwPVq1cvLVy4UHPnztXkyZONjgagGjh69Kief/55RUdHa9SoUdqyZUuJ/XXq1GHgMc4oJCREI0eO1AcffCBvb2+1atVK8fHxev/993XVVVepfv36RkeEiZ3q/AgKCpKnp6datWplQCK4opCQEI0aNUpffPGF/Pz81KFDB8XHx+u9997TqFGjiu+0DZyOxWLRAw88oPvuu08PPPCA4uLitGnTJr377ru69tpr+VkITtuxY4d8fHwUHR1d7s9NWYVKFRcXp/z8fH3yySeaMWOGYmJiNHHiRA0ZMsToaACqgWXLlunEiRNKTk7WqFGjSu3/3//+p8suu8yAZHAl48ePV1RUlGbOnKk333xTkZGRuvvuuzVmzBijowGoJh5++GFFRETo22+/1QcffKCIiAjdfffduvnmm42OBhcxZMgQeXp66u2339bYsWMVGhqqcePGaezYsUZHgws5cuRIud4B8N8sDiY5AgAAAAAAwCSYWQUAAAAAAADToKwCAAAAAACAaVBWAQAAAAAAwDQoqwAAAAAAAGAalFUAAAAAAAAwDcoqAAAAAAAAmAZlFQAAAAAAAEyDsgoAAAAAAACmQVkFAABcypo1a9SkSRN99913Rkcps0OHDunCCy9UUlKS0VEqzPTp09W3b9/T7n/kkUfUpEkT7d+/v1xf97HHHtOLL75Yrs8JAAAqB2UVAACAQZ5//nkNHTpUMTExxduOHTumJk2a6OabbzYwWflZsWKFunTpUumvO27cOE2fPl3btm2r9NcGAABlQ1kFAABggD/++EMLFy7ULbfcUmL7li1bJEktWrQwIla5stvtWrNmjTp37lzpr12rVi0NHTqU1VUAALggyioAAAADTJkyRe3bt1dUVFSJ7Zs3b5YkNW/e3IhY5WrLli3KyMgwpKySpKuuukqrV69mdRUAAC6GsgoAAFQJaWlpmjBhgnr27KmWLVuqZ8+emjBhgtLT00sdu3//ft11111q166d2rVrp9tvv11JSUnq06ePrrvuugrPevDgQS1evFj9+vUrte/kyqqqUFatXLlSzZo1U3BwsCGv36ZNG0VGRmrq1KmGvD4AADg/7kYHAAAAKKusrCyNGDFC+/bt0xVXXKHmzZtr69atmjZtmlavXq0ZM2bIz89PkpSenq5Ro0bp6NGjGj58uOrXr6/4+Hhdf/31On78eKXkXbZsmQoLC9WrV69S+7Zs2aLAwMASc6xc1cqVKw1bVXVSx44dtXTpUkMzAACAc0NZBQAAXN5HH32kvXv36sknn9SoUaOKtzdr1kzPPPOMPvroI917772SpA8//FApKSl6+eWXdemll0qSRo4cqf/973/6+OOPKyVvfHy8atSoUaqQys7O1r59+3ThhRdWSo6KlJeXp7Vr1xo+KL5x48b68ccflZSUVCUKQAAAqgMuAwQAAC7v119/VUhIiK655poS26+55hqFhIRowYIFxdsWL16s8PBwXXzxxSWOHTNmTKVklaSkpCRFR0fLYrGU2L5161Y5HI4qcQlgfHy8HA6HOnToUK7Pm5qaqg8//FDjx4/XpEmTtGnTpjMef7Kg2r9/f7nmAAAAFYeyCgAAuLz9+/erXr16cncvuWjc3d1ddevWVVJSUoljY2NjZbWW/DEoNDRUAQEBJbbNmTNHI0aMUNu2bdWnT59Sr2uz2fTcc8+pU6dO6tChgx599FHl5eWdNe+xY8eKL0v8t5PD1c90J8A///xTbdu2LfXWsmVLNWvWrMSxTz/9tJo0aaJ169aVep7rrrtOTZo00W+//VbqY27SpInGjh1bvC0hIUF33HGHLrroIrVt21b9+/c/6132VqxYobZt28rb2/uMx52LX375Re+88466dOmip556SiNGjNCKFSv0yiuvyOFwnPIx/778EwAAuAbKKgAAgNMIDAzUtddeW3wJ4X+99957WrNmjX788UfNnz9fu3fv1ssvv3zW57VarbLb7aW2O3MnwA4dOmjdunUl3ubNm6egoCDdc889xcfl5ubqp59+UlBQkGbMmHHK56pfv76+/fbbEttmzpyp+vXrl9g2duxY1atXTwsXLlR8fLw+/PBDNWnS5Iwf46pVq9SlS5czHnMuduzYoeTkZD311FNq0aKFvL29FR0drbFjx6pv376aNm3aKR938vPs5uZWblkAAEDFoqwCAAAuLyYmRgkJCbLZbCW222w27d27t8SsoujoaO3bt69UWXT06FFlZmaW2Na1a1cNHTpU0dHRp3zdmTNn6rbbblNERIRCQkJ055136rvvvlNhYeEZ84aGhurYsWOltm/ZskU1atRQvXr1zvj4f8vPz9ddd92l9u3b67bbbivePm/ePFmtVo0fP15z585VTk5OqccOHjxYq1evVlpamiQpOTlZW7duLXGXwrS0NO3bt0/Dhw+Xr6+vrFar6tatq7i4uNNmSk9P19atW8u1rJo/f75uvPHGU+5r06aN0tPTS339JRV/nkNDQ8stCwAAqFiUVQAAwOX169dPaWlppVYQffPNN0pLSytRvvTu3Vupqan66aefShx7rsPVMzMzdfDgQTVt2rR4W4sWLZSTk6Pk5OQzPrZWrVo6fPhwiVLrxIkTSkhIULNmzUrNsjqTp556Snl5eXrppZdKbJ8xY4aGDBmiIUOGyMPDQ3PmzCn1WF9fX/Xr10+zZ8+WVFS+XXzxxfL09Cw+JiQkRA0aNNCjjz6qn3/+WYmJiWfNtGrVKvn5+ally5ZOfxxn4+PjU/x5WbdunS688EK98847xftbtmypvXv3lnrcoUOHJBV9zgEAgGvgboAAAMDl3XzzzZo3b56eeeYZbdmyRc2aNdPWrf/f3v2FNLnHcRz/TFKozf5oI8b6a4ZUVKjEEukiL4rMEGQjySAwhEKCQBmoXXhRUBREJaQTg0qKcK0ZRRjl7tILM4nwTCyKNLoIaWIwh7mdK0fPmZ6zwzmdFuf9uhrf58++e3b34ff7Pr/J6/Vqw4YNhjfS1dTU6OHDh2psbNSrV6+Uk5OjFy9e6OXLl1qxYkXS3zm3Uun7OVeZmZmGYwvZtWuXfD6fRkdH42FXMBjU7OysIpGIPB5PwjVLlizRkSNHDLWbN28qEAjI6/Vq8eLF8fq7d+80MDAgt9utjIwMlZaWyuv1yuVyJdzX6XTq9OnTOnr0qO7fv6+2tjY9efLEcM6tW7fU0dGh1tZWvX37VjabTXV1dSotLZ339/X19cnhcCTMBfszly5dktlsTqjv379fRUVFhlowGFQoFNLg4GC8Zjab533uQ0NDWrduHWEVAAC/EMIqAADwy8vMzNSdO3d05coV9fb2yufzKTs7W5WVlTp58qRhmHlWVpZu376t8+fP6969ezKZTHI4HLpx44acTmfSA8HngpWpqSlZrdb45++PLWT37t1KS0vTwMBAPKwaHh6WJL1+/XreN9zt3LnTEFb19/fr4sWLam9v1+rVqw3ndnV1KScnRzt27JAkVVRUyOVyaXR0VJs2bTKcW1BQoFgspqtXr2rlypXKy8tLCKuys7Pldrvldrv19etX3b17V/X19crLy9PGjRsTen3+/Lmqq6v/9Bn80R9Xus3JyclRUVGRpqen4zWXyyWr1ar8/Px4bWRkRAcOHDBcG41GNTQ0tGCoBgAAUhNhFQAA+KU4HA6NjIwk1LOystTc3Kzm5ua/vMeaNWvU0tJiqH358kWhUEg2my2pPpYuXSqbzaZgMBgfSD48PCyz2bzgjKvvey0pKdGjR4/iAVRVVZWqqqqS+u7x8XGdOnVKbrdbDofDcGxmZkbd3d2amppScXGx4ZjX61VDQ0PC/ZxOpy5cuJDUs7NYLDp27Jg8Ho/evHkzb1j17NmzpH6HJJ07dy5hC+N87Ha7BgcHVVBQoEWLFhm2dk5NTWl8fFzLly83XNPX16eJiQk5nc6k+wEAAD8fYRUAAPjfmZ6eTlhBNbf17vuAZ3Z2Vt++fdPMzIxisZgikYhMJlN8ppPT6VRbW5sKCwuVnp6ulpYWVVRUJPXmuerqah0+fFgfPnzQ2rVrk+49HA6rtrZWJSUlCdsCJSkQCGhyclJ+v1/Lli2L1x88eKD29nbV1dUZZlJJ0qFDh7R582bDSqU5k5OT6ujo0MGDB7V+/XrFYjH5fD6Fw2Ft3bo16b7/qfLycp09e1bhcNjwH42Njeny5cvzhnB+v1/FxcWGuWIAACD1EVYBAID/nZqaGtntdm3ZskXRaFT9/f0KBALKz883rNjp7u42hCDbt2+X3W5Xb2+vJOn48eMKhUIqKytTNBrVvn37VF9fn1QPhYWF2rNnjzwej86cOZN07z09PQoGg3r//r0eP36ccHzbtm0qKytTbm6uoV5ZWanW1lY9ffo0YVucxWJZ8M196enp+vz5s06cOKGJiQllZGQoNzdX165dS9h++COZTCY1Njaqs7NTXV1dSktLUzQaldVqVVNTU8K8sbGxMfX09Kizs/M/6xEAAPw7TLFYLPazmwAAAPgvXb9+XX6/Xx8/flQkEtGqVau0d+9e1dbWGuZb/WifPn1SeXm5vF7v31pdhb/W0NAgi8Wipqamn90KAAD4mwirAAAAAAAAkDKSf58wAAAAAAAA8IMRVgEAAAAAACBlEFYBAAAAAAAgZRBWAQAAAAAAIGUQVgEAAAAAACBlEFYBAAAAAAAgZRBWAQAAAAAAIGUQVgEAAAAAACBl/A4xkHKhZ+CmQQAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 1440x720 with 1 Axes>"
       ]
@@ -554,9 +548,11 @@
   {
    "cell_type": "markdown",
    "id": "673031c9-7d80-45d4-b209-301c127d3edf",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "source": [
-    "# A better-sampled grid\n",
+    "## A better-sampled grid\n",
     "\n",
     "The IMF has many more low-mass stars than high-mass stars. So, instead of sampling M1 linearly, we can sample it in log space. \n",
     "\n",
@@ -565,7 +561,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 15,
    "id": "5956f746-e3b9-4912-b75f-8eb0af66d3f6",
    "metadata": {},
    "outputs": [],
@@ -584,7 +580,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 16,
    "id": "108d470a-bb21-40b0-8387-2caa7ab0f923",
    "metadata": {},
    "outputs": [],
@@ -605,7 +601,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 17,
    "id": "fb8db646-f3d0-4ccd-81ba-7fde23f29c79",
    "metadata": {},
    "outputs": [
@@ -620,9 +616,8 @@
       "Total starcount for this run will be: 40\n",
       "Generating grid code\n",
       "Constructing/adding: lnM_1\n",
-      "Population-83f80d829dbd418aa2bc745c99b71991 finished! The total probability was: 0.9956307907476224. It took a total of 0.9961590766906738s to run 40 systems on 2 cores\n",
-      "There were no errors found in this run.\n",
-      "OrderedDict([('luminosity distribution', OrderedDict([(0.25, 0.0212294), (2.75, 0.00321118), (-0.25, 0.0268827), (1.25, 0.0104553), (3.75, 0.00283037), (6.25, 7.34708e-05), (-0.75, 0.0771478), (0.75, 0.030004499999999996), (2.25, 0.00921541), (3.25, 0.0045385), (1.75, 0.014776889999999999), (4.25, 0.002380189), (4.75, 0.000869303), (5.25, 0.0007310379999999999), (5.75, 0.00036002859999999996), (-2.75, 0.1961345), (-1.75, 0.2181597), (-3.25, 0.0), (-2.25, 0.2568974), (-1.25, 0.11973310000000001)]))])\n"
+      "Population-4f3ee0143c0548338494d2f1fbacc915 finished! The total probability was: 0.9956307907476225. It took a total of 1.5107016563415527s to run 40 systems on 2 cores\n",
+      "There were no errors found in this run.\n"
      ]
     }
    ],
@@ -645,13 +640,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
+   "execution_count": 18,
    "id": "68ee1e56-21e5-48f4-b74c-50e48685ae94",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABKsAAAJgCAYAAABFgeDFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8rg+JYAAAACXBIWXMAAAsTAAALEwEAmpwYAACaK0lEQVR4nOzdd3hUZd7G8Xtm0nvvAULohB5QmnQEsSBrBcXe3dVddV07dn3XumvvHdsqKAIqXRCkl0BCIAmk94T0Mpl5/whGIyABkpyU7+e6uHY5ZzJzT/BAcud5fsdkt9vtAgAAAAAAANoAs9EBAAAAAAAAgF9RVgEAAAAAAKDNoKwCAAAAAABAm0FZBQAAAAAAgDaDsgoAAAAAAABtBmUVAAAAAAAA2gzKKgAAAAAAALQZDkYHaA+Kispls9lb/HX8/T1UUFDW4q8DtFVcA+jsuAbQ2XENAFwHANdA52A2m+Tr637M85RVTWCz2VulrPr1tYDOjGsAnR3XADo7rgGA6wDgGgDbAAEAAAAAANBmUFYBAAAAAACgzaCsAgAAAAAAQJtBWQUAAAAAAIA2g7IKAAAAAAAAbQZ3AwQAAAAANEltbY1KS4tltdbIZqszOg46oNxcs2w2m9ExcJLMZoscHJzk6ekjR0enk34eyioAAAAAwHFVVpartLRIHh7ecnb2k9lskclkMjoWOhgHB7OsVsqq9shut8tmq1N1daWKinLl6ekrV1f3k3ouyioAAAAAwHGVlR2Sj0+AnJxcjI4CoA0ymUyyWBzk5uYpBwdHlZQUnnRZxcwqAAAAAMBx1dXVytHR2egYANoBR0dnWa21J/3xlFUAAAAAgCZh2x+ApjjVvysoqwAAAAAAANBmUFYBAAAAAIB2yW63Gx3hmIzOZvTrnwrKKgAAAABApzVmTOyf/nr77deP+JiXXnpBY8bE6rXXXjrqcz7++DyNGROrv/zl7GO+7qOPPqAxY2L1+OPzGh3fsWO7/vnPv2vGjEmaMGGkZs2aoSeffEQZGel/+j4WL/5WY8bEKjc35/hv+hTdeuv1uu22m1v8df7oj+/xwIEU3XzzNS3yWo8/Pk8XXzyz4fcXXHCOnnrq0SZ//Lp1P+mxxx5q8dc5lqN9bsaMidV77711ys/dGrgbIAAAAACg03rttXePevzVV/+jnTu3a+DAQY2OW61W/fDDEkVH99Dixd/q2mtvlIPDkd9am0wm5eRka8+eOPXrF9PoXHV1tX76ac0RH7Nx4wbddddtGj9+kv71rwfk7u6hjIx0ffLJB7r++iv0xhvvKzw84hTebfO4445/GTK/bOTIMXrttXfl6+snSVq1arl27drZKq/9xBP/lru7R5Mf//nn81VXZz3u46688lpVVJSfSrSjOtrn5rXX3lVwcHCzv1ZLoKwCAAAAAHRaMTEDjjj21VdfaMeObZo792oNH356o3MbNqxTUVGhHn30ad1yy7Vas2aVJk6cfMRzhIaGqaamRqtWLT+irNqw4WdZLBYFB4c0Ov7RR+9pwIBBevjhJxqODR0aq5EjR+uii2bq008/1h133H0qb7dZREV1N+R1fX195evra8hr9+rVp0WetzXLx6P9t95WsQ0QAAAAAIDD4uN367//fU7Dhg3XtdfeeMT57777Vr1799WgQYPVr1+MFi786qjPYzKZNH78JK1cueKIcytW/KBx4yYcsSKrsLBQNpvtiMcHBATqH/+4S8OHn9bk93G0rXpbt27WmDGx2rFjuyTp7bdf1+WXX6QVK5Zp9uy/aOLEUbrhhquUmnpA69b9pMsvv0iTJo3W9ddfqX379h7zuceMidWCBf/TE088rGnTJmjKlDP0wAP/UlFRYaPXX7r0O1199RxNnjxG559/ll566QVVV1c1nC8qKtKDD96nc889UxMnjtaVV87WkiWLGs7/fhvg22+/rrfeeq3h9d9++3Xdf//duuCCc46Y1fTQQ/fq2mvnHvNzVVJSoieeeFjTp0/UtGkT9Mor/zniz+GP2/N+/HGprrjiUk2cOFpnnz1FjzzygPLz8xo+P1u2bNT27Vs1Zkystm7d3PC5X7jwK82aNUNnnjlO27dvPWIboCTV1tbomWee1JlnjtOMGZP0zDNPNVp9dbStgsf73Pz6/3+/DTA3N0ePPvqgZs6crkmTRuuWW67Ttm1bGs5nZWVqzJhYrV69Qvfee5emTBmr6dMn6umnH1dVVZVaEmUVAAAAAACSSktL9eCD98jb20fz5j0us7nxt8xFRUVav36tzjzzLEnSWWedra1bNyk9Pe2ozzdx4mRlZWUoISG+4VhVVZV+/nmtJk2aesTjTz99lHbu3K7bbrtJixd/q8zMjIZzZ589U2ecMb4Z3mVj2dlZeuONV3TttTfpgQceUXp6qu6663b997/Pae7cq/Xww08oJydLjz764J8+z2uv/VeS9OijT+rmm/+mdet+0ksvPd9w/u23X9fjj8/T4MFD9cQTz+jii2dr4cKv9M9//qOhXHr00Qd04ECy7rzzHj3zzIvq1au3Hn98nrZu3XzE651zzkydd96sw6/9rs45Z6ZmzDhH2dlZ2rFjW8PjysvL9NNPqzV9+tHnh9lsNt1xx1+1fv063Xrr7br//nnatWuHli//4ZjvdefO7XrssYc0fvxEPfvsf/TXv/5dW7Zs1MMP3y+pfptk37791KtXb7322rvq3fu3VVnvvfeWbrvtDt1++11HrLj71bJlP+jAgRQ9+OBjuuqq6/T994v14IP3HDNPUz43f5Sfn6/rrpurPXvidPPNt+nhh5+Us7OLbr/9Zm3ZsqnRY5966jGFhYXrySef1ezZl2vRogX68MOjb59tLmwDBAAAAACctOTMEn27LkVVNXWG5nBxsuic0VHqHuZ10s/xxBPzlJubo//85/WGuUi/98MPiyVJU6ZMkyRNmnSm/vOf5/XNN1/p5ptvO+LxAwYMUmBgkFatWq4+ffpKkn7+ea1cXFw1dGjsEY+//vqbVV5ersWLv2koDIKCgjVy5GhdfPFsdenS7aTf27FUVlbqn/+8tyHP9u1b9b//fa4XX3xVw4YNlySlpaXp5ZdfUEVFhdzc3I76PD169NK999YPFB8+vH6F2po1qyRJJSWH9PHH7+v88y/Q3/52hyRpxIjTFRgYrIceukfr16/TqFFjtH37Vl199XUNpdzgwUPl7e0jR0fHI14vKChYgYFBkn7b3ubvH6DAwCB9//1iDR48VJK0YsUySXZNmXLmUXNv2PCz4uN369ln/6vTThspSRo2bIQuvPCcY37OduzYLmdnF82Zc4WcnJwkSV5e3kpI2CO73a6oqO5yc/NQXZ31iK13s2ZdpHHjJh7zuSXJx8dHzz77Hzk7u0iSHBwc9MwzT2nfvr3q2bP3n36sdPTPzR999tnHKi0t0xtvvN+wHXXUqDG68spL9eqr/9Vbb33Q8NjRo8fq1ltvlyTFxo7Qpk2/6Oeff9J119103Cwni7IKAAAAAHDSftycph1JBUbHkCS5Ojvo+nP7n9THfvrpR/rpp9W6+ebbNGjQ4KM+ZvHibzV8+GmyWCwqLS2VVL8aavHiRbruupuPKFV+3Qq4atVy3XjjrZLqtwCOHz9JFovliOd3cnLS3Xffp2uvvUHr169r2D62cOFXWrz4Wz3yyJMaO3b8Sb2/P9O//28rfH4t6X6/6sfb21uSVFZWesyyasCAxoPog4KCVVVVKUnavTtONTU1mjy5cWE0YcIkPfaYo7Zt26JRo8ZoyJBYvfnm60pISNDpp4/U6aeP0S23HFkCHovFYtG0aTP09ddf6u9//6ecnJy0ZMkijRo1Vl5e3kf9mB07tsnJybmhqJIkV1dXnX76aO3ateOoHzNkyFC9+eYrmjv3Yo0fP0kjR47WiBGna+TI0cfN2LNnr+M+ZuTIMQ1FlSSNGTNezzzzlHbu3N6ksqoptm/fqoEDBzWam2Y2mzVp0lS99dZrjbYd/vHPNjAwSLm5uc2S41goqwAAAAAAJ21KbKSqqq1tYmXVlOGRJ/WxcXG79NprL+mMMyZo9uzLj/qYhIR4JSXtV1LSfk2fPuGI86tXrziijJHqtwJ+8cV87du3V+HhkVq/fp2ee+6lP83j7x+gs88+T2effZ6k+llTjzzygJ555imNGTOuWe/EZ7FYGhUjv3J1dT2h53F2dm70e5PJ1LC9r7S0RFL9+/o9s9ksHx9flZWVSZIefvgJffTRu1q27AetWrVcZrNZsbGn6Z//vFchIaFNynHWWefoww/f1bp1a9SrVx/t2rVD//d/zx/z8SUlJfLx8Tni+B+z/l5MzED9+98v6rPPPtZnn32sjz56T35+/po79ypdcMElf5rP1fXoZd/v/XFV36/5fv08NYfS0hJ16dLliON+fv6y2+2qqKhoOObi0vi/D7PZLLv9yNlqzYmyCsAx2e12peWWaVNCruIPFsnT1VFRoV7qFuqpbqFe8nJzMjoiAAAADNY9zEu3XTjo+A9so0pKDumhh+5RSEhowza2o1m8+Bu5u7vrySefPeLcI488oIULvzpqWRUTM1BBQcFauXK5oqK6y8vLWwMHDj7icbt3x+lf//qHHnzwkSPuQDh0aKxmz75c//nPcyotLTnmKqHfM5lMstkaF4iVlZXH/biW4OnpKUkqKMhvdPc7m82moqLChjLGw8NDt956m2688a9KTT2gn35arffee0vPPfd/f1o4/V5kZBcNHDhYK1YsU0ZGuvz8/DVixMhjPt7Hx0fFxUWy2+2NSsCSkkN/+jqnnTZSp502UlVVVdqyZZO++GK+XnjhGcXEDGrY8nmyfl2196tfB9X/WmLV/9k2LosqKyt0Ijw9PVVQcOSKyIKCfEn12xp//f9GoKwCcISMvDJtjM/VpoRcZRc2/kvv90u8/b2c1S3US91CPOtLrBBPubkcuZ8cAAAAaIvsdrsee+whFRUV6fXX35GHh8dRH1dTU6Mff/xeY8eOP+qsqSlTpmn+/A+VmnrgiLlS9VsBJ2r16hU6eDBFEydOPurKqMjILqqsrNAXX3yqYcNGHDHcPTX1oAIDg5pUVEmSu7u7UlKSGx3buXN7kz62ufXvP0BOTk5atuz7RkXdypXLZbVaNXDgIOXm5ujGG6/W7bffoTPOmKguXbppzpxuiovbpayszKM+79G2UkrSjBnn6oUXnlFGRrrOPHP6MR8nScOGDdeHH76rtWtXN2yxrK2t1caNG464W+OvXnnlP9q2bbPeeON9ubi4aPTosQoKCtZVV81Wbm6O+vTpK4vFrLqTXGy4efNG1dXVNeReuXKZJDXM4XJzc1dOTk6jj/njn+2fvef65xqm//3vc+Xm5igoKFhSfXm4YsWP6tu3X8MsLqNQVgGQJGUVlGtTfK42JuQqM7/8iPNdgz1VWW1VbvFvP40pKKlWQUmetuzNazgW7OuqbqFeigqpX33VJdhDLk78VQMAAIC258svP9PPP6/VBRdcourqGsXF7TriMe7u7kpOTlJpaclRV05J0rRpMzR//odauPBr/fWvfz/i/MSJU/T55/OVkZGul19+66jP4eXlpZtvvk3PPfe0brnlWp1zzvkKCwtXWVmZ1qxZqaVLv9O8eU80+b2NGjVWa9eu0X//+7xGjx6rnTu3a+nS75r88c3Jy8tbl156uT744B05ODho5MjRSklJ1ttvv67Bg4fqtNNGyWw2KyQkVM89938qKSlVeHiEEhLitWHDOl1xxTVHfV4Pj/oVWz/+uFQxMQMVGhomSZowYbJeeOEZJSYm6IEHHvnTbLGxIzRixEg98cQjuuGGAgUHB+uLLz5VcXGRAgICj/oxw4eP0Pz5H+rxx+fpzDOnq7bWqk8++UA+Pj4aMmRYQ7YdO7Zpy5ZNJzxnKi8vRw89dI9mzrxA+/Yl6s03X9VZZ52jLl26SqofhP7RR+/pww/fU//+MVq7drW2bGl8x8RjfW5+dfHFc7R06Xe67babdPXV18vNzV1ff/2FDh48oH//+8UTytsS+A4S6MRyiirqC6r4XKXnHbn/uWuIp0b0DdLw3kEK8Knfs15WWauD2aU6kF2ilKz6/y0sqf7dc1Yqp6hSv+ypb/pNJinM313dDpdX3UI91SXIQ44Of970AwAAAC0tMTFBkvTll5/qyy8/PepjBg8eKmdnF/n4+Cg2dsRRHxMd3UM9e/bS0qWLdMMNtxxxvn//AQoODpHZbGk0zPyPZs26UF26dNWXX36q119/SYcOHZKbm7v69euvF198taEIaYoZM85VRka6lixZpAULvtTgwcP02GNP66abjl78tLTrrrtJfn5++t//PtfXX38pX18/nXfeLF199Q0Nq8gef/z/9PrrL+mtt17ToUPFCgoK1tVXX685c6446nOOHTteixd/o8cfn6dzzz1f//jH3ZIkNzc3DRkyVEVFRYqK6n7cbE888W+9+up/9NZbr6q6ukaTJk3RuefO0s8//3TUxw8ffrrmzXtcH3/8ge69958ymUwaNGiw/vOf1xq2PJ5//gXavXuX7rzzb7r//oePenfJY5k58wKVlpbonnvukLOziy688JJGd96bO/dqFRcX65NPPpDVatWoUaP1r389oH/96x/H/dz8KiAgQK+++rZeffU/euaZJ2Wz2dSnTz89//zLR1092NpM9l8nnuGYCgrKZLO1/KcpMNBTeXmlx38gcAryiiu1OaG+oDqYc+R/b5FBHvUFVZ8gBfkef/ifJB0qr9GBrBKlZJXoQHapDmSVqKSi9piPt5hNCg90b9g6GBXqpbAAd4WGeHMNoFPj3wF0dlwDQNu+DrKzDyokpKvRMdDBOTiYZbWe2vDuiooKnX/+dN1yy+0699zzmykZTtSf/Z1hNpvk73/0bbcSK6uATqGwpKphBlVKVskR58MD3TW8T31BFervfsLP7+3upEE9AjSoR/0dM+x2u4pKqxtWXh04XGKVV1klSXU2u1JzypSaU6bVh5/DwWJWdLi3IgLcGwa4h/q5yWxuvjudAAAAAOi4srIytXTpd9qw4We5uLho6tTpRkfCSaKsAjqootLq+hVUCTlKyjiyoArxc2tYQRUeeOxG+2SYTCb5ebnIz8tFw3rX7/O22+3KK65sKLBSskp1MKdU1YdvcWyts2lvapH2phY1PI+zk0Vdgz1/G+Ae6qkgH9dmvVUvAAAAgI7BZDLriy8+lbu7ux566HG5uLgYHQknibIK6EAOlddoc0KuNsXnaF/6If1x82qQj6uG9w3SiL7Bigh0b9XSx2QyKcjXTUG+bjqt3693m7Aru7CiYftgen65kjMOqfbwst/qmjolphUrMa244XncnB3qV16FeCnq8P/6eTlTYAEAAACdXEhIiBYvXm50DDQDyiqgnSupqNHWvXnaGJ+jvWnF+uMUugBvl/qCqk+wugR7tKlSx2w2KSzAXWEB7ho9IFSBgZ7Kyj6kzPzyhtlXKVmlSs8rU93huXEV1VbtOVCkPQd+W4Hl5eZYP7z98BD3qFAvebsbe6tVAAAAAMDJoawC2qGyylptTczTpvgcxR8slu0PDZWfl/PhGVTBigr1bFMF1fE4WMzqEuypLsGeOmNQ/e1Va611SsstP7x9sH4VVmZ+eUMxV1JRq51JBdqZVNDwPL6ezo22D3YL8ZKHq6MRbwkAAAAAcAIoq4B2oqKqVtv25WtjfK72HChsWGn0Kx8PJ8X2qd/i1z3MS+Z2VFAdj6ODRd3DvNQ9zKvhWFWNVak5ZQ3D21OyS5VTWNFwvqi0WkWl1dq2L7/hWHS4l64+q+9JDZEHAABA/RzS9vSDUADGsP9xy88JoqwC2rDKaqu278vXpoRcxaUUyFrX+IL3cndSbO9AjegbrB4R3h2qoDoeFycH9Yr0Ua9In4ZjFVW1Oni4uPp1C2FBSVXD+aSMEj3y3mZdMa23Tu8fYkBqAACA9sticVRtbbWcnBhaDeDP1dZWy8Hh5He2UFYBbUxVjVU79hdoY3yOdiUXylpna3Tew9VRsb0DNbxvsHpH+shs7jwF1fG4uTiqbzc/9e3m13CspKJGB7JKtTMpXyu2Zqi6tk5vfLtHCanFmj25p5wcLQYmBgAAaD88PLxVXJwvd3dvubi4ymy2sMoKQAO73S6brU5VVZUqLz8kT0/fk34uyiqgDaiurdOupPqCamdSgWqsjQsqdxcHDe1Vv4KqT1cfWcxmg5K2P15uThoY7X/4V4DeWrRHZZW1WrMjU8mZJbr5/BiF+LkZHRMAAKDNc3V1l4ODo8rKilVefkg2W53RkdABmc1m2Wy24z8QbZLZbJGjo5N8fYPk6HjyN70y2U91I2EnUFBQJput5T9NgYGeyssrbfHXQdtQa63TruRCbYzP0Y79BaqubfyPvauzg4b2CtDwPsHq181XDpaOX1C1xjVQWFKl177Zrf3phyRJzk4WXTmtj07rF9yirws0Bf8OoLPjGgC4DgCugc7BbDbJ39/jmOdZWQW0olqrTbtTCrUpIUfb9uWrqqZxQeXiZNGQnvUFVf8oPzk6dPyCqrX5ebnon5cO0dc/JWvJhlRV19Tp9W92a29asS6d1EOODmwLBAAAAAAjUVYBrSCroFyLNxzU1sR8VVZbG51zdrRoUA9/jegbrAHd/ShLWoGDxawLx/dQrwgfvbVoj8qrrFq1LUPJGYd008wYBbMtEAAAAAAMQ1kFtIJXF+xWel5Zw++dHMwaGH24oIr2lzNDvg0xqEeAHr56hF5dGKekjBKl5pbp4fc26crpfTSiL9sCAQAAAMAIlFVAKygpr5YkhQW465xR3TSoh79cnLj82gI/LxfdPXuovlqTrKW/pKqqpk6vLazfFnjJRLYFAgAAAEBrYyAO0Ip6RfrotH7BFFVtjIPFrIsm9NDf/jJQ7i71fzYrt2boiQ+3KreowuB0AAAAANC5UFYBwGGDewbooauGq3uYlyTpYE6pHn5vkzYn5BqcDAAAAAA6D8oqAPidAG9X/WvOUE0dHilJqqyu0ysL4vTxD4mqtdoMTgcAAAAAHR9lFQD8gYPFrEsm9dRfZw2Qm3P9tsDlW9P1xEdblFtcaXA6AAAAAOjYKKsA4BiG9ArUvKuGKyr08LbA7FI9/O4mbdnLtkAAAAAAaCmUVQDwJwJ8XHXPZUM1JfbXbYFWvfx1nD75MVHWOrYFAgAAAEBzo6wCgONwsJh16eSeunXWALke3ha4bEu6nvxoi/LYFggAAAAAzYqyCgCaaOjhbYHdQjwlSSlZ9dsCtybmGZwMAAAAADoOyioAOAGBPq6657JhmjwsQpJUUW3VS1/t0qfL97EtEAAAAACaAWUV0ArsRgdAs3J0MGv2lF665fyYhm2BP2xK01Mfb1X+IbYFAgAAAMCpoKwCgJM0rHeQHrpquLoe3haYnFmiee9s0rZ9bAsEAAAAgJNFWQW0IpPRAdDsgnxcde9lwzRp6G/bAv/7v136bAXbAgEAAADgZFBWAcApcnQwa87UXrp5ZoxcnS2SpO83punpj7eq4FCVwekAAAAAoH2hrAKAZhLbJ0gPXjlcXYI9JElJmSWa9+5Gbd+fb3AyAAAAAGg/KKsAoBkF+7rpvsuHacLQcElSeZVV//lypz5fuZ9tgQAAAADQBJRVANDMHB0sunxqb914Xn+5ONVvC1z6S6r+75NtKixhWyAAAAAA/BnKKgBoISP6BuuhK4erS1D9tsD9GYc0791N2pnEtkAAAAAAOBbKKgBoQcF+brpv7jCNH1K/LbCsslYvfLFTX6zarzob2wIBAAAA4I8oqwCghTk6WDT3zN66/tx+cj68LXDJBrYFAgAAAMDRUFYBQCs5vV+IHrpyuCIC67cF7kuv3xa4K7nA4GQAAAAA0HZQVgFAKwrxc9P9c4dp3OAwSfXbAp//fIf+tzqJbYEAAAAAIMoqoFXY7UYnQFvi5GjRFdP66Lpz+snZsX5b4HfrD+rf87erqLTa4HQAAAAAYCzKKqA1mYwOgLZkZP8QPXhlrMID3SVJiWnFmvfuRsWlsC0QAAAAQOdFWQUABgr1d9f9c2M1dmCoJKm0olbPf7ZDX61Jls3GkjwAAAAAnQ9lFQAYzNnRoqvO6qtrz+4rJ0ez7JIW/XxAz3y6TcVlbAsEAAAA0LlQVgFAGzEqJlQPXjFc4QH12wITUos1752N2n2g0OBkAAAAANB6KKsAoA0JC3DX/VfEasyA+m2BJRW1eu7T7VrwE9sCAQAAAHQOlFUA0MY4O1p09Yy+umbGb9sCv1lXvy0wt7jS6HgAAAAA0KIoqwCgjRo9IFQPXDFcYb/bFnjfGxs0f9k+lVXWGpwOAAAAAFoGZRUAtGHhAe56YG6szhhUvy2wzmbXj5vTdPdr67Xkl4OqtdYZnBAAAAAAmhdlFQC0cc5OFl05va8euCJWfbr4SJIqq636YmWS7n3jF63fnS2bnXlWAAAAADqGTlVW1dTU6KqrrtLKlSuNjgIAJywq1Et3XTpEt10wUKH+bpKkgpIqvfntHj36/mbFHywyOCEAAAAAnLpOU1YlJCRozpw52rp1q9FRAOCkmUwmDeoRoEeuGaG503rLy91JknQwu1T/nr9NL3yxQxn55QanBAAAAICT12nKqvnz5+vmm2/WwIEDjY4CAKfMYjZr/OBwPXXD6Tp3dDc5Odb/db4zqUAPvv2L3l+aoOKyaoNTAgAAAMCJ6zBl1YIFC9SvX78jfpWWlkqSHn74YU2YMMHglOjsTEYHQIfj4uSgmWO766kbRuqMQWEymSS7XVq9PVP3vL5BC9emqKrGanRMAAAAAGgyB6MDNJeZM2dq5syZRscAAEP4eDjryul9NCU2Ql+sStLOpAJV19Zp4doUrdqWoZljozRmYKgs5g7zMwoAAAAAHRTftQBABxIe6KHbLxykuy4doq7BnpKkQ+U1en/pXj30zibt2J8vO3cOBAAAANCGUVYBQAfUt6uvHrgyVted00/+Xs6SpMz8cr345U79e/42HcwuNTghAAAAABxdmyur4uPj1b9/f2VnZx9xbtGiRZoxY4YGDhyo6dOna8GCBa0fEADaCbPJpJH9Q/TE9afrwgnRcnWu3/mdkFqsh9/bpDe+3a38Q5UGpwQAAACAxtrUzKqkpCTdcMMNslqPHAa8ePFi3Xnnnbriiis0ZswYLVu2THfffbdcXFw0bdq0Jr/Ghx9+2JyRAaDNc3SwaPppXTV2YJi+WZeilVszVGeza8PuHG1OyNPk2AidPbKr3FwcjY4KAAAAADLZ28DwEqvVqs8++0zPPvusHB0dVVxcrNWrVyskJKThMVOmTFFMTIyef/75hmO333679u7dqyVLlhgRG2iy2Q8sUWlFjWaMjtKNswYaHQedXFZ+ud5fvEfrdmQ2HPN0c9TFU3rrrFFRcnRoc4tuAQAAAHQibWJl1ZYtW/TMM8/ommuuUXBwsO6///5G59PS0pSamqp//OMfjY6feeaZWrJkidLS0hQZGdli+QoKymSztXynFxjoqbw85sh0RL92wpWVNfwZ/wmugdbhIOma6X00fmCoPlu5X/vTD6m0olZvLYzTwtX79Zdx0RreJ0gmk8noqJ0O1wA6O64BgOsA4BroHMxmk/z9PY59vhWzHFN0dLSWLVumW2+9VRaL5YjzycnJkqSoqKhGx7t27SpJSklJafmQANDBRId76545Q3XL+QMU7OsqScorrtJrC3fr8Q+3KDGt2NiAAAAAADqlNrGyKiAg4E/Pl5bWt6oeHo1bN3d3d0lSWVlZywQDmkkb2G0LHJXJZNKw3oEa1MNfq7dnauHaFJVV1io5s0RPfbxVQ3sF6oLx0QrxczM6KgAAAIBOok2UVcdzvG/0zeY2sUAMANotB4tZk4ZFaFRMiBZvOKgfNqWp1mrT1sQ87difr3GDw3TumCh5uTkZHRUAAABAB9cuWh5PT09JUnl5eaPjv66o+vU80NaZxAwgtG2uzg76y7hoPXn96Ro9IEQmSXU2u1ZszdC/XluvRT8fUHVtndExAQAAAHRg7aKs+nVWVWpqaqPjBw8ebHQeANA8/LxcdM2MfnroquHqH+UnSaqqqdNXa5J17xsbtHZnVqvceAIAAABA59MuyqquXbsqIiJCS5cubXT8hx9+ULdu3RQWFmZQMgDo2LoEe+qOiwfrHxcPUkRg/dzAotJqvbM4XvPe3aS4lAKDEwIAAADoaNrFzCpJuuWWW3TPPffI29tb48eP1/Lly7VkyRI9//zzRkcDgA4vJspf/a7y089x2fpqTZKKy2qUnlem5z7bof5RfrpoQg9FBh371rMAAAAA0FTtpqyaNWuWampq9M477+iLL75QZGSknn76aZ111llGRwOATsFsNmnMwFAN7xukHzalacmGg6qqqdPulELNS9moUQNCdP7Y7vLzcjE6KgAAAIB2zGQ/3q32oIKCslaZzRIY6Km8vNIWfx20vr++sEblVVZNGhqhOVN7GR2nzeIaaF9Kymu0cF2KVm/LlO3wPyVODmZNGR6ps07vKlfndvPzkDaDawCdHdcAwHUAcA10DmazSf7+x96Z0S5mVgEA2h4vdyddPrW3Hr12hIb0DJAk1Vht+m79Qf3r9fVasTVd1jqbwSkBAAAAtDeUVQCAUxLq766//mWg/jVnqLqHeUmSSitq9dEPiXrg7Y3ampgnFvECAAAAaCrKKgBAs+gV6aP7Lh+mG8/rr0Cf+rlVOYUVeumrXXrq461KyjxkcEIAAAAA7QFlFQCg2ZhMJo3oG6zHrj1dl0zqKXeX+rlV+9IP6fEPtuh/q5MMTggAAACgraOsAgA0O0cHs6YOj9RTN47UtNO6yMFikiR9t/6gNsbnGJwOAAAAQFtGWQW0JpPRAYDW5e7iqIsm9NAj15zWsMrqvSUJyimsMDgZAAAAgLaKsgoA0OJC/Nx07dn9JElVNXV6ZUGcamrrDE4FAAAAoC2irAIAtIpBPQI0/fQukqS03DJ9smyfwYkAAAAAtEWUVQCAVjPrjO7qFeEtSVqzI1M/x2UZnAgAAABAW0NZBQBoNRazWTecFyNPN0dJ0gff71VGfrnBqQAAAAC0JZRVAIBW5evprOvO6SeTpJpam15dEKfqGuZXAQAAAKhHWQUAaHUxUf46Z3Q3SVJmfrk++H6v7Ha7saEAAAAAtAmUVQAAQ5w7Okp9u/pKktbvztZPO5lfBQAAAICyCgBgELPZpOvP6SdvdydJ0sc/Jiott8zgVAAAAACMRlkFtAJ2NwFH5+3hrBvO7S+TSaq12vTK17tUWW01OhYAAAAAA1FWAQAM1aerr2aO7S5Jyimq1PtLE5hfBQAAAHRilFVAKzIZHQBoo2aM7KqYKD9J0sb4XK3almFwIgAAAABGoawCABjObDLpunP6ydfTWZI0f/k+HcguMTgVAAAAACNQVgEA2gRPNyfdeF5/mU0mWevseuXrOFVU1RodCwAAAEAro6wCALQZPSN8dMH4aElS/qEqvbOY+VUAAABAZ0NZBQBoU84cEanBPQIkSVsT8/Tj5nSDEwEAAABoTZRVAIA2xWQy6Zqz+8rfy0WS9MXK/UrKOGRwKgAAAACthbIKANDmuLs46qaZMbKYTaqz2fXqwjiVVTK/CgAAAOgMKKsAAG1S9zAvXTyxhySpsKRaby3aIxvzqwAAAIAOj7IKANBmTRoWodjegZKknUkFWvpLqsGJAAAAALQ0yiqgFbAWBDg5JpNJV07vqyAfV0nSV6uTlZhWbGwoAAAAAC2KsgoA0Ka5uTjoppkxcrCYZbPb9drCOJWU1xgdCwAAAEALoawCWpPJ6ABA+9Q1xFOzp/SUJBWX1eiNb3fLZmPNIgAAANARUVYBANqFcYPCdHq/YEnSngNFWvTzAWMDAQAAAGgRlFUAgHbBZDJp7rTeCvV3kyQtXJuiPQcKDU4FAAAAoLlRVgEA2g0Xp/r5VU4OZtklvfHNbhWXVRsdCwAAAEAzoqwCALQrEYEeumxqb0lSSUWtXl+4W3U2m8GpAAAAADQXyioAQLszZmCoxgwIlSTtTSvWwrUpBicCAAAA0FwoqwAA7dKcqb0UHuguSVr080HtTCowOBEAAACA5kBZBQBol5wdLbp5ZoycHS2SpLcW7VFhSZXBqQAAAACcKsoqAEC7Fervrium1c+vKqus1asL42StY34VAAAA0J5RVgEA2rXT+4do/JBwSVJSRom+Wp1scCIAAAAAp4KyCmgVdqMDAB3apZN6qEuwhyRp6cZUbUvMMzgRAAAAgJNFWQW0IpNMRkcAOiRHB4tumhkjV+f6+VVvfxevvOJKg1MBAAAAOBmUVQCADiHY101XTe8rSaqotuq1hXGqtTK/CgAAAGhvKKsAAB1GbJ8gTR4WIUlKySrV5yv3G5wIAAAAwImirAIAdCgXTeyhqFAvSdLyLenalJBrcCIAAAAAJ4KyCgDQoThYzLrpvP5yd3GQJL27OF45RRUGpwIAAADQVJRVAIAOJ8DHVdfM6CdJqqqp06tfx6mmts7gVAAAAACagrIKANAhDe4ZoGmndZEkpeaWaf7yfQYnAgAAANAUlFUAgA5r1hnd1SPCW5K0enum1u/ONjgRAAAAgOOhrAIAdFgOFrNuPLe/PFwdJUkfLN2rzPxyg1MBAAAA+DOUVQCADs3Py0XXndNPJknVtXV6dUGcqmuYXwUAAAC0VZRVQCuw241OAHRuA7r7a8aobpKkjPxyffTDXmMDAQAAADgmyiqgFZlMRicAOq+ZY6LUp4uPJGldXLZ+2plpbCAAAAAAR0VZBQDoFMxmk244t7+83J0kSR/9kKi03DKDUwEAAAD4I8oqAECn4e3hrBvO7S+TSaq12vTKgjhVVluNjgUAAADgdyirAACdSt+uvpo5JkqSlFNYofeXJsjOYDkAAACgzaCsAgB0OjNGdVP/KD9J0sb4XK3azvwqAAAAoK2grAIAdDpmk0nXndNPvp7OkqT5yxJ1MLvU4FQAAAAAJMoqAEAn5eXmpBvO7S+zySRrnV2vLNiliirmVwEAAABGo6wCAHRavSJ99Jdx3SVJecVVendxPPOrAAAAAINRVgEAOrUzT+uiQdH+kqQtiXlatjnd4EQAAABA50ZZBQDo1Mwmk645u5/8vernV32+cr+SMg8ZnAoAAADovCirgFbApiKgbfNwddSNM2NkMZtUZ7PrtQVxKqusNToWAAAA0ClRVgEAICk6zFsXTeghSSooqdbbi/bIxvyqNqGsslZLfjmo5z/fobjkAqPjAAAAoIU5GB0AAIC2YnJshBLTirUlMU87kgr0/S+pmn56V6NjdVoZ+eVavjlNP+/OVk2tTZK0N61ID1wxXOEB7ganAwAAQEuhrAIA4DCTyaSrzuqr1NxS5RVX6X+rkxUd7q1ekT5GR+s0bHa7diUVaNmWdO1OKTzifE2tTa98vUsPXjFczk4WAxICAACgpbENEACA33FzcdDNMwfIwWKSzW7XawvjVFJRY3SsDq+y2qplm9N03xsb9OKXOxsVVQOj/XXHxYN1zqhukqSsggp98P1e2dmmCQAA0CGxsgoAgD/oGuKpSyf30off71VxWY3e/HaP/n7RIJlNJqOjdTi5xZVasSVdP+3MVGV1XcNxZyeLxgwI1eRhEQr2c5Mk9e3qq/0ZhxR/sEjrd2erdxcfnTEozKjoAAAAaCGUVQAAHMX4wWHam1qkjfG52p1SqO9+PqBzRkcZHatDsNvtSkgt1rLNadq+L7/RHVMDfVw0aVikxgwIlZtL4y9TzGaTrj+3v+a9s1GHymv08Y+J6hbiqS7Bnq37BgAAANCiKKsAADgKk8mkK6b10cGcMuUUVmjB2hT1CPdW325+Rkdrt2pq67RhT46WbU5Tel55o3N9u/pqcmyEBkUHyGw+9go2b3cn3Xhef/3f/G2qtdr06oI4PXjlcLk68yUNAABAR8FXdgAAHIOrs4NumRmjRz/YrFqrTc9/sUN9uvpqUHSABkX7K8DH1eiI7UJRabVWbE3X6u2ZKqusbTju6GDWyP7BmjwsUhFBHk1+vt5dfHX+2O76ak2ycooq9f7SBN1wbn+Z2KYJAADQIVBWAQDwJyKCPHTZ1F56d3GCrHV2xSUXKi65UB//KIUHuGtgD38Nig5QdLiXLGbuW/J7SRmH9OPmNG3Zm6c622+b/Xw9nTVxaLjOGBQmTzenk3rus0Z2VWJ6seKSC7UxPle9In00cWhEc0UHAACAgSirAAA4jrEDwxTk46pf9uRoR1KBikqrJUkZ+eXKyC/Xkg2pcndx0IDu/hrYw18xUf7ycHU0OLUxrHU2bU7I1Y+b05WSVdLoXHS4l6bERmpor0A5WE6t2DObTLru7H6a9+4mFZVW69Pl+xQV6qWoUK9Tel4AAAAYj7IKaA3cXR1o93p38VXvLr6y2+1Kyy3TjqQC7dyfr+TMEtkllVdZtWFPjjbsyZHZZFKPcC8N6hGggT0CFObv1uG3qJVU1Gj1tgyt2JahQ2U1DcctZpOG9w3SlNjIZi+SPN2cdNN5MXr6k62y1tn16oI4zbtquNxcOmdRCAAA0FFQVgEAcAJMJpO6BNffge6cUd1UUl6jXckF2pFUoN0pBaqsrpPNbldi+iElph/SF6uSFODtUj/nqoe/enfxkaODxei30WxSc0q1bHO6NuzJkbXO1nDc081R4weHa/yQcPl6OrfY6/eI8NZfxkXr85X7lX+oSm9/F69bZw3o8OUgAABAR0ZZBbQivncCOh4vdyeNHhCq0QNCZa2zaV9asXYk1ZdXOYUVkqT8Q1VavjVdy7emy9nRon7dfOtXXUX7y8ej5YqclmKz2bVtX76WbU7T3rTiRue6BHlocmykTusX1Gql3JkjIrUvvVjb9uVr2758/bgpTVNHdGmV1wYAAEDzo6wCAKCZOFjM6tvNT327+emSST2VXVihnfvztSOpQIlpxaqz2VVdW9dQqkhS1xBPDYr216AeAfL3b/od8YxQUVWrNTuytGJruvIPVTUcN5mkIT0DNSU2Qr0ifVp9VZPJZNLVM/rq4Xc3Kf9Qlb5YlaTocG9Fh3u3ag4AAAA0D8oqAABaSIifm0JGdNHUEV1UUWXV7gOFDeVVWWWtJOlgdqkOZpfqm3UH5OPprJgoPw2KDlC/br5ydW4b/0xnFZRr2ZZ0/bwrW9W1dQ3HXZ0ddMagUE0aGqEAH1cDE0ruLo66aWaMnvhwi+psdr26ME7zrhrRaQfdAwAAtGdt46tgAAA6ODcXBw3vE6ThfYJks9mVklWiHUn52rm/QKm5ZZKk4tJqrd2ZpbU7s+RgMal3pI8G9gjQoB4BCmrlMshmt2t3SqF+3JymuOTCRudC/Nw0OTZCo2JC5OLUdr6UiAr10iWTeurjHxNVWFKttxbt0d8uGCgze7ABAADalbbzFSYAAJ2E2Wxq2KY264xoFZZUaWdSgeLTirUjMU81VpusdXbtPlCk3QeKNH/ZPoX6uzUMaY8O95aDxdwi2apqrPo5LlvLNqcr+/DMrV/FdPfTlNhI9Y/ya7MF0MSh4dqbVqzNCbnamVSgJRsOasbIbkbHAgAAwAmgrAIAwGB+Xi4aPyRcF07to4zMYiWkFmnH/gLtSMpXYUm1JCmroEJZBalaujFVbs4Oiulev11wQLR/s2x1yy+u1PKt6VqzI0uV1daG486OFo0aEKLJwyIU6u9+yq/T0kwmk66c1kepOaXKLarU12tS1CPcW727+BodDQAAAE1EWQUAQBvi5GjRwOgADYwO0GX2XsrIK9eOpHzt2F+gpIxDskuqqLZqY3yuNsbnymSSosO964e0RwcoPNC9yQPO7Xa7EtOK9ePmdG3blye7/bdzAd4umjg0QmcMCpWbS/ua++Tm4qCbZ8bosQ+2yFpn02vf7NbDV42Ql7uT0dEAAADQBJRVAAC0USaTSRFBHooI8tCMkd1UWlGjXckF2plUoF3Jhaqstspul/anH9L+9EP63+pk+Xs518+5ig5Qny4+cnK0HPG8tdY6bdiTo2Wb05V2eF7Wr3pH+mhybKSG9AyQ2dw2t/o1RZdgT82e0lMfLN2rQ2U1euPb3frHRYPb9XsCAADoLCirAABoJzzdnDQqJlSjYkJlrbNpf/qhhlVXv86XKiip1sqtGVq5NUNODmb16+angT3qV11J0sptGVq9PUOlFbUNz+tgMev0fsGaHBuhLsGehry3ljBuUJgS04q1YXeO9hwo0rc/H9B5Y6KMjgUAAIDjoKwCWoFd9uM/CABOgIPFrD5dfdWnq68unthTOUUV2nl4ztXe1GLV2eyqsdq0fX++tu/Pl7RXZpNJtt/t9fP2cNLEIeEaNyRcXm4db4ucyWTS3DN762B2qbIKKvTN2hT1jPBWv25+RkcDAADAn6CsAgCgAwj2ddOU4W6aMjxSldVW7TlQqB37C7QzKV8lh1dR/VpURYV6aUpshGL7BLXYXQXbChen+vlVj76/WTVWm974ZrceumqEfD2djY4GAACAY6CsAlqRScxKAdDyXJ0dNKx3kIb1DpLNbteBrFLtTMpXZXWdRvQNUnS4t9ERW1V4oIcuP7O33v4uXiUVtXr9m92669LBspg7dlEHAADQXlFWAQDQgZlNJnUP81L3MC+joxhq9IBQ7U0r1tqdWUpMK9aCn1L0l3HRRscCAADAUfAjRQAA0CnMmdJLEYHukqTv1h/UzqQCgxMBAADgaCirAABAp+DsaNFNM2Pk7GSRJL357W4VllQZnAoAAAB/RFkFAAA6jVB/d10xrbckqbzKqlcXxslaZzM4FQAAAH6PsgoAAHQqp/cL0YQh4ZKkpIwS/W91ksGJAAAA8HuUVQAAoNO5ZFIPdQn2kCR9vzFN2xLzDE4EAACAX1FWAQCATsfRwaKbZ8bI1bl+ftVb38Urr7jS4FQAAACQKKsAAEAnFeTrpqvP6itJqqy26tUFcaq1Mr8KAADAaJRVQGuwGx0AAHA0w3oHaUpspCTpQHapPl+x3+BEAAAAoKwCAACd2oUTohUV6iVJWr41XRvjcwxOBAAA0LlRVgGtyWR0AADAHzlYzLppZn+5uzhIkt5bkqCcwgqDUwEAAHRelFUAAKDTC/B21TVn95MkVdXU6ZUFcaqprTM4FQAAQOdEWQUAACBpcI8ATT+tiyQpLbdMnyzbZ3AiAACAzomyCgAA4LDzz+iunhHekqQ1OzK1Pi7b4EQAAACdD2UVAADAYQ4Ws248L0Yero6SpPe/T1BGfrnBqQAAADoXyioAAIDf8fV01vXn9pNJUk2tTa8uiFN1DfOrAAAAWgtlFQAAwB/ERPnr7FHdJEmZ+eX68Ie9stvtxoYCAADoJCirAAAAjuK8MVHq08VHkvRzXLbW7swyNhAAAEAnQVkFAABwFGazSTec21/e7k6SpI9+TFRabpnBqQAAADo+yioAAIBj8PZw1g3n9pfJJNVabXplQZwqq61Gx2pVNrtd2/fn6/nPd+jR9zdrx/58oyMBAIAOzsHoAEBnwJQTAGi/+nT11cyx3fX1mmTlFFbo/aUJhwssk9HRWlRltVXrdmVp2ZZ05RZVNhx/8cudGhjtr0sn91Swr5uBCQEAQEdFWQW0oo79bQ0AdFwzRnbVvrRixaUUamN8rnpH+mjC0AijY7WI3KIKLd+SobW7MlVZ/dtdEF2cLDKZTKqstmpnUoH2HCjUmSO66OyR3eTsZDEwMQAA6GgoqwAAAI7DbDLpunP6ad67m1RUWq35y/cpKsxL3UK8jI7WLOx2uxIOFunHzenasT+/0YrgIB9XTRoWoTEDQ1Vrtel/q5P0084sWevs+m79Qf0cl61LJvVUbO/ADr/aDAAAtA7KKgAAgCbwdHPSjef119Mfb5O1zq5XF8TpoSuHy83F0ehoJ62mtk4b9uTox81pysgrb3Sub1dfTYmN1MBof5nN9SWUq7N01Vl9NW5wuD7+ca9SskpVVFqtVxfEqU8XH82Z0kvhgR5GvBUAANCBUFYBAAA0Uc8IH10wPlqfr9yvvOIqvbM4QbecH9PuVhQVllRp5bYMrd6eqbLK2objjg5mjewfosmxEYr4k9Kpe5iX7psbq7U7s/TlqiSVVdYqIbVYD72zSZOGRei8MVFyc+HLTAAAcHL4KgIAAOAEnDkiUolpxdq+P19bE/P04+Z0TR0eaXSs47Lb7UrKLNGyzWnanJAnm/23zX6+ns6aODRc4waHy8O1aSvFzCaTzhgUpmG9A7XgpxSt2Joum92uHzen6Zc92bpgfA+NGhAiczsr8gAAgPEoqwAAAE6AyWTS1TP66uF3N6mgpEpfrNyv6DAvRYd7Gx3tqKx1Nm1KyNWyzWlKySptdK5HuLcmx0ZoaK9AOVjMJ/X87i6OmjOll84YFKaPf0xUYlqxSipq9c7ieK3enqE5U3t1mNleAACgdVBWAQAAnCAPV0fdNDNGT360RXU2u15bGKeHrhrR5FVJraGkvEartmdo5bYMHSqraThuMZs0om+QJsdGKiq0+UqkyCAP3T17iH6Jz9HnK/aruKxGSZklevS9zTpjcJhmndFdnm5OzfZ6AACg46KsAgAAOAndw7x08cQe+mTZPhWUVOutRXv0twsGGr7tLTWn9PBWvFxZ62wNx73cHDV+SLjGDwmXj4dzi7y2yWTS6f1CNLhHgL79+YB+2JimOptdq7dnanNCrs4/o7vGDw5vGNgOAABwNJRVAAAAJ2nSsAglphVr89487Uwq0NJfUnXW6V1bPYfNZte2ffXzsxLTihud6xLsoSmxkRrRN0iODpZWyePi5KALx/fQmAGhmr98n+KSC1VeZdVHPyRqzfZMzZ7SS70ifVolCwAAaH8oqwAAAE6SyWTSldP7KjWnTLnFlfpqdbJ6hHu3WhFTXlWrn3ZkafmWdBWUVP0ulzS0V6CmxEaqZ4S3YXcrDPV3198vHKTt+/M1f9k+5R+qUmpumZ76eKtG9g/WhRN6tNgqLwAA0H5RVgGt4Hc3XAIAdDBuLg66aWaMHv9wi6x1Nr22ME7zrhohL/eWm8+UVVCuZZvTtS4uSzW1v231c3N20BmDwzRxaLgCvF1b7PVPhMlk0pCegerfzU9Lf0nVdxsOqtZq0/rdOdq6L1/njY7S5NiIkx7wDgAAOp4TLqsqKyvl6lr/xU9RUZEWL14ss9ms6dOny8fHp7nzAR0LIzoAoEPqGuKp2ZN76oPv96q4rEZvfrtbf79ocLPOZrLZ7YpLLtSyzWmKSylsdC7U302Th0VoVEyonJ1aZ6vfiXJytOjcMVEaFROiz1bs15bEPFXX1Onzlfu1ZkemZk/pqQmBnkbHBAAAbUCTy6qSkhL9/e9/V0lJib744guVlZXpL3/5i7KysmS32/XKK6/ok08+UWRkZEvmBQAAaJPGDQ5TYlqxNuzJ0e4DRVq0/oDOHR11ys9bVWPVul3ZWr4lXdmFFY3ODYz21+RhEeoX5Wf4YPemCvBx1S2zBmh3SqE+WZaorIIKZRdW6LnPdmj9nlydP7qbAnzaxqowAABgjCavt37hhRf0yy+/aOzYsZKkL7/8UpmZmbrrrrv0wQcfyGw264UXXmipnAAAAG2ayWTS3Gm9FervJkla+FOK9hwoPM5HHVtecaU+Xb5Pd7z8sz7+MbGhqHJ2tGjS0Ag9cf3puv3CQYrp7t9uiqrf6x/lp4evHqGLJvRoWA22fleW7nvrFy1cm6Ka2jqDEwIAAKM0eWXVihUrdNlll+lvf/ubJGnZsmXy9/fX1VdfLUmaM2eO3n333ZZJeQree+89ffnllzKZTOrSpYsee+wx+fr6Gh0LAAB0QC5O9fOrHnt/s2qsNr3xzW7Nu3pEk4eI2+12JaYV64dNadq+P7/RzMMAbxdNGhahsQND5ebi2ELvoHU5WMyadloXnd4/WF+sTNL63dmqtdq0cG2K1u3K0qWTempwzwDDBsQDAABjNHllVUFBgXr27ClJKi0t1fbt2zV69OiG876+vqqsrGz+hKdgy5Yt+vLLL/XZZ5/p22+/Vffu3fXss88aHQsAAHRgEYEeumxqb0lSSUWtXl+4W3U2259+TK21Tj/tzNS8dzfp6U+2adu+34qqPl18dOusAXrqhpE6c0SXDlNU/Z6Ph7OuO6efnr51jLoEeUiS8g9V6b9f7dLzn+9QVkG5wQkBAEBravLKquDgYKWlpUmqX1VVV1en8ePHN5zfunWrQkNDmz3gqfDx8dGDDz4od3d3SVK/fv30+eefG5wKAAB0dGMGhioxrVhrd2Vpb1qxFq5N0awzoo94XFFptVZuy9Dq7RkqrahtOO5gMev0/sGaPCxCXYI7z9DxflH+evDK4Vq9PUNfrUlWeZVVcSmFevDtjZo6PFJnj+omV2duZg0AQEfX5H/tJ0yYoPfff19lZWX67rvv5O3trYkTJyonJ0dvvvmmFi5cqJtvvrklsx7VggULdO+99x5x/JdfflF0dLSio+u/MCwrK9Mrr7yi2bNnt3ZEAADQCc2Z2ksp2SXKyCvXop8Pqke4jwZG+0uSkjNLtGxzmjYl5KrO9ttePx8PJ00YGqFxg8Pk5eZkVHRDmc0mTRgaodg+Qfp6TbJWb89Unc2uJb+kav3ubF00oYdO6xfM1kAAADqwJpdVd911lyorK/Xll18qODhY8+bNk4uLixITE/Xxxx/r3HPP1fXXX9+SWY9q5syZmjlz5p8+JicnRzfddJOGDh2qSy+9tHWCAQCATs3Z0aKbZ8bokfc2q7q2Tm8t2qO/jOuutTuzlJRZ0uix3cO8NDk2QrG9g+RgafKUhg7N081Jc6f10RmDw/TxD4lKyixRcVmN3vh2j1Zty9Ccqb0VeXjLIAAA6FhMdvvvR3ce2759+9SjR48jfopVU1Oj4uJiBQUFtUjAU5WQkKAbb7xRF1100Umv/CooKJPN1qRP0ykJDPRUXl5pi78OWt/1/14la51N00/vogvH9zA6TpvFNYDOjmugY9qwO1tvfLvniOMWs0mxfYI0OTZC0WHeBiRre451Ddjsdq2Py9YXq5JUUl4jSTKZpIlDIjTzjCi5d8A5Xui8+LcAnR3XQOdgNpvk73/sHzo1eWXVlVdeqfPPP1933nlno+NOTk5ttqjKyMjQlVdeqQceeEAzZswwOg4AAOiETu8fosT0Q1q1LUOS5OHqqPFDwjRhSIR8PZt2l8DOzmwyafSAUA3pGahv1qVo2eZ02ex2Ld+arl/ic3TB+GiNGRgqM1sDAQDoEJpcVlVUVCgiIqLFgsTHx+uCCy7Q8uXLFRIS0ujcokWL9OqrryotLU3h4eG64YYbjrv1T5Lee+89VVZW6o033tAbb7whSerRowd3BIQBWn5lHgCg7Zo9uafCA9zl6mxRbO8gOTlajI7ULrm5OOiSST01dmCoPlm2T/EHi1RWWav3liQc3hrYi1VqAAB0AE0uq6644gq9++676t+/vwYMGNCsIZKSknTDDTfIarUecW7x4sW68847dcUVV2jMmDFatmyZ7r77brm4uGjatGl/+rz33Xef7rvvvmbNCpwKk/iJLwB0Rg4WsyYNa7kf+nU24YEeuvOSwdqyN0+frtinwpJqHcgu1eMfbNGYAaG6YHy0vNw754B6AAA6gibPrLr22mu1ZcsWVVVVycXFRT4+PjKbGw8ANZlMWrZsWZNf3Gq16rPPPtOzzz4rR0dHFRcXa/Xq1Y1WVk2ZMkUxMTF6/vnnG47dfvvt2rt3r5YsWdLk1wKMdP4/v5W1zqYLJvbUFTP6GR0HAIAOo6raqi9W7NNXK/fLWmeTJLm7OGj2mX00Y3SULAysBwCg3Wnyyqrq6mrFxMQ064tv2bJFzzzzjK655hoFBwfr/vvvb3Q+LS1Nqamp+sc//tHo+JlnnqklS5YoLS1NkZGRzZrpaBiwjlNX/99PRUUNf8Z/gmsAnR3XADq7k70GpsVGaEi0nz5dtk87kgpUXmXVmwvjtPjnFM2Z3Et9uvq2QFqgZfBvATo7roHOodkGrH/44YfNEuj3oqOjtWzZMvn7++urr7464nxycrIkKSoqqtHxrl27SpJSUlJapawCAABA2xbs66bbLhykHfvzNX/5PuUWVSojr1z/N3+bRvQN0kUTesjPy8XomAAAoAmadV30nj1H3pb5zwQEBMjf3/+Y50tL69tUD4/GbZu7u7skqays7AQTAgAAoCMb1CNAj15zmv4yrrucHOu/1N0Yn6t739yg79YfaNgqCAAA2q4mr6yqqanRf/7zH/3000+qqKiQzfbbP/R1dXUqLy9XWVmZ4uPjmy3c8cZp/XFmFgAAAODoYNaMkd00sn+IPl+5Xxvjc1VTa9P/VifrQHapbp4ZI5OJm54AANBWNbntefHFF/XWW2/p0KFDcnV1VUZGhkJDQ+Xg4KDs7GzV1tY2+533PD09JUnl5eWNjv+6ourX8wAAAMAf+Xm56MbzYnTXpUMUFlC/Mn/L3jz9uDnd4GQAAODPNLmsWrp0qUaMGKEVK1bozTfflCQ9+OCD+v777/X666/LarXK0dGxWcP9OqsqNTW10fGDBw82Og8AAAAcS9+uvvrXnKHyPzyz6ouV+5WUccjgVAAA4FiaXFbl5ORo6tSpMpvNCg4Olr+/v7Zt2yZJGjdunM4//3x9/vnnzRqua9euioiI0NKlSxsd/+GHH9StWzeFhYU16+sBAACgY/JwddSNM/vLYjapzmbXawvjVFZZa3QsAABwFE0uq1xcXBqtnOrSpYsSExMbfj9w4EClpaU1bzpJt9xyixYtWqRHHnlEa9as0UMPPaQlS5botttua/bXAgAAQMcVHeatiyb2kCQVlFTrrUV7ZDvOjFQAAND6mlxW9e3bV2vWrGn4fffu3RtWVkn1K69aYlDlrFmz9PDDD2vt2rW65ZZbtGnTJj399NM666yzmv21gJbC18EAALQNk4dFaFjvQEnSzqQCLf0l9TgfAQAAWluT7wY4e/Zs/f3vf9fs2bP1xhtvaMaMGfrf//6ne+65R927d9d7772nwYMHn3SQWbNmadasWUc9d8kll+iSSy456ecGAAAAJMlkMumq6X2VmlOqvOIqfbU6WT3CvdUr0sfoaAAA4LAmr6yaPn26Hn30URUXF8vV1VWjRo3SnDlz9PXXX+vZZ5+Vl5eX/vWvf7VkVqDd4y7ZAAAYz83FQTfPHCAHi1k2e/38qpLyGqNjAQCAw5pcVknShRdeqMWLF8tisUiSHnjgAa1YsUJff/21li5dqh49erRISAAAAKA5dQ3x1OzJPSVJxWU1evPb3bLZ2LcPAEBb0OSyau7cuVq/fv0Rx8PCwtS3b1+tXbtWM2bMaNZwAAAAQEsZNzhMp/ULliTtPlCkResPGBsIAABI+pOZVZWVlSoqKmr4/caNGzVlyhR17dr1iMfabDatWbNG6enpLZMSAAAAaGYmk0lzz+ytg9mlyi6s0MKfUtQj3Fv9uvkZHQ0AgE7tT8uqmTNnqrS0VFL9P+ZPPPGEnnjiiaM+3m63a/To0S2TEgAAAGgBrs4OunlmjB77YLNqrDa98c1uzbt6hHw8nI2OBgBAp3XMssrPz0///ve/tWvXLtntdr388suaMmWKevfufcRjzWaz/Pz82AYIAACAdiciyENzpvbSu4sTVFJRq9cX7tadlw6WxXxC410BAEAzOWZZJUnjxo3TuHHjJEmZmZm65JJLNGjQoFYJBgAAALSWsQPDlJhWrHW7srU3rVgL16Zo1hnRRscCAKBTavKPi5588smjFlX79u1TUlJSs4YCAAAAWttlU3srPNBdkrTo54PamVRgcCIAADqnE1rb/MYbb+iee+6RVD9U/frrr9e5556rs88+W9dcc43Ky8tbJCQAAADQ0pwdLbp5ZoycHS2SpLcW7VFhSZXBqQAA6HyaXFa99dZbeu6555Sfny9JWrJkidasWaOpU6fqlltu0ebNm/Xyyy+3WFAAAACgpYX6u+uKafUzWssqa/Xawt2y1tkMTgUAQOfS5LLq66+/1pQpU/Tmm29KkhYvXixXV1c9/fTTuvXWWzV79mwtXbq0xYICAAAAreH0/iEaPzhMkrQ/45C+Wp1scCIAADqXJpdVaWlpOuOMMyRJtbW1Wr9+vUaMGCEXFxdJUnR0dMOqKwAAAKA9u3RyT3UJ8pAkLd2Yqm378gxOBABA59HkssrLy0tlZWWSpF9++UUVFRUN5ZUkpaamKiAgoPkTAgAAAK3M0cGim86PkYtT/fyqtxfFK7+40uBUAAB0Dk0uq4YMGaKPPvpIP/zwg5577jk5ODho6tSpqq2t1Q8//KD58+frtNNOa8msAAAAQKsJ9nXT1Wf1lSRVVFv16sI41VqZXwUAQEtrcll17733ytnZWX/7298UHx+vO+64Q4GBgdq6dav+9re/KTAwULfddltLZgUAAABaVWyfIE0eFiFJSskq1ecr9xucCACAjs+hqQ8MDQ3VN998oz179ig4OFjBwcGSpD59+ui5557ThAkT5Orq2mJBAQAAACNcNLGHkjIPKSWrVMu3pKtXpI+G9wkyOhYAAB1Wk1dWSZKDg4MGDhzYUFRJkre3t8466yyKKgAAAHRIDhazbjovRm7O9T/nfXdxvHKKKgxOBQBAx3VCZRUAAADQGQX4uOqas+vnV1XV1OnVr+NUU1tncCoAADomyioAAACgCYb0DNS0EV0kSam5ZZq/fJ/BiQAA6JgoqwAAAIAmmjWuu3qEe0uSVm/P1Prd2QYnAgCg4zlmWbVq1Srl5+e3Zhagw7LbjU4AAACag4PFrBvP6y8PV0dJ0gdL9yozv9zgVAAAdCzHLKvuvPNOrVq1quH3c+fO1fr161sjEwAAANBm+Xm56Lpz+kmSqmvr9OqCOFXXML8KAIDmcsyyym63a8uWLaqsrJQkbdy4UQUFBa0WDOiITCajEwAAgOYwoLu/zh7VVZKUkV+uj37ca3AiAAA6DodjnZg6daq+/vprLViwoOHYXXfdpbvuuuuYT2YymbRnz55mDQgAAAC0ReeNidL+9ENKSC3Wul3Z6hXpo7EDw4yOBQBAu3fMsurhhx9W//79lZiYqJqaGi1cuFDDhg1TZGRka+YDAAAA2iSL2azrz+2vee9uUkl5jT76IVHdQrwUGeRhdDQAANq1Y5ZVTk5Ouuyyyxp+v2DBAl188cU655xzWiUYAAAA0Nb5eDjrhnP66ZnPtqvWatMrC+L04BWxcnU+5pfZAADgOI45s+qPEhISGoqq/Px87dy5U/Hx8SosLGyxcAAAAEBb17ebn84bEyVJyims0PtLE2TnVsAAAJy0E/qRT1xcnB555BHt2rWr0fFBgwbpvvvu04ABA5o1HAAAANAenD2qm/alH9LulEJtjM9V7y6+mjAk3OhYAAC0S00uq/bu3avLL79cknTRRRcpOjpaNptNycnJ+vbbbzV37lx9/vnn6tmzZ4uFBQAAANois8mk687pp3nvbFRxWY3mL0tU91AvdQ3xNDoaAADtTpPLqhdeeEHu7u767LPPFB7e+KdEN998sy644AK99NJLevHFF5s9JAAAANDWebk56cbzYvR/n2yTtc6uVxbs0kNXjpCbC/OrAAA4EU2eWbV582bNnj37iKJKkkJCQnTppZfql19+adZwAAAAQHvSK9JHfxnXXZKUV1yldxfHM78KAIAT1OSyqqamRu7u7sc87+HhoaqqqmYJBXQ0dvFFKgAAncWZp3XRwGh/SdKWxDwt25xucCIAANqXJpdVffv21aJFi2S1Wo84V1tbq2+//Va9evVq1nAAAABAe2M2mXTt2f3k7+UsSfp85X4lZR4yOBUAAO1Hk8uqa6+9Vrt27dJll12m77//Xnv37tXevXu1ZMkSXXbZZdq9e7euvvrqlswKdAAmowMAAIBW4OHqqBtnxshiNqnOZtdrC+JUVllrdCwAANqFJk97nDx5sh544AE988wzuv322xuO2+12OTs76+6779a0adNaIiMAAADQ7kSHeeuiCT00f/k+FZRU6+1Fe/TXCwbKbOKHVwAA/JkTujXJnDlzNGPGDK1fv17p6emy2+2KiIjQqFGj5OPj00IRAQAAgPZpcmyEEtOKtSUxTzuSCvT9L6mafnpXo2O1Orvdrn3ph1RjrVP/bn4yUdgBAP7ECd9H18fHR9OnT2+JLAAAAECHYjKZdNVZfZSaW6q84ir9b3WyosO91SvSx+horaKmtk7rd2dr2ZZ0ZeSVS5J6RXhr9pRe6hLsaXA6AEBb1eSZVQAAAABOnJuLo26eOUAOFpNsdrteWxinkooao2O1qMKSKn25Kkl3vLxO7y/d21BUSVJi+iE9/N4mffTDXuZ4AQCOirIKAAAAaGFdQzx16aSekqTishq9+e0e2ex2g1M1L7vdrv0Zh/Tawjj989X1WrzhoMqr6u8k7uvprL+M666pwyNlNplkt0srtmbo3jc2aPX2DNlsHetzAQA4NSe8DRAAAADAiRs/JFx704q1MT5Xu1MK9d3PB3TO6CijY50ya51NmxJytWxzmlKyShud6xHurcmxERraK1AOlvqfk48dFKZPfkxU/MEilVXW6v2le7V6e6bmTO2l6DBvI94CAKCNaXJZZbPZZDazEAsAAAA4GSaTSVdM66ODOWXKKazQgrUp6hHurb7d/IyOdlJKymu0anuGVm7L0KGy37Y1WswmjegbpMmxkYoK9Tri48ID3HXnJYO1ZW+ePl2xT4Ul1TqQXarHP9iiMQNC9Zfx0fJ2d2rNtwIAaGOaXFadd955uuCCC3TFFVe0ZB4AAACgw3J1dtDNM2P02AebVWu16fVv9+jhq4bL28PZ6GhNlppTqh83p+mXPTmy1v22fc/LzVHjh4Rr/JBw+Rzn/ZhMJsX2CdKA7v76bsNBLf0lVdY6m9buytKWxFzNHNNdE4eFy8IPywGgU2pyWXXgwAG5urq2ZBYAAACgw4sM8tBlU3rp3SUJKimv0evf7NadlwyR2WwyOtox2Wx2bduXpx83pysxrbjRuS7BHpoSG6kRfYPl6HBi5ZKzk0WzzuiuMQNC9Ony/dq+P1+V1XWav3yf1uzM1JzJvdSnq28zvhMAQHvQ5LJqzJgx+uGHHzRz5kw5ObEsFzghzAwFAAC/M2ZgqBLTirUuLlsJqcVasDZFs87obnSsI5RX1eqnHVlaviVdBSVVDcdNJmlor0BNiY1UzwhvmUynVrQF+brpbxcM1M6kfH2ybJ9yiyqVkVeu/5u/TSP6BumiCT3k5+Vyqm8HANBONLms6tOnj95//32NHTtWAwYMkL+//xEzrEwmk5544olmDwl0FG3356UAAKA1mUwmXTa1t1KyS5WZX65FPx9QzwhvDejub3Q0SVJWQbmWbU7Xurgs1dTaGo67OTvojMFhmjg0XAHezb/rYmB0gPp29dMPm1L17c8HVFNr08b4XG3fn69zRnXT1OFdTnj1FgCg/THZ7U27Z26fPn2O/2Qmk+Lj4085VFtTUFDWKrfTDQz0VF5e6fEfiHbnmqdWyC7pnFHddH4b/KlpW8E1gM6OawCdXWe8BjLzy/XI+5tUU2uTh6uj5l013LAVRDa7XXHJhVq2OU1xKYWNzoX6u2lybKRG9Q+Rs5OlVfIUllTp85X7tTE+t+FYkK+rZk/uqYHRAa2SwQid8ToAfo9roHMwm03y9/c45vkmr6xKSEholkAAAAAA6oUFuOuKM/vozUV7VFZZq9e+2a1/XjpEDpbWWz1UVWPVul3ZWr4lXdmFFY3ODYz21+TYCPXv5nfKW/1OlJ+Xi248L0bjBhfpk2WJysgrV25RpV74YqcGRfvr0sk9FeTr1qqZAACto8ll1e/ZbDYVFhbKy8uL+VUAAADAKRgZE6LE9GKt3p6p/emH9NWaZF00oUeLv25ecaWWb0nXTzuzVFltbTju7GjRmAGhmhQboRA/48ugvl19Ne+q4VqxNUMLfkpWZXWddiQVaPeBQk07rYtmnN6t1VZ7AQBaxwmVVQcPHtQzzzyjtWvXqqqqSu+8844k6bnnntPdd9+t2NjYFgkJAAAAdGSXTuqp5MwSpeWWaekvqeoV4aPBPZt/q5vdbtfe1GL9uDlN2/fn6/cDQQK8XTR5WITGDAyVm4tjs7/2qbCYzQ13HPzfqiSt3ZUla51di34+qJ/jsnXxxJ6K7R3Y6qu/AAAto8nriw8cOKALL7xQGzdu1NixYxuOWywWJScn6+qrr9b27dtbIiMAAADQoTk5WnTzzBi5HF4h9PZ3e5RfXNlsz19rrdNPOzI1791N+r/527Rt329FVZ8uPvrrrAF66oaRmjqiS5srqn7P291JV8/oq/vmDlO3EE9JUmFJtV5dEKdnPt2ujPxygxMCAJpDk8uq5557Ti4uLlq8eLHmzZunX+eyjxgxQosXL1ZAQIBeeumlFgsKAAAAdGTBfm666qy+kqTyKqteXRgna53tOB/154pKq/XVmiTd8fLPendJgtJyyyRJDhazxgwM1cNXj9A/Zw/VkF6BMpvbz6qk6DBv3X9FrK6c3kcervXlWvzBIs17Z6M+Xb5PFVXW4zwDAKAta/I2wA0bNuiqq66Sv7+/ioqKGp0LDg7W7Nmz9dZbbzV7QAAAAKCzGN4nSIlDI7R8a7pSskr1+Yr9mj2l1wk/T3JmiZZtTtOmhFzV/e6u1j4eTpowNELjBofJy619z541m0w6Y1CYhvUO1II1KVqxLV11Nrt+2JSmDXtydOH4aI2MCZGZrYEA0O40uayqqamRl5fXMc87Ojqqurq6WUIBAAAAndVFE3soKfOQDmSXatmWdPWK9FFsn6Djfpy1zqYte/O0bHOakjJLGp3rHualybERiu0d1Kp3GmwN7i6OmjO1l8YOCtUnPyYqMf2QSspr9PZ38Vq1PUOXTemtroe3DAIA2ocml1V9+vTRihUrNGfOnCPOWa1WffPNN+rdu3ezhgMAAAA6G0cHs26aGaOH392kimqr3l0Sr8hgDwX7Hv3OfKUVNVq9PVMrtqaruKym4bjFbFJsnyBNjo1QdJh3a8U3TJdgT909Z6h+2ZOjz1fuV3FZjZIySvTIe5s0bnCYZo2LbtgyCABo25pcVt1www26+eabdeedd2rSpEmSpIyMDC1fvlxvv/229uzZoxdeeKGlcgLtmv34DwEAAGgQ6OOqa2b01X+/2qXK6jq9+nWc7ps7TI4OlobHpOeW6cfN9Vveaq2/zbbycHXU+CFhmjAkQr6ezkbEN4zJZNLp/UM0qEeAFv18QD9sSlOdza5V2zO1KSFXs87ornGDw9vVfC4A6IxMdru9yd9Hf/XVV3riiSdUXl4uu90uk8kku90uZ2dn/f3vf9eVV17ZglGNU1BQJput5euGwEBP5eWVtvjroPVd/dQKSdK5o7tp5tjuBqdpu7gG0NlxDaCz4xo40mcr9un7jWmSpPGDw3TZ1N7asT9fP25OU0JqcaPHRgR6aEpshE7rFywnR8tRnq3zySoo1yfL9ml3SmHDsS5BHpoztZd6RvgYF+xPcB2gs+Ma6BzMZpP8/T2Oeb7JK6skadasWZo6darWrVuntLQ02Ww2hYeHa9SoUfL19T3lsAAAAAB+85dx0dqfcUhJGSVatT1TO5IKVFT625xYk6TBPQM0JTZSvbv4yMQw8UZC/d31j4sGadu+fH26fJ/yD1UpNbdMT360VSP7h+jCCdHy8ehcq88AoD04obJKkjw8PDR16lQVFhbKbDZTUgEAAAAtxMFi1k3nxWjeu5tUVlnbUFS5Ojto7MBQTRoWoUAfV4NTtm0mk0lDewUqJspPS35J1eINB1VrtWn97mxt25enc0dHaXJsRIcbPA8A7dkJlVVJSUl68cUXtXbtWlVWVkqSPD09NWnSJN12220KCQlpkZAAAABAZ+Xn5aIbzuuvV7+Ok7eHkyYOjdDoASFycTrhnzt3ak6OFp03JkqjY0L06Yr92pqYp6qaOn2+cr9+2pmp2ZN7qX+Un9ExAQA6gbJq165dmjt3rmpra3XGGWeoS5custvtSklJ0TfffKM1a9Zo/vz56tKlS0vmBQAAADqd/t389N/bx7LNrxkE+Ljq1lkDFJdSoE9+3KfswgplFVTo2c+2a1jvQF08sYcCvFmtBgBGanJZ9cwzz8jDw0Mff/zxEYVUYmKi5s6dq6efflovv/xys4cEAAAAOjuKquYVE+WvR67x1bLN6Vq4LkXVNXXasjdPu5IKdNbpXTXttC4MqgcAgzR5Y/aOHTs0d+7co66c6tWrl+bOnav169c3azgAAAAAaCkOFrOmndZFT1x3uk7vHyxJqrHatGBtiu5/6xdt25enE7h5OgCgmTS5rPLy8lJdXd0xz7u7u8vFxaVZQgEAAABAa/H1dNb15/TXv+YMVWRQ/a3U8w9V6b//26Xnv9ih7MIKgxMCQOfS5LJqzpw5eu+997R///4jzuXk5OjDDz/URRdd1KzhAAAAAKC19Ir00YNXxuqyqb3k7lI/MSUuuVAPvPWLvli1X1U1VoMTAkDncMyZVffcc88Rx6qrqzVz5kyNHTtWUVFRMplMysjI0Jo1a+Ts7NyiQQEAAACgpVnMZk0cGqHhfYL01ZpkrdmeqTqbXUs2pOrnuGwN6Rmo6DAvdQ/zUrCfm8zMEgOAZmeyH2MTdp8+fU78yUwmxcfHn3KotqagoEw2W8vvVQ8M9FReXmmLvw5a39VPrZAknTu6m2aO7W5wmraLawCdHdcAOjuuAbRFKVkl+vjHRCVnlhxxzs3ZQd0PF1fdw7zVPcxLHq6Op/R6XAfo7LgGOgez2SR/f49jnj/myqqEhIQWCQQAAAAA7UVUqJfuvXyY1sdl66edWTqQXaKaWpskqaLaqriUQsWlFDY8PtjXtaG4ig73UkSghxwsTZ6+AgDQn5RVAAAAAADJbDJp9IBQjR4QqjqbTRl55UrOLFFS5iElZ5Yoq+C3Aew5RZXKKarU+t3ZkiRHB7O6hniqe6iXosO9FR3mJV9PZ5nYPggAx3RCZdWCBQu0bt065eXlyWazHXHeZDLp/fffb7ZwAAAAANCWWMxmdQn2VJdgT40fEi5JqqiqVXJWiZIzf/tVVlkrSaq12rQ//ZD2px+SNqVJkrw9nBQd5t0w+6pbiJecnSyGvScAaGuaXFY9//zzev311+Xo6Ch/f3+ZzSxlBQAAAAA3F0fFRPkrJspfkmS325VbXKnkjJKGFVhpuWWqOzwH91BZjbYm5mlrYp6k+pVb4YHuig7z0qDewQr0dFKIP8PbAXReTS6rvv76a40ZM0b//e9/5erq2pKZAAAAAKDdMplMCvZ1U7Cvm0bGhEiSamrrlJpT1rB1MDnzkApKqiVJNrtdabllSsst06rtmZIkV2cHdQ/1bJh/1T3MS55uToa9JwBoTU0uq8rKynTmmWdSVAEAAADACXJytKhHhLd6RHg3HCsuq25YeZWSWaKUrFJV19ZJkiqrrdp9oEi7DxQ1PD7I17V+cPvhAisyiOHtADqmJpdVY8eO1YYNG3ThhRe2ZB4AAAAA6BR8PJw1tFeghvYKlCTV2WyqrJM2786q30KYVaLM/PKGx+cWVSq3qFIbdudIkhwsZnUL8WxYedU9zEv+Xi4MbwfQ7jW5rHrggQd01VVX6Y477tDkyZPl7+9/1L8Ehw8f3qwBAQAAAKAzsJjNigr2lIejWeMH/za8PSWrVMmZh5T0h+Ht1jqb9mcc0v6MQw3P4e3u1FBcRYd5q1uop1ycuAk8gPalyX9rZWZmqrS0VN99950WL158xHm73S6TyaT4+PhmDQgAAAAAnZWbi6P6R/mpf5SfpPrvu/KKKxuKq+TMQ0rN+d3w9vIabduXr2378iVJJpMUHuBxuLzyUmyfILk6U14BaNua/LfUI488opKSEl1zzTXq1q2bHBz4Cw4AAAAAWpPJZFKQr5uCfN00sn/98PZaa50O5pQpOeOQkrNKlJRRooKSKkmS3S6l55UpPa9Ma3ZkatH6A7p/bizD2gG0aU1unPbt26dbb71V1113XUvmATocu91udAQAAAB0YI4OFvUI91aP8N+Gtx9qGN5ev/rq1+HtecVVev2b3fr7RYNkMTOcHUDb1OSyKiQkRGb+MgMAAACANs/bw1lDegVqyOHh7TabXW98u1sb43O150CRvlqdrAsn9DA4JQAcXZPbp2uvvVbvv/++9u/f35J5gA6NO7MAAADACGazSVdN76vwQHdJ0pJfUrUpIdfgVABwdE1eWZWQkCCTyaRzzz1XkZGRCggIkMViafQYk8mk999/v9lDAgAAAABOjbOTRbfOGqBH3tusymqr3vkuXmH+bgoP9DA6GgA00uSVVStXrpTFYlFISIhqa2uVlZWl9PT0Rr/S0tJaMisAAAAA4BQE+7rp+nP6ySSpurZOL321SxVVtUbHAoBGmryyasWKFS2ZAwAAAADQCgb1CNB5Y6K0YG2Kcooq9ea3e/TXCwbKzMgKAG0EE9MBAAAAoJM5e3Q3De4RIEnakVSgResOGBsIAH6nySur5s6d26THffDBBycdBgAAAADQ8swmk649u58efX+TcooqtXBtirqGeGrQ4QILAIzU5LIqPT39iGM2m01FRUWqrq5WeHi4evbs2azhAAAAAAAtw83FQbfOGqDHPtii6to6vfHtHj14RayC/dyMjgagkzvlmVV1dXVavny57r//fl1zzTXNFgwAAAAA0LLCAz10zYy+emVBnCqrrXrp61267/JhcnFq8reKANDsTnlmlcVi0dSpU3XhhRfqmWeeaY5MAAAAAIBWEtsnSNNP7yJJysgr17uLE2S32w1OBaAza7YB6926dVNCQkJzPR3QYfDPPAAAANq6v5wRrX7dfCVJmxJy9f3GNIMTAejMmqWsqqmp0TfffCN/f//meDoAAAAAQCsym0268bwY+Xu5SJK+WLVfew4UGpwKQGd1yncDrKmpUUpKikpKSvTXv/612YIBHZHJ6AAAAADAMXi4OurWWQP0xEdbVGu16bWFu/XglbEK8HY1OhqATuaU7gYo1c+s6t69u84++2zNnj272YIBAAAAAFpX1xBPXTGtt95aFK+yylq9/HWc7pkzVE6OFqOjAehETvlugAAAAACAjmNUTKhSskq1fEu6DmaX6sMf9urqs/rKZGKfAIDW0WwD1gEAAAAAHcPFE3uoZ4S3JGndrmyt3JZhcCIAnckxV1a99NJLJ/WEt95660mHAQAAAAAYz8Fi1s0zY/Twe5tUXFaj+cv2qUuQp3ocLrAAoCWdcln1x6WglFUAAAAA0P55ezjr5vMH6OmPt6rOZtfLX+/SQ1cNl4+Hs9HRAHRwxyyrli9fftwPLisr0/PPP69Vq1bJwcHhmHcMBAAAAAC0Pz3CvTVnSi998P1eHSqv0Stfx+mfs4fIwcJEGQAt55hlVXh4+J9+4OLFi/XUU08pNzdXQ4cO1bx589SrV69mDwgAAAAAMM64wWFKzirR2p1Z2p9xSJ8u36fLpvY2OhaADqzJdwP8VVpamh5++GGtW7dO3t7eeuyxx3TBBRe0RDYAAAAAgMFMJpMun9pLGXllSskq1YqtGYoK9dLoAaFGRwPQQTV57WZtba1efvllnXPOOVq3bp3OP/98LVmyhKIKOB670QEAAACAU+PoYNEt5w+Qp5ujJOn9pXt1ILvE4FQAOqomlVUbNmzQueeeq//+97+KjIzUhx9+qCeeeEK+vr4tnQ8AAAAA0Ab4ebnoxvNiZDaZZK2z6eWvdqmkosboWAA6oD8tqwoLC3XnnXfqqquuUnZ2tu644w59/fXXio2Nba18QMdiOv5DAAAAgLaqb1dfXTghWpJUUFKt1xfuVp3NZnAqAB3NMcuq+fPna/r06fruu+80ceJELV68WNddd50cHE54zBUAAAAAoIOYOjxSI/oGSZLiDxbpf6uTDU4EoKM5ZvP08MMPN/z/FStWaMWKFcd9MpPJpD179jRPMgAAAABAm2MymXTV9L7KzK9Qel6Zlv6Sqm4hnhrRN9joaAA6iGOWVTNnzpTJxJ4lAAAAAEBjzk4W3TorRo+8t1kV1Va9uzhBYQHuigj0MDoagA7gmGXVU0891Zo5AAAAAADtSJCvm64/t79e/GKHqmvr9NJXu/TgFbFyc3E0OhqAdq5JdwMEAAAAAOCPBkb7a+bYKElSblGl3vx2j2x2u8GpALR3lFUAAAAAgJM2Y1Q3DekZIEnakVSgb9amGJwIQHtHWQUAAAAAOGlmk0nXnt1PwX5ukqRv1h3Q9n35BqcC0J5RVgEAAAAATomrs4P+OmuAnJ0skqQ3F+1WTmGFwakAtFeUVQAAAACAUxYW4K5rZ/SVJFVW1+m/X+1SVY3V4FQA2iPKKqCF2cWASQAAAHQOw3oHacbIrpKkzPxyvfNdvOwMXAdwgiirgFZkMjoAAAAA0MLOH9td/aP8JEmb9+Zp6cZUgxMBaG8oqwAAAAAAzcZsNumGc/srwNtFkvTlqiTtPlBocCoA7QllFQAAAACgWXm4OurWWQPk5GCW3S69vnC38osrjY4FoJ2grAIAAAAANLsuwZ66YnofSVJZZa1e+nqXamrrDE4FoD2grAIAAAAAtIiR/UM0OTZCkpSaU6YPvt/LwHUAx0VZBQAAAABoMRdN6KFekT6SpJ/jsrVia4axgQC0eZRVAAAAAIAW42Ax66aZMfL1dJYkfbp8nxLTio0NBaBNo6wCAAAAALQob3cn3Xx+jBwsJtXZ7Hp1QZyKSquNjgWgjerwZdWLL76o6dOn66yzztJTTz0lm81mdCQAAAAA6HSiw7w1Z0ovSdKh8hq9smCXrHV8fwbgSB26rFq9erXWrVunb775Rt9++622b9+u5cuXGx0LAAAAADqlcYPDdcagUElSUkaJ5i/bZ3AiAG1Rhy6rxo0bp48//liOjo46dOiQSktL5e3tbXQsdDLc7AQAAAD4zZwpvRUV6iVJWrktQz/tzDQ4EYC2pt2XVQsWLFC/fv2O+FVaWipJcnR01JtvvqlJkyYpICBAgwcPNjYwOjeTyegEAAAAgKEcHcy65fwYebk5SpI+/D5RKVklBqcC0Ja0+7Jq5syZ2rNnzxG/PD09Gx5z3XXXaePGjQoICNC///1vA9MCAAAAAPy8XHTTzBiZTSZZ62x6+etdKqmoMToWgDai3ZdVfyYxMVF79uyRVL/C6uyzz1ZCQoLBqQAAAAAAvbv46qKJPSRJhSXVen3hbtVxQywA6uBlVXJysu6//37V1NSorq5Oixcv1vDhw42OBQAAAACQNCU2Qqf3C5YkxR8s0perkgxOBKAtaDNlVXx8vPr376/s7Owjzi1atEgzZszQwIEDNX36dC1YsKBJzzlt2jSNGzdOM2fO1MyZM+Xh4aEbb7yxmZMDAAAAAE6GyWTSFdP7KDLIQ5L0/cY0bYzPMTgVAKM5GB1AkpKSknTDDTfIarUecW7x4sW68847dcUVV2jMmDFatmyZ7r77brm4uGjatGnHfe7bbrtNt912W0vEBgAAAACcImdHi26ZNUCPvrdJ5VVWvbM4XmH+7oo4XGAB6HxMdrvdbtSLW61WffbZZ3r22Wfl6Oio4uJirV69WiEhIQ2PmTJlimJiYvT88883HLv99tu1d+9eLVmyxIjYwAmx1tl0/j+/lSRdNr2PLp7c2+BEAAAAQNuzJSFHD7+1QXa7FOrvruduP0Mebk5GxwJgAENXVm3ZskXPPPOMrrnmGgUHB+v+++9vdD4tLU2pqan6xz/+0ej4mWeeqSVLligtLU2RkZEtnrOgoEw2W8t3eoGBnsrLK23x10Hrstb9NiSyvLyGP+M/wTWAzo5rAJ0d1wDQua+DLv5uOn9sd321JllZBeV68r2N+tsFA2U2mYyOhlbUma+BzsRsNsnf/9irJw2dWRUdHa1ly5bp1ltvlcViOeJ8cnKyJCkqKqrR8a5du0qSUlJSWj4kAAAAAKBVzBjZVUN7BUqSdiYV6Ju1fM8HdEaGllUBAQHy9/c/5vnS0vo21cOjcdvm7u4uSSorK2u5cAAAAACAVmUymXTNjL4K9XeTJH2z7oC27cszOBWA1tZm7gZ4NMcbp2U2t+n4AAAAAIAT5OrsoFtnDZCLU/3um7cW7VFWQbnBqQC0pjbd9nh6ekqSyssb/8X064qqX88D7QW77QEAAIDjC/V317Vn95MkVVbX6eWv41RZfeTd4wF0TG26rPp1VlVqamqj4wcPHmx0HgAAAADQsQztFaizR9XPK87ML9e7i+OPu/sGQMfQpsuqrl27KiIiQkuXLm10/IcfflC3bt0UFhZmUDIAAAAAQEubOaa7YqL8JEmb9+bpm3UHVFNbZ3AqAC3NwegAx3PLLbfonnvukbe3t8aPH6/ly5dryZIlev75542OBgAAAABoQWazSdef21+Pvr9JecVVWrg2RYt+PqCIIA9Fh3kpOsxb3cO8FOTrKpOJoRtAR9Hmy6pZs2appqZG77zzjr744gtFRkbq6aef1llnnWV0NAAAAABAC/NwddQt5w/Qv+dvU3mVVXU2uw5ml+pgdqlWbM1oeExUqJeiw7zUPdxL3UO95ObiaHByACfLZGfT73EVFJTJZmv5T1NgoKfy8kpb/HXQuqx1Nl3/71WSpFlndNfZo7oZmqct4xpAZ8c1gM6OawDgOvgzZZW1SjhYpKTMQ0rOLNGB7FLVWm3HfHyov5u6h3qpe7i3osO8FB7oLgt3lG/zuAY6B7PZJH9/j2Oeb/MrqwAAAAAA8HB1VGyfIMX2CZJU/0Ph9LwyJWeWKCmjRMlZJcoprGh4fFZBhbIKKrQuLluS5ORoVrcQL3UPO7wCK8xbvp7OhrwXAH+OsgoAAAAA0O44WOrLp24hXpo4tP5YWWWtkjNLlHx49VVyZokqqq2SpJpamxLTipWYVtzwHL6ezg3FVfcwL3UL8ZSTo8WAdwPg9yirAAAAAAAdgoerowZG+2tgtL8kyWa3K6ewoqG4Sso8pPTcctkOT8MpKq3W5r152rw3T5JkMZsUEeih7uG/rb4KZng70OooqwAAAAAAHZLZZFKov7tC/d01ekCoJKm6tk4Hs0sbZl8lZ5aoqLRakuqHt+eU6mBOqVYeHt7u7uKgqMN3HowO81JUmJfcGd4OtCjKKqCFcQsDAAAAoO1wdrSoV6SPekX6NBwrLKmqL66ySpSccUgHsktVc3h4e3mVVXHJhYpLLmx4fIifW6PZVxFBDG8HmhNlFdCKWD0MAAAAtD1+Xi7y83JpNLw9I6+8YfZVUmaJsn83vD27sELZhRX6+dfh7Q5mdQvxbJh9FR3O8HbgVFBWAQAAAADwOw4Ws7qGeKpriKcmHB7eXl5Vq5TDxdWvQ9zLqw4Pb7falJh+SInphxqew9fTWd3Dfr37oLe6hnjKmeHtQJNQVgEAAAAAcBzuLo6K6e6vmO71w9vtdrtyiiqVnHmoocBKzy1Tne234e1b9uZpy+Hh7WaTSd1CPXXJxJ7qEeFt2PsA2gPKKgAAAAAATpDJZFKIn5tC/Nw0Kqbx8PZfV14lZ5WosKR+eLvNbldyZon+/ek2XX9Ofw3rHWhkfKBNo6wCAAAAAKAZHG14e1FptZIzDykx7ZCWb0lXrdWmV77epdlTemnSsAjjwgJtGLcrAAAAAACghfh6OmtY7yBdOrmnbrtwoJwdLbJL+vjHRH2xar9s3D4cOAJlFQAAAAAArWBAd3/dPWeIvNwcJUlLNqTqrUV7ZK2zGZwMaFsoqwAAAAAAaCXdQrx079xYBfu6SpI27M7R85/vUGW11eBkQNtBWQUAAAAAQCsK8nHVvZcPU3SYlyQp/mCRnvp4q4pKqw1OBrQNlFUAAAAAALQyTzcn3XnpEA3uESBJSsst0xMfblZGfrnByQDjUVYBLY6BiQAAAACO5Oxo0S2zYjR+SLgkqaCkWk9+uEWJacXGBgMMRlkFAAAAAIBBLGazLp/aS7PO6C5Jqqi26plPt2tzQq7ByQDjUFYBAAAAAGAgk8mks0d10zUz+spiNslaZ9OrC+L04+Y0o6MBhqCsAgAAAACgDRg9IFS3XThQzk4W2SXNX7ZPn6/cL5ud0SLoXCirAAAAAABoI2Ki/PWv2UPl7e4kSVr6S6re/HaPaq02g5MBrYeyCgAAAACANqRriKfuu3yYQvzcJEm/7MnR859vV0WV1eBkQOugrAIAAAAAoI0J8HHVvZcPU49wb0lSQmqxnvp4i4pKqw1OBrQ8yioAAAAAANogD1dH3XnJYA3pGSBJSs8r1+MfblZGXpnByYCWRVkFAAAAAEAb5eRo0S3nD9CEoeGSpMKSaj350VbtTS0yOBnQciirAAAAAABow8xmky6b0kt/GdddklRRbdWzn23XpoRcg5MBLYOyCgAAAACANs5kMmnGyG669uy+sphNstbZ9dqCOP2wKc3oaECzo6wCWpjdbnQCAAAAAB3FqJhQ3X7hILk4WWSX9OnyffpsxT7Z+MYDHQhlFQAAAAAA7Uj/KD/9a85Qebs7SZK+35imN77ZrVqrzeBkQPOgrAJakclkMjoCAAAAgA6gS7Cn7ps7TKH+bpKkjfG5ev7z7aqoqjU4GXDqKKsAAAAAAGiHArxddc9lw9QjwluSlJBarCc/3qrCkiqDkwGnhrIKAAAAAIB2ysPVUXdePFjDegVKkjLyyvX4h1uUnldmcDLg5FFWAQAAAADQjjk5WnTTzBhNGhYhSSoqrdaTH21VwsEig5MBJ4eyCgAAAACAds5sNmn25J66cEK0JKmy2qrnPt+ujfE5BicDThxlFQAAAAAAHYDJZNL007rq+nP6yWI2yVpn12sLd+v7jalGRwNOCGUVAAAAAAAdyOn9Q/T3iwbJ1dkiSfpsxX7NX7ZPNrvd4GRA01BWAQAAAADQwfTr5qd/zRkmHw8nSdKPm9P0+sLdqrXWGZwMOD7KKgAAAAAAOqDIIA/dd3msQv3dJEmbEnL17Gc7VF5Va3Ay4M9RVgEAAAAA0EH5e7vo3suHqVeEtyQpMa1YT320VYUlVQYnA46NsgpoYewKBwAAAGAkdxdH3XHJYMX2DpQkZeSX67EPNistt8zgZMDRUVYBrchkdAAAAAAAnZKjg0U3zozR5NgISVJxWY2e+niL4g8WGZwMOBJlFQAAAAAAnYDZZNKlk3rqogk9JEmV1XX/396dR1Vd538cf10EFEERcEcEsYYQNREVEZ3MHdTskP7UrOOUdbCxZhzzmJiTtnjUtDEr01zapnIcyME0tzR/LW6TuMxPWUplT80BITRFgfv7AyFuuKBy7/fCfT7O8RzO53sv98Wlr8mL9/fz1d/WHda+5NMGJwMsUVYBAAAAAOAgTCaThoW3V+wDIWrgZFJpmVkrP0vW1v1ZMpvZxAT2gbIKAAAAAAAHE96plaaN7Sa3hg0kSf/cdVxrd/ygsjIKKxiPsgoAAAAAAAcU7O+luAlh8mrSUJK0IylHyzcc1ZWSUoOTwdFRVgEAAAAA4KDatfTQ84+Gybe5uyQpKe2sXvvHYZ2/eMXgZHBklFUAAAAAADgw76aNFPdIdwX5NZMkfZ9TqPkfJSmv8JKxweCwKKsAAAAAAHBwjRu5aNrYbup5T0tJ0qm8X/TK3w8o60yRwcngiCirAAAAAACAXJydFDsqREN6+kmSCs9f1oKPDyo5I9/gZHA0lFUAAAAAAECS5GQyadzAuzVuwF2SpEuXS7Xkn0e099hpg5PBkVBWAdbGnV8BAAAA1DFDerXX5FEhcm5gUmmZWas2JmvzvkyZzfyAA+ujrAJsyWR0AAAAAAComV7BrTTtf7rJraGzJCnhf0/oX9+cNDgVHAFlFQAAAAAAuKZ7/L0U90h3eTVpKEnavDdLZ879YnAq1HeUVQAAAAAA4LratfDQn0d3lSSVmc3atDvD2ECo9yirAAAAAADADbVv1URhQS0kSXuPnWG6ClZFWQUAAAAAAG7qgcgOksqnqzYyXQUroqwCAAAAAAA35dfSQz0qp6tO60w+01WwDsoqAAAAAABQIxXTVWaz9BnTVbASyioAAAAAAFAj7Vp6qMc9LSVJ+5JP6zTTVbACyioAAAAAAFBjD0QGyKTy6aqNu9ONjoN6iLIKAAAAAADUWLsWVaerzuhU3gWDE6G+oawCrMwss9ERAAAAAKBWVZ2u2rQnw+g4qGcoqwAbMslkdAQAAAAAuGO+LTzUM5jpKlgHZRUAAAAAALhlIyM7/Lp3FdNVqEWUVQAAAAAA4Jb5NnevnK7az3QVahFlFQAAAAAAuC0W01W7M4yOg3qCsgoAAAAAANwW3+bu6tWplaTy6aof/8t0Fe4cZRUAAAAAALhtI/tcvTOg2LsKtYOyCgAAAAAA3La2zd0VfnW66t/JZ5TLdBXuEGUVAAAAAAC4IyMjA2QyXZ2u2p1udBzUcZRVAAAAAADgjrTx+XW66ruUn5R79rzBiVCXUVYBAAAAAIA7NrJPlekq9q7CHaCsAqzMbDY6AQAAAABYXxsfd/Vmugq1gLIKAAAAAADUipGRHSqnqz7bnWF0HNRRlFUAAAAAAKBWtPZurN6dWkuSDqT+pBymq3AbKKsAAAAAAECtqXpnQKarcDsoqwAAAAAAQK1p7d1YESFVpqt+YroKt4ayCgAAAAAA1KqRfQLkZDJJkj7bnW5wGtQ1lFUAAAAAAKBWtfJurIiQ8jsDHkg7q2ymq3ALKKsAAAAAAECtGxHJdBVuD2UVAAAAAACoda28Giuic/l0VVLaWWWdKTI4EeoKyioAAAAAAGAVVfeu2sidAVFDlFUAAAAAAMAqWno1Vp/O5XcGTPqe6SrUDGUVAAAAAACwmhF9/KvsXZVhbBjUCZRVgA1d/fsZAAAAABxG1emqg0xXoQYoqwAAAAAAgFVVvTPghm+5MyBujLIKAAAAAABYVctmburTpXy66tAP/1XmaaarcH2UVQAAAAAAwOpG9AlQA6eKvauYrsL1UVYBAAAAAACra9nMrXLvKqarcCOUVQAAAAAAwCaqTlexdxWuh7IKAAAAAADYRItmboq8unfV4eP/Vcbpnw1OBHtEWQUAAAAAAGxmRESVvau+zTA2DOwSZRUAAAAAALCZ5s3cFNmljaTy6ar0U0xXwRJlFQAAAAAAsKkRffyrTFexdxUsUVYBVmY2G50AAAAAAOxLc0839e1aPl115EQe01WwQFkFAAAAAABsbniEP3cGxDVRVgE2ZDI6AAAAAADYieaebup3dbrqPyfydPJHpqtQjrIKAAAAAAAYYnjVOwPuZroK5SirAAAAAACAIXw8G6nfvW0llU9XpWXmG5wI9oCyCgAAAAAAGGZElb2r1m5PMzgN7AFlFQAAAAAAMIx300b6/dXpqqTUn3Qit9DgRDAaZRUAAAAAADDU8Ah/OTe4emdA9q5yeJRVAAAAAADAUN5Nf9276ujJfB1nusqhUVYBAAAAAADDDe/tL+cG5TXFZ98yXeXIKKsAAAAAAIDhvJs20tDe/pKko+lMVzkyyioAAAAAAGAXxgy8+9e9q5iucliUVYDVmY0OAAAAAAB1go+nm+6711eSdCw9X8dzmK5yRJRVgC2ZTEYnAAAAAAC7Fh3x695VG749aXAaGIGyCgAAAAAA2A2vJg11X7fyOwMeyzinH3IKjA0Em6OsAgAAAAAAdiW6d9XpKvaucjSUVQAAAAAAwK54NWmo/lenq5Izzun77AJjA8GmKKsAAAAAAIDdiY7wl4sz01WOiLIKAAAAAADYnWYev+5dlZLJdJUjoawCAAAAAAB2Kbo301WOiLIKAAAAAADYpWYeDdW/m6+k8umqtKxzBieCLVBWAQAAAAAAuxXduz3TVQ6GsgoAAAAAANgtT4+Guj+0fLoqNauA6SoHQFkFWJnZ6AAAAAAAUMdFhbeXK9NVDoOyCrAhk9EBAAAAAKAO8vRoqP5VpqtSM5muqs8oqwAAAAAAgN2L6u3PdJWDoKwCAAAAAAB2z9PdVfd3L5+uSstmuqo+c5iy6sMPP1RMTIzRMQAAAAAAwG0aFv7rdFXit+kym9kluD5yiLIqOTlZq1atMjoGAAAAAAC4A57urhrQvZ0k6fvsAqVmFRgbCFZR78uqCxcu6IUXXtC0adOMjgIAAAAAAO7QsPD2cnW5unfVNyeZrqqH6nxZlZiYqE6dOlX7U1RUJEmaO3euHn/8cbVt29bgpAAAAAAA4E41rTpdlVPI3lX1kLPRAe7Ugw8+qAcffPCax9avXy8XFxdFR0dr//79tg0GAAAAAACsYliv9vryYI4uXylT4rfpusffSyaTyehYqCV1frLqRjZu3KgjR45o1KhRmj17tk6cOKE//OEPRscCAAAAAAB3oKm7qwZena76IadQKUxX1St1frLqRt57773Kj/fv36+FCxfq/fffNy4QAAAAAACoFUPD2+vLg7kqvlKqxG/TFcx0Vb1hN5NVKSkpCgkJ0enTp6sd27Rpk4YPH66uXbsqKipKiYmJtg8I3Cb2+gMAAACA2te0sasGhPlKko7nFCqZ6ap6wy7KqhMnTig2NlYlJSXVjm3evFnTp09X3759tWzZMvXq1UvPPfectm7dekuvER4ervXr19dWZOD2UPIDAAAAQK0Z1qu9Gro0kCRt+CadOwPWE4ZeBlhSUqJ169bptddek4uLyzUfs2TJEkVFRSkuLk6S1K9fPxUWFmrp0qUaNmyYTXL6+HjY5HUkqUWLJjZ7LdhGo18uV37s4dGQ7/FN8P7A0XEOwNFxDgCcB8CtnAMtJI3sF6iEL3/Q8dxC5Z67pNCgltYLB5swtKxKSkrS4sWLNWnSJLVq1UqzZ8+2OJ6dna2srCxNmzbNYn3o0KHasmWLsrOz5efnZ/WceXnnVVZm/Xa2RYsmOnu2yOqvA9s6f/HKrx+fL+Z7fAOcA3B0nANwdJwDAOcBcDvnQL/OrbTx25MqvlyqDz4/Jl+vRuxdZeecnEw3HAwy9DLAjh07aseOHXr66afVoEGDasdPnjwpSerQoYPFur+/vyQpPT3d+iEBAAAAAIDdatLYVYPCyu8MeCL3Zx3LyDc4Ee6UoWVV8+bN5ePjc93jRUXlbaqHh2Xb5u7uLkk6f/689cIBAAAAAIA6YWiv9mroyt5V9YVdbLB+PTf7j8vJya7jAwAAAAAAG/Bwc/l1uurHn3Usnemqusyu254mTco3Vbtw4YLFesVEVcVxAAAAAADg2Ib2aq9GV6erEr9luqous+uyqmKvqqysLIv1zMxMi+MAAAAAAMCxebi5aFCP8umqkz/+rKNMV9VZdl1W+fv7q127dtq6davF+vbt2xUQEKC2bdsalAwAAAAAANibIT2rTFexd1Wd5Wx0gJuZMmWK4uLi5Onpqf79+2vnzp3asmWLlixZYnQ0AAAAAABgR8qnq/y0aU+G0k/9rP87ma+uHa9/YzfYJ7svq2JiYnT58mW9++67io+Pl5+fnxYuXKjo6GijowEAAAAAADszpKefdiZl62JxqTZ8e1JdAr1lMpmMjoVbYDdlVUxMjGJiYq55bNy4cRo3bpyNEwG1j78eAQAAAMC6yu8M6KeNezKUfqpI/3cyT107Njc6Fm6BXe9ZBQAAAAAAcKuG9PKTW0P2rqqrKKsAAAAAAEC94t7IRYN7+EmSMk4X6T8n8gxOhFtBWQUAAAAAAOqdwT395NawfPejDd8yXVWXUFYBAAAAAIB6p3y6qp2k8umqI0xX1RmUVQAAAAAAoF4awnRVnURZBQAAAAAA6qXGjVw0pGf53lWZp4t05DjTVXUBZRUAAAAAAKi3Bvdox3RVHUNZBQAAAAAA6i2L6aozRfox7xeDE+FmKKsAAAAAAEC95t+6SeXHl6+UGpgENUFZBVgZI6YAAAAAANQcZRVgQyaTyegIAAAAAADYNcoqAAAAAAAA2A3KKgAAAAAAANgNyioAAAAAAADYDcoqAAAAAAAA2A3KKgAAAAAAANgNyioAAAAAAADYDcoqAAAAAAAA2A3KKgAAAAAAANgNyioAAAAAAADYDcoqwMrMRgcAAAAAAAdnMjoAbgllFQAAAAAAAOwGZRUAAAAAAADsBmUVAAAAAAAA7AZlFQAAAAAAAOwGZRUAAAAAAADsBmUVAAAAAAAA7AZlFQAAAAAAAOwGZRUAAAAAAADsBmUVAAAAAAAA7AZlFQAAAAAAAOyGs9EB6gInJ1O9fC3YhnMDJ7X0cpMkubu58D2+Cd4fODrOATg6zgGA8wCwxjnQqKFz5c9lLs4NOM8MdrP332Q2m802ygIAAAAAAADcEJcBAgAAAAAAwG5QVgEAAAAAAMBuUFYBAAAAAADAblBWAQAAAAAAwG5QVgEAAAAAAMBuUFYBAAAAAADAblBWAQAAAAAAwG5QVgEAAAAAAMBuUFYBAAAAAADAblBW2bFTp04pLCxMb7/9ttFRAJs5e/asZs+erfvvv1+hoaGKiYnRli1bjI4FWNWmTZs0fPhwde3aVVFRUUpMTDQ6EmAzZWVlWrt2rUaOHKnQ0FANGjRI8+fP1/nz542OBhji6aef1uDBg42OAdjcd999p/Hjx+vee+9V37599fLLL+vChQtGx4JBnI0OgGszm82aNWsW/1CDQ7l8+bKeeOIJFRUV6U9/+pNatmypbdu2aerUqSotLdWIESOMjgjUus2bN2v69OmaOHGi+vbtqx07dui5555To0aNNGzYMKPjAVa3evVqvf7665o0aZIiIiKUnp6uN954Q8ePH9eaNWuMjgfY1IYNG/TFF1+offv2RkcBbOrw4cN67LHHNGDAAC1fvlyZmZn629/+pvz8fC1ZssToeDAAZZWd+uSTT3Ty5EmjYwA29fXXXys1NVXx8fHq2rWrJCkyMlI//vijVq1aRVmFemnJkiWKiopSXFycJKlfv34qLCzU0qVLKatQ75nNZq1evVpjx47Vs88+K0nq06ePvLy89Je//EUpKSkKDg42OCVgG2fOnNG8efPUunVro6MANrd48WJ169ZNS5culclkUp8+fVRWVqb33ntPFy9elJubm9ERYWNcBmiHsrOztXjxYr388stGRwFsyt3dXWPHjlWXLl0s1gMDA5WVlWVQKsB6srOzlZWVpSFDhlisDx06VCdPnlR2drZByQDbuHDhgh544IFqv4wIDAyUJP7uh0OZPXu2IiMjFRERYXQUwKby8/N14MABjR8/XiaTqXJ9woQJ2rFjB0WVg6KssjNlZWWaOXOmoqKi9Pvf/97oOIBNRURE6KWXXrL4n9SVK1f01Vdf6e677zYwGWAdFRO0HTp0sFj39/eXJKWnp9s8E2BLHh4emj17tsLCwizWd+zYIUm66667jIgF2Fx8fLyOHTumv/71r0ZHAWzu+++/l9lslqenp6ZOnapu3bopLCxMc+bM0aVLl4yOB4NwGaCNlJSUKD4+/rrHW7ZsqYEDB+qDDz5QTk6OVqxYYcN0gPXV9Bz4rUWLFikjI0PLli2zZjzAEEVFRZLKf2Cvyt3dXZLYtxAO6ciRI1q5cqUGDRqkjh07Gh0HsLrc3FzNnz9f8+fPl7e3t9FxAJvLz8+XJM2cOVODBw/W8uXLlZaWptdff13FxcVasGCBwQlhBMoqGykuLtbcuXOve7xXr14KCAjQ66+/rjfeeENNmjSxXTjABmpyDlQtq8xmsxYtWqQPPvhAkyZN0qBBg2yQErAts9l8w+NOTgxAw7EkJSVp8uTJateunV555RWj4wBWV3FTpfvuu09Dhw41Og5giCtXrkiSunfvrjlz5kgqv+LCbDZr4cKFmjJlivz8/IyMCANQVtmIu7u70tLSrnu8tLRU48eP17BhwxQZGamSkpLKY2VlZSopKZGzM98u1F03Owequnz5smbOnKnPP/9ckyZN0owZM6ycDjBGxS8mfntb5oqJKn5xAUeyefNmzZw5UwEBAVq9erW8vLyMjgRY3ccff6y0tDRt3Lix8t//Fb/IKCkpUYMGDSy2RwDqo4qJ8t9ug9O3b18tWLBAaWlplFUOiPbDTpw6dUpHjhzRkSNHlJiYaHHszTff1JtvvlnjH/SBuuz8+fOKjY3VwYMHNWvWLE2cONHoSIDVVOxVlZWVpaCgoMr1zMxMi+NAfffee+9p4cKF6tWrl5YtW0ZRC4exbds2nTt3Tn379q12LCQkRPPnz1dMTIwByQDbCQgIkFT+C+uqKiauKGwdE2WVnWjZsqUSEhKqrY8ePVrjx4/XQw89ZEAqwLZKS0v11FNP6ciRI1qyZImGDRtmdCTAqvz9/dWuXTtt3bpVgwcPrlzfvn27AgIC1LZtWwPTAbYRHx+vBQsWKDo6WgsXLpSrq6vRkQCbefHFF6tN1y5btkwpKSl666231K5dO4OSAbbTsWNH+fr6avPmzXr44Ycr13ft2iVnZ2eFhoYamA5GoayyE66ururSpcs1j7Vs2fK6x4D65B//+If+/e9/a+zYsWrdurUOHz5cecxkMunee+81LhxgJVOmTFFcXJw8PT3Vv39/7dy5U1u2bNGSJUuMjgZYXV5enubNmydfX19NmDBBycnJFsfbt2/PhtOo1wIDA6utNWvW7IY/GwD1jclk0vTp0zVt2jRNnz5dMTExOnr0qJYvX65HHnmE/w84KMoqAHZj27ZtkqR169Zp3bp1FscaNGhQ7YcYoD6IiYnR5cuX9e677yo+Pl5+fn5auHChoqOjjY4GWN0333yjixcvKjc3VxMmTKh2/NVXX9WoUaMMSAYAsKXo6Gi5urpq2bJlio2NlY+Pj6ZMmaLY2Fijo8EgJvPNbkUEAAAAAAAA2Aj3xAYAAAAAAIDdoKwCAAAAAACA3aCsAgAAAAAAgN2grAIAAAAAAIDdoKwCAAAAAACA3aCsAgAAAAAAgN2grAIAAAAAAIDdoKwCAAAAAACA3aCsAgAAdcr+/fsVFBSk9evXGx3ljp05c0bh4eHKzs42OorVrFu3TgMHDrzu8ZkzZyooKEg5OTm1+rrPP/+85s+fX6ufEwAA2AZlFQAAgEHmzZun4cOHy8/Pr3KtoKBAQUFBeuKJJwxMVnt2796tPn362Px1p0yZonXr1ik1NdXmrw0AAO4MZRUAAIABvvvuO+3cuVNPPvmkxXpycrIkKSQkxIhYtaqsrEz79+9XRESEzV+7bdu2Gj58ONNVAADUQZRVAAAABnj//fcVFhamNm3aWKwfO3ZMktSpUycjYtWq5ORkFRYWGlJWSdKYMWO0b98+pqsAAKhjKKsAAEC9kJ+frxdffFH33XefOnfurPvuu08vvviizp07V+2xOTk5euaZZ9S9e3d1795dTz31lLKzszVgwAA9+uijVs966tQp7dq1S4MGDap2rGKyqj6UVXv27FFwcLC8vLwMef1u3bqpdevW+vjjjw15fQAAcHucjQ4AAABwp4qKijR+/HhlZmbqoYceUqdOnZSSkqK1a9dq3759io+Pl4eHhyTp3LlzmjBhgvLy8jRu3DgFBgYqKSlJEydO1C+//GKTvN98841KS0vVv3//aseSk5Pl6elpsY9VXbVnzx7Dpqoq9OzZU19//bWhGQAAwK2hrAIAAHXe6tWrlZGRoRdeeEETJkyoXA8ODtZLL72k1atXa+rUqZKkVatW6fTp01q0aJEeeOABSdLDDz+sV199VWvWrLFJ3qSkJDVu3LhaIXX+/HllZmYqPDzcJjmsqbi4WAcPHjR8o/jf/e532rhxo7Kzs+tFAQgAgCPgMkAAAFDnffHFF/L29tbYsWMt1seOHStvb2/t2LGjcm3Xrl1q0aKFRowYYfHYSZMm2SSrJGVnZ8vX11cmk8liPSUlRWazuV5cApiUlCSz2awePXrU6uc9e/asVq1apbi4OC1evFhHjx694eMrCqqcnJxazQEAAKyHsgoAANR5OTk56tChg5ydLYfGnZ2dFRAQoOzsbIvH+vv7y8nJ8p9BPj4+atq0qcXa5s2bNX78eIWGhmrAgAHVXrekpESvvPKKevXqpR49emjWrFkqLi6+ad6CgoLKyxKrqthc/UZ3Ajxw4IBCQ0Or/encubOCg4MtHjt37lwFBQXp0KFD1T7Po48+qqCgIH311VfVvuagoCDFxsZWrqWnp+uPf/yjevfurdDQUA0ePPimd9nbvXu3QkND1ahRoxs+7lZs27ZNb7/9tvr06aM5c+Zo/Pjx2r17t1577TWZzeZrPqfq5Z8AAKBuoKwCAAC4Dk9PTz3yyCOVlxD+1ooVK7R//35t3LhR27dv14kTJ7Ro0aKbfl4nJyeVlZVVW6/JnQB79OihQ4cOWfzZunWrmjVrpj//+c+Vj7t06ZI2bdqkZs2aKT4+/pqfKzAwUJ9++qnFWkJCggIDAy3WYmNj1aFDB+3cuVNJSUlatWqVgoKCbvg17t27V3369LnhY27F999/r9zcXM2ZM0chISFq1KiRfH19FRsbq4EDB2rt2rXXfF7F+9ygQYNaywIAAKyLsgoAANR5fn5+Sk9PV0lJicV6SUmJMjIyLPYq8vX1VWZmZrWyKC8vTz///LPFWmRkpIYPHy5fX99rvm5CQoImT56sVq1aydvbW08//bTWr1+v0tLSG+b18fFRQUFBtfXk5GQ1btxYHTp0uOHzq7p8+bKeeeYZhYWFafLkyZXrW7dulZOTk+Li4rRlyxZduHCh2nOjoqK0b98+5efnS5Jyc3OVkpJicZfC/Px8ZWZmaty4cXJ3d5eTk5MCAgIUExNz3Uznzp1TSkpKrZZV27dv12OPPXbNY926ddO5c+eqff8lVb7PPj4+tZYFAABYF2UVAACo8wYNGqT8/PxqE0T//Oc/lZ+fb1G+3H///Tp79qw2bdpk8dhb3Vz9559/1qlTp3TPPfdUroWEhOjChQvKzc294XPbtm2rn376yaLUunjxotLT0xUcHFxtL6sbmTNnjoqLi7VgwQKL9fj4eEVHRys6OlouLi7avHlztee6u7tr0KBBSkxMlFRevo0YMUKurq6Vj/H29lbHjh01a9Ysff7558rKyrpppr1798rDw0OdO3eu8ddxM25ubpXvy6FDhxQeHq6333678njnzp2VkZFR7XlnzpyRVP6eAwCAuoG7AQIAgDrviSee0NatW/XSSy8pOTlZwcHBSklJUUJCgjp06GBxR7onn3xSmzZt0qxZs/Sf//xHgYGBSkpK0qFDh+Tl5VXj16yYVKq6z1WTJk0sjl1P7969tX79ev3www+VZVdqaqpKS0tVXFyslStXVntO48aN9cgjj1isffjhh9q1a5cSEhLk5uZWuZ6enq4DBw5oxowZcnV1VXR0tBISEjRmzJhqn3f06NGaPXu2Jk6cqH/961965513tH37dovH/P3vf9eaNWu0YsUKnThxQm3atNGzzz6r6Ojoa359e/fuVXh4eLV9wW5kyZIlcnd3r7YeFRWliIgIi7XU1FQVFBTo4MGDlWvu7u7XfN8PHz4sf39/yioAAOoQyioAAFDnNWnSRGvXrtUbb7yhL7/8UuvXr5ePj4/GjRunZ555xmIzc29vb33yySdauHChPv30U5lMJoWHh+uDDz7Q6NGja7wheEWxUlRUpBYtWlR+XPXY9fTr109OTk46cOBAZVmVnJwsSTp69Og173DXs2dPi7Jq3759Wrx4sVatWqV27dpZPDY+Pl6BgYG69957JUkxMTEaM2aMfvjhB919990Wj+3evbvMZrPefPNNNW/eXEFBQdXKKh8fH82YMUMzZszQ+fPntW7dOk2fPl1BQUHq2LFjtax79uzR448/fsP34Ld+O+lWITAwUBEREbp06VLl2pgxY9SiRQuFhoZWrqWlpWn48OEWzy0rK9Phw4evW6oBAAD7RFkFAADqlPDwcKWlpVVb9/b21ty5czV37tybfg4/Pz+99dZbFmvnzp1TQUGB2rRpU6McTZs2VZs2bZSamlq5IXlycrLc3d2vu8dV1awDBgzQ559/XllATZgwQRMmTKjRa+fk5Gjq1KmaMWOGwsPDLY5duXJFGzZsUFFRkSIjIy2OJSQkKC4urtrnGz16tBYtWlSj987Dw0OTJk3SypUrdfz48WuWVTt37qzR1yFJCxYsqHYJ47X4+vrq4MGD6t69u5ydnS0u7SwqKlJOTo6aNWtm8Zy9e/cqLy9Po0ePrnEeAABgPMoqAADgcC5dulRtgqri0ruqBU9paalKSkp05coVmc1mFRcXy2QyVe7pNHr0aL3zzjsKCwuTi4uL3nrrLcXExNToznOPP/64Hn74YWVlZal9+/Y1zn7x4kVNmTJFAwYMqHZZoCTt2rVLhYWFSkxMlKenZ+X6Z599plWrVunZZ5+12JNKksaOHavg4GCLSaUKhYWFWrNmjUaOHKmAgACZzWatX79eFy9eVEhISI1z36lRo0Zp3rx5unjxosX3KDs7W0uXLr1mCZeYmKjIyEiLfcUAAID9o6wCAAAO58knn5Svr686deqksrIy7du3T7t27VJoaKjFxM6GDRssSpCuXbvK19dXX375pSRp8uTJKigo0IgRI1RWVqahQ4dq+vTpNcoQFham+++/XytXrtQrr7xS4+zbtm1TamqqMjIytGXLlmrHu3TpohEjRuiuu+6yWB83bpxWrFihHTt2VLsszsPD47p37nNxcdHZs2f11FNPKS8vT66urrrrrru0fPnyapcfWpPJZNKsWbP00UcfKT4+Xk5OTiorK1OLFi30/PPPV9tvLDs7W9u2bdNHH31ks4wAAKB2mMxms9noEAAAALb07rvvKjExUbm5uSouLlarVq00ZMgQTZkyxWJ/K2s7deqURo0apYSEhFuarsLNxcXFycPDQ88//7zRUQAAwC2irAIAAAAAAIDdqPn9hAEAAAAAAAAro6wCAAAAAACA3aCsAgAAAAAAgN2grAIAAAAAAIDdoKwCAAAAAACA3aCsAgAAAAAAgN2grAIAAAAAAIDdoKwCAAAAAACA3fh/8kriZejj0vMAAAAASUVORK5CYII=\n",
       "text/plain": [
        "<Figure size 1440x720 with 1 Axes>"
       ]
@@ -690,11 +685,25 @@
     " \n",
     "Remember you can play with the binwidth too. If you want a very accurate distribution you need a narrow binwidth, but then you'll also need high resolution (lots of stars) so lots of CPU time, hence cost, CO<sub>2</sub>, etc."
    ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "ba032bd8-b4a2-4558-9fd9-8e1e03d7d162",
+   "metadata": {},
+   "source": [
+    "Things to try:\n",
+    "* Change the resolution to make the distributions smoother: what about error bars, how would you do that?\n",
+    "* Different initial distributions: the Kroupa distribution isn't the only one out there\n",
+    "* Change the metallicity and mass ranges\n",
+    "* What about a non-constant star formation rate? This is more of a challenge!\n",
+    "* What about evolved stars? Here we consider only the *zero-age* main sequnece. What about other main-sequence stars? What about stars in later phases of stellar evolution?\n",
+    "* Binary stars! (see notebook_luminosity_function_binaries.ipynb)"
+   ]
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -708,7 +717,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebook_population.ipynb b/examples/notebook_population.ipynb
index f6f27ee4329b90d22651068ea0aca8d8756c5eb9..a24638c0bd3a15a57bbf611fccb71b2100c75945 100644
--- a/examples/notebook_population.ipynb
+++ b/examples/notebook_population.ipynb
@@ -7,7 +7,7 @@
     "tags": []
    },
    "source": [
-    "# Running populations with binarycpython\n",
+    "# Tutorial: Running populations with binary_c-python\n",
     "This notebook will show you how to evolve a population of stars\n",
     "\n",
     "Much of the code in the binarycpython package is written to evolve a population of stars through the Population object, rather than running a single system. Let's go through the functionality of this object step by step and set up some example populations. \n",
@@ -1109,7 +1109,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python 3",
+   "display_name": "Python 3 (ipykernel)",
    "language": "python",
    "name": "python3"
   },
@@ -1123,7 +1123,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.6.4"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/examples/notebook_solar_system.ipynb b/examples/notebook_solar_system.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..67556a6556f73188f9c888b0538a3a4aa40be24e
--- /dev/null
+++ b/examples/notebook_solar_system.ipynb
@@ -0,0 +1,326 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "ddc06da3-fc68-4c6f-8067-14ea862b964d",
+   "metadata": {},
+   "source": [
+    "## Solar system using the API functionality\n",
+    "We use the API interface to construct a model of the Solar system."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "56886792-d379-4eac-b0d4-54508edb39c7",
+   "metadata": {},
+   "source": [
+    "First we must construct the argument string that we pass to binary_c"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "ec48125c-6bf5-48f4-9357-8261800b5d8b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from binarycpython.utils.functions import temp_dir\n",
+    "from binarycpython import _binary_c_bindings\n",
+    "\n",
+    "TMP_DIR = temp_dir(\"notebooks\", \"notebook_solar_system\")\n",
+    "M_1 = 1.0  # Msun\n",
+    "metallicity = 0.02\n",
+    "max_evolution_time = 15000  # Myr. You need to include this argument.\n",
+    "api_log_filename_prefix = TMP_DIR,\n",
+    "orbiting_objects = \"\"\"\\\n",
+    "orbiting_object name=Mercury,M=1MMercury,orbital_separation=1AMercury,orbits=star1,orbital_eccentricity=0.206 \\\n",
+    "orbiting_object name=Venus,M=1MVenus,orbital_separation=1AVenus,orbits=star1,orbital_eccentricity=0.007 \\\n",
+    "orbiting_object name=Earth,M=1MEarth,orbital_separation=1AEarth,orbits=star1,orbital_eccentricity=0.017 \\\n",
+    "orbiting_object name=Mars,M=1MMars,orbital_separation=1AMars,orbits=star1,orbital_eccentricity=0.093 \\\n",
+    "orbiting_object name=Jupiter,M=1MJupiter,orbital_separation=1AJupiter,orbits=star1,orbital_eccentricity=0.048 \\\n",
+    "orbiting_object name=Saturn,M=1MSaturn,orbital_separation=1ASaturn,orbits=star1,orbital_eccentricity=0.056 \\\n",
+    "orbiting_object name=Uranus,M=1MUranus,orbital_separation=1AUranus,orbits=star1,orbital_eccentricity=0.047 \\\n",
+    "orbiting_object name=Neptune,M=1MNeptune,orbital_separation=1ANeptune,orbits=star1,orbital_eccentricity=0.009 \\\n",
+    "orbiting_object name=Pluto,M=1MPluto,orbital_separation=1APluto,orbital_eccentricity=0.2444,orbits=star1,orbital_eccentricity=0.244 \\\n",
+    "orbiting_objects_log 1\n",
+    "\"\"\"\n",
+    "# Here we set up the argument string that is passed to the bindings\n",
+    "\n",
+    "argstring = \"\"\"\n",
+    "binary_c  M_1 {M_1} metallicity {metallicity} max_evolution_time {max_evolution_time} api_log_filename_prefix {api_log_filename_prefix} {orbiting_objects} \n",
+    "\"\"\".format(\n",
+    "    M_1=M_1,\n",
+    "    metallicity=metallicity,\n",
+    "    max_evolution_time=max_evolution_time,\n",
+    "    api_log_filename_prefix=TMP_DIR,\n",
+    "    orbiting_objects=orbiting_objects\n",
+    ").strip()\n",
+    "\n",
+    "\n",
+    "output = _binary_c_bindings.run_system(argstring)\n",
+    "#print(output)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "55c8ea24-0fc0-452c-8121-1e7667433479",
+   "metadata": {},
+   "source": [
+    "There is a lot of data here if you uncomment the print statement! \n",
+    "\n",
+    "Let's split it into a dict of lists of data, one list for each planet, and let's select only objects that are still orbiting their central star."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "323aad96-408d-404a-a56f-da98d51844dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "ename": "NameError",
+     "evalue": "name 'pop' is not defined",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
+      "\u001b[0;32m/tmp/ipykernel_216542/1241251901.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m     14\u001b[0m         \u001b[0mx\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mline\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msplit\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     15\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;34m'CS1'\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m             \u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     17\u001b[0m             \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# remove first element of the list \"Object\" - this is superfluous\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     18\u001b[0m             \u001b[0mx\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mpop\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# remove second element of the list \"index\" - this is superfluous\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
+      "\u001b[0;31mNameError\u001b[0m: name 'pop' is not defined"
+     ]
+    }
+   ],
+   "source": [
+    "import re\n",
+    "import pandas as pd\n",
+    "import math\n",
+    "#pd.set_option(\"display.max_rows\", None, \"display.max_columns\", None)\n",
+    "data = {}\n",
+    "for line in output.splitlines():\n",
+    "    #print (line)\n",
+    "    match = re.search('Object (\\d+) (\\S+)',line)\n",
+    "    if match:\n",
+    "        number = match.group(1)\n",
+    "        name = match.group(2)\n",
+    "        if not name in data:\n",
+    "            data[name] = []\n",
+    "        x = line.split()\n",
+    "        if x[4] == 'CS1':\n",
+    "            x.pop(0) # remove first element of the list \"Object\" - this is superfluous\n",
+    "            x.pop(0) # remove second element of the list \"index\" - this is superfluous\n",
+    "            x.pop(0) # remove third element of the list \"name\" - this is superfluous (it's the dict key)\n",
+    "            x.pop(1) # remove (originally) fourth element \"CS1\" - this is superfluous (we select this already) \n",
+    "            data[name].append(x)            "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b2b99ae0-2e5f-49b1-bb27-1b65ef926e72",
+   "metadata": {},
+   "source": [
+    "Now convert this data to Pandas dataframes"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "5be09aa5-02cf-4db5-97eb-a4aefbddfac6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "dataframes = {}\n",
+    "for planet in data:\n",
+    "    dataframes[planet] = pd.DataFrame(data[planet], \n",
+    "                                      dtype=float, # required! argh!\n",
+    "                                      columns=['time',\n",
+    "                                               'mass',\n",
+    "                                               'angular momentum',\n",
+    "                                               'separation',\n",
+    "                                               'period',\n",
+    "                                               'eccentricity',\n",
+    "                                               'temperature',\n",
+    "                                               'angular frequency',\n",
+    "                                               'spin of central object',\n",
+    "                                               'in disc'],\n",
+    "                                     )\n",
+    "    #print (dataframes['Earth'])"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7a15227d-b69f-4668-8ad8-3e9bfbaa0ee9",
+   "metadata": {},
+   "source": [
+    "We now make a plot of the separation (distance from the object to the Sun) as a function of time."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "ff18274d-0ed7-42cc-8830-b2261a893c6f",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 12,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "x = 'time'\n",
+    "y = 'separation'\n",
+    "for planet in dataframes:\n",
+    "    #print (dataframes[planet])\n",
+    "    df = dataframes[planet]\n",
+    "    p = sns.lineplot(data=df,\n",
+    "                     sort=False,\n",
+    "                     x=x,\n",
+    "                     y=y,\n",
+    "                     estimator=None,\n",
+    "                     ci=None,\n",
+    "                     legend='full'\n",
+    "                    )\n",
+    "    xx = df.head(1).loc[0,x]\n",
+    "    yy = df.head(1).loc[0,y]\n",
+    "    p.text(xx,yy,planet)\n",
+    "    \n",
+    "p.set_xlabel(\"time/Myr\")\n",
+    "p.set_ylabel(\"separation/au\")\n",
+    "#p.set(xlim=(0,5)) # might be necessary?\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4ab65543-b864-41d9-98e6-10a5ef051a22",
+   "metadata": {},
+   "source": [
+    "The inner objects are swallowed by the Sun when it becomes a red giant. Earth survives, although mass loss from the red-giant Sun and tides mess with its orbit somewhat. Jupiter is pushed out beyond the orbits of Saturn and Uranus, and this simple model assumes they are ejected in the interaction because Jupiter is (far) more massive. There are options to detect when its orbit is too close to Neptune, and hence possibly eject Neptune, but I'll let you explore these.\n",
+    "\n",
+    "We now construct a plot of the temperature of each planet vs time. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "13214947-a209-4695-a6e2-692614af05dd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "[None]"
+      ]
+     },
+     "execution_count": 5,
+     "metadata": {},
+     "output_type": "execute_result"
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 1440x720 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "\n",
+    "import seaborn as sns\n",
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "# set up seaborn for use in the notebook\n",
+    "sns.set(rc={'figure.figsize':(20,10)})\n",
+    "sns.set_context(\"notebook\",\n",
+    "                font_scale=1.5,\n",
+    "                rc={\"lines.linewidth\":2.5})\n",
+    "\n",
+    "x = 'time'\n",
+    "y = 'temperature'\n",
+    "for planet in dataframes:\n",
+    "    df = dataframes[planet]\n",
+    "    p = sns.lineplot(data=df,\n",
+    "                     sort=False,\n",
+    "                     x=x,\n",
+    "                     y=y,\n",
+    "                     estimator=None,\n",
+    "                     ci=None,\n",
+    "                     legend='full'\n",
+    "                    )\n",
+    "    xx = df.head(1).loc[0,x]\n",
+    "    yy = df.head(1).loc[0,y]\n",
+    "    p.text(xx,yy,planet)\n",
+    "    \n",
+    "p.set_xlabel(\"time/Myr\")\n",
+    "p.set_ylabel(\"Temperature/K\")\n",
+    "p.set(ylim=(30,3000)) # might be necessary?\n",
+    "p.set(yscale=\"log\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8feac6a0-4a91-4600-8b3b-fab149ffb640",
+   "metadata": {},
+   "source": [
+    "It gets a little toasty on Earth in the not too distant future!"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "22df65d7-1c77-4e9c-b188-955219377014",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "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.9.5"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}