From 48c8657f0fe9ba78d3d63470af9753a4c231c2bf Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Mon, 4 Nov 2024 18:31:42 -0500
Subject: [PATCH 1/8] refactor contingency table, add tests

---
 README.md              |   2 +
 src/pqm/pqm.py         | 523 +++++++----------------------------------
 src/pqm/utils.py       | 230 ++++++++++++++++++
 tests/test_gaussian.py |  71 ------
 tests/test_pqm.py      | 110 +++++++++
 5 files changed, 422 insertions(+), 514 deletions(-)
 create mode 100644 src/pqm/utils.py
 delete mode 100644 tests/test_gaussian.py
 create mode 100644 tests/test_pqm.py

diff --git a/README.md b/README.md
index 3e26801..3d3d001 100644
--- a/README.md
+++ b/README.md
@@ -22,9 +22,11 @@ PQMass takes in $x$ and $y$ two datasets and determines if they come from the sa
 
 ![Headline plot showing an example tessellation for PQMass](media/Voronoi.png "")
 PQMass partitions the space by taking reference points from $x$ and $y$ and creating Voronoi tessellations around the reference points. On the left is an example of one such region, which we note follows a Binomial Distribution; the samples are either inside or outside the region. On the right is the entire space partitioned, allowing us to see that this is a multinomial distribution, a given sample can be in region P or any other region. This is crucial as it allows for two metrics to be defined that can be used to determine if $x$ and $y$ come from the same underlying distribution. The first is the $\chi_{PQM}^2$
+
 $$\chi_{PQM}^2 \equiv \sum_{i = 1}^{n_R} \left[ \frac{(k({\bf x}, R_i) - \hat{N}_{x, i})^2}{\hat{N}_{x, i}} + \frac{(k({\bf y}, R_i) - \hat{N}_{y, i})^2}{\hat{N}_{y, i}} \right]$$
 
 and the second is the $\text{p-value}(\chi_{PQM}^2)$
+
 $$\text{p-value}(\chi_{PQM}^2) \equiv \int_{-\infty}^{\chi^2_{\rm {PQM}}} \chi^2_{n_R - 1}(z) dz$$
 
 For $\chi_{PQM}^2$ metric, given your two sets of samples, if they come from the same
diff --git a/src/pqm/pqm.py b/src/pqm/pqm.py
index 5d441a7..1380d8e 100644
--- a/src/pqm/pqm.py
+++ b/src/pqm/pqm.py
@@ -1,370 +1,22 @@
-from typing import Optional
+from typing import Optional, Union, Tuple
 import warnings
+
 import torch
 import numpy as np
-from scipy.stats import chi2_contingency, chi2
-from scipy.spatial.distance import cdist
-from torch.distributions import Multinomial
-from typing import Optional, Union, Tuple
+from scipy.stats import chi2_contingency
+
+from .utils import (
+    _mean_std_numpy,
+    _mean_std_torch,
+    _sample_reference_indices_numpy,
+    _sample_reference_indices_torch,
+    _compute_counts_numpy,
+    _compute_counts_torch,
+    _rescale_chi2,
+)
 
 __all__ = ("pqm_chi2", "pqm_pvalue")
 
-def _mean_std(sample1, sample2, dim=0):
-    """Get the mean and std of two combined samples without actually combining them."""
-    # Check if both samples are PyTorch tensors
-    if isinstance(sample1, torch.Tensor) and isinstance(sample2, torch.Tensor):
-        n1 = sample1.shape[dim]
-        n2 = sample2.shape[dim]
-        
-        mx = torch.mean(sample1, dim=dim)
-        sx = torch.std(sample1, dim=dim, unbiased=True)
-        my = torch.mean(sample2, dim=dim)
-        sy = torch.std(sample2, dim=dim, unbiased=True)
-        
-        m = (n1 * mx + n2 * my) / (n1 + n2)
-        s = torch.sqrt(
-            (
-                (n1 - 1) * (sx ** 2)
-                + (n2 - 1) * (sy ** 2)
-                + n1 * n2 * (mx - my) ** 2 / (n1 + n2)
-            )
-            / (n1 + n2 - 1)
-        )
-        return m, s
-
-    # Check if both samples are NumPy arrays
-    elif isinstance(sample1, np.ndarray) and isinstance(sample2, np.ndarray):
-        n1 = sample1.shape[dim]
-        n2 = sample2.shape[dim]
-        
-        mx = np.mean(sample1, axis=dim)
-        sx = np.std(sample1, axis=dim, ddof=1)
-        my = np.mean(sample2, axis=dim)
-        sy = np.std(sample2, axis=dim, ddof=1)
-        
-        m = (n1 * mx + n2 * my) / (n1 + n2)
-        s = np.sqrt(
-            (
-                (n1 - 1) * (sx ** 2)
-                + (n2 - 1) * (sy ** 2)
-                + n1 * n2 * (mx - my) ** 2 / (n1 + n2)
-            )
-            / (n1 + n2 - 1)
-        )
-        return m, s
-
-def rescale_chi2(chi2_stat, orig_dof, target_dof, device):
-    """
-    Rescale chi2 statistic using appropriate methods depending on the device.
-    """        
-    if device.type == 'cuda' or device == 'cuda':
-        # Move tensors to CPU and convert to NumPy
-        chi2_stat_cpu = chi2_stat.cpu().item()  # Convert to float
-        orig_dof_cpu = orig_dof.cpu().item()    # Convert to float
-    else:
-        chi2_stat_cpu = chi2_stat
-        orig_dof_cpu = orig_dof
-
-    if orig_dof_cpu == target_dof:
-        return chi2_stat_cpu
-        
-    if chi2_stat_cpu / orig_dof_cpu < 10:
-        # Use cumulative probability method for better accuracy
-        cp = chi2.sf(chi2_stat_cpu, orig_dof_cpu)
-        return chi2.isf(cp, target_dof)
-    else:
-        # Use simple scaling for large values
-        return chi2_stat_cpu * target_dof / orig_dof_cpu        
-
-def _chi2_contingency_torch(
-    counts_x: torch.Tensor,
-    counts_y: torch.Tensor
-) -> Tuple[torch.Tensor, float, torch.Tensor, torch.Tensor]:
-    """
-    Perform chi-squared contingency test using PyTorch tensors.
-    
-    Returns:
-        chi2_stat (torch.Tensor): Chi-squared statistic.
-        p_value (float): p-value.
-        dof (torch.Tensor): Degrees of freedom.
-        expected (torch.Tensor): Expected frequencies.
-    """
-    counts = torch.stack([counts_x, counts_y])
-    
-    # Observed counts
-    O = counts.float()
-    
-    # Row sums and column sums
-    row_sums = O.sum(dim=1, keepdim=True)  # shape (2, 1)
-    col_sums = O.sum(dim=0, keepdim=True)  # shape (1, N)
-    total = O.sum()
-    
-    # Expected counts under the null hypothesis of independence
-    E = row_sums @ col_sums / total  # shape (2, N)
-    
-    # Degrees of freedom
-    dof = (O.size(0) - 1) * (O.size(1) - 1)
-    
-    # Avoid division by zero
-    mask = E > 0
-    O_masked = O[mask]
-    E_masked = E[mask]
-    
-    # Compute chi-squared statistic
-    chi2_stat = ((O_masked - E_masked) ** 2 / E_masked).sum()
-    
-    # Move dof and chi2_stat to the same device
-    dof = torch.tensor(dof, dtype=torch.float32, device=chi2_stat.device)
-    
-    # Compute p-value using the survival function (1 - CDF)
-    p_value = torch.special.gammaincc(dof / 2, chi2_stat / 2).item()
-    
-    return chi2_stat, p_value, dof, E
-
-def _sample_reference_indices_numpy(Nx, nx, Ny, ny, Ng, x_samples, y_samples):
-    """
-    Helper function to sample references for CPU-based NumPy computations.
-
-    Parameters
-    ----------
-    Nx : int
-        Number of references to sample from x_samples.
-    nx : int
-        Number of samples in x_samples.
-    Ny : int
-        Number of references to sample from y_samples.
-    ny : int
-        Number of samples in y_samples.
-    Ng : int
-        Number of references to sample from a Gaussian distribution.
-
-    Returns
-    -------
-    np.ndarray  
-        References samples.
-    """
-
-    if Nx > nx:
-        raise ValueError("Cannot sample more references from x_samples than available")
-    if Ny > ny:
-        raise ValueError("Cannot sample more references from y_samples than available")
-    
-    # Reference samples from x_samples
-    xrefs_indices = np.random.choice(nx, Nx, replace=False)
-    xrefs = x_samples[xrefs_indices]
-    x_samples = np.delete(x_samples, xrefs_indices, axis=0)
-    
-    # Reference samples from y_samples
-    yrefs_indices = np.random.choice(ny, Ny, replace=False)
-    yrefs = y_samples[yrefs_indices]
-    y_samples = np.delete(y_samples, yrefs_indices, axis=0)
-    
-    # Combine references
-    refs = np.concatenate([xrefs, yrefs], axis=0)
-    
-    # Gaussian references
-    if Ng > 0:
-        m, s = _mean_std(x_samples, y_samples)
-        gauss_refs = np.random.normal(
-            loc=m,
-            scale=s,
-            size=(Ng, ) + tuple(x_samples.shape[1:])
-        )
-        refs = np.concatenate([refs, gauss_refs], axis=0)
-
-    return refs
-
-def _compute_distances_numpy(x_samples, y_samples, refs, current_num_refs, num_refs):
-    """
-    Helper function to calculate distances for CPU-based NumPy computations.
-
-    Parameters
-    ----------
-    x_samples : np.ndarray
-        Samples from the first distribution. Must have shape (N, *D) N is the
-        number of x samples, and D is the dimensionality of the samples.
-    y_samples : np.ndarray
-        Samples from the second distribution. Must have shape (M, *D) M is the
-        number of y samples, and D is the dimensionality of the samples.
-    refs : np.ndarray
-        Reference samples. Must have shape (num_refs, *D) where D is the
-        dimensionality of the samples.
-    current_num_refs : int
-        Number of reference samples used in the test.
-    num_refs : int
-        Number of reference samples to use.
-
-    Returns
-    -------
-    tuple
-        Results from scipy.stats.chi2_contingency.
-    """
-
-    # Compute distances
-    distances_x = cdist(x_samples, refs, metric='euclidean')
-    distances_y = cdist(y_samples, refs, metric='euclidean')
-    
-    # Nearest references
-    idx_x = np.argmin(distances_x, axis=1)
-    idx_y = np.argmin(distances_y, axis=1)
-    
-    # Counts
-    counts_x = np.bincount(idx_x, minlength=current_num_refs)
-    counts_y = np.bincount(idx_y, minlength=current_num_refs)
-    
-    # Remove references with no counts
-    C = (counts_x > 0) | (counts_y > 0)
-    counts_x = counts_x[C]
-    counts_y = counts_y[C]
-    
-    n_filled_bins = np.sum(C)
-    if n_filled_bins == 1:
-        raise ValueError(
-            """
-            Only one Voronoi cell has samples, so chi^2 cannot 
-            be computed. This is likely due to a small number 
-            of samples or a pathological distribution. If possible, 
-            increase the number of x_samples and y_samples.
-            """
-        )
-    if n_filled_bins < (num_refs // 2):
-        warnings.warn(
-            """
-            Less than half of the Voronoi cells have any samples in them.
-            Possibly due to a small number of samples or a pathological
-            distribution. Result may be unreliable. If possible, increase the
-            number of x_samples and y_samples.
-            """
-        )
-    
-    # Perform chi-squared test using SciPy
-    contingency_table = np.stack([counts_x, counts_y])
-    return chi2_contingency(contingency_table)
-
-def _sample_reference_indices_torch(Nx, nx, Ny, ny, Ng, x_samples, y_samples, device):
-    """
-    Helper function to sample references for GPU-based Torch computations.
-
-    Parameters
-    ----------
-    Nx : int
-        Number of references to sample from x_samples.
-    nx : int
-        Number of samples in x_samples.
-    Ny : int
-        Number of references to sample from y_samples.
-    ny : int
-        Number of samples in y_samples.
-    Ng : int
-        Number of references to sample from a Gaussian distribution.
-
-    Returns
-    -------
-    np.ndarray  
-        References samples.
-    """
-    
-    if Nx > nx:
-        raise ValueError("Cannot sample more references from x_samples than available")
-    if Ny > ny:
-        raise ValueError("Cannot sample more references from y_samples than available")
-    
-    # Reference samples from x_samples
-    x_indices = torch.randperm(nx, device=device)
-    xrefs_indices = x_indices[:Nx]
-    x_samples_indices = x_indices[Nx:]
-    xrefs = x_samples[xrefs_indices]
-    x_samples = x_samples[x_samples_indices]
-    
-    # Reference samples from y_samples
-    y_indices = torch.randperm(ny, device=device)
-    yrefs_indices = y_indices[:Ny]
-    y_samples_indices = y_indices[Ny:]
-    yrefs = y_samples[yrefs_indices]
-    y_samples = y_samples[y_samples_indices]
-    
-    # Combine references
-    refs = torch.cat([xrefs, yrefs], dim=0)
-    
-    # Gaussian references
-    if Ng > 0:
-        m, s = _mean_std(x_samples, y_samples)
-        # Ensure m and s have the correct shape
-        if m.dim() == 1:
-            m = m.unsqueeze(0)
-        if s.dim() == 1:
-            s = s.unsqueeze(0)
-        gauss_refs = torch.normal(
-            mean=m.repeat(Ng, 1),
-            std=s.repeat(Ng, 1),
-        )
-        refs = torch.cat([refs, gauss_refs], dim=0)
-    return refs
-    
-def _compute_distances_torch(x_samples, y_samples, refs, current_num_refs, num_refs):
-    """
-    Helper function to calculate distances for GPU-based Torch computations.
-
-    Parameters
-    ----------
-    x_samples : torch.Tensor
-        Samples from the first distribution. Must have shape (N, *D) N is the
-        number of x samples, and D is the dimensionality of the samples.
-    y_samples : torch.Tensor
-        Samples from the second distribution. Must have shape (M, *D) M is the
-        number of y samples, and D is the dimensionality of the samples.
-    refs : torch.Tensor
-        Reference samples. Must have shape (num_refs, *D) where D is the
-        dimensionality of the samples.
-    current_num_refs : int
-        Number of reference samples used in the test.
-    num_refs : int
-        Number of reference samples to use.
-
-    Returns
-    -------
-    tuple
-        Results from the PyTorch implementation of chi2_contingency.
-    """
-
-    # Compute distances and find nearest references
-    distances_x = torch.cdist(x_samples, refs)
-    distances_y = torch.cdist(y_samples, refs)
-
-    idx_x = distances_x.argmin(dim=1)
-    idx_y = distances_y.argmin(dim=1)
-
-    counts_x = torch.bincount(idx_x, minlength=current_num_refs)
-    counts_y = torch.bincount(idx_y, minlength=current_num_refs)
-    
-    # Remove references with no counts
-    C = (counts_x > 0) | (counts_y > 0)
-    counts_x = counts_x[C]
-    counts_y = counts_y[C]
-    
-    n_filled_bins = C.sum().item()
-    if n_filled_bins == 1:
-        raise ValueError(
-            """
-            Only one Voronoi cell has samples, so chi^2 cannot 
-            be computed. This is likely due to a small number 
-            of samples or a pathological distribution. If possible, 
-            increase the number of x_samples and y_samples.
-            """
-        )
-    if n_filled_bins < (num_refs // 2):
-        warnings.warn(
-            """
-            Less than half of the Voronoi cells have any samples in them.
-            Possibly due to a small number of samples or a pathological
-            distribution. Result may be unreliable. If possible, increase the
-            number of x_samples and y_samples.
-            """
-        )
-    
-    # Perform chi-squared test using the PyTorch implementation
-    chi2_stat, p_value, dof, expected = _chi2_contingency_torch(counts_x, counts_y)
-    return chi2_stat, p_value, dof, expected
 
 def _pqm_test(
     x_samples: Union[np.ndarray, torch.Tensor],
@@ -432,12 +84,9 @@ def _pqm_test(
     """
 
     # Determine if we're working with NumPy or PyTorch
-    is_numpy = isinstance(x_samples, np.ndarray) and isinstance(y_samples, np.ndarray)
     is_torch = isinstance(x_samples, torch.Tensor) and isinstance(y_samples, torch.Tensor)
-    
-    if not (is_numpy or is_torch):
-        raise TypeError("x_samples and y_samples must both be either NumPy arrays or PyTorch tensors.")
-    
+    assert type(x_samples) == type(y_samples), "x_samples and y_samples must be of the same type"
+
     # Validate sample sizes
     nx = x_samples.shape[0]
     ny = y_samples.shape[0]
@@ -450,63 +99,79 @@ def _pqm_test(
             "Number of samples is small (less than twice the number of reference samples). "
             "Result will have high variance and/or be non-discriminating."
         )
-    
+
     # Z-score normalization
     if z_score_norm:
-        mean, std = _mean_std(x_samples, y_samples)
+        if is_torch:
+            mean, std = _mean_std_torch(x_samples, y_samples)
+        else:
+            mean, std = _mean_std_numpy(x_samples, y_samples)
 
         x_samples = (x_samples - mean) / std
         y_samples = (y_samples - mean) / std
-    
+
     # Determine fraction of x_samples to use as reference samples
     if x_frac is None:
         x_frac = nx / (nx + ny)
-    
+
     # Determine number of samples from each distribution
-    if is_numpy:
-        counts = np.random.multinomial(
-            num_refs,
-            [x_frac * (1.0 - gauss_frac), (1.0 - x_frac) * (1.0 - gauss_frac), gauss_frac],
-        )
-        Nx, Ny, Ng = counts
-    elif is_torch:
-        probs = torch.tensor(
-            [
-                x_frac * (1.0 - gauss_frac),
-                (1.0 - x_frac) * (1.0 - gauss_frac),
-                gauss_frac,
-            ],
-            device=device,
-        )
-        counts_tensor = Multinomial(total_count=num_refs, probs=probs).sample()
-        counts = counts_tensor.round().long().cpu().numpy()
-        Nx, Ny, Ng = counts.tolist()
-    
+    counts = np.random.multinomial(
+        num_refs,
+        [x_frac * (1.0 - gauss_frac), (1.0 - x_frac) * (1.0 - gauss_frac), gauss_frac],
+    )
+    Nx, Ny, Ng = counts
+
     # Validate counts
     if Nx + Ny + Ng != num_refs:
         raise ValueError(
             f"Something went wrong. Nx={Nx}, Ny={Ny}, Ng={Ng} should sum to num_refs={num_refs}"
         )
-    
-    # Sampling reference indices
-    if is_numpy:
-        refs = _sample_reference_indices_numpy(Nx, nx, Ny, ny, Ng, x_samples, y_samples)
-    elif is_torch:
-        refs = _sample_reference_indices_torch(Nx, nx, Ny, ny, Ng, x_samples, y_samples, device)
-    
-    # Update num_refs in case Gaussian samples were added
-    current_num_refs = Nx + Ny + Ng
-    
-    # Compute nearest references and counts
-    if is_numpy:
-        return _compute_distances_numpy(x_samples, y_samples, refs, current_num_refs, num_refs)
-    
-    elif is_torch:
-        return _compute_distances_torch(x_samples, y_samples, refs, current_num_refs, num_refs)
+    if Nx > x_samples.shape[0]:
+        raise ValueError("Cannot sample more references from x_samples than available")
+    if Ny > y_samples.shape[0]:
+        raise ValueError("Cannot sample more references from y_samples than available")
+
+    # count samples in each voronoi bin
+    if is_torch:
+        refs = _sample_reference_indices_torch(Nx, Ny, Ng, x_samples, y_samples, device)
+        counts_x, counts_y = _compute_counts_torch(x_samples, y_samples, refs, num_refs)
+    else:
+        refs = _sample_reference_indices_numpy(Nx, Ny, Ng, x_samples, y_samples)
+        counts_x, counts_y = _compute_counts_numpy(x_samples, y_samples, refs, num_refs)
+
+    # Remove references with no counts
+    C = (counts_x > 0) | (counts_y > 0)
+    counts_x = counts_x[C]
+    counts_y = counts_y[C]
+
+    n_filled_bins = C.sum().item()
+    if n_filled_bins == 1:
+        raise ValueError(
+            """
+            Only one Voronoi cell has samples, so chi^2 cannot 
+            be computed. This is likely due to a small number 
+            of samples or a pathological distribution. If possible, 
+            increase the number of x_samples and y_samples.
+            """
+        )
+    if n_filled_bins < (num_refs // 2):
+        warnings.warn(
+            """
+            Less than half of the Voronoi cells have any samples in them.
+            Possibly due to a small number of samples or a pathological
+            distribution. Result may be unreliable. If possible, increase the
+            number of x_samples and y_samples.
+            """
+        )
+
+    # Perform chi-squared test using SciPy
+    contingency_table = np.stack([counts_x, counts_y])
+    return chi2_contingency(contingency_table)
+
 
 def pqm_pvalue(
-    x_samples,
-    y_samples,
+    x_samples: Union[np.ndarray, torch.Tensor],
+    y_samples: Union[np.ndarray, torch.Tensor],
     num_refs: int = 100,
     re_tessellation: Optional[int] = None,
     z_score_norm: bool = False,
@@ -572,20 +237,6 @@ def pqm_pvalue(
         pvalue(s). Null hypothesis that both samples are drawn from the same
         distribution.
     """
-    # Check the device and convert to the respective type (Numpy or Torch) and call their respective _pqm_test function
-
-    if device.type == 'cpu' or device == 'cpu':
-        # Check if x_samples and y_samples are not already NumPy arrays
-        if not isinstance(x_samples, np.ndarray):
-            x_samples = x_samples.cpu().numpy()
-        if not isinstance(y_samples, np.ndarray):
-            y_samples = y_samples.cpu().numpy()
-    elif device.type == 'cuda' or device == 'cuda':
-        # Check if x_samples and y_samples are not already torch tensors
-        if not torch.is_tensor(x_samples):
-            x_samples = torch.tensor(x_samples, device=device)
-        if not torch.is_tensor(y_samples):
-            y_samples = torch.tensor(y_samples, device=device)
 
     if re_tessellation is not None:
         return [
@@ -600,17 +251,18 @@ def pqm_pvalue(
             )
             for _ in range(re_tessellation)
         ]
-    
+
     _, p_value, _, _ = _pqm_test(
         x_samples, y_samples, num_refs, z_score_norm, x_frac, gauss_frac, device
     )
-    
+
     # Return p-value as a float
-    return p_value if isinstance(p_value, float) else float(p_value)
+    return p_value
+
 
 def pqm_chi2(
-    x_samples,
-    y_samples,
+    x_samples: Union[np.ndarray, torch.Tensor],
+    y_samples: Union[np.ndarray, torch.Tensor],
     num_refs: int = 100,
     re_tessellation: Optional[int] = None,
     z_score_norm: bool = False,
@@ -686,20 +338,6 @@ def pqm_chi2(
         chi2 statistic(s).
     """
 
-    # Check the device and convert to the respective type (Numpy or Torch) and call their respective _pqm_test function
-    if device.type == 'cpu' or device == 'cpu':
-        # Check if x_samples and y_samples are not already NumPy arrays
-        if not isinstance(x_samples, np.ndarray):
-            x_samples = x_samples.cpu().numpy()
-        if not isinstance(y_samples, np.ndarray):
-            y_samples = y_samples.cpu().numpy()
-    elif device.type == 'cuda' or device == 'cuda':
-        # Check if x_samples and y_samples are not already torch tensors
-        if not torch.is_tensor(x_samples):
-            x_samples = torch.tensor(x_samples, device=device)
-        if not torch.is_tensor(y_samples):
-            y_samples = torch.tensor(y_samples, device=device)
-
     if re_tessellation is not None:
         return [
             pqm_chi2(
@@ -714,14 +352,13 @@ def pqm_chi2(
             for _ in range(re_tessellation)
         ]
 
-
     chi2_stat, _, dof, _ = _pqm_test(
         x_samples, y_samples, num_refs, z_score_norm, x_frac, gauss_frac, device
     )
 
     # Rescale chi2 statistic if necessary
     if dof != num_refs - 1:
-        chi2_stat = rescale_chi2(chi2_stat, dof, num_refs - 1, device)
+        chi2_stat = _rescale_chi2(chi2_stat, dof, num_refs - 1)
 
     # Return chi2_stat as a float
-    return chi2_stat.item() if isinstance(chi2_stat, torch.Tensor) else float(chi2_stat)
\ No newline at end of file
+    return chi2_stat
diff --git a/src/pqm/utils.py b/src/pqm/utils.py
new file mode 100644
index 0000000..9c37363
--- /dev/null
+++ b/src/pqm/utils.py
@@ -0,0 +1,230 @@
+from typing import Tuple
+import warnings
+
+import numpy as np
+import torch
+from scipy.stats import chi2
+from scipy.spatial.distance import cdist
+
+__all__ = (
+    "_mean_std_torch",
+    "_mean_std_numpy",
+    "_rescale_chi2",
+    "_chi2_contingency_torch",
+    "_sample_reference_indices_numpy",
+    "_compute_counts_numpy",
+    "_sample_reference_indices_torch",
+    "_compute_counts_torch",
+)
+
+
+def _mean_std_torch(sample1, sample2):
+    """Get the mean and std of two combined samples without actually combining them."""
+    n1 = sample1.shape[0]
+    n2 = sample2.shape[0]
+
+    mx = torch.mean(sample1, dim=0)
+    sx = torch.std(sample1, dim=0, unbiased=True)
+    my = torch.mean(sample2, dim=0)
+    sy = torch.std(sample2, dim=0, unbiased=True)
+
+    m = (n1 * mx + n2 * my) / (n1 + n2)
+    s = torch.sqrt(
+        ((n1 - 1) * (sx**2) + (n2 - 1) * (sy**2) + n1 * n2 * (mx - my) ** 2 / (n1 + n2))
+        / (n1 + n2 - 1)
+    )
+    return m, s
+
+
+def _mean_std_numpy(sample1, sample2):
+    """Get the mean and std of two combined samples without actually combining them."""
+    n1 = sample1.shape[0]
+    n2 = sample2.shape[0]
+
+    mx = np.mean(sample1, axis=0)
+    sx = np.std(sample1, axis=0, ddof=1)
+    my = np.mean(sample2, axis=0)
+    sy = np.std(sample2, axis=0, ddof=1)
+
+    m = (n1 * mx + n2 * my) / (n1 + n2)
+    s = np.sqrt(
+        ((n1 - 1) * (sx**2) + (n2 - 1) * (sy**2) + n1 * n2 * (mx - my) ** 2 / (n1 + n2))
+        / (n1 + n2 - 1)
+    )
+    return m, s
+
+
+def _rescale_chi2(chi2_stat, orig_dof, target_dof):
+    """
+    Rescale chi2 statistic using appropriate methods depending on the offset.
+    """
+
+    if chi2_stat / orig_dof < 10:
+        # Use cumulative probability method for better accuracy
+        cp = chi2.sf(chi2_stat, orig_dof)
+        return chi2.isf(cp, target_dof)
+    # Use simple scaling for large values
+    return chi2_stat * target_dof / orig_dof
+
+
+def _sample_reference_indices_torch(Nx, Ny, Ng, x_samples, y_samples, device):
+    """
+    Helper function to sample references for GPU-based Torch computations.
+
+    Parameters
+    ----------
+    Nx : int
+        Number of references to sample from x_samples.
+    Ny : int
+        Number of references to sample from y_samples.
+    Ng : int
+        Number of references to sample from a Gaussian distribution.
+
+    Returns
+    -------
+    np.ndarray
+        References samples.
+    """
+
+    # Reference samples from x_samples
+    x_indices = torch.randperm(x_samples.shape[0], device=device)
+    xrefs = x_samples[x_indices[:Nx]]
+    x_samples = x_samples[x_indices[Nx:]]
+
+    # Reference samples from y_samples
+    y_indices = torch.randperm(y_samples.shape[0], device=device)
+    yrefs = y_samples[y_indices[:Ny]]
+    y_samples = y_samples[y_indices[Ny:]]
+
+    # Combine references
+    refs = torch.cat([xrefs, yrefs], dim=0)
+
+    # Gaussian references
+    if Ng > 0:
+        m, s = _mean_std_torch(x_samples, y_samples)
+        # Ensure m has the correct shape
+        shaper = torch.ones(Ng, *x_samples.shape[1:], device=device)
+        gauss_refs = torch.normal(mean=m * shaper, std=s)
+        refs = torch.cat([refs, gauss_refs], dim=0)
+    return refs
+
+
+def _sample_reference_indices_numpy(Nx, Ny, Ng, x_samples, y_samples):
+    """
+    Helper function to sample references for CPU-based NumPy computations.
+
+    Parameters
+    ----------
+    Nx : int
+        Number of references to sample from x_samples.
+    Ny : int
+        Number of references to sample from y_samples.
+    Ng : int
+        Number of references to sample from a Gaussian distribution.
+
+    Returns
+    -------
+    np.ndarray
+        References samples.
+    """
+
+    # Reference samples from x_samples
+    xrefs_indices = np.random.choice(x_samples.shape[0], Nx, replace=False)
+    xrefs = x_samples[xrefs_indices]
+    x_samples = np.delete(x_samples, xrefs_indices, axis=0)
+
+    # Reference samples from y_samples
+    yrefs_indices = np.random.choice(y_samples.shape[0], Ny, replace=False)
+    yrefs = y_samples[yrefs_indices]
+    y_samples = np.delete(y_samples, yrefs_indices, axis=0)
+
+    # Combine references
+    refs = np.concatenate([xrefs, yrefs], axis=0)
+
+    # Gaussian references
+    if Ng > 0:
+        m, s = _mean_std_numpy(x_samples, y_samples)
+        gauss_refs = np.random.normal(loc=m, scale=s, size=(Ng,) + tuple(x_samples.shape[1:]))
+        refs = np.concatenate([refs, gauss_refs], axis=0)
+
+    return refs
+
+
+def _compute_counts_torch(x_samples, y_samples, refs, num_refs):
+    """
+    Helper function to calculate distances for GPU-based Torch computations.
+
+    Parameters
+    ----------
+    x_samples : torch.Tensor
+        Samples from the first distribution. Must have shape (N, *D) N is the
+        number of x samples, and D is the dimensionality of the samples.
+    y_samples : torch.Tensor
+        Samples from the second distribution. Must have shape (M, *D) M is the
+        number of y samples, and D is the dimensionality of the samples.
+    refs : torch.Tensor
+        Reference samples. Must have shape (num_refs, *D) where D is the
+        dimensionality of the samples.
+    current_num_refs : int
+        Number of reference samples used in the test.
+    num_refs : int
+        Number of reference samples to use.
+
+    Returns
+    -------
+    tuple
+        Results from the PyTorch implementation of chi2_contingency.
+    """
+
+    # Compute distances and find nearest references
+    distances_x = torch.cdist(x_samples, refs)
+    distances_y = torch.cdist(y_samples, refs)
+
+    idx_x = distances_x.argmin(dim=1)
+    idx_y = distances_y.argmin(dim=1)
+
+    counts_x = torch.bincount(idx_x, minlength=num_refs)
+    counts_y = torch.bincount(idx_y, minlength=num_refs)
+
+    return counts_x.cpu().numpy(), counts_y.cpu().numpy()
+
+
+def _compute_counts_numpy(x_samples, y_samples, refs, num_refs):
+    """
+    Helper function to calculate distances for CPU-based NumPy computations.
+
+    Parameters
+    ----------
+    x_samples : np.ndarray
+        Samples from the first distribution. Must have shape (N, *D) N is the
+        number of x samples, and D is the dimensionality of the samples.
+    y_samples : np.ndarray
+        Samples from the second distribution. Must have shape (M, *D) M is the
+        number of y samples, and D is the dimensionality of the samples.
+    refs : np.ndarray
+        Reference samples. Must have shape (num_refs, *D) where D is the
+        dimensionality of the samples.
+    current_num_refs : int
+        Number of reference samples used in the test.
+    num_refs : int
+        Number of reference samples to use.
+
+    Returns
+    -------
+    tuple
+        Results from scipy.stats.chi2_contingency.
+    """
+
+    # Compute distances
+    distances_x = cdist(x_samples, refs, metric="euclidean")
+    distances_y = cdist(y_samples, refs, metric="euclidean")
+
+    # Nearest references
+    idx_x = np.argmin(distances_x, axis=1)
+    idx_y = np.argmin(distances_y, axis=1)
+
+    # Counts
+    counts_x = np.bincount(idx_x, minlength=num_refs)
+    counts_y = np.bincount(idx_y, minlength=num_refs)
+
+    return counts_x, counts_y
diff --git a/tests/test_gaussian.py b/tests/test_gaussian.py
deleted file mode 100644
index 170900f..0000000
--- a/tests/test_gaussian.py
+++ /dev/null
@@ -1,71 +0,0 @@
-import numpy as np
-from pqm import pqm_pvalue, pqm_chi2
-import pytest
-
-
-@pytest.mark.parametrize("z_score_norm", [True, False])
-@pytest.mark.parametrize("num_refs", [20, 100])
-@pytest.mark.parametrize("ndim", [1, 50])
-def test_pass_pvalue(z_score_norm, num_refs, ndim):
-    new = []
-    for _ in range(50):
-        y_samples = np.random.normal(size=(500, ndim))
-        x_samples = np.random.normal(size=(250, ndim))
-
-        new.append(pqm_pvalue(x_samples, y_samples, z_score_norm=z_score_norm, num_refs=num_refs))
-
-    # Check for roughly uniform distribution of p-values
-    assert np.abs(np.mean(new) - 0.5) < 0.15
-
-
-@pytest.mark.parametrize("num_refs", [20, 100])
-@pytest.mark.parametrize("ndim", [1, 50])
-def test_pass_chi2(num_refs, ndim):
-    new = []
-    for _ in range(50):
-        y_samples = np.random.normal(size=(500, ndim))
-        x_samples = np.random.normal(size=(250, ndim))
-
-        new.append(pqm_chi2(x_samples, y_samples, num_refs=num_refs))
-    new = np.array(new)
-    assert np.abs(np.mean(new) / (num_refs - 1) - 1) < 0.15
-
-
-@pytest.mark.parametrize("num_refs", [20, 100])
-@pytest.mark.parametrize("ndim", [1, 50])
-def test_fail_pvalue(num_refs, ndim):
-    new = []
-    for _ in range(50):
-        y_samples = np.random.normal(size=(500, ndim))
-        y_samples[:, 0] += 5  # one dim off by 5sigma
-        x_samples = np.random.normal(size=(250, ndim))
-
-        new.append(pqm_pvalue(x_samples, y_samples, num_refs=num_refs))
-
-    assert np.mean(new) < 1e-3
-
-
-@pytest.mark.parametrize("z_score_norm", [True, False])
-@pytest.mark.parametrize("num_refs", [20, 100])
-@pytest.mark.parametrize("ndim", [1, 50])
-def test_fail_chi2(z_score_norm, num_refs, ndim):
-    new = []
-    for _ in range(100):
-        y_samples = np.random.normal(size=(500, ndim))
-        y_samples[:, 0] += 5  # one dim off by 5sigma
-        x_samples = np.random.normal(size=(250, ndim))
-
-        new.append(pqm_chi2(x_samples, y_samples, z_score_norm=z_score_norm, num_refs=num_refs))
-    new = np.array(new)
-    assert (np.mean(new) / (num_refs - 1)) > 1.5
-
-
-@pytest.mark.parametrize("x_frac", [None, 0.0, 0.5, 1.0])
-@pytest.mark.parametrize("gauss_frac", [0.0, 0.5, 1.0])
-def test_fracs(x_frac, gauss_frac):
-    x_samples = np.random.normal(size=(500, 50))
-    y_samples = np.random.normal(size=(250, 50))
-    x_samples[:, 0] += 5  # one dim off by 5sigma
-
-    pval = pqm_pvalue(x_samples, y_samples, x_frac=x_frac, gauss_frac=gauss_frac)
-    assert pval < 1e-3
\ No newline at end of file
diff --git a/tests/test_pqm.py b/tests/test_pqm.py
new file mode 100644
index 0000000..50cce7d
--- /dev/null
+++ b/tests/test_pqm.py
@@ -0,0 +1,110 @@
+import numpy as np
+import torch
+
+from pqm import pqm_pvalue, pqm_chi2
+import pytest
+
+
+def _get_dist(dist, size):
+    if dist == "normal":
+        return np.random.normal(size=size)
+    elif dist == "cauchy":
+        return np.random.standard_cauchy(size=size)
+    else:
+        raise ValueError("Invalid dist")
+
+
+@pytest.mark.parametrize("dist", ["normal", "cauchy"])
+@pytest.mark.parametrize("use_pytorch", [True, False])
+@pytest.mark.parametrize("z_score_norm", [True, False])
+@pytest.mark.parametrize("num_refs", [20, 100])
+@pytest.mark.parametrize("ndim", [1, 50])
+def test_pass_pvalue(dist, use_pytorch, z_score_norm, num_refs, ndim):
+    new = []
+    for _ in range(50):
+        y_samples = _get_dist(dist, (500, ndim))
+        x_samples = _get_dist(dist, (250, ndim))
+        if use_pytorch:
+            x_samples = torch.tensor(x_samples)
+            y_samples = torch.tensor(y_samples)
+        new.append(pqm_pvalue(x_samples, y_samples, z_score_norm=z_score_norm, num_refs=num_refs))
+
+    # Check for roughly uniform distribution of p-values
+    assert np.abs(np.mean(new) - 0.5) < 0.15
+
+
+@pytest.mark.parametrize("dist", ["normal", "cauchy"])
+@pytest.mark.parametrize("use_pytorch", [True, False])
+@pytest.mark.parametrize("num_refs", [20, 100])
+@pytest.mark.parametrize("ndim", [1, 50])
+def test_pass_chi2(dist, use_pytorch, num_refs, ndim):
+    new = []
+    for _ in range(50):
+        y_samples = _get_dist(dist, (500, ndim))
+        x_samples = _get_dist(dist, (250, ndim))
+        if use_pytorch:
+            x_samples = torch.tensor(x_samples)
+            y_samples = torch.tensor(y_samples)
+
+        new.append(pqm_chi2(x_samples, y_samples, num_refs=num_refs))
+    new = np.array(new)
+    assert np.abs(np.mean(new) / (num_refs - 1) - 1) < 0.15
+
+
+@pytest.mark.parametrize("dist", ["normal", "cauchy"])
+@pytest.mark.parametrize("use_pytorch", [True, False])
+@pytest.mark.parametrize("num_refs", [20, 100])
+@pytest.mark.parametrize("ndim", [1, 50])
+def test_fail_pvalue(dist, use_pytorch, num_refs, ndim):
+    new = []
+    for _ in range(50):
+        y_samples = _get_dist(dist, (500, ndim))
+        y_samples += 1 if dist == "normal" else 5
+        x_samples = _get_dist(dist, (500, ndim))
+
+        if use_pytorch:
+            x_samples = torch.tensor(x_samples)
+            y_samples = torch.tensor(y_samples)
+
+        new.append(pqm_pvalue(x_samples, y_samples, num_refs=num_refs))
+
+    assert np.mean(new) < 1e-3
+
+
+@pytest.mark.parametrize("dist", ["normal", "cauchy"])
+@pytest.mark.parametrize("use_pytorch", [True, False])
+@pytest.mark.parametrize("z_score_norm", [True, False])
+@pytest.mark.parametrize("num_refs", [20, 100])
+@pytest.mark.parametrize("ndim", [1, 50])
+def test_fail_chi2(dist, use_pytorch, z_score_norm, num_refs, ndim):
+    new = []
+    for _ in range(100):
+        y_samples = _get_dist(dist, (500, ndim))
+        y_samples += 1 if dist == "normal" else 5
+        x_samples = _get_dist(dist, (500, ndim))
+
+        if use_pytorch:
+            x_samples = torch.tensor(x_samples)
+            y_samples = torch.tensor(y_samples)
+
+        new.append(pqm_chi2(x_samples, y_samples, z_score_norm=z_score_norm, num_refs=num_refs))
+    new = np.array(new)
+    assert (np.mean(new) / (num_refs - 1)) > 1.5
+
+
+@pytest.mark.parametrize(
+    "dist,gauss_frac", [["normal", 0.0], ["normal", 0.5], ["normal", 1.0], ["cauchy", 0.0]]
+)
+@pytest.mark.parametrize("use_pytorch", [True, False])
+@pytest.mark.parametrize("x_frac", [None, 0.0, 0.5, 1.0])
+def test_fracs(dist, use_pytorch, x_frac, gauss_frac):
+    x_samples = _get_dist(dist, (500, 50))
+    y_samples = _get_dist(dist, (500, 50))
+    x_samples += 1 if dist == "normal" else 10
+
+    if use_pytorch:
+        x_samples = torch.tensor(x_samples)
+        y_samples = torch.tensor(y_samples)
+
+    pval = pqm_pvalue(x_samples, y_samples, x_frac=x_frac, gauss_frac=gauss_frac)
+    assert pval < 1e-3

From 7d89324dcd854c1dabd9993ac972c6a1182bad6d Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Mon, 4 Nov 2024 18:42:04 -0500
Subject: [PATCH 2/8] add consistency tests

---
 src/pqm/utils.py          |  3 ---
 tests/test_consistency.py | 46 +++++++++++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 3 deletions(-)
 create mode 100644 tests/test_consistency.py

diff --git a/src/pqm/utils.py b/src/pqm/utils.py
index 9c37363..1269753 100644
--- a/src/pqm/utils.py
+++ b/src/pqm/utils.py
@@ -1,6 +1,3 @@
-from typing import Tuple
-import warnings
-
 import numpy as np
 import torch
 from scipy.stats import chi2
diff --git a/tests/test_consistency.py b/tests/test_consistency.py
new file mode 100644
index 0000000..ee411b7
--- /dev/null
+++ b/tests/test_consistency.py
@@ -0,0 +1,46 @@
+from pqm.utils import _mean_std_torch, _mean_std_numpy, _compute_counts_numpy, _compute_counts_torch
+
+import numpy as np
+import torch
+
+import pytest
+
+
+@pytest.mark.parametrize("num_samples", [10, 100, 1000])
+@pytest.mark.parametrize("dims", [10, 100])
+def test_mean_std(num_samples, dims):
+    x = np.random.rand(num_samples, dims)
+    y = np.random.rand(num_samples, dims)
+    m_np, s_np = _mean_std_numpy(x, y)
+    assert m_np.shape == (dims,)
+    assert s_np.shape == (dims,)
+
+    x = torch.tensor(x)
+    y = torch.tensor(y)
+    m_pt, s_pt = _mean_std_torch(x, y)
+    assert m_pt.shape == (dims,)
+    assert s_pt.shape == (dims,)
+
+    assert np.allclose(m_np, m_pt.numpy())
+    assert np.allclose(s_np, s_pt.numpy())
+
+
+@pytest.mark.parametrize("num_refs,num_samples", [[10, 100], [100, 1000]])
+@pytest.mark.parametrize("dims", [10, 100])
+def test_compute_counts(num_refs, num_samples, dims):
+
+    x = np.random.rand(num_samples, dims)
+    y = np.random.rand(num_samples, dims)
+    refs = np.random.rand(num_refs, dims)
+
+    counts_x_np, counts_y_np = _compute_counts_numpy(x, y, refs, num_refs)
+    assert counts_x_np.shape == (num_refs,)
+
+    x = torch.tensor(x)
+    y = torch.tensor(y)
+    refs = torch.tensor(refs)
+    counts_x_pt, counts_y_pt = _compute_counts_torch(x, y, refs, num_refs)
+    assert counts_x_pt.shape == (num_refs,)
+
+    assert np.allclose(counts_x_np, counts_x_pt)
+    assert np.allclose(counts_y_np, counts_y_pt)

From 2995cd716701528865f99073a36955d9bf78b478 Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Mon, 4 Nov 2024 18:47:32 -0500
Subject: [PATCH 3/8] add codecov

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a391c00..75683b6 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -68,4 +68,6 @@ jobs:
           pytest -vvv --cov=${{ env.PROJECT_NAME }} --cov-report=xml --cov-report=term tests/
 
       - name: Upload coverage reports to Codecov with GitHub Action
-        uses: codecov/codecov-action@v4
\ No newline at end of file
+        uses: codecov/codecov-action@v4
+        with:
+          token: ${{ secrets.CODECOV_TOKEN }}
\ No newline at end of file

From f4a5fecfc666f99e4ee7f0218b84d27ae41e6c0d Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Tue, 5 Nov 2024 10:04:18 -0500
Subject: [PATCH 4/8] bug fix remove samples that are refs

---
 .github/workflows/ci.yml |  2 +-
 src/pqm/pqm.py           | 19 ++++++++++++++-----
 src/pqm/utils.py         |  4 ++--
 tests/test_errors.py     | 21 +++++++++++++++++++--
 tests/test_pqm.py        |  2 +-
 5 files changed, 37 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 75683b6..2c37f9a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -20,7 +20,7 @@ jobs:
   build:
     runs-on: ${{matrix.os}}
     strategy:
-      fail-fast: false
+      fail-fast: true
       matrix:
         python-version: ["3.9", "3.10", "3.11"]
         os: [ubuntu-latest, windows-latest, macOS-latest]
diff --git a/src/pqm/pqm.py b/src/pqm/pqm.py
index 1380d8e..7a422df 100644
--- a/src/pqm/pqm.py
+++ b/src/pqm/pqm.py
@@ -84,8 +84,13 @@ def _pqm_test(
     """
 
     # Determine if we're working with NumPy or PyTorch
+    assert type(x_samples) == type(
+        y_samples
+    ), f"x_samples and y_samples must be of the same type, not {type(x_samples)} and {type(y_samples)}"
     is_torch = isinstance(x_samples, torch.Tensor) and isinstance(y_samples, torch.Tensor)
-    assert type(x_samples) == type(y_samples), "x_samples and y_samples must be of the same type"
+    if not is_torch:
+        x_samples = np.array(x_samples)
+        y_samples = np.array(y_samples)
 
     # Validate sample sizes
     nx = x_samples.shape[0]
@@ -126,17 +131,21 @@ def _pqm_test(
         raise ValueError(
             f"Something went wrong. Nx={Nx}, Ny={Ny}, Ng={Ng} should sum to num_refs={num_refs}"
         )
-    if Nx > x_samples.shape[0]:
+    if Nx >= x_samples.shape[0] - 2:
         raise ValueError("Cannot sample more references from x_samples than available")
-    if Ny > y_samples.shape[0]:
+    if Ny >= y_samples.shape[0] - 2:
         raise ValueError("Cannot sample more references from y_samples than available")
 
     # count samples in each voronoi bin
     if is_torch:
-        refs = _sample_reference_indices_torch(Nx, Ny, Ng, x_samples, y_samples, device)
+        refs, x_samples, y_samples = _sample_reference_indices_torch(
+            Nx, Ny, Ng, x_samples, y_samples, device
+        )
         counts_x, counts_y = _compute_counts_torch(x_samples, y_samples, refs, num_refs)
     else:
-        refs = _sample_reference_indices_numpy(Nx, Ny, Ng, x_samples, y_samples)
+        refs, x_samples, y_samples = _sample_reference_indices_numpy(
+            Nx, Ny, Ng, x_samples, y_samples
+        )
         counts_x, counts_y = _compute_counts_numpy(x_samples, y_samples, refs, num_refs)
 
     # Remove references with no counts
diff --git a/src/pqm/utils.py b/src/pqm/utils.py
index 1269753..ecad938 100644
--- a/src/pqm/utils.py
+++ b/src/pqm/utils.py
@@ -103,7 +103,7 @@ def _sample_reference_indices_torch(Nx, Ny, Ng, x_samples, y_samples, device):
         shaper = torch.ones(Ng, *x_samples.shape[1:], device=device)
         gauss_refs = torch.normal(mean=m * shaper, std=s)
         refs = torch.cat([refs, gauss_refs], dim=0)
-    return refs
+    return refs, x_samples, y_samples
 
 
 def _sample_reference_indices_numpy(Nx, Ny, Ng, x_samples, y_samples):
@@ -144,7 +144,7 @@ def _sample_reference_indices_numpy(Nx, Ny, Ng, x_samples, y_samples):
         gauss_refs = np.random.normal(loc=m, scale=s, size=(Ng,) + tuple(x_samples.shape[1:]))
         refs = np.concatenate([refs, gauss_refs], axis=0)
 
-    return refs
+    return refs, x_samples, y_samples
 
 
 def _compute_counts_torch(x_samples, y_samples, refs, num_refs):
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 6c68ebd..966ccba 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -4,16 +4,33 @@
 
 
 def test_num_refs():
+    # more num_refs than samples
     with pytest.raises(ValueError):
         pqm_pvalue(np.random.normal(size=(10, 50)), np.random.normal(size=(15, 50)), num_refs=100)
-    with pytest.raises(ValueError):
-        pqm_chi2(np.random.normal(size=(15, 50)), np.random.normal(size=(10, 50)), num_refs=100)
 
+    # Not very many samples compared to num_refs
     with pytest.warns(UserWarning):
         pqm_pvalue(
             np.random.normal(size=(100, 100)), np.random.normal(size=(110, 100)), num_refs=150
         )
 
+    # More x refs than x samples
+    with pytest.raises(ValueError):
+        pqm_pvalue(
+            np.random.normal(size=(50, 100)),
+            np.random.normal(size=(50, 100)),
+            num_refs=50,
+            x_frac=1.0,
+        )
+    # More y refs than y samples
+    with pytest.raises(ValueError):
+        pqm_pvalue(
+            np.random.normal(size=(50, 100)),
+            np.random.normal(size=(50, 100)),
+            num_refs=50,
+            x_frac=0.0,
+        )
+
 
 def test_filled_bins():
     with pytest.raises(ValueError):
diff --git a/tests/test_pqm.py b/tests/test_pqm.py
index 50cce7d..fa26df0 100644
--- a/tests/test_pqm.py
+++ b/tests/test_pqm.py
@@ -100,7 +100,7 @@ def test_fail_chi2(dist, use_pytorch, z_score_norm, num_refs, ndim):
 def test_fracs(dist, use_pytorch, x_frac, gauss_frac):
     x_samples = _get_dist(dist, (500, 50))
     y_samples = _get_dist(dist, (500, 50))
-    x_samples += 1 if dist == "normal" else 10
+    x_samples += 1 if dist == "normal" else 5
 
     if use_pytorch:
         x_samples = torch.tensor(x_samples)

From 32709ec0b39158d5e30185b354e8853f20f5ee75 Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Tue, 5 Nov 2024 10:07:42 -0500
Subject: [PATCH 5/8] safer test

---
 tests/test_pqm.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/test_pqm.py b/tests/test_pqm.py
index fa26df0..50cce7d 100644
--- a/tests/test_pqm.py
+++ b/tests/test_pqm.py
@@ -100,7 +100,7 @@ def test_fail_chi2(dist, use_pytorch, z_score_norm, num_refs, ndim):
 def test_fracs(dist, use_pytorch, x_frac, gauss_frac):
     x_samples = _get_dist(dist, (500, 50))
     y_samples = _get_dist(dist, (500, 50))
-    x_samples += 1 if dist == "normal" else 5
+    x_samples += 1 if dist == "normal" else 10
 
     if use_pytorch:
         x_samples = torch.tensor(x_samples)

From c46ceda7ac7974614624b9ba8a7858330bff04e5 Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Tue, 5 Nov 2024 10:12:01 -0500
Subject: [PATCH 6/8] safer tests, add badge

---
 README.md         | 1 +
 tests/test_pqm.py | 4 ++--
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/README.md b/README.md
index 3d3d001..fc33baf 100644
--- a/README.md
+++ b/README.md
@@ -4,6 +4,7 @@
 [![CI](https://github.com/Ciela-Institute/PQM/actions/workflows/ci.yml/badge.svg)](https://github.com/Ciela-Institute/PQM/actions/workflows/ci.yml)
 [![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
 ![PyPI - Downloads](https://img.shields.io/pypi/dm/pqm)
+[![codecov](https://codecov.io/gh/Ciela-Institute/PQM/graph/badge.svg?token=wbkUiRkYtg)](https://codecov.io/gh/Ciela-Institute/PQM)
 [![arXiv](https://img.shields.io/badge/arXiv-2402.04355-b31b1b.svg)](https://arxiv.org/abs/2402.04355)
 
 [PQMass](https://arxiv.org/abs/2402.04355) is a new sample-based method for evaluating the quality of generative models as well as assessing distribution shifts to determine if two datasets come from the same underlying distribution.
diff --git a/tests/test_pqm.py b/tests/test_pqm.py
index 50cce7d..53a2176 100644
--- a/tests/test_pqm.py
+++ b/tests/test_pqm.py
@@ -59,7 +59,7 @@ def test_fail_pvalue(dist, use_pytorch, num_refs, ndim):
     new = []
     for _ in range(50):
         y_samples = _get_dist(dist, (500, ndim))
-        y_samples += 1 if dist == "normal" else 5
+        y_samples += 1 if dist == "normal" else 10
         x_samples = _get_dist(dist, (500, ndim))
 
         if use_pytorch:
@@ -80,7 +80,7 @@ def test_fail_chi2(dist, use_pytorch, z_score_norm, num_refs, ndim):
     new = []
     for _ in range(100):
         y_samples = _get_dist(dist, (500, ndim))
-        y_samples += 1 if dist == "normal" else 5
+        y_samples += 1 if dist == "normal" else 10
         x_samples = _get_dist(dist, (500, ndim))
 
         if use_pytorch:

From acfe43896748e5d5fa2b1b41e2c71f7fb6cdd497 Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Tue, 5 Nov 2024 17:18:20 -0500
Subject: [PATCH 7/8] use faster asarray for numpy

---
 src/pqm/pqm.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/pqm/pqm.py b/src/pqm/pqm.py
index 7a422df..540c51c 100644
--- a/src/pqm/pqm.py
+++ b/src/pqm/pqm.py
@@ -89,8 +89,8 @@ def _pqm_test(
     ), f"x_samples and y_samples must be of the same type, not {type(x_samples)} and {type(y_samples)}"
     is_torch = isinstance(x_samples, torch.Tensor) and isinstance(y_samples, torch.Tensor)
     if not is_torch:
-        x_samples = np.array(x_samples)
-        y_samples = np.array(y_samples)
+        x_samples = np.asarray(x_samples)
+        y_samples = np.asarray(y_samples)
 
     # Validate sample sizes
     nx = x_samples.shape[0]

From a50adf342af8f89e77ff805aa902347bfdaef43e Mon Sep 17 00:00:00 2001
From: Connor Stone <connorstone628@gmail.com>
Date: Tue, 5 Nov 2024 18:11:54 -0500
Subject: [PATCH 8/8] check all notebooks

---
 notebooks/mnist.ipynb       | 139 ++++++------------------------------
 notebooks/test.ipynb        |  76 ++++++++++----------
 notebooks/time_series.ipynb |  64 ++++++++---------
 3 files changed, 94 insertions(+), 185 deletions(-)

diff --git a/notebooks/mnist.ipynb b/notebooks/mnist.ipynb
index 6d17580..613c062 100644
--- a/notebooks/mnist.ipynb
+++ b/notebooks/mnist.ipynb
@@ -2,7 +2,7 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 1,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -26,107 +26,9 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 2,
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n",
-      "Failed to download (trying next):\n",
-      "HTTP Error 403: Forbidden\n",
-      "\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz to ../data/MNIST/raw/train-images-idx3-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 9912422/9912422 [00:01<00:00, 7146199.76it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ../data/MNIST/raw/train-images-idx3-ubyte.gz to ../data/MNIST/raw\n",
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n",
-      "Failed to download (trying next):\n",
-      "HTTP Error 403: Forbidden\n",
-      "\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz to ../data/MNIST/raw/train-labels-idx1-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 28881/28881 [00:00<00:00, 1476166.44it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ../data/MNIST/raw/train-labels-idx1-ubyte.gz to ../data/MNIST/raw\n",
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n",
-      "Failed to download (trying next):\n",
-      "HTTP Error 403: Forbidden\n",
-      "\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw/t10k-images-idx3-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 1648877/1648877 [00:00<00:00, 9588212.52it/s]\n"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ../data/MNIST/raw/t10k-images-idx3-ubyte.gz to ../data/MNIST/raw\n",
-      "\n",
-      "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n",
-      "Failed to download (trying next):\n",
-      "HTTP Error 403: Forbidden\n",
-      "\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n",
-      "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "100%|██████████| 4542/4542 [00:00<00:00, 1605066.03it/s]"
-     ]
-    },
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "Extracting ../data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ../data/MNIST/raw\n",
-      "\n"
-     ]
-    },
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "test_data = datasets.MNIST(root='../data', train=False, download=True, transform=None)\n",
     "train_data = datasets.MNIST(root='../data', train=True, download=True, transform=None)"
@@ -134,7 +36,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 3,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -148,14 +50,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "99.55365942972128 13.221414209651563\n"
+      "98.74855893968599 13.400799380690533\n"
      ]
     }
    ],
@@ -165,9 +67,8 @@
     "n = len(x_samples) // num_repeats\n",
     "\n",
     "for i in range(num_repeats):\n",
-    "    for _ in range(num_repeats):\n",
-    "        z = pqm_chi2(x_samples[i*n:(i+1)*n], y_samples[i*n:(i+1)*n], device=device)\n",
-    "        zs.append(z)\n",
+    "    z = pqm_chi2(x_samples[i*n:(i+1)*n], y_samples[i*n:(i+1)*n], device=device, re_tessellation=num_repeats)\n",
+    "    zs += z\n",
     "\n",
     "print(np.median(zs), np.std(zs))"
    ]
@@ -179,7 +80,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -201,7 +102,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 8,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -210,19 +111,18 @@
     "n = len(x_samples) // num_repeats\n",
     "\n",
     "for i in range(num_repeats):\n",
-    "    for _ in range(num_repeats):\n",
-    "        pval = pqm_pvalue(x_samples[i*n:(i+1)*n], y_samples[i*n:(i+1)*n], device=device)\n",
-    "        p_val.append(pval)"
+    "    pval = pqm_pvalue(x_samples[i*n:(i+1)*n], y_samples[i*n:(i+1)*n], device=device, re_tessellation=num_repeats)\n",
+    "    p_val += pval"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -243,11 +143,18 @@
     "plt.tight_layout()\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "tarp_project",
+   "display_name": "PY39",
    "language": "python",
    "name": "python3"
   },
@@ -261,7 +168,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/test.ipynb b/notebooks/test.ipynb
index 06c308c..0479c7c 100644
--- a/notebooks/test.ipynb
+++ b/notebooks/test.ipynb
@@ -2,14 +2,14 @@
  "cells": [
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 17,
    "metadata": {},
    "outputs": [],
    "source": [
     "import numpy as np\n",
     "import matplotlib.pyplot as plt\n",
     "from pqm import pqm_chi2, pqm_pvalue\n",
-    "from scipy.stats import norm, chi2, uniform\n",
+    "from scipy.stats import norm, chi2, uniform, iqr\n",
     "import torch\n",
     "import matplotlib as mpl\n",
     "mpl.rcParams['figure.dpi'] = 200\n",
@@ -90,7 +90,7 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "99.93539387845146 13.815304235093942\n"
+      "97.59767630858892 13.848343024931788\n"
      ]
     }
    ],
@@ -113,7 +113,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAABJwAAAKoCAYAAAAyFeVdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAB7CAAAewgFu0HU+AACVV0lEQVR4nOzdd3hUVf7H8c+EXiRNVCQIGewVEsBegARR7CRiWxsmAfuqJKCu7roqBOtaScJil5KA+FMsJGDFAskIdoUMuKCoyDBEaiCZ3x9jAjeNJMzMmfJ+Pc88cr/3zrmf7CpJvnPOuTaPx+MRAAAAAAAA4CNRpgMAAAAAAAAgvNBwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE+1NR0AwW3btm366quvJEndu3dX27b8KwMAAAAAQLjYuXOn1q1bJ0k65phj1LFjR5+MS/cATfrqq680aNAg0zEAAAAAAICfLV68WAMHDvTJWCypAwAAAAAAgE8xwwlN6t69e+2fFy9erB49ehhMAwAAAAAAfGnt2rW1K5t27wHsLRpOaNLuezb16NFDCQkJBtMAAAAAAAB/8eW+zSypAwAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBPtTUdAAAABE6f8fNMR9CqSSNMRwAAAICfMcMJAAAAAAAAPkXDCQAAAAAAAD5FwwkAAAAAAAA+RcMJAAAAAAAAPkXDCQAAAAAAAD4VUU+py8/PV2Fhoex2u1wulyRpwoQJSkpKCvi4brdbEydOlMPhqK25XC5NmDBBaWlpRr4OAAAAAAAAX4iYhlN6erqcTqcWLFigmJgYSZLT6VRycrJyc3OVmZkZsHGdTqdycnKUm5sru91eW588ebLS09OVlJSksrKygH4dAAAAAAAAvhIRS+ry8/NVVFRkadJIkt1uV0FBgbKysiwzjfw9bnp6utxut9xut6WenZ0tu90uh8OhnJycgH0dAAAAAAAAvhQRDaecnBylpKRYmjQ1apavNdTg8de4DodDJSUlmjhxYr1zNTOeSkpKfHY/AAAAAACAQAr7hpPD4ZDb7W5yf6OkpCSVlJTUm3Hkr3EzMzMVExOjrKysRt8bFxfns/sBAAAAAAAEUtg3nGbOnClJio+Pb/SamuZOQ7OK/DFuXl6eNmzYoJSUlHrvqbk2PT3dZ/cDAAAAAAAIpLBvONU0Xxpahlaj5tySJUuMjltUVCTJu6yu7ubf/vo6AAAAAAAAfC3sn1JXs7ys7hK13dWca8lSNF+P63Q6lZGRoaSkJC1YsMDv96uxZs2aJs+vXbu22WMBAAAAAABIEdBwcrlcQXut0+lUTk6OnE6nHA6HsrOzlZubG9BsvXr1ava1AAAAAAAAzRH2S+qCmd1uV2FhocrKylRWVqaSkhL17duXPZgAAAAAAEBIC/sZTqEiKSlJZWVlio2NVWpqqgoLC5WWlub3+65evbrJ82vXrtWgQYP8ngMAAAAAAISPsJ/hVLOvUXOWmTW1P1Kgxq3ZLDwjI8OyF5O/7peQkNDkq0ePHs0eCwAAAAAAQIqAhlNTT3WrUdPEac61/h534MCBkrwbf8+aNcvv9wMAAAAAAPC1sG84DRgwQJJUXl7e6DVOp1PSrmaPP8fNz89XbGys0tPTG3yP3W6v/XNZWdle3w8AAAAAACDQwr7hlJqaKkmW5Wl11ZxryZ5JrR03Ly9PbrdbRUVFtQ2i3e2+ZC45OXmv7wcAAAAAABBoYd9wqmm+NPbkN7fbLafTqaSkpICMWzNTyW63W2Yz1XA4HLV/TklJ2ev7AQAAAAAABFrYN5wkKTc3V06ns8EZRTX7JBUUFNQ753Q6lZycrKysLJ+Nm56erqSkpEaXxuXl5Unybh5etyHV2q8DAAAAAAAgkCKi4ZSdna20tDSlpqZalqQ5HA7l5OQoNze3wZlBeXl5cjgcys/Pt8w82ptxU1JSlJWVpeTk5HpjZmVlyel0Ki0trbbx5IuvAwAAAAAAIJDamg4QKIWFhcrPz1d6errsdrtcLpfcbrcKCwstS9d2N2rUKBUVFclutzfayGnNuJmZmUpJSamdsVSzb5PdbldxcXGj72vt/QAAAAAAAALJ5vF4PKZDIHitWbNGvXr1kiStXr1aCQkJhhMBAPZGn/HzTEfQqkkjTEcAAADAX/z1e39ELKkDAAAAAABA4NBwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE/RcAIAAAAAAIBP0XACAAAAAACAT9FwAgAAAAAAgE+1NR0AAAAEp447tsnu+kWddmxTpx3b1XFnpTrurPlnpTrs2K5OO7er/c4d+r1rnBw9j9D33XurOqqN6egAAAAwjIYTAACoFb/ZraErFit1xWc6ddVSddxZ2aL3V7TvrC96Hq4lCUeqNOFILe1xqLa16+intAAAAAhWNJwAAIhwfVw/K3X55xq2/DMl//ydouRp9VjdKrfo9JUOnb7SIUnaEdVG3+zfV0sSjtSShKP0gT3ZV7EBAAAQxGg4AQAQgY7+dYXO+mGRhi3/TIesX+23+7SrrlK/tT+q39oflbFkrn7tGicdtFrKyJA6dfLbfQEAAGAWDScAACJIoutn/WNBgYY4S5t1fbVs2tShs7a1bf/Xq4O2tdv15+1t26sqKkqH/75Kfdxr9zjeAZtc0i23SBMnStnZUlaW1Lnz3n5ZAAAACDI0nAAAiAQVFdL99+vd/z6m9tU7m7x0c7uOet+erOJDTtB79gHa2GmfZt2i+yaXBqz5VgPXfKsBP3+rI39zqq2nuuGLf/1Vuu02adIkadw4aexYqUuXln5VAAAACFI2j8fT+o0aEPbWrFmjXr16SZJWr16thIQEw4kAAC1SXS29/LKUk+Nt8jRiXZcYFR98vOYfcoI+7X2ctrdtv9e37ly5Vf1++UED13yrU1Yt1cCfv2384n33le64Q7rhBqlr172+NwAAAJrHX7/303BCk2g4AUAIW7JEuvlm6bPPGjz9e5dYzT56qIoPOV5fHHiYPLYov8ZJXvOtblk0Xaet+qLxi+LjvUvtbrtNastEbAAAAH/z1+/9/v3JEgAABN5vv0mjR0vHH99gs6kyqq2ePT5NgzPylHvG1XL0PMLvzSZJKks4UleO+rf0ySfSWWc1fNH69d7ZWGecIa3232bmAAAA8C8aTgAAhAuPR3rmGenQQ6Vp07zHdSzoO1DDRj+t3DOu1uYOhjbrPvFE6a23pM8/l845p+FrFi2S+vWT3ngjoNEAAADgGzScAAAIBzt2eJ/4dsMN3g3C6zrkEOnNNzU67V6tiusZ+HwNGTTI21AqLZXOO6/+eZfLW7/tNqmyMvD5AAAA0GpsjgAAiAh9xs8zHUGrJo3wz8AbN0rp6VJxcf1zXbtK99wj3XKL1L699JH5/x3qSU6WXn9d+vRT6bLLpFWrrOcfe0z6+GNpxgzJbjcSEQAAAC3DDCcAAELZqlXSSSc13Gy68krpxx+lceO8zaZgd+KJ0hdfSCNH1j+3ZInUv79UVBT4XAAAAGgxGk4AAISqxYu9G4N/+6213rGjtzHzwgtSjx5msrVWTIxUWCg9/XT9JllFhXcm1/XXS9u2GYkHAACA5qHhBABAKJo9Wzr9dOn33631/faT3n+/4VlCocJm8zaVPv/cu/dUXc8+K51wgrRiReCzAQAAoFloOAEAEEo8Humhh6S0tPqzfI480tukOf54M9l8rV8/qaxMuvzy+ueWLZNOOaX+7C4AAAAEBRpOAACEih07pDFjpOzs+udSUqRFi6Q+fQIey6/22Ud66SVp2jSpUyfrud9+887yWrbMTDYAAAA0ioYTAAChoKJCGjFCys+vf+6666S33vLufxSObDbpmmu8G4cfdZT13B9/SIMHe2dCAQAAIGjQcAIAINht3y5dcEHDT6LLzfU2odq1C3isgDvqKO8srpNOstY3bJCGDpU++8xMLgAAANRDwwkAgGBWXS1dfbX03nvWeseO3qe5ZWd7ZwBFiuho6Z13pNNOs9Y3bpRSU6WPPzaTCwAAABY0nAAACGbjxkkzZlhr3bt7n0SXlmYkknH77ONdQjh0qLW+aZN05pn1m3MAAAAIOBpOAAAEq0cf9b5217Wrd4ZPuDyJrrW6dJHeeEMaPtxa37JFOvtsaf58M7kAAAAgiYYTAADBacYM6fbbrbW2baU5c6SkJDOZgk2nTtLcudJ551nr27ZJ554rzZtnJBYAAABoOAEAEHwWLpSuvLJ+fdo07z5F2KVDB+9eViNHWuuVldKFF0qvvWYmFwAAQISj4QQAQDBZtszbKNmxw1qfNEn629/MZAp27dt7Z4Rdeqm1vmOHdPHF7OkEAABgAA0nAACCxU8/SWedJVVUWOs33uh9Gh0a17at9NJL0lVXWes7d3pnP/34o5lcAAAAEYqGEwAAwcDl8jab1q611keOlB5/XLLZjMQKKW3aeJcdZmRY6xs2SOec4/3fGAAAAAFBwwkAANO2bvVufP3dd9b6qadKL7/sbaSgeaKipClTpAsusNaXL5fS0uovVQQAAIBf0HACAMAkj8e7N9OiRdb6kUdKr78udexoJlcoi4ryNur697fW33tPuv567//mAAAA8CsaTgAAmPTUU9Ls2dZaz57SO+9IsbFmMoWDLl2k//s/qUcPa33qVOmxx8xkAgAAiCA0nAAAMGXpUumOO6y1bt2kt9+WevUyEimsJCR4m06dOlnrd9whvfGGmUwAAAARgoYTAAAmbN4sXXKJVFlprc+YIR1zjJlM4WjAAOnFF601j0e69FJp2TIzmQAAACIADScAAEy4+Wbphx+stdtv9z6pDr6VliY98IC1tnmzdO650q+/mskEAAAQ5mg4AQAQaDNmSNOmWWvJydKDD5rJEwkmTPBuzr671aul88/3PiUQAAAAPkXDCQCAQHI6pawsa61rV28Tqn17M5kigc0mFRRIJ59srS9eLF1zDU+uAwAA8LG2pgMAABApDh73ugpfyVH/igpL/dYzsjR36g+Sfmj4jWGmz/h5xu4dl3S95n69Qgdt/G1XceZM6dhjpTvvNJYrkpn896HGqkkjTEcAACDsMMMJAIAAue3jl9V/rbWpNPuowZp71GBDiSKPq3O0Ro+8x/s0wN3dc4/06admQgEAAIQhGk4AAATAyauWasxnsy21lbE9dE/qWEOJItfy7r2lWbOkqN1+DKqq8j65zu02lgsAACCc0HACAMDP4je79dibjyhKu/YJqoxqq5vOy9HmDp0NJotgZ54p/fOf1tpPP0ljxrCfEwAAgA/QcAIAwI9snmo9/NZj2m/zBks99/Sr9PUBBxtKBUnePZtOO81amzlTeu45M3kAAADCCA0nAAD86NrS/9NgZ5ml9n5isqYNPN9QItRq00Z6+WUpNtZav+km6YfI2MAdAADAX2g4AQDgJ0f+5lTO+89bar93idXtI/4uj41vwUGhVy/pv/+11rZskS65RNq+3UwmAACAMMBPuwAA+EFUdZUmvvOk2lfvrK1Vy6a/n3O71neJMRcM9V14oXfvpt0tXSqNH28kDgAAQDig4QQAgB9c8cVbOu7X5ZZa/vEXaVGffmYCoWmPPioddZS19vjj0ltvGYkDAAAQ6mg4AQDgY/v/+YfGffiipVYel6BHT7nCUCLsUadO0vTpUocO1vrVV0tr1xqJBAAAEMpoOAEA4GP3LCjQPpVbLbU7z7xBlW3bGUqEZjnmGO9Mp92tWyddeaVUXW0mEwAAQIii4QQAgA8NLl+iET8sstQKj07R5wcdYygRWmTsWOn8Ok8QLCmRHnnETB4AAIAQRcMJAAAf6VS5Tf+e/6yl5urUTQ8OvsZQIrSYzeZ9al3Pntb6nXdKS5aYyQQAABCCaDgBAOAjt3wyXQkVv1tqDw6+Vhs6RxtKhFaJj5deftnbfKqxc6d02WXSli3mcgEAAIQQGk4AAPjA4b+v1HWLX7PUPut1tIqOHmooEfbKGWd4ZzXtbsUK6Z57jMQBAAAINTScAADYSzZPtR589ym19ezaWLoyqq3uOvMG6ywZhJZ775VOOMFae+wxltYBAAA0Aw0nAAD20qXL3lXSLz9Yas+ekKby+F6GEsEn2rWTnntOat9+V626WrruOmnHDnO5AAAAQgANJwAA9kL3TRs0/v3nLbWVsT30zIkXmwkE3zr88PrL6L78Upo82UweAACAEEHDCQCAvXD3wqnqtn2ztTbsBm1v276RdyDkZGdLxx5rrd13n/Tdd2byAAAAhICIajjl5+crNTVVWVlZSk9PV3p6uhwOh7FxJ0+erNTUVMXGxqpv3757fJ/T6VRqaqry8/PldDot9aKiIqWnp1vqAAD/OnWlQ+d/94Gl9tqRZ2hRn35mAsE/2rWT/vtfKWq3H5sqK6WMDO8SOwAAANTT1nSAQKlpxixYsEAxMTGSvI2a5ORk5ebmKjMzM2Djut1upaenKysrS8XFxZIkh8Oh9PR0JScnKzs7W7m5uQ2+r6SkRCUlJQ1myc3Nld1ub9XXAQBomQ47tuv++c9Yau6OXXX/kOsMJYJfDRgg3Xab9PDDu2qLFknPPivdcIO5XAAAAEEqImY45efnq6ioyNIUkiS73a6CggJlZWW1aqZTa8dNT09XTk6O0tLSamtJSUkqKytTTEyMJk+erKKiombnqHlvdnZ2i78GAEDr3PjpLPV2/2qpTTr9aq3vEmMmEPzvX/+S+va11saPl/73PzN5AAAAglhENJxycnKUkpJiaQrVqGn65OTkBGTcmgZUSkpKvffExMTUzojKyMho8J5paWkqLy9XcXGxysrK5PF4VFZWpqSkpBbnBwC0Ts+Nvytz8RxLbUnPIzXzuGGGEiEgOneWCgqstU2bpDFjJI/HTCYAAIAgFfYNJ4fDIbfb3WRDJikpSSUlJXK73X4ft2ZJXGpqaoPvqam73e5G92Oy2+1KSUmhyQQAhtz20UvqULWj9nhHVBvddeb18tjC/tsqBg+WrquzbPLtt6VXXzWTBwAAIEiF/U/GM2fOlCTFx8c3ek1cXJwkNbo3ki/HLS8vr601tNxu9z2YfLGhOQDAt476rVwXfvO+pfZKv7P0Y/c+RvLAgIceknr0sNZuuUVat85MHgAAgCAU9g2nmmZPQ8veatScW7Jkid/HzcrKkt1uV1paWoMzlHafDdXU2AAAAzweTXhvmqK0a/lURfvOeuLkSw2GQsDFxEhPP22trV/vbToBAABAUgQ8pa6mgVMz26ghNedasqSuteMmJSXVznJqSGlpae2fBwwY0OA1DodDeXl5tccul0ujRo2ybELeXGvWrGny/Nq1a1s8JgCEq9NXOnTKT8sstSknpMnVOdpQIhhz4YVSWpq0+0M+pk+XLr9cGjHCXC4AAIAgEfYNJ5fLFVLX1jSSMjMzG5zhVFJSooEDB1oaTk6nU3379lVmZqal3hy9evVq0fUAEKmiqqs04b1pltrarvGaNuA8Q4lg3JNPSgsWSBs27KqNGSN9843UrZu5XAAAAEEg7JfUhZKioiI5HA7Z7Xbl5ubWO2+321VQUKDs7Ox69ezsbOXn5ys/Pz9QcQEgooz8eoEO/+MnS+2R0/6mbe06GkoE4w44QHrkEWttzRrp3nvN5AEAAAgiNJyChNvtVkZGhmJiYlRcXNzg7KaYmJhGl82NGjVKkpSTk9Oi+65evbrJ1+LFi1v8tQBAuOm4Y5tu/+hlS+277n0056jBhhIhaFx9tZSSYq09+aR3lhMAAEAEC/sldXFxcXK73c1a1tbUfkz+Hjc9PV2SVFZWZnlSXXPVvMftdsvhcDS4IXlDEhISWnwvAIg0o5e8rgM2Wf++n3jGNaqOamMoEYKGzSZNmSIddZS0fbu3VlUl3XyzVFLiPQ8AABCBwn6GU3Oe9FbTNGrJU+F8Oe7kyZNVWlraZLPJ6XQqKytLRbtvTtoIp9O5x2sAAM0Tv9mtMZ9b/+79sE9/fWhPNpQIQadvX+mOO6y1hQul2bPN5AEAAAgCYd9wqnnSW1NPhqtp0AwcODDg4+bn5ysvL08rV65scmZTXl6e8vPza2dCNaU1M6QAAA27+ZPp2qdya+1xtWyadMY1BhMhKE2YINV9EMftt0tbtpjJAwAAYFjYN5xSU1MleZeaNabmXGP7I/lr3JKSEuXl5amsrKzeLKiioiKVlJTUHsfHx0vyPr2uIbvPamrucjoAQNMSXT/rsqXvWGqvHT1Y3+5PYx91dOkiPfywtfa//0mTJpnJAwAAYFjYN5xqmj27N29253a75XQ6W9yk2dtxHQ6HcnJytGDBggaX3C1ZssQyUykpKUnZ2dnKy8trcLyaHC1pmgEAmpb9wQtqV11Ve7y9TTs9fOrfDCZCUEtPlwbX2Uh+8mSJpe4AACAChX3DSZJyc3PldDob3Nto1qxZkqSCgoJ655xOp5KTk5WVleXTcWueSFdzzu12176cTqccDoeKioosDaeUlJRG7yV5l9zFxMQ0eD8AQMslr/lWZ/34iaU2bcD5Wtutu6FECHo2m/TEE1Kb3TaT375duu02c5kAAAAMiYiGU3Z2ttLS0pSammpZAlczyyg3N7fBmUh5eXlyOBzKz8+Xw+Hwybhut1vJyclyOBxKTk5WbGys5dW3b18lJze8EW1ubq6ysrIss6pqxnO5XI3OlgIAtJDHozvfm2YpuTp10zMn7nkfPUS4o4+WbrjBWnv9dendd83kAQAAMKSt6QCBUlhYWLvptt1ul8vlktvtVmFhoVJSUhp8z6hRo2pnGjW2NK6l406cOLFZT5FraONvu92u4uLi2maWy+VSXFycUlJSlJubu8cxAQDNM/zHT5T8y/eW2hMnXaI/O3QxlAgh5V//kqZPl9at21W7+Wbpq6+k9u3N5QIAAAggm8fj8ZgOgeC1Zs0a9frrqTurV69WQkKC4UQA0Dp9xs9r1nXtqnZo/n+vV+KGtbW1VTE9lHrdM9rRpp2/4iHAVk0a4d8bTJsmjR5trU2eLI0b59/7hqDm/rfpT37/9wEAgCDmr9/7I2JJHQAAzTXyqwWWZpMkTT79KppNaJmrr5YGDbLW7rtP+uUXI3EAAAACjYYTAAB/aVe1Qzd8VmipfdHjML112MmGEiFkRUVJTz5prW3aJOXkmMkDAAAQYDScAAD4y0VfL1Svjb9Zag+f9jfv08eAlho0SLr2Wmvt5ZelRYvM5AEAAAggGk4AAEhqW7VTN346y1Ir7XmEFvU+zlAihIWJE6XoaGvtxhulqiozeQAAAAKEhhMAAGp4dtPjJ1/G7Cbsnf328z61bndLl0oFBUbiAAAABAoNJwBAxPPObpppqZUdeLg+7tPPTCCEl+uvl446ylq7+25p40YzeQAAAAKAhhMAIOJd+M17Oqju7KZTmN0EH2nXrv4G4uvXS5MmmckDAAAQADScAAARraHZTY4DD9NHffobSoSwNHiwdMEF1trjj0urV5tIAwAA4HdtTQcAAMCkC759X73dv1pq7N0U/vqMnxfwe9r3Ha75tv9TW0+1t7Btm/SPf0jPPx/wLAAAAP7GDCcAQMRqU12lGz+xzm76osdh+jAxyVAihDNnfIJe7XeWtfjii9KyZWYCAQAA+BENJwBAxLrgm/fVx73WUvvPyZcyuwl+85+TL9Wm9p12FTweadw4c4EAAAD8hIYTACAitamu0k2fzLDUlvY4VO/bkw0lQiRY3yVGU44faS0WF0vvvmsmEAAAgJ/QcAIARKTzv60/u+lxZjchAKYOvEC/do2zFseNk6qqzAQCAADwAxpOAICI09DeTUt7HKL37QMMJUIk2dauox459Qpr8auvpJdeMhMIAADAD2g4AQAiznnffiD7hl8stf/wZDoE0Oyjh0rHHGMt3n23tGWLmUAAAAA+RsMJABBR2lRX6cZPrbOblh1wiN5jdhMCqDqqjTR5srX488/S448byQMAAOBrNJwAABHl3O8+VF/Xz5YaT6aDEWeeKaWkWGuTJkm//24mDwAAgA/RcAIARIyo6irdVGfvpi8POFgL+w40lAgRzWbzznLavdn555/SffeZywQAAOAjNJwAABHjnO8/Ul/XGkuN2U0wqn9/6Yo6G4jn5Uk//mgmDwAAgI/QcAIARAaPR9d/WmgpfbV/Xy3oO8hQIOAv998vdeiw63jnTmnCBHN5AAAAfICGEwAgIpzhLNPhf/xkqT3B7CYEg4MOkm691VqbM0datMhIHAAAAF+g4QQAiAhZi2dbjpfH91LJwcxuQpCYMEGKj7fWxo2TPB4zeQAAAPYSDScAQPhbvFgn/u8rSyl/0EXy2Pg2iCARHS3dc4+19umn0ty5RuIAAADsLX7SBgCEv4ceshz+2jVOrx95hpksQGPGjJEOPtha+8c/pKoqM3kAAAD2Ag0nAEB4W7FCmm1dTjdtwPmqbNvOUCCgEe3bS//+t7X2zTfS9Olm8gAAAOwFGk4AgPD2yCOWfXAq2nfW9H7DDQYCmnDxxdKxx1pr994r7dhhJg8AAEAr0XACAISv336TnnvOUnq1/1n6s0MXQ4GAPYiKkh54wFpzOqVp08zkAQAAaCUaTgCA8PXUU9L27bWHlVFtNS35PIOBgGYYMUI68URr7b77pK1bzeQBAABoBRpOAIDwtGmT9PTTltLco87Q7/vEN/IGIEjYbPVnOf3yi/TMM2byAAAAtAINJwBAePrvf6UNGyyl/EEXGQoDtNDgwVJKirU2caJUUWEmDwAAQAvRcAIAhJ8dO6RHH7WUig8epBX7HmQoENAKdWc5rV8vPf64kSgAAAAtRcMJABB+Cgul//3PUso7fqShMEArDRoknX++tfbww97GEwAAQJCj4QQACC8ejzR5srV24okq7XmkmTzA3vj3v717OtX488/6/34DAAAEIRpOAIDwUlwsLVtmrWVnW39pB0LFMcdIl11mrT35pHcTcQAAgCBGwwkAEF7qzv449FDpvPPMZAF84Z//lNq02XW8dWv9/Z0AAACCDA0nAED4KCuTFiyw1saNk6L4docQdvDB0ujR1lpBgbRypZk8AAAAzcBP4ACA8PHQQ9bjAw6QrrjCTBbAl/7xD6lDh13HO3ZI//qXuTwAAAB7QMMJABAenE7v0+l2d/PNUseOZvIAvpSQIF1/vbX20kvSd9+ZyQMAALAHNJwAAOHh0Uel6updx127SmPGmMsD+NqECd5/r2tUV0v33GMuDwAAQBNoOAEAQt/69dK0adZaZqYUG2smD+AP3btLf/+7tVZU5N27DAAAIMjQcAIAhL6CAu+Tu2q0bSvdequxOIDf3H57/UYqs5wAAEAQouEEAAhtO3ZITz9trV18sdSrl5k8gD9FR0s5OdbaW29JixebyQMAANAIGk4AgND22mvSmjXW2i23mMkCBMKNN0r77Wet/fOfRqIAAAA0hoYTACC0/ec/1uMTTpAGDTKTBQiELl2k7Gxr7e23pc8+M5MHAACgATScAAChq7RU+uQTa43ZTYgEY8bUn+X0r3+ZyQIAANAAGk4AgNBVd3ZTz57SyJFmsgCB1KVL/b2c3nlH+vRTM3kAAADqoOEEAAhNa9dKM2daazfcILVrZyYPEGhjxkj772+tsZcTAAAIEjScAAChacoU7xPqanTsKGVmmssDBFrnzvVnOc2fX3+ZKQAAgAE0nAAAoWfbNm/DaXdXXCHFx5vJA5gyZox0wAHWGrOcAABAEKDhBAAIPTNmSL//bq3dfLOZLIBJnTpJ48dba8XF0qJFZvIAAAD8hYYTACC0eDz1NwsfMkQ65hgzeQDTMjOlHj2stXvvNZMFAADgLzScAACh5aOPpKVLrbVbbjESBQgKDc1yWrDA+98KAACAITScAAChpe7sJrtdGjHCTBYgWDQ0y4m9nAAAgEE0nAAAoWPVKmnuXGvtppukNm1MpAGCR8eO0oQJ1trChdKHH5rJAwAAIh4NJwBA6Hj6aam6etdx167SNdeYywMEk4wMqWdPa41ZTgAAwBAaTgCA0LB5szR1qrV27bVSdLSZPECwaWiW03vvSR98YCYPAACIaDScAACh4cUXJbd717HN5l1OB2CX0aPrz3LiiXUAAMAAGk4AgOBXXV1/s/ARI6SDDzaTBwhWHTtKd95prX3wgfT++0biAACAyEXDCQAQ/ObPl374wVq75RYzWYBgN3q0lJBgrTHLCQAABBgNJwBA8Ks7u+moo6ShQ81kAYJdhw71Zzl9+CF7OQEAgICi4QQACG4//CC98461dvPN3j2cADTs2mulXr2stfvuM5MFAABEJBpOAIDg9vTT1uO4OOmKK8xkAUJFhw7S+PHW2sKF0qJFZvIAAICIQ8MJABC8Nm2SXnjBWrvuOqlzZzN5gFBy7bVSjx7W2r//bSYLAACIODScAADB65VXpIqKXcc2mzR2rLk8QCjp2FHKybHW3n1XWrzYTB4AABBRaDgBAIKTxyM984y1ds45Up8+RuIAISkjQ9pvP2uNWU4AACAA2poOEEj5+fkqLCyU3W6Xy+WSJE2YMEFJSUlGxp08ebKKi4tVWlqquLg4JSUlNet9/vo6ACCoLFokffmltXb99WayAKGqc2dp3Djvq8abb0pffCH1728uFwAACHsR03BKT0+X0+nUggULFBMTI0lyOp1KTk5Wbm6uMjMzAzau2+1Wenq6srKyVFxcLElyOBxKT09XcnKysrOzlZubG9CvAwCCTt3ZTX37SsOGmckChLIxY6RJk6T163fV/v1vac4cc5kAAEDYi4gldfn5+SoqKrI0aSTJbreroKBAWVlZcjgcARs3PT1dOTk5SktLq60lJSWprKxMMTExmjx5soqKigL2dQBA0PntN6nu34Njx0pREfFtC/Ctrl2l22+31l57TfrqKzN5AABARIiIn9xzcnKUkpJiadLUqGn65NTdVNNP49Y0hFJSUuq9JyYmpnaGUkZGhk/uBwAhaepUaceOXccdO0rXXGMuDxDqbrhBio211u6/30wWAAAQEcK+4eRwOOR2u5vc3ygpKUklJSVyu91+H7ekpEQlJSVKTU1t8D01dbfbLafT6fevAwCCzs6dUl6etXbppVJcnJk8QDjo1k269VZrrbBQ+u47I3EAAED4C/uG08yZMyVJ8fHxjV4T99cvMSUlJX4ft7y8vLbW0PI3u91e++fdz/vr6wCAoPPmm9Lq1dYam4UDe+/mm72Npxoej/TAA+byAACAsBb2Daea5ktDy9Bq1JxbsmSJ38fNysqS3W5XWlpag7OVdp+dtPvY/vo6ACDo1N0sfOBAacAAM1mAcBIT42067W76dGn5ciNxAABAeAv7p9TVNHDimliKUXOuJUvRWjtuUlJS7SynhpSWltb+ecBuv2D56+tYs2ZNk+fXrl3b7LEAYK/9+KP019M7a91wg5ksQDi69Vbp8celTZu8x9XV0sSJ0rRpJlMBAIAwFPYNJ5fLFVLX5v21b0lmZqZlNpO/7terV69mXwsAfvfss9bjuDjp4ovNZAHCUXy8t4mbm7ur9uKL0j/+ISUmmssFAADCTtgvqQslRUVFcjgcstvtyt39B0EAiASbN0vPPWetjR4tdepkJg8Qrm67zfrfVVWVNGmSuTwAACAshf0Mp1DhdruVkZGhmJgYFRcXN7lXky+trrsxbx1r167VoEGDApIFQISbPl3auHHXsc0mjRljLg8Qrvbbz/vf1mOP7ao995x0113SQQeZywUAAMJK2Dec4uLi5Ha7m7XMrKn9kfw9bnp6uiSprKzM8qQ6f92vRkJCQrOvBQC/8Xikp5+21s46S2rg70MAPjBunHeD/u3bvcc7dkiTJ0tPPWU2FwAACBthv6SuOTOFapo4LZlV5MtxJ0+erNLS0kabTb6+HwAEnc8+k5Yutdauv95IFCAi9OghZWRYawUF0s8/m8kDAADCTtg3nGqe9NbUk+GcTqckaeDAgQEfNz8/X3l5eVq5cmWjzSZf3g8AgtIzz1iP+/SRhg83EgWIGDk5Uvv2u44rK6VHHjGXBwAAhJWANpzi4+MDeTtJUmpqqiTvHkmNqTmXlpYW0HFLSkqUl5ensrKyerOSioqKVFJS4tP7AUBQ+v13adYsa23sWKlNGzN5gEiRkCBdc421NmWKtG6dmTwAACCsBHQPJ4/Ho9dee00XXnhhwO5Z03zZvXmzO7fbLafTqaSkpICO63A4lJOTowULFjS4BG7JkiXKysry2f0AwKQ+4+c1em7sZ4XKqaysPd7epp1OWJOgDU28BwgHTf13ESirxo+Xpk71PqlOkrZu9W4m/uCDZoMBAICQF/AldWlpaZowYYIqKioCds/c3Fw5nc7aJWe7m/XXp+oFBQX1zjmdTiUnJ1saP74Yt+aJdDXn3G537cvpdMrhcKioqKjeErvW3g8AglVUdZUu/+JtS+3NI07Vhs7RhhIBEaZPH+mKK6y1p56SNmwwEgcAAISPgDac3G63pkyZopSUFF133XUaNWqUltbdJNYPsrOzlZaWptTUVMuStJpZRrm5uQ3ODMrLy5PD4VB+fr4cDodPxnW73UpOTpbD4VBycrJiY2Mtr759+yo5OdmnXwcABKvBzlIlVPxuqb3Uf4ShNECEmjBBstl2Hf/5J0+rAwAAey2gS+ry8vKU8dcTUYYOHaqNGzcqPz9fOTk5Sk9P13XXXee3excWFio/P1/p6emy2+1yuVxyu90qLCxUSkpKg+8ZNWpU7Uyjxho5LR134sSJDc5QqquxDcRb83UAQLD6m+Mty/GXBxyspT0ONZQGiFCHHSZdfLE0c+au2uOPS7feKu2zj6lUAAAgxNk8Ho/HdAhJWrBggfLz8xUXF6fx48erd+/epiNB0po1a9SrVy9J0urVq5WQkGA4EYBQ1NBeNQnuX/VhXoaitOvb0LizblbhscMCGQ2IaKsm/TWj8MsvpeOOs56cPFkaN87vGYJiL6tJzKwEAEQuf/3eH/A9nBozcOBAJSYmatasWbLb7TrzzDM1Z84c07EAAH5y6bJ3Lc2mig5d9MYRpxlMBESwY4+VzjvPWnvkEe8m4gAAAK0Q0IbTqlWr6tUWLlyoUaNGKTY2Vg899JA2bNigkSNHatKkSVq/fr2GDRumhx9+OJAxAQB+1q5qhy7+sthSm330EG1r19FQIgC66y7r8W+/Sf/9r5ksAAAg5AW04bT7ZthTp07VIYccotTUVBUWFioxMVGTJk3Shg0bNGvWLPXv318ZGRmaP3+++vfvrzFjxjDjCQDCROryz9V9i9tSe6XfWWbCAPAaNEgaVmdJa26uVFlpJg8AAAhpAW04eTweDRw4UG3atFFWVpbKy8s1dOhQFRcXa8WKFRo3bpyio+s/Cnvo0KGaMmWKPB6Ppk6dGsjIAAA/uHypdbPwzxOO0op9DzKUBkCturOc1qyRXnrJTBYAABDSAr6HU1lZmaKjozVu3DiVl5dr/vz5Gjp0aLPeO3LkSJWVlfk5IQDAnxJdP+vkn7601F7tN9xQGgAWp50mnXqqtTZxorRzp5k8AAAgZAW84TR58mS5XC5NmjRJiYmJzXrPww8/rOHDh6uiokLr16/3c0IAgD9duvQdy7GrUze9c9jJhtIAqOfuu63H5eXSzJlmsgAAgJAV0IZTXFyc7rjjjha/78EHH9T8+fOVmJioMWPG+CEZACAQOuysVNrXCyy1oqOHanvb9oYSAagnNVUaONBae/BBqbraTB4AABCSAtpwysnJadX7ysrKlJeXp9LSUg0ZMsTHqQAAgTL8h0WK21phqU1nOR0QXGy2+ns5ffutNHeukTgAACA0BbThlJGRIUmqqKho8PzChQsbPJeYmKiMjIxmL8EDAASny+osp1vU+1itjOtpKA2ARp17rnTMMdba/fdLHo+ZPAAAIOQEfA+niy++WLGxsRo+vP4n2omJiUpLS+NJdAAQhg5Z95OOX/ONpfZKv7MNpQHQpKio+rOcvvhCevttM3kAAEDICWjDaerUqXK73fJ4PCovL693PjExUfPnz9eKFSu0dOnSQEYDAPjZZcuss5vWdY5R8SHHG0oDYI/S0qRDD7XWmOUEAACaKaANp8LCQs2fP1/FxcUqLS1t9LpJkyYpLy8vgMkAAP7Uccc2jfx6oaU269hU7WjTzlAiAHvUpo00YYK19umn0vvvG4kDAABCS0AbTtHR0ZKkoUOH1v4ZABD+zvn+Y3Xbvrn2uFo2TT/uTIOJADTL5ZdLvXtba/ffbyYLAAAIKQFtOG3cuLHZ1zqdTj8mAQAE0uVfWPd9+TAxSWtiDjCUBkCztWsnjR9vrS1c6J3pBAAA0ISAz3Bq7Al1u/viiy8CkAYAEBBLl6r/2h8spVf71X9wBIAgdfXVUo8e1toDDxiJAgAAQkdAG04DBgzQ0KFD9eeffzZ6zdKlS3XxxRcrNTU1gMkAAH5TZ0++X7vGacHBgwyFAdBiHTtKd9xhrc2bJ/GAFwAA0ISANpyys7NVXV2tmJgYXX/99ZozZ46WLl2qhQsXas6cORo1apSSk5MVExOjO+r+YAMACD1//im9/LKlNPPYM1UV1cZQIACtkpUlxcdbaw8+aCYLAAAICW0DfcPCwkKlpqZqypQp9Z5E5/F4lJSUpFmzZgU6FgDAH6ZPlzZtqj2sskVpxnHDDAYC0Cpdukh//7t09927akVF0vffS4cfbi4XAAAIWgGd4SRJdrtd5eXlmjRpkvr37y+PxyOPx6P+/fsrNzdXpaWlSkxMDHQsAICveTzSlCmW0sK+A7S2W3dDgQDslRtukLp123Xs8UgTJ5rLAwAAglrAG041srOzVVpaqurqalVXV6u0tFTjxo0zFQcA4GulpVKdh0C80u8sQ2EA7LWYGOnGG621V16RVq40EgcAAAQ3Yw2nPRk1apTpCACAvVFn2fSabt31YWKSoTAAfOLWW6XOnXcdV1VJkycbiwMAAIJX0DacHA6H6QgAgNbauNG7f9NuZhx3pqrZLBwIbd27S5mZ1tq0adIvv5jJAwAAglbANw2vqKhQfn6+ysvLG73G6XTK6XQGMBUAwKdeeUXasqX2cKctSjOPZbNwICzccYf0zDNSZaX3uLJSeuQR7wsAAOAvAW04rVy5UgcffLAk7xPpmhIbGxuISAAAX/N46i2nKznkeK3rGmcoEACf6tlTuuYa63/nU6ZIEyZI++5rLhcAAAgqAW04ZWVlaejQoUpPT5fdbm/0uvLyco0dOzaAyQAAPrNkifTll5bSq8cNNxQGgF/k5EhTp3r3cJK8Mxoff1y6/36jsQAAQPAIaMPJ5XKptLR0j9cNHTpUk9mAEgBCU36+9bh3b32U2N9MFgD+kZgoXXaZ9NJLu2pPPSWNGydFR5vLBQAAgkZANw0fMGBAs6/Nzc31YxIAgF9UVNTbLFwZGfLYgvYZFQBaa8IEyWbbdbxxo/T00+byAACAoBK0vwGkpqaajgAAaKlXX7VsFq42bbx7vQAIP0ccIY0caa09+qi0ebOZPAAAIKgEtOGUnp6uhx9+uFnXJicn+zkNAMDnCgqsx+eeKx14oJksAPzvzjutx+vX119WCwAAIlJAG05Dhw5VYmKixo4dq2XLljV57fr16wOUCgDgE2VlksNhrWVmmskCIDD695fOPttae/hhaft2M3kAAEDQCOim4WeeeaZcLpfcbrfy//r0KyYmxnKN2+1usA4ACHJ1ZzUcdJA0bJiZLAAC5667pLfe2nX8yy/S889LWVnGIgEAAPMC2nBasmRJbUOpxoYNGwIZAQDgD3/+6d2/aXfXXefdwwlAeDvpJOmMM6T3399VmzRJuvZaqV07U6kAAIBhAV1SFxcXp/z8fFVXVzf5crlcgYwFANhbM2ZImzbtOo6K8v6yCSAy3H239XjVqvpPrAQAABEloA0nu92uAQMG7PG6mJgYxcbGBiARAMAn6i6nO+ccqWdPM1kABN6QIdLxx1trDz4oVVWZyQMAAIwLaMOpsLBQ/fr1a9a1ZWVl/g0DAPANh0MqLbXW2CwciCw2W/1ZTj/8IM2ebSYPAAAwLqANp+jo6No/L126VHPmzNHSpUtrawsXLlRFRUW9awEAQaygwHqckCANH24mCwBzRoyQjjvOWnvgAcnjMZMHAAAYFdCGk+RtNA0cOFDJyclKT09XXl5e7bnY2FilpaVpzpw5gY4FAGiNTZukV16x1tgsHIhMDc1y+vJL6c03zeQBAABGBbThtHHjRg0ZMkQbNmxQRkaGpkyZYjnfv39/zZ8/X/Pnz9eqVasCGQ0A0BozZ3qfUFeDzcKByHbRRdIRR1hr99/PLCcAACJQQBtOOTk5yszM1IoVKzRlyhRlZGQ0eN2UKVOUm5sbyGgAgNaou1n42WdLvXqZyQLAvKgoacIEa23xYqmkxEweAABgTMCX1E2aNKlZ13n4JAwAgtvSpd5fJHfHZuEALr1USky01u6/30wWAABgTEAbTjabrdnXbtiwwY9JAAB7re5m4T17SmedZSYLgODRtm39WU4ffih99JGZPAAAwIiANpxcLlezrtu4cSMNJwAIZps3Sy+/bK1de633F00AuPJK7xMrd/fAA2ayAAAAIwLacIqNjdWdd95pqTW0dC4lJUXDhg0LVCwAQEvNmiVVVOw6ttmk0aPN5QEQXDp0kLKzrbV335WWLDGTBwAABFxAG065ubmaMmWKhg8frtdee02rVq2SzWZTRUWFli5dqqlTp+qQQw6R2+3WHXfcEchoAICWqLtZ+PDhUu/eZrIACE7XXSftt5+1xiwnAAAiRkDXPkRHR2vWrFkaNmyYiouLa+v5u/3ikpiYaDkHAAgyX34pffaZtcZm4QDq6tRJuuMO60yn11/3/h1y7LHmcgEAgIAI+FPqUlJS5HK5dNFFF8nj8dS+oqOjlZGRoRUrViix7pNNAADBo+5m4T16SCNGmMkCILiNGSPFxVlrDz5oJgsAAAiogDecJCkmJkaFhYWqrq5WeXm5NmzYIJfLpSlTppiIAwBori1bpJdestauuUZq185MHgDBbZ99pFtusdZmzZJ++MFMHgAAEDBGGk67S0xMVHR0tKW2cuVKjR071lAiAECjCguljRt3Hdts3n1aAKAxN93kbTzV8HikiRPN5QEAAAFhvOHUEKfTqdLSUtMxAAB11V1ON2yYxDJoAE2JjZVuvNFae/lladUqI3EAAEBgBHTT8ObMWnK5XCopKVFc3fX+AACzvvlGWrTIWmOzcADN8fe/S48/Lm3d6j2uqpJyc6VnnzUaCwAA+E9AG04zZ87Uxo0b5fF4Gr3GZrPJ4/HI7XYHLhgAYM/qzm7af3/p3HPNZAEQWrp3924g/thju2rTpkl3320uEwAA8KuANpzi4uKUkpKirKyseufcbrfKy8s1a9YsjRkzRsnJyYGMBgBoyrZt0osvWmtsFg6gJe64Q3r6aamy0ntcWSk99JDUMdVsLgAA4BcBbTjFxMTozjvvVL9+/Rq9Jjs7W+PHj9eAAQMCFwwA0LTZs6UNG6w1NgsH0BIHHiiNHm1dRpeXp+6jB2hd11hzuQAAgF8EdNPw3Nxc2e32PV43adIk5eXlBSARAKBZ8vOtxykpUt++ZrIACF05OVLb3T7v3LZN1y15zVweAADgNwFtOA0dOlTdunVr1rVN7fMEAAig77+XPvzQWsvIMJMFQGjr3Vu66ipL6W9fzFPclo2GAgEAAH8JaMOpJTbUXboBADCj7mbh3btLF1xgJAqAMDBhgtSmTe1h5x3bNXrJXHN5AACAXwRlw2nhwoVyOp2mYwAAtm+XXnjBWrv6aql9eyNxAISBvn2lyy+3lK50vKnorX8aCgQAAPwhoJuGx8fHN3ne7XbX/pk9nAAgCLz2mrR+vbXGZuEA9tadd0ovvST9tYXCPpVbdW3p/+mxUy/fwxsBAECoCOgMJ4/How0bNjT6io6OVv/+/TVlyhRdxy80AGBe3c3CBw+WDj3UTBYA4eOww6RLLrGUrin7P+2zfbOhQAAAwNcC2nCy2+2aPHmyqqurG3y5XC6VlpYqg81oAcC85cul996z1vj7GYCv3HWXZLPVHnbbvllXlb1hMBAAAPClgDac4uLilJKSEshbAgBaa+pU63F8vHThhWayAAg/Rx0ljRxpKY1e8rq6bN9iKBAAAPClgDacCgsL1a9fv0DeEgDQGpWV0nPPWWtXXSV17GgmD4DwdPfdlsPYbX/qb1+8ZSgMAADwpYA2nKKjo/d6jIcfftgHSQAATXr9dWndOmuN5XQAfO244zT/kBMspYzFc9SpcpuhQAAAwFcC2nDyBZ5eBwABUFBgPT71VOnww81kARDWnjjJunl4/NYKXbb0bUNpAACAr7QN5M2m1t0PpIXKy8vldDp9lAYA0CCnUyouttYyM81kARD2vj7gYC20D9AQZ2ltbczi2Xq5/9na3q6DwWQAAGBvBLTh5PF4lJubq5UrV9Ye786225NKGnt/bGxsq++fn5+vwsJC2e12uVwuSdKECROUlJTU6jF9Ma7D4VB6errKysoUExPT6HVOp1NZWVlKT09XSkqK7HZ7bd3hcGjmzJnKzc2trQNAq9T9cCA2tt7GvgDgS0+edIml4dR9s1uXfDlfLySfazAVAADYGwFtOGVkZCglJUWpqalKSUlRcnKy5fyKFSs0e/ZsJScna8CAAZZz69evV3l5uebMmdOqe6enp8vpdGrBggW1TR2n06nk5GTl5uYqs5Wf3u/NuA6HQ3l5ecrPz2/Wvdxut0pKSlRSUtLgeZpNAPbajh3StGnW2pVXSp06mckDICJ80fNwfdinv05b9UVtbcxnRZp+3HBVtm1nMBkAAGitgDacVq5cqTFjxsjhcKhbt24NXpObm6sxY8YoKyurwWsOPvjgFt83Pz9fRUVF2rBhg2UGkd1uV0FBgdLT0zVgwIAWz3Rq7biTJ0/WzJkzNWDAAKWnp2vWrFlyu90t/rpqJCUlqaCgYK9nagEIT33Gz2v2tWf++InyfvvNUkv981Atb8EYANAaT5x8iaXh1GPTeqV/VaxX+p9tMBUAAGitgG4aPn78eM2aNavRZlON3Nxc5eTkNHguLS2txffNyclRSkpKg8vVasZr7H7+GDc7O1tlZWXKy8tTSkpKi+6Zlpam8vJyFRcXq6ysTB6PR2VlZTSbAPjEpUvftRyX9jxCy7v3NpQGQCQpTThKnxx0rKU29rNCtavaYSgRAADYGwF/Sl10dHSzrlm/fn2D5yZNmtSi+zkcDrnd7iYbMklJSSopKWnRLCN/jdscdrtdKSkpNJkA+FTCxt902kqHpTb9uOGG0gCIRE/WeWJdQsU6Xfj1e4bSAACAvRHQhlNLnjC3pw3Em2vmzJmSpPj4+EaviYuLk6RG90YK5LgAYMoly95VlHY9zKGiQxfNO/xkg4kARJpPDzpGixOOtNRu/HSm2lbtNJQIAAC0VkAbTrGxsXrvvT1/SrVx40afzQqqafY09fS3mnNLliwxPi4AmNC2aqcu/rLYUpt99BBta9fRUCIAEclmqzfL6aCNv+nCb5jlBABAqAnopuGZmZlKSUlRSUmJBg8e3OA1q1atUmpqqrKysnxyz5rGVc1so4bUnGtJk8tf4zZHzdPtarhcLo0aNapV+1utWbOmyfNr165t8ZgAQs/QFYu13+YNltr04840lAZAJPuoT385DjxMSb/8UFu76ZMZeu2owdrZJqA/ugIAgL0Q0O/aaWlpGjJkiFJSUpSammrZh8jpdKq4uFhFRUVKSkrSHXfc4ZN7ulyukLp2T0pKSjRw4EBLw8npdKpv377KzMy01JujV69ePssGIHRdvvRty3FpzyP0Y/c+ZsIAiGw2mx4/+TK9WHhvbck7y2mhCo8dZjAYAABoiYB/TFRUVKQhQ4Zo/vz5Ki62Lt/weDxKSkrSrFmzAh0rJNjtdhUUFNSbyWS325Wdna3JkycrOTlZmZmZhhICCEW93L9aHkUuSa/2Y7NwAOZ8mJjUwCynmXrtqCHMcgIAIEQYeUpdWVmZpkyZoiFDhsjj8cjj8ah///7Kzc1VaWmpEhMTAx0rJMTExDS6bG7UqFGSpJycnBaNuXr16iZfixcv3uvcAILbJcvetRxv7NBF8w47xVAaAJBks+mxUy63lA7a+Jsu+nqhoUAAAKCljH1ElJmZGZCZOHFxcXK73c1a1tbUfkyBGre17Ha7JO9+UQ6Ho3ap4p4kJCT4MxaAINe2aqcu/so623TO0UO0vV0HQ4kAwOujPv1VduDhSv7l+9raTZ/O1JyjmeUEAEAoCPgMpxpLly7VnDlztHTp0trawoULVVFR4dP7NPUUuRo1TaPmXOvvcRvjdDqVlZWloqKiZl0LAM2Ruvwzdd/sttRe6XeWmTAAsDubTY+fcpml1ItZTgAAhIyAN5yWLl2qgQMHKjk5Wenp6ZZNrmNjY5WWlqY5c+b47H4DBgyQJJWXlzd6TU2DZuDAgcbHbUxeXp7y8/OVnp6+x2trZjsBwJ5ctvQdy/HihCO1Yt+DDKUBAKuaWU67u+nTmWpbtdNQIgAA0FwBbTht3LhRQ4YM0YYNG5SRkaEpU6ZYzvfv31/z58/X/PnztWrVKp/cMzU1VZJ3qVljas41tj9SIMdtTHx8vCQ1ugxx91lNzV1OByCy9d7wi079aaml9iqzmwAEkwb2cuq18TeN/HqBoUAAAKC5AtpwysnJUWZmplasWKEpU6YoIyOjweumTJmi3Nxcn9yzptlTUlLS4Hm32y2n09niJo2/xm1MUlKSsrOzLTPCdleTwxfNLQCR4ZJl8y3H7o5d9fZhJxtKAwAN+7hPP5X2PMJSu/HTWWpXtcNQIgAA0BwBX1I3adKkZl3n8Xh8ds/c3Fw5nc4G9zaaNWuWJKmgoKDeOafTqeTkZGVlZfl03NZISUlp9F6Sd8ldTEyMz+4HILy1q9qhtK+sDfPZRw/V9rbtDSUCgEbYbHr8ZPZyAgAg1AS04WSz2Zp97YYNG3x23+zsbKWlpSk1NdWyBM7hcCgnJ0e5ubkNzkTKy8uTw+FQfn6+HA6Hz8bdndPprH1vaWlpk9fm5uYqKyvLMqvK7XYrOTlZLpdLCxYs8MkG5QDC37AfP1P3LW5L7dXjhpsJAwB7wCwnAABCT0CfKVvz1LY92bhxo08bTpJUWFhYu+m23W6Xy+WS2+1WYWGhUlJSGnzPqFGjVFRUJLvd3mjjqDXjFhUVaeLEiXK73XK5XLVNovT0dMXFxSkmJkajRo1Sdna25X12u13FxcW1zSyXy6W4uDilpKT4bAkigMhw2bK3Lcef9zpa5fv2MpQGAPbgr72cXpl5d22p18bfNPKrBZrRj2Y5AADBKKANp9jYWN1555168MEHa2sNLZ1LSUnRqFGjfH7/zMzMRjfdbkhSUlKTT6Fr7bhpaWl7tdcSzSUAe6OP62ed/NOXltor/MIGIMgt6n2clvQ8UgN//ra2duOnszT7mKHa0aadwWQAAKAhAV1Sl5ubqylTpmj48OF67bXXtGrVKtlsNlVUVGjp0qWaOnWqDjnkELndbt1xxx2BjAYAEeOSZe9ajl2duundQ08ylAYAmslm0+OnWPdySqj4XSO/4ol1AAAEo4DOcIqOjtasWbM0bNgwFRcX19bz8/Nr/5yYmGg5BwDwnfY7dyi93mbhQ9gsHEBIYJYTAAChI+BPqUtJSZHL5dJFF10kj8dT+4qOjlZGRoZWrFihxMTEQMcCgIhw5o+fKH5rhaU2nc3CAYQKm02PNTDLKY1ZTgAABJ2AznCqERMTo8LCQknSypUrFRcXp+joaBNRACCiXLbsHcvxpwcdI2d8gqE0ANByn/Q+TosTjtSgNbtmOd3w6UwVMcsJAICgEvAZTnUlJibSbAKAAEh0/awT//eVpfYqs5sAhBqbTY+fXHeW0zqN+pItGQAACCYBneFUUFCgMWPGKCcnx/KkOgCA/1261Dq7aT2bhQMRr8/4eaYjtEpDs5xu/GSGCo8equ3tOhhMBgAAagT8KXUej0dlZWWBvC0ARLwOOyuV9rV1j5OiY1JU2ZblJwBCkM2mR0+9wlI6YJNLl9dprAMAAHMC2nBKSkpSWVmZ3n333T1eO2fOnAAkAoDIcOaPnyiu3mbhZxpKAwB777ODjtXHvY+z1MZ+VqjOlVsNJQIAALsLaMPJbrfLZrM169qcnBw/pwGAyHHFF29Zjhf1Plar4noaSgMAvlF3llP3LW5d5XjTUBoAALC7gDacJk2apBkzZujhhx9WRUVFk9euX78+QKkAILwdtm6VZZ8TSXql39mG0gCA7zh6HqEFfQdaalmfz9Y+2zcbSgQAAGoEdNPwsWPHSpIWLFignJwcxcTEyG63Ky4urvYal8slt9vd7JlQAICm1Z3d9HuXWM0/5ARDaQDAtx495XINLV9SexyzbZNGL5mrx0+53GAqAAAQ0IbTzJkztXHjRnk8HknShg0bGt1APDY2NpDRACA8/fmnLvzmPUtpxrHDtLNNQP/6BwC/+eaAg/X2oSfprB8/qa2NXjJXzyefK3enbgaTAQAQ2QK6pC4uLk7Z2dnasGFDk6/S0tJAxgKA8PXKK+q62wa6VbYoTe833GAgAPC9x065TNXaNTt+n8qtyvqcB9AAAGCSzz/irqiokNPprH2tWLFCK1euVHZ2tux2u0aNGqXo6Ogmx0hKSmKGEwDsLY9HevZZS2lh34Fa2627oUAA4B8/du+j/zvyNF3w7Qe1tavL3tC0AedrXVd+pgQAwASfN5z69OmjjRs3KiYmRhMmTFBOTo4SExMleZ9SV/PnPSksLPR1NACILJ9+Kn35paX0cn82CwcQnv5z8mU657uP1NZTLUnqtHO7xn5WqPtSMg0nAwAgMvllSV1MTIycTqfuuOMOS4Opuc0mSerfv78/ogFA5Kgzu+mnmAP0YSJ/twIITyvjemr20UMttcuXvqUeFesMJQIAILL5peFUUFCwx2VzAAA/+uMPadYsS+nVfsPlsQV06z4ACKgnT75ElVG7JvB3qNqpGz+daTARAACRyy+PKUpJSalXW7p0aaPX9+vXzx8xACByPfecVFlZe7i9TVsVHpNqMBAA+N+a6P0147gzdeUX82prF39ZrCnHp2l1zAEGkwEAEHn80nDq1q3+I2hnzJghp9OpoqIi2Wzep4ikpaXJbrfLbrc3+B4AQCtUV0t5eZbSW4edIldnZp4CCH9PnXixLv6qWB13epvu7aqrdMui6bpjxN8NJwMAILL4vOEUFxfXYH3SpEmSJIfDoQEDBig/P1/XXXedr28PACgulsrLLSU2CwcQKX7fJ14v9T9bGUvm1tYu/OY9PXtCmsrje5kLBgBAhPH5Zh41s5cak5SUJEm6+OKLm7xu7NixPssEABGlzmbh33Xvo7KeRxgKAwCBN+X4NG1u17H2uI2nWrd+/KrBRAAARB4ju8c2ZwldaWlpgNIAQBhZvVp64w1L6ZX+Z0t7+DAAAMLJ+i4xem7AeZbaud9/pMN/X2koEQAAkcdIw2lPs6Akye12+z8IAISbggLvHk41unbVa0eeYSwOAJiSP+giVXToYqnd/tFLhtIAABB5fL6H0/r16/Xaa68pMTGx0WtcLpeWLVsmj8fT4Pny8nK5XC5fRwOA8LZjhzR1qrX2t79pc4fOZvIAgEEVHbuqYOAFuv3jV2prqSsWK3nNtypLONJgMgAAIoNfnlKXlpa2x2tq9nJqTExMjI/SAECEeP11ae1aa23sWOmV/5nJAwCGTRtwvq4ue0PxWytqazkfPK+LL8tlqTEAAH7mlyV1Ho9nr18AgBaqs1m4Tj5ZOuYYM1kAIAhs7tBZT500ylIbtOZbDXayVygAAP7mlxlOubm5SkpKUlxcXIvf63K5VF5ergkTJvghGQCEqR9+kBYutNZ42icA6JV+Z2v0kteVUPF7bS37gxf0QWKSqqPaGEwGAEB483nDyWazady4cXs1xtChQ/XQQw/5KBEARIApU6zH++4rNWN5MwCEu8q27fToqZfr0XmP1daOWLdK53/7gV47eojBZAAAhDefL6mLjY31yTgsqwOAZtqyRXr+eWvt2mulDh2MxAGAYDP3yDP0/b69LbXbPn5F7XfuMJQIAIDw5/OGU1lZWVCNAwBhb+ZMye3edWyzSVlZxuIAQLCpjmqjyadfZan12vibLlv6tqFEAACEP583nKKjo4NqHAAIax6P9PTT1tqZZ0p2u5k8ABCkFvYdqCU9j7TUbvx0prps32IoEQAA4c0vT6kDAATI559LdWeEslk4ANRns2nSGVdbSvtu2ajrlsw1EgcAgHBHwwkAQtmTT1qPe/eWRowwkwUAglxZwpEqPniQpZax5DXp998beQcAAGgtGk4AEKp+/VUqLLTWrr9easNjvgGgMQ+ddqWqZas97lq5VXrgAYOJAAAITzScACBU5edLO3Z7wlLHjtLo0ebyAEAI+LF7H7129GBr8dlnpZUrzQQCACBM0XACgFBUWSlNmWKtXX65FB9vJg8AhJBHT7lC29u03VXYsUO6915zgQAACEM0nAAgFL32mrR2rbV2441msgBAiPk5ej+93L/Ofncvvyx9+aWZQAAAhCEaTgAQiupuFn7KKVK/fkaiAEAoevrEi/Vn+067Ch6PdOed5gIBABBmaDgBQKj54gtp0SJrjdlNANAirs7RKhh0kbU4b5700UdmAgEAEGZoOAFAqHnqKetxjx7SRRc1fC0AoFFTB16gdZ1jrMXx472znQAAwF6h4QQAoWT9eunVV621MWOkdu3M5AGAELalfSc9edIoa/GTT7z75AEAgL1CwwkAQsl//ytt27bruF07KTPTXB4ACHHT+w2XEhOtxZwc79NAAQBAq9FwAoBQUVUlPfOMtXbxxdIBB5jJAwBhYEebdtLEidbiihXSs8+aCQQAQJig4QQAoeKNN6SffrLW2CwcAPbexRdLJ5xgrd13n7Rhg5k8AACEARpOABAq6m4WPmCAdPzxZrIAQDix2aRHHrHWXC7pgQfM5AEAIAzQcAKAUPDtt9KCBdbajTd6f0kCAOy9k06S0tKstSeflJxOM3kAAAhxNJwAIBQ8/bT1eN99pVGjGr4WANA6kyZZn/pZWSlNmGAuDwAAIYyGEwAEu40bpRdesNYyMqSOHc3kAYBw1bdv/b3xZs2SPv3UTB4AAEIYDScACHbPPy9t3rzruE0baexYY3EAIKzdfbcUG2ut3X675PGYyQMAQIii4QQAway6uv5yugsukHr1MhIHAMJeXJz0j39Ya59+KhUVmckDAECIouEEAMFs/nxp+XJrre5yDwCAb91wg3d53e7Gj5e2bzeTBwCAEETDCQCC2VNPWY+PPlo6/XQzWQAgUrRv791AfHdOZ/0ZpwAAoFE0nAAgWC1fLr31lrV2442SzWYmDwBEkpEjpZNOstb+/W/J5TKTBwCAENPWdAAACFd9xs/bq/f/q/hZXbXbJrUVHbro+B/21da9HBcA0Aw2m/TII9KJJ+6qud3eptNjjxmLBQBAqGCGEwAEoW7bNin9qxJLbfpxZ2pr+46GEgFABDrhBGnUKGvt6aelFSvM5AEAIITQcAKAIHTZ0nfUeceuzWl32qL0QvI5BhMBQISaONG7p1ONHTu8G4gDAIAm0XACgCDTtmqnrip7w1J7+7CT9Uu3/QwlAoAIlpgo3XyztTZ7tvTxx2byAAAQImg4AUCQOfuHj9Vj03pLberAC8yEAQBId90lxcVZa7fcIlVVmckDAEAIoOEEAMHE49HoJa9bSqU9j9CyAw8zFAgAoJgY6d57rTWHQ5o2zUgcAABCAQ0nAAgiA9d8o+N+XW6pMbsJAILA2LHSkUdaa3fe6X1yHQAAqIeGEwAEkdGl1tlNq6P31/xDTjCUBgBQq1076T//sdb++EP65z+NxAEAINjRcAKAIHHQhrUa9uNnltpzyeepOqqNoUQAAIuUFOnCC621p56SvvnGTB4AAIIYDScACBLXlP2fouSpPf6zfSfNOjbVYCIAQD2PPCJ16LDruKrKu4G4x9P4ewAAiEA0nAAgCHTbtknpX5VYajOOO1ObOnQ2lAgA0KDERGncOGttwQJp7lwjcQAACFY0nAAgCIxaNl9dK7fWHlfZovRC8rkGEwEAGjV+vJSQYK3ddpu0dWvD1wMAEIHamg4QSPn5+SosLJTdbpfL5ZIkTZgwQUlJSUbHdTgcSk9PV1lZmWJiYvx+PwDBpU11la4ue8NSe+fQE7Umen9DiQAATerSRXroIenSS3fVVq3yLre7+25jsQAACCYR03BKT0+X0+nUggULaps6TqdTycnJys3NVWZmZsDHdTgcysvLU35+vvGvA4A5Z/2wSD3/XGep/XfgBWbCAACaZ9Qo6ZlnpI8+2lWbOFG66iqpVy9zuQAACBIRsaQuPz9fRUVFliaNJNntdhUUFCgrK0sOhyNg406ePFnJycnKy8tTenp6s2Y1+fPrAGCQx6Prlsy1lL7ocZgcPY8wkwcA0Dw2m/TEE1LUbj9Ob9kiZWebywQAQBCxeTzh/0iN2NhYDRgwQMXFxQ2et9lsSklJafS8v8eNjY2V2+3Whg0bmmw++evraMqaNWvU669P6VavXq2EuvsVAGhUn/Hz9nhN0prvNOcV6+azN5yXo3lHnOqvWACAOlZNGtH6N48ZI+XlWWsffiidyt/jAIDQ4K/f+8N+hpPD4ZDb7W5yf6OkpCSVlJTI7XYbHzdY7gcgMEaXzrUcr+nWXe8cdpKZMACAlrv/fqnuB4Y33SRVVRmJAwBAsAj7htPMmTMlSfHx8Y1eExcXJ0kqKSlp9JpAjRss9wPgfwnuXzX8x08tteeTz1VVVBtDiQAALbbvvtJ991lry5ZJU6eayQMAQJAI+4ZTTfOlqaVqNeeWLFlifNxguR8A/7u67A218VTXHm9q30kzjzvTYCIAQKuMHSsddZS1dtdd0oYNZvIAABAEwv4pdTXLy2pm/zSk5lxLlqL5a9xA32/NmjVNnl+7dm2zxwLQfF23b9GoL+dbarOOSdWfHboYSgQAaLW2bb0biA8duqu2fr10zz3Sk0+aywUAgEFh33ByuVwhdW2g79eLx/YCRoxa9q72qdxae1wtm54bcJ7BRACAvTJkiDRypDR79q7aM89IV18tJScbiwUAgClhv6QOAIJNu6odum7JXEvt3UNP1OqYA8wEAgD4xsMPSx077jqurvY+xY4NxAEAESjsZzihaatXr27y/Nq1azVo0KAApQEiwwXfvK8em9ZbagUDLzSUBgDgM336SHff7X3VKC2VpkyRbrjBWCwAAEwI+4ZTXFyc3G53s5aZNbU/UqDGDfT9EhIS9iYWgBayeao15vPZltrnvY6WI+EIQ4kAAD51xx3Syy9L33+/q3bnnd7ldgcwkxUAEDnCfkldU091q1HTxGnOtf4eN1juB8A/hi3/TH1d1s36nz0+zVAaAIDPdeggPfustVZRId12m5k8AAAYEvYNpwEDBkiSysvLG73G6XRKkgYOHGh83GC5HwA/8Hg09rMiS+m77n30vp3NZAEgrJxxhnTlldba9OlScbGROAAAmBD2DafU1FRJktvtbvSamnNpac2fZeCvcYPlfgB878T/faV+a3+01J49IU2y2QwlAgD4zUMPSbGx1tr110vbtpnJAwBAgIV9w6mm+VJSUtLgebfbLafTqaSkpKAYN1juB8D3xn5WaDleHb2/5h1+qqE0AAC/2m8/adIka23Fivo1AADCVNg3nCQpNzdXTqezdsnZ7mbNmiVJKigoqHfO6XQqOTlZWVlZPh23tQJ9PwC+c9Rv5Tpt1ReWWt6gi1QV1cZQIgCA3113nXTCCdbaxInS8uVm8gAAEEAR0XDKzs5WWlqaUlNTLUvSHA6HcnJylJub2+DMoLy8PDkcDuXn58vhcPhs3N05nc7a95aWlvrl6wBg3pg6ezf90TlahcekGEoDAAiIqChpyhSpzW4fLlRWepfWeTzmcgEAEABtTQcIlMLCQuXn5ys9PV12u10ul0tut1uFhYVKSWn4l75Ro0apqKhIdru90UZOa8YtKirSxIkT5Xa75XK5ap8ql56erri4OMXExGjUqFHKzs72yf0AmNV7wy86+4dFltq0Aedre7sOhhIBAALmuOOkW2+VHnlkV62kRJoxQ7r0UmOxAADwN5vHw8craNyaNWvUq1cvSdLq1auVkJBgOBEQOvqMnydJeuDdp3T50ndq63+276STxz6nio5dTUUDAOxm1aQR/r3Bpk3SEUdIa9bsqu2/v/T999JfHzwCAGCKv37vj4gldQBgSvdNG5T21QJL7ZV+Z9FsAoBI0rWr9MQT1tpvv0l3320mDwAAAUDDCQD86Jqy19Whakft8fY2bTVtwPkGEwEAjLjgAumcc6y1Z56RliwxEgcAAH+j4QQAfrLP9s26wvGWpTbnqCH6fZ94Q4kAAMbYbNKTT0qdOu2qeTxSVpa0c6e5XAAA+AkNJwDwk8u/eFvdKrfUHlfLpvzjRxpMBAAwqk8f6d57rbUvvpAee8xIHAAA/ImGEwD4w7ZtGl0611J6+7CTtDKup5k8AIDgcNtt0lFHWWv33CP9+KOZPAAA+AkNJwDwhxdeUPfNbktpyvFpZrIAAIJHu3ZSQYF3iV2Nbduk0aOl6mpzuQAA8DEaTgDga1VV0kMPWUof9e6nr3ocYigQACConHiidPPN1trHH0vPPmsmDwAAfkDDCQB8bfZsqbzcUnr2BGY3AQB288ADUmKitZaTI61aZSQOAAC+RsMJAHzJ45EmTrSUvjzgYH3S+zhDgQAAQalLF2nqVGtt82YpM9P7vQQAgBBHwwkAfOn116WlSy2lZ49Ps+7VAQCAJA0ZImVkWGvFxdLzzxuJAwCAL9FwAgBf8Xikf/3LUloRl6B3Dz3RUCAAQNB76CGpZ50nmP7979Ivv5jJAwCAj9BwAgBfaWB20xMnX6rqqDZm8gAAgl90tJSXZ61t3Chdfz1L6wAAIY2GEwD4QiOzm948/BRDgQAAIWPECOmKK6y111+XZs0ykwcAAB+g4QQAvsDsJgDA3nj8cWm//ay1G2+U1q0zEgcAgL1FwwkA9lYDs5t0+OHMbgIANF98vPTUU9baH39It9xiJg8AAHuJhhMA7K0GZjfpnnuY3QQAaJm0NOmii6y16dOl//s/M3kAANgLbU0HAICQ1sjsJl18sbTsHTOZAAAhp8/4eZKk7j0uVHHH+YrZtqn23G+XX6PU0c+oomNXv2ZYNWmEX8cHAEQWZjgBwN5oZHaT2jC7CQDQcuu6xuq+oRmW2v6bXLq3JK+RdwAAEJxoOAFAazU1uwkAgFaac9QQvZ+YbKmN/OY9nfX9x4YSAQDQcjScAKC1mN0EAPAHm00Tht+oivadLeUH331a+/253lAoAABahoYTALQGs5sAAH60tlt33TNsrKUWu+1PPfT2f7zfgwAACHI0nACgNZjdBADws7lHnqE3DzvFUjt9pUN/+2KeoUQAADQfDScAaClmNwEAAsFm011n3qDfusZZyne+95z6rl9tKBQAAM1DwwkAWorZTQCAANnYaR+NO+sWS63Tzu169M1H1bZqp6FUAADsGQ0nAGgJZjcBAALsQ3uynk86x1I77tfluumTGYYSAQCwZzScAKAlmN0EADBg0hlXa0VcgqV246ezlPTzd4YSAQDQNBpOANBczG4CABiyrV1H3XruHdoRtesDjjaeaj365qPqXLnVYDIAABpGwwkAmquoiNlNAABjvj7gYD1+8mWWWh/3Wt29cKqhRAAANI6GEwA0x44d0p13WmvMbgIABNiUE9JUduDhltply97V0BWfG0oEAEDDaDgBQHNMnSqtWGGt/fvfzG4CAARUVVQb/f2c27W5XUdLfdLbTyp+s9tMKAAAGkDDCQD2ZNOm+ns3DRokjRxpJg8AIKL9L7aH7huaYal13+JW7tv/8e43CABAEKDhBAB78thj0m+/WWuTJ0s2m5k8AICIN/PYYSo++HhLLaV8iUaXvm4oEQAAVjScAKAp69Z5m0u7O/ts6fTTzeQBAECSbDaNH36T1nWOsZRz3n9ex/3yg5lMAADshoYTADTl/vu9S+pq2GzSxInm8gAA8Jf1XWJ0+4i/W2rtq3fqqf+brG7bNjXyLgAAAoOGEwA0xumUnn3WWvvb36RjjzWTBwCAOj60J+vpE9IttV4bf9NDbz3Ofk4AAKNoOAFAY+6+W9qxY9dx+/bSffeZywMAQAMePfUKLU440lI7c/lnurrsDUOJAACg4QQADXM4pOnTrbUbb5R69zaTBwCARlRFtdHN52bL1ambpX7ne9N0zNrlhlIBACIdDScAaMj48dbj6GjpzjvNZAEAYA9+7bavbhtxm6XWvnqnnn59Evs5AQCMoOEEAHUVF3tfuxs/XoqPN5MHAIBmeL/vAD17fJqldtDG3zTp7SfYzwkAEHA0nABgd9XV9Wc3HXigdPPNZvIAANACj5x6hUp7HmGpnf3jJ/rbF/MMJQIARKq2pgMAgD/0Gd+6H6zP/fYDPelwWGo5x47UzPve80UsAAD8amebtrrpvGy99dzNit32Z2397oVT5TjwcH1zwMEG0wEAIgkznADgL+2qduiOj16y1FbEJajomBRDiQAAaLm13brrtnOs+zl1qNqpp1/PVdftWwylAgBEGhpOAPCXy5a+o97uXy213DOuVlVUG0OJAABonff6DtSUQRdZan3ca9nPCQAQMDScAEBS1+1bdPOi6ZZaac8jVHzw8YYSAQCwdx4+7UqVHXi4pXbODx/r2tL/M5QIABBJaDgBgKSsz2crfmuFpTbpjKslm81MIAAA9tLONm110/nZcnfsaqnf+d5/ddKqpWZCAQAiBg0nABGvl/tXZS6eY6kVH3y8ShOOMpQIAADf+KXbfrpthHU/p7aeaj31f5OVUGcZOQAAvkTDCUDE+8fCqepQtaP2eKctSrmnX2UwEQAAvrPw4EF69JTLLbW4rRXKf+0BdarcZigVACDc0XACENFOc5Zp2PLPLLUXks/Vin0PMpQIAADfe/KkUXr3kBMstSN/X6nJb/+HTcQBAH5BwwlAxGpXtUP3Lsi31P7oHK3/nHypoUQAAPiHxxal20bcph/jrR+onPv9Rxrz+WxDqQAA4YyGE4CIdXXpG+rr+tlSyz39KlXU2VwVAIBwsLlDZ2VedJcqOnSx1LM/eEGnO8sMpQIAhCsaTgAiUvdNLt3yyXRLbWmPQ1V0TIqhRAAA+N+quJ66+dxxqtaup7BGyaMn/m+ytHy5wWQAgHBDwwlARBr//nPqWrnVUrs3JUseG38tAgDC2/t9B+ih06+01KK3b5YuuED6808zoQAAYYffrABEnKQ132nkN+9ZarOOSdGyAw8zlAgAgMB69vg0vXnYKdbit99KV14pVVebCQUACCs0nABElKjqKv2rZIqlVtG+syaffpWhRAAAGGCzadzZt+q77n2s9blzpfvvN5EIABBmaDgBiCijvizWMb+VW2qPn3K5/ugSaygRAABmbG3fUZkX3a0NHfexnrj3Xm/jCQCAvUDDCUDEiN76p8Z9+KKl9mP8QXoxaYShRAAAmLU65gDdeH6OquruYXjZZdKSJWZCAQDCAg0nABHj7x+/oritFZbaP1MytbNNW0OJAAAwb1GffnrwjGusxa1bpXPOkVauNBMKABDyaDgBiAiH/75Sf/viLUvtrUNP0id9+pkJBABAEPnvwAukq6+2Fn//XTr7bGnDBhORAAAhjoYTgPDn8ehfJXlq49n11J2tbTvogSHXGQwFAEAQsdmkvDxp6FBr/fvvpQsvlLZvN5MLABCyaDgBCHvnfvehjl/9taX27Alp+jl6P0OJAAAIQu3bS7NnS0cfba1/8IF07bVSdXXD7wMAoAE0nACEtX22b9ad702z1FZH76+8QRcZSgQAQBCLjpbeekvq0cNaf/VV6R//MJMJABCSaDgBCGvj339OPTatt9TuHzJa29t1MJQIAIAg16uXNG+e1LWrtf7gg1JBgZlMAICQQ8MJQNg64X9f6vKl71hqHyQm6d1DTjSUCACAENG/vzRrltSmjbU+dqz0zjsNvwcAgN3QcAIQljru2KZJbz9pqW1u11F3nXmDd2NUAADQtLPOkp55xlqrqpLS06WlS41EAgCEjramAwDhpM/4eaYjaNWkEaYjBIW/f/yq+rjXWmq5p1+lNdH7G0oEAEAIysyUVq6UJk3aVdu0SRoxQvrsM+/yOwAAGhBRDaf8/HwVFhbKbrfL5XJJkiZMmKCkpCQj47b0fU6nU1lZWUpPT1dKSorsdntt3eFwaObMmcrNza2tAxFryRJdt2SutdTzSL2URDMOAIAWe+ABadUqacaMXbVffpHOPtv7BLu4OGPRAADBK2IaTunp6XI6nVqwYIFiYmIkeRs1ycnJys3NVWZmZkDHbc373G63SkpKVFJS0uCYNJsASZWV0ujRauPZ9ejm7W3aavxZN8ljYxUxAAAtFhUlPf+89PPP0kcf7ap//bU0fLi0YIG0zz7G4gEAglNE/PaVn5+voqIiS3NHkux2uwoKCpSVlSWHwxGwcX2dJykpSWVlZcrOzm7x1wCEnUmTpK++spT+c/JlKo9nyj8AAK3WoYM0d6502GHW+pIl0rnnSlu2GIkFAAheEdFwysnJUUpKiqW5UyMtLa32mkCNuzd50tLSVF5eruLiYpWVlcnj8aisrGyvlwUCYeGbb6T777eW9rMrf9BFhgIBABBG4uKkd9+VEhKs9Q8+kNLSvLOMAQD4S9g3nBwOh9xud5MNmaSkJJWUlMjtdvt9XF/ksdvtSklJockE7K6qSho9Wtqxo7a00xal7LNu1s42EbN6GAAA/+rdWyopkfbbz1p/+23p8sulnTvN5AIABJ2wbzjNnDlTkhQfH9/oNXF/bXTY2N5IvhzXX3mAiPfkk9Lnn1tK+cdfpG8OONhQIAAAwtRhh0nz50t1Z+sXFUkZGVJ1dYNvAwBElrBvONU0bRpavlaj5tySJUv8Pq6/8gARzemU7rrLUiqP66n/nHSpoUAAAIS5447zzmrq0sVaf/556ZZbJI/HSCwAQPAI+3UmNcvS4pp4XGvNuZYsqWvtuL7I43A4lJeXV3vscrk0atSo2v2fWmLNmjVNnl+7dm2LxwQCyuORMjPrbVY6fvhN2t6ug6FQAABEgBNOkN54QzrrLGn79l31p56SunWTHnjAXDYAgHFh33ByuVxBde3e3qOkpEQDBw60NJycTqf69u2rzMxMS705evXiyV0IcdOmeR/HvLvrr9eSfY42kwcAgEgyeLA0e7Z0wQXW/ZsefFDaZx9p/Hhj0QAAZoX9krpwYrfbVVBQoOzs7Hr17Oxs5efnKz8/31A6wICff5Zuv91a69VLmjTJTB4AACLRiBHSK69IUXV+tZgwQXr6aTOZAADG0XAKITExMY0umxs1apQkKScnp0Vjrl69usnX4sWL9zo34BdVVdIVV0gbN1rreXneT1QBAEDgXHyxVFBQv37jjd7vzQCAiBP2S+ri4uLkdrubtZStqX2VfDWuv/LY7XZJ3n2fHA6HkpKSmvW+hISEZt8DCCq5udL771trV1zh3UcCAAAE3rXXSps2eTcN392YMdK2bfXrAICwFvYznJp6GlyNmuZPc67d23Fb+z6n06msrCwVFRXt8f1Op3OP1wAh7bPPpHvusdYOOkh64gkzeQAAgNfNN0v331+/fuutLHkHgAgT9g2nAQMGSJLKy8sbvaamQTNw4EC/j9va9+Xl5Sk/P1/p6el7zFYz2wkISxs3Spde6l1SVyMqyrt3RGysuVwAAMDrzjulf/6zfn3CBG/d4wl0IgCAAWHfcEpNTZXkXWrWmJpzje2P5MtxW/u++Ph4SVJmZmaD79l9VlNzl9MBIcfjkcaOlVatstbvuUc65RQjkQAAQB02m3TvvQ3PaPrXv7yNJ5pOABD2wr7hVNO0KSkpafC82+2W0+lscZOmteO29n1JSUnKzs5WXiObLtaM15KmGRByXnxRmj7dWjvlFOmuu8zkAQAAjcvJkR5/vH49N9e7xI6mEwCEtbBvOElSbm6unE5ng3sbzZo1S5JU0MBTNZxOp5KTk5WVleXTcVvzvpSUlEbfI3mX3MXExDR4PyAs/PijdMMN1lpMjHcpXduwf/4BAACh6ZZbpClT6tefeMI7a7m6OvCZAAABERENp+zsbKWlpSk1NdWylM3hcCgnJ0e5ubkNznDKy8uTw+FQfn6+HA6Hz8Zt7ftyc3OVlZVlmR3ldruVnJwsl8ulBQsWtGjjcyBkVFZKl10mbd5srU+d6t0sHAAABK+sLOn55717Lu4uL8/7ZLvd92UEAISNiJkWUFhYWLvptt1ul8vlktvtVmFhoVJSUhp8z6hRo1RUVCS73d7okrvWjNva99ntdhUXF9c2pVwul+Li4pSSkqLc3NyW/48ChIq77pLKyqy1jAxp5EgzeQAAQMtcdZXUsaN0+eXWBtMLL0jbt3uXzbdrZy4fAMDnbB4Pi6fRuDVr1qhXr16SpNWrVyshIcFwouDWZ/w80xG0atII0xF8a/586cwzrbXDD5dKS6UuXRp9WzD8fwEACA3B8L0zGL5vBeR/h9dek0aNknbssNbPOUeaMaPJ7+0AAP/w1+/9EbGkDkCI+v136corrbX27fmBFACAUHXhhdLcuVKHDtb6m29KgwdLv/1mJBYAwPdoOAEITtXV0tVX1//B86GHpOOOMxIJAAD4wNlnextMnTpZ60uWSCed5H1QCAAg5EXMHk4AQsxjj0lvv22tjRgh3XSTmTwAAIS5QC/rS77oX5o6+9+K3fbnrqLT6W06vfGGdOKJAc0DAPAtZjgBCD7z50vZ2dbaAQdIzz0n2WxmMgEAAJ8qSzhSaVdM1uro/a0n1q+Xhgzx7vcEAAhZNJwABJfly72biVZX76rZbNJLL0ndu5vLBQAAfK48vpcuuuJhfXnAwdYT27Z5n0b71FNmggEA9hoNJwDBo6JCOv98ye221v/5TyklxUQiAADgZ+u6xuqSSyfqPXuy9YTH411Kn51t/SAKABASaDgBCA7V1dIVV0jffWetjxwp3X23mUwAACAgtrTvpOtG3iNdd139kw89JF1+ubR9e+CDAQBajYYTgODwj394Nwjd3bHHSs8/L0XxVxUAAOGuKqqNlJ8v3Xdf/ZMzZkipqdLvvwc+GACgVfgtDoB5M2dKDz5orcXHS6+/LnXtaiYTAAAIPJvN+yHUc89Jbes8UPujj6QBA6SyMjPZAAAtQsMJgFkOh3TNNdZa27ZSUZHUp4+RSAAAwLCrr5bmzav/wdPq1dLJJ0svvmgkFgCg+Wg4ATDnt9+kCy6Qtm611v/zH+mMM0wkAgAAwWLYMO+spoQEa337dumqq6RbbpF27DCTDQCwRzScAJhRWSmlpXk/qdxdZqY0dqyZTAAAILj06yeVlkqnnVb/3BNPsK8TAAQxGk4AAq/mMccff2ytn3qq9OST3v0bAAAAJGn//aWSEu/PDnV98AH7OgFAkKLhBCDwnn3W+xSa3fXq5d23qX17M5kAAEDwatfOO6PpueekDh2s59jXCQCCEg0nAIE1d279Tyg7dfI+kW6//YxEAgAAIeLqq737OvXsaa2zrxMABB0aTgACZ8ECadQoqbraWn/uOal/fzOZAABAaBk40LuE7tRT65974gnvbKfy8sDnAgBY0HACEBiLF0vnn+/dLHx3d9/tbUIBAAA01/77ez/IuvHG+ueWLPF+kPXKK4HPBQCoRcMJgP99+6101lnS5s3WekaGdN99ZjIBAIDQ1q6d92EjDe3r9Oef0hVXSFde6f0zACDgaDgB8K9Vq7yPLHa5rPX0dO/m4TyRDgAA7I2rr5Y++UQ65JD65156yTvbacmSgMcCgEhHwwmA//z6q7fZ9Msv1vqwYdLLL0tt2pjJBQAAwktSkuRwSNdcU/9cebl00knSQw/V30cSAOA3NJwA+IfbLZ15prRihbV+4onSnDlS+/ZGYgEAgDDVtas0bZo0fbrUrZv13M6dUna2NHy4tHatmXwAEGFoOAHwvS1bpHPOkb780lo/5hhp3jypSxczuQAAQPi75BJp6VLphBPqnysulo49Vnr99YDHAoBIQ8MJgG9VVkppadKiRda63S69+64UG2smFwAAiByJidKHH0p33VV/v8g//pAuuEC69FJp3Toj8QAgEtBwAuA7VVXep8G8/ba13qOH9xPFHj3M5AIAAJGnXTvp/vulBQukAw+sf37GDOnII73/9HgCnw8AwhwNJwC+UVkpXXaZNHOmtR4bK82f753hBAAAEGiDB3uX+Z9/fv1zf/zhnel0wQXSzz8HPBoAhDMaTgD23pYt3h/iZs2y1rt0kd56Szr6aDO5AAAAJCk+XnrtNemFFxpe3v9//ycddZQ0dSqznQDAR2weD3+jonFr1qxRr169JEmrV69WQkKC4UTBrc/4eaYjBFy3bZv036L7NPDnb60n2rf3bhCekmIkVyT+fwEAAPas+6YN+lfxszr7x08aPP9R736aMPxGrYk5IMDJrFZNGmH0/gAih79+72eGE4BWi9/s1vTpd9ZvNtXMbDLUbAIAAGjMuq6xuv7COzX2/PFa1zmm3vlTf1qq+dNu0LVLXleb6qrABwSAMEHDCUCrHFjxu2a9mqOjfnda6u6OXb2bcw4daigZAADAnr19+ClKve4ZzT5qcL1znXds1z0LCzTvuZt14k/LDKQDgNBHwwlAi9nXr1Hhyznq67Jurvlb1zhdfNkk6fjjDSUDAABoPnenbrr9nNt1ddq9+mWffeudP/yPnzR9xl16eu5E9dz4u4GEABC6aDgBaJGjfl2hwley1fPPdZb6/6L3V/plufqxex8zwQAAAFrp/b4DNWz0M3q531kNnh/xwyItmDpGt3z8qjrs2B7gdAAQmmg4AWi2gau/1vTpdyp+a4Wl/mP8QUq7fLL+F9vDUDIAAIC9s6lDZ9195g1KuzxX3+xnr3e+485K/X3Rq1owdayG/7CIp9kBwB7QcALQLCnLP9dLs+5Rt8otlvrSHofo4ssn6fd94g0lAwAA8J3ShKN07lWP6c4zb5CrU7d65xMqfteUuRP1ysy7dOi6VYEPCAAhgoYTgCbZPNW6edF0TZ3zb3XcWWk598lBx+ryUQ/I3cAPYwAAAKGqOqqNXu13lgZn5On5pHNUZav/a9PJP32pt567WZPefkIHVrC/EwDURcMJQKO6bt+ivNce1G0fv1Lv3PxDTtA16f/U5g6dDSQDAADwv42d9tE/U8doxNX/0acHHVPvfFtPtS75cr7ey8/UPxYUKH6zO/AhASBI0XAC0KBE18+a++JtGrb8s3rnio4equvPH6/tbdsbSAYAABBY3++XqEsveVDXnz9eP+/Tvd75DlU7Nbr0dX2Yd51u+/Al7bN9s4GUABBcaDgBqGfIisV6/YW/62DXGku9yhalfw8erTvOvlU727Q1lA4AAMAAm01vHX6KhmY8q/+cdKm2tOtQ75IuO7bp5k9n6qMpo5X1eZE67thmICgABAcaTgBq2TzVuvGTGZo6+9/1Ngd3deqmv118n/476ELJZjOUEAAAwKxt7TrqsVMv1+mZU/V80jmqjKr/IVzMtk2a8P7z+jAvQ1c45qld1Q4DSQHALBpOACRJXbZv0bNzJ+qOj15WlKyP+f12v0Sdd9Vj+qRPPzPhAAAAgsy6rrH6Z+oYDcnMU+HRKQ1uLL7f5g26v/hZfZCXodGLX1OX7VsaGAkAwhMNJwDq4/pZr710h4b/+Gm9c68fcbouuuIhrYne30AyAACA4LYmen+NG3Grhl37tOYddnKD1xz45x/6x3v/1aIp1+q2D19S3JaNAU4JAIFHwwmIZB6PLl36jt584VYduv5/llNVtijdP/ha3XLuHdrWrqOhgAAAAKGhfN9euuGCCTrnqsf1QWJSg9fEbNukmz+dqUXPXqt/FT+rBPevAU4JAIHDrr9AhNr/zz80+e0ndPpKR71zGzruoxvPz9EiltABAAC0yNcHHKyrLr5Px//vK9328Ss6fvXX9a7ptHO7rnLM0+VfvK03jzhVU45P0/f7JRpICwD+Q8MJiDQejy749n39q3iKoht4ZO933fso46K7tSbmAAPhAAAAwsPnBx2jUZdNUtLP32nM57M1bPln9a5p66nWBd9+oAu+/UAfJCbpxaQRes8+QNVRbQwkBgDfouEERJD4zW49MP/pBvdqkqRXjztT/x6Soa3tWUIHAADgC46eRyjzort18B//U9bnc3TBt++pXXVVvetOX+nQ6SsdWtNtP73S/yzp94HSfvsZSAwAvsEeTkCEOPOHTzT/v9c32Gz6tWucrk77p+4cfhPNJgAAAD9Yse9BGjfiVp2WNVVTB5yvzY3skZlQ8btyPnhB6tVLuuIK6ZNPJI+nwWsBIJjRcALCXLdtm/TYGw8rb+6Dit9aUe/8a0eeoWGjn9H7fQcYSAcAABBZ1nbrrvuHZuiksc/pkVMu1/pO3Rq+sLJSeuUV6eSTpf79pfx8adOmwIYFgL1AwwkIUzZPtS78eqGK/3u9Lvz2/Xrn13fqpjEXTNDfz71DFR27Bj4gAABABNvYaR89efKlOnnsNI0762Z9tX/fxi9etkzKypJ69pQyMqSPPmLWE4Cgxx5OQBhKWvOd7lmYr35rlzd4/p1DT9Rdw27Q+i4xgQ0GAAAAi23tOqrw2GEqPCZVx639UVd+MU/nfPeROlTtqH9xRYU0dar3lZgo/e1v3tfBBwc+OADsAQ0nIIz03Pi7cj54Xud992GD5ys6dNE9qWM098gzJJstsOEAAADQOJtNyw48TLcfeJjuHzxaX/T6WXr2WWnlyoavX7lSuu8+7+ukk6Qrr5QuvliKjQ1sbgBoBEvqgDDQuXKrbv/wJS2YOqbRZtN79mQNu/ZpzT1qMM0mAACAILahc7Q0bpy0YoX01lvSOec0/fPbJ59IY8ZIBxwgpadLc+ZIW7YELjAANIAZTkAIs3mqNfLrhRr34Yvaf5OrwWvK43rqgcGjtbDvwIA1mvqMnxeQ+wAAAIS1qCjprLO8r9WrvZuIv/CC9P33DV9fWSkVFXlfnTt73zdypDRihNStkc3JAcBPaDgBocjj0ekrHbr9o5d07K8rGrxkY4cuevyUy/Ry/7O1o027AAcEAACAT/XqJY0fL+XkSGVl0osvStOnS3/80fD1W7ZIs2d7X+3bS6mp3ubTeedJ8fGBzQ4gItFwAkJIVHWVzvrhE439vEhH/1be4DU7bVF6uf/ZevyUy+Ru7DG7AAAACE02mzRggPf18MPSO+94m09vvOGd4dSQykpp3jzvq00bafBg6YILpLPP9m4+DgB+QMMJCAHtd+7QRV8vUNbi2UrcsLbR695PTNb9Q0Zrxb4HBTAdAAAAjGjf3jtj6bzzpA0bpFmzvK8PPpCqqhp+T1WVVFLifUnSYYftWrZ32mlSx46Byw8grNFwAoJY58qtumzp27puyVwd0MgeTZK0PL6XHhg8Wu/3HRDAdAAAAAgasbFSVpb39ccf0uuvezcPLy6Wduxo/H0//OB9Pf641KmTd/ZTTQOqb9+AxQcQfmg4AUEobstGXVX2pq5yvKGYbZsava48rqfyBo3UnKOHaGcb/nMGAACApH33lUaP9r42bpTefNO7l9Pbb0vbtjX+vq1bvU/Fe+st7/Ehh0hDhkhnnCGdfrrUo0dA4gMID/yGCgSJqOoqnbpqqdK/LNaw5Z+pffXORq/9av++euaEdL176ImqjmoTwJQAAAAIKdHR0uWXe1+bN3ubTq+/Lr37rrRuXdPvXb7c+8rL8x4feqi3+VTTgDrwQH+nBxDCaDgBhiW4f1X6VyVK+2qBev7Z9Df9Tw86Rs+ckK6P+vT3bhgJAAAANFeXLlJamvdVXe192t3bb3s3Hv/8c2+tKT/+6H3l53uPDz3U23g65RTphBO8M6L4GRXAX2g4AQZ02FmpM3/8RKO+nK+Tf/pyj9cXH3y8njkhXV/0PDwA6QAAABD2oqKkgQO9r3vukdav9+73VNOA+v33PY9R04AqKPAex8VJgwZ5m08nnOD9c2ysf78OAEGLhhMQIG2rdur41V9r+I+f6LxvP1D09s1NXr+9TTu9ecSpmjJopJZ37x2glAAAAIhI8fHSJZd4X9XV0tKl0nvvSe+/L334oVRRsecxXC5vs+qdd3bVDj9cOv54b/Opf3/p2GO9M60AhD0aToAfddm+RaetdGjY8s80pHzJHptMkvT1/n0189hUvX7kGaro2DUAKQEAAIDdREVJSUne1+23S1VV0rJl3uZTTQNq48bmjfX9997XCy94j20271K8/v2lfv12/XO//fzztQAwhoYT4GP7bt6glOWfa9jyz3TyT8vUoaqJx9D+ZWOHLnrtqMEqPDZV3+zP42cBAAAQRNq02dWAuu22XQ2oDz6QPvpI+uwzae3a5o3l8Ug//OB9zZixq37ggd7G09FHS0ce6X0dcYTUlQ9ggVBFwwnYW1u3er/Jvv++il4uVNLP3ytKnma99ePex2nWscP07qEnanvb9n4OCgAAAPjA7g2ov//d20Ras8b7M3HNq6xM2r69+WP+8ov39dZb1nrv3rsaUDWvww5jbyggBNBwAlpq61bp00+904k/+MD7DbWyUpI0oBlvX3bAISo+5HjNPfIMrYk5wK9RAQAAAL+z2aRevbyv9HRvrbJS+vLLXQ2oL77wLq3b05Pw6vrpJ+/r7bet9fh46eCDvU/Gq/tPmlFAUKDhBOzJb79JDof0ySfeJtPixbUNpubYEdVGnx50rOYfcoJKDj5ev3bb139ZAQAAgGDQvr00YID3deON3trWrdJXX3k3JP/iC+8/v/xS2rKl5eOvX+99ff55/XNxcd7mU+/eUp8+1n/27i3ts0/rvy4AzRZRDaf8/HwVFhbKbrfL5XJJkiZMmKCkpCQj4wb6fdiDmqnADof19csvLR5qU/tOej8xWfMPPUHv2wew+TcAAADQqZP3aXWDBu2qVVVJy5d7G1Bffy1984307bdSeXnLZ0PVcLm8HxIvXtzw+bi4XQ2ohASpZ89dr5rjzp1bd28AtSKm4ZSeni6n06kFCxYoJiZGkuR0OpWcnKzc3FxlZmYGdNxAvw91/PHHrs0Kf/jBu+mhwyGtW9e68f6/vbvZbdy89zj+88RpXtHheNpOpkjQhA6adpEWoDztIpsCQ63OpkBF+ApGvAPp+AaOD3UDB5R7A2Np0UXPSpxtFx2LuxZFU9FpkyJpcmKxb2iaZMqzUElb1otlDS2J8vcDEJJJPtQzg79enj+fl3+v5NHceE2/+Nb39YtvfV+fbz6bb50BAACAdfPMM9J3vjPYzvrsM+m3vx0kn9Ik1K9/PUhOPXnydK95cjLYwnDyOYZxmoT65jelO3dOt1deOX2+tTVoCwAYcS0STs1mU+12W/1+P0vSSJJpmjo4OJDjONrZ2bl0D6F5r7voctfWP/85uDNyNrGUbv/uGTa3GzekUkn60Y8G2zvvSDdv6r/+83/zqDkAAABwvT3/vPS97w22s774QnrvPel3vxskn9599/T5e+89fTIqFceD7Ve/mn7e5qb0jW8Mkk9f+9rwdvv26L5btwY9vTY28qknsMI2kiSZbTmtArt165Z2dnbU6XTGHt/Y2JBt2xOP533dRZd7Gh988IFee+01SdL777+vV199NbdrXynXlX760/m74Z730kuDZVrfeec0wfTVr46c9joJJwAAAOTgvf/+j2VXoXi++GIwwfi770rHx4Pn7713+vinPy27hgNf+cog8bS1NXg8vxmGdPPmoL0x7vHFF0lYIVdX1e5f+x5OYRgqjuOpvX4sy1IQBIrjeKjn0FVcd9Hlrq2bN+dPNt28ebrMq2UNejK9+eaguy8AAACA1fTss4Pf7W++Of74P/4h/eEPp0mo3/9e+uMfh7e//OXq6/n554Pk17wJsGeeGSSfXn55MAH6yy+fbuf/fumlwfbii5MfX3xx0Ovq+ecH/4cks5CTtU84PXz4UJJ0+/btiedsbW1JkoIgUKVSudLrLrrctfXWWxefk34hvfWW9N3vniaY3niDD1kAAABg3bzwwuC3/7S2wl//OpqE+uij0wRR+rzfX1y9z3vyZPD6V1GHGzcG/09pAip9/sIL0nPPDfZNe3zuuUEPrvQx3c7//eyzp49nt/P7NjdPHzc3aacVzNonnIIgkKSpPX7SY48fP545UTPvdRdd7to6+yVy9+7pF8u3v336/PXXBx9aAAAAACANegiNm8T8vM8/lz7++DQB9fHH0qefDhYnOrul+z79dLAq9qr717+kv/99sK2iZ54ZTUJtbp7uTx/P70u383+P227cuPjx7DZu340b0ttvSz/5ybL/x5Zq7VvbcRxLOu39M056LD33Kq+76HIX+eCDD6Yef//997PnH3744czXXbo7d6Sf/1wyzcGXxjgffZT7y375l//L/ZoAAAC4fi76nY4V8corg+0iT54MhuvFsfTnP58+nt/ieNDL6uz2t78NVu3D4P/xyZPBAlGr7sc/ln74w2XXYiZn2/pffvllbtdd+4TTySVWI1vEuYsud5F0YrBZ/OAHP5j5XAAAAADze+1/ll0DAE/lZz8bbAXzySef6PXXX8/lWjdyuQoAAAAAAADwb2vfwwnTnR0yN85nn32m3/zmN7pz546+/vWva7NAcx59+OGHWa+sX/7yl7p79+6SawTkixjHdUCc4zogznEdEOe4Dooa519++aU++eQTSdLbb7+d23WLkz2Y09bWluI4nmmY2bT5kfK67qLLXeTVV1+98Jw3Jy0rWiB3796d6d8KFBUxjuuAOMd1QJzjOiDOcR0ULc7zGkZ31toPqZu2qlsqTeLMcu7TXnfR5QAAAAAAABZt7RNOOzs7kqRerzfxnCiKJEn37t278usuuhwAAAAAAMCirX3CqVwuS5LiOJ54TnqsUqlc+XUXXQ4AAAAAAGDR1j7hlCZfgiAYezyOY0VRJMuyFnLdRZcDAAAAAABYtLVPOEmS53mKoigbcnbW4eGhJOng4GDkWBRFKpVKcl031+suuhwAAAAAAMAiXYuEU61WU6VSUblcHhqSFoah6vW6PM8b2zPI932FYahms6kwDHO77qLLAQAAAAAALNLmsiuwKK1WS81mU47jyDRNnZycKI5jtVot2bY9tszu7q7a7bZM05yYyJnnussoBwAAAAAAsCgbSZIky64EAAAAAAAA1se1GFIHAAAAAACAxSHhBAAAAAAAgFyRcAIAAAAAAECuSDgBAAAAAAAgVyScAAAAAAAAkCsSTgAAAAAAAMgVCScAAAAAAADkioQTAAAAAAAAckXCCQAAAAAAALnaXHYFgHlFUSTP83R0dKStrS1JkuM4qlarE8s0m021Wi2ZpqmTkxNJ0t7enizLWkidgctot9t6+PChJCmOY0mS67qqVCpTyxHnWDVhGMpxHHW7XRmGceH588YwsY9lumycNxoNdTqd7HeMZVnEOVbeZeN8nFKppIODg6kxS5xjmeaJc9qmEyRAAfm+nxiGkbRaraH9tVot8X1/bJlKpZJYlpX0+/1sX6/XSwzDmFgGWJZKpTISl/1+P7FtO6lUKlPLEedYFd1uN6lWq4mkRNJQXE4ybwwT+1iWy8Z5+ll+9jdMt9tNTNNMJCW1Wm1iWeIcyzLP5/k4tVotkZR0u92J5xDnWJZ545y26WQknFA4vu8nkpJOpzO0v9PpJIZhJJZlTSwz7kOj1Wpd+MUHLJLneYnneROPm6Y59ouIOMeq8DwvsSwrqVar2WfzLD/c5o1hYh/LMG+c27Y98hsmSQaJqPQa5xstSUKcYznmjfNxut1u1pCfFKvEOZbhaeKctul0JJxQKL1eL5E0toeH53mJpMQ0zZFjhmEktm1PvK6kqceBRTJNM+n1ehOPe543Nl6Jc6yqWX+4zRvDxD5WwSxx3u12p8Zi2vvDMIyx1yfOsWxPk3CybTuxLGtqY5o4xyqYNc5pm16MScNRKK7rShqMbT2vVqvJ9311Op2h/WEYKo7jqWNhLctSEATZPDnAMkVRpDAMJx43DCMb550izlF088YwsY8iCYJAQRCoXC6PPZ7uj+NYURRl+4lzFF29Xle9Xs/mthmHOEfR0Da9GAknFEYURQqCQJImvkGr1apM0xzal066fPv27YnXTr/80usDy/bgwYOJSadOpyPbtof2EecounljmNhHkfR6PUmDWBz3GX/2N8zZ48Q5iiyKIsVxPPLb5TziHEVC23Q2JJxQGO12W9LpGzqKouxuybQ3Y3ps2goD6bHHjx/nU1ngKVQqFcVxrFKppHq9PnQsvTt+/k4KcY6imzeGiX0Uieu6Mk1TlUplbAPl7N3sszFNnKPIXNeV7/sXnkeco0hom86GhBMKI33DbW1tKQgC+b4v13W1t7enMAx169atsXcL0x9v07rwpsfWodsiiu/g4CD7omk0Gtre3lYQBGo2m6rX6zo+Ph75kiLOUXTzxjCxjyKxLEu9Xk+tVmvs8aOjo+z5zs5O9pw4R1E1Go2Rm2eTEOcoEtqms9lcdgWAWZ2dy6DT6cjzvOzvWq2mTz/9VKVSSd1ud+iu4fm5bqa5zLnAVTEMQ8fHx3IcR0EQKIoilctlmaapbrc79o4IcY6imzeGiX2sk7QXSLVaHfqsJ85RRFEUqdfrqVarzXQ+cY4ioW06G3o4oTDSDG8QBNkEbWel+x48eLDIagFXwjAMlcvloS+oKIr0xhtvrMV4bgDAsHa7rTAMZZrmUMMFKCrXdYllrC3aprMh4YTCSO/0maY5Mvlaul8aTLI5bYUvYNWl8zdJUrfbVb/fV6VSyY6Vy+Vs3DgAoPjiONaDBw9kGIY6nc7UuT2AIkiH0hHLWFe0TWdDwgmFkY5lHfeGTqVv/LNzIKTlZumSOG0sLbAo9+/fl23bWRd0wzDUarWGGiHn75YQ5yi6eWOY2Mc6cBxH0uAmw7jfOcQ5iiQdSnfRqnTnEecoEtqmsyHhhMKY9mZOpW/Kbreb7Zvlzkr6hucuDJat2WwqiqKxXdBt29bx8bEsy1Icx2o2m9kx4hxFN28ME/soukajoaOjo4nJJok4R7HMO5SOOEeR0DadDQknFEY6xGia9M25vb2d7UtXeen1ehPLpZO+3bt372mqCDy1Tqcz9Y6gYRh69OiRpOEvL+IcRTdvDBP7KLJmsynf93V8fDy18UKcoyjCMNTR0ZFKpZK2t7dHtnQeyvv372f7UsQ5ioS26WxIOKEw0kb42S6Jk5ydaLlcLkuavqxkeiydJwdYliiKLuw+axiGTNMc+vIizlF088YwsY+iSpfRHrf6aLvdHloggjhHUViWpX6/r16vN3ZLY/3Ro0fZvhRxjiKhbTobEk4oDNM0s6FE496gURQpjmMZhjHUQyR9o05a2SuOY0VRNPRBACyLbdszrUIXRRFxjrUybwwT+yiiMAxVr9f16NGjsUMmHj9+PNTjiTjHdUCco0hom86GhBMKJR0Pfnh4OHIsXbXr4OBgbLkoirLuiWel1xpXDlg013UVRdHQ/EznNZtNVSqVkS8i4hxFN28ME/soknRFujQm08ZK2sgIw1DtdntkiB1xjnUyacJk4hxFQtt0BglQMJ7nJZKSTqeT7et0OomkpFarTSxXqVQS0zSTfr+f7et2u4lhGInneVdZZeBSOp3O2Ljs9/tJrVZLbNueWJY4x6rp9XqJpJHP7UnmjWFiH8s0a5z3+/3ENM3s3EmbaZpjyxPnWKbLfp6f1+/3s/K+7088jzjHMl02zmmbTreRJEmyyAQXkIcgCOR5XnZ3xDRNua574fKrzWZTrVZLpmnq5OREcRyrXq9fetlW4KrFcaz9/f2su206r5PruheO5ybOsWztdlv7+/uK43jkLvbW1pYMw9Du7q5qtdrY8vPGMLGPRZonzuv1uhqNxoXXtm1bnU5n7DHiHIv0tJ/n0mAlRt/3h8rHcSzTNGUYxtAiKCniHIv0tHFO23QyEk4AAAAAAADIFXM4AQAAAAAAIFcknAAAAAAAAJArEk4AAAAAAADIFQknAAAAAAAA5IqEEwAAAAAAAHJFwgkAAAAAAAC5IuEEAAAAAACAXJFwAgAAAAAAQK5IOAEAAAAAACBXJJwAAAAAAACQKxJOAAAAAAAAyBUJJwAAAAAAAOSKhBMAAAAAAAByRcIJAAAAAAAAudpcdgUAAABwder1uqIoUhRFkiTXdVWtVpdcKwAAsO5IOAEAAKypcrksz/NkWZYkKQgClctldTodtVqtJdcOAACsM4bUAQAArKFGoyHXdbNkkyTZtq1araZ2u612u73E2gEAgHVHwgkAAGANdTodOY6jOI6H9u/u7mbHAQAArgoJJwAAgDVkWZYMwxjZn+5L53QCAAC4CiScAAAA1pDneer3+yNJpyAIJA3mdwIAALgqG0mSJMuuBAAAABZje3tbktTr9ZZcEwAAsM7o4QQAAHBNOI4jwzDU7XaXXRUAALDmNpddAQAAAFw9x3EkiWQTAABYCHo4AQAArDnHcVQul9VqtbJ96VxOAAAAV4GEEwAAwBpzHEd7e3uqVqvZvjiOh5JPAAAAeWNIHQAAwApqNpvqdrsKgkCmacr3fZmmObVMGIaSJMuyJEmlUkmStL+/P3ReFEXa3d29gloDAAAMkHACAABYMWEYqtfryfd9hWGoUqmkUqmk4+NjGYYxtkwURdrf3896LjmOkyWg0sezPM+7svoDAABsJEmSLLsSAAAAmMxxHLXbbdVqtbGJojiO5TiOOp3OEmoHAAAwioQTAADAikt7ORmGoX6/P3QsTTa1Wq2JvZ8AAAAWjUnDAQAAVpxlWTJNU3Ecj6wu5ziOfN8n2QQAAFYKCScAAIACqFQqkjS0upzjOPI878LJxAEAABaNIXUAAAAFEEWRtre3s2F1ruuqXC5niajzHMdRFEXZhOG2bY+cY5qm6vX6hQmrIAjk+77iOJZhGNmj67pjrytJruvq6Ogoe/1OpzPx3FSz2ZTrupIGvbp2d3dVq9WmlgEAAKuJhBMAAEBBbG9vK4oiVSoVlctlVavVC8tsbGyMnftJkur1uhqNhlqt1tjEVRzHevDggaIoUqvVGkpMRVEkx3G0s7Mjz/MmDukrlUqK41imaV44qbnrujo8PNTOzg4ToAMAUHAMqQMAACiIs0mhWZJNkmQYhra2tsYeS4fjOY6jOI5HjpdKJUVRpG63O9ILyjRNdbtdHR0d6f79+xNff2trS67rKggCRVE08bwwDFUul7M6AwCAYiPhBAAAUBDb29uSNDVxc1npMLfDw8Oh/a7rZj2bpjk4OFAYhqrX6xPPSZNjvu9PPOfhw4cThwcCAIDiIeEEAABQAFEUZcPMwjAc2yNpHicnJ5I0Mlyu2WzKtu0L53eyLEuWZanRaEysk2EYqlQqajabY4/Hcazbt2/P9w8AAAAriYQTAADAiovjWK7rDs21dL5H0ryCIJBpmkMTerfbbUmaefW7nZ2dC+u0t7enOI6za5/VbDbp3QQAwJoh4QQAALDC4jiW4zjZ0Lbd3V1J04enzSIMQ5VKpbGTefd6PUmDOZxmkQ71S8uNY1mWTNMcW+9erzdzcgsAABTD5rIrAAAAgMkcx5Hv+9lE2mlPoHRY3SwTbEdRJNd1h/Ztb2/L87yhnk1P66Jhca7rql6vK4qiLMF0drJwAACwPkg4AQAArCjHcbKV5M6qVCpqt9tqNpuq1WozXesyPaJm6bF0VnreRb2UqtWq6vW6fN+X53mSBpOFp88BAMD6YEgdAADACnJdV7u7u7Isa+wxSdrf37+S1057UQVBMNP56XkX9ZY6P3l4XhOfAwCA1UPCCQAAYMU0Gg2VSqWJE2nbti3LshTHsRqNhqRB0id9/rRM05TneQrDUGEYZvvDMFSj0RjZF0WRarXaTMP70snDgyDQ4eHhyFA/AACwHkg4AQAArBjDMFStVqee8+jRI1UqFfm+L8dx1Ol0Zh5eN4tarSbLsvTgwQNJg95Ivu+rWq0qCIIs6eQ4jmzbnnlYXDp5uOd56na7TBYOAMCa2kiSJFl2JQAAAHA1bt26pTiONe9PPtd1dXR0pL29PUmnw+3K5bJOTk5kmma2gt44GxsbI6vQNRoN1et1tVqtkV5cGxsbsm17ZOU8AABQLCScAAAA1lCaKEp7IqU9i6YlhyYJgkC+7ysMw2xOqSAItLe3N9SrKgiCbB4n13V1eHiYraRn23b22nEc6/79++p2u1lZx3EURZHCMJRhGNrZ2VG5XM611xYAAFgcEk4AAAC4tGazKd/3R5JG8yS0AADA+mEOJwAAAFyabdsKw1DNZlNRFMlxHN27d2/Z1QIAACuCHk4AAACYy/b2tqIoyv4+P1cTAAC4vujhBAAAgLm0Wi2ZppnNDUWyCQAApOjhBAAAAAAAgFzRwwkAAAAAAAC5IuEEAAAAAACAXJFwAgAAAAAAQK5IOAEAAAAAACBXJJwAAAAAAACQKxJOAAAAAAAAyBUJJwAAAAAAAOSKhBMAAAAAAAByRcIJAAAAAAAAuSLhBAAAAAAAgFyRcAIAAAAAAECuSDgBAAAAAAAgVyScAAAAAAAAkCsSTgAAAAAAAMgVCScAAAAAAADkioQTAAAAAAAAckXCCQAAAAAAALki4QQAAAAAAIBckXACAAAAAABArv4fvYd93A6Z6hgAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -134,7 +134,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 5,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -162,25 +162,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 6,
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "[104.40352594092553,\n",
-       " 155.07906291802087,\n",
-       " 237.6050907005531,\n",
-       " 321.1802315690494,\n",
-       " 453.91883059344593,\n",
-       " 532.2020743464961,\n",
-       " 668.8676381448771,\n",
-       " 778.871790671511,\n",
-       " 879.1335454783574,\n",
-       " 958.1304630578486]"
+       "[87.78255069969191,\n",
+       " 331.1434148092645,\n",
+       " 597.0572437276523,\n",
+       " 818.2823065152768,\n",
+       " 1019.7557437855078,\n",
+       " 1238.2373287958894,\n",
+       " 1447.9053653550432,\n",
+       " 1614.2638559620054,\n",
+       " 1987.8668888677041,\n",
+       " 2099.817218897284]"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     }
@@ -191,12 +191,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -208,6 +208,7 @@
    "source": [
     "fig, ax = plt.subplots(figsize=(6, 3.5))\n",
     "ax.errorbar(np.arange(10), zs_mean, yerr=zs_std, fmt='.', capsize=3)\n",
+    "ax.axhline(130, color='red', linestyle='--')\n",
     "ax.set_xlabel(r'Number of modes dropped')\n",
     "ax.set_ylabel(r'$\\chi^2_{{\\rm PQM}}$')\n",
     "plt.tight_layout()\n",
@@ -238,12 +239,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 9,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -266,7 +267,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 38,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -282,24 +283,21 @@
     "\n",
     "for n_modes in range(10):\n",
     "    gmm_short = GaussianMixtureModel(num_components=20 - n_modes, num_dims=100, means=means[n_modes:], variances=variances[n_modes:], weights=weights[n_modes:])\n",
-    "    p_val = []\n",
     "    x_samples = gmm.generate_samples(num_samples=5000)\n",
     "    y_samples = gmm_short.generate_samples(num_samples=5000)\n",
-    "    for i in range(20):\n",
-    "        pval = pqm_pvalue(x_samples, y_samples, device = device)\n",
-    "        p_val.append(pval)\n",
-    "    p_value_mean.append(np.median(p_val))\n",
-    "    p_value_std.append(np.std(p_val))"
+    "    pval = np.array(pqm_pvalue(x_samples, y_samples, device = device, re_tessellation=20))\n",
+    "    p_value_mean.append(np.log(np.median(pval)+1e-300))\n",
+    "    p_value_std.append(np.std(np.log(pval+1e-300)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 39,
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x700 with 1 Axes>"
       ]
@@ -310,19 +308,25 @@
    ],
    "source": [
     "fig, ax = plt.subplots(figsize=(6, 3.5))\n",
-    "ax.plot(np.arange(10), p_value_mean, 'o')\n",
-    "ax.axhline(0, color='red', linestyle='--')\n",
+    "ax.errorbar(np.arange(10), p_value_mean, yerr=p_value_std, fmt='.', capsize=3)\n",
+    "ax.axhline(np.log(1e-3), color='red', linestyle='--')\n",
     "ax.set_xlabel(r'Number of modes dropped')\n",
-    "ax.set_ylabel('p value')  # Modified ylabel\n",
-    "ax.set_yscale('log')\n",
+    "ax.set_ylabel('log(p value)')  # Modified ylabel\n",
     "plt.tight_layout()  # Increase the padding\n",
     "plt.show()"
    ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": []
   }
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "tarp_project",
+   "display_name": "PY39",
    "language": "python",
    "name": "python3"
   },
@@ -336,7 +340,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,
diff --git a/notebooks/time_series.ipynb b/notebooks/time_series.ipynb
index d1c5721..42a92bc 100644
--- a/notebooks/time_series.ipynb
+++ b/notebooks/time_series.ipynb
@@ -46,33 +46,33 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "metadata": {},
    "outputs": [
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "0.01 101.8060834988602 15.554635843895161\n",
-      "0.012742749857031334 96.62637052804726 9.04051050274939\n",
-      "0.016237767391887217 103.28695687492157 11.510920281637269\n",
-      "0.0206913808111479 94.16428784194059 11.768393286322361\n",
-      "0.026366508987303583 112.29198621843746 14.691044275525506\n",
-      "0.03359818286283781 100.87985806702318 13.884186295195038\n",
-      "0.04281332398719394 101.49725971020106 9.230807135126653\n",
-      "0.0545559478116852 108.52242969836146 17.625619037048622\n",
-      "0.06951927961775606 145.3931397287824 18.36138467817544\n",
-      "0.08858667904100823 146.13284001555863 17.3142561268065\n",
-      "0.11288378916846889 183.96552333522732 26.665437564894663\n",
-      "0.14384498882876628 248.31221263317548 41.17426910059236\n",
-      "0.18329807108324356 327.65017950264973 58.460721956784184\n",
-      "0.23357214690901212 399.49488693891226 71.39231046792266\n",
-      "0.29763514416313175 610.3408232462023 114.15715787490471\n",
-      "0.37926901907322497 1049.7187715149266 181.15009814135186\n",
-      "0.4832930238571752 1321.019438955153 220.96517845787312\n",
-      "0.615848211066026 1968.1711814925984 317.09494447136774\n",
-      "0.7847599703514611 2668.896700287143 369.33351522285284\n",
-      "1.0 3535.788188607212 402.6737212006869\n"
+      "0.01 100.89581280536342 13.021347343248523\n",
+      "0.012742749857031334 99.29338082170935 16.772287181292945\n",
+      "0.016237767391887217 106.65897087831716 12.865500803669983\n",
+      "0.0206913808111479 94.2445056547761 15.92235404770378\n",
+      "0.026366508987303583 108.89551895493938 14.687380638385607\n",
+      "0.03359818286283781 106.17132451779497 14.056129603801027\n",
+      "0.04281332398719394 111.66719296709199 17.286369725396344\n",
+      "0.0545559478116852 125.0756779465738 17.747082656143277\n",
+      "0.06951927961775606 137.35343190699854 21.896890224880973\n",
+      "0.08858667904100823 144.27641381633964 18.790715313373536\n",
+      "0.11288378916846889 196.80318344023084 22.390201281451322\n",
+      "0.14384498882876628 259.55485825330106 27.88974850365713\n",
+      "0.18329807108324356 363.3671243837876 67.4927129505813\n",
+      "0.23357214690901212 628.0253101750119 99.54363119973272\n",
+      "0.29763514416313175 1032.2089653985397 143.63567443520492\n",
+      "0.37926901907322497 1841.018792367092 207.64443330291348\n",
+      "0.4832930238571752 3299.3509311386283 327.8315178073717\n",
+      "0.615848211066026 5731.8400170353925 427.242415784251\n",
+      "0.7847599703514611 7937.442462455868 319.3178233896011\n",
+      "1.0 9777.72168884108 164.5663628004715\n"
      ]
     }
    ],
@@ -89,9 +89,8 @@
     "    null_samples = gmm_null.generate_samples(num_samples=5000)\n",
     "    y_samples = gmm.generate_samples(num_samples=5000)\n",
     "    zs = []\n",
-    "    for _ in range(num_repeats):\n",
-    "        z = pqm_chi2(y_samples, null_samples, device = device)\n",
-    "        zs.append(z)\n",
+    "    z = pqm_chi2(y_samples, null_samples, device = device, re_tessellation=num_repeats)\n",
+    "    zs += z\n",
     "        \n",
     "    chisqs_mean[i] = np.median(zs)\n",
     "    chisqs_std[i] = np.std(zs)\n",
@@ -105,7 +104,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -136,7 +135,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x400 with 2 Axes>"
       ]
@@ -177,7 +176,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "metadata": {},
    "outputs": [],
    "source": [
@@ -193,9 +192,8 @@
     "    null_samples = gmm_null.generate_samples(num_samples=5000)\n",
     "    y_samples = gmm.generate_samples(num_samples=5000)\n",
     "    p_val = []\n",
-    "    for _ in range(num_repeats):\n",
-    "        pval = pqm_pvalue(y_samples, null_samples, device = device)\n",
-    "        p_val.append(pval)\n",
+    "    pval = pqm_pvalue(y_samples, null_samples, device = device, re_tessellation=num_repeats)\n",
+    "    p_val += pval\n",
     "    p_val_mean[i] = np.median(p_val)\n",
     "    p_val_std[i] = np.std(p_val)"
    ]
@@ -207,7 +205,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 1200x600 with 1 Axes>"
       ]
@@ -235,7 +233,7 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "tarp_project",
+   "display_name": "PY39",
    "language": "python",
    "name": "python3"
   },
@@ -249,7 +247,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.18"
+   "version": "3.9.5"
   }
  },
  "nbformat": 4,