From 3c0fa9c1f52cd9ab6ed7ee1f806e294ba420aace Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Sun, 14 Jul 2024 23:15:56 +0200 Subject: [PATCH 01/94] Add halo_model param description to docstring --- wimprates/summary.py | 1 + 1 file changed, 1 insertion(+) diff --git a/wimprates/summary.py b/wimprates/summary.py index 2e35a12..e1387ae 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -32,6 +32,7 @@ def rate_wimp(es, mw, sigma_nucleon, interaction='SI', 'bremsstrahlung' for Bremsstrahlung photons 'migdal' for the Migdal effect :param m_med: Mediator mass. If not given, assumed very heavy. + :param halo_model: A class giving velocity distribution and dark matter density. :param t: A J2000.0 timestamp. If not given, conservative velocity distribution is used. :param progress_bar: if True, show a progress bar during evaluation From b0fe5f216694716d0dd649801f42193274ee58ec Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Mon, 22 Jul 2024 17:59:01 +0200 Subject: [PATCH 02/94] Add basic file --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 pyproject.toml diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..7fd26b9 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" \ No newline at end of file From a40921d228281e969ade0ca9e321185f441c28c5 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Mon, 22 Jul 2024 23:53:33 +0200 Subject: [PATCH 03/94] Moved Ibe's model --- tests/test_wimprates.py | 4 +- wimprates/data/migdal/{ => Ibe}/REFERENCE | 0 wimprates/data/migdal/{ => Ibe}/Xe.dat | 0 wimprates/data/migdal/{ => Ibe}/dat_to_cvs.py | 0 .../migdal/{ => Ibe}/migdal_transition_Ar.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Ge.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Si.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Xe.csv | 0 wimprates/migdal.py | 79 +++++++++++-------- wimprates/summary.py | 6 +- 10 files changed, 54 insertions(+), 35 deletions(-) rename wimprates/data/migdal/{ => Ibe}/REFERENCE (100%) rename wimprates/data/migdal/{ => Ibe}/Xe.dat (100%) rename wimprates/data/migdal/{ => Ibe}/dat_to_cvs.py (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Ar.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Ge.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Si.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Xe.csv (100%) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index bb24ce1..d8903ac 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -40,8 +40,8 @@ def test_spindependent(self): 0.00019944698779638946) - def test_migdal(self): - self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', **self.opts), + def test_migdal_Ibe(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Ibe", **self.opts), 0.27459766238555017) diff --git a/wimprates/data/migdal/REFERENCE b/wimprates/data/migdal/Ibe/REFERENCE similarity index 100% rename from wimprates/data/migdal/REFERENCE rename to wimprates/data/migdal/Ibe/REFERENCE diff --git a/wimprates/data/migdal/Xe.dat b/wimprates/data/migdal/Ibe/Xe.dat similarity index 100% rename from wimprates/data/migdal/Xe.dat rename to wimprates/data/migdal/Ibe/Xe.dat diff --git a/wimprates/data/migdal/dat_to_cvs.py b/wimprates/data/migdal/Ibe/dat_to_cvs.py similarity index 100% rename from wimprates/data/migdal/dat_to_cvs.py rename to wimprates/data/migdal/Ibe/dat_to_cvs.py diff --git a/wimprates/data/migdal/migdal_transition_Ar.csv b/wimprates/data/migdal/Ibe/migdal_transition_Ar.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Ar.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Ar.csv diff --git a/wimprates/data/migdal/migdal_transition_Ge.csv b/wimprates/data/migdal/Ibe/migdal_transition_Ge.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Ge.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Ge.csv diff --git a/wimprates/data/migdal/migdal_transition_Si.csv b/wimprates/data/migdal/Ibe/migdal_transition_Si.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Si.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Si.csv diff --git a/wimprates/data/migdal/migdal_transition_Xe.csv b/wimprates/data/migdal/Ibe/migdal_transition_Xe.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Xe.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Xe.csv diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 97635d9..baaa71d 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -1,6 +1,14 @@ -"""Migdal effect +""" +Migdal effect + +Two implemented models: + * Ibe et al: https://arxiv.org/abs/1707.07258 + * Cox et al: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032 + In the energy range of DM, the dipole approximation model implemented by Ibe et al + is compatible with the one developped by Cox et al (check discussion in Cox et al) """ + import numericalunits as nu import numpy as np import pandas as pd @@ -9,41 +17,48 @@ from functools import lru_cache from fnmatch import fnmatch import wimprates as wr + +from .data.migdal.Cox.Migdal import Migdal as Migdal_Cox export, __all__ = wr.exporter() @lru_cache() -def read_migdal_transitions(material='Xe'): +def read_migdal_transitions(material='Xe', model="Ibe"): # Differential transition probabilities for vs energy (eV) - df_migdal_material = pd.read_csv(wr.data_file('migdal/migdal_transition_%s.csv' %material)) - - # Relevant (n, l) electronic states - migdal_states_material = df_migdal_material.columns.values.tolist() - migdal_states_material.remove('E') - - # Binding energies of the relevant electronic states - # From table II of 1707.07258 - energy_nl = dict( - Xe=np.array([3.5e4, - 5.4e3, 4.9e3, - 1.1e3, 9.3e2, 6.6e2, - 2.0e2, 1.4e2, 6.1e1, - 2.1e1, 9.8]), - Ar=np.array([3.2e3, - 3.0e2, 2.4e2, - 2.7e1, 1.3e1]), - Ge=np.array([1.1e4, - 1.4e3, 1.2e3, - 1.7e2, 1.2e2, 3.5e1, - 1.5e1, 6.5e0]), - # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm - Si=np.array([1844.1, - 154.04, 103.71, - 13.46, 8.1517]), - ) - - binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) + if model == "Ibe": + df_migdal_material = pd.read_csv(wr.data_file('migdal/Ibe/migdal_transition_%s.csv' %material)) + + # Relevant (n, l) electronic states + migdal_states_material = df_migdal_material.columns.values.tolist() + migdal_states_material.remove('E') + + # Binding energies of the relevant electronic states + # From table II of 1707.07258 + energy_nl = dict( + Xe=np.array([3.5e4, + 5.4e3, 4.9e3, + 1.1e3, 9.3e2, 6.6e2, + 2.0e2, 1.4e2, 6.1e1, + 2.1e1, 9.8]), + Ar=np.array([3.2e3, + 3.0e2, 2.4e2, + 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, + 1.4e3, 1.2e3, + 1.7e2, 1.2e2, 3.5e1, + 1.5e1, 6.5e0]), + # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm + Si=np.array([1844.1, + 154.04, 103.71, + 13.46, 8.1517]), + ) + + binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) + elif model == "Cox": + pass + else: + raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") return df_migdal_material, binding_es_for_migdal_material, @@ -77,7 +92,7 @@ def vmin_migdal(w, erec, mw, material): @wr.vectorize_first def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), include_approx_nr=False, q_nr=0.15, material="Xe", - t=None, halo_model=None, consider_shells=None, + t=None, halo_model=None, consider_shells=None, migdal_model="Ibe", **kwargs): """Differential rate per unit detector mass and deposited ER energy of Migdal effect WIMP-nucleus scattering @@ -112,7 +127,7 @@ def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), include_approx_nr = 1 if include_approx_nr else 0 result = 0 - df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material) + df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material, model=migdal_model) if consider_shells is None: consider_shells = _default_shells(material) for state, binding_e in binding_es_for_migdal.items(): diff --git a/wimprates/summary.py b/wimprates/summary.py index e1387ae..8ac5c5c 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -10,7 +10,7 @@ @export def rate_wimp(es, mw, sigma_nucleon, interaction='SI', detection_mechanism='elastic_nr', m_med=float('inf'), - t=None, halo_model=None, + t=None, halo_model=None, **kwargs): """Differential rate per unit time, unit detector mass and unit recoil energy of WIMP-nucleus scattering. @@ -31,6 +31,10 @@ def rate_wimp(es, mw, sigma_nucleon, interaction='SI', 'elastic_nr' for regular elastic nuclear recoils 'bremsstrahlung' for Bremsstrahlung photons 'migdal' for the Migdal effect + :param migdal_model: model of Migdal effect + 'Ibe' for model implemented in Ibe et al: https://arxiv.org/abs/1707.07258 + 'Cox' for exclusive transition model implemented + in Cox et al: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032 :param m_med: Mediator mass. If not given, assumed very heavy. :param halo_model: A class giving velocity distribution and dark matter density. :param t: A J2000.0 timestamp. From 9ce21df5ffe74a589a7ceea281283b6390ee2066 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 23 Jul 2024 00:00:24 +0200 Subject: [PATCH 04/94] Added Cox model package at tag --- .gitmodules | 3 +++ wimprates/data/migdal/Cox | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 wimprates/data/migdal/Cox diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..b466ab9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "wimprates/data/migdal/Cox"] + path = wimprates/data/migdal/Cox + url = https://github.com/petercox/Migdal.git diff --git a/wimprates/data/migdal/Cox b/wimprates/data/migdal/Cox new file mode 160000 index 0000000..99bb84c --- /dev/null +++ b/wimprates/data/migdal/Cox @@ -0,0 +1 @@ +Subproject commit 99bb84cda8407e9b065a1ef2f6ad539a16d24bea From b8514716d6ba9c26f7d327a36188233bdb174e58 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:01:42 +0200 Subject: [PATCH 05/94] Moving submodule --- .gitmodules | 2 +- wimprates/data/migdal/{Cox => Cox/cox_submodule} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename wimprates/data/migdal/{Cox => Cox/cox_submodule} (100%) diff --git a/.gitmodules b/.gitmodules index b466ab9..e7f2d09 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "wimprates/data/migdal/Cox"] - path = wimprates/data/migdal/Cox + path = wimprates/data/migdal/Cox/cox_submodule url = https://github.com/petercox/Migdal.git diff --git a/wimprates/data/migdal/Cox b/wimprates/data/migdal/Cox/cox_submodule similarity index 100% rename from wimprates/data/migdal/Cox rename to wimprates/data/migdal/Cox/cox_submodule From 328478a2e3a8c0d1993f5d6398b89379766e278d Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:06:20 +0200 Subject: [PATCH 06/94] Updating import statements --- wimprates/migdal.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index baaa71d..5d9f121 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -9,16 +9,21 @@ is compatible with the one developped by Cox et al (check discussion in Cox et al) """ +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any, Optional, Self + +from fnmatch import fnmatch +from functools import lru_cache import numericalunits as nu import numpy as np import pandas as pd -from scipy.interpolate import interp1d from scipy.integrate import dblquad -from functools import lru_cache -from fnmatch import fnmatch +from scipy.interpolate import interp1d + import wimprates as wr -from .data.migdal.Cox.Migdal import Migdal as Migdal_Cox + export, __all__ = wr.exporter() From 5ad10fcf2c91fc21e1294d223cad2132edee12f0 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:12:27 +0200 Subject: [PATCH 07/94] Add utility function to preformat data for Cox's interpolators --- wimprates/utils.py | 47 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/wimprates/utils.py b/wimprates/utils.py index 10eb230..f8c1d7b 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -4,7 +4,7 @@ from boltons.funcutils import wraps import numpy as np -from tqdm import tqdm +from tqdm.autonotebook import tqdm def exporter(): @@ -60,3 +60,48 @@ def itr(x): for x in itr(xs)]) return f(xs, *args, **kwargs) return newf + + +@export +def pairwise_log_transform(a, b): + """ + Preprocesses two input arrays by reshaping, concatenating, and applying a logarithmic transformation. + + This function takes two input arrays (or single values), reshapes them into column vectors, + concatenates them horizontally to form a 2D array, and then applies the natural logarithm + to each element of the resulting array. It ensures compatibility with the downstream function + that expects a 2D array with two columns, regardless of whether the input consists of single + values or multiple pairs of values. + + Parameters + ---------- + a : array-like or float + The first input array or single float value. + b : array-like or float + The second input array or single float value. + + Returns + ------- + numpy.ndarray + A 2D array with shape (n, 2), where n is the number of elements in the input arrays. + Each row contains the natural logarithm of the corresponding elements from the input arrays. + + Examples + -------- + >>> pairwise_log_transform([4.5, 2.7], [400, 900]) + array([[ 1.5040774 , 5.99146455], + [ 0.99325177, 6.80239476]]) + + >>> pairwise_log_transform(4.5, 400) + array([[1.5040774 , 5.99146455]]) + + Notes + ----- + - If `a` and `b` are not arrays, they will be converted to arrays. + - If `a` and `b` are single values, the output will be a 2D array with a single row. + - The function applies `np.log` to each element in the concatenated array. + """ + a = np.atleast_1d(a).reshape(-1, 1) + b = np.atleast_1d(b).reshape(-1, 1) + arr = np.concatenate((a, b), axis=1) + return np.log(arr) From ef27b65fe2936d5f937ee9fda0629e7bbebce7c2 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:13:24 +0200 Subject: [PATCH 08/94] Wrapper module to include Cox's package Cox's package relies on relative paths to run. It assumes the main Python process is running in its root dir. This wrapper runs the necessary methods within the root of the submodule and then moves the working dir back to the original one. It returns a configured instance of the Migdal class from the submodule for which the probabilities and total probabilities have already been computed. --- wimprates/data/migdal/Cox/cox_wrapper.py | 32 ++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 wimprates/data/migdal/Cox/cox_wrapper.py diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py new file mode 100644 index 0000000..fc0b1c0 --- /dev/null +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -0,0 +1,32 @@ +""" +The paths in the code in Peter Cox's package assume the working directory to be +the root of its package. With this wrapper we change the working dir when computing +the interpolators, then returning the Migdal class instance once they've been instantiated. +The working directory is then reset. +""" + +import os +import sys + +import wimprates as wr + +from .cox_submodule.Migdal import Migdal + +export, __all__ = wr.exporter() + + +@export +def cox_migdal_model(element: str, **kwargs): + original_cwd = os.getcwd() + + try: + migdal_directory = os.path.join(os.path.dirname(__file__), "cox_submodule") + os.chdir(migdal_directory) + + material = Migdal(element) + material.load_probabilities(**kwargs) + material.load_total_probabilities(**kwargs) + finally: + os.chdir(original_cwd) + + return material From 28ba5d823ec0aea7a85217ecb85e877e70878083 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:21:23 +0200 Subject: [PATCH 09/94] Add docstring to cox_wrapper.py --- wimprates/data/migdal/Cox/cox_wrapper.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index fc0b1c0..58366b6 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -17,6 +17,25 @@ @export def cox_migdal_model(element: str, **kwargs): + """ + This function creates a Cox Migdal model for a given element. + + Parameters: + - element (str): The element for which the Cox Migdal model is created. + - **kwargs: Additional keyword arguments for loading probabilities and total probabilities. + + Returns: + - material: The Cox Migdal material object. + + Example usage: + cox_migdal_model("carbon", arg1=value1, arg2=value2) + + Note: The Cox's model assumes that the main process is running in its root directory and uses + relative paths. Therefore, we need to switch the working directory to the root of the package + when computing the interpolators. + This wrapper function changes the working directory temporarily, instantiates the Migdal class, + and then resets the working directory back to its original state. + """ original_cwd = os.getcwd() try: From 6fc1f86cabd5f678c274a7f73f9c42098af1a12e Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:26:16 +0200 Subject: [PATCH 10/94] Implemented Peter Cox et al. Migdal model Refactored the code so that the Migdal model can be selected using a simple keyword argument. Examples will be prepared in the notebooks/ dir. Two tests have been added: - One for Cox's full model for single ionization rates - One for Cox's model using dipole approximation --- tests/test_wimprates.py | 13 ++ wimprates/__init__.py | 2 +- wimprates/migdal.py | 329 +++++++++++++++++++++++++++++++--------- 3 files changed, 270 insertions(+), 74 deletions(-) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index d8903ac..ac1fd9d 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -43,6 +43,16 @@ def test_spindependent(self): def test_migdal_Ibe(self): self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Ibe", **self.opts), 0.27459766238555017) + + + def test_migdal_Cox(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Cox", **self.opts), + 0.2843514286729741) + + + def test_migdal_Cox_dipole(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Cox", dipole=True, **self.opts), + 0.30438231874513705) def test_brems(self): @@ -104,3 +114,6 @@ def test_average_v_earth(self): # places=1 means that we get the same results at the first decimal (fine for 500.0) places=1 ) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/wimprates/__init__.py b/wimprates/__init__.py index 9878a28..e06501b 100644 --- a/wimprates/__init__.py +++ b/wimprates/__init__.py @@ -14,4 +14,4 @@ from .migdal import * from .electron import * from .summary import * - +from .data.migdal.Cox.cox_wrapper import * diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 5d9f121..47bfb23 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -27,78 +27,201 @@ export, __all__ = wr.exporter() -@lru_cache() -def read_migdal_transitions(material='Xe', model="Ibe"): +@dataclass +class Shell: + name: str + material: str + binding_e: float + model: str + single_ionization_probability: Callable # to assign interpolators to + + def __call__(self: Self, *args, **kwargs) -> np.ndarray: + return self.single_ionization_probability(*args, **kwargs) + + @property + def n(self: Self) -> int: + return int(self.name[0]) + + @property + def l(self: Self) -> str: + return self.name[1:] + + +def _default_shells(material: str) -> list[str]: + + consider_shells = dict( + # For Xe, only consider n=3 and n=4 + # n=5 is the valence band so unreliable in liquid + # n=1,2 contribute very little + Xe=["3*", "4*"], + # TODO, what are realistic values for Ar? + Ar=["2*"], + # EDELWEIS + Ge=["3*"], + Si=["2*"], + ) + return consider_shells[material] + + +def create_cox_probability_function( + element, + state: str, + material: str, + dipole: bool = False, +) -> Callable[..., np.ndarray[Any, Any]]: + + fn_name = "dpI1dipole" if dipole else "dpI1" + fn = getattr(element, fn_name) + + def get_probability( + e: float | np.ndarray, # energy of released electron + erec: Optional[float | np.ndarray] = None, # recoil energy + v: Optional[float | np.ndarray] = None, # recoil speed + ) -> np.ndarray: + if erec is None: + if v is None: + raise ValueError("Either v or erec have to be provided") + elif v is None: + v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 + else: + raise ValueError("Either v or erec have to be provided") + # print(f"{e/nu.keV=} corresponds to {v=}") + e /= nu.keV + + input_points = wr.pairwise_log_transform(e, v) + return fn(input_points, state) / nu.keV # type: ignore + + return get_probability + + +@export +def get_migdal_transitions_probability_iterator( + material: str = "Xe", + model: str = "Ibe", + considered_shells: Optional[list[str] | str] = None, + dark_matter: bool = True, + e_threshold: Optional[float] = None, + dipole: bool = False, + **kwargs, +) -> list[Shell]: # Differential transition probabilities for vs energy (eV) + # Check if considered_shells is an empty list + if considered_shells is None: + considered_shells = _default_shells(material) + + shells = [] if model == "Ibe": - df_migdal_material = pd.read_csv(wr.data_file('migdal/Ibe/migdal_transition_%s.csv' %material)) + df_migdal_material = pd.read_csv( + wr.data_file("migdal/Ibe/migdal_transition_%s.csv" % material) + ) # Relevant (n, l) electronic states migdal_states_material = df_migdal_material.columns.values.tolist() - migdal_states_material.remove('E') + migdal_states_material.remove("E") # Binding energies of the relevant electronic states # From table II of 1707.07258 energy_nl = dict( - Xe=np.array([3.5e4, - 5.4e3, 4.9e3, - 1.1e3, 9.3e2, 6.6e2, - 2.0e2, 1.4e2, 6.1e1, - 2.1e1, 9.8]), - Ar=np.array([3.2e3, - 3.0e2, 2.4e2, - 2.7e1, 1.3e1]), - Ge=np.array([1.1e4, - 1.4e3, 1.2e3, - 1.7e2, 1.2e2, 3.5e1, - 1.5e1, 6.5e0]), + Xe=np.array( + [ + 3.5e4, + 5.4e3, + 4.9e3, + 1.1e3, + 9.3e2, + 6.6e2, + 2.0e2, + 1.4e2, + 6.1e1, + 2.1e1, + 9.8, + ] + ), + Ar=np.array([3.2e3, 3.0e2, 2.4e2, 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, 1.4e3, 1.2e3, 1.7e2, 1.2e2, 3.5e1, 1.5e1, 6.5e0]), # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm - Si=np.array([1844.1, - 154.04, 103.71, - 13.46, 8.1517]), + Si=np.array([1844.1, 154.04, 103.71, 13.46, 8.1517]), ) - binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) - elif model == "Cox": - pass - else: - raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") + for state, binding_e in zip(migdal_states_material, energy_nl[material]): + if not any(fnmatch(state, take) for take in considered_shells): + continue + binding_e *= nu.eV + + # Lookup for differential probability (units of ev^-1) + p = interp1d( + np.array(df_migdal_material["E"].values) * nu.eV, + df_migdal_material[state].values / nu.eV, + bounds_error=False, + fill_value=0, + ) - return df_migdal_material, binding_es_for_migdal_material, + shells.append(Shell(state, material, binding_e, model, p)) + elif model == "Cox": + element = wr.cox_migdal_model( + material, + dipole=dipole, + dark_matter=dark_matter, + e_threshold=e_threshold, + ) -def _default_shells(material): + for state, binding_e in element.orbitals: + if not any(fnmatch(state, take) for take in considered_shells): + continue - consider_shells = dict( - # For Xe, only consider n=3 and n=4 - # n=5 is the valence band so unreliable in liquid - # n=1,2 contribute very little - Xe=['3*', '4*'], - # TODO, what are realistic values for Ar? - Ar=['2*'], - # EDELWEIS - Ge=['3*'], - Si=['2*'], - ) - return consider_shells[material] + shells.append( + Shell( + state, + material, + binding_e * nu.keV, + model, + single_ionization_probability=create_cox_probability_function( + element, + state, + material, + dipole=dipole, + ), + ) + ) + else: + raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") + return shells -def vmin_migdal(w, erec, mw, material): + +def vmin_migdal( + w: np.ndarray, erec: np.ndarray, mw: float, material: str +) -> np.ndarray: """Return minimum WIMP velocity to make a Migdal signal with energy w, given elastic recoil energy erec and WIMP mass mw. """ - y = (wr.mn(material) * erec / (2 * wr.mu_nucleus(mw, material) ** 2))**0.5 - y += w / (2 * wr.mn(material) * erec)**0.5 + y = (wr.mn(material) * erec / (2 * wr.mu_nucleus(mw, material) ** 2)) ** 0.5 + y += w / (2 * wr.mn(material) * erec) ** 0.5 return np.maximum(0, y) @export @wr.vectorize_first -def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), - include_approx_nr=False, q_nr=0.15, material="Xe", - t=None, halo_model=None, consider_shells=None, migdal_model="Ibe", - **kwargs): +def rate_migdal( + w: np.ndarray, + mw: float, + sigma_nucleon: float, + interaction: str = "SI", + m_med: float = float("inf"), + include_approx_nr: bool = False, + q_nr: float = 0.15, + material: str = "Xe", + t: Optional[float] = None, + halo_model: Optional[wr.StandardHaloModel] = None, + consider_shells: Optional[list[str]] = None, + migdal_model: str = "Ibe", + dark_matter: bool = True, + dipole: bool = False, + e_threshold: Optional[float] = None, + **kwargs, +) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of Migdal effect WIMP-nucleus scattering @@ -129,42 +252,66 @@ def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), (e.g. error tolerance). """ halo_model = wr.StandardHaloModel() if halo_model is None else halo_model - include_approx_nr = 1 if include_approx_nr else 0 - result = 0 - df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material, model=migdal_model) - if consider_shells is None: + if not consider_shells: consider_shells = _default_shells(material) - for state, binding_e in binding_es_for_migdal.items(): - binding_e *= nu.eV - if not any(fnmatch(state, take) for take in consider_shells): - continue - # Lookup for differential probability (units of ev^-1) - p = interp1d(df_migdal['E'].values * nu.eV, - df_migdal[state].values / nu.eV, - bounds_error=False, - fill_value=0) + shells = get_migdal_transitions_probability_iterator( + material=material, + model=migdal_model, + considered_shells=consider_shells, + dipole=dipole, + e_threshold=e_threshold, + dark_matter=dark_matter, + ) + + result = 0 + for shell in shells: def diff_rate(v, erec): # Observed energy = energy of emitted electron # + binding energy of state - eelec = w - binding_e - include_approx_nr * erec * q_nr + eelec = w - shell.binding_e - include_approx_nr * erec * q_nr if eelec < 0: return 0 - return ( - # Usual elastic differential rate, - # common constants follow at end - wr.sigma_erec(erec, v, mw, sigma_nucleon, interaction, - m_med=m_med, material = material) - * v * halo_model.velocity_dist(v, t) - - # Migdal effect |Z|^2 - # TODO: ?? what is explicit (eV/c)**2 doing here? - * (nu.me * (2 * erec / wr.mn(material))**0.5 / (nu.eV / nu.c0))**2 - / (2 * np.pi) - * p(eelec)) + if migdal_model == "Ibe": + return ( + # Usual elastic differential rate, + # common constants follow at end + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + # Migdal effect |Z|^2 + # TODO: ?? what is explicit (eV/c)**2 doing here? + * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) + ** 2 + / (2 * np.pi) + * shell(eelec) + ) + elif migdal_model == "Cox": + return ( + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + * shell(eelec, erec) + ) # Note dblquad expects the function to be f(y, x), not f(x, y)... r = dblquad( @@ -178,8 +325,44 @@ def diff_rate(v, erec): material=material, ), lambda _: wr.v_max(t, halo_model.v_esc), - **kwargs)[0] + **kwargs, + )[0] result += r - return halo_model.rho_dm / mw * (1 / wr.mn(material)) * result + return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + + +### (DEPRECATED) Maintain this for backwards accessibility +@lru_cache() +def read_migdal_transitions(material="Xe"): + # Differential transition probabilities for vs energy (eV) + + df_migdal_material = pd.read_csv( + wr.data_file("migdal/Ibe/migdal_transition_%s.csv" % material) + ) + + # Relevant (n, l) electronic states + migdal_states_material = df_migdal_material.columns.values.tolist() + migdal_states_material.remove("E") + + # Binding energies of the relevant electronic states + # From table II of 1707.07258 + energy_nl = dict( + Xe=np.array( + [3.5e4, 5.4e3, 4.9e3, 1.1e3, 9.3e2, 6.6e2, 2.0e2, 1.4e2, 6.1e1, 2.1e1, 9.8] + ), + Ar=np.array([3.2e3, 3.0e2, 2.4e2, 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, 1.4e3, 1.2e3, 1.7e2, 1.2e2, 3.5e1, 1.5e1, 6.5e0]), + # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm + Si=np.array([1844.1, 154.04, 103.71, 13.46, 8.1517]), + ) + + binding_es_for_migdal_material = dict( + zip(migdal_states_material, energy_nl[material]) + ) + + return ( + df_migdal_material, + binding_es_for_migdal_material, + ) From e4a5802d5a6d2e67cc28cc13a9eeca60f13fcffc Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:27:53 +0200 Subject: [PATCH 11/94] Remove debug print statement --- wimprates/migdal.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 47bfb23..d536561 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -85,7 +85,7 @@ def get_probability( v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 else: raise ValueError("Either v or erec have to be provided") - # print(f"{e/nu.keV=} corresponds to {v=}") + e /= nu.keV input_points = wr.pairwise_log_transform(e, v) From 502fa0896292a6fb5292231c32771149bb0cdc67 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 14:46:43 +0200 Subject: [PATCH 12/94] Add dockstrings --- wimprates/migdal.py | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index d536561..bd789e1 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -29,8 +29,28 @@ @dataclass class Shell: + """ + Describes a specific atomic shell for the selected atom. + + Attributes: + name (str): The name of the shell. + element (str): The element class of the atom. + binding_e (float): The binding energy for the shell. + model (str): The model used for the single ionization probability computation. + single_ionization_probability (Callable): A function to assign interpolators to. + The interpolator will provide the single ionization probability for the shell + according to the selected model. + + Methods: + __call__(*args, **kwargs) -> np.ndarray: + Calls the single_ionization_probability function with the given arguments and keyword arguments. + + Properties: + n (int): Primary quantum number. + l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox. + """ name: str - material: str + element: str binding_e: float model: str single_ionization_probability: Callable # to assign interpolators to @@ -48,6 +68,13 @@ def l(self: Self) -> str: def _default_shells(material: str) -> list[str]: + """ + Returns the default shells to consider for a given material. + Args: + material (str): The material for which to determine the default shells. + Returns: + list[str]: The default shells to consider for the given material. + """ consider_shells = dict( # For Xe, only consider n=3 and n=4 @@ -69,7 +96,7 @@ def create_cox_probability_function( material: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: - + fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) @@ -95,7 +122,7 @@ def get_probability( @export -def get_migdal_transitions_probability_iterator( +def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", considered_shells: Optional[list[str] | str] = None, @@ -256,7 +283,7 @@ def rate_migdal( if not consider_shells: consider_shells = _default_shells(material) - shells = get_migdal_transitions_probability_iterator( + shells = get_migdal_transitions_probability_iterators( material=material, model=migdal_model, considered_shells=consider_shells, From 6128b40140e2f4fbdfbd253934f3a13da02e4693 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:02:55 +0200 Subject: [PATCH 13/94] Update tutorial notebook for Migdal --- notebooks/Migdal.ipynb | 1002 ++++++++++++++++++++++------------------ 1 file changed, 555 insertions(+), 447 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 11e4f55..60cde54 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -1,447 +1,555 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:26.733826Z", - "start_time": "2022-07-22T19:16:24.834775Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from tqdm import tqdm\n", - "import numericalunits as nu\n", - "\n", - "import wimprates as wr" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Convert Xe.dat to nicer format" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:26.776139Z", - "start_time": "2022-07-22T19:16:26.735821Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
1_02_02_13_03_13_24_04_14_25_05_1E
1.0000001.013107e-142.538509e-131.417923e-123.745613e-121.931796e-116.875756e-124.272023e-112.097481e-102.115778e-094.937655e-105.173118e-071.000000
1.0456361.013389e-142.539291e-131.424572e-123.746781e-121.941191e-116.950745e-124.272690e-112.096290e-102.124282e-094.851036e-105.103404e-071.045636
1.0933541.013681e-142.540099e-131.431461e-123.747978e-121.950850e-117.033516e-124.273357e-112.095044e-102.133447e-094.762062e-105.031270e-071.093354
1.1432501.013985e-142.540935e-131.438595e-123.749203e-121.960773e-117.124774e-124.274019e-112.093738e-102.143335e-094.670743e-104.956689e-071.143250
1.1954231.014299e-142.541800e-131.445980e-123.750456e-121.970957e-117.225280e-124.274673e-112.092371e-102.154013e-094.577099e-104.879646e-071.195423
\n", - "
" - ], - "text/plain": [ - " 1_0 2_0 2_1 3_0 \\\n", - "1.000000 1.013107e-14 2.538509e-13 1.417923e-12 3.745613e-12 \n", - "1.045636 1.013389e-14 2.539291e-13 1.424572e-12 3.746781e-12 \n", - "1.093354 1.013681e-14 2.540099e-13 1.431461e-12 3.747978e-12 \n", - "1.143250 1.013985e-14 2.540935e-13 1.438595e-12 3.749203e-12 \n", - "1.195423 1.014299e-14 2.541800e-13 1.445980e-12 3.750456e-12 \n", - "\n", - " 3_1 3_2 4_0 4_1 \\\n", - "1.000000 1.931796e-11 6.875756e-12 4.272023e-11 2.097481e-10 \n", - "1.045636 1.941191e-11 6.950745e-12 4.272690e-11 2.096290e-10 \n", - "1.093354 1.950850e-11 7.033516e-12 4.273357e-11 2.095044e-10 \n", - "1.143250 1.960773e-11 7.124774e-12 4.274019e-11 2.093738e-10 \n", - "1.195423 1.970957e-11 7.225280e-12 4.274673e-11 2.092371e-10 \n", - "\n", - " 4_2 5_0 5_1 E \n", - "1.000000 2.115778e-09 4.937655e-10 5.173118e-07 1.000000 \n", - "1.045636 2.124282e-09 4.851036e-10 5.103404e-07 1.045636 \n", - "1.093354 2.133447e-09 4.762062e-10 5.031270e-07 1.093354 \n", - "1.143250 2.143335e-09 4.670743e-10 4.956689e-07 1.143250 \n", - "1.195423 2.154013e-09 4.577099e-10 4.879646e-07 1.195423 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "SOURCE='Xe'\n", - "df = dict()\n", - "with open(wr.data_file(f'migdal/{SOURCE}.dat')) as f:\n", - " header = False\n", - " for i, line in enumerate(f.read().splitlines()):\n", - " if 'Principal' in line:\n", - " header = True\n", - " continue\n", - " if 'Energy' in line:\n", - " header = False\n", - " continue\n", - " \n", - " if header:\n", - " n, l = [int(x) for x in line.split()]\n", - " else:\n", - " e, rate = [float(x) for x in line.split()]\n", - " df.setdefault(e, dict())\n", - " df[e]['%d_%d' % (n, l)] = rate\n", - " \n", - "df = pd.DataFrame(df).T\n", - "df['E'] = df.index\n", - "\n", - "df.to_csv('migdal_transition_ps.csv', index=False)\n", - "df_migdal = df\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Rows are energies, columns are (n, l) states. Data is the differential transition probabilities, at the 1 eV/c reference momentum, not divided by 2 pi." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Reproduce figure 4" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "To reproduce figure 4 of https://arxiv.org/pdf/1707.07258.pdf, we must\n", - " * Convert to the other reference momentum of $m_e * .001 c$\n", - " * Divide by 2 pi.\n", - " * Convert eV -> keV; multiply energies by 1e3 and divide differential probabilities by 1e3." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:27.594619Z", - "start_time": "2022-07-22T19:16:26.778591Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'diff. p (keV^-1)')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import wimprates\n", - "\n", - "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", - "df2, _ = wimprates.migdal.read_migdal_transitions(SOURCE)\n", - "for n in df.keys():\n", - " x = df_migdal[n].values.copy()\n", - " if not n.endswith('0'):\n", - " continue\n", - " for c in df2.keys():\n", - " if c.startswith(str(n).split('_')[0]) and not c.endswith('0'):\n", - " x += df[c]\n", - " \n", - " plt.plot(df['E'] / 1e3, x * scale * 1e3)\n", - "#plt.plot(df['E'] / 1e3, df['2_0']**0.5 + df['2_0'])\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.ylim(1e-7, 1e2)\n", - "plt.xlabel(\"E (keV)\")\n", - "plt.ylabel(\"diff. p (keV^-1)\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Compare with spectrum from LUX talk" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "To verify we have the correct spectrum, let's compare to a curve trace from slide 10 of a [recent LUX talk](https://indico.cern.ch/event/699961/contributions/3043408/attachments/1692619/2723656/JLIN_Sub_GeV_DM_Talk_IDM2018_V4.pdf)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:47.277779Z", - "start_time": "2022-07-22T19:16:27.599861Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:19<00:00, 5.09it/s]\n" - ] - } - ], - "source": [ - "es = np.logspace(np.log10(5e-2), np.log10(2), 100) * nu.keV\n", - "rs = wr.rate_migdal(\n", - " w=es,\n", - " mw=0.5 * nu.GeV/nu.c0**2,\n", - " sigma_nucleon=1e-35 * nu.cm**2,\n", - " progress_bar=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:47.750262Z", - "start_time": "2022-07-22T19:16:47.282805Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'dr/dE (keV kg day)^-1')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ref_curve = pd.read_csv('migdal_0.5gev_curvetrace_lux.csv', index_col=False)\n", - "plt.plot(es / nu.keV, \n", - " rs * (nu.kg * nu.day * nu.keV))\n", - "plt.plot(10**ref_curve['logE'], 10**ref_curve['logR'], color='red', label='Curve trace')\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.xlabel('E (keV)')\n", - "plt.ylabel('dr/dE (keV kg day)^-1')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Looks good! The remaining deviations look like curve tracing artifacts." - ] - } - ], - "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.10.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Migdal Tutorial\n", + "Tutorial to compute Migdal rates according to different models.\n", + "Models from two sources are currently implemented:\n", + " - **Ibe**: https://link.springer.com/article/10.1007/JHEP03(2018)194\n", + " - **Cox**: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:26.733826Z", + "start_time": "2022-07-22T19:16:24.834775Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numericalunits as nu\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "import wimprates as wr\n", + "\n", + "sns.set_theme()\n", + "sns.set_style('ticks')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Convert Xe.dat to nicer format (Ibe)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:26.776139Z", + "start_time": "2022-07-22T19:16:26.735821Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "SOURCE='Xe'\n", + "df = dict()\n", + "with open(wr.data_file(f'migdal/Ibe/{SOURCE}.dat')) as f:\n", + " header = False\n", + " for i, line in enumerate(f.read().splitlines()):\n", + " if 'Principal' in line:\n", + " header = True\n", + " continue\n", + " if 'Energy' in line:\n", + " header = False\n", + " continue\n", + " \n", + " if header:\n", + " n, l = [int(x) for x in line.split()]\n", + " else:\n", + " e, rate = [float(x) for x in line.split()]\n", + " df.setdefault(e, dict())\n", + " df[e]['%d_%d' % (n, l)] = rate\n", + " \n", + "df = pd.DataFrame(df).T\n", + "df['E'] = df.index\n", + "\n", + "df.to_csv('migdal_transition_ps.csv', index=False)\n", + "df_migdal = df\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Rows are energies, columns are (n, l) states. Data is the differential transition probabilities, at the 1 eV/c reference momentum, not divided by 2 pi." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Reproduce figure 4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To reproduce figure 4 of https://arxiv.org/pdf/1707.07258.pdf, we must\n", + " * Convert to the other reference momentum of $m_e * .001 c$\n", + " * Divide by 2 pi.\n", + " * Convert eV -> keV; multiply energies by 1e3 and divide differential probabilities by 1e3." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:27.594619Z", + "start_time": "2022-07-22T19:16:26.778591Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", + "df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n", + "for n in df.keys():\n", + " x = df_migdal[n].values.copy()\n", + " if not n.endswith('0'):\n", + " continue\n", + " for c in df2.keys():\n", + " if c.startswith(str(n).split('_')[0]) and not c.endswith('0'):\n", + " x += df[c]\n", + " \n", + " plt.plot(df['E'] / 1e3, x * scale * 1e3, label=n[0])\n", + "\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.xlabel(\"Energy [keV]\")\n", + "plt.ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using the iterator getter for different models\n", + "The getter function `wr.get_migdal_transitions_probability_iterators` provides a list of instanses of the Shell class.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "wr.migdal.Shell?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", + "shells_ibe = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Ibe\", considered_shells=(\"*\"))\n", + "\n", + "E = df[\"E\"].to_numpy() * nu.eV\n", + "\n", + "for shell in shells_ibe:\n", + " x = shell(E)\n", + " if shell.l != \"_0\":\n", + " continue\n", + " for _shell in shells_ibe:\n", + " if shell.n == _shell.n and _shell.l != \"_0\":\n", + " x += _shell(E)\n", + " plt.plot(E / nu.keV, x * scale * nu.keV, label=f\"n={shell.n}\")\n", + " \n", + "\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.title(\"Ibe model\")\n", + "plt.xlabel(\"E [keV]\")\n", + "plt.ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "shells_cox = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", considered_shells=(\"*\",))\n", + "\n", + "\n", + "E = np.logspace(0, np.log10(20e3), 1000) * nu.eV\n", + "v = np.repeat(1e-4, len(E))\n", + "\n", + "def print_f(arr, pref=\"\"):\n", + " if arr is not None:\n", + " return 0\n", + " print(f\"{pref} {arr[:2]=}\")\n", + "for shell in shells_cox:\n", + " x = shell(E.copy(), v=v)\n", + " if shell.l != \"s\":\n", + " continue\n", + " for _shell in shells_cox:\n", + " if shell.n == _shell.n and _shell.l != \"s\":\n", + " x += _shell(E.copy(), v=v)\n", + " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " \n", + "\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "ax.set_title(\"Cox model\")\n", + "ax.set_xlabel(\"E [keV]\")\n", + "ax.set_ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "shells_cox_dipole = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", dipole=True, considered_shells=(\"*\",))\n", + "\n", + "\n", + "E = df[\"E\"].to_numpy().copy() * nu.eV\n", + "v = np.repeat(1e-3, len(E))\n", + "\n", + "def print_f(arr, pref=\"\"):\n", + " if arr is not None:\n", + " return 0\n", + " print(f\"{pref} {arr[:2]=}\")\n", + "for shell in shells_cox_dipole:\n", + " x = shell(E.copy(), v=v)\n", + " if shell.l != \"s\":\n", + " continue\n", + " for _shell in shells_cox_dipole:\n", + " if shell.n == _shell.n and _shell.l != \"s\":\n", + " x += _shell(E.copy(), v=v)\n", + " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " \n", + "\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "ax.set_title(\"Cox model with Dipole Approximation\")\n", + "ax.set_xlabel(\"E [keV]\")\n", + "ax.set_ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Compare with spectrum from LUX talk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To verify we have the correct spectrum, let's compare to a curve trace from slide 10 of a [recent LUX talk](https://indico.cern.ch/event/699961/contributions/3043408/attachments/1692619/2723656/JLIN_Sub_GeV_DM_Talk_IDM2018_V4.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "es = np.logspace(np.log10(5e-2), np.log10(2), 100) * nu.keV\n", + "\n", + "WIMP_MASS = 0.5 # GeV\n", + "SIGMA = 1e-35 # cm^2\n", + "\n", + "def extract_exponent(num):\n", + " # Convert the number to a string in scientific notation\n", + " num_str = f\"{num:.1e}\"\n", + " # Split the string on 'e' to separate the mantissa and exponent\n", + " num, exponent_str = num_str.split('e')\n", + " # Convert the exponent part to an integer\n", + " exponent = int(exponent_str)\n", + " return num, exponent\n", + "\n", + "_, SIGMA_Exp = extract_exponent(SIGMA)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rs_ibe = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Ibe\",\n", + " include_approx_nr=False,\n", + " progress_bar=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "ref_curve = pd.read_csv(\"migdal_0.5gev_curvetrace_lux.csv\", index_col=False)\n", + "ax.plot(\n", + " 10 ** ref_curve[\"logE\"], 10 ** ref_curve[\"logR\"], color=\"red\", label=\"Curve trace\"\n", + ")\n", + "ax.plot(es / nu.keV, rs_ibe * (nu.kg * nu.day * nu.keV), label=\"Ibe\")\n", + "\n", + "ax.set_title(rf\"Migdal rate for $m_{{WIMP}} = {WIMP_MASS}$ GeV/c$^2$ and $\\sigma_{{nucleon}} = 10^{{{SIGMA_Exp}}}$ cm$^2$\")\n", + "ax.set_xscale(\"log\")\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xlabel(\"Deposited energy [keV$_{ee}$]\")\n", + "ax.set_ylabel(\"Differential Rate [keV$^{-1}$ kg$^{-1}$ day$^{-1}$]\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks good! The remaining deviations look like curve tracing artifacts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparing Cox and Ibe models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "WITH_DIPOLE = False\n", + "\n", + "rs_cox = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Cox\",\n", + " dipole=False,\n", + " # e_threshold=0.1 * nu.keV,\n", + " progress_bar=True,\n", + ")\n", + "if WITH_DIPOLE:\n", + " rs_cox_dipole = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Cox\",\n", + " dipole=True,\n", + " include_approx_nr=False,\n", + " progress_bar=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_rs = pd.DataFrame(dict(\n", + " E=es/nu.keV,\n", + " r_cox=rs_cox * (nu.kg * nu.day * nu.keV),\n", + " r_ibe=rs_ibe* (nu.kg * nu.day * nu.keV),\n", + "))\n", + "if WITH_DIPOLE:\n", + " df_rs['r_cox_dipole'] = rs_cox_dipole * (nu.kg * nu.day * nu.keV)\n", + "\n", + "df_rs = df_rs.melt(id_vars='E')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "\n", + "g = sns.relplot(data=df_rs, x=\"E\", y=\"value\", hue=\"variable\", kind=\"line\")\n", + "g.set(\n", + " xscale=\"log\",\n", + " yscale=\"log\",\n", + " xlabel=r\"Deposited energy [keV$_{ee}$]\",\n", + " ylabel=\"Differential Rate [keV$^{-1}$ kg$^{-1}$ day$^{-1}$]\",\n", + " title=rf\"Migdal rate for $m_{{WIMP}} = {WIMP_MASS}$ GeV/c$^2$ and $\\sigma_{{nucleon}} = 10^{{{SIGMA_Exp}}}$ cm$^2$\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The observed discrepancies between the models are due to multiple factors:\n", + " - The model by Cox does not use the dipole approximation and normalizes the electron spinors using different techniques. This influences mostly the ***shape*** of the distribution.\n", + " - The two models use slightly different binding energy values for the considered orbitals. This affects the the minimum energies at which the migdal effect is kinematically allowed and, consequently, the ***horizontal stretch*** of the distributions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Binding energies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "l_model = []\n", + "l_n = []\n", + "l_l = []\n", + "l_Binding_E = []\n", + "\n", + "for shell in shells_cox:\n", + " l_model.append(\"Cox\")\n", + " l_n.append(shell.n)\n", + " l_l.append(shell.l)\n", + " l_Binding_E.append(shell.binding_e)\n", + "\n", + "orb_conv = {key:val for key, val in zip([\"_0\", \"_1\", \"_2\"], [\"s\", \"p\", \"d\"])}\n", + "\n", + "for shell in shells_ibe:\n", + " l_model.append(\"Ibe\")\n", + " l_n.append(shell.n)\n", + " l_l.append(orb_conv[shell.l])\n", + " l_Binding_E.append(shell.binding_e)\n", + "\n", + "df = pd.DataFrame(dict(\n", + " Model=l_model,\n", + " n=l_n,\n", + " l=l_l,\n", + " Binding_E=l_Binding_E,\n", + "))\n", + "shell_order = [\"1s\",\"2s\",\"2p-\", \"2p\", \"3s\", \"3p-\", \"3p\", \"3d-\", \"3d\", \"4s\", \"4p-\", \"4p\", \"4d-\", \"4d\", \"5s\", \"5p-\", \"5p\"]\n", + "df[\"name\"] = (df.n.astype(str) + df.l).astype(pd.CategoricalDtype(categories=shell_order, ordered=True))\n", + "df.sort_values(\"name\", inplace=True)\n", + "df.reset_index(drop=True, inplace=True)\n", + "considered_shells = df.query(\"n in [3,4]\").groupby([\"Model\", \"name\"], observed=True).mean(numeric_only=True)\n", + "all_shells = df.groupby([\"Model\", \"name\"], observed=True).mean(numeric_only=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "g = sns.catplot(data=all_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\")\n", + "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", yscale=\"log\", title=\"Binding Energies for all orbitals\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "g = sns.catplot(data=considered_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\", order=considered_shells.index.levels[1].values)\n", + "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", title=\"Binding Energies for considered orbitals\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A check was made by fixing the binding energies for the Ibe model to the ones utilised by Peter Cox *et al*. The resulting rates were the following:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](rates_fixed_binding_energies.png)" + ] + } + ], + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 8bde9892557274813ab7150579518e6fc660a408 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:09:18 +0200 Subject: [PATCH 14/94] Remove typing.Self for python3.9 --- wimprates/migdal.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index bd789e1..6e9b200 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional, Self +from typing import Any, Optional from fnmatch import fnmatch from functools import lru_cache @@ -55,15 +55,15 @@ class Shell: model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self: Self, *args, **kwargs) -> np.ndarray: + def __call__(self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self: Self) -> int: + def n(self) -> int: return int(self.name[0]) @property - def l(self: Self) -> str: + def l(self) -> str: return self.name[1:] From e0d51d4761db159c83f19e78ae7aab3bef94fadc Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:11:55 +0200 Subject: [PATCH 15/94] Require seaborn --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 81ced55..408d07d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ pandas tqdm boltons numericalunits +seaborn From f8e86848ee865cf8dc9581b50fcfa297c6a7f584 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:34:07 +0200 Subject: [PATCH 16/94] Add output to notebook --- notebooks/Migdal.ipynb | 440 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 404 insertions(+), 36 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 60cde54..81fe72c 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:26.733826Z", @@ -24,7 +24,29 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/loren/projects/wimprates/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", + " warnings.warn(\n", + "/home/loren/projects/wimprates/wimprates/utils.py:7: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", + " from tqdm.autonotebook import tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------\n", + "Migdal ionisation probabilities\n", + "P. Cox, M. Dolan, C. McCabe, H. Quiney (2022)\n", + "arXiv:2208.12222\n", + "------------------------------------------\n" + ] + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numericalunits as nu\n", @@ -51,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:26.776139Z", @@ -61,7 +83,150 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1_02_02_13_03_13_24_04_14_25_05_1E
1.0000001.013107e-142.538509e-131.417923e-123.745613e-121.931796e-116.875756e-124.272023e-112.097481e-102.115778e-094.937655e-105.173118e-071.000000
1.0456361.013389e-142.539291e-131.424572e-123.746781e-121.941191e-116.950745e-124.272690e-112.096290e-102.124282e-094.851036e-105.103404e-071.045636
1.0933541.013681e-142.540099e-131.431461e-123.747978e-121.950850e-117.033516e-124.273357e-112.095044e-102.133447e-094.762062e-105.031270e-071.093354
1.1432501.013985e-142.540935e-131.438595e-123.749203e-121.960773e-117.124774e-124.274019e-112.093738e-102.143335e-094.670743e-104.956689e-071.143250
1.1954231.014299e-142.541800e-131.445980e-123.750456e-121.970957e-117.225280e-124.274673e-112.092371e-102.154013e-094.577099e-104.879646e-071.195423
\n", + "
" + ], + "text/plain": [ + " 1_0 2_0 2_1 3_0 \\\n", + "1.000000 1.013107e-14 2.538509e-13 1.417923e-12 3.745613e-12 \n", + "1.045636 1.013389e-14 2.539291e-13 1.424572e-12 3.746781e-12 \n", + "1.093354 1.013681e-14 2.540099e-13 1.431461e-12 3.747978e-12 \n", + "1.143250 1.013985e-14 2.540935e-13 1.438595e-12 3.749203e-12 \n", + "1.195423 1.014299e-14 2.541800e-13 1.445980e-12 3.750456e-12 \n", + "\n", + " 3_1 3_2 4_0 4_1 \\\n", + "1.000000 1.931796e-11 6.875756e-12 4.272023e-11 2.097481e-10 \n", + "1.045636 1.941191e-11 6.950745e-12 4.272690e-11 2.096290e-10 \n", + "1.093354 1.950850e-11 7.033516e-12 4.273357e-11 2.095044e-10 \n", + "1.143250 1.960773e-11 7.124774e-12 4.274019e-11 2.093738e-10 \n", + "1.195423 1.970957e-11 7.225280e-12 4.274673e-11 2.092371e-10 \n", + "\n", + " 4_2 5_0 5_1 E \n", + "1.000000 2.115778e-09 4.937655e-10 5.173118e-07 1.000000 \n", + "1.045636 2.124282e-09 4.851036e-10 5.103404e-07 1.045636 \n", + "1.093354 2.133447e-09 4.762062e-10 5.031270e-07 1.093354 \n", + "1.143250 2.143335e-09 4.670743e-10 4.956689e-07 1.143250 \n", + "1.195423 2.154013e-09 4.577099e-10 4.879646e-07 1.195423 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "SOURCE='Xe'\n", "df = dict()\n", @@ -128,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:27.594619Z", @@ -138,7 +303,28 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", "df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n", @@ -169,18 +355,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mwr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmigdal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mShell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0melement\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbinding_e\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msingle_ionization_probability\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcollections\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Describes a specific atomic shell for the selected atom.\n", + "\n", + "Attributes:\n", + " name (str): The name of the shell.\n", + " element (str): The element class of the atom.\n", + " binding_e (float): The binding energy for the shell.\n", + " model (str): The model used for the single ionization probability computation.\n", + " single_ionization_probability (Callable): A function to assign interpolators to.\n", + " The interpolator will provide the single ionization probability for the shell\n", + " according to the selected model.\n", + "\n", + "Methods:\n", + " __call__(*args, **kwargs) -> np.ndarray:\n", + " Calls the single_ionization_probability function with the given arguments and keyword arguments.\n", + "\n", + "Properties:\n", + " n (int): Primary quantum number.\n", + " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", + "\u001b[0;31mFile:\u001b[0m ~/projects/wimprates/wimprates/migdal.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + } + ], "source": [ "wr.migdal.Shell?" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", "shells_ibe = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Ibe\", considered_shells=(\"*\"))\n", @@ -208,9 +442,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "shells_cox = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", considered_shells=(\"*\",))\n", @@ -245,9 +490,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHOCAYAAABTk+fWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAADOY0lEQVR4nOzdd1zU9R/A8dfdcceeAjIEFORAEFTEvTVHqZVpZWY56mdlNkxLTU1Ni5wNLffItLIsTW2oZY40t7lARcSB7L057u77+wM9RVAZBwh+ng95cHy+4/P+wnn3vs/n8/18ZJIkSQiCIAiCIAjlJq/pAARBEARBEGorkUgJgiAIgiBUkEikBEEQBEEQKkgkUoIgCIIgCBUkEilBEARBEIQKEomUIAiCIAhCBYlEShAEQRAEoYJEIiUIgiAIglBBIpESBEEQBEGoIJFICXXSuXPnmDRpEt27dycoKIgWLVowYMAAli9fTnp6ek2HV61eeOEFXnjhhQod2717dyZOnGjkiIocOnQIPz8/Dh06ZCjbs2cPCxcuLHV/Pz8/PvzwwwrVFRMTg5+fn+ErMDCQNm3aMHDgQD7++GMiIyPLFF9VqMzf537CwsLw8/PjlVdeqZLz17SqfH7ez9atW1mzZk2p2/z8/O76PBbqHpOaDkAQjO2HH35gxowZNGrUiJdeeonGjRuj1Wo5c+YM33//Pf/99x9ffvllTYf50AsMDGTDhg00btzYULZnzx7Wr1/PG2+8USV1vvDCC/Tr1w+9Xk9WVhbh4eH89NNPrFu3jnfeeYeXX375nvHVJoWFhWzZsgWAffv2kZCQQP369Ws4KuNatGgRVlZWNVL3tm3biIyMZPjw4SW2bdiwARcXl+oPSqgRIpES6pQTJ04wffp02rdvz1dffYVKpTJs69ChAyNGjGDfvn01GKFwk5WVFc2bN6/WOl1dXYvV2aVLF0aMGMGYMWOYO3cuvr6+dOnSpcbiM6a//vqL1NRUunbtyu7du9m0aROvvvpqjcQiSRIFBQWYmZkZ9bwBAQFGPZ+x1ObnjVB+omtPqFOWLl2KTCZj5syZxZKom1QqFT169DD8rNfrWb58OX369KFp06a0a9eO9957j/j4eMM+H3zwAUFBQZw5c6bYccOGDaN9+/YkJibeNZ6bXUorVqxg2bJldO/eneDgYF544QWio6MpLCxk3rx5dOzYkZYtW/L666+TkpJS7BxliRGK3qyWL19Ot27dCAoKYsCAAezZs6fUuLKzs5k9ezbdu3enadOmdOrUiY8++ojc3Nx7/4JL8eabb9K3b99iZa+++ip+fn78/vvvhrKzZ8/i5+fHrl27gJJdZxMnTmT9+vUAxbrhYmJiip178+bNPProozRr1ozHH3+cv//+u9wx387MzIyPPvoIpVLJypUrDeWlde1NnDiRFi1aEBkZybBhw2jevDlt27blww8/JC8vr9h5CwoKmD9/frHf8YwZM8jMzLxvTBqNhq+++srwN2/bti2TJk0iNTW1zNe1ceNGlEolYWFhuLq68vPPP3PnGvU3r/GXX34hLCyMDh06EBwczNChQwkPDy+2b3mu/WY37Hfffcejjz5KUFAQmzZtAuDo0aMMGzaMFi1a0KxZMwYPHszu3bsNxx49epTAwEBmz55d7Jw///wzfn5+/Pjjj4ayO7v2bl7P1q1bmTt3Lh07dqRFixa8+uqrJCcnk52dzdSpU2nTpg1t2rRh0qRJ5OTkFKtn/fr1PP/887Rr147mzZvTv39/li9fTmFhoWGfF154gd27d3P9+vViz9Xbr//Orr0LFy7w2muv0apVK4KCgnjiiScMv5M749+2bRuffvopHTt2JCQkhOHDh3Pp0iWEB5NokRLqDJ1Ox8GDBwkMDMTV1bVMx0yfPp0NGzYwdOhQunbtyvXr1/n88885fPgwP//8Mw4ODkyePJlTp07x9ttv8/PPP2NjY8OiRYs4fPgwK1aswNnZ+b71fPvtt6jVaj744AMyMzOZPXs2r776Ks2aNcPExISPP/6Y2NhYZs+ezeTJk1myZEm5YoSibo5FixYxaNAgevfuTXx8PFOnTkWv19OoUSPD+fLy8hg6dCjx8fGGhCcyMpIvvviCCxcusGbNGmQyWZl/7+3bt2f79u0kJibi7OyMVqvl8OHDmJmZceDAAR599FEADhw4gImJCa1bty71PKNHjyY3N5ft27ezYcMGQ/ntv9/du3dz+vRp3nzzTSwsLFixYgVjxozhjz/+wMPDo8wx36l+/foEBgZy4sQJtFotJiZ3f2ksLCxk1KhRPPvss4waNYoTJ06wePFiYmNjDX83SZIYPXo0Bw8eZNSoUYSGhnL+/HkWLlzIf//9x4YNG0pN9KEocR49ejTHjh3jpZdeIiQkhOvXr7Nw4UJOnTrFTz/9dN+Wnfj4ePbv30+vXr1wcHDgySefZPHixRw5cqTU3/+nn35KQEAAs2bNIisri0WLFvHCCy+wefPmYr/Xslz7TX/++SdHjx7l9ddfx9HRkXr16nH48GFGjhyJWq3mo48+QqVS8d133/Hqq6+yYMECHnvsMUJDQ3nrrbeYP38+oaGh9OjRg8jISD788EMef/xxnn766Xte+83radOmDWFhYVy/fp3Zs2fzzjvvYGJigp+fHwsWLCA8PJxPP/0US0tLpkyZYjj26tWr9OvXjwYNGqBUKjl37hxLlizh0qVLhIWFATBt2jSmTp3KtWvXWLRo0X3juXTpEoMHD6ZevXpMnjwZe3t7tmzZwsSJE0lOTuZ///tfsf0XLFhASEgIH330EdnZ2cybN4/XXnuN3377DYVCcd/6hGomCUIdkZSUJKnVamns2LFl2v/ixYuSWq2Wpk+fXqz85MmTklqtlhYsWGAou3z5shQSEiKNHj1aOnDggOTv7y99+umn963j2rVrklqtlh5//HFJp9MZytesWSOp1Wrp1VdfLbb/Rx99JKnVaikrK6tcMWZkZEhBQUHS66+/Xmy/Y8eOSWq1Who6dKihbOnSpZK/v7906tSpYvv+8ccfklqtlnbv3m0o69atmzRhwoR7XuOVK1cktVotbdq0SZIkSTp69KikVqulOXPmSN27dzfsN2LECOnZZ581/Hzw4EFJrVZLBw8eNJTNmDFDUqvVpdajVqul9u3bG343klT0N/f395eWLl16zxhv/h1WrFhx133efvttSa1WS8nJyXeNb8KECZJarZa+/vrrYscuXrxYUqvV0tGjRyVJkqS9e/dKarVaWr58ebH9fv31V0mtVksbNmwwlA0dOrTY32fbtm2SWq2Wtm/fXuzYU6dOSWq1Wlq/fv09r1WSJGnRokWSWq2W9u7dK0mSJF29elXy8/OT3n333WL73bzGAQMGSHq93lAeExMjBQYGSpMnTy73tUtS0d+qZcuWUnp6erF9n3nmGaldu3ZSdna2oUyr1Ur9+vWTOnfubIhBr9dL//vf/6TQ0FDpwoUL0mOPPSb16dNHysnJKXa+O5+fN6/nlVdeKbbfzf9XM2fOLFY+evRoqXXr1nf5LUqSTqeTCgsLpU2bNklNmjQpdj2jRo2SunXrVupxarVa+uKLLww/jx07VmratKkUGxtbbL+XX35ZatasmZSZmVks/v/973/F9vvtt98ktVotnThx4q6xCjVHdO0JD62bXTYDBgwoVh4cHIyPjw///vuvoczLy4uZM2fy559/8sorrxAaGlquAdFdunRBLr/1383HxweArl27FtvvZnlsbGy5Yjxx4gQFBQX079+/2H4hISG4u7sXK/v777/x9fWlSZMmaLVaw1fHjh2RyWQcPny4zNcF4Onpibu7uyGWAwcOoFarefzxx4mJieHq1atoNBqOHTtG+/bty3XuO7Vp06bY4OKbLR3Xr1+v1HmBEt1e93Ln77lfv37Arb/XwYMHAXjqqaeK7ffoo49iYWFR7Ll1p7///hsbGxu6detW7O/TpEkTnJyc7vv3kSSJn3/+GVdXVzp06ACAh4cHrVu3ZseOHWRnZ5c4pl+/fsVaId3d3WnRokWpdyze79pvatu2Lba2toafc3NzOXnyJL1798bS0tJQrlAoePzxx4mPjzd0X8lkMmbPno2lpSUDBw4kJiaGzz77DAsLi3te+03dunUr9vO9/r+lp6cX694LDw/n1VdfpU2bNjRp0oTAwEAmTJiATqfj8uXLZar/TgcPHqRdu3YlWsoHDBhAXl4eJ06cKFbevXv3Yj/f7Da8+bogPFhE155QZ9jb22Nubl5iTM3d3JwGobSuOWdn5xIvWl27dsXR0ZHk5GSGDx9erib2299QAJRK5T3LCwoKyhXjzf0cHR1L7HdnWUpKCleuXCEwMLDUWNPS0u51KaVq166dYRD/gQMH6NChA35+fjg6OnLgwAG8vLzIz8+vdCJlZ2dXokylUhl+X5URGxuLSqUq8Te5k4mJCfb29sXKnJycgFt/h/T0dExMTAzdrjfJZDIcHR3vOQVHSkoKmZmZNG3atNTt9/v7HDx4kJiYGEaMGFEsaXr00Uc5dOgQ27ZtY/DgwcWOudvz5ty5c8XKynLtd5bflJmZiSRJJcrh1vP79nPY29vTvXt31q9fT8+ePYuNQbqfivx/s7S0JDY2lueff55GjRrx/vvv4+7ujqmpKadOneLDDz8kPz+/zDHcLj09vczXDSWf5ze7gStav1C1RCIl1BkKhYK2bduyb98+4uPj73v78c0Xq8TExBL7JiYmlnjDmDZtGjk5Ofj6+vLRRx8RGhp63zfdyiprjDf3S05OLnGO5OTkYq1S9vb2mJqa8vHHH5da553XXRbt2rVj48aNnDp1ilOnTvHaa68BRa0SBw4cIDY2FgsLC5o1a1buc1eHhIQEzp49S6tWre45PgpAq9WSlpZW7PeUlJQE3Po72NnZodVqSU1NLZZMSZJEcnIyQUFBdz2/vb09dnZ2rFixotTtt7fmlGbjxo0ArF69mtWrV5e6/c5E6m7Pmzvf0Mty7TfdOc7OxsYGuVxu2P92N2/YuP28+/fv57vvviM4OJidO3eyfft2evfuXeJYY/rzzz/Jzc1l4cKFxf7P3JlQlpednV2Zr1uofUTXnlCnvPLKK0iSxJQpU9BoNCW2FxYWGu4aa9u2LYBhrp2bTp06RVRUlGE7wI8//siWLVuYOnUqixcvJjMzk0mTJlXhlVCuGJs3b46pqSlbt24ttt/x48dLdHt17dqVa9euYWdnR1BQUImvBg0alDvOdu3aIZPJ+Pzzz5HJZLRq1cpQfujQIfbv30+rVq0MLQB3UxOfvPPz85k8eTJarbbYPFL3cufvedu2bQCGgdzt2rUDSv7dtm/fTm5urmF7abp27Up6ejp6vb7Uv4+3t/ddj83IyGDnzp2EhISwdu3aEl/9+/fn9OnTXLhwoUT8t3dtXr9+nRMnTpQ6MP1+1343NxPpnTt3Fvv76vV6tmzZgouLi+GmiMTERN59911atWrF999/T/fu3Zk8eTLXrl27Zx2VdTP5u/1GAEmS+OGHH0rsq1Kpyvw8bdeuHQcPHiQhIaFY+S+//IK5ubmYLqGWEy1SQp3SokULpk+fzowZMxg4cCCDBw/G19cXrVZLeHg4P/zwA76+vnTv3h1vb2+effZZ1q1bh1wup3PnzoY74lxdXQ0T7Z0/f55Zs2YxYMAABg4cCMBHH33Em2++yZo1a0qdkM9Yyhqjra0tI0eOZPHixUyePJk+ffoQHx/PwoULS3QpDBs2jB07djB06FCGDx+On58fer2euLg4/vnnH0aOHFnulqN69erh6+vLP//8Q5s2bTA3NweK7uhLT08nPT29TImnWq0GYPny5XTu3Bm5XI6fn99d73Arr7i4OP777z/DhJwRERH89NNPxMbGMnHiRDp27HjfcyiVSlavXk1ubi5BQUGGO9c6d+5MaGgoUDRnWceOHZk3bx7Z2dmEhIRw/vx5vvjiCwICAnjiiSfuev6+ffuydetWRo0axQsvvEBwcDBKpZL4+HgOHTpEjx496NmzZ6nHbt26lYKCAl544QXatGlTYrudnR1bt25l48aNvP/++4by1NRUXn/9dZ555hmysrJYuHAhKpWqxIzoZbn2e3nnnXcYOXIkL774IiNHjkSpVPLtt98SGRnJggULkMlk6HQ6xo0bh0wmY/78+SgUCj755BOefPJJxo4dy7fffmu058Od2rdvj1KpNEzOqtFo+O6770qdskKtVrNjxw6+/fZbmjZtikwmu2tL4+uvv87ff//Niy++yOuvv46trS1bt25l9+7dvPvuu1hbW1fJ9QjVQyRSQp3zzDPPEBwczJo1a1ixYgVJSUkolUoaNmxIv379GDp0qGHf6dOn4+HhwcaNG/n222+xsrKiU6dOjBs3Dnt7e3Jzc3n77bdp0KAB06ZNMxzXu3dvnn/+eebNm0dISAjBwcFVdj33i/Gmt956CwsLC7799lt++eUXvL29mTFjBqtWrSp2PgsLC9avX8+yZcvYsGEDMTExmJmZ4erqSvv27UsMTi+r9u3bc+HChWLjoNzc3GjYsCGXL1++ZyvMTf369eP48eN8++23fPnll0iSxF9//VWhVrLSfPPNN3zzzTcoFAqsrKxo0KAB3bp145lnninzDOZKpZIlS5Ywa9YsFi9ejJmZGU8//TTvvfeeYR+ZTMZXX33FwoUL+fnnn1myZAl2dnY88cQTvPPOO/dMBBQKBYsXL2bt2rX88ssvLFu2DIVCgYuLC61atTIkm6XZuHEj9erV45FHHil1u5+fH82bN2fLli2MHz/eUD527FhOnz7NpEmTyM7OJjg4mAULFuDp6Vnua7+X1q1bs2bNGhYuXMikSZPQ6/X4+/uzePFiwwDxL774gqNHj7Jq1SrDhwBbW1sWLFjA0KFDmTt3LpMnTy5TfeXl4+PDwoUL+eyzz3jjjTews7OjX79+DB8+vMQUBS+++CKRkZF8+umnZGVlIUkS58+fL/W83t7efP/99yxYsMAw1srHx4ewsLASNyQItY9MKs+tKoIgCA+xiRMnsn379hJ3WdVWhw4d4sUXX+Tzzz+nT58+99y3rl27IBiLGCMlCIIgCIJQQSKREgRBEARBqCDRtScIgiAIglBBokVKEARBEAShgkQiJQiCIAiCUEEikRIEQRAEQaggMY9UFQoNDUWj0ZS6xpIgCIIgCA+mpKQkVCoVR48eve++IpGqQgUFBeh0upoOQxAEQRCEctBqtZT1XjyRSFWhmyt7//XXXzUciSAIgiAIZdWjR48y7yvGSAmCIAiCIFSQSKQEQRAEQRAqSCRSgiAIgiAIFSQSKUEQBEEQhAoSiZQgCIIgCEIFibv2BEEQBKGG6XQ6CgsLazqMh4ZSqUShUBjlXCKREgRBEIQaIkkS8fHxpKen13QoDx07OztcXFyQyWSVOo9IpARBEAShhtxMopydnbGwsKj0m7pwf5IkkZubS2JiIgCurq6VOp9IpARBEAShBuh0OkMSVa9evZoO56Fibm4OQGJiIs7OzpXq5hODzQVBEAShBtwcE2VhYVHDkTycbv7eKzs2TSRSgiAIglCDRHdezTDW710kUoIgCIIgCBUkEilBEARBEB5Y69ev55VXXqFt27b4+fnxxx9/1HRIxYhEqpZKTc4h5koaebmamg5FEARBEKrML7/8QlpaGl26dKnpUEpV4bv2zp49W6HjGjdujKmpaUWrFYD8vEIWz92DTqsHwNxCST0nK+o5WeLgZHnjuxUO9SxQmYobMwVBEITa6/vvv0culxMTE8PmzZtrOpwSKvwuO3DgwAoN1Nq4cSOBgYEVrVYATE1NCGzuRvSFJLIyC8jLLSTmShoxV9JK7Gtta4ajsxXOLtY4u1rj5GKNs4u1SLAEQRAEo5o4cSJnzpxh6tSphIWFcfnyZRo3bsz06dNp2rRphc8rl9+/8ywzM5M5c+awZ88e0tPTcXBwICQkhE8//bTC9ZZVpd5NX331VTw9Pcu0r06nY+rUqZWpTrhBJpfx5HPNAdAUaElNziElqeir6HE2qUk55OUWkpWRT1ZGPtGRycXOYV/PoiipcrWmvosNrh622NcTk8EJgiA8CCRJokCjq5G6TVWKCr8XJCUlMWvWLEaNGoWVlRXz589nzJgx7Ny5E6VSiU6nQ5Kke55DJpOVe16nsLAw9u3bx7hx43B3dycpKYm9e/dW6BrKq1KJVLdu3QgODi7TvjqdjilTplSmOqEUKlMTXNxtcXG3LbEtN0dDSlIOyQlZJMZnkRiXRVJ8FtlZBaSl5JKWksuFswmG/c3Mlbi42+DmYYdrA1vcPGyxcxDJlSAIQnWSJIkJi/4h4nJqjdTfpKEDs8d0rNBrf0ZGBuvWrcPX1xcAU1NTRowYwcmTJwkNDWX48OEcPnz4nudwd3dn165d5ar39OnT9OvXjwEDBhjK+vbtW+74K6LCidSiRYto1KhRmfdXKBQsWrQILy+vilYplJOFpQoLSxUeDe2LledkF5B0I7FKjM8iPjaThNhM8vMKuXwxhcsXUwz7mpkrcfOwpYGXPR6NHGjgZYepmbK6L0UQBEGoBZydnQ1JFICPjw8ACQlFH9pnzJhBTk7OPc+hUqnKXW9AQACbNm3CycmJTp06oVary32OiqpwIvXII49UyzGC8VlamWLZ2JSGjR0NZTqdnqT4LGKvZRAXk0FcTDoJsVnk5xVy6UIyly4UdQ3KZFDf1QaPRvZ4NHTAo5EDtvbmNXUpgiAIdY5MJmP2mI61smvPxsam2M9KZdEH74KCAgC8vLzK1LVXXlOnTsXW1pbVq1czZ84cXF1dGTVqFEOGDCn3ucpLjDgWAFAo5CW6CHVaPYnxWVy/ms61y6lci04jPTWX+NhM4mMzObL/CgA2dmY0bOyIt68jjXwdsbY1q6nLEARBqBNkMhlmdfCmoKrq2rO2tmby5MlMnjyZ8+fPs3btWmbMmIGvry+tWrWqTMj3ZbS/kl6vZ8uWLTz55JPGOqVQwxQmclwb2OLawJbQ9kVdslkZ+Yak6trlVOKuZ5KZns+pozGcOhoDgFN9KxqpHWnk60RDHwfRFSgIgiAAVde1dzs/Pz8mTZrExo0buXTpUu1JpLRaLZMmTRKJVB1nbWtGQDM3Apq5AUV3DcZcSSM6MpnoyGRiYzJISsgmKSGbw/suI5PLcPe0o7G/E75N6uPibiMGrwuCIDykvL29y33M6dOnuX79OqmpRYPvT548CYCDgwOtW7cGYPDgwfTs2RNfX18UCgWbN29GqVQSGhpqvODvolyJ1KJFi+66TavVVjoYofZRmZrgrXbCW+0EQF6uhssXU7h0IZnoyCRSk3OJuZxGzOU0dv9xAWtbM9QBzvgG1KeRryNKZflucRUEQRAeLuvXr2fTpk2Gn1etWgVA69at+eabbwAICQlh8+bNxMTEIJfLUavVLFmyxDDYvSrJpPuN+rpN06ZNeeSRR7CysiqxTafTsXnzZiIiIowaYG3Wo0cPAP76668ajqTmpKfmculCEpERiVy6kEzhbYMnTZRyvNVOBAS7og6sj5m56AIUBOHhkZ+fT3R0NI0aNcLMTIwtrW73+v2X5/27XC1SarWaJ598kq5du5bYVlBQUCxjFAQAOwcLQtp6EdLWC22hjstRKVw4m0BkRCIZaXlcOJvAhbMJyBUyQ1Ll17Q+5haV6yMXBEEQhOpQrkTq6aefRqcr/XZMExMTxowZY5SghLrJRKmgsb8zjf2dkSSJhLgszp2KI+JUHEkJ2VyMSORiRCLyH2U0UjsSHOKOX1MXsZyNIAiC8MAq1zvUc889d9dtCoVCJFJCmclkMlzcbHBxs6FrHz+SErKIOBVPxKk4EmIziTqXRNS5JJQqBf5BLgSFuOPt64hccf81lwRBEAShulT6o/4XX3zBm2++aYxYhIeYU31rnHpa07mnLylJ2Zw5Hsvp4zGkJudy+th1Th+7jqW1KU1buNGijSfOLtY1HbIgCIIgVD6RWrlypUikBKOq52RFl95qOvfy5frVdE4fu87Z/2LJySrg0N5oDu2NpoGXPSFtPQlo5iq6/gRBEIQaU+l3oHLc9CcI5SKTyWjgZU8DL3t6PRFA1Pkk/jt8jfNnE4i5kkbMlTT+2HyWoBA3Qtp64dqg5MLNgiAIglCVKp1IickVheqgUMhRB9RHHVCf7Mx8/jsSw4lDV0lLyeXYv1c59u9VGnjZ07pjQ5oEu6IwEWOpBEEQhKon+kSEWsfKxoyOPRrToZsPly+lcOLgVcJPxRlaqay2hhPavmjKBStr05oOVxAEQajDRCIl1FoyuYxGjR1p1NiRXpn5HDt4lWMHrpCdWcDuPy6wb+dFAlu40a6LN/XdbO5/QkEQBEEoJzFGSqgTrGzM6NJLTcfujQk/FcfhfdFcv5puWEy5cRNnOnT3wbORg+iOFgRBEIym0olUSEiIMeIQBKNQmMgJCnEnKMSd61fT+Hf3JSJOxRkm+2zgZU+H7j6oA+ojk4uEShAE4UGWmJjImjVr2L9/P1evXsXS0pKQkBDGjRuHl5dXTYcHGCGRWrNmjRHCEATjc/e0Z9CLLUlNzuHf3VH8dySGmCtpbFh9FMf6VnR6xJfA5m7IRUIlCILwQDp79iw7duxg4MCBNG/enMzMTJYuXcrTTz/Nli1bcHFxqekQK55Ipaam4uDgYMxYBKFKODha0ndQMF16qTm0L5qjB66QnJDNpvUn2PdnJF16qglo5ipaqARBEB4wLVu25I8//sDE5Fa60qpVKzp37szGjRsfiBVVKnyPeOfOnXnzzTfZs2ePGCcl1ApWNmb06NuEt6f2oNujfpiZK0lOyOandcdZMn8v4SdjkfTiuSwIglAREydOpF+/fhw6dIgnn3yS5s2bM2jQIM6cOVPhc9rY2BRLogAcHBxwcXEhMTHRUJaZmcmUKVPo1KkTQUFBdOnShbFjx1a43vKocItU7969+euvv9i5cydOTk4MGDCAgQMH4unpacz4BMHoTM2UdHrEl1YdGnL4n2gO7okmKT6LjWuP4+xqTbdH/VEHOItB6YIg1BhJkpAKC2qkbpnStMKvf0lJScyaNYtRo0ZhZWXF/PnzGTNmDDt37kSpVKLT6e7b+CKTyVAoFHfdHhcXR2xsLN7e3oaysLAw9u3bx7hx43B3dycpKYm9e/dW6BrKq8KJ1Pz588nOzmbr1q38/PPPLF26lGXLlhEaGsqgQYPo06cPpqZiDh/hwWVmrqRzTzWtOzbi4N5LHNobTWJcFhtWHcHT24FH+jWhgZd9TYcpCMJDRpIkYtdOpiDmfI3Ub9rAH7cXZ1UomcrIyGDdunX4+voWncvUlBEjRnDy5ElCQ0MZPnw4hw8fvuc53N3d2bVr1123z5o1CxsbGwYMGGAoO336NP369StW1rdv33LHXxGVGmxuZWXFc889x3PPPUdUVBQbN25k69atTJgwgZkzZ9K3b18GDhxIcHCwseIVBKMzM1fStbcfbTo14sDfURzaG83VS6ms+mI/Ac1c6f6YPw6OljUWny4/n/z4eAqSU5AKtQAo7e0wdXREVU9M5yAIdVPt/H/t7OxsSKIAfHx8AEhISABgxowZ5OTk3PMcKpXqrtuWLl3Krl27+PLLL7G1vbUsWEBAAJs2bcLJyYlOnTqhVqsrcxnlYrQJOX18fJgwYQLjx49n9+7d/PTTT/z000/88MMPNG7cmK1btxqrKkGoEuYWKnr0bUJo+4bs2X6B/45eI/xkHOdOx9OynRede/liaVX1raySTkfGmbOkHj5CxqnT5F69dtd9lba2WPurcWgVikOb1ihtxMSjglDbyWQy3F6cVSu79mzueA1SKpUAFBQUXYuXl1eZuvZKs2nTJj799FOmTp1K9+7di22bOnUqtra2rF69mjlz5uDq6sqoUaMYMmRIha6jPIw+s7lCoaBHjx40a9aMFStW8PXXX3Px4kVjVyMIVcbW3pzHBzejTedG/PVrBBfPJXFk/2VOHYuhax8/WrX3Qq4w/lp+hZmZxP36Owk7/0KTklJsm4m1FaZOTshVKpAkNGnpaFJSKMzIIPXQEVIPHYGvllKvbRtc+z2KTUCAaKkShFpMJpMhU5nVdBhGV9Guvb/++ospU6bwyiuv8Pzzz5c4xtramsmTJzN58mTOnz/P2rVrmTFjBr6+vrRq1cqo13AnoyZSOp2OXbt28dNPP/HPP/+g1Wrx8/Nj0KBBxqymSkVFRfHee++RnZ1N/fr1mTdvHs7OzjUdllAD6rvZMOR/bYiOTGbnlnDiYzPZvvksxw9epc+AQBo1djRKPYUZGVz78WcStu9Ar9EAoLC0xLF9O+xaNMcmMACVnW2J4/QaDdmXosk4dZqUAwfJiY4m5cC/pBz4F2t/Pzyffw674CCjxCgIgmAMFenaO3z4MGPHjuWJJ54o0514fn5+TJo0iY0bN3Lp0qXakUhFRkby008/sWXLFtLS0rCysmLQoEEMGjSIpk2bGqOKajNt2jRGjRpF7969WbVqFfPnz2f27Nk1HZZQgxr5OvLy2E4cP3iVv38/R1J8Ft8sPkhAM1d69g/A1t68QufVFxYS+8tWYjb+jC4vDwBLHx/cn3ycem1bF7U+3YNcpcLG3w8bfz88nhlEzuUrxP36G0m795J17jxnp07HvlVLvEe9jJn4MCAIwgPg9jvtyiIqKorRo0fToEEDBg4cyH///WfYZmVlRePGjQEYPHgwPXv2xNfXF4VCwebNm1EqlYSGhhoz/FJVOJG6ecfeTz/9xNmzZwFq7I69K1eusHLlSk6ePElkZCTe3t5s27atxH7R0dHMmjWLY8eOYW5uTt++fRk/fjxmZkXNp8nJyURFRdGrVy8AnnnmGTp16iQSKQG5XEZoey8Cm7uy+4/zHD1whfCTcVwIT6BjD186dPNBYVL27r70U6eJWryM/NhYACx9vPF64XnsmjercJecZUMvGr/+Gh6DnyVm408k7PiTtCPHOHHqDB6Dn8Ht8X7ITcQ65YIg1B4nT54kKyuLrKysEuOdWrduzTfffAMULVe3efNmYmJikMvlqNVqlixZYhjsXpVkUgVn02zWrBkajeaBmEPqzz//ZObMmTRr1ozo6GgkSSqRSGVmZtKvXz/c3NwYPXo0qamphIWF0alTJ+bNmwfAmTNn+OCDD/j5558Nx7Vu3Zrt27djb1/+2+B79OgBFPXtCnVLfGwmf2w6w9VLqQA41bei76BgPL3vPdu/Li+Py19/Q/zv2wFQ2tnRcPgLOHXpjExu3HFXuddiiFqyjMwzRR90LLw8afz6a1j7Vd/dLIIg3F1+fj7R0dE0atTI8IFeqD73+v2X5/27wh9PO3XqxKBBg+jcuTNyI78BlFf37t155JFHgKKZVUubRfX7778nMzOTzZs3G5a2USgUjB8/ntdeew0fH5+73kkgBu0Kd3Jxs2HY6HacORHL9l/OkpSQzZovDxDS1pMeff0xtyjZLZdx5iyRXyyiIKFoNl6XR3vjNfR5TKyqZmoFC48GNJ01g6S/dxO9ei25V65yauJkPJ97lgYDByC7x4R3giAIQtlUOANatGgRXbt2LZZEZWVlsW/fPrZs2UJGRoZRAiyLsiRye/fupV27dsXWB+zduzcqlYo9e/YA4OrqSnx8vCGhys7OprCwEDs7uyqJW6jdZDIZQSHuvD6hKy1aewBw/OBVvpqzh7MnYg3PI71Gw6UVqzkz+QMKEhIxdXIk8MNp+Lw6qsqSqNtjdO7ejZAvv8CxUwfQ67m6/jvOTJ1OQVJyldYtCILwMDDagIkvv/yS5cuXk5+fj0wmY+PGjdja2jJs2DA6dOjAqFGjjFVVhURFRTFw4MBiZSqVCk9PT6KiogBwdHSkUaNG/Pnnn/Ts2ZONGzfSs2fPe573ZvNfaeLi4nB1da188MIDzdxCRf9nmxEc2oBtP54iJSmHn9Yd5+QxZ3p0dCJuySJyoi8DUL93TxoOfxETC4tqjVFpY4163FjsQ0KIWrqczLPh/Pf2OBq/MZp6bdtUayyCIAh1iVH65NavX8+XX37JoEGDWLp0abEusm7durF7925jVFMpmZmZJSYKg6LJw25vPZs+fTqLFy82rCU4bty46gxTqMW8fOrxyvjOdO7li0Ih52JEIiuXnuBisgITWxuaTH2fxqNfrfYk6qai1qmuNP9sHla+jdFmZ3MubA5XvlmPpNPVSEyCIAi1nVFapNavX8/w4cN577330N3xguzl5cWVK1eMUU2VkCSp2BgoX1/fYoPN7+deA9Hu1Vol1E0mJgo6dvLA4sSf7L9mQZaZE+H1O6PxdSBQHVjT4QFg7upK0CcfceXrb4jdso2YjT+TfTEK9bixKG2sazo8QRCEWsUoLVLXrl2jU6dOpW6ztLQkMzPTGNVUio2NTalxZGVlldpSJQgVkRV5kZNj36Xw312Exv5OiIcWuULGxchUFs/dw5nj1++7PEJ1kJuY0OilEajHvY1cpSL9v5OcHPce2Zeiazo0QRCEWsUoiZS1tTXJyaUPXL1+/Tr16tUzRjWV4uPjYxgLdZNGo+Hq1avVMs+EULdJej3XN2/h9MTJ5MfHY+rkSLOPP6Tf20/yv7GdcHG3IS+3kJ/Xn2Dj2mPk5mhqOmQAnDp3InhuGGYu9SlITOT0xMmkHLr38g2CIAjCLUZJpNq1a8eKFSvIzc01lMlkMrRaLd999x0dO3Y0RjWV0rlzZw4ePEhaWpqhbOfOnWg0Grp06VKDkQm1nSY9g4hZH3N59ddIWi312rWl+WfzsWniD0B9VxteeqsjXXqrkctlRJyKZ+m8PVy68GDcNWfZsCHN5s/Brnkz9AUFnAubw/VftjwQLWeCIAgPOqOMkXrzzTcZNGgQffv25ZFHHkEmk7Fu3ToiIiKIjY3ls88+M0Y1d5WXl2eYwuD69etkZ2fzxx9/AEUTajo4ODB48GDWrVvH6NGjGT16NCkpKXzyySf0799ftEgJFZZ2/ASRny+iMD0duUpFw5HDcenTq8TcYwqFnC691KgD6rNp/QmSE7NZt+wg7bp40/1R/3LNil4VTKysCPhgMpeWrSD+jx1cXvU1edfj8B71kpgNXRAE4R4qPLP5nS5evEhYWBiHDh1Cq9WiUCho06YNkydPrvJEJSYm5q4Du9euXUubNkW3d9++RIyZmRn9+vUrtkSMsYmZzesufWEhV75ZT+wvWwGw8PRAPf4dLL3uP7t/oUbHji1nOfbvVQBc3G146vkQHOtbVWnMZSFJEnFbfyV61RqQJOyaN8Pv3XFVPt+VIDyMxMzmZTNhwgROnDhBYmIiSqUStVrNa6+9VuneLmPNbG60ROomjUZDWloatra2D/0TQyRSdVNuTAwX5n1GTnTRwGyXx/rQcPiLKMq5vuT5M/Fs2XCSvNxCTJRyej8RSEhbzwdiJv2UQ0e4sOAz9Pn5mHs0IGDq+5jVr1/TYQlCnSISqbIZN24crVu3xtPTk/z8fDZu3Mjff//N2rVrK7Uo8QOVSKWmphabMfxOZ8+eJTDwwbj1uzqJRKpukSSJhJ1/Eb1iFfqCAkysrfF983UcWreq8DmzMvLZ/N1/REcWjZcKbO5Gv6eDMDVTGivsCsu+dImImWFoUlNR2toSMH0KVuVcuV0QhLsTiVTF6HQ6evToQadOnZg5c2aFz2OsRMooAzNee+01CgoKSt0WGRnJSy+9ZIxqBKHGFKSkEjErjKgvF6MvKMA2OIjmny+oVBIFYG1rxtBRbXikXxPkchln/4tl+af/EB9b81OGWHl7EzzvEywbNaIwI4Mz739A+qnTNR2WIAgPqIkTJ9KvXz8OHTrEk08+SfPmzRk0aFCp699WhkKhwNraGq1WayjLzMxkypQpdOrUiaCgILp06cLYsWONWu/dGCWRSk5OZvz48SXKr1y5wogRI8RgbqHWkiSJxN17OPHG26QdPYbMxASvYS8QOOMDTOvdvRW2PGRyGe27+TDs9fbY2JmRmpzDqs//4fjBKzV+55xpvXo0/WgGNk0D0eXlET5jFskH/q3RmARBeHAlJSUxa9YsXnrpJT799FPy8/MZM2YMhYWFQFFrklarvefXnRN7Q9FrsVarJS0tjZUrV3LlyhWeeeYZw/awsDB2797NO++8w8qVK3nvvfdQqUouHl8VjHI7zrJlyxgyZAhhYWFMmjQJgNjYWIYPH46zszNLly41RjWCUK00aWlELV5K6qEjAFj6+OD71pgyDSivCI+G9ox6pzObv/uPixGJbPvxNFcupdJ3YBAq05q7c87E0pLAaVO4sOAzUv49xPk589G+OgqXPr1qLCZBqOskSaJAVzPzzZkqVBUeq5mRkcG6devw9fUtOpepKSNGjODkyZOEhoYyfPhwDh++91x17u7u7Nq1q1jZxo0bmTJlCgAWFhZ8+umntGjRwrD99OnT9OvXjwEDBhjK+vbtW6FrKC+jvDr7+PiwcOFCXnrpJdzd3XnssccYPnw4lpaWrFq1Ciurmr8bSRDKSpIkkvft59Ky5WizspGZmODx7NO4P/VklU8FYGGp4rmRrTiwO4pdv5/n9LHrxF3L4OnhLXGqX3PLt8hVKvzeHUfU0uUkbN9J1OKlFGZk0OCZQQ/E4HhBqEskSeKDv+ZxPuVSjdTv5+jDh93HVej/trOzsyGJAgw9UgkJCQDMmDGDnJyce56jtJakHj164O/vT1paGr///jtvv/02ixYtMswDGRAQwKZNm3BycqJTp06o1epyx15RRntXaN26NbNmzeL9999nzZo1mJiYsHr1auzs7IxVhSBUufyEBC4tXUHaseMAWDZqhO/bY7Bs2LDaYpDJZXTo3hiPhg789M0xkhOzWfn5PzwxuDlNgl2rLY4ScSkU+Lz2CkpbW2J+2MjVb7+nMCODRi+PRCav2XmwBKHOqaUfUO5cck2pLLpx5uY4ai8vr/sOWSgtgXNwcDDc1Na5c2fS0tKYO3euIZGaOnUqtra2rF69mjlz5uDq6sqoUaMYMmRIpa/pfiqcSKWnp5co69KlC0OHDmXr1q2sWLECpVJp2E8kVMKDTF9YSOwvW7m24Uf0Gg0yExMaPD2QBoOeqrEJKT29HRj1Tmc2fnOcK1Ep/Pj1MTr0aEy3Pn7I5TXzIiuTyfB6/jmUtrZEr1hF3K+/oysooPHoV5EpFDUSkyDUNTKZjA+7j6uVXXv3U9GuvTsFBgayf/9+w8/W1tZMnjyZyZMnc/78edauXcuMGTPw9fWlVavK3RR0PxV+h2jbtu1df9GSJDFw4MBiZRERERWtShCqVPrJU1xavpK8azEA2DQNxOe1UVg0aFDDkYGltSkvvNKGndsiOLQ3mv1/XSQ+JoOnhrbA3KJ6BlKWxq3fY5hYWRH5+UIS/9yFVKjF960xIpkSBCORyWSYmZRvbrraoKJde3c6fvw4Hh4epW7z8/Nj0qRJbNy4kUuXLj24idTrr78uxkYItVre9ViiV39N2pGjAChtbWg4YhhOXbs8UM9tuaJosk43Dzu2/nCSqPNJLP/0H54ZEYqLm839T1BFnLt2Rq404cL8z0jasxe9thD1O2+LJWUEQbgr73LORbd79242b95M165dcXV1JSMjgy1btnDgwAEWLFhg2G/w4MH07NkTX19fFAoFmzdvRqlUVmrCzrKq8CveG2+8Ycw4BKHaFGZlEfPDRuJ+/R1JpwO5HNdH++Dx3DMorWtuQPf9BIW44+RizQ+rj5KemsuqL/7hiWebE9jCrcZicuzQHpmJCefnzCdl/7+c12rxe3cccmXNTygqCELt5+HhgUajYf78+aSlpWFvb4+fnx/ffPMNrVu3NuwXEhLC5s2biYmJQS6Xo1arWbJkSbVMv2T0JWKEW8TM5g8WbW4usVu2EfvLVnS5uQDYh7ak4YgXH4huvLLKy9Xw8/oTRJ1LAqBzL1+69FQjq6FxUwBpx44TETYHqbAQ+5Yt8JvwbrmXzBGEh42Y2bxm1fjM5v379+fChQtl3l+v19O/f3+ioqIqWqUgVIiuoIDrm37h2KjRXPtuA7rcXCwaehEwfSoBU9+vVUkUgLmFiudeak3bLkVN5Ht3RPLTuuMUakpOYldd7FuGEDBlEnKVirRjJ4iYFYbuLqsdCIIg1CUV7tqLjIwkPz+/zPtLklTuYwShMrTZ2cT99gexW39Fm1m05IqZmxueQwbj2KFdrb5lXy6X0evxAJxdrNm28RThJ+NIS8nl2RGh2NiZ10hMds2bETB9CuEffkzGqdOc+3g2TaZMEt18giDUaZUaFfr666+Xawr2B2kAr1B3FaSkELtlG/F/7EB/I3E3re+MxzNP49ytS526s6x5aw/sHS34cc0x4mIyWPH5Pzw7IhR3T/saicc2MJDAaVM4O30m6f+d5Pyc+fhNGC8GoAuCUGdV+NXt9mnYy8PevmZe4IW6TZIkMsPDifv1d1L+PQR6PQAWXp40GPgUjh3b16kE6nZe3vV46a2ObFh1hMT4LL7+8l8eH9yMpi3cayQem4AmNJk8kfCZH5N6+AgXFnyG37ixdfb3LwjCw63CiVRYWJgx4xCECtFmZ5O07x/i/9hB7uUrhnKbwADcn3oS+5YhD0VLqH09C0a80Z6f158gMjyRn9edICkhm669amYQul2zYJpMeo+Ij2eTsv9fIpWqonmmanF3qiAIQmlEe7tQ60g6HeknT5H419+kHDqMdGNVcblKhVO3Lrg+1qdal3R5UJiaKXl2RCv++jWCf3dfYt/OSFISs3nyueaYKKu/Nci+ZQh+49/h3Jx5JO3eg9xUhc9rrzwUia0gCA8PkUgJtYKk05EZcY7kfw6Q8u9BCm9bosjCy5P6j/TAuXtXTB7yBbLlchk9+wfgVP/WIPSsjHyeHdkKC8vqnwm9Xrs2qMe+xYVPPydh+07kSmXR2nwimRIEoY4QiZTwwNIVFJBx6jRpR4+RcvBwseTJxNoKp86dce7RDUvvRuKN+Q7NW3tg62DOD6uPcu1yGqu+2M+Q/7XGwdGy2mNx6twRSVtI5OeLiNv2GyZWVng+92y1xyEIglAVRCIlPDAkvZ7cq9fIOHOW9OMnyDh9Br3m1qKdJlZWOLRpjWPH9tgGNRW31d9Ho8aOjHyjA9+uOExqcg6rvtjPsyNb4dGw+m/4cO7eDV1+AZeWLufa9z+gcrDHpXevao9DEATB2EQiJdSYosTpKhmnz5J59iwZZ8LRZmUV28fUyRH70JY4tArFNjhIJE/l5ORizUtvduC7lUeIi8ngm8X/MuD5FjQJdq32WFwf64MmLY2YHzYStWQ5Sltb6rVtU+1xCIIgGJNIpIRqIUkS+fEJ5ERFkR11ieyLRd91d6wCLjc1xaaJP7bBQdiHtsTC00N021WSlY0Zw0a346d1x4kMT+THtcfo2T+Atp2rv0vUc8hgCtPSSdj5Jxfmf0bgjA+wCWhSrTEIglB7rVmzhrCwMLp27crSpUtrOhzASInUmTNnaNq0qTFOJdRykiRRmJFB7tVr5MVcJy8mhtxrMeRcikabnV1if7mZWVHi1DQQm6aBWDX2EZM3VgGVqQnPjmjF9s1nOLL/Cju3hJOekkvvJwORV+P0CDKZDJ/XRqFJTyftyFHCZ4UR/MksLDw9qy0GQRBqp6SkJL788kvq1atX06EUY5R3rEGDBtGsWTOef/55Hn30UZSi+6VOk3Q6CpKTyU9IpCAxseh7QiL58QnkXb9easIEIDMxwbKhF1aNfbD08cGqsQ8Wnh4icaomcrmMPgOaYudgwc6tERzZf5mMtDyeGtoClWn1/Q1kCgV+777D2akzyDp/nrPTZxE8JwxTxwfrxVEQhAfL3Llz6d69O7GxsTUdSjFGefX85JNPWL9+Pe+99x6zZ8/m6aefZvDgwbi4uBjj9EI1kHQ6tDm5aHOy0WZmoUlNQ5NW9FWYlm54rElNozAjwzBzeKlkMszq18fcwx2LBg0wb9AAS++GWHh4iDFONUwmk9Guqw+29uZs+vY/LoQnsHbxvwwe2Qorm+pbfV5hakqTKZM4PWkKeTExhM+YSVDYrId++gpBqM0mTpzImTNnmDp1KmFhYVy+fJnGjRszffr0SvdaHT16lD///JM//viDcePGldiemZnJnDlz2LNnD+np6Tg4OBASEsKnn35aqXrLwiiJ1JNPPsmTTz7JqVOnWLduHatWrWLFihV069aNoUOH0qaNGFBaFSRJQq/RoM/PR5dfgL6g6LsuP7/UMl1eHtrs7KKvrGy0OTmGn3U5ueWqW6ZUYurkhFl9Z8zqO2PqXPTd3N0dMzdXFKamVXTVgjEENHPD2saMDauPEnstg5U3pkdwqm9dbTEobawJnD6FU++9T+7Va5ybPY+AaVNEC6UgcOP1vaCgRuqWm5pWePxkUlISs2bNYtSoUVhZWTF//nzGjBnDzp07USqV6HQ6JEm65zlkMhmK25aU0ul0zJw5k1dffRVnZ+dSjwkLC2Pfvn2MGzcOd3d3kpKS2Lt3b4WuobyM+ooVHBzMnDlzmDhxIj/88AMbNmxg+PDh+Pj4MHToUAYMGICpeIOtNH1hIacnTSH7YhTc5wlZXnIzM5Q21ijt7FDZ26NysEdlb4/ytscqe3uUdrZiuY9azqORAyPf7MC3yw+RmpzL6oUHGDyyFZ7eDtUWg6mTEwHTJnNqwmQyTp3m0rKV+Lw2StxgIDzUJEni9MTJZJ07XyP1WzfxJyhsVoX+H2ZkZLBu3Tp8fX0BMDU1ZcSIEZw8eZLQ0FCGDx/O4cOH73kOd3d3du3aZfj522+/JTc3l+HDh9/1mNOnT9OvX79i6wD37du33PFXRJV89FOpVJiZmaFUKpEkiby8PKZPn87ixYv5/PPPad68eVVU+9CQtFoKEpOKJVFylQq5mRkKM1MUZmbITYsey81MUZiaFX03N8fEygqltRUKSytMrCxRWlujsLS8UWYpWgMeMg6Olox4owPfrzrC9SvpfLP0IAOGNCegmVu1xWDZsCF+494m4uPZJGzfgYWHO279+1Vb/YLwQKqlHyacnZ0NSRSAj48PAAkJCQDMmDGDnDvu1r6TSnVrFYaUlBS++OILZs+eXaz8TgEBAWzatAknJyc6deqEWq2uzGWUi1HfNc+dO8e3337L1q1bKSwspE+fPsybN4/g4GDOnTvHBx98wAcffMCWLVuMWe1DR2FuTuiKJWhzc1GYmhY1w4rWIaGCLK1MefHVdvy87jjnzyaw8Zvj9ErPp20X72qLwaF1KxoOf5HLq78metXXmLu5Yd8ypNrqF4QHiUwmIyhsVq3s2rOxsSn2882bzwpuXIuXl1eZuvZu+vzzz1Gr1YSGhpKZmQmAVqtFq9WSmZmJhYUFJiYmTJ06FVtbW1avXs2cOXNwdXVl1KhRDBkypELXUR5GSaR+++031q9fz/Hjx3FwcGDEiBE899xzODk5Gfbx9/dn7NixvPzyy8ao8qEnV6numZ0LQnkoVQqeHh5qmB5hx5ZwMtLz6NU/AFk1TY/g9kR/cq/FkPjnX5yfu4Cg2R9j6SWmRRAeTjKZDIVZ9d0AUl3K27UXHR3N0aNHadWqVYn9WrVqxfLly+ncuTPW1tZMnjyZyZMnc/78edauXcuMGTPw9fUt9VhjMkoi9c477xAQEMDHH39M37597/oG36BBAx5//HFjVCkIgpHdnB7B1t6CP7dFcGhvNJnpeTw5pAVKpeL+J6gkmUyGz6v/Iz8+nswzZ4mYFUbw3E9Q2dlWed2CIFSP8nbtvf/++4aWqJs+/vhjzMzMeOedd/Dz8ytxvJ+fH5MmTWLjxo1cunSpdiRSb775Ji+++CJWpdy6nJOTQ3h4OK1atcLDw4OwsDBjVCkIQhWQyWS07+aDja0Zv3x/kohT8WRnHuTZka2wsKz6FlC5Uon/hHc59e5E8uPjOffJHJrOnC6mzRCEOsLbu3xDBpo0KbnygY2NDRYWFsVmBBg8eDA9e/bE19cXhULB5s2bUSqVhIaGVjrm+zHKwJqFCxdy6dKlUrdFR0fz4osvGqMaQRCqSdMQd54f1RpTMxOuXU5j9cL9pKWUb4qMilLaWNNk6iQUlhZkRZwjavGy+46pEATh4RYSEsLmzZt56623ePPNN4mJiWHJkiWGwe5VySgtUvd6kdNqtcjFQGhBqHUaNnZkxBtF0yOkJOWwauF+nnupFW4edlVet0WDBvi9O47wDz8i8a9dWPn64PponyqvVxCEivvkk09KlDk4OHD+vHGncfjmm29KlL333nu89957Rq2nrCqc4WRnZxMbG2uYqj0pKcnw882vS5cusWnTJhwdHY0WsCAI1cfZxZqX3uxIfTcbcrIK+Pqrf4mMSKiWuu1bNMfrhecBiF6xmsyIc9VSryAIQnlUuEVqzZo1fPnll0DRuIoxY8aUup8kSbzyyisVrUYQhBpmbWvG8Nfb8ePXx7h0IZnvVx2l78CmhLT1qvK63Qc8QfbFi6Ts/5dzs+fSfME8VA72VV6vIAhCWVU4kerQoQMWFhZIksTcuXMZOnQobm7FJ/FTqVSo1Wpat25d6UAFQag5pmZKnnu5Ndt+OMXJozFs+/E0Gen5dO2trtJZyGUyGb5vvE7etZgby8jMpemsGWLwuSAID4wKJ1ItWrSgRYsWAOTl5fH0009Tv359owUmCMKDRaGQ8/jgZtjYm7NvZyT7dkaSmZZHv6eDUZhU3ThIhbk5/pPe4+T4CWSdO0/0yjX4vPq/KqtPEAShPIzy6jdmzBiRRAnCQ0Amk9Gtjx/9ng5GJpdx8mgM3608TEF+YZXWa+7mhnrsWwDE//4HCX/tus8RgiAI1aPCiVRsbCyFhYWGx/f7EgSh7ghp68ngkaEoVQouXUhmzZf/kpmRV6V1OrQKxeO5ZwGIWryMrMiLVVqfIAhCWVS4a69Hjx5s2LCB4OBgunfvft9xEhERERWtShCEB5Bvk/oMG92O71YeISE2k1Vf7GfI/9rg7GJdZXV6PDOI7ItRpB05yvnZc2m2YC7KO9b2EgRBqE4VTqQ+/vhjPDw8DI+rcsCpIAgPJjcPO0beNtfU6oX7eXZEKA0bV82UJzK5HPXYNzk5fgL5sXGcn7uAwOlTkSmqfgkbQRCE0sgkMWVwlenRowcAf/31Vw1HIghVKzdHw4ZVR7h2OQ2FQs4Tg5vRNMS9yurLuXKVU+9NQp+fj/tTT9Jw2AtVVpcgVJX8/Hyio6Np1KgRZnVwgeIH3b1+/+V5/65wi1R5xz3dOTWCIAh1h4Wlihdebcumb08QcSqen9efICU5h849fauktdrSyxPfN0Zzfu4Crv+8GWu1L/XatTV6PYIgCPdT4USqLOOibifGSAlC3WaiVDDohZbs3BbBwT2X2LP9AskJ2Tw+uBlKpfG73hw7diDrQiSxv2zlwmcLaebRAIsGDYxejyAINat79+5cv369RPmpU6cwNTWtgYiKq9QYKTEuShCE28nkMno9HoCjsxW//XSas//FkpaSw7MjWmFta/yui4bDXiA76hKZZ85yLmwOwXNnY2JhbvR6BEGoWb1792bkyJHFylQqVQ1FU1yFE6mnnnrKmHEIglCHhLT1xMHJkh/XHCX2WgYrPtvHsyONv+CxTKHA791xnHxnPHkx17n4xSL8JowXH/IEoY5xdHSkefPmNR1GqapuOmJBEB5qDX3q8fLbHXGqb0VWZgFrvjzA2f+MP6ecys4W/wnvIjMxIeXfg1zf9IvR6xAE4f4mTpxIv379OHToEE8++STNmzdn0KBBnDlzpsrrzszMZMqUKXTq1ImgoCC6dOnC2LFjq7xeqORgcycnJ5RKZZkGnovB5oLw8LGvZ8nINzvw07oTXIxI5KdvjpOUkEWXnmpkcuO1Gln7qfH+30tELV7KlW/WY+XjjV2zYKOdXxCqmyRJFGp0NVK3UqWocKtuUlISs2bNYtSoUVhZWTF//nzGjBnDzp07USqV6HQ67jdZgEwmQ3HHlCZbt27lhx9+QKlUEhoayvjx4/Hz8zNsDwsLY9++fYwbNw53d3eSkpLYu3dvha6hvMSEnIJQS+n1euKzE4nNSiA9P4tsTQ6SJCGTybBWWWJrZoOdmQ125jY4mNshl9VMA7SpmZLBI1vx541B6Ht3RBYNQn+2GSrTCr8ElVC/d0+yLkSS+Ncuzs9dQLMFczBzdjba+QWhukiSxOpFB4i5nFYj9Xs0tGf4mPYVSqYyMjJYt24dvr6+AJiamjJixAhOnjxJaGgow4cP5/Dhw/c8h7u7O7t23VoGqnv37gQHB+Pm5sa1a9dYsmQJQ4YMYfPmzYb5LE+fPk2/fv0YMGCA4bi+ffuWO/6KEBNyCkItEp+VyMGYE5yKj+B8yiUKdWVb487UxBRPG1c87NzxsnXHx8GLRvYeKBXKKo64iPzGIHSn+lb8+tNpwk/GkZyYzTPDQ3FwtDRKHTKZDO9XXibn8hVyoqI4FzaHoI9nojAXg8+F2qe2vqM6OzsbkigAHx8fABISEgCYMWMGOTk59zzHnYPIp0yZYngcGhpKhw4dePTRR1m5ciXTp08HICAggE2bNuHk5ESnTp1Qq9XGuJwyqXAidXvWJwaeC0LV0ev1HIw5zh+RuzmXHFVsm6lChbuNC3bmtlirLFHI5OgliUxNNhl5maTnZ5JekEmBtoDI1MtEpl42HKuUm+Dj4IXa0Qc/R2/U9Rpha1a1y620aFM0CH3j2uMkxmWx/NN9DHi+BeoA4yx6rjA1xX/ieE6Nn0DOpWjOz/uUJu9PEDOfC7WKTCZj+Jj2tbJrz+aOJZuUyqIPawUFBQB4eXmVqWvvXpydnWnZsiVnz541lE2dOhVbW1tWr17NnDlzcHV1ZdSoUQwZMqQil1EuxmtXFwTBqCRJYv/VI/x45lfishOBoheY4Pr+tHQLpml9P9ys69+3y06n1xGfncSV9OtczbjO5fQYIlOiySrI5lxyVLHkzNXKGT8nH/wdG9PEqTEuVk5Gb2328q7HqLGd+PHrY8RcSeP7lUfo3NOXLr2MM27KzNmZJpMncWbKNNKOHuPS8pV4v/I/0Wou1CoymcyoXd8Piop07ZXmzmTM2tqayZMnM3nyZM6fP8/atWuZMWMGvr6+tGrVqtJx34vR/ko6nY7ff/+dQ4cOkZ6ejp2dHW3atKFPnz6YmNS9J4MgVKVLqVdYeXwDkSnRAFipLHnUtys9vDviYGFXrnMp5ArcbVxwt3GhPS2BohehuOxELiRf4nzyJS4kR3EtM4647ETishPZHf0vALam1obEyt/Rh4b2HpjIK9+6Y21rxrDR7dix5SxH9l9h785IYq+lM+D5FphbVH5uGGs/Nep33ubc7LnE/74ds/r1cR/wRKXPKwhC5VSka+9OCQkJHD9+nCeeKP3/tJ+fH5MmTWLjxo1cunSpdiRSqampvPzyy4SHh2NiYoKdnR3p6en8+OOPrFq1ihUrVuDg4GCMqgShTtPoCtl49le2nNuJXtJjamLKgCa9ecy3G2ZK401oKZPJcLOuj5t1fbo2agdAtiaHC8mXilqpki5yMfUKGQVZHI75j8Mx/wFFXYm+9RrhfyO5UtdrVOG4FCZyHn0qCHdPe7b9eIqL55JY/uk/PD2sJa4NbCt9jfXataHRyOFEr1zN5TVrMXV2wrFD+0qfVxCEivP29i7X/tu2bWP37t107twZZ2dnrl27xrJly1AoFIwYMcKw3+DBg+nZsye+vr4oFAo2b95suMOvqhklkQoLCyM6Opp58+bx6KOPolAo0Ol0/Pbbb0ybNo2wsDDmzp1rjKqqXFpaGu+++y4xMTEolUqCg4OZNm3aAzODqlB3xWUlsmD/Mq5kFC2F0N4zlBebD8TB3K5a6rdSWRLiFkSIWxBQlNRdSr3KueSLnEuO4nxyFDmaXM4knudM4nkA5DI5De0aoHb0prFDQ7wdPHGzqo9cXvY7BINDG+Dsas0Pa46RnprLqi/20/PxJrTq0LDS3XFuj/cjPyGBuG2/cWHB58hVKhxaVf0LqyAIxtGgQQMSEhL4+OOPycrKwtramrZt2/Lmm28abngDCAkJYfPmzcTExCCXy1Gr1SxZssQw2L0qyaT7jfoqg9DQUN544w2GDRtWYtuaNWtYtGgRR48erWw11SI9PZ3IyEhatWqFXq9n/PjxBAQE8PLLL5f7XOVZPVp4uB28dpzFh78hT5uPrak1/wsdQusGzWs6rGL0kp7rmfGcS4oiIvki55MukpSbWmI/MxNTGtl74mPvibeDFz4OXmUaa5WXq2HL9yc5f7bo7h7/IBf6PxNc6a4+SafjwoLPSf5nPzITE/wnviuSKeGBkJ+fT3R0NI0aNcLMzPhLKAn3dq/ff3nev43SIiVJUrHbHW+nVqvvO0L/fq5cucLKlSs5efIkkZGReHt7s23bthL7RUdHM2vWLI4dO4a5uTl9+/Zl/Pjx5XqC2tnZGfpT5XI5TZs2JSYmplLxC8LdaHVa1p38md8i/wagiVNj3mr3UrW1QpWHXCbHw9YND1s3ejbuBEBybirnkqK4mHqZS6lXiE67Rr62gIikSCKSIg3HmivN8LJ1x9POHU9bd7zs3PGwdcNCeWtqAnMLFc+MCOXwP5fZuTWcc6fjiYvJYOALITTwsq9w3DKFAvU7byFJelL2/8u5sDk0HjMa5+5dK3xOQRCEm4ySSLVv354DBw7Qvn3J8Qf79++ndevWlTp/ZGQke/bsoVmzZuj1+lITs8zMTIYNG4abmxtffPEFqamphIWFkZ6ezrx58ypUb0FBAZs2beLdd9+tVPyCUJrM/Czm7l/K+Rt3zT3h34vBQY+jMMJg7uriaOFARy8HOnoVffjQ6/Vcz4onKvUKUalXuJR6hcvpMeQV5pe4QxDAybLejQTLjQY2rrhZu9CsrSseDe356ZvjpKXksmbRAbo/5k+7Lt4VvquvKJl6m0iFCcl79xH5+ULyExPxeGYQsnJ0QwqCINypwolUenq64fHo0aMZM2YMOp2O/v374+joSHJyMlu3bmXHjh0sWrSoUkF2796dRx55BChay6e0dXu+//57MjMz2bx5s2Fgu0KhYPz48bz22muGftLnnnvOMDHY7Xx8fFi+fLnhZ71ez4QJE2jbti2dO3euVPyCcKfYrATC9n5JQnYSFkpzxrQZRqh7s5oOq9Lk8lutVjcHsWv1Oq5nxnE1PZYrGde5lnGdK+nXSc1LJyknhaScFI7Gnip2nnoW9ri1csU8woO8Kyb8uS2C8xFxDBzSEhu7ik2wKTcxQT32TUwd63H9581c+24DmeERqMe+icq+4i1egiA83Co8Rsrf37/YmIebp7lbmbGWiLmZSN3ZtTd06FCsra1ZvHixoUyj0dCyZUvGjh3LyJEjy1XPtGnTyMnJYe7cufcc23GzH7U0cXFxuLq6ijFSQjERSZHM/Wcp2ZocnCzrManz6zSwca3psKpdVkE2VzNiuZp+nasZscRmJRCbGU9GQdatnSSwT/LA9UogckmBzqSQwoBYHBurqG/lSH0rJ1xufK9nbl/mQe4Jf+7i0rIV6AsKMLG2wmPws7j06YVcTNUiVCMxRqpm1fgYqddff/2BmuAuKiqKgQMHFitTqVR4enoSFRV1l6NKN2fOHBISEli0aNEDdY1C7ffPlcN8dfgbtHotjR0a8l6n17Cr4tnEH1TWplYEOqsJdC6+lEN2QQ6xWQlcz4znelY8193jia8fjtlpT8xzbVGc8uLa9RgON9yFXqE1HGciN8HZsh71rZyob+WIi5XTjUTLCWfLesWWw6n/SHes/dRcmP8ZOdHRRC9fSdy2X3Ht+yjO3bphYlW5ZWskSUKXl09hRjrazCz02kIknR5JpwO9HrmpKQpzcxTmZigsLFBaW4vZ1x9iRrjnS6gAY/3eK5xIvfHGG0YJwFgyMzNLTE0PRdPVZ2RklPk8kZGRrFy5Em9vb0Ni1r59eyZMmFDq/vfKVu/VWiU8XCRJYlPEH3x/egsArRs05402IzA1EdNq3MnK1BK1qTdqx+LzzRQ8oeH3305xan889ikNcMx3g+bxJJpeJzE3Ba1eW9SqlVWy616GDAcLuxtJlaMh0XKePBq7Q2dJ2PAz+XHxRK9YzeU132Dt74dtUFPM3d0xc3ZCYW6OTGmCPr8AXX4+urw8dLm5aNIzKExPpzA9g8KMDDQ3H6eno9doynzNMhMTTB3rYersjKmzExYeHlj5eGPZqFGlkzrhwXVz+ZTc3FzMxZqQ1S43Nxe49XeoqDrfji1JUrlalXx9fTl//nwVRiQ8bLR6HcuOrjfMFt7P7xGGNhtw36VdhOJMTVU8OSCUkOapbP72P9JTc+GAG/27dqLz441J12aSkJ1EfFYSCTlJxGcnkZCdTEJ2EvnaAlJy00jJTeMsF0qc266/HS1i7Gh8NhWL5Gwyz5wl88zZUqIoH7mZGUoba+RKJTKFoqjVSSZDX1CALi8fbW4u+vx8JK2W/PgE8uNLJoFmLi5Y+/th1ywY22ZBmNarV+m4hAeDQqHAzs6OxMSiJaAsLCxEL0g1kCSJ3NxcEhMTsbOzQ1HJ1mCjJVKXL19mw4YNREVFkZ+fX2ybTCbj66+/NlZVpbKxsSEzM7NEeVZWVrVMyCUIpcnR5LLgwDJOJ5xHJpMxssWz9PbtUtNh1WqejRx4ZVwn/th8lpNHYjjwdxQXzibQ/9lmBDX0J6i+f7H9JUkioyCLxOzkG8nVjQQrpyjJSs/PJF3K5293+NvNHNtsFV5xGuqnarHL1GGdp0elBYUeMFUiMzPFxMwclaUllg6OqOzsUdrZorKzQ2lni9LODtWN74oyjHuRdDo0qankJyZRkJhIfkIiuZcvkx0VXfRzfDz58fEk7d4DgLlHA+xbhuDYvh1Wal/xxlvLubi4ABiSKaH62NnZGX7/lWGUROrChQs8++yzODs7c/XqVfz8/EhLSyMhIQFXV9dis49WFR8fnxJjoTQaDVevXi0xdkoQqkNSTgqf7P2Sa5lxmJqYMrbdS4ZZw4XKMTVT8sTg5vg3deHXjadJTsxm9aL9tO3sTbdH/VAqb33ClMlk2JnZYGdmU6K7ECBfW2BIshJzbiRbvsmczk4iKScFnaQvJQI9kIVClkN9q1zcbXS426hoYGOLu40Z7tZ2KMq4dI5MocDUyQlTJycIDCi2rTAri+yLUWSeOUv6yVNkX4wi71oMeddiiN28BVMnR+q1b4djp45YNfYRSVUtJJPJcHV1xdnZmcLCwpoO56GhVCor3RJ1k1ESqQULFtCxY0c+/fRTmjZtykcffURgYCC7d+/m/fff5+233zZGNffUuXNnFi9eTFpaGvY3bmXeuXMnGo2GLl1EC4BQvaJSrzB731ek52dib27LxE6v08i+6j9QPGz8mrrg6e3A9l/COXU0hoN7LnHhbAKPP9sMT++yre9pZmJaNFGonXuJbTq9jpS89ButWDe7CotasuKyE8nXFhjGZR25frLYsfUs7Glg44K7jStetu40sveggY0rJoqyv+wqra2xb9Ec+xbN8XrheQqzssg4dYaUgwdJPXyUgqRkYn/ZSuwvW7Fs1Ij6vR/BqXMnTCzFuKraRqFQGO2NXaheRlkipnPnzkybNo1u3boREBDAjz/+SFBQ0SfvFStWsHv3btatW1fh8+fl5bFnT1Gz9vr167l27RoTJ04EoHXr1jg4OJCZmUm/fv1wd3dn9OjRpKSk8Mknn9CxY8cKT8hZWWKJmIfTwWvHWXRoDRpdIV627kzs/Dr1LMQ8RVXtQngCv/54iqzMApBB644N6f6oPyrTqhkKKkkSqXnpXM+MJyYzruguwxtfxaZwuI1CrqCBjSuN7DxoaN+AhnYeNLRrgIWq/AONdQUFpB//j+T9+0k5eBjpRmuG3NQUx04dcX+iPxaeInkXhIooz/u3URKp5s2bs2LFCkJDQ2natClLly6lQ4cOABw8eJDXXnuNEydOVPj8MTExd70Dbu3atbRp0wYovkSMmZkZ/fr1K/cSMcYkEqmHy5135jVzCWBs+5eLLYMiVK38vEJ2bAnnv8PXALCvZ0G/Z4Jp1NixWuPILsghJjOe65lxXMuM40p6DJfTrpFTmFfq/q7WzvjWa4S6XiN863njaetWrhnuC7OySNq9h/jtO8m7dmtJK/vQlrgPeAKbwADR7ScI5VDta+3Vr1/fMNO5l5cXR44cMSRS58+fx7KSzcwNGjQo0510jRo1YuXKlZWqSxAqQqMrZMnhb/jn6hEAHvPtxgvNB9aq5V7qAjNzJY8/24yAZq5s++EUaSm5fLP4IM1befBI/yZYWFbPdBNWppb4O/ng73TrRhdJkkjOTSU67RqX02OKvtKukZybSlxWInFZiey9fAgAU4UKbwcv/By9CXRW41fPG7N7jLlSWlvj1r8frv36khVxjtgtW0k5eJi0o8dIO3oMK19fPIc8i12L5iKhEgQjM0qL1KRJk7C3t+e9995jyZIlLFy4kCeffBKlUsmmTZt4/PHHmTlzpjHirVVEi9TDISU3jQX7lxGZehmFTM7IkMGGRX2FmlOQX8if2yI49u9VACwsVfR6IoCgEPcHKpnIKsjmYuplIlOib3xdJveOliuFTI63gxcBTr4EOqvxd/S5Z2IFkHc9ltgtW0nctdswp5V1E388hwzGLljc9CAI91LtXXtXr14lMTGR0NBQdDodYWFhbN26FYBu3boxZcoUrKysKltNrSMSqbrvdMI5Pv93JZkF2ViqLBjX/n80veP2e6FmXY1O5dcfT5GUkA1AI19H+g4KwsHxwRyQrZf0xGYlcCE5moikSMKTIknKSSm2j0KuwN/Rh+YugTR3DcDT9u7JoSY9nes/byb+9+2GhMo2OIiGw1/EyqfkXYyCINRAIiWUTiRSdZde0rM5YjsbzmxFkiS87BowrsMoXKycajo0oRQ6rZ4Du6PYuzMSnVaPiYmcTj19ad/VB4XJgz8xamJOCuGJFwhPiuRs4oUSiZW9uS3NXAIIcW1Kc5eAUlurClJSidn4Ewk7/kTSakEmw7l7N7yGDkHlIG6GEITb1UgipdPp+P333zl06BDp6enY29vTunVr+vTpg8lDuhCoSKTqpsz8LL46vJbjcWcA6NaoPS+FPItKLPfywEtNzuHXjaeJjkwGwNnFmr6DgvBoVLapEh4EkiQRn53Ef3Fn+S8+nLOJ59Hobs0/pFQoaVa/Ca0bNKelWxDWpsV7A/ITE7m67juS9uwFimZfb/DUk7gPeAK5SjyHBQFqIJFKTU3l5ZdfJjw8HBMTE+zs7EhPT0er1RIQEMCKFStwcKg9L1TGIhKpuudY7GmWHFlHRn4mSrkJL7UcTHfvDjUdllAOkiRx+th1dmwJJzdHAzJo2daLHn39MTOv3JpbNUGjK+Rc0kX+izvLkdhTJGQnGbbJZXICnHxp06AF7TxCsDGzNmzLOn+B6JWryTpftGSOmasL3q/8D/sWzav7EgThgVPtidS7777Ln3/+ycyZM3n00UdRKBTodDp+++03pk2bRo8ePZg7d25lq6l1RCJVd+QX5rP2v5/489I/ADSwceXNtiNoKCbZrLVyczT8uTWC/44UTZVgZW1K7ycCCWju+kANRi8PSZK4lhHLoZgTHL5+kivpt6ZCUMjkBLsE0MmrFaHuzTAzMS26k3DfP1xevRZNaioAjh070OilEaK7T3ioVXsiFRoayhtvvMGwYcNKbFuzZg2LFi3i6NGjla2m1hGJVN1wKj6C5ce+M3zS76fuweDgJ1Apal/rhVDS5YvJ/LrxNClJOQB4q514bGDTB3YwenkkZCdxKOY//r16jKi0K4ZyUxNTWrk3o7NXa4LrN0Gfn8/Vb78n7tffQa9HYWFBw+EvUL9Xz1qbVApCZVR7ItWyZUsWLlxI+/btS2w7cOAAb7zxBseOHatsNbWOSKRqt9S8dNae2MiBa0XP3XoW9rze+kVxV14dpC3Usf/vKP756yI6rR6FiZxOj/jSvps3JiZ1Yy6w2Mx49l05wj9XDpOQk2wor2dhTw/vDnRr1B7TuDSiFi8lO/IiALbNgmn8+muY1XeuqbAFoUZUeyL1xhtv4OXlxfjx40tsmzt3LpcuXWLx4sWVrabWEYlU7aTV69geuZsfzmwjT5uPTCajd+MuDG76eIWW8hBqj5SkbH776YxhMLqjsxWPDWxKw2qeGb0qSZJEZEo0/1w5wj9Xj5CtKWqJk8lktHBtSo+G7XE9doVr679Hr9EgNzOj4fAXcOndC5n8wb/DURCMoVoSqZszmQPExcUxZswYevXqRf/+/XF0dCQ5OZmtW7eyY8cOFi1aRJMmTSpSTa0mEqnaRa/X88/VI/x4ZpvhE3tjh4a83PI5vB08azg6obpIksSZE7Hs+OUsOdlF8y4FhzagZ/8mWFqZ1nB0xqXRFXI45gR/Rv1DeFKkodzB3I5H7Zrh+etJcs8VDUa3a9Ec37fGoLIXY6eEuq9aEil/f/9ifec3T3O3soiIiIpUU6uJRKp2kCSJI9dPsuH0Fq5lxgFga2rNs0H96e7dAblMfAp/GOXlatj123mOHbwCUtHyM4/0a0KL1h7I5HVv3FBsZjx/XdrP7ssHySoomrxUKTdhQKIjbn9HIBUWorS1ofEbr+PQKrSGoxWEqlUtidTChQvLNQhxzJgxFammVhOJ1INNo9Ww98ohfr2wi+uZ8QBYKs153L8Xj6q7YWZSt1ofhIqJuZLGrxtPkxCbCYBHQ3v6DgrC2dWmhiOrGoW6Qv69dpxfL/xFdFrRHY0OGVoGHC7A6saAfJfH+tBw+IsoTMX/EaFuEjObPyBEIvVgSsxJYdelf9h5cR9ZN8aHmJmY8pi6G/39emKpsqjhCIUHjV6n5/A/l/n7j/MUanTI5TLadvGmc09fVKZ1c8JhSZKISLrIbxd2ceT6SeQ6Pe3/yybkfNE6gOYeHviNfxvLhg1rNlBBqAIikXpAiETqwZGryePfa8fYe+UwEbeNBXGyrMejvt3o3qi9GEgu3FdGWh5/bD7D+TMJANjam/PoU01RB9Sv4ciqVkJ2Er9f+Ju/og/gcjWTngezsMzXI5koaDRyOG6PPSqmSRDqlBpNpKKjow1LxDR8yD+piESqZqXmpXM89jTHYk9zKj6CQr0WABkyAp3V9PbtQiu3ZsjFnUhCOZ0/E88fm8+SkVbUOuMf5EKfJwOxsavbyXhWQTa/R/7N3yf/pMM/iTSKLRqMr23hR5t3J2FmaX2fMwhC7VAjidTvv//OnDlziI+PN5S5uLgwYcIE+vTpY4wqah2RSFWvXE0e55KjiEiK5FRChGF8x00NbFzp3LANnbxaU89C3HkkVI6mQMueHRc4uDcaSS+hMlXQtbcfrTs2RK6o28l5bmEeOyL3EP3zz4QeTUEuQbqdCotXh9C5zWMo5HVj7i3h4VXtidSePXt49dVXady4MU888QTOzs4kJCSwZcsWoqKiWLx4MV26dKlsNbWOSKSqjkar4WpGLNFp14hOv8bFlGiupF9H4tbTWYaMxvUa0tItiBDXILzs3EX3g2B0CXGZ/PrjaWKupAHg4mZD36eDcPes+8l6gVbD7j9/QP71FixydWhMZBzr6kHHJ1+gdYPm4o5Xodaq9kRq8ODBWFlZsWzZsmLdJJIk8fLLL5OTk8P3339f2WpqHZFIVY5WpyUpN5X47ETis5KIy04kITuJ+Kwk4nOSKO2p62rljL9TYwKcfGnmGoCdWd28s0p4sEh6iROHr/LntnPk5xWCDELbedH9sdq5EHJ55SQlcuTjmSgvxQJwws+cmG5NGNx8AM1cmogPMEKtU573b6PcbnLu3DkWLFhQYqyJTCZjyJAhpc54LjwcJElCp9eh0RWi0WnI1eaTq8kjpzCXHE0euTe+ZxRkkZ6fSUZ+Bml5maTnZxpmXL4bW1NrGtp70OjGl79jY+zNbavpygThFplcRkhbL/wCXdi5NZxTx65z9MAVIk7H0/vxAAJbuNXpZMLSyZku8z7j4tq1JG7eRovzeTinnubTxKt4e/ozrPnTNLRvUNNhCkKVMEoiJZfLKSwsLHWbVqut0y8gNUGv1zP/wDKuZsQioyhhlSNHJpPdeCy77bEcZNwoK9pHLpMhu7GPXCYDbi+TG86BTIZe0iNJevSSHr0k3fFdj3TbY70kUagrNCRNGl0hGn1hqS1HZaVSKHGxcsbFygkX6xvfrZxws6mPvZmteG4JDxRLa1OeHNKCZq09+O3GQsg/rz/Bf0eu8djAoDqxEPLdyBQKfEeMwCEgkAuffoF7Uh6Dt6extfNZJiRG0t27A88G9RetxEKdY5SuvWHDhpGbm8s333yDmZmZoVyj0fDCCy9gYWHB6tWrK1tNrVNVXXu5mjxe2TKRAp3GqOetDuZKMyyVFlgqzbFQ3fiuNMfG1Ao7c1vszGywM7PB/sZjK5WlSJaEWkmr1XHg7yj2/XlrIeSOPRrTobtPnVkI+W5yr8UQ8VEY+XHx6JQKfm9rRZSHKeYmZgwI6MNj6u6oFHW/y1Oovap9jNTRo0cZPnw4dnZ29OnTB0dHR5KSktixYwfp6el8/fXXhISEVLaaWqcqx0hl5GeSkJ2MXpIACb0kISHdaD26+Vgq9vhWmb749jv2KSor2kcuk9/2dbMV61aZDFmx7SqFEpVCifLGd5VCZSgzkZuIpEh46KQm5/DbT6e5dKFo/cZ6TpY8NjCIRr51ZyHk0hRmZXF+7gIyTp4C4Fwbd7Z7a0Amw9myHi82H0Qr92biNUF4INXI9AdHjhxh3rx5nDp1CkmSkMvlBAcHM27cOFq1amWMKmodMdhcEAQoGit49r9Ytv8STk5WAQBBLd3p1T8AS+u6u8yKpNMRvXINcb/+BoC+uR/fNdOSXJgFQAvXpowMeYb6Vk41GaYglFCtiVR+fj49e/ZkxowZdO/enby8PDIzM7GxscHcvG5PTnc/IpESBOF2+XmF7PrtHEf/vbUQco++/oS08ayTCyHfFL9jJ5eWLEfS6bDwaUTkoFA2X9+PVq9FqVDyVJM+PO7fE6Xo7hMeEOV5/670JB9mZmYUFBQYkiZzc3Pq16//0CdRgiAIdzIzV/LYwCBGvtEBFzcb8vMK+XXjadZ8eYDkxOyaDq/KuPTqSeDMaZjY2JAbFY33qr/5OHAEQfX9KNQVsuHMVsZvn8XphHM1HaoglJtRZktr27Yt//77rzFOJQiCUOc18LLn5bc70uuJAJQqBdcup7F0/l7++esiOp2+psOrEraBgQTPCcPMzZWCpGTiZ37KGLtuvNVuJHZmNsRlJTJz9+d88e8qMvOzajpcQSgzo4yRCg8P54033mDAgAH06tULJyenEgMI7ezsKltNrSO69gRBuJ/01Fx+/ek0UeeSgKKZ0fs/2wzXBnVzTrTCzCzOhc0mMzwCmUKBz+uvYt2pHd+f2cL2i3uQJAlrUytGhjxDe49QMRhdqBHVPtjc39//1gnv8qSPiIiobDW1jkikBEEoC0mSOH3sOtt/OUtebiEyuYz2Xb3p3EuNUln3pkrQazREfrGI5H37AWjwzCA8hwwmOu0qiw9/w5WM6wCEugXzcuhzOJjb1WC0wsOo2hOphQsX3vdTw5gxYypbTa0jEilBEMojO6uAPzadIfxkHFA0VUK/Z4Lx8q5Xw5EZn6TXc3X9d8Rs/BkAp66daTxmNHq5jM3ndvBT+G/o9DoslOa82Hwg3Rq1F61TQrWpkekPhJJEIiUIQkWcOx3Pbz+fJjuzaKqE0PZe9Ojrj6lZ3burLX7Hn0QtXgp6PXYtmuM/YTwKc3Oupl9n8ZFviEq9AkBQfX9ea/0CjhYONRyx8DAQidQDQiRSgiBUVH5eIX9ui+D4wasA2NiZ0XdQML5NnGs4MuNLO3acc7PnoS8owMrXl4AP3kdpY4NOr+PXC7vYcGYrhbpCLJTmvNxyMB29Wtd0yEIdVyOJlE6n4/fff+fQoUOkp6djZ2dHmzZt6NOnDyYmRlnSr9YRiZQgCJUVHZnMth9PkZaSC0CL1h70fDwAM/O61TqVdf4C4TM/QpuVjbm7G4EzPsDUqWiiztisBBYdXMPF1MsAtPcM5eWWg7FS1d21C4WaVe2JVGpqKi+//DLh4eGYmJhgZ2dHeno6Wq2WgIAAVqxYgYPDw9ccKxIpQRCMoVCjY9fv5zi0Lxqkotap/s80w8evbs0InnsthrPTZ6JJTkZVz4HA6VOx8PQEQKvXsSn8d34K/x29pMfB3I7RrV8k2KVJDUct1EXVOiEnQFhYGNHR0cybN4+TJ0/yzz//cPLkSebOncvly5cJCwszRjWCIAgPJaVKQe8nAhk2uh329SzITM9n/bJD/LrxFAX52poOz2gsPBoQPPtjzD0aoElJ5fSkqWRGFE3SaSJX8HTTfszq8S6uVs6k5qUza88XrD7+AxpdYQ1HLjzMjJJI/f3337z99tv069cPhaLoVl2FQkH//v158803+fvvv41RjSAIwkPNy7ser4zrTKsODQE49u9VlszbQ3Rkcs0GZkSmjvUICpuFtb8f2uxszn4wg9QjRw3bG9dryOze79PLpzMAv0f+zeSds7meGV9TIQsPOaMkUpIk4evrW+o2tVqNGM8uCIJgHCpTEx59qikvvNYWOwdzMtLy+GbJQX7/+TSagrrROqW0tibww2nYh7ZEr9EQ8fFsEv7aZdhuZmLKy6HPMbHT69iYWnEl4zoTd4SxO/pf8X4jVDujJFLt27fnwIEDpW7bv38/rVuLOywEQRCMqVFjR14Z14WW7bwAOLL/Ckvn7+XKpZQajsw4FKam+E96D+fuXUGv5+IXXxK7dVuxfULcmjK39xSaOvtRoNPw1eG1LDy0hrzC/JoJWngoGWWweUREBGPGjKFXr170798fR0dHkpOT2bp1Kzt27GDRokW4uroa9n9YlosRg80FQagOUeeT2PrDSTLT80EGbTo1ovtj/nViVnRJkri8Zi2xm7cA4Dl0CB5PDyy2j16vZ/O57fxwZht6SY+LlRNvt3sZbwfPmghZqAMemCVibp76ztloH5blYkQiJQhCdcnPK2TnlnBOHL4GgFN9KwY83wIX99q/Zp8kSVzb8CPXvtsAgPvAAXi98HyJ95ZzSVF8cXAVybmpKOQKhjUfRO/GXcSM6EK5PZBLxNzuYVkuRiRSgiBUt8iIBLZsOEVOVgFyhYzuj/rTtos3cnntTyaub97C5dVfA+Da91EavTwSmbz4CJVsTQ5LDq/j8PX/AOjo1ZpRoUMwMzGt7nCFWkzMbP6AEImUIAg1ISe7gG0/nOL82QQAvHwcePK5Ftjam9dwZJUX/8cOopYsA0nCuXs3Go95DZmieBemJEn8euEv1p3chF7S42HrxrgOo3Czrl9DUQu1TbXPIyUIgiA8OCytTHlmRCj9nwlGqVJwJSqVJfP2cPr49ZoOrdJc+vTC9+03QC4ncdffnJ//GfrC4vNIyWQy+vk9wrRub2NnZsO1jFgm7fiEQzEnaihqoS4TiZQgCEIdJJPJaNHGk1fGdcbdy46CfC2b1p/gp2+Ok5erqenwKsW5axf83xuPzMSElP0HODd7LnpNyWtq4uTL7F7v08SpMXnafObvX8a6kz+j0+tqIGqhrhKJlCAIQh3m4GjJiNfb06W3Gplcxtn/Ylk6by/RF2v3JJ712rWhyeSJyFUq0o4cI3zmx+jy8krsZ29uy9Sub9PP7xEAtpzbycd7F5JdkFPdIQt1lEikBEEQ6ji5Qk6XXmpGjGmPg6MFmRn5fLPkIDu2hKPV1t7WGfuQFgRMm4LczIyMU6cJ//AjtLklkykTuYIXmw/knfb/w9TElNMJ53n/z9nEZMbVQNRCXSMSKUEQhIdEAy97Rr3TmZC2niDBwT2XWL3wAClJ2TUdWoXZNg2k6YfTUFhakBkeQfiMmWhzc0vdt61HCLN6jMfJwoH47CQm75zD8dgz1RyxUNeIREoQBOEhojI1od/TwTw7IhRzCyVxMRks/3Qfp4/F1HRoFWbtpyZwxjQUlpZknTvP2Wkfos0uvevOy64BYT0n0sTJlzxtPrP3fcWWczvE0jJChRk9kUpNTSU2NrbElyAIgvDg8GvqwivjOuPp7YCmQMemb//jl+//q7Xr9Vn7NqbprOmYWFuRfSGSs9NmUJiVVeq+NmbWTO3yJo94d0RCYt3JTXx56Gs0usJS9xeEezHKPFLZ2dmEhYXx66+/UlBQUOo+D8ts5rcT80gJgvCg0+v07P0zkn07I5EkqOdkycAXW+LiZlPToVVITvRlznwwA21mJpbejQicMQ2ljXWp+0qSxPaLe1hz4kf0kh5fh4aM7/gq9ua1fzZ4oXKqfULO999/n23btjFo0CD8/PxQqVQl9hkwYEBlq6l1RCIlCEJtcfliMpvWnyArswCFiZxe/QMI7eBVK5dXyblylbNTp1GYkYlFQy+afjgNpe3dk6PTCedYcGA5OZpc7M1tmdDxNbwdvKoxYuFBU+2JVIcOHRg1ahTDhg2r7KnqFJFICYJQm+Rma/jl+/+IjEgEwD/Ihf7PBGNuUfLD8YMu9+o1zkydTmF6OhaeHgTOnI7Kzu6u+8dnJzF731dcz4zHVKHizXYjaeXerPoCFh4o1T6zeUFBAWq12hinEgRBEGqIhZWKwS+1otcTAcgVMs6djmfZgn1cjU6t6dDKzcLTg6YffYjS3r4oqZo8DU1a2l33d7Fy4qNH3qO5SwAFOg3z/lnKbxd2VWPEQm1llESqS5cuHDt2zBinEgRBEGqQTCajbWdvRr7RAft6FmSk5fH1V/+yf9dFJH3turPNooE7QR9/iKpePfJiYjgzZTqa9Iy77680Z0Kn0Tzi0wkJiTUnfmTV8Q3o9fpqjFqobYySSL322mv89ttvrF69msuXL5Oenl7iSxAEQag93DzsGPVOJ5q2cEPSS/z16zk2rDla65aXMXdzo+lHH6Kq50BeTAxnP5hOYWbmXfdXyBX8r+VzDG32FAB/RO5mzv4l5BfmV1fIQi1jlDFS/v7+RSe7x6DE2nbX3uTJk9m4cSNnz57FxMSkQucQY6QEQajtJEni+MGr/LHpLDqdHjsHC54e1hLXBrXrzra82FhOv/8BhWlpWDZqRODMaSitS7+b76aD146z8NAaCnWFNLLzYELn0TiY21VPwEKNKs/7d8UyhDu8/vrrtfLOjrv5999/0elq77IJgiAIxiKTyWjZzgvXBrZsXHuc9NRcVi3cT58nAwlp61lrXvvN3dxoOms6ZyZPIyc6mrPTZtL0w2mYWFne9Zi2HiE4mNsx55/FRKdfY/Kfc5jc5Q0a2LhWY+TCg84oLVJV6cqVK6xcuZKTJ08SGRmJt7c327ZtK7FfdHQ0s2bN4tixY5ibm9O3b1/Gjx+PmZlZuerLzc1l2LBhLFu2jLZt24oWKUEQhBvycjX88t1JLoQnABAc2oC+A4NQqhQ1HFnZ5V69ypkpRVMjWPn6EjhjKiaWd0+mABKyk/h47yLishKxUlkysdNo1I7e1RSxUBOq/a6920VHR3PixAkuX75slPNFRkayZ88evLy88PHxKXWfzMxMhg0bRk5ODl988QUTJkxg69atTJkypdz1LViwgBdffBF7e/vKhi4IglCnmFuoeHZEKD36+iOTwamjMaz8/J9atVafhacngR9OK5oBPTKS8BmlL3R8u/pWTszs8S6NHRqSrcnhw92fcSz2dDVFLDzojNYi9fvvvzNnzhzi4+MNZS4uLkyYMIE+ffpU+Lx6vR65vCjfmzhxImfOnCnRIrVs2TK++uordu3ahYODAwBbt25l/Pjx/Pbbb4YE7LnnniMhIaFEHT4+Pixfvpzjx4+zZMkSli1bBoCfn59okRIEQSjF5YvJ/LTuBDlZBahMTXhicDOaBNeeLq/sS5c4M2U6upwcbAKaEDBtCor79GDkawv49MByTsSdRS6TMyr0ebp7t6+miIXqVO0tUnv27OGdd97BysqKcePGMXv2bMPP77zzDnv27KnwuW8mUfeyd+9e2rVrZ0iiAHr37o1KpSpW93fffceuXbtKfC1fvhyAo0ePEh4eTvfu3enevTsAvXr1KpYcCoIgCNCwsSOj3ul0Y60+LT9+fYy/fo1AX0umSLDy9iZwxgcoLC3IDI8gfObH6O6yxNlNZiamvNvxNbo2bIde0rPkyDf8HP67WPD4IWeUFqnBgwdjZWXFsmXLiiU+kiTx8ssvk5OTw/fff1/Zau7aItWuXTsGDhzI+PHji5X37duX5s2b89FHH1WovrK0SN3MWksTFxeHq6uraJESBKHO0uv0/PnrOQ7uuQSAj58TTw1tUWtmQ886f4Gz0z5El5eHbbNgmkyeiMLU9J7HSJLEd6d/YXPEdgB6N+7CiBbPlOmDv1A7VHuL1Llz5xgyZEiJJ5FMJmPIkCGcP3/eGNXcVWZmJjY2JRfYtLGxISPj7pOv1WZ6TT6F6Qlos9PQ5eeg12rEpyJBEKqdXCGn1+MBPPV8C0yUcqLOJ7His39IiL37XE0PEms/NQHTpiA3MyPj5CnOfTIXvebec2XJZDKGBD/JiBbPIEPG9ot7+OzflWh0hdUUtfAgMcr0B3K5nMLC0p9AWq22xm6PlSSpUnWXJQG8V7Z6r9aqytAX5HH1y9fQ52WV2CYzUd34Ut7xXYX8tse3l8uUKmSKop/lNx8rb24zRa40Lfa92GN57blbRxCEqtM0xB1HF2t+WH2EtJSiKRIef6YZgS3cajq0+7Jp4k/AB+8TPuMj0o+f4NycefhPfA/5fcbHPqruhq2ZDYsOreFgzHGy9mbzXsfXMFeW725xoXYzSiIVFBTEihUr6NKlS7HpBjQaDatWraJZs6pd+NHGxobMUmaqzcrKuuudfrWZzESJsp47moRopEINcKslStJqkLTVOPOwwgS50gyZUnXju+n9k69i228cqzJDZmKKTHVj243HMoWy1sxTIwgPOxc3G15+uxM/rzvOpQvJ/LTuOLEx6fR4zB+54sHu9rINDKTJlElEzPyYtCPHuLDgc/zGvY1Mce8Pi+09W2Jjasncf5ZyNvECM3d/zvudx2Bleu8pFYS6wyiJ1BtvvMHw4cN55JFH6NOnD46OjiQlJbFjxw7S09P5+uuvjVHNXfn4+BAVFVWsTKPRcPXqVQYOHFilddcEmcIE92FF474kSQK9FklbiL5Qg6TTIBVqkLSFhqTq1uNC9NqCGz/fvl1T/Hht4Y1zaJAKC4qO0RQgaQvQawqQCgswJG86LXpdNuRD1UxhKruRfKluJWImpkUtZ7cnZXe0nt16fKPc5PZy1a3zqG4cK1rWBMEoLCxVDHm5Nbt+P8+Bv6P4d/cl4q9nMvCFECwsH+xxU3bBQfhPfJeIj2eTsv8AF01NafzGaGT3GfvUtL4/H3R7m4/3LORi6mWm/b2AqV3exM68ds3+LlSMURKp0NBQVq1axfz581m/fj2SJCGXywkODmbBggWEhIQYo5q76ty5M4sXLyYtLc0w/9POnTvRaDR06dKlSuuuaTKZDBRKZAolclOLaqlTkqQbSZYGqTAffWFRcnXz++2Pi5flIxVqbny/ffsd59EUgF57szakwvyi7VV4TUXdmbclbCamRd2fCpMb35WgMCn2c1F3qMmNxze+3zgGw2MlMrmiKFGTy0EuL3osu+O7XF70Yn1z32Lb7/EiftfWuruUS3okSQ96PSAh6fUgFX3denyrXJKkojK9HknSgSTdeKy/9Vivu+28ulvH6nVF9dx2bkl/Yx/DOYt+LnVbsWN1xfYvVkdp+xer4444StR/Wxy3Py7265Tf9vuW3fgnu/X7v62cG+Uymczw9yz6GyuKWjfkJkVlCpNb2xU3tstNkCkUt3XBqwzd7PLbHt8sl998rDJHbmqOXGWB3NS86Llcgy25coWcR/o1wbWBLVs2nCQ6MpkVn/3D4Jda4exy72VZapp9yxD8xo/l3Jz5JO76G7mZKd6jXr7v79PHwYvp3d9h1u4vuJYRywe75jO161s4WdarpsiFmmL0mc3z8vIMg7/Nzc2Ncr6bUxisX7+ea9euMXHiRABat26Ng4MDmZmZ9OvXD3d3d0aPHk1KSgqffPIJHTt2ZN68eZWOoaLEPFIVJ+l1dyRdmqJES3szAdPcSsa0N5OxUpI57W3HGva/dawg1Eky+Y3EyhzZbQmWIdkys0Bubo3C3Bq5hTUKc5vbHlsXJXlGkhCXyQ+rj5KWkovKVMFTQ0NQB9Q32vmrSuLuPUR+thAkCfennsTrxaFlSk7js5OYuftzknJSqGdhz9Sub+Fm/eBfr1Bced6/H/glYmJiYu46aHvt2rW0adMGKL5EjJmZGf369avQEjHGJBKpB1uxljVtAXpN/q3HhTe6QHVaJF1RVyi6Gz9rCw1lRdtv7HN72e3767TFWlaKWkVuttiUbJ25s9UEqQra4mQ3Wsdk8jsey4pawG6UF7WqyG+1jBnKbx5T1OpSrGXt9vMZjr19m+LWPjeONbTIyW7b545jS7TS3V7X7eeRKUrddrPFr1j8d4nPcO03nicgFbXAGV4uix5LSDd6uW/bdmP/om53HZJOd+tvrdfCjZ8lnfZG2Y3tOu2Nct1tXfQaw3NUr73V3S5pNUUfJm6WafLRa/LQF+QZ5fkiM7VAYW5VlGBZ2aOwssfE+sZ3KwdDmcLSpkzd4rk5Gn78+hhXolJABj0e86d9N58Hfvxj/PYdRH21FADPIYPxePbpMh2XkpvGrN1fcD0rHltTayZ3eZOG9g2qMlTByKolkYqNjcXJyQmlUklsbOx993dze/Dv3DA2kUgJVaH0/7KllJW2n0xWlCwIdZIkSUWtrgV56DW56AvykApyDUmW/ubj/Gx0udno87LQ5WXe+J6NPi+7fImYTI7C0haFlQMmto4obZ0wsXPGxNYZE1snlLZOyM2KBl3rdHr+2HSWY/9eASC4pTv9ng7GRPlgj0+M3bKN6JWrAWg4chjuTzxepuMy8jP5aM9CLqfHYKk0Z1LnMWJ9vlqkWhKpJk2asGHDBoKDg/H397/vJ4uIiIiKVFOriURKEITaRJL06PNz0OVmFSVXuZnostOK5qvLSr31ODsNXU5GmZIuuZklJrbOKO1dUDq4Ep7kxN+HNUgSuHva8cyIUKxtHuzpAq79sJGr678DwOe1V3Dp06tMx+Vocvlk75ecT7mEqYkpEzq+RtP6flUZqmAk1ZJIbdq0ia5du2Jvb8+mTZvuu/+AAQMqUk2tJhIpQRDqKkmvQ5eTiS47FW1WKtqMJLSZSWjTk9BmJFKYkYQ+t/RJOeMKXdmX3Q2NZIqlsoA+QUm4NXRG5eyJytkTExunB6rbT5Ikrqxdx/WfN4NMhu9bY3Du1rVMx+ZrC5j7zxJOJ5xDKTfh3Y6v0tw1sCrDFYyg2sdIHTlyhICAACwtS86bkZOTQ3h4OK1atapsNbWOSKQEQXiY6TV5RQlWehKFaXEUpsRSmBqLJjWOtDQNu7N6kKm3Q4GW9lb78FJdBkBuaoHSqSipMnX2QuXshcrJ09BNWBMkSSJ6+Urifv0d5HL83n0Hx/btynSsRlfIZwdWcDT2FCZyE8Z3GEWIW1AVRyxURrUnUrd3893pzJkzPP3006JrTxAEQTDQFxaQHRfD5p8ucjmmaGWMEMeLNJEOIJNKn5VOWc8NUzdfTF0bY+rWGFX9hshNqm9uKkmv5+KixST+tQuZiQn+k97DIbRlmY7V6rR8dnAlh2P+QyFXMK79/wh1r9rJqoWKK8/7t1Hucb1XLqbVasVCjoIgCEIxcqUpNp4+DH3Lm51bwzm0N5rjyY3RhXamV1d7dCkxaJKuoEm8SkHiFXSZyUUtWimxZJ/ec+MkJqicvTB188HMzRczD39M7F2rrFtQJpfT+PVX0RcUkPzPfs7PnkfA9KnYBgbc91gThQlvt3uZLw6u4uC148zfv4yx7f9H6wbNqyRWofpUOJHKzs4utixLUlJSibv38vPz2bRpE46OjhWPUBAEQaiz5HIZvZ8IxMHRkj82neHk0Vgy0gt4elgbHJp2Muyny82kIPZi0VfcRfJjI9HnZqKJj0ITH0XW8R0AKCztMPPwx8yjCWYeAajqexl15QKZQoHv2DfRFeSTduQYEbPCaPrRDKy8739HnolcwVttRyKXyTlw9SgLDiznrXYjaedRtlYt4cFU4a69RYsW8eWXX953P0mSeOWVVxg7dmxFqqnVRNeeIAhC2UVGJPLTN8fQFOio52TJcy+3xsGx9HFRkiShzUiiIO4iBbGR5MdcoCDuIui0xfaTqcwx9wrEvFEzzBsFo6znbpQWK11BAeEzZpF5NhylrQ1BYR9h7l62aX50eh1fHV7LviuHkcvkvNF2OB08H75xxA+yahkjdeLECU6cOIEkScydO5ehQ4eWmCtKpVKhVqtp3bp1Raqo9UQiJQiCUD7xsZl8v+IwmRn5WFiqeGZEKJ6NHMp0rF6roSD2IvnXzpF/LZz8mPNIBbnF9lHYOGLeMBgL72aYezdDYV7xJWu0OTmcmTqdnKhLqBwdCf7kI0ydytYDo9frWXJkHbsv/4tMJmNM6+F0avhwvlc+iKp9sPmiRYt4+umnqV9fTIN/O5FICYIglF9WRj7frzpCXEwGChM5TzzbjKYh7uU+j6TXoUm4Ql70yaKvaxHFW6xkcsw8m2Dh2wpLdSuU9i7lrqMwI4PTk6aQdz0Wc3c3gsJmobQt22LFeknPsqPfsuvSfmTIeK31C3RtVLY7AYWqVaeWiKnNRCIlCIJQMZoCLZvWn+D82QQAuvbxo9MjjSvVLacvLCD/ajh50afIvXSCwqRrxbYrnTyw9G2FhboVpm6Ny7wKQEFSEqcmTkGTnIyljzdNZ83AxKJsi8jrJT0rjn3Pn1H7kCHjlVbP0927Q7mvTTCuGkmkLl++zIYNG4iKiiI/P794JTIZX3/9tTGqqVVEIiUIglBxer3En9siOLjnEgAhbT157KmmyBXGuRO8MC2e3Mij5Fw4Qv7V8GIztSss7bDwa41VQEfMPJvcN6nKjbnO6UlT0GZmYtM0kIAPJqMwNS1THJIkser4BrZfLLobcVToEB7x6XSfo4SqVO2J1IULF3j22Wdxdnbm6tWr+Pn5kZaWRkJCAq6urnh4eLB27drKVlPriERKEASh8o7sv8wfm84gSfy/vfuOq6r+Hzj+OnexNwjiQMGBintrLixH2S8tzbRSy5GabXN/vy1zlGk5G2ppzlIbtrO+jnKP3ANxoIICMi77csfvDxQlUOBy4QK+n48HDy7nfM7n8z4eLvft53zO50PdBlV47OkW6BxsMntPLlNGKhmRh0iL2Ed65KE8Y6vUrt64NOyAa8OOOATWvWOvWGrkOY5NewNTejperVsROul1VJqixWmxWFhx6Gt+ivgfIMmUvZV5IjV69Gi0Wi3z5s0jLCyMjRs30qhRI7Zu3cqUKVNYuHAhLVq0KGkzFY4kUkIIYRunj11l45cHMRrNBNbwYNDwNri4Fa3Hp7gspmwyLhwj9cRO0k/vxnxbUqXxqIJrWCfcmnRD610137HJx49z4s3pmA0G/Lp2pu5LL6AUcS5Fi8XCl/9s5IczOZ8ZY1o/TbfgDrY5KVEsxfn8tkn/6IkTJ+jbt2/uxJtmc073aNeuXXn22WeZO3euLZoRQghxj6ofFsDTY9rj5Kwl+lIyyxf8TUJ8Wqm0pai1OIc0p8rDzxP08nL8B0zCpdF9KFpHjMmxJP29kUtLxhG9choph//EbMjIPdajUSPqTxyPolYTt3U755d+ftdJq/O0qyg83ewxetXtCsDH+1ax/cKe0jhFYUM2SaT0ej0eHh6oVCo0Gk2eiTrDwsI4fvy4LZoRQghxD6tRy4tnXuiIp7czidfTWb7gb65EJZZqm4pGi0u91vj3fYWgV5ZTpd+rOAU3BxQyL50k7odFXPxwBLGbF5F5+RQWiwXvVi2p+9ILoCjE/PgTl9auL3p7isIzzR/ngZBOWLCwaO8KdkYdKL0TFCVmk0TK39+fpKQkAIKCgti3b1/uvtOnTxe4mLEQQghRXL5VXHn2hQ5Ure5BeqqBlUt2c+bEtTJpW6V1wLVhR6oOmkbNFz7Bq+tgNF4BWLIzST3yJ9ErpnJl2evoD/2OT/vWBI8cDsCl9V8T8+NPRW5HURSGt3yC8NodsFgszN+9nL2X/ymlsxIlZZNEqkWLFhw8eBCAhx9+mM8++4ypU6fy5ptvMnfuXLp162aLZoQQQghc3R0ZMqY9IfX9yDaYWL98Hwd3XyzTGDTuPnh1fIwaYxYSOGQ6rk26oWh0GK6dJ/6nj4maPxKt7iqBfR8E4Nxny4n/6+8i169SVIxq/SSda7XFbDEzb9dS9l85UlqnI0rAJoPNo6KiiI2NpVWrVphMJmbOnMnmzZsB6NatG9OmTcPV1bXEwVY0MthcCCFKj8lk5oevj3B432UAOj9Qly4965XaosWFxpORQsrh/6E/+CvGxKsAWCyQnuiL/mw8ikZDw/9OxbNpkyLXaTabWbDnc/6O2o9GpWHCfaNpVrVRaZ2CuEEm5CwnJJESQojSZbFY2PrrGXb8HgFAs9Y1eGhAY9Q2mmvKupjMZET+g/7AL6SfPYjFYiHpLGQmgkqnJezdt3GrV6/I9ZnMJj7ctYw9lw+hVWmY2GksTQIalOIZiDJ/ak8IIYSwB0VR6NarPg/1b4yiwD/7LvHVF/vJNpjsGJMK5zotCBg4hRpjF+LR+kG8QnXo3MFsyObY1Clc+3lVnmkV7katUvNS++G0qtaUbLOR9/5awonYM6V8FqKobJJI7dq1i59//jn35/j4eEaOHEnHjh2ZMGECWVlZtmhGCCGEKFDL9kE8/kxrNBoVESdiWfXJbjLSDfYOC61XAL49hxP00qfUHtYfrasas8HC+c+/4fwHo0jYvh5TZuHTOGhUal5pP5zmVcMwmLKZtWMxZ69fKP0TEIWySSI1f/58IiMjc39+//332b9/P82bN+fXX39l6dKltmhGCCGEuKP6jfx56rl2ODhquHQhkRWLd5GSnFn4gWVA7eSGb/dBNPlwITovd0xZEH80g4T/fUXUwtEkbFuLKSPlrnVo1Vpe6ziKsCr1yTRm8e72BUQlXSmjMxB3YpNE6sKFCzRs2BAAo9HI77//zvjx41m4cCEvvvgiP/74oy2aEUIIIe6qZrA3w57vgKubA7ExKXy+8G+ux6XaO6xcjn5VCJs5E62HB8Z0SLrggDkjnaS/NhC1cAwJW9dgSr9zQqVTa5lw32jq+tQmzZDOO9vmE5MSW4ZnIP7NJolUamoq7u7uABw/fpyMjIzcgVpNmjQhJibGFs0IIYQQhfIPdOeZFzri7etMUkIGXyzcSczlZHuHlcupagAN35yG2smJrIQsMjLrovWricWQQdLfG4laNJrE7V9hzsoo8HhHrSOTOz9PkEc1kjP1vLP1I+LTE8r4LMRNNkmkfHx8uHDhAgA7d+4kMDCQgIAAANLS0tAUcdFGIYQQwha8fJwZNq4jAdXcSUs1sGLxLs6fjbd3WLlcg4MJnTIRRaMh+VgEWab6VHn0dXT+tbEYMkncsZ6oxWNJ3vcTFlN2/uN1Lkzt+iJV3aoQn57AO1s/IilTX0BLorTZJJHq1KkT8+bNY9asWXzxxRfcf//9ufvOnTtHtWrVbNGMEEIIUWSubg4MHdueoBAfDFlG1ny6l5NHys8dEs8mjan36kugKFz75XcSDkdRbfh7VOn3KhqvAMzpeq7/toxLH79E6rEdWCzmvMc7uvOfri/h6+xNTEos726dT6qhdNYfFHdmk0TqlVdeITQ0lK+++ooGDRowZsyY3H0//PADzZs3t0UzQgghRLE4OGp5cmQbQhsHYDKZ2bDyAIf2RNk7rFy+HTsQPGoEAJfWrufqL7/j2rAjNZ77CN9eo1C7eGJMukbsdx9yZdkEMi4czXu8szf/7foSno7uXEy+wsxtC8nILh8D7O8VpT4hZ2pqKjqdDp1OV5rNlEsyIacQQpQPZrOFnzYe5eDunCSq5yMNads52M5R3RK1Zh2X1n8NikL9Ca/h26E9AGZDJsn7fiRp17dYbsw75RLaHu/7h6D1qHLr+KQrvPm/eaQa0mhUpR6TO49Dp9ba5Vwqg3I1Iaerq+s9mUQJIYQoP1QqhYf6N6Z915zk6dfvTrD99wjKy+IeNQYNxL/nA2CxcOaDD0k+dhwAlc4Rr46PUXPsYtxb9gJFRdqpXVz++CUStq3DnJ0zT2NNz2pM6TwOR40Dx2PPMHfnZxjN9puU9F5idY9UdHQ0fn5+aLVaoqOjCy0fGBhoTTMVmvRICSFE+WKxWNixJYKtv+TMDN6+azD392lgt/X5bmcxmTj13gck7N6D2sWFJrOm41yzZp4yWdcucP335WRezEm01O6++HQfgkuDDiiKwonYM7y7fSHZpmw61GjJi+2eRaWSRUyKq0zW2mvQoAHr16+nSZMmhIaGFvpLePLkSWuaqdAkkRJCiPJp9/Zz/PbdCSBnVvQHHw1DUdk/mTJlZXH8jbdJOXkKna8vTd6bgYOPT54yFouFtFO7SdjyBUZ9zpOITrUa49t7FFrvQA7FHOO9vz7GZDbRPfg+RrUaXC4SxYqkTBKpb775hq5du+Ll5cWmTZsKvUj9+vWzppkKTRIpIYQovw7ujuKHDUfAAo1bVuORgU1R2XGx45uy9SkcnTSFjCvRONcKovGMd9C4uOQrZ87OInn3dyTt/AaL0YCi1uJ5X3882z/CnuijzNu1FIvFQt8GPRncpG/Zn0gFViaJlCicJFJCCFG+HTt0hW/X/IPZbCG0cQCPPtUcjUZt77DIvBbLkYmTyU5MwqNJYxr+dyoqbcGDx7MTrxL/86dknD8MgNa3On4PjuYvw3U+3b8agCHN+tOnfvcyi7+is+tg8/Pnz3Po0KHcCTqFEEKI8iqseTUGDGuFWqPi1NGrrFu2n2yD/QdpO/pXoeF/pqJydCT5yFHOLlx8x4HxWq8AAgb9B79HXkLl7E52/GWiV06j6amjDAztBcDKfzaw/cKesjyFe4bNEqmff/6Zbt268eCDDzJ48GB69+5Nt27d+OWXX2zVhBBCCGFz9Rv5M2h4G7Q6NefOxLHq0z1kZuSfTbysuYYEEzpxPKhUxG3dTtSqNXcsqygKbmGdqTF6Pm5Nc3pTUv7ZQsutm+lRJQyAxXtXcjD66B3rENaxSSK1bds2Xn31VVxdXXnttdeYPXt27s+vvvoq27Zts0UzQgghRKkIrufLU8+1w8FRw6XzCXz58W7SUw32DguvFs2pMy5nkuvLGzYR8/PdOyfUTm749RlL1affRusdiDk1ka47/6S12gOzxczcnZ9xKi6yLEK/Z9hkjNQTTzyBq6srn376aZ7HLC0WCyNGjCAtLY1169aVtJkKR8ZICSFExXL1SjKrPt1DeqoBP39XnhrdDjd3R3uHxaX1XxO1Zh2oVIROeh2ftm0KPcacnUXitrUk7/kBExZW1fDjpIOCi9aJt8Jfo6anLN92J2U+RurUqVMMHjw431wViqIwePBgTp8+bYtmhBBCiFIVUM2DYWM74ObhSNy1VL5YuJOkhHR7h0X1x/vj3+N+MJs5M2ceKafPFHqMSuuAz/3DCBzyDg5eAQy6HEdQhoG07Aze3Taf2NTys4hzRWaTREqlUpGdXfD9ZKPRKPNXCCGEqDB8/V0Z9nwHPL2dSbyezheLdpIQb9/FgBVFIWT0KLxatcRsMHDinRlkXCl8MmwAxxoNqD7iA3xbPcjQmGT8s4wkZup5+485JGXqSznyys8miVTjxo1ZunQpmZl5F0o0GAwsX76cpk2b2qIZIYQQokx4+TgzbFx7fKu4ok/KZMWincTHpto1JkWtpv7rr+JaJwRjSgon3p6OISmpSMeqdI749hhOyOC3GJWqwSvbRGxmMu/8+A5pWfY9r4rOJmOk9u/fz7Bhw/D09KRXr174+voSFxfHb7/9RlJSEitWrKBFixa2iLdCkTFSQghRsaWmZPHlx7uJu5qCi5sDQ0a3wy/Aza4xGZKSOTpxMplXr+Faty5h776F2sGhyMebM9M48fNi5qafJVWjIsSsYVrPSbh4y5ipm8p8jFSrVq1Yvnw51apVY/Xq1Xz44YesXbuWatWqsXz58nsyiRJCCFHxubo5MGRMO/wD3UlLyWLFkl1ci7bv7TCdpwcN35iGxs2N1IgIzsz9CIup6HNfqRxdCOv3Oq/W7Y2D2UKkysic795Ef2x7KUZdedl8ZvOMjAz0ej3u7u44OTnZsuoKR3qkhBCicshIN7Dqkz3EXE7GyVnLU8+1o2p1D7vGpD9xkmP/eROL0UjgIw9T+9lhxa7jcORuZu9bgVGBdknpPFm1FX69R6HSFr2HqzKy68zmGRkZmEwmEhMTiY6Ozv0SQgghKionZx1Pj25HtZqeZKRn8+XHu7kSlWjXmNwbNqDuSy8AEP3dZmJ+/KnYdTQNaccLHYajALs9nfnh8l6iv5hMdkKMjaOtvDS2qCQ1NZWZM2fy448/kpWVVWCZkydP2qIpIYQQwi4cnbQ89Vxb1ny2l0sXEvny4z08ObINNWp72y0mv873kRUby8UvV3Nu6ec4VKmCd+tWxaqjfc1WJGbq+eLQ1/zq44r7tWu0Wj6BKg+/gEv9wuerutfZJJGaMWMGP/zwA/3796d+/frodDpbVCuEEEKUKw6OWp4c1Za1y/ZyMTKB1Z/tYdDwNgSF+NgtpmqP9SPz6jWu/b6F0+/PpfGMd3CtE1KsOh6sF8719EQ2n97CxiruuEUnYdkwG4/2ffHuOhhFZf+FnMsrm4yR6tixI6NGjWLo0KG2iKnSkDFSQghROWUbTKxbvo/zEfFodWqeeLY1tev62i0es9HIyXdmkPTPYbRenjR9fxYOfn7Fq8NiZsHuz/k7aj8OqBgVFU81gxHHoDCq9H0Fjatn6QRfDpX5GKmsrCzq1atni6qEEEKIck+rU/PE8NaEhPqRbTCxduleIk/H2S0elUZD/Qmv4RxUk+zEJE68MwNjWvEmEVUpKsa2GUKjKvXIwszK4EASHZ3IvHiMK8teJ/NK4bOp34tskkh16dKFAwcO2KIqIYQQokLQatUMfKYV9Rr6YzSaWbd8H2dPxdotHo2LCw3/MxWtlxfpF6M4NXsOZqOxWHVo1Vpe7ziamh7VSDZmsrJeLQy+gZhSE4j+8j/o/9lSStFXXDZJpMaMGcNPP/3E559/zoULF0hKSsr3JYQQQlQ2Go2aAUNbUj/MH5PRzPrP99u1Z8rBz5eG/5mCytGR5MNHiFzyKcUdweOsc2JK53H4OHsRk36dVcHV0dRtBSYj8T8uIe7nT7CYCl4W7l5kkzFSoaGhOZXdZU29e/GpPRkjJYQQ9waT0cyGlQc4ffwaGo2Kgc+2JqR+8cYo2VLC/gOcfHcWmM3UfGowNQY8Vuw6LiVH898/5pCWnUHrak151uJD8vb1gAWH6vXxf/R1NG5etg++HCjO57dNEqkFCxYUujDxuHHjStpMhSOJlBBC3Dv+nUw9Mbw1wfXsl0zF/PQL5z75DIB6r72MX+dOxa7jRGwE07fNx2g20qNOZwa51yXuu48wZ6WjdvXC/7HxOFYPtXXodlfmiZQomCRSQghxbzEZzXy98gBnykkydf7zFUR/+z2KRkOjt9/Ao1HDYtex69IBPty5DAsWBjfpy0P+jbn69Wyy4y+DSoNvz+G4t+hRCtHbj11nNhdCCCHuVWqNigFDWt4agL5sH+fOxNstnlpDn8anfVssRiOnZs4m40rxVxppX6MlQ5v3B2DNkW/Zpb9EtWGzcAltB2Yj8T9/QtyPS+7ZcVNWJ1LR0dFkZ2fnvi7sq6LIzMxk2rRp9OzZk969e/PRRx/ZOyQhhBAViFqjov/QFtRtWOXG03x7OR9hn2RKUamo+8pLuNarizEllRNvv0u2PqXY9TxYL5w+9e8HYMm+LzmedJEqj47Hq+uTgELKP1uIWfcupsziTblQGVh9a69BgwasX7+eJk2aEBoaWugYqYoy2Pytt97Cw8ODl19+GYC4uDj8ijmp2U1ya08IIe5dRqOJr784QMTJWDRaFYOGt7HbpJ2GpGSOvD6JrNhY3Bs1pNFb/0Wl1RarDrPFzEe7lrPr0gGctI68Hf4aQZ7VST97gGvfzMViyETrW52AgVPRelYppTMpG2UyRuqbb76ha9eueHl5sWnTpkITqX79+lnTDBcvXmTZsmUcPnyYiIgIgoOD+eGHH/KVO3/+PNOnT+fAgQM4OTnx0EMPMX78eBwdHYvcVlpaGt27d2f79u02WeZGEikhhLi3GY0mvvriAGdvJlMj2lC7jn2SqfSoKI5MmIIpI4Mq3cOp88LYQj+7/81gyubdbQs4GReBt5Mn794/AR9nL7KunufqVzMwpSSgdvHAf8BkHKvVLaUzKX2VarD5li1beOedd2jatCnnz5/HYrHkS6T0ej19+vQhMDCQsWPHkpCQwMyZM+nUqRNz5swpclunTp3i1VdfpWPHjhw4cAAPDw8mTJhAgwYNrIpdEikhhBDGbBNffbGfs6fi0GhVDB7Rhlp2SqYSDx7ixDszwGwmaMhTVH+s+J0cqYY0/vPHHK7or1LDI5B3wsfjrHPCqL/O1fUzMMReQNHoqNL3ZVzqty2Fsyh9lWqweXh4ONu2bWP+/Pk0atSowDLr1q1Dr9ezePFiOnfuTN++fZk2bRqbN28mMjIyt9ygQYMIDw/P9zVy5EgAjEYjkZGRtGnThk2bNjFkyBCef/75MjlPIYQQlZNGq+bxYa0ICfXDmG1m7bJ9XIi8bpdYvFo0J3jEswBcXLmK67t2F7sOV50LUzqPw8vRg0vJ0bz/98cYTUY07j4EDpmOU3BzLEYD1za8T9KezcWeELSiKfeJlEpVeIjbt2+nffv2eHt7527r2bMnOp2Obdu25W5bu3Ytf/75Z76vzz7LmWejatWqODk58cADDwDQrVs3UlNTSUhIsPFZCSGEuJdotGoG3kimbq7NZ69kqupDvan6UG8Azsz9iNSzkYUckZ+fiw+TOz+Po8aB47FnWLzvS8wWMyoHJwIGTsatRQ/AQsKWL0j4YwUWi9nGZ1F+lPtEqigiIyMJCQnJs02n01GzZs08PVKF8fHxoXHjxrnrBh45cgRHR0e8vO48c2v37t3v+BUTE2PdCQkhhKh0cpOp+reSqahz9vmPeu3hz+DZvBlmg4GT784i63rxk7paXjV4reMo1IqKvy7uZd3R7wFQVGp8e43CO/xpAJL3bCbu+wVYTMVb96+iqBSJlF6vx93dPd92d3d3kpOTi1XXW2+9xZw5c3j44Yd55513mD9/frEH4wkhhBAF0dxY6Di4Xk4ytWbpXq5EJZZ5HIpaTf3XX8WpRnUMCQmcnD4TU2ZmsetpGtCQ51o/BcC3J3/l14icu0CKouDZvi9+//cCqNSkHtvO1a9mYTYUv43yTmPvAEqTxWIpdhIUHBzM2rVri1z+bgPRbg5WE0IIIW66mUytWbqXi5HXWf3pXoaMaUdANY+yjcPFhYb/mcKR1yeRdu48Z+Z+ROik11GKMKTmdl1rt+d6eiLrj21m+aH1+Lp40zKwMQBujbuidnLn2qY5ZJw7RMzqNwkYOAW1c/7Oj4qqUvRIubu7o9fr821PSUkpsKdKCCGEsCetTs2g4a2pXsuLzIxsvvx4N7Ex+T/HSpujvz+hkyeiaDQk7NnLxS9XW1XPow17Ex7cEYvFwoe7lnEh8VLuPuc6Laj65JuonFzJio4geuVUspNjbXUKdleimc2L81WaQkJC8o2FMhgMREVF5Rs7JYQQQpQHOgcNg0e0IbCGBxnp2Xz5yR6ux6WWeRzuDUKp80LOE+pXNn3LtS1/FrsORVEY0XIQjf1DyTJmMWvHYhLSk3L3O1arR+CQd1G7+5J9PZroFVMxxEbZ6hTsyupbe+Hh4cW6bVaaM5t37tyZJUuWkJiYmDsw/Pfff8dgMNClS5dSa1cIIYQoCUcnLU+OasvKJbu5Fq1n5ZLdDHu+PV4+LmUaR5WuncmMjubS+q+JXPwxjv5V8GgcVqw6NCo1r3YYybQ/3ueK/iqzdyzmrfBXcdTmTIyt861OtaEziFn7Ntnxl4n+choBj0/GsYZ1czWWF1ZPyFmU2cxvZ+3M5hkZGblTGKxevZpLly4xadIkANq0aYO3t3fuhJzVqlVj7NixXL9+nVmzZnHfffcVa0JOW5MJOYUQQhRFWmoWKxfvIu5aKh5eTgx7vgMeXk5lGoPFYuHMnHnE//U3GjdXmrw3E6fAwGLXE5saz5Qts9FnpdIqsAnjOz6XZyojU0YKV7+aSdbl0ygaHf6Pjce5TktbnkqJVaqZzS9fvnzHQdsrV66kbducWVNvXyLG0dGRPn36FHuJGFuTREoIIURRpegzWbFoFwnxaXj7OjN0bAfcPMr2M8yUlcWxqW+QGhGBY2AgTd+ficbVtdj1nIk/x1v/m0e22chD9boztHn/PPvN2VnEbvqA9LMHQKXBv9+ruISWn1nQK1UiVZFJIiWEEKI4khMzWLF4J0kJGfhWcWXo2Pa4uDmUaQyGxMScBY7j4vFo0piGb0xDpSn+SKCdUfv5cNcyAEa0fIIedfIOtbGYjMR+P5+0E3+DoqLKIy/i2qiTTc6hpOySSF24cIH169cTGRlJ5r/molAUhRUrVtiimQpFEikhhBDFlXg9nRWLdqJPzqRKVTeGjGmPs4uuTGNIu3CBIxOnYs7MJKB3T0JGj7Kqnk0nfmbd0e9RKSomdXqeZlUb5tlvMZuI+3ExqUe2Agp+fcbi1jS85CdQQmW+1t6ZM2fo168ff/75Jzt27ECv13Px4kX27t3LpUuXKv06O0IIIYStePk48/SYdri6ORAbk8LqT/eQmZFdpjG41KpFvVdfBkXh6s+/EvPTL1bV069BL7rUaofZYmbezs+ISrqSZ7+iUuPX53ncmj8AWIj7YRH6g7+V/ATKkE16pEaPHo1Wq2XevHmEhYWxceNGGjVqxNatW5kyZQoLFy6kRYsWtoi3QimtHimjycy0j3dy6VoKOo0KrVad97tGhVajRqdVodOo0WpU6LT/+n5bmYLKOmjVOOhu+65To9OoUalklnchhCgLcVdTWLF4F+lpBqoHefHkqLY4OJbtPNqXN37DxZWrQKWi0Vv/xbNJ42LXYTQZmb5tPifiIvB19mbG/RPwdMo7+ajFYuH678vR7/sJAJ8HnsGjTR+bnIM1ivP5bZMrcuLECd54443cUflmc87ihF27duXZZ59l7ty5rFq1yhZNCSDbaCbqqp6U9LL9HwqATqvGUfevJEurxlGnybfNIbec5rZy+Y9x1GlwdMjZp1GrZEkeIYQA/ALceGp0O1Yu3sXli4msXbaXJ0e2RatTl1kM1R7tS3pUFHFbt3N69hyazJmFU9WqxapDo9YwvuNzTN3yHjGpsbz318e80e0VHDS3blcqioLPA8+iaHQk7/qW679/jsWYjWcH6574L0s2SaT0ej0eHh6oVCo0Gk2eWcbDwsJYtGiRLZoRNzg5aFg69QHikjLIzjaTbTRjMJpyvmebMBjNZN/8bjRhuFEm25izzZB9q+ztxxhv1JNlMGHINpGVfeO18daq3YbsnH2klc65qVQKjrqbCZcmN/n6d9KV+1qX97XjjWMcHPLvd9BKj5oQomIJCHTnyVFtWfXJbqLOJfDViv088Uxr1JqyWZhEURTqPD+GjCsxpEZEcHL6LJq8NwONS/HmuXJ1cGFS5+eZuuU9ziZcYOGeL3ilwwhUyq3zUBQF725PoWh0JO34ioT/rcJiNuF1X/+71Gx/Nkmk/P39SUpKAiAoKIh9+/bRsWNHAE6fPo1LMf/BReGcHbUEBWjLpC2T2ZKTWBlykqtMgzH39a3v+bdlGm68NpjIyjYW+HPONiNGU84dZrPZQnqmkfRMI5Bl83PR5SZmOYna7Umag+5W0pZ3f/6yjjo1jg6a23rZNGjL6A+bEOLeUq2mJ4NGtGH1p3uIPBXHN2sO8ehTLcrsP4YqnY4GUyZyePwEMi5f5swH82gwdTKKung9Y1XdqvD6fc/x9taP2HP5EGuPfMeTTfP2OCmKgnfngSgqNYnb1pK4bS2YzXh1ftyWp2RTNkmkWrRowcGDB7n//vt5+OGHWbBgAXFxcWi1Wr755hv+7//+zxbNCDtRqxScHDQ4OZTevXmjyZybVN1MuDJzX+dNujINJjKzjDfK3CpnyL71+t913XSzR01fCj1q6hu9aXdMum5s02lVaNUqNJob39U549pyf9bctk19W1nNrW03v1SqnF48laKgVim5r1X/el0emc0WLBYLZosFsyXn55vbTGYLFguYLf/62Xyj/I3vltuOu7nddHu9ZgtmM3mOyfM993UBZcy3xXXX42+VsZgtmPLVfSvOf+/7d/ym2/4Nbo/fQs5/NAoa0XpzmKslz7bcV/mO+/e+mxRFQVEUVAo3visoKm5tQ0G5uU+V81ql3LatgNc3fw81KhUajYJGrUKtUnJ/f9Vq5bbfZwW1WoVGpaDRqFCrcrbd/lp9433hoFWjuzEmVHfz9Y1xnuX1972katb2ZsDQlqxbvo8Th2NwcDhCn8eblNlQCJ23Fw2mTOLo5GkkHjjEhZWrqP3M0GLX08CvLmNaP83CPV/w3anfqOpWhfDgjvnKed3XH0WlJuF/q0jcsR6LxYRX5yfK5dAPm3wyjhkzhtjYnAUIR44cSXx8PJs3bwagd+/eTJw40RbNiEpMo1bh6qTC1cn2vWzmGz1qN5OuPElatomsrNsTsLwJWt6ELu/+m4mayZzzgWQyW0jLNJKWabT5OZRUblJ124fb7QnXnf403fVJlLvsvJkA5SYaN5IM823bhCgNtx6YufkgTc7rmwmXg1aNk6MGZwcNzo5anB1v+17QNkcNWk3ZjUm6mzqhVXj0yeZs/PIgh/ZewsFJywMPNyiz5MK1Tgh1XxrH6ffnEv3t9zjXrIF/9+JPVdC5Vluupsay4fhPfLZ/DVVcfAjzD81XzrNDP1CpSPhjJUl/bcjpmeo6uNwlUzIhZymSeaTuDdlG8229ZgX3qN1KznJ6xIymnDFp2aac8Ws3Xxtv/nzbfqMx7/Zb328lJpXVzcTvZi+I6kYvSO42RcnplftXL9zN8mrVrTK36si7TykouczznYL33XZ8Qb2BN3ts1AXEdasXkX+dy2313BbX7R8cN1/d3JSbBit5txe4L/fY/B9EFkveXkCz5V/bzAVsy1PuRu/ZbdvMFgsmkwWT2YzRZMn5vTaZMRXw2mS25Pyum/PuN5osmExmjDf3m26M68w2k3Wjh9lUyu8BjVqFi5MGZwctTo4a3Jy1uDnrcHfR4eaS893dxQF355uvc7Y76tSl8qF/aE8Um786AkC33vXpdH9dm7dxN1Fr1nFp/dcoGg1h09/CvUH+JKgwFouF+buX83fUflx0zsy4fyJV3aoUWDZpz2YStnwBgEf7vjnjqEo5mSrzp/aEuJfl3HLT4epsvxgKvl1141bR7beILAXvu5u7/cG6457bEp48yYqSPwG5/VaR+l9JhRBFYTLlJFXZxlvJlSHbnPvQzO2JV1a2iYxMI+lZ2Tnfb7zOGZuZnTtGMyMrm4ysnGEBRpOZ5FQDyamGYsWl1ahwd9Hh4eKAp7sDXm4OeLs74unmgJebI15uDni5O+Lt7lisoRPN29YkK8vIb9+d4H8/n8bBUUOb+2oXK7aSqPHE46RHXeL6rt2cmvkeTT+YjYOfX7HqUBSFMW2GEJsaT0TCBWbvWMy790/ARZf/D6ln24dRVGqu/7aM5F3fgtmMd/ch5aZnyuoeqejoaPz8/NBqtURHRxdaPtCKhQ8rOumREkKIistktpCZZSQt81bSlZaZTWq6AX26AX1azldK2q3XN7+MJnPhDdzGxUmLn6cTvp5O+Hk54ed548vLGV9PJ3w8HNGo8z7QsvWX02z/PQKARwY1o2mr6jY798KYMjM5Omkqaecv4FK7Fo1nTkftVPxFlpMykpm8ZTbX0xNpGtCASZ2eR60q+FZq8v5fuP7rZwC4t34InweeKbVkqkyWiGnQoAHr16+nSZMmhIaGFnoyJ0+etKaZCk0SKSGEuPdYLBYyDaYbSVUWyakGEvWZJKZkkZiS8z0pJSt3W0ZW4eMqFQW83Bxzk6yqvi4E+roQezKes0diUFQKjw9tSf2wgDI4wxxZcXEcfm0i2cnJ+LRvS/0J41FUxX96+ULiJf7zxxyyTAZ61e3Ksy0G3rGs/uBvxP/8CQDurXrj02N4qSRTZZJIffPNN3Tt2hUvLy+++eabQsv361f+J9WyNUmkhBBCFCY9M5v4pAzikjJyvifmf323Hq7aKPiiwgI41fGmRogPNf3dCKrqRlUfF9Tq0puaRX/yFMemvYHFaKT64/0JenKQVfXsuXyID/7+FIARLQfRo07nO7f5zxbif/wYsODeoic+vUagKLY9xzIZI3V7YlS9enUaNmxY4HxRaWlpnDhxwtpmhBBCiErN2VFLzQAtNQPcC9xvNltITssiLjEnuYpNTCc6Lo3o+FSuxKVxPikDNRa8UEg7e53vzsblzpms1aio4e9GUIAbQQHuBFV1JyjAHV9PR5v05Lg3CCVk7HOcnb+Iy19twLlmTfw65Z/OoDBtqzfnicb/x7qj37P84HoC3aoU+CQfgHuz+1EUFXE/LEZ/8FdUzm54d7EugbMFmww2HzJkSO5tvn87f/48Q4YMuSdv7QkhhBAlpVIpNwanO1Kvple+/ZkGI1eupfLz+sMkxKTQUK1B7+vEhcR0sgwmzl1J5tyV5DzHuDnrqFPdgzo1PKlT3ZM6NTzx83SyKrny7x5OetQlor/9nrPzF+IY4I9b3TrFrqdfg15c1l/lr4t7+WDnZ3d9ks+taTiocpKp7OtXCixTVmySSN3t7qDRaMxdg08IIYQQtuWo0xBSw5NRL3Tky092c+ViEoEZJqa81o0s4OJVPRdj9Fy8msKFGD1X4lJJSTdw6Ewch87E5dbj4aojpLondat7Ui/Ii4a1fYo8t1+tIU+RcekSiQcOcWrmbJrOeQ+dd/6k724URWF066e4lhJb6JN8AG6Nu+Ic3ByVk2ux2rE1q8dIpaam5q6pFx4ezqJFi2jQoEGeMpmZmaxYsYKtW7eybdu2kkdbwcgYKSGEEGUpI93AikW7iL2agrevC8+M64CLm0OeMtlGExdi9Jy9nMzZS0mcvZTExav6fPNxKQrUDvSgcYgvYSE+NAr2wc1Zx50Y09I4MmEKGZcv41q3LmHvvoXaweGO5e+kOE/ylZYyGWy+cOHCIi1GbLFYeO6553jllVesaaZCk0RKCCFEWdMnZ/D5gp0kJ2ZQtboHQ8a0x8Hx7jegDNk3k6skIqKSOHH+OtHxedfSUhQICnAnLMSHsBBfwoJ98HDNmyhlxMRwZPwkjKmp+HXpTN1XXrTqdmFxnuQrDWWSSB06dIhDhw5hsVh4//33eeqpp/LNFaXT6ahXrx5t2rSxpokKTxIpIYQQ9nA9LpXPF+wkPc1A7bq+DBrRGk0xl7q5npzB8XPXORZ5naOR8VyOTc1XpmaAG2HBPjSp40ezen64OGlJOnKU42+8DWYzQU8/SfX+j1p1Dnsv/8Ocv3OmOijsST5bK5NE6nYLFy5kwIAB+Pv7l7SqSkUSKSGEEPYSfSmJlUt2Ycgy0bBpVR59qkWJVgxITMnMTayORcZz8WpKnv1qlUKjYB9aN/Sn/rXjJKxeCYpC6OSJ+LRtbVWbm078zLqj36NSVEzr8sIdn+SztTJPpETBJJESQghhT+fOxLFm6V7MJgutOgTR+9Ewm01gmZyalZNYnbvOodOx+Xqs+qYcIPTacXBwIGzmu3iEFH8ZG4vFwoI9X/DXxb2FrslnS3ZNpBISEsjMzMy3XZaIEUIIIcre8X+i2bjqIFigS496dOlZr1TaiY5PZf+Ja+w7eY1jkfGYjSYGRm8hKOMqyVpXTvceTpvWdWhZvwqOxVhb0GDK5q0/5xKRcIFAN/+7PslnK2WeSKWmpjJz5kx+/PFHsrKyCixzL84jJYmUEEKI8mD/zgv8tPEYAA8+FkarDrVKtb30zGwOR8Rx8NB5am9eiodBT5SjP+uq3Y9Gp6NlaBU6NAmkTUN/nB0Ln2KhrJ/kK5OZzW83Y8YMfvjhB/r370/9+vXR6e78eKQQQgghylarDrVISzGw7bcz/LTpGM4uOho2Lb07Rc6OWto3DqR940BSu9TgyOuTqZl5jUf0B/jGvTW7jsaw62gMWo2K9o2r0qt9LcKCfe5429HTyYOJ943hP3/M4fDVk6z4Z0OZP8l3JzbpkerYsSOjRo1i6NChtoip0pAeKSGEEOWFxWLh503H2L/zIiq1wuARbQiu51cmbSfsP8DJ6TPBYsGt/yD+8WnIziMxXIm7Na6qmp8rvdoHEd6qJu4uBXfIlNWTfMX5/LbJlONZWVnUq1c691yFEEIIUXKKotCrXxgNm1bFbLLw1Rf7ib6UVCZte7dqSa1hQwBI2bSeh6saWDIxnHkvd6FnuyCcHNRciUtl2ffHGfb2r3yw5gAnzl/Pt3JKm+rNeKLx/wGw/OB6jl07VSbx341NEqkuXbpw4MABW1QlhBBCiFKiUin0HdyM2nV9MWSZWLN0Lwn/mniztAQ+8jBVwruB2czp9z8g40o0dWp4Mm5AM774b0+e79+UkOoeZBvNbD1wmYkL/2LcnP/xw1/nSM3Izq2nX4Ne3BfUBrPFzAc7PyMmJbZM4r8Tm9zaO3v2LC+++CIDBgygW7dueHp65itT0LbKTm7tCSGEKI+yMo2sXLKLmMvJePs688wLHXFxLf5yLsVlzs7m2NQ3SDl9GsfAQJq+PxONa9618iIuJfLzzgtsO3QFQ7YJAJ1WTadmgfRoG0SDWt5km425T/K1CGzMpE5jbRpnmT+1FxqaM0HW3eamkKf2hBBCiPIjVZ/J8gV/k5SQQWBNT4aMboeuGNMSWMuQlMTh1yZiiI/Hs1lTGv53Koo6/xN4qRnZbD1wiZ93XSDqtsk/q1dx5YE2QbRq7MH6UxtpGdiY8OCONo2xzBOpBQsWFDrB17hx40raTIUjiZQQQojyLD42lc8X/E1GejZ1G1Zh4LBWqNQ2GfVzV6nnznF00jTMWVlUfbgPwSOeuWNZi8XCyQsJ/L4nih2Hr5BlyOml0mpUdG5ejcE9Qqnibdt5pWRm83JCEikhhBDl3aULiXy5ZBdGo5kW7WryUP/GNpv9/G7id+7i9Ow5ANR96QWqhHct9Jj0zGy2H7rCr7svcPZyMgDN6/nx9nMdbBpbmT+1d1NKSgo7duzg+++/Jzk52ZZVCyGEEKIU1KjlxaNPtUBR4ODuKHZsiSiTdn07tKf64/0BOLv4Y1IizhZ6jLOjll7tazH35S68/2InHu4UzMOdgks71LuyWSK1aNEiOnXqxMiRI5k4cSKXL18GYOjQoXz66ae2akYIIYQQNhbaOIDej4YBsPWXMxzaE1Um7dYcNBCv1i2xZGdzauZsDElJRTpOURRCg7wZ1bcxrRsGlG6QhbBJIrV69WoWLVpE//79+eSTT/LM+9CtWze2bt1qi2aEEEIIUUpadahFx+51APhhw1EiTpb+tAKKSkW9V17CqVoghusJnJr1Pubs7MIPLEdslkgNGzaMadOmcd999+XZFxQUxMWLF23RjBBCCCFKUXjv+jRpWQ2L2cKGlQfKZMJOjYsLoVMmoXZ2JuXkKc4vXV7qbdqSTRKpS5cu0alTpwL3ubi4oNfrbdGMEEIIIUqRoig8/HhTguv5km0wsXbpXhKvp5d6u87Vq1HvtZdBUbj6y29c/fW3Um/TVmySSLm5uREfH1/gvitXruDj42OLZoQQQghRytQaFQOGtiIg0J20VANrl+4lI91Q6u16t2pJzScHAXDu02XoT9p/+ZeisEki1b59e5YuXUp6+q2sVVEUjEYja9euzXe7TwghhBDll4OjhidGtMbNw5H42FS++uIAJqO51Nut3v9RfDq0x2I0cmrW+2TFXy/1NkvKJonUiy++SHR0NA899BCzZs1CURRWrVrFgAEDuHjxImPH2nbqdiGEEEKULncPJwaPaIPOQcPFyOts/upwvkWEbU1RFOq++DzOQTXJTkri1Kz3MBtKvzesJGySSAUFBbF27VqCg4NZu3YtFouF7777Di8vL9asWUNgYKAtmhFCCCFEGfIPdKf/kBYoKoUjB66w7bczpd6m2smJBlMmonFzJTXiLJFLPin1BK4kbLaoTp06dVi2bBkGg4HExEQ8PDxwdHS0VfVCCCGEsIM6oVV46LEwfvj6KNt/i8DL25mmrWuUapuOAQHUH/8qx9+aTuyfW3EJrk3gw31KtU1rlbhHKjMzk06dOvHnn38CoNPp8Pf3lyRKCCGEqCRatAvKnWNq81dHOHem4AfMbMmzWVNqDRsCwPnlK0g6crTU27RGiRMpR0dHsrKycHJyskU8QgghhCiHwnvVp1GzQMxmC1+v2E/c1ZRSbzPw//rg17ULmM2cfu8DMq9dK/U2i8smY6TatWvHrl27bFGVEEIIIcohRaXwyBNNqVHLi6xMI2uW7iVVn1m6bSoKIWOfw7VOCMaUFE7NfA9TZum2WVw2SaRGjx7Njz/+yMKFCzlz5gyJiYkkJSXl+RJCCCFExabRqhn4TGu8fV1ITsxg3fJ9GLKMpdqm2sGB0EkT0Hp4kHb+AmcXLC5Xg88Viw2iCQ0NvVWhohRY5uTJkyVtpsLp3r07AH/88YedIxFCCCFsJyE+jWUf/UVGejb1Gvnz+LBWqFQFf/7bSvLxExz/z5tYTCaCnn6S6v0fLbW2ivP5bZOn9p5//vk7JlBCCCGEqFy8fV144tnWrPx4N2eOX+O374/Tq29Yqbbp0aghtUcO59zHn3Jx1RpcatfCq2WLUm2zKGySSL3wwgu2qEYIIYQQFUSN2t70G9yMDSsPsnfHBby8nWnbObhU26zauydp589z7dffOf3BPJq+Pxunavadq9ImY6RuSklJYceOHXz//fckJyfbsmohhBBClDMNmwbS/aGc4T2/fn+C08eulnqbwSOH4xZaH1NaOidnzMaYXvqLKt+NzRKpRYsW0alTJ0aOHMnEiRO5fPkyAEOHDuXTTz+1VTNCCCGEKEc6dAuhZfuaYIGNqw5yJSqpVNtTabWETnodnbc3GZcvc+GLlaXaXqHx2KKS1atXs2jRIvr3788nn+Sdyr1bt25s3brVFs0IIYQQopxRFIXe/cIICfXDmG1m3bK9JF4v3V4inZcXoZMnoHF3t/sYbZslUsOGDWPatGncd999efYFBQVx8eJFWzQjhBBCiHJIpVbR/+mW+Ae6k5ZqYO2yvWSkl+5iw2716tLmi6WEjHmuVNspjE0SqUuXLtGpU6cC97m4uKDX623RjBBCCCHKKQdHDYNGtMbNw5H4a6l8veIAJqO5VNtU1OpSrb8obJJIubm5ER9f8Lo7V65cwcfHxxbNCCGEEKIcc/dwYtCINugc1Fw4e53NXx8pV5NnlgabJFLt27dn6dKlpN82cl5RFIxGI2vXrs13u08IIYQQlVNAoDv9h7REUSkc2X+Z7b9F2DukUmWTROrFF18kOjqahx56iFmzZqEoCqtWrWLAgAFcvHiRsWPH2qKZMrFt2zb69u3LI488wqOPPsr+/fvtHZIQQghRodQJrcKDj+ZM0LnttzMc3nfJzhGVHpskUkFBQaxdu5bg4GDWrl2LxWLhu+++w8vLizVr1hAYaN/JsopjypQpzJkzh++++44XXniB6dOn2zskIYQQosJp2T6IjuEhAGz+6gjnIwoeAlTRWT2z+alTp6hduzYODg4A1KlTh2XLlmEwGEhMTMTDwwNHR8cSB3jx4kWWLVvG4cOHiYiIIDg4mB9++CFfufPnzzN9+nQOHDiAk5MTDz30EOPHj7cqhpSUlNzv/v7+JT4HIYQQ4l4U3juUpIQMjv8TzVdf7OfZFzriF+Bm77BsyuoeqX79+nH69GkAhgwZQmRkJAA6nQ5/f3+bJFEAERERbNu2jaCgIEJCQgoso9frGTp0KGlpacyfP5+JEyeyefNmpk2bVuz25s2bx5gxY+jatStz5syxqg4hhBBCgKJSeOSJptSo5UVWppE1S/eSqs+0d1g2ZXWPlE6nw2DImSNi7969pKWl2Syo24WHh3P//fcDMGnSJI4dO5avzLp169Dr9Xz77bd4e3sDoFarGT9+PGPGjMlNwAYNGsS1a9fyHR8SEsJnn32GyWTi448/ZunSpYSFhfHnn38ybtw4vv32W7tP+CWEEEJURBqtmoHPtGb5gr9IiE9n3fJ9DBnTHp2DTZb7tTurz6JGjRp8/vnnudMe7Nmzh6tX77zGTo8ePaxqR6UqvNNs+/bttG/fPjeJAujZsydTpkxh27ZtuYnU2rVr71rPiRMnSEpKIiwsZ4BceHg4EydOJDExMU/dQgghhCg6Z1cdg0a0Yfn8v4m+lMw3qw8xYFgrVKqK30lhdSI1duxYJkyYwB9//IGiKHzwwQd3LKsoCidPnrS2qUJFRkby2GOP5dmm0+moWbNm7i3HoggICODSpUtcvnyZ6tWrc/DgQXQ6HV5eXnc8pnv37nfcFxMTQ9WqVYvcvhBCCFFZ+fi5MvDZ1nz58W5OH7/Glh9O0uP/Gto7rBKzOpF68MEHadeuHefPn+fJJ5/kv//9L3Xq1LFlbEWm1+txd3fPt93d3Z3k5OQi1+Pn58fUqVMZPXo0KpUKjUbDvHnz5LaeEEIIYQM1a3vT94lmbFx1kN3bzuHn70rztjXtHVaJlPipvZYtW9KvXz86depEjRo1bBlbiVkslmInQX379qVv375FLv/HH3/ccd/dequEEEKIe1Gj5oHExaaw/bcIftx4FG8/F4KCK+4KKDZ5au/KlSu5A8/twd3dvcD1/FJSUgrsqRJCCCGE/XR5oB4NmlTFbLLw9RcHSLyeXvhB5ZTViVRZPbVXFCEhIfnGQhkMBqKiou44ZYIQQggh7ENRKfQd1Iyq1T1ITzOwfvk+sjKN9g7LKuX+qb2i6Ny5M0uWLCExMTF3YPjvv/+OwWCgS5cupdauEEIIIayj1akZ+Ewrln70F7FXU9i0+iADn2ld4Z7kUyxWLsv8008/MWHCBIxGI4qi3HV155I8tZeRkcG2bdsAWL16NZcuXWLSpEkAtGnTBm9vb/R6PX369KFatWqMHTuW69evM2vWLO677z7mzJljVbu2cHOM1N3GUQkhhBD3sitRiaxYtAuj0Uz7rsE88LD9n+Qrzue31YkUQEJCQpGf2mvTpo1VbVy+fPmOg7ZXrlxJ27ZtgbxLxDg6OtKnTx+rl4ixFUmkhBBCiMIdO3iFTasPAfB/A5vSrI19H14rzud3iaYV9fb2xtvbu1Sf2qtevXruoPa7qV27NsuWLbN5+0IIIYQoXWEtqhF7LYW/tpzlxw05T/LVrF0xJsK2erD57WbOnFnupj4QQgghRMXRrWd9QhsHYDKZ+eqL/SQlVIwn+azukYqOjsbPzw+tVkt0dHSh5QMDA61tSgghhBCV3M0n+b64vpOr0XrWLd/HM+M64uBYvtfkszq67t27s379epo0aUJ4eHihE1+W5hIxQgghhKj4dA4aBj7bOudJvpiK8SSf1YnUjBkzcm/nzZgxQ5ZREUIIIUSJeXg5MfCZVqxYvIuIE7Hlfk0+qxOpfv365b5+9NFHbRKMEEIIIUT1IC8eeaIpm1YdKvdr8pX4xmNCQgLr1q1j//79xMbGAlClShXatm3L448/njtBphBCCCFEUYU1r0Z8bGrOmnwbjuLl40ytOr72DiufEj21t2vXLnr06MH8+fPZs2cPSUlJJCYmsmfPHubNm0evXr3Yt2+frWIVQgghxD2kS496NGoWiNls4esVB0iIt99ydHdidSKVkJDAyy+/jJubGx9++CH79+/nr7/+4u+//2b//v3MnTsXJycnXnzxRRITE20ZsxBCCCHuAYqi8H9PNCWwhgcZ6dmsW7aPzIxse4eVh9WJ1IYNGzCbzaxdu5ZevXrh5OSUu8/JyYkHH3yQNWvWYDQa2bBhg02CFUIIIcS9RatVM/DZ1rh7OBIfm8qGlQcwm8z2DiuX1YnUX3/9xWOPPUZAQMAdywQGBvLoo4+yY8cOa5sRQgghxD3Ozd2Rgc+2RqtTc+5MPL98e9zeIeWyOpE6d+4cLVu2LLRcq1atOHfunLXNCCGEEEJQtboH/QY3BwX277zIvr8u2DskoASJlF6vx9u78HVwvL290ev11jYjhBBCCAFAaOMAuj8YCsAv3x0n8nScnSMqQSJlMBjQarWFltNoNGRnl6+BYUIIIYSomDp0C6Fpq+pYzBY2rDxA3LUUu8ZTonmkzp07h1qtLrSMEEIIIYQtKIrCQwMak5iQTtS5BH7ffJLBI9rYLZ4SJVKTJ08utIzFYpHlY4QQQghhMxqNmgFDW/Lrt8epE1rFvrFYe+DMmTNtGYcQQgghRJG5uDrw6FMt7B2GbdbaE0IIIYS4F5VoiRghhBBCiHuZJFJCCCGEEFaSREoIIYQQwkqSSAkhhBBCWEkSKSGEEEIIK0kiJYQQQghhJUmkhBBCCCGsJImUEEIIIYSVJJESQgghhLCSJFJCCCGEEFaSREoIIYQQwkqSSAkhhBBCWEkSKSGEEEIIK2nsHUBlFhsbi8lkonv37vYORQghhBBFFBMTg1qtLlJZ6ZEqRQ4ODmg0BeeqJpMJvV6PyWQqdHtB22JiYoiJiSmdwIvgTvGXRT1FPaYo5e5WRq5Ryeqx1XWy1TUqaHtluUbW1mXPa3SnfeXtvVRZrlFhZeTvXd561Go1Dg4ORTvIIuzi2LFjlnr16lmOHTtW6PaCtoWHh1vCw8PLLN5/u1P8ZVFPUY8pSrm7lZFrVLJ6bHWdbHWNCtpeWa6RtXXZ8xrdaV95ey9VlmtUWBn5e2d9PdIjJYQQQghhJUmkhBBCCCGsJImUEEIIIYSVJJESQgghhLCSJFJ24ufnx7hx4/Dz8yt0+53K2pOtYrKmnqIeU5Rydysj16hk9djqOtnqGpXkXEqLLeOx53vJmmt0p31yjaw7Rv7e2e/vnWKxWCwlalXYxc25qf744w87RyLuRK5R+SfXqGKQ61T+3cvXSBIpIYQQQggrya09IYQQQggrSSIlhBBCCGElSaSEEEIIIawkiZQQQgghhJUkkRJCCCGEsJLG3gGIsvPcc88RExODoij4+voyffp0qlatau+wxA2JiYm8/vrrXL58Ga1WS5MmTXjjjTfQ6XT2Dk3cZsqUKezYsYPY2FiOHz+ORiN/Ru0tMjKSCRMmkJqair+/P3PmzKFKlSr2DkvcpjK/b2T6g3tISkoKbm5uAKxcuZLDhw/zwQcf2DkqcVNSUhIRERG0bt0as9nM+PHjadiwISNGjLB3aOI2e/fuJTg4mI4dO1a6D4SK6qmnnuLpp5+mZ8+eLF++nNOnTzN79mx7hyVuU5nfN3Jrz44uXrzIf//7Xx555BEaNmxInz59Cix3/vx5hg8fTrNmzWjfvj3Tp08nMzOz2O3dTKIAUlNTrY77XlKW18jT05PWrVsDoFKpCAsLIzo6usTnUNmV9fuoTZs2+Pr6ljTse56trlt8fDyRkZH06NEDgMcff5zffvutTM6hsrPle6syv28qT0pYAUVERLBt2zaaNm2K2WymoM5BvV7P0KFDCQwMZP78+SQkJDBz5kySkpKYM2dOsdt87bXX2LNnDx4eHnz++ee2OI1KzR7XCCArK4tvvvmG119/vaSnUOnZ6xqJkrHVdbt69SpVq1ZFURQAXF1d0Wq1JCYm4uXlVabnVNnIe6toJJGyo/DwcO6//34AJk2axLFjx/KVWbduHXq9nm+//RZvb28A1Go148ePZ8yYMYSEhAAwaNAgrl27lu/4kJAQPvvss9yfP/jgAywWC0uXLmXx4sW8+eabpXBmlYc9rpHZbGbixIm0a9eOzp07l8ZpVSr2uEai5Gx13e40OuVmYiWsZ8v3VmUmiZQdqVSF31ndvn077du3z/0FBejZsydTpkxh27Ztub+ka9euLXK7iqIwcOBAunTpIolUIexxjd566y00Gg1TpkyxLuh7jL3eR6JkbHXdqlatytWrV7FYLCiKQmpqKtnZ2Xh6epZi9PcGW763KjMZI1XORUZG5vtF1Ol01KxZk8jIyCLXk5aWxtWrV3N//uWXX6hbt67N4ryX2eoaAbz33ntcu3aNWbNmyf+obciW10iUnaJcN19fX2rXrs2WLVsA2LBhAw888ECZx3qvkveW9EiVe3q9Hnd393zb3d3dSU5OLnI9GRkZjBs3jqysLACqVq3K+++/b7M472W2ukYREREsW7aM4OBgHnvsMQA6dOjAxIkTbRbrvcpW1wjg9ddfZ8+ePUDOrY9WrVoxd+5cm8Qp8irqdXvzzTeZOHFi7rQH98rYnPKgqNeoMr9vJJGqoG52YxeVr68vGzZsKMWIxL8V9xrVrVuX06dPl2JE4t+Ke40A+Q9IOfDv61a3bl02bdpkx4jEv/37GlXm943c2ivn3N3d0ev1+banpKQU+L8AUfbkGpV/co0qJrlu5Z9cI0mkyr2QkJB895kNBgNRUVH3xCC+ikCuUfkn16hikutW/sk1kkSq3OvcuTO7d+8mMTExd9vvv/+OwWCgS5cudoxM3CTXqPyTa1QxyXUr/+QayRgpu8rIyGDbtm0AXLlyhdTUVH755RcgZxZYb29vnnjiCVatWsXYsWMZO3Ys169fZ9asWTz88MP3TLZvT3KNyj+5RhWTXLfyT65R0chae3Z0+fJlunfvXuC+lStX0rZtWyBn+v3p06dz4MABHB0d6dOnD+PHj8fR0bEsw70nyTUq/+QaVUxy3co/uUZFI4mUEEIIIYSVZIyUEEIIIYSVJJESQgghhLCSJFJCCCGEEFaSREoIIYQQwkqSSAkhhBBCWEkSKSGEEEIIK0kiJYQQQghhJUmkhBBCCCGsJImUEEIIIYSVJJESQlQamzZton79+nf82rNnz12PDw8Pzy379ttv527fs2cP9evXz11nzFoJCQmEhYXxyiuv3LFMamoqTZs2ZfTo0QBs2bIlzzkcPXq0RDEIIWxLFi0WQlQ6M2fOJDg4ON/2OnXqFHpsly5dGDt2LL6+vjaPy9vbm/DwcLZs2UJycjIeHh75yvz4449kZmbSv39/AFq3bs369evZunUrS5YssXlMQoiSkURKCFHp1K1bl8aNG1t1rLe3N82aNbNtQLd57LHH+PXXX9m8eTNPPfVUvv0bN27E19eXrl27AuDh4UGzZs04d+5cqcUkhLCe3NoTQggrpKamMnz4cDp06MCRI0cAMBgMLF68mF69ehEWFka7du2YPHkyCQkJucd16tSJgIAANm3alK/OyMhIDh8+zCOPPIJGI//PFaIikHeqEKLSMZvNGI3GPNsURUGtVtuk/qtXrzJy5Eiys7NZv349NWrUwGw2M3bsWA4cOMDw4cNp0aIFV65cYcGCBRw5coSNGzfi6OiISqWiX79+LFmyhFOnThEaGppb78aNG4GcXishRMUgiZQQotJ5/PHH821Tq9WcOHGixHWfPHmSUaNGUbNmTRYtWoSnpycAP//8Mzt27GDBggX06NEjt3xoaCj9+/dn06ZNDB48GMhJlD7++GM2bNjAtGnTADAajXz//fe0aNGCkJCQEscphCgbkkgJISqd2bNn50tGFEUpcb1//fUXkydPplu3bsyaNQudTpe773//+x/u7u5069YtT29YgwYN8PPzY+/evbmJVI0aNWjbti2bN29mwoQJ6HQ6tm/fTlxcHC+//HKJ4xRClB1JpIQQlU5ISIjVg83vZsuWLWRlZTFo0KA8SRTA9evX0ev1hIWFFXhsYmJinp/79+/P+PHj+fPPP+nVqxebNm3C2dmZ3r172zxuIUTpkURKCCGKaPLkyfz888+MHDmShQsXct999+Xu8/LywtPTk6VLlxZ4rIuLS56fe/TogYeHBxs3bqRNmzZs3bqVRx55JF85IUT5Jk/tCSFEETk4OLBgwQK6du3KmDFj2LJlS+6+rl27kpSUhNlspnHjxvm+/j2vlYODA3369OHvv//ms88+Izs7WwaZC1EBSY+UEKLSiYiIwGQy5dtes2ZNvL29S1S3Vqtl7ty5TJ06lZdeeonZs2fTp08fHnroITZv3syoUaN4+umnadKkCVqtlqtXr7Jnzx66d+/OAw88kKeu/v37s3r1aj7//HOCg4Np0aJFiWITQpQ9SaSEEJXO5MmTC9w+ffp0BgwYUOL6VSoVM2bMwMXFhddff52MjAwGDBjAkiVLWLlyJd999x2ffvoparWagIAAWrduTb169fLV07BhQxo2bMiJEyekN0qICkqxWCwWewchhBDlQXh4OK1bt+bdd99FpVKhUtl/9IPFYsFkMvHtt98ydepUNmzYUCoD6YUQ1rH/XwkhhChHvv32Wxo1asT06dPtHQoAf/zxB40aNWLq1Kn2DkUIUQDpkRJCiBtOnz6NwWAAwMfHh8DAQDtHBHq9nosXL+b+XKdOHZycnOwYkRDidpJICSGEEEJYSW7tCSGEEEJYSRIpIYQQQggrSSIlhBBCCGElSaSEEEIIIawkiZQQQgghhJUkkRJCCCGEsJIkUkIIIYQQVpJESgghhBDCSv8PxYF3z2rLq7UAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "shells_cox_dipole = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", dipole=True, considered_shells=(\"*\",))\n", @@ -304,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -327,25 +583,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac4d28696c694ee7aaac335f8e2a0871", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -379,9 +669,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45a57ced132e443393b8ee8ee4e2f974", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import seaborn as sns\n", "\n", @@ -459,7 +785,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -498,9 +824,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAHoCAYAAACsIyBvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVk0lEQVR4nO3de3zO9f/H8ee1kznNaZsWEWI5qy9m2MaQMBUdHHKKlDlWxhwq6etUKXKInGL4omSKb/omaaTofFBoJIdhY2abmR2v3x+uXb8u2+y6tmtHj/vt5nbr+nze1/v9uq5r5tn7835/LoPRaDQKAAAAcijuAgAAAEoKghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEYrVtm3b5O3tbfGnXbt2Gjx4sPbu3Zutvbe3txYvXmzXGgIDAzVlyhTz40OHDsnb21uHDh2y6zjWyBo7tz/btm0r8ppsdfP7WRSuXLmi559/Xr6+vvL29tbo0aOLdPzcLF68WN7e3hbHBg8erMGDBxfJ+IGBgXr22WfzbHf27NlsP18//vijFi9erISEhHyPn9PrB0o6p+IuAJCkuXPnqn79+jIajbp06ZI2bNigUaNGadmyZQoMDDS327Jli+64445CraVp06basmWL7rnnnkId51ZeeOEF+fj4ZDtep06dYqjGNkuWLFGlSpWKdMx33nlHu3fv1pw5c1SnTh1VqVKlSMcv7Tw9PbVlyxaLn6+ffvpJS5YsUZ8+feTm5laM1QFFi2CEEqFhw4Zq3ry5+bGfn5/atGmj//73vxbBqFWrVoVeS6VKlYpknFupW7dusdcgSRkZGcrIyJCLi4vVz2nSpEkhVpSzyMhI1alTRw899JBd+jMajUpJSZGrq6td+itqycnJKl++vNXtXVxcSsTPG1AScCkNJVK5cuXk7OwsJyfL7H7zpbSsS3EHDx7UjBkz5OPjIx8fH40dO1bR0dEWz01LS9Prr7+uDh06qGXLlhowYIB+/fXXbGPndCltypQpuu+++3Tq1CmNHDlS9913nwICAjRv3jylpqZaPP/ChQsaP3687rvvPrVu3VoTJ07Ur7/+avdLYVmXSfbt26c+ffqoRYsWevDBB7V169ZsbS9evKiXX35Z/v7+atasmQIDA7VkyRKlp6eb22RdTlm5cqXeeecdBQYGqnnz5jp48KAk6fPPP1fv3r3VrFkzdenSRevWrcvxUklOl9KuXr2q1157TYGBgWrWrJn8/Pw0e/ZsXbt2zaLdrl279Pjjj+tf//qXWrZsqS5dumjq1Km5vgdZNX/99dc6ceKE+ZJj1md35coVvfLKK/Lz8zPXvWDBgmyfmbe3t1599VVt2rRJPXr0UPPmzRUeHp7ruJ988omGDx+ujh07qkWLFurRo4fmz5+f7fUURGZmplauXKkHH3xQzZo1k6+vryZPnqwLFy5YtBs8eLCCgoL03XffqX///mrZsqWmTZtm0Wb37t3q3bu3mjdvri5duigsLMzi/M2X0hYvXqzXX39dktSlS5ds72tBXv8333yjwYMHy8fHRy1atFCnTp00btw4JScn5/u9AuyJGSOUCJmZmUpPT5fRaFRsbKxWrVql5ORkBQUFWfX8F198UZ06ddKbb76p8+fP64033tCkSZMs/gF46aWXtH37dg0fPlwdOnRQZGSkxo4dq6SkJKvGSEtLU3BwsB577DENHz5c3333nd555x1VqlRJY8eOlSRdu3ZNQ4YMUXx8vEJCQlS3bl3t379fzz//fL7ej5vdHBSPHj2q1157TSNHjpS7u7s++OADTZ8+XXXr1lWbNm0k3QhFjz/+uBwcHDRmzBjVqVNHP/30k5YtW6aoqCjNnTvXos/169fr7rvvVmhoqCpVqqS6detq3759GjdunFq3bq2FCxcqPT1da9as0aVLl/J8LcnJyRo0aJAuXLigUaNGydvbW5GRkVq0aJH+/PNPrV27VgaDQT/99JOef/559ezZU2PHjlW5cuV07tw5czDLSdYloJkzZyoxMVHz58+XJN1zzz1KSUnRkCFDdObMGY0bN07e3t76/vvvtWLFCh05ckQrVqyw6Ovzzz/X999/rzFjxsjd3V01atTIddy///5b/v7+Gjp0qMqXL6+//vpLK1eu1K+//potdOTXK6+8oi1btmjQoEHq1KmToqKi9Pbbb+vbb7/Vtm3bVL16dXPbixcvatKkSXr66af1/PPPy8Hh//+f98iRI5ozZ47Gjh0rd3d37dixQ7Nnz1ZaWppGjBiR49iPP/644uPjtX79ei1ZskQeHh6SZL68nN/Xf/bsWT377LNq3bq1Zs+eLTc3N0VHR2v//v1KS0uzaZYLKCwEI5QITzzxhMVjFxcXvfTSS/Lz87Pq+X5+fnrxxRfNj+Pj4/XGG2/o4sWL8vDw0IkTJxQeHq5hw4Zp8uTJkqQOHTqoRo0aCgkJsWqMtLQ0jRs3Tj169JAk+fr66vDhw9q5c6c5GIWHh+vUqVNauXKl/P39JUkdO3ZUcnKytmzZYtU4knINUhERERZrrOLi4rRp0ybdeeedkqQ2bdro4MGD2rFjhzkYLV68WPHx8frvf/9rbufr6ytXV1e99tprGjFihMV6qnLlymn16tVydnY2H3vuuedUs2ZNrV692nxZzc/Pz+IyZ27Wr1+vY8eO6f333zdfLvX19VXNmjU1fvx47du3TwEBAfrpp59kNBo1c+ZMVa5c2fz8vn375tp31iWgSpUqKS0tzeJy0ObNm3Xs2DEtXLjQ/Jl16NBBFSpU0Pz583XgwAF16NDB3P7atWvasWOHVeuT/rm422g06v7771eDBg00aNAgHT16VPfee2+efdzKiRMntGXLFg0cOFAvvfSS+XiTJk30+OOPa926dRY/I1euXNHChQvl6+ubra+YmBht377dXFNAQIAuX76sd955RwMHDswxjNxxxx3y8vKSJDVu3Fi1a9e2y+v//ffflZKSosmTJ1u06d27tzVvC1AkuJSGEuG1117T1q1btXXrVq1cuVJ9+vTRq6++qg0bNlj1/Jv/gc66vHPu3DlJMl8CuPkXcI8ePbLNwuTGYDDkOE7WGJL03XffqWLFiuZQlMXama8sISEh5vfjn39unsVo3LixOexIN0LN3XffbVHTl19+KR8fH3l6eio9Pd38J6vGb7/91qLPwMBAi1B07do1HT58WF27drVYa1SxYkWrgtHevXvVsGFDNW7c2GL8jh07ymAwmMfPCk3PPfecPvnkk2yXQm118OBBVahQQQ8++KDF8ayg9c0331gcb9eundWLts+cOaOJEyeqQ4cOaty4sZo2bapBgwZJkv76668C1S39/89rnz59LI63aNFCDRo0yFZ7lSpVcgxF0o31ezcHlaCgIF29elW///57vurL7+tv3LixnJ2d9dJLLyk8PFxnzpzJ1/hAYWLGCCVCgwYNLBZf+/v7KyoqSm+88YYeeuihPHfFVK1a1eJx1j/g169fl3Tj/6glmS8JZHFycsr23NyUL19e5cqVyzZOSkqK+fGVK1fk7u6e7bm3uiyTk7vuusvi/chNTrXfXFNsbKz27t2rpk2b5thHXFycxeOb36OEhAQZjcYcX4M1rys2NlanTp3Kc/w2bdpo6dKlWr9+vUJDQ5WamqqGDRtq1KhRNgdL6f8/C4PBkK1mJycn889Elptfd26SkpI0cOBAlStXTs8995zuvvtuubq66sKFCxo7dqz5Z64gsmrz9PTMds7T09Mi+OZVe04/j1nHbn4PrFGQ11+nTh2tXbtWq1at0quvvqpr167prrvu0uDBgzV06FCbawEKA8EIJZa3t7e++uor/f3332rRokWB+soKEBcvXlTNmjXNx9PT0/P1j8OtxslpQbc1a3EKS7Vq1eTt7a3nnnsux/M3/+N7c5Bwc3OTwWBQbGxstuda87qqVaumcuXKac6cObmez9K1a1d17dpVqamp+vnnn/Xuu+9q4sSJqlWrlu677748x/qnqlWr6pdffpHRaLR4TbGxsUpPT7cYV8r+unNz8OBBxcTEaP369Wrbtq35eGJiok313UrWz2tMTEy221PExMTYVHtOn1HWMWv/p+CfCvr6W7durdatWysjI0OHDx/W+vXrNWfOHLm7u6tXr1421wPYG5fSUGIdPXpUkrL9I5AfWfcE2rFjh8XxXbt25bjIOb/atGmjpKQkRUREWBz/73//a7cxbNWpUyf9+eefqlOnjpo3b57tzz+DYk4qVKigZs2a6fPPP7fYzZWUlJTjTThzGv/MmTOqWrVqjuPfvH5FujHr1bZtW02aNEmS9Mcff9j4qm+sY7p27Zo+//xzi+Pbt283n8+PrBBy8y0MNm/enK/+ctKuXTtJ0scff2xx/Ndff9WJEyfM560RGRlp/ruUZefOnapYsWKus3jS/7++f84+SvZ7/Y6OjmrZsqVmzJghSfm+rAfYGzNGKBEiIyOVkZEh6cb0/meffaYDBw6oW7duuuuuuwrcf4MGDfTQQw9p3bp1cnJyUvv27RUZGanVq1fb9WaEffr00bp16zR58mRNmDDBvKPrq6++kiSL3UK3curUKf3888/Zjt9xxx023+By/Pjx+vrrr9W/f38NHjxY9erVU2pqqs6ePat9+/Zp5syZefY5fvx4PfvssxoxYoSGDh2qjIwMrV69WhUrVlR8fPwtnzt06FB99tlnGjRokIYNGyZvb29lZmbq/Pnz+uqrrzR8+HC1bNlSb7/9ti5cuCBfX1/dcccdSkhIUFhYmJydnS1mJqz1yCOPaOPGjQoNDVVUVJQaNWqkH374Qe+++64CAgLUvn17m/uUpPvuu09VqlTRjBkzNHbsWDk5OWnHjh06duxYvvrLSf369dWvXz9t2LBBDg4O5kvLb7/9try8vDRs2DCr+/L09FRwcLDGjh0rDw8Pffzxxzpw4IBCQkJuuQusUaNGkqR169apT58+cnJyUr169Qr0+jdt2qSDBw+qU6dO8vLyUkpKij788ENJyvfnAdgbwQglwj/vVVO5cmXVrl1bU6dO1cCBA+02xuzZs+Xu7q7w8HCtX79ejRs31uLFi/XCCy/YbYwKFSpo3bp1mjNnjt544w0ZDAZ17NhRM2bM0DPPPGOx2+pW3nrrrRyPjxo1yuat/56entq6daveeecdrV69WtHR0apYsaJq1aolPz8/q+5q7O/vr8WLF+vtt9/Wc889Jw8PDw0YMEAxMTHZZjVuVqFCBW3cuFErVqzQli1bdPbsWbm6usrLy0vt27dXrVq1JEktW7bU4cOHNX/+fF2+fFlubm5q1qyZ1q5dq4YNG9r0mqUbC9HDwsK0YMECrVq1SnFxcapZs6aGDx9u3kWYH9WqVdO7776r1157TZMmTVL58uXN90e6ebF0Qbzyyiu66667tHXrVv3nP/9RpUqV5Ofnp4kTJ9o0i9q4cWP17dtXixcv1t9//y1PT09NnTo1z3Dl4+OjZ599VuHh4frggw+UmZmpsLAw+fj45Pv1N27cWAcOHNDixYt18eJFVahQQY0aNdKyZcvUsWNHq18TUJgMRqPRWNxFAGXd8uXLtXDhQn355ZeF/pUmRSUtLU2PPPKIatasqTVr1hR3OQBgF8wYAXaWdYuB+vXrKy0tTQcPHtT69ev10EMPlepQNG3aNHXo0EEeHh66dOmSNm3apBMnTmj69OnFXRoA2A3BCLAzV1dXrVu3TmfPnlVaWpq8vLw0cuRIBQcHF3dpBZKUlKTXXntNly9flrOzs5o0aaIVK1awNgRAmcKlNAAAABO26wMAAJgQjAAAAEwIRgAAACYEo0IyaNAg85cqAgCA0oFdaYXk/PnzxV0CAACwETNGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAExuy2A0bdo0+fn5ydvbW+np6RbnPvjgA/Xu3Vs9evTQxIkTdf369WKqEgAAFLXbMhg98sgjCg8Pz3b8+PHjWrZsmTZu3Khdu3bJzc1N7733XpHVZczMtGs7AABgG6fiLkCSTp06pdWrV+uXX35RZGSk6tevr507d2Zrd/LkSc2aNUs//PCDypcvr169eikkJESurq42jde2bdscj0dGRqpp06Zyc3OTJHXs2FELFixQcHCw7S/qJpmZRjk4GG7ZxuDgoJM7Vyo59nyubcrX8FK9oJEFrgcAAGRXIoJRZGSkIiIi1LJlS2VmZspoNGZrk5CQoKFDh+rOO+/UokWLdPnyZc2dO1dXrlzR/Pnz7VLHvffeq7lz5yo6Olru7u763//+p3PnztmlbwcHg5ZuOqComPgcz7f0vlP9Hmyl5NjzSo4+bZcxAQCAbUpEMAoMDFTXrl0lSVOmTNHhw4eztdm8ebMSEhK0fft2Va9eXZLk6OiokJAQBQcHq0GDBpKkAQMGKDo6OtvzGzRooJUrV96yjnr16mny5MkaPXq0nJ2d1a5dOzk52e8tioqJ199RcTmeu9PDzW7jAACA/CkRwcjBIe+lTvv27ZOvr685FElS9+7dNW3aNEVERJiD0aZNmwpUS1BQkIKCgiRJu3btUv369QvUHwAAKD1KRDCyxokTJ/Too49aHHNxcVGdOnV04sQJu41z6dIlubu7KzExUatWrdKIESNybdulS5dcz50/f15eXl52qwsAABS+UhOMEhISzIui/8nNzU3x8Tmv28nNpEmTdOjQIUk3LuO1bt1ab731lvlcTEyMUlNT1a9fP/Xs2bPgxQMAgFKh1ASj3BiNRhkMt97tdbM33ngj13O2bM/fs2dPruduNZsEAABKplJzHyM3NzclJCRkO56YmJjjTBIAAICtSs2MUYMGDbKtJUpNTdXp06ezrT0qajExMbp48aLFsbS0NKsWlQMAgJKj1AQjf39/LVu2THFxcapWrZokaffu3UpNTVVAQECx1rZlyxYtWbIk23FmsgAAKF1KRDBKTk5WRESEJCkqKkpXr17Vp59+KunGXaqrV6+u/v37a8OGDRo9erRGjx6t2NhYzZs3T7179zZv1S8u/fr1U2BgoMWx4OBgZowAAChlSkQwio2N1YQJEyyOZT0OCwuTj4+P3NzctG7dOs2aNUvjxo2Tq6urgoKCFBISUhwlW/D09JSnp6fFMWdn52KqBgAA5FeJCEa1a9fWsWPH8mxXr149rV69uggqAgAAt6MSEYxKOxZfAwBQNhCM7IDF1wAAlA0EIztg8TUAAGUDwcgOWHwNAEDZwJQGAACACcEIAADAhEtpdsCuNAAAygaCkR2wKw0AgLKBYGQH7EoDAKBsIBjZAbvSAAAoG5jSAAAAMCEYAQAAmBCMAAAATFhjZAds1wcAoGwgGNkB2/UBACgbCEZ2wHZ9AADKBoKRHbBdHwCAsoEpDQAAABOCEQAAgAnBCAAAwIRgBAAAYMLiazvgPkYAAJQNBCM74D5GAACUDQQjO+A+RgAAlA0EIzvgPkYAAJQNTGkAAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCE7fp2wJ2vAQAoGwhGdsCdrwEAKBsIRnbAna8BACgbCEZ2wJ2vAQAoG5jSAAAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAw4c7XdsCXyAIAUDYQjOyAL5EFAKBsIBjZAV8iCwBA2UAwsgO+RBYAgLKBKQ0AAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEQAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAQAAmDgVdwFlQUxMjC5evGhxLC0tTQ4O5E4AAEoTgpEdbNmyRUuWLMl23M3NrRiqAQAA+UUwsoN+/fopMDDQ4lhwcDAzRgAAlDIEIzvw9PSUp6enxTFnZ+diqgYAAOQXUxoAAAAmBCMAAAATglEZkJlptGs7AABuV6wxKgMcHAxauumAomLic23jfbeHhvT+lyTDLfsyZmbKwKJxAMBtimBURkTFxOvvqLhcz9/p4SaDg4NO7lyp5NjzObYpX8NL9YJGFlaJAACUeASj20xy7HklR5+26TmZmUY5ONx6psmWdgAAlFQEI+TJmkt1tTyraMyADkVYFQAA9kcwglXyulQHAEBZwCpbFDtrdssZMzOt6svadgAA5IQZIxS7vC7VtfS+U/0ebHXLheMSi8cBAAVHMEKJcKtLdXd63Pgy3vwsHAcAwBZcSgMAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABObd6WdOXNG+/bt048//qjo6Ghdv35d1apV0z333KN27dqpffv2cnZ2LoxaAQAACpXVwejQoUNasWKFvvnmG2VmZqpmzZqqUaOGXFxcdPbsWX3//fd67733VL16dfXr108jRoxQpUqVCrN2AAAAu7IqGI0ZM0YRERHq2LGj3nzzTfn4+Kh69eoWbTIyMnTs2DHt3r1bH3/8sbZs2aL58+erffv2hVI4AACAvVkVjCpWrKhdu3bprrvuyrWNo6OjmjRpoiZNmmjcuHH66KOPFB0dbbdCAQAACptVwej111+3qVMHBwf16dMnXwUBAAAUF6t2pa1du1ZxcWXjm9Xj4uL09NNP68EHH1Tv3r01ffp0paamms+fOHFCjz76qLp3764hQ4YoJiamGKsFAABFyapgNG/ePPn7++u5557T/v37ZTTm/W3oJZXBYNCzzz6rTz/9VB999JGSk5MVFhZmPj9jxgw988wz+t///qdOnTrpzTffLMZqAQBAUbIqGK1evVoPPPCA9u7dq2eeeUadO3fWokWLdObMGbsUcerUKb388st6+OGH1aRJEwUFBeXY7uTJkxoxYoRatWolX19fzZo1S9evX7dprKpVq6pNmzaSblzya9asmc6dOydJunTpkk6cOKEHHnhAkvTEE0/os88+K8ArAwAApYlVwahDhw5688039dVXX+mll16Su7u73nnnHXXv3l3Dhg3Tzp07LS5H2SoyMlIRERGqW7euGjRokGObhIQEDR06VElJSVq0aJFCQ0O1Y8cOvfjii/keNyUlReHh4erUqZMk6cKFC/Ly8pLBYJAkVapUSc7OzmXmMiIAALg1m27wWLlyZQ0cOFADBw7U8ePHtXXrVu3YsUMhISFyc3NTUFCQ+vbtq2bNmtlURGBgoLp27SpJmjJlig4fPpytzebNm5WQkKDt27ebbxXg6OiokJAQBQcHmwPVgAEDctwN16BBA61cudL8ODMzU6GhoWrXrp38/f0lKddLhFlBCQAAlG023/k6yz333KMpU6Zo0qRJ2rt3r7Zt26ZNmzZp8+bN+uOPP2zqy8Eh74mrffv2ydfX1+L+Sd27d9e0adMUERFhDkabNm2yasyZM2fKyclJ06ZNMx/z8vLShQsXZDQaZTAYdPXqVaWlpalq1ao2vR4AAFA65TsYZbly5YpOnTqlU6dOyWg0ysmpwF3mKGu32D+5uLioTp06OnHihE19vf7664qOjtaSJUssZoPc3d1Vr149ff755+rWrZu2bt2qbt265dpPly5dcj13/vx5eXl52VQXAAAoXvlKMRkZGdq7d68+/PBD7d+/X+np6WrYsKGmTJmihx9+2N41SrqxxsjNzS3bcTc3N8XHx1vdT2RkpFavXq369eubg1b79u0VGhoqSXrllVcUGhqq+fPny9PTU/Pnz7fPCwAAACWeTcHo+PHj+vDDD7Vjxw7FxsaqQoUK6tu3rx577DG1aNGisGq8pazLXtZq2LChjh07dsvz27Zts6qvPXv25HruVrNJAACgZLIqGG3ZskUffvihfvvtNxmNRv3rX//SxIkT1aNHD7m6uhZ2jZJuzAwlJCRkO56YmJjrTjYAAABbWBWMZsyYIXd3d40YMUKPPfaY7r777kIuK7sGDRpkW0uUmpqq06dPZ1t7VNRiYmJ08eJFi2NpaWlWLSoHAAAlh1XBaOnSperUqZMcHR0Lu55c+fv7a9myZYqLi1O1atUkSbt371ZqaqoCAgKKrS7pxozakiVLsh3PaU0UAAAouawKRjmtlzlx4oS+++47xcXF6bHHHpOHh4eio6NVpUoVmy+vJScnKyIiQpIUFRWlq1ev6tNPP5UktW3bVtWrV1f//v21YcMGjR49WqNHj1ZsbKzmzZun3r17F/ultH79+ikwMNDiWHBwMDNGAACUMjbvSsvIyNBLL72k8PBw88Jnf39/eXh4aMaMGWrcuLEmTJhgU5+xsbHZnpP1OCwsTD4+PnJzc9O6des0a9YsjRs3Tq6urgoKClJISIitL8HuPD095enpaXHM2dm5mKoBAAD5ZXMwWrZsmXbu3KnJkyfLz8/P4nvN/Pz8FB4ebnMwql279i13imWpV6+eVq9ebWvJAAAAVrE5GIWHh2v06NF66qmnlJGRYXGudu3aOnv2rN2KAwAAKEo2B6Po6Gi1atUqx3PlypVTUlJSQWsqddiVBgBA2WBzMKpRo4bOnDmjdu3aZTt38uRJ3XHHHXYprDRhVxoAAGWDzcEoICBAy5cvl7+/v9zd3SXd+Pb5xMRErV+/Xp07d7Z7kSUdu9IAACgbbA5G48eP1759+9SzZ0/5+PjIYDDorbfeUmRkpJycnDR69OjCqLNEY1caAABlg81TGu7u7tq6dat69eql33//XY6Ojjp69Kj8/f21efNmVa1atRDKBAAAKHw2zxhdvnxZ7u7uevXVV3M8//vvv6tp06YFLqw0YfE1AABlg83BKDg4WGFhYSpXrly2c5GRkRoxYoQOHjxol+JKCxZfAwBQNtgcjC5duqSQkBAtXrzY4vipU6f01FNPFfvXcxQHFl8DAFA22Pwv94oVK/Ttt99q7ty55mPnzp3TsGHD5OnpqXfffdeuBZYGnp6eatq0qcUfZ2fnYv3SXQAAYDubZ4waNGigxYsXa8SIEapVq5Z69uypYcOGqWLFilqzZo0qVapUGHUCAAAUunxd62nbtq1mzZql1157TU888YQk6b333mNHGgAAKNWsmjG6cuVKtmMBAQEaNGiQduzYoVWrVsnZ2dncjoAEAABKI6uCUbt27WQwGHI8ZzQa9eijj1ocO3LkSMErK0XYrg8AQNlgVTAaM2ZMrsEIbNcHAKCssCoYjRs3rrDrKNXYrg8AQNlg8640ZMd3pQEAUDZYNaWxcuVKXb9+3aaODx8+rC+//DI/NQEAABQLq4LRtm3b1LVrVy1YsEAnTpzItV1KSor+97//6ZlnnlH//v2VmJhot0IBAAAKm1WX0nbs2KGNGzdqzZo1WrFihWrUqKEmTZqoRo0acnFxUXx8vE6fPq0///xTGRkZCggIUHh4uBo2bFjY9QMAANiNVcHIyclJQ4cO1aBBg7Rnzx5FRETo559/1k8//aTr16+rWrVqql+/vkaPHq3evXvrrrvuKuy6AQAA7M6mxdeOjo564IEH9MADDxRWPaUS9zECAKBsYFeaHXAfIwAAygaCkR1wHyMAAMoGgpEdcB8jAADKBqY0AAAATAhGAAAAJgQjAAAAE5uD0ahRo7R///7CqAUAAKBY2RyMTpw4oWeeeUbdu3fXunXrdPXq1cKoCwAAoMjZHIx2796t5cuXq06dOpo3b578/Pz08ssv69ixY4VRHwAAQJHJ13b9gIAABQQE6PTp09q4caPCw8P1wQcfqHXr1nryySfVrVs3OTo62rvWEos7XwMAUDYU6D5GderU0dSpUzV69GiNHz9ehw4d0vfffy9PT089/fTTGjRokAwGg71qLbG48zUAAGVDgYLRhQsXtGnTJm3dulWXL1+Wv7+/evbsqT179mjOnDk6efKkXn75ZXvVWmJx52sAAMqGfAWjb775Rhs3btSXX34pFxcX9enTR4MHD9bdd98tSXrkkUe0bt06LVmy5LYIRtz5GgCAssHmYNSjRw/9/fffql27tkJCQvTYY4+pUqVK2dq1bNlSiYmJdikSKIjMTKMcHG59SdeaNgCAss/mYFSzZk1NmjRJnTt3vuX6oSZNmmjPnj0FKg6wBwcHg5ZuOqComPgcz9fyrKIxAzoUcVUAgJLI5mC0du1aq9q5uLioVq1atnYPFIqomHj9HRVX3GUAAEo4VgfjtlelsquMmZlWtbW2HQCgdLJ5xujee+/N9RKawWBQ5cqV1axZM40cOVLt2rUrcIFAYavo6iKDg4NO7lyp5NjzubYrX8NL9YJGFmFlAICiZnMwGjNmjLZv366kpCR17txZ7u7uunjxor788ktVrFhRgYGB+uabbzR8+HCtXLlSHTqwdgOlQ3LseSVHny7uMgAAxcjmYFSlShV5eHhox44dqlChgvl4UlKShg8frpo1a2r79u166qmntHz5coIRyjRrd7Ox6w0ASgebg9H69es1adIki1AkSRUrVtTw4cP12muv6emnn9aAAQP04osv2q1QoCTKa8ebxK43AChNbA5GFy5ckJNTzk9zdHTUpUuXJEkeHh5KT08vWHVAKcCONwAoO2wORvXq1VNYWJj8/f0tAlJ6errCwsJUr149SdLFixdVvXp1+1VagvElsigsXKoDgKJlczAaP368xo8frwceeEBdunSRu7u7Ll26pD179ig6OlqLFi2SJB04cECtWrWyd70lEl8ii8JizaU677s9NKT3vyTdOhgZMzNlIKwDwC3ZHIy6du2q5cuXa9GiRdqwYYOMRqMMBoOaNWummTNnys/PT5I0e/ZsuxdbUvElsihMeV2qu9PDLc/bDXCrAQCwjk3BKDU1Vd9++63uuecebd26VcnJyUpISJCbm5vKly9fWDWWeHyJLEoCbjcAAAVn05SGk5OTRo0apVOnTkmSypcvr5o1a97WoQgAAJQdNgUjBwcH1axZU1evXi2segAAAIqNzYtgHnvsMW3cuFEZGRmFUQ8AAChE27Ztk7e3t7y9vXXo0KFs541Go7p16yZvb28NHjzYbuN6e3tr8eLFNj/v7Nmz8vb21rZt2+xWy63YvPja2dlZJ0+eVM+ePRUYGCgPDw+L704zGAwaNmyYPWsEAAB2VrFiRW3dulU+Pj4Wx7/99ludPn1aFStWLKbKipfNwWj+/Pnm/37vvfeynScYAQBQ8vXs2VM7duzQjBkzVKlSJfPxrVu36r777rttl83YHIz27NlTGHUAAIAi1KtXL+3YsUM7d+5U//79JUmJiYn67LPP9OKLL2rdunUW7a9cuaKFCxdqz549iouLU82aNRUUFKQxY8bIxcXF3O7q1auaN2+edu/erdTUVN1///25fkXY33//rcWLF+vrr79WYmKi7rrrLg0aNEhPPvlk4b3wPNgcjGrVqlUYdQAAgCJUqVIlde/eXR9++KE5GO3cuVMODg7q0aOHRTBKSUnRkCFDdObMGY0bN07e3t76/vvvtWLFCh05ckQrVqyQdGN90ujRo/XTTz9pzJgxat68uX788UeNHJn9PmrHjx9X//795eXlpdDQUHl4eOirr77SrFmzFBcXp7FjxxbNG3ETm4NRlhMnTui7775TXFycHnvsMXl4eCg6OlpVqlSRq6urPWsEAACF4NFHH9WQIUMUGRmphg0b6sMPP9SDDz5ocWlNksLDw3Xs2DEtXLhQPXr0kCR16NBBFSpU0Pz583XgwAF16NBB+/fv16FDhzR9+nQNGTLE3M7Z2VkLFiyw6HPu3LmqWLGiNm3aZB6vQ4cOSk1N1YoVKzR48GBVqVKlCN4FSzbvSsvIyNC0adMUFBSkV155RYsWLVJMTIwkacaMGXr33XftXiQAALC/tm3bqk6dOvrwww917Ngx/fbbb3r00UeztTt48KAqVKigBx980OJ43759JUnffPONJJl3ufXu3duiXVBQkMXjlJQUHTx4UN26dZOrq6vS09PNf/z9/ZWSkqKff/7ZXi/TJjbPGC1btkw7d+7U5MmT5efnZ/Fi/fz8FB4ergkTJti1SACFw5ovn+ULaoGyy2AwqG/fvlq/fr1SUlJ09913q3Xr1tnaXblyRe7u7ha70CWpRo0acnJy0pUrV8ztnJycVK1aNYt2Hh4e2fpLT0/X+vXrtX79+hxri4vL/auQCpPNwSg8PFyjR4/WU089le1eRrVr19bZs2ftVhyAwpXXl9TW8qyiMQM65Lt/ghdQ8vXt21eLFi3S5s2b9fzzz+fYpmrVqvrll1/M34+aJTY2Vunp6eYgVLVqVaWnpysuLs4iHF28eNGiPzc3Nzk6Ourhhx/WwIEDcxyzdu3aBX1p+WJzMIqOjlarVq1yPFeuXDklJSUVtCYARSivL6ktiMIOXgAKrmbNmhoxYoT++usvPfLIIzm28fX11a5du/T555+rW7du5uPbt283n5ckHx8frVq1Sjt27DCvMZJuLOr+p/Lly8vHx0d//PGHvL29LXa1FTebg1GNGjV05swZtWvXLtu5kydP6o477rBLYQDKhlsFryqVXWXMzJTBIe/ljta2A2C7kJCQW55/5JFHtHHjRoWGhioqKkqNGjXSDz/8oHfffVcBAQFq3769JKljx45q06aN3njjDSUnJ6tZs2b68ccf9dFHH2Xrc/r06Ro4cKCefPJJDRgwQLVq1VJSUpJOnz6tL774QmFhYYXyWvNiczAKCAjQ8uXL5e/vL3d3d0k3rlEmJiZq/fr16ty5s92LBFA2VXR1kcHBQSd3rlRy7Plc25Wv4aV6Qdm3+wIoGuXKlVNYWJgWLFigVatWme9jNHz4cItt9Q4ODlq2bJnmzp2rVatWKS0tTffff79WrFhh3s2W5Z577tG2bdv0zjvvaOHChbp8+bIqV66sunXrKiAgoKhfopnNwWj8+PHat2+fevbsKR8fHxkMBr311luKjIyUk5OTRo8eXRh1lmgxMTHZrp+mpaXJgf+7BaySHHteydGni7sM4LbQt29f826yW7n58lfVqlU1c+ZMzZw585bPq1y5subMmaM5c+ZYHD927Fi2trVr187WLqc2OT23sNgcjNzd3bV161YtWrRIERERcnR01NGjR9W5c2eNHz9eVatWLYQyS7YtW7ZoyZIl2Y67ubkVQzUAACC/8nWDR3d3d7366qv2rqXU6tevnwIDAy2OBQcHM2MEAEApk+87X+P/eXp6ytPT0+KYs7NzMVUDAADyK1/B6Pvvv9fOnTt17tw5Xb9+3eKcwWDI9sVzAAAApYHNwejDDz/U9OnTVaVKFdWrVy/bzIjRaLRbcQAAAEXJ5mC0atUq9ejRQ6+99lqJuiETAABAQdm8OvjcuXN6/PHHCUUAAKDMsTkYNWjQQJcuXSqMWgAAAIqVzcHo+eef18qVKxUdHV0Y9QAAABQbm9cYbdy4UYmJierevbvuvffebDd0NBgMWrZsmb3qAwAAKDI2B6M///xTDg4Oql69umJiYhQTE2Nx3mAw2K04AABQNkVERCgsLEyHDx9WUlKSPDw8FBAQoOHDh6tOnTrFVpfNweiLL74ojDoAAEA+ZGYa5eBQ9JMSBRl3wYIFWr58ubp166aZM2eqRo0aioqKUnh4uIYNG1asWYM7XwMAUIo5OBi0dNMBRcXEF9mYtTyraMyADvl67r59+7R8+XI9++yzeuGFF8zH27Rpo0ceeaTYJ2CsCkbbt29XQECAqlWrZj4WHR0td3d3OTo6WhzbvHmzJkyYYP9KAQBAjqJi4vV3VFxxl2GVNWvWyN3dXePGjcvxfNZ3j2ZmZmrFihV6//33FRMTozvvvFMDBw7UsGHDJEmff/65xowZo+XLl6tz586SpISEBPXu3VstW7bUokWL8lWfVbvSpk6dqjNnzpgfZ2RkqFOnTjp69KhFuwsXLmj58uX5KgQAAJRt6enp+vHHH+Xr65vnd4q+/vrrevvtt/XQQw9p+fLl6tKli+bOnaulS5dKkrp27aq+ffvqxRdf1OXLlyVJM2fOVEZGhmbOnJnvGq2aMcrpaz746g8AAGCLK1euKCUlRV5eXrdsd/nyZW3YsEFPPfWUnnvuOUlSx44dlZSUpFWrVmnYsGGqWLGipk+frkOHDunll19Wz549tXPnTq1YscLiCpetbL6PEQAAQH5kTarktYP9119/VVpamnr27GlxvFevXrp27ZqOHDkiSapUqZLmzZunPXv2KDQ0VAMGDFBAQECBaiQYAQCAIlGtWjWVK1dO586du2W7+PgbC8k9PDwsjru7u0u6MfOU5b777lOtWrWUmpqqQYMGFbhGghEAACgSTk5O+te//qVvvvlGaWlpubbLunn0zV9BlvX4nzeXXrJkiWJjY3X33Xdr5syZBV7qY/V2/UOHDunChQuSbqwUNxgMOnTokKKiosxt/v777wIVAwAAyrannnpKI0eO1NKlS83rh/5p7969atmypZydnbVr1y41bdrUfO6TTz5RhQoV1KRJE0nSTz/9pJUrV2rGjBlq2rSp+vfvr7Vr1+qpp57Kd31WB6M333wz27HXX3892zHufA0AQNGq5Vml1Izn7++vUaNGadmyZfrrr7/Uq1cv8w0eP/74Y508eVJffPGFBg8erDVr1sjFxUX333+/vvnmG23ZskXjxo1ThQoVdO3aNYWGhqpDhw7q16+fJCk4OFhvvfWWOnbsqIYNG+arPquCUVhYWL46BwAAhSsz05jvmy0WdNz83vn6+eef13333af169frpZdeUlJSkjw9PdW+fXtNnTpVkjRp0iS5ubnpgw8+0IoVK+Tl5aUpU6aY72M0b948xcfHa/bs2eZ+R40apYiICIWGhmrLli153hIgJ1YFo7Zt29rcMQAAKHzF8XUg9hi3U6dO6tSp0y36d1BwcLCCg4NzPP/qq6/q1VdftTjm6Oio999/v0B1sfgaAADA5Lb7rrS4uDhNmjRJZ8+elbOzs1q0aKEZM2bIxcVFkjRt2jTt379fMTEx+v333+XkdNu9RQAA3LZuuxkjg8GgZ599Vp9++qk++ugjJScnW6yheuSRRxQeHl6MFQIAgOJSIqZDTp06pdWrV+uXX35RZGSk6tevr507d2Zrd/LkSc2aNUs//PCDypcvr169eikkJESurq5Wj1W1alW1adNG0o3rl82aNdPZs2fN51lPBQDA7atEzBhFRkYqIiJCdevWVYMGDXJsk5CQoKFDhyopKUmLFi1SaGioduzYoRdffDHf46akpCg8PPyWi78AAMDto0TMGAUGBqpr166SpClTpujw4cPZ2mzevFkJCQnavn27qlevLunG6vOQkBAFBwebA9WAAQMUHR2d7fkNGjTQypUrzY8zMzMVGhqqdu3ayd/fvzBeFgAAKGVsDkbbt2/P9ZzBYJCbm5uaNGmimjVrWt2ng0PeE1f79u2Tr6+vORRJUvfu3TVt2jRFRESYg9GmTZusGnPmzJlycnLStGnTrK4TAACUbTYHoylTppjvbv3P7yP55zEHBwc9/PDD+ve//223XV0nTpzQo48+anHMxcVFderU0YkTJ2zq6/XXX1d0dLSWLFlSoDt1d+nSJddz58+fl5eXV777BgAARc/m1PLBBx/o+eefV4cOHRQUFKQaNWro0qVL2rlzpw4cOKBXXnlFv//+u5YuXapatWpp7Nixdik0ISFBbm5u2Y67ubmZv4XXGpGRkVq9erXq169vDlrt27dXaGiopBt32jx06JCkG5f4WrdurbfeessOrwAAAJR0NgejsLAwdevWzRwkJKl+/fpq27at5s2bpw8//FALFy5UfHy8duzYYbdglBuj0WjTrE/Dhg117NixXM+/8cYbVve1Z8+eXM/dajYJAIDb1eLFi7VmzRr99NNPOnv2rLp06aK3335bDz74YHGXJikfu9K+/PJL+fn55XjO399fX331lSSpXbt2OnfuXMGq+wc3NzclJCRkO56YmJjjTBIAALcDY2bmbTVuYbN5xigjI0OnT59W+/bts507deqUed2Ri4uL+W7S9tCgQYNsa4lSU1N1+vTpbGuPilpMTIwuXrxocSwtLc2qReUAABSEwcFBJ3euVHLs+SIbs3wNL9ULGllk4xUlm4NRx44dtXDhQt11113q0OH/v813//79evvtt83H/vrrL9WqVctuhfr7+2vZsmWKi4tTtWrVJEm7d+9WamqqAgIC7DZOfmzZskVLlizJdpyZLABAUUiOPa/k6NPFXUa+JScna9q0afrf//4nR0dH9enTR5MmTbLYwHXhwgXNnz9f+/fvV3Jyspo3b66pU6eqWbNmdq3F5mA0ffp0DR48WE8//bQqVqyoGjVqKDY2VklJSapTp46mT59ubjt06FCr+kxOTlZERIQkKSoqSlevXtWnn34q6cadqKtXr67+/ftrw4YNGj16tEaPHq3Y2FjNmzdPvXv3zvWmkEWlX79+CgwMtDgWHBzMjBEAAFZ46623zBMvf/zxhxYtWiRnZ2eFhIRIkuLj4zVw4EBVqFBBL730kipXrqz169dr6NCh+uyzz1SjRg271WJzMKpZs6Y++ugjbdu2Td9//72uXLmiJk2aqE2bNurTp4/Kly8vSXryySet7jM2NlYTJkywOJb1OCwsTD4+PnJzc9O6des0a9YsjRs3Tq6urgoKCjK/acXJ09NTnp6eFsecnZ2LqRoAAEqXOnXqaO7cuZIkPz8/JScna+3atRo5cqSqVKmidevWKSEhQR988IE5BPn6+qpbt25avXq1Jk+ebLda8nWTofLly+vJJ5+0KfzcSu3atW+5UyxLvXr1tHr1aruMCQAASoZu3bpZPH7ggQe0bNky/fnnn2rTpo0OHDggHx8fValSRenp6ZJu3By6devW+u233+xaS4n4ShAAAHD7+ue3WkgyzwplbWyKi4vTzz//rKZNm2Z7bp06dexai83BKC0tTStXrtTOnTt17tw5paSkWJw3GAz6448/7FZgacCuNAAA8u/y5csWj2NjYyVJHh4ekqQqVarIz88v27IbSXbdAS/lIxi99dZbWrt2rfz9/dW1a1e7F1QasSsNAID82717t4YNG2Z+/Nlnn6l8+fJq1KiRpBvfUPHxxx+rQYMGqlChQqHWYnMw2rVrl8aMGVPod7QuTdiVBgBA/p0+fVpTp05Vz5499ccff2jVqlUaMmSIqlSpIkkaNmyYduzYoUGDBmnIkCG68847dfnyZf3yyy+qWbOmRagqKJuDUXx8vFq3bm23AsoCdqUBAIpT+RpF+6Xl9h7v+eef17fffqsJEybI0dFRAwYM0PPPP28+X61aNW3ZskULFy7U/PnzdeXKFdWoUUMtW7bMtnC7oGwORm3atNHRo0fVrl07uxYCALbIzDTKwSHv70m0th1QWhkzM4vlLtTGzEwZ8nFlZNy4cRo3bpwky13pffv21bx583J9noeHh2bPnp2/Ym1gczB68cUXNXr0aN15553q1KkTa4wAFAsHB4OWbjqgqJj4XNvU8qyiMQM65HoeKAvyE05K87iFzeZg9PDDDys9PV0TJkyQwWCQq6urxXmDwaAffvjBbgWWBuxKA4pHVEy8/o6KK+4yAJQhNgej7t27y2BgWvqf2JUGAEDZYHMwutX1v9sVu9IAACgbuPO1HbArDQCAssGqYPTdd9+pSZMmqlixor777rs827dp06bAhQFAQVWp7GrVzpn87q4BUPZYFYwGDx6s999/Xy1atNDgwYNzXWNkNBplMBh05MgRuxYJAPlR0dVFBgcHndy5Usmx53NsU76GV7FsdQZQMlkVjMLCwtSgQQPzf8MSu9KAki059rySo08XdxkASgGrglHbtm1z/G/cwK40AADKBhZf2wG70gAAKBusCkZTp061ukODwaA5c+bku6DSiF1pAACUDVYFo0OHDlk8TkxMVGJiopycnFS1alVduXJF6enpqly5MpePAJQJfBcbcHuyKhh98cUX5v/+9ddfNW7cOM2YMUM9evSQo6OjMjIy9Mknn+iNN97QggULCq1YACgqfBcbcHuyeY3Ra6+9puHDhysoKMh8zNHRUb1791ZsbKzmzJmjzZs327VIACgOfBcbcPuxeXXw77//rkaNGuV4rlGjRjp69GiBiwKAsi4z02iXNgDsy+YZo0qVKunrr7+Wr69vtnNff/21KlWqZJfCShPuYwTAVnldquMyHVA8bA5GDz30kFavXq309HT17t1b7u7uunTpknbs2KF169Zp2LBhhVBmycZ9jADkB5fqgJLH5mD0wgsv6PLly3rvvfe0du1a83Gj0aiHHnpIL7zwgj3rKxW4jxEAAGWDzcHIyclJ8+bN0zPPPKNDhw7pypUrqlq1qtq2bWv+2pDbDfcxAgCgbMj3na/r16+v+vXr27MWAACAYpXvYBQbG6uoqCilpKRkO9emTZsCFQUAAFAcbA5GMTExmjx5svlu2Ebjje2kBoNBRqNRBoNBR44csW+VAHCbqVLZVcbMTBmsWKtobTsAebM5GP373//WkSNHFBISIm9vb7m4uBRGXQBwW6vo6iKDg4NO7lyp5NjzubYrX8NL9YJGFmFlQNlmczD69ttvNXnyZD366KOFUQ8A4B+SY88rOfp0cZcB3DZsnns1GAzy8vIqjFoAAACKlc0zRg8++KD27t2r9u3bF0Y9pRJ3vgYAoGywORj16NFDL730koxGozp37qyqVatma9O0aVN71FZqcOdrAADKBpuD0dChQyVJGzZs0MaNGy3O3a670rjzNQAAZYPNwWju3LmFUUepxp2vAQAoG2wORn369CmMOgAAAIod13oAAABMrJoxWrJkiR5//HHVrFkzx0XG/2QwGDRmzBi7FAcAAFCUrA5G/v7+BCMAAFCmWRWMjh49muN/AwAAlCWsMQIAADApcDC6evWqfvvtN0VFRdmjHgAAgGJj9Xb9L7/8Ujt37pSzs7N69+6t9u3ba+PGjZo/f76uX78uSerWrZvefPNN7uEDAABKJauC0ZdffqlRo0bJxcVFzs7O+vjjj/XSSy9p1qxZ6tChg7y9vXXkyBHt3r1bmzZt0pAhQwq7bgAAALuzKhitXr1avr6+Wr58ucqVK6dZs2Zp7ty5euKJJzRz5kxzu2nTpmn79u23XTDiS2QBACgbrApGx48f17///W+VK1dOkvT0009rw4YN6tatm0W77t276/PPP7d/lSUcXyILAEDZYFUwiouLk4eHh/mxu7u7JKlatWoW7apWrarExEQ7llc68CWyAACUDVYvvjYYDDn+N/gSWQAAygqrg9Fff/0lR0dHSVJGRob52M1tAAAASiurg9HUqVOzHZs8ebLFY6PRyGwSAAAotawKRnPnzi3sOgAAAIqdVcGoT58+hV0HAABAsWPbFAAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAUAZlJlptEsb4HZj9X2MAAClh4ODQUs3HVBUTHyO52t5VtGYAR3y1XdmplEODnnfs87adkBJQjACgDIqKiZef0fF2b3fvEKXVLDgBRQnghEAwGaFFbqA4sYaIwAAABOCEQAAgAmX0uwgJiZGFy9etDiWlpYmBwdyJwAApQnByA62bNmiJUuWZDvu5uZWDNUAAID8IhjZQb9+/RQYGGhxLDg4mBkjALetKpVdZczMlCGP34PWtAGKEsHIDjw9PeXp6WlxzNnZuZiqAYDiV9HVRQYHB53cuVLJsedzbFO+hpfqBY0s4sqAWyMYAQAKTXLseSVHny7uMgCrMX8JAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEQAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAQAAmBCMAAAATJyKu4CiFhcXp0mTJuns2bNydnZWixYtNGPGDLm4uNzyHAAAKPtuuxkjg8GgZ599Vp9++qk++ugjJScnKywsLM9zAACg7CsRwejUqVN6+eWX9fDDD6tJkyYKCgrKsd3Jkyc1YsQItWrVSr6+vpo1a5auX79u01hVq1ZVmzZtJEkODg5q1qyZzp07l+c5AABQ9pWIYBQZGamIiAjVrVtXDRo0yLFNQkKChg4dqqSkJC1atEihoaHasWOHXnzxxXyPm5KSovDwcHXq1MmmcwAAoGwqEWuMAgMD1bVrV0nSlClTdPjw4WxtNm/erISEBG3fvl3Vq1eXJDk6OiokJETBwcHmQDVgwABFR0dne36DBg20cuVK8+PMzEyFhoaqXbt28vf3t2h7q3MAAKDsKhHByMEh74mrffv2ydfX1xyKJKl79+6aNm2aIiIizMFo06ZNVo05c+ZMOTk5adq0aTadAwAAZVeJCEbWOHHihB599FGLYy4uLqpTp45OnDhhU1+vv/66oqOjtWTJEhkMBqvP3axLly65njt//ry8vLxsqgsAABSvUhOMEhIS5Obmlu24m5ub4uPjre4nMjJSq1evVv369c1Bq3379goNDb3lOQAAUPaVmmCUG6PRmOfMzj81bNhQx44ds/lcTvbs2ZPruVvNJgEAgJKpROxKs4abm5sSEhKyHU9MTMxxJgkAAMBWpSYYNWjQINtaotTUVJ0+fTrXLf4AAAC2KDWX0vz9/bVs2TLFxcWpWrVqkqTdu3crNTVVAQEBxVpbTEyMLl68aHEsLS3Nqt12AACg5CgRwSg5OVkRERGSpKioKF29elWffvqpJKlt27aqXr26+vfvrw0bNmj06NEaPXq0YmNjNW/ePPXu3bvYZ4y2bNmiJUuWZDvOJT4AsF1mplEODnmvHbW2HWCLEhGMYmNjNWHCBItjWY/DwsLk4+MjNzc3rVu3TrNmzdK4cePk6uqqoKAghYSEFEfJFvr166fAwECLY8HBwcwYAUA+ODgYtHTTAUXF5L7juJZnFY0Z0KEIq8LtokQEo9q1a1u1G6xevXpavXp1EVRkG09PT3l6elocc3Z2LqZqAKD0i4qJ199RccVdBm5DTGkAAACYlIgZo9KOxdcAAJQNBCM7YPE1AABlA8HIDlh8DQBA2UAwsgMWXwMAUDYwpQEAAGBCMAIAADDhUpodsCsNAICygWBkB+xKAwCgbCAY2QG70gCgaFWp7CpjZqYMefyetaYN8E8EIztgVxoAFK2Kri4yODjo5M6VSo49n2Ob8jW8VC9oZBFXhtKOYAQAKLWSY88rOfp0cZeBMoT5RQAAABOCEQAAgAmX0uyA7foAAJQNBCM7YLs+AABlA8HIDtiuDwBA2UAwsgO26wMAUDYwpQEAAGBCMAIAADAhGAEAAJgQjAAAAExYfG0H3McIAICygWBkB9zHCACAsoFgZAfcxwgAgLKBYGQH3McIAICygSkNAAAAE4IRAACACcEIAADAhGAEALitZGYa7doOZQuLrwEAtxUHB4OWbjqgqJj4XNvU8qyiMQM6FGFVKCkIRgCA205UTLz+joor7jJQAhGM7IA7XwMAUDYQjOyAO18DAFA2EIzsgDtfAwCyZGYa5eBgKHAbFA+CkR1w52sAQJa8FnezsLtkIxgBAGBnLO4uvbjWAwAAYEIwAgAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAABFqEplVxkzM61qa2072A/3MbIDvisNAGCtiq4uMjg46OTOlUqOPZ9ru/I1vFQvaGQRVgaJYGQXfFcaAMBWybHnlRx9urjLwE0IRnbAd6UBAFA2EIzsgO9KAwCgbGBKAwAAwIRgBAAAYEIwAgAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYGIxGo7G4iyiLmjdvroyMDHl5eZmPXU64pvT0zBzbu7o4ya2Sq9KuXlFmRnqu/To4Osm5UtVsx2/Vt7X959a3Nf07OTmouluFXM/npTDfm8LuvzjfG6lwP9uC1p5X//zcF9/PfWn+uSyK/kvaZ+vl5aUNGzbkux5Yj2BUSFq3bq3U1FR5eHhY1f78+fOSZBGk7Kk091+aay/t/Zfm2kt7/6W5dvq3f98Eo6JDMCohunTpIknas2cP/Rdh3/RffH3Tf/H1Tf/F239h146CYY0RAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABM2K4PAABgwowRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIyK2KlTp/Tyyy/r4YcfVpMmTRQUFGS3vnft2qXRo0crICBArVq1Uu/evfWf//xHmZmZJaK/4hxr//79GjRokNq1a6dmzZqpS5cumjt3rhITE0tUn0U1Tn77/PTTT+Xt7a2zZ8+WyLEkKSkpSf7+/vL29tZvv/1m03OLor+iHMeWPvP7fhfmWNu2bZO3t3e2P/Pnz89Xjfbur6SMBftyKu4CbjeRkZGKiIhQy5YtlZmZKXveLeG9997TnXfeqcmTJ6tGjRo6dOiQZs+erTNnzig0NLTY+yvOseLj43Xfffdp6NChcnNzU2RkpBYvXqzIyEitWbOmxPRZ1mov6rEk6Z133lFGRkaJ7a8oxymq2gt7rFWrVqly5crmxzVr1ixR/ZWUsWAnRhSpjIwM83+HhoYae/XqZbe+Y2Njsx2bM2eOsXnz5saUlJRi76+kjJVly5YtxkaNGhkvXLhQovssqnGs6XPXrl3GRo0aGc+cOVMixzp+/LixVatWxk2bNhkbNWpk/PXXXwtUp737K8pxbO2zIJ9tYY314YcfGhs1apTj74f8sHd/JWUs2BczRkXMwSHvq5d79uzR0qVLdfLkSTk6OqpOnTqaMGGCAgICbvm86tWrZzvWuHFjpaSk6MqVK/L09LSpb2v6CwwMVKdOnXTnnXdq3bp1SkhIUPv27TVz5kx5enrm+VqLY6wsVatWlSSlp6dLyv/7fqs+7V1zYY5zc59paWl6/fXX9dFHHykjI0Pdu3dXmzZt8l1zUYw1e/Zs9e/fX/Xq1ct2Lj+f7636s+dnWxjj3KpPe3+2RTnWzezx9/afCuvvbHGPBesRjEqY06dPa8KECerVq5cmTpyozMxMHT16VPHx8fnq74cfflDVqlVVo0YNu/T9z/6y7N69W7Vq1dIrr7yihIQEvfnmmxo3bpy2bNmSr5oLc6yMjAylp6fr+PHjWrp0qTp37qxatWoV6L3JrU971VyY49yqz7feekubNm3SuHHj1KRJE+3cuVMLFiywqeaiHOvTTz/V0aNHtWjRIv3+++8W5/Lz+d6qvyz2+GwLY5y8+rTnZ1sUYwUFBSkuLk533nmnnnjiCT399NNydHTM99/b3PrLYs/faUU5FuykuKesbmc5XUrLmmJOTEwscP+//vqrsUmTJsalS5fape+b+zMajcbOnTsb77vvPmN8fLz52Ndff21s1KiRcf/+/Xar3V5j+fn5GRs1amRs1KiRccSIEcakpCSj0Viw9ya3Pu1Vc2GOk1ufcXFxxhYtWhgXLlxo0b5fv375vtxSmGNdu3bNGBAQYPzggw+MRqPRePDgQYtLOrZ+vnn1ZzTa57MtjHHy6tOen21hj7Vv3z7j4sWLjfv27TPu37/fOHPmTOO9995rnDlzptFotP1zzas/o9F+f2eLcizYF7vSShhvb285OjoqJCREX3zxRb53Hl28eFHjx49X8+bNNXLkyAL3nVN/WXx8fOTm5mZ+7Ovrq0qVKunnn3+W9P8zBVl/jHksOC/IWHlZsWKFNm3apH//+986fvy4Ro0apYyMjAK9N7n1aW3N1r4/BR3Hlj7//PNPXb9+Xd26dbNo3717d4vHtny2BR3rVpYtW6YaNWqob9++OZ639fPNq78sBf1s7TWOLX3a87O111i58fPz09ixY+Xn56eOHTvq5Zdf1rBhw7R582bFxMTY/Lnm1V8We/ydtddYKHoEoxKmXr16Wr58uRITEzV27Fj5+vpq1KhROnfunNV9JCYmauTIkXJ1ddWyZcvk7OxcoL5z6y/LPy91/fPYxYsXJUnDhg1T06ZNzX++/fbbQhsrL/fee6/uv/9+PfHEE1qyZIkOHTqk3bt3F+h9z61Pa2u29v0p6Di29Jn1nJv7vPmxLZ9tQcfKTVRUlNasWaPx48fr6tWrSkhI0LVr1yRJ165dU1JSkk2frzX93apGaz9be45jS5/2+mztOZYtevTooYyMDB05csQuvy//2d+t6svv77SCjoWixxqjEsjf31/+/v66evWq9u3bp7lz52rq1Klat25dns9NSUlRcHCwLl26pC1btqhatWoF6juv/iQpNjY2x2MeHh6SpJkzZ1r8ks9pgaa9xrJF48aNzesUpIK977n1aU3N1r4/BR3Hlj5btWplfv4/txffPEZ+as/vWLk5e/as0tLS9Mwzz2Q7N2TIELVs2VLvv/++1Z+vtf3lVqO1n609x7Glz5CQEPPzC/LZ2nOsgrDH39ubFcbf2fyOhaJHMCrBKlWqpJ49e+rXX3/Vzp0782yfnp6uCRMm6OjRo9qwYYPFwtz89G1tf4cOHVJiYqL5Xh3ffPONrl69qpYtW0qS6tevb7fa8xrLFj/99JMyMjJUu3Zti+O2vu959WmP98ce49jSZ6NGjeTq6qrdu3erSZMm5jb/+9//LJ6Tn9rzO1ZuGjdurLCwMItjR44c0dy5czVz5kw1b97c4lxen68t/RXks7XnOLb0WatWLbt8tvYcyxaffPKJHB0dLfqT8v/3Nqf+CuPvbH7HQtEjGBWx5ORkRURESLoxFX316lV9+umnkqS2bdvqs88+008//SR/f395eHjo7Nmz+vjjj9WhQ4c8+3711Ve1d+9eTZo0SdevX7e4Rn3PPfdo586dNvWdV3+VKlWSJFWsWFEjR47UyJEjlZiYqPnz56tFixby8/Oz+n0p7LHGjh2rZs2aydvbW66urjp69KhWrVolb29vde3aVZs3b7b5fc+rzywFfX8KY5y8+nRxcVH//v21cuVKubq6mncT2XKJoqjGcnNzk4+PT47nsi512PL5WtNfloJ8toUxjrV92uOzLYqxRowYoXbt2qlRo0aSbmzNf//99zVkyBB5eHjY/Pc2r/6y2ON3WlGOBfsiGBWx2NhYTZgwweJY1uOwsDB5e3tr7969mjt3rq5cuSIPDw/16tUr23Ny8tVXX0mS3njjjWzn8tN3Xv1l/VLs1q2b7rjjDs2YMcPiPhy2KOyxWrRooU8++UQrVqyQ0WhUrVq19MQTT2jEiBFycXHJ1/ueV59ZCvr+FMY41vQ5ceJEZWRkaNWqVcrMzFS3bt303HPPaerUqVbXXtRj5aYgf69uxR4/+8UxTmG/3/Yaq169etq6dasuXLigzMxM3X333Zo2bZoGDx4syfbPNa/+stjj/S7KsWBfBmNeW4SAW8i6QdnLL79cpsayl6KquTS+N6Udn23ZxO80sCsNAADAhGAEAABgwqU0AAAAE2aMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIuI398ssvGjNmjDp16qRmzZqpffv26tevn+bNm2dzX9u2bZO3t7d+++03u9Tm7e2tV1991S59STe+28vb21vbtm0zH8uq+ezZs3YbB0Dpxp2vgdvUl19+qeDgYLVt21aTJk2Sh4eHLl68qMOHD+u///2vpkyZUtwlAkCRIxgBt6lVq1apdu3aWr16tZyc/v9XQa9evTRp0qRirAwAig+X0oDb1JUrV1StWjWLUJTFweH/fzV4e3tr8eLF2doEBgbmOKuUkJCgqVOnqm3btmrVqpVGjRqlM2fOWLT5448/9Oyzz8rX11fNmjVTx44d9cwzz+jChQvZ+tu+fbt69Oihli1b6qGHHtLevXuztfn77781ceJEc389evTQxo0brXofAOCfCEbAbapVq1b65ZdfNGvWLP3yyy9KS0uzS7/Tp0+XwWDQ/PnzNW3aNP36668aPHiwEhISJEnXrl3TU089pUuXLunll1/We++9p2nTpsnLy0tJSUkWfX355ZfauHGjxo8fr0WLFqlKlSoaO3asRdA6fvy4HnvsMf35558KDQ3Vu+++q06dOmnWrFlasmSJXV4TgNsHl9KA29TEiRP1119/af369Vq/fr2cnZ3VrFkzBQYG6sknn1TFihXz1W+zZs00Z84c8+N77rlHAwYM0MaNGxUcHKy//vpLV65c0ezZs9W1a1dzu549e2brKyUlRe+9954qVaokSWratKn8/Py0a9cuPfPMM5KkuXPnqmLFitq0aZO5XYcOHZSamqoVK1Zo8ODBqlKlSr5eC4DbDzNGwG2qWrVq+s9//qOtW7dq4sSJCgwM1N9//60333xTvXv31uXLl/PVb+/evS0e33///apVq5YOHTokSapbt66qVKmi+fPna9OmTTp+/Hiuffn4+JjDjiS5u7urRo0aioqKknQjOB08eFDdunWTq6ur0tPTzX/8/f2VkpKin3/+OV+vA8DtiRkj4DbXvHlzNW/eXJKUlpam+fPna+3atVq1apUmT55sc3/u7u45Hrty5YokqXLlylq/fr2WL1+uBQsWKD4+Xh4eHnriiScUHBwsZ2dn8/OqVq2arS8XFxelpKRIurFOKj093TzrlZO4uDibXwOA2xfBCICZs7Ozxo4dq7Vr1yoyMlLSjSCSmpqarW1ugePSpUs5HqtTp475sbe3txYsWCCj0ahjx45p27ZtWrp0qVxdXc2XyKzh5uYmR0dHPfzwwxo4cGCObWrXrm11fwBAMAJuUzExMfL09Mx2/MSJE5JkPlerVi0dO3bMos0333yja9eu5djvjh071L17d/PjH3/8UVFRUXrssceytTUYDLr33ns1bdo0hYeH6/fff7fpNZQvX14+Pj76448/5O3tLRcXF5ueDwA3IxgBt6kRI0bojjvuUOfOnVW/fn0ZjUYdOXJEa9asUYUKFTRkyBBJ0sMPP6y3335bb7/9ttq2bavjx49rw4YNqly5co79Hj58WNOnT9eDDz6oCxcuaMGCBapZs6Z5Rmfv3r36z3/+o65du+quu+6S0WjUZ599poSEBHXo0MHm1zF9+nQNHDhQTz75pAYMGKBatWopKSlJp0+f1hdffKGwsLD8v0kAbjsEI+A2FRwcrD179mjdunWKiYlRWlqaPDw81L59ez377LNq0KCBpBsB6urVqwoPD9eaNWvUokULvf322xo9enSO/c6ePVsfffSRXnjhBaWmpsrHx0fTp083rxeqW7eu3NzctGrVKsXExMjZ2Vn16tXTvHnz1KdPH5tfxz333KNt27bpnXfe0cKFC3X58mVVrlxZdevWVUBAQL7fHwC3J4PRaDQWdxEAAAAlAdv1AQAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIDJ/wG/hifJe7ZUcwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "g = sns.catplot(data=all_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\")\n", "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", yscale=\"log\", title=\"Binding Energies for all orbitals\")" @@ -508,9 +855,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "g = sns.catplot(data=considered_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\", order=considered_shells.index.levels[1].values)\n", "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", title=\"Binding Energies for considered orbitals\")" From 9e6db2f46d14e2301cc06c1ce350c33ea8ac2672 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:37:17 +0200 Subject: [PATCH 17/94] Revert "Remove typing.Self for python3.9" This reverts commit 8bde9892557274813ab7150579518e6fc660a408. --- wimprates/migdal.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 6e9b200..bd789e1 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional +from typing import Any, Optional, Self from fnmatch import fnmatch from functools import lru_cache @@ -55,15 +55,15 @@ class Shell: model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self, *args, **kwargs) -> np.ndarray: + def __call__(self: Self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self) -> int: + def n(self: Self) -> int: return int(self.name[0]) @property - def l(self) -> str: + def l(self: Self) -> str: return self.name[1:] From 5b608a549c727bc9628a8ed7894d611be9f23c4b Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:52:12 +0200 Subject: [PATCH 18/94] Revert "Require seaborn" This reverts commit e0d51d4761db159c83f19e78ae7aab3bef94fadc. --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 408d07d..81ced55 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,3 @@ pandas tqdm boltons numericalunits -seaborn From e6d05cc47d80adf56da5c1c8706ebe16760d97df Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 22:32:27 +0200 Subject: [PATCH 19/94] Require Python3.11 --- setup.py | 51 +++++++++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 22 deletions(-) diff --git a/setup.py b/setup.py index d7e5d33..7b2abd5 100644 --- a/setup.py +++ b/setup.py @@ -1,28 +1,35 @@ import setuptools -readme = open('README.md').read() -history = open('HISTORY.md').read().replace('.. :changelog:', '') -requirements = open('requirements.txt').read().splitlines() +readme = open("README.md").read() +history = open("HISTORY.md").read().replace(".. :changelog:", "") +requirements = open("requirements.txt").read().splitlines() setuptools.setup( - name='wimprates', - version='0.5.0', - description='Differential rates of WIMP-nucleus scattering', - long_description=readme + '\n\n' + history, - long_description_content_type='text/markdown', - author='Jelle Aalbers', - url='https://github.com/jelleaalbers/wimprates', - license='MIT', + name="wimprates", + version="0.5.0", + description="Differential rates of WIMP-nucleus scattering", + long_description=readme + "\n\n" + history, + long_description_content_type="text/markdown", + author="Jelle Aalbers", + url="https://github.com/jelleaalbers/wimprates", + license="MIT", packages=setuptools.find_packages(), - setup_requires=['pytest-runner'], + setup_requires=["pytest-runner"], install_requires=requirements, - package_dir={'wimprates': 'wimprates'}, - package_data={'wimprates': [ - 'data/bs/*', 'data/migdal/*', 'data/sd/*', 'data/dme/*']}, - tests_require=requirements + ['pytest', 'unittest'], - keywords='wimp,spin-dependent,spin-independent,bremsstrahlung,migdal', - classifiers=['Intended Audience :: Science/Research', - 'Development Status :: 3 - Alpha', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3'], - zip_safe=False) + package_dir={"wimprates": "wimprates"}, + package_data={ + "wimprates": ["data/bs/*", "data/migdal/*", "data/sd/*", "data/dme/*"] + }, + tests_require=requirements + ["pytest", "unittest"], + keywords="wimp,spin-dependent,spin-independent,bremsstrahlung,migdal", + classifiers=[ + "Intended Audience :: Science/Research", + "Development Status :: 3 - Alpha", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + ], + python_requires=">=3.11", + zip_safe=False, +) From ea47279ae5201822cec259bd12e851bde23aabc2 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 22:32:59 +0200 Subject: [PATCH 20/94] Require importlib package for Cox model --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 81ced55..a531b0f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ pandas tqdm boltons numericalunits +importlib_metadata \ No newline at end of file From 1eed19643cee9095e2557af89d5b50a56442b80d Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 23:05:16 +0200 Subject: [PATCH 21/94] Add __init__.py in tests to fix module structure Without it, pytests do not recognise wimprates.data.migdal.Cox modules --- tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/__init__.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 From 853c4f012a4bbad813ca44d03672b885bd6dad6b Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 01:14:15 +0200 Subject: [PATCH 22/94] Add all content of data/ for build --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 7b2abd5..ea4f5bc 100644 --- a/setup.py +++ b/setup.py @@ -18,7 +18,7 @@ install_requires=requirements, package_dir={"wimprates": "wimprates"}, package_data={ - "wimprates": ["data/bs/*", "data/migdal/*", "data/sd/*", "data/dme/*"] + "wimprates": ["data/bs/*", "data/migdal/**", "data/sd/*", "data/dme/*"] }, tests_require=requirements + ["pytest", "unittest"], keywords="wimp,spin-dependent,spin-independent,bremsstrahlung,migdal", From c95fdbe5f744cc3e448019bcd9793c6fd5819fca Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 01:18:46 +0200 Subject: [PATCH 23/94] Add deprecation warning for old func --- wimprates/migdal.py | 4 ++-- wimprates/utils.py | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-) mode change 100755 => 100644 wimprates/migdal.py diff --git a/wimprates/migdal.py b/wimprates/migdal.py old mode 100755 new mode 100644 index bd789e1..0b206ca --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -359,10 +359,10 @@ def diff_rate(v, erec): return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) - -### (DEPRECATED) Maintain this for backwards accessibility +@wr.deprecated("Use get_migdal_transitions_probability_iterators instead") @lru_cache() def read_migdal_transitions(material="Xe"): + ### (DEPRECATED) Maintain this for backwards accessibility # Differential transition probabilities for vs energy (eV) df_migdal_material = pd.read_csv( diff --git a/wimprates/utils.py b/wimprates/utils.py index f8c1d7b..890fb38 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -1,6 +1,8 @@ +import functools import inspect import os import pickle +import warnings from boltons.funcutils import wraps import numpy as np @@ -105,3 +107,21 @@ def pairwise_log_transform(a, b): b = np.atleast_1d(b).reshape(-1, 1) arr = np.concatenate((a, b), axis=1) return np.log(arr) + +@export +def deprecated(reason): + """ + This is a decorator which can be used to mark functions as deprecated. + It will result in a warning being emitted when the function is used. + """ + def decorator(func): + @functools.wraps(func) + def new_func(*args, **kwargs): + warnings.warn( + f"Call to deprecated function {func.__name__} ({reason}).", + category=DeprecationWarning, + stacklevel=2 + ) + return func(*args, **kwargs) + return new_func + return decorator \ No newline at end of file From 986937d3723df3e4d3c50a4b5231712ee2a553d9 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 14:26:00 +0200 Subject: [PATCH 24/94] Fix typing --- wimprates/data/migdal/Cox/cox_wrapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index 58366b6..67dd5f6 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -16,7 +16,7 @@ @export -def cox_migdal_model(element: str, **kwargs): +def cox_migdal_model(element: str, **kwargs) -> Migdal: """ This function creates a Cox Migdal model for a given element. From 176bf94dca743300c26f10a9d95a7e04fab16439 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:25:06 +0200 Subject: [PATCH 25/94] Reduce required python3 version to 3.9 --- setup.py | 4 +++- wimprates/migdal.py | 22 ++++++++++++---------- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/setup.py b/setup.py index ea4f5bc..2b55601 100644 --- a/setup.py +++ b/setup.py @@ -27,9 +27,11 @@ "Development Status :: 3 - Alpha", "Programming Language :: Python", "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", ], - python_requires=">=3.11", + python_requires=">=3.9", zip_safe=False, ) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 0b206ca..6c23e4b 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional, Self +from typing import Any, Optional, Union from fnmatch import fnmatch from functools import lru_cache @@ -49,21 +49,22 @@ class Shell: n (int): Primary quantum number. l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox. """ + name: str element: str binding_e: float model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self: Self, *args, **kwargs) -> np.ndarray: + def __call__(self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self: Self) -> int: + def n(self) -> int: return int(self.name[0]) @property - def l(self: Self) -> str: + def l(self) -> str: return self.name[1:] @@ -96,14 +97,14 @@ def create_cox_probability_function( material: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: - + fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) def get_probability( - e: float | np.ndarray, # energy of released electron - erec: Optional[float | np.ndarray] = None, # recoil energy - v: Optional[float | np.ndarray] = None, # recoil speed + e: Union[float, np.ndarray], # energy of released electron + erec: Optional[Union[float, np.ndarray]] = None, # recoil energy + v: Optional[Union[float, np.ndarray]] = None, # recoil speed ) -> np.ndarray: if erec is None: if v is None: @@ -112,7 +113,7 @@ def get_probability( v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 else: raise ValueError("Either v or erec have to be provided") - + e /= nu.keV input_points = wr.pairwise_log_transform(e, v) @@ -125,7 +126,7 @@ def get_probability( def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", - considered_shells: Optional[list[str] | str] = None, + considered_shells: Optional[Union[list[str], str]] = None, dark_matter: bool = True, e_threshold: Optional[float] = None, dipole: bool = False, @@ -359,6 +360,7 @@ def diff_rate(v, erec): return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + @wr.deprecated("Use get_migdal_transitions_probability_iterators instead") @lru_cache() def read_migdal_transitions(material="Xe"): From fd9c56eb145a73092ecbef85ffa794024675a8c5 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:28:58 +0200 Subject: [PATCH 26/94] Update notebook output --- notebooks/Migdal.ipynb | 58 ++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 25 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 81fe72c..8c26173 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -29,9 +29,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/loren/projects/wimprates/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", + "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", " warnings.warn(\n", - "/home/loren/projects/wimprates/wimprates/utils.py:7: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", + "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/utils.py:9: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", " from tqdm.autonotebook import tqdm\n" ] }, @@ -304,10 +304,18 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1780/1628684340.py:2: DeprecationWarning: Call to deprecated function read_migdal_transitions (Use get_migdal_transitions_probability_iterators instead).\n", + " df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n" + ] + }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -389,7 +397,7 @@ "Properties:\n", " n (int): Primary quantum number.\n", " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", - "\u001b[0;31mFile:\u001b[0m ~/projects/wimprates/wimprates/migdal.py\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/migdal.py\n", "\u001b[0;31mType:\u001b[0m type\n", "\u001b[0;31mSubclasses:\u001b[0m " ] @@ -583,13 +591,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ac4d28696c694ee7aaac335f8e2a0871", + "model_id": "7a50bf4773e2478eb785d709ba357b25", "version_major": 2, "version_minor": 0 }, @@ -612,16 +620,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -669,13 +677,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "45a57ced132e443393b8ee8ee4e2f974", + "model_id": "17e26c918caa4a0a98a5b8489efc468b", "version_major": 2, "version_minor": 0 }, @@ -713,7 +721,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -730,22 +738,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -785,7 +793,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -824,22 +832,22 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -855,22 +863,22 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From df7d904c2b6045359c0aea0c41e3da88e5a13d88 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:37:49 +0200 Subject: [PATCH 27/94] Update pytest.yml --- .github/workflows/pytest.yml | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 402bbaf..48cc63d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -19,19 +19,21 @@ jobs: # Test coveralls (with numba disabled) and normal pytest test: [ 'coveralls', 'pytest', ] # Only do coveralls once; pytest on all python versions - python-version: [3.8, 3.9, "3.10"] + python-version: [3.9, "3.10", "3.11", "3.12"] exclude: - - python-version: 3.8 + - python-version: 3.10 test: coveralls - - python-version: 3.9 + - python-version: 3.11 + test: coveralls + - python-version: 3.12 test: coveralls steps: - name: Setup python - uses: actions/setup-python@v4 + uses: actions/setup-python@v5.1.1 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v3 + uses: actions/checkout@v4.1.7 - name: Install requirements for tests run: | # Requirements for running the notebooks as a pytest From c1d26c0a11731353d888207de172ca3b95529880 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:03:39 +0200 Subject: [PATCH 28/94] Update pytest.yml + fix test Bump action versions. Use `pip install -e .` instead of `python setup.py develop` as the latter is now deprecated. Trying to fix issue with jinja2 being deprecated. --- .github/workflows/pytest.yml | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 48cc63d..3094b2d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -29,19 +29,23 @@ jobs: test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5.1.1 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4.1.7 + uses: actions/checkout@v4 - name: Install requirements for tests run: | + pip install --upgrade pip + # Require setuptools for python3.12 as well + pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax - python setup.py develop + pip install -e . + pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From a7c2e0d71bc5a9a98d0f36b4cf47aa01edafc655 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:07:51 +0200 Subject: [PATCH 29/94] Downgrade jinja for pytest.yml The following error arises while `Test package` executes in the workflow. The following suggestion was followed: https://github.com/d2l-ai/d2l-book/issues/46#issuecomment-1262704457 --- .github/workflows/pytest.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 3094b2d..bb381c7 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -41,11 +41,11 @@ jobs: pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython + pip install jinja2==3.0.3 pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . - pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From d2b44da4b3feab7a4de221181e0def3f0e09947f Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:13:29 +0200 Subject: [PATCH 30/94] Update pytest.yml Recursively checkout submodules --- .github/workflows/pytest.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index bb381c7..709af4e 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -34,6 +34,8 @@ jobs: python-version: ${{ matrix.python-version }} - name: Checkout repo uses: actions/checkout@v4 + with: + submodules: 'recursive' - name: Install requirements for tests run: | pip install --upgrade pip From 180e3917d89942a9cf7b5fbb7425335ee7a12011 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 18:55:40 +0200 Subject: [PATCH 31/94] Update pytest.yml Add libraries for notebooks --- .github/workflows/pytest.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 709af4e..ecb4de8 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -48,6 +48,7 @@ jobs: # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . + pip install seaborn matplotlib - name: Test package if: matrix.test == 'pytest' run: From 062f66b3cf1a33f1098d5a424a5d12b3ba4b7b07 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:18:44 +0200 Subject: [PATCH 32/94] Add j2000 to datetime utility function --- wimprates/halo.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/wimprates/halo.py b/wimprates/halo.py index 4f943da..bf6b33b 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -67,6 +67,17 @@ def j2000_from_ymd(year, month, day_of_month): + np.floor(30.61 * (m + 1)) + day_of_month - 730563.5) +@export +def j2000_to_datetime(j2000_date): + """ + Returns date in np.datetime64 instance from the fractional number of days since J2000.0 epoch. + It is effectively the inverse of the j2000 function. + """ + zero_value = pd.to_datetime("2000-01-01T12:00").value + + nanoseconds_per_day = nu.day / nu.ns + _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value + return pd.to_datetime(_date + zero_value) @export def earth_velocity(t, v_0 = None): From 3bf17b67ca480b4df7c1e5890a5b60dcffcfffdb Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:44:03 +0200 Subject: [PATCH 33/94] Add j2000_to_datetime pytest --- tests/test_halo.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/test_halo.py b/tests/test_halo.py index bee71a5..782e1f8 100644 --- a/tests/test_halo.py +++ b/tests/test_halo.py @@ -1,7 +1,7 @@ from datetime import datetime import pandas as pd -from wimprates import j2000, StandardHaloModel, j2000_from_ymd +from wimprates import j2000, StandardHaloModel, j2000_from_ymd, j2000_to_datetime import numericalunits as nu import numpy as np @@ -21,6 +21,11 @@ def test_j2000_datetime(): assert j2000(date) == 3318.25 +def test_datetime_j2000(): + date = 3318.25 + assert j2000_to_datetime(date) == datetime(year=2009, month=1, day=31, hour=18) + + def test_j2000_ns_int(): date = datetime(year=2009, month=1, day=31, hour=18) value = pd.to_datetime(date).value From 1679466bcd3967d53cfb203f5d236f299adeec77 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:37:49 +0200 Subject: [PATCH 34/94] Update pytest.yml --- .github/workflows/pytest.yml | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 402bbaf..48cc63d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -19,19 +19,21 @@ jobs: # Test coveralls (with numba disabled) and normal pytest test: [ 'coveralls', 'pytest', ] # Only do coveralls once; pytest on all python versions - python-version: [3.8, 3.9, "3.10"] + python-version: [3.9, "3.10", "3.11", "3.12"] exclude: - - python-version: 3.8 + - python-version: 3.10 test: coveralls - - python-version: 3.9 + - python-version: 3.11 + test: coveralls + - python-version: 3.12 test: coveralls steps: - name: Setup python - uses: actions/setup-python@v4 + uses: actions/setup-python@v5.1.1 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v3 + uses: actions/checkout@v4.1.7 - name: Install requirements for tests run: | # Requirements for running the notebooks as a pytest From 97fcd2567e1028d4487c7791190e100b49dcde0d Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:03:39 +0200 Subject: [PATCH 35/94] Update pytest.yml + fix test Bump action versions. Use `pip install -e .` instead of `python setup.py develop` as the latter is now deprecated. Trying to fix issue with jinja2 being deprecated. --- .github/workflows/pytest.yml | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 48cc63d..3094b2d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -29,19 +29,23 @@ jobs: test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5.1.1 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4.1.7 + uses: actions/checkout@v4 - name: Install requirements for tests run: | + pip install --upgrade pip + # Require setuptools for python3.12 as well + pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax - python setup.py develop + pip install -e . + pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From 03f61dd5c4f3bbca965e4886766ddc69f41ad856 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:07:51 +0200 Subject: [PATCH 36/94] Downgrade jinja for pytest.yml The following error arises while `Test package` executes in the workflow. The following suggestion was followed: https://github.com/d2l-ai/d2l-book/issues/46#issuecomment-1262704457 --- .github/workflows/pytest.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 3094b2d..bb381c7 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -41,11 +41,11 @@ jobs: pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython + pip install jinja2==3.0.3 pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . - pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From f5db5f7fbae54db66641dade8fece964a2764b2a Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 17:13:29 +0200 Subject: [PATCH 37/94] Update pytest.yml Recursively checkout submodules --- .github/workflows/pytest.yml | 2 ++ 1 file changed, 2 insertions(+) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index bb381c7..709af4e 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -34,6 +34,8 @@ jobs: python-version: ${{ matrix.python-version }} - name: Checkout repo uses: actions/checkout@v4 + with: + submodules: 'recursive' - name: Install requirements for tests run: | pip install --upgrade pip From 8866e901156457031a84b4cf817753edf475375c Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 18:55:40 +0200 Subject: [PATCH 38/94] Update pytest.yml Add libraries for notebooks --- .github/workflows/pytest.yml | 1 + 1 file changed, 1 insertion(+) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 709af4e..ecb4de8 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -48,6 +48,7 @@ jobs: # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . + pip install seaborn matplotlib - name: Test package if: matrix.test == 'pytest' run: From e5d38ef1babb9e36dd1f1156fb4bdd8cb31c17ea Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:58:35 +0200 Subject: [PATCH 39/94] Revert "Update pytest.yml" This reverts commit 180e3917d89942a9cf7b5fbb7425335ee7a12011. These commits have been cherry-picked from another branch. --- .github/workflows/pytest.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index ecb4de8..709af4e 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -48,7 +48,6 @@ jobs: # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . - pip install seaborn matplotlib - name: Test package if: matrix.test == 'pytest' run: From c9d9d42782d118aa0f057cad64319a168055b9d2 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:12 +0200 Subject: [PATCH 40/94] Revert "Update pytest.yml" This reverts commit d2b44da4b3feab7a4de221181e0def3f0e09947f. --- .github/workflows/pytest.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 709af4e..bb381c7 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -34,8 +34,6 @@ jobs: python-version: ${{ matrix.python-version }} - name: Checkout repo uses: actions/checkout@v4 - with: - submodules: 'recursive' - name: Install requirements for tests run: | pip install --upgrade pip From e579c2f4a1a2adf457ff7e5914808191bf367177 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:15 +0200 Subject: [PATCH 41/94] Revert "Downgrade jinja for pytest.yml" This reverts commit a7c2e0d71bc5a9a98d0f36b4cf47aa01edafc655. --- .github/workflows/pytest.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index bb381c7..3094b2d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -41,11 +41,11 @@ jobs: pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython - pip install jinja2==3.0.3 pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . + pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From 7859f3e2581cb851ecfa616f361c6677398387a4 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:16 +0200 Subject: [PATCH 42/94] Revert "Update pytest.yml + fix test" This reverts commit c1d26c0a11731353d888207de172ca3b95529880. --- .github/workflows/pytest.yml | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 3094b2d..48cc63d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -29,23 +29,19 @@ jobs: test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5 + uses: actions/setup-python@v5.1.1 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4 + uses: actions/checkout@v4.1.7 - name: Install requirements for tests run: | - pip install --upgrade pip - # Require setuptools for python3.12 as well - pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax - pip install -e . - pip install -U jinja2 + python setup.py develop - name: Test package if: matrix.test == 'pytest' run: From 687bc5ecf28ef31b39b743421f703fead9ee1eb1 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:17 +0200 Subject: [PATCH 43/94] Revert "Update pytest.yml" This reverts commit df7d904c2b6045359c0aea0c41e3da88e5a13d88. --- .github/workflows/pytest.yml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 48cc63d..402bbaf 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -19,21 +19,19 @@ jobs: # Test coveralls (with numba disabled) and normal pytest test: [ 'coveralls', 'pytest', ] # Only do coveralls once; pytest on all python versions - python-version: [3.9, "3.10", "3.11", "3.12"] + python-version: [3.8, 3.9, "3.10"] exclude: - - python-version: 3.10 + - python-version: 3.8 test: coveralls - - python-version: 3.11 - test: coveralls - - python-version: 3.12 + - python-version: 3.9 test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5.1.1 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4.1.7 + uses: actions/checkout@v3 - name: Install requirements for tests run: | # Requirements for running the notebooks as a pytest From 0aeec6830cc6f045d55a28dc9879e35c9453496c Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:18:44 +0200 Subject: [PATCH 44/94] Add j2000 to datetime utility function --- wimprates/halo.py | 11 +++++++++++ 1 file changed, 11 insertions(+) diff --git a/wimprates/halo.py b/wimprates/halo.py index 4f943da..bf6b33b 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -67,6 +67,17 @@ def j2000_from_ymd(year, month, day_of_month): + np.floor(30.61 * (m + 1)) + day_of_month - 730563.5) +@export +def j2000_to_datetime(j2000_date): + """ + Returns date in np.datetime64 instance from the fractional number of days since J2000.0 epoch. + It is effectively the inverse of the j2000 function. + """ + zero_value = pd.to_datetime("2000-01-01T12:00").value + + nanoseconds_per_day = nu.day / nu.ns + _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value + return pd.to_datetime(_date + zero_value) @export def earth_velocity(t, v_0 = None): From 9088162e18d01581d03d4c0a906b70ba9e8a849a Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:44:03 +0200 Subject: [PATCH 45/94] Add j2000_to_datetime pytest --- tests/test_halo.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/tests/test_halo.py b/tests/test_halo.py index bee71a5..782e1f8 100644 --- a/tests/test_halo.py +++ b/tests/test_halo.py @@ -1,7 +1,7 @@ from datetime import datetime import pandas as pd -from wimprates import j2000, StandardHaloModel, j2000_from_ymd +from wimprates import j2000, StandardHaloModel, j2000_from_ymd, j2000_to_datetime import numericalunits as nu import numpy as np @@ -21,6 +21,11 @@ def test_j2000_datetime(): assert j2000(date) == 3318.25 +def test_datetime_j2000(): + date = 3318.25 + assert j2000_to_datetime(date) == datetime(year=2009, month=1, day=31, hour=18) + + def test_j2000_ns_int(): date = datetime(year=2009, month=1, day=31, hour=18) value = pd.to_datetime(date).value From 020d015de3395aba3aa3ce90f4d56ef6be96e985 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Sun, 14 Jul 2024 23:15:56 +0200 Subject: [PATCH 46/94] Add halo_model param description to docstring --- wimprates/summary.py | 1 + 1 file changed, 1 insertion(+) diff --git a/wimprates/summary.py b/wimprates/summary.py index 2e35a12..e1387ae 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -32,6 +32,7 @@ def rate_wimp(es, mw, sigma_nucleon, interaction='SI', 'bremsstrahlung' for Bremsstrahlung photons 'migdal' for the Migdal effect :param m_med: Mediator mass. If not given, assumed very heavy. + :param halo_model: A class giving velocity distribution and dark matter density. :param t: A J2000.0 timestamp. If not given, conservative velocity distribution is used. :param progress_bar: if True, show a progress bar during evaluation From 3e4ad01d68bc2a63b4a74241b97e06da70d79e4f Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Mon, 22 Jul 2024 17:59:01 +0200 Subject: [PATCH 47/94] Add basic file --- pyproject.toml | 3 +++ 1 file changed, 3 insertions(+) create mode 100644 pyproject.toml diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..7fd26b9 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,3 @@ +[build-system] +requires = ["setuptools"] +build-backend = "setuptools.build_meta" \ No newline at end of file From 393ef75ce7f2b13174dd7bfcbe7d56ec3ce30da9 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Mon, 22 Jul 2024 23:53:33 +0200 Subject: [PATCH 48/94] Moved Ibe's model --- tests/test_wimprates.py | 4 +- wimprates/data/migdal/{ => Ibe}/REFERENCE | 0 wimprates/data/migdal/{ => Ibe}/Xe.dat | 0 wimprates/data/migdal/{ => Ibe}/dat_to_cvs.py | 0 .../migdal/{ => Ibe}/migdal_transition_Ar.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Ge.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Si.csv | 0 .../migdal/{ => Ibe}/migdal_transition_Xe.csv | 0 wimprates/migdal.py | 79 +++++++++++-------- wimprates/summary.py | 6 +- 10 files changed, 54 insertions(+), 35 deletions(-) rename wimprates/data/migdal/{ => Ibe}/REFERENCE (100%) rename wimprates/data/migdal/{ => Ibe}/Xe.dat (100%) rename wimprates/data/migdal/{ => Ibe}/dat_to_cvs.py (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Ar.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Ge.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Si.csv (100%) rename wimprates/data/migdal/{ => Ibe}/migdal_transition_Xe.csv (100%) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index bb24ce1..d8903ac 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -40,8 +40,8 @@ def test_spindependent(self): 0.00019944698779638946) - def test_migdal(self): - self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', **self.opts), + def test_migdal_Ibe(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Ibe", **self.opts), 0.27459766238555017) diff --git a/wimprates/data/migdal/REFERENCE b/wimprates/data/migdal/Ibe/REFERENCE similarity index 100% rename from wimprates/data/migdal/REFERENCE rename to wimprates/data/migdal/Ibe/REFERENCE diff --git a/wimprates/data/migdal/Xe.dat b/wimprates/data/migdal/Ibe/Xe.dat similarity index 100% rename from wimprates/data/migdal/Xe.dat rename to wimprates/data/migdal/Ibe/Xe.dat diff --git a/wimprates/data/migdal/dat_to_cvs.py b/wimprates/data/migdal/Ibe/dat_to_cvs.py similarity index 100% rename from wimprates/data/migdal/dat_to_cvs.py rename to wimprates/data/migdal/Ibe/dat_to_cvs.py diff --git a/wimprates/data/migdal/migdal_transition_Ar.csv b/wimprates/data/migdal/Ibe/migdal_transition_Ar.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Ar.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Ar.csv diff --git a/wimprates/data/migdal/migdal_transition_Ge.csv b/wimprates/data/migdal/Ibe/migdal_transition_Ge.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Ge.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Ge.csv diff --git a/wimprates/data/migdal/migdal_transition_Si.csv b/wimprates/data/migdal/Ibe/migdal_transition_Si.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Si.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Si.csv diff --git a/wimprates/data/migdal/migdal_transition_Xe.csv b/wimprates/data/migdal/Ibe/migdal_transition_Xe.csv similarity index 100% rename from wimprates/data/migdal/migdal_transition_Xe.csv rename to wimprates/data/migdal/Ibe/migdal_transition_Xe.csv diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 97635d9..baaa71d 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -1,6 +1,14 @@ -"""Migdal effect +""" +Migdal effect + +Two implemented models: + * Ibe et al: https://arxiv.org/abs/1707.07258 + * Cox et al: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032 + In the energy range of DM, the dipole approximation model implemented by Ibe et al + is compatible with the one developped by Cox et al (check discussion in Cox et al) """ + import numericalunits as nu import numpy as np import pandas as pd @@ -9,41 +17,48 @@ from functools import lru_cache from fnmatch import fnmatch import wimprates as wr + +from .data.migdal.Cox.Migdal import Migdal as Migdal_Cox export, __all__ = wr.exporter() @lru_cache() -def read_migdal_transitions(material='Xe'): +def read_migdal_transitions(material='Xe', model="Ibe"): # Differential transition probabilities for vs energy (eV) - df_migdal_material = pd.read_csv(wr.data_file('migdal/migdal_transition_%s.csv' %material)) - - # Relevant (n, l) electronic states - migdal_states_material = df_migdal_material.columns.values.tolist() - migdal_states_material.remove('E') - - # Binding energies of the relevant electronic states - # From table II of 1707.07258 - energy_nl = dict( - Xe=np.array([3.5e4, - 5.4e3, 4.9e3, - 1.1e3, 9.3e2, 6.6e2, - 2.0e2, 1.4e2, 6.1e1, - 2.1e1, 9.8]), - Ar=np.array([3.2e3, - 3.0e2, 2.4e2, - 2.7e1, 1.3e1]), - Ge=np.array([1.1e4, - 1.4e3, 1.2e3, - 1.7e2, 1.2e2, 3.5e1, - 1.5e1, 6.5e0]), - # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm - Si=np.array([1844.1, - 154.04, 103.71, - 13.46, 8.1517]), - ) - - binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) + if model == "Ibe": + df_migdal_material = pd.read_csv(wr.data_file('migdal/Ibe/migdal_transition_%s.csv' %material)) + + # Relevant (n, l) electronic states + migdal_states_material = df_migdal_material.columns.values.tolist() + migdal_states_material.remove('E') + + # Binding energies of the relevant electronic states + # From table II of 1707.07258 + energy_nl = dict( + Xe=np.array([3.5e4, + 5.4e3, 4.9e3, + 1.1e3, 9.3e2, 6.6e2, + 2.0e2, 1.4e2, 6.1e1, + 2.1e1, 9.8]), + Ar=np.array([3.2e3, + 3.0e2, 2.4e2, + 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, + 1.4e3, 1.2e3, + 1.7e2, 1.2e2, 3.5e1, + 1.5e1, 6.5e0]), + # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm + Si=np.array([1844.1, + 154.04, 103.71, + 13.46, 8.1517]), + ) + + binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) + elif model == "Cox": + pass + else: + raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") return df_migdal_material, binding_es_for_migdal_material, @@ -77,7 +92,7 @@ def vmin_migdal(w, erec, mw, material): @wr.vectorize_first def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), include_approx_nr=False, q_nr=0.15, material="Xe", - t=None, halo_model=None, consider_shells=None, + t=None, halo_model=None, consider_shells=None, migdal_model="Ibe", **kwargs): """Differential rate per unit detector mass and deposited ER energy of Migdal effect WIMP-nucleus scattering @@ -112,7 +127,7 @@ def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), include_approx_nr = 1 if include_approx_nr else 0 result = 0 - df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material) + df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material, model=migdal_model) if consider_shells is None: consider_shells = _default_shells(material) for state, binding_e in binding_es_for_migdal.items(): diff --git a/wimprates/summary.py b/wimprates/summary.py index e1387ae..8ac5c5c 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -10,7 +10,7 @@ @export def rate_wimp(es, mw, sigma_nucleon, interaction='SI', detection_mechanism='elastic_nr', m_med=float('inf'), - t=None, halo_model=None, + t=None, halo_model=None, **kwargs): """Differential rate per unit time, unit detector mass and unit recoil energy of WIMP-nucleus scattering. @@ -31,6 +31,10 @@ def rate_wimp(es, mw, sigma_nucleon, interaction='SI', 'elastic_nr' for regular elastic nuclear recoils 'bremsstrahlung' for Bremsstrahlung photons 'migdal' for the Migdal effect + :param migdal_model: model of Migdal effect + 'Ibe' for model implemented in Ibe et al: https://arxiv.org/abs/1707.07258 + 'Cox' for exclusive transition model implemented + in Cox et al: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032 :param m_med: Mediator mass. If not given, assumed very heavy. :param halo_model: A class giving velocity distribution and dark matter density. :param t: A J2000.0 timestamp. From 6af845811574256de6295e86e01205b9b8404a3d Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 23 Jul 2024 00:00:24 +0200 Subject: [PATCH 49/94] Added Cox model package at tag --- .gitmodules | 3 +++ wimprates/data/migdal/Cox | 1 + 2 files changed, 4 insertions(+) create mode 100644 .gitmodules create mode 160000 wimprates/data/migdal/Cox diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..b466ab9 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "wimprates/data/migdal/Cox"] + path = wimprates/data/migdal/Cox + url = https://github.com/petercox/Migdal.git diff --git a/wimprates/data/migdal/Cox b/wimprates/data/migdal/Cox new file mode 160000 index 0000000..99bb84c --- /dev/null +++ b/wimprates/data/migdal/Cox @@ -0,0 +1 @@ +Subproject commit 99bb84cda8407e9b065a1ef2f6ad539a16d24bea From 453eb5b5bea3c6980ccae5f4218cd911d2e8e99e Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:01:42 +0200 Subject: [PATCH 50/94] Moving submodule --- .gitmodules | 2 +- wimprates/data/migdal/{Cox => Cox/cox_submodule} | 0 2 files changed, 1 insertion(+), 1 deletion(-) rename wimprates/data/migdal/{Cox => Cox/cox_submodule} (100%) diff --git a/.gitmodules b/.gitmodules index b466ab9..e7f2d09 100644 --- a/.gitmodules +++ b/.gitmodules @@ -1,3 +1,3 @@ [submodule "wimprates/data/migdal/Cox"] - path = wimprates/data/migdal/Cox + path = wimprates/data/migdal/Cox/cox_submodule url = https://github.com/petercox/Migdal.git diff --git a/wimprates/data/migdal/Cox b/wimprates/data/migdal/Cox/cox_submodule similarity index 100% rename from wimprates/data/migdal/Cox rename to wimprates/data/migdal/Cox/cox_submodule From 6254779a05a117405ef45e95202bdffb156ff641 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:06:20 +0200 Subject: [PATCH 51/94] Updating import statements --- wimprates/migdal.py | 13 +++++++++---- 1 file changed, 9 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index baaa71d..5d9f121 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -9,16 +9,21 @@ is compatible with the one developped by Cox et al (check discussion in Cox et al) """ +from collections.abc import Callable +from dataclasses import dataclass +from typing import Any, Optional, Self + +from fnmatch import fnmatch +from functools import lru_cache import numericalunits as nu import numpy as np import pandas as pd -from scipy.interpolate import interp1d from scipy.integrate import dblquad -from functools import lru_cache -from fnmatch import fnmatch +from scipy.interpolate import interp1d + import wimprates as wr -from .data.migdal.Cox.Migdal import Migdal as Migdal_Cox + export, __all__ = wr.exporter() From 5dc19acb32cfacf7a96e197b195aa2a6973cfca2 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:12:27 +0200 Subject: [PATCH 52/94] Add utility function to preformat data for Cox's interpolators --- wimprates/utils.py | 47 +++++++++++++++++++++++++++++++++++++++++++++- 1 file changed, 46 insertions(+), 1 deletion(-) diff --git a/wimprates/utils.py b/wimprates/utils.py index 10eb230..f8c1d7b 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -4,7 +4,7 @@ from boltons.funcutils import wraps import numpy as np -from tqdm import tqdm +from tqdm.autonotebook import tqdm def exporter(): @@ -60,3 +60,48 @@ def itr(x): for x in itr(xs)]) return f(xs, *args, **kwargs) return newf + + +@export +def pairwise_log_transform(a, b): + """ + Preprocesses two input arrays by reshaping, concatenating, and applying a logarithmic transformation. + + This function takes two input arrays (or single values), reshapes them into column vectors, + concatenates them horizontally to form a 2D array, and then applies the natural logarithm + to each element of the resulting array. It ensures compatibility with the downstream function + that expects a 2D array with two columns, regardless of whether the input consists of single + values or multiple pairs of values. + + Parameters + ---------- + a : array-like or float + The first input array or single float value. + b : array-like or float + The second input array or single float value. + + Returns + ------- + numpy.ndarray + A 2D array with shape (n, 2), where n is the number of elements in the input arrays. + Each row contains the natural logarithm of the corresponding elements from the input arrays. + + Examples + -------- + >>> pairwise_log_transform([4.5, 2.7], [400, 900]) + array([[ 1.5040774 , 5.99146455], + [ 0.99325177, 6.80239476]]) + + >>> pairwise_log_transform(4.5, 400) + array([[1.5040774 , 5.99146455]]) + + Notes + ----- + - If `a` and `b` are not arrays, they will be converted to arrays. + - If `a` and `b` are single values, the output will be a 2D array with a single row. + - The function applies `np.log` to each element in the concatenated array. + """ + a = np.atleast_1d(a).reshape(-1, 1) + b = np.atleast_1d(b).reshape(-1, 1) + arr = np.concatenate((a, b), axis=1) + return np.log(arr) From c9a703a22f47d60db260f064c6c99ce5becdc12d Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:13:24 +0200 Subject: [PATCH 53/94] Wrapper module to include Cox's package Cox's package relies on relative paths to run. It assumes the main Python process is running in its root dir. This wrapper runs the necessary methods within the root of the submodule and then moves the working dir back to the original one. It returns a configured instance of the Migdal class from the submodule for which the probabilities and total probabilities have already been computed. --- wimprates/data/migdal/Cox/cox_wrapper.py | 32 ++++++++++++++++++++++++ 1 file changed, 32 insertions(+) create mode 100644 wimprates/data/migdal/Cox/cox_wrapper.py diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py new file mode 100644 index 0000000..fc0b1c0 --- /dev/null +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -0,0 +1,32 @@ +""" +The paths in the code in Peter Cox's package assume the working directory to be +the root of its package. With this wrapper we change the working dir when computing +the interpolators, then returning the Migdal class instance once they've been instantiated. +The working directory is then reset. +""" + +import os +import sys + +import wimprates as wr + +from .cox_submodule.Migdal import Migdal + +export, __all__ = wr.exporter() + + +@export +def cox_migdal_model(element: str, **kwargs): + original_cwd = os.getcwd() + + try: + migdal_directory = os.path.join(os.path.dirname(__file__), "cox_submodule") + os.chdir(migdal_directory) + + material = Migdal(element) + material.load_probabilities(**kwargs) + material.load_total_probabilities(**kwargs) + finally: + os.chdir(original_cwd) + + return material From 331f4b851a6c1e9ce3264db5e30fd47ff5117f92 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:21:23 +0200 Subject: [PATCH 54/94] Add docstring to cox_wrapper.py --- wimprates/data/migdal/Cox/cox_wrapper.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index fc0b1c0..58366b6 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -17,6 +17,25 @@ @export def cox_migdal_model(element: str, **kwargs): + """ + This function creates a Cox Migdal model for a given element. + + Parameters: + - element (str): The element for which the Cox Migdal model is created. + - **kwargs: Additional keyword arguments for loading probabilities and total probabilities. + + Returns: + - material: The Cox Migdal material object. + + Example usage: + cox_migdal_model("carbon", arg1=value1, arg2=value2) + + Note: The Cox's model assumes that the main process is running in its root directory and uses + relative paths. Therefore, we need to switch the working directory to the root of the package + when computing the interpolators. + This wrapper function changes the working directory temporarily, instantiates the Migdal class, + and then resets the working directory back to its original state. + """ original_cwd = os.getcwd() try: From 2050efc1e879a82ffda8a6f6a6a167ff707ba655 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:26:16 +0200 Subject: [PATCH 55/94] Implemented Peter Cox et al. Migdal model Refactored the code so that the Migdal model can be selected using a simple keyword argument. Examples will be prepared in the notebooks/ dir. Two tests have been added: - One for Cox's full model for single ionization rates - One for Cox's model using dipole approximation --- tests/test_wimprates.py | 13 ++ wimprates/__init__.py | 2 +- wimprates/migdal.py | 329 +++++++++++++++++++++++++++++++--------- 3 files changed, 270 insertions(+), 74 deletions(-) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index d8903ac..ac1fd9d 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -43,6 +43,16 @@ def test_spindependent(self): def test_migdal_Ibe(self): self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Ibe", **self.opts), 0.27459766238555017) + + + def test_migdal_Cox(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Cox", **self.opts), + 0.2843514286729741) + + + def test_migdal_Cox_dipole(self): + self.assertAlmostEqual(wr.rate_wimp_std(1, detection_mechanism='migdal', migdal_model="Cox", dipole=True, **self.opts), + 0.30438231874513705) def test_brems(self): @@ -104,3 +114,6 @@ def test_average_v_earth(self): # places=1 means that we get the same results at the first decimal (fine for 500.0) places=1 ) + +if __name__ == "__main__": + unittest.main() \ No newline at end of file diff --git a/wimprates/__init__.py b/wimprates/__init__.py index 9878a28..e06501b 100644 --- a/wimprates/__init__.py +++ b/wimprates/__init__.py @@ -14,4 +14,4 @@ from .migdal import * from .electron import * from .summary import * - +from .data.migdal.Cox.cox_wrapper import * diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 5d9f121..47bfb23 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -27,78 +27,201 @@ export, __all__ = wr.exporter() -@lru_cache() -def read_migdal_transitions(material='Xe', model="Ibe"): +@dataclass +class Shell: + name: str + material: str + binding_e: float + model: str + single_ionization_probability: Callable # to assign interpolators to + + def __call__(self: Self, *args, **kwargs) -> np.ndarray: + return self.single_ionization_probability(*args, **kwargs) + + @property + def n(self: Self) -> int: + return int(self.name[0]) + + @property + def l(self: Self) -> str: + return self.name[1:] + + +def _default_shells(material: str) -> list[str]: + + consider_shells = dict( + # For Xe, only consider n=3 and n=4 + # n=5 is the valence band so unreliable in liquid + # n=1,2 contribute very little + Xe=["3*", "4*"], + # TODO, what are realistic values for Ar? + Ar=["2*"], + # EDELWEIS + Ge=["3*"], + Si=["2*"], + ) + return consider_shells[material] + + +def create_cox_probability_function( + element, + state: str, + material: str, + dipole: bool = False, +) -> Callable[..., np.ndarray[Any, Any]]: + + fn_name = "dpI1dipole" if dipole else "dpI1" + fn = getattr(element, fn_name) + + def get_probability( + e: float | np.ndarray, # energy of released electron + erec: Optional[float | np.ndarray] = None, # recoil energy + v: Optional[float | np.ndarray] = None, # recoil speed + ) -> np.ndarray: + if erec is None: + if v is None: + raise ValueError("Either v or erec have to be provided") + elif v is None: + v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 + else: + raise ValueError("Either v or erec have to be provided") + # print(f"{e/nu.keV=} corresponds to {v=}") + e /= nu.keV + + input_points = wr.pairwise_log_transform(e, v) + return fn(input_points, state) / nu.keV # type: ignore + + return get_probability + + +@export +def get_migdal_transitions_probability_iterator( + material: str = "Xe", + model: str = "Ibe", + considered_shells: Optional[list[str] | str] = None, + dark_matter: bool = True, + e_threshold: Optional[float] = None, + dipole: bool = False, + **kwargs, +) -> list[Shell]: # Differential transition probabilities for vs energy (eV) + # Check if considered_shells is an empty list + if considered_shells is None: + considered_shells = _default_shells(material) + + shells = [] if model == "Ibe": - df_migdal_material = pd.read_csv(wr.data_file('migdal/Ibe/migdal_transition_%s.csv' %material)) + df_migdal_material = pd.read_csv( + wr.data_file("migdal/Ibe/migdal_transition_%s.csv" % material) + ) # Relevant (n, l) electronic states migdal_states_material = df_migdal_material.columns.values.tolist() - migdal_states_material.remove('E') + migdal_states_material.remove("E") # Binding energies of the relevant electronic states # From table II of 1707.07258 energy_nl = dict( - Xe=np.array([3.5e4, - 5.4e3, 4.9e3, - 1.1e3, 9.3e2, 6.6e2, - 2.0e2, 1.4e2, 6.1e1, - 2.1e1, 9.8]), - Ar=np.array([3.2e3, - 3.0e2, 2.4e2, - 2.7e1, 1.3e1]), - Ge=np.array([1.1e4, - 1.4e3, 1.2e3, - 1.7e2, 1.2e2, 3.5e1, - 1.5e1, 6.5e0]), + Xe=np.array( + [ + 3.5e4, + 5.4e3, + 4.9e3, + 1.1e3, + 9.3e2, + 6.6e2, + 2.0e2, + 1.4e2, + 6.1e1, + 2.1e1, + 9.8, + ] + ), + Ar=np.array([3.2e3, 3.0e2, 2.4e2, 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, 1.4e3, 1.2e3, 1.7e2, 1.2e2, 3.5e1, 1.5e1, 6.5e0]), # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm - Si=np.array([1844.1, - 154.04, 103.71, - 13.46, 8.1517]), + Si=np.array([1844.1, 154.04, 103.71, 13.46, 8.1517]), ) - binding_es_for_migdal_material = dict(zip(migdal_states_material, energy_nl[material])) - elif model == "Cox": - pass - else: - raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") + for state, binding_e in zip(migdal_states_material, energy_nl[material]): + if not any(fnmatch(state, take) for take in considered_shells): + continue + binding_e *= nu.eV + + # Lookup for differential probability (units of ev^-1) + p = interp1d( + np.array(df_migdal_material["E"].values) * nu.eV, + df_migdal_material[state].values / nu.eV, + bounds_error=False, + fill_value=0, + ) - return df_migdal_material, binding_es_for_migdal_material, + shells.append(Shell(state, material, binding_e, model, p)) + elif model == "Cox": + element = wr.cox_migdal_model( + material, + dipole=dipole, + dark_matter=dark_matter, + e_threshold=e_threshold, + ) -def _default_shells(material): + for state, binding_e in element.orbitals: + if not any(fnmatch(state, take) for take in considered_shells): + continue - consider_shells = dict( - # For Xe, only consider n=3 and n=4 - # n=5 is the valence band so unreliable in liquid - # n=1,2 contribute very little - Xe=['3*', '4*'], - # TODO, what are realistic values for Ar? - Ar=['2*'], - # EDELWEIS - Ge=['3*'], - Si=['2*'], - ) - return consider_shells[material] + shells.append( + Shell( + state, + material, + binding_e * nu.keV, + model, + single_ionization_probability=create_cox_probability_function( + element, + state, + material, + dipole=dipole, + ), + ) + ) + else: + raise ValueError("Only 'Cox' and 'Ibe' models have been implemented") + return shells -def vmin_migdal(w, erec, mw, material): + +def vmin_migdal( + w: np.ndarray, erec: np.ndarray, mw: float, material: str +) -> np.ndarray: """Return minimum WIMP velocity to make a Migdal signal with energy w, given elastic recoil energy erec and WIMP mass mw. """ - y = (wr.mn(material) * erec / (2 * wr.mu_nucleus(mw, material) ** 2))**0.5 - y += w / (2 * wr.mn(material) * erec)**0.5 + y = (wr.mn(material) * erec / (2 * wr.mu_nucleus(mw, material) ** 2)) ** 0.5 + y += w / (2 * wr.mn(material) * erec) ** 0.5 return np.maximum(0, y) @export @wr.vectorize_first -def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), - include_approx_nr=False, q_nr=0.15, material="Xe", - t=None, halo_model=None, consider_shells=None, migdal_model="Ibe", - **kwargs): +def rate_migdal( + w: np.ndarray, + mw: float, + sigma_nucleon: float, + interaction: str = "SI", + m_med: float = float("inf"), + include_approx_nr: bool = False, + q_nr: float = 0.15, + material: str = "Xe", + t: Optional[float] = None, + halo_model: Optional[wr.StandardHaloModel] = None, + consider_shells: Optional[list[str]] = None, + migdal_model: str = "Ibe", + dark_matter: bool = True, + dipole: bool = False, + e_threshold: Optional[float] = None, + **kwargs, +) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of Migdal effect WIMP-nucleus scattering @@ -129,42 +252,66 @@ def rate_migdal(w, mw, sigma_nucleon, interaction='SI', m_med=float('inf'), (e.g. error tolerance). """ halo_model = wr.StandardHaloModel() if halo_model is None else halo_model - include_approx_nr = 1 if include_approx_nr else 0 - result = 0 - df_migdal, binding_es_for_migdal = read_migdal_transitions(material=material, model=migdal_model) - if consider_shells is None: + if not consider_shells: consider_shells = _default_shells(material) - for state, binding_e in binding_es_for_migdal.items(): - binding_e *= nu.eV - if not any(fnmatch(state, take) for take in consider_shells): - continue - # Lookup for differential probability (units of ev^-1) - p = interp1d(df_migdal['E'].values * nu.eV, - df_migdal[state].values / nu.eV, - bounds_error=False, - fill_value=0) + shells = get_migdal_transitions_probability_iterator( + material=material, + model=migdal_model, + considered_shells=consider_shells, + dipole=dipole, + e_threshold=e_threshold, + dark_matter=dark_matter, + ) + + result = 0 + for shell in shells: def diff_rate(v, erec): # Observed energy = energy of emitted electron # + binding energy of state - eelec = w - binding_e - include_approx_nr * erec * q_nr + eelec = w - shell.binding_e - include_approx_nr * erec * q_nr if eelec < 0: return 0 - return ( - # Usual elastic differential rate, - # common constants follow at end - wr.sigma_erec(erec, v, mw, sigma_nucleon, interaction, - m_med=m_med, material = material) - * v * halo_model.velocity_dist(v, t) - - # Migdal effect |Z|^2 - # TODO: ?? what is explicit (eV/c)**2 doing here? - * (nu.me * (2 * erec / wr.mn(material))**0.5 / (nu.eV / nu.c0))**2 - / (2 * np.pi) - * p(eelec)) + if migdal_model == "Ibe": + return ( + # Usual elastic differential rate, + # common constants follow at end + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + # Migdal effect |Z|^2 + # TODO: ?? what is explicit (eV/c)**2 doing here? + * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) + ** 2 + / (2 * np.pi) + * shell(eelec) + ) + elif migdal_model == "Cox": + return ( + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + * shell(eelec, erec) + ) # Note dblquad expects the function to be f(y, x), not f(x, y)... r = dblquad( @@ -178,8 +325,44 @@ def diff_rate(v, erec): material=material, ), lambda _: wr.v_max(t, halo_model.v_esc), - **kwargs)[0] + **kwargs, + )[0] result += r - return halo_model.rho_dm / mw * (1 / wr.mn(material)) * result + return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + + +### (DEPRECATED) Maintain this for backwards accessibility +@lru_cache() +def read_migdal_transitions(material="Xe"): + # Differential transition probabilities for vs energy (eV) + + df_migdal_material = pd.read_csv( + wr.data_file("migdal/Ibe/migdal_transition_%s.csv" % material) + ) + + # Relevant (n, l) electronic states + migdal_states_material = df_migdal_material.columns.values.tolist() + migdal_states_material.remove("E") + + # Binding energies of the relevant electronic states + # From table II of 1707.07258 + energy_nl = dict( + Xe=np.array( + [3.5e4, 5.4e3, 4.9e3, 1.1e3, 9.3e2, 6.6e2, 2.0e2, 1.4e2, 6.1e1, 2.1e1, 9.8] + ), + Ar=np.array([3.2e3, 3.0e2, 2.4e2, 2.7e1, 1.3e1]), + Ge=np.array([1.1e4, 1.4e3, 1.2e3, 1.7e2, 1.2e2, 3.5e1, 1.5e1, 6.5e0]), + # http://www.chembio.uoguelph.ca/educmat/atomdata/bindener/grp14num.htm + Si=np.array([1844.1, 154.04, 103.71, 13.46, 8.1517]), + ) + + binding_es_for_migdal_material = dict( + zip(migdal_states_material, energy_nl[material]) + ) + + return ( + df_migdal_material, + binding_es_for_migdal_material, + ) From 0978c49622eb7a77852a4b96b8424272246bad01 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 12:27:53 +0200 Subject: [PATCH 56/94] Remove debug print statement --- wimprates/migdal.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 47bfb23..d536561 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -85,7 +85,7 @@ def get_probability( v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 else: raise ValueError("Either v or erec have to be provided") - # print(f"{e/nu.keV=} corresponds to {v=}") + e /= nu.keV input_points = wr.pairwise_log_transform(e, v) From d4b33d20249ac06bf83719e91c6aab094eb91cfd Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 14:46:43 +0200 Subject: [PATCH 57/94] Add dockstrings --- wimprates/migdal.py | 35 +++++++++++++++++++++++++++++++---- 1 file changed, 31 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index d536561..bd789e1 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -29,8 +29,28 @@ @dataclass class Shell: + """ + Describes a specific atomic shell for the selected atom. + + Attributes: + name (str): The name of the shell. + element (str): The element class of the atom. + binding_e (float): The binding energy for the shell. + model (str): The model used for the single ionization probability computation. + single_ionization_probability (Callable): A function to assign interpolators to. + The interpolator will provide the single ionization probability for the shell + according to the selected model. + + Methods: + __call__(*args, **kwargs) -> np.ndarray: + Calls the single_ionization_probability function with the given arguments and keyword arguments. + + Properties: + n (int): Primary quantum number. + l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox. + """ name: str - material: str + element: str binding_e: float model: str single_ionization_probability: Callable # to assign interpolators to @@ -48,6 +68,13 @@ def l(self: Self) -> str: def _default_shells(material: str) -> list[str]: + """ + Returns the default shells to consider for a given material. + Args: + material (str): The material for which to determine the default shells. + Returns: + list[str]: The default shells to consider for the given material. + """ consider_shells = dict( # For Xe, only consider n=3 and n=4 @@ -69,7 +96,7 @@ def create_cox_probability_function( material: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: - + fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) @@ -95,7 +122,7 @@ def get_probability( @export -def get_migdal_transitions_probability_iterator( +def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", considered_shells: Optional[list[str] | str] = None, @@ -256,7 +283,7 @@ def rate_migdal( if not consider_shells: consider_shells = _default_shells(material) - shells = get_migdal_transitions_probability_iterator( + shells = get_migdal_transitions_probability_iterators( material=material, model=migdal_model, considered_shells=consider_shells, From 4fcb1bdcc9237e4ad3aaa306fc0552e3cdd9e982 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:02:55 +0200 Subject: [PATCH 58/94] Update tutorial notebook for Migdal --- notebooks/Migdal.ipynb | 1002 ++++++++++++++++++++++------------------ 1 file changed, 555 insertions(+), 447 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 11e4f55..60cde54 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -1,447 +1,555 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:26.733826Z", - "start_time": "2022-07-22T19:16:24.834775Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import pandas as pd\n", - "from tqdm import tqdm\n", - "import numericalunits as nu\n", - "\n", - "import wimprates as wr" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Convert Xe.dat to nicer format" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:26.776139Z", - "start_time": "2022-07-22T19:16:26.735821Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/html": [ - "
\n", - "\n", - "\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
1_02_02_13_03_13_24_04_14_25_05_1E
1.0000001.013107e-142.538509e-131.417923e-123.745613e-121.931796e-116.875756e-124.272023e-112.097481e-102.115778e-094.937655e-105.173118e-071.000000
1.0456361.013389e-142.539291e-131.424572e-123.746781e-121.941191e-116.950745e-124.272690e-112.096290e-102.124282e-094.851036e-105.103404e-071.045636
1.0933541.013681e-142.540099e-131.431461e-123.747978e-121.950850e-117.033516e-124.273357e-112.095044e-102.133447e-094.762062e-105.031270e-071.093354
1.1432501.013985e-142.540935e-131.438595e-123.749203e-121.960773e-117.124774e-124.274019e-112.093738e-102.143335e-094.670743e-104.956689e-071.143250
1.1954231.014299e-142.541800e-131.445980e-123.750456e-121.970957e-117.225280e-124.274673e-112.092371e-102.154013e-094.577099e-104.879646e-071.195423
\n", - "
" - ], - "text/plain": [ - " 1_0 2_0 2_1 3_0 \\\n", - "1.000000 1.013107e-14 2.538509e-13 1.417923e-12 3.745613e-12 \n", - "1.045636 1.013389e-14 2.539291e-13 1.424572e-12 3.746781e-12 \n", - "1.093354 1.013681e-14 2.540099e-13 1.431461e-12 3.747978e-12 \n", - "1.143250 1.013985e-14 2.540935e-13 1.438595e-12 3.749203e-12 \n", - "1.195423 1.014299e-14 2.541800e-13 1.445980e-12 3.750456e-12 \n", - "\n", - " 3_1 3_2 4_0 4_1 \\\n", - "1.000000 1.931796e-11 6.875756e-12 4.272023e-11 2.097481e-10 \n", - "1.045636 1.941191e-11 6.950745e-12 4.272690e-11 2.096290e-10 \n", - "1.093354 1.950850e-11 7.033516e-12 4.273357e-11 2.095044e-10 \n", - "1.143250 1.960773e-11 7.124774e-12 4.274019e-11 2.093738e-10 \n", - "1.195423 1.970957e-11 7.225280e-12 4.274673e-11 2.092371e-10 \n", - "\n", - " 4_2 5_0 5_1 E \n", - "1.000000 2.115778e-09 4.937655e-10 5.173118e-07 1.000000 \n", - "1.045636 2.124282e-09 4.851036e-10 5.103404e-07 1.045636 \n", - "1.093354 2.133447e-09 4.762062e-10 5.031270e-07 1.093354 \n", - "1.143250 2.143335e-09 4.670743e-10 4.956689e-07 1.143250 \n", - "1.195423 2.154013e-09 4.577099e-10 4.879646e-07 1.195423 " - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "SOURCE='Xe'\n", - "df = dict()\n", - "with open(wr.data_file(f'migdal/{SOURCE}.dat')) as f:\n", - " header = False\n", - " for i, line in enumerate(f.read().splitlines()):\n", - " if 'Principal' in line:\n", - " header = True\n", - " continue\n", - " if 'Energy' in line:\n", - " header = False\n", - " continue\n", - " \n", - " if header:\n", - " n, l = [int(x) for x in line.split()]\n", - " else:\n", - " e, rate = [float(x) for x in line.split()]\n", - " df.setdefault(e, dict())\n", - " df[e]['%d_%d' % (n, l)] = rate\n", - " \n", - "df = pd.DataFrame(df).T\n", - "df['E'] = df.index\n", - "\n", - "df.to_csv('migdal_transition_ps.csv', index=False)\n", - "df_migdal = df\n", - "df.head()" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Rows are energies, columns are (n, l) states. Data is the differential transition probabilities, at the 1 eV/c reference momentum, not divided by 2 pi." - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Reproduce figure 4" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "To reproduce figure 4 of https://arxiv.org/pdf/1707.07258.pdf, we must\n", - " * Convert to the other reference momentum of $m_e * .001 c$\n", - " * Divide by 2 pi.\n", - " * Convert eV -> keV; multiply energies by 1e3 and divide differential probabilities by 1e3." - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:27.594619Z", - "start_time": "2022-07-22T19:16:26.778591Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'diff. p (keV^-1)')" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "import wimprates\n", - "\n", - "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", - "df2, _ = wimprates.migdal.read_migdal_transitions(SOURCE)\n", - "for n in df.keys():\n", - " x = df_migdal[n].values.copy()\n", - " if not n.endswith('0'):\n", - " continue\n", - " for c in df2.keys():\n", - " if c.startswith(str(n).split('_')[0]) and not c.endswith('0'):\n", - " x += df[c]\n", - " \n", - " plt.plot(df['E'] / 1e3, x * scale * 1e3)\n", - "#plt.plot(df['E'] / 1e3, df['2_0']**0.5 + df['2_0'])\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.ylim(1e-7, 1e2)\n", - "plt.xlabel(\"E (keV)\")\n", - "plt.ylabel(\"diff. p (keV^-1)\")" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "### Compare with spectrum from LUX talk" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "To verify we have the correct spectrum, let's compare to a curve trace from slide 10 of a [recent LUX talk](https://indico.cern.ch/event/699961/contributions/3043408/attachments/1692619/2723656/JLIN_Sub_GeV_DM_Talk_IDM2018_V4.pdf)" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:47.277779Z", - "start_time": "2022-07-22T19:16:27.599861Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████████| 100/100 [00:19<00:00, 5.09it/s]\n" - ] - } - ], - "source": [ - "es = np.logspace(np.log10(5e-2), np.log10(2), 100) * nu.keV\n", - "rs = wr.rate_migdal(\n", - " w=es,\n", - " mw=0.5 * nu.GeV/nu.c0**2,\n", - " sigma_nucleon=1e-35 * nu.cm**2,\n", - " progress_bar=True)" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": { - "ExecuteTime": { - "end_time": "2022-07-22T19:16:47.750262Z", - "start_time": "2022-07-22T19:16:47.282805Z" - }, - "pycharm": { - "name": "#%%\n" - } - }, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'dr/dE (keV kg day)^-1')" - ] - }, - "execution_count": 5, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
" - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "ref_curve = pd.read_csv('migdal_0.5gev_curvetrace_lux.csv', index_col=False)\n", - "plt.plot(es / nu.keV, \n", - " rs * (nu.kg * nu.day * nu.keV))\n", - "plt.plot(10**ref_curve['logE'], 10**ref_curve['logR'], color='red', label='Curve trace')\n", - "plt.xscale('log')\n", - "plt.yscale('log')\n", - "plt.xlabel('E (keV)')\n", - "plt.ylabel('dr/dE (keV kg day)^-1')" - ] - }, - { - "cell_type": "markdown", - "metadata": { - "pycharm": { - "name": "#%% md\n" - } - }, - "source": [ - "Looks good! The remaining deviations look like curve tracing artifacts." - ] - } - ], - "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.10.4" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Migdal Tutorial\n", + "Tutorial to compute Migdal rates according to different models.\n", + "Models from two sources are currently implemented:\n", + " - **Ibe**: https://link.springer.com/article/10.1007/JHEP03(2018)194\n", + " - **Cox**: https://journals.aps.org/prd/abstract/10.1103/PhysRevD.107.035032\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:26.733826Z", + "start_time": "2022-07-22T19:16:24.834775Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numericalunits as nu\n", + "import numpy as np\n", + "import pandas as pd\n", + "import seaborn as sns\n", + "\n", + "import wimprates as wr\n", + "\n", + "sns.set_theme()\n", + "sns.set_style('ticks')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Convert Xe.dat to nicer format (Ibe)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:26.776139Z", + "start_time": "2022-07-22T19:16:26.735821Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "SOURCE='Xe'\n", + "df = dict()\n", + "with open(wr.data_file(f'migdal/Ibe/{SOURCE}.dat')) as f:\n", + " header = False\n", + " for i, line in enumerate(f.read().splitlines()):\n", + " if 'Principal' in line:\n", + " header = True\n", + " continue\n", + " if 'Energy' in line:\n", + " header = False\n", + " continue\n", + " \n", + " if header:\n", + " n, l = [int(x) for x in line.split()]\n", + " else:\n", + " e, rate = [float(x) for x in line.split()]\n", + " df.setdefault(e, dict())\n", + " df[e]['%d_%d' % (n, l)] = rate\n", + " \n", + "df = pd.DataFrame(df).T\n", + "df['E'] = df.index\n", + "\n", + "df.to_csv('migdal_transition_ps.csv', index=False)\n", + "df_migdal = df\n", + "df.head()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "Rows are energies, columns are (n, l) states. Data is the differential transition probabilities, at the 1 eV/c reference momentum, not divided by 2 pi." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Reproduce figure 4" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To reproduce figure 4 of https://arxiv.org/pdf/1707.07258.pdf, we must\n", + " * Convert to the other reference momentum of $m_e * .001 c$\n", + " * Divide by 2 pi.\n", + " * Convert eV -> keV; multiply energies by 1e3 and divide differential probabilities by 1e3." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "ExecuteTime": { + "end_time": "2022-07-22T19:16:27.594619Z", + "start_time": "2022-07-22T19:16:26.778591Z" + }, + "pycharm": { + "name": "#%%\n" + } + }, + "outputs": [], + "source": [ + "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", + "df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n", + "for n in df.keys():\n", + " x = df_migdal[n].values.copy()\n", + " if not n.endswith('0'):\n", + " continue\n", + " for c in df2.keys():\n", + " if c.startswith(str(n).split('_')[0]) and not c.endswith('0'):\n", + " x += df[c]\n", + " \n", + " plt.plot(df['E'] / 1e3, x * scale * 1e3, label=n[0])\n", + "\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.xlabel(\"Energy [keV]\")\n", + "plt.ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Using the iterator getter for different models\n", + "The getter function `wr.get_migdal_transitions_probability_iterators` provides a list of instanses of the Shell class.\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "wr.migdal.Shell?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", + "shells_ibe = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Ibe\", considered_shells=(\"*\"))\n", + "\n", + "E = df[\"E\"].to_numpy() * nu.eV\n", + "\n", + "for shell in shells_ibe:\n", + " x = shell(E)\n", + " if shell.l != \"_0\":\n", + " continue\n", + " for _shell in shells_ibe:\n", + " if shell.n == _shell.n and _shell.l != \"_0\":\n", + " x += _shell(E)\n", + " plt.plot(E / nu.keV, x * scale * nu.keV, label=f\"n={shell.n}\")\n", + " \n", + "\n", + "plt.xscale('log')\n", + "plt.yscale('log')\n", + "plt.title(\"Ibe model\")\n", + "plt.xlabel(\"E [keV]\")\n", + "plt.ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "plt.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "shells_cox = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", considered_shells=(\"*\",))\n", + "\n", + "\n", + "E = np.logspace(0, np.log10(20e3), 1000) * nu.eV\n", + "v = np.repeat(1e-4, len(E))\n", + "\n", + "def print_f(arr, pref=\"\"):\n", + " if arr is not None:\n", + " return 0\n", + " print(f\"{pref} {arr[:2]=}\")\n", + "for shell in shells_cox:\n", + " x = shell(E.copy(), v=v)\n", + " if shell.l != \"s\":\n", + " continue\n", + " for _shell in shells_cox:\n", + " if shell.n == _shell.n and _shell.l != \"s\":\n", + " x += _shell(E.copy(), v=v)\n", + " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " \n", + "\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "ax.set_title(\"Cox model\")\n", + "ax.set_xlabel(\"E [keV]\")\n", + "ax.set_ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "shells_cox_dipole = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", dipole=True, considered_shells=(\"*\",))\n", + "\n", + "\n", + "E = df[\"E\"].to_numpy().copy() * nu.eV\n", + "v = np.repeat(1e-3, len(E))\n", + "\n", + "def print_f(arr, pref=\"\"):\n", + " if arr is not None:\n", + " return 0\n", + " print(f\"{pref} {arr[:2]=}\")\n", + "for shell in shells_cox_dipole:\n", + " x = shell(E.copy(), v=v)\n", + " if shell.l != \"s\":\n", + " continue\n", + " for _shell in shells_cox_dipole:\n", + " if shell.n == _shell.n and _shell.l != \"s\":\n", + " x += _shell(E.copy(), v=v)\n", + " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " \n", + "\n", + "\n", + "ax.set_xscale('log')\n", + "ax.set_yscale('log')\n", + "ax.set_title(\"Cox model with Dipole Approximation\")\n", + "ax.set_xlabel(\"E [keV]\")\n", + "ax.set_ylabel(\"Differential inoisation probability [keV$^{-1}$]\")\n", + "ax.legend()\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "### Compare with spectrum from LUX talk" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "pycharm": { + "name": "#%% md\n" + } + }, + "source": [ + "To verify we have the correct spectrum, let's compare to a curve trace from slide 10 of a [recent LUX talk](https://indico.cern.ch/event/699961/contributions/3043408/attachments/1692619/2723656/JLIN_Sub_GeV_DM_Talk_IDM2018_V4.pdf)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "es = np.logspace(np.log10(5e-2), np.log10(2), 100) * nu.keV\n", + "\n", + "WIMP_MASS = 0.5 # GeV\n", + "SIGMA = 1e-35 # cm^2\n", + "\n", + "def extract_exponent(num):\n", + " # Convert the number to a string in scientific notation\n", + " num_str = f\"{num:.1e}\"\n", + " # Split the string on 'e' to separate the mantissa and exponent\n", + " num, exponent_str = num_str.split('e')\n", + " # Convert the exponent part to an integer\n", + " exponent = int(exponent_str)\n", + " return num, exponent\n", + "\n", + "_, SIGMA_Exp = extract_exponent(SIGMA)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "rs_ibe = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Ibe\",\n", + " include_approx_nr=False,\n", + " progress_bar=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plt.subplots()\n", + "\n", + "ref_curve = pd.read_csv(\"migdal_0.5gev_curvetrace_lux.csv\", index_col=False)\n", + "ax.plot(\n", + " 10 ** ref_curve[\"logE\"], 10 ** ref_curve[\"logR\"], color=\"red\", label=\"Curve trace\"\n", + ")\n", + "ax.plot(es / nu.keV, rs_ibe * (nu.kg * nu.day * nu.keV), label=\"Ibe\")\n", + "\n", + "ax.set_title(rf\"Migdal rate for $m_{{WIMP}} = {WIMP_MASS}$ GeV/c$^2$ and $\\sigma_{{nucleon}} = 10^{{{SIGMA_Exp}}}$ cm$^2$\")\n", + "ax.set_xscale(\"log\")\n", + "ax.set_yscale(\"log\")\n", + "ax.set_xlabel(\"Deposited energy [keV$_{ee}$]\")\n", + "ax.set_ylabel(\"Differential Rate [keV$^{-1}$ kg$^{-1}$ day$^{-1}$]\")\n", + "plt.legend()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Looks good! The remaining deviations look like curve tracing artifacts." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Comparing Cox and Ibe models" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "WITH_DIPOLE = False\n", + "\n", + "rs_cox = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Cox\",\n", + " dipole=False,\n", + " # e_threshold=0.1 * nu.keV,\n", + " progress_bar=True,\n", + ")\n", + "if WITH_DIPOLE:\n", + " rs_cox_dipole = wr.rate_migdal(\n", + " w=es,\n", + " mw=WIMP_MASS * nu.GeV / nu.c0**2,\n", + " sigma_nucleon=SIGMA * nu.cm**2,\n", + " migdal_model=\"Cox\",\n", + " dipole=True,\n", + " include_approx_nr=False,\n", + " progress_bar=True,\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_rs = pd.DataFrame(dict(\n", + " E=es/nu.keV,\n", + " r_cox=rs_cox * (nu.kg * nu.day * nu.keV),\n", + " r_ibe=rs_ibe* (nu.kg * nu.day * nu.keV),\n", + "))\n", + "if WITH_DIPOLE:\n", + " df_rs['r_cox_dipole'] = rs_cox_dipole * (nu.kg * nu.day * nu.keV)\n", + "\n", + "df_rs = df_rs.melt(id_vars='E')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import seaborn as sns\n", + "\n", + "g = sns.relplot(data=df_rs, x=\"E\", y=\"value\", hue=\"variable\", kind=\"line\")\n", + "g.set(\n", + " xscale=\"log\",\n", + " yscale=\"log\",\n", + " xlabel=r\"Deposited energy [keV$_{ee}$]\",\n", + " ylabel=\"Differential Rate [keV$^{-1}$ kg$^{-1}$ day$^{-1}$]\",\n", + " title=rf\"Migdal rate for $m_{{WIMP}} = {WIMP_MASS}$ GeV/c$^2$ and $\\sigma_{{nucleon}} = 10^{{{SIGMA_Exp}}}$ cm$^2$\",\n", + ")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The observed discrepancies between the models are due to multiple factors:\n", + " - The model by Cox does not use the dipole approximation and normalizes the electron spinors using different techniques. This influences mostly the ***shape*** of the distribution.\n", + " - The two models use slightly different binding energy values for the considered orbitals. This affects the the minimum energies at which the migdal effect is kinematically allowed and, consequently, the ***horizontal stretch*** of the distributions. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Binding energies" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "l_model = []\n", + "l_n = []\n", + "l_l = []\n", + "l_Binding_E = []\n", + "\n", + "for shell in shells_cox:\n", + " l_model.append(\"Cox\")\n", + " l_n.append(shell.n)\n", + " l_l.append(shell.l)\n", + " l_Binding_E.append(shell.binding_e)\n", + "\n", + "orb_conv = {key:val for key, val in zip([\"_0\", \"_1\", \"_2\"], [\"s\", \"p\", \"d\"])}\n", + "\n", + "for shell in shells_ibe:\n", + " l_model.append(\"Ibe\")\n", + " l_n.append(shell.n)\n", + " l_l.append(orb_conv[shell.l])\n", + " l_Binding_E.append(shell.binding_e)\n", + "\n", + "df = pd.DataFrame(dict(\n", + " Model=l_model,\n", + " n=l_n,\n", + " l=l_l,\n", + " Binding_E=l_Binding_E,\n", + "))\n", + "shell_order = [\"1s\",\"2s\",\"2p-\", \"2p\", \"3s\", \"3p-\", \"3p\", \"3d-\", \"3d\", \"4s\", \"4p-\", \"4p\", \"4d-\", \"4d\", \"5s\", \"5p-\", \"5p\"]\n", + "df[\"name\"] = (df.n.astype(str) + df.l).astype(pd.CategoricalDtype(categories=shell_order, ordered=True))\n", + "df.sort_values(\"name\", inplace=True)\n", + "df.reset_index(drop=True, inplace=True)\n", + "considered_shells = df.query(\"n in [3,4]\").groupby([\"Model\", \"name\"], observed=True).mean(numeric_only=True)\n", + "all_shells = df.groupby([\"Model\", \"name\"], observed=True).mean(numeric_only=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "g = sns.catplot(data=all_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\")\n", + "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", yscale=\"log\", title=\"Binding Energies for all orbitals\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "g = sns.catplot(data=considered_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\", order=considered_shells.index.levels[1].values)\n", + "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", title=\"Binding Energies for considered orbitals\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "A check was made by fixing the binding energies for the Ibe model to the ones utilised by Peter Cox *et al*. The resulting rates were the following:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "![Image](rates_fixed_binding_energies.png)" + ] + } + ], + "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.12.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 0380e5a1e562b37f2e1d1b68661e8caa5d4e44e0 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:09:18 +0200 Subject: [PATCH 59/94] Remove typing.Self for python3.9 --- wimprates/migdal.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index bd789e1..6e9b200 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional, Self +from typing import Any, Optional from fnmatch import fnmatch from functools import lru_cache @@ -55,15 +55,15 @@ class Shell: model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self: Self, *args, **kwargs) -> np.ndarray: + def __call__(self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self: Self) -> int: + def n(self) -> int: return int(self.name[0]) @property - def l(self: Self) -> str: + def l(self) -> str: return self.name[1:] From 381a30d0eead45107c2645c96c2d95b62f893041 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 17:11:55 +0200 Subject: [PATCH 60/94] Require seaborn --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 81ced55..408d07d 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ pandas tqdm boltons numericalunits +seaborn From 11138704a9410d5dc7869eec2fed1b19c0dd9872 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:34:07 +0200 Subject: [PATCH 61/94] Add output to notebook --- notebooks/Migdal.ipynb | 440 +++++++++++++++++++++++++++++++++++++---- 1 file changed, 404 insertions(+), 36 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 60cde54..81fe72c 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:26.733826Z", @@ -24,7 +24,29 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/loren/projects/wimprates/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", + " warnings.warn(\n", + "/home/loren/projects/wimprates/wimprates/utils.py:7: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", + " from tqdm.autonotebook import tqdm\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "------------------------------------------\n", + "Migdal ionisation probabilities\n", + "P. Cox, M. Dolan, C. McCabe, H. Quiney (2022)\n", + "arXiv:2208.12222\n", + "------------------------------------------\n" + ] + } + ], "source": [ "import matplotlib.pyplot as plt\n", "import numericalunits as nu\n", @@ -51,7 +73,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:26.776139Z", @@ -61,7 +83,150 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1_02_02_13_03_13_24_04_14_25_05_1E
1.0000001.013107e-142.538509e-131.417923e-123.745613e-121.931796e-116.875756e-124.272023e-112.097481e-102.115778e-094.937655e-105.173118e-071.000000
1.0456361.013389e-142.539291e-131.424572e-123.746781e-121.941191e-116.950745e-124.272690e-112.096290e-102.124282e-094.851036e-105.103404e-071.045636
1.0933541.013681e-142.540099e-131.431461e-123.747978e-121.950850e-117.033516e-124.273357e-112.095044e-102.133447e-094.762062e-105.031270e-071.093354
1.1432501.013985e-142.540935e-131.438595e-123.749203e-121.960773e-117.124774e-124.274019e-112.093738e-102.143335e-094.670743e-104.956689e-071.143250
1.1954231.014299e-142.541800e-131.445980e-123.750456e-121.970957e-117.225280e-124.274673e-112.092371e-102.154013e-094.577099e-104.879646e-071.195423
\n", + "
" + ], + "text/plain": [ + " 1_0 2_0 2_1 3_0 \\\n", + "1.000000 1.013107e-14 2.538509e-13 1.417923e-12 3.745613e-12 \n", + "1.045636 1.013389e-14 2.539291e-13 1.424572e-12 3.746781e-12 \n", + "1.093354 1.013681e-14 2.540099e-13 1.431461e-12 3.747978e-12 \n", + "1.143250 1.013985e-14 2.540935e-13 1.438595e-12 3.749203e-12 \n", + "1.195423 1.014299e-14 2.541800e-13 1.445980e-12 3.750456e-12 \n", + "\n", + " 3_1 3_2 4_0 4_1 \\\n", + "1.000000 1.931796e-11 6.875756e-12 4.272023e-11 2.097481e-10 \n", + "1.045636 1.941191e-11 6.950745e-12 4.272690e-11 2.096290e-10 \n", + "1.093354 1.950850e-11 7.033516e-12 4.273357e-11 2.095044e-10 \n", + "1.143250 1.960773e-11 7.124774e-12 4.274019e-11 2.093738e-10 \n", + "1.195423 1.970957e-11 7.225280e-12 4.274673e-11 2.092371e-10 \n", + "\n", + " 4_2 5_0 5_1 E \n", + "1.000000 2.115778e-09 4.937655e-10 5.173118e-07 1.000000 \n", + "1.045636 2.124282e-09 4.851036e-10 5.103404e-07 1.045636 \n", + "1.093354 2.133447e-09 4.762062e-10 5.031270e-07 1.093354 \n", + "1.143250 2.143335e-09 4.670743e-10 4.956689e-07 1.143250 \n", + "1.195423 2.154013e-09 4.577099e-10 4.879646e-07 1.195423 " + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ "SOURCE='Xe'\n", "df = dict()\n", @@ -128,7 +293,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": { "ExecuteTime": { "end_time": "2022-07-22T19:16:27.594619Z", @@ -138,7 +303,28 @@ "name": "#%%\n" } }, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", "df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n", @@ -169,18 +355,66 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mwr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmigdal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mShell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0melement\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbinding_e\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msingle_ionization_probability\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcollections\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Describes a specific atomic shell for the selected atom.\n", + "\n", + "Attributes:\n", + " name (str): The name of the shell.\n", + " element (str): The element class of the atom.\n", + " binding_e (float): The binding energy for the shell.\n", + " model (str): The model used for the single ionization probability computation.\n", + " single_ionization_probability (Callable): A function to assign interpolators to.\n", + " The interpolator will provide the single ionization probability for the shell\n", + " according to the selected model.\n", + "\n", + "Methods:\n", + " __call__(*args, **kwargs) -> np.ndarray:\n", + " Calls the single_ionization_probability function with the given arguments and keyword arguments.\n", + "\n", + "Properties:\n", + " n (int): Primary quantum number.\n", + " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", + "\u001b[0;31mFile:\u001b[0m ~/projects/wimprates/wimprates/migdal.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + } + ], "source": [ "wr.migdal.Shell?" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "scale = ((nu.me * 1e-3 * nu.c0)/(nu.eV / nu.c0))**2 / (2 * np.pi)\n", "shells_ibe = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Ibe\", considered_shells=(\"*\"))\n", @@ -208,9 +442,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "shells_cox = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", considered_shells=(\"*\",))\n", @@ -245,9 +490,20 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "shells_cox_dipole = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", dipole=True, considered_shells=(\"*\",))\n", @@ -304,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -327,25 +583,59 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "ac4d28696c694ee7aaac335f8e2a0871", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "fig, ax = plt.subplots()\n", "\n", @@ -379,9 +669,24 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "45a57ced132e443393b8ee8ee4e2f974", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import seaborn as sns\n", "\n", @@ -459,7 +785,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -498,9 +824,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "g = sns.catplot(data=all_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\")\n", "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", yscale=\"log\", title=\"Binding Energies for all orbitals\")" @@ -508,9 +855,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "g = sns.catplot(data=considered_shells, y=\"Binding_E\", x=\"name\", hue=\"Model\", kind=\"bar\", order=considered_shells.index.levels[1].values)\n", "g.set(ylabel=\"Binding Energy (keV)\", xlabel=\"Subshell\", title=\"Binding Energies for considered orbitals\")" From 28e67a33000bfefcc806c39004d2730b029c6ac5 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:37:17 +0200 Subject: [PATCH 62/94] Revert "Remove typing.Self for python3.9" This reverts commit 8bde9892557274813ab7150579518e6fc660a408. --- wimprates/migdal.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 6e9b200..bd789e1 100755 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional +from typing import Any, Optional, Self from fnmatch import fnmatch from functools import lru_cache @@ -55,15 +55,15 @@ class Shell: model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self, *args, **kwargs) -> np.ndarray: + def __call__(self: Self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self) -> int: + def n(self: Self) -> int: return int(self.name[0]) @property - def l(self) -> str: + def l(self: Self) -> str: return self.name[1:] From cc392068a822bbf2521123dc02c5454900a08122 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 21:52:12 +0200 Subject: [PATCH 63/94] Revert "Require seaborn" This reverts commit e0d51d4761db159c83f19e78ae7aab3bef94fadc. --- requirements.txt | 1 - 1 file changed, 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index 408d07d..81ced55 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,4 +4,3 @@ pandas tqdm boltons numericalunits -seaborn From 0b79d66617f6cb5a579e27e44c1495dd0e22d963 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 22:32:27 +0200 Subject: [PATCH 64/94] Require Python3.11 --- setup.py | 51 +++++++++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 22 deletions(-) diff --git a/setup.py b/setup.py index d7e5d33..7b2abd5 100644 --- a/setup.py +++ b/setup.py @@ -1,28 +1,35 @@ import setuptools -readme = open('README.md').read() -history = open('HISTORY.md').read().replace('.. :changelog:', '') -requirements = open('requirements.txt').read().splitlines() +readme = open("README.md").read() +history = open("HISTORY.md").read().replace(".. :changelog:", "") +requirements = open("requirements.txt").read().splitlines() setuptools.setup( - name='wimprates', - version='0.5.0', - description='Differential rates of WIMP-nucleus scattering', - long_description=readme + '\n\n' + history, - long_description_content_type='text/markdown', - author='Jelle Aalbers', - url='https://github.com/jelleaalbers/wimprates', - license='MIT', + name="wimprates", + version="0.5.0", + description="Differential rates of WIMP-nucleus scattering", + long_description=readme + "\n\n" + history, + long_description_content_type="text/markdown", + author="Jelle Aalbers", + url="https://github.com/jelleaalbers/wimprates", + license="MIT", packages=setuptools.find_packages(), - setup_requires=['pytest-runner'], + setup_requires=["pytest-runner"], install_requires=requirements, - package_dir={'wimprates': 'wimprates'}, - package_data={'wimprates': [ - 'data/bs/*', 'data/migdal/*', 'data/sd/*', 'data/dme/*']}, - tests_require=requirements + ['pytest', 'unittest'], - keywords='wimp,spin-dependent,spin-independent,bremsstrahlung,migdal', - classifiers=['Intended Audience :: Science/Research', - 'Development Status :: 3 - Alpha', - 'Programming Language :: Python', - 'Programming Language :: Python :: 3'], - zip_safe=False) + package_dir={"wimprates": "wimprates"}, + package_data={ + "wimprates": ["data/bs/*", "data/migdal/*", "data/sd/*", "data/dme/*"] + }, + tests_require=requirements + ["pytest", "unittest"], + keywords="wimp,spin-dependent,spin-independent,bremsstrahlung,migdal", + classifiers=[ + "Intended Audience :: Science/Research", + "Development Status :: 3 - Alpha", + "Programming Language :: Python", + "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.11", + "Programming Language :: Python :: 3.12", + ], + python_requires=">=3.11", + zip_safe=False, +) From a0ada21fb20e0102df573ca6983c922ba366a6ed Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 22:32:59 +0200 Subject: [PATCH 65/94] Require importlib package for Cox model --- requirements.txt | 1 + 1 file changed, 1 insertion(+) diff --git a/requirements.txt b/requirements.txt index 81ced55..a531b0f 100644 --- a/requirements.txt +++ b/requirements.txt @@ -4,3 +4,4 @@ pandas tqdm boltons numericalunits +importlib_metadata \ No newline at end of file From 426a0ed1fc9ee24bcb9a9f60dad9bf1cc45ac228 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Tue, 6 Aug 2024 23:05:16 +0200 Subject: [PATCH 66/94] Add __init__.py in tests to fix module structure Without it, pytests do not recognise wimprates.data.migdal.Cox modules --- tests/__init__.py | 0 1 file changed, 0 insertions(+), 0 deletions(-) create mode 100644 tests/__init__.py diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000..e69de29 From 7b3fbc9899c21bc58205d9ef0206a304d9912494 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 01:14:15 +0200 Subject: [PATCH 67/94] Add all content of data/ for build --- setup.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/setup.py b/setup.py index 7b2abd5..ea4f5bc 100644 --- a/setup.py +++ b/setup.py @@ -18,7 +18,7 @@ install_requires=requirements, package_dir={"wimprates": "wimprates"}, package_data={ - "wimprates": ["data/bs/*", "data/migdal/*", "data/sd/*", "data/dme/*"] + "wimprates": ["data/bs/*", "data/migdal/**", "data/sd/*", "data/dme/*"] }, tests_require=requirements + ["pytest", "unittest"], keywords="wimp,spin-dependent,spin-independent,bremsstrahlung,migdal", From f59cc33baf5d6e68bebce5c8e018b09f4f603706 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 01:18:46 +0200 Subject: [PATCH 68/94] Add deprecation warning for old func --- wimprates/migdal.py | 4 ++-- wimprates/utils.py | 20 ++++++++++++++++++++ 2 files changed, 22 insertions(+), 2 deletions(-) mode change 100755 => 100644 wimprates/migdal.py diff --git a/wimprates/migdal.py b/wimprates/migdal.py old mode 100755 new mode 100644 index bd789e1..0b206ca --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -359,10 +359,10 @@ def diff_rate(v, erec): return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) - -### (DEPRECATED) Maintain this for backwards accessibility +@wr.deprecated("Use get_migdal_transitions_probability_iterators instead") @lru_cache() def read_migdal_transitions(material="Xe"): + ### (DEPRECATED) Maintain this for backwards accessibility # Differential transition probabilities for vs energy (eV) df_migdal_material = pd.read_csv( diff --git a/wimprates/utils.py b/wimprates/utils.py index f8c1d7b..890fb38 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -1,6 +1,8 @@ +import functools import inspect import os import pickle +import warnings from boltons.funcutils import wraps import numpy as np @@ -105,3 +107,21 @@ def pairwise_log_transform(a, b): b = np.atleast_1d(b).reshape(-1, 1) arr = np.concatenate((a, b), axis=1) return np.log(arr) + +@export +def deprecated(reason): + """ + This is a decorator which can be used to mark functions as deprecated. + It will result in a warning being emitted when the function is used. + """ + def decorator(func): + @functools.wraps(func) + def new_func(*args, **kwargs): + warnings.warn( + f"Call to deprecated function {func.__name__} ({reason}).", + category=DeprecationWarning, + stacklevel=2 + ) + return func(*args, **kwargs) + return new_func + return decorator \ No newline at end of file From fa79a1a7bc149e11421a56880269bbdd41f652e3 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 14:26:00 +0200 Subject: [PATCH 69/94] Fix typing --- wimprates/data/migdal/Cox/cox_wrapper.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index 58366b6..67dd5f6 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -16,7 +16,7 @@ @export -def cox_migdal_model(element: str, **kwargs): +def cox_migdal_model(element: str, **kwargs) -> Migdal: """ This function creates a Cox Migdal model for a given element. From e69cc848e873265c04ece9e39a8512f23f7ec76e Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:25:06 +0200 Subject: [PATCH 70/94] Reduce required python3 version to 3.9 --- setup.py | 4 +++- wimprates/migdal.py | 22 ++++++++++++---------- 2 files changed, 15 insertions(+), 11 deletions(-) diff --git a/setup.py b/setup.py index ea4f5bc..2b55601 100644 --- a/setup.py +++ b/setup.py @@ -27,9 +27,11 @@ "Development Status :: 3 - Alpha", "Programming Language :: Python", "Programming Language :: Python :: 3", + "Programming Language :: Python :: 3.9", + "Programming Language :: Python :: 3.10", "Programming Language :: Python :: 3.11", "Programming Language :: Python :: 3.12", ], - python_requires=">=3.11", + python_requires=">=3.9", zip_safe=False, ) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 0b206ca..6c23e4b 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -11,7 +11,7 @@ from collections.abc import Callable from dataclasses import dataclass -from typing import Any, Optional, Self +from typing import Any, Optional, Union from fnmatch import fnmatch from functools import lru_cache @@ -49,21 +49,22 @@ class Shell: n (int): Primary quantum number. l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox. """ + name: str element: str binding_e: float model: str single_ionization_probability: Callable # to assign interpolators to - def __call__(self: Self, *args, **kwargs) -> np.ndarray: + def __call__(self, *args, **kwargs) -> np.ndarray: return self.single_ionization_probability(*args, **kwargs) @property - def n(self: Self) -> int: + def n(self) -> int: return int(self.name[0]) @property - def l(self: Self) -> str: + def l(self) -> str: return self.name[1:] @@ -96,14 +97,14 @@ def create_cox_probability_function( material: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: - + fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) def get_probability( - e: float | np.ndarray, # energy of released electron - erec: Optional[float | np.ndarray] = None, # recoil energy - v: Optional[float | np.ndarray] = None, # recoil speed + e: Union[float, np.ndarray], # energy of released electron + erec: Optional[Union[float, np.ndarray]] = None, # recoil energy + v: Optional[Union[float, np.ndarray]] = None, # recoil speed ) -> np.ndarray: if erec is None: if v is None: @@ -112,7 +113,7 @@ def get_probability( v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 else: raise ValueError("Either v or erec have to be provided") - + e /= nu.keV input_points = wr.pairwise_log_transform(e, v) @@ -125,7 +126,7 @@ def get_probability( def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", - considered_shells: Optional[list[str] | str] = None, + considered_shells: Optional[Union[list[str], str]] = None, dark_matter: bool = True, e_threshold: Optional[float] = None, dipole: bool = False, @@ -359,6 +360,7 @@ def diff_rate(v, erec): return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + @wr.deprecated("Use get_migdal_transitions_probability_iterators instead") @lru_cache() def read_migdal_transitions(material="Xe"): From 65430fad3094c4d9700326334121390431435ece Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 7 Aug 2024 16:28:58 +0200 Subject: [PATCH 71/94] Update notebook output --- notebooks/Migdal.ipynb | 58 ++++++++++++++++++++++++------------------ 1 file changed, 33 insertions(+), 25 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 81fe72c..8c26173 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -29,9 +29,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/home/loren/projects/wimprates/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", + "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", " warnings.warn(\n", - "/home/loren/projects/wimprates/wimprates/utils.py:7: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", + "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/utils.py:9: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", " from tqdm.autonotebook import tqdm\n" ] }, @@ -304,10 +304,18 @@ } }, "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_1780/1628684340.py:2: DeprecationWarning: Call to deprecated function read_migdal_transitions (Use get_migdal_transitions_probability_iterators instead).\n", + " df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n" + ] + }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -389,7 +397,7 @@ "Properties:\n", " n (int): Primary quantum number.\n", " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", - "\u001b[0;31mFile:\u001b[0m ~/projects/wimprates/wimprates/migdal.py\n", + "\u001b[0;31mFile:\u001b[0m ~/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/migdal.py\n", "\u001b[0;31mType:\u001b[0m type\n", "\u001b[0;31mSubclasses:\u001b[0m " ] @@ -583,13 +591,13 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ac4d28696c694ee7aaac335f8e2a0871", + "model_id": "7a50bf4773e2478eb785d709ba357b25", "version_major": 2, "version_minor": 0 }, @@ -612,16 +620,16 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 12, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" }, @@ -669,13 +677,13 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "45a57ced132e443393b8ee8ee4e2f974", + "model_id": "17e26c918caa4a0a98a5b8489efc468b", "version_major": 2, "version_minor": 0 }, @@ -713,7 +721,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -730,22 +738,22 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 15, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -785,7 +793,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -824,22 +832,22 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 17, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkYAAAHoCAYAAACsIyBvAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAABVk0lEQVR4nO3de3zO9f/H8ee1kznNaZsWEWI5qy9m2MaQMBUdHHKKlDlWxhwq6etUKXKInGL4omSKb/omaaTofFBoJIdhY2abmR2v3x+uXb8u2+y6tmtHj/vt5nbr+nze1/v9uq5r5tn7835/LoPRaDQKAAAAcijuAgAAAEoKghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEYrVtm3b5O3tbfGnXbt2Gjx4sPbu3Zutvbe3txYvXmzXGgIDAzVlyhTz40OHDsnb21uHDh2y6zjWyBo7tz/btm0r8ppsdfP7WRSuXLmi559/Xr6+vvL29tbo0aOLdPzcLF68WN7e3hbHBg8erMGDBxfJ+IGBgXr22WfzbHf27NlsP18//vijFi9erISEhHyPn9PrB0o6p+IuAJCkuXPnqn79+jIajbp06ZI2bNigUaNGadmyZQoMDDS327Jli+64445CraVp06basmWL7rnnnkId51ZeeOEF+fj4ZDtep06dYqjGNkuWLFGlSpWKdMx33nlHu3fv1pw5c1SnTh1VqVKlSMcv7Tw9PbVlyxaLn6+ffvpJS5YsUZ8+feTm5laM1QFFi2CEEqFhw4Zq3ry5+bGfn5/atGmj//73vxbBqFWrVoVeS6VKlYpknFupW7dusdcgSRkZGcrIyJCLi4vVz2nSpEkhVpSzyMhI1alTRw899JBd+jMajUpJSZGrq6td+itqycnJKl++vNXtXVxcSsTPG1AScCkNJVK5cuXk7OwsJyfL7H7zpbSsS3EHDx7UjBkz5OPjIx8fH40dO1bR0dEWz01LS9Prr7+uDh06qGXLlhowYIB+/fXXbGPndCltypQpuu+++3Tq1CmNHDlS9913nwICAjRv3jylpqZaPP/ChQsaP3687rvvPrVu3VoTJ07Ur7/+avdLYVmXSfbt26c+ffqoRYsWevDBB7V169ZsbS9evKiXX35Z/v7+atasmQIDA7VkyRKlp6eb22RdTlm5cqXeeecdBQYGqnnz5jp48KAk6fPPP1fv3r3VrFkzdenSRevWrcvxUklOl9KuXr2q1157TYGBgWrWrJn8/Pw0e/ZsXbt2zaLdrl279Pjjj+tf//qXWrZsqS5dumjq1Km5vgdZNX/99dc6ceKE+ZJj1md35coVvfLKK/Lz8zPXvWDBgmyfmbe3t1599VVt2rRJPXr0UPPmzRUeHp7ruJ988omGDx+ujh07qkWLFurRo4fmz5+f7fUURGZmplauXKkHH3xQzZo1k6+vryZPnqwLFy5YtBs8eLCCgoL03XffqX///mrZsqWmTZtm0Wb37t3q3bu3mjdvri5duigsLMzi/M2X0hYvXqzXX39dktSlS5ds72tBXv8333yjwYMHy8fHRy1atFCnTp00btw4JScn5/u9AuyJGSOUCJmZmUpPT5fRaFRsbKxWrVql5ORkBQUFWfX8F198UZ06ddKbb76p8+fP64033tCkSZMs/gF46aWXtH37dg0fPlwdOnRQZGSkxo4dq6SkJKvGSEtLU3BwsB577DENHz5c3333nd555x1VqlRJY8eOlSRdu3ZNQ4YMUXx8vEJCQlS3bl3t379fzz//fL7ej5vdHBSPHj2q1157TSNHjpS7u7s++OADTZ8+XXXr1lWbNm0k3QhFjz/+uBwcHDRmzBjVqVNHP/30k5YtW6aoqCjNnTvXos/169fr7rvvVmhoqCpVqqS6detq3759GjdunFq3bq2FCxcqPT1da9as0aVLl/J8LcnJyRo0aJAuXLigUaNGydvbW5GRkVq0aJH+/PNPrV27VgaDQT/99JOef/559ezZU2PHjlW5cuV07tw5czDLSdYloJkzZyoxMVHz58+XJN1zzz1KSUnRkCFDdObMGY0bN07e3t76/vvvtWLFCh05ckQrVqyw6Ovzzz/X999/rzFjxsjd3V01atTIddy///5b/v7+Gjp0qMqXL6+//vpLK1eu1K+//potdOTXK6+8oi1btmjQoEHq1KmToqKi9Pbbb+vbb7/Vtm3bVL16dXPbixcvatKkSXr66af1/PPPy8Hh//+f98iRI5ozZ47Gjh0rd3d37dixQ7Nnz1ZaWppGjBiR49iPP/644uPjtX79ei1ZskQeHh6SZL68nN/Xf/bsWT377LNq3bq1Zs+eLTc3N0VHR2v//v1KS0uzaZYLKCwEI5QITzzxhMVjFxcXvfTSS/Lz87Pq+X5+fnrxxRfNj+Pj4/XGG2/o4sWL8vDw0IkTJxQeHq5hw4Zp8uTJkqQOHTqoRo0aCgkJsWqMtLQ0jRs3Tj169JAk+fr66vDhw9q5c6c5GIWHh+vUqVNauXKl/P39JUkdO3ZUcnKytmzZYtU4knINUhERERZrrOLi4rRp0ybdeeedkqQ2bdro4MGD2rFjhzkYLV68WPHx8frvf/9rbufr6ytXV1e99tprGjFihMV6qnLlymn16tVydnY2H3vuuedUs2ZNrV692nxZzc/Pz+IyZ27Wr1+vY8eO6f333zdfLvX19VXNmjU1fvx47du3TwEBAfrpp59kNBo1c+ZMVa5c2fz8vn375tp31iWgSpUqKS0tzeJy0ObNm3Xs2DEtXLjQ/Jl16NBBFSpU0Pz583XgwAF16NDB3P7atWvasWOHVeuT/rm422g06v7771eDBg00aNAgHT16VPfee2+efdzKiRMntGXLFg0cOFAvvfSS+XiTJk30+OOPa926dRY/I1euXNHChQvl6+ubra+YmBht377dXFNAQIAuX76sd955RwMHDswxjNxxxx3y8vKSJDVu3Fi1a9e2y+v//ffflZKSosmTJ1u06d27tzVvC1AkuJSGEuG1117T1q1btXXrVq1cuVJ9+vTRq6++qg0bNlj1/Jv/gc66vHPu3DlJMl8CuPkXcI8ePbLNwuTGYDDkOE7WGJL03XffqWLFiuZQlMXama8sISEh5vfjn39unsVo3LixOexIN0LN3XffbVHTl19+KR8fH3l6eio9Pd38J6vGb7/91qLPwMBAi1B07do1HT58WF27drVYa1SxYkWrgtHevXvVsGFDNW7c2GL8jh07ymAwmMfPCk3PPfecPvnkk2yXQm118OBBVahQQQ8++KDF8ayg9c0331gcb9eundWLts+cOaOJEyeqQ4cOaty4sZo2bapBgwZJkv76668C1S39/89rnz59LI63aNFCDRo0yFZ7lSpVcgxF0o31ezcHlaCgIF29elW///57vurL7+tv3LixnJ2d9dJLLyk8PFxnzpzJ1/hAYWLGCCVCgwYNLBZf+/v7KyoqSm+88YYeeuihPHfFVK1a1eJx1j/g169fl3Tj/6glmS8JZHFycsr23NyUL19e5cqVyzZOSkqK+fGVK1fk7u6e7bm3uiyTk7vuusvi/chNTrXfXFNsbKz27t2rpk2b5thHXFycxeOb36OEhAQZjcYcX4M1rys2NlanTp3Kc/w2bdpo6dKlWr9+vUJDQ5WamqqGDRtq1KhRNgdL6f8/C4PBkK1mJycn889Elptfd26SkpI0cOBAlStXTs8995zuvvtuubq66sKFCxo7dqz5Z64gsmrz9PTMds7T09Mi+OZVe04/j1nHbn4PrFGQ11+nTh2tXbtWq1at0quvvqpr167prrvu0uDBgzV06FCbawEKA8EIJZa3t7e++uor/f3332rRokWB+soKEBcvXlTNmjXNx9PT0/P1j8OtxslpQbc1a3EKS7Vq1eTt7a3nnnsux/M3/+N7c5Bwc3OTwWBQbGxstuda87qqVaumcuXKac6cObmez9K1a1d17dpVqamp+vnnn/Xuu+9q4sSJqlWrlu677748x/qnqlWr6pdffpHRaLR4TbGxsUpPT7cYV8r+unNz8OBBxcTEaP369Wrbtq35eGJiok313UrWz2tMTEy221PExMTYVHtOn1HWMWv/p+CfCvr6W7durdatWysjI0OHDx/W+vXrNWfOHLm7u6tXr1421wPYG5fSUGIdPXpUkrL9I5AfWfcE2rFjh8XxXbt25bjIOb/atGmjpKQkRUREWBz/73//a7cxbNWpUyf9+eefqlOnjpo3b57tzz+DYk4qVKigZs2a6fPPP7fYzZWUlJTjTThzGv/MmTOqWrVqjuPfvH5FujHr1bZtW02aNEmS9Mcff9j4qm+sY7p27Zo+//xzi+Pbt283n8+PrBBy8y0MNm/enK/+ctKuXTtJ0scff2xx/Ndff9WJEyfM560RGRlp/ruUZefOnapYsWKus3jS/7++f84+SvZ7/Y6OjmrZsqVmzJghSfm+rAfYGzNGKBEiIyOVkZEh6cb0/meffaYDBw6oW7duuuuuuwrcf4MGDfTQQw9p3bp1cnJyUvv27RUZGanVq1fb9WaEffr00bp16zR58mRNmDDBvKPrq6++kiSL3UK3curUKf3888/Zjt9xxx023+By/Pjx+vrrr9W/f38NHjxY9erVU2pqqs6ePat9+/Zp5syZefY5fvx4PfvssxoxYoSGDh2qjIwMrV69WhUrVlR8fPwtnzt06FB99tlnGjRokIYNGyZvb29lZmbq/Pnz+uqrrzR8+HC1bNlSb7/9ti5cuCBfX1/dcccdSkhIUFhYmJydnS1mJqz1yCOPaOPGjQoNDVVUVJQaNWqkH374Qe+++64CAgLUvn17m/uUpPvuu09VqlTRjBkzNHbsWDk5OWnHjh06duxYvvrLSf369dWvXz9t2LBBDg4O5kvLb7/9try8vDRs2DCr+/L09FRwcLDGjh0rDw8Pffzxxzpw4IBCQkJuuQusUaNGkqR169apT58+cnJyUr169Qr0+jdt2qSDBw+qU6dO8vLyUkpKij788ENJyvfnAdgbwQglwj/vVVO5cmXVrl1bU6dO1cCBA+02xuzZs+Xu7q7w8HCtX79ejRs31uLFi/XCCy/YbYwKFSpo3bp1mjNnjt544w0ZDAZ17NhRM2bM0DPPPGOx2+pW3nrrrRyPjxo1yuat/56entq6daveeecdrV69WtHR0apYsaJq1aolPz8/q+5q7O/vr8WLF+vtt9/Wc889Jw8PDw0YMEAxMTHZZjVuVqFCBW3cuFErVqzQli1bdPbsWbm6usrLy0vt27dXrVq1JEktW7bU4cOHNX/+fF2+fFlubm5q1qyZ1q5dq4YNG9r0mqUbC9HDwsK0YMECrVq1SnFxcapZs6aGDx9u3kWYH9WqVdO7776r1157TZMmTVL58uXN90e6ebF0Qbzyyiu66667tHXrVv3nP/9RpUqV5Ofnp4kTJ9o0i9q4cWP17dtXixcv1t9//y1PT09NnTo1z3Dl4+OjZ599VuHh4frggw+UmZmpsLAw+fj45Pv1N27cWAcOHNDixYt18eJFVahQQY0aNdKyZcvUsWNHq18TUJgMRqPRWNxFAGXd8uXLtXDhQn355ZeF/pUmRSUtLU2PPPKIatasqTVr1hR3OQBgF8wYAXaWdYuB+vXrKy0tTQcPHtT69ev10EMPlepQNG3aNHXo0EEeHh66dOmSNm3apBMnTmj69OnFXRoA2A3BCLAzV1dXrVu3TmfPnlVaWpq8vLw0cuRIBQcHF3dpBZKUlKTXXntNly9flrOzs5o0aaIVK1awNgRAmcKlNAAAABO26wMAAJgQjAAAAEwIRgAAACYEo0IyaNAg85cqAgCA0oFdaYXk/PnzxV0CAACwETNGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAExuy2A0bdo0+fn5ydvbW+np6RbnPvjgA/Xu3Vs9evTQxIkTdf369WKqEgAAFLXbMhg98sgjCg8Pz3b8+PHjWrZsmTZu3Khdu3bJzc1N7733XpHVZczMtGs7AABgG6fiLkCSTp06pdWrV+uXX35RZGSk6tevr507d2Zrd/LkSc2aNUs//PCDypcvr169eikkJESurq42jde2bdscj0dGRqpp06Zyc3OTJHXs2FELFixQcHCw7S/qJpmZRjk4GG7ZxuDgoJM7Vyo59nyubcrX8FK9oJEFrgcAAGRXIoJRZGSkIiIi1LJlS2VmZspoNGZrk5CQoKFDh+rOO+/UokWLdPnyZc2dO1dXrlzR/Pnz7VLHvffeq7lz5yo6Olru7u763//+p3PnztmlbwcHg5ZuOqComPgcz7f0vlP9Hmyl5NjzSo4+bZcxAQCAbUpEMAoMDFTXrl0lSVOmTNHhw4eztdm8ebMSEhK0fft2Va9eXZLk6OiokJAQBQcHq0GDBpKkAQMGKDo6OtvzGzRooJUrV96yjnr16mny5MkaPXq0nJ2d1a5dOzk52e8tioqJ199RcTmeu9PDzW7jAACA/CkRwcjBIe+lTvv27ZOvr685FElS9+7dNW3aNEVERJiD0aZNmwpUS1BQkIKCgiRJu3btUv369QvUHwAAKD1KRDCyxokTJ/Too49aHHNxcVGdOnV04sQJu41z6dIlubu7KzExUatWrdKIESNybdulS5dcz50/f15eXl52qwsAABS+UhOMEhISzIui/8nNzU3x8Tmv28nNpEmTdOjQIUk3LuO1bt1ab731lvlcTEyMUlNT1a9fP/Xs2bPgxQMAgFKh1ASj3BiNRhkMt97tdbM33ngj13O2bM/fs2dPruduNZsEAABKplJzHyM3NzclJCRkO56YmJjjTBIAAICtSs2MUYMGDbKtJUpNTdXp06ezrT0qajExMbp48aLFsbS0NKsWlQMAgJKj1AQjf39/LVu2THFxcapWrZokaffu3UpNTVVAQECx1rZlyxYtWbIk23FmsgAAKF1KRDBKTk5WRESEJCkqKkpXr17Vp59+KunGXaqrV6+u/v37a8OGDRo9erRGjx6t2NhYzZs3T7179zZv1S8u/fr1U2BgoMWx4OBgZowAAChlSkQwio2N1YQJEyyOZT0OCwuTj4+P3NzctG7dOs2aNUvjxo2Tq6urgoKCFBISUhwlW/D09JSnp6fFMWdn52KqBgAA5FeJCEa1a9fWsWPH8mxXr149rV69uggqAgAAt6MSEYxKOxZfAwBQNhCM7IDF1wAAlA0EIztg8TUAAGUDwcgOWHwNAEDZwJQGAACACcEIAADAhEtpdsCuNAAAygaCkR2wKw0AgLKBYGQH7EoDAKBsIBjZAbvSAAAoG5jSAAAAMCEYAQAAmBCMAAAATFhjZAds1wcAoGwgGNkB2/UBACgbCEZ2wHZ9AADKBoKRHbBdHwCAsoEpDQAAABOCEQAAgAnBCAAAwIRgBAAAYMLiazvgPkYAAJQNBCM74D5GAACUDQQjO+A+RgAAlA0EIzvgPkYAAJQNTGkAAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCE7fp2wJ2vAQAoGwhGdsCdrwEAKBsIRnbAna8BACgbCEZ2wJ2vAQAoG5jSAAAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAw4c7XdsCXyAIAUDYQjOyAL5EFAKBsIBjZAV8iCwBA2UAwsgO+RBYAgLKBKQ0AAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEQAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAQAAmDgVdwFlQUxMjC5evGhxLC0tTQ4O5E4AAEoTgpEdbNmyRUuWLMl23M3NrRiqAQAA+UUwsoN+/fopMDDQ4lhwcDAzRgAAlDIEIzvw9PSUp6enxTFnZ+diqgYAAOQXUxoAAAAmBCMAAAATglEZkJlptGs7AABuV6wxKgMcHAxauumAomLic23jfbeHhvT+lyTDLfsyZmbKwKJxAMBtimBURkTFxOvvqLhcz9/p4SaDg4NO7lyp5NjzObYpX8NL9YJGFlaJAACUeASj20xy7HklR5+26TmZmUY5ONx6psmWdgAAlFQEI+TJmkt1tTyraMyADkVYFQAA9kcwglXyulQHAEBZwCpbFDtrdssZMzOt6svadgAA5IQZIxS7vC7VtfS+U/0ebHXLheMSi8cBAAVHMEKJcKtLdXd63Pgy3vwsHAcAwBZcSgMAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABObd6WdOXNG+/bt048//qjo6Ghdv35d1apV0z333KN27dqpffv2cnZ2LoxaAQAACpXVwejQoUNasWKFvvnmG2VmZqpmzZqqUaOGXFxcdPbsWX3//fd67733VL16dfXr108jRoxQpUqVCrN2AAAAu7IqGI0ZM0YRERHq2LGj3nzzTfn4+Kh69eoWbTIyMnTs2DHt3r1bH3/8sbZs2aL58+erffv2hVI4AACAvVkVjCpWrKhdu3bprrvuyrWNo6OjmjRpoiZNmmjcuHH66KOPFB0dbbdCAQAACptVwej111+3qVMHBwf16dMnXwUBAAAUF6t2pa1du1ZxcWXjm9Xj4uL09NNP68EHH1Tv3r01ffp0paamms+fOHFCjz76qLp3764hQ4YoJiamGKsFAABFyapgNG/ePPn7++u5557T/v37ZTTm/W3oJZXBYNCzzz6rTz/9VB999JGSk5MVFhZmPj9jxgw988wz+t///qdOnTrpzTffLMZqAQBAUbIqGK1evVoPPPCA9u7dq2eeeUadO3fWokWLdObMGbsUcerUKb388st6+OGH1aRJEwUFBeXY7uTJkxoxYoRatWolX19fzZo1S9evX7dprKpVq6pNmzaSblzya9asmc6dOydJunTpkk6cOKEHHnhAkvTEE0/os88+K8ArAwAApYlVwahDhw5688039dVXX+mll16Su7u73nnnHXXv3l3Dhg3Tzp07LS5H2SoyMlIRERGqW7euGjRokGObhIQEDR06VElJSVq0aJFCQ0O1Y8cOvfjii/keNyUlReHh4erUqZMk6cKFC/Ly8pLBYJAkVapUSc7OzmXmMiIAALg1m27wWLlyZQ0cOFADBw7U8ePHtXXrVu3YsUMhISFyc3NTUFCQ+vbtq2bNmtlURGBgoLp27SpJmjJlig4fPpytzebNm5WQkKDt27ebbxXg6OiokJAQBQcHmwPVgAEDctwN16BBA61cudL8ODMzU6GhoWrXrp38/f0lKddLhFlBCQAAlG023/k6yz333KMpU6Zo0qRJ2rt3r7Zt26ZNmzZp8+bN+uOPP2zqy8Eh74mrffv2ydfX1+L+Sd27d9e0adMUERFhDkabNm2yasyZM2fKyclJ06ZNMx/z8vLShQsXZDQaZTAYdPXqVaWlpalq1ao2vR4AAFA65TsYZbly5YpOnTqlU6dOyWg0ysmpwF3mKGu32D+5uLioTp06OnHihE19vf7664qOjtaSJUssZoPc3d1Vr149ff755+rWrZu2bt2qbt265dpPly5dcj13/vx5eXl52VQXAAAoXvlKMRkZGdq7d68+/PBD7d+/X+np6WrYsKGmTJmihx9+2N41SrqxxsjNzS3bcTc3N8XHx1vdT2RkpFavXq369eubg1b79u0VGhoqSXrllVcUGhqq+fPny9PTU/Pnz7fPCwAAACWeTcHo+PHj+vDDD7Vjxw7FxsaqQoUK6tu3rx577DG1aNGisGq8pazLXtZq2LChjh07dsvz27Zts6qvPXv25HruVrNJAACgZLIqGG3ZskUffvihfvvtNxmNRv3rX//SxIkT1aNHD7m6uhZ2jZJuzAwlJCRkO56YmJjrTjYAAABbWBWMZsyYIXd3d40YMUKPPfaY7r777kIuK7sGDRpkW0uUmpqq06dPZ1t7VNRiYmJ08eJFi2NpaWlWLSoHAAAlh1XBaOnSperUqZMcHR0Lu55c+fv7a9myZYqLi1O1atUkSbt371ZqaqoCAgKKrS7pxozakiVLsh3PaU0UAAAouawKRjmtlzlx4oS+++47xcXF6bHHHpOHh4eio6NVpUoVmy+vJScnKyIiQpIUFRWlq1ev6tNPP5UktW3bVtWrV1f//v21YcMGjR49WqNHj1ZsbKzmzZun3r17F/ultH79+ikwMNDiWHBwMDNGAACUMjbvSsvIyNBLL72k8PBw88Jnf39/eXh4aMaMGWrcuLEmTJhgU5+xsbHZnpP1OCwsTD4+PnJzc9O6des0a9YsjRs3Tq6urgoKClJISIitL8HuPD095enpaXHM2dm5mKoBAAD5ZXMwWrZsmXbu3KnJkyfLz8/P4nvN/Pz8FB4ebnMwql279i13imWpV6+eVq9ebWvJAAAAVrE5GIWHh2v06NF66qmnlJGRYXGudu3aOnv2rN2KAwAAKEo2B6Po6Gi1atUqx3PlypVTUlJSQWsqddiVBgBA2WBzMKpRo4bOnDmjdu3aZTt38uRJ3XHHHXYprDRhVxoAAGWDzcEoICBAy5cvl7+/v9zd3SXd+Pb5xMRErV+/Xp07d7Z7kSUdu9IAACgbbA5G48eP1759+9SzZ0/5+PjIYDDorbfeUmRkpJycnDR69OjCqLNEY1caAABlg81TGu7u7tq6dat69eql33//XY6Ojjp69Kj8/f21efNmVa1atRDKBAAAKHw2zxhdvnxZ7u7uevXVV3M8//vvv6tp06YFLqw0YfE1AABlg83BKDg4WGFhYSpXrly2c5GRkRoxYoQOHjxol+JKCxZfAwBQNtgcjC5duqSQkBAtXrzY4vipU6f01FNPFfvXcxQHFl8DAFA22Pwv94oVK/Ttt99q7ty55mPnzp3TsGHD5OnpqXfffdeuBZYGnp6eatq0qcUfZ2fnYv3SXQAAYDubZ4waNGigxYsXa8SIEapVq5Z69uypYcOGqWLFilqzZo0qVapUGHUCAAAUunxd62nbtq1mzZql1157TU888YQk6b333mNHGgAAKNWsmjG6cuVKtmMBAQEaNGiQduzYoVWrVsnZ2dncjoAEAABKI6uCUbt27WQwGHI8ZzQa9eijj1ocO3LkSMErK0XYrg8AQNlgVTAaM2ZMrsEIbNcHAKCssCoYjRs3rrDrKNXYrg8AQNlg8640ZMd3pQEAUDZYNaWxcuVKXb9+3aaODx8+rC+//DI/NQEAABQLq4LRtm3b1LVrVy1YsEAnTpzItV1KSor+97//6ZlnnlH//v2VmJhot0IBAAAKm1WX0nbs2KGNGzdqzZo1WrFihWrUqKEmTZqoRo0acnFxUXx8vE6fPq0///xTGRkZCggIUHh4uBo2bFjY9QMAANiNVcHIyclJQ4cO1aBBg7Rnzx5FRETo559/1k8//aTr16+rWrVqql+/vkaPHq3evXvrrrvuKuy6AQAA7M6mxdeOjo564IEH9MADDxRWPaUS9zECAKBsYFeaHXAfIwAAygaCkR1wHyMAAMoGgpEdcB8jAADKBqY0AAAATAhGAAAAJgQjAAAAE5uD0ahRo7R///7CqAUAAKBY2RyMTpw4oWeeeUbdu3fXunXrdPXq1cKoCwAAoMjZHIx2796t5cuXq06dOpo3b578/Pz08ssv69ixY4VRHwAAQJHJ13b9gIAABQQE6PTp09q4caPCw8P1wQcfqHXr1nryySfVrVs3OTo62rvWEos7XwMAUDYU6D5GderU0dSpUzV69GiNHz9ehw4d0vfffy9PT089/fTTGjRokAwGg71qLbG48zUAAGVDgYLRhQsXtGnTJm3dulWXL1+Wv7+/evbsqT179mjOnDk6efKkXn75ZXvVWmJx52sAAMqGfAWjb775Rhs3btSXX34pFxcX9enTR4MHD9bdd98tSXrkkUe0bt06LVmy5LYIRtz5GgCAssHmYNSjRw/9/fffql27tkJCQvTYY4+pUqVK2dq1bNlSiYmJdikSKIjMTKMcHG59SdeaNgCAss/mYFSzZk1NmjRJnTt3vuX6oSZNmmjPnj0FKg6wBwcHg5ZuOqComPgcz9fyrKIxAzoUcVUAgJLI5mC0du1aq9q5uLioVq1atnYPFIqomHj9HRVX3GUAAEo4VgfjtlelsquMmZlWtbW2HQCgdLJ5xujee+/N9RKawWBQ5cqV1axZM40cOVLt2rUrcIFAYavo6iKDg4NO7lyp5NjzubYrX8NL9YJGFmFlAICiZnMwGjNmjLZv366kpCR17txZ7u7uunjxor788ktVrFhRgYGB+uabbzR8+HCtXLlSHTqwdgOlQ3LseSVHny7uMgAAxcjmYFSlShV5eHhox44dqlChgvl4UlKShg8frpo1a2r79u166qmntHz5coIRyjRrd7Ox6w0ASgebg9H69es1adIki1AkSRUrVtTw4cP12muv6emnn9aAAQP04osv2q1QoCTKa8ebxK43AChNbA5GFy5ckJNTzk9zdHTUpUuXJEkeHh5KT08vWHVAKcCONwAoO2wORvXq1VNYWJj8/f0tAlJ6errCwsJUr149SdLFixdVvXp1+1VagvElsigsXKoDgKJlczAaP368xo8frwceeEBdunSRu7u7Ll26pD179ig6OlqLFi2SJB04cECtWrWyd70lEl8ii8JizaU677s9NKT3vyTdOhgZMzNlIKwDwC3ZHIy6du2q5cuXa9GiRdqwYYOMRqMMBoOaNWummTNnys/PT5I0e/ZsuxdbUvElsihMeV2qu9PDLc/bDXCrAQCwjk3BKDU1Vd9++63uuecebd26VcnJyUpISJCbm5vKly9fWDWWeHyJLEoCbjcAAAVn05SGk5OTRo0apVOnTkmSypcvr5o1a97WoQgAAJQdNgUjBwcH1axZU1evXi2segAAAIqNzYtgHnvsMW3cuFEZGRmFUQ8AAChE27Ztk7e3t7y9vXXo0KFs541Go7p16yZvb28NHjzYbuN6e3tr8eLFNj/v7Nmz8vb21rZt2+xWy63YvPja2dlZJ0+eVM+ePRUYGCgPDw+L704zGAwaNmyYPWsEAAB2VrFiRW3dulU+Pj4Wx7/99ludPn1aFStWLKbKipfNwWj+/Pnm/37vvfeynScYAQBQ8vXs2VM7duzQjBkzVKlSJfPxrVu36r777rttl83YHIz27NlTGHUAAIAi1KtXL+3YsUM7d+5U//79JUmJiYn67LPP9OKLL2rdunUW7a9cuaKFCxdqz549iouLU82aNRUUFKQxY8bIxcXF3O7q1auaN2+edu/erdTUVN1///25fkXY33//rcWLF+vrr79WYmKi7rrrLg0aNEhPPvlk4b3wPNgcjGrVqlUYdQAAgCJUqVIlde/eXR9++KE5GO3cuVMODg7q0aOHRTBKSUnRkCFDdObMGY0bN07e3t76/vvvtWLFCh05ckQrVqyQdGN90ujRo/XTTz9pzJgxat68uX788UeNHJn9PmrHjx9X//795eXlpdDQUHl4eOirr77SrFmzFBcXp7FjxxbNG3ETm4NRlhMnTui7775TXFycHnvsMXl4eCg6OlpVqlSRq6urPWsEAACF4NFHH9WQIUMUGRmphg0b6sMPP9SDDz5ocWlNksLDw3Xs2DEtXLhQPXr0kCR16NBBFSpU0Pz583XgwAF16NBB+/fv16FDhzR9+nQNGTLE3M7Z2VkLFiyw6HPu3LmqWLGiNm3aZB6vQ4cOSk1N1YoVKzR48GBVqVKlCN4FSzbvSsvIyNC0adMUFBSkV155RYsWLVJMTIwkacaMGXr33XftXiQAALC/tm3bqk6dOvrwww917Ngx/fbbb3r00UeztTt48KAqVKigBx980OJ43759JUnffPONJJl3ufXu3duiXVBQkMXjlJQUHTx4UN26dZOrq6vS09PNf/z9/ZWSkqKff/7ZXi/TJjbPGC1btkw7d+7U5MmT5efnZ/Fi/fz8FB4ergkTJti1SACFw5ovn+ULaoGyy2AwqG/fvlq/fr1SUlJ09913q3Xr1tnaXblyRe7u7ha70CWpRo0acnJy0pUrV8ztnJycVK1aNYt2Hh4e2fpLT0/X+vXrtX79+hxri4vL/auQCpPNwSg8PFyjR4/WU089le1eRrVr19bZs2ftVhyAwpXXl9TW8qyiMQM65Lt/ghdQ8vXt21eLFi3S5s2b9fzzz+fYpmrVqvrll1/M34+aJTY2Vunp6eYgVLVqVaWnpysuLs4iHF28eNGiPzc3Nzk6Ourhhx/WwIEDcxyzdu3aBX1p+WJzMIqOjlarVq1yPFeuXDklJSUVtCYARSivL6ktiMIOXgAKrmbNmhoxYoT++usvPfLIIzm28fX11a5du/T555+rW7du5uPbt283n5ckHx8frVq1Sjt27DCvMZJuLOr+p/Lly8vHx0d//PGHvL29LXa1FTebg1GNGjV05swZtWvXLtu5kydP6o477rBLYQDKhlsFryqVXWXMzJTBIe/ljta2A2C7kJCQW55/5JFHtHHjRoWGhioqKkqNGjXSDz/8oHfffVcBAQFq3769JKljx45q06aN3njjDSUnJ6tZs2b68ccf9dFHH2Xrc/r06Ro4cKCefPJJDRgwQLVq1VJSUpJOnz6tL774QmFhYYXyWvNiczAKCAjQ8uXL5e/vL3d3d0k3rlEmJiZq/fr16ty5s92LBFA2VXR1kcHBQSd3rlRy7Plc25Wv4aV6Qdm3+wIoGuXKlVNYWJgWLFigVatWme9jNHz4cItt9Q4ODlq2bJnmzp2rVatWKS0tTffff79WrFhh3s2W5Z577tG2bdv0zjvvaOHChbp8+bIqV66sunXrKiAgoKhfopnNwWj8+PHat2+fevbsKR8fHxkMBr311luKjIyUk5OTRo8eXRh1lmgxMTHZrp+mpaXJgf+7BaySHHteydGni7sM4LbQt29f826yW7n58lfVqlU1c+ZMzZw585bPq1y5subMmaM5c+ZYHD927Fi2trVr187WLqc2OT23sNgcjNzd3bV161YtWrRIERERcnR01NGjR9W5c2eNHz9eVatWLYQyS7YtW7ZoyZIl2Y67ubkVQzUAACC/8nWDR3d3d7366qv2rqXU6tevnwIDAy2OBQcHM2MEAEApk+87X+P/eXp6ytPT0+KYs7NzMVUDAADyK1/B6Pvvv9fOnTt17tw5Xb9+3eKcwWDI9sVzAAAApYHNwejDDz/U9OnTVaVKFdWrVy/bzIjRaLRbcQAAAEXJ5mC0atUq9ejRQ6+99lqJuiETAABAQdm8OvjcuXN6/PHHCUUAAKDMsTkYNWjQQJcuXSqMWgAAAIqVzcHo+eef18qVKxUdHV0Y9QAAABQbm9cYbdy4UYmJierevbvuvffebDd0NBgMWrZsmb3qAwAAKDI2B6M///xTDg4Oql69umJiYhQTE2Nx3mAw2K04AABQNkVERCgsLEyHDx9WUlKSPDw8FBAQoOHDh6tOnTrFVpfNweiLL74ojDoAAEA+ZGYa5eBQ9JMSBRl3wYIFWr58ubp166aZM2eqRo0aioqKUnh4uIYNG1asWYM7XwMAUIo5OBi0dNMBRcXEF9mYtTyraMyADvl67r59+7R8+XI9++yzeuGFF8zH27Rpo0ceeaTYJ2CsCkbbt29XQECAqlWrZj4WHR0td3d3OTo6WhzbvHmzJkyYYP9KAQBAjqJi4vV3VFxxl2GVNWvWyN3dXePGjcvxfNZ3j2ZmZmrFihV6//33FRMTozvvvFMDBw7UsGHDJEmff/65xowZo+XLl6tz586SpISEBPXu3VstW7bUokWL8lWfVbvSpk6dqjNnzpgfZ2RkqFOnTjp69KhFuwsXLmj58uX5KgQAAJRt6enp+vHHH+Xr65vnd4q+/vrrevvtt/XQQw9p+fLl6tKli+bOnaulS5dKkrp27aq+ffvqxRdf1OXLlyVJM2fOVEZGhmbOnJnvGq2aMcrpaz746g8AAGCLK1euKCUlRV5eXrdsd/nyZW3YsEFPPfWUnnvuOUlSx44dlZSUpFWrVmnYsGGqWLGipk+frkOHDunll19Wz549tXPnTq1YscLiCpetbL6PEQAAQH5kTarktYP9119/VVpamnr27GlxvFevXrp27ZqOHDkiSapUqZLmzZunPXv2KDQ0VAMGDFBAQECBaiQYAQCAIlGtWjWVK1dO586du2W7+PgbC8k9PDwsjru7u0u6MfOU5b777lOtWrWUmpqqQYMGFbhGghEAACgSTk5O+te//qVvvvlGaWlpubbLunn0zV9BlvX4nzeXXrJkiWJjY3X33Xdr5syZBV7qY/V2/UOHDunChQuSbqwUNxgMOnTokKKiosxt/v777wIVAwAAyrannnpKI0eO1NKlS83rh/5p7969atmypZydnbVr1y41bdrUfO6TTz5RhQoV1KRJE0nSTz/9pJUrV2rGjBlq2rSp+vfvr7Vr1+qpp57Kd31WB6M333wz27HXX3892zHufA0AQNGq5Vml1Izn7++vUaNGadmyZfrrr7/Uq1cv8w0eP/74Y508eVJffPGFBg8erDVr1sjFxUX333+/vvnmG23ZskXjxo1ThQoVdO3aNYWGhqpDhw7q16+fJCk4OFhvvfWWOnbsqIYNG+arPquCUVhYWL46BwAAhSsz05jvmy0WdNz83vn6+eef13333af169frpZdeUlJSkjw9PdW+fXtNnTpVkjRp0iS5ubnpgw8+0IoVK+Tl5aUpU6aY72M0b948xcfHa/bs2eZ+R40apYiICIWGhmrLli153hIgJ1YFo7Zt29rcMQAAKHzF8XUg9hi3U6dO6tSp0y36d1BwcLCCg4NzPP/qq6/q1VdftTjm6Oio999/v0B1sfgaAADA5Lb7rrS4uDhNmjRJZ8+elbOzs1q0aKEZM2bIxcVFkjRt2jTt379fMTEx+v333+XkdNu9RQAA3LZuuxkjg8GgZ599Vp9++qk++ugjJScnW6yheuSRRxQeHl6MFQIAgOJSIqZDTp06pdWrV+uXX35RZGSk6tevr507d2Zrd/LkSc2aNUs//PCDypcvr169eikkJESurq5Wj1W1alW1adNG0o3rl82aNdPZs2fN51lPBQDA7atEzBhFRkYqIiJCdevWVYMGDXJsk5CQoKFDhyopKUmLFi1SaGioduzYoRdffDHf46akpCg8PPyWi78AAMDto0TMGAUGBqpr166SpClTpujw4cPZ2mzevFkJCQnavn27qlevLunG6vOQkBAFBwebA9WAAQMUHR2d7fkNGjTQypUrzY8zMzMVGhqqdu3ayd/fvzBeFgAAKGVsDkbbt2/P9ZzBYJCbm5uaNGmimjVrWt2ng0PeE1f79u2Tr6+vORRJUvfu3TVt2jRFRESYg9GmTZusGnPmzJlycnLStGnTrK4TAACUbTYHoylTppjvbv3P7yP55zEHBwc9/PDD+ve//223XV0nTpzQo48+anHMxcVFderU0YkTJ2zq6/XXX1d0dLSWLFlSoDt1d+nSJddz58+fl5eXV777BgAARc/m1PLBBx/o+eefV4cOHRQUFKQaNWro0qVL2rlzpw4cOKBXXnlFv//+u5YuXapatWpp7Nixdik0ISFBbm5u2Y67ubmZv4XXGpGRkVq9erXq169vDlrt27dXaGiopBt32jx06JCkG5f4WrdurbfeessOrwAAAJR0NgejsLAwdevWzRwkJKl+/fpq27at5s2bpw8//FALFy5UfHy8duzYYbdglBuj0WjTrE/Dhg117NixXM+/8cYbVve1Z8+eXM/dajYJAIDb1eLFi7VmzRr99NNPOnv2rLp06aK3335bDz74YHGXJikfu9K+/PJL+fn55XjO399fX331lSSpXbt2OnfuXMGq+wc3NzclJCRkO56YmJjjTBIAALcDY2bmbTVuYbN5xigjI0OnT59W+/bts507deqUed2Ri4uL+W7S9tCgQYNsa4lSU1N1+vTpbGuPilpMTIwuXrxocSwtLc2qReUAABSEwcFBJ3euVHLs+SIbs3wNL9ULGllk4xUlm4NRx44dtXDhQt11113q0OH/v813//79evvtt83H/vrrL9WqVctuhfr7+2vZsmWKi4tTtWrVJEm7d+9WamqqAgIC7DZOfmzZskVLlizJdpyZLABAUUiOPa/k6NPFXUa+JScna9q0afrf//4nR0dH9enTR5MmTbLYwHXhwgXNnz9f+/fvV3Jyspo3b66pU6eqWbNmdq3F5mA0ffp0DR48WE8//bQqVqyoGjVqKDY2VklJSapTp46mT59ubjt06FCr+kxOTlZERIQkKSoqSlevXtWnn34q6cadqKtXr67+/ftrw4YNGj16tEaPHq3Y2FjNmzdPvXv3zvWmkEWlX79+CgwMtDgWHBzMjBEAAFZ46623zBMvf/zxhxYtWiRnZ2eFhIRIkuLj4zVw4EBVqFBBL730kipXrqz169dr6NCh+uyzz1SjRg271WJzMKpZs6Y++ugjbdu2Td9//72uXLmiJk2aqE2bNurTp4/Kly8vSXryySet7jM2NlYTJkywOJb1OCwsTD4+PnJzc9O6des0a9YsjRs3Tq6urgoKCjK/acXJ09NTnp6eFsecnZ2LqRoAAEqXOnXqaO7cuZIkPz8/JScna+3atRo5cqSqVKmidevWKSEhQR988IE5BPn6+qpbt25avXq1Jk+ebLda8nWTofLly+vJJ5+0KfzcSu3atW+5UyxLvXr1tHr1aruMCQAASoZu3bpZPH7ggQe0bNky/fnnn2rTpo0OHDggHx8fValSRenp6ZJu3By6devW+u233+xaS4n4ShAAAHD7+ue3WkgyzwplbWyKi4vTzz//rKZNm2Z7bp06dexai83BKC0tTStXrtTOnTt17tw5paSkWJw3GAz6448/7FZgacCuNAAA8u/y5csWj2NjYyVJHh4ekqQqVarIz88v27IbSXbdAS/lIxi99dZbWrt2rfz9/dW1a1e7F1QasSsNAID82717t4YNG2Z+/Nlnn6l8+fJq1KiRpBvfUPHxxx+rQYMGqlChQqHWYnMw2rVrl8aMGVPod7QuTdiVBgBA/p0+fVpTp05Vz5499ccff2jVqlUaMmSIqlSpIkkaNmyYduzYoUGDBmnIkCG68847dfnyZf3yyy+qWbOmRagqKJuDUXx8vFq3bm23AsoCdqUBAIpT+RpF+6Xl9h7v+eef17fffqsJEybI0dFRAwYM0PPPP28+X61aNW3ZskULFy7U/PnzdeXKFdWoUUMtW7bMtnC7oGwORm3atNHRo0fVrl07uxYCALbIzDTKwSHv70m0th1QWhkzM4vlLtTGzEwZ8nFlZNy4cRo3bpwky13pffv21bx583J9noeHh2bPnp2/Ym1gczB68cUXNXr0aN15553q1KkTa4wAFAsHB4OWbjqgqJj4XNvU8qyiMQM65HoeKAvyE05K87iFzeZg9PDDDys9PV0TJkyQwWCQq6urxXmDwaAffvjBbgWWBuxKA4pHVEy8/o6KK+4yAJQhNgej7t27y2BgWvqf2JUGAEDZYHMwutX1v9sVu9IAACgbuPO1HbArDQCAssGqYPTdd9+pSZMmqlixor777rs827dp06bAhQFAQVWp7GrVzpn87q4BUPZYFYwGDx6s999/Xy1atNDgwYNzXWNkNBplMBh05MgRuxYJAPlR0dVFBgcHndy5Usmx53NsU76GV7FsdQZQMlkVjMLCwtSgQQPzf8MSu9KAki059rySo08XdxkASgGrglHbtm1z/G/cwK40AADKBhZf2wG70gAAKBusCkZTp061ukODwaA5c+bku6DSiF1pAACUDVYFo0OHDlk8TkxMVGJiopycnFS1alVduXJF6enpqly5MpePAJQJfBcbcHuyKhh98cUX5v/+9ddfNW7cOM2YMUM9evSQo6OjMjIy9Mknn+iNN97QggULCq1YACgqfBcbcHuyeY3Ra6+9puHDhysoKMh8zNHRUb1791ZsbKzmzJmjzZs327VIACgOfBcbcPuxeXXw77//rkaNGuV4rlGjRjp69GiBiwKAsi4z02iXNgDsy+YZo0qVKunrr7+Wr69vtnNff/21KlWqZJfCShPuYwTAVnldquMyHVA8bA5GDz30kFavXq309HT17t1b7u7uunTpknbs2KF169Zp2LBhhVBmycZ9jADkB5fqgJLH5mD0wgsv6PLly3rvvfe0du1a83Gj0aiHHnpIL7zwgj3rKxW4jxEAAGWDzcHIyclJ8+bN0zPPPKNDhw7pypUrqlq1qtq2bWv+2pDbDfcxAgCgbMj3na/r16+v+vXr27MWAACAYpXvYBQbG6uoqCilpKRkO9emTZsCFQUAAFAcbA5GMTExmjx5svlu2Ebjje2kBoNBRqNRBoNBR44csW+VAHCbqVLZVcbMTBmsWKtobTsAebM5GP373//WkSNHFBISIm9vb7m4uBRGXQBwW6vo6iKDg4NO7lyp5NjzubYrX8NL9YJGFmFlQNlmczD69ttvNXnyZD366KOFUQ8A4B+SY88rOfp0cZcB3DZsnns1GAzy8vIqjFoAAACKlc0zRg8++KD27t2r9u3bF0Y9pRJ3vgYAoGywORj16NFDL730koxGozp37qyqVatma9O0aVN71FZqcOdrAADKBpuD0dChQyVJGzZs0MaNGy3O3a670rjzNQAAZYPNwWju3LmFUUepxp2vAQAoG2wORn369CmMOgAAAIod13oAAABMrJoxWrJkiR5//HHVrFkzx0XG/2QwGDRmzBi7FAcAAFCUrA5G/v7+BCMAAFCmWRWMjh49muN/AwAAlCWsMQIAADApcDC6evWqfvvtN0VFRdmjHgAAgGJj9Xb9L7/8Ujt37pSzs7N69+6t9u3ba+PGjZo/f76uX78uSerWrZvefPNN7uEDAABKJauC0ZdffqlRo0bJxcVFzs7O+vjjj/XSSy9p1qxZ6tChg7y9vXXkyBHt3r1bmzZt0pAhQwq7bgAAALuzKhitXr1avr6+Wr58ucqVK6dZs2Zp7ty5euKJJzRz5kxzu2nTpmn79u23XTDiS2QBACgbrApGx48f17///W+VK1dOkvT0009rw4YN6tatm0W77t276/PPP7d/lSUcXyILAEDZYFUwiouLk4eHh/mxu7u7JKlatWoW7apWrarExEQ7llc68CWyAACUDVYvvjYYDDn+N/gSWQAAygqrg9Fff/0lR0dHSVJGRob52M1tAAAASiurg9HUqVOzHZs8ebLFY6PRyGwSAAAotawKRnPnzi3sOgAAAIqdVcGoT58+hV0HAABAsWPbFAAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAUAZlJlptEsb4HZj9X2MAAClh4ODQUs3HVBUTHyO52t5VtGYAR3y1XdmplEODnnfs87adkBJQjACgDIqKiZef0fF2b3fvEKXVLDgBRQnghEAwGaFFbqA4sYaIwAAABOCEQAAgAmX0uwgJiZGFy9etDiWlpYmBwdyJwAApQnByA62bNmiJUuWZDvu5uZWDNUAAID8IhjZQb9+/RQYGGhxLDg4mBkjALetKpVdZczMlCGP34PWtAGKEsHIDjw9PeXp6WlxzNnZuZiqAYDiV9HVRQYHB53cuVLJsedzbFO+hpfqBY0s4sqAWyMYAQAKTXLseSVHny7uMgCrMX8JAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIAJwQgAAMCEYAQAAGBCMAIAADAhGAEAAJgQjAAAAEwIRgAAACYEIwAAABOCEQAAgAnBCAAAwIRgBAAAYEIwAgAAMCEYAQAAmBCMAAAATJyKu4CiFhcXp0mTJuns2bNydnZWixYtNGPGDLm4uNzyHAAAKPtuuxkjg8GgZ599Vp9++qk++ugjJScnKywsLM9zAACg7CsRwejUqVN6+eWX9fDDD6tJkyYKCgrKsd3Jkyc1YsQItWrVSr6+vpo1a5auX79u01hVq1ZVmzZtJEkODg5q1qyZzp07l+c5AABQ9pWIYBQZGamIiAjVrVtXDRo0yLFNQkKChg4dqqSkJC1atEihoaHasWOHXnzxxXyPm5KSovDwcHXq1MmmcwAAoGwqEWuMAgMD1bVrV0nSlClTdPjw4WxtNm/erISEBG3fvl3Vq1eXJDk6OiokJETBwcHmQDVgwABFR0dne36DBg20cuVK8+PMzEyFhoaqXbt28vf3t2h7q3MAAKDsKhHByMEh74mrffv2ydfX1xyKJKl79+6aNm2aIiIizMFo06ZNVo05c+ZMOTk5adq0aTadAwAAZVeJCEbWOHHihB599FGLYy4uLqpTp45OnDhhU1+vv/66oqOjtWTJEhkMBqvP3axLly65njt//ry8vLxsqgsAABSvUhOMEhIS5Obmlu24m5ub4uPjre4nMjJSq1evVv369c1Bq3379goNDb3lOQAAUPaVmmCUG6PRmOfMzj81bNhQx44ds/lcTvbs2ZPruVvNJgEAgJKpROxKs4abm5sSEhKyHU9MTMxxJgkAAMBWpSYYNWjQINtaotTUVJ0+fTrXLf4AAAC2KDWX0vz9/bVs2TLFxcWpWrVqkqTdu3crNTVVAQEBxVpbTEyMLl68aHEsLS3Nqt12AACg5CgRwSg5OVkRERGSpKioKF29elWffvqpJKlt27aqXr26+vfvrw0bNmj06NEaPXq0YmNjNW/ePPXu3bvYZ4y2bNmiJUuWZDvOJT4AsF1mplEODnmvHbW2HWCLEhGMYmNjNWHCBItjWY/DwsLk4+MjNzc3rVu3TrNmzdK4cePk6uqqoKAghYSEFEfJFvr166fAwECLY8HBwcwYAUA+ODgYtHTTAUXF5L7juJZnFY0Z0KEIq8LtokQEo9q1a1u1G6xevXpavXp1EVRkG09PT3l6elocc3Z2LqZqAKD0i4qJ199RccVdBm5DTGkAAACYlIgZo9KOxdcAAJQNBCM7YPE1AABlA8HIDlh8DQBA2UAwsgMWXwMAUDYwpQEAAGBCMAIAADDhUpodsCsNAICygWBkB+xKAwCgbCAY2QG70gCgaFWp7CpjZqYMefyetaYN8E8EIztgVxoAFK2Kri4yODjo5M6VSo49n2Ob8jW8VC9oZBFXhtKOYAQAKLWSY88rOfp0cZeBMoT5RQAAABOCEQAAgAmX0uyA7foAAJQNBCM7YLs+AABlA8HIDtiuDwBA2UAwsgO26wMAUDYwpQEAAGBCMAIAADAhGAEAAJgQjAAAAExYfG0H3McIAICygWBkB9zHCACAsoFgZAfcxwgAgLKBYGQH3McIAICygSkNAAAAE4IRAACACcEIAADAhGAEALitZGYa7doOZQuLrwEAtxUHB4OWbjqgqJj4XNvU8qyiMQM6FGFVKCkIRgCA205UTLz+joor7jJQAhGM7IA7XwMAUDYQjOyAO18DAFA2EIzsgDtfAwCyZGYa5eBgKHAbFA+CkR1w52sAQJa8FnezsLtkIxgBAGBnLO4uvbjWAwAAYEIwAgAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAABFqEplVxkzM61qa2072A/3MbIDvisNAGCtiq4uMjg46OTOlUqOPZ9ru/I1vFQvaGQRVgaJYGQXfFcaAMBWybHnlRx9urjLwE0IRnbAd6UBAFA2EIzsgO9KAwCgbGBKAwAAwIRgBAAAYEIwAgAAMCEYAQAAmBCMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYGIxGo7G4iyiLmjdvroyMDHl5eZmPXU64pvT0zBzbu7o4ya2Sq9KuXlFmRnqu/To4Osm5UtVsx2/Vt7X959a3Nf07OTmouluFXM/npTDfm8LuvzjfG6lwP9uC1p5X//zcF9/PfWn+uSyK/kvaZ+vl5aUNGzbkux5Yj2BUSFq3bq3U1FR5eHhY1f78+fOSZBGk7Kk091+aay/t/Zfm2kt7/6W5dvq3f98Eo6JDMCohunTpIknas2cP/Rdh3/RffH3Tf/H1Tf/F239h146CYY0RAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABM2K4PAABgwowRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIyK2KlTp/Tyyy/r4YcfVpMmTRQUFGS3vnft2qXRo0crICBArVq1Uu/evfWf//xHmZmZJaK/4hxr//79GjRokNq1a6dmzZqpS5cumjt3rhITE0tUn0U1Tn77/PTTT+Xt7a2zZ8+WyLEkKSkpSf7+/vL29tZvv/1m03OLor+iHMeWPvP7fhfmWNu2bZO3t3e2P/Pnz89Xjfbur6SMBftyKu4CbjeRkZGKiIhQy5YtlZmZKXveLeG9997TnXfeqcmTJ6tGjRo6dOiQZs+erTNnzig0NLTY+yvOseLj43Xfffdp6NChcnNzU2RkpBYvXqzIyEitWbOmxPRZ1mov6rEk6Z133lFGRkaJ7a8oxymq2gt7rFWrVqly5crmxzVr1ixR/ZWUsWAnRhSpjIwM83+HhoYae/XqZbe+Y2Njsx2bM2eOsXnz5saUlJRi76+kjJVly5YtxkaNGhkvXLhQovssqnGs6XPXrl3GRo0aGc+cOVMixzp+/LixVatWxk2bNhkbNWpk/PXXXwtUp737K8pxbO2zIJ9tYY314YcfGhs1apTj74f8sHd/JWUs2BczRkXMwSHvq5d79uzR0qVLdfLkSTk6OqpOnTqaMGGCAgICbvm86tWrZzvWuHFjpaSk6MqVK/L09LSpb2v6CwwMVKdOnXTnnXdq3bp1SkhIUPv27TVz5kx5enrm+VqLY6wsVatWlSSlp6dLyv/7fqs+7V1zYY5zc59paWl6/fXX9dFHHykjI0Pdu3dXmzZt8l1zUYw1e/Zs9e/fX/Xq1ct2Lj+f7636s+dnWxjj3KpPe3+2RTnWzezx9/afCuvvbHGPBesRjEqY06dPa8KECerVq5cmTpyozMxMHT16VPHx8fnq74cfflDVqlVVo0YNu/T9z/6y7N69W7Vq1dIrr7yihIQEvfnmmxo3bpy2bNmSr5oLc6yMjAylp6fr+PHjWrp0qTp37qxatWoV6L3JrU971VyY49yqz7feekubNm3SuHHj1KRJE+3cuVMLFiywqeaiHOvTTz/V0aNHtWjRIv3+++8W5/Lz+d6qvyz2+GwLY5y8+rTnZ1sUYwUFBSkuLk533nmnnnjiCT399NNydHTM99/b3PrLYs/faUU5FuykuKesbmc5XUrLmmJOTEwscP+//vqrsUmTJsalS5fape+b+zMajcbOnTsb77vvPmN8fLz52Ndff21s1KiRcf/+/Xar3V5j+fn5GRs1amRs1KiRccSIEcakpCSj0Viw9ya3Pu1Vc2GOk1ufcXFxxhYtWhgXLlxo0b5fv375vtxSmGNdu3bNGBAQYPzggw+MRqPRePDgQYtLOrZ+vnn1ZzTa57MtjHHy6tOen21hj7Vv3z7j4sWLjfv27TPu37/fOHPmTOO9995rnDlzptFotP1zzas/o9F+f2eLcizYF7vSShhvb285OjoqJCREX3zxRb53Hl28eFHjx49X8+bNNXLkyAL3nVN/WXx8fOTm5mZ+7Ovrq0qVKunnn3+W9P8zBVl/jHksOC/IWHlZsWKFNm3apH//+986fvy4Ro0apYyMjAK9N7n1aW3N1r4/BR3Hlj7//PNPXb9+Xd26dbNo3717d4vHtny2BR3rVpYtW6YaNWqob9++OZ639fPNq78sBf1s7TWOLX3a87O111i58fPz09ixY+Xn56eOHTvq5Zdf1rBhw7R582bFxMTY/Lnm1V8We/ydtddYKHoEoxKmXr16Wr58uRITEzV27Fj5+vpq1KhROnfunNV9JCYmauTIkXJ1ddWyZcvk7OxcoL5z6y/LPy91/fPYxYsXJUnDhg1T06ZNzX++/fbbQhsrL/fee6/uv/9+PfHEE1qyZIkOHTqk3bt3F+h9z61Pa2u29v0p6Di29Jn1nJv7vPmxLZ9tQcfKTVRUlNasWaPx48fr6tWrSkhI0LVr1yRJ165dU1JSkk2frzX93apGaz9be45jS5/2+mztOZYtevTooYyMDB05csQuvy//2d+t6svv77SCjoWixxqjEsjf31/+/v66evWq9u3bp7lz52rq1Klat25dns9NSUlRcHCwLl26pC1btqhatWoF6juv/iQpNjY2x2MeHh6SpJkzZ1r8ks9pgaa9xrJF48aNzesUpIK977n1aU3N1r4/BR3Hlj5btWplfv4/txffPEZ+as/vWLk5e/as0tLS9Mwzz2Q7N2TIELVs2VLvv/++1Z+vtf3lVqO1n609x7Glz5CQEPPzC/LZ2nOsgrDH39ubFcbf2fyOhaJHMCrBKlWqpJ49e+rXX3/Vzp0782yfnp6uCRMm6OjRo9qwYYPFwtz89G1tf4cOHVJiYqL5Xh3ffPONrl69qpYtW0qS6tevb7fa8xrLFj/99JMyMjJUu3Zti+O2vu959WmP98ce49jSZ6NGjeTq6qrdu3erSZMm5jb/+9//LJ6Tn9rzO1ZuGjdurLCwMItjR44c0dy5czVz5kw1b97c4lxen68t/RXks7XnOLb0WatWLbt8tvYcyxaffPKJHB0dLfqT8v/3Nqf+CuPvbH7HQtEjGBWx5ORkRURESLoxFX316lV9+umnkqS2bdvqs88+008//SR/f395eHjo7Nmz+vjjj9WhQ4c8+3711Ve1d+9eTZo0SdevX7e4Rn3PPfdo586dNvWdV3+VKlWSJFWsWFEjR47UyJEjlZiYqPnz56tFixby8/Oz+n0p7LHGjh2rZs2aydvbW66urjp69KhWrVolb29vde3aVZs3b7b5fc+rzywFfX8KY5y8+nRxcVH//v21cuVKubq6mncT2XKJoqjGcnNzk4+PT47nsi512PL5WtNfloJ8toUxjrV92uOzLYqxRowYoXbt2qlRo0aSbmzNf//99zVkyBB5eHjY/Pc2r/6y2ON3WlGOBfsiGBWx2NhYTZgwweJY1uOwsDB5e3tr7969mjt3rq5cuSIPDw/16tUr23Ny8tVXX0mS3njjjWzn8tN3Xv1l/VLs1q2b7rjjDs2YMcPiPhy2KOyxWrRooU8++UQrVqyQ0WhUrVq19MQTT2jEiBFycXHJ1/ueV59ZCvr+FMY41vQ5ceJEZWRkaNWqVcrMzFS3bt303HPPaerUqVbXXtRj5aYgf69uxR4/+8UxTmG/3/Yaq169etq6dasuXLigzMxM3X333Zo2bZoGDx4syfbPNa/+stjj/S7KsWBfBmNeW4SAW8i6QdnLL79cpsayl6KquTS+N6Udn23ZxO80sCsNAADAhGAEAABgwqU0AAAAE2aMAAAATAhGAAAAJgQjAAAAE4IRAACACcEIuI398ssvGjNmjDp16qRmzZqpffv26tevn+bNm2dzX9u2bZO3t7d+++03u9Tm7e2tV1991S59STe+28vb21vbtm0zH8uq+ezZs3YbB0Dpxp2vgdvUl19+qeDgYLVt21aTJk2Sh4eHLl68qMOHD+u///2vpkyZUtwlAkCRIxgBt6lVq1apdu3aWr16tZyc/v9XQa9evTRp0qRirAwAig+X0oDb1JUrV1StWjWLUJTFweH/fzV4e3tr8eLF2doEBgbmOKuUkJCgqVOnqm3btmrVqpVGjRqlM2fOWLT5448/9Oyzz8rX11fNmjVTx44d9cwzz+jChQvZ+tu+fbt69Oihli1b6qGHHtLevXuztfn77781ceJEc389evTQxo0brXofAOCfCEbAbapVq1b65ZdfNGvWLP3yyy9KS0uzS7/Tp0+XwWDQ/PnzNW3aNP36668aPHiwEhISJEnXrl3TU089pUuXLunll1/We++9p2nTpsnLy0tJSUkWfX355ZfauHGjxo8fr0WLFqlKlSoaO3asRdA6fvy4HnvsMf35558KDQ3Vu+++q06dOmnWrFlasmSJXV4TgNsHl9KA29TEiRP1119/af369Vq/fr2cnZ3VrFkzBQYG6sknn1TFihXz1W+zZs00Z84c8+N77rlHAwYM0MaNGxUcHKy//vpLV65c0ezZs9W1a1dzu549e2brKyUlRe+9954qVaokSWratKn8/Py0a9cuPfPMM5KkuXPnqmLFitq0aZO5XYcOHZSamqoVK1Zo8ODBqlKlSr5eC4DbDzNGwG2qWrVq+s9//qOtW7dq4sSJCgwM1N9//60333xTvXv31uXLl/PVb+/evS0e33///apVq5YOHTokSapbt66qVKmi+fPna9OmTTp+/Hiuffn4+JjDjiS5u7urRo0aioqKknQjOB08eFDdunWTq6ur0tPTzX/8/f2VkpKin3/+OV+vA8DtiRkj4DbXvHlzNW/eXJKUlpam+fPna+3atVq1apUmT55sc3/u7u45Hrty5YokqXLlylq/fr2WL1+uBQsWKD4+Xh4eHnriiScUHBwsZ2dn8/OqVq2arS8XFxelpKRIurFOKj093TzrlZO4uDibXwOA2xfBCICZs7Ozxo4dq7Vr1yoyMlLSjSCSmpqarW1ugePSpUs5HqtTp475sbe3txYsWCCj0ahjx45p27ZtWrp0qVxdXc2XyKzh5uYmR0dHPfzwwxo4cGCObWrXrm11fwBAMAJuUzExMfL09Mx2/MSJE5JkPlerVi0dO3bMos0333yja9eu5djvjh071L17d/PjH3/8UVFRUXrssceytTUYDLr33ns1bdo0hYeH6/fff7fpNZQvX14+Pj76448/5O3tLRcXF5ueDwA3IxgBt6kRI0bojjvuUOfOnVW/fn0ZjUYdOXJEa9asUYUKFTRkyBBJ0sMPP6y3335bb7/9ttq2bavjx49rw4YNqly5co79Hj58WNOnT9eDDz6oCxcuaMGCBapZs6Z5Rmfv3r36z3/+o65du+quu+6S0WjUZ599poSEBHXo0MHm1zF9+nQNHDhQTz75pAYMGKBatWopKSlJp0+f1hdffKGwsLD8v0kAbjsEI+A2FRwcrD179mjdunWKiYlRWlqaPDw81L59ez377LNq0KCBpBsB6urVqwoPD9eaNWvUokULvf322xo9enSO/c6ePVsfffSRXnjhBaWmpsrHx0fTp083rxeqW7eu3NzctGrVKsXExMjZ2Vn16tXTvHnz1KdPH5tfxz333KNt27bpnXfe0cKFC3X58mVVrlxZdevWVUBAQL7fHwC3J4PRaDQWdxEAAAAlAdv1AQAATAhGAAAAJgQjAAAAE4IRAACACcEIAADAhGAEAABgQjACAAAwIRgBAACYEIwAAABMCEYAAAAmBCMAAAATghEAAIDJ/wG/hifJe7ZUcwAAAABJRU5ErkJggg==", + "image/png": "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", "text/plain": [ "
" ] @@ -855,22 +863,22 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 18, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] From c71e0c67103799c5aed45d0883e9e5a164606aab Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:58:35 +0200 Subject: [PATCH 72/94] Revert "Update pytest.yml" This reverts commit 180e3917d89942a9cf7b5fbb7425335ee7a12011. These commits have been cherry-picked from another branch. --- .github/workflows/pytest.yml | 1 - 1 file changed, 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index ecb4de8..709af4e 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -48,7 +48,6 @@ jobs: # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . - pip install seaborn matplotlib - name: Test package if: matrix.test == 'pytest' run: From 17146272ccb440b7bcdd79d56d04f4ed8a443f4f Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:12 +0200 Subject: [PATCH 73/94] Revert "Update pytest.yml" This reverts commit d2b44da4b3feab7a4de221181e0def3f0e09947f. --- .github/workflows/pytest.yml | 2 -- 1 file changed, 2 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 709af4e..bb381c7 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -34,8 +34,6 @@ jobs: python-version: ${{ matrix.python-version }} - name: Checkout repo uses: actions/checkout@v4 - with: - submodules: 'recursive' - name: Install requirements for tests run: | pip install --upgrade pip From 07ca8baee2082f38179ab08121b4168b99872a59 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:15 +0200 Subject: [PATCH 74/94] Revert "Downgrade jinja for pytest.yml" This reverts commit a7c2e0d71bc5a9a98d0f36b4cf47aa01edafc655. --- .github/workflows/pytest.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index bb381c7..3094b2d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -41,11 +41,11 @@ jobs: pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython - pip install jinja2==3.0.3 pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax pip install -e . + pip install -U jinja2 - name: Test package if: matrix.test == 'pytest' run: From 5955350d5ea0fc7ec8e78f48799b40d27d4e2a01 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:16 +0200 Subject: [PATCH 75/94] Revert "Update pytest.yml + fix test" This reverts commit c1d26c0a11731353d888207de172ca3b95529880. --- .github/workflows/pytest.yml | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 3094b2d..48cc63d 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -29,23 +29,19 @@ jobs: test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5 + uses: actions/setup-python@v5.1.1 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4 + uses: actions/checkout@v4.1.7 - name: Install requirements for tests run: | - pip install --upgrade pip - # Require setuptools for python3.12 as well - pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax - pip install -e . - pip install -U jinja2 + python setup.py develop - name: Test package if: matrix.test == 'pytest' run: From 30332476a4134c96b294a710409af6d178c06914 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 8 Aug 2024 17:59:17 +0200 Subject: [PATCH 76/94] Revert "Update pytest.yml" This reverts commit df7d904c2b6045359c0aea0c41e3da88e5a13d88. --- .github/workflows/pytest.yml | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 48cc63d..402bbaf 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -19,21 +19,19 @@ jobs: # Test coveralls (with numba disabled) and normal pytest test: [ 'coveralls', 'pytest', ] # Only do coveralls once; pytest on all python versions - python-version: [3.9, "3.10", "3.11", "3.12"] + python-version: [3.8, 3.9, "3.10"] exclude: - - python-version: 3.10 + - python-version: 3.8 test: coveralls - - python-version: 3.11 - test: coveralls - - python-version: 3.12 + - python-version: 3.9 test: coveralls steps: - name: Setup python - uses: actions/setup-python@v5.1.1 + uses: actions/setup-python@v4 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v4.1.7 + uses: actions/checkout@v3 - name: Install requirements for tests run: | # Requirements for running the notebooks as a pytest From 5286f6c3a7f188856a9d34ea1c42e7ece0df29d2 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Fri, 9 Aug 2024 13:41:06 +0200 Subject: [PATCH 77/94] Rebase on update_cicd --- .github/workflows/pytest.yml | 21 +++++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/.github/workflows/pytest.yml b/.github/workflows/pytest.yml index 402bbaf..ecb4de8 100755 --- a/.github/workflows/pytest.yml +++ b/.github/workflows/pytest.yml @@ -19,27 +19,36 @@ jobs: # Test coveralls (with numba disabled) and normal pytest test: [ 'coveralls', 'pytest', ] # Only do coveralls once; pytest on all python versions - python-version: [3.8, 3.9, "3.10"] + python-version: [3.9, "3.10", "3.11", "3.12"] exclude: - - python-version: 3.8 + - python-version: 3.10 test: coveralls - - python-version: 3.9 + - python-version: 3.11 + test: coveralls + - python-version: 3.12 test: coveralls steps: - name: Setup python - uses: actions/setup-python@v4 + uses: actions/setup-python@v5 with: python-version: ${{ matrix.python-version }} - name: Checkout repo - uses: actions/checkout@v3 + uses: actions/checkout@v4 + with: + submodules: 'recursive' - name: Install requirements for tests run: | + pip install --upgrade pip + # Require setuptools for python3.12 as well + pip install setuptools # Requirements for running the notebooks as a pytest pip install cython ipython + pip install jinja2==3.0.3 pip install nbconvert nbmake pytest-xdist pytest coverage coveralls pytest-cov pytest-notebook ipython_genutils # Several optional packages that are imported in the notebooks pip install git+https://github.com/XENON1T/laidbax - python setup.py develop + pip install -e . + pip install seaborn matplotlib - name: Test package if: matrix.test == 'pytest' run: From 22e9ffe9d84221ff0dfa2b1b1e296f8f7f50a25b Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 17:00:54 +0200 Subject: [PATCH 78/94] Round j2000_to_datetime output to fix pytest --- wimprates/halo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/halo.py b/wimprates/halo.py index bf6b33b..78110db 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -77,7 +77,7 @@ def j2000_to_datetime(j2000_date): nanoseconds_per_day = nu.day / nu.ns _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value - return pd.to_datetime(_date + zero_value) + return pd.to_datetime(_date + zero_value).round("ns") @export def earth_velocity(t, v_0 = None): From c071c3b5cf7b87ae64141828ea5fe7a6707280e3 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 17:14:03 +0200 Subject: [PATCH 79/94] Reduce precision of j2000_to_datetime return to seconds --- wimprates/halo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/halo.py b/wimprates/halo.py index 78110db..6be8351 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -77,7 +77,7 @@ def j2000_to_datetime(j2000_date): nanoseconds_per_day = nu.day / nu.ns _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value - return pd.to_datetime(_date + zero_value).round("ns") + return pd.to_datetime(_date + zero_value).round("s") @export def earth_velocity(t, v_0 = None): From cfbd5de16feb29ddd5ab5555f5b18633b959b5f1 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:14:58 +0200 Subject: [PATCH 80/94] Ignore notebooks in root dir --- .gitignore | 3 +++ 1 file changed, 3 insertions(+) diff --git a/.gitignore b/.gitignore index cddca21..10addf7 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1,6 @@ +# Notebooks in root dir +/*.ipynb + # Byte-compiled / optimized / DLL files __pycache__/ *.py[cod] From 22e70fa4aa49eea4c18b9447786a8d4aafcfd69b Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 21:09:32 +0200 Subject: [PATCH 81/94] Remove overhead on import Refactored a bit the code here to remove expensive and unutilised computation on import of wimprates --- wimprates/electron.py | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/wimprates/electron.py b/wimprates/electron.py index b86a4a1..90c3e0a 100644 --- a/wimprates/electron.py +++ b/wimprates/electron.py @@ -1,5 +1,6 @@ """Dark matter - electron scattering """ +from functools import lru_cache import numericalunits as nu import numpy as np from scipy.interpolate import RegularGridInterpolator, interp1d @@ -9,13 +10,17 @@ export, __all__ = wr.exporter() __all__ += ['dme_shells', 'l_to_letter', 'l_to_number'] -# Load form factor and construct interpolators -shell_data = wr.load_pickle('dme/dme_ionization_ff.pkl') -for _shell, _sd in shell_data.items(): - _sd['log10ffsquared_itp'] = RegularGridInterpolator( - (_sd['lnks'], _sd['lnqs']), - np.log10(_sd['ffsquared']), - bounds_error=False, fill_value=-float('inf'),) + +@lru_cache() +def get_shell_data(): + """Load form factor and construct interpolators""" + shell_data = wr.load_pickle('dme/dme_ionization_ff.pkl') + for _shell, _sd in shell_data.items(): + _sd['log10ffsquared_itp'] = RegularGridInterpolator( + (_sd['lnks'], _sd['lnqs']), + np.log10(_sd['ffsquared']), + bounds_error=False, fill_value=-float('inf'),) + return shell_data dme_shells = [(5, 1), (5, 0), (4, 2), (4, 1), (4, 0)] @@ -54,6 +59,9 @@ def dme_ionization_ff(shell, e_er, q): # Ry = rydberg = 13.6 eV ry = nu.me * nu.e ** 4 / (8 * nu.eps0 ** 2 * nu.hPlanck ** 2) lnk = np.log(e_er / ry) / 2 + + shell_data = get_shell_data() + return 10**(shell_data[shell]['log10ffsquared_itp']( np.vstack([lnk, lnq]).T)) @@ -84,8 +92,8 @@ def v_min_dme(eb, erec, q, mw): return (erec + eb) / q + q / (2 * mw) -# Precompute velocity integrals for t=None @export +@lru_cache() def velocity_integral_without_time(halo_model=None): halo_model = wr.StandardHaloModel() if halo_model is None else halo_model _v_mins = np.linspace(0, 1, 1000) * wr.v_max(None, halo_model.v_esc) @@ -105,7 +113,6 @@ def velocity_integral_without_time(halo_model=None): fill_value=0, bounds_error=False) return inverse_mean_speed_kms -inverse_mean_speed_kms = velocity_integral_without_time() @export @@ -141,9 +148,12 @@ def rate_dme(erec, n, l, mw, sigma_dme, # No bounds are given for the q integral # but the form factors are only specified in a limited range of q + shell_data = get_shell_data() qmax = (np.exp(shell_data[shell]['lnqs'].max()) * (nu.me * nu.c0 * nu.alphaFS)) + # Precompute velocity integrals for t=None + inverse_mean_speed_kms = velocity_integral_without_time() if t is None: # Use precomputed inverse mean speed, # so we only have to do a single integral From 3ab6231dd1fcfd2da24cdad1645ecd08135ddbc4 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:05:50 +0200 Subject: [PATCH 82/94] Implement optional multiprocessing for Migdal --- wimprates/migdal.py | 241 +++++++++++++++++++++++++++----------------- 1 file changed, 150 insertions(+), 91 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 6c23e4b..a4219f4 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -10,6 +10,7 @@ """ from collections.abc import Callable +from concurrent.futures import ProcessPoolExecutor from dataclasses import dataclass from typing import Any, Optional, Union @@ -17,6 +18,7 @@ from functools import lru_cache import numericalunits as nu import numpy as np +from tqdm.autonotebook import tqdm import pandas as pd from scipy.integrate import dblquad from scipy.interpolate import interp1d @@ -68,7 +70,7 @@ def l(self) -> str: return self.name[1:] -def _default_shells(material: str) -> list[str]: +def _default_shells(material: str) -> tuple[str]: """ Returns the default shells to consider for a given material. Args: @@ -88,45 +90,25 @@ def _default_shells(material: str) -> list[str]: Ge=["3*"], Si=["2*"], ) - return consider_shells[material] + return tuple(consider_shells[material]) -def create_cox_probability_function( - element, - state: str, - material: str, +def _create_cox_probability_function( + element: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) - def get_probability( - e: Union[float, np.ndarray], # energy of released electron - erec: Optional[Union[float, np.ndarray]] = None, # recoil energy - v: Optional[Union[float, np.ndarray]] = None, # recoil speed - ) -> np.ndarray: - if erec is None: - if v is None: - raise ValueError("Either v or erec have to be provided") - elif v is None: - v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 - else: - raise ValueError("Either v or erec have to be provided") - - e /= nu.keV - - input_points = wr.pairwise_log_transform(e, v) - return fn(input_points, state) / nu.keV # type: ignore - - return get_probability + return fn @export def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", - considered_shells: Optional[Union[list[str], str]] = None, + considered_shells: Optional[Union[tuple[str], str]] = None, dark_matter: bool = True, e_threshold: Optional[float] = None, dipole: bool = False, @@ -193,6 +175,7 @@ def get_migdal_transitions_probability_iterators( dipole=dipole, dark_matter=dark_matter, e_threshold=e_threshold, + **kwargs ) for state, binding_e in element.orbitals: @@ -205,10 +188,8 @@ def get_migdal_transitions_probability_iterators( material, binding_e * nu.keV, model, - single_ionization_probability=create_cox_probability_function( + single_ionization_probability=_create_cox_probability_function( element, - state, - material, dipole=dipole, ), ) @@ -230,10 +211,92 @@ def vmin_migdal( return np.maximum(0, y) +def get_diff_rate( + w: float, + shells: list[Shell], + mw: float, + sigma_nucleon: float, + halo_model: wr.StandardHaloModel, + interaction: str, + m_med: float, + migdal_model: str, + include_approx_nr: bool, + q_nr: float, + material: str, + t: Optional[float], + **kwargs, +): + result = 0 + for shell in shells: + + def diff_rate(v, erec): + # Observed energy = energy of emitted electron + # + binding energy of state + eelec = w - shell.binding_e - include_approx_nr * erec * q_nr + if eelec < 0: + return 0 + + if migdal_model == "Ibe": + return ( + # Usual elastic differential rate, + # common constants follow at end + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + # Migdal effect |Z|^2 + # TODO: ?? what is explicit (eV/c)**2 doing here? + * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) + ** 2 + / (2 * np.pi) + * shell(eelec) + ) + elif migdal_model == "Cox": + vrec = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 + input_points = wr.pairwise_log_transform(eelec/nu.keV, vrec) + return ( + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + * shell(input_points, shell.name) / nu.keV + ) + + # Note dblquad expects the function to be f(y, x), not f(x, y)... + result += dblquad( + diff_rate, + 0, + wr.e_max(mw, wr.v_max(t, halo_model.v_esc), wr.mn(material)), + lambda erec: vmin_migdal( + w=w - include_approx_nr * erec * q_nr, + erec=erec, + mw=mw, + material=material, + ), + lambda _: wr.v_max(t, halo_model.v_esc), + **kwargs, + )[0] + + return result + + @export -@wr.vectorize_first def rate_migdal( - w: np.ndarray, + w: Union[np.ndarray, float], mw: float, sigma_nucleon: float, interaction: str = "SI", @@ -243,11 +306,13 @@ def rate_migdal( material: str = "Xe", t: Optional[float] = None, halo_model: Optional[wr.StandardHaloModel] = None, - consider_shells: Optional[list[str]] = None, + consider_shells: Optional[tuple[str]] = None, migdal_model: str = "Ibe", dark_matter: bool = True, dipole: bool = False, e_threshold: Optional[float] = None, + progress_bar: bool = False, + multi_process: Optional[Union[bool, int]] = True, **kwargs, ) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of @@ -279,8 +344,21 @@ def rate_migdal( Further kwargs are passed to scipy.integrate.quad numeric integrator (e.g. error tolerance). """ + _is_array = True + if not isinstance(w, np.ndarray): + if isinstance(w, float): + _is_array = False + w = np.array([w]) + else: + raise ValueError("w must be a float or a numpy array") + halo_model = wr.StandardHaloModel() if halo_model is None else halo_model + if progress_bar: + prog_bar = tqdm + else: + prog_bar = lambda x, *args, **kwargs: x + if not consider_shells: consider_shells = _default_shells(material) @@ -293,72 +371,53 @@ def rate_migdal( dark_matter=dark_matter, ) - result = 0 - for shell in shells: - - def diff_rate(v, erec): - # Observed energy = energy of emitted electron - # + binding energy of state - eelec = w - shell.binding_e - include_approx_nr * erec * q_nr - if eelec < 0: - return 0 - - if migdal_model == "Ibe": - return ( - # Usual elastic differential rate, - # common constants follow at end - wr.sigma_erec( - erec, - v, - mw, - sigma_nucleon, - interaction, - m_med=m_med, - material=material, - ) - * v - * halo_model.velocity_dist(v, t) - # Migdal effect |Z|^2 - # TODO: ?? what is explicit (eV/c)**2 doing here? - * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) - ** 2 - / (2 * np.pi) - * shell(eelec) - ) - elif migdal_model == "Cox": - return ( - wr.sigma_erec( - erec, - v, + results = [] + if multi_process and not dipole: + multi_process = None if isinstance(multi_process, bool) else multi_process + with ProcessPoolExecutor(multi_process) as executor: + futures = [] + for val in w: + futures.append( + executor.submit( + get_diff_rate, + val, + shells, mw, sigma_nucleon, + halo_model, interaction, - m_med=m_med, - material=material, + m_med, + migdal_model, + include_approx_nr, + q_nr, + material, + t, ) - * v - * halo_model.velocity_dist(v, t) - * shell(eelec, erec) ) - # Note dblquad expects the function to be f(y, x), not f(x, y)... - r = dblquad( - diff_rate, - 0, - wr.e_max(mw, wr.v_max(t, halo_model.v_esc), wr.mn(material)), - lambda erec: vmin_migdal( - w=w - include_approx_nr * erec * q_nr, - erec=erec, - mw=mw, - material=material, - ), - lambda _: wr.v_max(t, halo_model.v_esc), - **kwargs, - )[0] - - result += r + for future in prog_bar(futures, desc="Computing rates"): + results.append(future.result()) + else: + for val in prog_bar(w, desc="Computing rates"): + results.append( + get_diff_rate( + val, + shells, + mw, + sigma_nucleon, + halo_model, + interaction, + m_med, + migdal_model, + include_approx_nr, + q_nr, + material, + t, + ) + ) - return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + results = np.array(results) if _is_array else float(results[0]) + return halo_model.rho_dm / mw * (1 / wr.mn(material)) * results @wr.deprecated("Use get_migdal_transitions_probability_iterators instead") From 411bfd60479ccaa6f79c34fdd3ce077c7b9b3081 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:07:51 +0200 Subject: [PATCH 83/94] Make Multiprocessing loop more Pythonic --- wimprates/migdal.py | 56 +++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 27 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index a4219f4..0af6b6a 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -12,10 +12,11 @@ from collections.abc import Callable from concurrent.futures import ProcessPoolExecutor from dataclasses import dataclass +import os from typing import Any, Optional, Union from fnmatch import fnmatch -from functools import lru_cache +from functools import lru_cache, partial import numericalunits as nu import numpy as np from tqdm.autonotebook import tqdm @@ -312,7 +313,7 @@ def rate_migdal( dipole: bool = False, e_threshold: Optional[float] = None, progress_bar: bool = False, - multi_process: Optional[Union[bool, int]] = True, + multi_processing: Optional[Union[bool, int]] = True, **kwargs, ) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of @@ -371,33 +372,34 @@ def rate_migdal( dark_matter=dark_matter, ) - results = [] - if multi_process and not dipole: - multi_process = None if isinstance(multi_process, bool) else multi_process - with ProcessPoolExecutor(multi_process) as executor: - futures = [] - for val in w: - futures.append( - executor.submit( - get_diff_rate, - val, - shells, - mw, - sigma_nucleon, - halo_model, - interaction, - m_med, - migdal_model, - include_approx_nr, - q_nr, - material, - t, - ) - ) + if multi_processing and not dipole: + multi_processing = None if isinstance(multi_processing, bool) else multi_processing + with ProcessPoolExecutor(multi_processing) as executor: + partial_get_diff_rate = partial( + get_diff_rate, + shells=shells, + mw=mw, + sigma_nucleon=sigma_nucleon, + halo_model=halo_model, + interaction=interaction, + m_med=m_med, + migdal_model=migdal_model, + include_approx_nr=include_approx_nr, + q_nr=q_nr, + material=material, + t=t, + ) - for future in prog_bar(futures, desc="Computing rates"): - results.append(future.result()) + n_workers = os.cpu_count() if multi_processing is None else multi_processing + results = list( + prog_bar( + executor.map(partial_get_diff_rate, w), + desc=f"Computing rates (MP={n_workers} workers)", + total=len(w), + ) + ) else: + results = [] for val in prog_bar(w, desc="Computing rates"): results.append( get_diff_rate( From a0e4d871e6ac3f5b9ab687c66f0016741a9e7cf4 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:08:57 +0200 Subject: [PATCH 84/94] Cache Cox Model instance during runtime --- wimprates/data/migdal/Cox/cox_wrapper.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index 67dd5f6..7743eef 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -5,17 +5,18 @@ The working directory is then reset. """ +from functools import lru_cache import os import sys -import wimprates as wr - from .cox_submodule.Migdal import Migdal +import wimprates as wr export, __all__ = wr.exporter() @export +@lru_cache def cox_migdal_model(element: str, **kwargs) -> Migdal: """ This function creates a Cox Migdal model for a given element. From 8e6c5959a2e8c416806de0e4c2b341edde548d02 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:11:20 +0200 Subject: [PATCH 85/94] Add caching functionality to save and load results --- tests/test_wimprates.py | 2 ++ wimprates/summary.py | 2 ++ wimprates/utils.py | 61 ++++++++++++++++++++++++++++++++++++++++- 3 files changed, 64 insertions(+), 1 deletion(-) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index ac1fd9d..727d5f8 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -14,6 +14,8 @@ class TestBenchmarks(unittest.TestCase): opts = dict(mw=50, sigma_nucleon=1e-45, + save_cache=False, + load_cache=False, ) def test_elastic(self): ref = 30.39515403337126 diff --git a/wimprates/summary.py b/wimprates/summary.py index 8ac5c5c..33a92d9 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -2,12 +2,14 @@ Summary functions """ import numericalunits as nu +nu.reset_units(42) # Comment this line this when debugging dimensional analysis errors import wimprates as wr export, __all__ = wr.exporter() @export +@wr.save_result def rate_wimp(es, mw, sigma_nucleon, interaction='SI', detection_mechanism='elastic_nr', m_med=float('inf'), t=None, halo_model=None, diff --git a/wimprates/utils.py b/wimprates/utils.py index 890fb38..5be1768 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -1,13 +1,17 @@ import functools +import hashlib import inspect import os import pickle +from typing import Any, Callable import warnings from boltons.funcutils import wraps import numpy as np from tqdm.autonotebook import tqdm +import wimprates as wr + def exporter(): """Export utility modified from https://stackoverflow.com/a/41895194 @@ -108,6 +112,7 @@ def pairwise_log_transform(a, b): arr = np.concatenate((a, b), axis=1) return np.log(arr) + @export def deprecated(reason): """ @@ -124,4 +129,58 @@ def new_func(*args, **kwargs): ) return func(*args, **kwargs) return new_func - return decorator \ No newline at end of file + return decorator + + +def _generate_hash(*args, **kwargs): + # Create a string with the arguments and module version + + args_str = wr.__version__ + str(args) + + # Add keyword arguments to the string + args_str += "".join( + [f"{key}{kwargs[key]}" for key in sorted(kwargs) if key != "progress_bar"] + ) + + # Generate a SHA-256 hash + return hashlib.sha256(args_str.encode()).hexdigest() + + +@export +def save_result(func: Callable) -> Callable[..., Any]: + @wraps(func) + def wrapper( + *args, cache_dir: str="wimprates_cache", save_cache: bool=True, load_cache: bool=True, **kwargs + ): + # Define the cache directory + CACHE_DIR = cache_dir + + # Generate the hash based on function arguments and module version + func_name = func.__name__ + cache_key = _generate_hash(*args, **kwargs) + + # Define the path to the cache file + cache_file = os.path.join(CACHE_DIR, f"{func_name}_{cache_key}.pkl") + + # Check if the result is already cached + if load_cache and os.path.exists(cache_file): + with open(cache_file, "rb") as f: + print("Loading from cache: ", cache_file) + return pickle.load(f) + + # Compute the result + result = func(*args, **kwargs) + + if save_cache: + # Ensure cache directory exists + if not os.path.exists(CACHE_DIR): + os.makedirs(CACHE_DIR) + + # Save the result to the cache + with open(cache_file, "wb") as f: + pickle.dump(result, f) + print("Result saved to cache: ", cache_file) + + return result + + return wrapper From 3996166735436aff37cbb9fa39470946c5f5eda9 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 17:00:54 +0200 Subject: [PATCH 86/94] Round j2000_to_datetime output to fix pytest --- wimprates/halo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/halo.py b/wimprates/halo.py index bf6b33b..78110db 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -77,7 +77,7 @@ def j2000_to_datetime(j2000_date): nanoseconds_per_day = nu.day / nu.ns _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value - return pd.to_datetime(_date + zero_value) + return pd.to_datetime(_date + zero_value).round("ns") @export def earth_velocity(t, v_0 = None): From 98c52f5dab95a2b06db8598251961ef73b761ede Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 17:14:03 +0200 Subject: [PATCH 87/94] Reduce precision of j2000_to_datetime return to seconds --- wimprates/halo.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/wimprates/halo.py b/wimprates/halo.py index 78110db..6be8351 100644 --- a/wimprates/halo.py +++ b/wimprates/halo.py @@ -77,7 +77,7 @@ def j2000_to_datetime(j2000_date): nanoseconds_per_day = nu.day / nu.ns _date = pd.to_datetime(j2000_date * nanoseconds_per_day).value - return pd.to_datetime(_date + zero_value).round("ns") + return pd.to_datetime(_date + zero_value).round("s") @export def earth_velocity(t, v_0 = None): From f25c5ff612ae817dce5d71fde4d73f9ef59bf215 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 21:09:32 +0200 Subject: [PATCH 88/94] Remove overhead on import Refactored a bit the code here to remove expensive and unutilised computation on import of wimprates --- wimprates/electron.py | 28 +++++++++++++++++++--------- 1 file changed, 19 insertions(+), 9 deletions(-) diff --git a/wimprates/electron.py b/wimprates/electron.py index b86a4a1..90c3e0a 100644 --- a/wimprates/electron.py +++ b/wimprates/electron.py @@ -1,5 +1,6 @@ """Dark matter - electron scattering """ +from functools import lru_cache import numericalunits as nu import numpy as np from scipy.interpolate import RegularGridInterpolator, interp1d @@ -9,13 +10,17 @@ export, __all__ = wr.exporter() __all__ += ['dme_shells', 'l_to_letter', 'l_to_number'] -# Load form factor and construct interpolators -shell_data = wr.load_pickle('dme/dme_ionization_ff.pkl') -for _shell, _sd in shell_data.items(): - _sd['log10ffsquared_itp'] = RegularGridInterpolator( - (_sd['lnks'], _sd['lnqs']), - np.log10(_sd['ffsquared']), - bounds_error=False, fill_value=-float('inf'),) + +@lru_cache() +def get_shell_data(): + """Load form factor and construct interpolators""" + shell_data = wr.load_pickle('dme/dme_ionization_ff.pkl') + for _shell, _sd in shell_data.items(): + _sd['log10ffsquared_itp'] = RegularGridInterpolator( + (_sd['lnks'], _sd['lnqs']), + np.log10(_sd['ffsquared']), + bounds_error=False, fill_value=-float('inf'),) + return shell_data dme_shells = [(5, 1), (5, 0), (4, 2), (4, 1), (4, 0)] @@ -54,6 +59,9 @@ def dme_ionization_ff(shell, e_er, q): # Ry = rydberg = 13.6 eV ry = nu.me * nu.e ** 4 / (8 * nu.eps0 ** 2 * nu.hPlanck ** 2) lnk = np.log(e_er / ry) / 2 + + shell_data = get_shell_data() + return 10**(shell_data[shell]['log10ffsquared_itp']( np.vstack([lnk, lnq]).T)) @@ -84,8 +92,8 @@ def v_min_dme(eb, erec, q, mw): return (erec + eb) / q + q / (2 * mw) -# Precompute velocity integrals for t=None @export +@lru_cache() def velocity_integral_without_time(halo_model=None): halo_model = wr.StandardHaloModel() if halo_model is None else halo_model _v_mins = np.linspace(0, 1, 1000) * wr.v_max(None, halo_model.v_esc) @@ -105,7 +113,6 @@ def velocity_integral_without_time(halo_model=None): fill_value=0, bounds_error=False) return inverse_mean_speed_kms -inverse_mean_speed_kms = velocity_integral_without_time() @export @@ -141,9 +148,12 @@ def rate_dme(erec, n, l, mw, sigma_dme, # No bounds are given for the q integral # but the form factors are only specified in a limited range of q + shell_data = get_shell_data() qmax = (np.exp(shell_data[shell]['lnqs'].max()) * (nu.me * nu.c0 * nu.alphaFS)) + # Precompute velocity integrals for t=None + inverse_mean_speed_kms = velocity_integral_without_time() if t is None: # Use precomputed inverse mean speed, # so we only have to do a single integral From e6ac0164888b2c8bda2db77b24e83ff41252b8c3 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:05:50 +0200 Subject: [PATCH 89/94] Implement optional multiprocessing for Migdal --- wimprates/migdal.py | 241 +++++++++++++++++++++++++++----------------- 1 file changed, 150 insertions(+), 91 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 6c23e4b..a4219f4 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -10,6 +10,7 @@ """ from collections.abc import Callable +from concurrent.futures import ProcessPoolExecutor from dataclasses import dataclass from typing import Any, Optional, Union @@ -17,6 +18,7 @@ from functools import lru_cache import numericalunits as nu import numpy as np +from tqdm.autonotebook import tqdm import pandas as pd from scipy.integrate import dblquad from scipy.interpolate import interp1d @@ -68,7 +70,7 @@ def l(self) -> str: return self.name[1:] -def _default_shells(material: str) -> list[str]: +def _default_shells(material: str) -> tuple[str]: """ Returns the default shells to consider for a given material. Args: @@ -88,45 +90,25 @@ def _default_shells(material: str) -> list[str]: Ge=["3*"], Si=["2*"], ) - return consider_shells[material] + return tuple(consider_shells[material]) -def create_cox_probability_function( - element, - state: str, - material: str, +def _create_cox_probability_function( + element: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) - def get_probability( - e: Union[float, np.ndarray], # energy of released electron - erec: Optional[Union[float, np.ndarray]] = None, # recoil energy - v: Optional[Union[float, np.ndarray]] = None, # recoil speed - ) -> np.ndarray: - if erec is None: - if v is None: - raise ValueError("Either v or erec have to be provided") - elif v is None: - v = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 - else: - raise ValueError("Either v or erec have to be provided") - - e /= nu.keV - - input_points = wr.pairwise_log_transform(e, v) - return fn(input_points, state) / nu.keV # type: ignore - - return get_probability + return fn @export def get_migdal_transitions_probability_iterators( material: str = "Xe", model: str = "Ibe", - considered_shells: Optional[Union[list[str], str]] = None, + considered_shells: Optional[Union[tuple[str], str]] = None, dark_matter: bool = True, e_threshold: Optional[float] = None, dipole: bool = False, @@ -193,6 +175,7 @@ def get_migdal_transitions_probability_iterators( dipole=dipole, dark_matter=dark_matter, e_threshold=e_threshold, + **kwargs ) for state, binding_e in element.orbitals: @@ -205,10 +188,8 @@ def get_migdal_transitions_probability_iterators( material, binding_e * nu.keV, model, - single_ionization_probability=create_cox_probability_function( + single_ionization_probability=_create_cox_probability_function( element, - state, - material, dipole=dipole, ), ) @@ -230,10 +211,92 @@ def vmin_migdal( return np.maximum(0, y) +def get_diff_rate( + w: float, + shells: list[Shell], + mw: float, + sigma_nucleon: float, + halo_model: wr.StandardHaloModel, + interaction: str, + m_med: float, + migdal_model: str, + include_approx_nr: bool, + q_nr: float, + material: str, + t: Optional[float], + **kwargs, +): + result = 0 + for shell in shells: + + def diff_rate(v, erec): + # Observed energy = energy of emitted electron + # + binding energy of state + eelec = w - shell.binding_e - include_approx_nr * erec * q_nr + if eelec < 0: + return 0 + + if migdal_model == "Ibe": + return ( + # Usual elastic differential rate, + # common constants follow at end + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + # Migdal effect |Z|^2 + # TODO: ?? what is explicit (eV/c)**2 doing here? + * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) + ** 2 + / (2 * np.pi) + * shell(eelec) + ) + elif migdal_model == "Cox": + vrec = (2 * erec / wr.mn(material)) ** 0.5 / nu.c0 + input_points = wr.pairwise_log_transform(eelec/nu.keV, vrec) + return ( + wr.sigma_erec( + erec, + v, + mw, + sigma_nucleon, + interaction, + m_med=m_med, + material=material, + ) + * v + * halo_model.velocity_dist(v, t) + * shell(input_points, shell.name) / nu.keV + ) + + # Note dblquad expects the function to be f(y, x), not f(x, y)... + result += dblquad( + diff_rate, + 0, + wr.e_max(mw, wr.v_max(t, halo_model.v_esc), wr.mn(material)), + lambda erec: vmin_migdal( + w=w - include_approx_nr * erec * q_nr, + erec=erec, + mw=mw, + material=material, + ), + lambda _: wr.v_max(t, halo_model.v_esc), + **kwargs, + )[0] + + return result + + @export -@wr.vectorize_first def rate_migdal( - w: np.ndarray, + w: Union[np.ndarray, float], mw: float, sigma_nucleon: float, interaction: str = "SI", @@ -243,11 +306,13 @@ def rate_migdal( material: str = "Xe", t: Optional[float] = None, halo_model: Optional[wr.StandardHaloModel] = None, - consider_shells: Optional[list[str]] = None, + consider_shells: Optional[tuple[str]] = None, migdal_model: str = "Ibe", dark_matter: bool = True, dipole: bool = False, e_threshold: Optional[float] = None, + progress_bar: bool = False, + multi_process: Optional[Union[bool, int]] = True, **kwargs, ) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of @@ -279,8 +344,21 @@ def rate_migdal( Further kwargs are passed to scipy.integrate.quad numeric integrator (e.g. error tolerance). """ + _is_array = True + if not isinstance(w, np.ndarray): + if isinstance(w, float): + _is_array = False + w = np.array([w]) + else: + raise ValueError("w must be a float or a numpy array") + halo_model = wr.StandardHaloModel() if halo_model is None else halo_model + if progress_bar: + prog_bar = tqdm + else: + prog_bar = lambda x, *args, **kwargs: x + if not consider_shells: consider_shells = _default_shells(material) @@ -293,72 +371,53 @@ def rate_migdal( dark_matter=dark_matter, ) - result = 0 - for shell in shells: - - def diff_rate(v, erec): - # Observed energy = energy of emitted electron - # + binding energy of state - eelec = w - shell.binding_e - include_approx_nr * erec * q_nr - if eelec < 0: - return 0 - - if migdal_model == "Ibe": - return ( - # Usual elastic differential rate, - # common constants follow at end - wr.sigma_erec( - erec, - v, - mw, - sigma_nucleon, - interaction, - m_med=m_med, - material=material, - ) - * v - * halo_model.velocity_dist(v, t) - # Migdal effect |Z|^2 - # TODO: ?? what is explicit (eV/c)**2 doing here? - * (nu.me * (2 * erec / wr.mn(material)) ** 0.5 / (nu.eV / nu.c0)) - ** 2 - / (2 * np.pi) - * shell(eelec) - ) - elif migdal_model == "Cox": - return ( - wr.sigma_erec( - erec, - v, + results = [] + if multi_process and not dipole: + multi_process = None if isinstance(multi_process, bool) else multi_process + with ProcessPoolExecutor(multi_process) as executor: + futures = [] + for val in w: + futures.append( + executor.submit( + get_diff_rate, + val, + shells, mw, sigma_nucleon, + halo_model, interaction, - m_med=m_med, - material=material, + m_med, + migdal_model, + include_approx_nr, + q_nr, + material, + t, ) - * v - * halo_model.velocity_dist(v, t) - * shell(eelec, erec) ) - # Note dblquad expects the function to be f(y, x), not f(x, y)... - r = dblquad( - diff_rate, - 0, - wr.e_max(mw, wr.v_max(t, halo_model.v_esc), wr.mn(material)), - lambda erec: vmin_migdal( - w=w - include_approx_nr * erec * q_nr, - erec=erec, - mw=mw, - material=material, - ), - lambda _: wr.v_max(t, halo_model.v_esc), - **kwargs, - )[0] - - result += r + for future in prog_bar(futures, desc="Computing rates"): + results.append(future.result()) + else: + for val in prog_bar(w, desc="Computing rates"): + results.append( + get_diff_rate( + val, + shells, + mw, + sigma_nucleon, + halo_model, + interaction, + m_med, + migdal_model, + include_approx_nr, + q_nr, + material, + t, + ) + ) - return halo_model.rho_dm / mw * (1 / wr.mn(material)) * np.array(result) + results = np.array(results) if _is_array else float(results[0]) + return halo_model.rho_dm / mw * (1 / wr.mn(material)) * results @wr.deprecated("Use get_migdal_transitions_probability_iterators instead") From 8c3e5eba63aae839d72c0cca1846560042dd9459 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:07:51 +0200 Subject: [PATCH 90/94] Make Multiprocessing loop more Pythonic --- wimprates/migdal.py | 56 +++++++++++++++++++++++---------------------- 1 file changed, 29 insertions(+), 27 deletions(-) diff --git a/wimprates/migdal.py b/wimprates/migdal.py index a4219f4..0af6b6a 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -12,10 +12,11 @@ from collections.abc import Callable from concurrent.futures import ProcessPoolExecutor from dataclasses import dataclass +import os from typing import Any, Optional, Union from fnmatch import fnmatch -from functools import lru_cache +from functools import lru_cache, partial import numericalunits as nu import numpy as np from tqdm.autonotebook import tqdm @@ -312,7 +313,7 @@ def rate_migdal( dipole: bool = False, e_threshold: Optional[float] = None, progress_bar: bool = False, - multi_process: Optional[Union[bool, int]] = True, + multi_processing: Optional[Union[bool, int]] = True, **kwargs, ) -> np.ndarray: """Differential rate per unit detector mass and deposited ER energy of @@ -371,33 +372,34 @@ def rate_migdal( dark_matter=dark_matter, ) - results = [] - if multi_process and not dipole: - multi_process = None if isinstance(multi_process, bool) else multi_process - with ProcessPoolExecutor(multi_process) as executor: - futures = [] - for val in w: - futures.append( - executor.submit( - get_diff_rate, - val, - shells, - mw, - sigma_nucleon, - halo_model, - interaction, - m_med, - migdal_model, - include_approx_nr, - q_nr, - material, - t, - ) - ) + if multi_processing and not dipole: + multi_processing = None if isinstance(multi_processing, bool) else multi_processing + with ProcessPoolExecutor(multi_processing) as executor: + partial_get_diff_rate = partial( + get_diff_rate, + shells=shells, + mw=mw, + sigma_nucleon=sigma_nucleon, + halo_model=halo_model, + interaction=interaction, + m_med=m_med, + migdal_model=migdal_model, + include_approx_nr=include_approx_nr, + q_nr=q_nr, + material=material, + t=t, + ) - for future in prog_bar(futures, desc="Computing rates"): - results.append(future.result()) + n_workers = os.cpu_count() if multi_processing is None else multi_processing + results = list( + prog_bar( + executor.map(partial_get_diff_rate, w), + desc=f"Computing rates (MP={n_workers} workers)", + total=len(w), + ) + ) else: + results = [] for val in prog_bar(w, desc="Computing rates"): results.append( get_diff_rate( From bfa43942819ccc087361d31468975b162a2a48b3 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:08:57 +0200 Subject: [PATCH 91/94] Cache Cox Model instance during runtime --- wimprates/data/migdal/Cox/cox_wrapper.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/wimprates/data/migdal/Cox/cox_wrapper.py b/wimprates/data/migdal/Cox/cox_wrapper.py index 67dd5f6..7743eef 100644 --- a/wimprates/data/migdal/Cox/cox_wrapper.py +++ b/wimprates/data/migdal/Cox/cox_wrapper.py @@ -5,17 +5,18 @@ The working directory is then reset. """ +from functools import lru_cache import os import sys -import wimprates as wr - from .cox_submodule.Migdal import Migdal +import wimprates as wr export, __all__ = wr.exporter() @export +@lru_cache def cox_migdal_model(element: str, **kwargs) -> Migdal: """ This function creates a Cox Migdal model for a given element. From 623ed89791d6df3de599f7aebf9e6dfdd34f578f Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Thu, 15 Aug 2024 23:11:20 +0200 Subject: [PATCH 92/94] Add caching functionality to save and load results --- tests/test_wimprates.py | 2 ++ wimprates/summary.py | 2 ++ wimprates/utils.py | 61 ++++++++++++++++++++++++++++++++++++++++- 3 files changed, 64 insertions(+), 1 deletion(-) diff --git a/tests/test_wimprates.py b/tests/test_wimprates.py index ac1fd9d..727d5f8 100644 --- a/tests/test_wimprates.py +++ b/tests/test_wimprates.py @@ -14,6 +14,8 @@ class TestBenchmarks(unittest.TestCase): opts = dict(mw=50, sigma_nucleon=1e-45, + save_cache=False, + load_cache=False, ) def test_elastic(self): ref = 30.39515403337126 diff --git a/wimprates/summary.py b/wimprates/summary.py index 8ac5c5c..33a92d9 100644 --- a/wimprates/summary.py +++ b/wimprates/summary.py @@ -2,12 +2,14 @@ Summary functions """ import numericalunits as nu +nu.reset_units(42) # Comment this line this when debugging dimensional analysis errors import wimprates as wr export, __all__ = wr.exporter() @export +@wr.save_result def rate_wimp(es, mw, sigma_nucleon, interaction='SI', detection_mechanism='elastic_nr', m_med=float('inf'), t=None, halo_model=None, diff --git a/wimprates/utils.py b/wimprates/utils.py index 890fb38..5be1768 100644 --- a/wimprates/utils.py +++ b/wimprates/utils.py @@ -1,13 +1,17 @@ import functools +import hashlib import inspect import os import pickle +from typing import Any, Callable import warnings from boltons.funcutils import wraps import numpy as np from tqdm.autonotebook import tqdm +import wimprates as wr + def exporter(): """Export utility modified from https://stackoverflow.com/a/41895194 @@ -108,6 +112,7 @@ def pairwise_log_transform(a, b): arr = np.concatenate((a, b), axis=1) return np.log(arr) + @export def deprecated(reason): """ @@ -124,4 +129,58 @@ def new_func(*args, **kwargs): ) return func(*args, **kwargs) return new_func - return decorator \ No newline at end of file + return decorator + + +def _generate_hash(*args, **kwargs): + # Create a string with the arguments and module version + + args_str = wr.__version__ + str(args) + + # Add keyword arguments to the string + args_str += "".join( + [f"{key}{kwargs[key]}" for key in sorted(kwargs) if key != "progress_bar"] + ) + + # Generate a SHA-256 hash + return hashlib.sha256(args_str.encode()).hexdigest() + + +@export +def save_result(func: Callable) -> Callable[..., Any]: + @wraps(func) + def wrapper( + *args, cache_dir: str="wimprates_cache", save_cache: bool=True, load_cache: bool=True, **kwargs + ): + # Define the cache directory + CACHE_DIR = cache_dir + + # Generate the hash based on function arguments and module version + func_name = func.__name__ + cache_key = _generate_hash(*args, **kwargs) + + # Define the path to the cache file + cache_file = os.path.join(CACHE_DIR, f"{func_name}_{cache_key}.pkl") + + # Check if the result is already cached + if load_cache and os.path.exists(cache_file): + with open(cache_file, "rb") as f: + print("Loading from cache: ", cache_file) + return pickle.load(f) + + # Compute the result + result = func(*args, **kwargs) + + if save_cache: + # Ensure cache directory exists + if not os.path.exists(CACHE_DIR): + os.makedirs(CACHE_DIR) + + # Save the result to the cache + with open(cache_file, "wb") as f: + pickle.dump(result, f) + print("Result saved to cache: ", cache_file) + + return result + + return wrapper From 0034cb4934cd44f84e7fb4ef7892374c7a7d2c84 Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 9 Oct 2024 03:11:09 +1100 Subject: [PATCH 93/94] Update Notebook + remove redundant arg in Cox interpolator --- notebooks/Migdal.ipynb | 148 ++++++++++++++++++++--------------------- wimprates/migdal.py | 10 +-- 2 files changed, 78 insertions(+), 80 deletions(-) diff --git a/notebooks/Migdal.ipynb b/notebooks/Migdal.ipynb index 8c26173..984c128 100644 --- a/notebooks/Migdal.ipynb +++ b/notebooks/Migdal.ipynb @@ -25,16 +25,6 @@ } }, "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", - " warnings.warn(\n", - "/home/loren/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/utils.py:9: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", - " from tqdm.autonotebook import tqdm\n" - ] - }, { "name": "stdout", "output_type": "stream", @@ -45,6 +35,16 @@ "arXiv:2208.12222\n", "------------------------------------------\n" ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/loren/projects/wimprates/wimprates/__init__.py:6: UserWarning: Default WIMP parameters are changed in accordance with https://arxiv.org/abs/2105.00599 (github.com/JelleAalbers/wimprates/pull/14)\n", + " warnings.warn(\n", + "/home/loren/projects/wimprates/wimprates/utils.py:11: TqdmExperimentalWarning: Using `tqdm.autonotebook.tqdm` in notebook mode. Use `tqdm.tqdm` instead to force console mode (e.g. in jupyter console)\n", + " from tqdm.autonotebook import tqdm\n" + ] } ], "source": [ @@ -308,14 +308,14 @@ "name": "stderr", "output_type": "stream", "text": [ - "/tmp/ipykernel_1780/1628684340.py:2: DeprecationWarning: Call to deprecated function read_migdal_transitions (Use get_migdal_transitions_probability_iterators instead).\n", + "/tmp/ipykernel_29500/1628684340.py:2: DeprecationWarning: Call to deprecated function read_migdal_transitions (Use get_migdal_transitions_probability_iterators instead).\n", " df2, _ = wr.migdal.read_migdal_transitions(SOURCE)\n" ] }, { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 3, @@ -367,40 +367,42 @@ "metadata": {}, "outputs": [ { - "name": "stdout", - "output_type": "stream", - "text": [ - "\u001b[0;31mInit signature:\u001b[0m\n", - "\u001b[0mwr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmigdal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mShell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0melement\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mbinding_e\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m \u001b[0msingle_ionization_probability\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcollections\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", - "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mDocstring:\u001b[0m \n", - "Describes a specific atomic shell for the selected atom.\n", - "\n", - "Attributes:\n", - " name (str): The name of the shell.\n", - " element (str): The element class of the atom.\n", - " binding_e (float): The binding energy for the shell.\n", - " model (str): The model used for the single ionization probability computation.\n", - " single_ionization_probability (Callable): A function to assign interpolators to.\n", - " The interpolator will provide the single ionization probability for the shell\n", - " according to the selected model.\n", - "\n", - "Methods:\n", - " __call__(*args, **kwargs) -> np.ndarray:\n", - " Calls the single_ionization_probability function with the given arguments and keyword arguments.\n", - "\n", - "Properties:\n", - " n (int): Primary quantum number.\n", - " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", - "\u001b[0;31mFile:\u001b[0m ~/.local/mambaforge/envs/migdal/lib/python3.12/site-packages/wimprates/migdal.py\n", - "\u001b[0;31mType:\u001b[0m type\n", - "\u001b[0;31mSubclasses:\u001b[0m " - ] + "data": { + "text/plain": [ + "\u001b[0;31mInit signature:\u001b[0m\n", + "\u001b[0mwr\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmigdal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mShell\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mname\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0melement\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mbinding_e\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mfloat\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0mmodel\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m \u001b[0msingle_ionization_probability\u001b[0m\u001b[0;34m:\u001b[0m \u001b[0mcollections\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mabc\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mCallable\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m\u001b[0m\n", + "\u001b[0;34m\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m->\u001b[0m \u001b[0;32mNone\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mDocstring:\u001b[0m \n", + "Describes a specific atomic shell for the selected atom.\n", + "\n", + "Attributes:\n", + " name (str): The name of the shell.\n", + " element (str): The element class of the atom.\n", + " binding_e (float): The binding energy for the shell.\n", + " model (str): The model used for the single ionization probability computation.\n", + " single_ionization_probability (Callable): A function to assign interpolators to.\n", + " The interpolator will provide the single ionization probability for the shell\n", + " according to the selected model.\n", + "\n", + "Methods:\n", + " __call__(*args, **kwargs) -> np.ndarray:\n", + " Calls the single_ionization_probability function with the given arguments and keyword arguments.\n", + "\n", + "Properties:\n", + " n (int): Primary quantum number.\n", + " l (str): Azimuthal quantum number for Ibe; Azimuthal + magnetic quantum number for Cox.\n", + "\u001b[0;31mFile:\u001b[0m ~/projects/wimprates/wimprates/migdal.py\n", + "\u001b[0;31mType:\u001b[0m type\n", + "\u001b[0;31mSubclasses:\u001b[0m " + ] + }, + "metadata": {}, + "output_type": "display_data" } ], "source": [ @@ -455,7 +457,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -469,21 +471,18 @@ "shells_cox = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", considered_shells=(\"*\",))\n", "\n", "\n", - "E = np.logspace(0, np.log10(20e3), 1000) * nu.eV\n", - "v = np.repeat(1e-4, len(E))\n", + "E = np.logspace(-4, np.log10(20), 1000)\n", + "v = np.repeat(1e-3, len(E))\n", + "points = wr.pairwise_log_transform(E.copy(), v)\n", "\n", - "def print_f(arr, pref=\"\"):\n", - " if arr is not None:\n", - " return 0\n", - " print(f\"{pref} {arr[:2]=}\")\n", "for shell in shells_cox:\n", - " x = shell(E.copy(), v=v)\n", + " x = shell(points)\n", " if shell.l != \"s\":\n", " continue\n", " for _shell in shells_cox:\n", " if shell.n == _shell.n and _shell.l != \"s\":\n", - " x += _shell(E.copy(), v=v)\n", - " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " x += _shell(points)\n", + " ax.plot(E, x, label=f\"n={shell.n}\")\n", " \n", "\n", "\n", @@ -503,7 +502,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAlIAAAHOCAYAAABTk+fWAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/TGe4hAAAACXBIWXMAAA9hAAAPYQGoP6dpAADFRklEQVR4nOzdd3wURRvA8d/V9B5CGgkQklBCgBA60hVUUBDEQkekw6uIgqIoiiLSlCIgRVSq0gQrCALSew2EEEJCeu/17vb9I+QgJJQkl8p8P5/j7nZnd567XLgnM7MzMkmSJARBEARBEIQSk1d2AIIgCIIgCNWVSKQEQRAEQRBKSSRSgiAIgiAIpSQSKUEQBEEQhFISiZQgCIIgCEIpiURKEARBEAShlEQiJQiCIAiCUEoikRIEQRAEQSglkUgJgiAIgiCUkkikhBrp2rVrvP/++3Tr1o2mTZvSokUL+vXrx6pVq0hOTq7s8CrUkCFDGDJkSKmO7datG9OnTzdwRPlOnDiBt7c3J06c0G87ePAgS5YsKba8t7c3n376aanqCg8Px9vbW39r0qQJbdq0oX///nzxxRcEBQU9VnzloSw/n0eZM2cO3t7ejBkzplzOX9nK8/P5KLt372bdunXF7vP29n7g51ioeZSVHYAgGNrPP//MrFmzqFevHm+88QYNGjRAo9Fw+fJlNm/ezPnz51m2bFllh/nEa9KkCVu2bKFBgwb6bQcPHmTDhg1MmjSpXOocMmQIvXv3RqfTkZaWRkBAANu2bWP9+vVMmTKFUaNGPTS+6iQvL49du3YB8N9//xETE0Pt2rUrOSrDWrp0Kebm5pVS92+//UZQUBDDhw8vsm/Lli04OjpWfFBCpRCJlFCjnDt3jk8++YT27dvz7bffolar9fs6dOjAiBEj+O+//yoxQqGAubk5zZs3r9A6nZycCtXZuXNnRowYwcSJE5k3bx6enp507ty50uIzpH379pGYmEiXLl04cOAAO3bsYOzYsZUSiyRJ5OTkYGxsbNDzNm7c2KDnM5Tq/LkRSk507Qk1ysqVK5HJZHz22WeFkqgCarWa7t2765/rdDpWrVpFr1698PHxoV27drz33ntER0fry8ycOZOmTZty+fLlQscNGzaM9u3bExsb+8B4CrqUVq9ezXfffUe3bt3w9fVlyJAhhISEkJeXx/z58+nYsSMtW7ZkwoQJJCQkFDrH48QI+V9Wq1atomvXrjRt2pR+/fpx8ODBYuNKT09n7ty5dOvWDR8fH5566ik+//xzMjMzH/4GF2Py5Mk8//zzhbaNHTsWb29v/vzzT/22K1eu4O3tzf79+4GiXWfTp09nw4YNAIW64cLDwwude+fOnTz77LM0a9aMF154gX///bfEMd/L2NiYzz//HJVKxZo1a/Tbi+vamz59Oi1atCAoKIhhw4bRvHlz2rZty6effkpWVlah8+bk5LBgwYJC7/GsWbNITU19ZEy5ubl8++23+p9527Ztef/990lMTHzs17V161ZUKhVz5szBycmJ7du3c/8a9QWv8ddff2XOnDl06NABX19fBg8eTEBAQKGyJXntBd2wmzZt4tlnn6Vp06bs2LEDgNOnTzNs2DBatGhBs2bNePXVVzlw4ID+2NOnT9OkSRPmzp1b6Jzbt2/H29ubX375Rb/t/q69gteze/du5s2bR8eOHWnRogVjx44lPj6e9PR0PvroI9q0aUObNm14//33ycjIKFTPhg0bGDRoEO3ataN58+b06dOHVatWkZeXpy8zZMgQDhw4QERERKHP6r2v//6uvevXrzNu3DhatWpF06ZNefHFF/Xvyf3x//bbbyxatIiOHTvi5+fH8OHDuXnzJkLVJFqkhBpDq9Vy/PhxmjRpgpOT02Md88knn7BlyxYGDx5Mly5diIiI4JtvvuHkyZNs374dW1tbZsyYwcWLF3nrrbfYvn07lpaWLF26lJMnT7J69WocHBweWc/GjRvx8vJi5syZpKamMnfuXMaOHUuzZs1QKpV88cUXREZGMnfuXGbMmMGKFStKFCPkd3MsXbqUAQMG0LNnT6Kjo/noo4/Q6XTUq1dPf76srCwGDx5MdHS0PuEJCgpi8eLFXL9+nXXr1iGTyR77fW/fvj1///03sbGxODg4oNFoOHnyJMbGxhw9epRnn30WgKNHj6JUKmndunWx5xk/fjyZmZn8/fffbNmyRb/93vf3wIEDXLp0icmTJ2Nqasrq1auZOHEif/31F3Xq1HnsmO9Xu3ZtmjRpwrlz59BoNCiVD/6vMS8vj9GjR/PKK68wevRozp07x/Lly4mMjNT/3CRJYvz48Rw/fpzRo0fj7+9PYGAgS5Ys4fz582zZsqXYRB/yE+fx48dz5swZ3njjDfz8/IiIiGDJkiVcvHiRbdu2PbJlJzo6miNHjvDMM89ga2tL3759Wb58OadOnSr2/V+0aBGNGzdm9uzZpKWlsXTpUoYMGcLOnTsLva+P89oL/PPPP5w+fZoJEyZgb2+PnZ0dJ0+eZOTIkXh5efH555+jVqvZtGkTY8eOZeHChTz33HP4+/vzv//9jwULFuDv70/37t0JCgri008/5YUXXuDll19+6GsveD1t2rRhzpw5REREMHfuXKZMmYJSqcTb25uFCxcSEBDAokWLMDMz48MPP9QfGxYWRu/evXF1dUWlUnHt2jVWrFjBzZs3mTNnDgAff/wxH330Ebdv32bp0qWPjOfmzZu8+uqr2NnZMWPGDGxsbNi1axfTp08nPj6eN998s1D5hQsX4ufnx+eff056ejrz589n3Lhx/PHHHygUikfWJ1QwSRBqiLi4OMnLy0t6++23H6v8jRs3JC8vL+mTTz4ptP3ChQuSl5eXtHDhQv22W7duSX5+ftL48eOlo0ePSg0bNpQWLVr0yDpu374teXl5SS+88IKk1Wr129etWyd5eXlJY8eOLVT+888/l7y8vKS0tLQSxZiSkiI1bdpUmjBhQqFyZ86ckby8vKTBgwfrt61cuVJq2LChdPHixUJl//rrL8nLy0s6cOCAflvXrl2ladOmPfQ1hoaGSl5eXtKOHTskSZKk06dPS15eXtJXX30ldevWTV9uxIgR0iuvvKJ/fvz4ccnLy0s6fvy4ftusWbMkLy+vYuvx8vKS2rdvr39vJCn/Z96wYUNp5cqVD42x4OewevXqB5Z56623JC8vLyk+Pv6B8U2bNk3y8vKSfvjhh0LHLl++XPLy8pJOnz4tSZIkHTp0SPLy8pJWrVpVqNzvv/8ueXl5SVu2bNFvGzx4cKGfz2+//SZ5eXlJf//9d6FjL168KHl5eUkbNmx46GuVJElaunSp5OXlJR06dEiSJEkKCwuTvL29pXfffbdQuYLX2K9fP0mn0+m3h4eHS02aNJFmzJhR4tcuSfk/q5YtW0rJycmFyg4cOFBq166dlJ6ert+m0Wik3r17S506ddLHoNPppDfffFPy9/eXrl+/Lj333HNSr169pIyMjELnu//zWfB6xowZU6hcwe/VZ599Vmj7+PHjpdatWz/gXZQkrVYr5eXlSTt27JAaNWpU6PWMHj1a6tq1a7HHeXl5SYsXL9Y/f/vttyUfHx8pMjKyULlRo0ZJzZo1k1JTUwvF/+abbxYq98cff0heXl7SuXPnHhirUHlE157wxCrosunXr1+h7b6+vnh4eHDs2DH9Nnd3dz777DP++ecfxowZg7+/f4kGRHfu3Bm5/O6vm4eHBwBdunQpVK5ge2RkZIliPHfuHDk5OfTp06dQOT8/P1xcXApt+/fff/H09KRRo0ZoNBr9rWPHjshkMk6ePPnYrwvAzc0NFxcXfSxHjx7Fy8uLF154gfDwcMLCwsjNzeXMmTO0b9++ROe+X5s2bQoNLi5o6YiIiCjTeYEi3V4Pc//73Lt3b+Duz+v48eMAvPTSS4XKPfvss5iamhb6bN3v33//xdLSkq5duxb6+TRq1IhatWo98ucjSRLbt2/HycmJDh06AFCnTh1at27Nnj17SE9PL3JM7969C7VCuri40KJFi2KvWHzUay/Qtm1brKys9M8zMzO5cOECPXv2xMzMTL9doVDwwgsvEB0dre++kslkzJ07FzMzM/r37094eDhff/01pqamD33tBbp27Vro+cN+35KTkwt17wUEBDB27FjatGlDo0aNaNKkCdOmTUOr1XLr1q3Hqv9+x48fp127dkVayvv160dWVhbnzp0rtL1bt26Fnhd0Gxb8vyBULaJrT6gxbGxsMDExKTKm5kEKpkEormvOwcGhyH9aXbp0wd7envj4eIYPH16iJvZ7v1AAVCrVQ7fn5OSUKMaCcvb29kXK3b8tISGB0NBQmjRpUmysSUlJD3spxWrXrp1+EP/Ro0fp0KED3t7e2Nvbc/ToUdzd3cnOzi5zImVtbV1km1qt1r9fZREZGYlarS7yM7mfUqnExsam0LZatWoBd38OycnJKJVKfbdrAZlMhr29/UOn4EhISCA1NRUfH59i9z/q53P8+HHCw8MZMWJEoaTp2Wef5cSJE/z222+8+uqrhY550Ofm2rVrhbY9zmu/f3uB1NRUJEkqsh3ufr7vPYeNjQ3dunVjw4YNPP3004XGID1KaX7fzMzMiIyMZNCgQdSrV48PPvgAFxcXjIyMuHjxIp9++inZ2dmPHcO9kpOTH/t1Q9HPeUE3cGnrF8qXSKSEGkOhUNC2bVv+++8/oqOjH3n5ccF/VrGxsUXKxsbGFvnC+Pjjj8nIyMDT05PPP/8cf3//R37pltXjxlhQLj4+vsg54uPjC7VK2djYYGRkxBdffFFsnfe/7sfRrl07tm7dysWLF7l48SLjxo0D8lsljh49SmRkJKampjRr1qzE564IMTExXLlyhVatWj10fBSARqMhKSmp0PsUFxcH3P05WFtbo9FoSExMLJRMSZJEfHw8TZs2feD5bWxssLa2ZvXq1cXuv7c1pzhbt24F4Pvvv+f7778vdv/9idSDPjf3f6E/zmsvcP84O0tLS+Ryub78vQou2Lj3vEeOHGHTpk34+vqyd+9e/v77b3r27FnkWEP6559/yMzMZMmSJYV+Z+5PKEvK2tr6sV+3UP2Irj2hRhkzZgySJPHhhx+Sm5tbZH9eXp7+qrG2bdsC6OfaKXDx4kWCg4P1+wF++eUXdu3axUcffcTy5ctJTU3l/fffL8dXQolibN68OUZGRuzevbtQubNnzxbp9urSpQu3b9/G2tqapk2bFrm5urqWOM527dohk8n45ptvkMlktGrVSr/9xIkTHDlyhFatWulbAB6kMv7yzs7OZsaMGWg0mkLzSD3M/e/zb7/9BqAfyN2uXTug6M/t77//JjMzU7+/OF26dCE5ORmdTlfsz6d+/foPPDYlJYW9e/fi5+fHjz/+WOTWp08fLl26xPXr14vEf2/XZkREBOfOnSt2YPqjXvuDFCTSe/fuLfTz1el07Nq1C0dHR/1FEbGxsbz77ru0atWKzZs3061bN2bMmMHt27cfWkdZFSR/914IIEkSP//8c5GyarX6sT+n7dq14/jx48TExBTa/uuvv2JiYiKmS6jmRIuUUKO0aNGCTz75hFmzZtG/f39effVVPD090Wg0BAQE8PPPP+Pp6Um3bt2oX78+r7zyCuvXr0cul9OpUyf9FXFOTk76ifYCAwOZPXs2/fr1o3///gB8/vnnTJ48mXXr1hU7IZ+hPG6MVlZWjBw5kuXLlzNjxgx69epFdHQ0S5YsKdKlMGzYMPbs2cPgwYMZPnw43t7e6HQ6oqKiOHz4MCNHjixxy5GdnR2enp4cPnyYNm3aYGJiAuRf0ZecnExycvJjJZ5eXl4ArFq1ik6dOiGXy/H29n7gFW4lFRUVxfnz5/UTcl69epVt27YRGRnJ9OnT6dix4yPPoVKp+P7778nMzKRp06b6K9c6deqEv78/kD9nWceOHZk/fz7p6en4+fkRGBjI4sWLady4MS+++OIDz//888+ze/duRo8ezZAhQ/D19UWlUhEdHc2JEyfo3r07Tz/9dLHH7t69m5ycHIYMGUKbNm2K7Le2tmb37t1s3bqVDz74QL89MTGRCRMmMHDgQNLS0liyZAlqtbrIjOiP89ofZsqUKYwcOZKhQ4cycuRIVCoVGzduJCgoiIULFyKTydBqtbzzzjvIZDIWLFiAQqHgyy+/pG/fvrz99tts3LjRYJ+H+7Vv3x6VSqWfnDU3N5dNmzYVO2WFl5cXe/bsYePGjfj4+CCTyR7Y0jhhwgT+/fdfhg4dyoQJE7CysmL37t0cOHCAd999FwsLi3J5PULFEImUUOMMHDgQX19f1q1bx+rVq4mLi0OlUlG3bl169+7N4MGD9WU/+eQT6tSpw9atW9m4cSPm5uY89dRTvPPOO9jY2JCZmclbb72Fq6srH3/8sf64nj17MmjQIObPn4+fnx++vr7l9noeFWOB//3vf5iamrJx40Z+/fVX6tevz6xZs1i7dm2h85mamrJhwwa+++47tmzZQnh4OMbGxjg5OdG+ffsig9MfV/v27bl+/XqhcVDOzs7UrVuXW7duPbQVpkDv3r05e/YsGzduZNmyZUiSxL59+0rVSlacn376iZ9++gmFQoG5uTmurq507dqVgQMHPvYM5iqVihUrVjB79myWL1+OsbExL7/8Mu+9956+jEwm49tvv2XJkiVs376dFStWYG1tzYsvvsiUKVMemggoFAqWL1/Ojz/+yK+//sp3332HQqHA0dGRVq1a6ZPN4mzduhU7Ozt69OhR7H5vb2+aN2/Orl27mDp1qn7722+/zaVLl3j//fdJT0/H19eXhQsX4ubmVuLX/jCtW7dm3bp1LFmyhPfffx+dTkfDhg1Zvny5foD44sWLOX36NGvXrtX/EWBlZcXChQsZPHgw8+bNY8aMGY9VX0l5eHiwZMkSvv76ayZNmoS1tTW9e/dm+PDhRaYoGDp0KEFBQSxatIi0tDQkSSIwMLDY89avX5/NmzezcOFC/VgrDw8P5syZU+SCBKH6kUkluVRFEAThCTZ9+nT+/vvvIldZVVcnTpxg6NChfPPNN/Tq1euhZWvaaxcEQxFjpARBEARBEEpJJFKCIAiCIAilJLr2BEEQBEEQSkm0SAmCIAiCIJSSSKQEQRAEQRBKSSRSgiAIgiAIpSTmkSpH/v7+5ObmFrvGkiAIgiAIVVNcXBxqtZrTp08/sqxIpMpRTk4OWq22ssMQBEEQBKEENBoNj3stnkikylHByt779u2r5EgEQRAEQXhc3bt3f+yyYoyUIAiCIAhCKYlEShAEQRAEoZREIiUIgiAIglBKIpESBEEQBEEoJZFICYIgCIIglJK4ak8QBEEQqjitVkteXl5lh1FjqFQqFAqFQc4lEilBEARBqKIkSSI6Oprk5OTKDqXGsba2xtHREZlMVqbziERKEARBEKqogiTKwcEBU1PTMn/pC/nJaWZmJrGxsQA4OTmV6XwikRIEQRCEKkir1eqTKDs7u8oOp0YxMTEBIDY2FgcHhzJ184nB5oIgCIJQBRWMiTI1Na3kSGqmgve1rGPPRCIlCIIgCFWY6M4rH4Z6X0UiJQiCIAiCUEoikRIEQRAEodrasGEDY8aMoW3btnh7e/PXX39VaP1isHk1lRifQWJ8BgqFPP+mvHNTyAptUyrvPFbIkMlloolYEARBqFF+/fVXADp37szOnTsrvP5SJ1JXrlwp1XENGjTAyMiotNUKQHZWHsu/OohWqyvZgTL0SZayIOlS3n2uVCtQqRSoCu7vPFaq7t0uz39+X1m1kRIj47s3pdIwE50JgiAIwsNs3rwZuVxOeHh49Uqk+vfvX6rWja1bt9KkSZPSVisARkZKmvq5EB2Rglaru3OT0GryH2vu3Ou0UuEDJfLLaHTk5pRvjAqF/G5iZaREfc9jI2MVRsZKTExVmJqpMTFVY2KmwtRUjYmZGhNTFQqF6HUWBEGoSaZPn87ly5f56KOPmDNnDrdu3aJBgwZ88skn+Pj4lPq8cnnlfl+UqWtv7NixuLm5PVZZrVbLRx99VJbqhDtkchkvvNrskeUkSUKnlfTJluZOEnV/4qXV5O/Ly9WSl6dFk6fVP86781iTpyUv7wFlcrXk5mjIydGQm6MFQKvVkZmRS2ZGbqleY36ipcbUTIWJmRpzcyPMLY0wtzDC3NJY/9jC0hi1keihFgThySJJEjm52kqp20itKPUwkbi4OGbPns3o0aMxNzdnwYIFTJw4kb1796JSqdBqtUiS9NBzyGQygy3vYghl+gbq2rUrvr6+j1VWq9Xy4YcflqU6oYRkMhkKZX73XUXR6aT8pCo7P7HKydaQk513d9udW3Z2HlkZuWRm5t9nZeaSmZFHdnYeSOjLJSc+uk61kUKfYFlZm2BlY4K1rQlWNqZY2eQ/V6mqzi+dIAhCWUiSxLSlh7l66zH+gywHjeraMndix1IlUykpKaxfvx5PT08AjIyMGDFiBBcuXMDf35/hw4dz8uTJh57DxcWF/fv3lyr28lDqRGrp0qXUq1fvscsrFAqWLl2Ku7t7aasUqgG5XIaxiQpjE1WpjtfpJLIz88jMzC2UaKWn5ZCelk16ag5pqTlkpGWTlppzpzVMS2JOJonxmQ88r5m5GitbU6xtTLC1N8Oulhm2tcyxdzDDxFRd2pcrCIIglICDg4M+iQLw8PAAICYmBoBZs2aRkZHx0HOo1VXr/+xSJ1I9evSokGOEJ4tcLsPUXI2p+eP9ouRka0i/k1Slp2STkpxFSlIWyUlZpCRmkpyURV6uloz0XDLSc4kMSy5yDhNTFXa1zO8kV2Y4OFpQ29kSKxsTcZWjIAhVjkwmY+7EjtWya8/S0rLQc5Uq/4/unJz8gbvu7u6P1bVXlYjBJUK1lj+g3Ry7WubF7pckiazMPFKSskhJyiQpMYvEuAwS4tJJjMsgNSWbrMw8wkOTCA9NKnSs2khJbaf8pMrByZLaThY4OFlgZFy61jZBEARDkclkGNfA8aFPVNfe/XQ6Hbt27aJv376GOqUglJlMJsPUTI2pmRonV6si+3NzNCTGZ5AQd+cWm05sdBpxMWnk5mi4fSuJ27cKJ1j2DuY4u1njUscaF3drajtZVug4NEEQhJrqierau59Go+H9998XiZRQraiNlDi6WOHoUjjJ0mp1JMSmExOVRkxkKrFRqcREpZGWkk18bDrxselcPB0O5E/14OhiiYu7Ne717XCrb4uZuZgrTRAEoaTq169f4mMuXbpEREQEiYn5g+8vXLgAgK2tLa1btzZofMUpUSK1dOnSB+7TaDRlDkYQqgqFQo6DU36XXlM/F/32jLQcIm4nExmWrL/PyswjIiyZiLBkTv53C4Batc1x97DDvb4d7h62mFsaV9IrEQRBqNk2bNjAjh079M/Xrl0LQOvWrfnpp5/KvX6Z9KhRXffw8fGhR48emJsXHY+i1WrZuXMnV69eNWiA1Vn37t0B2LdvXyVHIpQXSZJISsgkIiyZ8FuJhAYnEhudVqScfW1zPLxr0aChA+71bVGK6RgEQXiE7OxsQkJCqFevHsbG4o8xQ3vY+1uS7+8StUh5eXnRt29funTpUmRfTk5OoYxQEJ4EMpkMW3szbO3N9C1Xmem5hIUkEBqcSOjNBKIjU4mPSSc+Jp0Th0JQquTU9bDDo6EDDRrWeuBAeUEQBKHqK1Ei9fLLL6PVFn+5pVKpZOLEiQYJShCqM1NzNQ2bOtGwqRMAWZm53LqRwI2rsdwIjCMtJZsb1+K4cS2Ov4FajhY0bOpIQx9HHF0sq9ylvYIgCMKDlSiReu211x64T6FQiERKEIphYqqmka8TjXydkCSJuOi0O4lULGE3E4mLTiMuOo3/9gZhbWtCw6ZONGrqiGtdG5FUCYIgVHFlvmpv8eLFTJ482RCxCEKNJ5PJ9IPY23f1IDsrj+sBMVy7FM2Na7EkJ2Zx/OBNjh+8ibWtKU39XGja0gV7B9H9JwiCUBWVOZFas2aNSKQEoZSMTVT4tnTFt6UreblaggNjuXoxmsAr0SQnZvLfP0H8908QznWsaOrnQpMWLphbiKkVBEEQqooyJ1IluOhPEISHUKkV+rFVeblaAi9Hc/FsBMGBcUTeTiHydgp7d1/F28eRlu3cqNfAHplcdP0JgiBUpjInUmIMhyAYnkqtwMfPBR8/FzLScrhyPpKLZ8KJvJ3C1YtRXL0YhY2dKX5t3Wjeqg5mopVKEAShUtS8hXoEoYYxszCi9VP1aP1UPaIjUzl7LJRLZyNISshk3+/X+PevQJo0d6Ztp/rFLoMjCIIglB+RSAlCNeLobMlz/ZvSo3cjrpyP5MzxMCLDkrl0JoJLZyJw97Cjbef6eDVyEN1+giAIFUCMkRKEakhtpKRFGzdatHEjIiyZE4ducuVCFKHBCYQGJ2Brb0bbzvVp3toVpVLMoi4IglBeypxI+fn5GSIOQRBKycXNmpcG+9H9+SxOHbnFmWOhJMZn8Me2S/z3TxDtu3rg19YNlViWRhCEGiY2NpZ169Zx5MgRwsLCMDMzw8/Pj3feeQd3d/cKiaHMidS6desMEIYgCGVlZWNCj96N6PS0J+dO3ubov8GkpWTz984rHN53g/Zd6tOynTtqI9GjLwhCzXDlyhX27NlD//79ad68OampqaxcuZKXX36ZXbt24ejoWO4xlPp/1MTERGxtbQ0ZiyAIBqA2UtLmqXq0bOfG+ZPhHNl/g5SkLPbuvsqRf4N5qnsDWrZ3F11+giBUey1btuSvv/5CqbybzrRq1YpOnTqxdevWCllxRV7aAzt16sTkyZM5ePCgGCclCFWQUqnAv707E9/vSp+BvtjYmZKZnsvfvwbw7dwDXDwTjqQTv7uCIFSM6dOn07t3b06cOEHfvn1p3rw5AwYM4PLly6U+p6WlZaEkCsDW1hZHR0diY2PLGvJjKXWLVM+ePdm3bx979+6lVq1a9OvXj/79++Pm5mbI+ARBKCOFQk6LNm4083fl/KlwDv4dSHJiFjs3nufYv8F0e74RDRrWEnPCCUI1IkkSUl5OpdQtUxmV+v+LuLg4Zs+ezejRozE3N2fBggVMnDiRvXv3olKp0Gq1j2yckclkKBQPblGPiooiMjKS+vXrlyrGkip1IrVgwQLS09PZvXs327dvZ+XKlXz33Xf4+/szYMAAevXqhZGRmCRQEKoKuUKOX1s3mvq5cOK/EI7sv0FMVBqbVp+knqc9Pfs2wcHRorLDFAThESRJIvLHGeSEB1ZK/UauDXEeOrtUyVRKSgrr16/H09Mz/1xGRowYMYILFy7g7+/P8OHDOXny5EPP4eLiwv79+x+4f/bs2VhaWtKvX78Sx1caZRp1am5uzmuvvcZrr71GcHAwW7duZffu3UybNo3PPvuM559/nv79++Pr62uoeAVBKCOVWkHH7g1o2c6Nw/tucPLwLUKC4lm54BCtO9al8zNeGJuoKjtMQRAeqnq2IDs4OOiTKAAPDw8AYmJiAJg1axYZGRkPPYdarX7gvpUrV7J//36WLVuGlVXFTFBssMt3PDw8mDZtGlOnTuXAgQNs27aNbdu28fPPP9OgQQN2795tqKoEQTAAE1M1T/dpjH/7uuzZdYXAyzGcOBTCpbMRdH+uIc1b1RGTegpCFSSTyXAeOrtadu1ZWloWeq5S5f/RlpOT/1rc3d0fq2uvODt27GDRokV89NFHdOvWrVTxlYbBr4NWKBR0796dZs2asXr1an744Qdu3Lhh6GoEQTAQGztTXhnRiuDAOP7eeYX42HR2/3yRM8dC6f2yL44uYtkZQahqZDIZMrVxZYdhcKXt2tu3bx8ffvghY8aMYdCgQeUZYhEGTaS0Wi379+9n27ZtHD58GI1Gg7e3NwMGDDBkNYIglAMP71qMeacTJw+HcHBPEJG3U1j19WHad6lPp2e8xISegiCUu9J07Z08eZK3336bF198kbfffrs8wyuWQRKpoKAgtm3bxq5du0hKSsLc3JwBAwYwYMAAfHx8DFGFIAgVQKGU066LBz5+Lvy14wpXL0ZxZH8wVy9G8fwAX+p52ld2iIIg1GAlvdIuODiY8ePH4+rqSv/+/Tl//rx+n7m5OQ0aNDBwhEWVOpEquGJv27ZtXLlyBUBcsScINYSFpTEvD2tJ4OVo/th+mcT4TH5acZzmrevwzAuNK2QwuqTVkpuYhCYjHZlSidraBqW5WbnXKwhC9XHhwgXS0tJIS0vj9ddfL7SvdevW/PTTT+Ueg0wq5WyazZo1Izc3V8wh9RDdu3cH8vtuBaG6ysnOY9/v1zh9NBTIX4rmhVebUa+B4Vun8lJSiDv4H4mnTpN2PQhddnah/UYOtbDyaYL9Ux2xbuaL7CFzyQhCdZednU1ISAj16tXD2LjmjYeqbA97f0vy/V3qFqmnnnqKAQMG0KlTJ+TyUk+QLghCFWdkrOK5/k3xaeHCr5vPk5SQyU/Lj9OmUz26PdfQIGOnsmNjCf9lG7H7DyBpNPrtMoUCpbkZOo0GbUYmObFxxO4/QOz+Axg5OOD68kvU7t5NJFSCIFSaUidSS5cuLbItLS2N8+fPk5SUROfOnStsDgdDCg4O5r333iM9PZ3atWszf/58HBwcKjssQah0bvVtGfNOJ/buDuDMsTBOHAoh+FocfV9vjnMd61KdU5eXR/i2HYT/sk2fQJk38KBWl85Y+TbFtI4rsjt/qGkys0gLDCTp1BniDh4iJzaW4GUriNixiwYTxmLl08RQL1UQBOGxlbpr737Lli1j1apVZGdnI5PJ2Lp1K02aNGHYsGF06NCB0aNHG6Kacjd48GCGDBlCz549Wbt2LYGBgcydO7dU5xJde0JNFXQ1ht1bLpKeloNcLqPbcw1p17l+ieadSgu6QdDXS8gKDwfA0qcJ7oNew7Jxo0ceq83JIWbPXm7/vA1NaioAjr2eoe7woShMTEr3ogShihFde+XLUF17BumT27BhA8uWLWPAgAGsXLmy0GRaXbt25cCBA4ao5oFCQ0OZOXMmL774Io0bN6Z3797FlgsJCeGNN96gefPmtGvXjtmzZ5N9zxiM+Ph4goODeeaZZwAYOHAge/bsKdfYBaE68mxUm7HvdqaRrxM6ncQ/v11l05qTZKQ/eoJASZKI3P0bl6bPICs8HJWVFV5Tp+Aze9ZjJVEACiMjnPv0puWKpdR+pgcA0X/t4cLU6WTeDi/TaxMEQSgJgyVSw4cP58MPP6Rjx46F9rm7uxMaGmqIah4oKCiIgwcP4u7urp9u/n6pqakMGzaMjIwMFi9ezLRp09i9ezcffvihvkx0dDROTk76WVPNzc1RqVQkJSWVa/yCUB2ZmqkZMNSP5wc0RamUc+NaHN8tOMStG/EPPEaTmUXg3HmErP4eSaPBrl1bWiz7hlpPdSjVTMlKMzMaTBhHk88+QWVjQ1Z4OBemTiPuvyNleWmCIAiPzSDzSN2+fZunnnqq2H1mZmak3ml6Ly/dunWjR4/8v0qnT5/O5cuXi5TZvHkzqamp7Ny5E1tbWyB/FvapU6cybtw4PDw8HjgtfWmnwheEmk4mk9GynTuudW3Y9uNZ4mPT+WnFcTo97UWnpz0LdfXlJCRy9bMvyAgJQaZUUm/kMByfe9Ygv1/Wvk1p/vV8rs9fRMqly1yfv5CsiAjqvPKy+P0VBKFcGaRFysLCgvj44v8KjYiIwM7OzhDVPNDjXDV46NAh2rVrp0+iAHr27IlarebgwYMAODk5ER0drU+o0tPTycvLw9raulziFoSaoraTJaPe6kjzVnWQJDi45zqb1p4iOysPgIzQMC6+9z4ZISGorKxo+sVnOD3/nEGTHLW1NU1mzcSl34sA3N60hRtLvkV3z1WAgiAIhmaQFql27dqxevVqunfvrp+IUyaTodFo2LRpU5HuvsoQHBxM//79C21Tq9W4ubkRHBwMgL29PfXq1eOff/7h6aefZuvWrTz99NMPPW/BgLTiREVF4eTkVPbgBaEaUBspeeHVZrg3sOP3Xy5y42osqxb9x3PtLYlb+Q3azExMXF1oPHMGxrVrl0sMMoWCusOHYuzoSPDKVcTu209uQgLe095FaSoGoQuCYHgGaZGaPHkykZGRPP/883z55ZfIZDLWr1/Pyy+/TGhoKOPHjzdENWWSmppaZNVpyF+JOiUlRf/8k08+Yfny5fTs2ZN9+/bxzjvvVGSYglDtNfN3ZcSkDljZmJCUkMmmX28TKXfAskljmn75ebklUfdy7PUMjWZMR25kRPL5CwR88ima9Iev3yUIglAaBmmRcnd3Z9OmTcyZM4dNmzYhSRK//vorbdq0Yf78+Tg7OxuimnIhSVKh7gVPT0+2b9/+2Mc/7NLIh7VWCUJN5uhiybN1E9gTkUSiqQuXHbti3qYuTUwrbokXW/+W+Hz+KQGffEZa4HUuf/QxTWbNRFXMH1SCIFRf06ZN49y5c8TGxqJSqfDy8mLcuHEV1htmkEQKoEGDBqxZs4bc3FySkpKwsrKqUvNeWFpaFjvoPS0t7YFX+gmCUHI6jYbgZSuI2/8vzZER2/5VLscac/zQLeJiMxgwxA8j4/Jfqw/AwrMBPp/P4srMWWTcDOHyh/nJlNrGpkLqFwSh/Gk0Gt544w3c3NzIzs5m69atjB49mh9//BF/f/9yr98gXXuJiYn6x2q1mtq1axdKogoWNa5MHh4e+rFQBXJzcwkLCxOJlCAYiCYzk6uffUHs/n9BLqfBuNG8NG0AA4b6oVTJCb4Wx9olR0lOzKywmMzq1sXni89Q29qSGRrG5RkzyRVTmghCjbFgwQJeeeUV2rVrR9euXVm8eDEODg78+uuvFVK/QRKpcePGkZNT/ER8QUFBvPHGG4aopkw6derE8ePHC80JtXfvXnJzc+ncuXMlRiYINUNOfAKXps8g+fwF5MbGNJoxHcde+ZPbNm7mzPAJ7TG3NCIuOo013xwmPLTikhlTV9f8ZMrenqyISK7MnEVeOU/LIghCYdOnT6d3796cOHGCvn370rx5cwYMGFDslEVloVAosLCwQFNBV+waJJGKj49n6tSpRbaHhoYyYsSIcm/xycrK4q+//uKvv/4iIiKC9PR0/fOC1rJXX30VCwsLxo8fz3///cfOnTv57LPP6NOnj2iREoQySr8ZwsX3ppMZGobKxpqmX3yGrX/LQmWc61gz6n8dqe1sSUZ6Lj98e4wr5yIrLEYTJ0d8Zn+S3zIVdpsrMz9Fk55eYfULggBxcXHMnj2bN954g0WLFpGdnc3EiRPJy8ufKkWr1aLRaB5602q1Rc4rSRIajYakpCTWrFlDaGgoAwcOrJDXZJAxUt999x2vv/46c+bM4f333wcgMjKS4cOH4+DgwMqVKw1RzQMlJCTwv//9r9C2guc//vgjbdq0wdLSkh9++IHZs2czadIkjI2N6d27d7EJoCAIjy/x9BkC5y1El52NSR3X/OkNHrDQt6W1CSMmtmfb+rMEBcSybf1ZEhMy6Ni9QYVMnGni5ESTzz7m8gczyQgJ4cons2ny6UyUpqblXrcgGJIkSeRocyulbiOFutS/rykpKaxfvx5PT8/8cxkZMWLECC5cuIC/vz/Dhw/n5MmTDz2Hi4sL+/fvL7Rt69at+pVKTE1NWbRoES1atChVjCVlkETKw8ODJUuW8MYbb+Di4sJzzz3H8OHDMTMzY+3atZibmxuimgdydXUlMDDwkeXq1avHmjVryjUWQXiSRP3xFzdXrQGdDivfpjSc9i5K84dfmac2UvLKiFbs3R3AiUMh/PtnIGkp2fTq54O8BIsel5apqytNPv2Yyx/OJD0oiIBPP6fJxx+KxY6FakOSJGbum09gws1Kqd/b3oNPu71TqmTKwcFBn0QB+h6hmJgYAGbNmkVGxsOnKlGr1UW2de/enYYNG5KUlMSff/7JW2+9xdKlSytk6I7Brtpr3bo1s2fP5oMPPmDdunUolUq+//57MSu4INRAklbLrXU/ErnrNwAcenTDY+xo5KrHuxpPLpfR88Um2NqZ8efOy5w+GkpGeg79Xm+BUqUoz9ABMKvrTpNZH3P5o49Ju3qNa3Pn0+jD95ErDfZfoiCUr2q69NH98zmq7vyfUTDO2t3d/YHLtRUoLoGztbXVr1zSqVMnkpKSmDdvXtVOpJKTk4ts69y5M4MHD2b37t2sXr0alUqlLycSKkGoGbRZWVxftJjEE/nN7+5DBuHSv1+p/jpt1bEuZhZqdmw4z9WL0WRmnOCVEa0wNin/6RHMPerT5OOPuPzRJySfO8+NJcvw/N8kZI+x5JQgVCaZTMan3d6pll17j1Larr37NWnShCNHKmbx8lInUm3btn3gGylJUpHlWK5evVraqgRBqCKyoqK49sVcMsNuI1Op8PzfJGo91aFM52zczBkTMzVb1p4mNDiRH5Yd5fU322BhVf7z0Fl4e9Fw2lQCZs8h7sAhVNbW1BsxrNzrFYSykslkGCuNKjsMgytt1979zp49S506dQwV1kOVOpGaMGGCWFVdEJ4gSWfPETh/EdqMDFQ21jSc/h6WDb0Ncu56DewZPqEdG1edJCYqjbVLjjB4TBvsapXv+EoAm5Z+eE6aQNA3S4jcuQu1tbV+4WNBECpW/fr1S1T+wIED7Ny5ky5duuDk5ERKSgq7du3i6NGjLFy4sJyiLKzUidSkSZMMGYcgCFWUJElEbNtB6PqNIElYeHvjPW0qRna2Bq3H0cWKEZM6sOG7EyTGZ/DDsmMMHtsWB0cLg9ZTHIduXchLSeHWuh+5te5HVFZWOHTrUu71CoJQNnXq1CE3N5cFCxaQlJSEjY0N3t7e/PTTT7Ru3bpCYpBJjxrVJZRawVp7D1uPTxCqsryUFIIWLyPp9BkAaj/Tg/qjRz32oPLSyEjLYf3K48REpWFiqmLwmLY4uVqVW333Cvn+ByJ37gK5nMYffYCNX8VcPi0IxcnOziYkJIR69epVqSXXaoqHvb8l+f4u9ajKPn36cP369ccur9Pp6NOnT5FlWgRBqJpSLl3m/FtTSTp9BplKhcf4MTSYMK5ckygAMwsjho5vh3MdK7Iy8/hx+TFu36qYWdDrDhtCrS6dQKcj8KsFZISGVUi9giBUX6VOpIKCgsjOzn7s8pIklfgYQRAqnqTVErZxM5c/+oTcxERMXF1oNv9LHHs+U2ExmJiqGTK2LXXq2ZKTrWH9yuOE3Igv93plcjkNJo7H0qcJ2qwsrn72uViXTxCEhyrTpCkTJkx4rNHzBcTgdEGo2jJCwwj6ZikZd1qOHXp0o/6bb6CohG4FI2MVg95szc/rTnPzejybVp3k5eEt8WxUu1zrlatUNJz2LhenvU92ZBRXP5+Lz+ezUBjVvCukBEEou1InUv369SvVcTY2NqWtUhCEciJptYRv38ntzT8jaTQozMzwGPsmtTo9ValxqY2UvDqyFVt/PMv1gBi2fH+al4e2xNvHsVzrVVla0PijD7j43vukBwUR9M0SvKdOEXNMCYJQRKkTqTlz5hgyDkEQKkla4HWCV64iIzh/uQmbVi3xGDfW4FfllZZSpeDl4S3ZseEcARei+OXHMwwc7o9X4/JtmTJxdqbh9Pe48vGnJBw5RpjTJtyHDCrXOgVBqH7En1eC8ITKS03lxtLlXHzvfTKCb6IwM8PzrUk0mvF+lUmiCigUcl4a1ILGzZzQaSV+WXeG6wEx5V6vlU8TGkwYC0D41u3E/nug3OsUBKF6EQtLCcITRpeXR/Rfe7i9+Wc06ekAOHTrivuwIaitK2aagdKQK+T0G9QCSYKrF6P4Zd0ZBo4o/zFTDt26khURSfjW7QR/uxJTNzfMPUo2aaAgCDWXaJEShCeEpNMRe+AQZ8dPJmT1WjTp6ZjVq0vTLz/H838Tq3QSVUChkPPS4BY08nVEq9Xx8/dnuHEtttzrdXv9VWxa+qHLzeXanLnkpaSUe52CIFQPIpEShBpO0mqJP3yEC1PeJWjRN+TExqKyscFj/BiaLfgKy0YNKzvEEslPpvxo2DQ/mdry/elyT6ZkCgVeU97C2NmJnLh4AuctRNJqy7VOQRCqB5FICUINpcvLI3rPXs5OmEzgvIVkhNxCYWaK+5BBtFy5DMeezyBTKCo7zFJRKOT0H+yHt09ttJr8ZCo4MK5c61Sam9Ho/WnIjY1JuXSZW+t+LNf6BEGoHkQiJQg1TE5cPGEbN3P6zXEEL1tBdlQ0Sgtz6rz2Ci1XfovrgJdqxJxICqWcAUNa4t2kIJk6RdjNxHKt09StDl5vTQYgctdvxB44VK71CYJQMuvWrcPb25sxY8ZUWJ0GSaQuX75siNMIglBKklZL0pmzXP3iS06PHsftLb+Ql5SE2s6WuiOH479qBW6vDkRlUf4LAFckhVJO/6F+eDSshSZPx6Y1J4m8nVyuddq1a4PrwAEABC9bTmaYWEZGEKqCuLg4li1bhp2dXYXWa5Cr9gYMGECzZs0YNGgQzz77LKpyXotLEIT8weNpgdeJO/QfCUeOFRoAbenTBMdePbFr27rc18arbEqlgoHD/Nmw6gRhNxPZ8N0Jho1vh4OTZbnV6fbaK6RfDyL5/AWuzV1AswVzK2X2d0EQ7po3bx7dunUjMjKyQus1SIvUl19+iU6n47333qNLly58/fXXREdHG+LUgiDcQ5uTQ+LpMwSvWMXpN8dxafoMov/4i7yUFJSWljj1eZ4Wy76h6eefUuupDjU+iSqgUit47Y3WOLtZk5WZx/qVJ0iISy+3+mRyOZ5v/w+1rS1Z4eHcXLmq3OoShJpi+vTp9O7dmxMnTtC3b1+aN2/OgAEDDNKrdfr0af755x/eeecdA0RaMgZpkerbty99+/bl4sWLrF+/nrVr17J69Wq6du3K4MGDadOmjSGqEYQnjqTVknErlNSAAJLPXSDl0mV0ubn6/QoTE2zbtqFWp45Y+TZFrnxyp4YzMlYy6M3W/PjtMWKi0vhpxXFGTOyAlY1JudSntrbCa+pbXP7wE2L3H8DSpwm1u3crl7oE4X6SJKHLyamUuuVGRqVeOzcuLo7Zs2czevRozM3NWbBgARMnTmTv3r2oVCq0Wi2SJD30HDKZDMU9F8potVo+++wzxo4di4ODQ6niKguD/q/r6+vLV199xfTp0/n555/ZsmULw4cPx8PDg8GDB9OvXz+MasAgV0EoL3kpKaQH3yQ9+CapAVdJuxaINjOzUBm1vT22/n7YtPTDqplvjRg4bigmpmoGjWnLD8uOkhCXwU8rjjFsQnssLMun282qSRPcXn+VsPUbubliFRaeDTB1cyuXugShgCRJXJo+g7RrgZVSv0WjhjSdM7tUyVRKSgrr16/H09MTACMjI0aMGMGFCxfw9/dn+PDhnDx58qHncHFxYf/+/frnGzduJDMzk+HDh5c4HkMolz9f1Wo1xsbGqFQqJEkiKyuLTz75hOXLl/PNN9/QvHnz8qhWEKoNTWYW2VFRZEVEkBUeQUbILdKDb5KbkFCkrMLUFMtG3lj6+GDT0g9Ttzql/mvwSWBuYcSQsW1Zt+woifGZrF+ZP2bK1ExdLvW59u9H6uUrd8dLzf8ShUn5tIIJgl41/T/AwcFBn0QBeHh4ABATk7/k06xZs8jIyHjoOdTqu7/LCQkJLF68mLlz5xbaXpEMmkhdu3aNjRs3snv3bvLy8ujVqxfz58/H19eXa9euMXPmTGbOnMmuXbsMWa0gVDnanBxy4uLJTUggJz6e3IREcuLiyI6KJisiktzEB1ymL5Nh7OSEef16WDT0xrJJY8zc3artfE+VxdLahMFj8pOpuOg0Nq46weAxbTE2MfyYsYLxUhfenkpWeDgha9bRYOI4g9cjCAVkMhlN58yull17lpaFLwIpuDgt585rcXd3f6yuvQLffPMNXl5e+Pv7k5qaCoBGo0Gj0ZCamoqpqSnKch7yYJCz//HHH2zYsIGzZ89ia2vLiBEjeO2116hVq5a+TMOGDXn77bcZNWqUIaoUhAqh02jQZmXduWXn32dmkpeaiiY1jbzUVPJS09CkppKXln+fm5SEJu3RA51VVlaYuDhj7OyMWV13zD3qY1q3LkpT0ZphCLb2ZgwZ05Yfvj1G5O0UNq89xaA326BSGz4pVVtb4TXlf1z+6BNi9v6Djb8fdm3F2FCh/Mhkshp5pWhJu/ZCQkI4ffo0rVq1KlKuVatWrFq1ik6dOpVLrAUMkkhNmTKFxo0b88UXX/D8888/sHnN1dWVF154wRBVCgYmSRIU3O7flv/k7rZ7niNJdx7eWzb/n/zj9We7p+w95aW79Ug6LZJWBzodkk6HpNXq7/Xb7i9z//6CYzRadHl5SHl56O7cpLw8dLm56PI06PJykfI0+c81eehy8/cXJE2azPx7KS+v1O+p3NgYI3t7jOztUNvbYWRnh7GjIyYuzpi4OKM0Ny/1uYXHU8vRgkGj2/Dj8mOE3Uzk5x9O8+qIViiUhp+L2KqpDy59XyBix6/cWLocCy8v1LY2Bq9HEGqyknbtffDBB/qWqAJffPEFxsbGTJkyBW9v73KJ814GSaQmT57M0KFDMS/miyEjI4OAgABatWpFnTp1mDNnjiGqfKLpNBouf/gxmbdCCyc2D0qC7uyX7nvOI5pPhbtkKhUKExMUJsYoTU1RWligsrREaZl/r7K0QGlphcrSApW1NUb2dihMTcVYpirAydWK10a1ZsN3Jwi+Fsf2DefoP7gFcoXhkym3Qa+RfP4iGSEhBC1ZRuOZM8RnQBBKoH79+iUq36hRoyLbLC0tMTU1rbAZAwySSC1ZsoSOHTvi6+tbZF9ISAhDhw7l6tWrhqhKAKS8PLLCI9BmZVV2KGUjk+kHTMrkcmRyOcjlyBRyZHLFPc/zH+dvv39bMeUKHqtUyNUq5Mr8e5lKhbzgplYjUymRq9TIVco7+9QoTIzvJEz33oyfmPmYaiq3erYMHO7P5jWnuHoxit9+UdJnoC8yuWGTHLlKhdeU/3HhnfdIPnuO6D/+xOn55wxahyAIVYtBEqmHDQzTaDTI5WJJP0NSmJjgv3oFuUnJwJ1cJP8fuPO9INM/L9iQ/49MdrdMwTGy+57nH6bfmF++YN+99d3zl7bsvufIZIX/Er+zX/x1LlQWD+9avDS4BVt/PMP5U7cxMlbyzIuNDf6ZNHWrg/uwIYSsWsOtdT9h1bQppm51DFqHIFRHX375ZZFttra2BAYadhqHn376yaDne5RSJ1Lp6emF+iXj4uKKTMuenZ3Njh07sLe3L32EQrEUxsaYODlWdhiCUK008nXihVea8evmC5z4LwQjYyVdehl+DIXT88+SdOYsyWfPcX3RN/jO+/KJnixVEGqyUv9mr1u3jmXLlgH5rRETJ04stpwkSRW6CrMgCMLDNGtVh5wcDX/tuMKhvUEYGStp18XDoHXIZDI8J03g3OS3yLgZQsS2HdR55WWD1iEIQtVQ6kSqQ4cOmJqaIkkS8+bNY/DgwTg7Oxcqo1ar8fLyonXr1mUOVBAEwVBad6xHTraGf/8MZO/uqxgZK/Fr627QOtS2NtQfPYrrC77m9s9bsW3TCrO6dQ1ahyAIla/UiVSLFi1o0aIFAFlZWbz88svUrl3bYIEJgiCUp47dG5CTreHov8H8tvUSaiMlPi1cDFqH/VMdiT98lMQTJwlavAzfr+aILj5BqGEMMgp84sSJIokSBKFakclkdH++IS3buYMEOzee53pAjMHr8Bg3GqW5ORnBN4nYvtOg5xcEofKVOpGKjIwk785khZGRkY+8CYIgVDUymYznXvKhqZ8LOp3ELz+cIeRGvEHrUNvYUO/NkQDc3vILGaFhBj2/IAiVq9RtzN27d2fLli34+vrSrVu3R15CLOaREgShKpLJZbzwajNyczQEXolhy9pTDB7TFld3w81KXqtzJ+IPHyXp1GmCvllKs3lzxPqJglBDlDqR+uKLL6hTp47+sZgfSBCE6kqhkNN/iB+b1pwiJCiejatOMmxCO2o7WT764MeQ38U3hnMBV8kIDiZ8+07qvNzfIOcWBKFylTqR6tevn/7xSy+9ZJBgBEEQKotSpeCVEf78tPI4EaHJrF95guET2mFXyzBrIhrZ2VJ/1EiCvlnC7c0/Y9emtZioUxBqgDKNkSrJTRAEoapTGyl5fVRrajtZkJGWw/qVJ0hJMtxSTLW6dsampR+SRsONpd/mL7gtCEK1VuoWqccZF3UvMUZKEITqwMRUzaAxbflh2VES4jJYv/I4wye0x8zCqMzn1nfxTXqLtMDrRP72By4v9jFA1ILw5OrWrRsRERFFtl+8eBEjo7L/3j5KmcZIiXFRgiDUROYWRgwe05bvlx7JT6a+O8HQcW0xMVWX+dxGteypO2Iowd+uJGz9Rmxb+2Pi5GSAqAXhydWzZ09GjhxZaJtaXfbf18dR6kRKjIsSBKEms7IxYcjYtqxbdoyYyFQ2rT7F4DFtUBuVfULN2s88Tfzho6RcvMSNpcvx+ewTZGJxd0EoNXt7e5o3b14pdYvfXEEQhAewq2XO4NFtMDZRER6axJbvT6PJK/u4JplMRoMJY5EbGZF6+QrRf+81QLSCULVNnz6d3r17c+LECfr27Uvz5s0ZMGAAly9fruzQykRMyCkIgvAQtZ0tef3N1qjUCkKC4tn201m0Wl2Zz2vs6Ij7kNcBCP3hJ3Li4sp8TuHJIUkSuTmaSrlJklTquOPi4pg9ezZvvPEGixYtIjs7m4kTJ+rzCa1Wi0ajeehNW8xFGrt378bHx4cWLVrw5ptvEhgYWOoYS0pMyCkIgvAIru42vDqyFRtXnyTwSgw7N56n3+vNkSvK1qjv9NyzxB8+Stq1QG58u5LGM2eIsafCI0mSxPdLjxJ+K6lS6q9T14bhE9uX6rOakpLC+vXr8fT0BMDIyIgRI0Zw4cIF/P39GT58OCdPnnzoOVxcXNi/f7/+ebdu3fD19cXZ2Znbt2+zYsUKXn/9dXbu3Kmf77I8iQk5BUEQHkM9T3sGDG3JL+tOc+V8JJIk0W9QCxRlSKZkCgUNJo3n/FtTST57jrh/D+LQrYvhghZqrOr6jevg4KBPogA8PDwAiInJX+dy1qxZZGRkPPQc9w8i//DDD/WP/f396dChA88++yxr1qzhk08+MVDkDyYm5BQEQXhM3k1q8/Kwlvzy4xkCLkQhSRIvDfYrUzJl6uqK26sDCf1pAyFrvse6RTPUNoZbnkaoeWQyGcMnticvt3LmIVOpFaVuPLG0LLxagEqlAiAnJwcAd3f3R3YdPqpuBwcHWrZsyZUrV0oVY0mV/fITQRCEJ4i3jyMDh/vzy7ozXL0YzbafztJ/sB8KZemTKZd+LxJ/9DgZwcEEr1hFw+nvilZ+4aFkMplBriCtakrTtVecsozjKimD/RS0Wi1//vknJ06cIDk5GWtra9q0aUOvXr1QKmveD1sQhIojSRK3UyK5Enud0JQI4jISyMzLQqfTYaIyxtLIAntTG9ysXahj5YyblTMqharc4vFqXJuBI1ry87ozXLsUzdYfzzBgaMtSJ1MyhQLPSeO58M57JB4/QcLRY9h3aG/gqAWh6itN1979YmJiOHv2LC+++KIhQ3sgg2Q4iYmJjBo1ioCAAJRKJdbW1iQnJ/PLL7+wdu1aVq9eja2trSGqEgThCZKek8E/Nw/z782jRKXHPvZxKoUKL7t6NK7lSRMHb7zs66OUKwwam2ej2rwywp8t358m8EoMP/9wmpeHtUSpLF09ZvXq4jrgJW5v+YWbK1dj1dQHlaVhFk0WhOqifv36JSr/22+/ceDAATp16oSDgwO3b9/mu+++Q6FQMGLEiHKKsjCDJFJz5swhJCSE+fPn8+yzz6JQKNBqtfzxxx98/PHHzJkzh3nz5hmiKkEQngC52jx+C/yHXdf2kpmXv9adWqGioX0DvOzr4WBmj4WROXKZjMy8LFKy04hJj+d2SiShyeGk5WZwJfY6V2Kv88uV3zFRGeNbuxEtnHxo4dQEGxMrg8TZoKEDr45sxZa1pwgKiGXzmtMMHN6y1F0uri/3J+H4CTJDw7i5ai3e77xlkDgFoaZydXUlJiaGL774grS0NCwsLGjbti2TJ0+ukCv2AGSSAToS/f39mTRpEsOGDSuyb926dSxdupTTp0+XtZpqp3v37gDs27evkiMRhOrjevxNlp/8iYi0aADcrFx4zqsb7ev4YawyfuTxkiQRkRZNQGwQAXFBXI65RmpOeqEy9azr0MK5CS2cfGhgWxdFGVurbl6PZ8v3p8jL1eLqbsNro1qVejmZtKAbXHzvfdDp8PzfJHEV3xMsOzubkJAQ6tWrh7Hxoz/7Qsk87P0tyfe3QVqkJEkqdDnjvby8vCp00JcgCNWTJEnsDtzLhos7kSQJa2NLhjTrTwd3f+Syxx97JJPJcLV0wtXSiWcadEIn6biZGMa5qMuci7pCcGIoIcm3CUm+zfaAvzBTmdC0diOaOTaimVNj7E1LPgyhvpc9Q8a2ZeOqk4SHJvHDt8cYNLoNFpYl//Kz8GyA26sDCdu4meCVqzD3aoCpq2uJzyMIQsUwSCLVvn17jh49Svv2RQdHHjlyhNatWxuimgqRlJTEu+++S3h4OCqVCl9fXz7++OMKW/xQEJ5E2XnZfHvyJ46HnwWgo3trRrYYiLmRWZnPLZfJaWBXlwZ2dXnZpzcp2alciL7K2ajLXIgOICM3k+PhZ/V1u1o60cyxMc0cG9O4VgPUysf73Xd1t2H4hHas/+4EsVFprFt6lMFj2mJjZ1rimF0HvETK5SukXLxE4LyF+H41B0UFrGIvCELJlbprLzk5Wf84KiqKiRMn8swzz9CnTx/s7e2Jj49n9+7d7Nmzh6VLl9KoUSNDxVyukpOTCQoKolWrVuh0OqZOnUrjxo0ZNWpUic8luvYE4dHSctL58tAyghJvoZArGNFiIE97PFUhl//rdDpuJN7iQnQA56MDuJF4q1ALukqupMGdQeuNHTzxtKuHsfLhCU1SQgbrV54gKSETc0sjBo9pi4OjRYljy01M4vxb75CXkoJdu7Z4v/eOWNj4CSO69sqXobr2Sp1INWzYsNB/dAWnedC2siwRExoaypo1a7hw4QJBQUHUr1+f3377rUi5kJAQZs+ezZkzZzAxMeH5559n6tSpZfoArl27lvDwcGbOnFniY0UiJQgPl5CZxOyDi4lIjcZcbcZ7HcfRsJZHpcWTnpPBpdhrnI8K4EJ0AIlZyYX2K2RyPGzr0tjBk4b2HjSwrYulcdEkKS01mw0rTxAbnYaxiYpXRvjj7mFX4nhSrgRwZeYsJI0Gl/79qDt0cGlfmlANiUSqfFX6GKkJEyZU2IRxQUFBHDx4kGbNmqHT6Yodc5WamsqwYcNwdnZm8eLFJCYmMmfOHJKTk5k/f36p6s3JyWHHjh28++67ZX0JgiDcJzY9nk/+XUR8ZiJ2JjbM6DwJVyunSo3J3MiMdnVa0q5OSyRJIio9Vj9o/WpsEAlZSVxPuMn1hJv6YxzM7GhgV48GtnXxtKtLPes6WFgaM2xCOzatPkV4aBLrV57gxVeb4ePnUqJ4rJo0psHEcQR9vYSIbTswsrPF6fnnDP2yhSpOjDMuH4Z6X0udSE2aNMkgATyObt260aNHDwCmT5/O5cuXi5TZvHkzqamp7Ny5Uz9nlUKhYOrUqYwbN06/ns9rr72mX9PnXh4eHqxatUr/XKfTMW3aNNq2bUunTp3K42UJwhMrPiORWQe+Jj4zEScLBz7q/D/szarWXHMymQxni9o4W9Smh0dHJEkiLiOBgLggAmKDCEoIISItmtiMBGIzEjgaln9lskImx83KBXcbV9x6uCD9Z07E9XS2bzhHSnIW7bt6lOiPUIeuXciOis6fX+q7Neg0Wlxe7FNOr1qoSgqWT8nMzMTExKSSo6l5MjMzgbvvc2lViynH5Y8xLuDQoUO0a9eu0MSfPXv25IMPPuDgwYP6RGrTpk2PVeesWbNQKpV88MEHpQtaEIRiJWYlM+vA18RlJOBoXouPu76NrYl1ZYf1SDKZDAdzexzM7elSrx0AGbmZBCeGciPxFjcSbhGUeIuU7FT9VYEAWIGjYyPso+uz7/drnLlxlda9XKlr44KDmf1j/f9W57VXkLRawrdu59badeTExlJ3xDDkYtWIGk2hUGBtbU1sbP5ktKampmLpIAOQJInMzExiY2OxtrZGoSjb9CcG+y28desWW7ZsITg4mOzs7EL7ZDIZP/zwg6GqKlZwcDD9+/cvtE2tVuPm5kZwcHCJzvXVV18RExPD0qVLH/mhLehHLU5UVBROTpXbVSEIVUlydiqf/fsNMelxOJjZMbPrW9UiiXoQM7Upvo6N8HXMv5hGkiQSMpMITgolNDmcW8kRhCbdJtrtKrnqLJzCGpMcKGNb9DluN1iDQiXD2dIRV0vH/CkbrPKnbahtXqvQTOwymQy3wa8jNzYmbP1Gon77g9SAq3iMG4OFV/FTzwg1g6OjI4A+mRIMx9raWv/+loVBEqnr16/zyiuv4ODgQFhYGN7e3iQlJRETE4OTk1OFzC6amppaZFVpyF9pOiUl5bHPExQUxJo1a6hfv74+MWvfvj3Tpk0zWKyC8CRKzUnnswPfEJEWjZ2pDTO7vl2qOZuqMplMhr2ZLfZmtrRxbaHfnp6bQVhyBOfO3SJ4Xw4WKQ54BHTkludJQnXhhCaHFzqPQq7A2dwBlzuJVf7NEeeXXsTUrQ43Fi8j42YIF9+djrVfC2r36IaVb1NUFkUHvkuShCY9ndz4BHISEshNSCAnPoHcxERyExLRpKWhy81Fm5ODpNWhMFIjNzJCYWyM2t4OI3t7jB1rY1a3LqZ13cU0DBVMJpPh5OSEg4MDeXl5lR1OjaFSqcrcElXAIInUwoUL6dixI4sWLcLHx4fPP/+cJk2acODAAT744APeeustQ1RTKpIklagp1NPTk8DAwMcu/7AR/Q9rrRKEJ0lGbiafH1jM7ZRIbEys+LjLWziYlfwqturKXG1GYwcvGvf0IqJRElu+Pw2p0OzGMzTvbUeWZRLhqVGEp0QRnhZNjiaH26lR3E6NKnQeuUyOk7kD7sNa0vhoOGbnb5J89hzJZ88BoLa3R21thVytRpuTizYri9zERHT39RKUmlyOmbs71s19sWrmi2XjRiKxqiAKhcJgX/yCYRkkkQoICODjjz/W9/XrdDoAunTpwsiRI1m4cCHr1683RFUPZGlpSWpqapHtaWlp+vFRgiBUvOy8bOYcWkZI8m2sjCyY2eUtHC0cKjusSuPiZsOotzry8/enibydwsmtsfTq14QX2z8DgE7SkZBZkFhF37mPJDw1mixNNhFp0UQQzdFGYOVqQ5PgbBrczsEmTUtufDy58fHF1qu0tMTIzg61vS1qWzuM7O1Q29qisrJEbmSEXK1GplCgy81Bl5OLNjOTnIQEcuLiyQqPIONmCHkpKWSEhJAREkLEjl+RGxtj29qfWk91xLpFc+RlHLQrCNWRQRKp1NRUrKyskMvlKJXKQgmNj48Py5YtM0Q1D+Xh4VFkLFRubi5hYWFFxk4JglAxcrV5fHV4BdcTbmKmNuXDLpNxsSz7mITqztLKhGET2rN7ywUun4vkj22XiYlMo1e/JigUcmqZ2VHLzI4WTj76YyRJIjErmfDUKG6nRBGeGkVEShTnbaM42jwLda4OuxQtxrk6FFoJjUKGRiXHxNYeO2c33BzqUt+mDk42bqVetDknIZHUy1dIvnCR5PMXyE1IIP7QYeIPHUZpYU7tp3vg2KsnxrWf3ERZePIYJJGqXbu2fqZzd3d3Tp06RYcOHQAIDAzEzKzsyzw8SqdOnVi+fDlJSUnY2NgAsHfvXnJzc+ncuXO51y8IQmEarYaFR77jcmwgxkojZnSahLu1WDOugEqloN+gFtR2tmTfH9c4cyyU+Ng0BgxpiZlF0e4ymUyGnakNdqY2NHNsrN8uSRJJ2Sn53YIF3YOpUUSlRpGRmwmkEBR7ieOxl/THWBtbUs/GjXo2dahv40Z9W7fHGq9mZGdLrc5PUavzU0iSRHrQDeIOHSb+8BHykpKI2L6TiB2/YtvKH9cBL2Hh7WWQ90oQqjKDJFJ+fn6cPXuWHj160KdPH5YsWUJcXBwqlYodO3bwwgsvlOn8WVlZHDx4EICIiAjS09P566+/AGjdujW2tra8+uqrrF+/nvHjxzN+/HgSEhL48ssv6dOnj+jaE4QKptPpWHzie85GXUatUDH9qQk0sKtb2WFVOTKZjA7dGlDL0YLt688RGpzId4v+Y8DQltSpa/PY57A1scbWxFp/9SDkJ1gp2amEp0YRmhyRPyVD0m3CU6NIzk69s4jz3Tn57Ext8Larj7e9B972Hrhbu6CQP3hMjkwmw8LLEwsvT+qNGErSmbNE/f4nyecvkHjyFIknT2HdvBl1Xh2IZaOGpX+TBKGKK/USMfcKCwsjNjYWf39/tFotc+bMYffu3QB07dqVDz/8EHNz81KfPzw8/IEDt3/88UfatGkDFF4ixtjYmN69e5d5iZiyEEvECE8inaRjxcn1HLh1DIVcwbSO42nu1PjRBz7h4mLS+GXdGeJj05ErZDzzQmNadahr8HmDcjS5hKVEcDMxjJCkMG4mhRGWEolO0hUqZ6Q0wsuuLk0cvPGt3Yj6Nm6PNedVZng4ETt+JXb/AbgzXtamlT/1Rg7DxNnZoK9FEMpLhay1JzyaSKSEJ41Op2P5qZ84eOs4cpmcKe3fpLVr88oOq9rIydaw++cLBFzIv1qvqZ8Lzw9oitqofCfezNbkcCPhFoHxwQTGB3M9IYTMvKxCZcxUJjSpnZ9U+To2wtG81sPPGRND+C/bidm3H3Q6ZEolTs8/S52BL6M0L//hHoJQFpWSSGm1Wv78809OnDhBcnIyNjY2tG7dml69eqF8QmffFYmU8CTR6rQsO/kjh0NPIpfJmdR2OB3cWlV2WNWOJEmcOBTC3t+uIukkHBwteHl4S+xqlb5Vv6R0ko7wlCgC4oK4FHONy7GBZOUVnkLB1dIJfxdfWrk0w8PWHbms+NaqzNvh3Pr+B5LOnAXyrx6s98YIanV+SszSLVRZFZ5IJSYmMmrUKAICAlAqlVhbW5OcnIxGo6Fx48asXr260NItTwqRSAlPCo1Oy9Lj33P09hkUMjn/a/cGbev4VXZY1VrozQS2/XiW9LQcjIyVvPhqMxo2rZyVErQ6LcGJoVyKucbFmGtcjw9Ge09XoI2xFS2dm9K2jh8+Dt7FdgEmnT1HyNp1ZN3On3zUpmUL6o8djbGDuMJPqHoqPJF69913+eeff/jss8949tlnUSgUaLVa/vjjDz7++GO6d+/OvHnzylpNtSMSKeFJkKPJ5ZtjazgdeRGFXMGU9m/SyqVZZYdVI6SlZrPtp7OE3UwEoM1T9ejRuxEK5aPHKpWn9NwMzkVe4VTkBc5HXSFbk6PfZ21sSXs3fzq6tcLD1r1Qq5MuL4+IHb9ye8svSBoNcmNj6g4fgmOvnqJ1SqhSKjyR8vf3Z9KkSQwbNqzIvnXr1rF06VJOnz5d1mqqHZFICTVdWk46c/9bzvWEm6jkSqZ0GE1L56aVHVaNotXq2Pf7NY4fvAmAcx0r+g9piY2daSVHli9Pm8eV2OucCD/PifBzpOdm6Pc5mTvQuV5butRrV2hNxczwcIKXrSA14CoANv4taTBpAmrr0s1vJQiGVuGJVMuWLVmyZAnt27cvsu/o0aNMmjSJM2fOlLWaakckUkJNFpuRwBcHlxCZFoOZyoRpT42nYa0GlR1WjRV4JYZdm8+TlZmHkbGSF15pRiPfqrUoukar4Xx0AIfDTnE64gK52vy14eQyOS2dm9K9fkeaOzZGLpcj6XRE/f4Ht35Yj5SXh8rKCs//TcSmpegSFipfhSdSkyZNwt3dnalTpxbZN2/ePG7evMny5cvLWk21IxIpoaYKiL3OwqOrSM1Jx87UhhmdJuFqVbW+1GuilKQstv10lvDQJABadajL0y80QqmsemuwZedlcyL8PPtuHuZa/N1VJ+xNbXmmQSd61O+IuZEZGbdCub5gEZlhtwFweakv7oNfRybWlRMqUYUkUgUzmQNERUUxceJEnnnmGfr06YO9vT3x8fHs3r2bPXv2sHTpUho1avTgk9VQIpESahpJkvgz6F9+PL8NnaSjrrUr05+agK2pdWWH9sTQanX8+2cgR//NT06cXK3oP8QPW/uqO6VAeEoU/9w8zMFbx+/Mtg5GCjVd6rXjOa9uOKitCP1hPVG//wGAVVMfvKa+jdrauhKjFp5kFZJINWzYsNDgwILTPGjb1atXS1NNtSYSKaEmyczLYs2ZzfwXehKAju6tGeM/CCOlupIjezIFXY1h58a7XX19BvrSuFnVnvAyV5vH0bDT/H59P6HJ+VfvyZDR0sWXvg2fwfZaFEFLvkWXnY3azhbv96Zi2dC7kqMWnkQVkkgtWbKkRFdZTJw4sTTVVGsikRJqisD4YJYc/57YjATkMjlDmr3Ec17dxJVWlSw1Ob+r7/at/K4+//buPPNCY5Sqqt0tJkkSV2ID+S1wH2fvWaammWMjXrT2J/e7zWSFRyBTKqk/5k0cn+lRidEKTyIxs3kVIRIpobrL0eSy9crv7ArciyRJ1DK1ZVLbEWJQeRWi0+r49+/rHNl3AwBHF0v6D/Gr0Ak8yyIiNZrd1/Zy8NZx/dxUzW086HE8nbwz+QstO/d9gbpDB4txU0KFEYlUFSESKaE6Oxd1mTVnNhObkQBAp7ptGNniFUzVJpUcmVCcG9di2bnxPJkZuaiNlPR52ZcmLap2V9+9YtPj2XH1bw6EHM1PqCSJF26ZUu9YKAC2bVrhNeUtFJW0dqrwZKnURCokJES/REzdunUNeepqRyRSQnUUknSbTRd3cj46AAA7Uxve8HsFfzHJZpWXmpLF9vXn9BN4tmznxjMvNkFVxbv67hWXkcCOq3/zb8hRtDot3reyeeZEOnKtDrP69Wj04fsY2dlVdphCDVcpidSff/7JV199RXR0tH6bo6Mj06ZNo1evXoaootoRiZRQnYSnRLE14A+OhuVPnquQyXnWqxsDmzyPsUq0AlQXOq2Og3uC+G9fEEhQ29mSAUOrT1dfgej0ODZd/JVjt8/gFJdH70MpmOboUNna4DNrJqZubpUdolCDVXgidfDgQcaOHUuDBg148cUXcXBwICYmhl27dhEcHMzy5cvp3LlzWaupdkQiJVR1kiRxMeYqvwXu48KdFiiAjm6tGNi0D47mtSoxOqEsggPj2LHxHJnpuaiNFPQe4IuPn0tlh1ViQQkhrL+wnYiQQF44kIxdqhbJ1JimMz/E6gmcVkeoGBWeSL366quYm5vz3XffFVqsUpIkRo0aRUZGBps3by5rNdWOSKSEqio2PZ5DoSc4dOsE0elxQP5l6K1cmjGgyXPUtalTyREKhpCWks32DWcJDc7v6vNr60bPvtWrqw/yv0vORF5ky/GfafP7DZwSNGiVchwmjqJh156VHZ5QA5Xk+1tpiAqvXbvGwoULi6z4LZPJeP3114ud8VwQhIojSRK3ksM5G3mJs1GXCUoI0e8zVhrRtV57nvXqKlqgahgLK2OGjGnLwb1B/PdPEGePhxEemsSAIS2xr119uvpkMhn+Ls1o1rcxv3n8RdjKzbhFZhP3zXdcDjnPc4Mni4sghEpjkERKLpeTl5dX7D6NRiPmmhGECqbVaQlLiSQwPpjA+GAC4oJIykrR75chw6e2N53rtqW1SzMxBqoGkyvkdO3ljXt9W3ZsOEdsVBqrvv6P3gOa0rSla2WHVyIqhYp+zfsQ92Ubjsz9jFpXInH69STfRb9Np+ET8BMLZguVwCBde8OGDSMzM5OffvoJ43suTc3NzWXIkCGYmpry/fffl7Waakd07QnlLTsvm7jMROIyEghPjeZ2SiS3UyIJT43SLxhbwEihpmnthvg5++Dn1FQs6/IESkvNZseGc9y6kT+lRYvWdejVzweVunp19QFIOh2nln1N3j9HADjc3AyTZ7syvMXLWBpVn9Y2oWqq8DFSp0+fZvjw4VhbW9OrVy/s7e2Ji4tjz549JCcn88MPP+Dn9+St6F1eiZROp+OrIyu4nRyBTCZDhqzwfXHboNjtcmQgkyGXyYCCe+57nn8vKyhb6B7kyO/c391+fzxymRy5TI7izn3+LX+7Qn7vtvtvDzpWjlwuQyFTFCl3/63w+fPLyYqUv+c5suK33znO0C2sGp2WXE0uOdr8m/6xJofMvGxSc9JJz80gLSedtDv3iZnJxGUmkp6b8cDzmqiM8bKrj7d9fbztPfC290CtUBk0dqH60ekkDu29zqG9+Vf1OTha0H+oH7VqW1R2aCUmSRIhGzYS9ct2AI41NeOaf21G+r1Kuzp+ojdEKLVKmf7g1KlTzJ8/n4sXLyJJEnK5HF9fX9555x1atWpliCqqnfJKpDLzshiz631yNDkGPa/weGR3EsviErF7EzQJCUmS0Ek6dHfu7z7X6bdLlO1X0Exlgr2ZHU4WDrhZueBm5UwdK2dqm9kXGbcoCAVCguLZvuEcGWk5qNQKnuvflGb+1aurr8Dtn7cStmETACeamHLc14z2bv6M8n8Nc3XVXcxZqLoqNJHKzs7m6aefZtasWXTr1o2srCxSU1OxtLTExOTJHvxXnl17qTnpxKbH67+s77/XSRJQcM99zwvfFz4WJHT598Wc94Fli9mvk+59nJ84aHW6IomEVtIWSjZ095XR3ldeV0z5+8s89JxI951PVyjJqSwymQxjhRFqhQq1Uo2RQo2JyhgLI3Ms1Gb33JthY2JNLVNb7M1sMVU92b9nQumlp2azY+N5QoLiAWjeqg69+jVBbWSQ4bMVKnz7TkJ/+AmAM43NONzMFDtTWya0GYZPbbHwsVAyFXrVnrGxMTk5OfqkycTE5IlPoCqCpZG5GAdQTh7egqTTJ4jFbb/3Xia72yUqv7d78Z6uQ5lMhlqhwkihRiFXiK4IoUKZWxozaHQbDu8L4uDf1zl/6jYRYUkMGNqSWo7Vq6vP9aW+yFVKQlZ/T8uADMyUJvzdJJHPDnxDn4Y9eMWnDyrRtS2UA4P82dG2bVuOHTtGu3btDHE6QahU+UkOQPUbgCsIJSWXy+j0tBdu9WzZvv4ccTHprP7mcLW8qs+5T29kSiU3V6yi4cV4bC0bssktkV3X9nIx+iqT247E1cqpssMUahiDDKAYO3Ysv//+O0uXLuX69eskJSWRnJxc6CYIgiBUXXUb2DPmnU7U87QnL1fLjo3n+XP7ZbSayuvuLg2nZ3tRb9RIABwOX2NKWhMsjMy5lRzO9L1zOBhyvJIjFGoagww2b9iw4d0TPqBr4urVq2WtptoR0x8IglDd6HQSB/++zn//BAHg6m7DgGF+WFpVryEb946Zqj14IJtrxXAxJv97qFv9DoxsMRC1Ul2ZIQpVWIXPbD5hwgQxtkMQBKEGkMtldH3WG2c3a3ZuPEd4aBKrFv7HS0P8qNfAvrLDe2yuL/VFyssjbONmYtb/zMg33+Cojwe/XP6d/TePEJwYypT2b+Jk4VDZoQrVnMGmPxCKEi1SgiBUZ4nxGfyy7jQxUWnIZNDtuYa07+pRbf5wliSJsPUbCd+aP8+Ux4RxxDVzZfGxtaTkpGGiNGZ8m6G0cW1RyZEKVU1Jvr/FJDOCIAhCsWztzRg5uSO+/q5IEuz7/Rq//HCGnOzilwSramQyGW6DX8e57wsABH+7AqcbSczt+QGNajUgS5PNgiPfseXS7kqd+kSo3gzWIqXVavnzzz85ceIEycnJWFtb06ZNG3r16oVSWf3mJDEE0SIlCEJNIEkSZ46F8dfOy+i0Ena1zHh5uD8O1WSKBEmSCF7+HTF/70GmVNL4ow+w8PVhw4Ud/HY9//9nf2dfJrYdLuZlE4BKmNk8MTGRUaNGERAQgFKpxNramuTkZDQaDY0bN2b16tXY2tqWtZpqRyRSgiDUJOGhSWz94QypKdmo1ApeGNiMJi2cKzusxyJptQQuWETCkWPIjY3x+ewTLLw8ORhynO9ObyBPp8HV0on3nhqHo3mtyg5XqGQV3rU3Z84cQkJCmD9/PhcuXODw4cNcuHCBefPmcevWLebMmWOIagRBEIRK5Opuw5tTntJPkbBt/Vn2/X4Vna7qD7WVKRR4vf0/rJs3Q5edTcCns8m8HU7nem2Z1e0dbEysCE+N4v29X3Ix+sm7ylwoPYMkUv/++y9vvfUWvXv3RqHIn8RQoVDQp08fJk+ezL///muIagRBEIRKZmZuxKDRbWjf1QOAI/uD2bzmJNlZVX/clFylouH0dzH39ESTls6Vjz8lJy6OBnZ1+fLp9/G0q0dGbiafH1rCnhsHKztcoZowSCIlSRKenp7F7vPy8kJcGCgIglBzyOUyevRuRL9BLVAq5dy4Fseabw4TH5Ne2aE9ksLEhMYzP8DE1ZXchASufPwpeSkp2JhY8XHXt+lcty2SJLH6zGbWX9guBqELj2SQRKp9+/YcPXq02H1HjhyhdevWhqhGEARBqEKa+rkwfGJ7LK2NSYjLYM3iw1wPiKnssB5JZWlJk1kzMaplT1ZEJAGffYE2Oxu1QsX41kN5xacPALuu7eXrY2vI1Vb91jah8hgkkRo/fjx//vknc+fOJSAggNjYWAICApg7dy5//fUXkydPFsvFCIIg1EDOdax5862ncKtvS062hs1rT/HfP0FVvifCyN6Oxp/MRGlhQXrQDQLnL0TSapHJZPRv8hwT2wxHIVdw/PZZPvv3a1Jzqn5rm1A5ynWJmIJT3z9525OyXIy4ak8QhCeFVqPj71+vcPpoKACNmznxwivNUBtV7elvUq8FcuWjT9Dl5lK75zN4jBut/866Enud+YdXkJGXhaN5LT7oNBFHMRP6E0EsESMIgiBUKIVSznP9m+LoYskf2y8TcCGKhLgMXh3ZCiubqjs3k2VDb7ymvMW1ufOI+XsPxg61cB3wEgBNHLz4rMe7zDm0jOj0OGb88xXvd5pIA7u6lRu0UKWIJWLKkWiREgThSRQWksgvP5whIy0HMwsjXhnhj6u7TWWH9VCRv/1ByKo1AHi+PRmHLp31+5KzUpj733KCk0IxVhrxbsexNK3d8EGnEmoAsUSMIAiCUGnc6tky6n8dqe1sSUZaDj9+e4wr5yMrO6yHcu79nH4pmRtLviX54iX9PmsTK2Z2fYumtb3J1uQw59AyToSfq6xQhSpGJFKCIAiCwVnZmDB8Qns8Gzug0ejY9tNZDu29XqUHodcdNgS7Du2RNBquzfmKjFuh+n0mKmOmPzWBNq4t0Og0LDy6in3BhysxWqGqEImUIAiCUC6MjJW8MqIVbTvXB+DAX9fZufE8mjxtJUdWPJlcjtdbk7Bs0hhtZiYBn84mJyFBv1+lUPF2u1F0q98BSZJYeXoDv17dU4kRC1WBSKQEQRCEciOXy3jmhcY8P6ApcrmMS2cj+GnFcTLScyo7tGLJ1Woavv8eJq4u5CYkcvXzL9FmZ9/dL5czxn8QLzZ8BoANF3ew8eLOKt3SJpQvkUgJgiAI5a5lO3def7MNxiYqbt9KYs03R4iLTqvssIqlsrCg8UcfoLS0JCP4JkFfL0bS3Z3hXCaTMahZPwY36wfAzqt/s/7CdpFMPaFEIiUIgiBUiPpe9oyc1AEbO1OSEzNZu+QIN6/HVXZYxTJ2dKTRB9OQKZUkHDtB6E8bipR5oeEzjPR7BYDdgf/ww7lfRDL1BDJ4IpWYmEhkZGSRmyAIgiDY1zbnjckd9TOhb1x1kounwys7rGJZNmpIg0kTAIjYvpOYf/YXKdPLswuj/V8H4I+gf1l7dotYn+8JY5AJOdPT05kzZw6///47OTnF93s/KbOZC4IgCA9naq5m8Jg2/LrpAlfOR7Jz03lSkrPo2L1BlZvc2aFLJ7IiIgj/eSvB367AuLYDVk19CpXp4fEUcpmClafW8/eNg2h1Wkb5v4ZcJjp9ngQGSaS++OILfvvtNwYMGIC3tzdqtdoQpxUEQRBqKKVSwUuDWmBlY8LRf4P5989AUpOzeLafD3JF1UpA3F5/lezIKOIPH+Hal/Pw/WoOJi7Ohcp0q98ehUzOt6d+5J+bh9FKOsa0GiSSqSeAQRKpgwcP8s477zBs2DBDnE4QBEF4AsjkMnr0boSltTF/7bzCmWNhpKZk03+wX5Vao08mk9Fg8gRy4uJIC7xOwOwv8P1qDioLi0LlOtdri0IuZ8mJdfwbchSFTM6b/q9XuVY2wbAMkirn5OTg5eVliFMJgiAIT5jWHesxcFhLlEo5QQGx/Lj8GBlpVWt6BIWREQ0/mIaRQy2yI6O49uU8dHl5Rcp1dG/NpDYjkMlk/HPzMN+f+1kMQK/hDJJIde7cmTNnzhjiVIIgCMITqGFTJ4aMa4eJqYrI2ymsXXKEhLj0yg6rELW1NY0+/ACFiQmpl68QvPy7YpOkju6tGNdqCDJk/BV0QEyNUMMZJJEaN24cf/zxB99//z23bt0iOTm5yE0QBEEQHqZOXRtGTu6Ata0pSQmZfL/kKJG3kys7rELM3N3wfncKyOXE7ttP5K7dxZbrUq8db965mm934D9subyrIsMUKpBMMkCa3LBh/irYD+sHfhKv2ivJ6tGCIAhCvvS0HDatPklUeApqIwWvjGhFPU/7yg6rkMjdvxGy+nuQy2k8cwY2LZoXW+6voAOsPbsFgIE+fRjQ5LkKjFIorZJ8fxtkNN+ECRPEYDpBEATBIMwtjBg6rh1bvj/FrRsJbFx1kpcGt6CRr1Nlh6bn1Pt5MkJCid23n8B5C2m2YC4mTkXj6+XZBY1Ow4/nt/Hz5d2o5EpebPRMJUQslBeDtEjVRDNmzGDr1q1cuXIFpbJ0+aZokRIEQSg9TZ6W7RvOce1SNDIZPD/AF7+2bpUdlp4uL4/LM2aSFngdE1dXfOfNQWlqWmzZ7QF/svlSfvfeSL9X6OXZpQIjFUqqJN/fBp/gIiQkhHPnznHr1i1Dn7rCHDt2DK22aq5OLgiC8KRQqhQMGNqSFm3qIEnw2y8XObL/RmWHpSdXqWg4/T3UdrZkhYdzfeE3hdbku9dLjZ+lf+P8br3vz/7M4dBTFRmqUI4Mlkj9+eefdO3aleeee47XX3+dZ599lq5du/LXX3+V6byhoaHMnDmTF198kcaNG9O7d+9iy4WEhPDGG2/QvHlz2rVrx+zZs8m+Z8Xux5WZmcnChQuZNm1ameIWBEEQyk4ul9H7ZV/ad/UAYN/v19i7O6DKXAWntrWh4fvTkKlUJJ06TdjGzQ8sO9CnNz0bdEZCYtmJdZyPulKBkQrlxSCJ1MGDB5kyZQrm5ua88847zJ07V/98ypQpHDx4sNTnDgoK4uDBg7i7u+Ph4VFsmdTUVIYNG0ZGRgaLFy9m2rRp7N69mw8//LDE9S1cuJChQ4diY2NT6pgFQRAEw5HJ8ifu7NG7EQDHDtxk95aL6LRVY007C88GNJgwFoDwX7YRf/hIseVkMhkj/AbSwc0fraRj/pGVBMYHV2SoQjkwyGDz5cuX06FDB7777jvk8ru52ahRoxg1ahTLly+nc+fOpTp3t27d6NGjBwDTp0/n8uXLRcps3ryZ1NRUdu7cia2tLQAKhYKpU6cybtw4fQL22muvERMTU+R4Dw8PVq1axdmzZwkLCytVAiYIgiCUr/ZdPTA1U7P75wucP3Wb3FwN/Qa1QFEFlpRx6NqFjFuhRO7cRdDiZRg7O2Nev16RcnKZnAmth5GZl8W5qCt8eWgZs7q9g5u1S8UHLRiEQT59165d4/XXXy+UREF+9v36668TGBhY6nPff87iHDp0iHbt2umTKICePXuiVqsLtYZt2rSJ/fv3F7mtWrUKgNOnTxMQEEC3bt3o1q0bAM888wzR0dGljl8QBEEwnOat6/DysJbIFTICLkTxy7ozaPKqxpjWukMHY928GbqcHK598SV5KSnFllMqlExpPxpvu/pk5GXx+cElxKbHV3C0gqEYpEVKLpeTV8xU+QAajabcp0YIDg6mf//+hbap1Wrc3NwIDn78ZtPRo0czevRo/XNvb2/27Nnz0Kv2Ckb2FycqKgqnYi6HNYTkYzvJjQsDmQyQ57/HMhnICj9GJrvzXH5nmwxZoccK/eNHHfuw8+QfKweFAplMgUyuALk8/15x5/md7TKFAuQKZHL5nXvl3bJ3thds08ckCIJwR8OmTrw6shU/f3+a6wExbF57mldG+KNSKyo1LplCgfe7U7jw7vT8ZWTmzqfJpx8jL+Y7xEipZlqn8Xy8fyG3UyL57OBiPus+FWtjy0qIXCgLgyRSTZs2ZfXq1XTu3BljY2P99tzcXNauXUuzZs0MUc0DpaamYmlZ9MNnaWlJygP+IqjOtFnpJO5fD1SNwZblTq64J8lSIFMokSlVyBQqZEolyPPvZYq72/Lv7zxXKPXHcH+ZO+XkKiNkSjUylREylRFylVr/XH5nm0xeuf9JC4JwV4OGDrw2qjWb157i5vU4Nqw6wWtvtMbIuHIXO1aam9Pog+lcfHc6qVcCuLXuR+qPGllsWXO1GTM6T2LmvvnEpMfx+cElzOo2BVOVSQVHLZSFQT5xkyZNYvjw4fTo0YNevXphb29PXFwce/bsITk5mR9++MEQ1ZSYJEllas14nC7Jh80x8bDWqrJQmJjj+NqH5MaGgaQDScq/guXO4/znBY91QOH9kiSBTlfssflXwjzgPA+tR0LSaUGnzb/8V6dFunOjyL2u0POCbfmxFqOgDJWcOsoV+YmVPuFSI1ca6R/LlOo7SZcxcrUxcrUJMnXRxzK1SdFtIkkThBKr52nPoNFt2LT6JGE3E1m/8jiDRrfB2ERVqXGZ1nHF861JXJvzFVG7f8e8gQcOXYofJ2xrYs2HnSfz0f4FhCaHs+DId7z/1ASUispNCIXHZ5CflL+/P2vXrmXBggVs2LABSZKQy+X4+vqycOFC/Pz8DFHNA1laWpKamlpke1pa2gOv9KvuTOs3x7R+88oOw6AkSVc0EdPeSbikOwmYVpN/0+QhafNvaDR3Ht+519z/OE9/DFpNoef6MppcdHk5SHduOk0uUl4uUl4O+vRNp0XKyUSbk2nw1y5Tqu9Juu4mWzKVMXIjE+R37guStLvJ2H2PVSbIjYzzkztZ5Q/AFYTy5lbPliFj27J+5QkiwpL5cfkxBo9ui6m5ulLjsmvbBteX+xP+yzaCl63A1M2t2MHnAI4WDrz/1AQ+/nchl2KuseL0eia0HiaGNVQTBkt5W7duzZYtW8jKytJ3tZmYVEzzpIeHR5GxULm5uYSFhRUZOyVUXfljrOTIqlDjjCRJoNXcTbI0OejycpE0uXeSrlx0mnsSsLxcpLxsdLnZSLnZ6HKz7jzOv9flZSPlZKHLy0aXkw06TX49mvxz6jKL/kFQWneTrvzWr7uP72kNUz0oKSvamiZTqsV/7BVA3+qr0yHpNIX+sLi/Nffe58DdMYsU3N/5vZJxd9ud/fl3cn33NwVd4ApltRub6FzHmmHj2/HTyuNER6Tyw/JjDBnTBnNL40cfXI7cXnuF9OCbJJ89x7U5X9Fs4VeoLCyKLVvf1o0p7Ucx97/lHLp1AntTW15t+kIFRyyUhsHbDk1MTCosgSrQqVMnli9fTlJSkn7+p71795Kbm1vqaRcEAe4sxK1UoVCqwMTc4OeXtHn5CVZu1p3E697HxW275/GdZEzKu5Ok3UneCrpIpbxstHnZkGGoaGX5486U6mLv5Ur1fdsKHuePRdOPcdNfZKC4515eeBycXHH3woYHhvOQfXeSEelOl/G93ceFEhBJd6cltLiyxXVTPziRkfTHFN3+wGOk4pOkyicrklzJ5Ir8LmyVcaEubJnaKD8hVxndbUVVGyM3NkNubI7C2Ay5iXn+cyPTcuvGru1syfDx7flpxTHiotP4ccVxho5tW6nJlEyhwGvK/7g4dRrZ0TFcn7+IxjNn5F9wU4wWTj6M9n+dFafWsz3gT+xNbenh0bGCoxZKqtRr7UVGRlKrVi1UKhWRkZGPLO/s7FyaasjKytJPYbBhwwZu377N9OnTgfxWMFtbW1JTU+nduzcuLi6MHz+ehIQEvvzySzp27Mj8+fNLVa8hiLX2hIomSVJ+69a9rWF52ejutIJJufmPC1rNCidod1vO7j9GqAJk8mKubs2/GpaCaWLujFeEu/f6/+Il3Z1e6oKxjneSTa1W3zJaAS8iv6va2By5iTkKMysUZjYoza1QmFmjMLe5s80ahZk1cmOzEreMJcZn8OO3x0hNyca+tjlDx7XD3MKonF7P48kIucXF995Hl5uL64CXcB8y6KHlf768m61X/kAuk/Nex3H4OftUUKRCgZJ8f5c6kWrUqBFbtmzB19eXhg0bPvLDfvXq1dJUQ3h4+AMHbf/444+0adMGyF8iZvbs2Zw5cwZjY2N69+7N1KlTC11FWNFEIiXUBJKky+/CzM1G0ubeGVOWp++OlDR5+ePJ7uzT3fP4bhnNPS0797TcaLVFW3Tu2VYm8jtTchS0gsnkd1u65PLC2+4te2d/frdX4ak7CiUyioLt8sItafclO0Va3Yo7130tcsWeoxzHvOVfgKK5OwZRe+fndc/z/DGFuUi5OXeT8oIu7YLkOzfnzn0WuuxMdNnpaLPS0WVnIOWVPCGXKdUorexRWtVCaVkr/97K/u5jS7tiW7iqYjIVd+g/ri/4GoCG09/Frl3bB5aVJInlJ3/iwK1jGCnUfNJtCh627hUUqQAVlEjt2LGDLl26YGNjw44dOx5Zvl+/fqWpploTiZQgCEI+SZuHLjsTbXZ+YqXLTEOTkYw2IwVtRlL+fXqy/rEu+zH6pBVKVDaOqGydUdk5o7J1Qm3ngsrWmZQsJT98e4y0KpRMhaz5nshdvyE3NqbZ/LmY1nF9YFmNTsuXh5ZxMeYqVkYWfN7jPRzM7Ssw2idbhSRS9zp16hSNGzfGzMysyL6MjAwCAgJo1apVWaupdkQiJQiCUDo6TS7atEQ0KXF3bvHkpcShSb3zPDUetA/uklSYWZFl6c3vNxqSkaPAzs6IoePaYWFj+LGOj0vSark8cxapl69g4uKM7/y5KE1NH1g+My+LT/Yv5FZyOK6WTszu/i6majHHVEWo8ETq3m6++12+fJmXX3651F171ZlIpARBEMqHpNOiSU0gLzGSvITI/PvESPISotCkxFEwbUma1oK9qc+SKZlhpUjm2bqXsK5TB2NnT4xcvFA7uFXoPG65ySlcmPIuuQkJ2LZpRcPp7+V33z5AYmYy7//zJUlZKTRzbMT0pyagEPPOlbuSfH8b5Kq9h+ViGo3msdbLEwRBEITHJZMrUFk7oLJ2gPvm1NPl5ZAbG0ZubCiWsaE8f/sGvwd6kqK15s9bPjyd8BfGF//NP4/KCCMnD4ycPTF28cLYrTEK0/JbpkVtbUXD6e9y6f0PSTxxivCt26kzcMADy9uaWjOt43g+3r+AC9FXWXfuF95o+Wq5xSeUXKkTqfT09EKTYMbFxRW5ei87O5sdO3Zgby/6dQVBEISKIVcZYeziibGLJwD2QK3YdH769igpaTbs1w7kObfLyOKuIeVkkh0WQHZYAAULiqkd3DF298GkbtP8xMq46LCVsrDw8sRj7JvcWLqcsI2bMfdsgE2L5g8sX9/WjUltR7DgyHf8feMgLpaO9PLsYtCYhNIrddfe0qVLWbZs2SPLSZLEmDFjePvtt0tTTbUmuvYEQRCqjoS4dH5cfpy0lGwcnS0ZPLYNysxYciKDyI4IIjv8GnlxYYUPkslR166Haf1mmDZoiZGLp8G6Am8sXU7M3n9QWljQfNF8jGo9vNHh16t72HBxBzKZjOlPjaeFk5gWobxUyBipc+fOce7cOSRJYt68eQwePLjIXFFqtRovLy9at25dmiqqPZFICYIgVC3xsen8sOwoGem5uLhZM3hM20ILHWszUsgKvUxW6GWyb10mL7FwT4vcxBzT+i0wbdASE4/mKEyKn6n8cehyc7k47QMyboZg4e2Fz+efIlc9eJ1ASZJYcWo9/4YcxURpzGfdp+Jm7VLq+oUHq/DB5kuXLuXll1+mdu3aZT1VjSISKUEQhKonJiqVH789RlZmHm71bRn0ZhtU6uJbmTSpCWSFXiLzxlmybp4vPC2DTI6xW2PMG7XHrGFbFGZWJY4lOzqa81PeQ5uRgVPv56j/5hsPLa/Raph9cDEBcUHUMrXl86enYW1cfmO6nlQVnkgJxROJlCAIQtUUeTuZn1YcJydbQ32vWrz6hj9K5cO77CSdluzwQDJvnCHzxtnC3YAyOSZ1fTBr1CE/qSrBklKJJ09x9fMvAfCaOoVaT3V4aPm0nHQ+/GceUemxeNrV4+Oub6NWPLglSyi5Skmkbt26xZYtWwgODiY7u/AMtjKZjB9++MEQ1VQrIpESBEGousJCEtnw3QnycrV4N6nNgGEtUSge/yrzvOQYMq4eIz3gKLnRwfrtMoUKU+/WWPh2xaSe72ONqbr143oitu3In6xzwVxMXR88WSdAZFoMM/75iozcTDq4+TO57chqtdB0VVeS72+DzEtw/fp1+vXrx/79+/nvv/9ITU0lNDSUkydPcvv27YdOjyAIgiAIlcGtni2vjGiFQikn8EoMOzeeR6d7/O8rlXVtrNv1xfWNr6gzfhk2XQahquWGpM0jI+AI0ZtnE7Z0LIn/biA34eFr0roPeg2rpj7osrO59uU8tFlZDy3vbFGbd9qPRiGTcyTsNDuv/v3YcQuGZZBEauHChXTs2JHff/8dSZL4/PPPOXjwICtWrCAnJ4e33nrLENUIgiAIgkHV97Jn4PCWyBUyrpyPZPfPF5BKkEwVUNk4YtPhJVzfXIjLyHlY+j+L3MQcbVoiyUe3E75iEpE/fkh6wJH8tQzvI1Mo8Jr6NiobG7Juh3Pj25WPbITwqe2tn1Nq86VdnIm8VOK4hbIzSCIVEBBA37599RNv6nQ6ALp06cLIkSNZuHChIaoRBEEQBIPzbFSb/oP9kMngwqlw/tp5udQ9KTKZDCOn+tj3HIX75NU4vDQVEw8/kMnJvn2V2B0LCVs2jqTDW9GkJxc6Vm1tjfe7U0AuJ/7Qf0T/+ehWph4eT/GMRyckJBYfW0t4alSp4hZKzyCJVGpqKlZWVsjlcpRKZaGJOn18fLhy5YohqhEEQRCEctHI14kXX2sOMjh1JJSDe66X+ZwypQrzRu1wenUGbhNXYN1xAAozK7RpiSQd3ETY0jHE7lpC7j2D1q2aNKbusCFA/iLHadeDHlnP8BYv06iWJ1mabOb9t4L03MdY8FkwGIMkUrVr1yY5ORkAd3d3Tp06pd8XGBhY7GLGgiAIglCV+LZ05bmX8ie5PLQniBP/hRjs3EpLO2w7v4bbxJXUevF/GDl7glZD+qUDhH/3NtE/f0l2RH7y5vxiH+zatUHSaAj8aj55qWkPP7dCyZT2o7A3tSUqPZZvjq3V9wwJ5c8ga+35+flx9uxZevToQZ8+fViyZAlxcXGoVCp27NjBCy+8YIhqBEEQBKFc+bevS2ZGLgf+us7fO69gaqqiacuHX0FXEjKlCgufTlj4dCI7IoiU4zvJuHaCzKBTZAadwtitCdYd+uMxcTwZt0LJjorm+qJvaPzRBw9d3NjK2JL3Oo7lw33zuBAdwMZLOxnc7CWDxS08mEGmPwgLCyM2NhZ/f3+0Wi1z5sxh9+7dAHTt2pUPP/wQc/PHn1OjphDTHwiCIFQ/kiTx969XOPnfLeRyGQNH+OPVuPwmnM6NDyfl+K+kXToEuvyB6MZ1GmHUoCvXF61Gl5uL26DXHrq4cYGjYWf4+thqACa2GU6num3KLe6aTEzIWUWIREoQBKF6knQSOzed59LZCJRKOYPHtMWtvm251qlJTSD5+K+knd2DpM3L30Yd4k7eBrkcn88+wcqnySPPs+nir+y4+hcquZJPu0/Fw9a9XOOuiSp8HilBEARBqElkchkvvNoMz0YOaDQ6Nq05SXRk6qMPLAOlpR32z4ykzvhlWPg9A3IFSm5jYg/odAR+NZ/c5JRHnueVpn3wc25Knk7DvMMrSM569DFC6RkkkTp27Bh//vmn/nl8fDxvvvkmHTp04L333iMnJ8cQ1QiCIAhChVEo5AwY2pI69WzJydaw4bsTJMaX/xVxSks7aj07hjrjlmDu2xXLujKUxpCXksqVD99Dk/7wxEgukzO5zQhcLBxJzEpm0bE1aHTaco/7SWWQRGrx4sUEB9+dHn/evHmcPn2aFi1a8Pfff7N69WpDVCMIgiAIFUqlVvDaG62o7WRBRloO61eeIC01+9EHGqJu69o49JmI27ivcezRBOSQeTueqzPGkHxit777rzimahPe7TgGE6UxV+OC2HBhR4XE/CQySCJ169YtGjduDIBGo2Hv3r1MnTqVpUuXMnnyZH7//XdDVCMIgiAIFc7YRMWg0W2wsTMlOTGTDd+dICszt8LqV9u74v7mp7i9kn8FfOqtPKJ3rCP8u7fJvHn+gcc5Wzoyoc0wAH6/vo8jYaceWFYoPYMkUunp6VhaWgJw5coVsrKy9AO1fH19iYoSM60KgiAI1Ze5pTGDx7TB3MKI2Kg0Nq85RV5exXaXub4ylFpdOgGQFCwjOyaK6E2fEbNjIZq0xGKPae3anL6NegKw4uR6bqc8fM0/oeQMkkjZ2dlx69YtAI4ePYqzszOOjo4AZGRkoFQaZLoqQRAEQag0NnZmDBrTBmMTFbdvJbFjw7kSLXJcVjKZDI+xozFxdUGXK5GRUAsJGRkBR7i98n+knPoDqZixUK/49KFpbW9ytLnMP7ySzNyHL4gslIxBEqmnnnqKRYsW8eWXX7Ju3Tp69Oih33fz5k1cXFwMUY0gCIIgVKraTpYMHOGPQiHn2qVo/i7DunyloTAxwfvdd5Cr1WSExaFw6YWRsydSTiYJe9YQ8f375ETdLHyMXMH/2r6BnakNUemxLD35AzpJzHxuKAZJpN5++20aNmzIzz//TKNGjRg3bpx+32+//UaLFi0MUY0gCIIgVLq6Hnb0fb05kL8u39F/gx9+gIGZ1XWn3ptvABDx69+YtxqCfa/RyI1MyY0OJuL7aSQe2FRoMLqlsQXvtB+NUq7kdMQFdl599ILIwuMp9wk509PTUavVqNXq8qymShITcgqCINRcxw/dZM+vAQD0fb05vgZcSuZRJEkiaNFi4g4eQm1nS/OvFyCTa0nYs5aMq0cBUDu4U6vPRIwc6+uP2xd8mJWnNyBDxgedJ9LMsXGFxVydVKkJOc3NzZ/IJEoQBEGo2dp2qk/bzvlJyq7NF7h5Pa7C6pbJZNQfOxpjZ2dyExIJ+noJClMrar/0Dg4vvYPc1JLc2FAivp9O4qEtSNr8pWe6e3SkW/0OSEgsPraWuIyECou5pip1IhUZGUleXp7+8aNugiAIglDTPN27EU2aO6PTSfy87gz/b+++w6Oo2gYO/2Z3s+k9gST0hBJ6b0IooUqRroAFFQFBQVQUKa/lFQVfERHEBogFCCgdVPpHAJXepYUACRCSAElIz2bL90cgEAMkbCaV576uvXZ35sw5zx437sPMmXOirxTdLOI6B3sCJ2aNl4o/eIgra9YB4FT7MSqNnI1jYGswm0jY9QtRP/+HzIQYAF5s8hQB7lVIMqTw2Z/fYXjAfFQib1Zf2qtduzbLly+nQYMGBAYGoijKA8ufOnXKqgBLM7m0J4QQZZ/RaGLJd/uICL+Bk4stL45tg5uHQ5G1H71pM+FffQsaDfU//hCX2oHZ+5L/2c31P77FnJGKYuuA9+MjcaobxLWUG7yzeTpJhhSCqz3Gyy2eLbJ4S4MiWbR49erVdOjQAXd3d1atWpVnItWvXz9rminVJJESQohHQ3paJj98+Rex0Ul4lXPihbGPYe9QNMNaLBYLZ2fN5vrO3eg9PWk0+zNsXJyz92fejCV2zWwyLp8BwKlBB7y6vsSJ+It8tHMuFouFMS2eo0O11kUSb2lQJImUyJskUkII8ehITEjj+zl/kngzncr+HjwzqiU6nbZI2jampnH0zbdIj7qKe/Om1J4yKccJDovZRPyuX0n4cyVYzNh4+FKu/wQ2XD/J8hPr0Wtt+LjzRCq7yXRFUMyDzS9cuMDhw4ezJ+gUQgghHgUubvYMHdECWzsdkefjWP/LsSKbY0rnkDW/lKLTEb//IFd/+yPHfkWjxaP9YHyf+QCtixeZcVeJ+mESnY32NPSpg8GUyay/5pOWWTTrCJYlqiVSf/zxBx07dqRHjx4MHTqUxx9/nI4dO7Jx40a1mhBCCCFKtHK+Lgx8rikajcLxg1cI3XS2yNp28q9G1Rey1ta7uOhHUi5czFXGvnIdKg6fib1/IyxGAzc2fMnQZA2e9m5EJcXw7YElRTrBaFmgSiIVGhrKG2+8gZOTE2+++SaffPJJ9vs33niD0NBQNZoRQgghSryAWt70GFAfgJ1bwji6/1KRte3b83HcmzfFYjRyZuYsTOm5zzBpHZzxeWoy7kFPAQqWI9t5Os6AVtHwV+QBNp/bWWTxlgWqjJEaPHgwTk5OfPfdd2g0d3Izi8XCSy+9REpKCsuWLStoM6WOjJESQohH17bfTvHn9nA0WoWnR7akWnWvImk3MzGRw+PeIDM+nvJdOlP91dH3LZsafpjYtbMxpyWz29udDa426DQ6Puw0gQCPKkUSb0lU5GOkTp8+zdChQ3MkUZA1YdjQoUM5c+aMGs0IIYQQpUbw44FZc0yZLPz6w0GuxSQVSbs2Li7UfOM1UBRitmzl+u4/71vWIaAxFV78FL1PAG2uxVMnxYDRbGTWX/NJNqQUSbylnSqJlEajyZ6c89+MRmOeUyMIIYQQZY2iUegzuCEVq7qTnpZJyIL9pCRlFEnbbg3qU3FA1rRD5776hvSY2PuWtXErh99zH+JUpw2DYm7ikWniWsoNvtr7o4yXygdVEqn69euzYMEC0v91LdZgMPD999/TsGFDNZoRQgghShWdjZbBLzTH3dOBhLhUln2/n8xMU5G0XWnIUzjXqokpJZWzn83GYrp/uxobW8r1fR2/oME8HX0TndnCgajjrPvn9yKJtTRTJZEaO3Ysp06donPnzkybNo1vvvmGDz/8kE6dOnHy5EnGjh2rRjNCCCFEqePgpGfoiBbY2dtwJTKBNUsPYzEX/pkejU5HzTfHo3VwIOnMGSKX/fLA8oqi4N52II17jad3fNaJkZATGzhxYV+hx1qaqZJINWvWjO+//54KFSqwZMkSZs+eTUhICBUqVOD777+nSZMmajQjhBBClEqe3k489UIztFoNp45Fs/W3olk2za58eQLGvAzA5V9XcvP4iTyPcQpsTb9+/6FxmhmzArP//p7YiGOFHWqppfrM5mlpaSQmJuLi4oK9vb2aVZc6cteeEEKIux0/eJnVS48A0HNgfZq2Lpo748LmfkXs1m3oPTxo9MVn2Li45HlMcvxV3vnjQ2K1FmqmGXmnzcs41WhaBNEWv2Kd2TwtLQ2TyUR8fDxRUVHZDyGEEOJRV79pRTp0rwnA76tOcO70/QeBq8l/xIvYV/DDEBfHublf5WsQuZO7L291mYCNBc7a61ix+QsSj2wtgmhLF1USqeTkZKZMmUKjRo1o06YNnTp1yvUQQgghBAR1rkHD5hWxmC2s/PlQkUyLoLWzo+aEN1B0OuL27Sf69/ytOlLF258Xmg4GYKOnA4e2zid+9wq5m+8uOjUq+fjjj9mwYQMDBw6kVq1a6PVFs+K1EEIIUdooikKvgQ2Iv5FK5Pk4li3cz/DX2uLgWLi/nU7+1aj6/HNcWPA9Fxb9iEvdOjhWzfvSYqfq7Th+7Sx/XzpEiI8r3ruWYc5IxSP4WZneCJUSqdDQUN58802GDRumRnVCCCFEmabVaRg0rCkLv/iT+Bup/PrjAZ4Z2QqtTvURNzn49upBwpGjxB84yNlZs2k48xM0eZz8UBSFUc2eITwugtiUG6zydmbonrWYDWl4dR+BohRuzCWdKp8+IyODmjVrqlGVEEII8UhwdLJl8PDm6G11RITH8cfqE4V+yUxRFKqPfQUbV1dSIyK5+NOSfB3noLdnfOuX0Coajjvbsd/FnqRDm7m2bi4Wc9HMi1VSqZJItW/fnoMHD6pRlRBCCPHIKOfjzIBnG6MocGhPJPt2XSj0NvVurlQf9woAV9dvIP7Q4XwdV92zKkMa9AVgfXk3om1tSD6xk5hVn2Ex3nt1k0eBKonU6NGj+f3331m0aBEXL14kISEh10MIIYQQudWoXZ7OvesAsHndScJOFf6dfB7NmuLb83EAwuZ8SebNm/k6rletTjTyqUOmxcQvNaph0OlIPbOX6F9nYM4smuVvShpV5pEKDAzMquwBg85OnSqaycdKEplHSgghRH5YLBY2/HKMw/suYWun48WxbfD2cS7UNk0ZGRx9823SLl3Go2VzAidNzNfg8Zvpiby96WPi02/S3rs2PQ7swZKZgV2l2vg8NQWNbemfQ/Jhfr9VGWz+yiuvyMh9IYQQwkqKotBjQH1uXE/JupPv+/0MH9cWB6fCu5NPa2tLzTfGc+ytd4jbu5+YzVvw6dY1z+Nc7VwY2+p5Ptwxh9Brp6jbZTBVt/1K+qVTXF32Ib6Dp6KxdSi0uEsa1Wc2F3fIGSkhhBAPIzXZwMI5u4m/kUplfw+eHVX4d/JdWbuOi9//iMbWloazPsWhYoV8Hbfs+DpWnfwDexs7pjV8GtOauZjTk7H1q4HPkP+gtXMs1LgLU7HObC6EEEII6zg46Rn8YnNs7XREno/j95XHC/1OPr/evXBt2ABzRgZnZ32BOTN/A8cH1e1JLa8A0jLT+eb8NryHTEVj70xGVBhXl3yAKa3wJxotCaxOpKKiosi81dl3LwVzv4cQQggh8ubt40z/Z5qgKHB43yX27CzcO/kUjYYar72KztmJlPBwIkOW5+s4rUbLuFYv4GhjT1jcRdZe/wffp99H4+CCITo8K5lKLfvJlNWX9mrXrs3y5ctp0KABgYGBeY6RKi2DzdPT05k2bRr79+9Ho9HQvXt3XnvtNavqkkt7QgghrLVn53k2rz2JosCQl1pQPbBcobZ34++9nJ7xP1AU6k37ANd6dfMX56VDzPprPgoK/+kwjpoah6wkKiUBfbmq+D7zAVp7p0KNXW1FMtj8448/plKlStmvy8pg808++QQvLy82bdoEwLVr14o5IiGEEI+ilkHVuHY1icP7LrFq8WGGv9YGT+/CS0g8W7ekXOdOxG7dxtnP59D4i8/QOeXdXqtKTejk35Zt53czd88PfNp9Kr7PfMDVxe9hiL1I9LJp+A59r0zczXcvJX6weUREBAsXLuTo0aOEhYXh7+/Phg0bcpW7cOEC06ZN4+DBg9jb29OzZ08mTJiAnZ1dvttKSUmhU6dO7Ny5U5X1AuWMlBBCiIIwGk389NUeLkfE41XeieHj2mBrZ1No7ZnS0jjy+gTSr0bj1bYNNSe8nq8TJenGDCZtnsGVpGia+tXn7bajybx+iaif/4M5LRm7KvXwGTwFja50rMVbpgabh4WFERoaSpUqVQgICLhnmcTERIYNG0ZKSgpz5sxh4sSJrF+/nqlTpz5UW5cuXcLDw4NPP/2U/v3788ILL5SaS5JCCCHKHp1Oy6Dnm+LsYsv1mGRWLz2CxVx45z+09vbUfPN1FK2W67v/5NqO0HwdZ6ez5bXWw9FpdByMOs6mc6HovSvjO/g/KHp70iNOELtyJhaTsdBiLy4lPpEKDg4mNDSUOXPmULfuva/XLlu2jMTERL766ivatWtH3759mTp1KuvXryc8PDy73JAhQwgODs71GDFiBABGo5Hw8HBatGjBqlWreO6553jllVeK5HMKIYQQ9+LsYseTLzRDq9Nw9p8Ydmw+W7jt1ahOpcFPAnD+2wWkR0fn67iq7hV5pmE/AH4+spKIhMvY+lXH56lJKDo9qecOErtuTplbm6/EJ1IaTd4h7ty5k9atW+Ph4ZG9rVu3buj1ekJD72TTISEhbN++Pddj/vz5APj6+mJvb0+XLl0A6NixI8nJycTFxan8qYQQQoj8q1DZnV6DGgCwa0sYJ48W7t3wFQf0w6VObUxpaZydNQeLKX/Jz+M1OtLEtx6ZZiOz/15IhtGAfeW6lB/4Nmh0pJz8k+t/fFfoUzoUpRKfSOVHeHh4rst+er2eypUr5zgjlRdPT0/q16+fvQDzsWPHsLOzw93d/b7HdOrU6b6Pq1evWveBhBBCiH9p2KwiLdtVA2DtsqPERCUWWluKVkuN18ehdXAg6cwZLq9cnb/jFIUxLZ7Dzc6FK4nR/HhkBQAOAY0p1288KBqSjmwlPjSk0GIvamUikUpMTMTFxSXXdhcXF27mcyHG2z744ANmzpxJ7969+fDDD5kzZ06ZuSNRCCFE6dalV22q1fAi02Bi+aL9pCYbCq0tu3Ll8B/1EgCXlv1Ccvj5fB3nYufMqy2fR0Fha/gu9l4+DIBTYGu8Hh8FQMKfK7m5//fCCbyIqbLWXkllsVgeOgny9/cnJCT/mfKDRvTfHvUvhBBCqEGj1TDwuSYsmJ21jMyKnw/y9MiWaLWFc17Eu3074vbu58Zff3N21hc0nPU/tLa2eR7XwKc2vQO7sO70Zr7Z9zMB7lXwcvTApXFnTCkJxIeGcGPz92gdXXGq06ZQYi8qBZrZ/GEehcnFxYXExNynOJOSku55pkoIIYQorewd9Dz1YnP0tlounrvBlvUnC60tRVEIGD0KG3d30i5fJuLnpfk+dnC93gR4VCElM425exdhNpsBcGszAJem3QELsevmkHbxeCFFXzSsPiMVHBz8UGd7CnMagYCAgFxjoQwGA5GRkQwYMKDQ2hVCCCGKQzkfZ/oOacwvPxxg366L+Pi50qhFpUJpy8bFmRpjx3Dyvx9xdf0GPJo3xa1hgzyP02l1vNZ6OG9v+ohT186x6tQfDKzbE0VR8Oz6IqaUm6Sc/pvoXz/B79n/YuvjXyjxF7YCzWxeUsYOtWvXjq+//pr4+PjsgeFbtmzBYDDQvn37Yo5OCCGEUF9gfR/ad61J6Oaz/LbiON4+TlSofP+bowrCvWkTfB7vRvQfmwj74ksaz/kcnZNjnsf5OHnzUtMhfLn3B3795zfqlatFoHd1FI0W7z7jMKUlkh7xD9HLPsJv2EfYuPsUSvyFqcTPbJ6WlpY9hcGSJUu4dOkS77zzDgAtWrTAw8ODxMREevXqRYUKFRgzZgw3btxgxowZtG3blpkzZxZb7DKzuRBCiMJkMVv45ccDnDkRg4urHSNeD8LROe8xTNYwpadnzXoedRXv9u2o+Ub+16Gdu2cRuyL24e3oyafdpuBgk7VcjDk9haif38UQexGduw8Vhn2M1tG1UOJ/GGVqZvMbN27w2muv8dprr7Fv3z6uXr2a/T4sLAzIGiP1448/4uDgwNixY5kxYwa9evVi2rRpxRy9EEIIUXgUjULfIY3w9HYk8WY6K34+hNlkLpS2tHZ21Bw/DjQaroXu5PruP/N97PCmg/F29ORayg1+OPRr9naNnSM+g6eicyuHMT6a6BWfYDYW3p2IhUG1M1IXL15k+fLlhIeHk56enrMRReHHH39Uo5lSpTDPSN3+z1ZSLq8KIYQoPtdiklj4xW4MGSZatfen6xN1Cq2tiCUhXP5lBTonJxrNmYWtp2e+jjt1LYz3t3+OBQtvthlJy4qNs/cZrl8m6sfJmNNTcKzblnJ9xhfr79vD/H6rMv3B2bNneeqppyhXrhyRkZHUqlWL+Ph4YmJi8PX1pVKlwhkA96gyZJp4fXYokdFJAChKVkKlufWc9SDH+zuvc5e1Zp9GUUABTY59Wa+1GgWtVoNWo6DRKDmetRoNWu2/3muUu7bden97m3LreO1d22+V0+kUbHRadNqczzY6DTqtJsfz7dcajSSeQoiyx7u8M30GN+LXHw+yJ/Q8fpVcqde4QqG0VempQcQfPExKeDjn5n5Fnfem5ivpqe1dgycCu7D29Ga+27+Emp7+uNtnXcbTe1Wk/IC3uBryISn/7Cbeww+Pdk8VSvxqUyWRmjVrFm3btuXzzz+nXr16fPTRR9StW5cdO3YwefJkxo8fr0Yz4hazxUJq+p2FHy2WrDNUWSdzS/SQt2Kn1SjodBpsbidat17rbiVbep0WWxsttnotepus13obDbZ63V2vb5XJVU6bY5+dbdYxkrwJIYpC7Qa+tAkO4M/t4az/5RjePs6U91V/CiCNTkfNN8Zx9PW3SDh8hOg/NuHbo3u+jn2qXm+ORp/kYsJlvt73E5PavZqdhNlXrY/X4yO5/tvXJOz6BRsPX5zrtVM9frWpkkidPHmS9957L3tdvNtzRXTo0IEXX3yRWbNmsXjxYjWaEoCdXsf8yZ1JScvMSqKw3EmmzLeeb136M1uy9pnNFiy3Xlu4XfbWPstd+/71Pu995HhvNme1bTJZMJktmM1mTOas11nbzFnlbu2/8zD/a1vWcXe2mTGbyd5uMlkwmsxkGk0YTRYyjSYyTRaMRhOZRvOtfWaMppyJpclswWQwkUHRLZppp9dib6vDzlaH/V2P29uz32e/vlVer8PeToe9PuexNroSP7RRCFFMOj4eSNSlm1wIu84viw4w4vUg7OxtVG/HoWJFqgx7lgvzF3Jx0Y+4NqiPQ8W8z4DptDrGtnqBdzZP50j0STaf20m3Gnfurndp1JnMuKvc/HsN1zbMw8bVG7tKtVWPX02qJFKJiYm4urqi0WjQ6XQ5JsesV68e8+bNU6MZcRedVoOrU+HcmVGWWCyW7KTq7gTrfq8NmSYMmSYybj8MWc+GTDMZBmPW863t9y535/n26MN0g4l0gwmSMlT5TDY6TY4EzN42K+FyuOu1ve3d723uvP7Xflu9VsbZCVGGaDQKA55twvzPdxF/I5VVSw4z5MXmKIVwZty3R3fi9x8g4chRwmbPof6Mj9Do8k4rKrn68XTDfvxw+Fd+PrqS+uVr4edyZ9oDj45Pkxl3ldQze4n+9RMqvDCjRE+LoEoiVb58eRISEgCoUqUK+/fvp02brCnfz5w5g6Nj3nNNCFEYFOX2uCltkbZrsVjIyDSRnmEiLcNIusFIanrWc1qGkfQMI2l37UtLN5KWvS9re/a+jKz9BmPWmd6s5M9AYkrB72zRKOQ6U+Zgp7tPomZzn0TtzuvCWqZCCJF/Do56nny+GYvm/sm5U7GEbjlLh261VG9H0WioPu4VDo99neSwc1xesYrKg5/M17Hda3TgYNRxjsecZu6eH/iw81voNFn/n1YUDeX6vMbVn/9DxtVwopd/hN+w6WjtnVT/DGpQJZFq0qQJhw4donPnzvTu3Zu5c+dy7do1bGxsWL16NU888YQazQhRaiiKgp0+6/Kcm0pzuphMZtIyjKTeSrJuJ1hpGVlJWlpG7kdqembObXeVM1vAbIHUdGOOMXcFoddpshOtrKTMJndSdutMWNaYtNs3A2SNP7t9s8Dt8Wo2Og02NhpstFn7dfe4iaEknlG7fYnbbLbkeG3KsZ07l7pv7zPnLpef7bcvp+fa98Dt5qzvQPalcwtmC7e2P0w9+R+X+TA3iWtu/ffV3LqR5e73inJnv1a5/T0ge//tMY93j3/Mfp09PlJ75/W/b06x0dz6+80a66jXaUrk9+xBfCu60nNgfdYuO8rOzWH4VXKjZp3yqrdj6+lJwMsjOfvZ51xa/ivuTRrjXLNGnsdpFA2vtBjGm5s+JDw+ghX//Mbg+ndyBY2NLeUHTeLKD++QeSOKmFUz8R08FUVb8pYIVmX6g8jISGJjY2nWrBkmk4np06ezfv16ADp27MjUqVNxciqZmWRhkgk5RUllsVjIMNw585V6V6KVeo+k655JWcadJC7TWDjz1uSHJvtH9d53it7942utHGMA75Ekmcw5kydRtmgUsL2dWOl12NlqcyRatnot9vqsfyQ4Odjg5KDH2cEGZ3s9Tg42ODtkPdvb6oo8Iftj1XH2/xmBrZ2Ol8a3xdO7cH6Lz8ycxfVdf2Ln50ej2TPztbAxwF+RB5j990IUReG/wW9Syysgx/6MmItE/TQFiyEd58Zd8Hp8VJH04cP8fpf4mc1LM0mkxKPCeOts2d3JV2r2+8xcyZkh89aYtFs3B2Qas8ahZZrMZGaaMBjN2duzxq5ljWMrK3Imf9w643I7EQSNRpPjbEuOpPAB27OnC7lHIpm/7Zqs9pXbr7PiyX5933oe5tPnp3DWGbu7b2CxZJ8NI8f7Owkst5JaMyaT5b7jIO9su3OjitFoIdN069mY9f1LvzUOUk1ajZKdVDnZ30m4XJ1s8XCxw93FDg8XW9yds1472hU88TIZzfz09d9cuhhPOV9nho9ri41e/aEOmUlJHHntDQw34vDp0Z2AUSPyfeycPYvYHbGP8o5e/K/bFOxt7HLsTwk7QMwvMwALnl1fxLV5T5Wjz00SqRJCEikh1GM2Z904cOcsUM7LTKa7LlH9e1++zhLl8Xt1+/KS9vblprsvPWU/kzvhuMdlqdJ2mehRZTJbyDAYb90wYsw+i5tuMJFhyBrnmL3/1j8eklMzSUo1kJx26znVQGJKplX/ENDbaHF3vp1k2eLlZk95dwe83R0o7+FAOXd7HO1t8vw+JSWm892sXaQkZdCwWUWeGNywUL6DCUeO8s97/wWg7gfv4taoYb6OSzGkMmHTNG6kxhPs34aXmz+Tu+4964jb9iMoGnyemoxDQON71KSeIkmkoqKi8Pb2xsbGhqioqDzL+/n5WdNMqSaJlBBCiNs3n2QnWamZJKcZSErNJCnFQEJyBnGJ6cQnZj0nJKWTks9xi/a2Osp7OODr5YivpyN+3o74eTnh5+2Ih4tddsJ04dx1Fn+zB4sFej/ZgMYtKxfKZw3/dj7Rv29E7+mZ74WNAf6JPct//282Fiy83fZlmlXImYRZLBau//YVSUe3o9g6UOH56ei9KhbGRwCKKJGqXbs2y5cvp0GDBgQGBuaZ3Z46dcqaZko1SaSEEEJYI91gJCEpZ4J1LSGN2PhUYuNSiY1P5Wbyg+/c1dto8fNyxNfLkco+zijX0wg/HIVWp2H4uDb4VFB/cWBTejpHxr9J+tVovDt2oOb4sfk+9ucjK1l/Zisutk7M7P4f3OxyTiZqMWVydel/SY88ic6tPBVe+AStg7PKnyBLkSRSq1evpkOHDri7u7N69eo8y/fr18+aZko1SaSEEEIUlnSDkWvxacTEpXL1egpR15OJup7C1espxMSl3vOSdg00uKFg0il4NPTFv5Ib/hVcCajoip1enTviEk+f4fikqWA2EzjpbTxbtczXcZmmTCZt+YTIm1do4luPiUFjcp2kMaUmcmXRRIwJsdhVrovv0P+gaNWfcLTIx0jt37+fOnXq3HO+qJSUFE6ePEnz5s0L2kypI4mUEEKI4mA0mYmNSyXqegpR15K5eDWRi1cTuXw1iRpGC7YoxGPh3K3FxTQahaq+LtSq4k6tyu7UrOxOBW8nq5e4uvjTYq6sXI2NqwuN5sxG75a/s1+RCVd4Z8sMjGYjI5sNpXNAUK4yhmuRXPlhMhZDGi5NuuH1+EirYnyQIk+k7r7M928nTpxg0KBBcmlPCCGEKGYms4XjJ66y/ufDWMwWKOfIubQM4u+x8oKjnY7a1Typ5+9J/epeBFRwzfeku+bMTI6++TapEZF4tGpJ4Dtv5XuA+/rTW/n56EpsdbbM7DaF8k7eucqkhh0k+pfpgAXvJ8biXL9DvurOr4f5/VblPN6DcjGj0Zi9Bp8QQgghio9Wo9CogR/GfgZ+X3kC5XoqH77cCnsPe85GxnMmIp6zkfGcu3yTlHQjB07FcOBUDAD2tlpqV/WkQXUvmtUpT+XyzvdNjjQ2NtQYP45jb71D3J69XNsRSrmOHfIVY89awRyIOsapa2HM2/sj73d8I1ce4VCjKe5BTxK/aznJJ3aqnkg9DKsTqeTk5Bxr6l27di3X3Xvp6emsXr0aLy8v6yMUQgghhKqatq5C5Pk4ThyOYuXiQ4x8ox1tG1agbcOshYeNJjMXoxI5cf4GJ8Kv88/5GySnZXLoTCyHzsTyw28nKefhQIva5Wlex4d6AZ7obXLOT+XkX41KTw0ickkI5+cvxLVePWy9884HsmY9f44Jm6Zx+no4G85u5YnArrnKuQUNxMarAvpyVdTpFCtZfWnvyy+/zNdixBaLhVGjRvH6669b00ypJpf2hBBClFSGDCMLvtjN9Zhkqlb35JlRre47JspsthARncjxc9c5dCaWY+eu51jRwFavpVENb5rX8aFZ7XJ4utoDYDGZOPbOFJLPhuHWqCF13v9Pvi/xbT//J9/sX4xOo2NGl3eo7Fah4B86n4pkjNThw4c5fPgwFouFTz/9lGeeeSbXXFF6vZ6aNWvSokULa5oo9SSREkIIUZJdi0liwezdZBpMtO1cneDHA/N1XHqGkaNh19h/Kob9J2OIS0zPsb96JTfaNapAUKMKOCTHcfT1CZgNBvxHjcC3R/d8tWGxWPhk99ccijpOVbeKfNx5IroiWmuvyAebf/nllwwaNIjy5dVfELE0k0RKCCFESXf80BVWLzkMwODhzR96cWOLxcL5KzfZfyqGAydjOHspntuZhaJAXX9POpsuYLd1DRpbWxp98Rn2vr75qjsh7SZvbvyQJEMK/et0Z3D9Pg8Vm7Ue5vdblVHgr776qiRRQgghRClUv0kFmj2WNc5ozdIj3IxPe6jjFUUhoKIbg7vUYuZr7fjxvW6MHtCAOtU8sFjgRPgNZl9wJtLBB3NGBodnfI4xM38zt7vZuzKi2VAAVp/axNnr5x/uwxUB1W+ni4uLIyoqKtdDCCGEECVT1z518KvkSnpaJisXH8JUgEXC3Z3t6PFYNT55NYiFU7rwfM86VPVz5Tfvx8hQdFguhjPrtc/5fv0/REQn5llfq0pNaFulBRaLhXl7fyTD+OAZ3YuaKpf2kpOTmT59Or/99hsZGbnnogBZIkYIIYQoyeJvpPDdrF1kpBt5rGMAnXvVVrX+C1E3OfjzKnz/2kCmouX7Sr2J17tQvZIbvdv6E9SoAja6e5/fSTakMGHjNOLSEuhevQMvNn1K1dj+rcjHSE2ePJkNGzYwcOBAatWqhV6vz1VGlogRQgghSraTR6NY8dMhAIaOaEH1wHKq1m+xWDjx7gckHjvOTY8KzPcMxmjJuovP09WOJ4IC6N66Cg52uZd9ORZ9immhcwCY2n4cDXzUTfTuVuSJVJs2bRg5ciTDhg0raFVliiRSQgghSpvfVx7nwF8RODjqGfVmO5xd7VStPz02liPj3sCUlobP0Kc55FWP9bvOZ8+u7mRvwxNB/vQO8sfJIeeJmQUHQ9h8biee9u7M7D4VR72DqrHdVuSDzTMyMqhZs6YaVQkhhBCiGHV9og7l/VxITTGwasmhey5+XBB25cpR9cXnAYj59Rd61nJg4dQujHuyERW8nUhOy2Tp5jO8OG0LP/1+kpvJd4YMPdOwPz5O3txIi2fRoV9UjctaqiRS7du35+DBg2pUJYQQQohipLPRMvC5JuhttUSEx7Fz81nV2yjfpRNujRthycwk7Isv0SnQpWUV5r0dzNvPNqOqrwtpGUZ+3RbG8I+2sHDdCeIT07HT2fJqy+dRFIWdEXvZe/mw6rE9LFUSqdGjR/P777+zaNEiLl68SEJCQq6HEEIIIUoHT28neg5sAMDOrWFcCLuuav2KolD9ldFoHRxIPhvGlbXrgay1AIMaVeCLNzow+fkWVK/oSobBxJrQcF76aAvfrj6Gp40vfQO7AfDdgaUkpOd9519hUmWMVGBg1kyoD5r2Xe7aE0IIIUqX9cuPcnjfJZycbRn5ZjucnG1VrT9m63bOzZ2HotPR6POZOFSulGO/xWLh4OlYlm85w+mIeAB0Wg1dWlbknP0GLidF0aFaa8a0eE7VuB7m91uVudZfeeWVfK+dI4QQQojSoXu/elyOTOBadBJrlh7m6REtUe6zHp81ynXqyI2//ib+4CHCvphLg/9NR9HeWfxYURSa1S5P08ByHAu7TsiWM/xz/gZ//BWJztEfx7rxaCxFs2zM/ahyRkrcm5yREkIIUdpdi05i/uxdGDPNdHy8FkGda6haf8aNGxweOx5TSipVnn2aigP737esxWLhePh1lm7KSqjAQuv6fkx+Xt01fYv8rr3bkpKS2LVrF+vWrePmzZtqVi2EEEKIYuDt40yP/vUB2LHxDBHnb6hav62nJ/4vDQcgMmQ5KRcj7ltWURQaVPdmxitt+XBUa5oGlqdxTW9V43lYqiVS8+bNIygoiBEjRjBx4kQuX74MwLBhw/juu+/UakYIIYQQRaxh84o0aFoBiwVWLT5Maoq6y7R4d2yPe/NmWIxGwuZ8idmY91p8jWqW4/0RrXn8sWqqxvKwVEmklixZwrx58xg4cCDffvstd18t7NixIzt27FCjGSGEEEIUA0VR6DGgPp7ejiTdTGfDr8dQc2SQoihUH/MyOicnUsLPc2XlatXqLmyqJVLPP/88U6dOpW3btjn2ValShYiI+5+mE0IIIUTJp7fV0f+ZJmi0CqePR3NoT6S69Xu4U21E1iW+S7+sIOXCRVXrLyyqJFKXLl0iKCjonvscHR1JTCzeOR6EEEIIUXC+FV3p1CNryqNNa//hWkySqvV7tw/Co2WLrEt8X3yJOTNT1foLgyqJlLOzM9ev33uyritXruDp6alGM0IIIYQoZq3a+eNf0wtjpplViw9jNJpUq1tRFALGjELn7EzKhQtcXrFKtboLiyqJVOvWrVmwYAGpqanZ2xRFwWg0EhISkutynxBCCCFKJ0Wj0GdIIxwc9cREJbL99zOq1q93c8N/1AgALv+6kuTz51WtX22qJFLjxo0jKiqKnj17MmPGDBRFYfHixQwaNIiIiAjGjBmjRjNCCCGEKAGcXex4YnBDAPaEnufc6VhV6/dq+xierVthMZkImz23RF/iUyWRqlKlCiEhIfj7+xMSEoLFYmHt2rW4u7uzdOlS/Pz81GhGCCGEECVEzTrlad6mKgBrlx0lJSlDtboVRcH/5ZHoXFxIjYjk0i8rVKtbbarNq169enUWLlyIwWAgPj4eV1dX7Ozs1KpeCCGEECVM5961iQi/QWx0EmuXH2XI8OaqLRmnd3Ml4OURnPnfZ1xesQqPFs1xrlFdlbrVVOAzUunp6QQFBbF9+3YA9Ho95cuXlyRKCCGEKONsbLT0f6YxWp2Gc6di2b/7oqr1e7V5DK+2bcBs5tycknkXX4ETKTs7OzIyMrC3t1cjHiGEEEKUIuV8XejSuzYAWzacIiZK3SmP/Ee9hI2rK6mRl7i07BdV61aDKmOkWrVqxd9//61GVUIIIYQoZZq3qUqN2uUwGc2sWnyIzEz1pkSwcXEhYPQoAC6vWkPS2TDV6laDKonUyy+/zG+//caXX37J2bNniY+PJyEhIcdDCCGEEGWToig8MbghTs62XItJZsu6k6rW79m6JV7tgsBsJuyLuZgN6q71VxCKRYXFcgIDA+9UeJ9BZqdOnSpoM6VOp06dANi2bVsxRyKEEEIUvvAz11jy3V4AnnqhGbXq+ahWd2ZiEofHjiczIYEK/fpQ9fnnVKv73x7m91uVu/ZeeeUV1UbpCyGEEKJ0CqjlTav2/uwJPc+65Ud5uZIbzq7q3Hxm4+JMwJhRnP74E66sXY9n61Y416qpSt0FoUoiNXbsWDWqEUIIIUQpF9yjFhfPXSf6SiJrQo7wzMiWKBp1TrZ4tmyBd4d2XNuxk7A582g0eyYaGxtV6raWKmOkbktKSmLXrl2sW7eOmzdvqlm1EEIIIUoBnU5L/2eaYKPXciHsOn+HqrvES7XhL2Lj6kra5cslYqJO1RKpefPmERQUxIgRI5g4cSKXL18GYNiwYXz33XdqNSOEEEKIEs6rnBPd+tQFYPvvp4m6lKBa3TYuzvi/fGstvhWrin0tPlUSqSVLljBv3jwGDhzIt99+y93j1zt27MiOHTvUaEYIIYQQpUTjlpWo3cAHs9nCqsWHMWQYVavb67HWeD7WGsxmIpcuV61ea6gyRmrJkiU8//zzvP3225hMOeeOqFKlChEREWo0I4QQQohSQlEUeg1qwJWIBOKup7BxzT888VRD1er3HzUCc0Y67o3Vq9MaqpyRunTpEkFBQffc5+joSGKiurOcCiGEEKLks3fQ0/fpxqDAkX2X+OdIlGp1691cqfPuVHx79lCtTmuokkg5Oztz/fr1e+67cuUKnp6eajQjhBBCiFKmaoAnbYOzFhve8OsxEuJSizkidamSSLVu3ZoFCxaQmnqncxRFwWg0EhISQtu2bdVopkiEhobSt29f+vTpQ//+/Tlw4EBxhySEEEKUau271cSvshsZ6UZWLz2C2VzgucBLDFUSqXHjxhEVFUXPnj2ZMWMGiqKwePFiBg0aREREBGPGjFGjmSIxefJkZs6cydq1axk7dizTpk0r7pCEEEKIUk2r1dD/6cbobbVcuhDH7m0la728glAlkapSpQohISH4+/sTEhKCxWJh7dq1uLu7s3TpUvz8/KyuOyIignfffZc+ffpQp04devXqdc9yFy5cYPjw4TRq1IjWrVszbdo00tPTrWozKSkp+7l8+fJWxy6EEEKILB5ejvToXx+A0M1hXLoQV8wRqcPqu/ZOnz5NtWrVsLW1BaB69eosXLgQg8FAfHw8rq6u2NkVfFr4sLAwQkNDadiwIWazmXstDZiYmMiwYcPw8/Njzpw5xMXFMX36dBISEpg5c+ZDtff5558zevRo7OzsMJvNLFmypMCfQQghhBBQv2kFzp2O5cThKFYvPcKoN9tha6fKBALFxuro+/Xrx/Lly2nQoAHPPfcc7733HgEBAej1elXP4gQHB9O5c2cA3nnnHU6cOJGrzLJly0hMTGTNmjV4eHgAoNVqmTBhAqNHjyYgIACAIUOGEBMTk+v4gIAA5s+fj8lk4ptvvmHBggXUq1eP7du38+qrr7JmzRpZS1AIIYQoIEVR6DGgPpcuxpMQl8rmdf/Q+8ninb6goKxOpPR6PQaDAYB9+/aRkpKiWlB302jyvvq4c+dOWrdunZ1EAXTr1o3JkycTGhqanUiFhIQ8sJ6TJ0+SkJBAvXr1gKwkbuLEicTHx+eoWwghhBDWsbO3oc/ghvz0zR4O771Ezbo+1KpbeofRWJ1IVapUiUWLFmVPe7B3716io6PvW75r167WNpWn8PBwBgwYkGObXq+ncuXKhIeH57seHx8fLl26xOXLl6lYsSKHDh1Cr9fj7u5+32M6dep0331Xr17F19c33+0LIYQQj4Kq1b1o1c6fPaHn2fDLUSq+1R5HJ9viDssqVidSY8aM4e2332bbtm0oisJnn31237KKonDq1Clrm8pTYmIiLi4uuba7uLg81OLJ3t7eTJkyhZdffhmNRoNOp+Pzzz+Xy3pCCCGEyoIfr8X5M9eIjU5iw6/HePL5ZqXy99bqRKpHjx60atWKCxcu8PTTT/Puu+9SvXp1NWMrMIvF8tD/Ufr27Uvfvn3zXX7btm333fegs1VCCCHEo0xno6Xv0EYs+GI3Z07EcHT/ZRq1qFTcYT20At+117RpU/r160dQUBCVKhVPB7i4uNxzGZqkpKTs8VFCCCGEKFl8KrjSoVsttv9+mo1r/qFqdU/cPByKO6yHYvU8Uv369ePMmTNA1jIwtweeF4eAgIBcY6EMBgORkZGSSAkhhBAl2GMdA6hU1R1DhpE1IaVv1nOrE6miumsvP9q1a8eePXuIj4/P3rZlyxYMBgPt27cvtriEEEII8WAajULfoY3Q22qJPB/HntDzxR3SQynxd+2lpaURGhoKZJ35Sk5OZuPGjQC0aNECDw8PBg8ezOLFixkzZgxjxozhxo0bzJgxg969e8sZKSGEEKKEc/d0pOsTddnw6zH+748zBNTyprxf7pvISiLFcq+pwvPh999/5+2338ZoNKIoyj1nHM9upAB37V2+fPm+g7Z/+uknWrZsCWQtETNt2jQOHjyInZ0dvXr1YsKECarMrm6t23E/aEC6EEIIIbJuEFv+/QHOnoyhvK8zw8e3RafTFkssD/P7bXUiBRAXF5fvu/ZatGhhbTOlliRSQgghRP4lJ2XwzcxQUpMNPNYxgM69ahdLHA/z+12gBW48PDzw8PAo9rv2hBBCCFH6OTnb0ntQA5YvOsBfO8KpUaccVfw9izusB7J6sPndpk+fLkmUEEIIIQqsVj2frPmkLLA25AgZ6ZnFHdIDWX1GKioqCm9vb2xsbIiKisqzvJ+fn7VNCSGEEOIR0q1PXS6eu0FCXCqb1pzkicEld2FjqxOpTp06sXz5cho0aEBwcHCeM4gX5hIxQgghhCg7bO109BnSkB+/+psj+y9Rs245AuuXzLVrrU6kPv744+zLeR9//HGpXB9HCCGEECVTFX9PHusQwF//F86GX49TsYo7Ti7Fdyf+/VidSPXr1y/7df/+/VUJRgghhBDitg7daxJ+5hoxUYms/+UYg4c3L3Enbgp01x5kTYGwbNkyDhw4QGxsLADlypWjZcuWPPnkk7i7uxc4SCGEEEI8enQ6Lf2GNmL+57sJOxXL4b2RNGlVpbjDyqFAd+39/fffdO3alTlz5rB3714SEhKIj49n7969fP7553Tv3p39+/erFasQQgghHjHlfF0I7hkIwKa1J4m7XnxL0t2L1YlUXFwc48ePx9nZmdmzZ3PgwAF2797Nn3/+yYEDB5g1axb29vaMGzcuxxp4QgghhBAPo1VQNaoEeJJpMLFmacla2NjqRGrFihWYzWZCQkLo3r079vb22fvs7e3p0aMHS5cuxWg0smLFClWCFUIIIcSjR9Eo9BncEFs7HZcj4vl7R3hxh5TN6kRq9+7dDBgwAB8fn/uW8fPzo3///uzatcvaZoQQQgghcPNwoFufugDs2HiWmKuJxRxRFqsTqfPnz9O0adM8yzVr1ozz589b24wQQgghBAANm1ekZp3ymExm1i49gsloLu6QrE+kEhMT8fDwyLOch4cHiYklI2sUQgghROmlKAq9BtXH3sGG6KhEdm4JK+6QrE+kDAYDNjY2eZbT6XRkZpbsdXKEEEIIUTo4udjRc2B9AHZvP8eVyOK9oa1A80idP38erVabZxkhhBBCCLXUaehHvcbRnDgcxY5NZ3l6RMtii6VAidSkSZPyLGOxWErcLKRCCCGEKN0e718PRVHwr+VdrHFYnUhNnz5dzTiEEEIIIfLN3kFPv6cbF3cY6qy1J4QQQgjxKCrQEjFCCCGEEI8ySaSEEEIIIawkiZQQQgghhJUkkRJCCCGEsJIkUkIIIYQQVpJESgghhBDCSpJICSGEEEJYSRIpIYQQQggrSSIlhBBCCGElSaSEEEIIIawkiZQQQgghhJUkkRJCCCGEsJIkUkIIIYQQVtIVdwBlWWxsLCaTiU6dOhV3KEIIIYTIp6tXr6LVavNVVs5IFSJbW1t0uju5qslkIjExEZPJlKPcvbb/e9u/31+9epWrV68W+me4X8xqHptXuQftlz61vtzD9N39tkuf5q+M9Kn1ZR/279+abdKnD95n7bai6NfC6lOdToetrW3+KrKIInPixAlLzZo1LSdOnMhz+7+3/ft9cHCwJTg4uNhiVvPYvMo9aL/0qfXlHqbv7rdd+jR/ZaRPrS/7sH//1myTPn3wPmu3FUW/FlWfPoickRJCCCGEsJIkUkIIIYQQVpJESgghhBDCSpJICSGEEEJYSRKpIuTt7c2rr76Kt7d3ntv/ve1+xxZXzGoem1e5B+2XPrW+3MP03f22S5/mr4z0qfVlH/bvvyDbCpv0qfqKqk8fRLFYLJYC1SCKxe25qbZt21bMkZQd0qfqkz5Vn/Sp+qRPC8ej0q+SSAkhhBBCWEku7QkhhBBCWEkSKSGEEEIIK0kiJYQQQghhJUmkhBBCCCGsJImUEEIIIYSVJJF6BE2ZMoVatWphNBqLO5RSb9SoUTzxxBP06dOH4cOHF8kK8mVZfHw8L730Et27d6d3795MmTIFg8FQ3GGVepMnTyYoKEj+7gsgPDycAQMG0K1bN5577jliY2OLO6RSr6x8LyWResT8/fffmEym4g6jzJg5cybr1q1j7dq1tG/fnpkzZxZ3SKWaoiiMGjWKjRs3snbtWtLS0vjpp5+KO6xSr2/fvqxevbq4wyjV3nvvPUaOHMmmTZvo0KEDn332WXGHVOqVle+lJFLFKCIignfffZc+ffpQp04devXqdc9yFy5cYPjw4TRq1IjWrVszbdo00tPTH7q91NRUZs2axcSJEwsaeolV1H3q7Oyc/To5OdnquEuyouxTNzc3mjdvDoBGo6FevXpERUUV+DOUNEX9PW3RogVeXl4FDbvUUaufr1+/Tnh4OF27dgXgySefZPPmzUXyGUoaNb+7ZeV7qSvuAB5lYWFhhIaG0rBhQ8xmM/eaGzUxMZFhw4bh5+fHnDlziIuLY/r06SQkJDz02Y9Zs2bx3HPP4e7urtZHKHGKuk8B3nzzTfbu3YurqyuLFi1S42OUKMXRpwAZGRmsXr2at956q6AfocQprj591KjVz9HR0fj6+qIoCgBOTk7Y2NgQHx9fpv9/ei/y3c1NEqliFBwcTOfOnQF45513OHHiRK4yy5YtIzExkTVr1uDh4QGAVqtlwoQJjB49moCAAACGDBlCTExMruMDAgKYP38+hw4dIjIykqlTpxbiJyp+Rdmnt3322WdYLBYWLFjAV199xfvvv18In6z4FEefms1mJk6cSKtWrWjXrl1hfKxiVRx9+ihSq5/vtwDI7cTqUaLmd7eskESqGGk0eV9Z3blzJ61bt87+MgJ069aNyZMnExoamv2FDAkJeWA9Bw4c4OTJkwQHB2dv69q1K0uXLsXHx8fKT1DyFGWf3k1RFJ566inat29f5hKp4ujTDz74AJ1Ox+TJk60LuoQrru/po0atfvb19SU6OhqLxYKiKCQnJ5OZmYmbm1shRl8yqfndLStkjFQJFx4enutLp9frqVy5MuHh4fmuZ+TIkezevZvt27ezfft2ADZv3lymkqj8UqtPU1JSiI6Ozn6/ceNGatSooVqcpYlafQrwv//9j5iYGGbMmPFI/ov/NjX7VNxffvrZy8uLatWqsXXrVgBWrFhBly5dijzW0uJR++7KGakSLjExERcXl1zbXVxcuHnzZjFEVPqp1adpaWm8+uqrZGRkAODr68unn36qWpyliVp9GhYWxsKFC/H392fAgAEAPPbYY2X6Bon7UfNv/6233mLv3r1A1qWZZs2aMWvWLFXiLO3y28/vv/8+EydOZObMmZQrV65MjvVRS377tKx8LyWRKqVun2K21pkzZ1SMpmx42D718vJixYoVhRhR6fewfVqjRg35bubBmr/9RzXBL4h/93ONGjVYtWpVMUZU+v27T8vK91Iu7ZVwLi4uJCYm5tqelJR0z4xf5E36VH3Sp+qTPi0a0s/qe9T6VBKpEi4gICDXNWWDwUBkZGSZG7BXVKRP1Sd9qj7p06Ih/ay+R61PJZEq4dq1a8eePXuIj4/P3rZlyxYMBgPt27cvxshKL+lT9Umfqk/6tGhIP6vvUetTGSNVjNLS0ggNDQXgypUrJCcns3HjRiBrxlcPDw8GDx7M4sWLGTNmDGPGjOHGjRvMmDGD3r17l8nMvqCkT9Unfao+6dOiIf2sPunT3BTL/WYaE4Xu8uXLdOrU6Z77fvrpJ1q2bAlkTbU/bdo0Dh48iJ2dHb169WLChAnY2dkVZbilgvSp+qRP1Sd9WjSkn9UnfZqbJFJCCCGEEFaSMVJCCCGEEFaSREoIIYQQwkqSSAkhhBBCWEkSKSGEEEIIK0kiJYQQQghhJUmkhBBCCCGsJImUEEIIIYSVJJESQgghhLCSJFJCCCGEEFaSREoIUWasWrWKWrVq3fexd+/eBx4fHBycXfa///1v9va9e/dSq1at7DXFrBUXF0e9evV4/fXX71smOTmZhg0b8vLLLwOwdevWHJ/h+PHjBYpBCKEuWbRYCFHmTJ8+HX9//1zbq1evnuex7du3Z8yYMXh5eakel4eHB8HBwWzdupWbN2/i6uqaq8xvv/1Geno6AwcOBKB58+YsX76cHTt28PXXX6sekxCiYCSREkKUOTVq1KB+/fpWHevh4UGjRo3UDeguAwYMYNOmTaxfv55nnnkm1/6VK1fi5eVFhw4dAHB1daVRo0acP3++0GISQlhPLu0JIYQVkpOTGT58OI899hjHjh0DwGAw8NVXX9G9e3fq1atHq1atmDRpEnFxcdnHBQUF4ePjw6pVq3LVGR4eztGjR+nTpw86nfw7V4jSQP5ShRBljtlsxmg05timKAparVaV+qOjoxkxYgSZmZksX76cSpUqYTabGTNmDAcPHmT48OE0adKEK1euMHfuXI4dO8bKlSuxs7NDo9HQr18/vv76a06fPk1gYGB2vStXrgSyzloJIUoHSaSEEGXOk08+mWubVqvl5MmTBa771KlTjBw5ksqVKzNv3jzc3NwA+OOPP9i1axdz586la9eu2eUDAwMZOHAgq1atYujQoUBWovTNN9+wYsUKpk6dCoDRaGTdunU0adKEgICAAscphCgakkgJIcqcTz75JFcyoihKgevdvXs3kyZNomPHjsyYMQO9Xp+97//+7/9wcXGhY8eOOc6G1a5dG29vb/bt25edSFWqVImWLVuyfv163n77bfR6PTt37uTatWuMHz++wHEKIYqOJFJCiDInICDA6sHmD7J161YyMjIYMmRIjiQK4MaNGyQmJlKvXr17HhsfH5/j/cCBA5kwYQLbt2+ne/furFq1CgcHBx5//HHV4xZCFB5JpIQQIp8mTZrEH3/8wYgRI/jyyy9p27Zt9j53d3fc3NxYsGDBPY91dHTM8b5r1664urqycuVKWrRowY4dO+jTp0+uckKIkk3u2hNCiHyytbVl7ty5dOjQgdGjR7N169bsfR06dCAhIQGz2Uz9+vVzPf49r5WtrS29evXizz//ZP78+WRmZsogcyFKITkjJYQoc8LCwjCZTLm2V65cGQ8PjwLVbWNjw6xZs5gyZQqvvfYan3zyCb169aJnz56sX7+ekSNH8uyzz9KgQQNsbGyIjo5m7969dOrUiS5duuSoa+DAgSxZsoRFixbh7+9PkyZNChSbEKLoSSIlhChzJk2adM/t06ZNY9CgQQWuX6PR8PHHH+Po6Mhbb71FWloagwYN4uuvv+ann35i7dq1fPfdd2i1Wnx8fGjevDk1a9bMVU+dOnWoU6cOJ0+elLNRQpRSisVisRR3EEIIURIEBwfTvHlzPvroIzQaDRpN8Y9+sFgsmEwm1qxZw5QpU1ixYkWhDKQXQlin+P8vIYQQJciaNWuoW7cu06ZNK+5QANi2bRt169ZlypQpxR2KEOIe5IyUEELccubMGQwGAwCenp74+fkVc0SQmJhIRERE9vvq1atjb29fjBEJIe4miZQQQgghhJXk0p4QQgghhJUkkRJCCCGEsJIkUkIIIYQQVpJESgghhBDCSpJICSGEEEJYSRIpIYQQQggrSSIlhBBCCGElSaSEEEIIIaz0/5DhehRGxfuuAAAAAElFTkSuQmCC", "text/plain": [ "
" ] @@ -516,22 +515,18 @@ "fig, ax = plt.subplots()\n", "shells_cox_dipole = wr.get_migdal_transitions_probability_iterators(material=SOURCE, model=\"Cox\", dipole=True, considered_shells=(\"*\",))\n", "\n", - "\n", - "E = df[\"E\"].to_numpy().copy() * nu.eV\n", - "v = np.repeat(1e-3, len(E))\n", - "\n", "def print_f(arr, pref=\"\"):\n", " if arr is not None:\n", " return 0\n", " print(f\"{pref} {arr[:2]=}\")\n", "for shell in shells_cox_dipole:\n", - " x = shell(E.copy(), v=v)\n", + " x = shell(points)\n", " if shell.l != \"s\":\n", " continue\n", " for _shell in shells_cox_dipole:\n", " if shell.n == _shell.n and _shell.l != \"s\":\n", - " x += _shell(E.copy(), v=v)\n", - " ax.plot(E / nu.keV, x * nu.keV, label=f\"n={shell.name}\")\n", + " x += _shell(points)\n", + " ax.plot(E, x, label=f\"n={shell.n}\")\n", " \n", "\n", "\n", @@ -597,12 +592,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7a50bf4773e2478eb785d709ba357b25", + "model_id": "b4bdfb538fbb4e94b4ee3a67f476bfcd", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/100 [00:00" + "" ] }, "execution_count": 10, @@ -683,12 +678,12 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "17e26c918caa4a0a98a5b8489efc468b", + "model_id": "0019ce0829864235bca83186622ae31f", "version_major": 2, "version_minor": 0 }, "text/plain": [ - " 0%| | 0/100 [00:00" + "" ] }, "execution_count": 13, @@ -753,7 +749,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -838,7 +834,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 15, @@ -847,7 +843,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -869,7 +865,7 @@ { "data": { "text/plain": [ - "" + "" ] }, "execution_count": 16, @@ -878,7 +874,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -927,5 +923,5 @@ } }, "nbformat": 4, - "nbformat_minor": 2 + "nbformat_minor": 4 } diff --git a/wimprates/migdal.py b/wimprates/migdal.py index 0af6b6a..c0b11aa 100644 --- a/wimprates/migdal.py +++ b/wimprates/migdal.py @@ -95,14 +95,15 @@ def _default_shells(material: str) -> tuple[str]: def _create_cox_probability_function( - element: str, + element, + orbital: str, dipole: bool = False, ) -> Callable[..., np.ndarray[Any, Any]]: fn_name = "dpI1dipole" if dipole else "dpI1" fn = getattr(element, fn_name) - return fn + return partial(fn, orbital=orbital) @export @@ -147,7 +148,7 @@ def get_migdal_transitions_probability_iterators( 6.1e1, 2.1e1, 9.8, - ] + ], ), Ar=np.array([3.2e3, 3.0e2, 2.4e2, 2.7e1, 1.3e1]), Ge=np.array([1.1e4, 1.4e3, 1.2e3, 1.7e2, 1.2e2, 3.5e1, 1.5e1, 6.5e0]), @@ -191,6 +192,7 @@ def get_migdal_transitions_probability_iterators( model, single_ionization_probability=_create_cox_probability_function( element, + state, dipole=dipole, ), ) @@ -274,7 +276,7 @@ def diff_rate(v, erec): ) * v * halo_model.velocity_dist(v, t) - * shell(input_points, shell.name) / nu.keV + * shell(input_points) / nu.keV ) # Note dblquad expects the function to be f(y, x), not f(x, y)... From 62e11e998f40866e7558f70d888b62203ea82eaa Mon Sep 17 00:00:00 2001 From: Lorenzo Principe <28869147+lorenzomag@users.noreply.github.com> Date: Wed, 9 Oct 2024 03:42:40 +1100 Subject: [PATCH 94/94] Add figure needed for notebook tutorial --- .gitignore | 4 +++- notebooks/rates_fixed_binding_energies.png | Bin 0 -> 41656 bytes 2 files changed, 3 insertions(+), 1 deletion(-) create mode 100644 notebooks/rates_fixed_binding_energies.png diff --git a/.gitignore b/.gitignore index 10addf7..065569f 100644 --- a/.gitignore +++ b/.gitignore @@ -75,4 +75,6 @@ target/ *.pdf # Temp -notebooks/dm_e \ No newline at end of file +notebooks/dm_e + +!notebooks/*.png diff --git a/notebooks/rates_fixed_binding_energies.png b/notebooks/rates_fixed_binding_energies.png new file mode 100644 index 0000000000000000000000000000000000000000..b4e7b7735743aa12b6ba00853f28fef43c64b157 GIT binary patch literal 41656 zcmbTeWmJ`4^euc8L@@xRQ;{y|PU%KMIs~LkxQlz`#uJilf zaqqZeyr13=4)J)-dG@oPwdR^@&b0}Ap(yp>F40{C0`WjbT3iKzxTyetZrwqHSNeB5 zwcsyaCkag_RXbBBS3?IAgo2^d8*4i!YYU?%E+!6+7IwDm&v>7)GCnbPa(d&)$INW= zf8OxS&cTd%h;WM>z6AY^w3Z_RfoX{Rb0b$c#{z*!r;-tWuI84!G2`lnGcwk+yS1NX(+lk|gZr!|?kST`*)k86|M zuRl%1MPR9LU3#U`gm3hu)R-;wt!(^o-FitEl>X#BmgpVwpv=Mz#D72KqsS!w&r8pv zsLA1{Peu`$GI!vobOK6?NATYFv}pf--=b_~Vq#MA=8vey@s`5*(Wd)Sq!f?mk+sQ3 zDoa0neK$Ybnc9H{Z_f`8h}-;7ZtrcT3AnQrXji1`)wz^gjfK&vW~-@WUMp?kv*aV! zn_g;Oq5W^HsQ>J6Jx{0V*;J*C@k&nuiGUlHqvL)ThSKn>GSl9LUzoxzEiLcw;Xm6s zSqv|8-PYgO+&nbFW7hBa^pJv{wd-QZCo-0rT%5_&(D3KRM47#_vqXV9yX7z~js!U+ zWoD@uHm5Fp6ALTr4Uvq2h?JDx6noo9F&C(rWPH)z{b0;;R%`s7Wg`>o4^>b%=_Jy6>|EcgOm=153Ng zHWWT{b#;YSB!$S!~SMo1dmC(r8O8|&P$ewyWIS_yu5tF zCSMAMfq{W~k-px7$BlRI-gR_zd@=m>A&aj;;PY~sBn}f5RY17V*{8LkoS_OUjr#g} z%?7Vi@9wx|ABLWK_kHt`eB2DF@X;~fs^dA|v_ic)Hs^oC^rxrVxZ81i>P&U3j7&@u z)%Fy6wN9N?mrI?|)3wg`SA z;+C{aSSFq9ZA-+?;i1VwOW?(B`{Ve;#Mr;}KRgbbCngdUlDKdaIX0(jqC-ONw}p}F zyqZh%y^`sUWy&*X^a=de)7Q6hx|)__F_bN^-@{JDr>(Ho>!gtt!l4;fx|8u`zxX9P$^=t8PGQktLoW*eN!ylf^>5 z>aNXQVYi(p6p|rdOuAzaHmBlVepAOK(vX(E11Ru%zR9oLV(3Gvpyyr>dp{NdfoA@C zPw?{Ia(7P(f1F|p-&*5y{G7t&?zsH{smC{d7a26()Jx*Fn|(c7?|yQ2HV9Wj!zAnJ z7rwq|s@8X3#wGLIV106o9^qLhrj#bs3pZ{tR!C|yS#Ef7vI}@rJU-?kJd~qk*8Cow zM9||iIyUw1Yz5-8qs?x}oww6l%>x-yL+}cj&xs)f&Q+6DUfk2O`XGq$g?k$UMryzl8 zX-T|D|Hqz<22OyW=Mjtf?y{8(}7G~GoxA(2a3U?QRnFqg$-G+~~H3!_2QB-{PW_H16bUIx9o5^xl z%za`m`8gY(85v<3%UO{cKTDC7*`@^a-?+Y9{_ zOgm1!f9KAtt?3%4zrXz;KliWBw=+g8YwQ=%*iC!B05l?>-gd+Jv$<0_$HrmGkZ*3u&GbFnL>{$0~AIvN`RX|fCf81h&+)#LDA$*Z3? zlarHqJPv39w5WxIQYXsH=D1U}%1j3U&}V(lZM?@6^@Ha+qiGU^y!ld7Q|r&S>f+<$ zi+wIVQr%Ywg)R?NAs+tR)}Ol6t#P=;&dwhDOs{J(TsW+vg7dNO1uJvo1>0(0%CEV( zG_zE9v{+!pd@%C6A_BDDVO z-?!7S#y5X%DhVE{`KgyfDSJdp+S}xZ;x}EQj!iA!G&`GG)K(>Psj`&xo|_GWmgQtfMvzS zJgYw`zsnAQ(&E-uVPlajL>;XxXDLKm>(G#D&6_{(94=1m|NGhFFh89( zh|RQzU^zxZUl~V2`NMs}booS%ye9i9ySY(2Vs_JzK>%1Pc6QZ9D5?@`(=}xaYioIP zT(;9ZSyJI-vXYV?d~_Tf9Q+&tU>UON>alE4!Iys=&oZ#3HZ$r}%I_W=s0l&zKJCVR zIR>k}S73E^uqF#x{ds9=$!ls3LMaOXPF7S@H1cry^6DCBj@Q&<_oaueV`CaJGBTa` zQ&10L^nZBJ@$&LgHE>BNfByaZ1@ayU*-hmeuFZftsR{@R#?Yj?iTc{Yf7>;jO2UP` z=AG4I>*oyYeYTE;2zlOoVe>vaxH+{wU6bMF;X!ZUd+8j>s@veDrB&}%Qfk&uwhY+U z)fP$|0}06h_@jaGSV(uNWME(*C?_XpulXJ`&Uns(w#QOl>e^Jp-y-VA!J*^Ddpi=L17v%k(0@Cf-^q<#H zH2V4m7Ut!%w+K2_jgM<0|5K~dTI=h1w@2d)6Ft3b0*m3hL7<~qVjnTO{tjfsK!sWf zHW|)UmWAz#fjU7KO|78vOt*TcX&-MD31$}nU;8$XS&iN!A2PB^o!LxGOvsKE>cv3% zGXxn`pJ(xXtF$nJw6%A1G=_`{A>s@IgxKq1D8gAEFE8hKrdQjNDHFYCG8-HFU-5!% zT<_MacZ+N%^JJW>zR$qG00Hm|s`g$Acaen`P-&o7!N@Ib`10k8ih-5>2fN%_HgyjO7`^JFHrwBH}*|~+2?GH27p#$ppb_m=YY;9f8XA)1ii(L5vb;i=^`}yCamD&vo*^mzXpuotk?~xEcTXZ`FuB-= zowb~_M?^%jjXsyf#l=r(Xl|RCnc+Rtm4>(6(^U$_V;ZlvH!dmsksF(wp4j$y*m`Sm z(LX#q{K^?H1o{2HK0Gk)jG{UK(xACJV|DO%02LMWuR-I*UN_`)M$2{`t8rT~fb!Ay zT>qEn{=Y3Ntmhh100HpMe*Xk6a4@sKwzihc=NwdG+>XbaS^`VW`X|J^cImq9+0@+~ z+|wfuAY||4#JFpwVCZwYj4vP{;08Sm#8cheBW!Frr%*u6+uHshc2Of_eah4Z0zUH;);rjel$*RMXS7b ze%`*g*zXqrJazgvjIN`jqehPl9F;F2A%Uv8_Tp~cpKcWmQPG>)1+h>+BH>TTZ?@gt zU8*ql?c>C;2b$xYl$4Y>wU^JI88n0dph5v=DxR5`AhfgF2JU`&X)*deq2Y9Vax!sv zSncu(cp#ybmDOeSqZGw2uZp#b8@hu6hZYroRT|h@cjGrqh`Gu zD@3j7?=R0u_?$k)#}jztx6MGxinzH|3!y8?%8CLVAy6`*rTTHbv9YoDqfhRFosI2a zH+HFPMIUNPvXFOT`(xkwriP9V>9-E&dLmmqoD2-#?#jhCu^hjU`P_bKDoy3xKSx|t zQo_2jvT}=TnuUw&+0L7nHtIIf)E$?Sb=DJXT-M`F_n7NnY%Bufc#)?T5QbarDX*$u zBjHQ6XWAw2FwWnPkcmKuq?a#Fq5hA%IKGo_J?VmO;#~G>Weog=t`Slz z`#NRGVzQi0#P2q<>{$aa7~_rz@{6M>J8=mKB!PoA@!tKGfa#nSXz4N^ml<1G1xseo zRdwEc;9V4V0FU6|!-up%Du3f5>b0`>+uFUZFOPL=ozPWPRgwI-tc=~j`w(|)YYR!9 z#;2y(twtH2xNfX!7m$U;Fsqp4OeGYg}OCS+dtBxqklo80F5IG zba+UP={oCv8yg!N_@aT=?ybhlBVqtHV-zPq{NVx}jX7L(6^%k&x(E^zQ&We_v%{NH8R_Yt!osp8g7MC5 zT&p-P0S@Goc~}jeR)DzT6<&244eeiac2koG^z`ryhm}^2ph_Wk&33jvp-5LhMOj(d z>wL57c+;n6U7NPA|5AJL?08#ATbl^jl}5v+PNnrvh!ifHNt{bLCUGO9r?)Z5GTrxA zFq7%$^Kw!lp?2Gd?UvS4Ytshnx1nDQR?IOT$$v>AWTP>#D4F0LzgTRX$Zf>-yu>zmadqWRxOve-FaS!s6mD zfVR6!4Ij737=53&T*(DijO<>-3PVVZTHA;+EpAk0=P!-+ox+B z-Otu?5?GDVRC5$Zd|7m~wO7{9eYa{>-JqX$gQgkD;`vg-pjp8H`RS%Y1;EuAjoBVq zjzNVbE_Aj`-Bft_)y~V_^95RE$TrOoI$&t?-8U=7+%`(uL4V%zS|Sj~Jv26=V8vIpWOBOe_+T9#Dw1N{l2L99Kib(V+_)%#>+qZMDBV zbAF~@FAWt88m;EGHpw{>GAyhnC`0h>TSrGn_epqOT!&ujtE;OcBebP4xbARkCJCP6 z{z{S^Xj<=*l876xulS|HNDQGQpQb+Jci*D~s$&e=%o)uvfV>n)3+5B0RPc50-@o4h z@{LVQ{B1j%Q5M#zS#JIi7?CN|aDlxJ3J#k|wYkao+BCt z$J0F%5I5ET2TM?E_L;MCa@HHw^csCqX6jtmjl1OrsE7eQeHN4kYe;-#^1#oJ@bN!FZwYW}k|B_T_v%6ri@Ywo{>teeD?N zZ8|`74T*_~@tFd(09n7TP^duBoT{>0+}tdB@X zr2qQ$E0C~!QQ`PlW`jPnH1D=jlWu8g=`S+T)LxK+XEi;0wAX^EDPxCdHU5#Vo0F}u zr_yqAzeY!6F-ZA#K(kp+(k!AyrV{WMh?5V{V`Agt2FPZm0}3KlHF#mYPJp~>y)bjT z4*1^QR^9d>h(e-`z1JXR4TI#i>x) z1w-Vcnf2TjR4>p5agGnEI6~;iC$QbB;Hy%7o-+g)b?D{qy{|u4s&LuVUWPp%YwYXlQh~-MBU!+` zv}62zE`9!Ce0HhF;fTg500b{!NS({35xfKS)~($ZY$Y`p^X8`S1qBmzuFQb^!%70? zCMK=f3Q6Xm(=}LN-Mo2o@4;5zxhu43Cx1RZju-N-^_iRTZ{0@|2@Zm6Ei_W%R+-ZK z;lVkFZ3g83eL%p#cP(}x&F~M}AW?O7Jfw)+*VlKZPHtysrfEaQ0fqFmYc}crGL-^RDD|A@ z;?~cFD2~8?^H2*>Lj7>IrRUOl9ECw;Kl-~YYrsSsp;DGVAegTlBOV{KrI1i z$8I=XA-=f0yw`KgX*0=@t(2yyqVfn-`#+E`Spay@OveUd)37-#Nkgg=aF}BOHh90X z7FENgm#DFd@JBjD?`hQvwof8UmGC_U^0%uh$7nLqo&ad-PY( zryvzJSSPK)AnF&DJU0;U*Pu2;!dt7en#IM%KYL)+ARk43ED>vV9uK77T}nx6YU=8m znl=1bc?AV3Ha3+;-{Y;BQq4@{8{ZNQ4yuvB&5nS*7;#1by(}Vg2 zY7C=RX=cYh-r;Lq<$@Q;9n00XR2Xy;2K`Va5Anvy=`|3C7?Q~UE}X7CBxnX-qoShX zw+YWIpi%@KxjEAXqm&9{WMpS0a_*(2rPa>s>V74P|Ly;AKBtT-C{{cmNI;&P*?x1@Vc9JmzRdMho>IcJu-HQk(!D< z68%i-Pw-ryJ=)c>XbS_WT?COOJp*Nq7`|wP?1;}OZ%DouUY*=$-I9$K^ zvYh{I(nFb$Qr?e=(-zG}$AwvbWw`y}cH!Cu3p+I|VafNtElCGJAYaqSMCZQ1_ct2% z_{*mdvNfN9aU+H(CK5ft&@U5>tbM3A)&4T^#?DCgy%ri1HHQ}12XRPw@qjbu?Uy(b zhCxGAi0@NJzbe=7AQq0U-=}x43|#4R*jG^TG6geprAkp3;KNqpN)J-f%gbux;TN_4 z9_2wj?_p7EGaWznz^N;w_^mma9vV)$wm}vWI$Xb_=^4U7uc#Zg^tWcG3qub!0nBH$ zWYsIzCsN(g>yC(V7t*lE7(q)_#|=-RyCN5n1_LIUgSn{>!VmUQUu{0t=onp5Qy+(= zqCSD!6KQ9bn78tH;28xMG8}WR_DOTDyCN9NQ&RL`3%s_z_3E>M>PCS=V2HwExbHg# zI!g$Hr*W{6qOVQYd9bl0bfU2k8?~XLHb#YWMJiTrc0BLD&2;oscGB*V4~=K(Abx9b zq)Wv_QMZ5sH%op+0awLZy_wO`*VQ&di-*{6E4cT$#C-H&MZg1I3z^K@t9?Tp#bv~Y zDc_}KdyV$})^Ul-;OW_OBX^d^hc3z^5mjDITP+)pfS-%@g=7|Mb63u71YH~k%9nxM z1inmOgbwEIhcv2KusgYwPz)S$hL+zfI8cU$q~Bn1wD}Vf}#`=oq!=S z7JInkQbofq*Ip}(LQicD_qafY{GclpPuNm9V`9RxOK-yHalM_E>R2`b|FGDAX{5&? zDgwkO3o#u;@#+$jXhu}G@c;efaevkwL}EhgjaTa8gPAIM2L%f5dQJ$Y#Nn@HN_q|s zI6jk11<1^yPle6Yr3-4_m3yd}%U0agr;sSW&dsnFU!O@Qc=B}ev)koSCnmR4);r_X zUo~WjFKk)w!2$y!Gi5%1BQ^{aZ_ioRNeEf5PGa(!!&(%=t!w1eiWTAHAb+bv;X@F4Q3c)U!XK|G8lk07$$|yzS2z%g z1S~3WnRIjHJ~&hHxb9S4b=Ev>W1s2m$|26>d@X?%iHn^-r(YFDEucHv#p~t!Qd#^w?vc`2sN?BT=+@AE z21jGtIhmEFH665IEeMh7$NzoQfx=ZFI>&vh{6;Hj|7WQz*0y{JB}7#Jb(oy~nm5|#y z7s$x;n=W2iW&L+GHx}fLbr7S@c5%7d>#>ie$0^bUz3fi?!uoVwktHGWwC)dwC9dkn z6GZW1#{;8BgK~P|NNmSJey;k$Ku*>BB~HZolCFhCPeIAS2CB$jz~!wYSIaHYU~1=% z!Ihmd#uWyLkz`of{bzKX!BehLH*S?JO^HlIQ6tv5E)mi-PVpo*S0!?gDeWIuD!DfK zy@Tg>TG&RY;HlwAMo}BSahJ>CaJ@;z^ia)GUY96tEqNtWC!@rkl14CKn86o+e0zCI ziuC!B1}Mfl?e{R2@S>y|6c zFN^otcuVVpU^h@8C<)Xgvtz&fo@SLe(t3!9A7z&x%q%Hy&3ETUMD<-Ln-OIt1v;k9G)GMwa=&$xY!?gH|9o&+&RP2F*F$5Od4MG>DEYm+Xf%n7uA zQ;+RW7+ysUuB6MeWtF(d0&I1m8JQZd_bu4`Z^(9azbFov!{|=VYj-f`LtLwJ&h|L*Ze%@e^yqWfKB9l+6wF_eTCk65OoIzC+1gH z)W4U4;&pww?Q4>!sAl+8xsx)-#L(#bPwGoN3j$k}?sL|HG1M~2f{tqU$d+jSydhuh zugh(i2S(RxQ_~^RMss;O_cs>w3+*B9a}&Bga~!S>eFT>T|J!%PoJEianB|<)@77%y zFhp0?2~I?MzTG24^#NI>%F1WEte}Er z6{x5gx<_kQ7I&nib&i+ZkW_bB)-RIHYA#&A^ThS+hD4m6Ij=DV=gu6e1>qd=j=E{M`g-hf=Ieaq-12b~x*!0oWY)F8{>UrNo&eK0D7vAK_ za?eXh8gT;czIosheS>}ZmnY7o03tExSdjq@8(V2pKMdS;F-R&0n3%3t6Q_?{ukE=oHrH~-{mt)^b$msdtTE)5w7Tni1QC|vLL zhGh;SPWBJ0ZFT#9A3QZyWuO&BeoQ$bIvXqu!lxL@52$iX9zKjtGLLUxb_qzR)97={ zu1nzIY8tG&hd}qm7wjwaue!G>kn;N<&gg|t*3)L#Yh{HPUJJ12W5^eh$E15FX zx4-|`t6kyar$oH^H;Ge`=T0Sga4o;i^>aEykd_zI+QxFjQtn#O7U9)+Sz4b1v5b@7 zBQtbKjfKN$FdOX{D(`UHPa{S>Ti{5r?Pi46F4knr->2P*ULC}$*blC_7f)7=2AEWl zi9|zq=b5a8GLH9ga*D~8lYymbuxv=~lQJ~@8f=>ta~Yn7f{s#W>t4c?Z1^-(=8^}g6+WcZtC5Zqo>`8NkpvnzkRXww`yc9JzON- z(*o!w((W77fk#LT52bfW!E&Ofx4{9$9T6iN;C(zjnw`n+`&CZvS?R^wK3fi_lBdvu zDcml6DgIwP1+vj7eA6i65+O*h?IcFsnkcrUQ9!IHOc^f>5>WB`x2QJaYpG`_v)f2- zy^ov1xb-kPLjU1^iH&xDu*d-nMX_W_HEcdTj4?56#Ew(hw_(j7u`CtCF>elpOpa@0 zbb|WpQ$?X?<>o3M8Er6xw=r@*A;Cor1%`#e0qV{O7wUrLclO2FKjEC&%*A0VbBa$Q zQl6WrE&WA@Cs*{0V9cJ1h9U-T1W!vnONG^2)7EOJVW_H_FjDP**0OLviUVnJ!_dpl zUN`gN>S{ZTjRb~-aJ1w};C}v`i2gPsg_p?rFg`~vYxLC^Q&k1s?h=MWDSI&E_L`|u z`2S{EHBUuxAWB;aDJ_V=az$EwjaO$3AhN8UZ#U+Eu!Ec*1L=n#{jTz@msRcx1=<+HFS<H1tz5$NqzU;hSe$ri4fcZxNHzJ;flOp>542H{xdknjoy zmQcYTgFy>roB)tTX1(?m&@f0kV6>_$L)IUuimpwR(SQ*G9&8te6hXwxqz3cv8v|6W z5b8T9-NKV|_Z(Fpz!T$jA+Nvr6nW1t2{|n8g4F}^84OB9BZobp*zT_vHI~}V3Be3U zP;l@)7`9-09kXn-)DdYtp>puFDBVMaIN{Zl2@e8#=I5OQxLUJ)lb@A+dJ!k~al+au zj73l1V^zdFkIDwQoz;FpTr!lX6>MgtDaQL|{;iPxO{8-WfUp0AmbL@yB_7tJN6p~R zfiHk6BqVg7l&}1^!_S{Tk+WAYo4T;R-VM`&oiLQFkqs&O+I+TR}q0mGW7`>X7ZD?R7bI_WDVYdrDq7pFRc?vh`g zX)z``)0SR*DcrK=ClMEyr`N%}#rmg_QWo%W(=Z}7dx27Zxqv6QjSMtrn85LFMnw*H z!gx0ixKHjMXz~d{YdEDrJQ&+ez)u6B#EL;jVzm;@|EDslk$8zJetK2(iJSH`3Jv zk3d>h_9-PL(#v%KKl`>%a1rhQD^jLk9l|Ula(wmev~43i){f zp+Yd@+~`o?r~+vXNPB75_vZu9HyLP=B0@~>6D9?);SC{S&g><4d21XePEJo*z0aJG zBb;Jts-|3AT$EI}x?Y^{pTF^FmG=p!_>4!=X`qJM`Mh$Ek!>9&uPIQt-8W4wj<=61 z`bqoO6B!s3cvM+gnLA<`5)!gUMUA|Rz2*Fp`Mi%GrTj|dz~_OnFS*p@Z><|%Qa2;; z+}?eU|9w05*r}|&>ZKsgEuV{Djma6viu@7|Z#dZ7larI*K)AZP!suGo96kZTr>v|j z@_f27c%Jq!(+HOO;S{LCV&Hp#4_esLA#TEEZ}}-e10V6|if&eZ2eeG7f_K<)6zJ82 z8mWJfr2Q$Na)sSoD$If2WU(G+fss9aea}r!BwitJAM6_APnJQSQ&aoEA)bKwFqm%w z2l}r;d+YL*GO@6a01Uz-$G|A0!iqsMo^@X(1-PVUQm9DQs~SLL>hg)Y7!9Lzb32t} z8_;kgMmK6zOvqf2ZIjP^HY_jD*~KN6ufDp&2oMbH7{Wjp;y#%`Jj^i@q$fUYZEM?` zcI;oCiaqv#Q4puK!CS<{#Nb5#0+0b|7{k=m6d>p`WMZ7BSGpy;qfL-|hI-~)z4XHF zCJ%BEG?U4z6- zKpGf+6DrmP(Oj#-^5rdY%6#IwEo13M_sAv3^Wt?OJPL-or``M$N&9cA+91JOCWQ-s zj}D<%Xun)yMRGu9f2V$QW$gHxs+Qpj!XU2TOeoUpAk-up+FFXgFn{W6aG!bg4zk8l zgAa2Oj_fw3Xc3S4H>hbS4*lB4wG-I#UANq-)2?=;a=Pip2$1hhRdMZi_w-y%!rFU& zak)HTt$e8E=F$v33-Ei&luK1%k$PGR56|L#O%}s}ybVF;r004w3{Q}8j$1G+GgQ_u zl*DW?S?|uCmzM`~Gx*@~rDtRS%p>sd@NSKIVyEY;YTMSC5US>~~PY-K%vdDoHV(Qj@35g`=_8Dh+g(fEJYt zk&$gNQ|l}MM&T{$lJe40n9@jn1+RR_mHc$~>mY&Qlrt(K5LtxFF$LOMG=H@`*GF7b zZqw7PO)L{-AeUtpk+}x;gE>cltCTqh5m^8Cl|!*`+iDdIIASZ!u`^_99LhD@57z!l zis4(S43^YAqiVLu#3H&omXITzBXIEc1ekeX$2ce1gyyazC+T+I!GbsD}wUk z$1Mr>9aVdxil9#aB$VRKod*k1Y+am^$Q|!~60HON^1i_NM%lskT-ps3w0Rilhq-E` ze?m?D0p`V;u}1DFf3@bn|MX89)9d#4Q7(r#vDXDk8lMZ9))$s-m0n2;z=ppb9p}Qu z%0u23KruC(ae+~67`wT*K3cE{PjwLxF&jA}1oN|iUWDmHdme#yaUlx6YQPQWj$;(XUOh_~*7f}}_biF_@$WA28fV$!fsKAUR*{d$E-u*WftY-!wG%R>TE=bo0N z#HZWE>wGtdC7~{fwrwu-TF;G-#0rrT-7K~|U-r`Tv~oR-j))3OZ=zZ6dvhvjUDE=W zZ7v4!X5mJN^}km$lbCN$9+h(`xL5OnUU^~HwtL)q2XRwu;bi|r0U1S{7zQE<9Fk0$!XeAR%G+A99I{=otUE0(J{EU zoPCe>?!o4GgsYiLdv|Z@Qn~f4u6r`m?V_^3NsaCszP>DrGlKOsdpyd!7Rzog0TX0J z;YeQ4&+)HhAOYQwKB+q?P{_DUG%~Z16}P4@@;&6{Zhln4!M(Ekm5GI&b-|at_610O zxz!vEbM^_oMUv44y(!rLtVM9j;x-_Eel9IZe*^DKjSB#Tmb%V15{M# z7IxD?u~`J_Y|!mj|91(~10MqW?#rNbh2`clk9qh5z=1q7m=B`YL6{zR2pqQkXH(c!hGq zWnq}Q*M%@brsb!i$x%0d}} zngN$DcKa1T;O%yL2AR)vpGzqkPNe*44hSLP9ek04GZHHMa^m4<{`1uE2%i%3~M( zm5(WL7AkYG7_)ul#|~{7exxhet#v8vY!!^xnNsW#Z2ZbVspq*cSpQuyg+6^pZV7bB#?879vbPGuVmb2cK6>g| z{TnUGv?aXs?qK^2Y+qlW!-7XSp?fpavGPuIODF;Cgzc0VV--%)$I`d5>Ee>86sq)CC_I=?%uy^Obb7n z4mbr?ZoBv>jbb5(yQ6wD+~P;JCdcMmi874%VVe+H=W8-YRpSRJwbkrjg86ql2``8V zS_!XdpUr$Ce?}Kw{8z0xU6t3N-ySlH#HRO6IXew4W90CG^~QGvcN19}ZH_!KQ3vXr z%k4LO^BB*+qKmg>Kg3N_RP*AyzTkd&Q)Gq@kHcu#FsalG>PP2X>Lx6Juql zYz#^DBXdTZ0nN$ftFdOZL*MI)^70G?3jRrV-nF^~1gyS=+7v4~UQu3@&oU+mtZi1V zTHoNSlCM83iNybK>5Sr0A^v4t83cD(C(o||^9(eY8O1N(nSF74>z!HagX)Q<}j zdUnF$Ad(UJ(J=svQ!X$n8_u~+yQWEIL}uny<_EBAB=K;zluEd&Fh8cUy;d4d*=h9Z zlvQTCl1uEF_A0iR!UV_Sg@Y4Ru}DI9|DF!w*Af9=6srBX=VAjc@iE$xERMG6^#5`V~Yf(bsu*<9Qeg~?aybN4_D zjYyKNICjbYQRTSBI!RJE8?@S7VcusDPCjo+Qnj7==Dg3D>v4TpMF6^<&S;iY(pkCf z%BM)m7owktnqDaZADiMiNENYcvLE#CkM_A_1pf_Zy}GB^3S5)pVLR14&Ul_W!-b7( zgVI|f0~Q0+tzQ(vB;pc3J)^pzCo51}o_X!_s8dExG%4{@R00|w(`1WzdEh|6XaO7B z&z3xLuzCpiIVl%i5Rhel(=8fti6Y?MAobF&@%!KW?6eT?zQM;9acEw#7i@TNoPuI^LNDpv-BamW|5>(=?_g|e(D`?r$3w4hk&E;r=Q(#MfJ3^{4-cIO&rk2YgNia3mI^M8_(!KK9 z>?%&P^{YbA)Ox|GQJ|@R217N&^zN*t-Fpb4+TQ9e z)|CL+yI}uY-h3RdMa;O9Ng2u9z*ts}`TRc`BUp~3rQ1RuKHt0D5q6JettV~Vg-rYP z>Gxc$&l~dp+32I(=8Trcs>3dQ1XH~DwFaF7k))4h)Q6c$(?vUi8UiA-NWr%_Nvo!Q6ATY!SQ062!kWE!M>pcKfRf?!Sq6>Idt;;08rveAJygd4rk+y zAE%1+6cz;v?=h$|d44S^uCY6Gnar?9se0zYZJ<`d6Mux`KNPF&HQW&P;@}|z0L-a4H8C2l@?uaYiI{<1$jpIww`v=7U4JeRI>NrVTH{>!0VSgUF? zT;cpV!Nf4#oBEPSqDG7dyX(Irnj&~AN$xJB-TRY_{%Jv81V?}CDCF_H#BDn>nN&~_ z6x%q^4WEShr%~@KvOqT`ZgcwC1A9&+YxM82*@x@v%vhp(>s@!tbaRIjrJk< z{)hN*Z2c}$vNvFzwZ44g&UO*6OpEWmhxf?E-J>&QJ~_NAxchFr(k`-S`1z+IrmdL>XdFnn1fbeSzcJ#UJdsX!^?80# zqQG-N7M`VaEJ}lLb}62(+1(@|LS8&D1#1Wj5DA>;{Yit9js_E;fX}is z=tUV^WjC9?e|4pjdRdVR3hO%8UD*BRuX8xVcwFX-6oHeqpNnJmrGI$*Yw&M?NuNKP zId!`$(RvntjT9WTxeRP;n}X#q?WuSw-xZ19Q6>g8vvYJ54^G*+Y>fK_v|ckeCnP3z z!J!E_;bRD0E^;2)3q)O~?b#Wuk-N%FnjE%bmxPZafz^)MoWFG8c^Ng?av#RhiY_Nk3RG8qi{zM;;s~)ncTf9#i z*j8`a+yC0!5*y~)LbCpp85oY)aL`j=vx%YHG1#Y%Bo=ahE{q97(QSoX;O3WI zj5#u1?9o&}}83wRg@jc|wqe#gm5UrIL|E?*lfdK?x8NA6pS!Kr{>81M^D1t54_HVEK6Kc{#M zNTw|` z2$#$IM}qCkeLRJ%eZC>G5@{F@ELPWg#&n*&+3?~aK0c>;pT2{ZIwu40gopXPK^_QK=l6iP`u6`p1O~2?YbY)W&1l{ z-!}u&Xy=pnxlh0)1aU21*w@Ez6GUocrowM3`0o<5O~Y9a52=5I4(;&fGFf+op;Im7 zNQiH0hCM6Tp;_^${ML`pe3%s-eotEuLwKXU`MTjWDgOPz-LQs(N2+Y-!F_tJcKv}m zF(jc_75-okArG8_=dcF{%hsy`K7M2ei!M1O1rChcA(c5%99b|nXS%{a^fR{CUW$lF zbOrcNUztAZjKjd^`&RuUl<+!fHh?$0ytPOC7u0~B(-VYL|HqdXw>~!m8eBGpC*Px> zkjr*_m|p+CML_s%9N%@S!r;UKoD%*8$4uY=<`Q^~?Ok16px%*-Me2B&8@BWh7f9WM?HivNBR+ zB}v0bNoJxH_i@$d{(irY$Nl)-_g}w1-jC0x==FMz>pHLVJkH}d&QfokVgIMdt2goI zAIV~U{WP)N?0c$_iX33ZpJ%_>MK62hJ=@7$`*Ar*Jngjo&ru829qPQQ-%b@Ysmq?9 zcn)y;=TtpC@mQh|@k0Tmk_LpXu*Zh(v8}M>x*t_L@1fkiJj9;-zDjBE%K*Pd?S*)g z#0LwuI=YQ>4uBV~B(61oHyW@mNGsd#^UYCp!!wSkRw?5OyG+k1N0uJhsSURLs>`r* zdI7;Y`gNzibf!Us`gMLCx2oC^yWqk}k?3E#mv0!=e?m>#u=JCIabMLT50lzsY-mXB zqFfN(HeJIX8IkwCplx z5IDLt8R{gTxNzz2wxnFS)+fhPji&o$@>Vv9x@kE)*P<2G)Qq#XvI`2-u<(6xCP6o? zGoxeWhPT}Xli!{AX!l$)w?uG_`nB;x-|3_(=T0!8js|I@HI{VM8;XBb`rangvbJ1x zJZbl#N-w4i?jjnk8+Oi4jdyf^J^WH5arsw$(w_`xvIVZ|%Y7U(_-QHbtj5>XxWLyI zZ*};T&(9qjUiy1yoSC-0qT6l%(~%`bK2p{$UhH%z_Yfdk*VB%p%2h$m!zHrcmcze) zSpRluLXCZmPE&T2S+&qr`{Elw)~8)dPq&1fM#H>eHi=^p{i$iEqxnqvD**X?cKEUE zrf2l7TuG%U{cY&A*4n~HGq+j)x-(tdmZD_YY&wgt*qvey({Z{QXS`nNV|axW<+U5n z{mwzAlyoFQYxQ==b-O%ue`Ya$QI}He-|cf{?VlfNombm8^BXt4N&xVA+7mq2-w)>n zNO~Cgef-9Ttv+6i0hEJovrlU$MJQX+O=^xsH729;Qnkr!m&-c6u0we8nZ*Y7bl`Lh z%FZbSbC`6bH87S>I9bf+?(Z1U4Gb2yzsufnV>92QriOzr?3U#omwjg_on%)0>UrVN z`bu?bQ+`>s>(?gFKHuVH`KmxBo1G)#t#d?b&5T)lco%%i3qT z?$x)|D{gsSlKbdza`!p=tJNG^XFev}mF~N2IU-jaOZcE%n+*%*ULov@1 z>xsdtC*$SMas}jNG8lToiCn>Dv*x6rxaZ8qKYp(?Ak{*W|sBiC5}k4Kb7nzPfx^)fz58M_cuTdybt zzd4iici9(dh%~=+8Cdo zP#7MMAZgt=6`gsMP{`l?o=9@t%5|6HPG#&_rIOv+CQh^8iX7j4d!j0oSlAd)AbfNq z15-qHu%P(!eA`^8Z zyh_2-+iUZ4E%AgWEcLCeVP`Ygqs3c{&q+%*-Qb&>-KmY^G2^3~UR-SI&9Y~YUzJ<; zj?XmhlWzM^h}1F4*0mKTWPqxU85bX4xmh`|Q`q@!{4X&@Zu|ZtqRN7d#qPVjwzI^ zt(+)#u;)vBr?wF0jN<>r@w`Lc#)=p6Hiwux9X!}J+>;;b^5(s8Qix2P9Y5PHN~~=6 z({4k3TbZ0=mkqtnUuWl_E?TM^=!lGMpj9-zQgUSHFmnnYzn7#0EWcbsJw9EUa->%@xfoyMtM_>J&pMkh zr+Od33G3{A`3{0RnwU#h>&)-XIFfai{WmRJvhU}?I?s+pS)m+UQo^mwX+-o;!j;=hvOvBQgLWkV3 z;XBba2U9=&L^0Hx&qn#WMEl{+-p!f=YSDA=J<|;nHz|g2a2mc#IkeT$`@o71UUO3Z zCB@tae0S_i`T9f@$A=3?BpB=lZ-Cp!Ni6M5Pg z>^2Y}?S`ZWa{AdjbeMQuGvp4|q}N2a%@4i2xFS98MRUtR>%cSg+G9rHKwj54=(dRN zR*qEuFRmV791jQ=Jxu-eutmUcZUGoKz8KT8wlY5d?JZ92*nNf6XfoC>`%j~9)!Z!5 zx3Q^3uUxZ&wNJ+K{;qciN;NF~W}8R#;!fP!#M1njCD|~Zjggh99sJ*@%*)(khi&K`q(~EexssN;H2)jwM=SgRdDfN<6>iTrPEp01R3qRkvt$j5vB36#! zZEf-XAPcdQ{F`0%?UZ{8mDg5L=Tg1CARc?|w8~9cgS9SU0LDhDUfsrvU(@Iz*q!u? z6X0sf=Z8V>e#p42xvZ|Y^knM;lwLQJCj8UNMZn(k{FY<6J>81M<(0{elvB}(6d#8O z^&O$mZ^*rJ`b9;vVf4zd$dk7XUx{FAQO7l?eW$9^Q4kB$Zl{U)ZEsViWNN=~VJoHl zZG0_U6w@CsqLv`VrN~c^za#z@z$G1o~B8P)L$504>iM| zH@j>~b!uuGBOyTe>DqPSi^N|yPJxD;{A!K%y9(1YGq*>~{TR|L2Hu2uZQPtJS;`~! z`^3c6Cmp48i(93QXUTUNH(d>UZNPH*LS*ynZsqn(Y_1zAxqa6%w(#Gu8{k7xxKim? zN7980whG+>(r5W1pXj_5=qkUSNoS>{&kfq_uA)2Zxt~3Mo4aZ*qbdyj5g^xo`Q9Pl zZ?*pV@)x_%7{zWCFo0v4TUHhb}YGj*5!j z;M{#UmgoXMe>QwoaGha=<(lIr8P#ES)IzSJM}iEOB|&8$o9``@7_Bl=$egrN1HF3v z6KM@kts9rGlt`}Gv1`6XrqXM!l^wi^M!VOJXy=3RoN~Txovh?}ZsR-k0S>yY3uw0< z{&e3CJ^a;cQ(=*2Is`AOvdYRKxFgxdfykAvlc)j7I!yE|YpMWJO_)PH6O-vHFhxm`6 z0F^oSnE@A&3Ubr+=sp;lphCO^o2&0*JvYI!nt|&`k!8~c=tRGd@M*;oO4|D0#3E>u zyNratyv#1u>8ucK#CG~SI`q^GrOtZ`FZO=U*j`X7GE`+WK;RZfi`Dtwb5g*y*Osvb zT$7dZ6)ib0Vkpm|EqAKxBR8e<$EEt;B6l+l$T=VSd#g=>mtW?gV2z8Xz}@=XUn&Fx zxnxL;M}Dm_$h~~_%=v{W^Gn{|E@u~(eQ#e|O*aS&(-Az{Uo6>B`^Fe2AYw8{olr@n z>JoXFr}B1b8#+21ruHjzRFc#{pM3Ww7}?`ck5CxnmZ&;Zk@bCzv20^+cYY0aq>B-! zlKy^2*{gZSLrZ0sndR#Ter*_y@$NM&oMwOVb{zYl6X>ws01-$)|+yWDK6aA#(Q_?c);<4m0mZJ z>5E5|dDjq}+MD z=oxLSqM@MyqmJ|%4-lJ}HfsJ*ZT>IbTwX1Ba~)hFG~BA3UteAB_8#73pw4&y{X$Hj zyK`!5v$tzrXs*npVi(8eHS5PR-I~PM`ekA?Z&uq4G)jNJKqpMVl8Y4CVQI=@EH zKHKO$Mn}dU;)z#IR;Qdu2IC^dZq1nXrHE#;cO=IM+_qWoeBH9^8vFh`vlGuJelPuz zXnt;*p7xl4hHr|+2+eR}O2a1Pa{P{c%dP$jzUQVq8oORpza3*qkrgql%n1lsvz}$o z2P`Jyi*at^EpacM{+t>n3T~RpQ8%-{RJ=lnDik<0;h)|i1}?g@4t;Z4Z7r+&-OG^Q&arH9=jlRh8M`d`S=w$K54W}w|tZx;RtqQ zZ$a0}@!MCcrV$<6xWrp>2O`3$k`i_Y7v_qEQfE*zod3M}?q@p{4r8%8%OgL{M@QDM z??sjW^8TTWu0j~@5vR!CzkeIT#DG{xLOkyOApJ1l*Fh+z8=9KFmVWCi3V85f52|$2 zi8-LuM#DN+f1a60sW>F!x4f_qos^EH7;(0(3oYe!hQ$-tuAe>)soqR)jJ#CI4oc-x zbqk89k&{mtj+(|bijS0geA@!|6AQdXe7q$b7hV@yvcXpu{KP%8KfAiRNJOIiWBC=p z4~6Uek27o5tbtc&yY9X}4e;Y2BJRS%!b>1?6VuQWu$=C>8Xm$6m`A0dqO>`*TCG9% zW^+s1vw`EG18x_P*Pvihu{GrC>nL@3;^t$n&`(5tiiQ_&EGxXbE_qjHgfoEQ=+Uf* z^vFnN;J>wSfhfBqQ~IR@OtN4Ox#$2+ueI=uy0(gK>(*Acc7+&c<9A;H$PnW}IBJ3Q zN=GbbKthX+izEImpW2h03#8GBf6RtpEc<0I&#Nl!SBalIpmhc7F4N6F+#+XJJ}e zxZRuK-Q2WQaHjp~+IPm@w>NKd(9QRt6WGJaoqYp%3@l!)a10^#=NO84K>Wn77*f7z zj<0(E_|i5JH>YDC=X%+s6M-ODHTj2M8kb_xy4%o6x9mFQ$iHp*((3hMma>vU%Pz;1 z4R)lpc@S$;sAa1C;2Rl7_?d7%VAACW;hkq6G(kGolE8&~Pm^zKc_w5CsU4}3jY@@P z>->Iv|Ju!<=DX=hBCmu(W!(@{iYVKIpwF-|x(6pfa{TNuEbxH|B?V{bGuU)FWZHwe zYrvq{u47pIgPNJ=^5uxk7n-r}25xwTMuVTwY_PKUE!fJ)b~=}@Tp!CJJ|Uh_QJDIH=7B=-C-wOd(03|OG|8jVDEr6~^GmePD0R;e@4$s2s^rYvL|@OxRUVWlQ$Zik7FrFbG~g*C*gomI`Ju_?5Vg9fU@k zILXfx>SXn(Z(UpF>LP4dS&8$>iO0WvNzckg%*xcy*nmh<*V`-gz8cZvWs2JR$5mB? zBTV)MoZ{d!NX%v7s!IY4>~VbR1Wr5#K8#B z2aebD#L<l#Or(j)$s1WtB)bk3EYGf`(<*qvr>$`OAvyNoJN%Dc&lWL`yL?Crz zt<_D2N2r&$q%(%%bEk|9F;Ao*H7kRm z?(*XMWr`=BG5PO%)0cCyct)S!RmsVnpRj_7`OmhmP)5Lq_fO5Qom#Q?mP=FkiI))) zVRVT^CJHPiYl@+K(_~RZ2TD-KD!v1fI3{1mxP$A9yh7p-kx72>FB%@^r__URa`KF z+MyXOe5!_W>C&aC>FH!FsQYPYjLggi9}>>*+^GhWS8F0snHbm#hZo{n4}U!hjlyJs zdHqZkCyZ{?)zuT=QC#iLE`64QtOq^DYsYeWmc^alv7-ZscwqFvP_rJye0W*m?c60c z^~fz#`Du_gr9zoQOkT<=Dz=a|2E$Q5BWhOj9dKF)=ffA1>9`!BK-#B>#;%-Z1$i4`yNB2LI^;%F1=#Uvcj{cJ2C7?a<%Y z)U;3dRj25|&Xq48+36F1DG>AFo`PKwZJd;X)%I)@y=G8Vkg(XCY!!Z|INCS{mLe!Y zFcmrK;aU6!oBsj~qt?>U4C0F68Y$-W-InV-&)Bs!^kk#o^%~ptM+8!W`NY^0X-5^$()|sw{G3jouILV_hw=u$L`~Kd(J&c zv;MhP#_HBYdF6qeJF&4JU`8%v{>=C#@k@A-EGd%Fc5f#obEB8v{*zlC$zE@l`h8O; zM!%(_=M2`v)9&s_*iIH*n6*KI`+evpy4p8Vm}3P#;8ak_=!&Xnd)zSgZWh{^kJU|B zs=V*NVmVXi9@B&a)8xhAq@-^`?dX$7`f`Z@>1I_v0SedK`}~8iu3Pt7%W6 zwt|&3)-vs%ho_pxbp)sQ7CNFa!v$S}C86iVi(;Nr9~L>qF#CaIEc&_%PhqhM(z*m}p;Xn?T?ZT1 z5kq?)DryaH4mFX3n)>MG!dXbDKmocL>|}O&`Y-QUzRM>jitI@l4CYjbhr98^qM}*%7^+K>)75Q1Vpe}GGqSQ*epedGDdLh3AfW{wVN`4B=}%+U0317u;P!+{;u*W6d&Io$ z2y|ltGEDWdS0v(lpZvU|KIdqt_=LVg?g`h=-*wEdNq?pZsut;OVB4tnrtA!mMbVUhwoRz@Vur5s}o{5Qx<~JhP9hhN-BMKtX6p@sC zHA&<+MR5{Sb=k$+D1Y2SEo@R6mu=Vsmgsi>QsT}IIEj~>%nJr$6RPBs)>5JxV`ZsNQ%+r61ddo!%k%QP_#X&tt%4am(e;~Mybhra&2AMp{(I%KmICQ zH_#PcUf$H#Bb(HAP5+g^XLt}Fr+YSj|qj%wy-wREf zj&v36mJ!wK0Iv|X!4K>CCI0%RMeYV6b%Qq_)nTbY;TMU_O!^OBbLlg5dqOHmgRn^O z5Ms!UuwUr>zIqMkJlx4ZC^<(`Gx*@KN}XYc(y41w_u#<~F!oG^ogFc^6tX+W3o~E~g^%eq7Dl-RI&z^}*T)GzAzod1(sz$TJ>9x!7 zYS`U$)eu>34ht?>O!N3I_dD^n8h?b38yGN?Nem=!gixd#2SxMD>9z!ONGFMT9QKK& zrDZ*AA+fpFD8U96)@Q`Ul+2nKdzIUYV0Hlo&;mN|U(m%xBpXHPNKDj7t_Jt!St9F2 zj?)mdQPZ6R4o-;EG%z4Ld+GBo<>PJj+keaR#(Nfg^WOyh#_ZUmwkVF1Q5pO+>yNQN zUA8ev>wf<@oO)Z^gkE;TE=+NN=UON1CoQ7P9$Kvo+kL-@{D)ggudJiiS}K;rsI z%=ci?Pr(R*7CiHxm~ugS%<1XrWN-?Z=0L2n5x&s7|B0~xn(WI1_b5ZhHwF zzn?IeLM@}!DZ~LeH6H3P(pd}G`8|f~Us+jMwM8b4t5OWyRHBh|CA&ou)`cv8=K_&fER`U4F3K(3y0K5 zcoa|LZM&j&5q(OuU8tcx;R;USh`u!YLW=+VTrcQi0eCn6(n1LzIEJ?QH0@7IH~-{5 z=3pUn_LC$~Pysn{y;UUZgSEIQ=p&%3&@U}5Iuq?9%um<)ASEGMa2Wo5Ldi(BGEs1? zT(d?Dr!ECPvOnR=94B{P5XBqZjpMLSr#m%;qU`8Q(Dp>RL99>OrRq3pFs|p;Ed~_> z-t4uj*c!I`@o$Zgodd~pLk+La@s1IGM_I01?G>^fLL5hN-8e@)^)P{n0Ci)pA+G$5q>)(a zzx2i|g6%t6B2e#g&lG(H;kxyJU8H-6*B0j=35RDvTNryCe;kIKN{R~~t{vg%MFj;L zzKiewAVYpU|L)@T2{927bAU#xN_umRV_>2jC2&_BLfwb3Q8{;*1(tt?LF#Sfpx_{4 zjlQ>=eOyARY~5wXrCn2Rr!oyL;XwY07J%!BMrY^JlYK~6lY8uqo?Q0!6_mqTT~UM5 zixO{T)})qLGjZk2?PzX?&K?8Iy2?Fv@qJQu8`ppv;>n0q-7bk@5kF;jj03W~z0n|t4K!~iYtr@p%3(L*j3%M#; z>0{ly;GJz1m`w!F!s+f?Eju1;wCmLoX?~NGH0ZRjXt5HM`h4Ujh`zpG0oLgJUTpJiWVpDSU1eAl^cA9wZ&5dPGv z3X4zdwJ#PggzrV!z9Rp3V2UW`e*SF9*bGq;9EEbm3;dchy8E;=G-%*>>K70|&A`Et zdnIw+ZK#nBI-Db)>%6dd8V2wkl$Wi)1=6jGMn24GgdPn1t)Y-kx-0~;Rhsy|;(~t6 zdzjF|HS|m8F^|Y zACTNflWbBoE-OT<;EOb?&;IBoP$yl6-xp|vY8c!HRP}YMH3jyuzA!%CEOhcgL#8X6 z)m=Ux1Q48gPZ*e)k?^Zmd!ulaaCpU*}529N;LST1Y(3?EBXHoV4*Zd6HPuV>}(j9wod|O|SXcGl7R% zpr#VF>?$<_Q6L;dw@n7HA>#;5;U~`e#5fgh>+#?S5F2X5qrY$E%M=3zK7R#A)20^- zKj2kHHtx=UOoopU47fgkJ_D5!%-8dqEhoO+ZQZzea}$Dz9pW~yi4U-y5IoF>)&W%5 zWU$nm5~o&D1tE0OdMMyJ;MHFTZ{4{F!%xG*ln*fcKzRNMVLu%q>II&t12qsV^h~|a zHXc#Dqjd+hS{{rS2t=ju4_jFqJkvGu3QkE$@r0uF0Em9zf82fiG`9MMfZPKOOa=MqV8$yZUT|bg%IQPM z*T|=t2H8y8P%JlNqEGAFkyjX)fYu2`3B4#(Dj)G|KEaq5a|nwpp3(rJCLBIt35iwr zP=0~A5C(tm5ZLubXI&OPtQi3vFKS>4dXpH3v+GYa4F31*wYCt>LGJrH?Hnikjtq z*Q@P*&;|9(h&C;Cg7vltpHiysMWwo3RP;7xTu_KDHGrg-w&Gw7!x;)4 z6VD45TtMv;?WJFBZ)g9$S^-!Zalj?>5wN&1bt44BFJPx`zA*Li9{{*F1rqD7%Usg| zQZM`EZ|SDqVes6|>3lxm*@oP@ECT_Pj6Lctc?p6VpvGsNh@&8hw7kX2&dyHb&4G^t zsT@cLGPd-W8FLs=Max9En^-7Jn0ZkXp{s~@L<pI%*yk9vmyR~9~ zG8lHIA<=e=y~XQ`GskkZ;<=<;j>NHk3cI2v;PlWvAIX)nnVgIa6(Op_=l%k`_i5N2 zGC741>7ZOLD<5e~PVTTJ4j>osADs(Hg^FXtqd1_vC8mFzHplxs@&v)v-y!DLs|+!A zORw5Ij{1+|<76*UVU*qo4rG`+-|L8MU##b{jOV=XF~6T6^6SCVrLuK)-RPt)+a#oJ z;HsJ;%D(S%0xI!a==9CtMU!boq_OiSg4j&&K(!B0vcREN5C=~S@H9_kD}Ci|8T&2x z=kMF$9D?6L*<+{!P{qYbPBlU!%qOt-o0jtH^Uu!CP6UpTt`wiNbSy~?$Y)=iD8HoJ zP+nO%i(;M3J~MW%dWwm93y|Am&|y<+Yb%#XWY$GN;Qk0S$Ol#6W$*<%S#f9)Yts-o z0KB=HaISIH;z-E!Mvn%f2c|1ir)BS)JpHsdyY5z{16PF0B(~D|=1dFY=z35>*Q?VAhL9jkgKu5@?{jN4} zoON_`Bj8L}U?`snEcd}XB3YL?s+ML?azrSrOS%g?cSe7|S9DIKs;ydojT@F4;(0s6>&4=k?{OR@!_;{x6c9b*#00hNz?fA#$} ziD^Y&=seU)bBo<1kDex}9YCJ>fhSk`p=bR1)SYO*QWxn1?bkIs4PFp)aHIh5&Oa$Ca$BXY?+Uo#oNVG{rx^JQ`PO~R zSgii(ovfBU4>v;<)%o_z4N2AB5S5=2+`cupJmaOJU-9XQz@KlgNm;?mZ-AE{F1^2?`|9W7 zVoVx2tX9D14K|KSRt!$s$}scNf}qMARd?0$(xQJbjvzmN7U*{ZZ_=hDwxEwje;UNV zPPLr^s{LzYleu3xhLHJiu=;i-xtt zBwW?+K|0j_M?=!iODU;Y4%tRV8lv}p)Z<_Z3yK0xlzSo=R6u5;5&Q-wNoDvB@-jfj zd;Zp&*btN8JqA~nn!j2hc^)ocBH^z8>FxJwnCV&u(P}Fl!5ge=^Y^G z4u1SdRfEYIWtf-ZJA{E%3ph)^=kNOqbed!KBO#nTTqr;TZ~qoeW01pm6c*&k3mUpY zY^?LJ66RnQ5|zCW5ftU2ezy2mtwJCq7L6ECmn2L@CW#SO9#nB(BGQ4=Z>~HEY8(n; z4aDaiAmauKJnPI@ymF{ZyX5Elj~!Geqd0D7){+H=e0zsR{4;&bTKxx?A@KtUi>AsA z@4FaMbvq)035=~0WJmph+L@9}P_8#`scO9t(VgMEtP zf)ckzGCWU!q0_M)h{K~nsL(%E31ApU^ixG$$T5)n@rj9T^Z`&>h$)5Fo*KEee9+`p z9eEjRZ279@4zQI4*6Xg4!Z)D7J?3GU;-5W3UE9jzT=-$o^`EW!j%+drZGPam!EVqI z*47u;z6!@bdnCMJ=+QC^wL7Nt=uu!)?*Xk3kXeAD^b0#zud*>8$9Fh=`aQ ziX+8<7HByPrOOB6*$zxOD6z_#UKEcP*q0ib=}$Y8SK&1$fH7hgkoU98xcY&^gpQ6h zKy1t_6r3*?lb4sL2{wf;VGywCZSg4TI2tvmZDB@T0|zwAqZ{UmOV>T#WY)(WwB;Ep z6znYxGQ<^78GOnJ=7e`Rjp{WbF0KWASm!|d2>?YW$pN>pu>3^tzx{;-dn+7@1ZLPl zKaYmB2x#;arS(IHbrv@#oKRn@B7Cs(9L8b*FwRQiBopB%@GQaDf;N2Ri7_`!6D$I` zfE4=w%;JCby10}((1mQ<$BCvIx-3u8<|3B-WP}4&b_7N|`(>`$6aR@%Tahn0p_<94 zr3278j%IlG7ZevG*Rr&-igdoDhogePKpNf?fX@G(mHjg(F>C?jH!Ds7;=<%8GFS}0 zUA51j2Pdlph+bLxeWaI|1^*IubEaxce{G!sepN)Q-#NG>@0Q!6SO0%FFsaRh)w^QV z>eUu@c1B}vQnoLBYHDiML_0uB1<*pkT>&v7Tc|jE9ZN|6EsweTOS>upE^R$Z){w}- zPR#MTNM_97MY2gcvI5Q7i7pL}GBV%=Gf@Ag$ZK89uo#BnbgDn3pI@U%pvd)lCL7A{^78VJ zpFXV~7K~g(uV5DcZ5`~!WvUjk8p)j+@AMm&lgdnD(}G=Dp3X56xA$B95JK3N@V72{ z`-)F!=qyYia))hIwe`oM)2F7+f)s&iX?*hXzkNqc5tfLO0~(c26MGLySA?fGo|k52 zuCEcCAlrREi6TgS%`X3hWZt+7OLonVt&2EFUH)WnCc&?!mxn4U^-bAu`BgYFU4vdyh}L`uQ?fUY5}fa2T!^ZdRJYbaG}xVJThk6;Wl2 z{3RMRP{)-oQeJlR-`3nO0tHg$Aw0xgYI`o`_t?)lbP}`YkrxlDH{Z|*sp1Ri-!HXW zj$Q9sWW`0n9Xocs-{J;I-Kx7Otq|5=NlL>9Pm#FXrL64cvtjL>Q`+i6mvetB#sHjh zb~@H)9<=2iq7|qgbL*$G4Fr(%z;;$m&l5v)G>t-#pGj$`YRqeY6q&k-jub+Uku4kCfAE6UM9(|yADng)m#9`b z91E9#ar`bhE5>IyZFgISlZnRj7&3u)@JKL|m>YzX zCQNdqb0K3&Ql59)L=V4ybs&OO!^4WKSv1Hc6Xw;nGYw{GLA)rXz4h(Qjc48heh&iz1t90mL@)AI)A~*i#_9*@7;A z_^^3~&Zz1^*6-gl$8V`h*dVEaXi06y*HH2+7Fax=A0&uql&g3x(A_(39k4xH1W^Ie zOr*gM*SGeXSWfTCZ^d$~JFnl)?J;+}pG7{#`j+p93ph+=T!+^pJ=!TE(s3&T892Ab z({%HRjpybh3jI{KA9oc`krjI_DnO>_z4xByfO`o@l0ZcRfn5RhOT#jgpX=85&xVts zAHQUmSNTxv7TdwKG@AGAR4Sj*9W*c|_I+qokQmGg-Uk_XeIw=bJn@G9FKjlYLCeH- z^Mrf%{j*<>sqQ$yn=OWx-`{z6AnE{OW=qtGaZZB8BLsziOHx065pbbSxUC8996Gp; zZbil4_bdt(^Z%sb9MZVG?kS#v0q4;2i96lvN&&Lc^Y2yti1lM+Y>W|s`k$){3WUeH z!&@5u{+@B^+qCL2MitL<8ssu|<5^;w%LB|A#GuqalCWrn8xdN?7-v@h7iI%d`Vkv;vVz3lXrh`G+x@~+=c!R*Lq~td z%j*3*4s6fn#a*M0E5gudjH<2!jDd3)i6{Eg?Pz|Sb$9>Y{}|oCREfg*#XtyQ%=Sqn}(T%Ny!x#eAqYq+Cs7qsgUt zxciXR{;M~bK4sg+rrB9nWeTGJa%fJ3W2#AUZETFXyxU z$5kVe^-lhAGK)=nidr|s)C+ss#7>T0@Zuazn14Juso?UxwLE0qXub)xf51UgrgF9n zzjRX3yAEFuGDk^;53Ten!eseY)=>`=|nMS8R6`(^;pD#?vFY zB2bBk?VnfgSJI{njyj$uc>V1yedR7Vqb79FmG8YAwvn-X&1B7Gr57?vSG32DG}Fn9 zs888=RdFU=npt<_#*M@J^}XF28N(f>zgbp=wPX}BU9B-&$aG8i;o6FUSX@Fv^dTW3 zw_2=TgHnZQSi*=fDDqc>A$#`K;q4+z5-O?_0$js<1}oP3Y^adsUGdxdzF^SXK>apx zEFpY^qY~ym!piXl%NK9p=F+aifnxsLn|Y}xEqQt7Q+~C_r7NEFG8w6i&x}ZLO$V~) zM5@<93}K9Y@rmUth>m`^S7}RD9-b6Iy_G+xDJwmDhK^jIt6TFUx{Swlr;bb)k;)IE zpg7~6h{g#jS$qW#&lr=C8J(8sj>lF?b5WvMt=v*WkuTA76hi4<)#Gk$Z4FY3Yojn8 zqA5>A%c;Y5RFt`1K}{37@~wCw=wdj&d9-eBZn;Wv4}L5fci7M{uyUfJm93tEkbTX3s`-<_TctLL#?h`?wTjGNL(1oeQHwJF?m+*?1byVT zfa9iLj~@(tGZ-nR4f?vWxjFZls<~s#EG)_lD+wbBkVzvtCyZORj0Kwq1_o9IYhRWokJQJhxO6lJ27!lCe6T<6J$l4Uxo05Ik#DwdH6IU; z>miNYIaBTZt_pd_x)0%zYz$C|IFjYpVY`w-YPHOqA$m?m#&Sh9C1DJDiCfp37pZBw zp`0;5sC@vh+Y|HN9P_sX0nAs0FTxyHx>HG1ixr+=Wa{6I5Y<;of3K_daNiH1Mb+i@k1r!JC{k{s zjC!;^iGadzt`WdPXoxGuwsBvd?^EqF!M<`pB1@B7s&gb`6rRG@$sJ>zG-6QW`13d9 zxn7se+&9I0&o=W`1+y!!&IPZ$2M?Zm=u6|d<*Z*@z7CCsBiB}6J2YtDY&!KthKFZH zdg;$<3gwsQ7rm24@Ao_K>{e7bpsLDwfblgwh2g`|u-zj)tjsClSek1td4&cB%7@0} zuhte_#cZqGGa`CwScyFTnvBuFz~-T5D^c-Zw#l}SX;fC3$tev=v&U1Ea(a|=dS=LX zxytdmGraWN^swUVkr?GODVoVyeJCBUxfvNd=y(_GeFc=>8SZf3HO$ApK^rBwGIB>| znpIeG-R6tn#vTa3&@@+BA$K8)&-3Pt(Sz)G&~SxCJ3k0avh93)%6t*U{dc9VA_(l( zTlh&$8P=v_I<7oX_wnU-yt_9O=3eNj$kA$Jm*h1xwf~Bzau!qB7&LU&HXcJ3zqJF9 za?=pOPm!l>q-><5z2qm?Q*nvc)7p9mN(0~9x0xbiVyG!#mfl1;1Qc&0miL5fIQ~)F zr<@L@H8lr>YaAK5<_9-zv^R@U?m~J+R6O0UUMUO4q+(tm!%8ahmI1T-gVVJYM?%@3 zAN`3(h47m67gnuQUQ=`2M%7ehqxfYFJl@TtQ|H@{9y>NjrpZETQE+BJHZn5u1F*KI z@0Wf^k^c|H$n_JsjZnGk9evs)6BO87%zr6Yw>`^B{qtAPpitRQXKmjg>g{1!PqThK zF{Or&Zoh2ti4eenn4QVN7qJeAfQLpQxecDy9KH!fsG%{XrfP5k@ouVlj&~T`TS?`udutOo;VyT6sQ)Lc6$L6T4#9{jM+f zdhF#KGkWZkyWIEInw6cU!U0_uxl5ne>jL*Hc{72AHW_k?23rW?9ENmm2?=?ugO{8u z){lf8x8G9>U#_(tPUmDf zkbm67O+Lnq;>-sR8n8+ao0^6kKY1ao%M#OIS+8<&!8;g1l11V;mZXr4v&5+t@vQL& z{RFFAKfp=sR_h2y$(QVg22~P1DTH?gWU4Oj1-c3My1o=3W$0%UE;k7U5uSLmu3f*L zngZ9~^}q&-`xW=>p}lb70>uZJSStDonYp=7VaYs&v90Fl)|=j4gIL9KvvafU%I9>& zWHa5nVh3S8y+XQz0r;Z7&+VU~oM z0k=GGVD_hWyx!YuE1vnKVNpszK;Twf+`5}jR}}RH1D(Ju;?x&E0E3-zGrf2k(exM!uJBBw@{KjYG6~(M^uKsC*W98n~-G~Rrlc$QRH<_HVzg5QMx@N-@*P0$% z@%UqAPWO7h8Y@s^rsD9B^Plwe>aVpuIpS;~++W;KWNy>L4BjX>Tqe2e0 zM@}s0>>D!-Tc?dq%K``q#+PKKYOk#^7vBlT-}H9jf3JDx)Ep{EtTvzO_(N?zOE z2|IgRTO}745z4&>4`_>vix)uMp`zf)`yb08{vzsYF*Gy; z$m;&IBis@ao4`>$5~-!CdPeD^LlvXRw;sPY73%(c_A$nO>37altjo|%nkX0mj!_7n z$JWC*MdntX6xi3FW6J_!19=^M&S!!=js$dx+nEeJS7U?Rv@%%DrlT zJdc0B)&4nc1x0-9XIfRaNfiq?lZLFuCvMCVI*#yUd6(23PC94{G|c!K;@mdGTCA{yvwxrEh*+)ilzt!UNd- z?*U|dFY@Or4{~0a@t^ORoi6p~yI!vM-`}G@_wce^erFxt$bYV_n(Ecd`_XLXqQ=|v z{7p8gVC`R!H`C^#IM`&R?}P_y$>W_dJwOpRO>idbd{R-@oBu@+H?FcyQ(4pYkx0#~m1` zdWyWm|KEPNpKt9|E_X(SqnJ1S+(rz5?tQ_hS;5*i24Co=qAzmuE3I;?+Hkdy>g3qT zshR1h3V9x$0M?w=kE^Jry6TLRZ#@VF$B3Dk`Jkj?ameZTig1W;A;hSB8`kIOuaj}D z&oTNz((=HutXru`uQu5?Q>Sb+-!&GnRDI) z5_fYr0tO1TPrv!mFm#yh_2zfJf7ofX@-DOAj#xW912P0RNFwWZ>LlEHurlat zVPB~7kati1NOpsBw~GpsGX+Ebj3jc@#tgSHa@Kuy%8hW^5fD$G>|b0INeJQE@_2FYMEU zp&8%+{CoF4MbCyp!HM4h)xtTIPfFd1kJAKw#b*G6a*g1J?JAqN4>G~=*Bt6Hd(=Zlk%%rDM))MK2M(PL#mpco&6GN)K=M@ zJf|&ec@7~ZwZJGOiVsm|fyU|KM9}3#odBR3DmgtXD8sHYP!mmIdNUW!e2OqM6W|K> zoLK~v3A`?dyc{L-T33DR?oX`&IHJmWm6)nZCY0 zenG*K>*>(xoXLr3j*$LZM!RlZEudPiwJWSd+3X!0kn;EeQ$O?IZsy|jT|QSM%sVJK z)vc9fVDX{G7tbduQ-G(P?^D@0Ft^q8oWbZ_P*KoQ2!TxC{nUw|1cW1#XzT#>)I#ID z4%@@}`dwMoV8>krSVDQF$4(L^<{#1~m>O<(J zU)4xch6WyQ6(#E#t8!IN-=-aUi~osy9~4OG@&DXJ|JNP%zkjIEiE+XBgZZM6s3;Sf zeYGm|3Vu@WFJZR(rXw-0cfFV;BZ3`UtCxN`pm~b)OUC^H*r2!o>Eiagw(#L9Ny-Ps zj^%6oyg3krm`200v)m~uDR2H<`3+9F1?VefK+<9wSNLEp6ic58-L~)Dh+>cz6LN$O z2*j>o5ZPej`FFL@noJcX{UK@V!9#~?@wWNgFQg1$55F#V+lgYy!T1O2R4ys0-Y>~P z4eK{-XatNt{cLysIn8A|J3C=kTF=R<`4gu3yhN^@00t_}hF)<`1g$E^#m5q(;Na^g>{W(26=>NdGZ0v~1F%^}1 zx^3vGk-sV(@Gvg@4jok(q!kvR7v<(%!IXuL*RKPCPi6#fW?=9^G@)gee!1%pi;i`4$&^l66BrX3QWyO#sEHxL5M`3Xi*u8uD&imi1!B!&Ue0T0_6oHSmpYQ4~rJZF{R1#Q`~7` z$oAi2KD}X~#j5XK-WiLI6O$OPUW47@viPmk5@e5(Ids%X9!i?@SjXJ^_Pw8YXo+jY zsZ6>D{XLZ^P_Rrspp7uuy=1FvXSWL%Aq>?||H#MCPXaNmqzO-W>eAl79+@U#@2a6% z$H=m(Ul@7k}(|m2Vc-*?Hvm7u_pYm6K}#UK~iSN{?~@j{`XO;Zce>oh)hDBAdpuTDli{-|eaI$-k$ju}eY+H_>l(A&2rI1#BS z{wMqj2V=cgA=25Cv0Q%ir#DXVP1< zGKJF?%T?Lavup~TyVAZ-ZE};$eA@Bbk?w$)U=|n_wi$2yrX=Wmlh;9AORlJRQ!s3Aenwi8SU=ajm^73^zk=K|vi9n8n2+aaxF6*$msZ2^sET+0U?& zTUPdj=f~@tRbPxkUG->h|0BDIfro9+tziUFXL^2Mhq$EVn>U~5yv%{+LWoM~AMsKl9*G(LgwV zwZrz&-ix3?`JsdQ5n#Z#S6|kOG|`9e92}9EF}%t}q0p|T#^4Y)$QL*TqG{e<5offE!ynHTd|Bm`=rNMqgr4X z6pEgn-s@85ZSOpX=q}-v+uGZ^dg@q=9x*c`(nm|!DS@b5=rlPw83y=A)+u2*CN}o< zATp?x_)?U3>|<{DrM-&1y}cwcfPBT|=He45T*n(%`+%l_0aV3h+m9VSOvydwAh+@L zrYpaPwqa-j4Vcd#d!H;xJbwJ(%7}+Y9%AGHK%|OG3zih07As{vJx0h4&bIC?Jy)*7 z!xRuR+RWS2+nb8q1w7=;ygdIFt2(rcL2G$+tpE7YqkVfFs<*#--rv8~*VmW)9OpZM zK`5{9`Z!eo{(*gA4ze4;%&{ryFC6U6Ann3;UL;P;UPgcGW#?CW)LhzExZ$PnTW@qtWHy9i{M&Kv#+Te~w~#1`^Ji;lp-f$V@E zih(wub$-N_^yrTw03Qq@=xTmhy#*n)5FC4xigW7-6$&i=o9H#@ypP@MA&7BpXeZ<< zD)4^_Qa&(mbbdao!k#MZNm<*!Xi3C_M?_KK`b7{m94&`Da)U!ocb(zmaf=NJj%ssV`DZQBhGse}sOa za==}+Tg0DlMjC)=9k|oMm|n#V6}Wxz7HkbdWkFC^U4HckeShlv zhjG%8m&q=}1Sfz7_{Sn)p%}KWVBWMT8K4uZyk~)F63Kw!OW`v9T7;Mde+zwYl0o+F z*XJh46Q;n)H3t*6MDrZMK4AL#=HpwAfzty68Tt7_3TVkY79LJ$DpU03sm{;Wd~9RR&7p$I;OM#DXC(A?>EudOIKn zQ&E2Y{243jE`VxM#B=IYhZ`BvMeJCJz?6J87Rk)a%)Mhd{obzmalDJ;>fg)Z@$}aL z76>QlSjE1u!J*G~`SRt=tSmeCJBUXX2*?z$;F5~S2r5Yb303R{B+Cp?$4laiNl+=dlk0uy62qoV*Fm@@2pV8$^rt<+K%T-=DUmA$ z#7=IW1Y2m9SKWMi74jS|Ny%f~Cb;Bl=*f|jml%mKu(Jn)&{lg&7)fSnz4zB<#Y#qR zsK$9gmV&*2vq=8Tj4Kv*afLRdd#h<#$+%G9#R2xtVK{|>uz_*zL!43I!k~;AAY(K> zI@*8pNlz*W|7($VeS6j0-TeWwCI^Xyk6+YAIyb-wTSGvD-dzFI3$nVfFHpRhI%!~<7Hrt<*D@L?mPUCf&| z|F4zrSU2-%lHjaavs!>lNIp(wc3Jyirkc{LLg02~!?ZIJz;?@HP)Alr#|79P1KwA4 zbJ1PkAZB1#SQ~IV885I=HNz}7YWXqX;W~$bOP+wowp<9iuT!@excm44a2542V9f|T zSP(d}(E@DN$pc3@->%Cp1NQWRo1_8`Neb*Vo2l^Ud8(<4ikF`sA8_&(nCUl)P5*JC z6m&ib=%^*2J2_jO8iBp