diff --git a/libra_toolbox/neutron_detection/activation_foils/calibration.py b/libra_toolbox/neutron_detection/activation_foils/calibration.py
index b98dfde..7ea2878 100644
--- a/libra_toolbox/neutron_detection/activation_foils/calibration.py
+++ b/libra_toolbox/neutron_detection/activation_foils/calibration.py
@@ -1,5 +1,5 @@
-from dataclasses import dataclass
-from typing import List
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
 import datetime
 import numpy as np
 
@@ -26,11 +26,12 @@ class Nuclide:
     """
 
     name: str
-    energy: List[float] = None
-    intensity: List[float] = None
-    half_life: float = None
-    atomic_mass: float = None
+    energy: Optional[List[float]] = None
+    intensity: Optional[List[float]] = None
+    half_life: Optional[float] = None
+    atomic_mass: Optional[float] = None
     abundance: float = 1.00
+    _uncalibrated_measured_energies: Optional[Dict] = field(default=None, repr=False)
 
     @property
     def decay_constant(self):
@@ -38,12 +39,31 @@ def decay_constant(self):
         Returns the decay constant of the nuclide in 1/s.
         """
         return np.log(2) / self.half_life
+    
+    def calibrated_measured_energies(self, channel_nb, calibration_coeffs):
+        """
+        Returns the calibrated measured energies of the nuclide in keV.
+        """
+        if self._uncalibrated_measured_energies is None:
+            return None
+        else:
+            uncalibrated = np.array(
+                self._uncalibrated_measured_energies.get(channel_nb, []),
+                dtype=float
+            )
+            return np.polyval(calibration_coeffs, uncalibrated)
 
 
+# ba133 = Nuclide(
+#     name="Ba133",
+#     energy=[80.9979, 276.3989, 302.8508, 356.0129, 383.8485],
+#     intensity=[0.329, 0.0716, 0.1834, 0.6205, 0.0894],
+#     half_life=10.551 * 365.25 * 24 * 3600,
+# )
 ba133 = Nuclide(
     name="Ba133",
-    energy=[80.9979, 276.3989, 302.8508, 356.0129, 383.8485],
-    intensity=[0.329, 0.0716, 0.1834, 0.6205, 0.0894],
+    energy=[276.3989, 302.8508, 356.0129, 383.8485],
+    intensity=[0.0716, 0.1834, 0.6205, 0.0894],
     half_life=10.551 * 365.25 * 24 * 3600,
 )
 co60 = Nuclide(
diff --git a/libra_toolbox/neutron_detection/activation_foils/compass.py b/libra_toolbox/neutron_detection/activation_foils/compass.py
index ddba183..dd07ced 100644
--- a/libra_toolbox/neutron_detection/activation_foils/compass.py
+++ b/libra_toolbox/neutron_detection/activation_foils/compass.py
@@ -169,6 +169,7 @@ class Measurement:
     stop_time: Union[datetime.datetime, None]
     name: str
     detectors: List[Detector]
+    detector_type: str = "NaI"  # Default detector type, can be 'NaI' or 'HPGe'
 
     def __init__(self, name: str) -> None:
         """
@@ -415,6 +416,8 @@ def compute_detection_efficiency(
         calibration_coeffs: np.ndarray,
         channel_nb: int,
         search_width: float = 800,
+        threshold_overlap: float = 200,
+        summing_method: str = 'sum_gaussian',
     ) -> Union[np.ndarray, float]:
         """
         Computes the detection efficiency of a check source given the
@@ -433,6 +436,12 @@ def compute_detection_efficiency(
             calibration_coeffs: the calibration polynomial coefficients for the detector
             channel_nb: the channel number of the detector
             search_width: the search width for the peak fitting
+            threshold_overlap: the threshold width for considering two peaks as overlapping
+            summing_method: method to sum counts under the peak, either 'sum_gaussian' or 'sum_histogram'
+                            with 'sum_gaussian' fitting a Gaussian to the peak and integrating it, 
+                            and with 'sum_histogram' summing the histogram counts under the peak.
+                            'sum_histogram' SHOULD NOT BE USED for OVERLAPPING peaks as it will
+                            overestimate the counts.
 
         Returns:
             the detection efficiency
@@ -448,11 +457,18 @@ def compute_detection_efficiency(
 
         calibrated_bin_edges = np.polyval(calibration_coeffs, bin_edges)
 
+        peak_energies = self.check_source.nuclide.calibrated_measured_energies(channel_nb, calibration_coeffs)
+        if peak_energies is None:
+            print("TOOLBOX: No calibrated measured energies found for the check source. Cannot compute detection efficiency.")
+            peak_energies = self.check_source.nuclide.energy
+
         nb_counts_measured = get_multipeak_area(
             hist,
             calibrated_bin_edges,
-            self.check_source.nuclide.energy,
+            peak_energies,
             search_width=search_width,
+            threshold_overlap=threshold_overlap,
+            summing_method=summing_method,
         )
 
         nb_counts_measured = np.array(nb_counts_measured)
@@ -497,26 +513,58 @@ def get_peaks(self, hist: np.ndarray, **kwargs) -> np.ndarray:
             the peak indices in ``hist``
         """
 
-        # peak finding parameters
-        start_index = 100
-        prominence = 0.10 * np.max(hist[start_index:])
-        height = 0.10 * np.max(hist[start_index:])
-        width = [10, 150]
-        distance = 30
-        if self.check_source.nuclide == na22:
+        if self.detector_type.lower() == 'nai':
+            # peak finding parameters
             start_index = 100
-            height = 0.1 * np.max(hist[start_index:])
-            prominence = 0.1 * np.max(hist[start_index:])
+            prominence = 0.10 * np.max(hist[start_index:])
+            height = 0.10 * np.max(hist[start_index:])
             width = [10, 150]
             distance = 30
-        elif self.check_source.nuclide == co60:
-            start_index = 400
-            height = 0.60 * np.max(hist[start_index:])
-            prominence = None
-        elif self.check_source.nuclide == ba133:
-            width = [10, 200]
-        elif self.check_source.nuclide == mn54:
-            height = 0.6 * np.max(hist[start_index:])
+            if self.check_source.nuclide == na22:
+                start_index = 100
+                height = 0.4 * np.max(hist[start_index:])
+                prominence = 0.4 * np.max(hist[start_index:])
+                width = [10, 150]
+                distance = 30
+            elif self.check_source.nuclide == co60:
+                start_index = 400
+                height = 0.60 * np.max(hist[start_index:])
+                prominence = None
+            elif self.check_source.nuclide == ba133:
+                start_index = 150
+                height = 0.10 * np.max(hist[start_index:])
+                prominence = 0.10 * np.max(hist[start_index:])
+            elif self.check_source.nuclide == mn54:
+                height = 0.6 * np.max(hist[start_index:])
+        elif self.detector_type.lower() == 'hpge':
+            # peak finding parameters for HPGe detectors
+            start_index = 10
+            prominence = 0.50 * np.max(hist[start_index:])
+            height = 0.50 * np.max(hist[start_index:])
+            width = [2, 50]
+            distance = 100
+            if self.check_source.nuclide == na22:
+                start_index = 100
+                height = 0.4 * np.max(hist[start_index:])
+                prominence = 0.4 * np.max(hist[start_index:])
+                distance = 100
+            elif self.check_source.nuclide == co60:
+                height = 0.5 * np.max(hist[start_index:])
+                prominence = 0.5 * np.max(hist[start_index:])
+            elif self.check_source.nuclide == ba133:
+                start_index = 150
+                height = 0.10 * np.max(hist[start_index:])
+                prominence = 0.10 * np.max(hist[start_index:])
+                distance = 10
+            elif self.check_source.nuclide == mn54:
+                start_index = 400
+                height = 0.7 * np.max(hist[start_index:])
+                prominence = 0.7 * np.max(hist[start_index:])
+                distance = 100
+        else:
+            raise ValueError(
+                f"Unknown detector type: {self.detector_type}. Supported types are 'NaI' and 'HPGe'."
+            )
 
         # update the parameters if kwargs are provided
         if kwargs:
@@ -537,6 +585,10 @@ def get_peaks(self, hist: np.ndarray, **kwargs) -> np.ndarray:
         )
         peaks = np.array(peaks) + start_index
 
+        # special case for Mn-54, only keep the first high count energy peak
+        if self.check_source.nuclide == mn54 and len(peaks) > 1:
+            peaks = np.array([peaks[0]])
+
         return peaks
 
 
@@ -550,6 +602,7 @@ def get_gamma_emitted(
         calibration_coeffs,
         channel_nb: int,
         search_width: float = 800,
+        summing_method: str = 'sum_gaussian',
     ):
         # find right background detector
 
@@ -569,6 +622,7 @@ def get_gamma_emitted(
             calibrated_bin_edges,
             energy,
             search_width=search_width,
+            summing_method=summing_method,
         )
 
         nb_counts_measured = np.array(nb_counts_measured)
@@ -713,6 +767,7 @@ def get_calibration_data(
     check_source_measurements: List[CheckSourceMeasurement],
     background_measurement: Measurement,
     channel_nb: int,
+    peak_kwargs: dict = None,
 ):
     background_detector = [
         detector
@@ -731,15 +786,28 @@ def get_calibration_data(
             hist, bin_edges = detector.get_energy_hist_background_substract(
                 background_detector, bins=None
             )
-            peaks_ind = measurement.get_peaks(hist)
+            if peak_kwargs is not None:
+                if measurement.check_source.nuclide in peak_kwargs.keys():
+                    kwargs = peak_kwargs[measurement.check_source.nuclide]
+                else:
+                    kwargs = {}
+            else:
+                kwargs = {}
+
+            peaks_ind = measurement.get_peaks(hist, **kwargs)
             peaks = bin_edges[peaks_ind]
 
             if len(peaks) != len(measurement.check_source.nuclide.energy):
                 raise ValueError(
-                    f"SciPy find_peaks() found {len(peaks)} photon peaks, while {len(measurement.check_source.nuclide.energy)} were expected"
+                    f"SciPy find_peaks() found {len(peaks)} photon peaks, while {len(measurement.check_source.nuclide.energy)} were expected",
+                    f" peaks found: {peaks} for {measurement.check_source.nuclide.name}",
                 )
             calibration_channels += list(peaks)
             calibration_energies += measurement.check_source.nuclide.energy
+            # Store the uncalibrated measured energies in the measurement object for later use
+            if measurement.check_source.nuclide._uncalibrated_measured_energies is None:
+                measurement.check_source.nuclide._uncalibrated_measured_energies = {}
+            measurement.check_source.nuclide._uncalibrated_measured_energies[channel_nb] = list(peaks)
 
     inds = np.argsort(calibration_channels)
     calibration_channels = np.array(calibration_channels)[inds]
@@ -763,7 +831,9 @@ def gauss(x, b, m, *args):
     return out
 
 
-def fit_peak_gauss(hist, xvals, peak_ergs, search_width=600, threshold_overlap=200):
+def fit_peak_gauss(hist, xvals, peak_ergs, 
+                   search_width=600, 
+                   threshold_overlap=200):
 
     if len(peak_ergs) > 1:
         if np.max(peak_ergs) - np.min(peak_ergs) > threshold_overlap:
@@ -772,17 +842,18 @@ def fit_peak_gauss(hist, xvals, peak_ergs, search_width=600, threshold_overlap=2
             )
 
     search_start = np.argmin(
-        np.abs((peak_ergs[0] - search_width / (2 * len(peak_ergs))) - xvals)
+        np.abs((peak_ergs[0] - search_width / ( len(peak_ergs))) - xvals)
     )
     search_end = np.argmin(
-        np.abs((peak_ergs[-1] + search_width / (2 * len(peak_ergs))) - xvals)
+        np.abs((peak_ergs[-1] + search_width / (len(peak_ergs))) - xvals)
     )
 
     slope_guess = (hist[search_end] - hist[search_start]) / (
         xvals[search_end] - xvals[search_start]
     )
 
-    guess_parameters = [0, slope_guess]
+    # guess_parameters = [0, slope_guess]
+    guess_parameters = [0, 0]
 
     for i in range(len(peak_ergs)):
         peak_ind = np.argmin(np.abs((peak_ergs[i]) - xvals))
@@ -792,6 +863,7 @@ def fit_peak_gauss(hist, xvals, peak_ergs, search_width=600, threshold_overlap=2
             search_width / (3 * len(peak_ergs)),
         ]
 
+
     parameters, covariance = curve_fit(
         gauss,
         xvals[search_start:search_end],
@@ -799,30 +871,43 @@ def fit_peak_gauss(hist, xvals, peak_ergs, search_width=600, threshold_overlap=2
         p0=guess_parameters,
     )
 
+    print("Fitted parameters:", parameters)
+
     return parameters, covariance
 
 
 def get_multipeak_area(
-    hist, bins, peak_ergs, search_width=600, threshold_overlap=200
+    hist, 
+    bins, 
+    peak_ergs, 
+    search_width=600, 
+    threshold_overlap=200,
+    summing_method='sum_gaussian',
+    ax=None,
 ) -> List[float]:
+    
+    print(peak_ergs)
 
     if len(peak_ergs) > 1:
         if np.max(peak_ergs) - np.min(peak_ergs) > threshold_overlap:
             areas = []
-            for peak in peak_ergs:
+            for p, peak in enumerate(peak_ergs):
                 area = get_multipeak_area(
                     hist,
                     bins,
                     [peak],
                     search_width=search_width,
                     threshold_overlap=threshold_overlap,
+                    summing_method=summing_method
                 )
                 areas += area
             return areas
+    
 
-    # get midpoints of every bin
+    # get midpoints of every binß
     xvals = np.diff(bins) / 2 + bins[:-1]
 
+
     parameters, covariance = fit_peak_gauss(
         hist, xvals, peak_ergs, search_width=search_width
     )
@@ -845,17 +930,24 @@ def get_multipeak_area(
         # Use unimodal gaussian to estimate counts from just one peak
         peak_params = [parameters[0], parameters[1], parameters[2 + 3 * i], mean, sigma]
         all_peak_params += [peak_params]
-        gross_area = np.trapz(
-            gauss(xvals[peak_start:peak_end], *peak_params),
-            x=xvals[peak_start:peak_end],
-        )
 
+        if summing_method == 'sum_gaussian':
+            gross_area = np.trapz(
+                gauss(xvals[peak_start:peak_end], *peak_params),
+                x=xvals[peak_start:peak_end],
+            )
+        elif summing_method == 'sum_histogram':
+            gross_area = np.trapz(
+                hist[peak_start:peak_end],
+                x=xvals[peak_start:peak_end],
+            )
         # Cut off trapezoidal area due to compton scattering and noise
         trap_cutoff_area = np.trapz(
             parameters[0] + parameters[1] * xvals[peak_start:peak_end],
             x=xvals[peak_start:peak_end],
         )
         area = gross_area - trap_cutoff_area
+
         areas += [area]
 
     return areas
@@ -939,7 +1031,7 @@ def get_events(directory: str) -> Tuple[Dict[int, np.ndarray], Dict[int, np.ndar
         time_values[ch] = np.empty(0)
         energy_values[ch] = np.empty(0)
         for i, filename in enumerate(data_filenames[ch]):
-            print(f'Processing File {i}')
+            # print(f'Processing File {i}')
 
             csv_file_path = os.path.join(directory, filename)
 
diff --git a/test/neutron_detection/compass_test_data/background_measurement/background_measurements.h5 b/test/neutron_detection/compass_test_data/background_measurement/background_measurements.h5
new file mode 100644
index 0000000..23fb0bf
Binary files /dev/null and b/test/neutron_detection/compass_test_data/background_measurement/background_measurements.h5 differ
diff --git a/test/neutron_detection/compass_test_data/background_measurement/calibration_coefficients.json b/test/neutron_detection/compass_test_data/background_measurement/calibration_coefficients.json
new file mode 100644
index 0000000..18aad4e
--- /dev/null
+++ b/test/neutron_detection/compass_test_data/background_measurement/calibration_coefficients.json
@@ -0,0 +1,18 @@
+{
+  "HPGe": {
+    "0": [
+      1.0198403099123785,
+      2.689961639523998
+    ]
+  },
+  "NaI": {
+    "4": [
+      0.7959901704589225,
+      -38.917607406086006
+    ],
+    "5": [
+      1.0622115094394577,
+      -30.576666718985596
+    ]
+  }
+}
\ No newline at end of file
diff --git a/test/neutron_detection/temp_create_spectra.ipynb b/test/neutron_detection/temp_create_spectra.ipynb
new file mode 100644
index 0000000..8257bc1
--- /dev/null
+++ b/test/neutron_detection/temp_create_spectra.ipynb
@@ -0,0 +1,360 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "89b5b7a2",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from libra_toolbox.neutron_detection.activation_foils import compass\n",
+    "from libra_toolbox.neutron_detection.activation_foils.calibration import ba133, cs137, co60, na22, mn54\n",
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "import json\n",
+    "import datetime\n",
+    "from pathlib import Path\n",
+    "from libra_toolbox.neutron_detection.activation_foils.calibration import CheckSource, Nuclide"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "8eba995a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def create_nuclide_spectrum(\n",
+    "    nuclide: Nuclide,\n",
+    "    signal_to_background_ratio: float,\n",
+    "    peak_standard_deviation: float,\n",
+    "    background_detector: compass.Detector,\n",
+    "    background_divider: float = 1.0,\n",
+    "):\n",
+    "    # In case background has many events, scale it down to speed up test\n",
+    "    background_hist = background_detector._spectrum / background_divider\n",
+    "\n",
+    "    total_counts_background = np.sum(background_hist)\n",
+    "    desired_signal_counts = signal_to_background_ratio * total_counts_background\n",
+    "\n",
+    "    nuclide_events = np.zeros((0,))\n",
+    "    for energy, intensity in zip(nuclide.energy, nuclide.intensity):\n",
+    "        compton_fraction = 0.1  # ~20% of events go to Compton scattering\n",
+    "        # Full energy peak\n",
+    "        nuclide_events = np.append(\n",
+    "            nuclide_events,\n",
+    "            np.random.normal(\n",
+    "                loc=energy,\n",
+    "                scale=peak_standard_deviation,\n",
+    "                size=int(desired_signal_counts * intensity * (1 - compton_fraction)),\n",
+    "            ),\n",
+    "        )\n",
+    "\n",
+    "        # Compton edge\n",
+    "        compton_edge = energy * (1 - 1 / (1 + (2 * energy / 511)))\n",
+    "        compton_events = int(desired_signal_counts * intensity * compton_fraction)\n",
+    "\n",
+    "        # Generate Compton events below the edge with a smooth falloff\n",
+    "        # Using exponential distribution peaked near the edge\n",
+    "        compton_samples = np.random.exponential(\n",
+    "            scale=compton_edge / 3, size=compton_events\n",
+    "        )\n",
+    "        # Shift to be centered below the edge\n",
+    "        compton_samples = compton_edge - np.abs(compton_samples)\n",
+    "        compton_samples = compton_samples[\n",
+    "            compton_samples > 0\n",
+    "        ]  # Remove negative energies\n",
+    "        nuclide_events = np.append(nuclide_events, compton_samples)\n",
+    "    nuclide_hist, _ = np.histogram(\n",
+    "        nuclide_events, bins=background_detector._calibrated_bin_edges\n",
+    "    )\n",
+    "\n",
+    "    noise_level = 1.0\n",
+    "    gaussian_noise = np.random.normal(\n",
+    "        0, noise_level * np.sqrt(nuclide_hist), size=nuclide_hist.shape\n",
+    "    )\n",
+    "\n",
+    "    overall_hist = nuclide_hist + background_hist + gaussian_noise\n",
+    "    return overall_hist\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "09ebc118",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test_get_peaks(detector_type, nuclide, signal_to_background_ratio):\n",
+    "\n",
+    "    # get real background measurement\n",
+    "    background_measurements = compass.Measurement.from_h5(\n",
+    "         \"compass_test_data/background_measurement/background_measurements.h5\"\n",
+    "    )\n",
+    "\n",
+    "    # read in calibration coefficients from json\n",
+    "    with open(\n",
+    "         \"compass_test_data/background_measurement/calibration_coefficients.json\", \"r\"\n",
+    "    ) as f:\n",
+    "        calibration_coefficients = json.load(f)\n",
+    "\n",
+    "    if detector_type == \"NaI\":\n",
+    "        coeffs = calibration_coefficients[\"NaI\"][\"4\"]\n",
+    "        peak_standard_deviation = 30.0  # keV\n",
+    "        background_divider = 100.0\n",
+    "        for background_measurement in background_measurements:\n",
+    "            if background_measurement.name == \"NaI Background\":\n",
+    "                background_detector = background_measurement.get_detector(4)\n",
+    "                break\n",
+    "    elif detector_type == \"HPGe\":\n",
+    "        coeffs = calibration_coefficients[\"HPGe\"][\"0\"]\n",
+    "        peak_standard_deviation = 2.0  # keV\n",
+    "        background_divider = 1.0\n",
+    "        for background_measurement in background_measurements:\n",
+    "            if background_measurement.name == \"HPGe Background\":\n",
+    "                background_detector = background_measurement.get_detector(0)\n",
+    "                break\n",
+    "    else:\n",
+    "        raise ValueError(f\"Unknown detector type: {detector_type}\")\n",
+    "\n",
+    "    background_detector._calibrated_bin_edges = np.polyval(\n",
+    "        coeffs, background_detector._bin_edges\n",
+    "    )\n",
+    "\n",
+    "    # Build simulated spectrum with nuclide peaks + background\n",
+    "    overall_hist = create_nuclide_spectrum(\n",
+    "        nuclide=nuclide,\n",
+    "        signal_to_background_ratio=signal_to_background_ratio,\n",
+    "        peak_standard_deviation=peak_standard_deviation,\n",
+    "        background_detector=background_detector,\n",
+    "        background_divider=background_divider,\n",
+    "    )\n",
+    "\n",
+    "    fig, ax = plt.subplots()\n",
+    "    ax.stairs(overall_hist, background_detector._calibrated_bin_edges, label=\"Simulated Spectrum\")\n",
+    "    ax.set_xlabel(\"Energy (keV)\")\n",
+    "    ax.set_ylabel(\"Counts\")\n",
+    "    ax.vlines(background_detector._calibrated_bin_edges[400], \n",
+    "              0, np.max(overall_hist), \n",
+    "              colors='lightgray', linestyles='dotted', linewidth=0.5)\n",
+    "    ax.set_title(nuclide.name)\n",
+    "    if detector_type == \"NaI\":\n",
+    "        ax.set_yscale(\"log\")\n",
+    "    ax.grid()\n",
+    "\n",
+    "    # Create a check source measurement instance\n",
+    "    check_source_detector = compass.Detector(channel_nb=0)\n",
+    "    check_source_detector._spectrum = overall_hist\n",
+    "    check_source_detector._bin_edges = background_detector._calibrated_bin_edges\n",
+    "\n",
+    "    check_source = CheckSource(nuclide=nuclide,\n",
+    "                               activity_date=datetime.datetime(2024, 1, 1),\n",
+    "                               activity=1.0)\n",
+    "    \n",
+    "    check_source_meas = compass.CheckSourceMeasurement('test')\n",
+    "    check_source_meas.check_source = check_source\n",
+    "    check_source_meas.detectors = [check_source_detector]\n",
+    "    check_source_meas.detector_type = detector_type\n",
+    "\n",
+    "    test_peak_inds = check_source_meas.get_peaks(overall_hist)\n",
+    "    test_peaks = background_detector._calibrated_bin_edges[\n",
+    "        test_peak_inds\n",
+    "    ]\n",
+    "    if len(test_peaks) != len(nuclide.energy):\n",
+    "        print(f\"test_peak length: {len(test_peaks)}\", f\"nuclide energy length: {len(nuclide.energy)}\")\n",
+    "        print(f\"Detected peaks at: {test_peaks}\")\n",
+    "    # assert len(test_peaks) == len(nuclide.energy)\n",
+    "    for test_energy, expected_energy in zip(test_peaks, nuclide.energy):\n",
+    "        if not np.isclose(test_energy, expected_energy, rtol=0.05):\n",
+    "            print(f\"Detected peak at {test_energy:.2f} keV, expected at {expected_energy} keV\")\n",
+    "        # assert np.isclose(test_energy, expected_energy, rtol=0.05)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "25566ef8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Testing NaI with Co60 at S/B=1.0\n",
+      "\n",
+      "Testing NaI with Cs137 at S/B=10.0\n",
+      "\n",
+      "Testing NaI with Mn54 at S/B=0.01\n",
+      "\n",
+      "Testing NaI with Na22 at S/B=10.0\n",
+      "\n",
+      "Testing NaI with Na22 at S/B=0.1\n",
+      "\n",
+      "Testing HPGe with Ba133 at S/B=1.0\n",
+      "\n",
+      "Testing HPGe with Co60 at S/B=1.0\n",
+      "\n",
+      "Testing HPGe with Cs137 at S/B=10.0\n",
+      "\n",
+      "Testing HPGe with Mn54 at S/B=0.01\n",
+      "\n",
+      "Testing HPGe with Na22 at S/B=10.0\n",
+      "\n",
+      "Testing HPGe with Na22 at S/B=0.1\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHHCAYAAABTMjf2AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjMsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvZiW1igAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZWBJREFUeJzt3XlcVOX+B/DPMAyDyCKKsigK7uGCC2i4ryiapdbNsoWszArKog1bXNq07Jq3mvJWV21zSUvtF6Yp7ruIaEjukCsgIowsDsPM+f2BHB1n2GfmzPJ5v16+nHPOM895zuPgfHlWmSAIAoiIiIickIvUBSAiIiKSCgMhIiIicloMhIiIiMhpMRAiIiIip8VAiIiIiJwWAyEiIiJyWgyEiIiIyGkxECIiIiKnxUCIiIiInBYDISIiInJaDISIyC4sXboUMpkMMpkMu3btMrouCAKCg4Mhk8lwzz33NCj/O/9kZ2dX+b4zZ87A3d0dMpkMKSkpdb4vEUnLVeoCEBHVhbu7O5YtW4YBAwYYnN++fTsuXLgApVLZoPzfffddhIaGGpxr0qRJlelffvlluLq6QqPRNOi+RCQNBkJEZFfGjBmDVatW4bPPPoOr663/wpYtW4bevXsjLy+vQfnHxMQgIiKiVmk3btyIjRs34vXXX8f777/foPsSkTTYNUZEduXhhx/G1atXsWnTJvFcWVkZVq9ejcmTJxukzcrKgkwmwyeffIKvv/4a7dq1g1KpRGRkJA4ePFjlPa5fvw6dTldtObRaLaZPn47p06ejXbt2DXsoIpIMAyEisishISGIiorC8uXLxXN//PEHCgsL8dBDD5l8z7JlyzB//nxMmzYN77//PrKysjBx4kRotVqjtEOHDoW3tzc8PDxw77334tSpUybzXLhwIa5du4a3337bPA9GRJJg1xgR2Z3JkydjxowZKC0tRaNGjfDTTz9h8ODBCAoKMpn+3LlzOHXqFHx9fQEAnTp1wn333YeNGzeKA6s9PDzwxBNPiIHQoUOHsGDBAvTr1w+pqakIDg4W88vOzsZ7772HTz75BN7e3pZ/YCKyGLYIEZHdefDBB1FaWorff/8d169fx++//27ULXa7SZMmiUEQAAwcOBAAcPbsWYM8lyxZgscffxzjx4/He++9h40bN+Lq1av44IMPDPJ744030LZtWzz99NNmfjIisja2CBGR3WnevDlGjBiBZcuWoaSkBDqdDg888ECV6Vu3bm1wXBkUXbt2rdr7DBgwAH379sXmzZvFc/v27cMPP/yA5ORkuLjwd0kie8dAiIjs0uTJkzF16lRkZ2cjJiam2inucrnc5HlBEGq8T3BwME6cOCEev/766xg4cCBCQ0ORlZUFAOJMtcuXL+PcuXNGgRcR2S4GQkRklyZMmIBp06Zh3759WLlypcXuc/bsWTRv3lw8PnfuHP755x+jtYYA4N5774WPjw8KCgosVh4iMi8GQkRklzw9PfHVV18hKysL48aNa3B+V65cMQh4AGD9+vU4dOgQXnzxRfHc119/jZKSEoN0W7Zsweeff45PPvkEnTt3bnBZiMh6GAgRkd2KjY01W179+vVDz549ERERAR8fH6SmpmLx4sUIDg7Gm2++KaaLjo42em9lC9DgwYNrvRgjEdkGBkJERKiYWZaUlIQ///wTJSUlCAwMxNSpUzFr1iz4+/tLXTwishCZUJvRgkREREQOiHM/iYiIyGkxECIiIiKnxUCIiIiInBYDISIiInJaDISIiIjIaTEQIiIiIqfFdYSqodfrcenSJXh5eUEmk0ldHCIiIqoFQRBw/fp1BAUF1bg5MgOhaly6dAnBwcFSF4OIiIjq4fz582jVqlW1aRgImaBSqaBSqVBeXg6goiK9vb0tfl+tVos///wT0dHRUCgUFr+fvWC9GGOdGGOdGGOdGGOdGHPEOlGr1QgODoaXl1eNaRkImRAXF4e4uDio1Wr4+PjA29vbaoGQh4cHvL29HebDaA6sF2OsE2OsE2OsE2OsE2OOXCe1GdbCwdJERETktBgIERERkdNiIEREREROi4EQEREROS0GQkREROS0GAgRERGR02IgRERERE6LgZAJKpUKYWFhiIyMlLooREREZEEMhEyIi4tDRkYGDh48KHVRiIiIyIIYCBEREZHTYiBERERETouBEBERETktBkJERETktBgISSRXfQMXrpVIXQwiIiKn5ip1AZxVnw+TAQBZ88ZKXBIiIiLnxRYhIiIicloMhIiIiMhpOUXXWEhICLy9veHi4gJfX19s3bpV6iIRERGRDXCKQAgA9uzZA09PT6mLQURERDaEXWNERETktGw+ENqxYwfGjRuHoKAgyGQyrF271iiNSqVCSEgI3N3d0bdvXxw4cMDgukwmw+DBgxEZGYmffvrJSiUnIiIiW2fzgVBxcTHCw8OhUqlMXl+5ciUSEhIwa9YspKamIjw8HKNGjUJubq6YZteuXTh06BB+++03fPjhhzh69Ki1ik9EREQ2zObHCMXExCAmJqbK6wsWLMDUqVMxZcoUAMCiRYuQlJSExYsXIzExEQDQsmVLAEBgYCDGjBmD1NRUdO/e3SgvjUYDjUYjHqvVagCAVquFVqs12zMBgFIuiHlXqnxt7nvZO9aLMdaJMdaJMdaJMdaJMUesk7o8i0wQBMGCZTErmUyGNWvWYPz48QCAsrIyeHh4YPXq1eI5AIiNjUVBQQHWrVuH4uJi6PV6eHl5oaioCIMHD8aiRYsQGRlplP/s2bMxZ84co/PLli2Dh4eHpR6LiIiIzKikpASTJ09GYWEhvL29q01r8y1C1cnLy4NOp4O/v7/BeX9/fxw/fhwAkJOTgwkTJgAAdDodpk6dajIIAoAZM2YgISFBPFar1QgODkZ0dHSNFVlXXWdvBACkzx4lntNqtdi0aRNGjhwJhUJh1vvZM9aLMdaJMdaJMdaJMdaJMUesk8oendqw60CoNtq2bYsjR47UKq1SqYRSqTQ6r1AozP7h0OhkYt7WuJ8jYL0YY50YY50YY50YY50Yc6Q6qctz2Pxg6er4+flBLpcjJyfH4HxOTg4CAgLqna9KpUJYWFiVLUdERETkGOw6EHJzc0Pv3r2RnJwsntPr9UhOTkZUVFS9842Li0NGRgYOHjxojmISERGRjbL5rrGioiKcPn1aPM7MzERaWhqaNm2K1q1bIyEhAbGxsYiIiECfPn2wcOFCFBcXi7PI6kOlUkGlUkGn05njEYiIiMhG2XwglJKSgqFDh4rHlYOZY2NjsXTpUkyaNAlXrlzBzJkzkZ2djR49emDDhg1GA6jrIi4uDnFxcVCr1fDx8WnwMxAREZFtsvlAaMiQIahphn98fDzi4+OtVCIiIiJyFHY9RshSOFiaiIjIOTAQMoGDpYmIiJwDAyGJ2dHC3kRERA6HgZDEGAcRERFJh4GQCdYcI8Q4iIiISDoMhEyw5hghPZuEiIiIJMNASGKMg4iIiKTDQEhiAjvHiIiIJMNAyARrjBFyqdh8HjmFGovdg4iIiKrHQMgEa4wR8lRWLOqtY98YERGRZBgISUQmk0ldBCIiIqfHQEhiXFCRiIhIOgyEJMIGISIiIukxEDKBCyoSERE5BwZCJlhjsHRlgxB7xoiIiKTDQEgiHCxNREQkPQZCkmOTEBERkVQYCEmE7UFERETSYyAkMY4RIiIikg4DIYlUDhFiHERERCQdBkImWGf6PDvHiIiIpMZAyARrTJ+vxK4xIiIi6TAQkghnzxMREUmPgZDEBI4SIiIikgwDIYlwZWkiIiLpMRCSCLvGiIiIpMdASGJsESIiIpIOAyGJyDh9noiISHIMhCTGwdJERETSYSBkgjUWVBRXlmYcREREJBkGQiZYY0FFdowRERFJj4EQEREROS0GQhKRcf48ERGR5BgISYxjhIiIiKTDQEhinDVGREQkHQZCEmHPGBERkfQYCEmMXWNERETSYSAkEbYIERERSY+BkMTYIERERCQdpwiESkpK0KZNG7z66qtSF0VUudeYwL4xIiIiyThFIPTBBx/g7rvvlroYBtg1RkREJD2HD4ROnTqF48ePIyYmRuqimMT2ICIiIunYdCC0Y8cOjBs3DkFBQZDJZFi7dq1RGpVKhZCQELi7u6Nv3744cOCAwfVXX30Vc+fOtVKJa48NQkRERNKz6UCouLgY4eHhUKlUJq+vXLkSCQkJmDVrFlJTUxEeHo5Ro0YhNzcXALBu3Tp07NgRHTt2tGax64RDhIiIiKTjKnUBqhMTE1Ntl9aCBQswdepUTJkyBQCwaNEiJCUlYfHixUhMTMS+ffuwYsUKrFq1CkVFRdBqtfD29sbMmTNN5qfRaKDRaMRjtVoNANBqtdBqtWZ8MkApB5RyAXrdrbzv/JsqsF6MsU6MsU6MsU6MsU6MOWKd1OVZZIKdTFuSyWRYs2YNxo8fDwAoKyuDh4cHVq9eLZ4DgNjYWBQUFGDdunUG71+6dCnS09PxySefVHmP2bNnY86cOUbnly1bBg8PD7M8BxEREVlWSUkJJk+ejMLCQnh7e1eb1qZbhKqTl5cHnU4Hf39/g/P+/v44fvx4vfKcMWMGEhISxGO1Wo3g4GBER0fXWJF1Ne7zXci8WowfnuyDnq19AVREsJs2bcLIkSOhUCjMej97xnoxxjoxxjoxxjoxxjox5oh1UtmjUxt2GwjV1RNPPFFjGqVSCaVSCZVKBZVKBZ1OBwBQKBRm/3CUCTJodDK4yF2N8rbE/RwB68UY68QY68QY68QY68SYI9VJXZ7DpgdLV8fPzw9yuRw5OTkG53NychAQENCgvOPi4pCRkYGDBw82KJ/asIt+SSIiIgdlt4GQm5sbevfujeTkZPGcXq9HcnIyoqKiJCxZ7VROn7ePEVpERESOyaa7xoqKinD69GnxODMzE2lpaWjatClat26NhIQExMbGIiIiAn369MHChQtRXFwsziKrrzu7xixBxqWliYiIJGfTgVBKSgqGDh0qHlcOZI6NjcXSpUsxadIkXLlyBTNnzkR2djZ69OiBDRs2GA2grqu4uDjExcVBrVbDx8enQXnVxE4m7RERETkkmw6EhgwZUmOgEB8fj/j4eCuVyHzYHkRERCQ9ux0jZEkqlQphYWGIjIy0+L3YHkRERCQdBkImWGPWmEJeUfWFpY6zkicREZG9YSAkkeZeSgBAsaZc4pIQERE5LwZCJliza4yIiIikw0DIBKsuqMhBQkRERJJhICQRLiNEREQkPQZCEmODEBERkXQYCEmEDUJERETSYyBkAgdLExEROQcGQiZYd7A0O8eIiIikwkBIItx0lYiISHoMhCTG9iAiIiLpMBCSCNuDiIiIpMdAyAQOliYiInIODIRMsOZgafaNERERSYeBkEQ4VpqIiEh6DIQkJrBJiIiISDIMhCTDJiEiIiKpMRAiIiIip8VAyARrzhrjwtJERETSYSBkgjVmjXGwNBERkfQYCEmMDUJERETSYSBERERETouBEBERETktBkIS42BpIiIi6TAQIiIiIqfFQEhiXFmaiIhIOgyEiIiIyGkxEDLBmgsqEhERkXQYCJlgjQUVK3GwNBERkXQYCBEREZHTYiAkMTYIERERSYeBEBERETktBkJERETktBgISY2jpYmIiCTDQIiIiIicFgMhIiIicloMhCTGjjEiIiLpOHwgVFBQgIiICPTo0QNdu3bFN998I3WRiIiIyEa4Sl0AS/Py8sKOHTvg4eGB4uJidO3aFRMnTkSzZs2kLhoAjpUmIiKSksO3CMnlcnh4eAAANBoNBEGAwOiDiIiIYAeB0I4dOzBu3DgEBQVBJpNh7dq1RmlUKhVCQkLg7u6Ovn374sCBAwbXCwoKEB4ejlatWuG1116Dn5+flUpPREREtszmA6Hi4mKEh4dDpVKZvL5y5UokJCRg1qxZSE1NRXh4OEaNGoXc3FwxTZMmTXDkyBFkZmZi2bJlyMnJsVbxa8TWKSIiIunY/BihmJgYxMTEVHl9wYIFmDp1KqZMmQIAWLRoEZKSkrB48WIkJiYapPX390d4eDh27tyJBx54wCgvjUYDjUYjHqvVagCAVquFVqs1x+OIXKGHUi4Aep2Y951/UwXWizHWiTHWiTHWiTHWiTFHrJO6PItMsKMmCZlMhjVr1mD8+PEAgLKyMnh4eGD16tXiOQCIjY1FQUEB1q1bh5ycHHh4eMDLywuFhYXo378/li9fjm7duhnlP3v2bMyZM8fo/LJly8RxRkRERGTbSkpKMHnyZBQWFsLb27vatDbfIlSdvLw86HQ6+Pv7G5z39/fH8ePHAQD//PMPnnnmGXGQ9AsvvGAyCAKAGTNmICEhQTxWq9UIDg5GdHR0jRVZVy8uP4wtJ3KROLozHr27DYCKCHbTpk0YOXIkFAqFWe9nz1gvxlgnxlgnxlgnxlgnxhyxTip7dGrDrgOh2ujTpw/S0tJqlVapVEKpVBqdVygUZv9wlMMFGp0McJEb5W2J+zkC1osx1okx1okx1okx1okxR6qTujyHzQ+Wro6fnx/kcrnR4OecnBwEBATUO1+VSoWwsDBERkY2tIg1sp+OSSIiIsdj14GQm5sbevfujeTkZPGcXq9HcnIyoqKi6p1vXFwcMjIycPDgQXMUk4iIiGyUzXeNFRUV4fTp0+JxZmYm0tLS0LRpU7Ru3RoJCQmIjY1FREQE+vTpg4ULF6K4uFicRVYfKpUKKpUKOp3OHI9QLTYIERERScfmA6GUlBQMHTpUPK4czBwbG4ulS5di0qRJuHLlCmbOnIns7Gz06NEDGzZsMBpAXRdxcXGIi4uDWq2Gj49Pg5+BiIiIbJPNB0JDhgypcdHB+Ph4xMfHW6lERERE5CjseoyQpVh3sDQ7x4iIiKTCQMgEDpYmIiJyDgyEiIiIyGkxECIiIiKnxUDIBGuOESIiIiLpMBAywZpjhDhWmoiISDoMhIiIiMhpMRCSmMC1pYmIiCTDQMgEjhEiIiJyDgyETOA6QkRERM6BgZDEOFiaiIhIOgyEiIiIyGkxEJIYG4SIiIikw0DIBA6WJiIicg4MhEzgYGkiIiLnwEBIYhwsTUREJB0GQkREROS0GAhJjCtLExERSYeBEBERETktBkIS02j1UheBiIjIaTEQMsGa0+fzi8ssfg8iIiIyjYGQCZw+T0RE5BwYCBEREZHTYiAkMc4aIyIikk69AqHU1FT89ddf4vG6deswfvx4vPnmmygr45gXIiIisg/1CoSmTZuGkydPAgDOnj2Lhx56CB4eHli1ahVef/11sxaQiIiIyFLqFQidPHkSPXr0AACsWrUKgwYNwrJly7B06VL88ssv5iyfw+MWG0RERNKpVyAkCAL0+or1bzZv3owxY8YAAIKDg5GXl2e+0hERERFZUL0CoYiICLz//vv44YcfsH37dowdOxYAkJmZCX9/f7MWkIiIiMhS6hUIffrpp0hNTUV8fDzeeusttG/fHgCwevVq9OvXz6wFlII1F1RkzxgREZF0XOvzpvDwcINZY5Xmz58PV9d6ZWlT4uLiEBcXB7VaDR8fH6mLQ0RERBZSrxahtm3b4urVq0bnb9y4gY4dOza4UERERETWUK9AKCsrCzqdzui8RqPBhQsXGlwoZ8JZY0RERNKpUz/Wb7/9Jr7euHGjQbeRTqdDcnIyQkNDzVc6IiIiIguqUyA0fvx4AIBMJkNsbKzBNYVCgZCQEPz73/82W+GIiIiILKlOgVDl2kGhoaE4ePAg/Pz8LFIo58K+MSIiIqnUa4pXZmamuctBREREZHX1nuuenJyM5ORk5Obmii1FlRYvXtzgghERERFZWr0CoTlz5uDdd99FREQEAgMDIZPJzF0up8FZY0RERNKpVyC0aNEiLF26FI899pi5y2N258+fx2OPPYbc3Fy4urrinXfewb/+9S+pi0VEREQ2oF6BUFlZmd1speHq6oqFCxeiR48eyM7ORu/evTFmzBg0btxY6qIRERGRxOq1oOLTTz+NZcuWmbssFhEYGIgePXoAAAICAuDn54f8/HxpC3Ubdo0RERFJp14tQjdu3MDXX3+NzZs3o3v37lAoFAbXFyxYYJbCAcCOHTswf/58HDp0CJcvX8aaNWvE9YwqqVQqzJ8/H9nZ2QgPD8fnn3+OPn36GOV16NAh6HQ6BAcHm618REREZL/qFQgdPXpUbGVJT083uGbugdPFxcUIDw/Hk08+iYkTJxpdX7lyJRISErBo0SL07dsXCxcuxKhRo3DixAm0aNFCTJefn4/HH38c33zzjVnLR0RERParXoHQ1q1bzV2OKsXExCAmJqbK6wsWLMDUqVMxZcoUABUDuZOSkrB48WIkJiYCqNgDbfz48UhMTKx2bJNGo4FGoxGP1Wo1AECr1UKr1ZrjcUSu0EMpF+ACnZj3nX83VJFGi+0n8jC4kx88lYqa32CjzF0vjoB1Yox1Yox1Yox1YswR66QuzyITBPsZpSKTyQy6xsrKyuDh4YHVq1cbdJfFxsaioKAA69atgyAImDx5Mjp16oTZs2dXm//s2bMxZ84co/PLli2Dh4eHGZ+EiIiILKWkpASTJ09GYWEhvL29q01brxahoUOHVtsFtmXLlvpkW2d5eXnQ6XTw9/c3OO/v74/jx48DAHbv3o2VK1eie/fuWLt2LQDghx9+QLdu3YzymzFjBhISEsRjtVqN4OBgREdH11iRdfXi8sPYciIXE3u2xLv3dQVQEcFu2rQJI0eONBp3VRdl5Tr0en8zAGDmPWF49/cM8drXj/ZGREhTuLnWa5y8JMxVL46EdWKMdWKMdWKMdWLMEeukskenNuoVCFWOD6qk1WqRlpaG9PR0o81YpTZgwACjla+rolQqoVQqoVKpoFKpoNPpAFRsKGvuD0c5XKDRyVAuuBjl3dD7bT+VD41OhqGdmuORqLZ4ILINOr29AQAQ+10qAGDDSwPROcC8wZ2lWeLfwd6xToyxToyxToyxTow5Up3U5TnqFQh9+umnJs/Pnj0bRUVF9cmyXvz8/CCXy5GTk2NwPicnBwEBAfXONy4uDnFxcVCr1fDx8WloMa3u6e9TAAD/frAHAEDpKkfWvLH4PPkU/r3pJABg9MKd6BHcBJ9O6oE2TT3g4sLVwc2pSFMObbkevo3dpC4KERFVw6z9I48++qhV9xlzc3ND7969kZycLJ7T6/VITk5GVFSU1cphq3w9DCPiF4Z3wB/TB2LEXRWz6dLOF2DoJ9vQ9s31+HLbaVwt0pjKhuqh66yN6PneJpzKuS51UYiIqBpmDYT27t0Ld3d3c2aJoqIipKWlIS0tDUDFzvdpaWk4d+4cACAhIQHffPMNvvvuO/z999947rnnUFxcLM4iqw+VSoWwsDBERkaa4xGqZe6R6gUlZQCAx+5uY3Ic112B3vg2NhLpc0bBz/NWa8XHG06g981xRWQ+xy7dnHmoq133LBERWVe9usbuXM9HEARcvnwZKSkpeOedd8xSsEopKSkYOnSoeFw5mDk2NhZLly7FpEmTcOXKFcycORPZ2dno0aMHNmzYYDSAui7suWvs/45cAgB0a1V9uT2Vrkh5eyTWpV3E9RvleHttxXpQIYlJ+PbxCIwIq3/9ObsbWp34WrX1NGQy4O216dg7Yzg8lfX6kSMiIgup1//KdwYHLi4u6NSpE959911ER0ebpWCVhgwZgppm+MfHxyM+Pt6s97VX+85WbB9yT/fAWqW/r0dLAMCYboHo/f4mCELFGKOseWMtVkZH9+W2M+LrU7lFmL4iDQAQu/gAfnnOPvboIyJyFvUKhJYsWWLuctiUO2eNWZK5V3HyuTkuyMOtbv+0TRu74cCbIxD5QUX32I6TVzCoY3PzFs6BFZZoMfePv/FE/xB8lnzKZJrbW4qIiMg2NGiM0KFDh/Djjz/ixx9/xOHDh81VJsnFxcUhIyMDBw8elLoodSIIApbtP1fv9zf3UmLaoLYAgMcXH8CZK9abAWjvsq4WY8XB8/jfzswq0xy7pIZObzfrlxIROYV6BUK5ubkYNmwYIiMj8eKLL+LFF19E7969MXz4cFy5csXcZaRaKjPDgNy4Ye3F18P/vR0L/jyBP/663OB8HZ2rvGJg+qpDF6pNt+Mkfz6IiGxJvQKhF154AdevX8exY8eQn5+P/Px8pKenQ61W48UXXzR3Ga3OurPGzNdCUFZeEQipJveqdx7e7gpkvDtKPP5sy2k891Mqwuf8iaSjDIiqopDX7kdJbz872hAROYV6BUIbNmzAl19+ibvuuks8FxYWBpVKhT/++MNshZOKvXaN5RVVTJ1v6PYZHm6uyJo3FnPu7SKeKyzVIm5ZKl5acRjn80salL8jknNBSiIiu1Svb0y9Xm9y+WqFQlHr7SzI/C5eKwVgvJBifcX2C0H6nFGYN/HWvmxr0y5h4Mdb8eexbMN7F5TipBMvHqjaclrqIhARUT3UKxAaNmwYpk+fjkuXLonnLl68iJdffhnDhw83W+Gcghl7Sq4U3QAABDVpZLY8PZWueKhPa6Pp9M/8cAghiUnIyisGALy++giiP91htvvam18PXzQ6t/P1oUibOdLgnEwG5Kpv1LgkBBERWUe9AqEvvvgCarUaISEhaNeuHdq1a4fQ0FCo1Wp8/vnn5i4j1VLGzVWMPd0ts2jfyfdj8PsLAwzODflkG0ISk7D79FUAwHu37XTvzCZFBCO4qQeaeLhh/5uGvxz0+TAZs387JlHJiIjodvUKhIKDg5GamoqkpCS89NJLeOmll7B+/XqkpqaiVatW5i6j1VlzsLQ5Zd5snfGs4xpCteXm6oKuLX0we1xYlWn+t6vq6ePOZMaYzuJrf+9b2848ubRiQ9x1Ry4ZvYeIiKyvToHQli1bEBYWBrVaDZlMhpEjR+KFF17ACy+8gMjISHTp0gU7d+60VFmtxpqDpc3ZQaK5OWvM0jvJP9E/FJlzxyBz7hgcf280+oY2Nbi+5nD1U8idQU2Dpzm0mojINtQpEFq4cCGmTp0Kb29vo2s+Pj6YNm0aFixYYLbCUd0UlGitthq0TCaDTCaDu0KOldOikDVvLBq7yQEAL688gpDEJKhvaK1SFil9svEEQhKTxOMXhrVHJ38vuCvk1b7vWonj1w0RkT2oUyB05MgRjB49usrr0dHROHToUIMLRfXz18VCuNVyPRtLSJtluM9c99l/IiQxCf/ZfAqfJZ/CnjN5OJHtWDPLlu7JMjh+JboTNrw0sNbrChERkbTqNJgkJyfH5LR5MTNXV64sXUfmnD3kJndBEzNNna8PhdwFmxMG43+7zmL5gfPi+U83nzRIt+GlgRi9cCdWPnM3+rZtZu1imlWRptzonExm3PHVxEOBArYCERHZnDr92tqyZUukp6dXef3o0aMIDKzdrue2zB4HS6tvaFGm0yOkmYek5WjfwhPxwzpUm2b0wopxZJO+3of1f13G2StF+G5PFgRBEAPD/+3KREhiEkrKjAMNe7TkCfv5LBEROZM6tQiNGTMG77zzDkaPHg13d3eDa6WlpZg1axbuuecesxZQCnFxcYiLi4NarYaPj49F72Wu9qCC4orWhuCm0gZCANCySSNkzRuL6ze06Db7z2rTPv9TKoKbNsL5/FLM+u0YosP88WdGjnj9tVVHoSkrw7imwLWSMrTwqbnFS6cXbG6l59Ym/l3il6XiiwZsh0JERA1Xpxaht99+G/n5+ejYsSM+/vhjrFu3DuvWrcNHH32ETp06IT8/H2+99ZalykrVKNPpAFQEIbbCy12BI7OisTtxWLXpzueXiq9vD4IAIOmvy9h5Og8AMPDjrcguvFFtXr8cuoChn2yDXi+Ie69Zyg2tzuD4rTF3VZHS9LYnv3PvNiIiydWpRcjf3x979uzBc889hxkzZojdGDKZDKNGjYJKpYK/v79FCkrVu6HVw8NNDqVr9bOVrM2nkQI+jRQ4/t5ojFftxvEGDpa+/6s9GN01AK4uMswwEXgs2HQSFwtKkX6pEPd+sRsAjFbFNpfO72wwOH6if0iVab3cFUh6cQAe+GovSu8IoIiISDp1XnmvTZs2WL9+Pa5du4bTp09DEAR06NABvr6+liifwzPXWOn/O3oJJWU6BPi415xYAu4KOTa8NAgA8PDX+7D37FXERrXBd3v/MUrb1q8xkl8ZDK1OgEIuw497zgJ5FWPTLhaUios2/nfHWQCAn6cSY7sFQABwqbCidakyCAKAq0UaNPNUWvLxANS8A32XIB+b67IjInJ29V6C2NfX164GEzuL5l6W/8JvqOXP3C2+nnNfV/F1Zl4xgpq4i61abq4VQcNDfVpj/fqqB+nnFWlMBlSVYpccwBcP90KIX+OGFr3BTEwoIyIiCXGxExPscdaYRqs3OSDXnoT6Na62a2/n60PrlW/6RbW4J9rtix82REFJWb3e53JHJFRaxm4yIiIpMRAywR632NCU6+Ar4RpC1tCkkQKH3xmJNc/3a1A+eUWaBr0/9/oN9Hh3U73ee2fP2F0zNyCJg6aJiCTDQMhBLD9wHkcuFEpdDIuSyWTwbeyGnq1vjUeb0LMlHu7TGkBFt6CqFtPR67uwYUlZOU7nFkGnr3/4+oKJNZY2ZWTXOz8iImoYy2xTTmQln07qAQB4ol8IOgV4AQC6txqKgR9vhdxFZjJo2ZSRg/YtPOt8r74fJOO6prxBLVJPDgjFu79nGJzbeCynitRERGRpbBGSmLm22PDzVCJuaDuz5GUPFj8RgVnjwsTjyiAIqFhUMmveWJz5cIzJ96ZfrF/L2fWb22lM+HJPvd5fac8d6yqVanW4WFCKtPMFZt1yhYiIasZAyEG4K1wgg/NMSRrW2R9T+ofWmC5r3lhkzRuLsEBv8VzSX5cRkpgE9Q0tjmersSkjB8Um9gyrrRkxnTGwg1+t0weZWPSy/7wtGK/ajW93Zta7HEREVHfsGnMQF66Vcmp2NQJ93JFxWW1wrvsd239sf20IWjf1gFZXsUVHcVk5PBRyuNawPtC0we0wbXDdWuOeGhAqrod0uwvXSuqUjzMRBMHkhrZERA3BQEhi5ugIqezqycwrNkNujmlK/1AM7OCHlr4e+CApA1lXjQOOwfO3Vfn+9+7rYtbyvHNPGJ4cEIr+87YYnJe7VARdlwtLEeDtzi9+AIWlWvR4909x8VFLrRRORM6JgZADyLpaEQB5uTv29PmGGNDBDwNudl+NDPOHTi/gYFY+tp24Ag83ORZsOlnt+99Zd8zk+Tn31j9AMrUvXMo/+Xjv9wz8b1cmEkZ2xIvDjWeZOQutTo9tJ65g6vcpBudDEpMwe1wYnqhF1ygRUU0YCJmgUqmgUqmg09nHYnctvCq21Xh6IL8YakvuIsPdbZvh7rbNAEAMOLafvILYxQfQtaU30i+qq8sCzw5uh0mRwWYt19ELhTh6cxmEXafznDoQGvDRFuSob635tOrZKPxr0V4AwOz/y0CXlj6IDGkqVfGIyEEwEDIhLi4OcXFxUKvV8PHxsezNzNA3Vq6r2GVd4cKx7w01uGNzg64XrU6P9IuFKNcLkAH4cd8/+FdEMCJCfC2+we2BzHz0n7cFu++YZeYsbg+Cjr83Gu4KOTYnDMIE1R5c15QjdvEBZLw7WsISEpEj4DenAyi/uVaOXM7xJOamkLugZ2tfRIY0RURIUyx8qCf6t/czaxDUopr94S4WlOKez3di9+k8s93P1h29UCBuhfJEvxCceL8iCAKA9i28sPHlis17S8p0OHzummTlJCLHwEDIAVQuGqjgzuZ257sn+2BNXP9q06RfVOORb/cjJDEJPd/9E+vSLlqpdNI49M+t4ObBiGCjoDOoSSOxlWzCl3tQVq63avmIyLEwEJKYYIa+sT9vbtEgZyBkdwZ3bI6WTRoha95YHHhzOL6Y3BOPR7WpMv21Ei2mr0jDBFXDFnW0VWXlesz5v4qVtz++vzvCgrxNpmvZpBE+ur8bAOA8lxwgogbgGCEHsPzAeQBA08ZuEpeEGqKFtzvu6R6Ee7oH4bkh7ZBdeAN3BXrjp/3n8N4d23KcunIdCAW6zt6IKQPao7C0DG+OucvuZw5O+nqv+PpfEa2qTdslqGL83vB/b+eUeiKqNwZCDmBgBz+cyS3imjMOJNCnEQJ9KqbXPzUgFP+KaIWL10oR85+dRmkXbT8D4FZAfLsgH3dM7NUKX2w9DQCY/0B39AltijbNGluw9PWz9vBFHD5XAAB4bVSnGj/PXW5rLdpzJg+RrS08sYGIHBIDIYmZY2spDzc5Ovh71ZyQ7Ja3uwLegQqx5eNwVh7OHdld4/suFd4QgyAAeG31UfH1muf7oWdrX/MXth4uFpTipZVpAIAXhrVH3ND2Nb5HJpPh0btb48d95/DsD4dw6C3nnF1HRA3DMUIOQKcHXDk+yKl0bVnR+vHyiI6o/Kf3Utbt95oJX+5BSGISEm4GIFK6fYXtV6I71fp9j0eFAADUN+q/VxwROTe2CDkAnV5f435Y5JieGhCKZ4d2NDqv0wtwkQFvrvkLyw+cx91tm2LxE5EY+9kuo61Yfj18Eb8evoh7w4Pw25FL+OW5KPRuY52FCsvK9ej49h/i8YG3htfp/R39veCucMENrR4/7vsHXF6RiOrKKb49J0yYAF9fXzzwwANSF8WIObrGdAJbhMiQ3EUGmUyGuRO7I2veWKx4Jgoebq7Y+uoQZM4dg5S3Rxi957cjlwAA93+1Fz8fPI9c9Q2LlvGXQxcMgqBXRnYUV0mvi3u6BwEAvtl51mxlIyLn4RSB0PTp0/H9999LXQyL0en1cGEgRLUkk8ng56lE1ryxWPZ0X/QxsU3F678cRZ8Pk7Hj5BUs238O93y+Eze09d9yZuuJXKw9fBGlZTqczr2OV1cdwSurjojX984YhhfquZ3IJ/8KBwBcLS6rd/mIyHk5RdfYkCFDsG3bNqmLYTEFJVr4eVa9OjFRVfq190O/9n74/eglxC87bHT98cUHxNd/XSzEiezrSDp6Gf97IgLXb5SjhZdSnN316aaTOPTPNey6YxXskWH+2JSRAwAIaeaBrKuG6/5EtPEVZ8jV18ReLZF05EKD8iAi52TzgdCOHTswf/58HDp0CJcvX8aaNWswfvx4gzQqlQrz589HdnY2wsPD8fnnn6NPnz7SFLiOzLGg4tWiMnRvZfP/lGTDKtcv0usF/JxyHl9sPY0L10oN0lRueAoAYTM3iq87+nviZE5RlXlXBkEAjIIgoGKqfEO9P76rGAgJ5uhvJiKnYfNdY8XFxQgPD4dKpTJ5feXKlUhISMCsWbOQmpqK8PBwjBo1Crm5uVYuqXTK9Xq0bFL3sRVEd3JxkeGhPq2x641h2PXGUOx6Yygy546p9j3VBUHV+fX5fjj+3mj0bdusXu+/nYebK/xvji968ruDDc6PiJyHzTcjxMTEICYmpsrrCxYswNSpUzFlyhQAwKJFi5CUlITFixcjMTGxTvfSaDTQaG7teK1WqwEAWq0WWq22HqWvmiv0UMoFuEIv5n3n37V1Q1OGRq51f5+9qG+9ODJr1Im/Z8Uq1eXl5Qht6o5LhaWQyaoe4D+xZ0u8e19XrP/rMr7Yehprn++PbSevIOHnNKyYejeuXNdA7gI8v+wwvnqkF7oFegLQQ6s1z15hPz0ZgdS923H0XD7Kysq4wCj4s2MK68SYI9ZJXZ5FJthRO7JMJjPoGisrK4OHhwdWr15t0F0WGxuLgoICrFu3Tjy3bds2fPHFF1i9enWV+c+ePRtz5swxOr9s2TJ4eHiY7TmIiIjIckpKSjB58mQUFhbC29v0noWVbL5FqDp5eXnQ6XTw9/c3OO/v74/jx4+LxyNGjMCRI0dQXFyMVq1aYdWqVYiKijLKb8aMGUhISBCP1Wo1goODER0dXWNF1tWLyw9jy4lcDO/UAv95uCeAigh206ZNGDlyJBSK2u0ZNWrhDlwsKMV/H+2N/u39zFpGW1GfenF0rBNjlXXyTooLNHoZ0mePkrpIkuPnxBjrxJgj1kllj05t2HUgVFubN2+uVTqlUgml0nj2lUKhMPuHoxwu0OhkKIeLUd51ud/ZqzcAyODmZv4y2hpL/DvYO9aJMY1eBo1OhjNXS9E5wLy/wNgrfk6MsU6MOVKd1OU5bH6wdHX8/Pwgl8uRk5NjcD4nJwcBAQH1zlelUiEsLAyRkZENLWKNzNUv6cLxEEQGRi/cicPnrkldDCKycXYdCLm5uaF3795ITk4Wz+n1eiQnJ5vs+qqtuLg4ZGRk4OBB+5l90tjNKRr3iGo0/4Fw8XXlatlERFWx+UCoqKgIaWlpSEtLAwBkZmYiLS0N586dAwAkJCTgm2++wXfffYe///4bzz33HIqLi8VZZPVhzRYhc/FQyqUuApFNiOl6qzV4ye4sFGu4ISsRVc3mA6GUlBT07NkTPXtWDChOSEhAz549MXPmTADApEmT8Mknn2DmzJno0aMH0tLSsGHDBqMB1HVhzRahnAbu59Q5wAsA4NeYK0sTVfrs5gQEABg8f5t0BSEim2fz/SlDhgypcaXY+Ph4xMfHW6lE5qXVNWyUUO82vnCVy+Dj4RgD3IjM4d7wIHi7u+KJJQeRV6RBXpGG29AQkUk23yIkBWt2jTV0iLNeAOQcKE1kpJXvrf3LFmw6KWFJiMiWMRAywZpdYw2dNabXC1xBl8iE9i284KmsaPRetv8c7v1il8QlIiJbxEBIYg1d2FsnCJC7MBAiMuXAW8PF10cvFEpYEiKyVQyE7FxhqRaMg4hM83BzNZhFFpKYJGFpiMgWMRAywaoLKjagQWjr8VxsysjBwSwuGkdUlQ8ndDM4Tv47p4qUROSMGAiZYN0xQvWPhKYstZ8FH4mk4tvYDZteHiQev/HLUQlLQ0S2hoGQxBo4RIiIaqGDv5fYMpRXVIaQxCScuVIkcamIyBYwEJIY4yAi65jQs6XB8fB/b0dZuV6i0hCRrWAgZIJ1xwgxFCKyhkZucqTPGWVw7voNrUSlISJbwUDIBHtaR4iIas9T6Yrnh7QTj3u/vxm51xu2zQ0R2TcGQkTkVBJGdkTLJrdWnR7w0VYJS0NEUmMgJDU2CRFZlavcBbsTh4nHZeV6JKxMk65ARCQpBkISM0cctOjR3mbIhci53N22qfj618MX8duRS9CU6yQsERFJgYGQCRwsTeT43h4bZrAj/YvLD2Nd2iUUa8pxQ1v3gCjtfAEEQUBhqRbZhRx3RGQvGAiZYG+DpRsr5WbIhci5dG3pg5S3Rxice331UXSZtRHTfjhUp7wuFpRivGo3Qmesx9TvU3D33GRzFpWILIiBkMTM0SDk7+3e8EyInNTDfVobndt+8gpSsvJx4VqJwXmdXkCO+gaS/87BT/v/Ec/3n7dFfH0gMx8A8PjiA7hWXGahUhORubhKXQBn15AtNiop5IxnierrwwldMXVgKLwbKRDx/mbx/AOL9oqvz344BuO+2IVjl9QG703+OxdbjueazHfHySvo+d4mLHq0F0Z3DbRM4YmowfgNKrGGtAjJb247r9NznBFRfclkMrRt7gk/TyVeGNbeZJq2b643CoIAVBkE3e7ZH1MRkpgEPX9OiWwSAyGJNSQQur9XSwR4u6N9C0/zFYjIib0S3QmvjerUoDw2vDTQ5Plvdp5FSlY+zueXmLxORNJg15gd0+oENPN0k7oYRA7l2cHtMH/jiVqn7xzghbvbNsPzQ9qhSFOOts09seGlgfg19SK+3nFWTDf3j+MG78uaN9ZsZSai+mMgZIJKpYJKpYJOZ/k1RRoyfb5cL8DbXWHG0hCR3EWGrHljcfjcNUz4cg+m9A/Bkt1ZAICx3QPR1q8xftz3D7a8MgS+jQ1/EWlx8+/OAd54c4y3QSBEtq2wRIszeUUI8HbHxC/3IFt9A++P74qzV4oxc1yY1MUjC2IgZEJcXBzi4uKgVqvh4+Nj0Xs1ZNSAXi+I44SIyLzCWzXBifdHQ+kqh5urC+7v1Qod/b0gCAKmD+8A11pMUvj9hQG45/NdJq/tP3sVfds2M3exqZ5e/+UINh7LMTj39tp0AMDi3ZmYPrwDHotqY7D2FDkGjhGSWEPGCOkYCBFZjIuLDErXijW6ZsTchY7+XgAqBlfXJggCKtYqSnpxAN4ee5fRtUlf78OFayW4odXh19QL+GHfP8jKKzbfA1CtXSwoNQqC7vSf5FN45Jv9VioRWRNbhCTWkOnzOoGBEJGt6xLkgy5BPlh+4BzOXDEMdAZ8tBXBTRvhfH6peK5pYzd8GxuBXq19rVbGcp0ernIXnM8vwcCPt2LJlEgM7dSi5jc6iM0Z1QdBlU7kXEdIYhJWPRuFyJCmNb+B7AIDIYk1pEVoU0YOWnixmZbIHqyN64+ycj1637ZWEQCDIAgA8ovLsOLAORRryrH/bD5ebcAstrJyfY1pLhaUov+8LQjwdke2umJrkD+PZYuB0EcbjkMQgMSYzvUuhy0TBAGzfjtWp/d8svEEVk6LslCJyNrYNSYxU3FQr3c3GZ1T39BiQ/plo/O51zUWKBURmZuXuwLNPJVQutb83+7PKRfw2P8O4Iutp9HrvU1Q39DW+X77z15Fv3nVb/UR91Mq4n5KBQAxCAKARoqK35E/3XQSX207g0Xbz2DN4Qt1LoMtKyvXIyUrH5tqaA36X2yE0bnD5wssVCqSAgMhiZVoysXXpWUVr8v0xr/FTV9+GM/+mFqvzSCJyHaceD8GnQO8ap0+v7gMn246CUEQoNML+H5vFkISk3DuasV6RFl5xfhx3z9GC6vuOHUFN0y0CAmCgG0nchGSmISkvy4jzcSX+uLdmQhJTMJ/kk+J515eeQSzfzuGXu9tQpGmHP/ZfApaXc0tTrbqbF4xHli0F89Usa/cwA5+OPH+aHiZmJlbVq43+Ysp2Sd2jUmsuEyHsnI93FxdsOzAeVS1EP+Fa6VVXCEie7Pq2SisPHge7yf9Xav0S3ZniVP4Kw2avxXzJnZD4q9/AQDGdguEb2M3aMp1+HZnJkrLbgUpG45lY+hdgXj+p1S0bNIIyw+cq1e5l+6pKMMj3+zDkQuFiAjxRf/2fgAqAiy9ULH8QLlOj2KNDp7urjY7jlEuq75czw1pB6WrHH1Cm+J/sRFo3dQDIz/dIV5/9sdUrgXlIBgI2QCtriIQKq/ityu9XsBVE5s3Bni7Y1JksKWLR0Rm5uWuwNMD22JCz5Zo5qlEWbkeHd/+o875VAZBABC3LBUf3d8d7gq5uCCksmLSG3adysP0lUdhrl0+jlwoBAA88u1+TBvcFneHNsMf6ZeRX1yGb2MjsWDTSXy57QyWT70bUe1sa4mAyrXbFmwyXjTzm8cjMLRTc2RdLTFYsX/4Xf4AgFC/xsi8bWbf9BWHsXBSD8hqCKrItrFrzASVSoWwsDBERkZa5X7lN/93qur/qNdWH0X+zUDo9sHVnDVGZN+a3VyTxs3VBaO7BDQorz1nrmLgx1sxeuEOo2tr0y5WGQS9PKJjg+773+1nMWXpQfyccgGb/87Fb0cuiYO0y01080tt+oo0AMDO03kG5z9+oDtGhvnDVe5S5bZF797XxeB4XdolDP1kmyWKSVbEQMiEuLg4ZGRk4ODBg1a5X2VLUFUzyH5JvTVI8fbp9lxQkchxqB7phWNzRiFz7hjsemMoegQ3qVc+plqPqzNtcFuMuNniAQDJrwzGvhnDMfOe+q2m/OLyw/h2VyYAYMfJKxAEAe+sTTc5FkkKW06Y3ij3wYiaW9cHdmiOUL/GBueyrnLvOHvHQEhCla2pt1qE6tZurRMEuLBJlsghyF1kaKx0hUwmQytfD/zyXD/8PC1KXIzRRQYMuDkexxxeHNYee2cMg7tCjvBWFSvoL34iAu2aeyLAxx1PDgjFBxO6iumXT70bwU0b1eke3+zMxH+ST+GHff9gvGq32cpeX1O/T2lwHiueuRv3hgcZnDv0z7UG50vSYSAkIYVLRfVra2gRup1B15hegCtbhIgcktxFhj6hTTGmW8UUitFdA/Dj033RoYUnOvp74tfn++G9O7pqauvNMZ3x8siOCPSpCGwejAzGveFB6N3GcJHAR/q2Qda8sTj9QQyi2jXDZw/1xH09gkxlWaWFm2/NPNtzJg83tDo8/V0KQhKTEJKYhKnfpxjNeLOUq0Wmlxtp5Vv7AM/f2x1v33MXbv+v9/6v9mBbFS1NZPsYCEmoiUfFtMyf9p9DSGISctU1rwlU+d+FTi/g+o1yuDAQInJojd0qZl6N614RgGxKGIw/Xx6MXq198VhUCA6/M9LoPWvj+iNr3lj8q3cro2uzxoXhmUHtDAb4+nu747OHe8KnkelNnCu3FOnZ2hf/eagnsuaNNdhzK/mVwbV6lsnf7EfndzZg89+31u7ZlJGDqLnJ+P3opVrlUR/lOj1OZF9H6rkCk9d/fb5fnfJr4eWOs3MNZ4ypb5RXkZpsHQMhCXkqKybtfbXtDACIA6Ir/bT/H/xyyHARsy3HczHpv3txraQibXOuLE3k0Hw8FDjz4RjEdDO9uIZvYzfx9dIpkYgO8xfHF80aZ9hitODBcEzpH2qWcq2fPkB83aSRAn1CmyJ+aPt65ZV7XQPV1jNmKZcpqecKMMrEIHIA8PNUooWXe4Pv4SbnL6X2itPnbYi7m9zg+K016UZpZv92DPnFZdDcnJXhpeQ/IZGzu309myEm9gjzcnPFq0M7YmIv4xai+mrh5Y4Dbw5HmU6PZp5K/Hxzy4kvtp6uV35/X1ajSFOO9Ucv48Gby4LMXJeO7/f+gw0vDcSZ3GJEhvqihZe7uDdaVW6//teFQiT+etQozY9P9cU3u/7B5L6t61VeAFgyJRJTllRMqnlt1VFEtfOrslWNbBdbhGyI4rbfKKoafKe/OUiocnqqK38LIaIabHttCB7v18bs+bbwdkcrXw+Dc8ffGw0AeHrArZanysHYNek6ayNe/+UoVFtP47VVR/D93n8AAClZ1xC3LBXf7DiLq0UaRH6wGXvumP5e6bcjl9D/oy3QlOuQdPQyxn2xC2fv2OwWALzdFfj68QiTgWNtBd/27Nc15Qif82e98yLpMBCSUNmdCyjeNl7wyvUbqE7lAGtFNb8VEREBgFIhh9JVXnNCM3BXyLH9tSF46+ZsNwCI7RdSpzzmbzyBVbcNC3h7bUXr+Lq0S8hW38C1Ei2+2n4GeUUaTPxyN9YcvoBynR4rDpzDF1tOIUetQae3NyBuWWqV92jbvHGV12qrfQtPLmHiANivIqE79w3bcCwbA3pXvK5qBlnl+YNZ+QDAWWNEZHPaNKsIMt4f3xUHs/IxsVcrdG3pg+hPTY/Tqa3c6xrx/8Cdp/IQ8f5mABVjgF5eeaRBedfXqfdj0PbN9ZLcm8zD4ZsTfv/9d3Tq1AkdOnTAt99+K3VxDNzQGrYI3d5CVNVs0srl4U/nFgEAwuu56BoRkaU9encb/OehngCAjv6132i2Ovd8vsss+ZiLi4sMzW4bsB6SmCRhaag+HDoQKi8vR0JCArZs2YLDhw9j/vz5uHr1qtTFElU3vqeqxRUrz25IzwbArjEish8/PlWxDtLcid2QOXeMeP6rR3pZ5f4H3xqB3W8MNXu+W14ZYnBcUsap9PbEob9FDxw4gC5duqBly5bw9PRETEwM/vzTdgaz9W7tW+W1mhZXvFxY/RgiIiJbM6CDHzYlDMbDfVobrGN0+9IAlmrlbuKhQHMvJXwaudWcuI68GxmOMhm5YAd2nLxi9vuQZdh0ILRjxw6MGzcOQUFBkMlkWLt2rVEalUqFkJAQuLu7o2/fvjhw4IB47dKlS2jZsqV43LJlS1y8eNEaRa+zO4f6VBkHWWcBViIiSay7uRikuaXNjDZ7npXu3H3+YkEpXlqZZrH7kXnZdCBUXFyM8PBwqFQqk9dXrlyJhIQEzJo1C6mpqQgPD8eoUaOQm2t/S53fOSZIqM1+G0REdq4yhgj0cccLw24tyPjs4HZY/EQEBndsLp5bU8cVoCtVTum3pvziMmTmGU/bJ9tj07PGYmJiEBMTU+X1BQsWYOrUqZgyZQoAYNGiRUhKSsLixYuRmJiIoKAggxagixcvok+fPlXmp9FooNHc2uZCrVYDALRaLbRabUMfx4Ar9NBDwPKnIuDr4Yb7vtwNpUtF8KN0ESDodFDKjYMhNxfB4Ly5y2WLKp/RGZ61tlgnxlgnxmy9Tl4Z0Q4RbXyh1Wrx54v9oVS4iGV9ZUQ7AEBRaRn2nclFZIgvugZ64q93hiPiw83V5rv0iUg8sfSgeCyHHtqbk1MsVSem/r/+KOkYPp/c06z3sQRb/5zUR12eRSbYSdODTCbDmjVrMH78eABAWVkZPDw8sHr1avEcAMTGxqKgoADr1q1DeXk57rrrLmzbtg0+Pj7o3bs39uzZg2bNmpm8x+zZszFnzhyj88uWLYOHh4eJdxAREZGtKSkpweTJk1FYWAhvb+9q09p0i1B18vLyoNPp4O/vb3De398fx48fBwC4urri3//+N4YOHQq9Xo/XX3+9yiAIAGbMmIGEhATxWK1WIzg4GNHR0TVWZF29uPww9HoBX9ycLdF19kYoXQS8F6HHOykumH1fd8xY85fR+xor5Ci+bf2h9NmjzFouW6TVarFp0yaMHDkSCgWXrwdYJ6awTow5ap1M+u9eHLusxqx7umBs9wB4uFV8lb2wLBUKVxcseLBHle+1VJ088NVeHM9RG50/MjPa5hdddMTPSWWPTm3YbSBUW/feey/uvffeWqVVKpVQKpVQqVRQqVTQ6SoCDoVCYfYPRzlcoIcg5quHCzT6iqZbjV4GQSaHRmf8wyOXywzOO8qHtjYs8e9g71gnxlgnxhytTn6NH2Ty/OePRkIGVLsPWSVz18m6FyvK1OGt9dDqbnW0TP/5KP77WITZ7mNJjvQ5qctz2PRg6er4+flBLpcjJyfH4HxOTg4CAgIalHdcXBwyMjJw8ODBmhObyfThHQyOq+qvvL0j09vd4eNYIqJaU8hdahUEWZKXu+EX8MZjOVWkJFtht4GQm5sbevfujeTkZPGcXq9HcnIyoqKiJCxZ/TwWFWJwrK/F0C31DS7aRURkSxorrbOnG5mPTTcpFBUV4fTp0+JxZmYm0tLS0LRpU7Ru3RoJCQmIjY1FREQE+vTpg4ULF6K4uFicRVZfd3aNWcWdcU9VW2xwISEiIpvl6mLcvlBQUoYmHuZfyJHMw6YDoZSUFAwdems59MqBzLGxsVi6dCkmTZqEK1euYObMmcjOzkaPHj2wYcMGowHUdRUXF4e4uDio1Wr4+Pg0KK/aUioMf3iq3GKDcRARkc0yNTD6pZVpWDql6qVbSFo2HQgNGTKkxoUF4+PjER8fb6USWY67Qo5GrnIAFa1QVW26SkREtqtZYzecvuPcthNXcDArH5EhTSUpE1XPbscIWZJKpUJYWBgiIyOtet/bf5FYfuCcyTSMj4iIbNfKaVEICzRebmXNYdvc3okYCJkkxawxAHC5LRI6eqHQqvcmIiLz0Jlo0l+2/xxCEpPw+OIDJt5BUmIgZEP6tferORGbhIiIbNqscWGYFBFs8tqOk1eQe/2GlUtE1WEgZIJUXWPzJnarMU2ZTm+FkhARUX31a++Hjx7ojrvbmh4TdOxS7Vc9JstjIGSCVF1jijouBPbLc/XbiZmIiCxvxTNR8HAzXleo6EY5Ri/cgT/+uixBqehODITsWO82vlIXgYiIqvH++K5G515YfhjHs6/jg/V/S1AiuhMDISIiIgsJ8Hav8tqFa6XIzCu2YmnIFAZCREREFlLTJJhh/96G/24/g9IyK+5kQAYYCJkg1WDpSrteH1pzIiIisgu+HlXvhC4IwNw/juPbnWetWCK6HQMhE6QaLF2Je9IQETmOVc/2w/29WlWb5kqRxkqloTsxECIiIrKg9i088e8Hw6tN8/3ef3DmSpGVSkS3YyBko4Z0ai6+DmnmIWFJiIjIGnLUXGhRCgyEbNTXj0WIr0d1DcCscWEG10eG+Vu7SEREZEGuLvxKlgJr3QSpB0sDgJuri7gQV+LoznBXVLy+vaWIiIgch/z2nbfJahgImSD1YOlKeqFiYzGZ7NYPRyd/L6mKQ0REFnT/V3sAAFqdHiGJSQhJTJK4RM7BVeoCUNX8PJW4cK0UANDcUwkAaOZZMaNM4OarRER2q61fY5w1sZjitzvPQqvjf/DWxEDIhr055i6sPHgeADAizB9r4/rDy90VH64/LnHJiIioIba8OgTqG1p0n/2nwfn3k7jthrUxELJhY7oFYky3QPG4R3ATnOX0SiIiu7TgwXDoBWDkXRWTXbzdq15osdLs344huos/wgK98cwPh9C9pQ/yijSYd393cewoNQwDISIiIiuYWMOiiqYs3ZOFpXuysPKZu3EgMx8HMvMBAOfyS/Dr8/3NXUSnxMHSJtjCrLGasQ+ZiMjePTu4Xa3S/XeH4RYcqecKTKYTBAF6vQCBA0lrjYGQCbYya4yIiBxbYkznWqXbcjy3Vuk++fME2r65HnvPXDU4X67TAwDSzhdg2g8p0OkZKFViIGRnbp9KT0REzuv7vVlG5+Q3vyN0t7UI/bDvH4z+z04AFWOONh7LwXjVbmw9UbvgytExECIiIpJQ+xae6BHcpM7vm7nuGErLdOLxuasl+GzLaQAwaPGZu/5vnM6tmGiTeXPK/l8XC/Hl1tNYvCsTXWdvbEDpTVNtPY2us8yfryVwsLSdYvcvEZFj2JwwGHvPXMXD3+yr83vvmrkBE3q2xLjwQDy5NEU8XxkIZVxSo+RmsHStuAyFpVoxzcGsaziYdQ3KGiaf6fQCTuZcx12B3lWmOXapEGM/2wUAGHFXC2z+u+bWpqy8Ygz5ZBs+e7gn7g0PqjG9pbBFiIiISGLejerfLrHm8EWDIAioCF5CEpMw5rOd4rnisvIa8wpJTMKba/6CIAg4fO4aAGDmunTE/GcnbmhvtT61nZGEnu9WrIH0c8p5MQgCYBQEhSQmYbxqt9G98oo0AICj5wtqLJclMRAiIiKSmIdbRSA0oWdLZM0bi8y5YxqUn4uJ8aQ19SRUtiIt238OP+4/hwlf7kH6xUIc+qciINLfloFeAK6VVLQunbtaUmN50s4X4K8LhcjKKxZbpR5YtLeirBLvscZAyM5wqDQRkePR6StmdVUGMA2dGPP09ylG5wZ+vLXa90z4co/4+sK1iuDmns93iQFS2EzTY36EWi7nMu6LXRjyyTY88NUeg/NSzwFiIERERCSxm7PbIb/tW3lCz5ZWLcPZPNM7F1wtLhNfhyQmiYs6VlJtPVNlnqY2jj2VW2RwXibxr/gMhEywhwUVOVaaiMhxVLa6yG/rJhpxcysOSdz2JZN/WyAEAA/+d6/4+t3/y2jwrSTuGWMgZAoXVCQiImvycq8YI9Qz2Fc8N7Z7IAJ93KUqUq0s3p3Z4DxMjWeyJgZCdkbqvlQiIjK/4KYeyJo3Fg9GBhuc3/DSIIlKZD21mc1mSQyEiIiIbJRPIwWaeymtft879zazpGINAyGqB26oR0TkHDr6e0pdBIfGQIiIiMiG3ZxZL2rsVsNS0FQnDITsjNTTDImIyLr0d/QANHLj7ljmxECIiIjIht05EkLuAnx8f3cAFWOI7J1e4pEeDITsFEcIERE5h2F3tTA4lstkUCoqvr5fHN6hTnkFeNvedPxynb7mRBbEQIiIiMiGPTu4HbLmjUXWvLEAALlcJm7BUdeJMz8+3dfs5WuocombhJwiEJowYQJ8fX3xwAMPSF0UIiKiepvSPwQf3d9dXI25qjiorV9jk+cb2eBA6+CmHpLe3ykCoenTp+P777+XuhhmwQUViYic16xxXdCvnZ84caaqDU+3vDqk3vfw97beukXe7q6Sj3NyikBoyJAh8PLykroYZsVlhIiInFflL8WW6FV6bnA7s+YX3sqnymtyF5nRrDhrkzwQ2rFjB8aNG4egoCDIZDKsXbvWKI1KpUJISAjc3d3Rt29fHDhwwPoFJSIishE1dY01RGhz0ws4BjdtVK/8vnk8osprLjKZ5L/YSx4IFRcXIzw8HCqVyuT1lStXIiEhAbNmzUJqairCw8MxatQo5Obmiml69OiBrl27Gv25dOmStR6DiIjIikx3jfUNbYr/PtYbALDz9aF4e+xdBtdbVLNdRyvfRkh+ZXCVA7D7tfWrdenaNr81Rsm7mq4vmUwGvcSDpSVflSkmJgYxMTFVXl+wYAGmTp2KKVOmAAAWLVqEpKQkLF68GImJiQCAtLQ0s5RFo9FAo9GIx2q1GgCg1Wqh1WrNco9KrtBDD8Eg38rX1d1LV14OpVyAq0xv9jLZqtrUi7NhnRhjnRhjnRhzmDoRKr4LoNdV/H3TY32DMaxjM2i1WgR4KdC2mbvB9TvTA4DSpeL4/56PgkKhwLkraqM0AOChgMnzpozr2gKLbu5XVvm9ZYpCpoemrMzs/x51yU8m2NCmVTKZDGvWrMH48eMBAGVlZfDw8MDq1avFcwAQGxuLgoICrFu3rtZ5b9u2DV988QVWr15dZZrZs2djzpw5RueXLVsGDw9pR7UTERFR7ZSUlGDy5MkoLCyEt7d3tWklbxGqTl5eHnQ6Hfz9/Q3O+/v74/jx47XOZ8SIEThy5AiKi4vRqlUrrFq1ClFRUUbpZsyYgYSEBPFYrVYjODgY0dHRNVZkXb24/DD0egFfPNJLPKfVarFp0yaMHDkSCoXppsSL10ox6j870L+9H/77aG+zlslW1aZenA3rxBjrxBjrxJij1snSPZn45M+T+PTBHhgZdus7c9epK3j2p1Q8P6Qdnh/SHgDQdfZG8fqO14Zi5L+34L0IvVgnO09dwXM33/PsoHbo/u6fAIBH+7bBj/v/MbjvPd0C8ftfl8Vjfy935Fy/gZ2vD8XAj7ciLNAbP0+LQo76BoYv2G5U7vBWPmjf3Atz7uti1vqo7NGpDZsOhMxl8+bNtUqnVCqhVBr3nyoUCrP/wJTDBXoIJvOt7n5yVy00OhnKBReH+iGuDUv8O9g71okx1okx1okxR6sTPeTQ6GRwkcsNnsvFVQGNTgY9bp33aqREXlEZAKCRuxs0+orxRpV1IpO7QqOTQZBVvEejuzkeSSaHq9wVxWU6Mf+Wzbyg0WWLx91aN8W5o5ehVLjdvG/Fd1UjpV7MBwC8lK5wc3WBVnCBDub/PqtLfpIPlq6On58f5HI5cnJyDM7n5OQgICDAYvdVqVQICwtDZGSkxe5RX1xHiIiI7nRrjIvhl4Spr4yUt0eKr73dFUifPaqqzAy4yIBj7442OPfSHVt8zBoXho0vDYK7W0V44XJzelszTyVS3h4hpkt+ZTA2vjzI9I2szKYDITc3N/Tu3RvJycniOb1ej+TkZJNdW+YSFxeHjIwMHDx40GL3aCgbGtpFREQSq/xKqOqX5bp8Y1TORJPdGVSZyLsy0KmkcHFBp4Bb6/bJb3uTn+etHpcW3u4Gx1KSvGusqKgIp0+fFo8zMzORlpaGpk2bonXr1khISEBsbCwiIiLQp08fLFy4EMXFxeIsMktQqVRQqVTQ6XQ1JyYiIrIRd8Yq7Vt4ormXEkM7NTc4/3hUG4Q0M70NR4cWXmjupcSQO97jckck9KyJhRcrt/CoDMzufI8tkjwQSklJwdChQ8XjysHKsbGxWLp0KSZNmoQrV65g5syZyM7ORo8ePbBhwwajAdTmFBcXh7i4OKjVavj4VL0iJhERkS2oaquNoCaNsG/GcMjvaLl5976uVeYV3NRDfI/BGj93xDRvjO4EAGikkKNUq8OZD8eI9xEDIZvud6ogeSA0ZMiQGrt54uPjER8fb6USERER2ZdbXWPGLTB3BkG1Yeo9d7bu3Hmv299TuW1Gfe5tbXYQq1mfbQ+Wtv0PFRERScOS3xDRYaZ7Yl6J7oiWTQy331DIXRAW6I0p/UINzj/cJxjPDTHvXmYNJXmLkC1i1xgREdmTyp4VS/2u3LN1E/Rs7Wvy2tMD2+LxqBCDc26uLlg/faBR2rkTu1uieA3CFiEiIiI7V9OssXrne/PvmgY9u7nabzhhvyUnIiIiAIC7omK2lkJu3q/1ypYmb3fH7UBy3CdrAFuePl8Zk3MZISIiqjR1UFtMHdTW7Pm6yl2QNW+swbk7j+0dW4RMsIcFFYmIiKjhGAgRERGR02IgRERERE6LgZAJtr2OUMXfVa0iSkRERLXHQMgEjhEiIiJyDgyEiIiIyGkxECIiIiKnxUDITnEdISIiooZjIGSCTQ+WtuiWekRERM6FgZAJHCxNRETkHBgIERERkdNiIGSnOEaIiIio4RgI2RkZhwgRERGZDQMhIiIicloMhIiIiMhpuUpdAFukUqmgUqlQXl4OAFCr1Wa/R1lpEfR6wSBvrVaLkpISqNVqKBQKk++7rr4BvaYEZaVKi5TLFtWmXpwN68QY68QY68QY68SYlHWiLS2GpkRm9u+zyvyEWgyolQm1SeWkLly4gODgYKmLQURERPVw/vx5tGrVqto0DISqodfrcenSJXh5eUFmhVHKarUawcHBOH/+PLy9vS1+P3vBejHGOjHGOjHGOjHGOjHmiHUiCAKuX7+OoKAguLhUPwqIXWPVcHFxqTGStARvb2+H+TCaE+vFGOvEGOvEGOvEGOvEmKPViY+PT63ScbA0EREROS0GQkREROS0GAjZEKVSiVmzZkGpVEpdFJvCejHGOjHGOjHGOjHGOjHm7HXCwdJERETktNgiRERERE6LgRARERE5LQZCRERE5LQYCBEREZHTYiBkQ1QqFUJCQuDu7o6+ffviwIEDUhfJImbPng2ZTGbwp3PnzuL1GzduIC4uDs2aNYOnpyfuv/9+5OTkGORx7tw5jB07Fh4eHmjRogVee+01cW84e7Fjxw6MGzcOQUFBkMlkWLt2rcF1QRAwc+ZMBAYGolGjRhgxYgROnTplkCY/Px+PPPIIvL290aRJEzz11FMoKioySHP06FEMHDgQ7u7uCA4Oxscff2zpR6u3murkiSeeMPrsjB492iCNI9XJ3LlzERkZCS8vL7Ro0QLjx4/HiRMnDNKY6+dl27Zt6NWrF5RKJdq3b4+lS5da+vHqrTb1MmTIEKPPyrPPPmuQxpHq5auvvkL37t3FRRGjoqLwxx9/iNed8XNSawLZhBUrVghubm7C4sWLhWPHjglTp04VmjRpIuTk5EhdNLObNWuW0KVLF+Hy5cvinytXrojXn332WSE4OFhITk4WUlJShLvvvlvo16+feL28vFzo2rWrMGLECOHw4cPC+vXrBT8/P2HGjBlSPE69rV+/XnjrrbeEX3/9VQAgrFmzxuD6vHnzBB8fH2Ht2rXCkSNHhHvvvVcIDQ0VSktLxTSjR48WwsPDhX379gk7d+4U2rdvLzz88MPi9cLCQsHf31945JFHhPT0dGH58uVCo0aNhP/+97/Wesw6qalOYmNjhdGjRxt8dvLz8w3SOFKdjBo1SliyZImQnp4upKWlCWPGjBFat24tFBUViWnM8fNy9uxZwcPDQ0hISBAyMjKEzz//XJDL5cKGDRus+ry1VZt6GTx4sDB16lSDz0phYaF43dHq5bfffhOSkpKEkydPCidOnBDefPNNQaFQCOnp6YIgOOfnpLYYCNmIPn36CHFxceKxTqcTgoKChLlz50pYKsuYNWuWEB4ebvJaQUGBoFAohFWrVonn/v77bwGAsHfvXkEQKr4sXVxchOzsbDHNV199JXh7ewsajcaiZbeUO7/09Xq9EBAQIMyfP188V1BQICiVSmH58uWCIAhCRkaGAEA4ePCgmOaPP/4QZDKZcPHiRUEQBOHLL78UfH19DerljTfeEDp16mThJ2q4qgKh++67r8r3OHqd5ObmCgCE7du3C4Jgvp+X119/XejSpYvBvSZNmiSMGjXK0o9kFnfWiyBUBELTp0+v8j3OUC++vr7Ct99+y89JDdg1ZgPKyspw6NAhjBgxQjzn4uKCESNGYO/evRKWzHJOnTqFoKAgtG3bFo888gjOnTsHADh06BC0Wq1BXXTu3BmtW7cW62Lv3r3o1q0b/P39xTSjRo2CWq3GsWPHrPsgFpKZmYns7GyDevDx8UHfvn0N6qFJkyaIiIgQ04wYMQIuLi7Yv3+/mGbQoEFwc3MT04waNQonTpzAtWvXrPQ05rVt2za0aNECnTp1wnPPPYerV6+K1xy9TgoLCwEATZs2BWC+n5e9e/ca5FGZxl7+/7mzXir99NNP8PPzQ9euXTFjxgyUlJSI1xy5XnQ6HVasWIHi4mJERUXxc1IDbrpqA/Ly8qDT6Qw+gADg7++P48ePS1Qqy+nbty+WLl2KTp064fLly5gzZw4GDhyI9PR0ZGdnw83NDU2aNDF4j7+/P7KzswEA2dnZJuuq8pojqHwOU895ez20aNHC4LqrqyuaNm1qkCY0NNQoj8prvr6+Fim/pYwePRoTJ05EaGgozpw5gzfffBMxMTHYu3cv5HK5Q9eJXq/HSy+9hP79+6Nr164AYLafl6rSqNVqlJaWolGjRpZ4JLMwVS8AMHnyZLRp0wZBQUE4evQo3njjDZw4cQK//vorAMesl7/++gtRUVG4ceMGPD09sWbNGoSFhSEtLc3pPyfVYSBEVhcTEyO+7t69O/r27Ys2bdrg559/ttsfJLKOhx56SHzdrVs3dO/eHe3atcO2bdswfPhwCUtmeXFxcUhPT8euXbukLopNqapennnmGfF1t27dEBgYiOHDh+PMmTNo166dtYtpFZ06dUJaWhoKCwuxevVqxMbGYvv27VIXy+axa8wG+Pn5QS6XG43gz8nJQUBAgESlsp4mTZqgY8eOOH36NAICAlBWVoaCggKDNLfXRUBAgMm6qrzmCCqfo7rPREBAAHJzcw2ul5eXIz8/32nqqm3btvDz88Pp06cBOG6dxMfH4/fff8fWrVvRqlUr8by5fl6qSuPt7W3Tv5xUVS+m9O3bFwAMPiuOVi9ubm5o3749evfujblz5yI8PBz/+c9/nP5zUhMGQjbAzc0NvXv3RnJysnhOr9cjOTkZUVFREpbMOoqKinDmzBkEBgaid+/eUCgUBnVx4sQJnDt3TqyLqKgo/PXXXwZfeJs2bYK3tzfCwsKsXn5LCA0NRUBAgEE9qNVq7N+/36AeCgoKcOjQITHNli1boNfrxf/0o6KisGPHDmi1WjHNpk2b0KlTJ5vtAqqLCxcu4OrVqwgMDATgeHUiCALi4+OxZs0abNmyxahLz1w/L1FRUQZ5VKax1f9/aqoXU9LS0gDA4LPiaPVyJ71eD41G47Sfk1qTerQ2VVixYoWgVCqFpUuXChkZGcIzzzwjNGnSxGAEv6N45ZVXhG3btgmZmZnC7t27hREjRgh+fn5Cbm6uIAgV0zxbt24tbNmyRUhJSRGioqKEqKgo8f2V0zyjo6OFtLQ0YcOGDULz5s3tbvr89evXhcOHDwuHDx8WAAgLFiwQDh8+LPzzzz+CIFRMn2/SpImwbt064ejRo8J9991ncvp8z549hf379wu7du0SOnToYDBVvKCgQPD39xcee+wxIT09XVixYoXg4eFhk1PFBaH6Orl+/brw6quvCnv37hUyMzOFzZs3C7169RI6dOgg3LhxQ8zDkerkueeeE3x8fIRt27YZTAMvKSkR05jj56VyWvRrr70m/P3334JKpbLpadE11cvp06eFd999V0hJSREyMzOFdevWCW3bthUGDRok5uFo9ZKYmChs375dyMzMFI4ePSokJiYKMplM+PPPPwVBcM7PSW0xELIhn3/+udC6dWvBzc1N6NOnj7Bv3z6pi2QRkyZNEgIDAwU3NzehZcuWwqRJk4TTp0+L10tLS4Xnn39e8PX1FTw8PIQJEyYIly9fNsgjKytLiImJERo1aiT4+fkJr7zyiqDVaq39KA2ydetWAYDRn9jYWEEQKqbQv/POO4K/v7+gVCqF4cOHCydOnDDI4+rVq8LDDz8seHp6Ct7e3sKUKVOE69evG6Q5cuSIMGDAAEGpVAotW7YU5s2bZ61HrLPq6qSkpESIjo4WmjdvLigUCqFNmzbC1KlTjX5ZcKQ6MVUXAIQlS5aIacz187J161ahR48egpubm9C2bVuDe9iamurl3LlzwqBBg4SmTZsKSqVSaN++vfDaa68ZrCMkCI5VL08++aTQpk0bwc3NTWjevLkwfPhwMQgSBOf8nNSWTBAEwXrtT0RERES2g2OEiIiIyGkxECIiIiKnxUCIiIiInBYDISIiInJaDISIiIjIaTEQIiIiIqfFQIiIiIicFgMhIqJauHr1Klq0aIGsrCwAwLZt2yCTyYz2bzK3xMREvPDCCxa9B5EzYyBERGb1xBNPQCaTGf0ZPXq01EVrkA8++AD33XcfQkJCGpxXTk4OFAoFVqxYYfL6U089hV69egEAXn31VXz33Xc4e/Zsg+9LRMYYCBGR2Y0ePRqXL182+LN8+XKL3rOsrMxieZeUlOB///sfnnrqKbPk5+/vj7Fjx2Lx4sVG14qLi/Hzzz+L9/Lz88OoUaPw1VdfmeXeRGSIgRARmZ1SqURAQIDBn9t3dpfJZPj2228xYcIEeHh4oEOHDvjtt98M8khPT0dMTAw8PT3h7++Pxx57DHl5eeL1IUOGID4+Hi+99JIYLADAb7/9hg4dOsDd3R1Dhw7Fd999J3ZhFRcXw9vbG6tXrza419q1a9G4cWNcv37d5POsX78eSqUSd999d5XPXFJSgpiYGPTv31/sLvv2229x1113wd3dHZ07d8aXX34ppn/qqaeQnJyMc+fOGeSzatUqlJeX45FHHhHPjRs3rsrWIyJqGAZCRCSJOXPm4MEHH8TRo0cxZswYPPLII8jPzwcAFBQUYNiwYejZsydSUlKwYcMG5OTk4MEHHzTI47vvvoObmxt2796NRYsWITMzEw888ADGjx+PI0eOYNq0aXjrrbfE9I0bN8ZDDz2EJUuWGOSzZMkSPPDAA/Dy8jJZ1p07d6J3795VPktBQQFGjhwJvV6PTZs2oUmTJvjpp58wc+ZMfPDBB/j777/x4Ycf4p133sF3330HABgzZgz8/f2xdOlSo7JMnDgRTZo0Ec/16dMHFy5cEMcnEZEZSb3rKxE5ltjYWEEulwuNGzc2+PPBBx+IaQAIb7/9tnhcVFQkABD++OMPQRAE4b333hOio6MN8j1//rwAQDhx4oQgCIIwePBgoWfPngZp3njjDaFr164G59566y0BgHDt2jVBEARh//79glwuFy5duiQIgiDk5OQIrq6uwrZt26p8pvvuu0948sknDc5t3bpVACD8/fffQvfu3YX7779f0Gg04vV27doJy5YtM3jPe++9J0RFRYnHiYmJQmhoqKDX6wVBEITTp08LMplM2Lx5s8H7CgsLBQDVlpGI6octQkRkdkOHDkVaWprBn2effdYgTffu3cXXjRs3hre3N3JzcwEAR44cwdatW+Hp6Sn+6dy5MwDgzJkz4vvubKU5ceIEIiMjDc716dPH6LhLly5iy8yPP/6INm3aYNCgQVU+T2lpKdzd3U1eGzlyJNq3b4+VK1fCzc0NQMU4nzNnzuCpp54yeIb333/foPxPPvkkMjMzsXXrVgAVrUEhISEYNmyYwT0aNWoEoKL7jYjMy1XqAhCR42ncuDHat29fbRqFQmFwLJPJoNfrAQBFRUUYN24cPvroI6P3BQYGGtynPp5++mmoVCokJiZiyZIlmDJlCmQyWZXp/fz8cO3aNZPXxo4di19++QUZGRno1q2bWH4A+Oabb9C3b1+D9HK5XHzdoUMHDBw4EEuWLMGQIUPw/fffY+rUqUZlqewybN68ed0floiqxUCIiGxOr1698MsvvyAkJASurrX/b6pTp05Yv369wbmDBw8apXv00Ufx+uuv47PPPkNGRgZiY2Orzbdnz5748ccfTV6bN28ePD09MXz4cGzbtg1hYWHw9/dHUFAQzp49azDo2ZSnnnoKzz33HO69915cvHgRTzzxhFGa9PR0KBQKdOnSpdq8iKju2DVGRGan0WiQnZ1t8Of2GV81iYuLQ35+Ph5++GEcPHgQZ86cwcaNGzFlyhTodLoq3zdt2jQcP34cb7zxBk6ePImff/5ZHIx8eyuLr68vJk6ciNdeew3R0dFo1apVteUZNWoUjh07VmWr0CeffIJHHnkEw4YNw/HjxwFUDAafO3cuPvvsM5w8eRJ//fUXlixZggULFhi891//+hcUCgWmTZuG6OhoBAcHG+W/c+dODBw4UOwiIyLzYSBERGa3YcMGBAYGGvwZMGBArd8fFBSE3bt3Q6fTITo6Gt26dcNLL72EJk2awMWl6v+2QkNDsXr1avz666/o3r07vvrqK3HWmFKpNEj71FNPoaysDE8++WSN5enWrRt69eqFn3/+uco0n376KR588EEMGzYMJ0+exNNPP41vv/0WS5YsQbdu3TB48GAsXboUoaGhBu/z8PDAQw89hGvXrlVZlhUrVmDq1Kk1lpOI6k4mCIIgdSGIiCzlgw8+wKJFi3D+/HmD8z/88ANefvllXLp0SRzkXJ2kpCS89tprSE9PrzYYM7c//vgDr7zyCo4ePVqnbkIiqh3+VBGRQ/nyyy8RGRmJZs2aYffu3Zg/fz7i4+PF6yUlJbh8+TLmzZuHadOm1SoIAioGRZ86dQoXL1402X1lKcXFxViyZAmDICILYYsQETmUl19+GStXrkR+fj5at26Nxx57DDNmzBADidmzZ+ODDz7AoEGDsG7dOnh6ekpcYiKSEgMhIiIiclocLE1EREROi4EQEREROS0GQkREROS0GAgRERGR02IgRERERE6LgRARERE5LQZCRERE5LQYCBEREZHTYiBERERETuv/Acx3OaxGLsB7AAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "test_cases = [\n",
+    "        [\"NaI\", co60, 1.0],\n",
+    "        [\"NaI\", cs137, 10.0],\n",
+    "        [\"NaI\", mn54, 0.01],\n",
+    "        [\"NaI\", na22, 10.0],\n",
+    "        [\"NaI\", na22, 0.1],\n",
+    "        [\"HPGe\", ba133, 1.0],\n",
+    "        [\"HPGe\", co60, 1.0],\n",
+    "        [\"HPGe\", cs137, 10.0],\n",
+    "        [\"HPGe\", mn54, 0.01],\n",
+    "        [\"HPGe\", na22, 10.0],\n",
+    "        [\"HPGe\", na22, 0.1],\n",
+    "    ]\n",
+    "\n",
+    "for detector_type, nuclide, signal_to_background_ratio in test_cases:\n",
+    "    print(f\"\\nTesting {detector_type} with {nuclide.name} at S/B={signal_to_background_ratio}\")\n",
+    "    test_get_peaks(detector_type, nuclide, signal_to_background_ratio)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "base",
+   "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.12.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/test/neutron_detection/test_compass.py b/test/neutron_detection/test_compass.py
index e46916f..ee8ea4b 100644
--- a/test/neutron_detection/test_compass.py
+++ b/test/neutron_detection/test_compass.py
@@ -7,11 +7,18 @@
     CheckSource,
     ActivationFoil,
     Reaction,
+    ba133,
+    cs137,
+    co60,
+    na22,
+    mn54,
 )
 from pathlib import Path
 import datetime
 import h5py
+import json
 
+this_file_path = Path(__file__).parent
 
 @pytest.mark.parametrize(
     "filename, expected_channel",
@@ -105,17 +112,24 @@ def test_sort_compass_files(tmpdir, base_name: str, expected_filenames: dict):
         ("no_waveforms", 535148093, 1237, -2, [5, 15], 5),
         ("waveforms", 80413091, 1727, 0, [4], 4),
         ("waveforms", 2850906749, 1539, 2, [4], 4),
-        ("waveforms", 14300873206559, 1700, 6, [4], 4)
+        ("waveforms", 14300873206559, 1700, 6, [4], 4),
     ],
 )
-def test_get_events(waveform_directory, expected_time, 
-                    expected_energy, expected_idx,
-                    expected_keys, test_ch):
+def test_get_events(
+    waveform_directory,
+    expected_time,
+    expected_energy,
+    expected_idx,
+    expected_keys,
+    test_ch,
+):
     """
     Test the get_events function from the compass module.
     Checks that specific time and energy values are returned for a given channel
     """
-    test_directory = Path(__file__).parent / "compass_test_data/events" / waveform_directory
+    test_directory = (
+        Path(__file__).parent / "compass_test_data/events" / waveform_directory
+    )
     times, energies = compass.get_events(test_directory)
     assert isinstance(times, dict)
     assert isinstance(energies, dict)
@@ -575,6 +589,7 @@ def test_check_source_detection_efficiency(expected_efficiency):
     # TEST
     assert np.isclose(computed_efficiency, expected_efficiency, rtol=1e-2)
 
+
 @pytest.mark.parametrize(
     "peak_energies, width, start_index, expected_peaks",
     [
@@ -602,12 +617,14 @@ def test_get_peaks(peak_energies, width, start_index, expected_peaks):
     overall_energy_events[0] = 1
     overall_energy_events[-1] = 3000
 
-    time_events = np.random.uniform(0, 100, size=int(nb_events_measured * (len(peak_energies) + 1)))
+    time_events = np.random.uniform(
+        0, 100, size=int(nb_events_measured * (len(peak_energies) + 1))
+    )
 
     test_nuclide = Nuclide(
         name="TestNuclide",
         energy=peak_energies,
-        intensity=[1.0]*len(peak_energies),
+        intensity=[1.0] * len(peak_energies),
         half_life=10000,
     )
     check_source = CheckSource(
@@ -623,11 +640,11 @@ def test_get_peaks(peak_energies, width, start_index, expected_peaks):
     detector = compass.Detector(channel_nb=channel_nb, nb_digitizer_bins=None)
     detector.events = np.column_stack((time_events, overall_energy_events))
     hist, bins = detector.get_energy_hist(bins=None)
-    
+
     peak_indices = measurement.get_peaks(hist, start_index=start_index)
 
     assert len(peak_indices) == len(expected_peaks)
-    assert np.allclose(expected_peaks - bins[peak_indices], 0, atol=2*width)
+    assert np.allclose(expected_peaks - bins[peak_indices], 0, atol=2 * width)
 
 
 @pytest.mark.parametrize(
@@ -707,7 +724,8 @@ def test_get_calibration_data(a, b):
     assert np.allclose(calibration_energies, real_energies, rtol=1e-2)
 
 
-def test_get_multipeak_area_single_peak():
+@pytest.mark.parametrize("summing_method", ["sum_gaussian", "sum_histogram"])
+def test_get_multipeak_area_single_peak(summing_method: str):
     """
     Test the get_multipeak_area function from the compass module.
     Checks that the area under the peaks is correctly computed.
@@ -723,14 +741,17 @@ def test_get_multipeak_area_single_peak():
     hist, bin_edges = np.histogram(energy_events, bins=np.arange(0, 3000))
 
     # RUN
-    areas = compass.get_multipeak_area(hist, bin_edges, peak_ergs=[energy])
+    areas = compass.get_multipeak_area(
+        hist, bin_edges, peak_ergs=[energy], summing_method=summing_method
+    )
 
     # TEST
     expected_area = np.sum(hist)
     assert np.isclose(areas[0], expected_area, rtol=1e-2)
 
 
-def test_get_multipeak_area_two_separated_peaks():
+@pytest.mark.parametrize("summing_method", ["sum_gaussian", "sum_histogram"])
+def test_get_multipeak_area_two_separated_peaks(summing_method: str):
     """
     Test the get_multipeak_area function from the compass module.
     Checks that the area under the peaks is correctly computed.
@@ -756,7 +777,9 @@ def test_get_multipeak_area_two_separated_peaks():
     hist, bin_edges = np.histogram(energy_events, bins=np.arange(0, 3000))
 
     # RUN
-    areas = compass.get_multipeak_area(hist, bin_edges, peak_ergs=[energy1, energy2])
+    areas = compass.get_multipeak_area(
+        hist, bin_edges, peak_ergs=[energy1, energy2], summing_method=summing_method
+    )
 
     # TEST
 
@@ -792,17 +815,36 @@ def test_get_multipeak_area_two_close_peaks():
     hist, bin_edges = np.histogram(energy_events, bins=np.arange(0, 3000))
 
     # RUN
-    areas = compass.get_multipeak_area(hist, bin_edges, peak_ergs=[energy1, energy2])
+    areas = compass.get_multipeak_area(
+        hist,
+        bin_edges,
+        peak_ergs=[energy1, energy2],
+        search_width=200,
+        summing_method="sum_gaussian",
+    )
 
     # TEST
     expected_area_peak_1 = nb_events_peak1
     expected_area_peak_2 = nb_events_peak2
     for i, expected_area in enumerate([expected_area_peak_1, expected_area_peak_2]):
+        print(
+            f"Peak {i+1}: Computed area = {areas[i]}, Expected area = {expected_area}"
+        )
         assert np.isclose(areas[i], expected_area, rtol=1e-2)
 
 
-@pytest.mark.parametrize("efficiency", [1e-2, 0.1, 0.5, 1.0])
-def test_get_gamma_emitted(efficiency: float):
+@pytest.mark.parametrize(
+    "efficiency, summing_method",
+    [
+        (1e-2, "sum_gaussian"),
+        (0.1, "sum_gaussian"),
+        (0.5, "sum_gaussian"),
+        (1.0, "sum_gaussian"),
+        (1e-2, "sum_histogram"),
+        (0.1, "sum_histogram"),
+    ],
+)
+def test_get_gamma_emitted(efficiency: float, summing_method: str):
     # BUILD
     nuclide_reactant = Nuclide(name="TestNuclide", atomic_mass=200)
     activated_nuclide = Nuclide(
@@ -854,6 +896,7 @@ def test_get_gamma_emitted(efficiency: float):
         calibration_coeffs=np.array([1.0, 0.0]),  # assume perfect calibration
         channel_nb=3,
         search_width=300,
+        summing_method=summing_method,
     )
     computed_value = gammas_emmitted[0]
 
@@ -1541,3 +1584,143 @@ def test_measurement_h5_spectrum_only_analysis_capability(tmpdir):
     assert loaded_detector.spectrum.dtype in [np.int32, np.int64, np.uint32, np.uint64]
     assert loaded_detector.bin_edges.dtype in [np.int32, np.int64, np.uint32, np.uint64]
     assert len(loaded_detector.bin_edges) == len(loaded_detector.spectrum) + 1
+
+
+def create_nuclide_spectrum(
+    nuclide: Nuclide,
+    signal_to_background_ratio: float,
+    peak_standard_deviation: float,
+    background_detector: compass.Detector,
+    background_divider: float = 1.0,
+):
+    # In case background has many events, scale it down to speed up test
+    background_hist = background_detector._spectrum / background_divider
+
+    total_counts_background = np.sum(background_hist)
+    desired_signal_counts = signal_to_background_ratio * total_counts_background
+
+    nuclide_events = np.zeros((0,))
+    for energy, intensity in zip(nuclide.energy, nuclide.intensity):
+        compton_fraction = 0.1  # ~10% of events go to Compton scattering
+        # Full energy peak
+        nuclide_events = np.append(
+            nuclide_events,
+            np.random.normal(
+                loc=energy,
+                scale=peak_standard_deviation,
+                size=int(desired_signal_counts * intensity * (1 - compton_fraction)),
+            ),
+        )
+
+        # Compton edge
+        compton_edge = energy * (1 - 1 / (1 + (2 * energy / 511)))
+        compton_events = int(desired_signal_counts * intensity * compton_fraction)
+
+        # Generate Compton events below the edge with a smooth falloff
+        # Using exponential distribution peaked near the edge
+        compton_samples = np.random.exponential(
+            scale=compton_edge / 3, size=compton_events
+        )
+        # Shift to be centered below the edge
+        compton_samples = compton_edge - np.abs(compton_samples)
+        compton_samples = compton_samples[
+            compton_samples > 0
+        ]  # Remove negative energies
+        nuclide_events = np.append(nuclide_events, compton_samples)
+    nuclide_hist, _ = np.histogram(
+        nuclide_events, bins=background_detector._calibrated_bin_edges
+    )
+
+    noise_level = 0.2
+    gaussian_noise = np.random.normal(
+        0, noise_level * np.sqrt(nuclide_hist), size=nuclide_hist.shape
+    )
+
+    overall_hist = nuclide_hist + background_hist + gaussian_noise
+    return overall_hist
+
+
+@pytest.mark.parametrize(
+    "detector_type, nuclide, signal_to_background_ratio",
+    [
+        ["NaI", co60, 1.0],
+        ["NaI", cs137, 10.0],
+        ["NaI", mn54, 0.01],
+        ["NaI", na22, 10.0],
+        ["NaI", na22, 0.1],
+        ["HPGe", ba133, 1.0],
+        ["HPGe", co60, 1.0],
+        ["HPGe", cs137, 10.0],
+        ["HPGe", mn54, 0.01],
+        ["HPGe", na22, 10.0],
+        ["HPGe", na22, 0.1],
+    ],
+)
+def test_get_peaks(detector_type, nuclide, signal_to_background_ratio):
+
+    # get real background measurement
+    background_measurements = compass.Measurement.from_h5(
+        this_file_path / "compass_test_data/background_measurement/background_measurements.h5"
+    )
+
+    # read in calibration coefficients from json
+    with open(
+        this_file_path / "compass_test_data/background_measurement/calibration_coefficients.json", "r"
+    ) as f:
+        calibration_coefficients = json.load(f)
+
+    if detector_type == "NaI":
+        coeffs = calibration_coefficients["NaI"]["4"]
+        peak_standard_deviation = 30.0  # keV
+        background_divider = 100.0
+        for background_measurement in background_measurements:
+            if background_measurement.name == "NaI Background":
+                background_detector = background_measurement.get_detector(4)
+                break
+    elif detector_type == "HPGe":
+        coeffs = calibration_coefficients["HPGe"]["0"]
+        peak_standard_deviation = 2.0  # keV
+        background_divider = 1.0
+        for background_measurement in background_measurements:
+            if background_measurement.name == "HPGe Background":
+                background_detector = background_measurement.get_detector(0)
+                break
+    else:
+        raise ValueError(f"Unknown detector type: {detector_type}")
+
+    background_detector._calibrated_bin_edges = np.polyval(
+        coeffs, background_detector._bin_edges
+    )
+
+    # Build simulated spectrum with nuclide peaks + background
+    overall_hist = create_nuclide_spectrum(
+        nuclide=nuclide,
+        signal_to_background_ratio=signal_to_background_ratio,
+        peak_standard_deviation=peak_standard_deviation,
+        background_detector=background_detector,
+        background_divider=background_divider,
+    )
+
+    # Create a check source measurement instance
+    check_source_detector = compass.Detector(channel_nb=0)
+    check_source_detector._spectrum = overall_hist
+    check_source_detector._bin_edges = background_detector._calibrated_bin_edges
+
+    check_source = CheckSource(nuclide=nuclide,
+                               activity_date=datetime.datetime(2024, 1, 1),
+                               activity=1.0)
+    
+    check_source_meas = compass.CheckSourceMeasurement('test')
+    check_source_meas.check_source = check_source
+    check_source_meas.detectors = [check_source_detector]
+    check_source_meas.detector_type = detector_type
+
+    test_peak_inds = check_source_meas.get_peaks(overall_hist)
+    test_peaks = background_detector._calibrated_bin_edges[
+        test_peak_inds
+    ]
+
+    assert len(test_peaks) == len(nuclide.energy)
+    for test_energy, expected_energy in zip(test_peaks, nuclide.energy):
+        print(f"Detected peak at {test_energy:.2f} keV, expected at {expected_energy} keV")
+        assert np.isclose(test_energy, expected_energy, rtol=0.05)