Repository: theochem/gbasis (language: python)

Issue:
[BUG] Negative Electron Density Values
**Describe the bug**
I was integrating density^(1/3) when I noticed that the electron density computed by `evaluate_density` gives a negative, but very small value, for faraway points (e.g. `-2.77765871e-128`). 

**To Reproduce**
Helium FCHK file: [helium.fchk.tar.gz](https://github.com/theochem/gbasis/files/6104600/helium.fchk.tar.gz)

```python
import numpy as np

from iodata import load_one

from grid.molgrid import MolGrid
from grid.becke import BeckeWeights
from grid.rtransform import BeckeTF
from grid.onedgrid import GaussChebyshevType2

from gbasis.wrappers import from_iodata
from gbasis.evals.density import evaluate_density

# load molecule
mol = load_one("helium.fchk")
dm = mol.one_rdms['scf']
print("molecular charge   = ", mol.charge)
print("atomic numbers     = ", mol.atnums)
print("atomic coordinates = ", mol.atcoords)

# make grid
oned = GaussChebyshevType2(150)
rgrid = BeckeTF(1.0e-6, 1.5).transform_1d_grid(oned)
grid = MolGrid.horton_molgrid(mol.atcoords, mol.atnums, rgrid, 350, BeckeWeights(order=3))

# evaluate density
basis, coord_types = from_iodata(mol)
dens = evaluate_density(dm, basis, grid.points, coord_type=coord_types)
print("min & max density = ", np.min(dens), np.max(dens))

index = np.where(dens < 0.0)
print("density     at points with negative densiry = ", dens[index])
print("coordinates of points with negative density = ", grid.points[index])
```

The output is:

```bash
molecular charge   =  0.0
atomic numbers     =  [2]
atomic coordinates =  [[0. 0. 0.]]
min & max density =  -2.77765870781763e-128 2.930734188084798
density     at points with negative densiry =  [-2.77765871e-128]
coordinates of points with negative density =  [[ 10.15753086 -15.57090172 -10.15753086]]
```

**Expected behaviour**
The electron density is expected to be positive at every point.

**System Information:**
 - OS: macOS
 - Python version: 3.6.10
 - NumPy version: 1.18.1
 - SciPy version: 1.4.1

**Additional context**
I am using the snippet below as a workaround, until this get fixed.
`dens[np.where((dens < 0.0) & (abs(dens) < 1.0e-15))] = 0.0`



Discussion / hints:
I think this is a round-off error in evaluating the density or a precision error in the 1-electron density matrix. It is sensible that when a quantity that is returned is expected to be positve, `gbasis` would test for negative elements, and then set them to zero (if they are negligible, perhaps using the criterion @FarnazH uses) and otherwise return an error.

Probably it is inevitable that some density values *evaluate* to something negative....but no reason to return those values and crash the codes of users.
A note the positive-definite kinetic energy density also shouldn't ever return a negative value. 
`gbasis.density.evaluate_posdef_kinetic_energy_density`

Probably the same approach is valid there.
@maximilianvz fixed this issue in PR #136 using the [numpy.clip](https://numpy.org/doc/stable/reference/generated/numpy.clip.html) by providing 0.0 as the minimum value of array, i.e., `dens.clip(min=0.0)`. 

Now that I am thinking, the only caveat is that if there are negative values with a large magnitude in the array, they are also set to zero. Whereas the recommended workaround in this issue, `dens[np.where((dens < 0.0) & (abs(dens) < 1.0e-15))] = 0.0`, make sure that the negative values have a small magnitude, when replacing them with zero.

I am not sure whether we should worry about this, but wanted to mention it. @PaulWAyers and @leila-pujal, feel free to let me know what you think.
@FarnazH I think that 1e-15 may be ambitious; I would be happy with 1e-8. (I can imagine cases where the electron density was evaluated from a density matrix that was read from a file with limited precision in the exponents.)

The other caveat is what I mentioned, which is that the same problem may occur for the positive definite k.e. density.
@PaulWAyers, sure, I understand that 1.0e-15 was ambitious. It is just what I had used in my specific script as a workaround. My main question was whether clipping (which does not check the magnitude of negative values) is a good enough solution. Any thoughts?

@maximilianvz clipped the output of `gbasis.density.evaluate_posdef_kinetic_energy_density` too. So, that is taken care of.
I'd like it to be vectorized....what about finding the minimum value of the array first, and if the minimum value is > -1.0e-8 we clip, and otherwise we raise an error?

Fix patch:
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index e674b658..f5065e2f 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -6,7 +6,7 @@ on:
     branches:
       - master
       - website
-      
+
   pull_request:
     types: [opened, synchronize, reopened, closed]
     branches:
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 166f66e5..173da30e 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -3,7 +3,7 @@
 - Communication is a two-party activity. If you’re not sure what someone means, then ask them; don’t assume.
 - If someone asks you to stop, then stop.
 - When critiquing the work of others, focus on ways to improve that work and keep in mind that your perspective is unique: what is obvious to you may not be obvious to others.
-- If a dispute can’t be resolved directly, contact the qc.devs administrators (qc.devs@gmail.com). If you do not feel comfortable contacting the qc.devs administrators directly, you can contact any of the individual administrators (ayers@mcmaster.ca, farnaz.heidarzadeh@queensu.ca, toon.verstraelen@ugent.be, or evohringer@udec.cl). 
+- If a dispute can’t be resolved directly, contact the qc.devs administrators (qc.devs@gmail.com). If you do not feel comfortable contacting the qc.devs administrators directly, you can contact any of the individual administrators (ayers@mcmaster.ca, farnaz.heidarzadeh@queensu.ca, toon.verstraelen@ugent.be, or evohringer@udec.cl).
 
 # Statement of Principles:
 The QCDevs team embraces the diversity of its past, current, and future members, recognizing that the diversity of our backgrounds, preferences, personalities, ambitions, priorities, knowledge, and skills provide unique and useful perspectives that enrich our collaboration and enhance the quality of the software we build together and helps us grow, together and separately, as developers and as people. This certainly includes diversity of ethnicity, race, body shape, personal appearance, age, gender identity and expression, sexual identity and orientation, culture, religion, political affiliation, socioeconomic status, physical and mental capabilities, and national origin, but also diversity of perspectives, skills, knowledge, educational background, and priorities. It is expected that members of QCDevs are not only open-minded towards diverse backgrounds and perspectives, but actively encourage the participation of others. We, both individually and collectively, have zero tolerance for disrespectful or inconsiderate behavior of any kind.
@@ -22,11 +22,11 @@ The QCDevs team strives to be welcoming and respectful, and we want to ensure th
 - be supportive,
 - be open to new ideas and approaches,
 - accept responsibility for their actions and the effects they have on others, sincerely, apologize without hesitation, and learn from their mistakes to become better,
-- communicate clearly, constructively, and politely during disagreements and, after any tense discussions are resolved, revisit them for lessons on how future interactions can be improved, 
+- communicate clearly, constructively, and politely during disagreements and, after any tense discussions are resolved, revisit them for lessons on how future interactions can be improved,
 - give others’ intentions the benefit of the doubt. Assume that others are trying to be constructive and helpful, because they probably are.
 - think about the long term. Just as you are building on others’ contributions, they will build on your contributions. Try to make it easier for them; think about the implications of your actions and decisions.
 - steadfastly strive to become a better colleague and developer,
- 
+
 Similarly, the following activities are always unacceptable:
 - sexualized language or imagery, and sexual attention or advances of any kind
 - trolling, insulting or derogatory comments, and personal or political attacks
@@ -37,13 +37,13 @@ Similarly, the following activities are always unacceptable:
 
 This isn't an exhaustive list of things that you can and cannot do. Rather, take it in the spirit in which it's intended - a guide to make it easier to communicate and participate in QCDevs. As a single overarching rule: do not focus on what is best for you, but focus on what is best for the QCDevs team as a whole. This does not mean that your personal success does not matter! It means that everyone’s success matters equally, because our team is strong only when all of us are thriving personally and professionally.
 
-## Enforcement: 
-If you believe someone is violating the code of conduct we ask that you report it to the QCDevs administrative team at qc.devs@gmail.com. However, if you believe anyone is in physical danger, please notify appropriate law enforcement first. If you do not feel comfortable contacting the QCDevs administrators collectively, you can contact any of the individual administrators (ayers@mcmaster.ca, farnaz.heidarzadeh@queensu.ca, toon.verstraelen@ugent.be, or evohringer@udec.cl). 
+## Enforcement:
+If you believe someone is violating the code of conduct we ask that you report it to the QCDevs administrative team at qc.devs@gmail.com. However, if you believe anyone is in physical danger, please notify appropriate law enforcement first. If you do not feel comfortable contacting the QCDevs administrators collectively, you can contact any of the individual administrators (ayers@mcmaster.ca, farnaz.heidarzadeh@queensu.ca, toon.verstraelen@ugent.be, or evohringer@udec.cl).
 
 All reports will be kept confidential whenever possible. The QCDevs Administrators will strive to protect the identity and safety of reporters. In some cases we may need to make a public statement of some form, in which case we will use the minimum details and identifying information necessary to protect our community. In rare cases, we may need to identify some of the people involved to comply with the law or protect other potential victims. In these cases, we will consult with the reporter to find out what their wishes are and take them into account. In all cases, we aim not to directly or indirectly identify reporters without their consent.
 
-In your report please include 
-- your name and contact information, 
+In your report please include
+- your name and contact information,
 - names (real, nicknames, and/or pseudonyms) of any individuals involved. If there were other witnesses besides you, please try to include them as well.
 - when and where the incident occurred. Please be as specific as possible.
 - your account of what occurred. If there is a publicly available record please include a link and/or screen shots.
@@ -54,11 +54,11 @@ In your report please include
 As quickly as possible, the QCDevs administrators will review the incident and determine whether an investigation is needed, including interviewing additional parties or witnesses. After we have determined what has happened, we’ll determine whether the behaviour contravenes the code of conduct. Actions taken may include one or more of the following:
 - nothing (for example, if we determine that no violation occurred).
 - a private reprimand to the individual(s) involved, explaining why the conduct was inappropriate. This is appropriate when the behavior is minor, potentially accidental, and there is no damage to the QCDevs team as a whole, nor to its principles.
-- a public reprimand. This is appropriate when the action compromises the cohesiveness and integrity of the QCDevs team as a whole. 
+- a public reprimand. This is appropriate when the action compromises the cohesiveness and integrity of the QCDevs team as a whole.
 - a request for a private or public apology.
 - a request to compose an accountability plan or to engage in mediation.
 - a temporary or permanent suspension from QCDevs.
 
 Once the QCDevs administrators have determined our final action, we will contact the original reporter to let them know what action (if any) we will be taking. We welcome feedback from the reporter on the appropriateness of our response, and we may (or may not) modulate our response based on that feedback.
 
-**Credits:** This document was written by Wil Adams, Paul Ayers, Fanwang Meng, Lian Pharoah, and Michael Richer based on previous codes of conduct in QCDevs projects (primarily from Farnaz Heidar-Zadeh and Toon Verstraelen) and the freeBSD code of conduct, the Python code of conduct, the Open-Source Contributor Code of Conduct, and resources provided by the Office of Equity and Inclusion at McMaster University. The current version of the code of conduct was edited, then approved, by the QCDevs administrators. 
+**Credits:** This document was written by Wil Adams, Paul Ayers, Fanwang Meng, Lian Pharoah, and Michael Richer based on previous codes of conduct in QCDevs projects (primarily from Farnaz Heidar-Zadeh and Toon Verstraelen) and the freeBSD code of conduct, the Python code of conduct, the Open-Source Contributor Code of Conduct, and resources provided by the Office of Equity and Inclusion at McMaster University. The current version of the code of conduct was edited, then approved, by the QCDevs administrators.
diff --git a/gbasis/contractions.py b/gbasis/contractions.py
index 7e982e02..4f09a466 100644
--- a/gbasis/contractions.py
+++ b/gbasis/contractions.py
@@ -519,14 +519,17 @@ def coord_type(self, coord_type):
                 - 'spherical'
         """
 
-
         if not isinstance(coord_type, str):
             raise TypeError("Coordinate type must be given as a string.")
         if coord_type not in ["c", "cartesian", "p", "spherical"]:
-            raise ValueError("`coord_type` is incorrectly specified. It must be either 'c' "
-                             "or 'cartesian' for Cartesian coordinates, or 'p' or 'spherical' "
-                             "for spherical coordinates.")
-        self._coord_type = {"c": "cartesian",
-                            "cartesian": "cartesian",
-                            "spherical": "spherical",
-                            "p": "spherical"}[coord_type]
+            raise ValueError(
+                "`coord_type` is incorrectly specified. It must be either 'c' "
+                "or 'cartesian' for Cartesian coordinates, or 'p' or 'spherical' "
+                "for spherical coordinates."
+            )
+        self._coord_type = {
+            "c": "cartesian",
+            "cartesian": "cartesian",
+            "spherical": "spherical",
+            "p": "spherical",
+        }[coord_type]
diff --git a/gbasis/evals/_deriv.py b/gbasis/evals/_deriv.py
index c96331a1..c357a82b 100644
--- a/gbasis/evals/_deriv.py
+++ b/gbasis/evals/_deriv.py
@@ -143,7 +143,7 @@ def _eval_deriv_contractions(coords, orders, center, angmom_comps, alphas, prim_
 
 
 def _eval_first_second_order_deriv_contractions(
-        coords, orders, center, angmom_comps, alphas, prim_coeffs, norm
+    coords, orders, center, angmom_comps, alphas, prim_coeffs, norm
 ):
     """Return the evaluation of direct 1st and 2nd derivative orders of a Cartesian contraction.
 
@@ -195,7 +195,7 @@ def _eval_first_second_order_deriv_contractions(
 
     # Useful variables
     new_coords = coords.T - center[None, :].T
-    gauss = np.exp(-alphas[:, None, None] * (new_coords ** 2))
+    gauss = np.exp(-alphas[:, None, None] * (new_coords**2))
 
     # Filters derivative orders
     indices_noderiv = orders <= 0
@@ -216,17 +216,21 @@ def _eval_first_second_order_deriv_contractions(
 
     # Calling 1st and 2nd derivatives functions for different combination of orders
     if indices_first_deriv.any():
-        first_deriv = _first_derivative(new_coords, gauss, indices_first_deriv,
-                                        angmom_comps, alphas)
+        first_deriv = _first_derivative(
+            new_coords, gauss, indices_first_deriv, angmom_comps, alphas
+        )
         if indices_second_deriv.any():
-            second_deriv = _second_derivative(new_coords, gauss, indices_second_deriv,
-                                              angmom_comps, alphas)
+            second_deriv = _second_derivative(
+                new_coords, gauss, indices_second_deriv, angmom_comps, alphas
+            )
     elif indices_second_deriv.any():
-        second_deriv = _second_derivative(new_coords, gauss, indices_second_deriv,
-                                          angmom_comps, alphas)
+        second_deriv = _second_derivative(
+            new_coords, gauss, indices_second_deriv, angmom_comps, alphas
+        )
         if indices_first_deriv.any():
-            first_deriv = _first_derivative(new_coords, gauss, indices_first_deriv,
-                                            angmom_comps, alphas)
+            first_deriv = _first_derivative(
+                new_coords, gauss, indices_first_deriv, angmom_comps, alphas
+            )
     # Combining all the derivatives
     norm = norm.T[:, :, np.newaxis]
     output = np.tensordot(prim_coeffs, norm * zeroth_deriv * first_deriv * second_deriv, (0, 0))
@@ -279,14 +283,15 @@ def _first_derivative(center_coords, gauss, indices_first_deriv, angmom_comps, a
     # zero (and negative power is undefined).
     power_part_1[power_part_1 < 0] = 0
     part1 = first_coords[:, None, :] ** power_part_1[:, :, None]
-    part2 = (2 * alphas[:, None, None]) * (first_coords ** 2)
+    part2 = (2 * alphas[:, None, None]) * (first_coords**2)
     part2 = first_ang_comp[None, :, :, None] - part2[:, :, None, :]
     # NOTE: Using an array of ones with same shape as first_ang_comp to power part2_zero_ang_mom
     # variable in order to get the same shape as part2. This is done in order to make easier
     # to filter at the end for the angular components corresponding to n=0
     array_ones = np.ones(first_ang_comp.shape)
-    part2_n_0 = -2 * alphas[:, None, None, None] * (
-            first_coords[:, None, :] ** array_ones[:, :, None])
+    part2_n_0 = (
+        -2 * alphas[:, None, None, None] * (first_coords[:, None, :] ** array_ones[:, :, None])
+    )
     raw_first_deriv = part1 * part2
     # Substitute angular components n=0 with correct derivative
     raw_first_deriv[:, n_0_indices, :] = part2_n_0[:, n_0_indices, :]
@@ -342,13 +347,15 @@ def _second_derivative(center_coords, gauss, indices_second_deriv, angmom_comps,
     n_2_indices = second_ang_comp >= 2
 
     # angular momentum == 0
-    total_n_0 = ((4 * alphas[:, None, None] ** 2) * (second_coords ** 2)) - \
-                (2 * alphas[:, None, None])
+    total_n_0 = ((4 * alphas[:, None, None] ** 2) * (second_coords**2)) - (
+        2 * alphas[:, None, None]
+    )
     raw_second_deriv = total_n_0[:, :, None, :] ** array_ones[None, :, :, None]
     # angular momentum == 1
     if any(second_ang_comp[0] == 1):
-        total_n_1 = ((4 * alphas[:, None, None] ** 2) * (second_coords ** 3)) \
-                    - ((6 * alphas[:, None, None]) * second_coords)
+        total_n_1 = ((4 * alphas[:, None, None] ** 2) * (second_coords**3)) - (
+            (6 * alphas[:, None, None]) * second_coords
+        )
         total_n_1 = total_n_1[:, :, None, :] ** array_ones[None, :, :, None]
         # Substitute angular components n=1 with correct derivative
         raw_second_deriv[:, n_1_indices, :] = total_n_1[:, n_1_indices, :]
@@ -363,9 +370,12 @@ def _second_derivative(center_coords, gauss, indices_second_deriv, angmom_comps,
             # Calculating
             # ..math:: 4 \alpha^{2}\left(x-X_{A}\right)^{4}-
             # \alpha(4 n+2)\left(x-X_{A}\right)^{2}+n(n-1)
-            part2_1_n_2 = (4 * alphas[:, None, None] ** 2) * (second_coords ** 4)
-            part2_2_n_2 = alphas[:, None, None, None] * (4 * second_ang_comp[:, :, None] + 2) \
-                                                      * second_coords[:, None, :] ** 2
+            part2_1_n_2 = (4 * alphas[:, None, None] ** 2) * (second_coords**4)
+            part2_2_n_2 = (
+                alphas[:, None, None, None]
+                * (4 * second_ang_comp[:, :, None] + 2)
+                * second_coords[:, None, :] ** 2
+            )
             part2_3_n_2 = second_ang_comp * (second_ang_comp - 1)
             part2_n_2 = part2_1_n_2[:, :, None, :] - part2_2_n_2 + part2_3_n_2[None, :, :, None]
             total_n_2 = part1_n_2[None, :, :, :] * part2_n_2
diff --git a/gbasis/evals/density.py b/gbasis/evals/density.py
index e1ff6778..c0712924 100644
--- a/gbasis/evals/density.py
+++ b/gbasis/evals/density.py
@@ -62,7 +62,7 @@ def evaluate_density_using_evaluated_orbs(one_density_matrix, orb_eval):
     return np.sum(density, axis=0)
 
 
-def evaluate_density(one_density_matrix, basis, points, transform=None):
+def evaluate_density(one_density_matrix, basis, points, transform=None, threshold=1.0e-8):
     r"""Return the density of the given basis set at the given points.
 
     Parameters
@@ -84,6 +84,9 @@ def evaluate_density(one_density_matrix, basis, points, transform=None):
         Transformation is applied to the left, i.e. the sum is over the index 1 of `transform`
         and index 0 of the array for contractions.
         Default is no transformation.
+    threshold : float, optional
+        The absolute value below which negative density values are acceptable. Any negative density
+        value with an absolute value smaller than this threshold will be set to zero.
 
     Returns
     -------
@@ -92,8 +95,12 @@ def evaluate_density(one_density_matrix, basis, points, transform=None):
 
     """
     orb_eval = evaluate_basis(basis, points, transform=transform)
-    # Fix: # 117; to avoid small negative density values, the array is clipped
-    return evaluate_density_using_evaluated_orbs(one_density_matrix, orb_eval).clip(min=0.0)
+    output = evaluate_density_using_evaluated_orbs(one_density_matrix, orb_eval)
+    # Fix #117: check magnitude of small negative density values, then use clip to remove them
+    min_output = np.min(output)
+    if min_output < 0.0 and abs(min_output) > threshold:
+        raise ValueError(f"Found negative density <= {-threshold}, got {min_output}.")
+    return output.clip(min=0.0)
 
 
 def evaluate_deriv_reduced_density_matrix(
@@ -553,6 +560,7 @@ def evaluate_posdef_kinetic_energy_density(
     points,
     transform=None,
     deriv_type="general",
+    threshold=1.0e-8,
 ):
     r"""Return evaluations of positive definite kinetic energy density at the given points.
 
@@ -581,17 +589,19 @@ def evaluate_posdef_kinetic_energy_density(
         are evaluated.
         Rows correspond to the points and columns correspond to the :math:`x, y, \text{and} z`
         components.
-    transform : np.ndarray(K_orbs, K_cont)
+    transform : np.ndarray(K_orbs, K_cont), optional
         Transformation matrix from the basis set in the given coordinate system (e.g. AO) to linear
         combinations of contractions (e.g. MO).
         Transformation is applied to the left, i.e. the sum is over the index 1 of `transform`
         and index 0 of the array for contractions.
-        Default is no transformation.
-    deriv_type : "general" or "direct"
+    deriv_type : "general" or "direct", optional
         Specification of derivative of contraction function in _deriv.py. "general" makes reference
         to general implementation of any order derivative function (_eval_deriv_contractions())
         and "direct" makes reference to specific implementation of first and second order
         derivatives for generalized contraction (_eval_first_second_order_deriv_contractions()).
+    threshold : float, optional
+        The absolute value below which negative density values are acceptable. Any negative density
+        value with an absolute value smaller than this threshold will be set to zero.
 
     Returns
     -------
@@ -611,7 +621,10 @@ def evaluate_posdef_kinetic_energy_density(
             transform=transform,
             deriv_type=deriv_type,
         )
-    # Fix: #117; to avoid small negative values, the array is clipped
+    # Fix #117: check magnitude of small negative density values, then use clip to remove them
+    min_output = np.min(output)
+    if min_output < 0.0 and abs(min_output) > threshold:
+        raise ValueError(f"Found negative density <= {-threshold}, got {min_output}.")
     return (0.5 * output).clip(min=0.0)
 
 
diff --git a/gbasis/evals/stress_tensor.py b/gbasis/evals/stress_tensor.py
index 0e19de98..61c1eada 100644
--- a/gbasis/evals/stress_tensor.py
+++ b/gbasis/evals/stress_tensor.py
@@ -8,9 +8,7 @@
 
 
 # TODO: need to be tested against reference
-def evaluate_stress_tensor(
-    one_density_matrix, basis, points, alpha=1, beta=0, transform=None
-):
+def evaluate_stress_tensor(one_density_matrix, basis, points, alpha=1, beta=0, transform=None):
     r"""Return the stress tensor evaluated at the given coordinates.
 
     Stress tensor is defined here as:
@@ -128,9 +126,7 @@ def evaluate_stress_tensor(
 
 
 # TODO: need to be tested against reference
-def evaluate_ehrenfest_force(
-    one_density_matrix, basis, points, alpha=1, beta=0, transform=None
-):
+def evaluate_ehrenfest_force(one_density_matrix, basis, points, alpha=1, beta=0, transform=None):
     r"""Return the Ehrenfest force.
 
     Ehrenfest force is the negative of the divergence of the stress tensor:
diff --git a/gbasis/integrals/electron_repulsion.py b/gbasis/integrals/electron_repulsion.py
index 20b57461..8daa8e1a 100644
--- a/gbasis/integrals/electron_repulsion.py
+++ b/gbasis/integrals/electron_repulsion.py
@@ -203,9 +203,7 @@ def construct_array_contraction(cls, cont_one, cont_two, cont_three, cont_four):
         return integrals
 
 
-def electron_repulsion_integral(
-    basis, transform=None, notation="physicist"
-):
+def electron_repulsion_integral(basis, transform=None, notation="physicist"):
     """Return the electron repulsion integrals fo the given basis set.
 
     Parameters
diff --git a/gbasis/integrals/nuclear_electron_attraction.py b/gbasis/integrals/nuclear_electron_attraction.py
index 355c2328..a6d139f1 100644
--- a/gbasis/integrals/nuclear_electron_attraction.py
+++ b/gbasis/integrals/nuclear_electron_attraction.py
@@ -3,9 +3,7 @@
 import numpy as np
 
 
-def nuclear_electron_attraction_integral(
-    basis, nuclear_coords, nuclear_charges, transform=None
-):
+def nuclear_electron_attraction_integral(basis, nuclear_coords, nuclear_charges, transform=None):
     """Return the nuclear electron attraction integrals of the basis set in the Cartesian form.
 
     Parameters
@@ -32,8 +30,6 @@ def nuclear_electron_attraction_integral(
 
     """
     return np.sum(
-        point_charge_integral(
-            basis, nuclear_coords, nuclear_charges, transform=transform
-        ),
+        point_charge_integral(basis, nuclear_coords, nuclear_charges, transform=transform),
         axis=2,
     )
diff --git a/gbasis/integrals/point_charge.py b/gbasis/integrals/point_charge.py
index 7a615696..b07dd3ff 100644
--- a/gbasis/integrals/point_charge.py
+++ b/gbasis/integrals/point_charge.py
@@ -266,9 +266,7 @@ def construct_array_contraction(
         return output
 
 
-def point_charge_integral(
-    basis, points_coords, points_charge, transform=None
-):
+def point_charge_integral(basis, points_coords, points_charge, transform=None):
     r"""Return the point-charge interaction integrals of basis set in the given coordinate systems.
 
     Parameters
diff --git a/website/README.md b/website/README.md
index 8c6c8510..4e1d2bf1 100644
--- a/website/README.md
+++ b/website/README.md
@@ -28,4 +28,4 @@ Now, paste and overwrite all of the files in gh-pages with the html. Then commit
 git add ./*
 git commit -m "Update website"
 git push origin gh-pages
-```
\ No newline at end of file
+```
diff --git a/website/_config.yml b/website/_config.yml
index cec4c220..caac2840 100644
--- a/website/_config.yml
+++ b/website/_config.yml
@@ -60,12 +60,10 @@ repository:
 launch_buttons:
   thebe                  : true
   colab_url: "https://colab.research.google.com"
-  
+
 copyright: "2022-2023"
 
 html:
   use_issues_button: true
   use_repository_button: true
   favicon: favicon.png
-
-
diff --git a/website/installation.ipynb b/website/installation.ipynb
index ba707d47..bb1d4e1b 100644
--- a/website/installation.ipynb
+++ b/website/installation.ipynb
@@ -1,171 +1,171 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "id": "f1be9e2f",
-   "metadata": {},
-   "source": [
-    "# Installation\n",
-    "\n",
-    "## Stable releases\n",
-    "\n",
-    "<div class=\"alert alert-block alert-warning\">\n",
-    "<b>Warning:\n",
-    "</b>\n",
-    "    \n",
-    "We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the “Latest git revision” section below.\n",
-    "</div>\n",
-    "\n",
-    "The following dependencies are required to run GBasis properly,\n",
-    "\n",
-    "* Python >= 3.6: http://www.python.org/ \n",
-    "* Numpy >= 1.10: http://www.numpy.org/\n",
-    "* SciPy >= 1.0, <1=.10.1 : http://www.scipy.org/\n",
-    "* PyTest >= 5.3.4: https://docs.pytest.org/\n",
-    "* PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov\n",
-    "\n",
-    "Normally, you don’t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.\n",
-    "\n",
-    "\n",
-    "## Installation with Ana- or Miniconda:\n",
-    "\n",
-    "1. To install GBasis using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then:\n",
-    "\n",
-    "```\n",
-    "# Activate your main conda environment if it is not loaded in your .bashrc.\n",
-    "# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3\n",
-    "source ~/miniconda3/bin/activate\n",
-    "\n",
-    "# Create a horton3 conda environment. (optional, recommended)\n",
-    "conda create -n horton3\n",
-    "source activate horton3\n",
-    "\n",
-    "# Install the stable release.\n",
-    "conda install gbasis -c theochem\n",
-    "\n",
-    "# Unstable releases\n",
-    "# (Only do this if you understand the implications.)\n",
-    "# Install the testing release. (beta)\n",
-    "conda install -c theochem/label/test gbasis\n",
-    "# Install the development release. (alpha)\n",
-    "conda install -c theochem/label/dev gbasis\n",
-    "```\n",
-    "\n",
-    "## Installation with Pip\n",
-    "\n",
-    "1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html):\n",
-    "\n",
-    "```\n",
-    "# Create a virtual environment in ~/horton3\n",
-    "# Feel free to change the path.\n",
-    "python3 -m venv ~/horton3\n",
-    "\n",
-    "# Activate the virtual environemnt.\n",
-    "source ~/horton3/bin/activate\n",
-    "\n",
-    "# Install the stable release in the venv horton3.\n",
-    "pip3 install gbasis\n",
-    "# alternative: python3 -m pip install gbasis\n",
-    "\n",
-    "# For developers, install a pre-release (alpha or beta).\n",
-    "# (Only do this if you understand the implications.)\n",
-    "pip3 install --pre gbasis\n",
-    "# alternative: python3 -m pip install --pre gbasis\n",
-    "```\n",
-    "\n",
-    "\n",
-    "2. You can install into your `{$HOME}` directory without creating a virtual environment\n",
-    "\n",
-    "```\n",
-    "# Install the stable release in your home directory.\n",
-    "pip3 install gbasis --user\n",
-    "# alternative: python3 -m pip install gbasis --user\n",
-    "\n",
-    "# For developers, install a pre-release (alpha or beta).\n",
-    "# (Only do this if you understand the implications.)\n",
-    "pip3 install --pre gbasis --user\n",
-    "# alternative: python3 -m pip install --pre gbasis --user\n",
-    "```\n",
-    "\n",
-    "This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.\n",
-    "    \n",
-    "In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`.\n",
-    "\n",
-    "In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of \n",
-    "Python modules.\n",
-    "\n",
-    "## Latest git revision\n",
-    "\n",
-    "This section shows how one can install the latest revision of GBasis from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, …) and so be prepared to accept them when using the following installation instructions.\n",
-    "\n",
-    "There are two installation methods:\n",
-    "\n",
-    "1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.\n",
-    "```\n",
-    "# clone the repo\n",
-    "git clone https://github.com/theochem/gbasis.git\n",
-    "cd gbasis\n",
-    "\n",
-    "pip install --user -e .[dev]\n",
-    "```\n",
-    "\n",
-    "2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.\n",
-    "```\n",
-    "# A) Clone git repo with https OR ssh:\n",
-    "# The second one only works if you have ssh set up for Github\n",
-    "#  A1) https\n",
-    "git clone https://github.com/theochem/gbasis.git\n",
-    "#  A2) ssh\n",
-    "git clone git@github.com:theochem/gbasis.git\n",
-    "# B) Optionally write the version string\n",
-    "pip install roberto  # or any of the three other ways of running pip, see above.\n",
-    "rob write-version\n",
-    "# C) Actual install, 6 different methods.\n",
-    "#  C1) setup.py, with env\n",
-    "python setup.py install\n",
-    "#  C2) pip, with env, correct PATH\n",
-    "pip install .\n",
-    "#  C3) pip, with env, broken PATH\n",
-    "python -m pip install .\n",
-    "#  C4) setup.py, without env\n",
-    "python setup.py install --user\n",
-    "#  C5) pip, without env, correct PATH\n",
-    "pip install . --user\n",
-    "#  C6) pip, without env, broken PATH\n",
-    "python -m pip install . --user\n",
-    "```\n",
-    "\n",
-    "\n",
-    "## Testing\n",
-    "\n",
-    "The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.\n",
-    "\n",
-    "With tox:\n",
-    "```\n",
-    "tox -e qa\n",
-    "```"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
-   "language": "python",
-   "name": "python3"
+  "cells": [
+    {
+      "cell_type": "markdown",
+      "id": "f1be9e2f",
+      "metadata": {},
+      "source": [
+        "# Installation\n",
+        "\n",
+        "## Stable releases\n",
+        "\n",
+        "<div class=\"alert alert-block alert-warning\">\n",
+        "<b>Warning:\n",
+        "</b>\n",
+        "    \n",
+        "We are preparing a 1.0 release. Until then, these instructions for installing a stable release will not work yet. If you enjoy living on the edge, try the development release as explained in the \u201cLatest git revision\u201d section below.\n",
+        "</div>\n",
+        "\n",
+        "The following dependencies are required to run GBasis properly,\n",
+        "\n",
+        "* Python >= 3.6: http://www.python.org/ \n",
+        "* Numpy >= 1.10: http://www.numpy.org/\n",
+        "* SciPy >= 1.0, <1=.10.1 : http://www.scipy.org/\n",
+        "* PyTest >= 5.3.4: https://docs.pytest.org/\n",
+        "* PyTest-Cov >= 2.8.0: https://pypi.org/project/pytest-cov\n",
+        "\n",
+        "Normally, you don\u2019t need to install these dependencies manually. They will be installed automatically when you follow the instructions below.\n",
+        "\n",
+        "\n",
+        "## Installation with Ana- or Miniconda:\n",
+        "\n",
+        "1. To install GBasis using the conda package management system, install [miniconda](https://conda.io/miniconda.html) or [anaconda](https://www.anaconda.com/download) first, and then:\n",
+        "\n",
+        "```\n",
+        "# Activate your main conda environment if it is not loaded in your .bashrc.\n",
+        "# E.g. run the following if you have miniconda installed in e.g. ~/miniconda3\n",
+        "source ~/miniconda3/bin/activate\n",
+        "\n",
+        "# Create a horton3 conda environment. (optional, recommended)\n",
+        "conda create -n horton3\n",
+        "source activate horton3\n",
+        "\n",
+        "# Install the stable release.\n",
+        "conda install gbasis -c theochem\n",
+        "\n",
+        "# Unstable releases\n",
+        "# (Only do this if you understand the implications.)\n",
+        "# Install the testing release. (beta)\n",
+        "conda install -c theochem/label/test gbasis\n",
+        "# Install the development release. (alpha)\n",
+        "conda install -c theochem/label/dev gbasis\n",
+        "```\n",
+        "\n",
+        "## Installation with Pip\n",
+        "\n",
+        "1. You can work in a [virtual environment](https://docs.python.org/3/tutorial/venv.html):\n",
+        "\n",
+        "```\n",
+        "# Create a virtual environment in ~/horton3\n",
+        "# Feel free to change the path.\n",
+        "python3 -m venv ~/horton3\n",
+        "\n",
+        "# Activate the virtual environemnt.\n",
+        "source ~/horton3/bin/activate\n",
+        "\n",
+        "# Install the stable release in the venv horton3.\n",
+        "pip3 install gbasis\n",
+        "# alternative: python3 -m pip install gbasis\n",
+        "\n",
+        "# For developers, install a pre-release (alpha or beta).\n",
+        "# (Only do this if you understand the implications.)\n",
+        "pip3 install --pre gbasis\n",
+        "# alternative: python3 -m pip install --pre gbasis\n",
+        "```\n",
+        "\n",
+        "\n",
+        "2. You can install into your `{$HOME}` directory without creating a virtual environment\n",
+        "\n",
+        "```\n",
+        "# Install the stable release in your home directory.\n",
+        "pip3 install gbasis --user\n",
+        "# alternative: python3 -m pip install gbasis --user\n",
+        "\n",
+        "# For developers, install a pre-release (alpha or beta).\n",
+        "# (Only do this if you understand the implications.)\n",
+        "pip3 install --pre gbasis --user\n",
+        "# alternative: python3 -m pip install --pre gbasis --user\n",
+        "```\n",
+        "\n",
+        "This is by far the simplest method, ideal to get started, but you have only one home directory. If the installation breaks due to some experimentation, it is harder to make a clean start in comparison to the other options.\n",
+        "    \n",
+        "In case the `pip3` executable is not found, pip may be installed in a directory which is not included in your `${PATH}` variable. This seems to be a common issue on macOS. A simple workaround is to replace `pip3` by `python3 -m pip`.\n",
+        "\n",
+        "In case Python and your operating system are up to date, you may also use `pip` instead of `pip3` or `python` instead of `python3`. The `3` is only used to avoid potential confusion with Python 2. Note that the `3` is only present in names of executables, not names of \n",
+        "Python modules.\n",
+        "\n",
+        "## Latest git revision\n",
+        "\n",
+        "This section shows how one can install the latest revision of GBasis from the git repository. This kind of installation comes with some risks (sudden API changes, bugs, \u2026) and so be prepared to accept them when using the following installation instructions.\n",
+        "\n",
+        "There are two installation methods:\n",
+        "\n",
+        "1. **Quick and dirty.** Of this method, there are four variants, depending on the correctness of your `PATH` variable and the presence of a virtual or conda environment. These different scenarios are explained in more detail in the previous section.\n",
+        "```\n",
+        "# clone the repo\n",
+        "git clone https://github.com/theochem/gbasis.git\n",
+        "cd gbasis\n",
+        "\n",
+        "pip install --user -e .[dev]\n",
+        "```\n",
+        "\n",
+        "2. **Slow and Smart.** In addition to the four variations in the quick and dirty method, the slow and smart can be used with `pip` or just with `setup.py`. You also have the options to use SSH or HTTPS protocols to clone the git repository. Pick whichever works best for you.\n",
+        "```\n",
+        "# A) Clone git repo with https OR ssh:\n",
+        "# The second one only works if you have ssh set up for Github\n",
+        "#  A1) https\n",
+        "git clone https://github.com/theochem/gbasis.git\n",
+        "#  A2) ssh\n",
+        "git clone git@github.com:theochem/gbasis.git\n",
+        "# B) Optionally write the version string\n",
+        "pip install roberto  # or any of the three other ways of running pip, see above.\n",
+        "rob write-version\n",
+        "# C) Actual install, 6 different methods.\n",
+        "#  C1) setup.py, with env\n",
+        "python setup.py install\n",
+        "#  C2) pip, with env, correct PATH\n",
+        "pip install .\n",
+        "#  C3) pip, with env, broken PATH\n",
+        "python -m pip install .\n",
+        "#  C4) setup.py, without env\n",
+        "python setup.py install --user\n",
+        "#  C5) pip, without env, correct PATH\n",
+        "pip install . --user\n",
+        "#  C6) pip, without env, broken PATH\n",
+        "python -m pip install . --user\n",
+        "```\n",
+        "\n",
+        "\n",
+        "## Testing\n",
+        "\n",
+        "The tests are automatically run when we build packages with conda, but you may try them again on your own machine after installation.\n",
+        "\n",
+        "With tox:\n",
+        "```\n",
+        "tox -e qa\n",
+        "```"
+      ]
+    }
+  ],
+  "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.8.0"
+    }
   },
-  "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.8.0"
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 5
+  "nbformat": 4,
+  "nbformat_minor": 5
 }
diff --git a/website/intro.md b/website/intro.md
index f9c03336..6a137a11 100644
--- a/website/intro.md
+++ b/website/intro.md
@@ -4,7 +4,7 @@
 [Gbasis](https://github.com/theochem/gbasis/) is a free, open-source, and cross-platform Python library designed to help you effortlessly work with Gaussian-type orbitals. Please use the following citation in any publication using Gbasis library:
 
 **"GBasis: A Python Library for Evaluating Functions, Functionals, and
-Integrals Expressed with Gaussian Basis Functions"**, 
+Integrals Expressed with Gaussian Basis Functions"**,
 Taewon David Kim, Leila Pujal, Maximilian van Zyl, Alireza Tehrani, Michelle Richer, Gabriela
 Sánchez-Díaz, Xiaotian Derrick Yang, Valerii Chuiko, Raymundo Hernández-Esparza, William Adams,
 Xiaomin Huang, Braden D. Kelly, Matthew Chan, Esteban Vöhringer-Martinez, Toon Verstraelen, Farnaz
diff --git a/website/requirements.txt b/website/requirements.txt
index 6daa1219..bd420b69 100644
--- a/website/requirements.txt
+++ b/website/requirements.txt
@@ -2,4 +2,4 @@ jupyter-book
 sphinx
 matplotlib
 numpy>= 1.10
-scipy>=1.0, <=1.10.1
\ No newline at end of file
+scipy>=1.0, <=1.10.1
diff --git a/website/tutorial.ipynb b/website/tutorial.ipynb
index 33fddbfe..8a9333d5 100644
--- a/website/tutorial.ipynb
+++ b/website/tutorial.ipynb
@@ -1,140 +1,140 @@
 {
- "cells": [
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": [
-    "# Getting started\n",
-    "\n",
-    "In this tutorial we are going to show some cases of using the GBasis library"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "# install GBasis module\n",
-    "!pip install git+https://github.com/theochem/gbasis"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 1,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import gbasis\n",
-    "import pyscf\n",
-    "import numpy as np\n",
-    "import matplotlib.pyplot as plt"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from gbasis.wrappers import from_pyscf\n",
-    "from gbasis.evals import density"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
-   "metadata": {},
-   "outputs": [
+  "cells": [
     {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "converged SCF energy = -74.9629916147472\n"
-     ]
-    }
-   ],
-   "source": [
-    "\n",
-    "# define molecule\n",
-    "mol = pyscf.gto.Mole()\n",
-    "mol.atom = '''\n",
-    "O 0.000000000000  0.000000000000  0.000000000000\n",
-    "H 0.000000000000 -0.757160000000  0.586260000000\n",
-    "H 0.000000000000  0.757160000000  0.586260000000'''\n",
-    "mol.basis = 'STO-3G'\n",
-    "\n",
-    "# define calculation\n",
-    "mol.build()\n",
-    "mf = pyscf.scf.RHF(mol)\n",
-    "mf.kernel()\n",
-    "rdm1 = mf.make_rdm1()\n",
-    "\n",
-    "# get basis set\n",
-    "basis = from_pyscf(mol)"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 6,
-   "metadata": {},
-   "outputs": [
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "# Getting started\n",
+        "\n",
+        "In this tutorial we are going to show some cases of using the GBasis library"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "# install GBasis module\n",
+        "!pip install git+https://github.com/theochem/gbasis"
+      ]
+    },
     {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 720x720 with 1 Axes>"
+      "cell_type": "code",
+      "execution_count": 1,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "import gbasis\n",
+        "import pyscf\n",
+        "import numpy as np\n",
+        "import matplotlib.pyplot as plt"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 2,
+      "metadata": {},
+      "outputs": [],
+      "source": [
+        "from gbasis.wrappers import from_pyscf\n",
+        "from gbasis.evals import density"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 5,
+      "metadata": {},
+      "outputs": [
+        {
+          "name": "stdout",
+          "output_type": "stream",
+          "text": [
+            "converged SCF energy = -74.9629916147472\n"
+          ]
+        }
+      ],
+      "source": [
+        "\n",
+        "# define molecule\n",
+        "mol = pyscf.gto.Mole()\n",
+        "mol.atom = '''\n",
+        "O 0.000000000000  0.000000000000  0.000000000000\n",
+        "H 0.000000000000 -0.757160000000  0.586260000000\n",
+        "H 0.000000000000  0.757160000000  0.586260000000'''\n",
+        "mol.basis = 'STO-3G'\n",
+        "\n",
+        "# define calculation\n",
+        "mol.build()\n",
+        "mf = pyscf.scf.RHF(mol)\n",
+        "mf.kernel()\n",
+        "rdm1 = mf.make_rdm1()\n",
+        "\n",
+        "# get basis set\n",
+        "basis = from_pyscf(mol)"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": 6,
+      "metadata": {},
+      "outputs": [
+        {
+          "data": {
+            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAm0AAAJDCAYAAABZrSP4AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOzddXRUV9vG4d/E3YWQkOAW3N3d3aV4cSnFHUpxKy1QKIVCcXd3dwgESQIJSYi7y8z5/iAvXym0RQKTwHOtNYsmM3PmjjS5s88+e6sURUEIIYQQQmRtOtoOIIQQQggh/puUNiGEEEKIbEBKmxBCCCFENiClTQghhBAiG5DSJoQQQgiRDUhpE0IIIYTIBjKltKlUqrUqlSpUpVLd/4f7VSqVaplKpfJWqVT3VCpVmb/c11OlUnll3HpmRh4hhBBCiC9NZo20rQMa/cv9jYECGbf+wAoAlUplA0wFKgIVgKkqlco6kzIJIYQQQnwxMqW0KYpyDoj8l4e0BP5QXroCWKlUKiegIXBcUZRIRVGigOP8e/kTQgghhPgqfa45bc6A/1/eDsh43z+9XwghhBBC/IWetgO8K5VK1Z+Xp1YxNTUtW7hwYS0nEkIIIYT4bzdv3gxXFMX+Y4/zuUpbIJDrL2+7ZLwvEKj1t/efedsBFEX5FfgVoFy5csqNGzc+RU4hhBBCiEylUqn8MuM4n+v06D6gR8ZVpJWAGEVRgoCjQAOVSmWdcQFCg4z3CSGEEEKIv8iUkTaVSrWZlyNmdiqVKoCXV4TqAyiKshI4BDQBvIFEoFfGfZEqlWomcD3jUDMURfm3CxqEEEIIIb5KmVLaFEXp/B/3K8Dgf7hvLbA2M3IIIYQQQnypZEcEIYQQQohsQEqbEEIIIUQ2IKVNCCGEECIbkNImhBBCCJENSGkTQgghhMgGpLQJIYQQQmQDUtqEEEIIIbIBKW1CCCGEENmAlDYhhBBCiGxASpsQQgghRDYgpU0IIYQQIhuQ0iaEEEIIkQ1IaRNCCCGEyAaktAkhhBBCZANS2oQQQgghsgEpbUIIIYQQ2YCUNiGEEEKIbEBKmxBCCCFENiClTQghhBAiG5DSJoQQQgiRDUhpE0IIIYTIBqS0CSGEEEJkA1LahBBCCCGyAT1tBxBCiA+VnpZOTHg8MeGxRIfFEh368t+EmEQSY5NIiP3fv0kkxSeTlpJGanIaaSnpL/9NTUOj1rz12HoGeugb6KNvqIeBkT76hvoYGOljamGMiYUJJhbGGf9tjIWNGVb2FljaWWDlYIGVvQVmViaoVKrP/BkRQnzJpLQJIbKsuKgEXviEEPQ0hFD/CMICIgkLiCAs8OW/MWFx//hcYzOjV6XK1MIEY3MjLO3M0TfQw8DIAH1DPfQN9dDV1X3juYqikJ6u/v9yl5JGWmo6KYkpRIXGEuAVTGJcEgkxSaSlpL319fX0dbF1ssbOxQZ7F1vsM/51dLUlZz5HcuRxwMBQP9M+V0KIL5+UNiGEVqWnpRPoHYKfZwDPHwUS4BXMC58QXjwNJS4y/rXHmlgYvyo/BUrnxtbJ+uXIVsYIl6W9BVZ25phamaKr+3lmf6SmpBEXmUB0WAzRYbHEZIz2RYbEEPEiirCACB5d8+bC7kjS09SvnqdSqXDIZYtTPkdy5nMkV4EcuBV1wa2IM7Y5rWWUTgjxBiltQojPJjo0Bq87fnjf8eXpvef4PQwg0Cv4VZlRqVQ4ZIxE1WhbgZx5XxaanHkdsM9lh6mFsZY/gjcZGOpj62SFrZPVvz5Oo9EQHRpLiF84QU9DCPQJeVlOfUI4v+vaawXVzMoE18LO5HZ3IV9JN/KXyk2eYrkwNDb4xB+NECIrUymKou0M761cuXLKjRs3tB1DCPEvYiPjeXzdh0fXffC+44v3bV/CX0S9uj9Hbntyu7vgWtgZt6LOuBVxIVchJ4xMDLWYWnuiQ2PwfRiIn2cgfg8DeP4wkGcPAoiPSgBAR1cH18I5yV8qNwXL5KFwhfzkLeGKvoH87S1EVqdSqW4qilLuo48jpU0I8bE0Gg1+noF4XvHi4VUvHl7zIeBJEAA6OipcCjpRoHQe8pdyI3/p3OQr4YappYmWU2d9iqIQ+jziZen9yy0yOAYAAyN9CpTOQ+EK+ShSsQDulQtgk8NKu6GFEG+Q0ialTQitUas1PL33HI/zD7l3/hH3Lz15dXrP0t6cIhULUKRCPgpXyE+hsnkxNjPScuIvS1hA5Kty/PCqF963fUlLTQfApaATxasVokS1whSvXgR7FxstpxVCSGmT0ibEZ6MoCoHewdw6eZ+bJ+9z79xDEmOTAHDK60DxaoUpUb0w7lUK4pTHQSbRf2apKWk8veuHx4XH3LvwiAeXnpAQkwiAUx4HStdxp0zd4pSqVRRza1MtpxXi6yOlTUqbEJ9UfHQCN0/c59ZJD26dvE+ofwTwci5a6TrulKhehOLVCstIThakVmt45vGce+cfcffcQ+6d9SQxLhkdHRUFy+alTN1ilK1XnCIV86Or9+aSJ0KIzCWlTUqbEJlKURQCvIK5eug2Vw/f4f7Fx2jUGkwtTShVsyil67pTtl5xcuZ11HZU8Z7S09J5dM2HW6fuc+vEfR7f8EGjUTC3MaN8gxJUbFyKsvVLyCicEJ+IlDYpbUJ8NLVag+flJ1zce4Mrh24T9DQUgDzFclGhUUkqNColozFfoP+Nol47cofrR+8SEx6Hjq4ORSsVoHKzMlRtWQ6nPA7ajinEF0NKm5Q2IT5Iakoad04/4OK+m1w+cJOYsDj0DfUpXbsoFRqVokKjUji62Wk7pvhM1GoNj6/7cO3IHa4evsPTe88ByFvClaotylK1ZXlyu7vIPEUhPoKUNiltQryztNR0bp7w4NyOq1w+cJPEuGRMzI2o0KgUVVuWo1yDEpiYZ72Fa8XnF+wbysW9N7m49waeV7xQFCVjseOK1GpfSQqcEB9ASpuUNiH+lTpdzZ0znpzdcYWLe28QH52ImbUpVVuUpVqr8pSq7S57X4p/FRkczeUDtzi/+xp3z3ii0Si4Fs5JzfaVqNmuErkKOmk7ohDZgpQ2KW1CvEFRFLxv+3Ji00VOb7tETFgcJuZGVG5elprtKlGmbjFZQV98kKiQGC7suc6Z7Vd4cOkJiqKQv3Ru6nauSu0OlbF2tNR2RCGyLCltUtqEeCXUP4LTWy5xYvNFnj8MRN9Aj4pNSlOnUxXKNSghe1aKTBUeGMm5nVc5ueUS3rd90dHVoVz94tTtXJXKzcvK95sQfyOlTUqb+MqlJKVyce8Njq4/y92zD1EUhaKVClCvazVqtK0oyzeIz8LXM4CTmy5yasslwgMjMTE3omb7SjTqWZNC5fPJ/DchkNImpU18tbxu+3J0/RlOb71MfHQijm52NOhenbpdqskyDUJr1GoNHucfcuLPC5zbdY2UxFTcijrTsEdN6napipW9hbYjCqE1UtqktImvSGJcEqe2XOLQb6fxueuHvqE+1VqVo9E3NSlRowg6OjrajijEKwmxSZzdcYWj687y6LoPevq6VG5Whqb96lKqVlEZfRNfHSltUtrEV+Cpx3MOrD7Jqc2XSIpPJm8JVxr3qkXtjlXk9KfIFnw9Azi67izH/7xAXGQ8LgVy0KRPHep3r46FjZm24wnxWUhpk9ImvlCpKWlc2HWN/b+exPOKFwZG+tRsV5Fm/erKHCGRbaUmp3Ju1zUOrj712vd18wH1KVQur7bjCfFJSWmT0ia+MBFB0Rxcc5JDv50mKiQG5/w5aNpXRiTEl8fnnh8H15x6NYJcpEJ+WgysT/U2FWRJGvFFktImpU18ARRF4dE1H/b8cozzu66hTldToVFJWg5qQJm6xWSumviiJcQmcXzDOfatPEGgdzA2OSxp2rcOTfrUwSaHlbbjCZFppLRJaRPZmFqt4dLeG+xYcohH130wsTCmQfcatPi2Hs75c2g7nhCflUaj4eaJ++z95SjXj95DT1+X2p2q0G54Y3K759J2PCE+mpQ2KW0iG0qKT+bYH+fY9dMRgn3DcMrrQOshjajfrZrs/SkEEOAVxJ6fj3FswzlSElMpW7847UY0oXRtd5nPKbItKW1S2kQ2EhUSw55fjnFg9UnioxIoWqkAbYc3pnLzsujqyilQIf4uNiKOA2tOsW/FcaJCYshbwpV2I5pQq30ldPV0tR1PiPcipU1Km8gGgv3C2LH4EEfXnyUtJZ2qLcvRdnhjilYqoO1oQmQLqSlpnN5yiR1LD/P8YSCObna0H9mUBj1qyHZZItuQ0ialTWRhvg/82bbwIKe3XUZHR0XdLlXp8F0zXAo4aTuaENmSRqPh2uE7bJm3n4fXvLFysKD1kIY0718PU0sTbccT4l9JaZPSJrIgr1vP2PjjHq4cuIWRqSFN+tShzdBG2LvYaDuaEF8ERVHwuPCILfP3c/O4ByYWxrT4tj5thzXCwtZc2/GEeCspbVLaRBby+MZTNs7ezbXDdzCzNqX14Aa0+La+/BIR4hPyuu3L1vn7uLDnBkamhrT4th5thzfB0k7+vxNZi5Q2KW0iC3h0zZuNs3dz/eg9zG3MaDOsES0HNsDUQq4EFeJz8fUMYNOPezi38xqGJgY0H1CPdiOayCb1IsuQ0ialTWiR9x1f1k/fwbUjd7GwNaPd8CY0/7aeLNshhBb5PQxk89y9nN1+BX0jfVoNakC7kU1lRxGhdVLapLQJLfB94M8fM3dxce8NzG3MaD+yKS2+rYexmZG2owkhMvg/CWLjD7s5u/0KxuZGtB3emNZDGskIuNAaKW1S2sRnFOgdzIZZuziz7QrGZoa0HtqItsMay1VrQmRhz+7788eMnVzafxNzGzM6jHr5R5aRqfyRJT4vKW1S2sRnEBEUzcbZuzny+xn0DfVoObAB7Uc2kQsMhMhGntx8yh8zd3L96D1scljSbWIbGvasgZ6+bE4vPg8pbVLaxCeUEJvEjsUH2bnsMOmpapr2rUOXcS2xdrTUdjQhxAd6cOkJv03ayoPLT3ApkINeMzpQtWU52R5LfHJZqrSpVKpGwFJAF1ijKMqcv92/GKid8aYJ4KAoilXGfWrAI+O+54qitPiv15PSJj6V1JQ0Dq05xaY5e4kJj6Nmu4p8M709OfM6ajuaECITKIrClYO3WTt5K88fvaBw+Xz0nd2J4tUKazua+IJlmdKmUql0gSdAfSAAuA50VhTF8x8ePxQorShK74y34xVFea9Le6S0icymKAoX9tzgt0lbCHoaSqlaRekzqyMFy+bVdjQhxCegTldz4s8L/DFjJ+EvoqjcrAz9fuyMc/4c2o4mvkBZqbRVBqYpitIw4+3xAIqi/PgPj78ETFUU5XjG21LahFY9vvGUVWP/5MGlJ7gWcab/nC6Uq19cTpkI8RVITkxh9/KjbJ2/n9TkNJoPqEfXCa1kmRCRqTKrtOlkQhZnwP8vbwdkvO8NKpXKDcgDnPrLu41UKtUNlUp1RaVStcqEPEK8k1D/COb1Xsmw6lMJ8Api2E+9WHntB8o3KCGFTYivhJGJIZ3HtGCtx3wa9qzBvhXH6FVsNLt+OkJaarq24wnxms996UwnYIeiKOq/vM9NUZRAlUqVFzilUqk8FEXx+fsTVSpVf6A/gKur6+dJK75IKUmpbFt4gG0LD6Ao0PH75nQc3VzWcBLiK2aTw4rhy3vT4tv6/DpuE6vG/MmBX08yYF5XKjYupe14QgCf+fSoSqW6DQxWFOXSPxxrHXBAUZQd//aacnpUfIj/zVtbPW4TIc/DqdG2In1/6ISjm522owkhshBFUbhx7B4rx/xJwJMgKjQuxbfzusp8N/HBstKcNj1eXohQFwjk5YUIXRRFefC3xxUGjgB5lIwXValU1kCioigpKpXKDrgMtPynixj+R0qbeF9+DwP55bsN3Dn9gDzFcjFoUXdKVC+i7VhCiCwsLTWdPT8f5c/Ze0hPTafNsEZ0HttSdkAR7y3LlLaMME2AJbxc8mOtoig/qFSqGcANRVH2ZTxmGmCkKMq4vzyvCrAK0PByft0SRVF++6/Xk9Im3lVCbBIbZ+1izy/HMDE3oseUdjTrVwddPV1tRxNCZBMRQdGsnbyVE39ewNbJmv5zOlOzfSWZ+yreWZYqbZ+blDbxXxRF4eyOq6wa8ydRITE07l2LnlPbYWVvoe1oQohsyvOKF798twGvW88oXcedIUt64lLASduxRDYgpU1Km/gHgd7B/DzyD26e8CB/6dwMXfoNhcvn03YsIcQXQK3WcGjNKX6fup3UpFTaf9eMTt83x9DYQNvRRBYmpU1Km/ib1ORUti44wNYFB9A30OWbae1pNqAeurqZsbKNEEL8v8jgaFaP38ypLZdwyuvA4MU9Kd+ghLZjiSxKSpuUNvEX984/ZOngtQR4BVOrfSX6z+2KrZOVtmMJIb5wt08/YPnwda9+9gxc0A0rB9mjWLxOSpuUNgEkxCSyZtJWDq05RY7c9gz7qRdl6xXXdiwhxFckNSWNbQv2s3nuPozNjRkwryv1ulSVCxXEK1LapLR99S7uvcHyEeuJDo2h1ZBG9JzSBiNTuRRfCKEdfg8DWTLoNzyveFGmbjGG/dQLpzwO2o4lsgApbVLavlqRwdEsH7Gei3tvkK+kGyN+7i0buwshsgSNRsPB1adYO3kr6nQNPaa0pfXQRjK39isnpU1K21dHURROb73ML99tICUxhW4T29B2eCP09D/3bmxCCPHvwgIiWT5yPVcO3KJIxfyMXt1flgf5iklpk9L2VYkKieGnYeu4uO8GRSrk57vV/clVUH4ACiGyrv/9ofnzqD9ITUql1/T2tBzcUEbdvkJS2qS0fRX+t0juzyPXkxSfQs+pbWkzrLH80BNCZBsRQdEsG7qWKwdv4165IN/92k/2Mf3KSGmT0vbFiwmP46dhv3N+93UKlcvL6NX9cS3srO1YQgjx3hRF4cSmi6wcvYG0lHR6z+xAi4H10dGRP0C/BlLapLR90a4fu8eiAb8SGxFP98ltaD+yqewXKoTI9sIDI1k6ZC3XjtylTN1ifLeqH3bONtqOJT6xzCptUvFFlpKcmMLyEeuZ1HI+5jZmLDs/nU7ft5DCJoT4Itg52zBj13cM+6kXDy4/YUD5CZzbeVXbsUQ2IaVNZBlet54xpMoU9q86QZuhjVh+cQb5SrppO5YQQmQqlUpF0751+OXKLHLmdeSHbsuZ12clCTGJ2o4msjgpbULrNBoNW+fvZ3jN6STFJTHn0DgGzOuKgZFswCyE+HK5FHBi8enJdJ3QitNbLzOwwkQeXHqi7VgiC5PSJrQqIiiaCc3nsXbKNqq2LMfKGz9Sura7tmMJIcRnoaevR4/JbVl0cjI6ujqMbvADm+buRa3WaDuayIKktAmtuX7sHgMrTsDzshcjfunDhA2DMbc21XYsIYT47IpUzM/PV2ZRo21F1k/bwfimc4h4EaXtWCKLkdImPru01HR+HbeJSS3nY+1gyU8XZ9C4Vy3ZXFkI8VUztTBm3LqBjFrVj0fXfRhYcSJXD9/RdiyRhUhpE59VsG8oo2rPYOfSwzTrX5dl56fjVkTWXhNCCHh5kULDHjVYfmkmNk5WTGmzkFVjN5Gelq7taCILkNImPpsrB28xuPJkAn1CmLx5GEOXfoOhsVxsIIQQf+daKCfLzk2j+YB67Fp2mO8bzCYsIFLbsYSWSWkTn5w6Xc1vk7Yytd1icuRx4OfLM6nWqry2YwkhRJZmYGTAkCU9Gf/HYJ7d92dw5UncPOmh7VhCi6S0iU8qMjiacU3msG3hAZr0qc3iU5NxyuOg7VhCCJFt1GpfiWUXpmPlYMHE5vPZOHs3Go1cXfo1ktImPhmPC48ZXHkSj288ZfSaAQxf3lvWXhNCiA/wv9OldTpVYcPMXUxqtYDYiDhtxxKfmZQ2kekURWHviuOMbfwjxmbGLD03jfpdq2k7lhBCZGtGpkZ8/9sAhi77hntnHzKk6hR87vlpO5b4jKS0iUyVmpzK4oFr+GXUH5RvWIKfLkwnT7Fc2o4lhBBfBJVKRbN+dVlwfCLpqWpG1p7B2R2yd+nXQkqbyDThgZF832A2R9efo8v4VkzdNgJTSxNtxxJCiC9O4Qr5WX5pBvlKuDG7+3LWTt4quyh8BaS0iUzx4PIThlabgq9nAJM3D6PnlLbo6Mi3lxBCfCo2OayYd3QCTfrUZuuCA0xtu5D46ARtxxKfkPxWFR/t6B/nGNNwNoYmhiw9O1WW8xBCiM9E30CP4ct7M+ynXtw6+YBh1acR4BWk7VjiE5HSJj6YRqNhzcQtLBqwmuLVC7Ps/HRyu8v8NSGE+Nya9q3D3MPjiY9JYHjN6dw566ntSOITkNImPkhyQjKzOv/E9kUHadqvDrP2jMbCxkzbsYQQ4qtVvFohlp2bhk0OKyY0m8eRdWe0HUlkMilt4r1FvIhidIPZXD5wk2/nd2Po0m/Q09fTdiwhhPjq5cjtwJLTUyhVqyiLB/7GmgmbZSHeL4iUNvFevO/4Mqz6VAKeBDFtxyhaD2mISqXSdiwhhBAZTC1NmLn7O5oPqMv2xYeY2WkZyQnJ2o4lMoGUNvHOrh25w3f1ZqHS0WHRqclUbFxK25GEEEK8ha6eLoMX92TQwu5cOXiL0Q1mExUSo+1Y4iNJaRPv5Oj6s0xttxiXAjlYem4aeYu7ajuSEEKIf6FSqWg5qAHTdozi+aNARtSaTqB3sLZjiY8gpU38K0VR+PPHPSz6dg2la7sz/9hEbJ2stB1LCCHEO6rYuBTzjkwgKT6ZkbVn8Oi6j7YjiQ8kpU38I3W6mmXD1vHHjJ3U7VKV6TtHYWJurO1YQggh3lPh8vlYfHoKJubGjGk0m6uH72g7kvgAUtrEWyUnpjCj8zIOrTlFx++b8/2aAegbyBWiQgiRXTnnz8Hi01NwLezMtPaLOfz7GW1HEu9JSpt4Q1xUAuObzuXqwdsMWtSD3jM6yBWiQgjxBbB2tGT+0QmUruPOkkG/sWnOHhRF0XYs8Y6ktInXRIXEMKbRbJ7cfMrEjUNoObC+tiMJIYTIRMZmRszYOYq6nauyfvpO1kzYIsUtm5DzXeKV0OfhjG82l7CASGbs+o6y9YprO5IQQohPQE9fj9Fr+mNiYcSOJYdIjEtiyNJv0NWVsZysTEqbACDQO5hxTeYQH5PIjwfG4l6loLYjCSGE+IR0dHQYvLgnJhYmbJ2/n8TYJL7/bYDscJOFyVdG8NTjOROaz0Oj1jD/6ATyl8qt7UhCCCE+A5VKRe8ZHTC1MGHt5K0kJSQzceNQDI0NtB1NvIWMg37lHl334fsGP6Crq8OC4xOlsAkhxFeo4+hmDFnak2uH7zK59QKS4mXbq6xISttX7OFVb8Y3m4u5tRkLT03GtbCztiMJIYTQkub96zHmtwF4nH/EpFZS3LIiKW1fqYdXvZnQfC6WdubMPzaRHG722o4khBBCy+p0rsrYdYPwvOIlxS0LktL2FfK84sWE5nOxcrBk/tGJ2LvYaDuSEEKILKJW+0qMyyhuE1vOJzEuSduRRAYpbV+ZB5efMLHFvIzCNkEKmxBCiDfUbFeR8esH8fCqN5NaLpDilkVIafuKPLj8hEkt52PtaMX8oxOwc5bCJoQQ4u1qtM0obtekuGUVUtq+Eo+u+7wqbPOOjJfCJoQQ4j/VaFuRCX8MflXckhNkjps2SWn7Cjy778/ElvOxtLOQwiaEEOK9VG9TIeNUqRfTOy4lNSVN25G+WlLavnCB3sGMbzYXI2MD5hwaK4VNCCHEe6vRtiIjVvTl1sn7/Nj9Z9Tpam1H+ipJafuChT4PZ1yTOWjUGn48NI4cuR20HUkIIUQ21bBHDQYu6Mal/TdZ2H81Go1G25G+OrKN1RcqKiSGcU3nkhCbxLwj43EtlFPbkYQQQmRzrQY3JDE+mfXTdmBsbsSQJT1RqVTajvXVkNL2BYqNjGd8s7mEv4jkxwNjZWsqIYQQmabzmBYkxiaxfdFBTMyN6TOro7YjfTWktH1hkhNTmNJmIQFPgpix+zvcKxfUdiQhhBBfEJVKRZ9ZHUmKT2bbwgNY2JrRfmRTbcf6Kkhp+4Ko09X82PMXHl3zYeKfQylTp5i2IwkhhPgCqVQqBi/uQWxEPGsmbME2hxV1OlfVdqwvnpS2L4SiKCwf+QdXDtxi0KIeVG9dXtuRhBBCfMF0dHT4fk1/okNjWDhgNVaOljJY8InJ1aNfiM1z93JozSk6jm5Gy4H1tR1HCCHEV8DAyICp20bgUtCJmZ2W4nPXT9uRvmhS2r4AR9efZf30ndTtUpVeMzpoO44QQoiviJmVKbP2fI+JhQmTWs0n2DdU25G+WFLasrnrR++yZPBaytYrzqiVfeXSayGEEJ+dvYsNP+z7ntTkNCa2mE9sRJy2I32RMqW0qVSqRiqV6rFKpfJWqVTj3nL/NyqVKkylUt3JuPX9y309VSqVV8atZ2bk+Vr43PPjh27LyVs8F5M2DUVPX6YoCiGE0I7cRV2Ytn0UIX7hzOgk2119Ch9d2lQqlS7wM9AYKAp0VqlURd/y0K2KopTKuK3JeK4NMBWoCFQApqpUKuuPzfQ1iAyOZmrbxZhamjBj53eYmBtrO5IQQoivXPFqhRi9uj8eFx6zbOjvKIqi7UhflMwYaasAeCuK8lRRlFRgC9DyHZ/bEDiuKEqkoihRwHGgUSZk+qKlJKUyrf1iYiPjmL5jJLY5pecKIYTIGmp1qEy3ia05vuE82xcd1HacL0pmlDZnwP8vbwdkvO/v2qpUqnsqlWqHSqXK9Z7PFRkURWHRgNU8ufmMcb8PlN0OhBBCZDndJramZruKrJ28jUv7b2o7zhfjc12IsB/IrShKCV6Opq1/3wOoVKr+KpXqhkqluhEWFpbpAbOLP3/cw5ntV+g1owNVWpTTdhwhhBDiDSqViu9+7U+BMnmY22uFLAWSSTKjtAUCuf7ytkvG+15RFCVCUZSUjDfXAGXf9bl/OcaviqKUUxSlnL29fSbEzn7O777Ohpm7qNe1Gh2+ky1DhBBCZF2GxgZM2z4SMytTprZbTHRojLYjZXuZUdquAwVUKlUelUplAHQC9v31ASqVyukvb7YAHmb891GggUqlss64AKFBxvvE3zz1eM78vispUiE/w3/uLUt7CCGEyPJsnayYtn0kMeGxzOzyE2mp6dqOlK19dGlTFCUdGMLLsvUQ2KYoygOVSjVDpVK1yHjYMJVK9UClUt0FhgHfZDw3EpjJy+J3HZiR8T7xF7ERcUxrvxhzK1MmbxmOgaG+tiMJIYQQ76RA6dyMWtmP+xcfs2L0Bm3HydYyZWEvRVEOAYf+9r4pf/nv8cD4f3juWmBtZuT4EqnVGuZ8s4LIoGgWnJiErZOVtiMJIYQQ76V2x8r43PNj+6KDFCqXj4Y9amg7UrYkOyJkcRtm7uTmCQ8GL+lJ4fL5tB1HCCGE+CC9prenVG13fhq2Dq9bz7QdJ1uS0paFXT5wi81z99GoVy0a96ql5TRCCCHEh9PV02X8+kFY2Vswo9NS2erqA0hpy6KCnoUyv+8qCpbJw+BF3bUdRwghhPhoVvYWTNkyjKiQGOb1WYlGo9F2pGxFSlsWlJqcyqyuP6FSwcQ/h2BgZKDtSEIIIUSmKFg2LwPmdeX60XtsW3hA23GyFSltWdCqsZvwvu3L6NUDyJHbQdtxhBBCiEzVrH9darWvxPppO7h77uF/P0EAUtqynDPbLnPg15O0H9mEys3KaDuOEEIIkelUKhXDf+5Nzvw5+LHHz0QGR2s7UrYgpS0LCfQOZsngtbhXLsg309trO44QQgjxyZiYGzPpz6EkxCQyv+8qmd/2DqS0ZRFpqenM6fkLuvq6jFs3ED39TFlCTwghhMiy8hTLxcAF3bh18j47Fh/67yd85aS0ZREbZu3iya1njFrRFwdXO23HEUIIIT6Lxr1rU61VedZP34HXbV9tx8nSpLRlAXfPPWTbggM06lWLqi3LaTuOEEII8dn8b36blb0Fc775heSEZG1HyrKktGlZXFQC83qvJGc+R76d11XbcYQQQojPzsLGjO/XfkugVzCrxm3WdpwsS0qbFimKwtIha4kKiWHcuoEYmxlpO5IQQgihFaVqFqXdyCYcWnOKS/tvajtOliSlTYtO/HmB87uu0XNKWwqWzavtOEIIIYRW9Zzajvylc7N44BoigqK1HSfLkdKmJaHPw/ll1B8Ur1aIdqOaajuOEEIIoXX6BnqMWzeIlMRUlgxag6Io2o6UpUhp0wJFUVg86DcUBUav7o+urnwZhBBCCIBcBZ3oPbMD147c5fjG89qOk6VIW9CCw2tPc+vkffrO7iTbVAkhhBB/02JgfYpXK8SK0RsJC4jUdpwsQ0rbZxbsF8av4zZTqrY7TfvW0XYcIYQQIsvR0dFh1Kp+qNPVLBn8m5wmzSCl7TNSFIXFA38DYNSKvqhUKi0nEkIIIbKmnHkd6TOzIzeO3ePYH+e0HSdLkNL2GR1Zd5Y7px/Q78fOOLrJrgdCCCHEv2n+bT1KVC/MyjF/EvEiSttxtE5K22cSERTNmgmbKVGjCE361NZ2HCGEECLL09HRYcQvfUhPTefnUX9oO47WSWn7TFZ89wcpSWmM+Lm3nBYVQggh3pFz/hx0m9Cai3tvcGnfDW3H0SopbZ/Bpf03Ob/7Ol0ntMI5fw5txxFCCCGylbYjGpO3hCvLR/xBQkyituNojZS2TywxLomfR6wnT7FctB/ZRNtxhBBCiGxHT1+Pkb/0ISokmrVTtmk7jtZIafvE/pixk4igaIYv742evp624wghhBDZUsGyeWkxsAEHV5/i0TVvbcfRCiltn9BTj+fs/eUYjfvUpkjF/NqOI4QQQmRrPae2xSaHFT+NWI9ardF2nM9OStsnoigKP4/8AzNrU3pNb6/tOEIIIUS2Z2JuTL8fO+N925fDa09rO85nJ6XtEzm95RL3Lz6m14wOWNiYaTuOEEII8UWo1aESJaoX5vep24kJj9N2nM9KStsnkBCbxOoJmylYJg8Ne9bUdhwhhBDii6FSqRi8uAeJsUn8PvXruihBStsnsPGH3USFxDJ4SU90deVTLIQQQmSm3O65aDWoAUd+P8vjG0+1HeezkUaRyfyfBLH3l2M07FmDwuXzaTuOEEII8UXqNqkN1o4WrPhuw1ezobyUtky2evwmDI315eIDIYQQ4hMytTDmm2nteXjNmzPbrmg7zmchpS0T3Tp1n6uH7tB5bEusHCy1HUcIIYT4otXrVp18Jd34bdJWUpJStR3nk5PVXjOJWq3h13GbyJHbnlZDGmo7jhBfJXW6mrAXUUSFxBAdHkdMeNzLf8PiiI2KJykhhZTEVJITU0jO+FeT/va1nvQN9TAyNcTIxBBDYwOMTAwwMTfG0s4cS1szrOwtsLIzx8reHFsnayxtzWRfYSE+M11dHQbM68qYhrPZs/woHb9vru1In5SUtkxyYuN5nnn4M2HDEAwM9bUdR4gvllqtIdg3jGeegQR4BxPsG07w83CCfcMIDYhE85YFN43NDLGwMcPY1OhlATM1wM7JCiMTQ3T1dd94vKIopCWnvSp20WGxJCekkBifTEx4HOlp6re+hqOrHU657cnhakeO3Ha4Fc5J7qIuWNmZf5LPhRACStYoQqVmZdgyfx8Ne9b4os90qbLj5L1y5copN27c0HaMV5ITkulV7HscXe1YfGaK/LUtRCZQqzW88Anh6f0AfB8G8uJpKIFPQ/B/EvzaaRAre/OMkmRPDjc7HF3tsHWyejUKZmlrjqGxQablUhSFhNgkosNiiQ6PIzosjvDASIL+Uh6Dn4eTkvj/Ga0dLHApkAPnvI645Hckj7sLedxdsHH8cn+5CPE5+T8JYkDZ8TTpU4shS77Rdpw3qFSqm4qilPvY48hIWybY+8txIoOjmbhxiBQ2IT6AWq3B1zOAB1d98Ln3nKcP/PF7+ILU5DQAdHR1cHS1JWceB4r3LEjuos7kLuqMa0EnjM2MPmtWlUqFmaUJZpYmuOTP8dbHKIpCZEgMfg9f8MwzAF/PQAKfhnLlyB2iw/5/MVAre3PyFHUhb7FcFCqTm6IV82OX0/pzfShCfDFyFXSiSZ9aHPrtDG2GNSZnXkdtR/okZKTtI8VFJfBN0VEUrVyQmbu+03YcIbKF1OQ0Hl734cFVbx5c8ebhNR8S45MBsLQ1I0+xXOTNGI3KW8yFXAWdvphpB7GR8Tx7EMCzBwE8vR/wstQ9DCQtJR0AR1db3CsVwL1Sftwr5setcE75Y1CIdxARFE0v9++o2rIcY38fqO04r5GRtixi++KDxEcn8s20dtqOIkSWFhYQybXj97h2zIM75x6RkpSKSqXCrXBOareviHul/BStmB/HXLZfdEmxsDGjZPXClKxe+NX70tPSeXo/gAdXvHlwxYvbZzw5lbGEgV1Oayo0KE6FBiUoVb0wRqaG2oouRJZm62RFq8EN2LbwIB2+a0aeYrm0HSnTyUjbR4gMjuYb9++o3Kws49cP0nYcIbIURVHwvvecC/tucvXoPXw9A4GXI0kVGpSgXF13ilbMj7mVqZaTZj2KohD0LIy7Fx5z/YQHt894khSfgr6hHiWqFqJS45JUa14WawcLbUcVIkuJi0qgZ5FRFK9WiOk7Rmk7ziuZNdImpe0jLB+xnkO/nWb1nbk45/syz58L8T4UReHpfX8u7LvF2d3XefE0FF09Xdwr5adC/ZejRbkK5viiR9I+hdSUNO5f9uL6cQ+uHfcg0DsEHR0VJaoXpmarclRqXEoKnBAZNs/bx7qp21l0cjLuVQpqOw4gpU3rpS30eTi9io2mQc+aDP+pl1azCKFNiqLw6MZTzuy8zuVDtwkNiERHR0XJ6oWp0bo8VZuVxsLGTNsxvyi+noGc3X2dc3uuE+gTikqlonC5vFRrUYaarcvLxQziq5ackMw37qNxLZyTeUcmaDsOIKVN66Vt2bDfObruLL8/WIhDLlutZhFCG3wfBnJm5zXO7LxGsF84+oZ6lK3jTuXGpajYsARW9jLy86kpisKzBwFcPnyXy4du4333OSqViuJVC1K7bQWqtSiLubWcfhZfn13LDrNq7CYWHJ9E8WqFtB1HSps2S1uofwS93L+j4Tc1GbZMRtnE1yMhNpHjmy5xZOMFfD0D0dFRUapmEWq3q0iVpqUwtTDRdsSvWoB3MGd2XuP0zmsEeoegp69LuXrFaNarFmXqFEVHR3YuFF+H5MQUvin6HW5FXZh7aJy248jVo9q0beEBADp+92VvlyHE//g9esH+Nac5sfUyyQkpFCyTm0FzO1O9ZTmZS5WFuOTPQbexLeg6pjne955zZsc1Tm2/wpXDd3HO50DzPrWp36WKlGvxxTMyMaT9yKb8Om4TDy4/wb1y1pjb9rFkpO09hQdG8k3R76jXrRojfu6jlQxCfA5qtYarR+6yb81p7px9iL6hHjXblKdF3zoULJ1b2/HEO0pLTefCvpvsW32ah9d9MDI1pF7HyjTvWxu3wjm1HU+ITyY5IZkeRUZRoHQeftj7vVazyEiblmxffAi1WkPH0TLKJr5MCbGJHPvzEvtWnyLINwx7Zxu+mdyaRt2ryx6a2ZC+gR6121WkdruKeN3xY9/qUxz98wIH1p6hbB13Wg6oS7m67nLqVHxxjEyNaDusCWsnb+XRdR8Kl8+n7UgfTUba3kNsRBzdCo6geusKfL9mwGd/fSE+JX+vYPatPsXxzZdITkihaIV8tB5YnypNS6Gr9+am6iL7ig6P49C6sxxYe4bI4Bic8znQol8d6neuion5590WTIhPKTEuie4FR1CqljuTNw/TWg4ZadOCfatOkJKYSvuRTbQdRYhM8+S2L3/OP8DVI3fRN9CjZtvytOxXlwKl3LQdTXwiVnbmdBndjPbDGnFh/032rjrFinFbWD9rD8371abNoPpY2sqoqsj+TMyNada/Hlvn7yfAKwiXAk7ajvRRZKTtHSUnptCj0EgKlc8ne4yKL8KT2778OW8/V4/ew9zalJb969C0Vy25sOAr9fjmM3b9cpxze25gZGpAi351aDu4gayxJ7K9qJAYuhcaSf1u1Ri+vLdWMsiSH5+5tO1fdYLlI9ZnmTVfhPhQXnf82DhvP1eP3MXMyoS2gxvQol8dTC2MtR1NZAF+j16waf6BV+WtZf+6tBlUX8qbyNaWDv2d4xvO88ejRdjksPrsry+l7TOWNnW6mt7Fv8fawZLFZ6bIFjwiW3rmGcAfs/dy+dAdzCxNaDO4Pi3715WyJt7K92Egm+Yf4PzemxiZGtD62/q0HVJflgsR2VKgTwh9in9Ph9HN6D2jw2d/fZnT9hld2neTYN8w+s/pIoVNZDsvnoWy4ce9nNl5HWMzI7qPa0Grb+vKL1/xr3IXcWbC2gH4egaycd5+Ni04wP7fTtNheGNa9KuNobGBtiMK8c6c8zlSrVU5Dq4+SZexLTAyzZ4X3MhI2zsYVXcmES+iWHt/Abq6clm8yB7CX0SxacEBjm68iJ6+Li0H1KX90IZf1bZGGo2GqNA4QvwjCA+KJj42iYS/3uKSSEtJf+tzjU0NMbUwfu1mYW2Kg7M1jrlsv7oRSq+7fqyftYcbJ+9j62RFl9FNaditGnr68re/yB4eXHrCqLozGbrsG5r1q/tZX1tOj36m0uZ125chVSYzYG4X2gxr/FleU4iPkZqcxo7lR9m6+DDpaWoa96xO5++aYquFeRyfS1pqOn6Pg/C69xxvjwCC/MIJ9Y8gJDCK9NQ3S5mOrg6m5kaYWppgYPhm6VAUSE5IIT42iaT45Le+ppmlMQ4utjjmssE1vyP5S7hSoEQuHFxsvugReY9LT/h9xi48r/ngUiAH387uSLm6xbQdS4j/pCgKQ6tNJSUxhV9vzfms/59KaftMpW1Bv1Wc332dP72XYmb19YxQiOxHURSuHL7LqolbCfYLp1rzMvSZ3g6n3PbajpbposPjuHnmIQ+uPcXb4znPHgW9Kmcm5ka45HPAMaNQObrY4JDLFvuc1phbmWBqYYyRicE7/8BWqzUkxiWTEJtITEQ8oQFRhAREEOIfSYh/BMH+kbx4Foo6XQOAuZUJ+YvnokBJV0pVK4R7hbwYGOp/ss+FNiiKwtWj9/h10jZePA2lcpNS9J/V4Yv8XhNfluN/XmBB31XM3j+GsvWKf7bXldL2GUpbdGgM3QqMoFGvmgxZ8s0nfz0hPpS/VzArx2/h5qkHuBZyYuCczpSuWUTbsTKNWq3hyR0/bpz25MZpT7zu+qMoCmZWJuQv5vJylKt4LvIXz0UON9vPvrp/anIazx69wPueP94eL0f7fB+9ID1NjZGJAaWqFaJ8naKUq1MUB2ebz5rtU0pNSWP3ihNsXngQdbqadkMa0nFkY4xMDLUdTYi3Sk1Jo3vBERQql5cZOz/f8l1S2j5Dads0dy/rp+1g9Z25uBaSPfpE1pOckMKmhQfZ9fMxDIwM6D6uBc371voi5hklxCVx6+wjrh6/z/WTD4iNSkBHR0XhMrkpV/tlAcpXzCXLbr+UnJjCnQtPuHHak+unPAkNiATArZATleoXo2L94hQs7fZFzJMNfxHFmqk7OLPzGg4uNnz7YycqNyn1RZ8mFtnXHzN3sunHvay9P5+ceR0/y2tKafvEpU2t1vBNkVHkzJ+DuYfGfdLXEuJDXD58hxXjthDqH0G9zpXpM7Vdtl8YNywwisvH7nH1+H3uXfIiPU2NuZUJ5eu4U76eO2VrFM6WF1IoioK/dwg3Tnly7cR9PK76oFFrsLQ1o0K9YlSsX4xytYpk+ysyPS494ecxm/D1DKRiwxIMnNOJHG5yylRkLREvouhWcARthzem7w+dPstrSmn7xKXt2pE7TG69kIkbh1CjbcVP+lpCvI/g5+GsGLeFq0fu4lY4J0MXdqVY5YLajvXB1GoNN8885OAfF7h+8gGKouCSz4GK9YtTqUExipTN88XtfRoXncjNM54vRxFPeZIQm4SZlQn121ekSfdquORz0HbED5aels7eVafYMHcfikah83dNaDO4wRc3r09kb9M7LOHBlSf86b0MfYNPf2YiS5U2lUrVCFgK6AJrFEWZ87f7RwF9gXQgDOitKIpfxn1qwCPjoc8VRWnxX6/3OUrb1PaLeXTNm41eSz/LF1SI/5KWms7O5UfZvPAQKh0V3cY0p9W3dbPtqdDoiDiObbnC4Y0XCX4egbW9OQ07V6Fu2/K45P88pyyygvQ0NR6XvTiy6RIXD99Fna6hdPVCNO1ZnUr1i2XbwhoWGMmqCVu5sP8WLgVyMGR+F0rV+HLmWYrs7fqxe0xqOZ8JG4ZQs92nH5jJMqVNpVLpAk+A+kAAcB3orCiK518eUxu4qihKokqlGgjUUhSlY8Z98YqivNf+KJ+6tIUFRNKj0Ajaj2pK75kdP9nrCPGuHt14ypLhf+D7MJCqzcrw7eyO2LtkzwntIQGRbFl2lBPbr5Gemk7xyvlp2r0aVRqX/Or/QIoMjeXopksc/vMSYS+isHOyov3gejTqUiXbjlRdP+7BL2M3E+QbRoMuVek3qz3mciW+0DKNRsM3Rb/DKY8Dcw+P/+Svl5VKW2VgmqIoDTPeHg+gKMqP//D40sByRVGqZryd5Urbxh92sWHWbtZ5LsQpT/Y9TSGyv+TEFNbP2sOeVSexzWHJ4AVdqdy4lLZjfZCwwCi2Lj/G0c2XQaWiQcdKtOhVA7dCTp89i6IoJCWkEB+TRNpb1nEDMDYzxMzi7eu4fWrqdDXXT3myc+VJ7l/1wc7Jik7DGlK/Y8VsWd5SklL5c/4Bdvx0FEtbMwbN7UL1lmW1HUt85TbP28e6qdtZ6zEf5/w5PulrZaXS1g5opChK34y3uwMVFUUZ8g+PXw4EK4oyK+PtdOAOL0+dzlEUZc9/veanLG0ajYaehUfhXCAHcw7KBQhCex7fesa8b38j0DuEZr1r0WtKm2y5Cn/g01C2/XycUzuvA9CgU2U6DW2AvbP1J3k9jUZDZGgcQc/DeeEbQdDzCIL8wgkJjCI+OpG4jN0Q/reu2n8xNNLHzNIYM0tjLG3McHK1xcnVlpy57V7996f6uiiKwp0LT9gw/yAPbz7DNoclbQfUoXG3qtlyWQ0fj+csHrYe77vPqdOhEoPmdsbMUrZTE9oRERRNtwLDaTeiCX1mfdqzatmytKlUqm7AEKCmoigpGe9zVhQlUKVS5QVOAXUVRfF5y3P7A/0BXF1dy/r5+X1U7n9y56wnYxv9yNjfB1KnU5VP8hpC/Bt1upotiw/z57z92Oaw4rufv8mWc4HiohPZsOAgB9efR89Aj4adK9NuYN1MX6csNiqBR7f9eHjbj0e3n/P43nOS4lNe3a+rp4Ojsw2OLtaYW5tiZmGMeUYJM7M0eevIlaIoJMUnExebRHzM/26JREfEE+QXQVR43GuPd8hpReEyuSlcypUiZdzIV9Q5U0/1KorCnfOP2frTMe5e8sLa3pw+k1pRp235bLeshjpdzZZFh/hz/gFsc1gxekVvSlYrpO1Y4is1uc1CfO74scFrySddficrlbZ3Oj2qUqnqAT/xsrCF/sOx1gEHFEXZ8W+v+SlH2hb0W8XFvTfY7Ls8W/4lK7K34OfhzBvwG55XvandrgKD53fNdiMRGo2G41uvsnb2PuKjE2jaoxqdRzTC2j5zliNRp6vxuPaUi0c8uH3Ri8BnYcDLranyFHaiSGk33ArmwMnNlpxudjjktMr0yfyJ8ckE+0cS5BdBoG8YPg8CeXjLj7CgaAD0DfQoUNyFinWKUrVRcZzzZN6yF57Xn/Lr9N08vu1L0fJ5GTSrPfmKuWTa8T+X/40kv/AJpf2whnQf3/Krn9MoPr9zO6/yQ7flzD4whrJ1P90OCVmptOnx8kKEukAgLy9E6KIoyoO/PKY0sIOXI3Jef3m/NZCoKEqKSqWyAy4DLf96EcPbfKrSlhSfTKfcQ6jVvhIjV/TN9OML8W9Obb/C8tGbABi6sCu1P8MVTZnt8R0/fpm4jSd3nuNe4WWhyOv+8YUiLTWdu5e9uXD4HpdPPCA2MgFDI31KVsmPe9k8FC7tSsESubT+h1Z4cMyrUT+Pqz54eQQAkKewE1UbFadaoxK4FnD86NExjUbDie3XWPvDXuKiEmjSvRo9vm+a7dawS05IYdXErRz+4zwFSrkx9te+uHziuUVC/FVqciqd8wylQqNSjP194Cd7nSxT2jLCNAGW8HLJj7WKovygUqlmADcURdmnUqlOAMWBoIynPFcUpYVKpaoCrAI0gA6wRFGU3/7r9T5VaTux6QLz+6xiwfFJFJfhevGZJMQmsvz7TZzefpWiFfIxZlWfbLcgaUJcEmtn7eXwn5ewsjen7+RW1G5d7qPLScDTMA5svMTJXTeIj03C2MyQirVfjl6Vq1lI6yXtv4QGRnHxqAcXj3jgedMXRVFwK+hIs65VqNO6LCZmRh91/PiYRDYuPMT+389hZmlCv6mtqduuQrY7ZXph/y2WjviD1JQ0vp3diUbdq2W7j0FkX8uG/c6JjRfY7Lv8k81PzVKl7XP7VKVtbJM5hPiG8fuDBfIDQ3wW3veeM6vnCkIDIun6fTM6jWqS7dblunfJi4UjNxL+IopWfWvRZVRjTM0//AdfSnIal4/d59j2a9y+6IWevi5VGxanVsvSlKlWMFtePQkvl/O4eMSD4zuu43U/AGMzQ2o3L02DDhUoWCLXR/3MeeYZyPIJ2/C8/pTKDYszbF5nrOzMMzH9pxf+IooFg9Zy59wjarQqx8hlPTH+yFIrxLt4eNWbEbWmM2plXxr2rPlJXkNKWyaXtoigaLrmG0bncS3pOaVtph5biLc5suE8P4/ZhKWtORN+60/Rivm1Hem9pCSlsn7uAXavPo1zHnu+W9KdIuXyfPDxwoKi2bn6DCd33SQ+NglHF2satK9Ao04VsfnA+XAajYaQwGie+4Ty4nkEMZEJxEYlEBudSExUArFRiaSmpL31uabmxlhYm2BpbYKFlSkW1iZY25njmtce1/yOWFh92FxDRVF4fPc5BzZe4sKhe6Qkp+FawJEWParSoH2FD57XpVZr2LvmDOvm7sfEzIhh8zpRpVHJDzqWtmg0GrYvO8r6WbtxyZ+DSesH4qqFJWHE10VRFHoVG02O3PafbNUIKW2ZXNr2/nKMX77bwK+35uBWxDlTjy3EX6UkpfLzmE0c+/MiZWoVZcyvfbPdqIjXvefMH7YBf69gmn9Tnd4TW37wqcrw4Bi2rTjJ4a1XUTQK1ZuUpGGHCpSolO+9NoNXqzX4PHzB3atPefY4mOc+oQQ8CyMl+f9LmY6uDhZWxlham2Jh/bKIGRm9ud+nRqOQEJ9MbFTCy6IXnUhCXPJrj7GyNcU1nwOu+RwoWMyFUpXyYe9k9V4fe0JcMucP3eXw5is8ueePQ04rOg6qS/125T+4vPk9DmL+sD/wuR9AvfYV+HZGu2y3VMzd84/4se+vJCemMmJJD2q1raDtSOILt27adrbO38+mpz9h7WiZ6ceX0pbJpW1k7RkkJSSz8trsTD2uEH/14lkoP3yzEh8Pf7p+34wuY5p/0svMM5uiKOxadYrff9yHlZ0FIxd1oWzND1uOJCIkhq0rTnF4yxUUjUL9duXpNKguju+404OiKAT6RXDnsjd3rvhw96oP8bEvi5WDk9WrQpUrnz2u+Rxwzm2HuaXxexXBv0pPUxMRGov/0zCe+4S+dvtfoXPObUfpyvkoVSkfJSrkw9zy3cqSoijcOv+EDUuO8vjOcxycrek0uC712pT7oPKWlprO5iVH2PrTMeycrJi4ui8FS7q+93G0KSIomh96r8Lzqjct+teh34z2cnWp+GR8H/gzoNwEhizpSfMB9TL9+FLaMrG0hfiF06PwSHrNaE+n7/9z61MhPsjlQ3dYMGgtKh0VY1b1pUL9T3d5+aeQnJTK0tGbOLPnJlWblGT4/C6Yf8ApwuTEFDYvP8nutefQaDTUb1uejoPqkCOX7Ts9PyI0lpP7bnNizy38n75c7sPByYpSlfNRunJ+SlbMi/VnHLlUFAVfrxDuXPbm9mUfPK4/IzkpFR0dFWWqFqBB67JUrFMEg3coHIqicPPcYzYuOcrju/44uljTf1JLKtd3/6A5bw9vPmPOwN+JCo9j2NxO1Gufva5ITk9L57dpO9m94gSFy+Vl4u8DsM/kdf6E+J/+Zcdhbm3GwhOTMv3YUtoysbRtX3SQNRO3yLZV4pNQqzWsn7WbbUuPUKCUGxPXfUsOVzttx3ovIf4RzOi9mmcPX9BzbDM6DKn/QSXi6klPfpm2m9DAKOq2LkvX4Q1wcv3vspaclMq1M484vucWty56odEouJdxo1bTkpSpUgAnV5ssc/FQWmo6jz0CuH72MacO3CE8OAZzS2NqNS1JnealKVTC5T+zKorCjbOPWDv3EL6Pg6hQpwiDprV+51HIv4qOiGPOwHXcvfiEFr1r0n9q62x3scv5vTdZPHQd+oZ6jP21H2VqF9V2JPEF2jRnD+un72Sj19JM39tZSlsmlrah1aaCovDTxRmZdkwhABLjkpnT71euHfOgyTc1+HZ2JwyMstfVj49v+zLtm19JT0tnzPKelK/j/t7HCA2MYuXMvVw+dh/XAo4MndmWYhXy/ufzAn3D2bPhIif23CY5KRW7HJbUa1maei3L4Jz7v4uvoiiEBsXg6x1CgG840ZEJREcmEBP1///+dc7bX5lZGGNlY4qltWnGvybY2lvglt+BPPkdMTX/7ysb1WoNd674cHz3TS6d8CQtNZ2crra06FaZBq3LYmz67/MA09PU7F1/no1LjqFoFLoMq0/r3jXe+zShOl3Nb7P2snv1acrVLsL4lb0/ermRz83fK5gfvlnJ88cvGDi3M8371NZ2JPGFCfQOpnfx7xkwrytthjbK1GNLacuk0hYWEEm3AsPpPaMDHb9vninHFAIgLDCSqZ1/wvfhCwbN7Uyz3rW0Hem9XTx8l/lD1mPtaMnMP77FJb/jez1frdawe+05Ni45CgrvVDoURcHjxjN2r7vI1TOP0NXToVbTktRvVQb3srn/dQ5gyItobl32xvtREM+8QvD1DiHxL1ta6evrYmlj+loZMzJ++4UI8bFJr5W72Ogk/vrz0sHJktz5HcldwJEiJXJRqkIejP/lYoz42CQun/Tk0LZrPLrrj5mFEY07VKB5l8rY5/j3ic9hL6JZOWMPl/5Xeme1o1j5979S98imS/w0biu5Czkxbf0A7HN+mv1fP5Wk+GTm9FvN1aP3aP1tPfrObJ+t5oSKrG9AufFY2Jgx/9jETD2ulLZMKm37Vh7n55F/sPrOXFwL5cyUYwrhdcePqV1+Ijk+hQm/D6Bc3WLajvTeDm28yPJxWylU2o2p6/pjZft+88Qiw2KZN+JP7l72oVI9d76d2hLHf5mPpCgK5494sGPtebweBGJhZULTzhVp1qkSNvZvf+20tHQ87zzn2nkvrl94wvOMOW6mZkbkLuBAngI5yFPAkdz5X16UYGZu9MGnUdVqDRGhsa/KoK9XKM+8gvH3DUedrkFfX5fiZXNTrmoBylcviIub7T++1sM7z9m9/gIXjz9ApaOiRqMSdOxfE7f/KMVXT3qyYvpuwl5E03V4AzoNrvveF1bcPPuQH/qvxczCmNlbhuCSL3tNCVGrNayetI09q05SqXFJxq7qK+u5iUyzfvoOtszbx2bf5Vhl0tZ7IKUt00rb2CZziHgRxZo7czPleEJcPnSHOf1XY2ljxowtw8hdNPstIbNj5Ul+m7mH8nWKMuHXPm8djfo3dy97M3f4nyTGJzN4Rhvqtyv/r49/9jiIX2bt5/5NX3LltadVj6rUbVEaw7ecSlYUhUceARzYdo1Lpx6SlJiKnp4uxcq6Ub5aAcpXLUiuPHafbY5baurL4nj9whOuX/B6VRydXKyp16I0jVqXxfYfSmdIYBR7N17iyI4bpKak0bJrFboMroPpv5SQpIQUfpq0k9N7b1GmekG+X9QFK1uz98rscz+ASV1/AeCHTYMyZauxz23fmtOsHLeZPMVyMX3TEOyy2aihyJq8bvsypMrkTF9oV0pbJpS2uKgEOuQaRPtRTek9o0MmJBNfM0VR2PXzcdZM3UGB0m5M+3MINp9gvZ9PSVEUNsw/yOalR6nRogyjl3Z/r/lTGo2GrStOsXHxUZzz2DNheXdy/8viqPGxSWxcfoL9m69iZm5Er1ENadCm7FtHj5KTUjl92IMD267h8ygIE1NDajQoRsUaBSlZIS8m/zA/TFEUgoOi8XkSQnhoLOGhsYSFxhIeFkt4aBxJialvPEelAktrU+zszbF3sMDOwQI7e3Ny5LSiYJGc/1qqggOjuHHRi4snPbl99Sm6ejpUq1uUZh0qUKyM21vLZExUAuuWHOPojhtY2ZrRd3Qjajcv9Y/FU1EUjmy9yoppe7CwMWXc0m7vfbo0wCeUCZ2Wk5SQzPT131K0/H/PMcxqrh/3YHafVZiYGzNt0xAKlHTTdiSRzSmKQs/Co8hTPBfTd4zKtONKacuE0nZy80Xm9V7JsvPTKVQu+/3AElmHRqNhxbgt7F9zmuotyzL6l94YvufolLYpisJvs/ayc+VJGnWpzJA5nd5rvlBcTCLzRmzixtlH1GpRmmE/tPvHifYajYaTe2+zdtERYqMSadKxAj2G1n/rEiJBAZHs2nCJ04fuER+XTO4CjjTvUIHaTUq8UdQURSHgeQRPHgbx1CsYH68QfLyCiYlKfPUYfX1d7BwssM0oZCamhvy9Gqk1CtFRCUSExREeGktUZDx//VHp4mZLvvyO5C3gSL6COSjs7oLFW9ZkC/SL4OCO6xzbc4v4uGRc89rTpF15Grcp+9ZRxMceAfwyax9PPAJwL+PG4MktyPMvpdfHM5DZgzcQHBBJ33HNaNW7+nuNMIYGRjKh43LCg2OYtWkQxSrke+fnZhVPHwQwtdNPxEbFM3n9wGw5FUFkLStGb+TgmlNsD/gl0069S2nLhNL2Y4+fuXf+IX/6LPvgBTeFUKerWTx8PSc2X6bt4Ab0md42W34/bVl2lPVzD9D8m+oMnNX+PX/5RzGx568E+0fy7ZSWNOlS+R+fHxkWy/yx27lzxYcipVwZNKkF+Yu+OZ80ODCKTavPcmL/HXR1X45WNe1QHvdSrq8dOy1NjcdtP65e9OLKhScEBUYBL8uZW14H8hVwpFDRnBQskhOHHJZYWpm896nT9HQ1keHxBDyP4OH9ALwfB+PjFUzwi2gAdHRUFC2Ri0rVClKpWkFy/W0+W3JSKmeOeHB45w0e3w/E2s6Mjr2q07htuTfKm0aj4dium/y+6Cjxccl0G1yHDv1q/WOBTohLZtH3W7h07D6NO1di8Iw271W2I0NjGdN2KdHhcczbMSxbniqNDIlhUvsl+D8JZvxv/anStLS2I4ls7PbpB4xrMofpO0ZSqWmZTDmmlLaPLG3qdDUdXAdTuVkZRv/aP5OSia9NWmo68was4fzem3Qf14Iu3zfLMuuFvY9DGy7w07it1G5TjtFLu79X6fTzCmZiz9UkJ6QwdXUviv/LaM3NC09YMH47SQmp9B/bhEbty7/xWsGBUWxZc47j+2+jo6NDk7bl6NC7+mvzwtRqDZfPP+HM8fvcuOJDYkIK+ga6lC6Xh4pVC1KslCu53GzR+9t6ZAkJKS9Pi4bFExYWS3h4HElJby75oVKBlaXJy9E4e3Ps7MyxtTNHX/9vx4tPxudJMLeuP+PKhSc89QoBIKeLNZWqFaRxyzK45bF/7TkeN33ZuPI0d68/w8benI69q9O4TVkMDF8vb3HRifzywz7OHLxHyYp5GTOvwz/uwarRaPhj0VG2/nKSao1L8P2iLhgYvvtp7dDASL5ruRh1upoFu0eS82+Zs4O46AQmt1/Kkzt+fL+yN7XbZq+FhEXWkZqSRnvngdTtUpVhy3plyjGltH1kaXtw+Qmj6sxk4sYh1JD/ucUHSE1OY9Y3K7h2zIN+M9rTdkgDbUf6IBcO3mH2gLWUr1OUyb/1Q0//3RdefXTHjym9f0NPX5cf1vUjT5G3X4GdnqZm/bLj7PjtHLkLODJuYac3rpRMiEvm959OcGTXTVQqaNy2HB16VcfO8f+LSlJSKscO3GH31qu8CIjCxtaMitUKUqlqAUqVz4PxX05Jx8Qk8vBBIA/uB/LgQQDeT4JJfMv8NX19Xf5+flSjVlCrNW881t7enCJFnSlazAX3Ys7kL5DjtSIXGhLD1QteXL34hNs3npGWqqZ85fy061KJUuXyvFbo715/xsaVp/G46YutvTm9htWnbrOSrz1GURSO7brJih/2Y2RiwOgf21OuesF/+GrA7t/O8esP+yhVpQCTV/Z8r7XY/L2DGd1qCSYWxizcMxIbh8y7cu5zSYxLZmqXn7h/yYvhS7rTqHt1bUcS2dS09ot5eu856x8typQ/xKW0fWRpWz99B1vm72d7wC+YWZlmUjLxtUiKT2Z6t5+5e/4xQxZ0oWmvWtqO9EHuXfJiYtdfKFA8F7O3Dnmvq0Rvnn/MrIHrsbIzZ/Yf/f9xZ4OQwCjmjN7Co7v+NG5fngHjm71xSvD6hScsnbmPyLA4mrQtR8e+NbD/y0UcEWFx7N1xjYO7bxIXm0yRYs607VKZqjUKo6v3cqROrdZw944fZ049xOPec/yfRwKgq6tD/gKOFCrshGMOq5cjZ/+72Zq/dURKURTi45MJD4sjLCyOiPCX//o/j+Dhg0CCg2MA0DfQpVAhJ8qVz0udeu7kdP7/KxhjohPZv+sG+7ZfJzoqgXwFc9C2cyVq1nN/rejdvf6UdT+d5OE9f8pXLcCwKS1e+9gB/LxDmPPdFny9QmjXpwY9h9X/x3J9YtcNFo/dRr6iOZn5ez8sbd7959vj276Mbf8TznkdmLdzGKbm2WujeXi5Tdqsniu5cfI+387uSKtvM38fSfHlO7jmFMuG/s7q23NwLfzxKwBIafvI0ja4ymQMjQ1YdHJyJqUSX4v4mEQmtV/Kk1vPGPVzL+p1rKztSB/k6YMAvm+7FNscVizcPQJz63f/5X7+0F3mjdyEa35HZq7r+4+n7W5e9OLHUZtRFIXh01tTo3GJ1+6Pj01i1YIjHN93G7d8Doya3ppCxf7/B2RcbBKbfj/Pvh3XSU9XU7VmYdp2qYx7iVzAy3L1+FEQZ055cvqUJxHh8RgbG1CqtBtFiznjXsyFgoWcMPpLSUxNTScyMoHwiDgiIuJJ+ocdESwtTbCzNcPO1gxLSxN0dP7/r+3w8Dg8HwTieT+A+x4BPHr4AoDCRXNSt5471WsUxi7jdG5qSjonj3qwa/MV/J6F4ZDDkt4D61C7QbFXf8FrNBr2b73G2qXH0dXTod+oRjRqXea1v/BTktP4dc5BDm27RpFSrkz5qds/LvVx5eQDfhyyAQdna2b/MQD7nFZvfdzb3DjtybRvVlGsQj5mbBz4xmnb7CA1JY25/dZw8cAtekxoSZfRzbQdSWQzoc/D6V5oJP1+7Ey7EU0++nhS2j6itEWHxdLRdTA9p7Wjy9iWmZhMfOmSE1KY0HYxT277Mm5Nf6o1z5xJqp9bQmwSQxrOJS1VzeJ9o7B3fvc1ri4fv8+sQX9QpLQb09b0xszi7aMxZw7dZcG47bjmc2Dysm445Xp9Yd1bl71ZNG0PkeHxdOhVjS79a73aVD09Xc2BXTfZsOYs8XFJNGhWik49quGccYyoyHh277rB8SMehIXFoaenQ/mK+ahbz53KVQtgaKiPWq3hmW84ng9f4PkwEJ+noYSFxxETk/Teny89PR1sbcxwdLCgcGEnihZxpmiRnNhnbEwfGhrL6RMPOHniAU99QgFwL+ZCi1ZlqFW7KLp6OiiKwvXL3qxbdQbvx0EUdndmwPAGrwoovLxSdsn0vdy9/ozy1QowYmqrN9Z4O3v4Hosn7sTO0YIf1vTG8R++dvevPWVq37VY2ZqxYNtgrP9hrbi3ObXzOvOH/UGL3jUZOLPd+366sgR1uppFQ9dxcusV+k5vR7uhDbUdSWQz/cqMwy6nNT8eGPvRx5LS9hGl7eyOq8zuvpylZ6dSuEL+TEwmvmRpqelM67Kc22c8Gf/bAKq3LKvtSB9EURRmD1jL5aP3mL9zBEXKvfv6XvevP2Nij1XkKZKTHzcM+MclPQ5uucrPM/fhXtaNab/0eG1dM7Vaw7qfTrB93QVy5bHj+1ltKeju/Crb1Yte/PrTcQL8IihVLjcDhjcgX4EcAAQGRLJ961WOHrlHepqaCpXyU7NWESpVyY+FhTHP/SM4dfoh9+4H8OhxEElJL+ewWVoaU6hADhwdLbHNGD2zszXDzs4cE2ODN+asaBSF6OjEV6Nx4eHxhEfEExAYiZd3CGlpagAc7M0pWtSZcmVyU7NGYcxMDfHzDef8uUecOv6A588jcMxhSbv2FWjUtCTGxgZoNAonDt/j95WniAiLo2bdovQeXBenjMVh/zfq9tuSYxga6TN+bgfKVHr94o4Ht/yYOnA9xqaGzF7Ti1x5376rwcNbvozvvgrXfI7M2fTte81xWzV1J3vWnGHS6j5UbVLqnZ+XlajVGub1X8PZ3dcZvqQHjXvIHDfx7n4Z9QdH1p1lZ/Cq997v9++ktH1EaVs69HfObL3Ejhcr0dV790nX4uulVmuY0/dXzu+9yYilPbL1BOcD687x88Tt9JnUknYD332+j9+TYEZ3+BlLWzMWbh/y1rlSiqKwbfVZ1i05RoVahZmwqPNr89eSElOYO2EnV848okm7cgwY3fjV/RHhcSyctY8bV3xwcbOl/9D6VKxaAJVKxeNHQWzddJnz5x6hp6dLg0bFad+xIi65bImNTeL02UccPe7Bw0dB6OioyJ/PkaJFcr662duZ8+x5OMEhMQSHxmbcYggOjSEx8e1Xj1pbmZDD0RInB0scHSzI4WCJS04r7GzM8HkahuejF3h6BvLAM5DQsDgMDPSoVrUADesVo2yZ3KhUKq5e9mbL5ss88AjA3MKYVq3L0qpNOSytTEhKSmXHn5fZtvESGrWGLr2q06lntVfLdfj7hvPD6C08fxbO4HFNadr+9V0lnj4KYlK/31FrNMz6tRcF3N8+7+baKU+mD1hHqSr5mba69zv/8klLTWd068UEPg1j+dEx5HC1e6fnZTVpqenM6PYzN04+YPxv/anR6qN/b4qvxKX9N5neYQkLjk+ieLVCH3UsKW0fUdp6FRtNrkJOzNj5XSamEl8qRVFYOmIDRzacz9ZXiQJ43/dnZPNFlKpWkOnrB7zz0h5hQdGMavcT6nQNi3cOxdHlzT1EFUVh7cIj7Fh7ntrNSjHqh7avTZYPC45h6rA/8fUO4dsxTWjR6f+v2r5+2Zt5M/aQnJhK70F1ad62HHp6ukRHJ7By+UlOHL+PqZkhLVqWpXXbctjYmnHrth979t/i8hVv0tM15M1jT8P6xahbuyjW1qY89Qvj5h0/bt71496DgNfmrpkYG5DD8WURMzM1fHOkTaMhIjKB4NAYQsPjSE///ytJHezMKVvKjbIl3ShT0hUbK1MePgri2In7nDrzkLi4ZGxsTKlXpyhtW5XDwcGC+x7+bN18hcsXvTAxMaBP/9o0b1kGHR0V4aGxrFp2nLMnHlCqXG7GTmuNbcZp14T4ZOaM3c71i1606lKJft81em0NtkDfcCb0XUtcTBLTfulOiX/Y1eDotmssGbeNOq3K8N2CTu/8dQ9+Hs6QhvNwyefA/F0jPnq0QVuSE1OY2G4Jj28+Y9qfQyhXTxbgFf8tPjqB9s4D6TK+Fd0ntfmoY0lp+8DSFuofQfeCIxgwtwtthjXO5GTiS6MoCmum7mDn8mN0+q4J30xsre1IHywuOpFhjeeRnqZm+bGxWNq8236VcTGJjOn4CyEvopi/ZRD53rKXqkajYfn0vRzefp3mXSrx7YRmrxWDxx4BTBu5iZSkNCbM60C5qgWAl3PX1q08zbaNl8idz4GJs9rilsf+5VIXRzxY+ctJkhJT6NilMh06VcLU1JD7DwJYu+48t+8+x9rKhLp1itKwfjHy5rHnjoc/h054cP22H9ExL3dBcHWxoWxJN0oWy4VLTityOFiir6fDi9BYAoOjiU9IfvODVqlwsDXHOYcVtlamRMUkEhwSw1O/MG7dfc6te8+Ji3/5vDyudlSrlJ+mDUpga23K1WtPOXbiPpev+qCjo6JFs1J06VQZG2tT/HzD+OWnE9y88Yyi7s6MHN2YPHkdXn68B++yfMFhjIz1GTu1FeUqvZy6oU5Xs3rRUfZsukL5agUYN6f9a6ebw0NimNBnLSGBUUxa2pXyNd4+IrB5+Qn+WHSEdv1r0Wfcu0/Mv3joDrP6/Ubzb6oz6Ifsu91fQmwiY5ovIMA7hB92jqBYpQLajiSygaFVp6BvpP/RFy1KafvA0nZ843kW9PuVFdd+IG9x10xOJr40O5cfY/WU7TTvW5tBcztny4Vz4WX5nNVvDddOPGDezuEUKftu89jUag0Te/zKgxvPmPl7X0pVefsvul/nHmT3+ot07FeTniMavPZ5unL2EbPHbMPa1ozpy7qRO//L+VcR4XHMHL8dT48AmrQqw8ARDTE00icoKJpF8w9x+6Yv7sVdGDW6MW657Xn8JJjf15/n6vWnWFub0rVTJZo3LUVUdCJHTz/gyMn7BAZFY25mROXyeSlbyo2S7rmIiUvitqc/j7yDCQ6LJSQ8jvDI+Hf+3Bno6+JgZ4Gj3csSV6KwMyWKOBMXl8zNu37cuO3LbQ9/FEWhbEk3GtUtRvVKBYiOSWTDn5c4cswDA3092rQqS4f2FbAwN+Lk8QesWH6c+PgUOnetTJfuVTEw0MPvWRg/TNqJr08oXXpVp0e/Wq+uWj24/To/zzmIa157Zq/ogY3d/19YEBOVwKR+v+PnHcrs33pTrGzuNz4ORVFYPnkXhzZdZtjsdjTuVOmdPwerZ+xm16pTTFjVm+rNsu9uA9FhsXzXdB7RobEsOjIOt8JvX1dQiP/5bdJWdi07zM6glRiZfviWVlLaPrC0LR64hgt7b7A94JdsudWQ+HyuHrvHtM7LqdaiDON/65+tv18uHLzDD/1/o/fElrQf9O7z2P5cdoyNS44xcm4HGrSv8NbHHNlxnaVTdtO8SyUGTmz+WmG7fOYRs0ZvIW/BHMxc3h2rjHlwjz0DmTpmKwnxKYya2Jza9YuhKAr79txi9cpT6Oio6PdtHZo2L01oWCw/rzjJhUteWJgb0alDRVo2L81tD3927r/JrXvPURQoVTwXjesWw8XFmrsPA7nzwJ97jwJJyFhQ18nBgpyOVjjameNob4GpqSG6ejqoUPH3Lq4oL0tOako60TGJhITHERoRh29ABPEJKRnHs6S0uwuliuYin6sdF696c/TUA4JDYzExNqB29cJ0aVsBRaOwbsMFTp95iLGxAZ3aV6Rzx4okxKew4ucTnDh2H7fcdoyb2IICBXOQkpzG8gWHOXrgDhWrFmD8jDav9li9ddmbGaO2YOdowYK1vbH6y2hpbHQiozqvID4umaVbB731qlK1WsOU3mu4f+0pS/cMJ/e/7Gv6V+lpaka1WEh4UDSrzkx66x6x2UVoQATD683GyNSQpccnYPGOI87i63T96F0mtVrA3CPjKVWz6AcfR0rbB5a2PiXH4FIgB9N3jMrkVOJL4vfoBSMb/EjOfA4sODgGI5O3XyWZHSTEJtG/1iys7CxYdmj0O19843HNh3FdVlKrRWlGL3z7KOP9G88Y33stxSvkYebKnq8d+861p0wespE8BRz5cVXPV6f07t3yZfLoLVhYmjB9XkfyFnAkLU3N0kVHOHLoLuUq5GXU901wcLDg1GlPFi07hkaj0LF9Bdq1LkdgUDQ/rz3NHQ9/nBwtaVS3GLWrF8LTK4idh2/zyOflVlJuzjaUcs9FgTz2pGk0+PiHExASQ2BINKERcWje8WefkaEeOR2scHawJJeTNa6OViQmpOLx+AV3PQOIiUtCT0+HOlUK0bphKdJS0zl68gFnLj4hXa2mTbMy9OhYmfCwOH7/4wLnLz6hcCEnJo1rjrOzNVeveLN4wWHiYpMYO7EFNWoWRlEU9u+8wS+Lj1CoSE5mLeqCecbSKvdv+zFx4B+4uNkyd3Wv15Zc8X8aysjOK3HIacXCjW+/ujcqLI7BTRdhbm3C0j3D33lBZe/7/gxvsoAGnSoxfF7nd3pOVuV5zYexLRbgXik/s7YPR08/e87VE59efHQC7XIOpPvkNnQd3+qDjyOl7QNK2//WZ+szqyMdvpPFFsXbxUbGM7z+bJITUlh2YiL2b5l0n50sH7+VwxsvsvjAaAqWfLcpATGRCQxutghDQ31+2j/irUtFhARGMazDz5hbmrB480DMLf+/PDzy8Gdc//U45rRi/m+9scgYmbl+2Zvp47aRw8mKuT91x9benJjoRKZP2cm9u/5061GVHr1qkJSUyrKfT3DsxH3ci+ZkwtjmGBjosXrDeY6euo+FuTG9u1alfNk8HDjhwf4T94iOTcLN2YbWDUvi4mzDA59gLt95hqdPEIoCFmZGuDpZ4+zwcrTNyEgfDaBRNKj+to+VgoKeSgeNRiEuPpmgsBgCQ2J4HhRFWroaEyN9yhd3o1LJPDjZWXDl5lMOnb5PQmIqhfI50rZRaUq7u7Bh6xUOnfDAwsyYb7pUoUWjkly45MXCJUdIT9cwbHA9GjUoTnRUAlMn7cTzQSDf9KlB1+5VUalUXDjziB8n78Q1jz0/Lu2KVcYCyDcueTFt2CYKFnNm9ooerxWvmxeeMOXb9VSqU4SJS7q8dYT49oUnTOy5mgbtyzNizrvPU1szcw87V55k/q7hFKuYvZdLOr75EgsH/07zvrUZPK+LtuOILOzbChOwcbRi9v4xH3wMKW0fUNou7r3BjE5LWXRqMu6V/3n/PvH1Sk9LZ1L7pTy44s28/aMpUv6fNz/PDjyvP+W7Votp3a82/ae929VPiqIwrd9abl14wuIdQ8lfzOWNxyQmpPBd11WEB0ezeMsgXHL//3IQvt4hjO69FnMLIxas7YNtxh6WF848YvakHbjldXhVQPx8w5g0fjvh4XF8P7YZdeq588AzkNlzDxAcEkP3LlXo2L4CW/fcYPPOa6jVGtq1LEvj+sXZsOsKx849BKBquXw0ru2Ob1AkO47dISwyHpUK3PM7UaG4GxYWxgRFxOEXHIlfUCQvwmLffaTNQA83Jxvccljj5mSNpakxz56Hc/nOM0Ii4gAoVdiZtg1KExudyK4jd/ANiMDKwphv2lemWAEnVq07x617z3F1sWFwn9rkdbXjx/kHuXP3OTVrFGLUsIYYGeqzcP5BTh5/QJ167owe0xQDQz1uXPFm2tiXRXfOsm7YZXw+zx9/wI9jt1GqYl6mLe36amFigN1/XOTXOQfp/G1tegyr/9aPa92Cw2z95SRjl3SlVot3m6eWnJjCt3VmY2Coz/JjY7Plbgl/tXrydnb+fIyhi7rR9Jua2o4jsqjlI9Zx4s+L7Az68GXCpLR9QGlbNXYT+1edYFfIqmz/w0Z8Gj+P2cT+NacZ/Usv6nWqou04HyUtNZ2hjeaRFJ/MytMT/3Eh3L/bvfYcv87ax7dTWtLymzfXo9NoNMwa9idXzz5m5qqelPnLxQkv/CP5rtcadFQqFq7rS46MeVWnjnowb8YeChXJyQ+Lu2JmbsSN60+ZMXU3hoZ6zPihHYWL5OTPzZf5/Y8LONhbMGFcM8zNjZg+fz9PfcOpXa0QfbpV4/wNH37fdon0dA1tGpeiZqWCnLnhxd5THiQmpVK+mCu1KxYEXRU3H/pz8e4zEpJTMdTXxdXJBldHK+ysTTE2NkBHRweFN/aLRwPo8PLq1rj4FILDY/ELjuJF2Ms9R3M5WlGzTD7y5bQjNCKWfac8CA6PI7ezDZ2blMXR2pzN+25w454feV3tGNGnDkmJqaxYewb/wCiaNyzBoN612Lv/Nr+tO4+NtSmTJ7agWFFnNm+8xNo1ZylcNCczf2iHtY3Zq1PKVtamzFveHUcnKwCO7rnF4ml7qFavKOPndni1HIiiKCydspujO28wbmEnav5t+zB4eVXqmM4rePYoiOX7R5Iz97utw3bjtCeTu62g66jGdPvu47f30Sa1WsO0zj9x68xDZu8aScmPXItLfJlOb73MnG9+YfmlmRQonfuDjiGl7QNK24ha09HR0WHRKdlvVLzpzM5rzOm3mraDG9BvZnttx/loB9af5+cJ25j6e38qNSj+Ts8JexFNv3pzKZmxEOvb5rHt+/MyK37Yz4DxTWnVveqr9ycnpTKi+69EhMWxYG0f3PK9vEr02iUvpny/heIlXZmxoDPGJgZcPP+YmdN245bbjpk/dsDOzpyly4+x78Ad6tYuyohhDbh26xnzlh3B0FCf8SMaY2Ssz4JfT+AbEEGVsnlp2bAkRy4+5PTVJwDUrliQQvkcOXfnKXe9AlEUsDY3plRhF0xNDQmLTSAwPIYX4bGkpavf63NpYWKIi70VTrYWmBsZEBQaw53HgaSrNZgaGVCrbH7y5rTl+IWHePmFYW1hTOt6JXF1tGb1pgsEh8XSsGZR+neuxu6Dt9m88xr58zowa3xLYmOTmTl7H2Hhccyc2poK5fNy/twj5szah4OjBQuXdMPG1oxHDwKZMOJPrGxMWfJrLywsX55y3rXhEr8uPEKX/jXpMajuq8xpqemM7/0bTx8FsWLv8LdemBAaGMWgJgspXNqNWev6vfPn48eBv3PlmAe/X56GjcPb953NLhJiExle/0cSYhL55dxUrLP5xyMy3//2IR20qActB7595Pq/ZFZpy76Xw72n9LR0fO76Uajc2xefFF+3IN8wlo3cQJHy+eg99eMWUcwKUpJS2frTMYqWz0vF+u++kOj6hYfRaBQGTWv91sIW4BvO2oVHKF+jEC27vT4SuXz2Afx8whj7Y7tXhc3HK5hZE3eQN58j0+d3wtjEgDu3fJk1fQ/5C+Zg4dJu2NqaMW/hIfYduEOXjpUYO7ox6zZfZPq8/eTNbc/SHzty4vIjhkzZSnJKGrNGNydffkfGLt7Hlbu+tGtUmv6dq/EwMIxl284TGhlH42pFqV+1MMaWRpy4683eSw8ICI3G2sKYUoVyUqaoCwXzOmBjZ4qhmd5bbvo457TEvWAOyrnnomBuB3T0VNx84s+eSw+48TSQooVz0rSmOxVKuHHi+hN+2n4e+xwWjPimNkXzO7F21xVWbLvA0D616dG2EicvPqLnqPU45bTix8mtCQ6Jod/IDUTFJrJ8STdcc9kwcepOLlx8QvUahZmzoDNhoXGMH7OF+PhkCrs7M2N+J0KCopk2ZiupqekAtO5WmfotSrN59TluXPJ69fXQN9Dj+7kdQKVi0cQdaDQa/s7B2Zquwxpw89xjbpx99M7fJz3HNCM9Tc225cfe+TlZlamFCRN/H0B8TCILB//+1s+T+LrZ57LFysGCJzefajvK11PafB8EkJqcJqVNvCE9LZ05fVej0lExdnXfL2Jrs92rTxMeFE3PMc3eeW25J/f8Obn7Jq16VX/rjgdqtYaF47ejb6DH8Bmvl7oT++9wYv8duvSrSbmM06XRUQlM+34rZmZGzFzUGRNTQ7yeBDNl4g5yOlsze25HjIz0mTVnP0eP36d3z+q0aV2W0VN2sH3vTVo3K83oIQ2ZMG8fx88/onubikwY1phfd15m3e4r1K5QgPbNynDsxhOWb7+AkYEeTWq6k4Ca/VcfcvK2N7aWJlQrnYdcLlb4Rkdzy/cFV7388fQPIUWdTg57CwrldqBQbsfXbgVz22NuZkREfCI3fQK45u3PPf9gYtJTKV7IiSolchMVn8i+y56cuONN3jz2NK1RlLtPXrBw0xliUlMZ3L0GRoZ6jFu0j5CYeH6e2YlC+RyZv+o4Z6978/O8LjjYmTNuxk72HL7DgjmdKJDfkakz93DytCfFS+Ri6sy2+D4LZ8rEHaSmpFOslCvfT27F/bv+/LzgMIqioFKpGDy+KW75HZg/cRcRobGvvi6OztYMGNeUe9eese/Py2/9ujfrXgUnN1vW/Lgf9TuOQObMY0+DTpU4+McFAp+GvtNzsrI8RV3oP6sDN07eZ/cvJ7QdR2QxKpWKQuXySmn7nP73yS4opU38zfof9vD41jNGLO2ZbfdX/KvI0Fi2LT9O5UYlKPEPi+H+naIorJ69H0tbUzoOrPPWx+xce55Hd/0ZPLnFq4sL4OUemctnH6B42dx0GVALeDkXbNaEHURFJTBtXkds7cwJDIhk/JgtmJoZMWd+J4yM9Jk6Yw9nzj5iYP/a1KpVmG+/28jDJ0FMHNWEKhXzM2jSZmLjk5g/oTUpipqhs7aTkJRC/05Vuf30BWv2XCFvTlu6Ny9PTFoq+y974mxvQZOqRcjtasMtvxecffAMQwM9Kri7UrxgThwczYlT0vCOiOSufxA3fV9w0zfwtdst3xd4vAjBPzYWlZEOuXPZUKaIC6ULOvMiMpazns8IjI2lUsncNKlShODIWPZdeUjhgjno3rQcIRGxLNt6HkcnK9o3Ks3RC56MWbSXVo1L8U27Shw8dZ+5q47zw6RW1KtZlN83XWTxyuPMmdWO4sVc+GHOfg4duUf5CnkZM7459+48Z/bMPajVGmrVd6dzz2oc3neb/TtfThMxMjZg4rwOJCelMm/iTtTq/x8tatCmLBVqFuL3RUcJeBb2xtdV30CPPmOb4fckhKPbrr3rtxndRzdF30CP32bteefnZGXNeteiSrPS/D5zF09u+2o7jshiCpbNi//jIBLjkrSa46spbY9vPsPcxgynPA7ajiKykJunHrB92VEa96xB9ZZltR0nU2yYf4C01HT6TGz5zs+5dOw+9689pfuIhpj+Zd2v/3n2JJgNP52gesNi1Gzy/5PaU1PSmD1mK4ZGeoyd3e7VRPgVi49y77YfI8c3p2CRnERGxDPu+y2o1Qpz5nfC3MKYiVN2cumKNyOGNqBc+TwMG7eZ1DQ1P83tTHRCMqN/2ImjnTnjhzZi/vpTbD54kyY1i1K+TB5W7LqEiZE+QzpVJzQpkXVHb2BspE/V0nl4EBjKgesP0SgKVYrnxiWnFQ9Dw7nq85yI+AQcrc0pW9CForkdsbYyQddQ542bvpEuLo5WlMznRPE8ThgZ6vM0NJKrT/0JS0mkWAEnyhR04ZF/CAduPESjD7XK5sPjaRDrjt+kWGFneresyK3HARy6+pC+Hatia2XKhCX7eR4ew4QhjXjyNITBU7bSoXU5vu1Vk9MXHjNn2VFmTGlN2TK5mb/oMLv33qRufXcGDa3HhfNPWLroCIqi0HNAbSpWLcCKxUe5e9MXgFx57Bk8vhl3rz9jy5qzr75GKpWK4TNaY2ikz4LxO946mlalYTGKlc/DH4uPkBD3lm293sLGwYKOQxtw+agHdy8+eefvtaxKpVIxcmlPrB0s+bHvryTEaveXs8haCpXNi6IoeGm50H81pc3r1jMKlsmTbbchEpkvLiqBBYPW4lY4JwOy8Z6Kf+X3JIijm6/Q/JsaOOd9tz9Q0lLT+W3OAVwLONKoY8U37tdoNCyeuBMzSyMGT2n52v9D65af5NmTEL6b0QY7x5ejbycO32P/zhu071qZuo2Kk5qazqTx24iKTGD23A645LJh2sw93Lrjx9jRTShbNjcjJmxFpaNi8Q8dOXj6Pst+P03Vcvno3aUqk5YdIDU1nTF963HL5wX7z9+ndZ0S2DtasHTXBVJS06lZLh/Po2O49NCX0gWdcS/gxOPwcM499kVPT4dieXJgamaEX3QMN5+/4MazAEIT4rGyNCavs+0bNzcnG3T0VfiER3L1WQD3XoQQlpRITgdL3HPnwD8ymgtefiTpqKlYzBVrcxNOefhgYW1MrTL5OH3Xm7XHbtCmfilyOVrzy86LuLra0rNVRU5efszWY7f5cXwrUGDQpM3ky+vAiG/rcfGqN7OXHGbGlNZUrVyAZT+f4Ojx+7RpV4Eu3apw6MAdtmy6jI6OinEz2uCcy4ZZE3cQFfFyW676LUpRu0kJ/lx1hsceAa++Tjb2Fgye0pLH9/zZs+HSG19jlUpFv4ktiIlIYNuKU+/8/daqby0cnK1ZM3MP2fGitr8ztzZl7K99CPELZ+X4LdqOI7KQgmVfnqV7ckO7p0i/itKWlpqOn2cA+Uq6aTuKyELWTN1BTEQ8Y1b1ydY7HvzVvrXn0DfUo+OwBu/8nJO7bxLkF0GfsU3fOp/v8qmHeD0IpM/oxlhmLO4K8OJ5BHs3X6FR67JUqP5y3cOY6ERWLjlK0eIu9M64kvH3NWd58jiY8ZNaUKSoMxs3X+bq9acMG1yfKpXzM27GTlBg6exObD90k11H7tCpRTka1SnG5GUHcXG0ok2j0izYdIaU1HRGdK3FGY+n3HwSQK1y+YhJT+HUPR/c8zji6GjB5af+BMfEUdDFHlMzA7zCI3kSGo6xiT421iaoDFWk60NQYgLekRH4Rke/cXsWHYVPVBRRaSloDMDQVA8HOzNSUXM3IIiwpCSc7C1wtrfkjl8Qj8LCKVnIGR0dFafu++DmYkPJ/E5sPH4TU0sjejQrz4lrTzhxy4sR39TGNzCSpRvOMG9CG1ycrBn7425yOFky4tu6XL7uw28bLzBtcktKlXRl8bKj+DwNpVffmtSqU4R1v53j0cMXmJoaMuXH9iTEJ7Ny6csLAlQqFUMmNMPS2pRfM0bl/qdm4xKUqVqAbWvOkpSxFddfFSyRi1otSrN3/XmiI95tb1ZDYwM6DW+It4c/D65rf75PZihWuSDthzfi+OZL3MlYB1AISztz7JxteOrxXKs5vorSFvAkiPQ0NXmK5dJ2FJFFeFx6wtGNF2g7uD75ir/bLgFZXXxMIid3XKNWq7JYvuN+immp6Wz5+QQFS+SifO0ib9yvKAqbfjlFTldbajct+dp9a5edQF9fj+6D/n8O3JrlJ0iIT2H4uGbo6upw6+Yztm+9SvOWZahavRA3bj5j/YYL1K/nTpNGxZkyZx/BIbHMmtiKQ2cesP+EB93bVKRIQScmLt1PPlc73Is48/OOC5Qr4kLjGkVZtP0cBvq65Mhhyal7Prg6WlG8gBPXfQNJTEvDytKYoPh4nkZEYm1pgpGpHglKOnHqVPSNdF+eEjXSQaMP6boQr6S9cUskHY0+aAzAxEwfSwtjFD0VEalJpOuBrY0Jii54BoURr07DxdGS+/7BBMbHUbVEHiLjErnxLJAyRV24/tifg9ceMbJbbRKTU/lp+3kGdKpKUFgsE5ftZ/LwJuTJZcvkBfsoVNCJdi3Ksn3fTQ4e92Dy+OaYmRoxbeYeEhNTGTGqMXb25syeuZekxFRc89jTsUdVTh+7z82rPgCYmhnRbWBtHtx+zuXTr18R2m1wXWKjEjm45epbvx+6DK1PWko6O1efeafvH4DabcpjZmnM/rVn//vB2USX0c3ImdeBZaM2kpqcpu04IovIWzwXz+77azXDV1HanmU047wlvoxfzuLjpKaksXTkBnK42dF1THNtx8k0x7ddJSUplea9arzzc07sukFIQBRdhzd469SBK6ce8vRREJ0H1n5tFM7zznMunHhAu55VsbU3B+DebT+OHrhDuy6VyJPPgfi4ZOb/eACXXDYMGFSXsLBYZs3Zj5urHSOG1GfxypPcvvec0UMb8DQgnA27rtK8XglcXW2Y8tNBiuZzJF9eB3advkerWsVI14W1h69TurAzsekphMcmUKm4G/cCQ/AOiSCfsy2hiYno6uvgZG9OImoC42KxsjRBZQjRaSlEpiah0ldhaW6EjqEKjb6CRu8fbvoKxib6mJoakqZSE5KUQDJqTM0N0NHXwT82Fh0jFXmcbQiJi0fRgzxONpx99IxUXQ3li+TiuncA+dzs0NVVsXD7GZrWKoaTnQUrdl2kT8cqhEcnMGbhXr4fWB9rS1PGzN5FyyalqFQuL0tXnuDp83CmTGzBi6Bo5i86jKmZIWMnNCfoRRSrVpwEoHPP6uR0seGn+YdJTXm5DEijVmVwzWvPb0uOkZ72/3PYipRypUzVAuz4/TzJialvfL1z5XOgZvPS7N9wkejwuHf6HjIyNqBBp8pcPHyX8KDod/7ey8oMjQ0YurAbL56GsnnhQW3HEVlEnuKuPH/0grSM5Xa04asobU/v+6NvoIdLgRzajiKygG1LDhPgFcyQBV2/mNOiGo2GA+vOU7R8XvK/44jyy1G2kxQqmYvytQq/cb+iKPz5llE2RVFYvego1nZmtO3xcq22tDQ1y+YexNHJiq59Xm4HtHzZMSIi4xk3sQV6ejpM/2Evqalqpk9pxcHjHhw8do9u7SthZm7MojUnqVwmD4UL5WDmiiOUKuxMTmdr9p27T9Pq7pzz9OXmkwDqVijAzaeBmJkYomeixxWv55TKlxO1joJvZDR2NqaEJCaALuSwMydFR0N4ciIW5sZo9BXiNWlEpCWh6IO5uSGKwcvRtLfd9Ix1MTHVJ0WlJjQlkTQdNSoDFUZG+gQlxqNjpCKXgxWh8fEkosbaygTPoDByOVphZ2HKFR9/Cua2xyc4nDRdhbKFXVh76Bp2DhbkymHNLzsu0rtdZeISkhm/eD/ff1sfjUZhzOxdDB9QFzdXW6bO2Ye1jSn9+9Tk7PnH7NxzkxIlXWnXsSIH9t3m2hUfDAz1GDamCS8CItm8/jwAunq69BnRgMDnERza+fpC5F0H1SEmMoED/zDa1nlIvZejbWvefeSsWc/qaNQKhzZefOfnZHWlaxahbsdKbF92BL9HL7QdR2QBeYvlQp2uxv+x9r4fvo7S5vEc1yLO6Onr/feDxRfN3yuYrYsPU6ttBcrVffdFZ7O6m2ce8sI37L1H2UID/3mU7eLxB/g8fEGnb18fZbt40pOH9/zpMbAOxhmld/vGSzz3DWfo940xMtLn3NlHnDh2n67dqlK4SE5WrTnDA88XfD+qEdGxSaxYe4ZqFfNTpVJ+pi7aT8E8DtSvWZS5a45TvpgbVnZmHLr4kBa1inHawwcdlYryxV05fseLgm72BCfEo6erws3Jhuu+gViYG5GqUpOsScfcwhD/+DiSlXRMTQ1IVNJI19VgbKqP2kAhSZVGlDoJlT6YmOqjMuSNm44hmJrqk6qjJiItkXQ9DWoDBQsLQ6LTk9HoKVhZGBMYH0u0OpUcduYEx8dhZm5AdHISj8PCKZ3fGa/gcKxtzFArCrf9XtC0alGuPvTD2NyQfM62LN9xgZ5tKpGcksbctSeYOLQxoZHxTFtykGljW6Cro8PkH/fSonlpqlUpwMpfT3P/QQC9etckdx57Fsw9QExMImUq5KVOw+Js/eMizzOW9ahQvSAlyuXmz1WnX7sitGhpN0pXyc/2NWdJiH/zStEPGW1zcrOjfF13Dm+8SGrKl3M6sd/MDpiYG7N05AZZdFeQJ2MqjTbntX0Vpc3vQQC53d/c9Fp8fdZM2Y6BkT4Dfuio7SiZ6sS2q1jamlG1ccn/fnCGfesvUqCYC+Vqvn2UbeuvZ8iV1546zUu99v4NK07jmteeBi1fbjIeE53Ilj8uUK12ESpUKUBampqVP58gX35HuvaoyuMnQezYdYNWLcpQtUoB5iw9TA5HS0YOqs+MpQexsTLhuwH1mLv2BEXzOZEvrz3Hrz6me9NynLv/DDNjA5xyWHLhgS9ViufmwYtQCjrbE69OIyQ2HlsbE17Ex5HL0Yro9BR09HXQNVQRnpKIgbEuGgOFaHUyOoYqVIag6Cskq9KJ1aSQrqsGfQX0eeOWrEonRpOMWl+DYqBgYKxDiiqdRFUaBiZ6JKMmUUnH3NyQyOQkdIx0MDc1JCotBRdHK276BZLfxY7E1FTSdDTkzWnH/uueNKvmzj2fIBxzWFIktwMrdl1kaI9ahEclsPPkXaYMb4KnVxAHTnoweXRTnvmFs2HbFcaOboK9nTkLlhxBV0+HcRNbEB2dyJZNLxfNHTC8AYZG+qxbdRrIuCJ0VCNiohLZv/X1UbWewxsQG53I0R1v3w6w85B6pCSlcWz79Xf+fmrWsxrR4XHcPPPlTN63sjOn7/R2eF715tzu9986UXxZXArkQN9AD98HAf/94E/kiy9tiXFJhL+IIlehnNqOIrTM49ITrh69R8eRjb+o/QVTU9K4fsqTyo1KoG/wbqPJvo+D8H0cRP125d86yvborj/eni9o2a3Kq7XXAK6df4KfTygdeld/Nfq2e+tVkpPS6Nm/FgDHjtwjNCSWPv1qoaurw4pfT2NlaULfXjXYuus6gUHRjPy2Hpv3XScwOJpxgxqybOPLU3GNahZl4+GbNK/uznXvQBKTU8mdy5bbTwOpUzY/5x/7Ui6/M88iotDRUxGnSUWjUrCyNOZ5dDTmZgZEpSZhZm6IWl8hVpOCgbEuaj0NaTpqlIy5ahp9BbW+hlQ9NWl6atL00l+7pWb8q854rEZPAT0VyTpqFH0FfSMdotOTwBB09FUkKmmYmRjhHx9H7hzWBETHYGZuyKOgMJzsLdDVVeEfE0Pp/DnZd+0BDSsV4tRtbyqWzIONhQkrd12iV9tKXL7zjMi4RFrUL8HWAzcxNTeiUR13tu6+TmR0It/2r42fXwSHjtwjfwFH6tR1Z/+eW0RFJWBtY0rL9hW4cOYRvhm7FBQompNyVfOzZ9OV10bAChV3wb2MG/s3X3nrCFKufA4UKePGmf233+2bEChVrRCmFsZcPurxzs/JDup1rkzeYi6s/2GPVucyCe3T1dPFKZ8jAU+CtJbhiy9tgV7BAOQq6KTlJEKbFEXht2k7sXWyokW/t6/4n13du+RFUkIKld9xU3iAM/vvoKOrQ/W/LJT7V/v+vIyJmeFro2wAO9ZfwD6HJbUavnythPhk9m6/RrXaRXDLY096uprNGy9RuEhOylfMy6Ur3ty950+P7lWJjU9mw7Yr1KxaEGMzQ7YduEmrBiXxfBbCnUeBfNO6Isu3n8c9ryNqXXjwLJjKpfJwwdOXCu6uHPfwpkLBXNx7EYKOgQ5RqSk421sSlpKEoguKgYpklZo0PQ1pKjX6RjokkQb6vLqwAAPAQAEDBR0DBY2+GpWB5q03RV+DjoHm1eMxALWeBo2eQqpKjUZfwdTUgFhNCiqjlyN7VhbG+MfEYGxmgI6eDgYmeni+CMXGyhRDfT0eh0WQN6ctJ+95U75oLtYcvEr3ZuWJjkvkxmN/KhR3Y9nGszSvXwI7azN+/PkIvbtWw8hQn6WrTlC9agGKuTvz+x8XSExMoWuPqqSmprMjYyStdceKGBnrs2X9/88ta/9NNaIjEzix/+5rX8vmXSsT7B/JjfNevE3N5qV59igIvyfB7/Q9pW+gR/m67lw9fv+1HRmyOx0dHXpNbkOQbxiH15/TdhyhZbkKOuH/f+ydd3hc1bW339Oma0a9N3dbltx7wTY2xpjee6hJCISSQrlAQigJgRSSECABAqGE3jFgMBjj3qssd6v3OiNNPe37Y0bCsuVg3w/si6zXz36sOWfvma3ZR3N+s9Zea/WJtu+Ozg2DfZa2E5tVH29m5/r9XHHnWb0m+KCTFZ9sweawMGrakCPqb5omSz7YyOipg4hPjjvkfEtjO8s/LeaUc8did379Xu3YWsm2DeWcd8VkZCVqZfvgrXX4O8JcdvU0ABZ9uo26Oi9XXj0NTTP4x9NfkpuTyJnzR/L3ZxcjCAI/vuokHnnyU1IS4zhlxjCefmMFM8YNZNH63ciSyPRxA/lwZQnTR/Xn8817KBqQzsrdFUwemsumyhosVpnWcIgEj52ytjaykz00hQIodokgKpJNiFrYrHIsEjQmvBQD0dopynREi4Ega4gWvceGoiFZTIQDhJ2p6AgWk4ikYcgmpmQSFjQUq4gmGwRMFV02sdkUmiNBFKuEYpPZXd9EXJwVp81CdXs7cU4rexuayU7z8NQHq7jm7Ems3V7B0EHpWC0yf3j+C35+/WxKK5v5eEkx110xjfWby/lq5R5+8qOTaW318+rra8jJTWLmyQW8/94GvG0BPPEOzjhvHEsWFVNd2QLAiHH9GFSQydsvrugmpqbMLiAxJY4PX+m5JulJ80ciisJRWdsmzy3C19LB9rX7jnjM94FxcwoZMW0Ir/xxAYEjrBjRR+8kZ0gmtfsb0NTjY3Xt/aJtTx2iKJBxhNnh++h96JrO8w+8Q86gdOZeNuV4T+dbJRyMsOzDTUw6dQQWm3JEY3ZuKqe+qpWZZ43u8fzCt9ahaTpnXDqp2/G3XliBy21n3nnRcl/BYIS3X13NxKmDGDgkA03T+c9LKxk8JIMJEwfw/oJNVFW3csOPTmb95nKWr97LVZdM5vMVuyitbObma2bx6L8+xxNnJzHFxc6yBi6bP45/friawv7prNhVxsDsZLZW1TGqfybryqqw2RRawyHiPXbawiES3HaqO7yINgFV1DFkE4tFQpMMNFkHi4mhRAUXso6kGIiKjmzRES0akkVDseg9NknRkC06kkVHVKJjkXVEi4ku6UhWAT8RTNlEE01kW/SxxS5T628nPdFFaySMxSYjWgX2N7VitcsokoSpCATDKigCumGwaONuZowdwIufrOeyM8exY18dO8rrmTNtKC++vYaRI3IZ2D+VJ55dTH5+MrNnFfDG2+uob/Bx+ZVTCYdU3nwjam274LLJSLLI6y9GrW2CIHDh1dOormhm1ZKv87YpFpn5F01g/bLdVJc1HXIdJKTEMWrqIJZ8sOmIqx2Mnz0cu9PKF28deQ3T7wOCIHDdfefT1tjOO09+dryn08dxJHtwBrqmU9tDHd9jQa8XbVW7a0nLT8FiPbIbWh+9jy9eX03lnjqu/tW5PWb8/z6zZlExfl+QUy+Z9M2dY3y1YAsWq8zkUw6NnjUMg4/fWMvYaYPIzk/uOl5X3crKxTs446LxXRGjn364GZ83yKUxK9uSxTuoq23jB1dPIxRSefHlFYwdnceEcf34+7OLyc1K5KSpg3nhrVXMmjyY3RUN7K9q5pIzxvLWF1s4c/pwXl+yhdQEF2UtraQnxFHe2ka/tES2VdcR57LREg6RGO/AFwkjWgXCgk5EMlBsEiE0JIuAKhoIiokqaQiKgShHRZeoaEhKVJBZFB1F1rAqPTeLoiFLKhZFQ4mJPEFRo+LNYiDEhKAq6Sh2iRAqikXClE0igoZsF6nzd5DkcdAaCeF0WBEUgepWH3FxVlr9ATIz4qlobGVgfgp7qptwxtlIiXfywfLtzJ06jBfeW8NZc0dgsyk8/vyX/OyGOTQ2d/Dq22v5YSytyr9fWk5efjIzZxXw/jsb6OgIkZjkYv5ZY1j08RaaY9GfU2cXkJGTyDsvdk/JcdpF45FkkY8PUyh+5lmjqatsYffWI0soandaOemsMSz9YCOh4KF54L7PDBnbj2lnjuHtJz7D13JkFSP66H10brU6Xmk/er1oqy1tIHNA2vGeRh/HCcMweOvxTxlQlMOU03u2LH2fWbOoGHeii6LJg454zOaVuymaOABnnO2Qc/t21NJc72PWGaO6HV/xRQmmaTLv3LFdx776fDv9B6VRUBTNC/fpwq1kZMYzcfJAlizdSXt7iB9cMZUNW8qprG7lmsun8u6nm9F1g6svmMQbn27i5ImDWVlcRqLHQZzHTpPXz6D8FAIhlZQUF6IgEDZ1XA4rTYEAAzISaQoE8MTZkGQRrxYiPs5G2NSQFAGLVSIsqig2AVPSsFhMkHUURUeSNaSYELNZdBQ5jN0awW45tDksEWzWCBaLitUSFXKyrCErGhargSDr2KwgKAayBQSLSdDU8DhthNCw2RQEq0Bj0E9eSjxt4RBOu4U4t42ypjbGDc5lV00jM0cNZOO+amaPHcSCVSVcPn8clfVtFAzOwGpVeG/xNn5w/kTWby1HscpMmTCABZ9uISnRyby5hSz+cgcdHSHOu3A8wWCE5Ut3AXDG+ePQdYMVMcuaJImcevZoSrZU0tzg61rDxBQ3oyYNYM2S7pUTOpkwqwCATct73vfWE9PPGE0oEGHbqiMf833hirvOItgR5sN/LTneU+njOJEZ89rVlTYcl9fv9aKtrqyR9PyU4z2NPo4Taz/bRsXuWs7/ac+5yL7PGIbBhq92MHbm0G4Rnv8Nb4uf8t31FE3o3+P59cuiN/2xU7uLwFVLdtJ/cDrpWQkANDe1U7Ktkmmx0ld1tW1s3ljGnLmFCILAR59sITcnkaLCbD5YuIV4j4PRI3L58PNtzJoyhGWbSwkEI0wanc/6kkrOnlHE64s3M21EPl9t28/UonzW76umID+NimYvmmiQGu9iT3MLWUlumkMB2o0IbpcVvx7BkEwsNgk/YQTFwGIBJB2L1USQo0LNatGwxUSZyxrBZgnhVCLEWQ5tLksEpyWCVQ7jtKjYLCoWJYLNoiFJUbepIEeteKYUdZkask67HsHjtNGmBrFYJKwOmdK2VtxOGygCTR1+stM8rNpbTr+0RDaV15Ia72J/UytxditLtuxjSF4qr322kbNnFfHFql2MLcrDYbfw2gfrOWveSFraAixfs5fTTxtJJKKxaHEJQ4dlkp2TyKefbAUgNz+Z7LykLtEGMGlmdK1Wf7Wr29qOmz6Y6rImamN74A7Ek+gkb3AaxUdRV7Ro0kCsNqVXpf7oJH9YFuNPKeKDZxYT7mWWxD6OjLhEF444G3Vlfe7Rbx2/L0h7SwfpeX2i7UTl7b9/RkpWIiedM+54T+VbZ++2KrzNHYybWXDEY4rXRm++RRMH9Hh+/bLdDCrMIj7p69ql3lY/JZsrmHxA1YRVS3dhmjA1luOtUyzMO20kpWWNbC+p4fTTRtLc4mflmr3Mmz2chV9tJxCMcM6pI3n94w1MHtWPRet2kxBnp7ypDQQTbzhMnN3CzvomMhPdrC+tJivVjT+i0qFHSHE7qWz3YirgcCiEDA1VMLDaJAJmGEE2kGQdQdaRFR1ZilrJbBYVuxLBrkRwKhFciopLieCxREi06j00jTgljNMSJM76tYCzKypWRcUiayBGsFlNdDGCrBiIFhNN0ujQw7idNtr1MBFTx+G04NPCtAaD5KUnUNHqxWm3EDF1Gtv9DM5PZW9NE5OK8li7s5Ipo/tR3eglLc2NLIu8vWgzZ84uYvGKneTnJpOW4uaDhVsYPCidQQPT+OjjaFTovPkj2ba1ksqKZgRBYNrMoWzZVIbPGwAgb0AKGTmJrDpITI2bHg1g2bB8d4/XRNGEAZRsKOtWDuu/YbEpFE0ZxPrFJUfU//vGBTefirepnS9eX328p9LHcUAQBNLyU6gr7xNt3zp1ZVHzZZ+l7cRk14ZStq3czbk/mdMrq2GsX1yCIAiM6aEE1eFYt2QHDpeNwSMOLXXV3hZg55ZKxk0f3O34mqW7MQyTSbO+fp0VX+0kKyeR/P4p6LrBwk+2MmZcP9LSPXz8yVZkWWTunELe/2Qzhmky/5Qi3vxoI6OGZ7N9fx1t7UFmTBjE6m3lzJ44hEXrdzN91AC2lNZSODCD6hYfumgS57RS2eYjNdFF2NBpCHZgtcvIFpGAHiEsaNjsEgEzArKBpBhYrCamGInuW1Ni7k5FjYo1SwS3JYJLCeJWQngsYZxyxyHNJQfwWEK4lTDumMBzKGGclqjws1tUZCWCVTER5ajVTVYMJMVElXQCRgSH3YIq6rRrYURFIM5lZV9zK+kJLnQJKlq8DMlOYcXOMgbnJLN2bxU5qfF8vnEPA3OSefOLLZw+s5CPlm5nRsz9/c7CTZx56gg2bC6nrLKZ008byb79DezeU8fcU4sQJYGFMRE3beYwDN1kdcy1KQgCk2cOZcvaUgL+cNdaZuUlkZ6TyLplPYu20dMGE/SHj8raNm5WAdWljdQcJ2vEd8mIqYMZNCqPt5/8rK9KwglKRn5qn6Xtu6A+9qb2ibYTk7f+/ilOt515V04/3lP5Tlj/ZQmDRuYQn3Ro2o6eMAyDtYt3MG7GkK6UHQeycdVeDMNk/PTuqUNWL9lJSrqHgUOjG3DbfUE2ry9j2syhCILAxg1lNDb4OG1+1F332efFTJ0yCLvDwgcLtzB5/AB2lzbQ0NTO+fNG88qC9YwvzOWrzftwO61sr6wn0W1nR3UD2Ske1uytpF96AjVt7aiCQVqCi0qvDxQBm0MhjEbQUBFkAbtdjgk2HVExsCgmimQgSSo2SwSbouJUVFxKGJcSJk4J41YiOOUgcUqIODmESw720AK4lQhxcginHBV4cUqYOEXFqYRxKBHsiooih1FkDVHSEGUd2RIVbhFRI2xq2K0KslXAb6i0RUIkuu00hvwEIhGyUtzsqW/CYpEQLRLN7QEG5adQVtfKsAHpVNS1kpediAAsXLGTmZMH88HnW5k9YxgWReLtDzcw++QCrFaZBR9vITHJxaTJg/js021oms6goRmkpLlZcYBlbfLMoaiqzoaVe7uOCYLA+OmD2bJmX48lqMZMG4RikVm7+MjdneNirtje6CIVBIELfnoq1XvrWf3Jlm8e0EevIz0/hbqyxiOOqv426d2iraIZgNTc5G/o2Udvo7mujRULNnHaVSfh6GHD/fedSEhl1+ZyRh9hbjaAyr0NtDa1M/aknsds31CG3WllcGFW1zHTNNmyrpRxUwd17QncsrEcXTeYNC1qkVu+dCcOp5Up0wazdVslvvYQp55SxPrNZbR5A5wzfzSfLS0hI9WNhkmLN8CZs4tYvnk/M8cPori0jmmjBlDV5KV/dhKaaVDV5mNQVhL+SARvJBS1TmHQoUVABrfDisUiETAiIBnIionDKmBVQI5FhdplgzjFwC5rUeEmR3DKYTyKHvtfJU4O4FGCPbZ4OYJLDuOUw7gVDaccwSVHiLMY2GQNu6zjsBjYFR1Z0jFFHUkGm1XEYhVQRQ2/EUGSRBLibEgWkaZgAEmUyEtPpMrrw2G3kJnsYXtlPZOG5bJqZzkj+mewcW81OWnxLNm4j1OnDeOTZds5a+5I/IEIxXtqmTltCIuX7sRmU5g2ZTDLV+zBNE3mnlpEa4uf7cVVCILApGmD2bS+tCs/W8HIHJwuG5vXdreajZo0kHBQZd+OQ5OG2hxWCif0Z/PKIw8syOqfSmp2IsWr935z5+8h084aQ2p2IgueW3K8p9LHcSA1N5lwIIKv+dhHEfdq0dZc04JikfH0kEC0j97N4jfWYOgGp14x7XhP5TuhfHcthm4woOhQN+fh2Lu9GoAhI3N7PF+6u45+g9O6pUWpq27F3xFicMHXyal3FlchyyIDh0Qtb9u2VFI0IgeLRWbb9ipEUWBkUTZrN5RisyoUFWSyuaSKiaP6sXzjPuLj7LQHo+45UxSQRIFGXwfJbgfbKuoYmJlMWNNp8PvJT00goGrU+TtwOix4HDZ006QtEiJoqlgsIi6bjFUR0EwVQ4ggSSoOxSDOYiKJYRxyBKcUwSmrOKWoEHPLIdxSgHg5gEfqubllP245iEeO4JBCOOUIdimEXQrhsRhYpQiSEMFlAbtiYJMFDEElZEYwBB2bVcJlt4AELeEgIUPDZbcSH2ejtLkFSRLISIqjtLEFWRKx2xX8oQj9c5KoaGhj9NBsNu+uZvKofoTCGsGwistpZeO2CqZMGEiHP8zO3bWMHpVLmzdAVXUrI0fnIgiwLZaiY1hhNqGgSvn+qNdBkiX6D0ln367u4mzAsIyua6AnBo/IoXxP/VEVgx9QmM3+kuoj7v99QpIlTrl0CpuW7KCx6tAAjj56N8mZ0YCspppjv/a9W7TVtpGYEd/rogb7+O+YpsmiV1cwbPwAcgalH+/pfCd03gz7F2R9Q8+v2bOtCqtdIXvAoYmmTdOkbHc9+Qe9X/t2RW/i/Yd8XQaueEsFg4dlYrUptLb6qahopii2R25bcTUD+qficFhZu7GU0SNy2VfeRDCkMmp4Nqs2lzJ1TH++2rCPzBQPm/ZUM2JgBmt2VjC8fwZN7QFUwyDF46A1EKIlFCQt3oUgCjQFA/iNME6bgsOmICugoxE0wqioKJKJTdawyTpxiokkhLDLYVxSJGYlC0fdoZIfjxwgXg4SLwVIkA9t8XKA+E5RJweIkwK45TBOOSrabFIIt8XEIkWQxDCKrCLLEeyKgNMqIskQNlU69DABQ8WiSCS47JiSSU17OwYmOcnxVLR6iegGg7OTWb+/mhSPk5pWH4IASAK6bhCIqDhsCis27Wf08Bw2bCtn3Kg8RFFgzYZSCodnxd77KuLi7PTrn8q2LVHRVhgT6MVbKrrWb8CQdEp313erjpCaGY/daaXsMKJtUGE2hm5QuvPIy/f0L8iien8joUD4mzt/D5lz6RRM0+SLN3quKNFH7yUpJtqaa1qP+Wv3atHWVNNKcmbi8Z5GH8eY3RvLqNhV2+uqHxxIaUk1NoeFjPwjd/3vLa5iQEFWj+lBmht8dPiC5A/untNw385aREkkf2BU6IVCKrtKaiganQd8bdEZMSIHTdPZsaOGwuHZVNW0UlPnZcKYfDZsiwoGi1Wh3R9mdEEOa0sqGFeQQ3l9K0nxLjTDwBsKkeiys7e+GatNId5loyUYFW4JcXYcNgUNE58WJmBG0AQdSTaxWwXsCrF8ajoORUcUQtjkMC5JxRkTa3FSEI8cwC0F8EhRwRYv+fGIgUNavBjAI/mJlwK4pSBuOUC8HCJOCuGKWdvsUog4i4EiRbBIGrKkYQgRVDOCKBk4rBJWq4jNKqELBi3hAD41jM0qkxrvoqajHX9EJdnjJKzreAMhhuansn53FcPyUtleXk9aYhxfbtjLxBH5LN+wj7GFOdQ2+PB1hBg2OIN1m8rIzUnC7bazbXsVAEUjcti+vQpN00nL8JCS5mbbpvKuNR0wNINwSKUmtn0Eovu08gelUbanvsdrZ2DMZb5nW9URX2/9CrKiXwaOQuh9n8jIT6Fo6mA+e2Xlcdnb1MfxIykjJtpq2475a/dq0dZc09qliPs4cVj06kqsdgsnndv70nx0sr+kmvyhmYjikf0JG4bBvpJqBgzv2TJXtjt6s84f3N3Stn9XLTn5yVhjJbJ2FFeh6wZFo6IWnG1bKrBaZQYNyWDf/gZCYZWiwizWbiwFYMKYfmzYVsGgfqls3FGJRZEIRlR03UCxRiN6K5vbyE9LYFNpDf0ykjCBilYviiVqnQobGvWBDiJoWBQRm03CapGwKiKiZKKjgqgiixqKqGIRw1HBJkdwyOEud2icFMAjhWJizI9bDOAWgz2KNo8YwC1G3aTxkp94KYhHCuGWg8TJQVwxa5tDChMn69hkFWtsL50i65iCRsiMEDFVQqaGLpgoskSc3YrVKlPb0U5Q1Uh02xEVgT11zaTFu2jyB9AMg5SkOHZXNjKhKI/V28oYV5RHU5ufhMRoKpaNxRVMGNOPnXtq8fqCFA7Porg4KqhGjMwlFFTZu6ceQRAoHJnLts0VXcJiQMxq2mlF7SR/UBplu+t6FCCpWQnExTvYt/3I3Z2dVuDe6iIFOOXSKdTsb6BkTe+qtdrHfycxIx6IbsE61vRu0Vbb2uV77uPEQI1oLHl7LVPOGI3T7Tje0/nOKN1Rc1Su0ZqyZkKBCIMKs3s832lhyR/Y3dK2f3c9/Yd8LeS2b61EEOiqgrC9uIphBVkoikRx7IZeODybDZvLyUz3kJoSR/GuGsYU5rByUynjhueyfMt+slM9lJTXMyQ3hR2VDWSmejBMk8YOP2mJLkQR6jv8hE2N1HgXFouEahoETY2QoRFBRRVUDFFDknQssoZF1qLuUUnDIak4pGjwQZwcIk4M4RRDuKUgcWIYpxjGI0VwiSFcYrjH5hYDuIRwrE8IjxTCKYZxSVEh6JIi2KUIDlnFKes4ZB2bbGBTDKyyid0iYLOIKBYBQQZV0PFpUcuhJImkxjvRMKnzdWAK0C8jkeKKevqlJ1LXFi0/5XRY0HQDUwBRENhf1URSgpONxZVMGJOPacLGrRUUDc+mqrqVtrbA167qmBW0aHQeLc0d1FZHXTm5/VOQZYn9B+1ryx+cTrs3SGus9NWBCILAwOFZ7N1+5Ja2tJxE7C4bZTt6r2ibftZYbE4rn7+28nhPpY9jiGKRiU9101jd5x791ggFwoT8YeJTPcd7Kn0cQ7at3E2HN9Ark+l2EugI0dEWOCrXaEPswyUjN6nH880NPuxOK3HxXwtdXTdobvB1VUEAqKlqITnVjSsWkVtV1UpebB41tW04HRZSkuMor2pm0IA06hp9qJpOfnYSVfWtFAzMYFd5IyMHZbG3uomUmOUopGnkJMdT1tiKIkukeqLHOyIRApqK22YlzmbFabFgU2QUSUAWQRZNZBEUEawi2CRwyOCQBayigUVQsQgRrEIYuxgkUUlEEUIkK4lYCJIgW4mTIj22eMWDQwzjlt04RRObKOORDByiiU3UUUQVSVARBBVJ0BAFHVHQQdAxBB3V1IgYGpqho2NgYIIAsiyS5onDFMAbCgGQ7HYQ0aLJa7NS3JTWtxDvsuEPq1gViaqGNrLT4ymtbmFAXgqVNS0M6JeKIEBFVTN5sXWtrWsjMclFnNtOTWzN8/rF1if2WFYkktPcNNZ9Xc4KovvaAJrqux/vJCM3iYaatv96nR2IKIrRMcfhxnassLtsTDiliNULt/TlbDvBSEj14G3s+W/lu6TXijZvY/TboifZ9Q09++hNrFm4FYtNYfSMYcd7Kt8ZLXVeABLTjvwLSXND5xh3j+fbmjuIT3R2O+ZrC2AYJgkHVEdorPOSGntdvz9MwB8mNTX6nI1N7SSnxGEYJnX1PjLSPFTH9nwoFhnThKQEJ81eP6lJcYQiGsRihGpbfaTFR1+/LRRCkkU8zmhhem84hFcNETY0TMFElgVsioRdkbHJEjYZLJKJLOpREUUEgQhWUccpGbhEAadkEifZUPUqUpQkDL2KeNmKRdBIto0jxTapW0u0DEM06oiX4xGNKuLkOBS8iASxCiGsgopDMnDJIi5ZwiZFBaNFNJFFE0k0EQUTQYw2URSQJBGLLBHvsKGaOo0dfkzAoojEOaxUNLchCgKmKBCKaKQlxVHZ2EZuRiKlNc1kp8VTXd9GZpqHqro2LIpEcqKL2jovKSnRCPmG2OdeamocjbEao53r1Ri7bgASkly0Nne3qMXHBHTbYdIYJKa58bX4USNaj+d7HJPuoaXe+80dv8dMOm0krQ0+9hywb7CP3o8nOQ5vD1bp75peK9p8zZ2ireebVB+9D9M0Wb1wM6NnDMPmsB7v6XxnNMdugklHIdpaG6J/D4mphxdtnoNEW6fFJfmAMY0NPlLTPV0/A6R0irbGdlKS42hu7UDVdDLT46msjVlZYuJMEKM/2O0WAIKRqPuzqsWHxSJjAu2hMAFVxWm1YLcqIEBE1wnpGgE9gl8L49fCBI0wEVNFR8VERRI1ZFFHEXUsgoYshGLNj0IQzFZSlER0vYp42YJVULHTjqGWYmgV3Zqpl+KWbEhmHfFKPKJRiVt24xA17KKGXYxa8ASCmGYAkQiSoCKLBlYJ7LKAQ5FxWhScFgWHRcZukbHIMgYmjQE/BiaCAPFOOwYmDT4/2cmernQocU4bVQ1t9MtIpLSmhay0eKrq28jJSKDDH6bNFyA9zUNtvZeUWFqjxtg3/5QUd9fPSSlxiKJAwwHiKSnVTeNBFrX4pOj6tzb1LNo6r7fWxiO/USWlebqu197K+DlFiJLIqoWbj/dU+jiGuJPiunTGsaTXira2mAJ2J/VZ2k4UynfUUF/RzMRTRx7vqXyn/G9EW3ODD4fLhi0mlno6n3SQFa7TMpMSE2mGYdJY7yM11q+hy5ITfVxf7yUt1U1NbFxGmoeKmhbiXDZafdH6l8GuPF/Rze7N7X5SE6JiIahqJMbZMYGWQJCQruN2WLFb5KjoE2MtZsESBRNJNJBFE2vM0mUVTSyigUM2ccZcmQ7RwCYaJEgWdL0ajyxjFXRsdBAnphBHKy6zrltzo2JHIU6yIBl1JCjxCEYlNkHDJkSwCSq2mIBzSAIWyYha+kQNk6iQjBgRwkaYkB4hqEfwaxE61DAtoQCaaYAACU47oiTS4g9G19TtpLYt+r7Kskh9awfZafHUNftITY4jEIyQELNIVtS0kpHmoabei9ttx2ZVqK//Wkg3xIS6LEskJsfRcIA7NDXDQ1O9r1vQQWLMWtdyGJdP5/nmhiN3CSWmeWhrbEfXjqxu6feRuAQnwycOZM3Crcd7Kn0cQzzJcV0641jyrYg2QRDmCYKwSxCEvYIg3NXDeasgCK/Hzq8RBCH/gHP/Ezu+SxCEU7+N+cDXlrb4lD5L24nC6k+jJWUmnjriOM/ku6XT3ZSYfuSiraUHUdaJaZo01XlJSY/vdrzhINHW1upHVXVS0g61tAWDEVrbAmRmJFBb3wZERVtlTSu5mQlUN3iJc1qpa2nHqkj4gmFESaC62YfNFhWSdW3tJLudIBATbgFCuobbZsOuKCiyhEUWscoSNlnCLkvYZAGLZMb2lEWtXYqgIhNEEUJYhQAWIYRNCCKYXjyyhF0wsdJOnJiEaAawxv0Mq/tX3ZpsOx0LAezYiBMtiEY9CYoHmxDEKoSxiRGsQgSrGIlZ8zSsoolNMmPzMRFFAwQTUzQwBBNTMKP/A4IAHqcNRZHoiETwhcIIAiiySF1bB/Eue9ceN5fLimmCEis9JivRj+3K6lYy0+Npam5H1XQyMjzU1LV1rUm7L0gwGAGiwvpAS1tKmptwSKXdG+w6ZrEqeBKdNNb2bBnrdMe3HIVoS0rzYBgmbYex3vUWJp46gtLtVdRXNn9z5z56BfEpcXS0+o/5F5L/b9EmCIIEPAGcBhQAlwqCUHBQt+uAVtM0BwKPAY/ExhYAlwDDgXnAk7Hn+/+ms7xEXILzG3r20VvYtKSEAUU5JMXCsXsr3hY/skXG4Try8lztbX7ch/lbUFWdYCCCJ+HgPW1+ADwJ0eAEb2v0cefeN2/shh8f76Aldi4x0UlrW9SqlpTgorG5g9SkOJrb/CTHu2hs7SA1MY6mNj/JbidhVUMQQJZEatp8WBSpS5yYRPe36RhYFAmLJKJIIrIkIIpgCga6qWGiIwoGkmAiCQY2ScQhKdglC3bRgi3W3EoGmBGsgoFDGYFg+rAn/CUq2lw/7NbsCX9Hts3DgoogCMRbR2MaDUiYKIKOjIYiaMiCjhz7XxRUQEMRwSaLKJKAJAgIAghCNAihs7ntNmyKTETXaQ+HMYGkOCdqLOFtkttBSI3uHZNjaV06bWKdxrGm1g6SEpyYJvh8IZISXbTG1iEhtma+zjVKdOKNrUv0savbmn593InvgH4H0nl9+A4a89+Ij+0p9h4HN9KxZMLc6BfFjV+WHOeZ9HGsiEuMWp7bj+Lv4dvg27C0TQD2mqa53zTNCPAacPZBfc4GXoj9/BYwW4iWKTgbeM00zbBpmqXA3tjz/X8TaI9+WDnc9m/j6fr4P46mauzcUMrwyYOO91S+c9Sw2pU37UjRNQNJ7vnP3YgJBVHqXjnEMKIb6DsrinSKBfGgCiMHVhwRxa9/FsTuxzr3s3X2P6Br13MKCN0+lDqFihAdeETVTQSi/UQEBEGMPgZEQUEQrICAKEZTm4hyz9eLIIiI8oDYzw4k8egs9kLnv8NMVxA45HxU3MV+Fg86Qde2wO7PKRz4fh/w80EvfMiaid3X9OvjIobRc6LYzuvDPMz5nlCs0ev0aIIXvo/kDE7HneiiZE3vrLXax6F0aotOrXGs+DZEWxZQecDjqtixHvuYpqkBXiDpCMf+rwj4gljtFmRF/jaero//4+wvriIciFA4ceDxnsp3jhrWUCxHd11HBdhh/txj9+BDBFGnH+9/SacgMA8wEQnQtY/KPKivgIBJd0HQaZw6ZK4xIXbkdPY2iH7smQc8Phx6bNyRpnI4eEZmDz/Fevakew5+Qw7ztN2G/i8z8Xcu68GJdAXh8M/Zef0Y+pGntui8Tnu7aBMEgYKJAyhZ2yfaThScsbRHAd/3T7QdEwRB+JEgCOsFQVjf2Nj4jf0D7cE+K9sJROc33IITQLRFwur/SrR1s94ceC52k/62avQebAgyu8TawZ0OfT1BOFTgfFuYgIlxkC3vvwgQ0+z8BTAPmKtpdp+3eYi0FL7xd/jG890EXNfT9vz4W0QQhK7r4WDEWPkz/agsbdHrNBLu3aINYPjEgVTva6DtOOTu6uPY8322tFUDOQc8zo4d67GPIAgy4AGaj3AsAKZpPm2a5jjTNMelpKR846QCviCOuD7RdqJQvHovqTlJJ0QFDDXyv7C06QaS1PNd3uwSbYce///VcV3ju/x+nf8dLHxir2X29ILC1yOEA7XKoX17lhMH9OsUYl2P/5vVKGqViwq9//b8h3u1I1GgB4jBg890f8sOcY8e+B4e7Tp1jj3EPSoIhzXe/a/co52WthNAtBVMiH5hLFnbV9LqRKBTX3wfLW3rgEGCIPQTBMFCNLDgg4P6fABcFfv5AmCxGb1TfABcEosu7QcMAtZ+C3Pqs7SdYOxct4/hEwcc72kcEzRVR7YcXbyOaZiHt6T9l3uwaR7qQjvYEhMVd9HnNozuP4MQPQbopoEoCOhGVKDpB7jZOseZmN0yy0efy8Q0O9vhp9s5LQMTw4w2M/oIExPTVDGJAAK6XgOAru08zHPp6NoeQMQ0g2hG94hKk4O8mQc8NmPviWmah7h7u37fHs4ZsTQgXefNr3/u9vsdIJoOXIsDxdTBa3akXtT/6h7tXNejcI9aThD3KMCgUXkoFrlPtJ0g2I+TaPv/3vBlmqYmCMJPgU8BCXjONM3tgiA8AKw3TfMD4F/AS4Ig7AVaiAo7Yv3eAEoADbjJNM1vJX42FIhgPUxOqj56F+2tfppq2xhQlHu8p3JMkGQJXT26PxO7y0rQH+75nNOCKInd0j8AuOMdGLqBvz2Ey23HE98ZRRqNLvR4oh9abW0BEmLnmpo7SMuIpoZobukgJclFfZOP4cOzWLW5lOkTXDS0tJMS76LZ58fpUjCMqPjI8rgJRTQ03QQxKhLibFYEBEKahmrqCFK02gCSiWgKSMgIGBimioGIYYqEdYOAoKIIESy6ikIEKxF8ajUe2UXACGMYJchiEqG2O1EDbyJZJnb73Q11G3p4CWHsICi0hTeCkIaBFw0JHRnNlFFNCd2UMUwJ05QxkVF1k7BuoBomugmmIUQtiJ3KzgRfKIwkCzhFCx6bjfZIiOb2IINTRQQBmr1+krOi72mnuO3cB9cpilOTXNRUtyGKAh63ncbmdnKyEgFoja2Ru3ONWv1d69X5OLrG3b/Y+toC5A5I7fE6CXRErx9H3JFHLaux61RWvpWkAP+nsdgUcodkUN6La6328TWd+iIcUr+h57fLt7JL3zTNj4GPDzr26wN+DgEXHmbsb4HffhvzOBA1rGI/ipQIfXx/qYgVvs4ZknGcZ3JssDuthGL5t44Ud4KT8j11PZ4TRZGEJBctB2W678zH1tTgw+W2E5/oRJLErnxfXZUQGnykpXlITHRSU9PKqNFR8Vxb7yU3M5GPvyzm1JOHEwyrpCbGoekGTpuCaUJmsodgrAJAWnwcu+oawYxGliY67CAINAcChEUtWrtTM9EEHU3U0QUdQzARRLBIMrppoJs6qqmjI6CZJhETIqZJyDSxiS68Wgvxsg0EBxjNOKX+EFmNHll90LuiEMJKGB2fHsIQ0mjTvAQNOyHTQtBQCBkWwoYF1bQQMUTChkBIF4gYIropYBgigikiImDGWmdkq2mCLxBGVkQcioLsEPBGgoRVjawED7V1XhRRQhQEvO1BJFEgHLNW6WpUxOVkJbJ+QxmpyW5EUaS21svE8f271iTObe+qPNHY4GPE6Lyu366pwYcki91Kl5mmSUtje1cS3YPpTA9yuNQxPRGKfVGwO3tvhZIDyRmc0WdpO0GwxCL41fCxFW3fm0CEo0UNq12bYPvo3VTsirq68k4Q0WZzWAgFjlK0xTtob+05/xZAYmrcIZnwk2PJeDvLWUmSSPIB5Y86a442xB6np3mob/CRmRYPQE1dG7lZiQRDKh5X1KJjlWMWl5grL9Fpp665HUkUsEkSvkAYAUhyOFAECW8gSETVoxYqI9ZMAdMQMGLCSDcFIrpASIOQLhA2RPwa+HUBvyEQMERChkibHkaUcmnTQkRMO0HTgV+vwGuq+LB2a14zQhjw6UF0IY02zYcmZBJGIWxaCJu26P+GQkAXiBgSmiFhGgoCChIWFMGCIihYxWi+OIdkwSVbSbI5sIgSmNAWCKFpOvH26BfMhtYO0uOjoklVdTKS3VTUtZKdFk9tow+3y0ZTS1Rc52YmUlPXRma6hzZvgEhEIy01KrQbGnykpkafR9cNmhp9XSK7c02TUtzdIorbvUE0VT+saGvvss45DnsdHUwoEBVtNseJ4fXIHZJBQ2UzwY7Q8Z5KH98xnelsIsfY0tZrRVskpGKxHl0uqz6+n1TsrsVqt5Cak3S8p3JMsNkthALhQ/Yt/TfcsaSpB+4XO5CEJBfelu5JIpM6LWkH1KhMTXf3aGkDSEmOo7GxnYR4BzarQk1tG7mZUXdd5z4sXTMQBOjwR0WnTVFo6QiSmxxPIKQiAAkOO3ZZxhcMEY5E3WsOWcEpW3DKVlyyFadkwy5asYgWZCwIKJgoGKaMakhopoKOAx0Hqukggh2TBJrUZkQpl1YtiIqDdtMGcgGSMrZbQx6CTw+gCWl4tXZUIY2gEcFvSAQMmYAhETJkVNOKgB3DVFANmbAhENRMAqpBUNMIqBodERV/WCUQVgmqKoZhkuJwRpPmmtDaEQQTshLd1La244x9bnnbg+SmxrO/upl+mUlUxsRbRU0rCR4HbpeN2novGenxNHYWio8JrsYGH6kxAdfS3IGhm12VLSBaiio5tbs487ZEE5InJH+DpS3xKCxtsS8XvbkW8IHkDskEoGpv/XGeSR/fNZ2Wtkifpe3bQQ1rWGwnxre7E52KXbXkDE4/fB6yXobVYUXXjKPa3O1OcHbtTzvc+YNFW0KsgHjnzRwgJdXTJeKcTitOl7WrBmlKSlyXeMhIj9bEzI5VpwiHIkiSSF1TO5nJHmqbfHhctq5N7WmeOGpavMiSSJzVQjii4w+pCAgk2x04ZQsSArpuEFZ1AqqKP6ISUDUCmkFIM4nELF6GqaCZMgENOjTo0MGvi3QYESQxKybccmjVAiBm0xbZRVNoebfWFtmJJqTRrvmJkELI0PEbCiYOVByoppWwIRPQwa/phAyBiCGgGgK6IWIYIkbMIogRdYcahommG7T6QwgmpDqd0QAN3aStI0h2YqzGq2bidlipafKRneKhqr6N/llJVNW1kpOeQE19G9np8QQ6S4ele2iM1UBMSflaSKfERFljTGSnHlDGrLW54xBx1rlX0Z3QsyXN979xjwY7RduJ8Vncae0vj1n/++i9yIqEIAjHPDK6197l1IiGdAJsfu0DakobyOqfdrynccxwxTaUdxym3FBPJMasYk01bT2fT46jtakD7YAAB4tVwZPgoP6AMZnZCTTWewnE9iplZSVQXtYUPZeZQCisUt/gIy87id376klOdGGzyuyvaKZfVhIle2sZkpfKpl1VDMxMpqbJFy1jJQg0eP30S0kkFNZo8sUEgtWKjEhbIERHOEIoohHRDHQdDEPAjLlINUMkogtd+8pCukDElKP7zUwLYdOKX1do07yEDSvNajNh00ZzpAavbu2x+TQ/7YZMwAjj03VUU6RNF+nQIaCLhAwJzZQxsGCYUSufaUqAiIAUc40qWEQZRZCQEBFNAdMwqfd2oGoGSU4HAtDWERVykihQVtdCXmoCgbCKVZbRDZOMJDd1Te30z0liX3kTOZkJ7NnfAEBedhIVFdGalxnpHpqbO2hvD5EZS39TXhpbn+xOq6dBY52X5APcpQBNMXF3OEtbY00bsiIR5znyqPxOl6rzBInkz+iXgiAI1MbWpo/eiyAIyIqEdowjo3utaMM0u5XU6aP30trgO6ri6d93UmI344bq1iMekzcoKmrL9/TstskZkIKm6dQeVPA6f2Aa+3d/HcBQMCIHwzApKa4CoLAohx0l1aiqTmFBtJhJ8fZqxo3Oo7GpncrqFkYWZLNhWzlTRvdj884qJhXl0dTmZ2BmEqU1LYzol0lpTTOKJOGxWWls8yMikBnnQjCg0etH1wysooxDUrAJCgoyEjKmLqFqIhFNIqzLhDSZoK4Q0BWCmkK7ZqFDt+LTrbQbNny6nXbDht+w4zOs+Aw7fsPSQ7PiNWz4jei4DsPW1bdDt9GhW/DrFkKx5lclAqpESJWIqBKqJhCMGAQjBuGIgRoxEA1wSBaS7VELW7MvgK7qZHncyKLA7qomRuZlUtPsI9nlQBCgrc2P3ap0Rahlp8bjbQ8ypjCXNRv2I4kCo0fksrW4krzcJNxuO9u2VETXZkQ0BWbx5go8CQ6ycqKira6qlWAgQr/B3b/oVOxrQBQFsvKTe7xGKvbUkzMgFUk+8i/DjTWt2F22E0a0yYqMJ9lFS733mzv38b1HEIWj2qbybdBrRZthmEefcbKP7x2B9hAhf5jE2Ob3E4G0mMWk8ShEW1a/FCRZpGx3zxGknWkeKvZ1txD0H5xO2d6GrrQTBYXZiKJA8eaoMCgamUM4rLFnVy39+6XgcFjYVlzJxDH9AFi7oZRxI/Ioq2phxKDMaI42A2wWmY5YCok0t4u6lg7G9s9iV1UjsiiSm+Ch3R/GFwjjVCykOlwIukAorBEKa0QiBroKoikjCxYwFDRdJqIrRHQLAVWhQ7cQ0Kz4tKhY8+l2vLoNr+6gTXfi1e20Gw68PTY7PsNJm+HAqztp0+14NRs+zY5Ps9Kh2QhqNkK6HW9EJKjLhHSJsCYR0UQMXcSCBQsyNkHBJsiYBviDEdr9IVLtLtxWC96OMP5ghMHpKbT5gzgUGZsiU1nbxoj+mazcWsb00f1ZtbmU7PR4auvaABg3Io+1G0oZPiwLh91C8fZqCodnA7BtayU2u8KgQenRx5vLKRyR25UqpFOE9x+c3m2tK/Y2kJGb1JVb7WDKdteRd9CYb6KhqoW07IRvrdrG94HENE+faDtBEAThqJJNfxv0WtEG///Z3Pv4v09LfRvAiWVpy4pa2uqrW454jGKRye6fQlksPcrB5PY/jGgbkk44pFITc785nFYGDE7/WrTFrDlbt1YiSSLDC7LYVlxFaoqbfrnJrNlQyriiaKoJry9IcryTNVvKmDaqP2u2lVGQn0Z1XRt2i4JFEPGHIgxKT6KtPYQ/pJIe58QhyTR5/YQjGjZJxqPYsAkKGCKhiEEgbBDRBDRNIaIphDQZw7TjVxX8WlS4dWg2AnocbZodr+7Aq9tp1R206DbadOd/aY6o2NOi//s0e1Sw6TbChh1vRCCsR19X02QwFBTBgmjKhCI64YhBKKRF96nJNhJtdnTNoL6tg0SbgwS7DW9HCEM3SPW42La3lolDc9lf28LAzCS8HSGmj+rP+uIKpo8dwIZtleRnJyEIsGd/AxPH9qO0rBG/P8yIoqho27qlguGF2UiySFODj7qaNgpHfZ3DcP/uOkRJJO+gfGwV+xrIG9hzjjZ/e4iG6lbyj1a0Vbd2WYZPFBLT4vtE24mCcGgi6++aXivaTBOEE2Rj+olM54djwkH7c3ozLo8DR5yNhqojF20AeYMzKD+Mpc3msJCWlUD53kMtbUA3F2nRqFx2xlyi8fFOcvOS2BpzyY0ozKa0rIn29hATx/Zja0kVGake4t12NmyrYPq4gazeUsbUkf1pbQ9SkJfGjooGphbks3lPNTnJ8eiqjtcfIt3twibINLcHsYoyaQ4XsiHRHggTCmugC9hEC3bBiqlL0ZQfqkhAlQhoIqZpx6/JMeEWdWf6NCsdugOv5sCrO2jXbbTp9h6bt0usOfBpNrxq1NUa1G1EDAfeiEBIkzENK6re+b+AP2wQihgoyDhFK27ZhmGYeP0hwmGNzDg3NlmmorGNtDgXLquFPTVNjMxNpyMUIcERdSWGQyo2i4yhRQMYpozqx5YdVYwbkce6jWUATBjTj20xV3XR8Gx8viCl+xsZMTIq0oq3VHatWSf7d9eTnZeE1fZ1dL0a0agubz5sYt2KWI6/vCFHb2lLjVmGTxQSUt19ou0EQRTFI6428q295rF9uWPHsVa/fRwfWmORjImpJ46lDSA1O5H6iuZv7ngA+YPTqatswX+Ysiu5A1IPcZ/m9I+6VfeUfB0NN6wwm0hYY3/sRj5iZC7FWyuJRDQKC6PWns1bKpg4th+aZrB+cxlji3JZt6WMqaP7EQyriGY071skGN2r5bJY8IdVBqUlsbe2BbfNgkuxUNHkJcFuI95qo8UXwB+KYJcUEix2JEMkGNLxhzVMQ8AiWBFMC6om0xER8WsimmGjQ4ta3Do0JWZ1i7pMvZqdNs1Fm+bssfk0J17Njk+z4NeizxPUbIT1qIUtqMkYppWgJhJURQKqiaFJWLFgERQ01cQfjBCKqHgUGy7FSiis0djWQV68B0kQqKhvJS8pHkxoavWT4nFSvK+Wgrw01m+vYEJhHkvX7yXBbUcN64QjGuNG5LJizV4SE5wM6p/Kps3lJCe5SE/3sHlTeXRNYhbQHcVVWKwy/WN7Gk3TZO+OmkNco1WljRi6cVjRtn9HLBfioCMXbYGOEO1tgRNOtCWme2ht8B02vU4fvQdBAPMYr3OvFW2iKB5Vjbw+vp90Ju90uE+s6hf5QzPZt/3oyuUMH5cPwNY1PWdsLxidR/neBlqbvq6MYLHIFIzMZf3KvV3HRo7NRxQFVi/fDcD0k4YSCERYsXw3hQVZJCQ4WbhoGyMKc0hNjuO9jzdz6owCWtoC+HxBslI9vPHJRk6ZMJgv1u5m4rBcPl+3myHZKRTvq8Vts5Jgt7O/toVEhx3JFGj0+qN52iQL4bCGNxBCMMAhWjA1kYgqEAwZqDoYhkJEkwlGJPyqSFCT6dAUfKoFv27Fp8r4NSvtmhWf5sCr2XpodlpVJdpPjVrp/Jo19jwSAU0mrClRsRYR0TQJUxcxdIGwahIJGwiqgENSotGvHSGCgQiJVjs2WWZPTTMZcXFgwr6aJsb0y2Tr/lrGDMhmf00LQ7KTaWzzM6Uwn6/W7eHMWUW8/ckm4t128jITWbFmL6fMGIbPF2TVmn1MnzYEQRBYtHAbiYlOhg3PwjRNVi/fzcgx+cix4IHyfQ001fsYOb5ft7XfvGZ/1zXQE1tW7SUpzU16zpELsH0xC2D+0MwjHtMbsMdS2WiRb6UiYx//h9E146gCc74Neq1okxUJXe39RYpPdDqj6k60nHyDR+TQXNd2VG6YYWPysTksbFy2u8fzY6YOBGDz6u6ibtLMIZTtqacuFvgQn+CkcGQuK77aBcDosfmkpXv4ZMFmZFnitLlFrF6zj7Y2P+eePppNWytISYgjPzuR1z/cwFXnTGRnaT2jB2URUXUy4uMIazoZnjiafQFG5WVQ2eglPzmeSEijxRekX0I8wUAEPazjFC1YkVHDBlrEwIEFUxXRNBE1LKLrAhFVIqRaCKoKAdVCh2qhPWLBF7HiU610aHbaVRveiJWgHndIC2hOfKoVn2qjXbXhi1jxq1Y6VAt+NRroEFQVNNVKWJUwdAlTk9A1CSMiIKgiTslKJKITDunYkEm2O2nrCGEXZJKdDmqafOQkeJBFiZaWANnJHjaUVFDYL521W8sZ3j+dzSWV2CwKU0bms3pTKRfMH8MnnxdjAuedOYbPPt+OquqcMX8kTU3trFmzl7mnjUCWJUr3NlBb3crUGUO71nL1kp0ATDhpSLc13rRyL1n5yaRlHbr/TNcNNq3Yw5hpg48qoGD35qjVb/DIE6MmcCdWW2dNyqOrWtLH9w9N1Y95arHeK9osMmrfN51ej9op2k6w6heDRkUtIrtje8mOBMUiM2LSADYs29Xj+QHDMonz2Nl4gFUNYNJJ0Zv+mqVfj5s6cyhl+xqormhGFAXmnTaCjRvKqK1tY/5pIzAMk4WfbuOMU0dgUSQWfLqFS84az96yRlI8LtKT3Sz4sphTJg5h0aqdnD2lgOWbS5lakM/6nRUMzkimoyOMoRlke9xUNLSR7HTikqwEAyqiIeCQLBgRE0MzsR8g3CIREQyFsCqgqhaCEYVgxEKHqhBQrbSrUetZVJQptEWseA9qbTHB5lfteCMKHaqVgGbDH7EQUhVCEYWIKqPqEroaFWxGl2ATiFfsdATDCKqAS7RgRaLFG2BwchKt7UGCgQiD0pLYV9vCpIE5VDa2MSwrlRZfkAmDc6hrbues6YV8sWo3588dxUeLt2O1yJw+u5CPFm1jyoQBpKW4+eiTLQwbmkH/fil8tnAbhm4yb/5IAFZ8tRNBgMnTB3et2+qluxg8PIukA0pVRSIaW9ftZ8yUgT1eF3u2VdLhDTLmIKH3TezeUkFqVgLxh8n71lux2KLRt8e6vFEfxxbTNNE1HblPtH079FnaTgw6S4h0flCeKAyMpd44GtEGMPakIdSWN1NXeeh+OEkSGT15IBtX7Om2JzQrL4ns/GTWfPW1aJsSu4Gv+CpquZl72ggEAT79eAtZmQmMHpXHR59sxeW0MWv6UD77soRp4weQFO/kjY828IOzJ1Cyr44JBTmEVQ2rKBHnsNLRHkZEJNnuoM0fpCg7nZpGH6kuJ1pIIxCKkB3nQQ3qhEMaHsWGGtIRNLCbSlS4RUQk3YKqSlFXqSoTilhQVRshzUIgYsEXthCI2PCpVtrCMq0HNW9YoT1mXWuPRC1roZh1LRwTbKauEA4LiLrcJdjMCCQo9mj6DiHmzg1pCBrkxLvZW9NMlscNBnR0hOmXmsCGnVWMGZjF0k37mDdhCJ+t2klBvzSKd1WjKBKnTh3GZ0tLOP3kQrYWV9HmDXD2aaMoLqmmvKKZM+aPwjRNPv14CyNG5ZId20O2YslOho/IISHJBUBLUzu7tlUzcUZ38bVzcwXhoMqYKYN6vGY2rdgDwKjDnD8cu7dUMGhkz+7W3kyn1f9YFxLv49iia1GjUJ9o+5aQFKlbdvc+eifhUARRFI75voLjjc1hJXdIBnu2lB/VuMLx/QEo2dDzuDFTB9HS2E75QbUTJ80Ywtb1ZV1lsNIy4hk4JKNLtKWleRgzth+fL9qOaZqcMX8kdfVe1m8s5azTRhIIRli6cg8XnD6GtZvLGJKfSnK8k0+X7mDuxKF88FUxV84dy7Z9tcwoGsDanRXMGNafzfurGZaZQtAfIRjRyHF7qGnxkR3nwWJItHWESLA6CIU0REPAFhNuuiZgqFErmKpKaLpMSJVQVSvBiII/ohBSrfgjUddpTy0QE2vBiEIwbCGiWglHZHRdQVWlqDCMCMimghkRMSKQZHHQ6g/iEixIhkDAHyHL5QYTWtoC5CZ4qG70MTY/iwZvB/mJ8YQiKjZBRhRFhmSlUNvk44LZo/h0xU7OmlXEoqU7MAyTi88cxwefbCEjzcO4Ufl89PEWHA4Ls2YMZcf2aqqrW5l32ggAaqtb2b+3nikHuEbXLtuNaZpMPuAYwMYVe5BkkaIJ3fe5dbJjQxm5g9KIj4m/I8HX4qeuvInBo04s1yh8bfUPB/tEW2+mU19I8rE1GPRa0aZYlGNeyLWPY4+hm4iSeEIl7+ykYGw/tq8rParrPG9wOi6PnY2HcZGOnTYIQRBY+sm2bsenzSlA03QWf7y169jMOQXsKK5mbyz329x5I6irbWPVyj1MmzKIxEQnL768koLBGQwZmMZLr69i7knDcDms/OOlpVxx1ng2lFQyKDsZTTfYtquGgVnJrNlWRnpCHNv31RLvsNPmCyKYAk5RoayhlTSnk5pmHw5RwY5CW3sQp2QhGNRAA0ETiYRMBF0kHDJBk4mERcIREU2TCasy4YhMWLWgRmwEw5YeW0S1EQwrhFUZTZPRtJgAVEUMVSKimpiqCJqIHjFxiha8/hCyIYIhEPSrpDlcVLf4UAwRCYGaBi/DMlNYtbOc0fmZLNtayvhBOazeXs5FM0bw4oK1FA3IYNGyHUiiyKwJg3jz443MmjyEqupWNhdXcu7po6muaeXzxSXMnVOI3W7h7bfWYbdbmDo9akX78J31iKLA9FnDutbrs/c2kpGd0K0SgmEYLF24jcKx+ThdhwbzRMIqxetKKRzXs6A7HFtXRa1zBUc5rjcgydHbqt4XCNer6XR/K9Y+0fatYHdZCcXqI/bRe7FYZTRVPyHD6yfOLSLYEWLryj1HPEaSRCbOLmDNFyU9WqKT0zyMP2kwC99a3+38kMJshhZl887LK7tuRvPPGYvDaeXVF5YDMHPWMDKzEnjp38tRFIlrr5rO9pJqvlq2i5t/eDINTe28u2ATN/5gBhuLK7HLCqOGZvHCu2v4wenjWb55P7NG9McwwC7IhFUdl6Tg9YfIdLtBN/EoFhpb/STb7bR3hEm2OhBVAVM1UQwJNawTJ1jQwyaKpmBEBNAkDFVEi0igKmiRqPiKqDKaHhVlPTVNl4lEJLSIjK5KGKqCrkroESkq1lQJQRXQQgaKIWFqJqYKDiyE/CqZrjiafX7iJAVTNwl0qAzPTqO8poX+KYls31tLQW4aG0oqmTw8j+LdtWi6wYRhOazdVs7NV5zEv99YhSKL/Oiyafz1n5+Tk5XAuWeM5p/PLMFqlbny8imUlTaydMkOzj1/HE6nFZ83wIJ31jNjznDSMuIBKNlcQcmWSs65fHK3LzibV++jtrKFU88f1+P1snH5boL+MFNOLTriawxg1cKtuBOcDBt74om2zi9RB+bB66P30akv7D182fku6cWizUY40CfaejuW2AejGj7x9i+OmjoYu9PKyk+2fnPnA5h6ahEdviBbV/ec+mP+xRNpbWpn9Zc7uo4JgsAFV02ltrKFVbEIRFecjbMvHM/yL3dQUdqIJItcfuVU9uyuY/XKvcybW0T//ik8/exXDBmYzmlzCnnjvfUUDspgVEE2T770FTdfPgNRENiwpZwpI/rx0kfruemcKVTUtzIsM4W65nb6Jyawv66Z7HgPChJxkoVWb5AUh4O6lnayXW4igWiEJqqArpqImoAdGTMiIMZEm6mKMfEVFV5qRESNRMVcT82IyGixMboqgSpCRMJUo9GhZtjEgQUtYmBFJhLUsRoyogbxso1mbwA7MpIp4m+PMDovg4qaVuKddpqaOshK8lBf7yMzycPgjCS27qnh2jMn8sqH65kyuj9WUWLDtgp+csVJLPpyO9W1bdx2wxy2b69mxao9XH7JZBITnLz84nJsNgvnXzQBgPfeWEsoqHLJVdO61u/tl1bicts59Zwx3db649fX4k5wMHVuYY/XwsqF23C57YyYNOCIry9N1Vn7RTETTyk84bYtwNcWmBMtOOpEI+SPbhWxO63H9HV7rWizOawEO/pEW2+n84PxRHSFW2wK42YVsPqzrUdlaRwzfQhWu8KKT7f1eH7c9MGkpHv4+PW13Y5PnjWMjOwE3npheVegwnmXTMJiVXjtxRUAzDmlkIzMeF56YRmiKHDjj0+mrt7L2+9t4IarZ+CwW/jrP7/g9htOIaLqvPTWGn55zckU76llUGYS8S4br3y8getPn8jGndXMLBzA7spGJvTPZnd1I2lOJw5ZxiUptHoD5MS5aW0P4hIVRBWshkQ4qGFDwVRB1AQUXYKIgE23gCpgRkRMVUIPi5iqDJpySBM0JdonIsb2q4mgijGxBhZdQo+Y2AUFQRUwIyaiKpBosRPwq7gUC1ZDxCJIdPjCjMvPYndFIx6nDVkXsMhS1JoY0bh89mj+88kG5k8ZxqJlO3HaLfz4wik88cJXjBqezdjCXP7z5hpOnj6UMSPyeOrpL0lLc3PBeeMoL2vkqy93cPZ5Y/F4HPj9Yd57Yy1TZwylXyxRbnV5MysX7+CMi8Zjs3+dGqe5wceqxTuYe+7YHuuNaqrO6i9KmDi7AOUw9Uh7YtvqvXR4g0yeN+KIx/QmIrEvkEqfpa1X02lps/WJtm8Hm8vW5x49AejcT3CihtdPnjeC1sZ2dm088oAEq01h/MxhrPqsuMd9N5IkctpF49m0ai/VZU3djp97xRR2bq2iJFZ71BPv4Ixzx7L4s23UVrd2Wdt276pjzep9jB2dz6SJA/jPKyvBhB9ddRKbiyvZvaee6y+ZyrJ1e5EQmTt1KK8uWM+Pz51CY2sHxTtrmDNuMEs27OWUUYNYt6OSmUP7s7++hXhLtLqAXZBpaw8iqJBsdxIMaHhkG6Iq4OlMDaKJyLqIqAoImgCRWAsLGGEQIxKypqAc1GRNwQyLEBYhIiDEUnmImgAq2JARVAE1pOORbGhBPWpda/MzMDGRuqZ24qxW2n1hJvTPpqSsjrR4F3ZkWtsDFGansaeqiZvPm8aTbyxnSG4qbquVvRWN3P2jU3n21RWoms6dN8zlb08vRpYlbrpuFp99XsyevfX88NoZWCwyL7+4AqtN4cKLJgLw4dvr6GgPcek1X1vZ3n15JbIsctYlE7ut86dvr8fQDU67cEKP18m2NftobwscvWv0061YbQqjTxr6zZ17ISdqGqITjWCnaOtzj3472J1Wgh09l+vpo/egdEVqnZiJLCfMHo6sSCz/aNNRjZs6r4jWpnaK1+7v8fyp549DkkU+fGVVt+Nzzx5NnMfOa88u7Tp2wWWTkUSRl/71FQBz5haSnhHPc88sQVV1bvjhTIIhlSefXszppxQxbHAGf3/2S+ZMHcKwQen8+ZnPufS0saQkunjh3TX89MJprC2pwC5IDMxKZvXWcmaPHMiSzfsYn5dFdbMXqyASb7Whh3RSHU6qGrzke+LxdQRxIKOGdAhDgmRDj1UnkDQBSRcRtaj4ElUBWZOQVRGLJnVriiYhqkK3JusSVkOGiIDVkLGbMkG/ilNQEHUBBZFEi53y+lbyE+JpbPYzJi+TLftqyEh0Y4YNapt9zC4ayIqtZVw+ZzSvfbIBiyxx3swi3vx0E+fNGUl9vZeVG/bz48unU7KzlrUbS7nmsqlIosAzz33F0CEZnDxzGLt31bJkcQlnnzsOT7yDdl+Qt19ZzbhJAxgcq0LQ3OBj0YebOfmMkSQekC8tElb5+I21jJ48kMy8pB6vga8WbMZqVxhzQJ63b0LXDVZ+spUxM4Z2s+qdSHQm1T3R0hCdaAQ7ou5Rm6PP0vat4Ip3EGgPdeVS6aN34omlIfA1dxznmRwfnG47E+YM58t31x9VtNrkUwrxJDl5Jya0DiYxxc3JZ47m4zfW0Vjb1nXcZrdw0TXTWbdiD5tjgi8pJY7zLp3E5x9vZcuGMmRZ4sab57B/XwMvvbCMvNxkrrhsMos+387Cz7Zx5y3zCIVUHvjDAu6+aR6iKPDrP33IHdfNobnNz4IvtnHpqWP4eEUJuQkeEuLsrN5SxtzRg1m7s5Ist5uOYIT29jDDs9KoavCSYnfQ2NaBoomkOlx0dERwCDIWUyIS0HGikCDZiQT1qNUsIuAWbHgkGw4ULKbcrVlNGbdoxWbKMfcnGBGTeMmGpAq0t4dIVOyIqkCbL0iWy01rWxAFEcUQaWr1MyY3k837auifmkhTQzuBkMrkIXksXL2L2WMGsWTNHlrbg1w5bxx/fv5Lhg/MYNSQLP7y3GKmjhvAqGFZ/OmJzxg5PJtz5o/iwYc/pKMjzC9uO5VIROP3D31AUnIcl1w2CYDnnlpMuy/ItT85uWu9XnxqMbpmcPG1J3Vb34/fWEtzvY8Lr+t+vJPWxnYWv7eRWWePOSrxtWXFbprr2ph17vgjHtPb8DZ14IizIyt9oq0309HmByAuwXlMX7fXira4hOjNvKMtcJxn0sd3SWJaPACtDb7jO5HjyMxzxtHa2E7x6r3f3DmG1aZw1g+msXbxDspiKTsO5vIbT8Y0TN54truwO/vSiaRmePjXXz7r2kt3+bUnkZYRz18f/YhIRGPK1MGcetoIXvvPKkqKq/jB5VMZNzafv/59EZGwxp23zmNbSTWvvbWW3991Ls2tfv71ygp+e+sZ1Db6WLVuP1fOH8eSDXvpl5xAv4wkPl+zm5MK+tHU2oGomqR6XGzdV0tBegqyKRD2a6Q6XVQ3eIkTFTJdbtraA4iagEey0dERwQgZSKqAW7TiEBQ6OiK0+UJ4D2q+9jBGBOIlOzZDRooIBDoiBPwqCYoNMwLhkEb/+HjMsEFLm59Uh4OmFj8DUxJxSQpb9tcwMiedveVNZCfHk2x38NXGfZw9dTjFO6oIhFSunj+Bf7y2nIF5KVx/3iQefuJThg3M4NarZ3L3Q+/hjrNx351n8uJ/VrJpczm33XwKAwek8a+nl1BR0cztd55BXJydkm2VfPTuBs65aAIDh2QAULa3nkXvb+LMSyaQeUDN0HBI5Y2nv2LkxP6MPkwVhPdfWI6m6px//cwjvqYAln6wEbvTysRTeg5sOBFoqW8jMd1zvKfRx3dMR2ufaPtW6Xwj21tPTAvMiUJCqhuAloYjr8HZ2xg/ezhWu4WlHx6di/SMK6ZgtSu8/WzP1ra0rATmnDuGT9/eQPMBothiVbjqp3PYU1LDV58WA2CzKdx8+2lUlTfz5ssrAbjx5lNISXXzyO8+JBLRuPeuM0mId/CbB99j3Mg8rrlsCgsXb2fTlgoe+MWZ7C5t4N2PN/PHO86lxevnyxW7uPbMiazcUkqSw86FM0eyfHMpmW43bpuNmtpWZg7rR02zj+ZWP8PSk2loascjWchyu6lp9GKGIN3uJBRUY3vcBOJlG27JihYyCPpVxIhwSBPC4O+IIKqQpNixCzKiKhAMRBPhuiUL7b4w3vYQg5KTUIM6hmqSl+BhV0UjiS4HI7Mz2L6vjgmDsqmt89LQ2sEvLprByg37MUy4fO4Ynn5tOYUDM7jjmtk88JePSU2K44Gfn8FvHl1AR0eIh399Hrt21vGfV1dx+mkjOO3UEWzaWMY7b63j7HPHMnZ8PzRN56+//4iUNDdX/WhW1zo999dF2B1WLr1+Rrd1XfjWOlqbO7jsxpPpiUBHiI9eXsmUuYVk90854utJU3VWfLKFSacWdUV1n4i0Nvi6Ppf66L20x0SbM75PtH0rxCVGLW3tLf7jPJM+vkviU+IQBIGWuhNXtNnsFiaeUsiKjzcf1XYAd4KTeRdP5Mv3N3ZzgR7IRdfPQNcN3npuWbfjs04rYsCQdP79+OdEItFouQlTBnHS7AJe+fcyqitbcDqt3PE/Z1BT08pTf/8cj8fBb351Dk3N7fzu0QVcedFk5swYxrMvLSMS0vjlj05h9aZSPvh0C3/5n/PxByN8/GUx1589iVVbS9lUXMEvLppBfUsHvrYgw3PSWbalFLekMGVQHvtrWrCJEvF2O/uqmtGCBpkuF2hRAaboAik2B3GSBTWk094eQlA5bNPDBu0dYQQ9WukgXrEiqtDSGiDBaiNetuD1hqhq8JKXEE+bN0gopDF9cD6V1S3sKq9nXP9s1m+vol96IlfNGctTry9DlkQumDmCp19fwdjhOdx+zWzuefR9JEnkj/ecxxPPfsnufXX86vYzcNqt/O7RBQwamMYtN52Czxfkkd99SHZOIj+8ISq63nltDaX7GrjpF6dhd0RdmVvW7Wftst1cct103PGOrnWLRDTe/NdSCsfmMyJWHeNgPn19LR2+IBf8eOYRX0sAm5fvoqMtwElnjvnmzr2Y1gYviWl9lrbeTntLB654B5J0bGVU7xVtfZa2EwJZkXEnuWg9gS1tACedORpvc8dRJdoFOPfakzBNeO+5pT2ez8hJ5OQzR/HJG2tpbWrvOi6KItfdNpf6mjY+fG1N1/Gf3HYqiiLz+B8+xjRNRo7K4+LLJvPxgs189eUOhg3N5KYbZrNm7X5efnUVd9wyj8JhmfzusY/pn5PEDVdM5/PlO3nl3XU8dud5aJrBe59u4c4rZ+P1h3jqjeVcfcpYclMTKN5Tx0nD+uG0WlldXE5evIeBqclUN3ixCRJD05JRkGhq8SNpkGp3RtNsBDW83iBEQFT/S4uAGtRpawtiqgYe2UqCYsUMmzQ2d5DhdtMvMZ5wUKOxtYPJA3OI+FVWbS9j4pBc8hMT2LiziotnjiQ73s1Tb61g5OAszp5WyL/eWsWU0f258ZKT+MVDbxMMqfzxnvP4cOEWlq7aw43XzmJMUS6/efA9BAF+86tzkGWJPz/6EW2tfu7+1dnYbAp1NW289OxXTD5pSFc9WF03ePaxz0hJ93DWpZO6refn726gud7HpT+ZRU+oEY13nvuKoon9GTrq6OqGLv1gI444G2NmnJhRo5201HtJTO0Tbb2d9lZ/l3HoWNJ7RVtSNFLKe8CNpo/eSXJmAg2VLcd7GseVcbMKcHnsLHhx2Td3PoC07ERmnT2aBS+vpL6q5/fwkh/NRNcM/vHwgm7Hx0weyPhpg3jxycWU72sAokEJ1980m41r9/Of56NzufrakxhWkMWjD39I8bZKzj5zNKfMGc6/X1zOO++u57f3nEtKkovbf/0WRYOzuOWaWSxds4fHnvmC395yBoos8vhLS7hk9ihGDMzkqbdWkGizcd60QlZuLaO+LhqRGY7olOyrY2BSIuP6ZdPY1kFNg5cEi5URWenEyRa8bUG8bUGECCiaQKYjjly3h0GJid3agIQEkiw2xAjoIYOmZj9qSCfb46EgPQVUk71VTSiCyIyh+bgkhXUllQzJTmF8v2xWbiqjxRfgR6dPZNm6vXy5fg9XnzGeBKuV595exckTB3PWjEJuue91TMPk8Qcu5stlu3jtnXWcfdoo5s8p5M573mTf/gbuvuMMMjPieeafi1m+bDfX/2gWg4dkRIM57noDSRK56efzutblzeeXsaekhmtuntMtK39rUzsv/HURBWPyGD25571sC15aSVOtl4t/MvuoriNvSwdLP9zEtNNHndCpLtpb/QQ7wiRnJhzvqfTxHeNtasfdJ9q+PTrN0yey2+xEIWdQOhW7e95Mf6JgtVs48+qTWPnJVir21B3V2Kt+cRqCKPDcIx/1eD4rP5nLbjyZpZ9sY9lBCXlvu+8cbHYLD9/5BuFYfqrTzx3LnNNG8OLTS1i5dBeyLPHgwxeQkurm3rvepKy0kTt+fhonzxzG0//6infeXc9ffncxyYkubv/1m+SmJ/DwnedQVtXMbx5bwJ3XncLIIVn887UV6EGN686ayMZdVSxZs5sbzpzExIJcvtywl1B7hNkjBxKJaKwpLscIGkzun8vAtCR2VTRSWtOCGtLIi/cwJjeD0XmZZLhdWBCjJagOaIIOuQnxjO+XRVFmKqkOB82tfnaWN9Dk9TNxYC4jM9OoqGplxdYyshI8TB2Sz9YdNewob+CqeeOYMbwf/3p3NQ67hR+fM4UFn29jybq9/PDCKQzNTeHeP7xPTmYCTz18GR98vJlX317L2aeN4trLpvLLu16nZEcN9/7PmUyeNJDXX13Nm6+t4exzx3L+RRMwTZM///YD9u2p4+4HzyM1tvF9+6ZyXnzqS2bMK2LW/K+T25qmyd8feJ9gIMKt95/bY61eb4uf//ztM8bNGMrYmNXuSPngua8IByOc9+Oe98mdKFTEgnqyB6cf55n08V0TDTiJP+av22tFm91lw+6y0VLXdryn0sd3TM7gDBoqm0/4ZMpnXTcDq03hrSc/P6pxKRnxnH/9TJZ+tIVdWyp67HPR9ScxaHgWf3/gfdoOSK+SlBLH7b89j7K9DTz9p4VAtOTVrXeezpCCTB75zbuU7W8gPt7J7/9wCVabzF23v0ZTYzt333kGp51axEuvrOLNt9bxl99dTE52Inc98Db79zfw5EOXYlFk7n30feZNHsbdP5rLvsomXv1gPZfOGU1eRiL/fGsle/Y1cOXsMQzKTubLdXvxe8OcPnYo4wZFk9pu2VWDW7IwdWAukwbmkuh0UN/SzqY91WzdV0t5bWuPrbi0jm37awmGVPKTE5g2JI+R2em0twZZU1yOzx/m1DGDmV00kD2ljWzYUclZUwqYXTSANz7ZyIJl2zn/5BHkJ8fzz9eWk57s5unfXEJlRQv//M9yZk8dyoO/OJNHHvuE9z7ezCXnjeeqSybziztfY39pIw/edy6zZgzj00+28sw/FjPz5GHcdMtcBEHgjZdWsmTRdq75yclMmDIIgHZvgEfufou0DA+33HNmN2G25KMtrPy8hB/cPIfcWKWEg3ntic8J+sNcf/cZR3X9BDpCfPD8UibPG0He4IyjGtvb6PzymHuCvw8nAi11bST0ibZvl8T0eFrr2473NPr4jun8gKzaV3+cZ3J8iU+K49TLprD4nXU0Vrce1djzfzgDT5KT5x75qKtE1YFIssTPf3c+gY4wf3/w/W59xk0ZxIVXT+OjN9ex9LNoNKnVpnDf7y/Cbrfwmztex+cNkJ4Rz8OPXkI4pHHnL1/D5wvyy5+dxrlnj+Wtd9bzwksrePz3lzJnRgHP/WcF/3pxGY/9+gKGD87kocc/Yc2GUv529wWMK8zlpffWIkQMbr/iZFIT43jlkw3sL23kzInDGJaXxierdrJsw37cspVpQ/MZkJ7Itn21rC4up3hPLY0NHcQJCgOSEijMTKPooDY8I5UctxshbFJR1cqmndWs2lZOc5ufSUPyGN8/m6bGDj5dtYvVxeVMK+rH5CG5fLRkO5+t3sX8KQXcfMF0Fi/fxZotZdx46XSuP28y9z/2EZ8v38GPL5/OeXNH8tM7XmHH7lru+fl8LjhjDD/75avU1LTx8IMXMHnSQFat2MOf/vARY8f14867z0IUBdas2M1zT33BjDnDufjKqUDUkvbY/e/T3NjOXb+/CGfc11naWxp9PPnQhwwdmcO5V0+jJ+oqm1nw8krmXjiBvEFHZyVa+J+VdLQFuPDGOUc1rjdStacOi00hNafnhMV99A40VcPb2H5cAk56tWhLSPP0WdpOAHJirojKE9xFCnB+LKLw7X8uPqpxDpeNy24+ha2r97H+q5099skflM6VP53Dis+2s3RhdzfpVTfNZmhRNn954H1qKpoBSE518+vfX0hjvY/7bn+dSFij/4BUHvr9hTQ2+Lj7jtfp6Ahx842zueziSXz40Wb+8vhn3HXrPG67YQ7rNpdx+6/f5MYrT+KHl05j5Yb93PLr1xk9MJN7bziVito2Hnv+C+ItFn5+6UyKBmTw8bIStu+s4eTC/pw1pYD89EQ27KxiU0k1etigX2I8I3MzmDAwh2HZqVhFmWAwQuCgFgqpJDodjOmfxbj+WQzPSiPTFUdDfTurtpRRWd/G9KJ+nDWpgCFpySxds4dNO6q4+JTR/OisSWwpruSJ/ywlNyOBP91xLrt21XLH794FQeDPv7oAuyxz2z1vYLMqPPXHyykcmsUtP3+FlpYOHn34IsaOyWfTxjIe/M27DBqUzn0PnoeiSOzZWctv732bAYPS+cW9Z3VZ0977zypWLt7BtbecwpDCrK51MU2Tv/3mPSJhlV/87oLDRrq99NiniKLA5bfOParrJhJWeefpxYyYPIhhY/sd1djeSMXuWrIHph3ziMI+ji1tsRRIfe7Rb5nE9Pi+PW0nAFkD0hAlkfKdNcd7Ksed1KxEZp07joWvrKTpMGk8Dsdpl0wiIy+JZ377Ydf+tIM5/5ppDCnK5okH3qf+AGuerEjc/ehFSJLI/T97lXZvNKl1QVEOd9x3Dtu3VvLg3W8SCWsUFuVw34PnUVbayM9ufona2jZ+eN0Mrrt6Oos+386d97zJtIkD+dvDl6KqOrfc9Rpuu4UX/3w1YwpzeerlZbz6zlruuu4Urjl3Etv31vLXF76kqaGdn54/jTkTBrNtXy0fLdnOus1lDEpO5IyJw5gzZjC5qYkEAhG27a1l045q9pQ2UlHZ2mMr2VPHhpIq9le1ICFQ1D+dMyYVMHf0IMSwweJVu/lo6XbCEZVrzpjAudML+eTL7fzjteU4HVZ+9ZN5TBvZn7t+9y6rNpbyw0un8ff7L+bDj7fw+DOLmTi2H//885U0N3Xw01tfIhAI86dHL6GoMJvFn2/n7jtfJzMrgd8+chEOh5XSvfXc87NXcHscPPinS7HFggzWr9zDs3/5jMkzh3LelVO6rdcnb65jzZc7uerWuWT36znn2vb1pXz5/ibOueYkko8yKexnr66iuc7LRTefclTjeisVu2rI6XON9no6jUEJx8HSJvTkCvm/zrhx48z169d/Y7+n73qFBU9/wfvNz/a48baP3sNNMx7Aneji4Xd/frynctypLW/ix7N+y9T5o7jz71cd1dgNy3Zx71XPcOaVU7jx/vN67FNd1sStFz9JenYif3z5R93KHG1Zt597b3qZAUPSefifV2GP1eX76L0N/O2Rjxg5Np/7H70Eu8PC5k3l3P+rtxFFgd88eD5FI3P5eOFWHn/icywWidt/fhrDh2fx+78uZPX6/QwZmM5Pr5+FLxDmb88vpqbey5Sx/Tl33iiavH5e/WgDpdXNxMfZOWPmcHKzEqlv9bN88z5KSqOuc1kSyUmLJzc9gdQEFw6nFUWS4KCPB8M0iUQ02jtC1DT6KK9toSGWPshqkZlclM+EglwkQWDLjmoWr9mNpuvMGD+I8+aMpLKqhdcXbKC6ro3pEwZy45UnsWZ9Kf9+dSXBUITrrpjGeaeP4dnnv+LtdzeQn5fMffeeTW5OEi8+v5SXX1zBiJE53Pfg+Xg8DnaVVHP3bf/BalV45O9XkpOXDEDJ5gr+54YXyM5L4tFnr+3mFt2xuYI7fvAMIyf15/6nrurR+uP3Bbnx9D8jigJ/X/DzbuO/CV+Ln+unP0C/YVn8/s2bT/jP2LZGH5cM+QXX338BF9x86vGeTh/fIcvfW8eDl/6NJ1Y9yMBR+Uc0RhCEDaZpjvv/fe1eXRwtNSeJcDCCt6md+JS+DNW9mWETBvDF66vQdeOEd01k5CVzwU/m8OpfFjL/iqkUTeo5vUNPjJ0+hPOuO4l3/rWUMScNYdLs4Yf0ycpP5o5HL+Y3N77I3+57j9sfubDrhj1yfH/ufuRCHvzl69z/s1d54G+XY7EqnH7OWKxWhT8++D7/c+vL/Paxyxg1Oo/H/3E19971Brf//BVu+8VpzJ8/ksLhWTz08If86v53OWP+SO67/QyWr9nL0y8u4+a7XmXG1ME8+j/nsmzdPl7/cD0rN+wnPzuR8+eNIiHByacrdvDqxxvRdYM4p5WJI/KZN3EoFqtMbZOPstoWKupaWbGlFO0b6rW6HFbyMxIYV5BLbno8cXYr7e0h1m0r5y/PL0Y3TNwuG2fMLGTmuIGs2rCfex99H38gwpABafzp3vPRIjr/88A7VFa3Mm5UHjddPwvBhJtue4n9+xs59+yx/Pj6GZgmPPSbd1n61U7mzR/JrT+fh6JIFG+u4N6fv4I73sEjf7+SjFg6if276vjVT18mOdXNQ0/+oJvgam7w8dCt/yE5w8Odj17c49+EaZo8fu/bNNV5+eMbNx2VYAN44dEF+NtD/OShC054wQawY120Fu+w8QOO80z6+K5pqIxuATkeexd7taVt5YcbuP+iv/D48vsZPLbn7N999A6+eGM1f7jhXzy57D76D88+3tM57oSCEX500kPEp8TxlwW/QBSPXMhGwho/O/9vNNV5eerjX5B4mJI8r/7jS1782yJ+dOd8zr2q+wb3zxds5o/3vsOUWcO45w8XIckSAMsW7+DhX79N/oA0Hv7r5XjiHbS3B3nwvnfZuKGMCy+ZyPU/moVhmDz3wjJef3MN2VmJ/Orus8jJTuT199bxyltr0XWD888aw8XnjGfN5lLe+mQTu/bV43RYmD+rkElj+uHzh1mzrYxVm0tpiblr45xWMlM9ZKbGk5nixu6wIIniIaLDNE00TafVG6CmwUtNg5faRh9qrOLEoLwUpo7uT9HgTIKBaOWGNZvKkGWRWZOHcP780VhliSf/tYSNWyvIzU7kputmMWFMPu9/uIl/PLMEp8PCHb+cz6QJA2hqbOfX97zJnt11/Pgnszn/ogkIgsCGNfv4zR2vk5Lu4ZHHryQlthbV5c384ppnUSwyf3r+OlIz4r9ev4jGXVc/S+muOv786g30O0z6ic/fWc+ffvkaP/jFPC696eiCCMp313Lj7Ic585qTuOGBC45qbG/lufvf5p0nF/FO+eMndBmvE4F/3P4yHz/3Je83HbkX79uytPVq0bZvSzk3TrqXX716C9POGX8MZtbH8aKmtIFrx97DzX++gtOvnvHNA04AFr2xhj//7GXuevJqZpw99qjGVu5r4OYzH6NgXD8e+vf1PYo+0zT57W2vsGrxDn77zDWMmtTdwvDBa2t48vcfMeeMUfz8gXO6nmPtyj088D9vkp4Rz/1/uISsnEQ0TefJxxfxwXsbGTkql1/ccTqZWQls3FTOw48uoM0bYP68kVxx2WQEQeCZl5bx6eJibDaFGVOGcOrJBSgWmXcWbubLVbvQNAOrRaZwSCajhmeTlOjC6w9R1+SjpsFLdb2X2kbvN1ranHYLWWnx0ZbqITnBhU2W2F/exObtleyraAIgKcHJOXNHcsq0YWwtqeLTL7azubgSd5yNay6bylnzRrKtuIrnXlhG8fZqJo7vzx2/nE9igpOlX+3kb48tJBzSuOfXZzMplsLji4Xb+PNvPyAnL5mH/3YFCYnRKi+N9V5+cfWzhEMaf3z+OnLyk7vN+W/3vcsnb67j7j9fyvR5RT3+XjXlTfz0jMcYMDyL3//nhqO2Tt9/zdNsXbWH51beh+c4JBj9v8jtZ/yBSEjlr5/ffbyn0sd3zAOX/JXKXTU8s+mRIx7TJ9qOQLT5Wjq4MOsn/PiRyzjvltOOwcz6OF6YpsklQ37B+DmF/PLJa4/3dP5PoOsGN5/6CEF/mH8uueeoM9V//OpqHr/nLa6763Qu+FHPZY8C/jA/u+Qp2po7+MvrN5KRk9jt/H+eXsJLTy5mzpmjuO3XZyMrUYvb1o1l3H/Xm5imyZ2/OYeJUwcD8MlHW3jqic/RNZ1rrpvBueePpyMQ5rl/L+XjhVsRBIEzTx/F5ZdOpqmlg3c/2sSS5bsIBCOkp3qYN3s4J00ZRFW9l83bK9m0vZJ95Y2YJkiSSGqSi9QkN2kpcaQmu3G7bIiigKx0Fy2GAeGwSlNzBw3N7TQ0t1Pf6KPNFwTAZpUpGprF6OE5jCzIRgvrfPJFMctW7SEUVsnKiGfe7ELOPX00ZeVNPP/vZWzaUkFysourrpjK6aeNpKXFzxN//YylX+1k0OB07rz7TPL7paCqOs/+/XPefX0NRaNzue/3F+P22AGorWrh7p+8iLfVz6PPXsvAod03vX/02hr+/sD7XHT9DK75ec/7qtSIxu2XPEn1/kae+OjnpGYdXfb+bav3csf5f+Xqu87k4puPLtq0t6KpGufn38r8q07ix7+7+HhPp4/vmJ9O/TXuJBe/++COIx7TJ9qOQLSZpsl56T9mzmXTuOmxHxyDmfVxPHnwB0+xe1MZL279fd8emxgbl+7knkuf4NwfzuJHv+k5sOBwmKbJb296kVWfFXPfM9cyYdawHvvVlDdz2yVP4oyz8eiLPyLlgAhE0zT5zz+X8PI/vmTUxP7c84eLiXPHBEhNKw/c9Sb7dtdxwWWTuOYns1EUicYGH3/980JWr9rL4CHp/OyX8xk0OJ26Oi8vvbKShZ9tw6LInHvOGC6+YAJWq8Ky1XtY+EUxG7aUY5pQMCSDcaPyGTcqj+ysREr21FKyp5b6Jh8NTe1d/wPoxuE/A+02hfQUN6nJcaQlu8lKj2fksGzSk+PYWlLNhi3lrN9URl2DD6fDwsnThzJvdiHDh2aye089z7+wjDXr9pOQ4OTySyZx5umjkGWJjxds4pl/fkkkovGDq6dz0cWTkGSR2ppWfnfv2+wqqeHsCyfw41tPQY65los3lfPAz17FMEweeuIKhhbldJvrV59s5dHbX2fM1EH85skfHHYf25/veJ3P317P3X+/kunzRx7VNRHoCPHTUx9BV3X++dW93YJQTmSKV+3ml6f/gXv/fQPTzjo6q3Yf3z8uyPoJ08+bwK2PX3PEY/pE2xGINoCbpvwKT3LcUSniPr6fLHxpGX+59UWeWn4f/Qr69rV18sTdb7DghWU89MqNjJ3Rs/A6HEF/mNsveZKasib++MZN9B+W2WO/Xduq+J9r/4Un0cnD/7qW9OzuFrfP3t/E3x78gPTsBB742+Vk5kY38EbCGv/822d8+PZ6hhRkcvdD55ORmYBpmnz15Q6eeHwR3rYA510wnkuvmILH46CquoV/v7iCL7/agWmazDhpKKeeUsj4sf1oaGrny2U7WbZ6Dzv31GEYJjarwsjCbEYV5pCdmUB6qoe0VDcOu0JTq582X+CQ30dAIDU5DrfLRnOLn7oGL3UNPvaXNbJhSzl79kdrrbqcVkYV5TBt4iBmTRtCOKKxeMkOPltUzM5dtbjjbFxy8STOPWsMNpvC7l21PPH4IrZvq2LU6Dxu+8U8smObmZcuLuGx330IwM/vPovpJ3+9Vp9/uJm/PvA+qRnxPPD4FWTldd8AvfjDzfzp7rcoGJXLg09ffVgx9eoTn/PinxZyxa1zjzonG8Cff/YyX7y1lkfeuoXCiUce4NLbee7+t3n7iUW8sfcxnLEvJX30TnzN7VyYfSM/fPhSLrht/hGP6xNtRyjafnfl39m9oZR/l/zpO55VH8eb5ro2Li+4nat/dS6X/OzI/5h6O+FghFvm/4H2tgBPfn4X8UlxRzW+qc7Lbef9DUGAv7xzC0mHyU20c0slv/rxv7HaFX737LWHlEvatqGMB37+KgC//vOlFI3N7zq3dHEJf/7thwgC3HDbqZwyfySiKNDeHuTZf37JRx9uxmZTmDd/JBdePJG0dA9V1S28/e4GFn9Zgq89REKCkzknF3DqKYUM6J9Khz/M5m0VrN9SzsYtFZTHIr46sdsV0lM9xLlsB2f8wDBMmlo6aGhqRz9g35siSwwflsm4kXmMHZXH4IHpmIbJmnX7+WxRMavW7EXTDPr3T+HUOYXMP20kToeFjevLeO3VVWzaUEac284NN85m7rwiBEHA5w3wrycX88n7G7sJ1+g8DF58cjGvPbuUkeP7ce8fLybO4+g21wWvrebJBz9kxIR+/PrvV+JwWntcn68WbOb3t7zMyeeM4Zd/uvSordFLP9jIwz95nktvPZUf3HF0pa56Oz+ech8JaR5+35dyqNezY81ebpt5P/e/9TMmnT7miMf1ibYjFG0v3P8Wrz36AR+0Podi6dUZTvoAbp79EIoi8+eFdx3vqfyforSkmltO/yNjZwzlvud/dNQ37H0l1fzyoifI7p/CH167EZujZ2FQuquWe65/Ht0w+O0z1zCwIKvb+ZqKZn59y3+oq2rllnvPZO45X3/o1da08sh971KyrYqBQzL48S2nMDIm7MpKG3nztTV8vqgYE5NZJxdw0SWTGDAwDVXVWbN2H58uKmb12n1omkFysouCoZkML8iiYFgmgwelE45oUYtZva/LclZX76UjcGjNWkEQSE50kpbiIT3NTXqqh4w0D6kpcfg7wpTsrKGkpIbtO6rZtauOUFjtEo1z5xQycEAqumaw9KsdvP7qavbuqScpycV5F07g9DNH4XLZiEQ0PnhrHa88v4yAP8z5l07i6htORont+wsGwvz5vvdYtmg7p547hp/efQaK0v0z7I1nvuL5xz5l4qyh3P3nSw+7b7FkQxl3Xf4PhozM4bcv/hiL9eg+CxuqW7jplN+T1T+NP757W9fexD6grryRq0ffzY9/ezHn/qSvlFdv5/NXlvOH6/7JM5sfIXdIz56HnugTbUco2hb9Zzl/vP6fPLvl0b5M1ScALz/yAf95dAGv7f4TnqO0KPV23n3mS57+zTvc9LuLOOOq6Uc9fs0XJTzw4+eZOLuAe57sOVkrRPe4/c91/6LDF+T+J39A4bju5Y3afUF+e/vrbF6zn5PmFvLTu8/AHR+1HhmGyZJFxfzryS9orPcxZcYQfnjTHLJi7tTGBh/vvLWOBR9sIhiMMHJULifNHMa0k4aQlOTC6w3w1bJdbNlWyY4dNdTGKqLIski//BTSUt0kJblITnKRnBxHUqILp9PCwdl1DcOgzRukubmDpqZ2mlo6aG7uoLq6lZpYpQlJEhk0MI1hQzOZML4f48f2QxQFdu+qY9nSnSz5ooS6Oi85uYlcdMlkZp8yHItFxjRNln+5k389+Tk1Va2MmzSAH91yCvn9v7ZMbt9Uzh9//S51Va1cd9spnP+Dqd2Etmma/Puxz3jj2a+YefoIfvG7Cw8rpGormrntvL/hirPz2Ds3405wHvmiEw1oueuix9m3rZK/f3Ynmfk9V1Y4UfngmcU8eeerPLf+t2T2T/3mAX18r3nhgbd57ZH3j9oQ1CfajlC0/W9NmX18P9mzuZybT36Inz9+NXMvn3q8p/N/CsMwuO8H/2Drqr386f2fMbAw55sHHcT7/17GPx54n/mXTeamB849bP63xto27r7+ORpq2rj9kYuYNrew23ld03nzhRW8/NSXxHns3HLvmUw+INAhHFJ55/U1vPbCciJhjbMuGM9FV0whKSUqxNvbg3z4/iYWfbqVyooWBAFGjspj9inDmX7SUFyxRLEtLR2U7KylZEc1e/c10NTUTnNzB7720BH/zqIokJjoJDkpjrQ0N8OGZFBQkMXggWlYY5ativImvvh8O4s/305tTRuiJDBqVB5nnzuWyVMHI4oCpmmyfUslz/1jMcWbK8jrn8KPbzmFcQckPw6HVF58cjHvvrySlHQPv3zwvG5uZIhGfz5+//ssencD8y+ewI33nnVYAd1c7+XOS5/C2+rnsbdvIbv/0Quul/74Ea88tpBf/OUK5lw48ajH93buPu8x6qua+dfah473VPo4Bjz8gyfYuW4fL+z481GN6xNtRyjaOtr8nJ9xA9c+eDEX/7JvH0ZvxzRNrh17D2l5yX37S3qgramdm+c9iigK/PWT2496fxvA849+zBv/WMzs88Zy28MXHdbC09bSwQM/fZkdmyu46PoZXHnznEP67t9Vx59+/Q77dtUx67QR/OTO+V1WN4DW5g7+/fQSPv1wE6IoMGtuEedfOon+g9KA6HpXlDex5MsdLF60nepYPdSRo3IZXpTN8MJshhVk4T5oc3g4rNLc4qepqZ1gMHLI3AVBwONxkJzkIj7e0U0UmaZJdXUrJcVVbC+uonhbFeVlTYiiwKjReZw8ZzhTpg3uek1dM1i+ZAdvvbKKXSU1eBIcXPWjWZx25mgk+evnLdlcwZ/ue5fq8mbmXzCO63926iH70+qrW3n0jtcp2VTBZT85mSt+Ovuwru6a8ibu+cHTeFv8PPj89Qwfd/QF3Vd8soWHrn+WUy6exM/+dFlfVPZBNNe2cWXRHVzy89P5wd1nH+/p9HEMuGH83aTkJPHgO784qnF9ou0IRRvA5QNvZeRJw7jjuRu+w1n18X+Fl37/Aa/8YQEvbv09KVmJ3zzgBGP3lgpuP+8vDBuTz0Ov3HTU+5NM0+S1J7/gxT8tZOLsAv7n8SuxHiYDfCSs8tTvFrDwzXUMKcrmjj9c3BU52omm6rz+3FJefWYpLreN626by8nzR3RVUQCoqWrh3dfX8umCTYSCKqPH9+OCyyYzbtKALiFhmia7dtaycvlu1q8rZe/eOgw9+vmWm5fE0GGZpKV5SE6JIzkljpQUN0nJLlxO26G1Rw2TtlY/jY3tNDX6aGpqp7GxnarKFkqKq/B6o/naXC4bBcOzGDOuH7NmF5CU9HWiWb8/zMIPNvHe62uor/OSmZ3IeZdM5JTTR2I/ILqztbmDV5/9ig9fW0tKuoef/eZsRk88tBTSV59s5fHfvIdpmtxy/7nMOG3EYdeodEcN91z9DLqm88Bz1zNkZO5h+x6O8l21/OzMP5E7OJ1H37q1L8t/D7z1+Kc8e99b/GvdQ2QNSDve0+njO0ZTNc5Oup7zbjmN6x46unx8faLtKETbPWf/gdZ6L0+u7jNfnwjU7G/g2nH3cO1953HRrX1JlXvii7fW8sdbX+Ls62ZywwPn/6+eY8HLK3nyvncZPr4fv3n6mv+a6mDZp9v4233vousmP/3VWZx81uhD+uzfXcdf7n+f3durycxJ5NIfzjhEvLX7gnz03gbef3MdzY3tZGQlMGn6YCZNG0zhyNyuTfwAwWCE3btq2b6tiu3bq9m7u46Wlg7+tx95ikUiPd1DQUE2BYVZDC/MJjcvGVH8WvF52wKsW7WXNct3s27VXgKBCIWjcrngsslMnDqom8Wupamdt15YwUdvrkONaMy/YDzX3nrKIda1oD/MU79bwKJ3NzB0ZA53/uHiQ1KqHMj29aX85vrnsDos/L/27jsqiquN4/h36B0EFGyoKNh77733EntLTIwaExNLokaNsSRqYtTEaNTYkxh77L333jugoiJVemeZ9w9WX2LABjosPJ9zOLvszuw+O8zu/rhz597vVgzErdjrh4nIsBg+b/0jsdFx/LzjS5xTTZMl/m9w3W8xtzBl9h6ZBSEn8L35iI8qjubLJYNo3OP1ut9IaHuN0LZozCo2zd/DppDfc/xk4jnF8BbTiAqPYcHxb+WQTjoWTtzAxkUHGD6rN027vllfpYObL/DjyFUULp6XKUs/xME5/cOtgX5h/PDVGq6eu0ejthUYMr4d1jb/nqRcVVVOHrrFH78dwPvmY/IWdKTHgHo0al3+Xy2CiYk6Du29xoHdV7l47i6JCTqsrM2pUqMo1Wt7ULpcQVzz5fpXoAJIStIREhJFSFBKy1lwcCSxMf89PIoCDg7W+hY5W5ydbbGzt/zPvpQQn8Rd7wDOn7nLqaO3uXH1IaoKjk42VK/tQasOlSj+3Bm0T4IjWbvsKNvXnSUxIYlGrcrT/aN6FCj07+moALyuP2LayNX43Q+h28D69BrS+IUto2cP3WTK4OU4u9ozdeVAXN6gpVmnS2Ziv9+4ePQ209Z+RumqMm9zWnyuPmBIvUl88kNP2g5Ie8YQkb0cXn+Kqb3nMu/kFIqWL/Ra62ZWaMsRY2AUKpWfxPhEHvsEUMBDziDNCRp3q8EvI/7E67IvHq/55sopBoxrj8/1R/wy+m8KFM1Dycqv3+epQbuKWNtZMHXICkZ2/ZUpyz/CtaBTmsvmyefAtKUD+HvhQf6at5+r5+4xeGxbaqQaRFZRFGo2KEGN+sU5dTglvP008R/+WnSI1u9VpXmHStg5WGFqakyTluVo0rIcsbEJXDxzl5NHb3Pq2B0O77sOgJWVGUWKuVDU05USpfNT1NMV13wOuLjY45LOWHPpUVWViPBYHvqGcPPaI27f8MPnTgAPfIOfHYL1KJGX3gPqU72OB8U88/4nMHrffMzWtWfYt/UiSYk6GrUuT48P6/9noFyAuNgE1iw6xNrfD2PvZM20pQMoV+3F4enApvPMHPX3KwXoF1k2bQtnD9zg0+ndJbC9wN6/T2Biakz9jjKvdU5x7/pDjIwUChbXLkfkiJa2OxfuMbTWeMauHEr9LnL2U04QGRZN79Jf0ui96gybLVOYpSfiSTTD2vxIVHgMM9YNo0g6Mx68zNNDcigw8sceVG9c6oXLX79wnzkTNuLrHUi1BiUYNKbNf+YthZSwdOrwLdYuO8q1C76YmZtQv3lZ2narhmfp/P9ZPjlZxeeOP3duPsbnTgDed/zxvhPwr9Y0WzsLnHLbpbSi5bHD2sYcnmtBS9YlE/okmhB9n7agwAgSE3TP7s/tYkdRD1eKerrgXsyVUmULPDuzNbWEhCSO7rnG1jWnuX7pAeYWptRvUZZu79dNM6ypqsqJfTdYMG0rgX5hNGxTgUGphkRJS2JCEounbWPTsiOUre7ONwtefKj6RdbN38viKZto3bcOQ7+XOTTTEx+bQJ+yX1G2lifjVwzWuhzxjkx8bxYPbj9m8aUZr72uHB59jdCWEJ9Ix9wfvVHnQWG45ny+gn1rTvLH1RnYOdq8fIUcyt83mJEd55CUmMS0NZ9SuMSbBTe/+8F8N3Ql3tce0WVgA/qPbPmv/mjPS0rU8c/K4/w1bx9JScl0+6g+XQbUS/ekhnteAWxdfZq9Wy8RF5tA8TL5adiqPLUblyT3C1rOdLpkfO8Fc98nCP/HoQQHRhIUGJFyiDQgnJg0Do8qCuRytME5jy3O+oDnnMcO17wOeJbKh9MLWrGSk5O5c/0xx/dfZ9c/5wl7Ek1+NyfadK1K03YVsUknUPndD2H+d1s4e+Q2hT1cGDK+HWVfcsZn4KNQvvt0Jbcu+tK+fx0GjG7zxoOIb1y4n4XfbqReu0p8OTf9cfgE7FhxhDmfr2DGlpGUq11c63LEO9Lb43PK1PZk9LIhr72uhLbXCG2QMgepbS5rpm2TkfJzinvXHzGozkTen9CJbp/LCQkv8tA7kNFdfyYpUZeh4JYQn8iCSZvYvuokZaoW4as5vXF2ffGhyOCAcH7/YQeHtl/GtaAjfT9tQp1mZdINH9FRcezbeoldG8/hfcsfgMLF8lCltgdV63hQqoLbf2YOeNvCQ6M5d9yLM8fucP6EF+GhMRgZKVSrV5y2XatRsYZ7umPaPQmKZNPK42xYfhRTMxP6fNqEtj1qvPSs3tMHbvDjiFUkJen4YlrX1578PbUNC/azaNJGareqwOh5/WXGgxdQVZXBdb7FyFjh10MTpM9sDhEWFEE3t09ee87RpyS0vWZomzVkMUf/OcO6R/PlTZaDjO74Ew/v+LPswneYvOMvckPzyCeQr977hcSElBa3Nz1UCrD/n/P8Mm4d5pamfDWrFxXreL50nUunvJk/dQv3vQJxzG1Lmx7Vadm1Gg7ptJKqqsp970DOHrvD2WN3uHrel6QkHZZWZhQrmY8iHi4UKpaHIsVSLp8/6eFNqKpKcEAEd+8EcN8rgLtegdy7E8DdOwGoqop9Lisq1/KgSq1iVKpZDAfH9GcfuH31IZtWHufwjivodMk0aF2eD0e1wDG33Qtr0CXpWDlrF6vn78e9ZD7Gzu1D/iJvPkvB+t/28fvkf6jbpiJfzu0nge0lLh6+wegOP8kA3jnMmd2XGdf+B2bsGkv5eiVfvsJzJLS9Zmjbumgfv3y2jOU3f8K1kEzDklOc3HmJiT3nMub3gdTvJB2GX8bvbhBfdvmZxPjElOBW6r/9xl6Vr1cAUz9ZwQOvQNr1q02fL1pgbfvi4JScnMy5o3fY9Mdxzh29g6mZCQ1al6dDn1q4l3hx59+Y6Hgunfbh3AlvvG8+5r53IDHR/59X1NnFjlxONtjnssI+lzUOjtbY57LGItWYaU+pqkpkeCzhodGEh8boL6MJ8o8gOiruX49ZpJgLJcoVoEptTzxK5U23RQ1SDgkf33uNTX8c5/oFXyytzGjWqTLtetUiXxp93J7nc8OPn79ex62LvrToXp1BEzqkezj5VTztw1avbUVG/SKB7VV803MuN8/6sPLydBm7LgdZNWMzy75Zywb/BVjbp9/HND0S2l4ztN0668Nndb9h3J+fUrdTtbdUmchqkpOT+aj6eCysLZh7YJy0sr4Cv7tBfPXez8THJjBx2ceUysAZhHEx8SyZvo2tf5zAMY8tg7/pSK3mZV7p7+DrHcimP46zb/MF4mMT8SiTn2adKtOgVfl0+4WlpqoqgY/DueeV0hL28F4w4U+iCUsVxOLjEl/4GDZ2lv8PebmsccxtS+FieSjs4UKhonmwfcUO//fvBLB74zn2b7lAWEg0rgUdad+7Jk07Vn6lFsC4mHj+/HkPGxYfxtbBVwr3vQAATr5JREFUkkETOtCg7X/HuntVqqryx8zt/DVrZ0oftl/6vrD/oUhx78YjBtWeSM+RbWQGhBxmUvc5+FzxZdm1mW+0voS21wxtiQlJdMwzkHaDmjBwWs+3VJnIivb+fZwfhyxl3LJB1GlXWetyDIK/bzDjes4j6HEYI2b1pl67jM3be+uSLz9/vQ6f637UaFKawd90IE/+XK+0bmR4LPs2n2f3hnPcveWPqZkJtZuWomnHylSoUfSFLVsvExebQFzsf4ObooC1jUWGWp6iImI5tP0yezae49aVhxibGFG9QQmadapClbqer9zR//SBG/w6YQOBj0Jp0b06H3zZGtsXnE36Mglxicwdu4Y9q0/StFsNhs3oLoHtFU3qO4+Lh26y7MJ3cnJTDqKqKj3dP6VCg9J8tfTNzhaW0PaaoQ1geKPJJCcnM/vgN2+hKpFV6XTJDK49EVVV+e3YRPmCekVhIZFMen8RN87dpcuQJvQf3TZDZxTqknT8s+wIK2ftQlEUen3WlDa9a2FhZf7ylUn54PS+4cfuDec4sPUSURGxWNtaUKWuJ+WrF6V8dXfyFnTUrDU1KVHH7asPuXTKm0unfLh+wZfEhCQKe7jQrFNlGrapgIPTq3/R+90PZvmPOzi87RIFi+XhsyldKPOSsdpeJsgvlCkf/c7ti770/KIFvUe0ktbnV3Tr/F2GNfmOPmPa02uUzGOdk/jfD6JfieEMnd2Pth83eaPHkND2BqFt0ZhVbJq3mw2BCzEzl74IOcnRLeeZ0m8+w+f2p1lP6Tz8qhITkvhtwnq2rzxKxXolGP1rf+xe0Ln+VQQ8fMK8bzZy+sAN7Byt6dC/Lm361ML2NfqJJMQncvbIHY7tucrFk948CYoEIE9eB8pXd6doqXy4ueehYNHcOOWxy/RgkpSow883hAc+gfh6B3L9gi9Xz94jLjYBRVFwL5GX8tXdqd+qHB6l87/W89+94cea3w5weNtFjE2M6TG0CV0GNnjjoTyeunLSi+8+XkJ8bAIj5vShdss3P9s0JxrbaRbeV3xZev57rF7SN1NkLwdWn2Ba/3lvNBPCUxLa3iC0Hdt0lknd5zDrwARK1fB4C5WJrEpVVT5rMpXw4Ch+Pz1ZQvtr2rXqBHPHrsHJxY7xv39E0TIFMvyY187eZc38/Zw+cANLG3Na96xJxwH1Xnr25PNUVeXh3SAunfLh4ilvrpy+S0RYzLP7rWzMKVgkN/kLO2PvaI2dgzV2DpbYOqT0VTO3MP3P4Lpqskp0ZCwRYTFEhMYQERZDZHgMwQERPPAJ5PGDJ+iSkp8tX6CIMxVqFKV89aKUq+b+wsFw03P93D1Wz9uXsj2szWndqyYdP6iHY57X2x7PU1WVzUsOsWjSRvIWcmb84o9w83DN0GPmNJeO3OSr9jMZOKUrnYY01boc8Y79+sUKdq88zAb/BW98pEZC2xuEtif+YfQo8ukbj7MiDNv5A9cZ23kWg6d1p/3AxlqXY3BuXbjH5A8XExUWzafTu9O4S+ac0ONzw4818/dzZPsljE2MadCuIm371Maj7JsFQ1VVCQ2OxNc7iId3g/D1DuSBTxB+viFEhMYQF5vGXKMvoSgKNnYWODjZUNA9NwXd8+DmnpuCRfNQoLAzltavdoj3eYkJSRzbeYWtfxzn2tm72OWyosP79V675TE9cTHxzB29mn3rz1CjWVlGzunzxrMl5FSqqjK8xXSCHj1hydmpcsZoDvRJrfHY2FsxfceYN34MCW1vENoA+pcaQeHSBZi49otMrkpkdaqqMqbjT3hfecDiM1OkI/EbCA2K4PvBS7lywosGHSozZGrXDHWKT83vXjDrFx1k/6bzxMUkUKpyYdr1q0Pt5mUzdSiKhPjElJazsBjCQ2NIiE/rDFIFa1sL7HNZYetghY2dZabOEBAaFMn2VSfY9ucJQoMiyVvIibZ9atOye/VX7uP3MjfP3+PHz1bgdy+YXiNa0mNY8wydtJFTHVh3iukDf2fY7L607FtX63LEOxYdEUuXfIPo/mU7+k3o/MaPkyVCm6IojsBqoDBwD+iqqmroc8tUAOYDdoAOmKqq6mr9fcuA+kC4fvH+qqpefNnzZiS0/TRoEcc2n2Ptw3nyAZYD3bv+iCH1J9G8dx2GzeqjdTkGSZekY82ve/nzp+04ONsxYlYvKtYrkWmPHx0Ry+51Z9iy8hiP74fg5GJHq541qde6AgXcDXeMxaREHVfP+LB3/VkObbtIUoKOKvWL065fHSrXK55pn0dJiTr+mr2T1b/sxtnVnhGz+1CulnQHeRPREbF8VGM8TnkdmL17rEztlQOd2nGRCZ1mMn3HaCo0KP3Gj5NVQtsM4ImqqtMURRkN5FJV9avnlvEEVFVV7yiKkg84B5RUVTVMH9q2qqq67nWeNyOhbd+qY8z44Dd+PTGZYhUKv9FjCMO24OvV/PPbPubsHYtnxcJal2Ow7lz25YfPVvLgjj/tB9Tn/THtME9joNo3lZyczNmDN9m0/Cjnj9wGoIB7bmo0KU2NJqUpUbFQlv8SjY6M49zhm5zYc42zB28SFRGLpbU5TbtUpW2fWhRwz5Opz/fAy58fPl3BncsPaPJeNQZN6iKHQzNg0fi1bJi3h9m7x1C88ovngRXZ09MTGNf7L8jQ51tmhbaMzuvTHmigv74cOAj8K7Spqno71XU/RVECgdxAWAaf+408nX7i0qEbEtpyqN5fteXg+tP8OuovZu0eLS2ub8ijnBu/7BjF0u+3sGnxQc4fuskXP/WiZCZ9uRkZGVGtUSmqNSpF4KNQTu27zom91/hn6RHWLTyIvZM1leoUp3j5gniWK4h7qfwZmh0gM4QGRXL78gNuX37AjfP3uHLah6REHXaO1tRsVoYaTUpTqY5Hph0CfUqXpGPLsiMs/X4zFpZmjFs0gNqtKmTqc+Q092/68c+CfTTvXUcCWw526fANSlQrmqn/kGZERlvawlRVddBfV4DQp7+ns3w1UsJdaVVVk/UtbTWBeGAfMFpV1fj01n8qIy1tAB+UHUXBEvn4Vvq15Vj71pzkh0GLGfpjL9p80EDrcgzehcM3+Wn4nwQ/DqNBh8r0H9MOlwKOb+W5oiNiOXv4Fif3XOPyKW+eBEYAYGxiROHiefEsV5CCRfOQ180J14KO5CvsnOlnC4c/icbvfjD+viE89g3B54Yfdy4/INAvDAAjIwU3D1eq1C/+1lsFzx64zqJJG/G97U+1xqUZ9mPPDJ9xmtMlJyczqs0P3L/px+IzU7B3stW6JKGBqLBo3ss/mB6j29N3/Jv3Z4N32NKmKMpeIK3zw79O/YuqqqqiKOkmQEVR8gIrgX6qqj49V34M4A+YAQtJaaWblM76A4GBAG5ubi8r+4XK1SvB4fWn0SXpZKDVHKrRe9XZu+o4Syaup0qTMri6OWtdkkGrWK8ECw5+zdpf97Jh4X6O77zMe0Oa0GVIkzTn9swIaztL6repQP02FQAI9g9/1rp1+5IvR7alDLz7lJGRgmtBJ1zdHMmd1wF7RxvsHa2xd7LBwckGc0uz50f8QE1WiQyPIfxJNOEhUSmXT6II9g/n/h1/wkOi/7W8a0FHSlQqTLv+BShezo2ipfO/8Rmlr+qhdyALJ67nzP7r5C3szLjfP6RWi3IyWG4m2Lr4INdOejH8l/4S2HKwq8dukZysUu4NJoh/WzLa0nYLaKCq6mN9KDuoqmrxNJazI+XQ6Xfp9V9TFKUBMFJV1ZcONZ3RlrZD607xXZ+5zD74DSWrF3vjxxGGzd83mCF1vqVImQLM2DIqy/ePMhRBj0JZPPUfDm06T578ufhwQkfqtK7wzsKEqqpEhMbg/yCEx/dDeOgTyP07AQQ+CiXYP5zwJ1H/GmPtVVhYmeHgZINjHjsKFs2DWzEX8hfJjaubIy4FHDM9mL5ITFQcq+bs4p9FBzA1N6XXFy1o90H9DA++K1Lcv+nHp42mUK52cSav+UxCcA726xcr2LX8EOse/5bh1vqs0qdtM9APmKa/3PT8AoqimAEbgRXPBzZFUfLqA58CdACuZrCeV1KxYSkUReHc3ssS2nIwVzdnhvzQkx8HL2HN7B30GNFa65Kyhdz5czF63vu07luX+ePW8t3HS3AvlZ/3hjalbusKb711W1GUlJY0R2uKl/9vq7yqqkRFxBIektJ6Fp/O3KM29lbPWuS07isHKdOKbV5ymC3LDhMVFkPTrtXpP6adHArNRAnxiUwfuAhLa3OGz+0vgS2HO7f3CuXqlchSg7FnNLRNA9YoijIAuA90BVAUpQowSFXVD/W31QOcFEXpr1/v6dAefyqKkhtQgIvAoAzW80rsnGzxrFyEs3uu0PvrTu/iKUUW1bhrDc7svsIf07dQqWEpileSDseZpWyNYvyy80v2rz/D2nl7mT5kGcsLOdNlUGOadq2u2SCliqJga2+Frb2VQQwhEvDwCRsW7GfXX8eJj0ukZotydP+sOZ5pBFKRMcun/oPP1YdM/Gsoji72WpcjNOR/L5BHXv5vPNfo25LjBtd9avmk9fw9fRNrHs7HNlfG5lIUhi0yLJohdSdhZmHC3APjsbSReQUzW3JyMid2XWHtr3u4deE+uXLb0rZ/PZp0rU7ufLm0Li/LUVWV62fvsn3FUQ5uOoeiQKPO1egyuLFMQfWWXDx8gzEdZ9GyX10++0nGcMzpti7axy+fLWPRxem4Fc+X4cfLEuO0aSUzQtu147cZ3ngy4/78lLqdMmc6HmG4Lh29xej2M2neuw6fz+mrdTnZlqqqXD5+hzW/7uH8oZsoikKFusVp1bs2NZuXzfEnBoU/iWLXX8fZteokfveCsLAyo0XPWnQa2Ijc+SXcvi2RodEMrjMRc2tzfj0wHou3fBKJyPomdZvDnQt3WXFrVqYcJs8qfdoMVolqRbFxsOL0rksS2gTl6xTnvWEtWDN7B2VqedCkW02tS8qWFEWhfG1Pytf2xO9uEHvXnWbf2lNMHbgY57wOtO5bh2bdauSoQ1OqqnLrwn22rTjCoc3nSYxPokyNYnT/rBm1W1fASlp+36rk5GRmDFpMWHAkP/3xiQQ2QUJ8Iuf3X6Vht5pZrl9jjg1txibGVG1enlM7LqDTJcuZg4J+Y9tz86wPcz5fQcFirjKg5luWr0hu+o5qTa/hLTm99ypblh5m+fStrJixjdLV3KnTpiJ1WlXAyTX7BThVVbl98T5Htl7k6LYLBDx4goWVGc2716RN/7oU8syrdYk5xrLJGzmz5wpDf+wlM6QIAC4fvkFsVBw121TSupT/yLGHR+H/Q3/8tG88pWt5ZkJlwtCFh0QyrMl3xMcl8vPeseTO/3YGiBVpe+gVwKEt5zm69QL3bj5GURRKVS1CndYVKV/bk0LFXQ12Bou4mHhunr/Hmf3XObrtIoEPn2BiakzFusWp26YitVqWlymn3rG9fx/nxyFLaf1+fYb+2CvLtaoIbfwybBl7/jjCukfzMbPInOF8pE9bJoS26PAYuhYcQsdPW/Dh1O6ZUJnIDu7deMTw5tPIVzQPP279Ug6XaOSBlz9HtlzkyLYL3LvhB4CNvSWlqrhTunpRylQrSrFyBbPU6fiphT+J4voZH66e8ubaaW+8rjxAl5SMiakxleqVoE6bitRoVhZbByutS82Rrp/y4qv2MyldoxhT1g7DxDTHHngSqaiqSu9iwyhepSgTVg/LtMeV0JYJoQ1gTJvpBD4IYfGlGZnyeCJ7OLX7MhN7zKV2m4qMXfqxwbbuZBcBD0K4ctKLa6e9uXrKm4fegQAYGRuRr7Azbp6uuHnkxc3TlYIeLuQvkuetz0gAKR/woUGRPPQOwPe2P753/J9dhuqn1zI1N6F4hUKUrlaUMtWLUrJKEaxtpUVNSwEPQhjWZCqWNhb8vPdrGUFAPHPnwj2G1hrPyEUDadq7bqY9rpyIkElqtK7EvOEr8L3llymn9YrsoXqzcgyY2Jnfv1nH0kkbGDCxi9Yl5WguBZ1wKehEk/eqAxAWHKlvvXrIA6+UoHRy91WSdf+f6SBXHjvyFXYmbyFn8hXOjXO+XOTKbYutgxU29lbYOlhjbW+Zbn/WhLhEIsNiiAqPITI8hqiwGEKDInh8Pxi/u8E8vheE370g4mISnq1jaWORMudog5K4ebpSonIRPMu5aTYmnfivqPAYvun+CwlxSczY/KkENvEvx7ecw8hIoWrz8lqXkqYcH9pqt6vM/BErObLhNL3GdNC6HJGFdB7ajMf3glj78y5y5bGn05CmWpck9BycbandqgK1W1V4dltiQhJ+94Lwve2vD1TB+N0L4sKR2+xdezrdxzIxM0lz7tGkRF26y+d1cyJvIWfK1vQgb2FnChTNg5uHK855HaRfVBYWH5vAxJ5zeejlz+Q1w3ArLid8iP9TVZUjG05Ttm4JHHJnzZlGcnxoc87vSOlanhxef0pCm/gXRVEYMqMnYUGRLBy3BjtHa5p0r6V1WSIdpmYmFPLMm+aZl3GxCQT7hREZGk1kWDRR4bFEhkUTGRZDQvx/p7ECsLa1xMbeCht7S2xzWadMa+Vkg3NeBznb3AAlJSbx/YcLuXbSi9GLPqJi/awzCbjIGu5de8iDW350+KSZ1qWkK8eHNoB6naunHCK9+Qi3Evm1LkdkIcbGRny18EMm9PiFn4Yuw9jUmIadq2tdlnhNFpZmFCiaR+syhEZ0STqmfbiIkzsu8ckPPanfqarWJYks6PD6UxgZKdRpn+GuZ2+N/LsI1OlQFUVROLwh/UMoIucyszBl4p+fULqmBz8MWsKRTee0LkkI8Yp0upTBc49uOc/AKV1pO6Ch1iWJLEhVVQ6vP0W5+qVwyJN1x4aU0AY45XWgbJ3iHFp3SutSRBZlYWXOpFWfUqJyEaZ9tIhjW89rXZIQ4iV0umR+GrqUQxvO8ME3naRfqkiXzxVfHt7xp37nrD1DkoQ2vXpdquN74xHel+9rXYrIoixtLJi8Zhge5d2Y+v4CDqyXkC9EVpWYkMS0Dxeyb/VJ+o5tT9dhLbUuSWRhB/4+jrGJMbXaZd1DoyCh7Zn6natjbGLMvr+OaV2KyMKs7Sz5bsNwStcoxoyBi9mx4ojWJQkhnpMQl8iUfvM5sukcH016j54j22hdksjCdLpkDqw+QdXm5bLsWaNPSWjTs3OypWqL8hxYfQJdqrGehHiela0Fk1d/RuVGpZnz+Qr++nErhjhItRDZUcSTKEZ3/InTu6/w6cxedB6adc8EFFnD5cM3CPYLpVH32lqX8lIS2lJp0qM2T/zDuHjwmtaliCzOwsqcb/78hCbda7Liu03MHraCpMQkrcsSIkfzuxvIFy2mcefiPcYsHkjr9xtoXZIwAPtWHcPKzpIarStqXcpLyZAfqVRvVQFreyv2rzpO5cZltS5HZHGmZiaM+PV98hRw4q8ftxLsF8rXSwdhZWuhdWlC5Di3zt1lQo9fSNYl8/3G4ZSp4aF1ScIAxMXEc+yfM9TtVA1zy8yZHP5tkpa2VMwszKjbqRpH/zlDTGSs1uUIA6AoCn3HtmfY7L5cOHSD4S2n4e8brHVZQuQohzac4ct2P2Jpbc5PO0dLYBOv7Pjmc8RExtGoR9Y/NAoS2v6jWZ+6xEXHy/Af4rW07FuXyas/I/hRKMMaT+XysVtalyREtqfTJbN86j98/+FCipZzY/buMRT0cNW6LGFAdi47iGvh3JSrW0LrUl6JhLbnlKrhgVvJ/OxcelDrUoSBqdyoNLP3jMHW0YbRHX7i71nbSU6Wk1qEeBvCgiIY12U2q2Zuo1mv2kz7Z3iWP/NPZC2PvAO4dOgGLd5vgJGRYcQhw6jyHVIUhZbvN+DmGW/uXn2gdTnCwBQo5srPe7+mbvvKLJu8kW+6/0J4SKTWZQmRrVw+dosh9Sdx7ZQXn8/pyxc/98PM3FTrsoSB2bXsIEbGRjTrXVfrUl6ZhLY0NO5RG1MzE2ltE2/EytaC0Ys+4tOZvbh4+Caf1J/MtZNeWpclhMFLTk5m1cxtjG4/E0sbC2bvGUuLPnVRFEXr0oSBSUpMYvfKI1RrWQGnfLm0LueVSWhLg72zLbXbV2HvqmPExyZoXY4wQIqi0Pr9BszaPQZTcxNGtf2B1bN3yBiAQryh0MAIxnf9meVT/6Fex6r8sm8c7qULaF2WMFCntl8kNCCclv3ra13Ka5HQlo6WAxoSFRrNoXUntS5FGLBi5dyYe2ActdtUZOmkDYxqPYMHtx9rXZYQBkNVVfavPcnAmhO4cvw2n/7Um68WfihD64gM2bJwL875clG1eXmtS3ktEtrSUb5eSQqVys+m+XtktHuRIdZ2Voxd8jEj53+A7+3HDKk/KaXVLUmndWlCZGnBfqFM7DmXGR8vJn9RF+YeGE/r/vXlcKjIEN+bj7iw/xqtBzbG2MRY63Jei4S2dCiKQrtBTfG6cI8bp6Q/ksgYRVFo0q0mC09MonqzciydtIHPm32Pz7WHWpcmRJajqio7VhxhYM1vuHj4JgOndGXmjq9wK55X69JENrD5t72YmpnQ6v0GWpfy2iS0vUDjHrWxtrdi0/w9WpcisglHF3vGLR/M10sHEfToCZ82nMLyqf9I30kh9B55BzC20yzmfL6CYuXdmH/kGzoNaYqxsXxdiYyLjohl759Hqf9eDRzy2GtdzmuTd8ELWNpY0KxPXY5sOE3I4zCtyxHZSN32lVl4YhL1O1Vl1cxtfFRjAke3nJdD8SLHio2KY8mkDQyqPZFb5+7y6cxeTPtnOPnc82hdmshG9v5xhNioONoPbqp1KW9EQttLtB3UFF2Sjq2L9mldishm7Bxt+PK3AUzfPBIrGwum9JvPmI4/ySFTkaMkJyezZ9VxBlQbx5rZO6jfqSqLTk+m9fuGM+CpMAzJyclsmr+HElWL4lnZXety3oi8I14if1EXarSpxNaFe4mLide6HJENla9TnF8PjWfI9B54X3nA0PqTmPPFSkIDI7QuTYi36urJOwxr+h0zP1lK7nyO/LRzNCPnfYCTq4PWpYls6OS2Czzy8qfTZy21LuWNSWh7BV2GtSIiJIo9fxzRuhSRTRmbGNPuo0YsOTeV9gMbs/vPY/SvNIbFE9fJjAoi27l1/i7j3pvDyFYzCPUPZ9RvA5i1ezSlqhXVujSRja2bvR2XQs7U6VBF61LemGKIfWiqVKminj179p09n6qqfF7/W8JDIll8+QfpECveukfeAfwxYwsH153GwtqM9h83pvMnzbB1sNa6NCHemPcVX1Z8v5lTOy9h52jDe581p+2AhlhYm2tdmsjmbpzy4vMG3zJkZh/aD2n2zp9fUZRzqqpmOC1KaHtFRzacZkqvXxi/6jPqdKj6Tp9b5Fz3b/rxx/TNHNl0Dms7SzoNaUq7gY0kvAmD4nPtIX/9sJWjm89hY29Fp0+a0n5gY6ztLLUuTeQQk3v8zMVD1/nj9mwsbd79wMwS2t5xaNPpkvmgzEhy5bFn1sEJMrijeKd8rj5g5bTNnNh+EQtrc1r2qUv7QY1xdXPWujQh0qSqKhcO3mD9r7s5t/8aVjYWdBjUhE6fNMXG3krr8kQO8sg7gAFlR9FtVFve//Y9TWrIrNBmkhnF5ATGxkZ0+bwVcz9fzqXDN6hQv5TWJYkcxL1MQb754xN8rj5g3dzdbP79AJsW7qNOu8p0/qQZxSsX0bpEIQBITEji4PrTbJi3h7vXHpIrjx39x3Wg9fsNsM0lLcTi3VszcysmZia0G2SYw3ykJi1tryEhLoF+JUdQsHheZuwc+86fX4ingh49YdPC/exYfpjoiFhKVStKq/71qNu+CuaWZlqXJ3KggAch7Fp5lJ1/HOGJfziFS+an05CmNOhSDTNzU63LEzlUwP1g3i8zktYfNuKTWX01q0MOj2oQ2gA2/LyDBV/9xcy94yhTu7gmNQjxVExkHLv+OMrWJQd45B2Ijb0VjbvVpGW/uhQumV/r8kQ2p0vScXr3FbYvP8zZvVcBqNK4NO0/bkzlRqWlG4nQ3C/DlrFz6UGWXptJnoJOmtUhoU2j0BYXE0/fEl9QrHxhvtvypSY1CPE8VVW5fPQW25cf5tiW8yQl6ihVvRhNe9SiTrtKcuKCyFT3b/pxYN0p9qw6TsjjMBxd7Wneqw4t+tbFRcMvRiFSC370hP6lRtC0T12Gzf1A01qkT5tGLKzM6fxZK5aMX83NM96UqCrjCgntKYpC+bolKF+3BGHBkexddZwdK48w5/MV/DrqT6o2LUvDztWo1rwcFlYyvIJ4fYEPQzi04QwH1p3C5+pDjIwUKjcqzdAfelGtWVmMTYy1LlGIf1k7azs6XTLdRrbRupRMIy1tbyAmMpa+JYZToqo7U/4ZpVkdQryIqqrcuXifg+tPc2jjGUIeh2FpY06NlhWo3aYSVRqVlvGxxAsFPAjhxPaLHNl0lmsnvQAoUcWdhl2qUbd9FRxdDG/CbZEzhPiF0r/0COq/V4ORCwdqXY60tGnJytaS975ozZLxq7l24jala3pqXZIQ/6EoCp4VC+NZsTADvu3C1eO3ObDuNEe3nOPA2lOYWZhSsUEparWqQPUW5XFwttW6ZKExVVW5e/0RJ7Zd4Pj2i3hf9gWgUIl89Pu6Aw06VyNv4dwaVynEy62asQldUjK9xnTQupRMJS1tbyguOo7+pUdSsHg+ZuwcIx1uhcFISkzi2kkvjm+7yIntFwh8+AQjI4USVdyp1LAUlRqWpnilwnK4K4eICo/h0pGbnD9wnbP7rhLgG4KiKJSs6k7NVhWp2ao8BYq5al2mEK/M/34QA8qOonn/+nz28/talwPIiQiahzaATfN2M2/ESr7f9hWVGpXRuhwhXpuqqnhfecCJbRc4s+8qdy7cR1VVrO0sqVCvJJUalaJc7eIUKOYi/5hkEwlxidy+eI+Lh25w/sB1bp67S7IuGUsbc8rVKUGN5uWo3qK8HPoUBuvHgQs5tPYkS6/+iHN+R63LASS0ZYnQlhCfyICyo8jlYs+cwxPlS00YvIgnUVw8dINzB65z/sB1gh49AcDeyYbSNYpRuroHpWsUo2g5N0zNpHeFIYgMjeb6aS+unfTi6kkv7ly4R2JC0rPD55UalqJyo1KUqOKOian8TYVh873lx8eVRtNhaAs+nt5T63KekT5tWYCZuSm9xnZg1uDFnNh6nlptK2tdkhAZYudoQ72OVanXsSqqqvLQK4BrJ+9w7aQX106lHFIFMLMwxb1MQTwrFsKzUhGKVypC/qJ5MDIy0vYF5HDxsQl4X/bl1vl73Dp/lzsX7/HIOxAAE1NjPCoUpv3HjSldoxhlanjIDAUi21k5eQPmVubZ6ozR1KSlLYN0SToGVk7p0/bbmanyn6rI1p4EhHP9lBfXT3tz5+J97ly6T1x0PJBygk7RcgUpWqYgRUoXwL1MQQqVyIeZhYyG/zaEBUfic/UBd6895O61h/hcfcC9G34k65IBcM7rgGflInhWKETpGh54Viwss2WIbO3maS+G1f+WnmM60G9CZ63L+Rc5PJpFQhvAia3nmfjeLIbO6UfbgU20LkeId0anS+bBrcf6Vp37eF26z90bj4iPSQDAyNiIAkVdKOiZlwIeLhT0cKWgR8p1azuZNPxlVFUl+FEoD+7489DLP+Xyjj/3bvoRGhD+bDlHV3uKlCqAR8VCFK9UBM+KhXFyddCucCHeMVVVGdF4Cn4+ASy9+iOWNhZal/Qvcng0C6nRuiLl6pZg5ZQNNOpeG2s7S61LEuKdMDY2onCp/BQulZ/mvesAKUHO/14QPleftv484v4tP07uvIQuSfdsXYfctri6OePi5oxLIWdc3ZxxLeRM7vy5cHR1yBHvo+TkZMKDowh+HErggxD87wcT8CCEgPvB+N8Pxt83+FkABrCysaCApyuVG5aiSOkCz1o0ZbgWkdMd/ecs107cZtivH2S5wJaZpKUtk9w5f5ehtSfQbVRbPpjUVetyhMhykhKTeHwvmIdeKa1Fj7wD8fcNJsA3mMAHT/4V6AAsbcxxdHXAOa8Djq4OODjZYu9sg51jyqW9sy22DtbY2FthbWeJuZWZ5icD6XTJxETGEh0RS0xELOEhUYQHRxIeEklESBThIVGEBkYQ4h9GyOMwngSE/+d1W9lYpIRYfZAt4OFCAY+8FCjmgqOLveavUYisJjEhiY8qfoW5pRnzTk3F2Djr9a2VlrYsxqNSERr3qM2Gn3fSekAjXAo5a12SEFmKiamJ/vCoK7T89306XTIhj0Pxvx9MsF8oIY/DCXkcSvDjMJ74h3H9lBcRT6KIjYpP9/GNjI2wtrPE2s4SC2tzLCzNMLcyw9wy5cfMwhRjE2NMTFN+nl5XjIx4Pgepakp/VV2ijqQkHbqkZHSJOhITk4iPTSA+JiHlUn89JiqOmIhYYqLi0q1PURRsc1lj72SDU75clK9b/F+hNE8BR1wLOWOby1qCmRCvYcuCvTz2CWTKplFZMrBlJmlpy0SBD0IYUG4UNdtUYuzKoVqXI0S2Ex+bkNJi9SSlBSsyNJroyJRWreiIWKLCY4iOiE0zWMXFJpCclBLCkhJ16PSXanLan4HGJv8PdsamxhgbG2FqZvIsBD4LhBamWNpYYGNvhZU+NFrbWWJtb4W9kw12jk9bBa1kwGIhMll4cCQflBtF8crufLflS63LSZe0tGVBeQo60XVEG/6YupHWHzWmfL2SWpckRLZibmlG7gKO5C6QNQbMFEJoa9nEtcRGxvHxjF5al/JOZO92RA10HdEGFzdn5g1f8Z++KkIIIYTIHLfP+bBjyUHaD25KoZL5tS7nnZDQlsnMLc34eEYv7l17yJYFe7UuRwghhMh2kpOTmTd8JQ557Oj9dUety3lnJLS9BbXaVaZS4zKsmLyBsMDwl68ghBBCiFe298+j3DjtxYAp3bC2zzljPkpoewsURWHwzD7ERcezePwarcsRQgghso2osGgWj1tNyerFaNyzttblvFMS2t4St+L56PRZC3avOMyVoze1LkcIIYTIFpZMWENEcCSfzOqX4+Y7zlmv9h3rPbYDLoWcmTN0KQnxiVqXI4QQQhi06yfvsG3Rfjp80hyPioW1Luedk9D2FllYW/DpnP48uOXHmplbtS5HCCGEMFhJiUnMGbqE3AWc6JvFJoR/VzIU2hRFcVQUZY+iKHf0l7nSWU6nKMpF/c/mVLcXURTllKIoXoqirFYUxSwj9WRFVZuXp36X6vw9fTO+t/y0LkcIIYQwSGtnbefetYcMnd03W88v+iIZbWkbDexTVdUD2Kf/PS2xqqpW0P+0S3X7dGCWqqrFgFBgQAbryZIG/dAbcysz5nyyhOTkZK3LEUIIIQzKIy9//vzuH+p2rEqN1pW0LkczGQ1t7YHl+uvLgQ6vuqKSMrleI2Ddm6xvSBxdHfjo+x5cPXaLbb/v17ocIYQQwmAkJycza/DvmFmYMnhmX63L0VRGQ5uLqqqP9df9AZd0lrNQFOWsoignFUXpoL/NCQhTVTVJ//tDINsOady8X30qNirN72P/xv9eoNblCCGEEAZh8/w9XDl6i0E/9MIpr4PW5WjqpaFNUZS9iqJcTeOnferl1JSZ59Obfb6QfqLUnsBsRVGKvm6hiqIM1Ae/s0FBQa+7uuYURWH4/A8xMlKY+fHvcphUCCGEeIlHXv4sGb+Gai0r0LR3Xa3L0dxLQ5uqqk1UVS2Txs8mIEBRlLwA+ss0m5BUVX2kv/QBDgIVgRDAQVGUp5PWFwAevaCOhaqqVlFVtUru3Llf4yVmHXncnPl4Ri8uH77BlgX7tC5HCCGEyLJ0umRmDlyEqbkJn8/9gJReVTlbRg+Pbgb66a/3AzY9v4CiKLkURTHXX3cGagPX9S1zB4AuL1o/u2nerz5VmpVj8bi/8fMJ0LocIYQQIkv6Z+4urp24zZCf+uKUL83BKXKcjIa2aUBTRVHuAE30v6MoShVFUX7XL1MSOKsoyiVSQto0VVWv6+/7ChiuKIoXKX3cFmewnixPURQ+/3UAJqYmzBy4CJ1ODpMKIYQQqfne8mPZxLXUbFOJRt1raV1OlqGkNHgZlipVqqhnz57VuowM2fPnUX78cAEfTOpKt1FttS5HCCGEyBISE5L4vMG3BPoGs+Ds9zi6OmhdUoYpinJO37c/Q2RGBI006Vmbup2qsXzSem6f89G6HCGEECJLWP7tOrwu3OOLeQOyRWDLTBLaNKIoCsPmfkAuF3um9Z9PXHSc1iUJIYQQmrp48BrrZm2n1YCG1GqX4YapbEdCm4Zsc1nz5ZJB+HkHMH/Un1qXI4QQQmgmIiSSHwYsIL+HKx9P76l1OVmShDaNla9Xkq4jWrNz6UGO/nNG63KEEEKId05VVeYMXUpYUASjlw3Bwjpnzi36MhLasoA+4zvjWakIs4YsJuB+sNblCCGEEO/U9sUHOPrPGfp90wWPioW1LifLktCWBZiamTBm5Sck65L5rs9cEhOSXr6SEEIIkQ14X7rP/JF/ULlpWbp80UrrcrI0CW1ZRD53F76YN4CbZ7xZMn6N1uUIIYQQb11MZCxTe8/FztGGLxcPwshIYsmLyNbJQup1rk7bj5uw4ecdHN9s2OPQCSGEEC+iqiqzBi/m8d1AxqwYgkNuO61LyvIktGUxA6f3xLNSEX4cuEimuRJCCJFtbZ6/h8PrT/H+t+9Rtk4JrcsxCBLashgzc1O+/utTFCOFKT1/IT42QeuShBBCiEx145QXC0f/RY3WFaUf22uQ0JYFuRbKzZeLB+Fz2Zc5nyzBEKcaE0IIIdLyxD+MyT1+xjm/IyMXfSz92F6DbKksqnrLCvQZ34l9q46xce4urcsRQgghMiwxIYkpPX8hKjyaiWu/wDaXtdYlGRQJbVlYj6/aUattZRaNWcXFQ9e1LkcIIYTIkPkjV3LtxG1GLBhIkTIFtS7H4Ehoy8KMjIwYtfhjCni48l3vuTLwrhBCCIO1Y+lBti3aT9cRbajfpbrW5RgkCW1ZnJWtJd+s+ZykRB3fdpstE8sLIYQwONeO32busGVUblKW/t++p3U5BktCmwEo4JGXMcuHcPeKLzM+WEBycrLWJQkhhBCvxP9eIN92n00eN2fGrPgEY2OJHm9KtpyBqNq8PB9N68mxzWdZMm611uUIIYQQLxUVFs34jjPRJer4dv1wOfEgg0y0LkC8uo5Dm+Pn7c/aWdvJV8yVVh801LokIYQQIk1JiUlM7vkLj7wC+G7rl7gVz6d1SQZPQpsBURSFwT/2wf9eEL98tgyXQs5UblxW67KEEEKIf1FVlV+GLefigWuMWPgRFeqX0rqkbEEOjxoYYxNjxqwYSqGS+ZnS8xfuXX+odUlCCCHEv6ybtZ2dSw/S/ct2NOtTT+tysg0JbQbI2s6SSeuHY2FlxoSOM3niH6Z1SUIIIQQARzaeYfG41dTvUp1+33TWupxsRUKbgcrj5sy364YTFhzBuA4/Eh0eo3VJQgghcrhLh28wvf88SlQryoiFA2WKqkwmW9OAeVZ2Z8Lfw7h37SETu84mIU4mlxdCCKEN70v3mfjeLPIWdWHShhGYW5ppXVK2I6HNwFVpWo6RCz/i8uEbTH//N3Q6GcNNCCHEu/X4biBft/8Bazsrvtv8JXaONlqXlC1JaMsGGvWozcfTe3L0nzP8+sVyVFXVuiQhhBA5RGhAOGPaTCcpUcd3W0aRu4Cj1iVlWzLkRzbR6bOWhAZGsGbmVhxd7On9dSetSxJCCJHNxUTGMq7jjzzxD2P69jG4lcivdUnZmoS2bOSDyV0JC4pg5ZSN2Oayof2QZlqXJIQQIpuKj01g4nuz8Lnsy6T1wylZvZjWJWV7EtqyEUVR+PzXD4gKjWbeiJWYWpjKrAlCCCEyXUJ8IpO6z+Hy4Zt8uWQQVZuX17qkHEH6tGUzxibGjFn5CVWbl+PnoUvZ8+dRrUsSQgiRjSQlJjG191zO7r7M5/M+oFH3WlqXlGNIaMuGzMxNGb9qGOUblOKngQs5uPak1iUJIYTIBnRJOqb1n8/JrecZOrsfLfo30LqkHEVCWzZlbmnGt2s/p1RNT6a/P59jm85qXZIQQggDptMl8+NHCzmy4TQfT+9J24+baF1SjiOhLRuzsLZg8sYRFK/sznd95nJy23mtSxJCCGGAkpOTmT1kMfv/Ps77k96j02cttS4pR5LQls1Z2VoyZdNI3Mu6MbnHzxLchBBCvBadLplZgxeze8Vhen/dke6j2mldUo4loS0HsHGw5vttX+FerhCTuv/MkQ2ntS5JCCGEAdAl6fhhwG/PAlufcTIGqJYktOUQNg7WTNs+mhJVi/Jdn7nsX3VM65KEEEJkYYkJKWeJHlh9gg8mdZXAlgVIaMtBrO0smbp5FGXrlmDGgAXsXHZQ65KEEEJkQQlxCUzqPodjm84y6IfedBvVVuuSBBLachxLGwsmbxxJ5aZlmTV4MZt/26N1SUIIIbKQuJh4vukyi9M7LvLZL+/TcWhzrUsSehLaciBzSzO+WfM5NdtU4tcvVvD3D5tlknkhhBBEh8cwtu0MLh64xshFA2n9YSOtSxKpSGjLoczMTRn316c07FaTpRPWsnD0KpKTk7UuSwghhEZCHocxstlUbp72ZvTyT2jau67WJYnnyNyjOZiJqQlfLhmEnaMNG37eQVhgOMMXfISpmewWQgiRkzzy8mdMm+mEB0cyeeMIKjcpq3VJIg3y7ZzDGRkZMXhmHxzzOrB0wlrCgyMZv+ozLG0stC5NCCHEO3D7nA/jOv4IKszYOZbiVdy1LkmkQw6PChRFofuodnwxfwAX9l/lyxbfExYUoXVZQggh3rJz+64wqvl3WFiZ89P+8RLYsjgJbeKZFv0bMGH159y79oDhjSbz+G6g1iUJIYR4S/b/fZwJHWeSr6gLsw58QwGPvFqXJF5CQpv4l5ptKjFt22jCQyL5vMG3XD95R+uShBBCZCJVVfnz+3+Y/v58StX05MfdX+OU10HrssQrkNAm/qN0LU9mH/wGSxsLvmzxPQfXnNC6JCGEEJkgIT6RHwYsYMWk9TTpVYepm0dhbW+ldVniFUloE2kq6JmXOYcmUryKO9/3m8ef3/8jY7kJIYQBCw+OZHSraexbdYx+E7swctFAzMxNtS5LvAYJbSJd9s62fL/tK5r0qsOKSev5YcACEuITtS5LCCHEa/K95cewehO5c/4uY1cOpedX7VEUReuyxGuSIT/EC5mZmzJy0UAKeOZl2Tdr8b8XxITVw3DIbad1aUIIIV7BhQPXmNLzZ0zMTPhh11hKVCumdUniDUlLm3gpRVHo8WU7xq4cyp0Ld/m09gS8Lt7TuiwhhBAvoKoqG37Zydi2M3DKl4s5hydKYDNwEtrEK6vfpToz944jOVlleKPJ7P/7uNYlCSGESEN8bAI/DFjAgi//pGbrSsw++A2uhXJrXZbIIAlt4rV4Vnbn1+OT8KxchOnvz2fBV3+hS9JpXZYQQgi9QN9ghjdO+ce63zedGbfqU6xsLbUuS2QCCW3itTnksWfa9tG0H9yUDT/vYGy7HwgPjtS6LCGEyPEuHb7B0NoT8PMOYOK6L+g5ugNGRvJVn13IX1K8ERNTE4b81JcRCz/i2vHbfFp7ArfP+WhdlhBC5EiqqrJ+zg5Gt5qGnZMtPx/5lhqtKmpdlshkEtpEhjTrU4+Ze8ehqin93LYs2CvjuQkhxDsUFRbN5B4/s3D0X9RsXYk5hydS0FOmpMqOJLSJDCtexZ1fT0ymQsNSzP18Od/3/ZXoiFityxJCiGzv9jkfPqk5npPbLvDR9z0Y//dnWNtJ/7XsSkKbyBR2TrZM2jCCDyZ15cjGM3xaewLel+5rXZYQQmRLqqqyaf4ehjeajC4pmR/3fE2Xz1vJgLnZnIQ2kWmMjIzoNqotM3aOJS46nmH1v2Xron1yuFQIITJRVFg0U3vPZd7wFVRsVJp5JydTqoaH1mWJd0BCm8h0ZesUZ96pKZSvX5JfPlvGpG5ziAiRs0uFECKjrh67xeBqX3N88zkGTOnGt+uHY+dkq3VZ4h2R0CbeCofcdkzeOIKB03pyeudFBlf7mouHrmtdlhBCGCRdko6VUzYwqtlUjE2N+Wn/eLqOaCPDeeQwGfprK4riqCjKHkVR7ugvc6WxTENFUS6m+olTFKWD/r5liqLcTXVfhYzUI7IWIyMjOg9ryZzDE7GwsWB0y2n8/vXfJCYkaV2aEEIYjMd3AxnRZAp/TN1Iox61mXdyCiWqFtW6LKEBJSP9jRRFmQE8UVV1mqIoo4Fcqqp+9YLlHQEvoICqqjGKoiwDtqqquu51nrdKlSrq2bNn37hu8e7FRcexYPQqtv++n2IVCjFq8SAKlyqgdVlCCJFlqarK7pVH+G3kShQjIz77uT8NutbUuizxBhRFOaeqapWMPk5G21XbA8v115cDHV6yfBdgh6qqMRl8XmFgLKwtGPbL+3yz5nOCHj5haM3xrP5xKzpdstalCSFElhPyOIxvuvzETx8voliFwvx2eqoENpHh0Oaiqupj/XV/wOUly3cHVj1321RFUS4rijJLURTzDNYjsrhabSuz8Nz3VGtZgSXjVzOi0WQe3H788hWFECIHUFWV/X8fZ2Dl0Vw8cJ1BP/Rm+s4x5HFz1ro0kQW89PCooih7Adc07voaWK6qqkOqZUNVVf1Pvzb9fXmBy0A+VVUTU93mD5gBCwFvVVUnpbP+QGAggJubW+X792UMMEOmqioH15xk7hfLSYhN4P1v36PD0ObSqVYIkWOFBYbz86fLOLb5LCWrF2PkooEU8JCZDbKDzDo8mtE+bbeABqqqPtYHsIOqqhZPZ9lhQGlVVQemc38DYKSqqm1e9rzSpy37CHkcxpyhizm1/SKla3nyxfwPZfoVIUSOoqoqB1af4LdRfxATGUe/CZ3pNKwlxsbyT2x2kVX6tG0G+umv9wM2vWDZHjx3aFQf9FBShnDuAFzNYD3CwDjldeDbdcMZuWgg968/ZHDVsfw17R85w1QIkSME3A9mfMcfmf7+fFwL5+bXE5N5b3hrCWwiTRltaXMC1gBuwH2gq6qqTxRFqQIMUlX1Q/1yhYFjQEFVVZNTrb8fyA0owEX9OlEve15pacuenviHMX/kHxxef4rCpQvwxbwBlKhWTOuyhBAi0+l0yWz5bQ9Lv1kLQP+J79FucFMJa9lUljg8qhUJbdnbyW3n+WXYckL8Qmk/uCn9JnbBylYmQBZCZA/3rj1g1uDF3DzjTdXm5fh0zvu4FJITDbIzCW0S2rK16IhYlk5Yw9aF+3DKl4tBP/SmTocqMhmyEMJgxUbF8cfUjWycuwsbBysG/dCbht1qyudaDiChTUJbjnD95B1+GbYMn8u+VG5alk9+6kv+YmmdzCyEEFmTqqoc3XiG3778k+BHT2jRvz4fTO6GvbPMGZpTSGiT0JZj6JJ0bFmwl+XfriMxPon3hrem26i2WFjJsH5CiKztwe3HzBu+gvP7ruJezo2hs/tRuqan1mWJd0xCm4S2HCfkcRiLv/6bfauO4eLmzIffdadup2pyaEEIkeVER8SyavomNv6yEzNLM/pN6Ezbj5tgbGKsdWlCAxLaJLTlWJeP3GDe8JXcvfqAMrWLM2hGLzwqFdG6LCGEQKdLZveKwyybuJawwAia9q7DgCndyeVir3VpQkMS2iS05Wg6XTK7lh1k2bfriAiOommfuvSf+B5OeR20Lk0IkUNdOnyD30b9gc9lX0rX9GTQD73wrOyudVkiC5DQJqFNANHhMayasZl/5u7C2NSYbqPa0unTFtLfTQjxzjy885gl49ZwbPNZXNycGTC1O/U6S9cN8X8S2iS0iVT8fAL4fczfHNt8FkdXB/qM70TzvvWk/4gQ4q154h/Gn9//w/bFBzCzMKXbqLZ0/qwl5pZmWpcmshgJbRLaRBquHb/NorGruHHKi4LF8/HBpPeo2bay/McrhMg0MZGxrJu9nfVzdpAYn0TLDxrQe2xH6bcm0iWhTUKbSIeqqpzYco4lE9by4JYfJasX44PJXSlXt6TWpQkhDFhCXALbFx/gr+mbCA+KpF7n6vSf2EXGjhQvJaFNQpt4CV2Sjt0rj7By8gZCHodSoUEp+o7vTOlaMkaSEOLVJcQnsmv5If6evplgv1DK1SvJh1O7U7yKnGQgXo2ENglt4hXFxyaw7ff9rP5xC2GBEVRuWpa+4zrJZPRCiBdKSkxizx9H+ev7fwh8EEKpGh70+6Yz5euXki4X4rVIaJPQJl5TXHQcWxbsY81PW4kIiaJaywr0Gt1ewpsQ4l8SE5LYv+oYf03bhP+9IIpXcaffN12o1LiMhDXxRiS0SWgTbygmMpbNv+1h3ewdRD6JomKj0vQc3Z6ydUrIB7IQOVh8bAK7lh9izcxtBD0MwaNSEfqM60S1FuXls0FkiIQ2CW0ig2Kj4ti6aB/r5+wgNCCc0jU96TG6PVWalpUPaCFykOc/C0rV8KDHV+2o2lzCmsgcEtoktIlM8vx/18UqFKLzsFbU61wNE1MTrcsTQrwloQHhbP5tD1sW7nvW6t7jq/aUqyut7iJzSWiT0CYyWWJCEvv+Osq62Tt4cMuP3AWc6Di0OS3eb4C1naXW5QkhMonvzUes/3kn+/46RlJCEjXbVKLriDaUrC79W8XbIaFNQpt4S5KTkzm98xLrZ2/n8pGbWNlZ0npAQ9oNakoeN2etyxNCvAFVVbl0+AYbft7Bqe0XMbMwpVnfenT6tIWMsybeOgltEtrEO3D7nA/r5+zg8IbToKrUaleFDp80o0zt4nL4RAgDEBcTz/6/j7N5/h7uXn2AfW5b2g1qSpuPGuOQ207r8kQOIaFNQpt4hwLuB7Nl4V52LjtE5JMo3Mu50WFIMxp0rSnzDAqRBT19z+5YepCo0Gjcy7nRfnBTGnarJe9Z8c5JaJPQJjQQFxPPgdUn2DRvN3evPsDW0YamverQckBD3Irn07o8IXI0nS6Zs7svs33xfk7vuAhA7fZVaD+kOWVqe0rruNCMhDYJbUJDqqpy+chNtizYy/HN59Al6ShXtwStBjSidocqmJmbal2iEDlGiF8oO5cfYufSgwQ+CCGXiz3N+tajzYeNpB+qyBIktEloE1lEaEA4u1ccZvuSA/jfC8Le2ZbGPevQvG9dCpcuqHV5QmRLSYlJnNl1md0rDnNy+wWSdclUbFSa1gMaUaNNJUzNZLgekXVIaJPQJrKY5ORkLuy/xrbf93Ny2wV0STo8KxWhaZ+6NOhaEztHG61LFMLg3bv2gF0rjrD/72OEBUbgkMeOpr3r0vKDhuQv6qJ1eUKkSUKbhDaRhYUFRXBg9Ql2rzyMz2VfTM1MqNm2Mo171qZK07IyaK8QryEsMJxD60+z948j3D5/F2MTY2q0qkizvnWp0qycvJ9EliehTUKbMBBeF++xZ+UR9q8+TkRIFHZONtTrXJ1G3WpRskYxjIyMtC5RiCwnNiqOE1vOsX/1cc7tvUqyLhn3cm4061OPht1qynAdwqBIaJPQJgxMYkIS5/Ze4cDfxzmx9TzxsQm4uDnToGsN6naqTrEKheTsNpGjJcQlcHbPFQ6tO8WJreeIj0kgT0EnGnarSaPutaSPqDBYEtoktAkDFhMZy/Et59j/93Eu7L9Gsi6ZvO55qNuxGvU6VaNYxcIS4ESOEB+bwNndlzm84TSntl8gNioOW0cb6nWuRqNutShV00Nao4XBk9AmoU1kE+HBkRzfco4jG09z8cB1dEk6XAvnpla7KtRqW4lSNTwwNjHWukwhMk1UWDSnd17ixNbznN55kbjoeOydbanVrjJ1O1WjfL2S0k9NZCsS2iS0iWwo4kkUJ7ae5+jG01zYf43EhCTsnGyo3rICtdpWplKTslhYmWtdphCvLfBBCCe2nuf4lnNcOXITXZKOXC721GxbmXqdqlGubgn550RkWxLaJLSJbC4mMpZze65wfMs5Tu+8SFRYDGYWppSvX5KqzStQtXk58rnLEAcia9Il6bh+0oszuy9xZtclfC77AlCweD5qtqlErbaVKV7VXQ59ihxBQpuENpGDJCUmcfXYLU5svcDZ3Zd4eMcfgAIerlRtXp4qzcpRpnZxaYUTmgp6+IQLB65yZtdlzu+7QlRYDMYmxpSu5Um15uWp2bYSBTzyal2mEO+chDYJbSIHe+QdwNldlzi96xKXD98gIS4RUzMTStbwoGKj0lRqWBqPSkXkcJN4q6LDY7h0+AYX9l/jwoFrPLjlB4CjqwNVm5ejavMKVGpUGmt7K40rFUJbEtoktAkBpExif+34bS7sv8qFA9fwungfAGt7K8rWKU6Z2sUpW6cExSoUks7dIkOiwqK5evw2V4/e5PKRm9w5f5fkZBVzKzPK1ilBxYalqdioNO5l3eTsZyFSkdAmoU2INIUFRXDp0A0uHLjKlSM3nx1KtbA2p3RNT8rU9qRUTU9KVHHHwtpC42pFVhb86AnXT97h2vHbXDl2C5/LvqiqiqmZCZ5V3ClfrySVGpehRLViMtenEC8goU1CmxCv5Il/GFeO3uLK0ZtcPXaLu1cfAGBkbIR7OTdKVfegVA0PSlYvikuh3NJCkkMlJiRx94ovN055cf3kHa6fvEPggxAAzC3NKFnDg7J1UlptS1QtirmlmcYVC2E4JLRJaBPijUQ8ieLWGe9nX8w3z3gTFx0PgJ2TDR6ViuBZqQield3xrFQEp3y5JMhlM7okHb43/bh9zofb5+9y+6wPd68+IDEhCYDcBZwoWb0YpWqkBHr3cm7SkiZEBkhok9AmRKbQJem4e/UBt876PPsSv3ftIcm6ZADsc9viXtaNouUK4V7ODfeybhQsnlf6xxmI6PAYfK48wOfyfXyu+OJz2Zd71x+SEJcIgJWdJR4VCz8L6SWqFSNPQSeNqxYie5HQJqFNiLcmLiYen8u+3Dl/F+/L9/G+7Mv9649IjE/5ojcxNSa/hyuFShagUMl8uJXIT6FSBchX1EVaZDQSFRaN700/fG8+4v71R9y/+QjfG34EPQx5toydkw3u5QrhXtaNYhUK4VnZnfzFXGSsNCHeMgltEtqEeKeSEpN4ePsxPpd98bn6AF99KPC/F8TTzxEjIwWXQrnJV8yFAsVcyV/MlXzFXMlbJDd5CjphZiH9oN6UqqpEhcXgfy+Ixz4BPPIO4JGXP4/u+PPI25/woMhny5pZmOJWIiVMu5XMT1F9C6kc6hZCGxLaJLQJkSXExcTz4NZj7t94mBIgvPxTAsUdf2Kj4v61rFPeXLgWzo1LIWfyuDmTp6ATzvkdcc6fi9z5HbF1tMmxoUKXpCPkcRjBj548+wl6+AT/e0H43w8i4H4w0eEx/1rHKW8u8hdzIV8xV/IXdUkJaiXz41IoN8bG0nomRFYhoU1CmxBZmqqqhAaE88grgADfoJTwcS+IgHspASTo0ZNn/eaeMrc0I5eLPbny2JPLxR4HF3ty5bEjVx57bB1tsHOywc7RBttcKdctrM2zbMjT6ZKJDo8h8kkUESFRRIZGEfEkivCgSEIDwwkLDCc0MILQgHBCA1J+T07+9+exuZUZLoVy41o4N676S5dCzuQtkod8RV2wtJEhW4QwBJkV2qTziRDirVAUBUdXBxxdHShL8f/cr0vSERoQntKi9ChU37IUQmhAOE8CwvHzCeDaydtEBEeR3j+XxibGWNlZYmVrob9MuW5hZY6ZpRnm+h8zSzPMLEwxMTXG2MQYE1MTjE2MMDE1RjEy4vncp6op9emSktElJpGUqEOnSyYpIYn42ATiYxJIiEsgPjaBhNhEYqPjiImIJSYy9tllbFR8unWbmBqTy8WBXHnscM6fC4+KhXHMm4vcBRzJnd9R3/roiI2DVZYNpUKId09CmxBCE8Ymxs/CSYkXLKdL0hEWFElkaBSRT1J+IvStV1Fh0cRExv0rLIUFRRIfE5wSrmITSIhNID42EV2SLlPqNjU3xdzSFHNLc8wsTTG3NMPS2gJreytyF3D8f3i0s8Q2lw22jtbYOepbCB1tsHOylTAmhHgjEtqEEFmasYkxTnkdcMrrkKHHSWk506W0mqVqQXv+kGTq501pmUtpkTPWt87JmZZCCK1IaBNC5AjGJimHRs2kG5gQwkDJv4xCCCGEEAZAQpsQQgghhAGQ0CaEEEIIYQAktAkhhBBCGAAJbUIIIYQQBkBCmxBCCCGEAZDQJoQQQghhACS0CSGEEEIYAAltQgghhBAGQEKbEEIIIYQBkNAmhBBCCGEAJLQJIYQQQhgACW1CCCGEEAYgQ6FNUZT3FEW5pihKsqIoVV6wXAtFUW4piuKlKMroVLcXURTllP721YqimGWkHiGEEEKI7CqjLW1XgU7A4fQWUBTFGPgVaAmUAnooilJKf/d0YJaqqsWAUGBABusRQgghhMiWMhTaVFW9oarqrZcsVg3wUlXVR1XVBOBvoL2iKArQCFinX2450CEj9QghhBBCZFfvok9bfuBBqt8f6m9zAsJUVU167nYhhBBCCPEck5ctoCjKXsA1jbu+VlV1U+aXlG4dA4GB+l/jFUW5+q6e24A4A8FaF5HFyDZJm2yXtMl2SZtsl/+SbZI22S5pK54ZD/LS0KaqapMMPscjoGCq3wvobwsBHBRFMdG3tj29Pb06FgILARRFOauqaronPuRUsl3+S7ZJ2mS7pE22S9pku/yXbJO0yXZJm6IoZzPjcd7F4dEzgIf+TFEzoDuwWVVVFTgAdNEv1w94Zy13QgghhBCGJKNDfnRUFOUhUBPYpijKLv3t+RRF2Q6gb0UbCuwCbgBrVFW9pn+Ir4DhiqJ4kdLHbXFG6hFCCCGEyK5eenj0RVRV3QhsTON2P6BVqt+3A9vTWM6HlLNLX9fCN1gnJ5Dt8l+yTdIm2yVtsl3SJtvlv2SbpE22S9oyZbsoKUcphRBCCCFEVibTWAkhhBBCGIAsG9pkiqz/UhTFUVGUPYqi3NFf5kpjmYaKolxM9ROnKEoH/X3LFEW5m+q+Cu/6NbwNr7Jd9MvpUr32zaluz3b7Crzy/lJBUZQT+vfaZUVRuqW6L9vsL+l9TqS631z/t/fS7wuFU903Rn/7LUVRmr/Twt+yV9guwxVFua7fN/YpilIo1X1pvp+yg1fYLv0VRQlK9fo/THVfP/177o6iKP3ebeVv1ytsl1mptsltRVHCUt2XLfcXRVGWKIoSqKQzDJmS4mf9NrusKEqlVPe9/r6iqmqW/AFKkjKuyUGgSjrLGAPegDtgBlwCSunvWwN011//DRis9WvKhG0yAxitvz4amP6S5R2BJ4CV/vdlQBetX4dW2wWISuf2bLevvOp2ATwBD/31fMBjwCE77S8v+pxItcwQ4Df99e7Aav31UvrlzYEi+scx1vo1vcPt0jDV58fgp9tF/3ua7ydD/3nF7dIfmJvGuo6Aj/4yl/56Lq1f07vaLs8t/ymwJAfsL/WASsDVdO5vBewAFKAGcCoj+0qWbWlTZYqstLQn5bXAq72mLsAOVVVj3mZRWcDrbpdnsvG+Aq+wXVRVva2q6h39dT8gEMj9rgp8R9L8nHhumdTbah3QWL9vtAf+VlU1XlXVu4AXb3byVFb00u2iquqBVJ8fJ0kZTzO7e5X9JT3NgT2qqj5RVTUU2AO0eEt1vmuvu116AKveSWUaUlX1MCmNI+lpD6xQU5wkZXzavLzhvpJlQ9srymlTZLmoqvpYf90fcHnJ8t3575tmqr6JdpaiKOaZXqE2XnW7WCiKclZRlJNPDxmTffcVeM39RVGUaqT8B+2d6ubssL+k9zmR5jL6fSGclH3jVdY1VK/72gaQ0mLwVFrvp+zgVbdLZ/17Y52iKE8HkJf9BdAfRi8C7E91c3bdX14mve32RvtKhob8yCgli0yRlZW8aJuk/kVVVVVRlHRP/dUn+bKkjI/31BhSvrzNSDn9+CtgUkZrfhcyabsUUlX1kaIo7sB+RVGukPLlbLAyeX9ZCfRTVTVZf7PB7i8icymK0huoAtRPdfN/3k+qqnqn/QjZzhZglaqq8YqifExKK20jjWvKSroD61RV1aW6LSfvL5lG09CmZpEpsrKSF20TRVECFEXJq6rqY/2XbOALHqorsFFV1cRUj/201SVeUZSlwMhMKfodyIztoqrqI/2lj6IoB4GKwHoMdF+BzNkuiqLYAdtI+WfpZKrHNtj95TnpfU6ktcxDRVFMAHtSPkdeZV1D9UqvTVGUJqT8E1BfVdX4p7en837KDl/CL90uqqqGpPr1d1L6jz5dt8Fz6x7M9Aq18Trvhe7AJ6lvyMb7y8ukt93eaF8x9MOjOW2KrM2kvBZ4+Wv6T38C/Rf3035cHYA0z3YxQC/dLoqi5Hp6eE9RFGegNnA9G+8r8GrbxYyUAbJXqKq67rn7ssv+kubnxHPLpN5WXYD9+n1jM9BdSTm7tAjgAZx+R3W/bS/dLoqiVAQWAO1UVQ1MdXua76d3Vvnb9SrbJW+qX9uRMtsPpBzZaKbfPrmAZvz7aIche5X3EYqilCClY/2JVLdl5/3lZTYDffVnkdYAwvX/EL/ZvvKuzrB43R+gIynHeOOBAGCX/vZ8wPZUy7UCbpOS2L9Odbs7KR+uXsBawFzr15QJ28QJ2AfcAfYCjvrbqwC/p1quMCkp3ui59fcDV0j58v0DsNH6Nb2r7QLU0r/2S/rLAdl5X3mN7dIbSAQupvqpkN32l7Q+J0g51NtOf91C/7f30u8L7qnW/Vq/3i2gpdav5R1vl736z9+n+8Zm/e3pvp+yw88rbJfvgWv6138AKJFq3Q/0+5EX8L7Wr+Vdbhf97xOBac+tl233F1IaRx7rP0cfktL3cxAwSH+/Avyq32ZXSDUaxpvsKzIjghBCCCGEATD0w6NCCCGEEDmChDYhhBBCCAMgoU0IIYQQwgBIaBNCCCGEMAAS2oQQQgghDICENiGEEEIIAyChTQghhBDCAEhoE0IIIYQwAP8DVuTJpkOpVHAAAAAASUVORK5CYII=\n",
+            "text/plain": [
+              "<Figure size 720x720 with 1 Axes>"
+            ]
+          },
+          "metadata": {
+            "needs_background": "light"
+          },
+          "output_type": "display_data"
+        }
+      ],
+      "source": [
+        "# create grid\n",
+        "x = np.linspace(-1, 1, 100)\n",
+        "xx, yy, zz = np.meshgrid(x, x, x)\n",
+        "points = np.array([xx, yy, zz]).T.reshape(-1, 3)\n",
+        "\n",
+        "# calculate density matrix\n",
+        "dens = density.evaluate_density(rdm1, basis, points)\n",
+        "dens = dens.reshape((100, 100, 100))\n",
+        "\n",
+        "# plot 3d density\n",
+        "plt.figure(figsize=(10, 10))\n",
+        "plt.contour(x, x, dens.sum(axis=2), 50)\n",
+        "plt.show()"
       ]
-     },
-     "metadata": {
-      "needs_background": "light"
-     },
-     "output_type": "display_data"
     }
-   ],
-   "source": [
-    "# create grid\n",
-    "x = np.linspace(-1, 1, 100)\n",
-    "xx, yy, zz = np.meshgrid(x, x, x)\n",
-    "points = np.array([xx, yy, zz]).T.reshape(-1, 3)\n",
-    "\n",
-    "# calculate density matrix\n",
-    "dens = density.evaluate_density(rdm1, basis, points)\n",
-    "dens = dens.reshape((100, 100, 100))\n",
-    "\n",
-    "# plot 3d density\n",
-    "plt.figure(figsize=(10, 10))\n",
-    "plt.contour(x, x, dens.sum(axis=2), 50)\n",
-    "plt.show()"
-   ]
-  }
- ],
- "metadata": {
-  "kernelspec": {
-   "display_name": "Python 3",
-   "language": "python",
-   "name": "python3"
-  },
-  "language_info": {
-   "codemirror_mode": {
-    "name": "ipython",
-    "version": 3
-   },
-   "file_extension": ".py",
-   "mimetype": "text/x-python",
-   "name": "python",
-   "nbconvert_exporter": "python",
-   "pygments_lexer": "ipython3",
-   "version": "3.6.13"
+  ],
+  "metadata": {
+    "kernelspec": {
+      "display_name": "Python 3",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.6.13"
+    },
+    "widgets": {
+      "application/vnd.jupyter.widget-state+json": {
+        "state": {},
+        "version_major": 2,
+        "version_minor": 0
+      }
+    }
   },
-  "widgets": {
-   "application/vnd.jupyter.widget-state+json": {
-    "state": {},
-    "version_major": 2,
-    "version_minor": 0
-   }
-  }
- },
- "nbformat": 4,
- "nbformat_minor": 4
+  "nbformat": 4,
+  "nbformat_minor": 4
 }


Test patch:
diff --git a/.github/workflows/pytest.yaml b/.github/workflows/pytest.yaml
index 10c71b0b..8702fa81 100644
--- a/.github/workflows/pytest.yaml
+++ b/.github/workflows/pytest.yaml
@@ -20,7 +20,7 @@ jobs:
 
     steps:
       - uses: "actions/checkout@v3"
-        
+
       - name: Setup python for test ${{ matrix.py }}
         uses: actions/setup-python@v4
         with:
diff --git a/tests/test_angular_momentum.py b/tests/test_angular_momentum.py
index 87d44a99..c36a2b28 100644
--- a/tests/test_angular_momentum.py
+++ b/tests/test_angular_momentum.py
@@ -14,10 +14,10 @@
 def test_angular_momentum_construct_array_contraction():
     """Test integrals.angular_momentum.angular_momentumIntegral.construct_array_contraction."""
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), "spherical"
     )
 
     # copied the code it is testing
@@ -369,7 +369,7 @@ def test_angular_momentum_construct_array_contraction():
 def test_angular_momentum_integral_cartesian():
     """Test gbasis.integrals.angular_momentum.angular_momentum_integral_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     angular_momentum_integral_obj = AngularMomentumIntegral(basis)
     assert np.allclose(
         angular_momentum_integral_obj.construct_array_cartesian(),
@@ -381,7 +381,7 @@ def test_angular_momentum_integral_spherical():
     """Test gbasis.integrals.angular_momentum.angular_momentum_integral_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     angular_momentum_integral_obj = AngularMomentumIntegral(basis)
     assert np.allclose(
         angular_momentum_integral_obj.construct_array_spherical(),
@@ -393,7 +393,7 @@ def test_angular_momentum_integral_mix():
     """Test gbasis.integrals.angular_momentum.angular_momentum_integral_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ['spherical'] * 8)
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
     angular_momentum_integral_obj = AngularMomentumIntegral(basis)
     assert np.allclose(
         angular_momentum_integral_obj.construct_array_mix(["spherical"] * 8),
@@ -404,7 +404,7 @@ def test_angular_momentum_integral_mix():
 def test_angular_momentum_integral_lincomb():
     """Test gbasis.integrals.angular_momentum.angular_momentum_integral_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     angular_momentum_integral_obj = AngularMomentumIntegral(basis)
     transform = np.random.rand(14, 18)
     assert np.allclose(
diff --git a/tests/test_base.py b/tests/test_base.py
index 6a4e8d9f..cb4d5497 100644
--- a/tests/test_base.py
+++ b/tests/test_base.py
@@ -10,7 +10,9 @@ def test_init():
     """Test base.BaseGaussianRelatedArray."""
     Test = disable_abstract(BaseGaussianRelatedArray)  # noqa: N806
     test = skip_init(Test)
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     assert not hasattr(test, "_axes_contractions")
     with pytest.raises(TypeError):
         Test.__init__(test, set([contractions]))
@@ -38,7 +40,9 @@ def test_contruct_array_contraction():
             "construct_array_contraction": BaseGaussianRelatedArray.construct_array_contraction
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
@@ -52,7 +56,9 @@ def test_contruct_array_cartesian():
             "construct_array_cartesian": BaseGaussianRelatedArray.construct_array_cartesian
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
@@ -66,7 +72,9 @@ def test_contruct_array_spherical():
             "construct_array_spherical": BaseGaussianRelatedArray.construct_array_spherical
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
@@ -80,6 +88,8 @@ def test_contruct_array_lincomb():
             "construct_array_lincomb": BaseGaussianRelatedArray.construct_array_lincomb
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
diff --git a/tests/test_base_four_symm.py b/tests/test_base_four_symm.py
index 92d2548c..374c6155 100644
--- a/tests/test_base_four_symm.py
+++ b/tests/test_base_four_symm.py
@@ -11,7 +11,9 @@ def test_init():
     """Test BaseFourIndexSymmetric.__init__."""
     Test = disable_abstract(BaseFourIndexSymmetric)  # noqa: N806
     test = skip_init(Test)
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test.__init__(test, [contractions])
     assert test._axes_contractions[0][0] == contractions
     with pytest.raises(TypeError):
@@ -21,7 +23,7 @@ def test_init():
 def test_contractions():
     """Test BaseFourIndexSymmetric.contractions."""
     Test = disable_abstract(BaseFourIndexSymmetric)  # noqa: N806
-    cont = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical")
     test = Test([cont])
     assert test.contractions[0] == cont
 
@@ -35,15 +37,21 @@ def test_construct_array_contraction():
             "construct_array_contraction": BaseFourIndexSymmetric.construct_array_contraction
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
 
 def test_construct_array_cartesian():
     """Test BaseFourIndexSymmetric.construct_array_cartesian."""
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones((1, 1)), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([2, 3, 4]), np.ones((1, 1)), 2 * np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones((1, 1)), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([2, 3, 4]), np.ones((1, 1)), 2 * np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseFourIndexSymmetric,
         dict_overwrite={
@@ -91,7 +99,9 @@ def test_construct_array_cartesian():
 
 def test_construct_array_spherical():
     """Test BaseFourIndexSymmetric.construct_array_spherical."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -127,8 +137,12 @@ def test_construct_array_spherical():
     with pytest.raises(TypeError):
         test.construct_array_spherical(bad_keyword=3)
 
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform_one = generate_transformation(
         1, cont_one.angmom_components_cart, cont_one.angmom_components_sph, "left"
     )
@@ -400,7 +414,9 @@ def test_construct_array_spherical():
 
 def test_construct_array_mix():
     """Test BaseFourIndex.construct_array_mix."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseFourIndexSymmetric,
@@ -423,8 +439,12 @@ def test_construct_array_mix():
         test.construct_array_cartesian(a=3), test.construct_array_mix(["cartesian"], a=3)
     )
 
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseFourIndexSymmetric,
@@ -566,8 +586,12 @@ def construct_array_cont(self, cont_one, cont_two, cont_three, cont_four):
         BaseFourIndexSymmetric,
         dict_overwrite={"construct_array_contraction": construct_array_cont},
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     # Remove the dependence on norm constants.
     cont_one.norm_cont = np.ones((1, cont_one.num_cart))
@@ -656,7 +680,9 @@ def construct_array_cont(self, cont_one, cont_two, cont_three, cont_four):
 
 def test_construct_array_lincomb():
     """Test BaseFourIndexSymmetric.construct_array_lincomb."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     sph_transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -732,8 +758,12 @@ def test_construct_array_lincomb():
             )
         },
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     cont_one.norm_cont = np.ones((1, cont_one.num_cart))
     cont_two.norm_cont = np.ones((1, cont_two.num_cart))
     test = Test([cont_one, cont_two])
@@ -1250,7 +1280,7 @@ def angmom_components_sph(self):
             """Raise error in case undefined conventions are accessed."""
             raise NotImplementedError
 
-    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical")
     Test = disable_abstract(  # noqa: N806
         BaseFourIndexSymmetric,
         dict_overwrite={
diff --git a/tests/test_base_one.py b/tests/test_base_one.py
index df6b669d..dd2975f1 100644
--- a/tests/test_base_one.py
+++ b/tests/test_base_one.py
@@ -11,7 +11,9 @@ def test_init():
     """Test BaseOneIndex.__init__."""
     Test = disable_abstract(BaseOneIndex)  # noqa: N806
     test = skip_init(Test)
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test.__init__(test, [contractions])
     assert test._axes_contractions == ((contractions,),)
     with pytest.raises(TypeError):
@@ -21,7 +23,9 @@ def test_init():
 def test_contractions():
     """Test BaseOneIndex.constractions."""
     Test = disable_abstract(BaseOneIndex)  # noqa: N806
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     test = Test([contractions])
     assert test.contractions[0] == contractions
 
@@ -33,14 +37,18 @@ def test_contruct_array_contraction():
         BaseOneIndex,
         dict_overwrite={"construct_array_contraction": BaseOneIndex.construct_array_contraction},
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
 
 def test_contruct_array_cartesian():
     """Test BaseOneIndex.construct_array_cartesian."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     contractions.norm_cont = np.ones((1, 5))
     Test = disable_abstract(  # noqa: N806
         BaseOneIndex,
@@ -78,7 +86,9 @@ def test_contruct_array_cartesian():
 
 def test_contruct_array_spherical():
     """Test BaseOneIndex.construct_array_spherical."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -108,7 +118,9 @@ def test_contruct_array_spherical():
         np.vstack([transform.dot(np.arange(9).reshape(3, 3)) * 2] * 2),
     )
 
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseOneIndex,
         dict_overwrite={
@@ -155,7 +167,9 @@ def test_contruct_array_spherical():
 
 def test_contruct_array_mix():
     """Test BaseOneIndex.construct_array_mix."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseOneIndex,
@@ -190,7 +204,9 @@ def test_contruct_array_mix():
         test.construct_array_cartesian(a=3), test.construct_array_mix(["cartesian"] * 2, a=3)
     )
 
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseOneIndex,
         dict_overwrite={
@@ -243,7 +259,7 @@ def angmom_components_sph(self):
             """Raise error in case undefined conventions are accessed."""
             raise NotImplementedError
 
-    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical")
     Test = disable_abstract(  # noqa: N806
         BaseOneIndex,
         dict_overwrite={
@@ -260,7 +276,9 @@ def angmom_components_sph(self):
 
 def test_contruct_array_lincomb():
     """Test BaseOneIndex.construct_array_lincomb."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     sph_transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
diff --git a/tests/test_base_two_asymm.py b/tests/test_base_two_asymm.py
index 76910628..4b609c00 100644
--- a/tests/test_base_two_asymm.py
+++ b/tests/test_base_two_asymm.py
@@ -11,7 +11,9 @@ def test_init():
     """Test BaseTwoIndexAsymmetric.__init__."""
     Test = disable_abstract(BaseTwoIndexAsymmetric)  # noqa: N806
     test = skip_init(Test)
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test.__init__(test, [contractions], [contractions])
     assert test._axes_contractions == ((contractions,), (contractions,))
     with pytest.raises(TypeError):
@@ -23,8 +25,12 @@ def test_init():
 def test_contractions_one():
     """Test BaseTwoIndexAsymmetric.constractions_one."""
     Test = disable_abstract(BaseTwoIndexAsymmetric)  # noqa: N806
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     test = Test([cont_one], [cont_two])
     assert test.contractions_one[0] == cont_one
 
@@ -32,8 +38,12 @@ def test_contractions_one():
 def test_contractions_two():
     """Test BaseTwoIndexAsymmetric.constractions_two."""
     Test = disable_abstract(BaseTwoIndexAsymmetric)  # noqa: N806
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     test = Test([cont_one], [cont_two])
     assert test.contractions_two[0] == cont_two
 
@@ -47,14 +57,18 @@ def test_contruct_array_contraction():
             "construct_array_contraction": BaseTwoIndexAsymmetric.construct_array_contraction
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
 
 def test_contruct_array_cartesian():
     """Test BaseTwoIndexAsymmetric.construct_array_cartesian."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexAsymmetric,
         dict_overwrite={
@@ -80,8 +94,12 @@ def test_contruct_array_cartesian():
             )
         },
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     cont_one.norm_cont = np.ones((1, 2))
     cont_two.norm_cont = np.ones((1, 5))
     test = Test([cont_one, cont_one], [cont_two])
@@ -105,7 +123,9 @@ def test_contruct_array_cartesian():
 
 def test_contruct_array_spherical():
     """Test BaseTwoIndexAsymmetric.construct_array_spherical."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -194,7 +214,9 @@ def test_contruct_array_spherical():
 
 def test_contruct_array_mix():
     """Test BaseTwoIndexAsymmetric.construct_array_mix."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexAsymmetric,
@@ -347,8 +369,12 @@ def construct_array_cont(self, cont_one, cont_two):
         BaseTwoIndexAsymmetric,
         dict_overwrite={"construct_array_contraction": construct_array_cont},
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     # Remove the dependence on norm constants.
     cont_one.norm_cont = np.ones((1, cont_one.num_cart))
@@ -393,7 +419,9 @@ def construct_array_cont(self, cont_one, cont_two):
 
 def test_contruct_array_lincomb():
     """Test BaseTwoIndexAsymmetric.construct_array_lincomb."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     sph_transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -556,7 +584,7 @@ def angmom_components_sph(self):
             """Raise error in case undefined conventions are accessed."""
             raise NotImplementedError
 
-    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical")
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexAsymmetric,
         dict_overwrite={
diff --git a/tests/test_base_two_symm.py b/tests/test_base_two_symm.py
index 5fcecfaf..ac6be7a3 100644
--- a/tests/test_base_two_symm.py
+++ b/tests/test_base_two_symm.py
@@ -12,7 +12,9 @@ def test_init():
     """Test BaseTwoIndexSymmetric.__init__."""
     Test = disable_abstract(BaseTwoIndexSymmetric)  # noqa: N806
     test = skip_init(Test)
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test.__init__(test, [contractions])
     assert test._axes_contractions[0][0] == contractions
     with pytest.raises(TypeError):
@@ -22,7 +24,7 @@ def test_init():
 def test_contractions():
     """Test BaseTwoIndexSymmetric.constractions."""
     Test = disable_abstract(BaseTwoIndexSymmetric)  # noqa: N806
-    cont = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical")
     test = Test([cont])
     assert test.contractions[0] == cont
 
@@ -36,7 +38,9 @@ def test_contruct_array_contraction():
             "construct_array_contraction": BaseTwoIndexSymmetric.construct_array_contraction
         },
     )
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     with pytest.raises(TypeError):
         Test([contractions])
 
@@ -49,7 +53,9 @@ def test_contruct_array_contraction():
 # to the tril blocks because the ordering is different.
 def test_contruct_array_cartesian():
     """Test BaseTwoIndexSymmetric.construct_array_cartesian."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexSymmetric,
         dict_overwrite={
@@ -67,8 +73,12 @@ def test_contruct_array_cartesian():
     assert np.allclose(test.construct_array_cartesian(), np.ones((4, 4)) * 2)
     assert np.allclose(test.construct_array_cartesian(a=3), np.ones((4, 4)) * 3)
 
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexSymmetric,
         dict_overwrite={
@@ -229,7 +239,9 @@ def test_contruct_array_cartesian():
 # to the tril blocks because the ordering is different.
 def test_contruct_array_spherical():
     """Test BaseTwoIndexSymmetric.construct_array_spherical."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -256,8 +268,12 @@ def test_contruct_array_spherical():
     with pytest.raises(TypeError):
         test.construct_array_spherical(bad_keyword=3)
 
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     transform_one = generate_transformation(
         1, cont_one.angmom_components_cart, cont_one.angmom_components_sph, "left"
     )
@@ -400,7 +416,9 @@ def test_contruct_array_spherical():
 
 def test_contruct_array_mix():
     """Test BaseTwoIndex.construct_array_mix."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexSymmetric,
@@ -421,8 +439,12 @@ def test_contruct_array_mix():
         test.construct_array_cartesian(a=3), test.construct_array_mix(["cartesian"], a=3)
     )
 
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexSymmetric,
@@ -489,7 +511,9 @@ def test_contruct_array_mix():
 
 def test_contruct_array_lincomb():
     """Test BaseTwoIndexSymmetric.construct_array_lincomb."""
-    contractions = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    contractions = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     sph_transform = generate_transformation(
         1, contractions.angmom_components_cart, contractions.angmom_components_sph, "left"
     )
@@ -548,8 +572,12 @@ def test_contruct_array_lincomb():
             )
         },
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     cont_one.norm_cont = np.ones((1, cont_one.num_cart))
     cont_two.norm_cont = np.ones((1, cont_two.num_cart))
     test = Test([cont_one, cont_two])
@@ -733,8 +761,12 @@ def construct_array_cont(self, cont_one, cont_two):
         BaseTwoIndexSymmetric,
         dict_overwrite={"construct_array_contraction": construct_array_cont},
     )
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
 
     # Remove the dependence on norm constants.
     cont_one.norm_cont = np.ones((1, cont_one.num_cart))
@@ -777,8 +809,12 @@ def construct_array_cont(self, cont_one, cont_two):
 
 def test_compare_two_asymm():
     """Test BaseTwoIndexSymmetric by comparing it against BaseTwoIndexAsymmetric."""
-    cont_one = GeneralizedContractionShell(1, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
-    cont_two = GeneralizedContractionShell(2, np.array([1, 2, 3]), np.ones(1), np.ones(1), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        1, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
+    cont_two = GeneralizedContractionShell(
+        2, np.array([1, 2, 3]), np.ones(1), np.ones(1), "spherical"
+    )
     sph_orb_transform = np.random.rand(8, 8)
     cart_orb_transform = np.random.rand(9, 9)
 
@@ -852,7 +888,7 @@ def angmom_components_sph(self):
             """Raise error in case undefined conventions are accessed."""
             raise NotImplementedError
 
-    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), 'spherical')
+    contractions = SpecialShell(1, np.array([1, 2, 3]), np.ones((1, 2)), np.ones(1), "spherical")
     Test = disable_abstract(  # noqa: N806
         BaseTwoIndexSymmetric,
         dict_overwrite={
diff --git a/tests/test_contractions.py b/tests/test_contractions.py
index 198e2d49..5d2448f7 100644
--- a/tests/test_contractions.py
+++ b/tests/test_contractions.py
@@ -169,7 +169,7 @@ def tests_init():
         np.array([0, 1, 2]),
         np.array([1, 2, 3, 4], dtype=float),
         np.array([5, 6, 7, 8], dtype=float),
-        'spherical'
+        "spherical",
     )
     assert test._angmom == 1
     assert np.allclose(test._coord, np.array([0, 1, 2]))
@@ -226,9 +226,13 @@ def test_angmom_components_sph():
 # TODO: add more tests
 def test_norm_prim_cart():
     """Test GeneralizedContractionShell.norm_prim_cart."""
-    test = GeneralizedContractionShell(0, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), 'spherical')
+    test = GeneralizedContractionShell(
+        0, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), "spherical"
+    )
     assert np.isclose(test.norm_prim_cart, 0.2519794355383807303479140)
-    test = GeneralizedContractionShell(3, np.array([0, 0, 0]), np.array([1.0]), np.array([0.5]), 'spherical')
+    test = GeneralizedContractionShell(
+        3, np.array([0, 0, 0]), np.array([1.0]), np.array([0.5]), "spherical"
+    )
     assert np.isclose(test.norm_prim_cart[7], 0.6920252830162908851679097)
 
 
@@ -261,14 +265,20 @@ def test_num_seg_cont():
 
 def test_assign_norm_cont():
     """Test GeneralizedContractionShell.assign_norm_cont."""
-    test = GeneralizedContractionShell(0, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), 'spherical')
+    test = GeneralizedContractionShell(
+        0, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), "spherical"
+    )
     test.assign_norm_cont()
     assert np.allclose(test.norm_cont, 1)
 
-    test = GeneralizedContractionShell(1, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), 'spherical')
+    test = GeneralizedContractionShell(
+        1, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), "spherical"
+    )
     test.assign_norm_cont()
     assert np.allclose(test.norm_cont, 1)
 
-    test = GeneralizedContractionShell(2, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), 'spherical')
+    test = GeneralizedContractionShell(
+        2, np.array([0, 0, 0]), np.array([1.0]), np.array([0.25]), "spherical"
+    )
     test.assign_norm_cont()
     assert np.allclose(test.norm_cont, 1)
diff --git a/tests/test_density.py b/tests/test_density.py
index 14d3da40..0b12eeda 100644
--- a/tests/test_density.py
+++ b/tests/test_density.py
@@ -62,7 +62,7 @@ def test_evaluate_density_using_evaluated_orbs():
 def test_evaluate_density():
     """Test gbasis.evals.density.evaluate_density."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     transform = np.random.rand(14, 18)
     density = np.random.rand(14, 14)
     density += density.T
@@ -77,7 +77,7 @@ def test_evaluate_density():
 def test_evaluate_deriv_density():
     """Test gbasis.evals.density.evaluate_deriv_density."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     transform = np.random.rand(14, 18)
     density = np.random.rand(14, 14)
     density += density.T
@@ -221,7 +221,7 @@ def test_evaluate_deriv_density():
 def test_evaluate_density_gradient():
     """Test gbasis.evals.density.evaluate_density_gradient."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     transform = np.random.rand(14, 18)
     density = np.random.rand(14, 14)
     density += density.T
@@ -281,7 +281,7 @@ def test_evaluate_density_horton():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density = np.load(find_datafile("data_horton_hhe_sph_density.npy"))
@@ -304,7 +304,7 @@ def test_evaluate_density_gradient_horton():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density_gradient = np.load(find_datafile("data_horton_hhe_sph_density_gradient.npy"))
@@ -328,7 +328,7 @@ def test_evaluate_hessian_deriv_horton():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density_hessian = np.zeros((10**3, 3, 3))
@@ -358,7 +358,7 @@ def test_evaluate_laplacian_deriv_horton():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density_laplacian = np.load(find_datafile("data_horton_hhe_sph_density_laplacian.npy"))
@@ -382,7 +382,7 @@ def test_evaluate_posdef_kinetic_energy_density():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density_kinetic_density = np.load(
@@ -409,7 +409,7 @@ def test_evaluate_general_kinetic_energy_density_horton():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     points = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_density_kinetic_density = np.load(
@@ -432,7 +432,7 @@ def test_evaluate_general_kinetic_energy_density():
     """Test density.evaluate_general_kinetic_energy_density."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     points = np.array([[0, 0, 0]])
-    basis = make_contractions(basis_dict, ["H"], points, 'spherical')
+    basis = make_contractions(basis_dict, ["H"], points, "spherical")
     points = np.random.rand(10, 3)
 
     with pytest.raises(TypeError):
diff --git a/tests/test_electron_repulsion.py b/tests/test_electron_repulsion.py
index 44ab0dd4..0746b1db 100644
--- a/tests/test_electron_repulsion.py
+++ b/tests/test_electron_repulsion.py
@@ -17,13 +17,21 @@
 def test_construct_array_contraction():
     """Test integrals.electron_repulsion.ElectronRepulsionIntegral.construct_array_contraction."""
     coord_one = np.array([0.5, 1, 1.5])
-    cont_one = GeneralizedContractionShell(0, coord_one, np.array([1.0]), np.array([0.1]), 'spherical')
+    cont_one = GeneralizedContractionShell(
+        0, coord_one, np.array([1.0]), np.array([0.1]), "spherical"
+    )
     coord_two = np.array([1.5, 2, 3])
-    cont_two = GeneralizedContractionShell(0, coord_two, np.array([3.0]), np.array([0.2]), 'spherical')
+    cont_two = GeneralizedContractionShell(
+        0, coord_two, np.array([3.0]), np.array([0.2]), "spherical"
+    )
     coord_three = np.array([2.5, 3, 4])
-    cont_three = GeneralizedContractionShell(0, coord_three, np.array([3.0]), np.array([0.2]), 'spherical')
+    cont_three = GeneralizedContractionShell(
+        0, coord_three, np.array([3.0]), np.array([0.2]), "spherical"
+    )
     coord_four = np.array([3.5, 4, 5])
-    cont_four = GeneralizedContractionShell(0, coord_four, np.array([3.0]), np.array([0.2]), 'spherical')
+    cont_four = GeneralizedContractionShell(
+        0, coord_four, np.array([3.0]), np.array([0.2]), "spherical"
+    )
 
     with pytest.raises(TypeError):
         ElectronRepulsionIntegral.construct_array_contraction(None, cont_two, cont_three, cont_four)
@@ -99,13 +107,11 @@ def test_electron_repulsion_cartesian_horton_sto6g_bec():
     """
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
     coords = np.array([[0, 0, 0], [1.0, 0, 0]])
-    basis = make_contractions(basis_dict, ["Be", "C"], coords, 'cartesian')
+    basis = make_contractions(basis_dict, ["Be", "C"], coords, "cartesian")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_elec_repulsion = np.load(find_datafile("data_horton_bec_cart_elec_repulsion.npy"))
-    assert np.allclose(
-        horton_elec_repulsion, electron_repulsion_integral(basis)
-    )
+    assert np.allclose(horton_elec_repulsion, electron_repulsion_integral(basis))
 
 
 def test_electron_repulsion_cartesian_horton_custom_hhe():
@@ -120,8 +126,11 @@ def test_electron_repulsion_cartesian_horton_custom_hhe():
     """
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     coords = np.array([[0, 0, 0], [0.8, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], coords, 'cartesian')
-    basis = [HortonContractions(i.angmom, i.coord, i.coeffs[:, 0], i.exps, i.coord_type) for i in basis[:8]]
+    basis = make_contractions(basis_dict, ["H", "He"], coords, "cartesian")
+    basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs[:, 0], i.exps, i.coord_type)
+        for i in basis[:8]
+    ]
     basis[0] = HortonContractions(
         basis[0].angmom, basis[0].coord, basis[0].coeffs[3:], basis[0].exps[3:], basis[0].coord_type
     )
@@ -132,15 +141,13 @@ def test_electron_repulsion_cartesian_horton_custom_hhe():
     basis.pop(2)
 
     horton_elec_repulsion = np.load(find_datafile("data_horton_hhe_cart_elec_repulsion.npy"))
-    assert np.allclose(
-        horton_elec_repulsion, electron_repulsion_integral(basis)
-    )
+    assert np.allclose(horton_elec_repulsion, electron_repulsion_integral(basis))
 
 
 def test_electron_repulsion_cartesian():
     """Test gbasis.integrals.electron_repulsion.electron_repulsion_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), "cartesian")
 
     erep_obj = ElectronRepulsionIntegral(basis)
     assert np.allclose(
@@ -158,7 +165,7 @@ def test_electron_repulsion_cartesian():
 def test_electron_repulsion_spherical():
     """Test gbasis.integrals.electron_repulsion.electron_repulsion_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), "spherical")
 
     erep_obj = ElectronRepulsionIntegral(basis)
     assert np.allclose(
diff --git a/tests/test_electrostatic_potential.py b/tests/test_electrostatic_potential.py
index 2d77214e..520349c8 100644
--- a/tests/test_electrostatic_potential.py
+++ b/tests/test_electrostatic_potential.py
@@ -14,12 +14,20 @@ def test_electrostatic_potential():
     """
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     coords = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    cartesian_basis = make_contractions(basis_dict, ["H", "He"], coords, 'cartesian')
-    cartesian_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in cartesian_basis]
-    spherical_basis = make_contractions(basis_dict, ["H", "He"], coords, 'spherical')
-    spherical_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in spherical_basis]
-    mixed_basis = make_contractions(basis_dict, ["H", "He"], coords, ['spherical'] * 9)
-    mixed_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in mixed_basis]
+    cartesian_basis = make_contractions(basis_dict, ["H", "He"], coords, "cartesian")
+    cartesian_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in cartesian_basis
+    ]
+    spherical_basis = make_contractions(basis_dict, ["H", "He"], coords, "spherical")
+    spherical_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in spherical_basis
+    ]
+    mixed_basis = make_contractions(basis_dict, ["H", "He"], coords, ["spherical"] * 9)
+    mixed_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in mixed_basis
+    ]
 
     # check density_matrix type
     with pytest.raises(TypeError):
@@ -146,7 +154,7 @@ def test_electrostatic_potential_cartesian():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     coords = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], coords, 'cartesian')
+    basis = make_contractions(basis_dict, ["H", "He"], coords, "cartesian")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     grid_1d = np.linspace(-2, 2, num=5)
@@ -155,9 +163,7 @@ def test_electrostatic_potential_cartesian():
 
     horton_nucattract = np.load(find_datafile("data_horton_hhe_cart_esp.npy"))
     assert np.allclose(
-        electrostatic_potential(
-            basis, np.identity(103), grid_3d, coords, np.array([1, 2])
-        ),
+        electrostatic_potential(basis, np.identity(103), grid_3d, coords, np.array([1, 2])),
         horton_nucattract,
     )
 
@@ -172,7 +178,7 @@ def test_electrostatic_potential_spherical():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     coords = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], coords, 'spherical')
+    basis = make_contractions(basis_dict, ["H", "He"], coords, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     grid_1d = np.linspace(-2, 2, num=5)
@@ -181,9 +187,7 @@ def test_electrostatic_potential_spherical():
 
     horton_nucattract = np.load(find_datafile("data_horton_hhe_sph_esp.npy"))
     assert np.allclose(
-        electrostatic_potential(
-            basis, np.identity(88), grid_3d, coords, np.array([1, 2])
-        ),
+        electrostatic_potential(basis, np.identity(88), grid_3d, coords, np.array([1, 2])),
         horton_nucattract,
     )
 
@@ -198,10 +202,16 @@ def test_electrostatic_potential_mix():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     coords = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    spherical_basis = make_contractions(basis_dict, ["H", "He"], coords, ['spherical'] * 9)
-    spherical_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in spherical_basis]
-    cartesian_basis = make_contractions(basis_dict, ["H", "He"], coords, ['cartesian'] * 9)
-    cartesian_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in cartesian_basis]
+    spherical_basis = make_contractions(basis_dict, ["H", "He"], coords, ["spherical"] * 9)
+    spherical_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in spherical_basis
+    ]
+    cartesian_basis = make_contractions(basis_dict, ["H", "He"], coords, ["cartesian"] * 9)
+    cartesian_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in cartesian_basis
+    ]
 
     grid_1d = np.linspace(-2, 2, num=5)
     grid_x, grid_y, grid_z = np.meshgrid(grid_1d, grid_1d, grid_1d)
diff --git a/tests/test_eval.py b/tests/test_eval.py
index 640a6d6b..2bcb3a88 100644
--- a/tests/test_eval.py
+++ b/tests/test_eval.py
@@ -12,7 +12,7 @@
 def test_evaluate_construct_array_contraction():
     """Test gbasis.evals.eval.Eval.construct_array_contraction."""
     test = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     answer = np.array(
         [
@@ -56,7 +56,7 @@ def test_evaluate_construct_array_contraction():
 def test_evaluate_basis_cartesian():
     """Test gbasis.evals.eval.evaluate_basis_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), "cartesian")
     evaluate_obj = Eval(basis)
     assert np.allclose(
         evaluate_obj.construct_array_cartesian(points=np.array([[0, 0, 0]])),
@@ -69,21 +69,21 @@ def test_evaluate_basis_spherical():
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
     # cartesian and spherical are the same for s orbital
-    basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), "spherical")
     evaluate_obj = Eval(basis)
     assert np.allclose(
         evaluate_obj.construct_array_cartesian(points=np.array([[0, 0, 0]])),
         evaluate_basis(basis, np.array([[0, 0, 0]])),
     )
     # p orbitals are zero at center
-    basis = make_contractions(basis_dict, ["Li"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Li"], np.array([[0, 0, 0]]), "spherical")
     evaluate_obj = Eval(basis)
     assert np.allclose(
         evaluate_obj.construct_array_cartesian(points=np.array([[0, 0, 0]])),
         evaluate_basis(basis, np.array([[0, 0, 0]])),
     )
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     evaluate_obj = Eval(basis)
     assert np.allclose(
         evaluate_obj.construct_array_spherical(points=np.array([[1, 1, 1]])),
@@ -97,28 +97,36 @@ def test_evaluate_basis_mix():
 
     # cartesian and spherical are the same for s orbital
     spherical_basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), "spherical")
-    spherical_basis_list = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), ["spherical"])
+    spherical_basis_list = make_contractions(
+        basis_dict, ["H"], np.array([[0, 0, 0]]), ["spherical"]
+    )
     assert np.allclose(
         evaluate_basis(spherical_basis, np.array([[0, 0, 0]])),
         evaluate_basis(spherical_basis_list, np.array([[0, 0, 0]])),
     )
 
     cartesian_basis = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), "cartesian")
-    cartesian_basis_list = make_contractions(basis_dict, ["H"], np.array([[0, 0, 0]]), ["cartesian"])
+    cartesian_basis_list = make_contractions(
+        basis_dict, ["H"], np.array([[0, 0, 0]]), ["cartesian"]
+    )
     assert np.allclose(
         evaluate_basis(cartesian_basis, np.array([[0, 0, 0]])),
         evaluate_basis(cartesian_basis_list, np.array([[0, 0, 0]])),
     )
 
     spherical_basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
-    spherical_basis_list = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
+    spherical_basis_list = make_contractions(
+        basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8
+    )
     assert np.allclose(
         evaluate_basis(spherical_basis, np.array([[1, 1, 1]])),
         evaluate_basis(spherical_basis_list, np.array([[1, 1, 1]])),
     )
 
     cartesian_basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
-    cartesian_basis_list = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["cartesian"] * 8)
+    cartesian_basis_list = make_contractions(
+        basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["cartesian"] * 8
+    )
     assert np.allclose(
         evaluate_basis(cartesian_basis, np.array([[1, 1, 1]])),
         evaluate_basis(cartesian_basis_list, np.array([[1, 1, 1]])),
@@ -128,11 +136,13 @@ def test_evaluate_basis_mix():
 def test_evaluate_basis_lincomb():
     """Test gbasis.evals.eval.evaluate_basis_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     evaluate_obj = Eval(basis)
     transform = np.random.rand(14, 18)
     assert np.allclose(
-        evaluate_obj.construct_array_lincomb(transform, ["spherical"], points=np.array([[1, 1, 1]])),
+        evaluate_obj.construct_array_lincomb(
+            transform, ["spherical"], points=np.array([[1, 1, 1]])
+        ),
         evaluate_basis(basis, np.array([[1, 1, 1]]), transform=transform),
     )
 
@@ -141,9 +151,13 @@ def test_evaluate_basis_horton():
     """Test gbasis.evals.eval.evaluate_basis against horton results."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     points = np.array([[0, 0, 0], [0.8, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], points, 'spherical')
-    cartesian_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, 'cartesian') for i in basis]
-    spherical_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, 'spherical') for i in basis]
+    basis = make_contractions(basis_dict, ["H", "He"], points, "spherical")
+    cartesian_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, "cartesian") for i in basis
+    ]
+    spherical_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, "spherical") for i in basis
+    ]
 
     horton_eval_cart = np.load(find_datafile("data_horton_hhe_cart_eval.npy"))
     horton_eval_sph = np.load(find_datafile("data_horton_hhe_sph_eval.npy"))
diff --git a/tests/test_eval_deriv.py b/tests/test_eval_deriv.py
index c32f6f9c..4f318170 100644
--- a/tests/test_eval_deriv.py
+++ b/tests/test_eval_deriv.py
@@ -16,7 +16,7 @@ def test_evaluate_deriv_construct_array_contraction():
     points = np.array([[2, 3, 4]])
     orders = np.array([0, 0, 0])
     contractions = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     with pytest.raises(TypeError):
         EvalDeriv.construct_array_contraction(
@@ -53,7 +53,7 @@ def test_evaluate_deriv_construct_array_contraction():
         orders[k] = 1
 
         test = GeneralizedContractionShell(
-            1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+            1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
         )
         answer = np.array(
             [
@@ -93,7 +93,7 @@ def test_evaluate_deriv_construct_array_contraction():
         orders[l] += 1
 
         test = GeneralizedContractionShell(
-            1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+            1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
         )
         answer = np.array(
             [
@@ -137,17 +137,13 @@ def test_evaluate_deriv_basis_cartesian():
         evaluate_obj.construct_array_cartesian(
             points=np.array([[1, 1, 1]]), orders=np.array([0, 0, 0])
         ),
-        evaluate_deriv_basis(
-            basis, np.array([[1, 1, 1]]), orders=np.array([0, 0, 0])
-        ),
+        evaluate_deriv_basis(basis, np.array([[1, 1, 1]]), orders=np.array([0, 0, 0])),
     )
     assert np.allclose(
         evaluate_obj.construct_array_cartesian(
             points=np.array([[1, 1, 1]]), orders=np.array([2, 1, 0])
         ),
-        evaluate_deriv_basis(
-            basis, np.array([[1, 1, 1]]), orders=np.array([2, 1, 0])
-        ),
+        evaluate_deriv_basis(basis, np.array([[1, 1, 1]]), orders=np.array([2, 1, 0])),
     )
 
 
@@ -160,42 +156,38 @@ def test_evaluate_deriv_basis_spherical():
         evaluate_obj.construct_array_spherical(
             points=np.array([[1, 1, 1]]), orders=np.array([0, 0, 0])
         ),
-        evaluate_deriv_basis(
-            basis, np.array([[1, 1, 1]]), np.array([0, 0, 0])
-        ),
+        evaluate_deriv_basis(basis, np.array([[1, 1, 1]]), np.array([0, 0, 0])),
     )
     assert np.allclose(
         evaluate_obj.construct_array_spherical(
             points=np.array([[1, 1, 1]]), orders=np.array([2, 1, 0])
         ),
-        evaluate_deriv_basis(
-            basis, np.array([[1, 1, 1]]), np.array([2, 1, 0])
-        ),
+        evaluate_deriv_basis(basis, np.array([[1, 1, 1]]), np.array([2, 1, 0])),
     )
 
 
 def test_evaluate_deriv_basis_mix():
     """Test gbasis.evals.eval.evaluate_deriv_basis_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    cartesian_basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["cartesian"] * 8)
-    spherical_basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
+    cartesian_basis = make_contractions(
+        basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["cartesian"] * 8
+    )
+    spherical_basis = make_contractions(
+        basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8
+    )
     evaluate_obj_cartesian = EvalDeriv(cartesian_basis)
     evaluate_obj_spherical = EvalDeriv(spherical_basis)
     assert np.allclose(
         evaluate_obj_cartesian.construct_array_mix(
             ["cartesian"] * 8, points=np.array([[1, 1, 1]]), orders=np.array([0, 0, 0])
         ),
-        evaluate_deriv_basis(
-            cartesian_basis, np.array([[1, 1, 1]]), np.array([0, 0, 0])
-        ),
+        evaluate_deriv_basis(cartesian_basis, np.array([[1, 1, 1]]), np.array([0, 0, 0])),
     )
     assert np.allclose(
         evaluate_obj_spherical.construct_array_mix(
             ["spherical"] * 8, points=np.array([[1, 1, 1]]), orders=np.array([2, 1, 0])
         ),
-        evaluate_deriv_basis(
-            spherical_basis, np.array([[1, 1, 1]]), np.array([2, 1, 0])
-        ),
+        evaluate_deriv_basis(spherical_basis, np.array([[1, 1, 1]]), np.array([2, 1, 0])),
     )
 
 
diff --git a/tests/test_kinetic_energy.py b/tests/test_kinetic_energy.py
index 286dc2ec..9cd90289 100644
--- a/tests/test_kinetic_energy.py
+++ b/tests/test_kinetic_energy.py
@@ -12,10 +12,10 @@
 def test_kinetic_energy_construct_array_contraction():
     """Test gbasis.integrals.kinetic_energy.KineticEnergyIntegral.construct_array_contraction."""
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), "spherical"
     )
     answer = np.array(
         [
@@ -160,7 +160,7 @@ def test_kinetic_energy_construct_array_contraction():
 def test_kinetic_energy_integral_cartesian():
     """Test gbasis.integrals.kinetic_energy.kinetic_energy_integral_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     kinetic_energy_integral_obj = KineticEnergyIntegral(basis)
     assert np.allclose(
         kinetic_energy_integral_obj.construct_array_cartesian(),
@@ -172,7 +172,7 @@ def test_kinetic_energy_integral_spherical():
     """Test gbasis.integrals.kinetic_energy.kinetic_energy_integral_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     kinetic_energy_integral_obj = KineticEnergyIntegral(basis)
     assert np.allclose(
         kinetic_energy_integral_obj.construct_array_spherical(),
@@ -184,7 +184,7 @@ def test_kinetic_energy_integral_mix():
     """Test gbasis.integrals.kinetic_energy.kinetic_energy_integral_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ['spherical'] * 8)
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
     kinetic_energy_integral_obj = KineticEnergyIntegral(basis)
     assert np.allclose(
         kinetic_energy_integral_obj.construct_array_mix(["spherical"] * 8),
@@ -195,7 +195,7 @@ def test_kinetic_energy_integral_mix():
 def test_kinetic_energy_integral_lincomb():
     """Test gbasis.integrals.kinetic_energy.kinetic_energy_integral_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     kinetic_energy_integral_obj = KineticEnergyIntegral(basis)
     transform = np.random.rand(14, 18)
     assert np.allclose(
@@ -213,16 +213,17 @@ def test_kinetic_energy_integral_horton_anorcc_hhe():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["H", "He"], np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]), 'cartesian'
+        basis_dict,
+        ["H", "He"],
+        np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_kinetic_energy_integral = np.load(
         find_datafile("data_horton_hhe_cart_kinetic_energy_integral.npy")
     )
-    assert np.allclose(
-        kinetic_energy_integral(basis), horton_kinetic_energy_integral
-    )
+    assert np.allclose(kinetic_energy_integral(basis), horton_kinetic_energy_integral)
 
 
 def test_kinetic_energy_integral_horton_anorcc_bec():
@@ -234,13 +235,14 @@ def test_kinetic_energy_integral_horton_anorcc_bec():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["Be", "C"], np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]), 'cartesian'
+        basis_dict,
+        ["Be", "C"],
+        np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_kinetic_energy_integral = np.load(
         find_datafile("data_horton_bec_cart_kinetic_energy_integral.npy")
     )
-    assert np.allclose(
-        kinetic_energy_integral(basis), horton_kinetic_energy_integral
-    )
+    assert np.allclose(kinetic_energy_integral(basis), horton_kinetic_energy_integral)
diff --git a/tests/test_moment.py b/tests/test_moment.py
index b191e14e..accd1306 100644
--- a/tests/test_moment.py
+++ b/tests/test_moment.py
@@ -12,10 +12,10 @@
 def test_moment_construct_array_contraction():
     """Test gbasis.integrals.moment.Moment.construct_array_contraction."""
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), "spherical"
     )
     answer = np.array(
         [
@@ -134,7 +134,7 @@ def test_moment_construct_array_contraction():
 def test_moment_cartesian():
     """Test gbasis.integrals.moment.moment_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     moment_obj = Moment(basis)
 
     assert np.allclose(
@@ -180,7 +180,7 @@ def test_moment_spherical():
     """Test gbasis.integrals.moment.moment_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     moment_obj = Moment(basis)
     assert np.allclose(
         moment_obj.construct_array_spherical(
@@ -225,7 +225,7 @@ def test_moment_mix():
     """Test gbasis.integrals.moment.moment_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ['spherical'] * 8)
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
     moment_obj = Moment(basis)
     assert np.allclose(
         moment_obj.construct_array_mix(
@@ -270,7 +270,7 @@ def test_moment_mix():
 def test_moment_spherical_lincomb():
     """Test gbasis.integrals.moment.moment_spherical_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     moment_obj = Moment(basis)
     transform = np.random.rand(14, 18)
     assert np.allclose(
diff --git a/tests/test_momentum.py b/tests/test_momentum.py
index 645e6c63..fbb655d9 100644
--- a/tests/test_momentum.py
+++ b/tests/test_momentum.py
@@ -12,10 +12,10 @@
 def test_momentum_construct_array_contraction():
     """Test gbasis.integrals.momentum.MomentumIntegral.construct_array_contraction."""
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), "spherical"
     )
     test = MomentumIntegral.construct_array_contraction(test_one, test_two).squeeze()
     answer = np.array(
@@ -162,7 +162,7 @@ def test_momentum_construct_array_contraction():
 def test_momentum_integral_cartesian():
     """Test gbasis.integrals.momentum.momentum_integral_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     momentum_integral_obj = MomentumIntegral(basis)
     assert np.allclose(
         momentum_integral_obj.construct_array_cartesian(),
@@ -174,7 +174,7 @@ def test_momentum_integral_spherical():
     """Test gbasis.integrals.momentum.momentum_integral_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     momentum_integral_obj = MomentumIntegral(basis)
     assert np.allclose(
         momentum_integral_obj.construct_array_spherical(),
@@ -186,7 +186,7 @@ def test_momentum_integral_mix():
     """Test gbasis.integrals.momentum.momentum_integral_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ['spherical'] * 8)
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
     momentum_integral_obj = MomentumIntegral(basis)
     assert np.allclose(
         momentum_integral_obj.construct_array_mix(["spherical"] * 8),
@@ -197,7 +197,7 @@ def test_momentum_integral_mix():
 def test_momentum_integral_lincomb():
     """Test gbasis.integrals.momentum.momentum_integral_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     momentum_integral_obj = MomentumIntegral(basis)
     transform = np.random.rand(14, 18)
     assert np.allclose(
diff --git a/tests/test_nuclear_electron_attraction.py b/tests/test_nuclear_electron_attraction.py
index 61c29de0..0e67871b 100644
--- a/tests/test_nuclear_electron_attraction.py
+++ b/tests/test_nuclear_electron_attraction.py
@@ -15,14 +15,12 @@ def test_nuclear_electron_attraction_horton_anorcc_hhe():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     coords = np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["H", "He"], coords, 'cartesian')
+    basis = make_contractions(basis_dict, ["H", "He"], coords, "cartesian")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_nucattract = np.load(find_datafile("data_horton_hhe_cart_nucattract.npy"))
     assert np.allclose(
-        nuclear_electron_attraction_integral(
-            basis, coords, np.array([1, 2])
-        ),
+        nuclear_electron_attraction_integral(basis, coords, np.array([1, 2])),
         horton_nucattract,
     )
 
@@ -36,14 +34,12 @@ def test_nuclear_electron_attraction_horton_anorcc_bec():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     coords = np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]])
-    basis = make_contractions(basis_dict, ["Be", "C"], coords, 'cartesian')
+    basis = make_contractions(basis_dict, ["Be", "C"], coords, "cartesian")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_nucattract = np.load(find_datafile("data_horton_bec_cart_nucattract.npy"))
     assert np.allclose(
-        nuclear_electron_attraction_integral(
-            basis, coords, np.array([4, 6])
-        ),
+        nuclear_electron_attraction_integral(basis, coords, np.array([4, 6])),
         horton_nucattract,
     )
 
@@ -51,57 +47,49 @@ def test_nuclear_electron_attraction_horton_anorcc_bec():
 def test_nuclear_electron_attraction_cartesian():
     """Test gbasis.integrals.nuclear_electron_attraction.nuclear_electron_attraction_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
 
     nuclear_coords = np.random.rand(5, 3)
     nuclear_charges = np.random.rand(5)
     ref = point_charge_integral(basis, nuclear_coords, nuclear_charges)
     assert np.allclose(
         ref[:, :, 0] + ref[:, :, 1] + ref[:, :, 2] + ref[:, :, 3] + ref[:, :, 4],
-        nuclear_electron_attraction_integral(
-            basis, nuclear_coords, nuclear_charges
-        ),
+        nuclear_electron_attraction_integral(basis, nuclear_coords, nuclear_charges),
     )
 
 
 def test_nuclear_electron_attraction_spherical():
     """Test gbasis.integrals.nuclear_electron_attraction.nuclear_electron_attraction_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
 
     nuclear_coords = np.random.rand(5, 3)
     nuclear_charges = np.random.rand(5)
     ref = point_charge_integral(basis, nuclear_coords, nuclear_charges)
     assert np.allclose(
         ref[:, :, 0] + ref[:, :, 1] + ref[:, :, 2] + ref[:, :, 3] + ref[:, :, 4],
-        nuclear_electron_attraction_integral(
-            basis, nuclear_coords, nuclear_charges
-        ),
+        nuclear_electron_attraction_integral(basis, nuclear_coords, nuclear_charges),
     )
 
 
 def test_nuclear_electron_attraction_mix():
     """Test gbasis.integrals.nuclear_electron_attraction.nuclear_electron_attraction_mix."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ['spherical'] * 8)
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), ["spherical"] * 8)
 
     nuclear_coords = np.random.rand(5, 3)
     nuclear_charges = np.random.rand(5)
-    ref = point_charge_integral(
-        basis, nuclear_coords, nuclear_charges
-    )
+    ref = point_charge_integral(basis, nuclear_coords, nuclear_charges)
     assert np.allclose(
         ref[:, :, 0] + ref[:, :, 1] + ref[:, :, 2] + ref[:, :, 3] + ref[:, :, 4],
-        nuclear_electron_attraction_integral(
-            basis, nuclear_coords, nuclear_charges
-        ),
+        nuclear_electron_attraction_integral(basis, nuclear_coords, nuclear_charges),
     )
 
 
 def test_nuclear_electron_attraction_lincomb():
     """Test gbasis.integrals.nuclear_electron_attraction.nuclear_electron_attraction_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
 
     nuclear_coords = np.random.rand(5, 3)
     nuclear_charges = np.random.rand(5)
diff --git a/tests/test_one_elec_int.py b/tests/test_one_elec_int.py
index 244f52a4..ea6d9bfa 100644
--- a/tests/test_one_elec_int.py
+++ b/tests/test_one_elec_int.py
@@ -46,10 +46,10 @@ def boys_func(order, weighted_dist):
 def test_compute_one_elec_int_v_recursion():
     """Test vertical recursion in _one_elec_int._compute_one_elec_integrals."""
     contr_one = GeneralizedContractionShell(
-        3, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.25]), 'spherical'
+        3, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.25]), "spherical"
     )
     contr_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.02, 0.01]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.02, 0.01]), "spherical"
     )
     coord_a = contr_one.coord
     angmom_a = contr_one.angmom
@@ -98,10 +98,10 @@ def test_compute_one_elec_int_s_type():
     """Test _one_elec_int._compute_one_electron_integrals for s-type primitives."""
     # GeneralizedContractionShell(angmom, coord, charge, coeffs, exps)
     s_type_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), "spherical"
     )
     s_type_two = GeneralizedContractionShell(
-        1, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.02]), 'spherical'
+        1, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.02]), "spherical"
     )
     coord_a = s_type_one.coord
     angmom_a = s_type_one.angmom
@@ -182,10 +182,10 @@ def test_compute_one_elec_int_multiple_contractions():
     """Test _one_elec_int._compute_one_electron_integrals for s-type contractions."""
     # GeneralizedContractionShell(angmom, coord, charge, coeffs, exps)
     contr_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.25]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.25]), "spherical"
     )
     contr_two = GeneralizedContractionShell(
-        1, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.02, 0.01]), 'spherical'
+        1, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.02, 0.01]), "spherical"
     )
     coord_a = contr_one.coord
     angmom_a = contr_one.angmom
@@ -227,10 +227,18 @@ def test_compute_one_elec_int_multiple_contractions():
 def test_compute_one_elec_int_generalized_contraction():
     """Test _one_elec_int._compute_one_electron_integrals for generalized contractions."""
     contr_one = GeneralizedContractionShell(
-        3, np.array([0.5, 1, 1.5]), np.array([[1.0, 2.0], [1.5, 2.5]]), np.array([0.1, 0.25]), 'spherical'
+        3,
+        np.array([0.5, 1, 1.5]),
+        np.array([[1.0, 2.0], [1.5, 2.5]]),
+        np.array([0.1, 0.25]),
+        "spherical",
     )
     contr_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([[3.0, 4.0], [3.5, 4.5]]), np.array([0.02, 0.01]), 'spherical'
+        2,
+        np.array([1.5, 2, 3]),
+        np.array([[3.0, 4.0], [3.5, 4.5]]),
+        np.array([0.02, 0.01]),
+        "spherical",
     )
     coord_a = contr_one.coord
     angmom_a = contr_one.angmom
diff --git a/tests/test_overlap.py b/tests/test_overlap.py
index ac84b232..bbde136c 100644
--- a/tests/test_overlap.py
+++ b/tests/test_overlap.py
@@ -13,10 +13,10 @@
 def test_overlap_construct_array_contraction():
     """Test gbasis.integrals.overlap.Overlap.construct_array_contraction."""
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0, 2.0]), np.array([0.1, 0.01]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), 'spherical'
+        2, np.array([1.5, 2, 3]), np.array([3.0, 4.0]), np.array([0.2, 0.02]), "spherical"
     )
     answer = np.array(
         [
@@ -77,9 +77,7 @@ def test_overlap_cartesian():
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
     basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     overlap_obj = Overlap(basis)
-    assert np.allclose(
-        overlap_obj.construct_array_cartesian(), overlap_integral(basis)
-    )
+    assert np.allclose(overlap_obj.construct_array_cartesian(), overlap_integral(basis))
 
 
 def test_overlap_spherical():
@@ -88,9 +86,7 @@ def test_overlap_spherical():
 
     basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     overlap_obj = Overlap(basis)
-    assert np.allclose(
-        overlap_obj.construct_array_spherical(), overlap_integral(basis)
-    )
+    assert np.allclose(overlap_obj.construct_array_spherical(), overlap_integral(basis))
 
 
 def test_overlap_mix():
@@ -125,7 +121,7 @@ def test_overlap_cartesian_norm_anorcc():
     """
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     overlap_obj = Overlap(basis)
     assert np.allclose(np.diag(overlap_obj.construct_array_cartesian()), 1)
 
@@ -139,7 +135,7 @@ def test_overlap_spherical_norm_sto6g():
     """
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     overlap_obj = Overlap(basis)
     assert np.allclose(np.diag(overlap_obj.construct_array_spherical()), 1)
 
@@ -152,11 +148,11 @@ def test_overlap_spherical_norm_anorcc():
     """
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
 
-    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["C"], np.array([[0, 0, 0]]), "cartesian")
     overlap_obj = Overlap(basis)
     assert np.allclose(np.diag(overlap_obj.construct_array_cartesian()), 1)
 
-    basis = make_contractions(basis_dict, ["Xe"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Xe"], np.array([[0, 0, 0]]), "cartesian")
     overlap_obj = Overlap(basis)
     assert np.allclose(np.diag(overlap_obj.construct_array_cartesian()), 1)
 
@@ -170,7 +166,7 @@ def test_overlap_cartesian_norm_sto6g():
     """
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
 
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     overlap_obj = Overlap(basis)
     assert np.allclose(np.diag(overlap_obj.construct_array_cartesian()), 1)
 
@@ -184,7 +180,10 @@ def test_overlap_horton_anorcc_hhe():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["H", "He"], np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]), "cartesian"
+        basis_dict,
+        ["H", "He"],
+        np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
@@ -201,7 +200,10 @@ def test_overlap_horton_anorcc_bec():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["Be", "C"], np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]), "cartesian"
+        basis_dict,
+        ["Be", "C"],
+        np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
 
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
diff --git a/tests/test_overlap_asymm.py b/tests/test_overlap_asymm.py
index e6f43529..edeb43bf 100644
--- a/tests/test_overlap_asymm.py
+++ b/tests/test_overlap_asymm.py
@@ -15,15 +15,16 @@ def test_overlap_integral_asymmetric_horton_anorcc_hhe():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["H", "He"], np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]), "cartesian"
+        basis_dict,
+        ["H", "He"],
+        np.array([[0, 0, 0], [0.8 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_overlap_integral_asymmetric = np.load(find_datafile("data_horton_hhe_cart_overlap.npy"))
     assert np.allclose(
-        overlap_integral_asymmetric(
-            basis, basis
-        ),
+        overlap_integral_asymmetric(basis, basis),
         horton_overlap_integral_asymmetric,
     )
 
@@ -37,15 +38,16 @@ def test_overlap_integral_asymmetric_horton_anorcc_bec():
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     # NOTE: used HORTON's conversion factor for angstroms to bohr
     basis = make_contractions(
-        basis_dict, ["Be", "C"], np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]), "cartesian"
+        basis_dict,
+        ["Be", "C"],
+        np.array([[0, 0, 0], [1.0 * 1.0 / 0.5291772083, 0, 0]]),
+        "cartesian",
     )
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     horton_overlap_integral_asymmetric = np.load(find_datafile("data_horton_bec_cart_overlap.npy"))
     assert np.allclose(
-        overlap_integral_asymmetric(
-            basis, basis
-        ),
+        overlap_integral_asymmetric(basis, basis),
         horton_overlap_integral_asymmetric,
     )
 
@@ -53,24 +55,37 @@ def test_overlap_integral_asymmetric_horton_anorcc_bec():
 def test_overlap_integral_asymmetric_compare():
     """Test overlap_asymm.overlap_integral_asymmetric against overlap.overlap_integral."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
-    cartesian_basis = make_contractions(basis_dict, ["Kr", "Kr"], np.array([[0, 0, 0], [1.0, 0, 0]]), "cartesian")
-    spherical_basis = make_contractions(basis_dict, ["Kr", "Kr"], np.array([[0, 0, 0], [1.0, 0, 0]]), "spherical")
-    mixed_basis = make_contractions(basis_dict, ["Kr", "Kr"], np.array([[0, 0, 0], [1.0, 0, 0]]), ['spherical'] * 9 + ['cartesian'])
-    cartesian_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in cartesian_basis]
-    spherical_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in spherical_basis]
-    mixed_basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in mixed_basis]
+    cartesian_basis = make_contractions(
+        basis_dict, ["Kr", "Kr"], np.array([[0, 0, 0], [1.0, 0, 0]]), "cartesian"
+    )
+    spherical_basis = make_contractions(
+        basis_dict, ["Kr", "Kr"], np.array([[0, 0, 0], [1.0, 0, 0]]), "spherical"
+    )
+    mixed_basis = make_contractions(
+        basis_dict,
+        ["Kr", "Kr"],
+        np.array([[0, 0, 0], [1.0, 0, 0]]),
+        ["spherical"] * 9 + ["cartesian"],
+    )
+    cartesian_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in cartesian_basis
+    ]
+    spherical_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type)
+        for i in spherical_basis
+    ]
+    mixed_basis = [
+        HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in mixed_basis
+    ]
 
     assert np.allclose(
         overlap_integral(cartesian_basis),
-        overlap_integral_asymmetric(
-            cartesian_basis, cartesian_basis
-        ),
+        overlap_integral_asymmetric(cartesian_basis, cartesian_basis),
     )
     assert np.allclose(
         overlap_integral(spherical_basis),
-        overlap_integral_asymmetric(
-            spherical_basis, spherical_basis
-        ),
+        overlap_integral_asymmetric(spherical_basis, spherical_basis),
     )
     assert np.allclose(
         overlap_integral(spherical_basis, transform=np.identity(218)),
diff --git a/tests/test_parsers.py b/tests/test_parsers.py
index 10059787..5a42726f 100644
--- a/tests/test_parsers.py
+++ b/tests/test_parsers.py
@@ -762,24 +762,28 @@ def test_make_contractions():
     """Test gbasis.contractions.make_contractions."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
     with pytest.raises(TypeError):
-        make_contractions(basis_dict, {"H", "H"}, np.array([[0, 0, 0], [1, 1, 1]]), 'spherical')
+        make_contractions(basis_dict, {"H", "H"}, np.array([[0, 0, 0], [1, 1, 1]]), "spherical")
     with pytest.raises(TypeError):
-        make_contractions(basis_dict, [0, 0], np.array([[0, 0, 0], [1, 1, 1]]), 'spherical')
+        make_contractions(basis_dict, [0, 0], np.array([[0, 0, 0], [1, 1, 1]]), "spherical")
 
     with pytest.raises(TypeError):
-        make_contractions(basis_dict, ["H", "H"], [[0, 0, 0], [1, 1, 1]], 'spherical')
+        make_contractions(basis_dict, ["H", "H"], [[0, 0, 0], [1, 1, 1]], "spherical")
     with pytest.raises(TypeError):
-        make_contractions(basis_dict, ["H", "H"], np.array([0, 0, 0, 1, 1, 1]), 'spherical')
+        make_contractions(basis_dict, ["H", "H"], np.array([0, 0, 0, 1, 1, 1]), "spherical")
     with pytest.raises(TypeError):
-        make_contractions(basis_dict, ["H", "H"], np.array([[0, 0, 0, 2], [1, 1, 1, 2]]), 'spherical')
+        make_contractions(
+            basis_dict, ["H", "H"], np.array([[0, 0, 0, 2], [1, 1, 1, 2]]), "spherical"
+        )
 
     with pytest.raises(ValueError):
-        make_contractions(basis_dict, ["H", "H", "H"], np.array([[0, 0, 0], [1, 1, 1]]), 'spherical')
+        make_contractions(
+            basis_dict, ["H", "H", "H"], np.array([[0, 0, 0], [1, 1, 1]]), "spherical"
+        )
 
     with pytest.raises(TypeError):
         make_contractions(basis_dict, ["H", "H"], np.array([[0, 0, 0], [1, 1, 1]]), [0, 0])
 
-    test = make_contractions(basis_dict, ["H", "H"], np.array([[0, 0, 0], [1, 1, 1]]), 'spherical')
+    test = make_contractions(basis_dict, ["H", "H"], np.array([[0, 0, 0], [1, 1, 1]]), "spherical")
     assert isinstance(test, tuple)
     assert len(test) == 2
     assert test[0].angmom == 0
diff --git a/tests/test_point_charge.py b/tests/test_point_charge.py
index b4586264..0b4fd6a7 100644
--- a/tests/test_point_charge.py
+++ b/tests/test_point_charge.py
@@ -33,9 +33,13 @@ def test_boys_func():
 def test_construct_array_contraction():
     """Test gbasis.integrals.point_charge.PointChargeIntegral.construct_array_contraction."""
     coord_one = np.array([0.5, 1, 1.5])
-    test_one = GeneralizedContractionShell(0, coord_one, np.array([1.0]), np.array([0.1]), 'spherical')
+    test_one = GeneralizedContractionShell(
+        0, coord_one, np.array([1.0]), np.array([0.1]), "spherical"
+    )
     coord_two = np.array([1.5, 2, 3])
-    test_two = GeneralizedContractionShell(0, coord_two, np.array([3.0]), np.array([0.2]), 'spherical')
+    test_two = GeneralizedContractionShell(
+        0, coord_two, np.array([3.0]), np.array([0.2]), "spherical"
+    )
     coord = np.array([[0, 0, 0]])
     charge = np.array([1])
     coord_wac = (0.1 * coord_one + 0.2 * coord_two) / (0.1 + 0.2)
@@ -70,10 +74,10 @@ def test_construct_array_contraction():
     )
 
     test_one = GeneralizedContractionShell(
-        1, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), 'spherical'
+        1, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        0, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.2]), 'spherical'
+        0, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.2]), "spherical"
     )
     v_000_000 = [
         2
@@ -97,10 +101,10 @@ def test_construct_array_contraction():
     )
 
     test_one = GeneralizedContractionShell(
-        0, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), 'spherical'
+        0, np.array([0.5, 1, 1.5]), np.array([1.0]), np.array([0.1]), "spherical"
     )
     test_two = GeneralizedContractionShell(
-        1, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.2]), 'spherical'
+        1, np.array([1.5, 2, 3]), np.array([3.0]), np.array([0.2]), "spherical"
     )
     assert np.allclose(
         PointChargeIntegral.construct_array_contraction(test_one, test_two, coord, charge).ravel(),
@@ -119,7 +123,7 @@ def test_construct_array_contraction():
 def test_point_charge_cartesian():
     """Test gbasis.integrals.point_charge.point_charge_cartesian."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'cartesian')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "cartesian")
     point_charge_obj = PointChargeIntegral(basis)
 
     points_coords = np.random.rand(5, 3)
@@ -128,16 +132,14 @@ def test_point_charge_cartesian():
         point_charge_obj.construct_array_cartesian(
             points_coords=points_coords, points_charge=points_charge
         ),
-        point_charge_integral(
-            basis, points_coords=points_coords, points_charge=points_charge
-        ),
+        point_charge_integral(basis, points_coords=points_coords, points_charge=points_charge),
     )
 
 
 def test_point_charge_spherical():
     """Test gbasis.integrals.point_charge.point_charge_spherical."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     point_charge_obj = PointChargeIntegral(basis)
 
     points_coords = np.random.rand(5, 3)
@@ -146,9 +148,7 @@ def test_point_charge_spherical():
         point_charge_obj.construct_array_spherical(
             points_coords=points_coords, points_charge=points_charge
         ),
-        point_charge_integral(
-            basis, points_coords=points_coords, points_charge=points_charge
-        ),
+        point_charge_integral(basis, points_coords=points_coords, points_charge=points_charge),
     )
 
 
@@ -164,14 +164,14 @@ def test_point_charge_mix():
         point_charge_obj.construct_array_mix(
             ["spherical"] * 8, points_coords=points_coords, points_charge=points_charge
         ),
-        point_charge_integral(basis, points_coords, points_charge)
+        point_charge_integral(basis, points_coords, points_charge),
     )
 
 
 def test_point_charge_lincomb():
     """Test gbasis.integrals.point_charge.point_charge_lincomb."""
     basis_dict = parse_nwchem(find_datafile("data_sto6g.nwchem"))
-    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), 'spherical')
+    basis = make_contractions(basis_dict, ["Kr"], np.array([[0, 0, 0]]), "spherical")
     point_charge_obj = PointChargeIntegral(basis)
 
     points_coords = np.random.rand(5, 3)
diff --git a/tests/test_stress_tensor.py b/tests/test_stress_tensor.py
index 5aef2759..a9ef3f56 100644
--- a/tests/test_stress_tensor.py
+++ b/tests/test_stress_tensor.py
@@ -19,7 +19,7 @@ def test_evaluate_stress_tensor():
     """Test gbasis.evals.stress_tensor.evaluate_stress_tensor."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     coords = np.array([[0, 0, 0]])
-    basis = make_contractions(basis_dict, ["H"], coords, 'spherical')
+    basis = make_contractions(basis_dict, ["H"], coords, "spherical")
     points = np.random.rand(10, 3)
 
     with pytest.raises(TypeError):
@@ -78,7 +78,7 @@ def test_evaluate_ehrenfest_force():
     """Test gbasis.evals.stress_tensor.evaluate_ehrenfest_force."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     coords = np.array([[0, 0, 0]])
-    basis = make_contractions(basis_dict, ["H"], coords, 'spherical')
+    basis = make_contractions(basis_dict, ["H"], coords, "spherical")
     points = np.random.rand(10, 3)
 
     with pytest.raises(TypeError):
@@ -139,7 +139,7 @@ def test_evaluate_ehrenfest_hessian():
     """Test gbasis.evals.stress_tensor.evaluate_ehrenfest_hessian."""
     basis_dict = parse_nwchem(find_datafile("data_anorcc.nwchem"))
     coords = np.array([[0, 0, 0]])
-    basis = make_contractions(basis_dict, ["H"], coords, 'spherical')
+    basis = make_contractions(basis_dict, ["H"], coords, "spherical")
     basis = [HortonContractions(i.angmom, i.coord, i.coeffs, i.exps, i.coord_type) for i in basis]
 
     points = np.random.rand(10, 3)