From ac5b27ffb278142e19edcfc05fbdd862423fd87c Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Mon, 6 Mar 2023 15:22:28 +0100
Subject: [PATCH 01/23] Added single-objective JES with MO-specific computation
 removed - variable names consistent with MES/GIBBON. Input constructors for
 JES & JES-exploit added, as well as optimizer of pathwise posterior samples &
 utility method for retrieving optima.

---
 botorch/acquisition/input_constructors.py     |  35 ++
 botorch/acquisition/joint_entropy_search.py   | 321 +++++++++++++++---
 botorch/acquisition/utils.py                  |  41 ++-
 botorch/utils/sampling.py                     |  68 ++++
 test/acquisition/test_input_constructors.py   |  29 ++
 test/acquisition/test_joint_entropy_search.py |  19 +-
 test/acquisition/test_utils.py                |  34 ++
 test/utils/test_sampling.py                   |  43 ++-
 ...tion_theoretic_acquisition_functions.ipynb |  74 +---
 9 files changed, 553 insertions(+), 111 deletions(-)

diff --git a/botorch/acquisition/input_constructors.py b/botorch/acquisition/input_constructors.py
index 40ec325fe9..2814984539 100644
--- a/botorch/acquisition/input_constructors.py
+++ b/botorch/acquisition/input_constructors.py
@@ -47,6 +47,7 @@
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
 )
+from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.max_value_entropy_search import (
     qMaxValueEntropy,
     qMultiFidelityMaxValueEntropy,
@@ -84,6 +85,7 @@
     expand_trace_observations,
     project_to_target_fidelity,
 )
+from botorch.acquisition.utils import get_optimal_samples
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models.cost import AffineFidelityCostModel
 from botorch.models.deterministic import FixedSingleSampleModel
@@ -1239,3 +1241,36 @@ def optimize_objective(
         return_best_only=True,
         sequential=sequential,
     )
+
+
+# TODO make single-objective with pairwise and multi-objective with pareto
+@acqf_input_constructor(qJointEntropySearch)
+def construct_inputs_qJES(
+    model: Model,
+    training_data: MaybeDict[SupervisedDataset],
+    bounds: Tensor,
+    num_optima: int = 64,
+    maximize: bool = True,
+    condition_noiseless: bool = True,
+    X_pending: Optional[Tensor] = None,
+    estimation_type: str = "LB",
+    num_samples: int = 64,
+    **kwargs: Any,
+):
+    dtype = model.train_targets.dtype
+    optimal_inputs, optimal_outputs = get_optimal_samples(
+        model, Tensor(bounds).to(dtype).T, num_optima=num_optima, maximize=maximize
+    )
+
+    inputs = {
+        "model": model,
+        "optimal_inputs": optimal_inputs,
+        "optimal_outputs": optimal_outputs,
+        "condition_noiseless": condition_noiseless,
+        "maximize": maximize,
+        "X_pending": X_pending,
+        "estimation_type": estimation_type,
+        "num_samples": num_samples,
+        **kwargs,
+    }
+    return inputs
diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index ca46933076..4fd11595ad 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -13,17 +13,46 @@
 from __future__ import annotations
 
 from typing import Any, Optional
+import warnings
+from math import pi
+import torch.distributions as dist
 
-from botorch.acquisition.multi_objective.joint_entropy_search import (
-    qLowerBoundMultiObjectiveJointEntropySearch,
-)
-from botorch.acquisition.multi_objective.utils import compute_sample_box_decomposition
+import torch
+from torch import Tensor
+
+from torch.distributions import Normal
+
+from botorch.models.utils import check_no_nans
+from botorch import settings
+from botorch.models.utils import fantasize as fantasize_flag
 from botorch.models.model import Model
+from botorch.models.gp_regression import MIN_INFERRED_NOISE_LEVEL
 from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
-from torch import Tensor
+from botorch.acquisition.monte_carlo import MCAcquisitionFunction
+from botorch.acquisition.acquisition import AcquisitionFunction, MCSamplerMixin
+from botorch.sampling.normal import SobolQMCNormalSampler
+from botorch.utils.transforms import is_fully_bayesian
+from botorch.exceptions.warnings import BotorchTensorDimensionWarning
 
+MCMC_DIM = -3  # Only relevant if you do Fully Bayesian GPs.
+ESTIMATION_TYPES = ["MC", "LB"]
+"""
+References
+.. [Hvarfner2022joint]
+    C. Hvarfner, F. Hutter, L. Nardi,
+    Joint Entropy Search for Maximally-informed Bayesian Optimization. 
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
 
-class qLowerBoundJointEntropySearch(qLowerBoundMultiObjectiveJointEntropySearch):
+.. [Tu2022joint]
+    B. Tu, A. Gandy, N. Kantas, B. Shafei,
+    Joint Entropy Search for Multi-objective Bayesian Optimization. 
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
+"""
+
+
+class qJointEntropySearch(AcquisitionFunction, MCSamplerMixin):
     r"""The acquisition function for the Joint Entropy Search, where the batches
     `q > 1` are supported through the lower bound formulation.
 
@@ -31,14 +60,6 @@ class qLowerBoundJointEntropySearch(qLowerBoundMultiObjectiveJointEntropySearch)
     at a candidate point `X` and the optimal input-output pair.
 
     See [Tu2022]_ for a discussion on the estimation procedure.
-
-    NOTES:
-    (i) The estimated acquisition value could be negative.
-
-    (ii) The lower bound batch acquisition function might not be monotone in the
-    sense that adding more elements to the batch does not necessarily increase the
-    acquisition value. Specifically, the acquisition value can become smaller when
-    more inputs are added.
     """
 
     def __init__(
@@ -46,11 +67,12 @@ def __init__(
         model: Model,
         optimal_inputs: Tensor,
         optimal_outputs: Tensor,
-        maximize: bool = True,
-        hypercell_bounds: Tensor = None,
+        condition_noiseless: bool = True,
+        posterior_transform: Optional[PosteriorTransform] = None,
         X_pending: Optional[Tensor] = None,
         estimation_type: str = "LB",
-        num_samples: int = 64,
+        maximize: bool = True,
+        num_samples: int = 256,
         **kwargs: Any,
     ) -> None:
         r"""Joint entropy search acquisition function.
@@ -62,42 +84,196 @@ def __init__(
                 sample only contains one optimal set of inputs.
             optimal_outputs: A `num_samples x 1`-dim Tensor containing the optimal
                 set of objectives of dimension `1`.
+            condition_noiseless: Whether to condition on noiseless optimal observations
+                f* [Hvarfner et. al.]or noisy optimal observations y* [Tu et. al,].
+                These are sampled identically, so this only controls the fashion in
+                which the GP is reshaped as a result of conditioning on the optimum.
+            posterior_transform: A PosteriorTransform (optional).
+            estimation_type: estimation_type: A string to determine which entropy
+                estimate is computed: Lower bound" ("LB") or "Monte Carlo" ("MC").
+                Lower Bound is recommended due to the relatively high variance
+                of the MC estimator.
             maximize: If true, we consider a maximization problem.
-            hypercell_bounds:  A `num_samples x 2 x J x 1`-dim Tensor containing the
-                hyper-rectangle bounds for integration, where `J` is the number of
-                hyper-rectangles. By default, the problem is assumed to be
-                unconstrained and therefore the region of integration for a sample
-                `(x*, y*)` is a `J=1` hyper-rectangle of the form  `(-infty, y^*]`
-                for a maximization problem and `[y^*, +infty)` for a minimization
-                problem. In the constrained setting, the region of integration also
-                includes the infeasible space.
             X_pending: A `m x d`-dim Tensor of `m` design points that have been
-                submitted for function evaluation, but have not yet been evaluated.
-            estimation_type: A string to determine which entropy estimate is
-                computed: "0", "LB", "LB2", or "MC". In the single-objective
-                setting, "LB" is equivalent to "LB2".
+                submitted for function evaluation, but have not yet been evaluated
             num_samples: The number of Monte Carlo samples used for the Monte Carlo
                 estimate.
         """
-        if hypercell_bounds is None:
-            hypercell_bounds = compute_sample_box_decomposition(
-                pareto_fronts=optimal_outputs.unsqueeze(-2), maximize=maximize
-            )
+        super().__init__(model=model)
+        sampler = SobolQMCNormalSampler(sample_shape=torch.Size([num_samples]))
+        MCSamplerMixin.__init__(self, sampler=sampler)
+        # To enable fully bayesian GP conditioning, we need to unsqueeze
+        # to get num_optima x num_gps unique GPs
 
-        super().__init__(
-            model=model,
-            pareto_sets=optimal_inputs.unsqueeze(-2),
-            pareto_fronts=optimal_outputs.unsqueeze(-2),
-            hypercell_bounds=hypercell_bounds,
-            X_pending=X_pending,
-            estimation_type=estimation_type,
-            num_samples=num_samples,
-        )
+        # inputs come as num_optima_per_model x (num_models) x d
+        # but we want it four-dimensional in the Fully bayesian case,
+        # and three-dimensional otherwise.
+        self.optimal_inputs = optimal_inputs.unsqueeze(-2)
+        self.optimal_outputs = optimal_outputs.unsqueeze(-2)
+        self.posterior_transform = posterior_transform
+        self.maximize = maximize
+
+        # The optima (can be maxima, can be minima) come in as the largest
+        # values if we optimize, or the smallest (likely substantially negative)
+        # if we minimize. Inside the acquisition function, however, we always
+        # want to consider MAX-values. As such, we need to flip them if
+        # we want to minimize.
+        if not self.maximize:
+            optimal_outputs = (-1) * optimal_outputs
+        self.num_samples = optimal_inputs.shape[0]
+        self.condition_noiseless = condition_noiseless
+        self.initial_model = model
+        tkwargs = {"dtype": optimal_outputs.dtype, "device": optimal_outputs.device}
+
+        # Here, the optimal inputs have shapes num_optima x [num_models if FB] x 1 x D
+        # and the optimal outputs have shapes num_optima x [num_models if FB] x 1 x 1
+        # The third dimension equaling 1 is required to get one optimum per model,
+        # which raises a BotorchTensorDimensionWarning.
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            with fantasize_flag():
+                with settings.propagate_grads(False):
+                    post_ps = self.initial_model.posterior(
+                        self.model.train_inputs[0], observation_noise=False
+                    )
+                    sample_idx = 0
+
+                # This equates to the JES version proposed by Hvarfner et. al.
+                if self.condition_noiseless:
+                    opt_noise = torch.full_like(
+                        self.optimal_outputs, MIN_INFERRED_NOISE_LEVEL)
+                    # conditional (batch) model of shape (num_models) x num_optima_per_model
+                else:
+                    opt_noise = None
+
+                self.conditional_model = self.initial_model.condition_on_observations(
+                    X=self.initial_model.transform_inputs(self.optimal_inputs),
+                    Y=self.optimal_outputs,
+                    noise=opt_noise,
+                )
+
+        self.estimation_type = estimation_type
+        self.set_X_pending(X_pending)
 
     @concatenate_pending_points
     @t_batch_mode_transform()
     def forward(self, X: Tensor) -> Tensor:
         r"""Evaluates qLowerBoundJointEntropySearch at the design points `X`.
+        Args:
+            X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
+            `d`-dim design points each.
+
+        Returns:
+            A `batch_shape`-dim Tensor of acquisition values at the given design
+            points `X`.
+        """
+        if self.estimation_type == "LB":
+            res = self._compute_lower_bound_information_gain(X)
+        elif self.estimation_type == "MC":
+            res = self._compute_monte_carlo_information_gain(X)
+        else:
+            raise ValueError(
+                f"Estimation type {self.estimation_type} is not valid."
+                f"Please specify any of {ESTIMATION_TYPES}"
+            )
+        return res
+
+    def _compute_lower_bound_information_gain(
+        self, X: Tensor, return_parts: bool = False
+    ) -> Tensor:
+        r"""Evaluates the lower bound information gain at the design points `X`.
+
+        Args:
+            X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
+            `d`-dim design points each.
+
+        Returns:
+            A `batch_shape`-dim Tensor of acquisition values at the given design
+            points `X`.
+        """
+        tkwargs = {
+            "dtype": self.optimal_outputs.dtype,
+            "device": self.optimal_outputs.device,
+        }
+        initial_posterior = self.initial_model.posterior(X, observation_noise=True)
+        # need to check if there is a two-dimensional batch shape -
+        # the sampled optima appear in the dimension right after
+        batch_shape = X.shape[:-2]
+        sample_dim = len(batch_shape)
+        # We DISREGARD the additional constant term.
+        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+
+        # initial_entropy of shape batch_size or batch_size x num_models if FBGP
+        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        initial_entropy = (
+            initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
+        )
+
+        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
+        # Compute the mixture mean and variance
+        posterior_m = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=True
+        )
+        noiseless_var = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=False
+        ).variance
+
+        mean_m = posterior_m.mean
+        if not self.maximize:
+            mean_m = -mean_m
+        variance_m = posterior_m.variance
+
+        check_no_nans(variance_m)
+        # get stdv of noiseless variance
+        stdv = noiseless_var.sqrt()
+        # batch_shape x 1
+        normal = torch.distributions.Normal(
+            torch.zeros(1, device=X.device, dtype=X.dtype),
+            torch.ones(1, device=X.device, dtype=X.dtype),
+        )
+        normalized_mvs = (self.optimal_outputs - mean_m) / stdv
+        cdf_mvs = normal.cdf(normalized_mvs).clamp_min(CLAMP_LB)
+        pdf_mvs = torch.exp(normal.log_prob(normalized_mvs))
+
+        ratio = pdf_mvs / cdf_mvs
+        var_truncated = noiseless_var * (
+            1 - (normalized_mvs + ratio) * ratio
+        ).clamp_min(CLAMP_LB)
+
+        var_truncated = var_truncated + (variance_m - noiseless_var)
+        conditional_entropy = 0.5 * torch.log(var_truncated)
+
+        # Shape batch_size x num_optima x [num_models if FB] x q x num_outputs
+        # squeeze the num_outputs dim (since it's 1)
+        entropy_reduction = (
+            initial_entropy - conditional_entropy.sum(dim=-2, keepdim=True)
+        ).squeeze(-1)
+        # average over the number of optima and squeeze the q-batch
+
+        entropy_reduction = entropy_reduction.mean(dim=sample_dim).squeeze(-1)
+        return entropy_reduction
+
+    def _compute_monte_carlo_variables(self, posterior):
+        """Retrieved the monte carlo samples  and their log probabilities from the posterior.
+
+        Args:
+            posterior: The posterior distribution.
+
+        Returns:
+            A two-element tuple containing:
+            - samples: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of samples drawn from the posterior.
+            - samples_log_prob: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of associated probabilities.
+        """
+        samples = self.get_posterior_samples(posterior)
+        samples_log_prob = (
+            posterior.mvn.log_prob(samples.squeeze(-1)).unsqueeze(-1).unsqueeze(-1)
+        )
+        return samples, samples_log_prob
+
+    def _compute_monte_carlo_information_gain(
+        self, X: Tensor, return_parts: bool = False
+    ) -> Tensor:
+        r"""Evaluates the lower bound information gain at the design points `X`.
 
         Args:
             X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
@@ -107,5 +283,64 @@ def forward(self, X: Tensor) -> Tensor:
             A `batch_shape`-dim Tensor of acquisition values at the given design
             points `X`.
         """
+        tkwargs = {
+            "dtype": self.optimal_outputs.dtype,
+            "device": self.optimal_outputs.device,
+        }
+
+        initial_posterior = self.initial_model.posterior(X, observation_noise=True)
+
+        add_term = 0.5 * (1 + torch.log(torch.ones(1, **tkwargs) * 2 * pi))
+        batch_shape = X.shape[:-2]
+        sample_dim = len(batch_shape)
+        # We DISREGARD the additional constant term.
+        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+
+        # initial_entropy of shape batch_size or batch_size x num_models if FBGP
+        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        initial_entropy = (
+            initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
+        )
+
+        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
+        # Compute the mixture mean and variance
+        posterior_m = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=True
+        )
+        noiseless_var = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=False
+        ).variance
+
+        mean_m = posterior_m.mean
+        if not self.maximize:
+            mean_m = -mean_m
+        variance_m = posterior_m.variance.clamp_min(CLAMP_LB)
+        conditional_samples, conditional_logprobs = self._compute_monte_carlo_variables(
+            posterior_m
+        )
+
+        normalized_samples = (conditional_samples - mean_m) / variance_m.sqrt()
+        # Correlation between noisy observations and noiseless values f
+        rho = (noiseless_var / variance_m).sqrt()
+
+        normal = torch.distributions.Normal(
+            torch.zeros(1, device=X.device, dtype=X.dtype),
+            torch.ones(1, device=X.device, dtype=X.dtype),
+        )
+        # prepare max value quantities and re-scale as required
+        normalized_mvs = (self.optimal_outputs - mean_m) / noiseless_var.sqrt()
+        mvs_rescaled_mc = (normalized_mvs - rho * normalized_samples) / (1 - rho**2)
+        cdf_mvs = normal.cdf(normalized_mvs).clamp_min(CLAMP_LB)
+        cdf_rescaled_mvs = normal.cdf(mvs_rescaled_mc).clamp_min(CLAMP_LB)
+        mv_ratio = cdf_rescaled_mvs / cdf_mvs
+
+        log_term = torch.log(mv_ratio) + conditional_logprobs
+        conditional_entropy = -(mv_ratio * log_term).mean(0)
+        entropy_reduction = (
+            initial_entropy - conditional_entropy.sum(dim=-2, keepdim=True)
+        ).squeeze(-1)
+
+        # average over the number of optima and squeeze the q-batch
+        entropy_reduction = entropy_reduction.mean(dim=sample_dim).squeeze(-1)
 
-        return self._compute_lower_bound_information_gain(X)
+        return entropy_reduction
diff --git a/botorch/acquisition/utils.py b/botorch/acquisition/utils.py
index 99b1f9a27a..95a77735fb 100644
--- a/botorch/acquisition/utils.py
+++ b/botorch/acquisition/utils.py
@@ -11,7 +11,7 @@
 from __future__ import annotations
 
 import math
-from typing import Callable, Dict, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union, Tuple
 
 import torch
 from botorch.acquisition import analytic, monte_carlo, multi_objective  # noqa F401
@@ -31,6 +31,8 @@
     FastNondominatedPartitioning,
     NondominatedPartitioning,
 )
+from botorch.utils.sampling import optimize_posterior_samples
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.transforms import is_fully_bayesian
 from torch import Tensor
 
@@ -473,3 +475,40 @@ def project_to_sample_points(X: Tensor, sample_points: Tensor) -> Tensor:
     X_new = X.repeat(*(1 for _ in batch_shape), p, 1)  # batch_shape x p x d
     X_new[..., -d_prime:] = sample_points
     return X_new
+
+
+def get_optimal_samples(
+    model: Model,
+    bounds: Tensor,
+    num_optima: int,
+    raw_samples: int = 1024,
+    num_restarts: int = 20,
+    maximize: bool = True,
+) -> Tuple[Tensor, Tensor]:
+    """Draws sample paths from the posterior and maximizes the samples using GD.
+
+    Args:
+        model (Model): The model from which samples are drawn.
+        bounds: (Tensor): The bounds of the search space. If the model inputs are normalized,
+            the bounds should be normalized as well.
+        num_optima (int): The number of paths to be drawn and optimized.
+        raw_samples (int, optional): The number of candidates randomly sample. Defaults to 512.
+        num_restarts (int, optional): The number of candidates to do gradient-based optimization on.
+        Defaults to 20.
+        maxiter (int, optional): The maximal number of iterations of gradient-based optimization.
+        Defaults to 100.
+        maximize: Whether to maximize or minimize the samples.
+    Returns:
+        Tuple[Tensor, Tensor]: The optimal input locations and corresponding
+        outputs, x* and f*.
+
+    """
+    paths = draw_matheron_paths(model, sample_shape=torch.Size([num_optima]))
+    optimal_inputs, optimal_outputs = optimize_posterior_samples(
+        paths,
+        bounds=bounds,
+        raw_samples=raw_samples,
+        num_restarts=num_restarts,
+        maximize=maximize,
+    )
+    return optimal_inputs, optimal_outputs
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 0f59da1c44..8269b02191 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -28,6 +28,7 @@
 from scipy.spatial import Delaunay, HalfspaceIntersection
 from torch import LongTensor, Tensor
 from torch.quasirandom import SobolEngine
+from botorch.utils.transforms import unnormalize
 
 
 @contextmanager
@@ -873,3 +874,70 @@ def sparse_to_dense_constraints(
         A[i, indices.long()] = coefficients
         b[i] = rhs
     return A, b
+
+
+def optimize_posterior_samples(
+    paths: SamplePath,
+    bounds: Tensor,
+    candidates: Optional[Tensor] = None,
+    raw_samples: Optional[int] = 1024,
+    num_restarts: int = 20,
+    maximize: bool = True,
+    **kwargs: Any,
+) -> Tuple[Tensor, Tensor]:
+    r"""Cheaply maximizes posterior samples by random querying followed by vanilla
+    gradient descent on the best num_restarts points.
+
+    Args:
+        paths: Random Fourier Feature-based sample paths from the GP
+        bounds: The bounds on the search space.
+        candidates: A priori good candidates (typically previous design points)
+            which acts as extra initial guesses for the optimization routine.
+        raw_samples: The number of samples with which to query the samples initially.
+        num_restarts: The number of points selected for gradient-based optimization.
+        maximize: Boolean indicating whether to maimize or minimize
+    Returns:
+        A two-element tuple containing:
+            - X_opt: A `num_optima x [batch_size] x d`-dim tensor of optimal inputs x*.
+            - f_opt: A `num_optima x [batch_size] x 1`-dim tensor of optimal outputs f*.
+    """
+    if maximize:
+
+        def path_func(x):
+            return paths.forward(x)
+
+    else:
+
+        def path_func(x):
+            return -paths.forward(x)
+
+    candidate_set = unnormalize(
+        SobolEngine(dimension=bounds.shape[1], scramble=True).draw(raw_samples), bounds
+    )
+
+    # queries all samples on all candidates - output shape
+    # raw_samples * num_optima * num_models
+    candidate_queries = path_func(candidate_set)
+    argtop_k = torch.topk(candidate_queries, num_restarts, dim=-1).indices
+    X_top_k = candidate_set[argtop_k, :]
+
+    # to avoid circular import, the import occurs here
+    from botorch.generation.gen import gen_candidates_scipy
+
+    X_top_k, f_top_k = gen_candidates_scipy(
+        X_top_k, path_func, lower_bounds=bounds[0], upper_bounds=bounds[1], **kwargs
+    )
+    f_opt, arg_opt = f_top_k.max(dim=-1, keepdim=True)
+
+    # For each sample (and possibly for every model in the batch of models), this
+    # retrieves the argmax. We flatten, pick out the indices and then reshape to
+    # the original batch shapes (so instead of pickig out the argmax of a
+    # (3, 7, num_restarts, D)) along the num_restarts dim, we pick it out of a
+    # (21  , num_restarts, D)
+    final_shape = candidate_queries.shape[:-1]
+    X_opt = X_top_k.reshape(final_shape.numel(), num_restarts, -1)[
+        torch.arange(final_shape.numel()), arg_opt.flatten()
+    ].reshape(*final_shape, -1)
+    if not maximize:
+        f_opt = -f_opt
+    return X_opt, f_opt
diff --git a/test/acquisition/test_input_constructors.py b/test/acquisition/test_input_constructors.py
index 043312aa0e..7db1ddcbc0 100644
--- a/test/acquisition/test_input_constructors.py
+++ b/test/acquisition/test_input_constructors.py
@@ -27,6 +27,9 @@
     get_best_f_analytic,
     get_best_f_mc,
 )
+from botorch.acquisition.joint_entropy_search import (
+    qJointEntropySearch,
+)
 from botorch.acquisition.knowledge_gradient import (
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
@@ -976,3 +979,29 @@ def test_construct_inputs_mfmes(self):
             inputs_mfmes = input_constructor(**constructor_args)
             inputs_test = {"foo": 0, "bar": 1, "current_value": current_value}
             self.assertEqual(inputs_mfmes, inputs_test)
+
+    def test_construct_inputs_jes(self):
+        func = get_acqf_input_constructor(qJointEntropySearch)
+        # we need to run optimize_posterior_samples, so we sort of need
+        # a real model as there is no other (apparent) option
+        model = SingleTaskGP(self.blockX_blockY[0].X(), self.blockX_blockY[0].Y())
+
+        kwargs = func(
+            model=model,
+            training_data=self.blockX_blockY,
+            objective=LinearMCObjective(torch.rand(2)),
+            bounds=self.bounds,
+            num_optima=17,
+            maximize=False,
+        )
+
+        self.assertFalse(kwargs["maximize"])
+        self.assertEqual(
+            self.blockX_blockY[0].X().dtype, kwargs["optimal_inputs"].dtype
+        )
+        self.assertEqual(len(kwargs["optimal_inputs"]), 17)
+        self.assertEqual(len(kwargs["optimal_outputs"]), 17)
+        # asserting that, for the non-batch case, the optimal inputs are
+        # of shape N x D and outputs are N x 1
+        self.assertEqual(len(kwargs["optimal_inputs"].shape), 2)
+        self.assertEqual(len(kwargs["optimal_outputs"].shape), 2)
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index d554c58bc9..1f6fd21c8c 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -7,7 +7,9 @@
 from itertools import product
 
 import torch
-from botorch.acquisition.joint_entropy_search import qLowerBoundJointEntropySearch
+from botorch.acquisition.joint_entropy_search import (
+    qJointEntropySearch,
+)
 
 from botorch.models.gp_regression import SingleTaskGP
 from botorch.models.model_list_gp_regression import ModelListGP
@@ -48,13 +50,18 @@ def get_model(train_X, train_Y, use_model_list, standardize_model):
     return model
 
 
-class TestQLowerBoundJointEntropySearch(BotorchTestCase):
-    def test_lower_bound_joint_entropy_search(self):
+class TestQJointEntropySearch(BotorchTestCase):
+    def test_joint_entropy_search(self):
         torch.manual_seed(1)
         tkwargs = {"device": self.device}
-        estimation_types = ("0", "LB", "LB2", "MC")
+        estimation_types = ("LB", "MC")
         num_objectives = 1
-        for (dtype, estimation_type, use_model_list, standardize_model,) in product(
+        for (
+            dtype,
+            estimation_type,
+            use_model_list,
+            standardize_model,
+        ) in product(
             (torch.float, torch.double),
             estimation_types,
             (False, True),
@@ -76,7 +83,7 @@ def test_lower_bound_joint_entropy_search(self):
             X_pending_list = [None, torch.rand(2, input_dim, **tkwargs)]
             for i in range(len(X_pending_list)):
                 X_pending = X_pending_list[i]
-                acq = qLowerBoundJointEntropySearch(
+                acq = qJointEntropySearch(
                     model=model,
                     optimal_inputs=optimal_inputs,
                     optimal_outputs=optimal_outputs,
diff --git a/test/acquisition/test_utils.py b/test/acquisition/test_utils.py
index 56908f9c5f..874dc69946 100644
--- a/test/acquisition/test_utils.py
+++ b/test/acquisition/test_utils.py
@@ -25,8 +25,10 @@
     project_to_sample_points,
     project_to_target_fidelity,
     prune_inferior_points,
+    get_optimal_samples,
 )
 from botorch.exceptions.errors import UnsupportedError
+from botorch.models import SingleTaskGP
 from botorch.utils.multi_objective.box_decompositions.non_dominated import (
     FastNondominatedPartitioning,
     NondominatedPartitioning,
@@ -766,3 +768,35 @@ def test_project_to_sample_points(self):
                 self.assertAllClose(X_augmented[0, :, -d_prime:], sample_points)
             else:
                 self.assertAllClose(X_augmented[:, -d_prime:], sample_points)
+
+
+class TestGetOptimalSamples(BotorchTestCase):
+    def test_get_optimal_samples(self):
+        dims = 3
+        dtype = torch.float64
+        for_testing_speed_kwargs = {"raw_samples": 50, "num_restarts": 3}
+        num_optima = 7
+        batch_shape = (3,)
+
+        bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
+        X = torch.rand(*batch_shape, 4, dims).to(dtype)
+        Y = torch.sin(X).sum(dim=-1, keepdim=True).to(dtype)
+        model = SingleTaskGP(X, Y)
+        X_opt, f_opt = get_optimal_samples(
+            model, bounds, num_optima=num_optima, **for_testing_speed_kwargs
+        )
+        X_opt, f_opt_min = get_optimal_samples(
+            model,
+            bounds,
+            num_optima=num_optima,
+            maximize=False,
+            **for_testing_speed_kwargs,
+        )
+
+        correct_X_shape = (num_optima,) + batch_shape + (dims,)
+        correct_f_shape = (num_optima,) + batch_shape + (1,)
+        self.assertEqual(X_opt.shape, correct_X_shape)
+        self.assertEqual(f_opt.shape, correct_f_shape)
+        # asserting that the solutions found by minimization the samples are smaller
+        # than those found by maximization
+        self.assertTrue(torch.all(f_opt_min < f_opt))
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index e100e20448..f06f8b7bef 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -14,6 +14,7 @@
 import numpy as np
 import torch
 from botorch.exceptions.errors import BotorchError
+from botorch.models import FixedNoiseGP
 from botorch.utils.sampling import (
     _convert_bounds_to_inequality_constraints,
     batched_multinomial,
@@ -28,7 +29,9 @@
     sample_hypersphere,
     sample_simplex,
     sparse_to_dense_constraints,
+    optimize_posterior_samples,
 )
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.testing import BotorchTestCase
 
 
@@ -361,7 +364,6 @@ def test_get_polytope_samples(self):
 
 
 class PolytopeSamplerTestBase:
-
     sampler_class: Type[PolytopeSampler]
     sampler_kwargs: Dict[str, Any] = {}
 
@@ -505,13 +507,11 @@ class Result:
 
 
 class TestHitAndRunPolytopeSampler(PolytopeSamplerTestBase, BotorchTestCase):
-
     sampler_class = HitAndRunPolytopeSampler
     sampler_kwargs = {"n_burnin": 2}
 
 
 class TestDelaunayPolytopeSampler(PolytopeSamplerTestBase, BotorchTestCase):
-
     sampler_class = DelaunayPolytopeSampler
 
     def test_sample_polytope_unbounded(self):
@@ -528,3 +528,40 @@ def test_sample_polytope_unbounded(self):
                     interior_point=self.x0,
                     **self.sampler_kwargs,
                 )
+
+
+class TestOptimizePosteriorSamples(BotorchTestCase):
+    def test_optimize_posterior_samples(self):
+        dtypes = (torch.float32, torch.float64)
+        dims = 2
+        dtype = torch.float64
+        eps = 1e-6
+        for_testing_speed_kwargs = {"raw_samples": 250, "num_restarts": 3}
+        nums_optima = (1, 7)
+        batch_shapes = ((), (3,), (5, 2))
+        for num_optima, batch_shape in itertools.product(nums_optima, batch_shapes):
+            bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
+            X = torch.rand(*batch_shape, 52, dims).to(dtype)
+            Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True).to(dtype)
+
+            # having a noiseless model all but guarantees that the found optima
+            # will be better than the observations
+            model = FixedNoiseGP(X, Y, torch.full_like(Y, eps))
+            paths = draw_matheron_paths(
+                model=model, sample_shape=torch.Size([num_optima])
+            )
+            X_opt, f_opt = optimize_posterior_samples(
+                paths, bounds, **for_testing_speed_kwargs
+            )
+
+            correct_X_shape = (num_optima,) + batch_shape + (dims,)
+            correct_f_shape = (num_optima,) + batch_shape + (1,)
+
+            self.assertEqual(X_opt.shape, correct_X_shape)
+            self.assertEqual(f_opt.shape, correct_f_shape)
+            self.assertTrue(torch.all(X_opt >= bounds[0]))
+            self.assertTrue(torch.all(X_opt <= bounds[1]))
+
+            # Check that the all found optima are larger than the observations
+            # This is not 100% deterministic, but just about.
+            self.assertTrue(torch.all((f_opt > Y.max(dim=-2).values)))
diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 6fd92283ef..1fae74bb71 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -227,7 +227,9 @@
     "\n",
     "[3] B. Tu, A. Gandy, N. Kantas and B. Shafei, [**Joint Entropy Search for Multi-Objective Bayesian Optimization**](https://arxiv.org/abs/2210.02905), NeurIPS, 2022.\n",
     "\n",
-    "[4] E. Garrido-Merchán and D. Hernández-Lobato, [**Predictive Entropy Search for Multi-objective Bayesian Optimization with Constraints**](https://www.sciencedirect.com/science/article/abs/pii/S0925231219308525), Neurocomputing, 2019."
+    "[4] C. Hvarfner, F. Hutter and N. Nardi, [**Joint Entropy Search for Maximally-Informed Bayesian Optimization**](https://arxiv.org/abs/2206.04771), NeurIPS, 2022.\n",
+    "\n",
+    "[5] E. Garrido-Merchán and D. Hernández-Lobato, [**Predictive Entropy Search for Multi-objective Bayesian Optimization with Constraints**](https://www.sciencedirect.com/science/article/abs/pii/S0925231219308525), Neurocomputing, 2019."
    ]
   },
   {
@@ -397,7 +399,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "id": "320b07cc",
    "metadata": {},
    "outputs": [],
@@ -424,9 +426,8 @@
     "\n",
     "jes_lb = qLowerBoundJointEntropySearch(\n",
     "    model=model,\n",
-    "    optimal_inputs=optimal_inputs.squeeze(-2),\n",
-    "    optimal_outputs=optimal_outputs.squeeze(-2),\n",
-    "    hypercell_bounds=hypercell_bounds,\n",
+    "    optimal_inputs=optimal_inputs,\n",
+    "    optimal_outputs=optimal_outputs,\n",
     "    estimation_type=\"LB\",\n",
     ")"
    ]
@@ -441,21 +442,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "382e37f4",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "pes_X = pes(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
     "mes_lb_X = mes_lb(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
@@ -481,20 +471,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "f7f639bb",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: candidate=tensor([[0.4279]], dtype=torch.float64), acq_value=0.13269657722877268\n",
-      "MES-LB: candidate=tensor([[0.4050]], dtype=torch.float64), acq_value=0.19125601676433068\n",
-      "JES-LB: candidate=tensor([[0.3982]], dtype=torch.float64), acq_value=0.24631777964460078\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from botorch.optim import optimize_acqf\n",
     "\n",
@@ -546,7 +526,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "fabc86e9",
    "metadata": {},
    "outputs": [],
@@ -576,7 +556,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "56bd5f5a",
    "metadata": {},
    "outputs": [],
@@ -610,7 +590,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "2c7dfaf0",
    "metadata": {},
    "outputs": [],
@@ -654,32 +634,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "ceac58f5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: \n",
-      "candidates=tensor([[0.0000, 0.0000, 0.5550, 0.0000],\n",
-      "        [0.0424, 0.4966, 0.0000, 0.0000],\n",
-      "        [0.1694, 0.0000, 0.1460, 0.0000],\n",
-      "        [0.0544, 0.0000, 0.0000, 0.4292]], dtype=torch.float64)\n",
-      "MES-LB: \n",
-      "candidates=tensor([[0.5049, 0.0203, 0.0291, 0.0560],\n",
-      "        [0.6612, 0.1512, 0.0000, 0.1993],\n",
-      "        [0.0000, 0.2376, 0.6425, 0.5808],\n",
-      "        [0.0000, 0.2852, 0.9665, 0.8014]], dtype=torch.float64)\n",
-      "JES-LB: \n",
-      "candidates=tensor([[0.0718, 0.0484, 0.1318, 0.1239],\n",
-      "        [0.3195, 0.0000, 0.0168, 0.4589],\n",
-      "        [0.6214, 0.0254, 0.2650, 0.0494],\n",
-      "        [0.0008, 0.1587, 0.2939, 0.5756]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "q = 4\n",
     "\n",
@@ -742,7 +700,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.8.0"
+   "version": "3.9.13"
   }
  },
  "nbformat": 4,

From 30cfc594a138ec6b238be3fdd25b730c11bc5e0a Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Fri, 31 Mar 2023 10:50:21 +0200
Subject: [PATCH 02/23] Added changes in constants in JES

---
 botorch/acquisition/joint_entropy_search.py | 52 ++++++++++++++-------
 1 file changed, 34 insertions(+), 18 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 4fd11595ad..b396e61796 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -14,7 +14,7 @@
 
 from typing import Any, Optional
 import warnings
-from math import pi
+from math import log, pi
 import torch.distributions as dist
 
 import torch
@@ -25,6 +25,7 @@
 from botorch.models.utils import check_no_nans
 from botorch import settings
 from botorch.models.utils import fantasize as fantasize_flag
+from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
 from botorch.models.model import Model
 from botorch.models.gp_regression import MIN_INFERRED_NOISE_LEVEL
 from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
@@ -36,6 +37,16 @@
 
 MCMC_DIM = -3  # Only relevant if you do Fully Bayesian GPs.
 ESTIMATION_TYPES = ["MC", "LB"]
+MC_ADD_TERM = 0.5 * (1 + log(2 * pi))
+
+# The CDF query cannot be strictly zero in the division
+# and this clamping helps assure that it is always positive.
+CLAMP_LB = torch.finfo(torch.float32).eps
+FULLY_BAYESIAN_ERROR_MSG = """JES is not yet available with Fully Bayesian GPs. Track the issue,
+which regards conditioning on a number of optima on a collecion of models,
+in detail at https://github.com/pytorch/botorch/issues/1680.
+"""
+
 """
 References
 .. [Hvarfner2022joint]
@@ -72,7 +83,7 @@ def __init__(
         X_pending: Optional[Tensor] = None,
         estimation_type: str = "LB",
         maximize: bool = True,
-        num_samples: int = 256,
+        num_samples: int = 64,
         **kwargs: Any,
     ) -> None:
         r"""Joint entropy search acquisition function.
@@ -95,7 +106,7 @@ def __init__(
                 of the MC estimator.
             maximize: If true, we consider a maximization problem.
             X_pending: A `m x d`-dim Tensor of `m` design points that have been
-                submitted for function evaluation, but have not yet been evaluated
+                submitted for function evaluation, but have not yet been evaluated.
             num_samples: The number of Monte Carlo samples used for the Monte Carlo
                 estimate.
         """
@@ -119,7 +130,7 @@ def __init__(
         # want to consider MAX-values. As such, we need to flip them if
         # we want to minimize.
         if not self.maximize:
-            optimal_outputs = (-1) * optimal_outputs
+            optimal_outputs = -optimal_outputs
         self.num_samples = optimal_inputs.shape[0]
         self.condition_noiseless = condition_noiseless
         self.initial_model = model
@@ -129,6 +140,9 @@ def __init__(
         # and the optimal outputs have shapes num_optima x [num_models if FB] x 1 x 1
         # The third dimension equaling 1 is required to get one optimum per model,
         # which raises a BotorchTensorDimensionWarning.
+        if isinstance(model, SaasFullyBayesianSingleTaskGP):
+
+            raise NotImplementedError(FULLY_BAYESIAN_ERROR_MSG)
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore")
             with fantasize_flag():
@@ -143,14 +157,16 @@ def __init__(
                     opt_noise = torch.full_like(
                         self.optimal_outputs, MIN_INFERRED_NOISE_LEVEL)
                     # conditional (batch) model of shape (num_models) x num_optima_per_model
+                    self.conditional_model = self.initial_model.condition_on_observations(
+                        X=self.initial_model.transform_inputs(self.optimal_inputs),
+                        Y=self.optimal_outputs,
+                        noise=opt_noise
+                    )
                 else:
-                    opt_noise = None
-
-                self.conditional_model = self.initial_model.condition_on_observations(
-                    X=self.initial_model.transform_inputs(self.optimal_inputs),
-                    Y=self.optimal_outputs,
-                    noise=opt_noise,
-                )
+                    self.conditional_model = self.initial_model.condition_on_observations(
+                        X=self.initial_model.transform_inputs(self.optimal_inputs),
+                        Y=self.optimal_outputs,
+                    )
 
         self.estimation_type = estimation_type
         self.set_X_pending(X_pending)
@@ -158,7 +174,8 @@ def __init__(
     @concatenate_pending_points
     @t_batch_mode_transform()
     def forward(self, X: Tensor) -> Tensor:
-        r"""Evaluates qLowerBoundJointEntropySearch at the design points `X`.
+        r"""Evaluates qJointEntropySearch at the design points `X`.
+
         Args:
             X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
             `d`-dim design points each.
@@ -173,7 +190,7 @@ def forward(self, X: Tensor) -> Tensor:
             res = self._compute_monte_carlo_information_gain(X)
         else:
             raise ValueError(
-                f"Estimation type {self.estimation_type} is not valid."
+                f"Estimation type {self.estimation_type} is not valid. "
                 f"Please specify any of {ESTIMATION_TYPES}"
             )
         return res
@@ -201,7 +218,8 @@ def _compute_lower_bound_information_gain(
         batch_shape = X.shape[:-2]
         sample_dim = len(batch_shape)
         # We DISREGARD the additional constant term.
-        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+        initial_entropy = 0.5 * \
+            torch.logdet(initial_posterior.mvn.lazy_covariance_matrix)
 
         # initial_entropy of shape batch_size or batch_size x num_models if FBGP
         # first need to unsqueeze the sample dim (first after batch dim) and then the two last
@@ -209,7 +227,6 @@ def _compute_lower_bound_information_gain(
             initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
         )
 
-        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
         # Compute the mixture mean and variance
         posterior_m = self.conditional_model.posterior(
             X.unsqueeze(MCMC_DIM), observation_noise=True
@@ -290,11 +307,11 @@ def _compute_monte_carlo_information_gain(
 
         initial_posterior = self.initial_model.posterior(X, observation_noise=True)
 
-        add_term = 0.5 * (1 + torch.log(torch.ones(1, **tkwargs) * 2 * pi))
         batch_shape = X.shape[:-2]
         sample_dim = len(batch_shape)
         # We DISREGARD the additional constant term.
-        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+        initial_entropy = MC_ADD_TERM + 0.5 * \
+            torch.logdet(initial_posterior.mvn.lazy_covariance_matrix)
 
         # initial_entropy of shape batch_size or batch_size x num_models if FBGP
         # first need to unsqueeze the sample dim (first after batch dim) and then the two last
@@ -302,7 +319,6 @@ def _compute_monte_carlo_information_gain(
             initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
         )
 
-        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
         # Compute the mixture mean and variance
         posterior_m = self.conditional_model.posterior(
             X.unsqueeze(MCMC_DIM), observation_noise=True

From 2619667bfc276a3cf800699c8b623c4e26ca489a Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Fri, 31 Mar 2023 12:58:23 +0200
Subject: [PATCH 03/23] Packaged the latest JES changes into one commit

---
 botorch/acquisition/input_constructors.py     |  5 ++++-
 botorch/utils/sampling.py                     |  1 +
 test/acquisition/test_joint_entropy_search.py | 22 +++++++++++++++++++
 test/acquisition/test_utils.py                |  4 ++--
 test/utils/test_sampling.py                   |  6 ++---
 5 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/botorch/acquisition/input_constructors.py b/botorch/acquisition/input_constructors.py
index 2814984539..b57e964f71 100644
--- a/botorch/acquisition/input_constructors.py
+++ b/botorch/acquisition/input_constructors.py
@@ -1259,7 +1259,10 @@ def construct_inputs_qJES(
 ):
     dtype = model.train_targets.dtype
     optimal_inputs, optimal_outputs = get_optimal_samples(
-        model, Tensor(bounds).to(dtype).T, num_optima=num_optima, maximize=maximize
+        model=model,
+        bounds=torch.as_tensor(bounds, dtype=dtype).T,
+        num_optima=num_optima,
+        maximize=maximize,
     )
 
     inputs = {
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 8269b02191..b3f8dcd3d8 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -896,6 +896,7 @@ def optimize_posterior_samples(
         raw_samples: The number of samples with which to query the samples initially.
         num_restarts: The number of points selected for gradient-based optimization.
         maximize: Boolean indicating whether to maimize or minimize
+    
     Returns:
         A two-element tuple containing:
             - X_opt: A `num_optima x [batch_size] x d`-dim tensor of optimal inputs x*.
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index 1f6fd21c8c..f9ee071e4e 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -55,17 +55,23 @@ def test_joint_entropy_search(self):
         torch.manual_seed(1)
         tkwargs = {"device": self.device}
         estimation_types = ("LB", "MC")
+
+
         num_objectives = 1
         for (
             dtype,
             estimation_type,
             use_model_list,
             standardize_model,
+            maximize,
+            condition_noiseless,
         ) in product(
             (torch.float, torch.double),
             estimation_types,
             (False, True),
             (False, True),
+            (False, True),
+            (False, True),
         ):
             tkwargs["dtype"] = dtype
             input_dim = 2
@@ -83,6 +89,7 @@ def test_joint_entropy_search(self):
             X_pending_list = [None, torch.rand(2, input_dim, **tkwargs)]
             for i in range(len(X_pending_list)):
                 X_pending = X_pending_list[i]
+
                 acq = qJointEntropySearch(
                     model=model,
                     optimal_inputs=optimal_inputs,
@@ -90,6 +97,8 @@ def test_joint_entropy_search(self):
                     estimation_type=estimation_type,
                     num_samples=64,
                     X_pending=X_pending,
+                    condition_noiseless=condition_noiseless,
+                    maximize=maximize
                 )
                 self.assertIsInstance(acq.sampler, SobolQMCNormalSampler)
 
@@ -104,3 +113,16 @@ def test_joint_entropy_search(self):
                     acq_X = acq(test_Xs[j])
                     # assess shape
                     self.assertTrue(acq_X.shape == test_Xs[j].shape[:-2])
+
+        with self.assertRaises(ValueError):
+            acq = qJointEntropySearch(
+                model=model,
+                optimal_inputs=optimal_inputs,
+                optimal_outputs=optimal_outputs,
+                estimation_type='NO_EST',
+                num_samples=64,
+                X_pending=X_pending,
+                condition_noiseless=condition_noiseless,
+                maximize=maximize
+            )
+            acq_X = acq(test_Xs[j])
\ No newline at end of file
diff --git a/test/acquisition/test_utils.py b/test/acquisition/test_utils.py
index 874dc69946..f8200dafff 100644
--- a/test/acquisition/test_utils.py
+++ b/test/acquisition/test_utils.py
@@ -778,8 +778,8 @@ def test_get_optimal_samples(self):
         num_optima = 7
         batch_shape = (3,)
 
-        bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
-        X = torch.rand(*batch_shape, 4, dims).to(dtype)
+        bounds = torch.tensor([[0, 1]] * dims, dtype=dtype).T
+        X = torch.rand(*batch_shape, 4, dims, dtype=dtype)
         Y = torch.sin(X).sum(dim=-1, keepdim=True).to(dtype)
         model = SingleTaskGP(X, Y)
         X_opt, f_opt = get_optimal_samples(
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index f06f8b7bef..ceb6b44f20 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -540,9 +540,9 @@ def test_optimize_posterior_samples(self):
         nums_optima = (1, 7)
         batch_shapes = ((), (3,), (5, 2))
         for num_optima, batch_shape in itertools.product(nums_optima, batch_shapes):
-            bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
-            X = torch.rand(*batch_shape, 52, dims).to(dtype)
-            Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True).to(dtype)
+            bounds = torch.Tensor([[0, 1]] * dims, dtype=dtype).T
+            X = torch.rand(*batch_shape, 52, dims, dtype=dtype)
+            Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True)
 
             # having a noiseless model all but guarantees that the found optima
             # will be better than the observations

From 46ad5a0e4566c45aca2b7edc4c10c8f969908a11 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Fri, 31 Mar 2023 19:23:34 +0200
Subject: [PATCH 04/23] Bug in sampling testBug in sampling test

---
 test/utils/test_sampling.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index ceb6b44f20..67306fb0fa 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -540,7 +540,7 @@ def test_optimize_posterior_samples(self):
         nums_optima = (1, 7)
         batch_shapes = ((), (3,), (5, 2))
         for num_optima, batch_shape in itertools.product(nums_optima, batch_shapes):
-            bounds = torch.Tensor([[0, 1]] * dims, dtype=dtype).T
+            bounds = torch.tensor([[0, 1]] * dims, dtype=dtype).T
             X = torch.rand(*batch_shape, 52, dims, dtype=dtype)
             Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True)
 

From bb218cf0e68a600853687af0254f8ed99a651731 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Mon, 3 Apr 2023 13:45:45 +0200
Subject: [PATCH 05/23] Modified sampling

---
 botorch/utils/sampling.py   | 4 ++--
 test/utils/test_sampling.py | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index b3f8dcd3d8..ba36661b7e 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -923,9 +923,9 @@ def path_func(x):
     X_top_k = candidate_set[argtop_k, :]
 
     # to avoid circular import, the import occurs here
-    from botorch.generation.gen import gen_candidates_scipy
+    from botorch.generation.gen import gen_candidates_torch
 
-    X_top_k, f_top_k = gen_candidates_scipy(
+    X_top_k, f_top_k = gen_candidates_torch(
         X_top_k, path_func, lower_bounds=bounds[0], upper_bounds=bounds[1], **kwargs
     )
     f_opt, arg_opt = f_top_k.max(dim=-1, keepdim=True)
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index 67306fb0fa..99de292110 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -536,12 +536,12 @@ def test_optimize_posterior_samples(self):
         dims = 2
         dtype = torch.float64
         eps = 1e-6
-        for_testing_speed_kwargs = {"raw_samples": 250, "num_restarts": 3}
+        for_testing_speed_kwargs = {"raw_samples": 512, "num_restarts": 10}
         nums_optima = (1, 7)
         batch_shapes = ((), (3,), (5, 2))
         for num_optima, batch_shape in itertools.product(nums_optima, batch_shapes):
             bounds = torch.tensor([[0, 1]] * dims, dtype=dtype).T
-            X = torch.rand(*batch_shape, 52, dims, dtype=dtype)
+            X = torch.rand(*batch_shape, 13, dims, dtype=dtype)
             Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True)
 
             # having a noiseless model all but guarantees that the found optima

From 5263d8d36b840bfed350a097db49667837bd281c Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Wed, 12 Apr 2023 09:47:38 +0200
Subject: [PATCH 06/23] Formatting, removed imports

---
 botorch/acquisition/input_constructors.py     |   5 +-
 botorch/acquisition/joint_entropy_search.py   | 101 +++++++++---------
 botorch/acquisition/utils.py                  |  17 ++-
 botorch/utils/sampling.py                     |   6 +-
 test/acquisition/test_input_constructors.py   |   4 +-
 test/acquisition/test_joint_entropy_search.py |  13 +--
 test/acquisition/test_utils.py                |   2 +-
 test/utils/test_sampling.py                   |   5 +-
 8 files changed, 71 insertions(+), 82 deletions(-)

diff --git a/botorch/acquisition/input_constructors.py b/botorch/acquisition/input_constructors.py
index b57e964f71..c052eb6007 100644
--- a/botorch/acquisition/input_constructors.py
+++ b/botorch/acquisition/input_constructors.py
@@ -43,11 +43,11 @@
 )
 from botorch.acquisition.cost_aware import InverseCostWeightedUtility
 from botorch.acquisition.fixed_feature import FixedFeatureAcquisitionFunction
+from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.knowledge_gradient import (
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
 )
-from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.max_value_entropy_search import (
     qMaxValueEntropy,
     qMultiFidelityMaxValueEntropy,
@@ -83,9 +83,9 @@
 from botorch.acquisition.risk_measures import RiskMeasureMCObjective
 from botorch.acquisition.utils import (
     expand_trace_observations,
+    get_optimal_samples,
     project_to_target_fidelity,
 )
-from botorch.acquisition.utils import get_optimal_samples
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models.cost import AffineFidelityCostModel
 from botorch.models.deterministic import FixedSingleSampleModel
@@ -1243,7 +1243,6 @@ def optimize_objective(
     )
 
 
-# TODO make single-objective with pairwise and multi-objective with pareto
 @acqf_input_constructor(qJointEntropySearch)
 def construct_inputs_qJES(
     model: Model,
diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index b396e61796..c0a8770f14 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -12,28 +12,26 @@
 
 from __future__ import annotations
 
-from typing import Any, Optional
 import warnings
 from math import log, pi
-import torch.distributions as dist
-
-import torch
-from torch import Tensor
 
-from torch.distributions import Normal
+from typing import Any, Optional
 
-from botorch.models.utils import check_no_nans
+import torch
 from botorch import settings
-from botorch.models.utils import fantasize as fantasize_flag
+from botorch.acquisition.acquisition import AcquisitionFunction, MCSamplerMixin
+from botorch.acquisition.objective import PosteriorTransform
+
 from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
-from botorch.models.model import Model
 from botorch.models.gp_regression import MIN_INFERRED_NOISE_LEVEL
-from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
-from botorch.acquisition.monte_carlo import MCAcquisitionFunction
-from botorch.acquisition.acquisition import AcquisitionFunction, MCSamplerMixin
+from botorch.models.model import Model
+
+from botorch.models.utils import check_no_nans, fantasize as fantasize_flag
 from botorch.sampling.normal import SobolQMCNormalSampler
-from botorch.utils.transforms import is_fully_bayesian
-from botorch.exceptions.warnings import BotorchTensorDimensionWarning
+from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
+from torch import Tensor
+
+from torch.distributions import Normal
 
 MCMC_DIM = -3  # Only relevant if you do Fully Bayesian GPs.
 ESTIMATION_TYPES = ["MC", "LB"]
@@ -42,22 +40,22 @@
 # The CDF query cannot be strictly zero in the division
 # and this clamping helps assure that it is always positive.
 CLAMP_LB = torch.finfo(torch.float32).eps
-FULLY_BAYESIAN_ERROR_MSG = """JES is not yet available with Fully Bayesian GPs. Track the issue,
-which regards conditioning on a number of optima on a collecion of models,
-in detail at https://github.com/pytorch/botorch/issues/1680.
+FULLY_BAYESIAN_ERROR_MSG = """JES is not yet available with Fully Bayesian GPs.
+Track the issue, which regards conditioning on a number of optima on a collecion
+ of models, in detail at https://github.com/pytorch/botorch/issues/1680.
 """
 
 """
 References
 .. [Hvarfner2022joint]
     C. Hvarfner, F. Hutter, L. Nardi,
-    Joint Entropy Search for Maximally-informed Bayesian Optimization. 
+    Joint Entropy Search for Maximally-informed Bayesian Optimization.
     In Proceedings of the Annual Conference on Neural Information
     Processing Systems (NeurIPS), 2022.
 
 .. [Tu2022joint]
     B. Tu, A. Gandy, N. Kantas, B. Shafei,
-    Joint Entropy Search for Multi-objective Bayesian Optimization. 
+    Joint Entropy Search for Multi-objective Bayesian Optimization.
     In Proceedings of the Annual Conference on Neural Information
     Processing Systems (NeurIPS), 2022.
 """
@@ -134,38 +132,42 @@ def __init__(
         self.num_samples = optimal_inputs.shape[0]
         self.condition_noiseless = condition_noiseless
         self.initial_model = model
-        tkwargs = {"dtype": optimal_outputs.dtype, "device": optimal_outputs.device}
 
         # Here, the optimal inputs have shapes num_optima x [num_models if FB] x 1 x D
         # and the optimal outputs have shapes num_optima x [num_models if FB] x 1 x 1
         # The third dimension equaling 1 is required to get one optimum per model,
         # which raises a BotorchTensorDimensionWarning.
         if isinstance(model, SaasFullyBayesianSingleTaskGP):
-
             raise NotImplementedError(FULLY_BAYESIAN_ERROR_MSG)
         with warnings.catch_warnings():
             warnings.filterwarnings("ignore")
             with fantasize_flag():
                 with settings.propagate_grads(False):
-                    post_ps = self.initial_model.posterior(
+                    # We must do a forward pass one before conditioning
+                    self.initial_model.posterior(
                         self.model.train_inputs[0], observation_noise=False
                     )
-                    sample_idx = 0
 
                 # This equates to the JES version proposed by Hvarfner et. al.
                 if self.condition_noiseless:
                     opt_noise = torch.full_like(
-                        self.optimal_outputs, MIN_INFERRED_NOISE_LEVEL)
-                    # conditional (batch) model of shape (num_models) x num_optima_per_model
-                    self.conditional_model = self.initial_model.condition_on_observations(
-                        X=self.initial_model.transform_inputs(self.optimal_inputs),
-                        Y=self.optimal_outputs,
-                        noise=opt_noise
+                        self.optimal_outputs, MIN_INFERRED_NOISE_LEVEL
+                    )
+                    # conditional (batch) model of shape (num_models)
+                    # x num_optima_per_model
+                    self.conditional_model = (
+                        self.initial_model.condition_on_observations(
+                            X=self.initial_model.transform_inputs(self.optimal_inputs),
+                            Y=self.optimal_outputs,
+                            noise=opt_noise,
+                        )
                     )
                 else:
-                    self.conditional_model = self.initial_model.condition_on_observations(
-                        X=self.initial_model.transform_inputs(self.optimal_inputs),
-                        Y=self.optimal_outputs,
+                    self.conditional_model = (
+                        self.initial_model.condition_on_observations(
+                            X=self.initial_model.transform_inputs(self.optimal_inputs),
+                            Y=self.optimal_outputs,
+                        )
                     )
 
         self.estimation_type = estimation_type
@@ -208,21 +210,18 @@ def _compute_lower_bound_information_gain(
             A `batch_shape`-dim Tensor of acquisition values at the given design
             points `X`.
         """
-        tkwargs = {
-            "dtype": self.optimal_outputs.dtype,
-            "device": self.optimal_outputs.device,
-        }
         initial_posterior = self.initial_model.posterior(X, observation_noise=True)
         # need to check if there is a two-dimensional batch shape -
         # the sampled optima appear in the dimension right after
         batch_shape = X.shape[:-2]
         sample_dim = len(batch_shape)
         # We DISREGARD the additional constant term.
-        initial_entropy = 0.5 * \
-            torch.logdet(initial_posterior.mvn.lazy_covariance_matrix)
+        initial_entropy = 0.5 * torch.logdet(
+            initial_posterior.mvn.lazy_covariance_matrix
+        )
 
         # initial_entropy of shape batch_size or batch_size x num_models if FBGP
-        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        # first need to unsqueeze the sample dim (after batch dim) and then the two last
         initial_entropy = (
             initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
         )
@@ -244,7 +243,7 @@ def _compute_lower_bound_information_gain(
         # get stdv of noiseless variance
         stdv = noiseless_var.sqrt()
         # batch_shape x 1
-        normal = torch.distributions.Normal(
+        normal = Normal(
             torch.zeros(1, device=X.device, dtype=X.dtype),
             torch.ones(1, device=X.device, dtype=X.dtype),
         )
@@ -271,15 +270,17 @@ def _compute_lower_bound_information_gain(
         return entropy_reduction
 
     def _compute_monte_carlo_variables(self, posterior):
-        """Retrieved the monte carlo samples  and their log probabilities from the posterior.
+        """Retrieves monte carlo samples and their log probabilities from the posterior.
 
         Args:
             posterior: The posterior distribution.
 
         Returns:
             A two-element tuple containing:
-            - samples: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of samples drawn from the posterior.
-            - samples_log_prob: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of associated probabilities.
+            - samples: a num_optima x batch_shape x num_mc_samples x q x 1
+                tensor of samples drawn from the posterior.
+            - samples_log_prob: a num_optima x batch_shape x num_mc_samples x q x 1
+                tensor of associated probabilities.
         """
         samples = self.get_posterior_samples(posterior)
         samples_log_prob = (
@@ -300,21 +301,17 @@ def _compute_monte_carlo_information_gain(
             A `batch_shape`-dim Tensor of acquisition values at the given design
             points `X`.
         """
-        tkwargs = {
-            "dtype": self.optimal_outputs.dtype,
-            "device": self.optimal_outputs.device,
-        }
-
         initial_posterior = self.initial_model.posterior(X, observation_noise=True)
 
         batch_shape = X.shape[:-2]
         sample_dim = len(batch_shape)
         # We DISREGARD the additional constant term.
-        initial_entropy = MC_ADD_TERM + 0.5 * \
-            torch.logdet(initial_posterior.mvn.lazy_covariance_matrix)
+        initial_entropy = MC_ADD_TERM + 0.5 * torch.logdet(
+            initial_posterior.mvn.lazy_covariance_matrix
+        )
 
         # initial_entropy of shape batch_size or batch_size x num_models if FBGP
-        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        # first need to unsqueeze the sample dim (after batch dim), then the two last
         initial_entropy = (
             initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
         )
@@ -339,7 +336,7 @@ def _compute_monte_carlo_information_gain(
         # Correlation between noisy observations and noiseless values f
         rho = (noiseless_var / variance_m).sqrt()
 
-        normal = torch.distributions.Normal(
+        normal = Normal(
             torch.zeros(1, device=X.device, dtype=X.dtype),
             torch.ones(1, device=X.device, dtype=X.dtype),
         )
diff --git a/botorch/acquisition/utils.py b/botorch/acquisition/utils.py
index 95a77735fb..9b90867e5f 100644
--- a/botorch/acquisition/utils.py
+++ b/botorch/acquisition/utils.py
@@ -11,7 +11,7 @@
 from __future__ import annotations
 
 import math
-from typing import Callable, Dict, List, Optional, Union, Tuple
+from typing import Callable, Dict, List, Optional, Tuple, Union
 
 import torch
 from botorch.acquisition import analytic, monte_carlo, multi_objective  # noqa F401
@@ -27,12 +27,12 @@
 from botorch.models.model import Model
 from botorch.sampling.base import MCSampler
 from botorch.sampling.get_sampler import get_sampler
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.multi_objective.box_decompositions.non_dominated import (
     FastNondominatedPartitioning,
     NondominatedPartitioning,
 )
 from botorch.utils.sampling import optimize_posterior_samples
-from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.transforms import is_fully_bayesian
 from torch import Tensor
 
@@ -489,14 +489,13 @@ def get_optimal_samples(
 
     Args:
         model (Model): The model from which samples are drawn.
-        bounds: (Tensor): The bounds of the search space. If the model inputs are normalized,
-            the bounds should be normalized as well.
+        bounds: (Tensor): Bounds of the search space. If the model inputs are
+            normalized, the bounds should be normalized as well.
         num_optima (int): The number of paths to be drawn and optimized.
-        raw_samples (int, optional): The number of candidates randomly sample. Defaults to 512.
-        num_restarts (int, optional): The number of candidates to do gradient-based optimization on.
-        Defaults to 20.
-        maxiter (int, optional): The maximal number of iterations of gradient-based optimization.
-        Defaults to 100.
+        raw_samples (int, optional): The number of candidates randomly sample.
+            Defaults to 1024.
+        num_restarts (int, optional): The number of candidates to do gradient-based
+            optimization on. Defaults to 20.
         maximize: Whether to maximize or minimize the samples.
     Returns:
         Tuple[Tensor, Tensor]: The optimal input locations and corresponding
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index ba36661b7e..9b9f591392 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -18,17 +18,17 @@
 
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from typing import Generator, Iterable, List, Optional, Tuple
+from typing import Any, Generator, Iterable, List, Optional, Tuple
 
 import numpy as np
 import scipy
 import torch
 from botorch.exceptions.errors import BotorchError
 from botorch.sampling.qmc import NormalQMCEngine
+from botorch.utils.transforms import unnormalize
 from scipy.spatial import Delaunay, HalfspaceIntersection
 from torch import LongTensor, Tensor
 from torch.quasirandom import SobolEngine
-from botorch.utils.transforms import unnormalize
 
 
 @contextmanager
@@ -896,7 +896,7 @@ def optimize_posterior_samples(
         raw_samples: The number of samples with which to query the samples initially.
         num_restarts: The number of points selected for gradient-based optimization.
         maximize: Boolean indicating whether to maimize or minimize
-    
+
     Returns:
         A two-element tuple containing:
             - X_opt: A `num_optima x [batch_size] x d`-dim tensor of optimal inputs x*.
diff --git a/test/acquisition/test_input_constructors.py b/test/acquisition/test_input_constructors.py
index 7db1ddcbc0..ba52209474 100644
--- a/test/acquisition/test_input_constructors.py
+++ b/test/acquisition/test_input_constructors.py
@@ -27,9 +27,7 @@
     get_best_f_analytic,
     get_best_f_mc,
 )
-from botorch.acquisition.joint_entropy_search import (
-    qJointEntropySearch,
-)
+from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.knowledge_gradient import (
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index f9ee071e4e..b6e98cc66f 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -7,9 +7,7 @@
 from itertools import product
 
 import torch
-from botorch.acquisition.joint_entropy_search import (
-    qJointEntropySearch,
-)
+from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 
 from botorch.models.gp_regression import SingleTaskGP
 from botorch.models.model_list_gp_regression import ModelListGP
@@ -56,7 +54,6 @@ def test_joint_entropy_search(self):
         tkwargs = {"device": self.device}
         estimation_types = ("LB", "MC")
 
-
         num_objectives = 1
         for (
             dtype,
@@ -98,7 +95,7 @@ def test_joint_entropy_search(self):
                     num_samples=64,
                     X_pending=X_pending,
                     condition_noiseless=condition_noiseless,
-                    maximize=maximize
+                    maximize=maximize,
                 )
                 self.assertIsInstance(acq.sampler, SobolQMCNormalSampler)
 
@@ -119,10 +116,10 @@ def test_joint_entropy_search(self):
                 model=model,
                 optimal_inputs=optimal_inputs,
                 optimal_outputs=optimal_outputs,
-                estimation_type='NO_EST',
+                estimation_type="NO_EST",
                 num_samples=64,
                 X_pending=X_pending,
                 condition_noiseless=condition_noiseless,
-                maximize=maximize
+                maximize=maximize,
             )
-            acq_X = acq(test_Xs[j])
\ No newline at end of file
+            acq_X = acq(test_Xs[j])
diff --git a/test/acquisition/test_utils.py b/test/acquisition/test_utils.py
index f8200dafff..41b4384e85 100644
--- a/test/acquisition/test_utils.py
+++ b/test/acquisition/test_utils.py
@@ -22,10 +22,10 @@
     expand_trace_observations,
     get_acquisition_function,
     get_infeasible_cost,
+    get_optimal_samples,
     project_to_sample_points,
     project_to_target_fidelity,
     prune_inferior_points,
-    get_optimal_samples,
 )
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models import SingleTaskGP
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index 99de292110..85fcc8bbc1 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -15,6 +15,7 @@
 import torch
 from botorch.exceptions.errors import BotorchError
 from botorch.models import FixedNoiseGP
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.sampling import (
     _convert_bounds_to_inequality_constraints,
     batched_multinomial,
@@ -25,13 +26,12 @@
     HitAndRunPolytopeSampler,
     manual_seed,
     normalize_linear_constraints,
+    optimize_posterior_samples,
     PolytopeSampler,
     sample_hypersphere,
     sample_simplex,
     sparse_to_dense_constraints,
-    optimize_posterior_samples,
 )
-from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.testing import BotorchTestCase
 
 
@@ -532,7 +532,6 @@ def test_sample_polytope_unbounded(self):
 
 class TestOptimizePosteriorSamples(BotorchTestCase):
     def test_optimize_posterior_samples(self):
-        dtypes = (torch.float32, torch.float64)
         dims = 2
         dtype = torch.float64
         eps = 1e-6

From 8c5a1e4da04bbb3cba70dd3be53d723984f9ecda Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <58733990+hvarfner@users.noreply.github.com>
Date: Wed, 12 Apr 2023 16:21:37 +0200
Subject: [PATCH 07/23] Update botorch/utils/sampling.py

Co-authored-by: Max Balandat <Balandat@users.noreply.github.com>
---
 botorch/utils/sampling.py | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 9b9f591392..f7a94b2f1a 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -31,6 +31,10 @@
 from torch.quasirandom import SobolEngine
 
 
+if TYPE_CHECKING:
+    from botorch.sampling.pathwise.path import SamplePath
+
+
 @contextmanager
 def manual_seed(seed: Optional[int] = None) -> Generator[None, None, None]:
     r"""Contextmanager for manual setting the torch.random seed.

From 90bbb833a92752add30e6fd602057030fbd59fa1 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <58733990+hvarfner@users.noreply.github.com>
Date: Wed, 12 Apr 2023 16:21:52 +0200
Subject: [PATCH 08/23] Update botorch/utils/sampling.py

Co-authored-by: Max Balandat <Balandat@users.noreply.github.com>
---
 botorch/utils/sampling.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index f7a94b2f1a..ea80d5ec4b 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -18,7 +18,7 @@
 
 from abc import ABC, abstractmethod
 from contextlib import contextmanager
-from typing import Any, Generator, Iterable, List, Optional, Tuple
+from typing import Any, Generator, Iterable, List, Optional, Tuple, TYPE_CHECKING
 
 import numpy as np
 import scipy

From 3f25196a7a6aca63e718bba1a6c614c207565da4 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <58733990+hvarfner@users.noreply.github.com>
Date: Thu, 13 Apr 2023 13:05:45 +0200
Subject: [PATCH 09/23] Update botorch/acquisition/joint_entropy_search.py

Co-authored-by: Max Balandat <Balandat@users.noreply.github.com>
---
 botorch/acquisition/joint_entropy_search.py | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index c0a8770f14..315eb9dcd3 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -40,10 +40,11 @@
 # The CDF query cannot be strictly zero in the division
 # and this clamping helps assure that it is always positive.
 CLAMP_LB = torch.finfo(torch.float32).eps
-FULLY_BAYESIAN_ERROR_MSG = """JES is not yet available with Fully Bayesian GPs.
-Track the issue, which regards conditioning on a number of optima on a collecion
- of models, in detail at https://github.com/pytorch/botorch/issues/1680.
-"""
+FULLY_BAYESIAN_ERROR_MSG = (
+    "JES is not yet available with Fully Bayesian GPs. Track the issue, "
+    "which regards conditioning on a number of optima on a collection "
+    "of models, in detail at https://github.com/pytorch/botorch/issues/1680".
+)
 
 """
 References

From e6b45f3da894af31bd368ee3cc7527315387ac5b Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Thu, 13 Apr 2023 21:58:22 +0200
Subject: [PATCH 10/23] All minor changes in one commit

---
 botorch/acquisition/joint_entropy_search.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 315eb9dcd3..a687ddfbc0 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -43,7 +43,7 @@
 FULLY_BAYESIAN_ERROR_MSG = (
     "JES is not yet available with Fully Bayesian GPs. Track the issue, "
     "which regards conditioning on a number of optima on a collection "
-    "of models, in detail at https://github.com/pytorch/botorch/issues/1680".
+    "of models, in detail at https://github.com/pytorch/botorch/issues/1680"
 )
 
 """

From f0bd2f2690db5eb225b56f5890f30fc8924f72c3 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Mon, 17 Apr 2023 10:04:29 +0200
Subject: [PATCH 11/23] Moved the intro text

---
 botorch/acquisition/joint_entropy_search.py | 30 +++++++++------------
 1 file changed, 13 insertions(+), 17 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index a687ddfbc0..23316a86cd 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -5,9 +5,20 @@
 # LICENSE file in the root directory of this source tree.
 
 r"""
-Acquisition function for joint entropy search (JES). The code utilizes the
-implementation designed for the multi-objective batch setting.
+Acquisition function for joint entropy search (JES). 
 
+References
+.. [Hvarfner2022joint]
+    C. Hvarfner, F. Hutter, L. Nardi,
+    Joint Entropy Search for Maximally-informed Bayesian Optimization.
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
+
+.. [Tu2022joint]
+    B. Tu, A. Gandy, N. Kantas, B. Shafei,
+    Joint Entropy Search for Multi-objective Bayesian Optimization.
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
 """
 
 from __future__ import annotations
@@ -46,21 +57,6 @@
     "of models, in detail at https://github.com/pytorch/botorch/issues/1680"
 )
 
-"""
-References
-.. [Hvarfner2022joint]
-    C. Hvarfner, F. Hutter, L. Nardi,
-    Joint Entropy Search for Maximally-informed Bayesian Optimization.
-    In Proceedings of the Annual Conference on Neural Information
-    Processing Systems (NeurIPS), 2022.
-
-.. [Tu2022joint]
-    B. Tu, A. Gandy, N. Kantas, B. Shafei,
-    Joint Entropy Search for Multi-objective Bayesian Optimization.
-    In Proceedings of the Annual Conference on Neural Information
-    Processing Systems (NeurIPS), 2022.
-"""
-
 
 class qJointEntropySearch(AcquisitionFunction, MCSamplerMixin):
     r"""The acquisition function for the Joint Entropy Search, where the batches

From 5cfa3915f39a31dd5affcc0dfa71d8ddf47ba225 Mon Sep 17 00:00:00 2001
From: Elizabeth Santorella <elizabeth.santorella@gmail.com>
Date: Mon, 17 Apr 2023 08:24:28 -0400
Subject: [PATCH 12/23] Update botorch/acquisition/joint_entropy_search.py

whitespace
---
 botorch/acquisition/joint_entropy_search.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 23316a86cd..2e8a1ae209 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -5,7 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 r"""
-Acquisition function for joint entropy search (JES). 
+Acquisition function for joint entropy search (JES).
 
 References
 .. [Hvarfner2022joint]

From 4d562fe70b8d68c848e796424f7fa12e37cae36c Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 15:18:51 +0200
Subject: [PATCH 13/23] Modified tutuorial to fit with new structure, and
 changed seed in the example to better highlight differences Changed
 .forward() to call in optimize_posterior_samples

---
 botorch/acquisition/joint_entropy_search.py   |   2 +-
 botorch/utils/sampling.py                     |   4 +-
 ...tion_theoretic_acquisition_functions.ipynb | 164 ++++++++++++------
 3 files changed, 113 insertions(+), 57 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 2e8a1ae209..13615e78d1 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -65,7 +65,7 @@ class qJointEntropySearch(AcquisitionFunction, MCSamplerMixin):
     This acquisition function computes the mutual information between the observation
     at a candidate point `X` and the optimal input-output pair.
 
-    See [Tu2022]_ for a discussion on the estimation procedure.
+    See [Tu2022joint]_ for a discussion on the estimation procedure.
     """
 
     def __init__(
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index ea80d5ec4b..134436b537 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -909,12 +909,12 @@ def optimize_posterior_samples(
     if maximize:
 
         def path_func(x):
-            return paths.forward(x)
+            return paths(x)
 
     else:
 
         def path_func(x):
-            return -paths.forward(x)
+            return -paths(x)
 
     candidate_set = unnormalize(
         SobolEngine(dimension=bounds.shape[1], scramble=True).draw(raw_samples), bounds
diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 1fae74bb71..4b02dea8d7 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -287,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 3,
    "id": "5770f703",
    "metadata": {},
    "outputs": [],
@@ -295,7 +295,7 @@
     "torch.manual_seed(0)\n",
     "np.random.seed(0)\n",
     "n = 5\n",
-    "train_X = draw_sobol_samples(bounds=bounds, n=n, q=1, seed=123).squeeze(-2)\n",
+    "train_X = draw_sobol_samples(bounds=bounds, n=n, q=1, seed=12345678).squeeze(-2)\n",
     "train_Y = f(train_X)\n",
     "\n",
     "\n",
@@ -319,13 +319,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 4,
    "id": "877a342b",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -365,25 +365,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 5,
    "id": "79e93848",
    "metadata": {},
    "outputs": [],
    "source": [
-    "from botorch.acquisition.multi_objective.utils import (\n",
-    "    sample_optimal_points,\n",
-    "    random_search_optimizer,\n",
-    ")\n",
+    "from botorch.acquisition.utils import get_optimal_samples\n",
     "\n",
-    "num_samples = 10\n",
-    "num_points = 1\n",
+    "num_samples = 32\n",
     "\n",
-    "optimal_inputs, optimal_outputs = sample_optimal_points(\n",
-    "    model=model,\n",
+    "optimal_inputs, optimal_outputs = get_optimal_samples(\n",
+    "    model,\n",
     "    bounds=bounds,\n",
-    "    num_samples=num_samples,\n",
-    "    num_points=num_points,\n",
-    "    optimizer=random_search_optimizer,\n",
+    "    num_optima=num_samples\n",
     ")"
    ]
   },
@@ -399,32 +393,28 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "320b07cc",
    "metadata": {},
    "outputs": [],
    "source": [
     "from botorch.acquisition.predictive_entropy_search import qPredictiveEntropySearch\n",
-    "from botorch.acquisition.multi_objective.max_value_entropy_search import (\n",
-    "    qLowerBoundMultiObjectiveMaxValueEntropySearch,\n",
+    "from botorch.acquisition.max_value_entropy_search import (\n",
+    "    qLowerBoundMaxValueEntropy,\n",
     ")\n",
-    "from botorch.acquisition.joint_entropy_search import qLowerBoundJointEntropySearch\n",
-    "from botorch.acquisition.multi_objective.utils import compute_sample_box_decomposition\n",
+    "from botorch.acquisition.joint_entropy_search import qJointEntropySearch\n",
     "\n",
-    "pes = qPredictiveEntropySearch(model=model, optimal_inputs=optimal_inputs.squeeze(-2))\n",
-    "\n",
-    "# Compute the box-decomposition\n",
-    "hypercell_bounds = compute_sample_box_decomposition(optimal_outputs)\n",
+    "pes = qPredictiveEntropySearch(model=model, optimal_inputs=optimal_inputs)\n",
     "\n",
     "# Here we use the lower bound estimates for the MES and JES\n",
-    "mes_lb = qLowerBoundMultiObjectiveMaxValueEntropySearch(\n",
+    "# Note that the single-objective MES interface is slightly different,\n",
+    "# as it utilizes the Gumbel max-value approximation internally and \n",
+    "# therefore does not take the max values as input.\n",
+    "mes_lb = qLowerBoundMaxValueEntropy(\n",
     "    model=model,\n",
-    "    pareto_fronts=optimal_outputs,\n",
-    "    hypercell_bounds=hypercell_bounds,\n",
-    "    estimation_type=\"LB\",\n",
+    "    candidate_set=torch.rand(1000, 1),\n",
     ")\n",
-    "\n",
-    "jes_lb = qLowerBoundJointEntropySearch(\n",
+    "jes_lb = qJointEntropySearch(\n",
     "    model=model,\n",
     "    optimal_inputs=optimal_inputs,\n",
     "    optimal_outputs=optimal_outputs,\n",
@@ -442,18 +432,44 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "id": "382e37f4",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "pes_X = pes(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
-    "mes_lb_X = mes_lb(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
-    "jes_lb_X = jes_lb(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
+    "# the acquisition function call takes a three-dimensional tensor\n",
+    "fwd_X = X.unsqueeze(-1).unsqueeze(-1)\n",
+    "\n",
+    "# make the acquisition functions live on the same scale\n",
+    "scale_acqvals = True\n",
     "\n",
+    "pes_X = pes(fwd_X).detach().numpy()\n",
+    "mes_lb_X = mes_lb(fwd_X).detach().numpy()\n",
+    "jes_lb_X = jes_lb(fwd_X).detach().numpy()\n",
+    "\n",
+    "if scale_acqvals:\n",
+    "    pes_X = pes_X / pes_X.max()\n",
+    "    mes_lb_X = mes_lb_X / mes_lb_X.max()\n",
+    "    jes_lb_X = jes_lb_X / jes_lb_X.max()\n",
+    "    \n",
     "plt.plot(X, pes_X, color=\"mediumseagreen\", linewidth=3, label=\"PES\")\n",
     "plt.plot(X, mes_lb_X, color=\"crimson\", linewidth=3, label=\"MES-LB\")\n",
     "plt.plot(X, jes_lb_X, color=\"dodgerblue\", linewidth=3, label=\"JES-LB\")\n",
+    "\n",
+    "plt.vlines(X[pes_X.argmax()], 0, 1, color=\"mediumseagreen\", linewidth=1.5, linestyle='--')\n",
+    "plt.vlines(X[mes_lb_X.argmax()], 0, 1, color=\"crimson\", linewidth=1.5, linestyle=':')\n",
+    "plt.vlines(X[jes_lb_X.argmax()], 0, 1, color=\"dodgerblue\", linewidth=1.5, linestyle='--')\n",
     "plt.legend(fontsize=15)\n",
     "plt.xlabel(\"$x$\", fontsize=15)\n",
     "plt.ylabel(r\"$\\alpha(x)$\", fontsize=15)\n",
@@ -471,10 +487,20 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "id": "f7f639bb",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PES: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.17330018797192714\n",
+      "MES-LB: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.042861226761573626\n",
+      "JES-LB: candidate=tensor([[0.3879]], dtype=torch.float64), acq_value=0.5383259121881295\n"
+     ]
+    }
+   ],
    "source": [
     "from botorch.optim import optimize_acqf\n",
     "\n",
@@ -526,13 +552,17 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 9,
    "id": "fabc86e9",
    "metadata": {},
    "outputs": [],
    "source": [
     "from botorch.test_functions.multi_objective import ZDT1\n",
-    "\n",
+    "from botorch.acquisition.multi_objective.utils import (\n",
+    "    sample_optimal_points,\n",
+    "    random_search_optimizer,\n",
+    "    compute_sample_box_decomposition\n",
+    ")\n",
     "d = 4\n",
     "M = 2\n",
     "n = 16\n",
@@ -556,7 +586,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 10,
    "id": "56bd5f5a",
    "metadata": {},
    "outputs": [],
@@ -590,14 +620,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "id": "2c7dfaf0",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hvarfner/Documents/botorch/botorch/models/gpytorch.py:96: BotorchTensorDimensionWarning: Non-strict enforcement of botorch tensor conventions. Ensure that target tensors Y has an explicit output dimension.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "from botorch.acquisition.multi_objective.predictive_entropy_search import (\n",
     "    qMultiObjectivePredictiveEntropySearch,\n",
     ")\n",
+    "from botorch.acquisition.multi_objective.max_value_entropy_search import (\n",
+    "    qLowerBoundMultiObjectiveMaxValueEntropySearch,\n",
+    ")\n",
     "from botorch.acquisition.multi_objective.joint_entropy_search import (\n",
     "    qLowerBoundMultiObjectiveJointEntropySearch,\n",
     ")\n",
@@ -634,10 +676,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "ceac58f5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PES: \n",
+      "candidates=tensor([[0.0000, 0.0000, 0.5909, 0.0000],\n",
+      "        [0.0491, 0.0000, 0.0000, 0.4991],\n",
+      "        [0.0196, 0.5491, 0.0000, 0.0278],\n",
+      "        [0.1252, 0.0000, 0.0721, 0.0000]], dtype=torch.float64)\n",
+      "MES-LB: \n",
+      "candidates=tensor([[0.1225, 0.0000, 0.1670, 0.1139],\n",
+      "        [0.0300, 0.0040, 0.9779, 0.2452],\n",
+      "        [0.6412, 0.0117, 0.0516, 0.0337],\n",
+      "        [0.0000, 0.3417, 0.8467, 0.5234]], dtype=torch.float64)\n",
+      "JES-LB: \n",
+      "candidates=tensor([[0.1730, 0.2471, 0.1120, 0.0229],\n",
+      "        [0.0000, 0.2464, 0.3733, 0.4131],\n",
+      "        [0.1596, 0.0000, 0.5558, 0.1183],\n",
+      "        [0.7028, 0.0661, 0.0934, 0.0351]], dtype=torch.float64)\n"
+     ]
+    }
+   ],
    "source": [
     "q = 4\n",
     "\n",
@@ -674,14 +738,6 @@
     ")\n",
     "print(\"JES-LB: \\ncandidates={}\".format(candidates))"
    ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": null,
-   "id": "23585d6d",
-   "metadata": {},
-   "outputs": [],
-   "source": []
   }
  ],
  "metadata": {
@@ -700,7 +756,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.9.13"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,

From 033a565d6310d8edf701c3bdb27f83274db614e6 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 15:32:47 +0200
Subject: [PATCH 14/23] Addition of all JES changes after rebase -
 Acqf.constructor - Sample optimization - Re-writing of Single-obj JES - Tests
 - Notebook fitting and changed examples for illustration's sake

---
 botorch/acquisition/input_constructors.py     |  35 ++
 botorch/acquisition/joint_entropy_search.py   | 321 +++++++++++++++---
 botorch/acquisition/utils.py                  |  41 ++-
 botorch/utils/sampling.py                     |  68 ++++
 test/acquisition/test_input_constructors.py   |  29 ++
 test/acquisition/test_joint_entropy_search.py |  19 +-
 test/acquisition/test_utils.py                |  34 ++
 test/utils/test_sampling.py                   |  43 ++-
 ...tion_theoretic_acquisition_functions.ipynb | 269 ++++++---------
 9 files changed, 633 insertions(+), 226 deletions(-)

diff --git a/botorch/acquisition/input_constructors.py b/botorch/acquisition/input_constructors.py
index b53d7f382f..f2cd321d63 100644
--- a/botorch/acquisition/input_constructors.py
+++ b/botorch/acquisition/input_constructors.py
@@ -47,6 +47,7 @@
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
 )
+from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.max_value_entropy_search import (
     qMaxValueEntropy,
     qMultiFidelityMaxValueEntropy,
@@ -84,6 +85,7 @@
     expand_trace_observations,
     project_to_target_fidelity,
 )
+from botorch.acquisition.utils import get_optimal_samples
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models.cost import AffineFidelityCostModel
 from botorch.models.deterministic import FixedSingleSampleModel
@@ -1239,3 +1241,36 @@ def optimize_objective(
         return_best_only=True,
         sequential=sequential,
     )
+
+
+# TODO make single-objective with pairwise and multi-objective with pareto
+@acqf_input_constructor(qJointEntropySearch)
+def construct_inputs_qJES(
+    model: Model,
+    training_data: MaybeDict[SupervisedDataset],
+    bounds: Tensor,
+    num_optima: int = 64,
+    maximize: bool = True,
+    condition_noiseless: bool = True,
+    X_pending: Optional[Tensor] = None,
+    estimation_type: str = "LB",
+    num_samples: int = 64,
+    **kwargs: Any,
+):
+    dtype = model.train_targets.dtype
+    optimal_inputs, optimal_outputs = get_optimal_samples(
+        model, Tensor(bounds).to(dtype).T, num_optima=num_optima, maximize=maximize
+    )
+
+    inputs = {
+        "model": model,
+        "optimal_inputs": optimal_inputs,
+        "optimal_outputs": optimal_outputs,
+        "condition_noiseless": condition_noiseless,
+        "maximize": maximize,
+        "X_pending": X_pending,
+        "estimation_type": estimation_type,
+        "num_samples": num_samples,
+        **kwargs,
+    }
+    return inputs
diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index ca46933076..4fd11595ad 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -13,17 +13,46 @@
 from __future__ import annotations
 
 from typing import Any, Optional
+import warnings
+from math import pi
+import torch.distributions as dist
 
-from botorch.acquisition.multi_objective.joint_entropy_search import (
-    qLowerBoundMultiObjectiveJointEntropySearch,
-)
-from botorch.acquisition.multi_objective.utils import compute_sample_box_decomposition
+import torch
+from torch import Tensor
+
+from torch.distributions import Normal
+
+from botorch.models.utils import check_no_nans
+from botorch import settings
+from botorch.models.utils import fantasize as fantasize_flag
 from botorch.models.model import Model
+from botorch.models.gp_regression import MIN_INFERRED_NOISE_LEVEL
 from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
-from torch import Tensor
+from botorch.acquisition.monte_carlo import MCAcquisitionFunction
+from botorch.acquisition.acquisition import AcquisitionFunction, MCSamplerMixin
+from botorch.sampling.normal import SobolQMCNormalSampler
+from botorch.utils.transforms import is_fully_bayesian
+from botorch.exceptions.warnings import BotorchTensorDimensionWarning
 
+MCMC_DIM = -3  # Only relevant if you do Fully Bayesian GPs.
+ESTIMATION_TYPES = ["MC", "LB"]
+"""
+References
+.. [Hvarfner2022joint]
+    C. Hvarfner, F. Hutter, L. Nardi,
+    Joint Entropy Search for Maximally-informed Bayesian Optimization. 
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
 
-class qLowerBoundJointEntropySearch(qLowerBoundMultiObjectiveJointEntropySearch):
+.. [Tu2022joint]
+    B. Tu, A. Gandy, N. Kantas, B. Shafei,
+    Joint Entropy Search for Multi-objective Bayesian Optimization. 
+    In Proceedings of the Annual Conference on Neural Information
+    Processing Systems (NeurIPS), 2022.
+"""
+
+
+class qJointEntropySearch(AcquisitionFunction, MCSamplerMixin):
     r"""The acquisition function for the Joint Entropy Search, where the batches
     `q > 1` are supported through the lower bound formulation.
 
@@ -31,14 +60,6 @@ class qLowerBoundJointEntropySearch(qLowerBoundMultiObjectiveJointEntropySearch)
     at a candidate point `X` and the optimal input-output pair.
 
     See [Tu2022]_ for a discussion on the estimation procedure.
-
-    NOTES:
-    (i) The estimated acquisition value could be negative.
-
-    (ii) The lower bound batch acquisition function might not be monotone in the
-    sense that adding more elements to the batch does not necessarily increase the
-    acquisition value. Specifically, the acquisition value can become smaller when
-    more inputs are added.
     """
 
     def __init__(
@@ -46,11 +67,12 @@ def __init__(
         model: Model,
         optimal_inputs: Tensor,
         optimal_outputs: Tensor,
-        maximize: bool = True,
-        hypercell_bounds: Tensor = None,
+        condition_noiseless: bool = True,
+        posterior_transform: Optional[PosteriorTransform] = None,
         X_pending: Optional[Tensor] = None,
         estimation_type: str = "LB",
-        num_samples: int = 64,
+        maximize: bool = True,
+        num_samples: int = 256,
         **kwargs: Any,
     ) -> None:
         r"""Joint entropy search acquisition function.
@@ -62,42 +84,196 @@ def __init__(
                 sample only contains one optimal set of inputs.
             optimal_outputs: A `num_samples x 1`-dim Tensor containing the optimal
                 set of objectives of dimension `1`.
+            condition_noiseless: Whether to condition on noiseless optimal observations
+                f* [Hvarfner et. al.]or noisy optimal observations y* [Tu et. al,].
+                These are sampled identically, so this only controls the fashion in
+                which the GP is reshaped as a result of conditioning on the optimum.
+            posterior_transform: A PosteriorTransform (optional).
+            estimation_type: estimation_type: A string to determine which entropy
+                estimate is computed: Lower bound" ("LB") or "Monte Carlo" ("MC").
+                Lower Bound is recommended due to the relatively high variance
+                of the MC estimator.
             maximize: If true, we consider a maximization problem.
-            hypercell_bounds:  A `num_samples x 2 x J x 1`-dim Tensor containing the
-                hyper-rectangle bounds for integration, where `J` is the number of
-                hyper-rectangles. By default, the problem is assumed to be
-                unconstrained and therefore the region of integration for a sample
-                `(x*, y*)` is a `J=1` hyper-rectangle of the form  `(-infty, y^*]`
-                for a maximization problem and `[y^*, +infty)` for a minimization
-                problem. In the constrained setting, the region of integration also
-                includes the infeasible space.
             X_pending: A `m x d`-dim Tensor of `m` design points that have been
-                submitted for function evaluation, but have not yet been evaluated.
-            estimation_type: A string to determine which entropy estimate is
-                computed: "0", "LB", "LB2", or "MC". In the single-objective
-                setting, "LB" is equivalent to "LB2".
+                submitted for function evaluation, but have not yet been evaluated
             num_samples: The number of Monte Carlo samples used for the Monte Carlo
                 estimate.
         """
-        if hypercell_bounds is None:
-            hypercell_bounds = compute_sample_box_decomposition(
-                pareto_fronts=optimal_outputs.unsqueeze(-2), maximize=maximize
-            )
+        super().__init__(model=model)
+        sampler = SobolQMCNormalSampler(sample_shape=torch.Size([num_samples]))
+        MCSamplerMixin.__init__(self, sampler=sampler)
+        # To enable fully bayesian GP conditioning, we need to unsqueeze
+        # to get num_optima x num_gps unique GPs
 
-        super().__init__(
-            model=model,
-            pareto_sets=optimal_inputs.unsqueeze(-2),
-            pareto_fronts=optimal_outputs.unsqueeze(-2),
-            hypercell_bounds=hypercell_bounds,
-            X_pending=X_pending,
-            estimation_type=estimation_type,
-            num_samples=num_samples,
-        )
+        # inputs come as num_optima_per_model x (num_models) x d
+        # but we want it four-dimensional in the Fully bayesian case,
+        # and three-dimensional otherwise.
+        self.optimal_inputs = optimal_inputs.unsqueeze(-2)
+        self.optimal_outputs = optimal_outputs.unsqueeze(-2)
+        self.posterior_transform = posterior_transform
+        self.maximize = maximize
+
+        # The optima (can be maxima, can be minima) come in as the largest
+        # values if we optimize, or the smallest (likely substantially negative)
+        # if we minimize. Inside the acquisition function, however, we always
+        # want to consider MAX-values. As such, we need to flip them if
+        # we want to minimize.
+        if not self.maximize:
+            optimal_outputs = (-1) * optimal_outputs
+        self.num_samples = optimal_inputs.shape[0]
+        self.condition_noiseless = condition_noiseless
+        self.initial_model = model
+        tkwargs = {"dtype": optimal_outputs.dtype, "device": optimal_outputs.device}
+
+        # Here, the optimal inputs have shapes num_optima x [num_models if FB] x 1 x D
+        # and the optimal outputs have shapes num_optima x [num_models if FB] x 1 x 1
+        # The third dimension equaling 1 is required to get one optimum per model,
+        # which raises a BotorchTensorDimensionWarning.
+        with warnings.catch_warnings():
+            warnings.filterwarnings("ignore")
+            with fantasize_flag():
+                with settings.propagate_grads(False):
+                    post_ps = self.initial_model.posterior(
+                        self.model.train_inputs[0], observation_noise=False
+                    )
+                    sample_idx = 0
+
+                # This equates to the JES version proposed by Hvarfner et. al.
+                if self.condition_noiseless:
+                    opt_noise = torch.full_like(
+                        self.optimal_outputs, MIN_INFERRED_NOISE_LEVEL)
+                    # conditional (batch) model of shape (num_models) x num_optima_per_model
+                else:
+                    opt_noise = None
+
+                self.conditional_model = self.initial_model.condition_on_observations(
+                    X=self.initial_model.transform_inputs(self.optimal_inputs),
+                    Y=self.optimal_outputs,
+                    noise=opt_noise,
+                )
+
+        self.estimation_type = estimation_type
+        self.set_X_pending(X_pending)
 
     @concatenate_pending_points
     @t_batch_mode_transform()
     def forward(self, X: Tensor) -> Tensor:
         r"""Evaluates qLowerBoundJointEntropySearch at the design points `X`.
+        Args:
+            X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
+            `d`-dim design points each.
+
+        Returns:
+            A `batch_shape`-dim Tensor of acquisition values at the given design
+            points `X`.
+        """
+        if self.estimation_type == "LB":
+            res = self._compute_lower_bound_information_gain(X)
+        elif self.estimation_type == "MC":
+            res = self._compute_monte_carlo_information_gain(X)
+        else:
+            raise ValueError(
+                f"Estimation type {self.estimation_type} is not valid."
+                f"Please specify any of {ESTIMATION_TYPES}"
+            )
+        return res
+
+    def _compute_lower_bound_information_gain(
+        self, X: Tensor, return_parts: bool = False
+    ) -> Tensor:
+        r"""Evaluates the lower bound information gain at the design points `X`.
+
+        Args:
+            X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
+            `d`-dim design points each.
+
+        Returns:
+            A `batch_shape`-dim Tensor of acquisition values at the given design
+            points `X`.
+        """
+        tkwargs = {
+            "dtype": self.optimal_outputs.dtype,
+            "device": self.optimal_outputs.device,
+        }
+        initial_posterior = self.initial_model.posterior(X, observation_noise=True)
+        # need to check if there is a two-dimensional batch shape -
+        # the sampled optima appear in the dimension right after
+        batch_shape = X.shape[:-2]
+        sample_dim = len(batch_shape)
+        # We DISREGARD the additional constant term.
+        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+
+        # initial_entropy of shape batch_size or batch_size x num_models if FBGP
+        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        initial_entropy = (
+            initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
+        )
+
+        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
+        # Compute the mixture mean and variance
+        posterior_m = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=True
+        )
+        noiseless_var = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=False
+        ).variance
+
+        mean_m = posterior_m.mean
+        if not self.maximize:
+            mean_m = -mean_m
+        variance_m = posterior_m.variance
+
+        check_no_nans(variance_m)
+        # get stdv of noiseless variance
+        stdv = noiseless_var.sqrt()
+        # batch_shape x 1
+        normal = torch.distributions.Normal(
+            torch.zeros(1, device=X.device, dtype=X.dtype),
+            torch.ones(1, device=X.device, dtype=X.dtype),
+        )
+        normalized_mvs = (self.optimal_outputs - mean_m) / stdv
+        cdf_mvs = normal.cdf(normalized_mvs).clamp_min(CLAMP_LB)
+        pdf_mvs = torch.exp(normal.log_prob(normalized_mvs))
+
+        ratio = pdf_mvs / cdf_mvs
+        var_truncated = noiseless_var * (
+            1 - (normalized_mvs + ratio) * ratio
+        ).clamp_min(CLAMP_LB)
+
+        var_truncated = var_truncated + (variance_m - noiseless_var)
+        conditional_entropy = 0.5 * torch.log(var_truncated)
+
+        # Shape batch_size x num_optima x [num_models if FB] x q x num_outputs
+        # squeeze the num_outputs dim (since it's 1)
+        entropy_reduction = (
+            initial_entropy - conditional_entropy.sum(dim=-2, keepdim=True)
+        ).squeeze(-1)
+        # average over the number of optima and squeeze the q-batch
+
+        entropy_reduction = entropy_reduction.mean(dim=sample_dim).squeeze(-1)
+        return entropy_reduction
+
+    def _compute_monte_carlo_variables(self, posterior):
+        """Retrieved the monte carlo samples  and their log probabilities from the posterior.
+
+        Args:
+            posterior: The posterior distribution.
+
+        Returns:
+            A two-element tuple containing:
+            - samples: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of samples drawn from the posterior.
+            - samples_log_prob: a num_optima x batch_shape x num_mc_samples x q x 1 tensor of associated probabilities.
+        """
+        samples = self.get_posterior_samples(posterior)
+        samples_log_prob = (
+            posterior.mvn.log_prob(samples.squeeze(-1)).unsqueeze(-1).unsqueeze(-1)
+        )
+        return samples, samples_log_prob
+
+    def _compute_monte_carlo_information_gain(
+        self, X: Tensor, return_parts: bool = False
+    ) -> Tensor:
+        r"""Evaluates the lower bound information gain at the design points `X`.
 
         Args:
             X: A `batch_shape x q x d`-dim Tensor of `batch_shape` t-batches with `q`
@@ -107,5 +283,64 @@ def forward(self, X: Tensor) -> Tensor:
             A `batch_shape`-dim Tensor of acquisition values at the given design
             points `X`.
         """
+        tkwargs = {
+            "dtype": self.optimal_outputs.dtype,
+            "device": self.optimal_outputs.device,
+        }
+
+        initial_posterior = self.initial_model.posterior(X, observation_noise=True)
+
+        add_term = 0.5 * (1 + torch.log(torch.ones(1, **tkwargs) * 2 * pi))
+        batch_shape = X.shape[:-2]
+        sample_dim = len(batch_shape)
+        # We DISREGARD the additional constant term.
+        initial_entropy = 0.5 * torch.logdet(initial_posterior.mvn.covariance_matrix)
+
+        # initial_entropy of shape batch_size or batch_size x num_models if FBGP
+        # first need to unsqueeze the sample dim (first after batch dim) and then the two last
+        initial_entropy = (
+            initial_entropy.unsqueeze(sample_dim).unsqueeze(-1).unsqueeze(-1)
+        )
+
+        CLAMP_LB = torch.finfo(tkwargs["dtype"]).eps
+        # Compute the mixture mean and variance
+        posterior_m = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=True
+        )
+        noiseless_var = self.conditional_model.posterior(
+            X.unsqueeze(MCMC_DIM), observation_noise=False
+        ).variance
+
+        mean_m = posterior_m.mean
+        if not self.maximize:
+            mean_m = -mean_m
+        variance_m = posterior_m.variance.clamp_min(CLAMP_LB)
+        conditional_samples, conditional_logprobs = self._compute_monte_carlo_variables(
+            posterior_m
+        )
+
+        normalized_samples = (conditional_samples - mean_m) / variance_m.sqrt()
+        # Correlation between noisy observations and noiseless values f
+        rho = (noiseless_var / variance_m).sqrt()
+
+        normal = torch.distributions.Normal(
+            torch.zeros(1, device=X.device, dtype=X.dtype),
+            torch.ones(1, device=X.device, dtype=X.dtype),
+        )
+        # prepare max value quantities and re-scale as required
+        normalized_mvs = (self.optimal_outputs - mean_m) / noiseless_var.sqrt()
+        mvs_rescaled_mc = (normalized_mvs - rho * normalized_samples) / (1 - rho**2)
+        cdf_mvs = normal.cdf(normalized_mvs).clamp_min(CLAMP_LB)
+        cdf_rescaled_mvs = normal.cdf(mvs_rescaled_mc).clamp_min(CLAMP_LB)
+        mv_ratio = cdf_rescaled_mvs / cdf_mvs
+
+        log_term = torch.log(mv_ratio) + conditional_logprobs
+        conditional_entropy = -(mv_ratio * log_term).mean(0)
+        entropy_reduction = (
+            initial_entropy - conditional_entropy.sum(dim=-2, keepdim=True)
+        ).squeeze(-1)
+
+        # average over the number of optima and squeeze the q-batch
+        entropy_reduction = entropy_reduction.mean(dim=sample_dim).squeeze(-1)
 
-        return self._compute_lower_bound_information_gain(X)
+        return entropy_reduction
diff --git a/botorch/acquisition/utils.py b/botorch/acquisition/utils.py
index 21f14fcbdf..6f9f999ee3 100644
--- a/botorch/acquisition/utils.py
+++ b/botorch/acquisition/utils.py
@@ -11,7 +11,7 @@
 from __future__ import annotations
 
 import math
-from typing import Callable, Dict, List, Optional, Union
+from typing import Callable, Dict, List, Optional, Union, Tuple
 
 import torch
 from botorch.acquisition import analytic, monte_carlo, multi_objective  # noqa F401
@@ -31,6 +31,8 @@
     FastNondominatedPartitioning,
     NondominatedPartitioning,
 )
+from botorch.utils.sampling import optimize_posterior_samples
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.transforms import is_fully_bayesian
 from torch import Tensor
 
@@ -473,3 +475,40 @@ def project_to_sample_points(X: Tensor, sample_points: Tensor) -> Tensor:
     X_new = X.repeat(*(1 for _ in batch_shape), p, 1)  # batch_shape x p x d
     X_new[..., -d_prime:] = sample_points
     return X_new
+
+
+def get_optimal_samples(
+    model: Model,
+    bounds: Tensor,
+    num_optima: int,
+    raw_samples: int = 1024,
+    num_restarts: int = 20,
+    maximize: bool = True,
+) -> Tuple[Tensor, Tensor]:
+    """Draws sample paths from the posterior and maximizes the samples using GD.
+
+    Args:
+        model (Model): The model from which samples are drawn.
+        bounds: (Tensor): The bounds of the search space. If the model inputs are normalized,
+            the bounds should be normalized as well.
+        num_optima (int): The number of paths to be drawn and optimized.
+        raw_samples (int, optional): The number of candidates randomly sample. Defaults to 512.
+        num_restarts (int, optional): The number of candidates to do gradient-based optimization on.
+        Defaults to 20.
+        maxiter (int, optional): The maximal number of iterations of gradient-based optimization.
+        Defaults to 100.
+        maximize: Whether to maximize or minimize the samples.
+    Returns:
+        Tuple[Tensor, Tensor]: The optimal input locations and corresponding
+        outputs, x* and f*.
+
+    """
+    paths = draw_matheron_paths(model, sample_shape=torch.Size([num_optima]))
+    optimal_inputs, optimal_outputs = optimize_posterior_samples(
+        paths,
+        bounds=bounds,
+        raw_samples=raw_samples,
+        num_restarts=num_restarts,
+        maximize=maximize,
+    )
+    return optimal_inputs, optimal_outputs
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 0f59da1c44..8269b02191 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -28,6 +28,7 @@
 from scipy.spatial import Delaunay, HalfspaceIntersection
 from torch import LongTensor, Tensor
 from torch.quasirandom import SobolEngine
+from botorch.utils.transforms import unnormalize
 
 
 @contextmanager
@@ -873,3 +874,70 @@ def sparse_to_dense_constraints(
         A[i, indices.long()] = coefficients
         b[i] = rhs
     return A, b
+
+
+def optimize_posterior_samples(
+    paths: SamplePath,
+    bounds: Tensor,
+    candidates: Optional[Tensor] = None,
+    raw_samples: Optional[int] = 1024,
+    num_restarts: int = 20,
+    maximize: bool = True,
+    **kwargs: Any,
+) -> Tuple[Tensor, Tensor]:
+    r"""Cheaply maximizes posterior samples by random querying followed by vanilla
+    gradient descent on the best num_restarts points.
+
+    Args:
+        paths: Random Fourier Feature-based sample paths from the GP
+        bounds: The bounds on the search space.
+        candidates: A priori good candidates (typically previous design points)
+            which acts as extra initial guesses for the optimization routine.
+        raw_samples: The number of samples with which to query the samples initially.
+        num_restarts: The number of points selected for gradient-based optimization.
+        maximize: Boolean indicating whether to maimize or minimize
+    Returns:
+        A two-element tuple containing:
+            - X_opt: A `num_optima x [batch_size] x d`-dim tensor of optimal inputs x*.
+            - f_opt: A `num_optima x [batch_size] x 1`-dim tensor of optimal outputs f*.
+    """
+    if maximize:
+
+        def path_func(x):
+            return paths.forward(x)
+
+    else:
+
+        def path_func(x):
+            return -paths.forward(x)
+
+    candidate_set = unnormalize(
+        SobolEngine(dimension=bounds.shape[1], scramble=True).draw(raw_samples), bounds
+    )
+
+    # queries all samples on all candidates - output shape
+    # raw_samples * num_optima * num_models
+    candidate_queries = path_func(candidate_set)
+    argtop_k = torch.topk(candidate_queries, num_restarts, dim=-1).indices
+    X_top_k = candidate_set[argtop_k, :]
+
+    # to avoid circular import, the import occurs here
+    from botorch.generation.gen import gen_candidates_scipy
+
+    X_top_k, f_top_k = gen_candidates_scipy(
+        X_top_k, path_func, lower_bounds=bounds[0], upper_bounds=bounds[1], **kwargs
+    )
+    f_opt, arg_opt = f_top_k.max(dim=-1, keepdim=True)
+
+    # For each sample (and possibly for every model in the batch of models), this
+    # retrieves the argmax. We flatten, pick out the indices and then reshape to
+    # the original batch shapes (so instead of pickig out the argmax of a
+    # (3, 7, num_restarts, D)) along the num_restarts dim, we pick it out of a
+    # (21  , num_restarts, D)
+    final_shape = candidate_queries.shape[:-1]
+    X_opt = X_top_k.reshape(final_shape.numel(), num_restarts, -1)[
+        torch.arange(final_shape.numel()), arg_opt.flatten()
+    ].reshape(*final_shape, -1)
+    if not maximize:
+        f_opt = -f_opt
+    return X_opt, f_opt
diff --git a/test/acquisition/test_input_constructors.py b/test/acquisition/test_input_constructors.py
index 2ffbc8432b..1c7aa64524 100644
--- a/test/acquisition/test_input_constructors.py
+++ b/test/acquisition/test_input_constructors.py
@@ -27,6 +27,9 @@
     get_best_f_analytic,
     get_best_f_mc,
 )
+from botorch.acquisition.joint_entropy_search import (
+    qJointEntropySearch,
+)
 from botorch.acquisition.knowledge_gradient import (
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
@@ -976,3 +979,29 @@ def test_construct_inputs_mfmes(self):
             inputs_mfmes = input_constructor(**constructor_args)
             inputs_test = {"foo": 0, "bar": 1, "current_value": current_value}
             self.assertEqual(inputs_mfmes, inputs_test)
+
+    def test_construct_inputs_jes(self):
+        func = get_acqf_input_constructor(qJointEntropySearch)
+        # we need to run optimize_posterior_samples, so we sort of need
+        # a real model as there is no other (apparent) option
+        model = SingleTaskGP(self.blockX_blockY[0].X(), self.blockX_blockY[0].Y())
+
+        kwargs = func(
+            model=model,
+            training_data=self.blockX_blockY,
+            objective=LinearMCObjective(torch.rand(2)),
+            bounds=self.bounds,
+            num_optima=17,
+            maximize=False,
+        )
+
+        self.assertFalse(kwargs["maximize"])
+        self.assertEqual(
+            self.blockX_blockY[0].X().dtype, kwargs["optimal_inputs"].dtype
+        )
+        self.assertEqual(len(kwargs["optimal_inputs"]), 17)
+        self.assertEqual(len(kwargs["optimal_outputs"]), 17)
+        # asserting that, for the non-batch case, the optimal inputs are
+        # of shape N x D and outputs are N x 1
+        self.assertEqual(len(kwargs["optimal_inputs"].shape), 2)
+        self.assertEqual(len(kwargs["optimal_outputs"].shape), 2)
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index d554c58bc9..1f6fd21c8c 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -7,7 +7,9 @@
 from itertools import product
 
 import torch
-from botorch.acquisition.joint_entropy_search import qLowerBoundJointEntropySearch
+from botorch.acquisition.joint_entropy_search import (
+    qJointEntropySearch,
+)
 
 from botorch.models.gp_regression import SingleTaskGP
 from botorch.models.model_list_gp_regression import ModelListGP
@@ -48,13 +50,18 @@ def get_model(train_X, train_Y, use_model_list, standardize_model):
     return model
 
 
-class TestQLowerBoundJointEntropySearch(BotorchTestCase):
-    def test_lower_bound_joint_entropy_search(self):
+class TestQJointEntropySearch(BotorchTestCase):
+    def test_joint_entropy_search(self):
         torch.manual_seed(1)
         tkwargs = {"device": self.device}
-        estimation_types = ("0", "LB", "LB2", "MC")
+        estimation_types = ("LB", "MC")
         num_objectives = 1
-        for (dtype, estimation_type, use_model_list, standardize_model,) in product(
+        for (
+            dtype,
+            estimation_type,
+            use_model_list,
+            standardize_model,
+        ) in product(
             (torch.float, torch.double),
             estimation_types,
             (False, True),
@@ -76,7 +83,7 @@ def test_lower_bound_joint_entropy_search(self):
             X_pending_list = [None, torch.rand(2, input_dim, **tkwargs)]
             for i in range(len(X_pending_list)):
                 X_pending = X_pending_list[i]
-                acq = qLowerBoundJointEntropySearch(
+                acq = qJointEntropySearch(
                     model=model,
                     optimal_inputs=optimal_inputs,
                     optimal_outputs=optimal_outputs,
diff --git a/test/acquisition/test_utils.py b/test/acquisition/test_utils.py
index 56908f9c5f..874dc69946 100644
--- a/test/acquisition/test_utils.py
+++ b/test/acquisition/test_utils.py
@@ -25,8 +25,10 @@
     project_to_sample_points,
     project_to_target_fidelity,
     prune_inferior_points,
+    get_optimal_samples,
 )
 from botorch.exceptions.errors import UnsupportedError
+from botorch.models import SingleTaskGP
 from botorch.utils.multi_objective.box_decompositions.non_dominated import (
     FastNondominatedPartitioning,
     NondominatedPartitioning,
@@ -766,3 +768,35 @@ def test_project_to_sample_points(self):
                 self.assertAllClose(X_augmented[0, :, -d_prime:], sample_points)
             else:
                 self.assertAllClose(X_augmented[:, -d_prime:], sample_points)
+
+
+class TestGetOptimalSamples(BotorchTestCase):
+    def test_get_optimal_samples(self):
+        dims = 3
+        dtype = torch.float64
+        for_testing_speed_kwargs = {"raw_samples": 50, "num_restarts": 3}
+        num_optima = 7
+        batch_shape = (3,)
+
+        bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
+        X = torch.rand(*batch_shape, 4, dims).to(dtype)
+        Y = torch.sin(X).sum(dim=-1, keepdim=True).to(dtype)
+        model = SingleTaskGP(X, Y)
+        X_opt, f_opt = get_optimal_samples(
+            model, bounds, num_optima=num_optima, **for_testing_speed_kwargs
+        )
+        X_opt, f_opt_min = get_optimal_samples(
+            model,
+            bounds,
+            num_optima=num_optima,
+            maximize=False,
+            **for_testing_speed_kwargs,
+        )
+
+        correct_X_shape = (num_optima,) + batch_shape + (dims,)
+        correct_f_shape = (num_optima,) + batch_shape + (1,)
+        self.assertEqual(X_opt.shape, correct_X_shape)
+        self.assertEqual(f_opt.shape, correct_f_shape)
+        # asserting that the solutions found by minimization the samples are smaller
+        # than those found by maximization
+        self.assertTrue(torch.all(f_opt_min < f_opt))
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index e100e20448..f06f8b7bef 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -14,6 +14,7 @@
 import numpy as np
 import torch
 from botorch.exceptions.errors import BotorchError
+from botorch.models import FixedNoiseGP
 from botorch.utils.sampling import (
     _convert_bounds_to_inequality_constraints,
     batched_multinomial,
@@ -28,7 +29,9 @@
     sample_hypersphere,
     sample_simplex,
     sparse_to_dense_constraints,
+    optimize_posterior_samples,
 )
+from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.testing import BotorchTestCase
 
 
@@ -361,7 +364,6 @@ def test_get_polytope_samples(self):
 
 
 class PolytopeSamplerTestBase:
-
     sampler_class: Type[PolytopeSampler]
     sampler_kwargs: Dict[str, Any] = {}
 
@@ -505,13 +507,11 @@ class Result:
 
 
 class TestHitAndRunPolytopeSampler(PolytopeSamplerTestBase, BotorchTestCase):
-
     sampler_class = HitAndRunPolytopeSampler
     sampler_kwargs = {"n_burnin": 2}
 
 
 class TestDelaunayPolytopeSampler(PolytopeSamplerTestBase, BotorchTestCase):
-
     sampler_class = DelaunayPolytopeSampler
 
     def test_sample_polytope_unbounded(self):
@@ -528,3 +528,40 @@ def test_sample_polytope_unbounded(self):
                     interior_point=self.x0,
                     **self.sampler_kwargs,
                 )
+
+
+class TestOptimizePosteriorSamples(BotorchTestCase):
+    def test_optimize_posterior_samples(self):
+        dtypes = (torch.float32, torch.float64)
+        dims = 2
+        dtype = torch.float64
+        eps = 1e-6
+        for_testing_speed_kwargs = {"raw_samples": 250, "num_restarts": 3}
+        nums_optima = (1, 7)
+        batch_shapes = ((), (3,), (5, 2))
+        for num_optima, batch_shape in itertools.product(nums_optima, batch_shapes):
+            bounds = torch.Tensor([[0, 1]] * dims).T.to(dtype)
+            X = torch.rand(*batch_shape, 52, dims).to(dtype)
+            Y = torch.pow(X - 0.5, 2).sum(dim=-1, keepdim=True).to(dtype)
+
+            # having a noiseless model all but guarantees that the found optima
+            # will be better than the observations
+            model = FixedNoiseGP(X, Y, torch.full_like(Y, eps))
+            paths = draw_matheron_paths(
+                model=model, sample_shape=torch.Size([num_optima])
+            )
+            X_opt, f_opt = optimize_posterior_samples(
+                paths, bounds, **for_testing_speed_kwargs
+            )
+
+            correct_X_shape = (num_optima,) + batch_shape + (dims,)
+            correct_f_shape = (num_optima,) + batch_shape + (1,)
+
+            self.assertEqual(X_opt.shape, correct_X_shape)
+            self.assertEqual(f_opt.shape, correct_f_shape)
+            self.assertTrue(torch.all(X_opt >= bounds[0]))
+            self.assertTrue(torch.all(X_opt <= bounds[1]))
+
+            # Check that the all found optima are larger than the observations
+            # This is not 100% deterministic, but just about.
+            self.assertTrue(torch.all((f_opt > Y.max(dim=-2).values)))
diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index f7d4a92b90..58c053edb0 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -227,7 +227,9 @@
     "\n",
     "[3] B. Tu, A. Gandy, N. Kantas and B. Shafei, [**Joint Entropy Search for Multi-Objective Bayesian Optimization**](https://arxiv.org/abs/2210.02905), NeurIPS, 2022.\n",
     "\n",
-    "[4] E. Garrido-Merchán and D. Hernández-Lobato, [**Predictive Entropy Search for Multi-objective Bayesian Optimization with Constraints**](https://www.sciencedirect.com/science/article/abs/pii/S0925231219308525), Neurocomputing, 2019."
+    "[4] C. Hvarfner, F. Hutter and N. Nardi, [**Joint Entropy Search for Maximally-Informed Bayesian Optimization**](https://arxiv.org/abs/2206.04771), NeurIPS, 2022.\n",
+    "\n",
+    "[5] E. Garrido-Merchán and D. Hernández-Lobato, [**Predictive Entropy Search for Multi-objective Bayesian Optimization with Constraints**](https://www.sciencedirect.com/science/article/abs/pii/S0925231219308525), Neurocomputing, 2019."
    ]
   },
   {
@@ -253,8 +255,6 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "import os\n",
-    "\n",
     "import torch\n",
     "import numpy as np\n",
     "from botorch.utils.sampling import draw_sobol_samples\n",
@@ -264,16 +264,8 @@
     "from botorch.fit import fit_gpytorch_mll\n",
     "\n",
     "tkwargs = {\"dtype\": torch.double, \"device\": \"cpu\"}\n",
-    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 2,
-   "id": "c455b9f4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
+    "\n",
+    "\n",
     "def f(x):\n",
     "    p1 = torch.cos(torch.pi * x)\n",
     "    p2 = 10 * torch.sin(torch.pi * x)\n",
@@ -303,7 +295,7 @@
     "torch.manual_seed(0)\n",
     "np.random.seed(0)\n",
     "n = 5\n",
-    "train_X = draw_sobol_samples(bounds=bounds, n=n, q=1, seed=123).squeeze(-2)\n",
+    "train_X = draw_sobol_samples(bounds=bounds, n=n, q=1, seed=12345678).squeeze(-2)\n",
     "train_Y = f(train_X)\n",
     "\n",
     "\n",
@@ -328,24 +320,12 @@
   {
    "cell_type": "code",
    "execution_count": 4,
-   "id": "08e9cd46",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import matplotlib.pyplot as plt\n",
-    "\n",
-    "%matplotlib inline"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 5,
    "id": "877a342b",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -355,6 +335,10 @@
     }
    ],
    "source": [
+    "import matplotlib.pyplot as plt\n",
+    "\n",
+    "%matplotlib inline\n",
+    "\n",
     "X = torch.linspace(bounds[0, 0], bounds[1, 0], 1000, **tkwargs)\n",
     "mean_fX = model.posterior(X).mean.squeeze(-1).detach().numpy()\n",
     "std_fX = torch.sqrt(model.posterior(X).variance).squeeze(-1).detach().numpy()\n",
@@ -381,33 +365,19 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "05591efd",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from botorch.acquisition.multi_objective.utils import (\n",
-    "    sample_optimal_points,\n",
-    "    random_search_optimizer,\n",
-    ")"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 5,
    "id": "79e93848",
    "metadata": {},
    "outputs": [],
    "source": [
-    "num_samples = 10\n",
-    "num_points = 1\n",
+    "from botorch.acquisition.utils import get_optimal_samples\n",
     "\n",
-    "optimal_inputs, optimal_outputs = sample_optimal_points(\n",
-    "    model=model,\n",
+    "num_samples = 32\n",
+    "\n",
+    "optimal_inputs, optimal_outputs = get_optimal_samples(\n",
+    "    model,\n",
     "    bounds=bounds,\n",
-    "    num_samples=num_samples,\n",
-    "    num_points=num_points,\n",
-    "    optimizer=random_search_optimizer,\n",
+    "    num_optima=num_samples\n",
     ")"
    ]
   },
@@ -423,36 +393,31 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": 6,
    "id": "320b07cc",
    "metadata": {},
    "outputs": [],
    "source": [
     "from botorch.acquisition.predictive_entropy_search import qPredictiveEntropySearch\n",
-    "from botorch.acquisition.multi_objective.max_value_entropy_search import (\n",
-    "    qLowerBoundMultiObjectiveMaxValueEntropySearch,\n",
+    "from botorch.acquisition.max_value_entropy_search import (\n",
+    "    qLowerBoundMaxValueEntropy,\n",
     ")\n",
-    "from botorch.acquisition.joint_entropy_search import qLowerBoundJointEntropySearch\n",
-    "from botorch.acquisition.multi_objective.utils import compute_sample_box_decomposition\n",
+    "from botorch.acquisition.joint_entropy_search import qJointEntropySearch\n",
     "\n",
-    "pes = qPredictiveEntropySearch(model=model, optimal_inputs=optimal_inputs.squeeze(-2))\n",
-    "\n",
-    "# Compute the box-decomposition\n",
-    "hypercell_bounds = compute_sample_box_decomposition(optimal_outputs)\n",
+    "pes = qPredictiveEntropySearch(model=model, optimal_inputs=optimal_inputs)\n",
     "\n",
     "# Here we use the lower bound estimates for the MES and JES\n",
-    "mes_lb = qLowerBoundMultiObjectiveMaxValueEntropySearch(\n",
+    "# Note that the single-objective MES interface is slightly different,\n",
+    "# as it utilizes the Gumbel max-value approximation internally and \n",
+    "# therefore does not take the max values as input.\n",
+    "mes_lb = qLowerBoundMaxValueEntropy(\n",
     "    model=model,\n",
-    "    pareto_fronts=optimal_outputs,\n",
-    "    hypercell_bounds=hypercell_bounds,\n",
-    "    estimation_type=\"LB\",\n",
+    "    candidate_set=torch.rand(1000, 1),\n",
     ")\n",
-    "\n",
-    "jes_lb = qLowerBoundJointEntropySearch(\n",
+    "jes_lb = qJointEntropySearch(\n",
     "    model=model,\n",
-    "    optimal_inputs=optimal_inputs.squeeze(-2),\n",
-    "    optimal_outputs=optimal_outputs.squeeze(-2),\n",
-    "    hypercell_bounds=hypercell_bounds,\n",
+    "    optimal_inputs=optimal_inputs,\n",
+    "    optimal_outputs=optimal_outputs,\n",
     "    estimation_type=\"LB\",\n",
     ")"
    ]
@@ -467,13 +432,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 7,
    "id": "382e37f4",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkkAAAHPCAYAAABHgU5sAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAC6R0lEQVR4nOzdd1zT1/oH8E8SSMIMIFuRKW5A3Hvh3ltr66h11Np6r53e22Ft77Xttbf2dvm79lrtVNuqbbV1VMW9Fa2Kg43svQmQnN8flMD5JkFCAiTwvF8vXu335DtOUOLDOc95jogxxkAIIYQQQjjilu4AIYQQQog5oiCJEEIIIUQHCpIIIYQQQnSgIIkQQgghRAcKkgghhBBCdKAgiRBCCCFEBwqSCCGEEEJ0oCCJEEIIIUQHCpIIIYQQQnSgIIk0ikgkeuTXkiVLWrqbFikhIQEikQgjRoxo6a40qREjRkAkEiEhIaGlu9LsTPHeRSIR/Pz8mu265nD16lWMHTsWTk5Oms8RS/77sWPHDohEImzYsKGlu0IayaqlO0As2+LFi/W+NmTIEKPv7+fnh8TERNDuOYQ8WmRkJEaOHInFixdjx44dLd0dgxQVFWHq1KlIS0vDiBEj4OPjA5FIBHt7+5buml5LlizBzp07ceLEiVb/S01bRUESMYqlfRATYg6+/PJLlJaWon379o2+R3R0NKytrZvtuqZ2+fJlpKam4oknnsCXX37Z0t0xiRkzZmDAgAFwdXVt6a6QRqIgiRBCmlnHjh2NvkeXLl2a9bqm9vDhQwBAQEBAC/fEdBQKBRQKRUt3gxiBcpJIs6nJhVCpVHj33XcRHBwMmUwGHx8fvPzyy1AqlZpzIyMjIRKJkJiYqLm25qtuPkXd3I5vv/0WAwYMgIODA5ycnDTnlJaW4q233kKPHj1gY2MDhUKBYcOGYdeuXTr76efnB5FIBMYYPvzwQ3Tr1g1yuRzt27fHc889h/z8fO78yZMnQyQS4ciRIzrvV1paCicnJzg4OKCoqMig71lhYSHWrl0LHx8fyOVydO3aFR988AHUarXWuVFRUXjppZfQu3dvuLm5QSaTISAgAKtXr0ZqaqrO+9+6dQuPP/44AgICIJfL4ebmhrCwMPzlL39BWlqa1vnR0dFYsmQJfHx8IJPJ4OHhgfnz5+P27ds6769SqbB582Z06dIFcrkcPj4+WLt2LQoLCw36PgBAfn4+PvroI4wbNw6+vr6QyWRo164dxo8fj6NHj+q9rrKyElu3bsWQIUPg5OQEGxsbBAUFYenSpbh69arW+du3b0dYWBhsbGzg6emJJUuWID09HUuWLIFIJEJkZKTm3Eflj23YsAEikUhrxFVfTlJiYiKefvppBAcHw9bWFi4uLujevTtWrlyJe/fucecKfxaWLFmCkSNHAgB27tzJ/czUzYmpLyfp119/xZgxY+Ds7Ay5XI7OnTvjlVde0fo7L3xvf/zxB6ZOnQpnZ2fY2dlh+PDhOHfunM5nCNV8D2um7t98802tvEZ938caNT+zddV8hixZsgS5ubl4+umn4eXlBZlMhh49emD79u16+5ScnIznnnsOwcHBsLGxgYuLC/r06YM333xT83dXJBJh586dAICRI0dy3++aP9f6cpIa+7kEAJ9//jlCQkI0f0dXrlyp88+ouLgYmzZtQmhoKBQKBezt7REYGIg5c+bg8OHDet8/qYMR0ggAmKF/fQAwX19fNnfuXGZvb88mT57MJk+ezBQKBQPAFi5cqDk3OjqaLV68mNnZ2TEAbPHixZqv559/XnPe8OHDGQC2YsUKJhaL2dChQ9n8+fPZ4MGDGWOMFRYWst69ezMAzM3Njc2ePZtNmDCByWQyBoA999xzWv309fVlANgzzzzDrK2t2ZgxY9jcuXOZh4cHA8BCQkJYQUGB5vyff/6ZAWCzZ8/W+b537NjBALCnnnqqQd+n+Ph4BoANGDCA9e7dmzk5ObGZM2eyyZMnMxsbG833Q2jevHnMysqKhYeHs+nTp7Pp06czPz8/BoB5eXmxlJQU7vwrV64wuVyueU9z585lkydPZt26dWMA2IkTJ7jz9+3bp/m+hYWFsdmzZ7P+/fszkUjEbG1t2cmTJ7X6NH/+fAaA2drasilTprAZM2YwhULBevfuzQYMGMAAsPj4+AZ9X3777TcGgPn5+bExY8awefPmsYEDBzKRSMREIhH73//+p3VNcXExGzZsGAPA7Ozs2Lhx49i8efNY//79mbW1NVu7di13/ssvv8wAMGtrazZ27Fg2Z84c5u7uzjp27MimTJmi9X2p+bMaPny4zj6/8cYbDAD74osvuPaav7d133tSUhJzcXFhAFinTp3YrFmz2PTp01mvXr2YSCTSukfNz1ONbdu2sXHjxjEALDAwkPuZ2bdvn97ravzzn/9kAJiVlRUbPXo0mzdvHuvQoQMDwIKDg1l6errO9/bMM88wW1tb1rNnTzZv3jwWGhrKADC5XM7++OMPnd+XurKystjixYvZ4MGDGQAWGhqq6fe2bdvq/T7WqPmZrevEiRMMAJs2bRoLDg5m3t7ebM6cOWzkyJFMIpEwAJr713Xq1Cnm5OSk+bs2Z84cNnnyZBYUFMQAsOvXrzPGGFu8eDELDAxkANi4ceO473dWVhZjjLEvvviCAWBvvPEG9wxjPpdefPFFJpVK2dixY9mMGTOYu7s7A8CGDh3K1Gq15vyqqirWv39/BoC5urqyqVOnsrlz57JBgwYxW1tbnZ8hRBsFSaRRGhskAWBdu3ZlaWlpmva4uDjNh1JMTAx3ja4Pv7pq/rGRy+UsMjJS6/U1a9YwAGzkyJGssLBQ0x4dHa35cPnll190PtPR0ZFduXJF015UVMRGjRrFAHD/uFZVVTEfHx9mbW3NMjIytPpQ8+F/8eJF/d+cOmr+4a0JXmo+cBljLCYmhnl7ezMA3D98jDF2/PhxrX/IVCoVe/PNNxkAtnTpUu61RYsWMQBs8+bNWn2Ijo5mqampXJ/s7OyYvb09O3r0KHfub7/9xqytrZmPjw9TKpWa9l27djEArGPHjlwwkJGRwXr06KF5jw0NkuLi4tj58+e12q9du8acnJyYo6MjKyoq4l5btmwZA8CGDRvGMjMzudfS09PZhQsXNMfnz59nIpGIKRQKdu3aNU173T/3pgySXn/9dQaArVmzRus+iYmJWj8buoKdmsCgvn8AdV136dIlJhaLmb29Pfc9KS8vZ3PmzGEA2KxZs3S+NwDsww8/5F77y1/+wgCwJ554Qm8/hPQFFHWf1ZggCQCbP38+Ky8v17y2b98+zd/NunJycpibmxsDwP71r38xlUrFvX7u3DnuZ3zx4sU6f6F41Hsy5nPJ09OT3b17V9OelZWlCeCOHTumaT9+/DgDwPr27cvKysq4exUUFHCfbUQ/CpJIo9R8+NT3JfxHvKZd+I8sY7UfGsIPwYYGSc8884zWa8XFxczGxoaJxWIWHR2t9fp//vMfBoBFRETofObf/vY3rWtu377NRCIRs7e35z54Nm7cyACw9957jzs/OjpaE+w0VN0g6ciRI1qvf/bZZwwAGz16dIPv2b59e9auXTuubcKECQwAi4qKeuT1a9euZQDYRx99pPP15557jgFge/fu1bTVjOBs375d6/yaUSFDgqT6/P3vf2cA2M8//6xpS0lJYRKJhMlkMpaQkPDIe9QEja+//rrWazV/7k0ZJD399NMMANu/f/8j+8qYaYOkmve+fv16rfMzMjI0P0dJSUla761m1Lau7OxsvSNW+jRVkOTo6Miys7O1rqkJ1Ov+Gbz77rsMABs/fnyD+tyYIMnYzyVdo1+bN2/Wes7u3bsZAPaXv/ylQe+F6EY5ScQoixcv1vulKznV2tpakzdRV3BwMADozINpiKlTp2q1Xb16FWVlZQgPD9eZrPrEE08AAM6ePaszx2f+/Plabd26dUNoaCiKi4tx/fp1TftTTz0FKysrfP7559z527ZtAwCsWLHCsDcEwMXFBWPGjNFqX7BgAQDg3LlzWv3OycnBF198geeffx7Lli3DkiVLsGTJElRWViInJwe5ubmac3v37g0AeOaZZxAZGYmqqiq9fanJt5o5c6bO14cOHQoAuHTpEoDqPKALFy4AAObNm6d1/vjx4+Hs7Kz3efqoVCocOXIEGzZswMqVKzXv78SJEwCABw8eaM6NjIyESqXC+PHj4evr+8h7nz59GkD9f+5NqebP429/+xsOHDiA8vLyJn1eXTXvfeHChVqvubu7Y+zYsVCr1Th79qzW62PHjtVqa9euHVxcXBr982xKvXv3Rrt27bTadX3m/P777wCAlStXNll/jP1c0vX91vVewsLCIBaL8cUXX2Dbtm3Iyckx1VtoU2h1GzGKoSUAPD09IZFItNodHBwAgEveNoSugKwmWVlfkqqTkxMUCgUKCgqQl5en9UGq7x9WPz8/REVFccnQXl5emDp1Kvbu3YuTJ09i+PDhqKiowJdffgkbGxvuH5/9+/dj//79WvcVfi/1PV+hUMDJyQn5+flcv7/77jusWLECxcXFOq8DqmvRuLi4AABefPFFnDlzRlNbx97eHgMHDsSkSZOwZMkSblVOTSLqo5asZ2dnA6gO1ioqKuDm5gZbW1ud5/r6+iIvL6/e+9X18OFDTJ48GTdu3Kj3/dVITk4GAAQGBjbo/jV/no/6c28qS5YswZEjR7Bnzx5MmTIFcrkcffv2xfjx4/Hkk0/C09OzyZ79qJ+VmvaUlBSt1zp06KDzGgcHBy4obyn19Q/gP3MM/TvTGMZ+Lul6P7reS3BwMN577z2sX78eK1aswKpVq9CjRw+MHj0aS5YsQUhIiIneUetGQRJpVmJx0wxeyuXyRl0nXBFjjFWrVmHv3r3Ytm0bhg8fjv379yM7OxuLFi3iVttFRUVpVsXUZUzNqcTERM1KoC1btmDSpElo3749bGxsAACDBg3C+fPnuaKcjo6OOH78OM6ePYtffvkFkZGROH78OI4ePYpNmzbh9OnT6NSpEwBofqOtr3goAPTv37/R7+FRnnrqKdy4cQOzZs3CSy+9hM6dO8PBwQFisRj//e9/sXLlSrMrOqprJEAfiUSC3bt345VXXsFPP/2E48eP4+LFizh9+jTeeecdHDp0CIMGDWrC3upX389JU/1MG6K+77M59M9Qpvp+P//885g7dy7279+Po0eP4vTp0/jggw+wZcsWfPDBB1i7dq0putuqWd7fHkIayNvbGwA0ZQSECgoKkJ+fDxsbG51TP/quq2mvuX+NiIgIBAUF4ccff0ReXp7eqbYNGzaAVecDcl9CSUlJOp9fWFio6XdN8PXrr7+ioqICzz33HNauXYugoCBNgAQAcXFxOu8lEokwZMgQvPvuu7h48SJSU1OxYMECZGRk4O9//7vmvJrfXt9//33s2LFD79dTTz0FoHq6RSqVIisrC2VlZTqfre/96VJSUoKjR4/Cw8MDu3fvRr9+/aBQKDT/YOh6fz4+PgCA2NjYBj3Dy8sLwKP/3OuSSqUAoHf0rmZkwhC9evXChg0bcOrUKWRlZeGvf/0rioqK8Je//MXgezXUo35WGjqS2FTq+z6rVCqkp6eb5DmG/p1pDGM/lwzl4+ODZ599Fj///DOysrLw1VdfQSKR4KWXXjJoJLetoiCJmLWaD8f68mX06d27N2xsbHD16lUuV6XG119/DQAYPHiwzt/O9uzZo9V29+5dREVFwd7eHmFhYdxrIpEIK1asQHl5OTZu3Ihjx46ha9euGDx4sMF9B6qnrI4dO6bVXlNHZeDAgZqpy5oPO11D8adOnUJGRkaDnunu7q6p6XLr1i1Ne01u1L59+xp0H2tra82okq7v45EjRwyaiikoKIBarYaXl5fWdG1lZaXOfo0YMQISiQSHDx9uULBSk1dV35+7kKurK6ysrBAfH6/1d7SyshInT5585HPr4+joiE2bNkEkEnF/Hvo09uel5r1/9913Wq9lZWXh8OHDEIlEjf67bKyaAPb+/ftar504cQKVlZUmeU5ERAQA4L///W+Dzm/M99vYzyVjWFlZ4fHHH0ffvn1RUVGh8/mER0ESMWs1v3UJC+k1hJ2dHZ588kmo1Wo888wzKCkp0bx2//59vP322wCA5557Tuf1H330EZecXVpaimeffRaMMSxdupQbqamxdOlSyGQybNmyBYwxLF++3OB+1/XCCy9wCZfx8fHYuHEjgOqE6xo1iZtff/019z5TUlKwatUqnffeunUr4uPjtdp//fVXALW/VQPVw/Y2NjZ44YUXsHfvXq1rlEolfvjhB03VZAB4+umnAQBvvPEGN2qUnZ2NF198sZ53rc3d3R0KhQK3bt3ikodVKhVefvllnf94ent7Y9GiRSgvL8fixYu1ElczMzNx8eJFzXHN92nLli1c3lNJSYnmz11IKpVi4MCByM3NxSeffKJpr6qqwvPPP6/z+6vPV199pTMQ+u2338AY4/489Gnsz8szzzwDsViM//znP7hy5YqmvaKiAs8++yzKysowc+bMBvWhKQwbNgxA9d/vugU44+Pj9f78NsZTTz0FV1dX/Pbbb5qf4bouXLiAzMxMzXFjvt/Gfi411IkTJ/D7779rTUXGx8cjOjoaIpFIb74WqaNlFtURS4c/l2/XLaAm/Hrttde0rtG3JFjf8t/333+fAWAeHh5s/vz5bNmyZezll1/WvK5rKXVddYu2ubu7szlz5rCJEydqiig2pJjkuHHj2Ny5c5mnpycDwLp3787y8/P1fm8ee+wxBoDJZDKdS48fpW4xyfDwcE0xySlTpjBbW1sGgD3++OPcNUqlknXv3l1TR2XWrFls0qRJzNbWlg0aNIgNGjRI6/tUU/SvW7dubNasWVqFAM+cOcM9Y//+/ZrnBwUFsSlTprD58+ezoUOHaop+1hTaq1FTY8fOzo5NnTqVzZw5kzk5ObHw8HCDi0n+4x//YACYRCLRFJP08/NjNjY27JlnntH596ewsFDz3u3s7NiECRPYvHnz2IABA5hUKtUqJvnCCy8wANyfu4eHh95ikowxdvToUSYWixkANnDgQDZjxgzWsWNH5urqqlki3pASANOmTWNAdSHI6dOnswULFrABAwYwkUjExGIx27NnD3cPfT9PISEhmvo4S5YsYcuWLWM//fTTI6+r+f5aWVmxiIgINn/+fObj48OA6uKW+opJGrIsvz71lQBgrLZMgUKhYFOmTGGjR49mdnZ2bM6cOfWWANBXDkHf8v0TJ04wBwcHBoD5+/uzuXPnsilTpmgVk2SsuiCrSCRicrmcTZs2jS1btowtW7ZM83PfkGKShn4u6aLrvX7wwQcMqC5WOX78eLZw4UI2duxYTcHKZ599Vue9CI+CJNIoNUFSfV+hoaFa1xgaJFVWVrJXX32VBQYGMmtra617PCpIYqy6Lsmbb77JunXrxmQyGXNwcGBDhgxh3377rc7zaz6MVCoV27x5M+vSpQuTyWTMy8uLPfPMMyw3N7fe783nn3/OALAFCxbUe54+dWvv5Ofns9WrVzNvb28mlUpZ586d2ebNm1lVVZXWdbm5uezpp59mfn5+TCaTsYCAAPbyyy+zkpISnd+nn3/+mT355JOse/fuzMnJidna2rLg4GD21FNPccXq6oqJiWGrV69mnTp1YnK5nDk4OLDOnTuz+fPnsz179nDFJBmr/vN79913WXBwMJNKpczb25utXr2a5efnN+jPTmjnzp2sV69ezNbWlrVr145NmzaN3bhxo95/YJVKJfvwww9Zv379mL29PbOxsWGBgYFs6dKl7OrVq1rnb9u2jYWEhDCZTMbc3d3Z448/zlJSUuqtiXPgwAHWt29fJpPJmIuLC5s7dy6Lj483qE7SyZMn2TPPPMPCwsJYu3btmFwuZwEBAWz+/Pns8uXLWs/U9/P04MEDNn36dNauXTtN8Fb3+1Lfz+GBAwfY6NGjmUKhYFKplAUFBbGXXnpJ59/55g6SlEole+WVV5iPjw+TSqUsMDCQvf3226yqqsqkQRJj1YVLV61axfz8/JhUKmUuLi6sd+/ebOPGjVzxR8YY++abb1h4eLimGn7dP9f63lNjP5d00fVeHzx4wF599VU2ePBg5uXlxaRSKWvfvj0bPXo0+/HHH7nq3EQ/EWNmthyEkBbm5+eHxMTERq+UGjduHI4cOYITJ07o3dOLWJ4lS5Zg586d9OdKSBtCOUmEmNClS5dw9OhRdO/enf4hJYQQC0d1kggxgVdeeQVJSUk4ePAgGGP4xz/+0dJdIoQQYiQKkggxgV27diE5ORm+vr7YtGkTpk2b1tJdIoQQYiTKSSKEEEII0YFykgghhBBCdKAgiRBCCCFEB8pJaiS1Wo3U1FQ4ODiYdJNUQgghhDQdxhiKiorg7e39yK1fKEhqpNTU1BYr0U8IIYQQ4yQnJz9yaxYKkhrJwcEBQPU32dHRsYV7QwghhJCGKCwshI+Pj+bf8fpQkNRINVNsjo6OFCQRQgghFqYhqTKUuE0IIYQQogMFSYQQQgghOlCQRAghhBCiAwVJhBBCCCE6UJBECCGEEKKDxQRJn3zyCfz8/CCXy9G/f39cunRJ77nbtm3D0KFD4ezsDGdnZ0RERGidv2TJEohEIu5r/PjxTf02CCGEEGIhLCJI2r17N9atW4c33ngD165dQ2hoKMaNG4fMzEyd50dGRmLBggU4ceIEzp8/Dx8fH4wdOxYpKSnceePHj0daWprm67vvvmuOt0MIIYQQCyBijLGW7sSj9O/fH3379sXHH38MoHpLEB8fHzz77LN45ZVXHnm9SqWCs7MzPv74YyxatAhA9UhSfn4+9u/f36g+FRYWQqFQoKCggOokEUKIgSorK6FSqVq6G8TCicViWFtbG7Q9mCH/fpt9McmKigpcvXoV69ev17SJxWJERETg/PnzDbpHaWkpKisr4eLiwrVHRkbC3d0dzs7OGDVqFN5++220a9dO5z2USiWUSqXmuLCwsBHvhhBC2rbCwkJkZ2dzn6eEGEMikcDW1hbu7u6QSqUmvbfZB0nZ2dlQqVTw8PDg2j08PHD37t0G3ePll1+Gt7c3IiIiNG3jx4/HzJkz4e/vj9jYWPztb3/DhAkTcP78eUgkEq17bNq0CW+++aZxb4YQQtqwwsJCpKSkwN7eHq6urgaPABBSF2MMKpUKZWVlKCgoQEJCAjp06ABbW1uTPcPsgyRjvfPOO9i1axciIyMhl8s17fPnz9f8f8+ePRESEoLAwEBERkZi9OjRWvdZv3491q1bpzmu2fuFEEJIw2RnZ8Pe3h4dOnSg4IiYjL29PVxcXJCYmIjs7Gx07NjRZPc2+8RtV1dXSCQSZGRkcO0ZGRnw9PSs99rNmzfjnXfewZEjRxASElLvuQEBAXB1dUVMTIzO12UymWafNtqvjZBHUzMgpRBIKgCUVS3dG9LSKisroVQqoVAoKEAiJieRSODi4oKSkhJUVZnuA8fsR5KkUil69+6NY8eOYfr06QCqE7ePHTuGNWvW6L3uvffewz/+8Q8cPnwYffr0eeRzHj58iJycHHh5eZmq64S0SfF5wCdXgMMxQGFFdZtUAgzsADzVCxjm27L9Iy2jJknb2tq6hXtCWiuZTAYAqKqqgpWVacIbsw+SAGDdunVYvHgx+vTpg379+mHLli0oKSnB0qVLAQCLFi1C+/btsWnTJgDAu+++i9dffx3ffvst/Pz8kJ6eDqB6SM7e3h7FxcV48803MWvWLHh6eiI2NhYvvfQSgoKCMG7cuBZ7n4RYMjUDPr4MfHQJqBAsWqpQAScTq7+mBAPvRQC29G9lm0SjSKSpNMXfLYsIkubNm4esrCy8/vrrSE9PR1hYGA4dOqRJ5k5KSoJYXDtz+Nlnn6GiogKzZ8/m7vPGG29gw4YNkEgkuHnzJnbu3In8/Hx4e3tj7NixeOuttzSRKCGk4SpUwAtHgZ/uPfrcX+4DifnAjmlAO9PlVxJCiMlZRJ0kc0R1kgipxhjw3CHg5/uGXRfmAeyaBdjQiFKbUF5ejvj4ePj7+3OLaAgxlYb+HTPk32+zT9wmhJi3LRe1AySJqDr/6OxS4OZKYNMowFEwSBuVAbz4e3WQRUhbJdweSywWw8nJCUOHDsXnn38O4TjGhg0btK7R9ZWQkMBdp1Qq8cEHH2DgwIFQKBSQSqXw8vJCnz598Oyzz+LgwYPN+K4th0VMtxFCzNPZ5OogqS4bK+CzScBIv9q2x3oC/doDi/YDKUW17b/cB0b5ATO7NkNnCTFjixcvBlCd4B4bG4uzZ8/izJkzOHbsmM4ts0JDQxEWFqb3fvb29pr/z8/Px+jRo3Ht2jVYW1tj4MCB8Pb2RnFxMa5evYqPP/4YR48exaRJk0z+viwdBUmEkEYpUAIvHOHbxCLtAKlGkEt1HtKsPbWr3gDgjUhgkA/gaa99DSFtxY4dO7jjo0ePYuLEidi1axcWLlyIyZMnc69Pnz4dGzZsaNC9X3/9dVy7dg1hYWE4cOAA2rdvz71+6dIlHDp0yJjut1o03UYIaZQPLgCpxXzb+iG6A6Qawe2Af43h2worgHfPmrx7hFi0MWPG4IknngCARu8xWuPHH38EAPzrX//SCpAAoF+/fnj99deNekZrRUESIcRg93OAL2/wbYN9qvOQHmV8EDCjC9+29y5wM0P3+YS0Vb16Vf9AJScnG3WfrKwsAICbm5vRfWprKEgihBiEMeCtU4CqTj6pTAK8G1E93dYQrw4FHAT7UG46Y7o+EtIaFBVVJ/AZW5qmZgutrVu3aiWCk/pRThIhxCBnk4FTSXzb8nDAx4BKGK62wJq+wKY602znHgJXUoE+3qbpJ7EMaqZGQUVpS3ejURRSW4hFTTPWwBjDgQMHAOCR22o9yvLly7F+/Xps3boVkZGRmD59Ovr3748+ffqgQ4cOpuhuq0VBEiHEIB9d4o897IDVj975R8uSMGB7FJBRUtv28eXq5G7SdhRUlGLqUcvMh/l5zEY4y0y74kClUiEuLg7//Oc/cf78echkMs3uEnW9+eabePPNN3XeIzQ0FFFRUZrjl156CXl5efjggw9w9+5dvPPOO5rXunfvjjVr1mDFihVcUWZSjYIkQkiDXUoBLqTwbX/pD9hJdZ9fH7kVsLI3sPFUbduJBOBeNtDZ1ahuEmJxdG2p4eDggJ07dyIwMFDrtfpKAHTs2JE7FovFePfdd7F27Vr88MMPOHXqFC5fvoykpCTcvn0bTz/9NA4fPowff/yRAiUBCpIIIQ0mHEXysgdmGVHjaEGP6tGj3LLatq/+AN4e2fh7EmKJauokicViODo6omfPnpg5cyacnZ11nm9ICYAa3t7eeO655/Dcc88BAKKjo7F582Zs374d+/fvx3fffYeFCxca9T5aGwqSCCENEp2lnYu0sjcgM+JTxNYaeOzPQKnG3mjglcGAfSNGpwixVMI6Sc2ha9eu+N///oe8vDzs27cPBw8epCBJgIIkQkiD7LzJH7vaVI8EGeuxHsCnVwD1n4tuSiqBfXeBJ4zLVSUWQiG1xc9jNrZ0NxpFIW0dOzSPGjUK+/btQ3Z2dkt3xexQkEQIeaT88urApa7HQ6rziozV3hGI8AeOxNW2fXUTeLwnoCNNg7QyYpHY5MnPhMcY05nzVCMmJgYAdBaabOsoQ4sQ8kh77gDlVbXHVuLqESBTWSQYNbqXA9zOMt39CWnLBg0ahC+++AIlJSVarx04cABbt24FAMyePbu5u2b2aCSJEFIvNQO+Fky1TQwCPEz4y//gjkAHB+Bhnc1v990Ferib7hmEtCb79+9HQkKC3tefe+45hIeHA6hO0H7yySexevVqhIeHo2PHjigrK8O9e/dw9271EPGqVatog1sdKEgihNTrciqQWMC3LQo17TPEImBaF+CTOgncP98H/jYEkNB4NyFabty4gRs3buh9ffr06Zog6dSpUzh06BCOHTuG2NhYREVFQaVSwcPDA7Nnz8aTTz6JCRMmNFfXLYqIUY3yRiksLIRCoUBBQQEcHQ0oNUyIhXnhKPD9ndrjTi7A0cdNny90PwcY8zXf9s0MYEhH3ecTy1JeXo74+Hj4+/tDLpe3dHdIK9TQv2OG/PtNv6MRQvQqqQAOPuDbZndrmoTq4HZAd8H+m8JkcUIIaU4UJBFC9DoUC5RW1h6LRcCMLk33POG9j8QBlaqmex4hhNSHgiRCiF51p9kAYLhv9V5tTWVyJ/64UAlceNh0zyOEkPpQkEQI0elhIXBeEKDM6da0z/RyAEI9+LbDcbrPJYSQpkZBEiFEJ2EukkJWXfSxqY0T7OV5JLa2GjchhDQnCpIIITr9KgiSJgQZt09bQwmDpIwS4EZG0z+XEEKEKEgihGhJLgSiBIHJpE66zzW1IBcgULDx+eGY5nk2IYTURUESIUSLcKrNWQ4M7NB8zxeOJkUmNt+zCSGkBgVJhBAtB+/zx+ODAGtJ8z1/lB9/HJ0NpBc33/MJIQSgIIkQIpBUANzM5NsmBTVvH3p5AY4yvu0kjSYRQpoZBUmEEI4wYdtZDgz0ad4+WImBoYLtSCITmrcPhBBCQRIhhCPMR5oQVB20NLfhvvzxmSSgSt38/SCEtF0UJBFCNNKKdEy1NdOqNqERgiCpsAK4ntYyfSGEtE0UJBFCNI7F88eOMqB/+5bpi4c90NWVbzuV1DJ9IYS0TRQkEUI0jgq2ABnp17yr2oSEeUnCbVIIsXQikUjzdf78eb3n7dmzR3Oen58f91pCQgJ3H31fGzZs0LrviRMnMGvWLLRv3x5SqRTOzs7o3Lkz5syZg48//hgFBQUNfi+RkZEQiUQYMWJEg85fsmSJzn4qFAoMGDAAH330Eaqqqhr8/KbQDPVzCSGWoKRCOwhpjm1I6jPIB/jvtdrjqHSgtBKwtW65PhHSVL755hsMHDhQ52tff/31I6+3s7PD7Nmz9b4eFhbGHW/cuBFvvPEGAKBr167o378/rK2tce/ePezduxc//PAD+vTpgwEDBjT8TTTC4MGDERRUvYS2qqoKiYmJOHfuHC5evIjffvsNBw8ehEgkatI+6ENBEiEEAHA6CVCqao+txMBwvxbrDgCgrzcgEQGqP/duq1QDV1KBYb71X0eIJZFIJOjWrRt2796NLVu2wMqK/6c5JycHhw4dQnh4OK5du6bnLoCrqyt27NjRoGdevXoVGzZsgLW1Nfbs2YPp06dzr6enp+Prr7+Gk5OTge/GcE899RSWLFnCtV25cgXDhg3Db7/9hn379mHmzJlN3g9daLqNEAIA+F2Qj9TPu3pT25ZkLwVCPfk2mnIjrdHChQuRnZ2Nw4cPa722e/duVFZW4vHHHzfZ8/bu3QvGGObOnasVIAGAp6cnXnjhBXTp0sVkzzREnz59NKNip06dapE+ABQkEUIAqNTAcUGQNCagZfoiJNwO5Vxyy/SDkKb02GOPQSQS6ZxW+/rrr2Fvb49p06aZ7HlZWVkAADc3N5Pd09Tc3d0BoEXzkmi6jRCC6+lAThnfFmEmQdKgDsAnl2uPb2YChUrtitzEMjG1GurchicHmxOxiwIisWnGGnx8fDBs2DD8/PPPKC4uhr29PQAgLi4O58+fxxNPPAFbW1uTPKvmeQDw448/Yv369ZqAxJxcuXIFQHW+VEuhIIkQorX0P7gd0FHRMn0R6uMNSCVAxZ/5UmoGXE4BRptJEEeMo84tQELXqS3djUbxi/4ZEldnk93v8ccfx8mTJ7F3714sWrQIQHUyd81rprRw4UJs2rQJycnJCAoKwsyZMzFkyBD07t0bISEhkEhaZllrVVUVkpKS8PHHH+PkyZPw8fHBE0880SJ9AWi6jRAC7aX/Y1p4VVtdciuglyAv6SzlJZFWaPbs2ZDJZJrACKgOkry8vDB69OhHXp+YmFhvCYCoqCjNuQEBAfjll1/g4+ODoqIi7Ny5E8uXL0d4eDhcXV2xevVqpKU1T/XWpUuXavpobW2NwMBAfPDBB3jsscdw/vx5ODo6Nks/dKGRJELauIeFwINcvs1cptpqDOoAXEypPb6cov9cQiyVk5MTJk2ahJ9++gnp6elITk7GvXv38Ne//rVBIzuPKgHg4uLCHY8ePRoxMTE4ePAgjhw5gkuXLuHmzZvIz8/HZ599hh9//BGnTp1C586djX5v9albAoAxhvT0dFy5cgV79uyBs7MzPvzwwxYb2aIgiZA27rSgirWzHAjz1H1uS+knqPp9O6u6rpOdtGX6Q0hTefzxx7F3717s2rUL8fHxmraGMKQEQA2pVIoZM2ZgxowZAID8/Hzs2rULf/vb35CZmYk1a9bg6NGjAIB33nkHd+/e5a7v0qULXnnlFYOeKaSrBEBRURHmz5+PTz75BC4uLti4caNRz2gsCpIIaeNOJfLHQzsC4pap26ZXmCdfL0nFgKgMYLBPy/aLGE/sooBf9M8t3Y1GEbuYPnFv4sSJcHJywpdffonU1FR07doV4eHhJn+OPk5OTli1ahW8vb0xbdo0nDhxAqWlpbC1tcWhQ4dw8uRJ7vzhw4cbHSTp4uDggPfeew+//vorPvroIwqSCCHNT6UGzgiW1Au3AjEHttZAD3fgRkZt25VUCpJaA5FYbNLkZ0snk8kwZ84cbNu2DQDw3HPPtUg/Ro0aBQBQqVTIz8+Hra0tIiMjm7UP/v7VyZH5+fnIyspqkXIFlLhNSBt2I6N6OX1d5hgkAdWr3Oq6ktoy/SCkqT3xxBNo164dXF1dsXDhwiZ5BmOs3tdjYmIAVE/Hubq61ntuU4mLq15RIhKJTFr+wBA0kkRIGybMR+rkAng5tExfHqWPF/C/67XH19KrR8Ik9KseaWWGDh2K7OzsJn3Ga6+9BqVSiVWrViEwMJB7LSUlBStXrgQATJ06FVJp8yf/FRUV4aWXXgJQPaVnZ2fX7H0AKEgipE0T5iOZ855owpGk4grgbg7Q3XwLBhPSrLKzs7USoOsKDw/XTN8VFxfjww8/xObNmxEcHIxu3bpBLpfj4cOHuHjxIiorKxEUFIQtW7YY3I9r167Vuynup59+yuVZff7555qpPMYYMjIycPnyZeTm5sLV1RWffPKJwX0wFQqSCGmjCpXVlbbrGmamU20A4G4H+CqAxDrFmS+nUpBESI2SkhLs3LlT7+v5+fmaIOnVV19Fnz59cPjwYdy4cQOnT59GQUEBHB0d0a9fP0ybNg2rV69u1AhOUVERLl68qPf1wsJC7vjs2bM4e/as5tjGxgb+/v5YunQpXnjhBXh6ttxyWxF71MQk0amwsBAKhULzl4oQS3M4FlhxoPZYKgFurgRsrFuuT4/y/BHgh+ja46nBwEcTWq4/pOHKy8sRHx8Pf39/yOXylu4OaYUa+nfMkH+/aTafkDZKONXW19u8AyRAe8rtMiVvE0KaEAVJhLRRwqRtc55qqyEMktKKgfTilukLIaT1oyCJkDYoMZ/P7QGAoWactF0j0BlwECy0iUrXfS4hhBiLgiRC2iDhKJKrDdC1ZUqhGEQsAkI8+La6BSYJIcSUKEgipA06JQiShpjhViT6CPeVE67QI4QQU6EgiZA2pkoNnBNsRWLO9ZGEwgQjSX9kVheVJIQQU6MgiZA25no6UFTBtw2xgKTtGqGCkaTiCiA2r2X6Qghp3ShIIqSNOS1Y+t+lHeDRMhX/G8XDDvC259soeZsQ0hQoSCKkjRHmI1nCqjYhYV4SBUmEkKZgMUHSJ598Aj8/P8jlcvTv3x+XLl3Se+62bdswdOhQODs7w9nZGREREVrnM8bw+uuvw8vLCzY2NoiIiMCDBw+a+m0Q0qIKyrVXg1lCfSQh4ZRbFK1wI4Q0AYsIknbv3o1169bhjTfewLVr1xAaGopx48YhMzNT5/mRkZFYsGABTpw4gfPnz8PHxwdjx45FSkqK5pz33nsP//nPf7B161ZcvHgRdnZ2GDduHMrLy5vrbRHS7M4mA+o6GxHJJEC/9i3Xn8bqJQiS7mYDZZUt0xdCSOtlEUHSv//9byxfvhxLly5Ft27dsHXrVtja2mL79u06z//mm2+wevVqhIWFoUuXLvj888+hVqtx7NgxANWjSFu2bMGrr76KadOmISQkBF9++SVSU1Oxf//+ZnxnhDQvYX2k/u0BuQVuc93DjS9ZoGLALd2/MxFCSKOZfZBUUVGBq1evIiIiQtMmFosRERGB8+fPN+gepaWlqKyshIuLCwAgPj4e6enp3D0VCgX69++v955KpRKFhYXcFyGWhDHt/dosMR8JAOykQOd2fBtNuRFCTM3sg6Ts7GyoVCp4ePDFUTw8PJCe3rBszZdffhne3t6aoKjmOkPuuWnTJigUCs2Xj4+PoW+FkBaVkA88LOLbLDEfqYYweZsqbxNLJRKJIBKJdLbV97VkyRKte127dg1PPPEEfH19IZPJ4OjoiKCgIEyZMgWbN29GWlpag/uVkJAAkUgEPz+/Bp2/YcMGnf20t7dHWFgY3n77bZSWljb4+ebAAgfaDfPOO+9g165diIyMhFwub/R91q9fj3Xr1mmOCwsLKVAiFkW4qs3NVns0xpKEegDf3ao9puk20hotXrxY72tDhgzhjr/44gssX74cKpUKfn5+GDduHOzs7BAXF4fDhw/jwIED6NChA+bPn9+kfQ4NDUVYWBgAQK1WIyUlBWfOnMFrr72Gffv24fTp07C1tW3SPpiK2QdJrq6ukEgkyMjgf03MyMiAp6ennquqbd68Ge+88w5+//13hISEaNprrsvIyICXlxd3z5o/WCGZTAaZTNbId0FIyxPmIw3zBUQWshWJLj3c+OP4fKBICTjQjylpRXbs2NGg81JSUrB69WqoVCp8+umnWLlyJcTi2smivLw87NmzB+3bN/1KjenTp2PDhg1cW3x8PAYMGIBr165h69at3KCDOTP76TapVIrevXtrkq4BaJKwBw4cqPe69957D2+99RYOHTqEPn36cK/5+/vD09OTu2dhYSEuXrxY7z0JsVSVKu2tSIZa8FQbAAS3A6wEn2B3slumL4S0tF9//RXl5eUYPHgwnn76aS5AAgBnZ2esXLkSQ4cObZH++fv7Y+XKlQCAU6dOtUgfGsPsgyQAWLduHbZt24adO3ciOjoaTz/9NEpKSrB06VIAwKJFi7B+/XrN+e+++y5ee+01bN++HX5+fkhPT0d6ejqKi4sBVM/1/uUvf8Hbb7+Nn3/+GX/88QcWLVoEb29vTJ8+vSXeIiFN6lo6UCJYIj/EwmeLZVbVgVJdf1BeEmmjsrKyAABubm6POLPluLu7AwCqqqpauCcNZ/bTbQAwb948ZGVl4fXXX0d6ejrCwsJw6NAhTeJ1UlISFzV/9tlnqKiowOzZs7n7vPHGG5ohwJdeegklJSVYsWIF8vPzMWTIEBw6dMiovCVCzJVwVVs3N8DNgrYi0aenO3Anq/b4Vpb+c4l5UjMgr6yle9E4zjZ8KYqWVJMje+zYMdy7dw+dO3du4R5pu3LlCgCga9euLdyThrOIIAkA1qxZgzVr1uh8LTIykjtOSEh45P1EIhE2btyIjRs3mqB3hJg3rXwkC59qq9HDDdhd55iSty1PXhkQvq2le9E415YD7cwk/3jq1Klwd3dHZmYmQkNDMXXqVIwYMQLh4eEIDw+HVCptkX6p1Wqkpqbim2++wVdffQUnJyesXr26RfrSGBYx3UYIaby8MuCmYBrK0vORavRw549j84BSqrxNWpH6SgDULX6sUChw+PBhdOvWDUqlEt9//z2eeeYZDBw4EM7Ozli4cGGzbb315ptvavookUjg4+ODV155BREREbhw4QL8/f2bpR+mYDEjSYSQxjmbDNTZiQRyK6CPd4t1x6S6ulZPd9RstaJmQHQ20Nur/usIsRT1lQDo2JH/bScsLAx//PEHfv/9d/z222+4cOECoqKiUFpaim+//RY//fQTfvvttyZP3q5bAgCozpeKiorC0aNH8dprr2HHjh1UAoAQYh6E9ZFaaisSxhiYsgJiuenW6NtYA0EuwP2c2rY/MilIIq1HQ0sA1BCLxRg7dizGjh0LoHrHiZ9++gkvvfQSHj58iGXLluH+/fsAgM8//xxnzpzhrnd1dcXmzZuN6rOuEgAVFRVYvXo1/ve//0Eul+PLL7806hnNhYIkQloxxoDTgqTt5sxHqohNRtHXv6Dk8DlUJqQAlVUQOzvCZlgfOMwdC9sxg7QqDRuqpzsfJFFekmVxtqnO7bFEzjYt3YNHs7W1xYIFC9C9e3eEhobiwYMHuH//PoKDg3HmzBns3LmTO9/X19foIEkXqVSKDz74ANu3b8c333yDLVu2aLYKM2cUJBHSisXmAanFfNuwZtivTV2mRO6mbSjY9gNQpeJfyytEyU/HUfLTccgHhMLt3y9C2qnxnerhBvwYXXt8m4IkiyIWmU/yc2sWEhKCdu3aIScnB9nZ2QgODsaOHTsMHqkyhoODA1xdXZGVlYXY2FiLCJIocZuQVky4qs3THujUxJ9LlQ8zkDJ5NQo+260VIAmVX7iBh2NXoOTI2UY/T5i8fT8XKLecMiyEmARjrN7Xc3NzkZubCwDNUnVbl8LCQmRnV1d8tbe3b5E+GIqCJEJaMWF9pKEdm3YrksrkdKROeQYVN+83+BpWXIr0J/6G4oONq8LbTVA7r0rNT78R0hZ89tlnWLFiBW7evKn1Wm5uLpYsWQLGGPr06QNf32YYThaoqKjAunXrwBiDv78/unTp0ux9aAyabiOklVJWAecf8m1NmY9UlZWH1JlrUfVQUG9Aag3FkzNgP2UExE4OKDsXhfyPvkVVUp3dyNVqZKzYAMme92EzuJdBz7WXAgFOQFx+bdsfmUCIR6PfCiHNTl9u3pIlS/Re07FjR02tv4qKCmzbtg3btm2Dr68vQkJCYG9vj/T0dFy6dAklJSVwc3PD9u3bDe5bWloaBgwYoPf11157DZMmTdIc79+/n6tXmJ2djevXryM1NRW2trbYvn270bmIzYWCJEJaqatpQFmdaScRgCFNFCSxyipkPPU6qhJSuXbrQB94fvlPSIP9NG3SYD84zJuArHXvoviHo7UnV1QiY/kb6HB8O6w8XQ16fg93Pkii5G1iKcrLywEAdna6S+ALE6vrCg0N1QRJTz75JHx8fHD48GFcuXIFFy9eRG5uLuzs7NCtWzdMmDABzz77LFxdDfvZAqoDsIsXL+p9vWZLlBo3btzAjRs3NMcymQw+Pj5YuXIlXnjhBQQFBRnch5ZCQRIhrZQwH6mHO+DSRKtxcjd9jvJzUVybtGsAvPd9CEk7J63zxTYyuH/6GkQ2chR99YumXZWVh4yVb8J734cQiRueDdDDHfi5zgwfBUnEUsTFxQHQrnn0qBwjIUdHR8yaNQuzZs0yWd/8/PwM6seGDRu0lv5bOspJIqSVEtZHaqqptvIrt5H/yXdcm8TbHV7f/1tngFRDJBLB7V/Pw3bMQP5+56JQuOMng/rQXZCXdC+nOjeJEHPGGMPHH38MABgxYkTLdoboREESIa1QTqn2aMrQJsjVVJcrkfncJkBdJyKRWsNzx9uw8mj3yOtFEgncP3kVVj6eXHvOxs9Qldrw4aCughkEpQqIz2/w5YQ0q+zsbCxcuBChoaH47LPP4ODggOeff76lu0V0oCCJkFZIONVmaw2Ee+o+1xj5//kGlQ/4JXQuLz0Jea+G7/ItcXaE25aXuTZWUobcfzZ819N2toC7IKUjOkv3uYS0tOLiYnz33Xd4+PAhpk6ditOnTyMgIKClu0V0oCCJkFZIONU2oD0gM3EGYlVqJvI//pZrk4V1gdMz8w2+l+2wPnBYMJFrK9pzGMpbMQ2+h3A06W62wd0gpFn4+flBrVYjNzcXP/30E0JDQ1u6S0QPCpIIaWUY066P1BRVtnP+8V+wMmVtg1gMty0vQ2TVuGjM5dWVENnVySxnDDlvbW3w9d0EQdIdCpIIIUaiIImQViY6G8gq5duGmzhIUt64h+I9h7k2x0VTIOve+KW9Vu4ucHr2Ma6t7PhFlF3QLo6nS1dB8nY0BUmEECNRkERIKyMcRergCPg7mfYZuf/6gjsWO9jB+aVlRt/XadU8SNz5fVPy//N1g64VTrelFwN5ZUZ3iRDShlGQREgrc1IQJA038VYkyhv3UHqY32vN6bmFsHJzNvreYjsbOK19gmsrPXoeyjuxj7w2wBmQSfg2Gk0yP4bW/yGkoZri7xYFSYS0IqWVwJU0vs3U+Ui57+/gjsXtFFA8ZboCdo4LJ0HsouDahAniuliJgU6CqgMUJJkPiaQ6gq2srGzhnpDWSqmszpG0amRepC4UJBHSipx/CFSoao8lImCQj+nur4yOQ+lvZ7g2p6fnQ2xva7JniO1stIKu4r3HUJX26DX9wik3KgNgPqytrSGTyVBQUECjScTkVCqVZhsWUwZJtC0JIa2IMB8p3AtwlJnu/gVb93DHYmdHKJbNNN0D/qRYNhP5H38LVlq9rxVUKhR+fQAuLy6t9zpa4WbeXF1dkZKSgocPH0KhUMDa2tpiNjol5ocxBpVKhbKyMhQUFECtVsPLy8ukz6AgiZBWpCmX/ldl5aH4x6Ncm2LZTJOOItWQuChgP2sMt69b4Ve/wPmvT9RbYkC4wu1BLlCpAqwlus8nzcvR0RFAdcXplJSUFu4NaS0kEglsbW3h7u4OqVRq0ntTkERIK5FcCMTl823DTbhfW+GO/WDKitoGqTUcl84w3QMEFEum85vfpmWh5PA52E8apvca4XRbxZ/bkwQ/eocU0kwcHR3h6OiIyspKqFSqR19ASD3EYnGTjkhSkERIKyEcRXKWAz3cTXNvdbkShV/s49ocZkbASrBc35RkIcGQ9e4G5dU7mrbCHfvrDZKc5ICXPZBWXNt2J4uCJHNkbW0Na2vrlu4GIfWixG1CWgnh0v+hHQGJiX7Ci/cfhyorj2tTrJxrmpvXw3HJdO647OSVRyZwayVvU14SIaSRKEgipBWoVAHnkvk2U1bZLvryZ+5YPiQcsh6Nr67dUPbTRkHsUGfnWsZQJMiLEqLK24QQU6EgiZBWICodKKrg24aaKEiquBuP8su3uLamWNGmi9hGBrspI7i24u8P6z75T8IVbhQkEUIai4IkQlqBk0n8cVdXwMNO97mGKqyTPA0AEjcX2I0bbJqbN4DD3HHcccWdOChvxeg9v4sgSMosAXJKdZ9LCCH1oSCJkFagqZb+q8uVKBKM3DgsmACRdfOt+ZAPDIVVBw+urWjPIb3n+zsBckH3aDSJENIYFCQRYuGySoAbGXzbMBMt/S85eArqvEKuzfHxKaa5eQOJxGLYzxrDtRX/eBRMz/JxiRjoTNuTEEJMgIIkQixcpGAUyc4a6NfeNPcWTrXZDA2Htb+Jbm4A4ZSbKjMX5Rdu6j1fOOV2L6cpekUIae0oSCLEwh2P54+HdASkJqgwXRn3EOVnr3NtDk807yhSDWmwH6Q9O3Ftxb9E6j1fOJJ0n4IkQkgjUJBEiAWrVAGnBUnbo/xMc2/hUnuxiwL2E/UXcmxq9pNHcMclB06CqdU6z9UVJKlpT1VCiIEoSCLEgl1O1V76P9Lf+PsyxlC0h0/Ytp8xGiKZafdFMoTdlOHcsSojB8ort3WeK6ywXVYFPCzUeSohhOhFQRIhFux4An/cw900S/+VV++gKoHfgNRhzljjb2wEaSdfWHf249qKD5zUea6bbfW2LHXdpeRtQoiBKEgixIIJ85FMNtX2/RHu2DqgA2Th3UxzcyPYT+ZHk0oOnARj2vNoIpH2lBslbxNCDEVBEiEWKqkAiOW3U8MoU0y1VVaheP8xrs1+ztgm22XbEMLq21XJ6VDeuKfzXOGUGyVvE0IMRUESIRZKONXWzgYI9dB5qkFKj1+EOreAa3OYPU7P2c1L2i0Q1v4duLbSQ2d0nktlAAghxqIgiRALJZxqG+EHiE0w2COcapP37QFrP2/jb2wCIpEIthOHcG0lR87pPFc4khSbB1Torj9JCCE6UZBEiAUqrQQuPOTbTJGPpCosRulhfmTGvoUTtoXsxgzijiv+eICqtCyt84RBUpUaSMhvwo4RQlodCpIIsUDnkgFlnVERiQgYaoL92kp+PQ1WXqemgLUV7KeNMv7GJiTv1xNihT3XVnr0vNZ5ChngxZ9GU26EEINQkESIBToaxx/39a4OCoxV8tNx7th29ABIXBTG39iERNZWsB3Vn2tr6JQblQEghBiCgiRCLIxKDfwuCJJGB5jgvvlFKI28zLXZTzevUaQatmP5KbeyU1egLlNqnUfbkxBCjEFBEiEW5no6kF3Gt401QZBU8uspoKp2Dk8kk8Ju3GDjb9wEbEf1B8S1H1+sTImyM9e0zqNaSYQQY1CQRIiFOSIYRQpuB/g5GX/f4p9OcMe2EQMgtrc1/sZNQOKigLxvD66t9Kj2lJswSEoqqE56J4SQhqAgiRALwhhwJJZvM8Uokiq3AGWnrnBtdtNGGn/jJmQ7ZiB3XHristY5ndoBdasiMAAxuU3bL0JI60FBEiEWJCYPiM/n20wz1Xaan2qTS7WW2psbYfJ2VUIKKhNSuTa5lfYoG025EUIaioIkQizIUcEokqc90NMEVbaLhavaIgaa7VRbDWn3QEjcnLm20pPao0nCFW4UJBFCGoqCJEIsiDAfaUyA8VW2VTn5KDvNJz2bW20kXURiMWyG9eHaynRMudEKN0JIY1GQRIiFyCiuXtlWl8lWtanqTLXZyLTyfcyVzYi+3HHZ6atgVVVcmzBIolpJhJCGoiCJEAvxu2CvNgcpMKCD7nMNobWqbcwgiO1sjL9xM7AVBEnqwmIor9/l2oTTbRklQH55U/eMENIaUJBEiIU4LMhHGukHSCXG3VOVnadjqs28V7XVZeXpCmlXfjhNWBDT3wmwFnzS0ZQbIaQhKEgixAIUKYHzgg1txwYaf9/ig6cAtVpzLLKVwzbCMqbaatgMF+YlXeKOrSVAIJ/fTcnbhJAGoSCJEAvwezxQUWdDW2sxMMIUG9oKVrXZjR0Esa3c+Bs3I9sR/bjj8mvRUBUWc220wo0Q0hgUJBFiAX59wB8P7Qg4GLmhbVVmLsrORnFtdhawqk1IPjAUkFrXNqhUKBdsUdLFlb+GptsIIQ1BQRIhZq5ICZxM5NsmdTL+viUHTwqm2mxgO3qA8TduZmJbOWz69+Tays5c5451rXBjrKl7RgixdBQkEWLmjicASsFU2xgTLP0XrmqzGz8YYhsjh6daiM2Q3txx2Tk+SBJOtxUogazSpu4VIcTSWUSQ9Mknn8DPzw9yuRz9+/fHpUuX9J57+/ZtzJo1C35+fhCJRNiyZYvWORs2bIBIJOK+unTp0oTvgJDGOyiYahvsAyiMTBuqyshB+bkors1uquWsahOSDw7jjitux0KVk6857uBYvUVJXTTlRgh5FLMPknbv3o1169bhjTfewLVr1xAaGopx48YhMzNT5/mlpaUICAjAO++8A09PT7337d69O9LS0jRfZ86caaq3QEijlVQAkQl820STTLWd4uabRHY2WnuhWRJ5r64QCRLOy+oEgWIREOTCX/OANrolhDyC2QdJ//73v7F8+XIsXboU3bp1w9atW2Fra4vt27frPL9v377417/+hfnz50Mm0z91YGVlBU9PT82Xq6ur3nMJaSnCqTYrMTDOFEv/fxZMtY2z3Kk2ABBJrSHvJ8hLOiuYchMGSTSSRAh5BLMOkioqKnD16lVERERo2sRiMSIiInD+/Hmj7v3gwQN4e3sjICAACxcuRFJSUr3nK5VKFBYWcl+ENDXhVNugDoCTsVNtmbkoP3+Da7PkqbYaNoN7ccfCIKkTjSQRQgxk1kFSdnY2VCoVPDz4bc49PDyQnp6u56pH69+/P3bs2IFDhw7hs88+Q3x8PIYOHYqioiK912zatAkKhULz5ePj0+jnE9IQpZXAiQS+zTRTbYJVbRY+1VbDZkg4d1x5Nx5VWXmaY2Hy9v1cWuFGCKmfWQdJTWXChAmYM2cOQkJCMG7cOPz666/Iz8/Hnj179F6zfv16FBQUaL6Sk5ObscekLTqRAJTX2atVIjLVVFskd2w3dpBFT7XVkIV2hsiW33OubnK6cCQpvxzIphVuhJB6mHWQ5OrqColEgoyMDK49IyOj3qRsQzk5OSE4OBgxMTF6z5HJZHB0dOS+CGlKB+7zxwM7AC5G7jtblZmrvarNAgtI6iKytoJ8QAjXVna2tqikzhVuNOVGCKmHWQdJUqkUvXv3xrFjxzRtarUax44dw8CBpttfqri4GLGxsfDy8jLZPQkxRoESOBbPtzVJAclWMtVWw2aI/rwkiVh7DzfKSyKE1MesgyQAWLduHbZt24adO3ciOjoaTz/9NEpKSrB06VIAwKJFi7B+/XrN+RUVFYiKikJUVBQqKiqQkpKCqKgobpTohRdewMmTJ5GQkIBz585hxowZkEgkWLBgQbO/P0J0+fUBv6pNKjFNPlJrnWqrIUzerryfiKqM2mVswrwkWuFGCKmP1aNPaVnz5s1DVlYWXn/9daSnpyMsLAyHDh3SJHMnJSVBLK6N9VJTU9GrV+0H5ebNm7F582YMHz4ckZGRAICHDx9iwYIFyMnJgZubG4YMGYILFy7Azc2tWd8bIfr8GM0fj/Qzwaq2rLxWVUBSF1lIMET2tmDFtclG5eeiYD9jNABa4UYIMYzZB0kAsGbNGqxZs0bnazWBTw0/Pz+wRyxZ2bVrl6m6RojJJRUAl1P5tlldjb9va9mrrT4iKyvYDAxF6dHaEiFl565rgiStFW451SvcRKLm7CUhxFKY/XQbIW3Nvrv8sZO8eiTJWCVaBSRb11RbDfnAUO64/NIfmv8XjiTllQM5Zc3RK0KIJaIgiRAzwph2kDS5U3VOkjGqsvJQdjaKa2ttU201bAbwQVJFdDxU+dU10HwcAZnge0l7uBFC9KEgiRAzcj0diM/n22bSVJtBZCHBEMmltQ2MaUaTJGIgkPKSCCENREESIWZkr2AUyU8BhJugJJjWVNvYga1yqg0ARDIpZL34yLL8wk3N/wv3cKORJEKIPhQkEWImKlTAL4ICkjO7Gp9U3Jam2mrIBVNu5RdrgyRhXlIMjSQRQvSgIIkQMxGZUL1VRl0zuhh/35KfTwim2uStdqqthk1/vvJ2edRdqMuVAHTv4UYIIbpQkESImRDWRurjBXRUGH/f4h+Pcsd244dAbGtk0SUzJ+vbnR+Cq6iE8nr1XKZwJCm3DMihPdwIITpQkESIGSgoB44n8G2mSNiuTEpD+eVbXJv9rAjjb2zmJI72kHYP4tpqptw6KnSscKPRJEKIDhQkEWIGDjyozkmqIZVUL/03VvG+Y9yx2NkRtiP6GX9jCyDv35M7rkne1rmHGyVvE0J0oCCJEDOwVzDVNtofUJhgRqx43+/csf2UERBJrY2/sQUQ1ksqv3wLTFUdiXaivCRCSAOYZFuSiooKREdHIysrC/n5+XBycoKbmxu6du0KqVT66BsQ0oYl5gNX0vi2mSZI2FZGx6HidizXZj+z9U+11RCOJKkLi1FxNx6y7kFaZQCoVhIhRJdGB0lZWVnYsWMHDh48iEuXLkGpVGqdI5PJ0K9fP0yePBmLFy+mDWQJ0UFYYdtZDozwM/6+xXv5USSJl5vWlh2tmZWXG6x8vVCVWBuBll+4CVn3IK2RJJpuI4ToYnCQFBMTg9deew379u1DRUUFAMDV1RW9e/eGi4sLHB0dUVBQgLy8PNy9exenTp3CqVOn8Oqrr2LmzJnYuHEjgoKCHvEUQtoGxrQLSE4ONn4bEsaY9lTbjNEQidvWDLu8fyiK6wZJF29CsWym1khSzp8r3NrZNnMHCSFmzaAgac2aNdi2bRtUKhVGjhyJxx57DCNGjIC/v7/ea+Li4nDixAl8++232LNnD3788UesWLECH330kdGdJ8TSXUsHEgv4tlkmWNWmvHqHG0EBAIc2NNVWw2ZATxTvOaQ5LrtwE4wxdFSIIJMAyjrJ8g9yKUgihPAM+rVy+/btePrpp5GUlISjR49i6dKl9QZIABAQEIBly5bh2LFjSExMxKpVq7B9+3ajOk1IayFM2PZ3AsI8jL+vcKrNOtAH0pBg42/cxEqrypFakoOUkmyklGSjuLLMqPvJBUUlVWlZqEpO173CjfKSCCECBo0kxcXFwdOz8RtJtW/fHh9++CHWr1/f6HsQ0looq7S3IZnRxfhtSFhlFYqEU22zxkBk7I1NTM3UuJOfhHMZd3A7LwH3C1N0BkV2VnJ0sHNFdydf9HDxQz+3LlBI7Rr0DOtOvhC7KKDOrR2uK79yG9YdvRDkAtzJrj2X9nAjhAgZFCQZEyA1xX0IsWQnEoACwXoHU2xDUnrsAtTZ+VybOa1qy68oxk+J5/Fz4nlkluc/8vySqnLcK3iIewUPsTfxLCQiMUJc/BHhHY6I9uGwtdK/Ua9IJIK8dzeUHj2vaVNevgWHmRG0PQkh5JGMKgFw//59BAeb/xA+IeZImLDdz9s025AU7fqNO5b36wlpoI/xNzZSaZUS38Yex67YSCjVlY2+j4qpcT0nFtdzYvFJ9M8Y07435voPQ0d7d53ny/v04IKk8iu3AejY6JZGkgghAkYtdRk8eDAuXrxoqr4Q0mbklwPH4/k2U2xDosrJR8mRc1ybw/zxxt/YSCdSb+CxE5uw88FRowIkodIqJX5KPIfHI9/Fm9e+QnxRutY5sr7duWPlrQdQlym1RpKyy6r3cSOEkBpGjSSVlJRg9OjR2LVrFyZPnlzvuefOncOgQYOMeRwhrcYv94FKde2xTAJMNMU2JHt/ByqrNMciuRR200YZf+NGKqksx5bbe3Ho4RW95/jae2CIR3f0cPaDr70H2skdYSWSQA01csoLkVqag7sFybiVm4Cr2Q90BlkMDL+nXsex1ChEePfCyq6T4GFTnZkt79UVEIsB9Z/f8CoVlFF30bF/KKQSfjuYB7lA//Ym/RYQQiyYUUHSsWPHMHXqVMycOROfffYZli1bpnXOzZs38fe//x2//fYbqqqqdNyFkLZHONU22h9Q6E+tabBCwVSb3cRhkDjaG3/jRogvSscrl/+H1FLteSwxRBjTvjfm+A9FZyf9U4Ht7VzR3s4Vfd06AwDKVRW4lHkXvz68jPMZd6AG485nYDiaeg2n0v/AgsCReCxwJGzsbSHtGoCK2zGa88qv3ILNwFAEOgPRguRtCpIIITWMCpIGDhyIc+fOYcKECVixYgUePnyIN954AwAQGxuL1157DXv27IFarYaPT8vnRBBiDhLygWvCbUhMURvpTiwqbvLL5RzmTzD+xo1wPuMONlz/CqVV2pX4+7l1xppu0+DvYPgCDrlEimFeIRjmFYKMsjzsTzyHvQlntJ6jVFdix4Mj+DX5El7oORtBfbvzQdLlWwCq85LqBklUBoAQUpfRe7d16tQJ58+fx5QpU7Bx40YkJSXBysoKO3bsQGVlJdq3b4/169dj+fLlpugvIRZPuA2Jiw0w3Nf4+xbtPsQdS7zcYDOst/E3NtDBpIt47+YerVEeOys51vWYhTHtw01SjsDDxhkru0zCgoAR+CH+NL6PP4XiqnLunMzyfLx0+XOscLNH3cl+5ZXbYIyhUzu+H1QGgBBSl0k2uHVzc8PevXsRFhaGHTt2AKhe5v/KK69gxYoVkMlMMI9ASCugaxuSKabYhqSiEsXfH+baHOaMhUhi5I0NtDfhDD64tVervavCBxt7L4anrYuOq4zjKLXDk53HY6b/EGy/dxg/JZ7TCtB+csnmgiRVVh6qEtPQycWbOy+GRpIIIXUYvZFTUVERNm7ciB49eiA7OxsikQiMMYSHh2P58uUUIBFSx5U0IEmwDclME9RGKvntDFRZeVxbc0+17YqN1BkgjfbuhY8GPdMkAVJdTlJ7rOs5C18MewHh7fgs+AwPGQrt+d8Jy6/c0lrhllUK5NEKN0LIn4wKkv75z3/C398fb775JpRKJV588UU8fPgQ8+bNw8GDBzFq1Cjk5ND4NSE19gm2IQlwAkJNsA1J4Zc/ccfyAaGQdjLBHF4D7Us4i0+if9ZqXxg4Cm/0ehwyibTZ+hLg6IUtA1bhlZB5sLeSVzeKRIgN4hPYM85dgq9CexSP8pIIITWMCpJeffVVFBUVYeXKlYiJicG7774LT09PfPfdd1i3bh0uXLiAQYMGIT4+/tE3I6SVU1YBBx7wbTO7Gr8NSUVsMspOXeXaHBdPNe6mBjieGqVzBGl55wlY1XVyi2yHIhKJMKljf3w14mUM9egBAIgJ5LcySTp1BqfSoxDgxF9LeUmEkBpGBUmPPfYYoqOj8emnn8LLy4t7bfPmzfjggw8QExODQYMG4coV/XVSCGkLjidob0My3QRTbYVf8SM4YhcF7CYPN/7GDXAl6z7euv4NmCAH6JmuU7Go05hm6UN9XOUK/KPPUqwPnY/kYH5H2w7JJfjH+S8gtk7l2mkkiRBSw6gg6euvv0ZAQIDe19euXYtdu3YhLy8Po0a1XEE7QszBXsFUW//2gI+jcfdkygqtbUgc5o2HWN70uYAPClLwtyvbUcVUXPuTweMwP3BEkz+/oUQiESb69MNLj6+HWlw7qiVRA/7xJUhR3uDOp5EkQkgNoxO3H2XOnDk4cuQIrKxMspCOEIuUV1a9oW1dptjMtvjgKahz+Exwx0VNP9WWpyzC+ivbUaaq4Npn+g7Gkk5jm/z5jeHr3hGy7kFcW1BsCaylGVwbjSQRQmo0eZAEAMOGDcPZs2eb41GEmKWm2oakcKcgYXtwL0iDOhp/43pUqqvw2tWdyCjjV9ON8g7D2h4zWiQHqaFs+vTgjoNiimEt5fd7yyqt3luPEEIMCpJu377d6Ad17VpbUtiY+xBiiYS1kcYEGL8NiTI6DuXnori25kjY/vD2ftzIjePaejr74++hj0EsapbfuxpNLtjstlNsCayssgDwWyZdTCtsxl4RQsyVQZ9oISEhWLBgAW7evNmoh12/fh1z585FaGhoo64nxBLF5QHXBZvTm6I2UsF/v+eOxa5OsJ84zPgb12N/4jn8lHiOa3OXO+HtPksglZj/lLpcMJJkX1SJboXWsJZmce3vXD2L7HIKlAhp6wwKkt544w0cPHgQvXr1QlhYGN59911cuHABSqX2/kwAUF5ejvPnz2PTpk3o2bMn+vTpg0OHDmn2dyOkLRBuQ9LOBhhmZAkjVU4+in84wrUpFk+DSNZ09YiicmKxRbDUXyq2wj/7PgkXmUOTPdeUrPy8IXZ14tpeRz8obPipw8xie/z1wmfIUxY3Y+8IIebGoF/9Xn/9daxatQr/+Mc/8OWXX2L9+vUQiUSwsrKCj48PnJ2d4eDggKKiIuTm5iI5ORkqlQqMMSgUCqxduxbr16+Hm5tbU70fQswKY9pB0pRgwNrI3UIKv/wZrLxO0rS1FRyXTDfupvVIL83Fq1d3QMXUXPv60PnorOjQZM81NZFIBHmfHig9dEbTJrsZjznTJuGzOlVKKis8kFCcgZcvf47/DFwNeTMWwySEmA+Dx8fd3d3x4Ycf4p133sGePXtw4MABnDlzBnFxcVrnenp6YujQoZg0aRLmzp0LuVxukk4TYimupALJglkbY6faWGUVCrbv49rsp4+ClaercTfWo6xKifVXtqOgooRrXxg4ChHtw5vkmU1J3qc7FySVX72DkOV8glhlhScAIDo/CW9f/wYbey82+3wrQojpNTqJwMbGBosXL8bixYsBAFlZWcjMzERBQQEUCgXc3d1pxIi0eT8KRpECnYEQI7chKf4lEqr0bK7NaeVc426qB2MMm27sQkwhX3BxoHs3LO8ysUme2dTkvbtxxxV3YtHJvgJA7WiRWuUIlcoWEkkpTqb/gf+7exBPd53SzD0lhLQ0ozItL126hH79+gEA3NzcKCgipI7yKuDgfb5tZhfjtyEp+L893LG8fwhkoZ2Nu6keX8X8jhNpfLFFX3t3vN5rISQWOrIiC/vzD4H9WSW8SgWvpHuQSnqiok5dzMoKD0hsqrdU+jb2BLooOmKkNy06IaQtMepTbsCAAZg0aRIuXbpkqv4Q0mociwcK+VqLRm9DUnbxJpTX+NLdihWzjbupHmfSb2HbPb6at72VHP/s8yTsrW2a5JnNQWxvC2kXf66t6nq01h5uqkpv7vidm7uQVJzZxL0jhJgTo4Kk999/Hzdu3MDAgQMxceJEXLx4Ued5f/nLXzB69GhjHkWIxREmbA9oD3QwchuS/P98wx1bdfCA3cShxt1Uh9jCVGy8zj9LDBE2hC9CR3t3kz+vucl6deWOldfuILgdf053+0HccWmVEq9d3QmloMo4IaT1MipI+utf/4rY2Fi88cYbiIyMxKBBgzB+/HgcP34c9+/fR2xsLI4cOYIffvgBFy5cMFWfCTF7uTq2IZnZVeepDaa8E4vSI3yNIsXKuRCZeMufPGUx1l/ejjIVX9rj6a5T0N/dBAWezIAwL6n82h10EgRJlZWeGN+hD9cWV5SG/7v7a1N3jxBiJoz6dI2NjcX8+fNx7do1sD/n948cOYKjR49y5zHGsHTpUmMeRYhFOfgAqBJsQzIhSP/5DSEcRRK7KOD4hGmTiSvVVXj16hdIK+M3MBvXvg/mBQw36bNaknAkqSoxDYFWxQDsNW0PckTYMX027hekIK4oTdP+ffwpDPbojt6uJthXhhBi1owKktauXYurV6+id+/eGD9+PJycnAAABQUF+Oyzz5CTkwOZTIb3338fy5cvN0V/CbEIwqm2iADA0YhtSCoTUlG87xjXplg+C2I70+UGMcbw/h8/4GZuPNfe3ckXL4bMMes92Qwl7eoPka0crLR2kzbflPsAaksaZJcBpRVSvBm+CMtOv48Kde3WJf+M+g47h79o0blZhJBHM2q67fz58+jZsycuXryIt956C88//zyef/55bNy4ETExMXjmmWdQWVmJjz/+GIWFVOKftA1JBcDVNL5thpGzVPmffgeoa4emRLY2UCybZdxNBb6NPY6DyfwiDHe5E/7RZylkEmuTPquliaysIAvhVwS634mCVFDk834O4OfggVVdJnPtmeX52Bp9oKm7SQhpYUYFSSqVCl27doVYrH0bhUKBjz76CLt27cK9e/ewatUqYx5FiMXYf48/dpIDw43YhqQqIwdF3/J5MI6Lp0LibGQWeB2/Jl/C1rsHuTa5RIpNfZ9EO7npnmNOZOGCKbertxHozJ9zP6f6v7P8hyC8HT9f+nPSBdzOS2jCHhJCWppRQVK/fv1w6tQplJSU6D1n9uzZGD16NI4dO6b3HEJaC8aA/YKptsmdoDVCYYiC//seTMlvQeK0ynTFI89l3MF7N/dotf89bAGCLWjLEUPJw/nkbeX1aHRyYVzb/T9Ts8QiMdaHzue2J2Fg2PzHD6hSq0AIaZ2MXt2Wnp6OSZMmISEhQe95EokEZWVlxjyKEItwKxOI5fdKNao2kionHwXb+U1lHeaOg5W3aZbhX81+gNev7tTak21Nt2kY4dW6CycKR5LU+UUIFBVwbQ9yav/f09YFS4PHcq/HFKbix4QzIIS0TkYFSRMmTMDq1atx6tQpdOvWDc888wyOHj2qGVmqqKjAp59+iqNHj8Lf3/8RdyPE8gkTtjs4An28Gn+//I+/BSup8wuGWAynZx9r/A3ruJJ1Hy9d2galupJrXxAwslWtZNPHqoMHJG4uXJtfJp+0fp9f5Ie5/sMR4ODJte24fxj5FcVN0kdCSMsyusDKxx9/DE9PT/zzn//EZ599hq1btwIA7O3tUVZWBpVKBcYYVq5caXRnCTFnVWrgZ8E2JH19srE7/hYyy/JQWqWEmjE4WNvCVe4Ib9t26OLkA3e5k86VY1UZOSj4Hz+KZD8rAtLAjkb39XT6LWy49iW3YgsAxnfog1VdJxl9f0sgEokg692N2+y24/0bgFsvzXFuGZBTCrSzrT62EkvwfM85eObcR5pziqvKsfP+UaztMaPZ+k4IaR4mqUL36quvYuXKlfjqq69w9OhRXLt2DVlZWRCJRAgICMCaNWuwdu1aUzyKELN1LhnIKuXbLhR+jqt36t/KwlXmiH7uXTDYvRv6uHWGrVV1rYD8/3wDVlanoKNEApcXjKs3xhjDnvhT+OTOz2Dg829GeoXi5ZB5bWq3e3mvrlyQ1O7yecimLIGyTprR/VxgoG3tcYiLP8Z4h+No6jVN277Es5jpNwQ+9rR/JSGticlK9bq5uWHdunVYt24dAKCyshIikQhWJq4GTIg5Kq1S4v3LOQBq9/uSypJhLX30Xl/ZykL8mnwJvyZfglRshWGePTHRKhAuO3/iznOYNx7WAY1PpC6tUuKDW3tx6OFlrddGe/fCq2GPwUpsRIa5BZIJKm9X3XqAwCfUuJNTGyjezwEGCr7ty7tMxMn0m5qROBVTY+vdA/hHHyqaS0hr0mS/MlpbW1OARNqE8xl38Njxf+NGKp/fYmt/1eB7Vair8HvqdVx/ezMgWNHm/PziRvfxenYMnjr9b50B0kSffm0yQAIAWRhfKwkVlQgU8zXd7udAi5etC2b783vmnUr/A3fyEk3dRUJIC6IohpBGUqoq8eHtffgl6QJKinqBMXmdV9Wws78Oa7EEnRU+aG/rCkepLUQQIb+iGJll+YgpSkVxpfaqz3bZSgw/lc21XRnZHhcqohFRJoeHjbPWNfrEFKbiqwe/43halM7Xl3eeiCeCRreqatqGkCgcYN3JF5UPaoMb//xkAE6a4we52tcBwONBETiYdAkFlbUlUL64fxj/6r+iiXpLCGluFCQR0giZZfl49coXiC5IBgCUFIdzr3sqUvHOgNno79YZsjq1depijCG5JAuXsu7iTMZtROXEQsXUmPpzKqxUtflClVYifDPOCXl3D2Dr3QPoovBBuGsQerULgr+DJ9zkCk0eUZVahYTidNzIicOJtBu4kRun89m2VjK8HDIPo7zDTPDdsGzy8K5ckNQx/g7Qoafm+H5Odf0rYRzpYG2Dx4JG4rM6lbcvZN3F7bwEdHf2a+puE0KaAQVJhBjoYUkW/nJhKzLKqgsiqVS2KC/liyG91L8DhnnWnz8kEonQ0d4dHe3dMdt/GPIrinHq4u/oevYKd96JEW7Ic6kNtO4WJONuQTK+jT0BALAWS2ArkUMNNYp0jEwJdXXqiDd6PY72dq4Ner+tnSy8G4p2H9Icd7h2DugwT3OcVw5klwJudtrXzvAdjF2xkcirUwJg+/3DeL8/reYlpDVoO8tYCDGBuMI0PHPuY02ABABlJT0B1ObzyCTAuEDD7+0ktUf/XbchVteOIlVIxTg42bueq4BKtQoFlSWPDJDsreT4a4+Z+GzwcxQg1SEXJG+73rwOuUR35W0hGysZHgscxbVdyrpH25UQ0kpQkERIAz0sycLaC58hV1nEtatK+3HHo/wBe90zbPWqeJCI4h+OcG2uT83FW+PWYkrHAY3ecV5hbYcng8dh96i/Y6bfEEja0BL/hpB2C4RIVvsHJgZDgDVfy0FX8naN6X6D4CJz4NpqRvkIIZbNIj4tP/nkE/j5+UEul6N///64dOmS3nNv376NWbNmwc/PDyKRCFu2bDH6noTkKYvwwsX/alVW9rUNRlGpH9c2JbiRz/jXF4C6dnsQka0NXJ59DL1cg/BSyFz8FPEmPhzwNBZ3GoOezv6w0ZPrBADetu0wtn1v/LPPk/gx4nUsDR4HR6mO+SICkbUVpCH8H5p/aRp3/KCeIEkukWJ+wAiu7XT6LSQVP7r8AyHEvJl9TtLu3buxbt06bN26Ff3798eWLVswbtw43Lt3D+7u2vtXlZaWIiAgAHPmzMFf//pXk9yTtG3lqgq8dOlzpJTy/1L2cPZDuO2TOM1qM3ptrYFRfoY/Qxkdh+L9x7k2xYrZkLjWrmSTSqwQ7toJ4a6dgM7Vid+5yiJklOVBqa4EYwxOUnu4yh0pIDKQPLwrlJdvaY59H94HOgZpjvVNt9WY2nEgdj44ipKqcgDVm9/uiT+FF3rObpL+EkKah9mPJP373//G8uXLsXTpUnTr1g1bt26Fra0ttm/frvP8vn374l//+hfmz58PmUxmknuStosxhn/d/B53/1zFVqOTY3u8338FjsTwozkR/oCNteHPyXt3e/USqj+JHezgtHp+vdeIRCK0kzuim7MverULQrhrJwQ4elGA1AiycD4vqcMtPnm+ZoWbPnbWckztOJBr+y35EvIEU7OEEMti1kFSRUUFrl69ioiICE2bWCxGREQEzp8/bzb3JK3X/sRzOJLCF4X0snHBv/otR2G5HJdT+fMbM9WmvHkfJQdPcm2Kp+dB4uxo+M1Io8gFQVLHuFvccYESyBRsOSM0x38orES1CfwV6irsTThrsj4SQpqfWQdJ2dnZUKlU8PDw4No9PDyQnp7erPdUKpUoLCzkvkjrdjsvEf+5vZ9rs7WS4V/9l6Od3BEHH4Db/cxBCgz3Nfw5ue/+jzsWOzlAsXKO4TcijWbl6wWxi0Jz7JmfDhuRijunvrwkAHCzcUJEe75e1r6Es1CqKvRcQQgxd2YdJJmTTZs2QaFQaL58fHxaukukCZVWKfHW9a9Rxfh/KP8eugC+9tUB9i/3+WvGBQIyA7P8yq/eRumRc1yb0zMLIHG0N7jPpPFEIhFkobVblIjB4FfJR0X1rXCrsUCQwF1QWYLfU6NM0ENCSEsw6yDJ1dUVEokEGRkZXHtGRgY8PT2b9Z7r169HQUGB5is5OVnvucTyfXrnZ61E7ccCR2KYVwgAIKkAuC4YeJzciKm23Hf5PDhxOwUUT80y/EbEaPJeXbljv6x47ljf9iR1BTh6oa8bvx/cvoQzYPUlNBFCzJZZB0lSqRS9e/fGsWPHNG1qtRrHjh3DwIED67nS9PeUyWRwdHTkvkjrdD7jDn5K4vPTejj7YXnniZrjgw/4a5zkwBADBxfLLt5E2Qm+9ITzswshtrc17EbEJGS9+KrpPjE3ueOGjCQBwEzfwdzxvYKHuJOfZFTfCCEtw+xLAKxbtw6LFy9Gnz590K9fP2zZsgUlJSVYunQpAGDRokVo3749Nm3aBKA6MfvOnTua/09JSUFUVBTs7e0RFBTUoHuStqukshzv3dzDtdlIpPh72AJYiWuTcoVTbROCAGsJDJL3Hj+KJHF3gePSGYbdhJiMLIwPkvxS+Ej4fq7uPdyEBnp0g6eNM9LrVGXfn3gW3Z0bkbBGCGlRZh8kzZs3D1lZWXj99deRnp6OsLAwHDp0SJN4nZSUBLG4dkAsNTUVvXr10hxv3rwZmzdvxvDhwxEZGdmge5K2a9u9X5Gt5JPy13Sbhg52bprjuDzgdhZ/3eROhj2n7Ox1lJ3iV805rX0CYlu5YTciJmPl6QqJlxtUadV/uMLptkIlkFkCeDwiXUwiEmOa7yD8392DmrbjqVF4pttUOEkp14wQSyJiNFneKIWFhVAoFCgoKKCpt1YiOj8JK898CFZnzVpft854v98KiOoMH3x4Efj3hdrrXG2Ai08BVg2cvGaMIXXasyg/f0PTJvF0RcfLuyCW667tRZpH+uK/oeTX0wAANUSY8rffUSaurYX19XRgaAMGhPKUxZh17E1UqmsT/1d1mYSFQaNN3WVCiIEM+ffbrHOSCGkuVWoV/nXzey5Akoqt8EKP2VyABGjnI03s1PAACQDKTl/lAiQAcP7rIgqQzEDdKTcxGPwKU7jXH1V5u4azzB4jvcK4tp+TLkDN1LovIISYJQqSCEF1zsgDwT+IizuNhbddO64tPg+4J0jgNWRVG2MMee/wdZGs2rvDceEkg/pLmoZMsMLNN/ked9zQ5G0AmOnHJ3CnlubgRk5co/tGCGl+FCSRNq+gogT/u3+Ya/Oz98CCwBFa5x6O5Y9dbYA+Xg1/VtmJSyi/zFdzdl63mNuFnrQcYfK2bwb/B97QkSQA6ObkC38HvqzIgeSLje4bIaT5UZBE2rwd94+guLKMa3u+52xYi7XXNRwSBEljAwGJAblIwuraVr5ecFgwUc8VpLlJnBxg7d9Bc6xVK+kRe7jVJRKJMNGnH9cWmXYDRYK/a4QQ80VBEmnTkoozsS+R319rlFcYwtoFap2bUaxdQHKc9ml6lR49D+W1aK7Ned1iiKzNfpFpm1K3XpIwSCqqANKLG36vce37QCKq/ZitUFfhWOp1o/tICGkeFCSRNu2TOz9DVSeZViq2wqquk3Wee0SQTuIgBQY1sIAkY0yrLpKVX3s4zB1nUH9J06sbJLkXZsJGMPJjyJSbs8weQzy6c20Hk2jKjZD6MMbw8qXP8cX9w8hTFrVoXyhIIm3W1ewHOJd5h2ub4z8MXrYuOs8/FMMfj/QDpA0sIFl2/BKUN/gkYJcXl0BkRaNI5kYWVpu8LQLgl8mPJgkT9x9lkk9/7vhuQTJiClMb2z1CWr0/8hJwLvMOtt8/jNnH3sI7N3a32DQ1BUmkTWKM4b91iv0BgLPUHk8EReg8v6AcuMAvfsP4oIY/K+/fO7k2a/8OsJ+p+1mkZcl6dgLqFKj1z+SHEO9lG3a/vm6d4Srja7H8SgnchOi1Jy5S8/8V6ipcy34AG0nLLG6hIIm0Secy72jtp7Ws83jYWeuueH0sHqiqU+JGJgFGNHCXifJzUSi/9AfX5rT2cRpFMlNiOxtIu/hpjv0z+Wz9uwaOJFmJJZggSOA+8vAaKtVVje0iIa1WSkk2TqXzK4Bn+w/ltoVqThQkkTZHzdTYdvdXrq29bTutaZG6hKvahnYE7Br4i03elq+4Y6sOHnCYM7ZhF5MWUXfKLUAQJD3I4QPmhpjo05c7LqgswaWse3rOJqTt+iH+NFfU185KXu9nc1OjIIm0OcdTbyC2KI1rezJ4vN7fVMoqgZOJfFtDV7WVX7uDssjLXJvTmscgklo3uL+k+dVN3g4QTLcpVUBCvmH362Dnhh7OflzbkZSruk8mpI0qqizDweRLXNvkjv31jvA3BwqSSJtSpVbhf/cPcW3+Dp4Y3b6XniuqA6TyOjMjYhEQEdCw5+V9wI8iSdxd4PAYVdc2d/I6lbcVZQVwKeLn2AxN3gaAse17c8dn0m+hpLK8Uf0jpDU6kHQBZSql5lgMEWb7DW3BHlGQRNqYwylX8bAki2t7qvMErpaN1jWCqbb+7QEXm0c/S3k7BqWHznBtTqvnQ2xDe7SZO2nXAKDOaJ9/liAvycDkbQAY5R2mVTPpZPrNRveRkNakSq3CD/GnubYRXqHw1LPauLlQkETajCq1Cl8/+J1r66rwwVCPHnqvqVQBv/MrwBs81ZYvyEUSOzvCcfG0hl1MWpRIag1Zj9rliwGC7UkaM5KkkNphgDu/NxxNuRFSLTLtJjLL87m2uQHDWqYzdVCQRNqME2lReFjKDwEs6zweIpFI7zUXU4BCJd/WkCCpMiEVxT9Hcm2KlXMgtrdtaHdJC+OSt7P4vKTGjCQB2lNu17JjkFWW37ibEdJKMMa4Zf8A0MPZD90FeXwtgYIk0iaomRpfCkaRuih80M+ti54rqglXtYW4A94Oj35ewf/tAdS1S6BEdjZQLJvV4P6Sllc3eVtYKymxACipMPyegz26wdaqdrqVgeFYalRju0hIq/BHXgKiC5K5trn+w1uoNzwKkkibcDr9FhKKM7i2RZ3G1DuKpGba+UgNGUVS5RWi8Fu+UKXjoqmQODUguiJmQ14nSPLNToBYreJeN2R7khoyiRQjvEK5NppyI22dcBTJy8YFQz31p0E0JwqSSKvHGMPOB0e5tgAHLwz26FbvdVHpQGYJ39aQKtuFO/aDldZZtSSRQLFiTkO7S8yEdVBHiOyqM/RlVRVon/uQe91UU24PClMQV5im52xCWjddxSNntWDxSCEKkkirdyEzGg8K+T1FFnWKgLieFW2A9ihSoDMQ9IiFFupyJQq2/ci12U8fBesOHg3uLzEPIokEstDOmmNhUcnGJG8DQFi7QK1tSmg0ibRVwuKRtlYyTG7B4pFCFCSRVk3XKJKPnZvWlIf2ddpB0vgGTLUV/3AUqix+HsZp9fwG9ZWYn/qKSkY3ciRJIhIjon0413Y8LQqMMT1XENI66SoeOaXjgBYtHilEQRJp1a7lxOB2Pl8u+/Gg0fXWRQKAB7lAfD7f9qh8JKZWI/+zXVybzbDekIUEN7S7xMzI66xw07XRbWPjmghvvnhpWmku7goSVwlp7XQVj5zVwsUjhShIIq3aNzHHuGNPG2etnBBdfovhj73sgZBHzJiV/n4Blff5gMxp9YIG9ZOYJ1lYnRVugoKSeeVAZmnj7hus6IAOtq5c23Fa5UbaEF3FI4d7hcCrhYtHClGQRFqtmMIUXM6+z7U9FjiqQQmBula11bMQDgCQ/yk/iiTtGgCbUf30nE0sgZWvF8QuCgCAV14a5BV8VHSvkVNuIpEIo7zDuLbjqVFQMwN3ziXEQukqHjkvwDyW/ddFQRJptXbFnuSOnaT2Wrux65JcCNzmdy555FSb8lYMys9e59oUq+fXW2KAmD+RSKRJ3haDwT+TL79+t5HJ2wC0gqTM8nzczkvUfTIhrYg5F48UoiCJtEoZZXn4PfUa1zbTbzBkEukjrz0iGEVylgP92td/TcHnP3DHEncXOMyMaFBfiXmru9mtv4kqbwPVZSh87fk53GOp1/WcTUjrobt4ZMtvQaILBUmkVfoh/jRUdaYuZGJrzPAb3KBrhVNtEf6AVT0/KarcAhT/yK+gc1wyHaI6G6QSy8WvcDN+o9saIpEIowWjSSfSbnB/bwlpjYSjSJ42zhjq2bNlOvMIFCSRVqe4sgw/J53n2ib69IOT1P6R12aXApf4kkqPLCBZ+M0BsPI6e1RYW8Fx0dSGdpeYubrJ28IgKSYXqDIiphFOueUqi3AzJ073yYS0AqklOTgtKB4523+Y2RSPFKIgibQ6vyRdQGlV7bJSEUQNTgg8GgfUXdVtaw0M6aj/fKZSofCL/Vyb/dSRsPJoZ0CPiTmz8nSFxMsNgHYZAKUKSMhv/L197T0Q6ODFtR1Li2r8DQkxcz8knILajItHClGQRFqVSnUVvo8/xbUN8+yJ9naueq7gCafaRvgCciv955cePouq5HSuTfEUbWTb2tTs46YoK0S7In6OzZgpNwAYJaiZdDLtJqoE+8QR0hoUV5bhQBJfPHKST3+zKh4pREESaVWOpUYhq7yAa1sQOKJB1xYpgbOCen6PWtVW8Dm/BYmsV1fIete/JxyxPFy9JMFokjEr3ABo5SXlVxTjek6M7pMJsWAHky9pFY+c7W9exSOFKEgirQZjDN/FnuDaQlz8G7ysNDIRqKjzC7y1GBjlr/98ZXQcyk7zK+gUT82kZf+tkKzuCjfhHm5GjiS1t3NFF4UP13aMCkuSVkbF1PhRUDxyqGcPeNuad2oCBUmk1bicfR9xRfxu6vMDRjb4euFU2yAfwFGm//zC/+3ljiVuzrCfNqrBzyOWo+5IUqAgSGrsHm51CRO4T6bfRKW6yvgbE2ImTqf/gbQyfl/LuWZYPFKIgiTSaghHkXzs3DDYo2FTX+VVwHG+TmC9G9qqCotR9P1hrs3xiakQyR5dh4lYHomTA6z9OwDQXuGWXAgUKnVd1XDCIKm4sgyXs+7rPpkQC7Qnjs8V7aLwQU/neobqzQQFSaRVeFCQgiuCLUjmB4yA+BEb2dY4mwyUVNYeiwCMCdB/fvH3R8BKy2sbJBI4LplmQI+Jpampl+SblQArVSX3mrGjSR42zughmBamvdxIaxGdn4Q/8vjfQucGDLOI1AQKkkir8F0cP4rkLLXHuA59Gny9cKqttxfgZqf7XMYYCr/8iWuzmzAEVn8uEyetU02QZK2ugm9WAvfanSwdFxholFcYd3w64w8oBcEYIZZoTxy/RZSbXIGRgr/v5oqCJGLxMsrytH7rnuk3BDJJwypeq9TA74L6fePqKSCpvHIbFXf4CxwX0yhSaycLq03eDsp4wL0m3OuvMUZ6h0KE2t+sS6uUuJh11/gbE9KCMsvycSLtBtc202+I2RaPFKIgiVg8XVuQTPcb1ODrr6QBOWV8W335SAU7+FEkKz9v2Azr3eDnEcsk69kJEFd/ZAalmz5IcpUrEOLC52jQlBuxdHsTzmh9Pk/tOKAFe2QYCpKIRdO1BcmkBm5BUuOQoCRNN1ego0L3uar8IpT8fJxrc3xiKkRi+lFq7cR2NpB2rQ5igjL4vzQPcvjyEY01WlBY8lzGbZSrKvScTYh5K6tSan0+j/fpC0epnlwGM0Sf7MSi6dqCxJBlpYxp5yPVV0CyaPchrX3aHBZMbPDziGWThVevlgwUTLdVqqv3cTPWcK8QiOtMuZWpKnA+447xNyakBRx6eAVFlfww/Vz/YS3Um8ahIIlYLGO3IAGAW1lAShHfpi9I0pWwbT9pGKzcnBv8PGLZ5H8WlbRXlsArL5V7zRRTbi4yB/Ry5RPiqLAksURqptb6fB7g3hUd7d1bqEeNQ0ESsVjHjdiCpIZwFMlXAXTRE2OVX7iJyvuJXBslbLctsvDa5G3haJIpVrgB2qvczmfeQWlVue6TCTFTFzLvIrmE/6GY52/+xSOFKEgiFokxhl1xkVxbT+eGb0FSQ9dUm77SHYU7+VEk60AfyAf30n0yaZWknf0gsq3ejLNTEyRvA9VTbpI69b0q1FU4m3HbNDcnpJkIR5ECHLzQ27VTC/Wm8ShIIhbpas4DxBTy0x3zDRxFissD7gs2J9U31abKyUfxL5Fcm+OiqRZRDI2YjsjKCrKQzgB0jyQxZvwzFFI79HEN5tpolRuxJLGFqVrFfef6W0bxSCEKkohF2hUbyR13sHPDYI/uBt1DOIrkZguEe+k+t2jPIaCiTmE/qTUc5o036HmkdZD1rp5yE65wK6qo3qLEFITblFzMuquVAEuIuRKOIjlJ7RHRPtygeyTF55vklw5jUZBELE5cYZpWkb15AcO5KYqGEAZJYwMAsY5fdBhjKPzmINdmP2UEJO2cDHoeaR3kvapXuLkVZsKxNJ97zVRTbkM9e8K6TrG9SrUKZ9JvmebmhDShPGURjqZc49qm+w5qcHFfACgvq8S0XQwRbyfj669uo1zZcps9U5BELI4wF0khtcN4A7YgAYD0YuB6Ot82Xk+VbeX1aFTeS+DaHJ+YYtDzSOtRk7wtgvZokqmStx2sbdDPrQvXdjz1umluTkgT2p94DhXq2qDGWizBDL/BBt3j+z13kWvrjBhHH/w9tzsG/rsI2WkmGqY1EAVJxKJklxdo/ZYyw3cw5BKpQfc5IhhFcpQCAzroPrfo21+5Yys/b8gHhhr0PNJ6WHXwgOTPsg+BTZS8DWivcrucfR8FFSWmewAhJqZUVWJfwlmuLcI7HC4yhwbfQ61m+CLRiWvzK8+Eq5ejKbpoMAqSiEX5If40qlhtaWOp2AozDfwtBQAOCYKkUf6AVMdWQurSchTv/Z1rc5w/kSpst2EikQiyP+sldWqiMgAAMMSzO6RiK82xiqlxKv0P0z2AEBM7lnodeRXFXNvcAMOKR548HINYhQ/Xtqx7y230TJ/0xGKUVinxk7DEfYc+cDbgtxQAyC8HLjzk2/Staiv59RTURXV+exeJ4DCfErbbOnlN5W3BSFJaMZBrovxqWys5Brp35dpolRsxV4wx7Ik7ybWFt+uEIMf2Bt1n2yV+f58OhamYMLOrnrObHgVJxGIcTLqIYsEKn3kBIwy+z+9xgKrOqgmZBBjhp/vcom/5hG2b4X1g1d7D4GeS1qUmL6ljTjKklUruNVOOJo0S7OV2LfsB8pRFes4mpOVcy4lBbFEa12boKNK9m+k468Tn4i1qlw6JlY5h/mZCQRKxCJXqKq2E7SEe3RtV4l441TbcF7DVsfCiMikNZaf5/CeHx2ifNgLIwqo/yCVMBf9M/i/ULRMGSQPdu3L5dmowRKbdNN0DCDER4eezj52b1kjoo/z3QAZ37FBehIULuug5u3lQkEQswtGUa8gsz+fa5geMNPg+JRXAKX5nEUzQs6qtaNdv3LFYYQ+7CUMNfiZpfSTOjrAOqM70F+Yl3co03XNsrGQY5NGNa6MpN2Ju4ovScSEzmmub4z8MYgPKsmSnF+EXaWeubRYewN7Z1iR9bCwKkojZUzE1vok5zrX1dPZHiIu/wfc6kQAo60x5W4mB0Tpuw9RqrSDJftZYiOUyg59JWqeaKbfgtHtc+80MXWc33mjBKrcbuXHIFuxZSEhL2i0sy2Jthwk+fQ26x449sVBayzXHElUVnprpU88VzYOCJDMUV5hGhePqOJ3+B5JK+F/Pnwga3agS98KptsE+gEKufV7ZmWuoSuYLKTnSVBupoyZ5u3MqX9g0sQAoMOF+tP3du8LWqjY4Z2CITLthugcQYoTs8kIcSbnKtc3wM6wsi7K8Ct8V8wFRRNEd+HRyM0kfjUFBkhnJryjG+3/8gKWnNuOfN75DIdVEAWMMX8Uc49qCHL0xwMC5bgAorwKOx/Nt4/WsahPWRpJ2D4Q0JFj3yaRNqhlJ8s+Kg3UVn7xtytEkmcQaQzx6cG3HaMqNmIkfE06jUm1cWZYfv7+LbLt2XNvyEfYm6Z+xKEgyE3nKIiw4sQn7E89BDYaiyjJsv3+4pbvV4i5n38f9An69/uONHEU6kwSU1Cm3IQIwJkD7PFVBEUoO8ktZHRZMssjNGUnTkXYPAqytYKVWISidr7x904R5SYD2Xm638hKQUZZn2ocQYqDSKiX2J57j2gwty6JWM+yI488PzXuAvsN1fDi3AAqSzISzzAH9XPmktf2J55BQZOIEBwvz1QO+kGMHW1eM8GpctetD/L9j6NcecLPTPq943zGw8oraBmsrOMwe06hnktZLLJdB1r066z84jZ9yM3VeUj+3zrC3tuHaTqTSlBtpWb8mG1+W5czvcbjn5Mu1PdlFqefs5mcxQdInn3wCPz8/yOVy9O/fH5cuXar3/O+//x5dunSBXC5Hz5498euv/PTJkiVLIBKJuK/x41u2SOCqrpO1Kux+fOenFuxRy/ojNx5RuXwS0WNBowzeyBYAKlXAkTi+raFTbXbjBtNmtkSnmsrbnZs4edtabIVhnj25NmEeCCHNqUqtwp64U1xbY8qybDvPB0TeRemYPKvlikcKWUSQtHv3bqxbtw5vvPEGrl27htDQUIwbNw6ZmbrHtM+dO4cFCxZg2bJluH79OqZPn47p06fj1i0+GXr8+PFIS0vTfH333XfN8Xb08rJ1wXxBFH4x667W0sq24ssYfhTJVeaIce0N28i2xsUUoEDwy4muDW2V0XFQXue/3w6PTWrUM0nrV5OX1FkwkpRaDGSZOKUwQlBY8kFhCuKL0vWcTUjTOpl+E2lluVzbgkDDyrI8uJWB0wq+DtLjTmmwsm654pFCFhEk/fvf/8by5cuxdOlSdOvWDVu3boWtrS22b9+u8/wPP/wQ48ePx4svvoiuXbvirbfeQnh4OD7++GPuPJlMBk9PT82Xs7Nzc7ydei0MGq21GeDHd35ClVql54rW6XZeolZwOD9wJKQSKz1X1O83wVRbqAfgrWPavOg7fhRJ4tEOtiMNW8pK2g557+oVbh2zEyGv4Kcd/jBxXlK4aye0k/GbfB5+eMW0DyGkARhj+C72BNfWzakjejobVpZl2y9pYHVmBuyUJXjiMfNaIGP2QVJFRQWuXr2KiIgITZtYLEZERATOnz+v85rz589z5wPAuHHjtM6PjIyEu7s7OnfujKeffho5OTmmfwMGsrWSYWUXfuQisTgT+xPP6rmiddp+/xB37CS1x9SOAxp1LzUDDguW/uuaamOVVSj6nk+Wd5g3HiKrxgVmpPWzDvSB2MEOEqZGp/T73GumnnKTiMQY0z6cazuacg1qpjbtgwh5hKjcWNwTLKiZHzDSoMUteVnF+MmKz8Odob4PRxcdiaItyOyDpOzsbKhUKnh48PtleXh4ID1d91Bzenr6I88fP348vvzySxw7dgzvvvsuTp48iQkTJkCl0j1io1QqUVhYyH01lfEd+qCzogPXtv3+YeQpi/Vc0brczI3HpSw+x2Nh4CjYWDWukOPVNCCrlG/TNdVWevQc1Nn5XBttQ0LqIxKLIetVPV2gVVTSxCNJADCuAz/dnFmej+s5sXrOJqRp7IqN5I69bdthmFdP3SfrsXNXDMqltYsRxGoVlk83bDPc5mD2QVJTmT9/PqZOnYqePXti+vTpOHDgAC5fvozIyEid52/atAkKhULz5ePTdJVAxSIxnus+nWsrqizDZ9G/NNkzzYlwFMlF5oDpfoMafT/hVFvndkCAjpnVQkHCtrxfT0gDOzb6uaRtkPXuDgDokspPD9/MABjTdUXjBTl6I9DBi2ujKTfSnOKL0nEu8w7XNi9guEELaiqUVfimkA+IRhXegV8Xw/fibGpmHyS5urpCIpEgI4Mfu87IyICnp6fOazw9PQ06HwACAgLg6uqKmJgYna+vX78eBQUFmq/k5GQD34lhQlwCtGqj/PbwMqJa+W+NUTmxuJrN74X1eOBog6q31qVmwK/87XTu1VaVkYPS3y9wbZSwTRpC3re60KNwJCmrFEhvgsFf4WhSZNpNlKsq9JxNiGl9K8hFcrS2xYQOhuVt7vvhHjLt+Wray4e27B5t+ph9kCSVStG7d28cO1ZbdVmtVuPYsWMYOHCgzmsGDhzInQ8AR48e1Xs+ADx8+BA5OTnw8vLS+bpMJoOjoyP31dTWdJ3KbUcAAO//8QMq1VVN/uyWwBjD5/f4/dJcZY6Y6tu4XCSgeqotTfAP1UQdQVLR94eBOlOtIlsb2E8zfANd0vbI+1SPJLXPfQi78iLutetNsPhsTPtwiFGb+1GmUtI2RqRZpJfm4qiOLUgMSYVQqxn+F8tX0+6eF4cBo/TUZGlhZh8kAcC6deuwbds27Ny5E9HR0Xj66adRUlKCpUuXAgAWLVqE9evXa85fu3YtDh06hPfffx93797Fhg0bcOXKFaxZswYAUFxcjBdffBEXLlxAQkICjh07hmnTpiEoKAjjxo1rkfeoi5uNE5Z3nsC1JRRnYE/cST1XWLbzmdG4kcsXM3qiUwRkjRxFAoADfC4tOrkAnV35NsaYVm0k+6kjILY3z99siHmRODvCupMvxGBaU27XmiBIcpUr0Nu1E9dGU26kOXwXFwlVnYUCcokUs/2HGnSPk0dicU/BF498qpP55ttaRJA0b948bN68Ga+//jrCwsIQFRWFQ4cOaZKzk5KSkJaWpjl/0KBB+Pbbb/Hf//4XoaGh+OGHH7B//3706FE9LC6RSHDz5k1MnToVwcHBWLZsGXr37o3Tp09DJjOvXd6n+w5GJ0d+7vaL+0eQVpqr5wrLpGJqbL17gGvzsHHGZJ/GjyKp1MBBwVTbFB2rS5VXbqPyQSLXRlNtxBA1U27dH97m2q+l6TrbeMIpt8vZ95FT3nSLSQjJVRbhQBKfkjClY384SQ3bY+2/F/mZkPaF6Zg6p5vR/WsqFrO2ec2aNZqRICFdydZz5szBnDlzdJ5vY2ODw4ctY180K7EEL/ScjVVn/wOG6ixQpboS//7jB7zXb3mr2U/sUPJlrcJ4T3We0Oi6SABwKVV7VdtkHUFSoaA2krV/B8gHhDT6uaTtkfftgaJvD6LbQ37a61YmUKECpCaujTfMsydsJFKU/ZmLpGJqHE65gscCR5n2QYT86fv4U6iok+phJZIYvAXJ7aspOOfEF49c3C4VVlL9+cItzSJGktq6bs6+mO7Lr+66kHUXvz683EI9Mq1yVYVWLlKQozfGCmrCGOoXPo8W3dyAQMGqNnVJGYr38flrDgsmtJrgkzQPeb/qkaSuqfyqH6UKuJ1l+ufZWMkwXLCH4YGki2CmXk5HCIDiyjLsS+Br9Y3r0BseNoYVYP7sN74WoWNZAR5/rIues80DBUkWYnmXiVrVdj+6vR+ZZfkt0yET2hUbiWwlP1WwuusUiBuxR1uNKjXwm2Ah4JRO2ueVHDgJVlxnuEkshsO8lt3Dj1ge66COEDs5wKG8GL5ZCdxrV1Ob5plTOvbnjpNLsrRy+ggxhX2JZ1FSVa45FkFk8KhlakIufrPl92SbJ4mBnZN5535SkGQhHKxt8GIIP31YUlWOd2/utujfHtNLc/F1DD+S09etM/q6ddZzRcOcSwZy+V0idE+1fXuQO7Yd2Q9W3uZXq4OYN5FYrFnl1l0w5dYUydsA0NPZH76CzUQPJF1smoeRNqtcVaG1ke0IrxCDN7L97/eJqJJYa46tqyrw1FzDtjFpCRQkWZDBHt0xXpCweSnrHg4kW+4H48d3foJSXak5FkOE1V0nG33fXwSr2sI8gI4Kvq0yPgXl56K4NqqwTRpL3re64nC3FEGQ1ETJ2yKRSGthw4m0KBRVlum5ghDDHUy6iPwKfvXZ40GjDbpHUV4pvlfztVcmld6Bp6+L0f1rahQkWZjnuk2Hq45pt6TiJtgDoYldyrqHk+l/cG3TfQchyNG40vQVKuCQYKpN1yhS0S4+D0rs7Ai7cYONejZpu2rykroJVrilFQNpRbquMN64Dr1hJarNCq9QV2nVsSGksSpUVVrFI/u5dUawYNusR/nqu/solvM7iq+a5KbnbPNCQZKFcZDa4qWQuVxbmaoCG659BaWqUs9V5qdCVYUtt/ZybQqpHZ4S1IVqjFOJQKGSb5skyEdiKhUKBUGSw+yxEMkaX5OJtG2ysC6ARIKO2YmwL+OjoqaacnOWOWCIZw+u7ZekCxY9BU/Mx68PLyGzPJ9rM3QUqbKiCjtzvbm2IXl30DXc/PZp04WCJAs00KMbJvvwSZsPClMsam+3r2J+R3IJv+xnVZdJcJAan8S39y5/3McL8OZ/iUHZyStQpfKjb1QbiRhDbG8LafdAiMG0VrldbaIpNwBanwUxhalaO7QTYqgKVRW+evA71xbqEoAwF8MqY/+0JxrpDnz+0sqB1nrONj8UJFmotT1mwM/eg2v7MeEMTgmmr8xRTGEKvorhf/i6Knww0aef0fcuKAd+FyzwmdlV+7wiQW0kaUgwZD107FdCiAFqi0o2T14SAPRxC9Zair0/8ayeswlpGF2jSE8GjzOoPIpazfB5DF9ssltePIaMsZzPWgqSLJRcIsWb4YsgFfPFFjdFfWfW+UlVahX+GbWLK20vEYnxQsgco5b81zj4oLo2TQ2pBJgsmGpT5RWi+NfTXJvjAkrYJsaT9/8zeVtHUcmyJpoNl4jEWqNJR1OuoaCipGkeSFo9faNIvdoZFtycPByDaGd+BdtTwSUQiy2nDh0FSRYswNELa7vP4NqKq8rxtyvbUWymK1y+ivkdDwpTuLaFgaMMTgTU50d+6yxE+AMKOd9W/ONRoKLOv1hSa9jPGmOS55O2zWZgGACgW8ptiOtUJ65UN+2U25SOA7QSuIVbSBDSUKYYRQKAjy/xuXFeRRmYOtu8i0cKUZBk4aZ0HIBR3mFcW2JxJjZe/4YbrTEHUTmx2HH/CNfma++BxZ3GmuT+ifnAFcE/RLqm2oS1kewnDoXE2VH7REIMZOXpCutAH9hWlCE4ja9DcTFFz0Um0E7uiJHefAXufYnnzO4zgJg/U40iXT6diCtO/LLiJ9ulwlpqMbuhAaAgyeKJRCK8EjIPQY786oHzmXfw6Z1fzGaVS2FFCd66/g3UqO2PRCTG+tD5Ru3PVpcwYdvFBhjObzYN5R8PUPEHv+stJWwTU5IPCgMAhCZGce1NGSQBwCw/fjf2jLI8nM24redsQnQz2SjScb62kktpHp543Hw3stWHgqRWwMZKhk19noRCase174k/iW9jj7dQr2qpmBpvR32n8wevu7Ov7osMxJj2VNvUYO2NRYUJ2xJvd9gM622SPhACADY1QVJSFNcelQ6UV2mfbyrdnDqii8KHa9ubcKbpHkhaHaWqwiSjSLevpiDSqTvX9oRtPGwcZEb3sblRkNRKeNq64O3eSyARJD9vvXuwxXMT/nv3IM5n8kuiw9sFYaGB9TbqcyUVSOa3f8MswVSbulyJoh/46T7H+RMgkph4i3bSptUEST2Sb0Ksrl1FoFQB15uoXhJQPao8y38I13Y1+wFiCpto8zjS6uxNOGuSUaRPfuU3srUvL8KTC3VU9LUAFCS1ImHtAvFK6Hyt9n/d/L7FqvAeenhFq2KrQmqH13ot1ArojLFbMKsQ5AL0FGwtVHLwFNR5fCTlMN/44pWE1GXl7Q4rv/awV5YgKJ2f2r3YxOWLRnn1gpOUX3JtDqPJxPwVVZZplWYJbxdk8ChSfHQmfrPnR5Hmix/AydVezxXmjYKkVmZ8hz5Y020a16YGw1vXv8XBZt788lzGHbxzYxfXJhGJ8VbvxXCVK/RcZbgCJfAL/28RZncFhL/8FO78iTu2GRoOa3/LqPpKLIu+KbcLTZyXJJVYYZYfP5p0PDUKaaW5TftgYvG+iz2hte/fyi6TDB9F2psKtbh2dF5eWYZVCwJM0seWQEFSKzQvYLhW6XgGhndu7sau2MhmSea+mv0Ar13dobW6Zl2PWQb/ZvIo++7yuR5W4uogqa6KB4koP3+Da3NcxAeThJhKTZAUIkjevpYGKJswLwkAZvoNhlxSu72OiqmxOy6yaR9KLFp2eSH2xJ3k2oZ7hqCbgTmj6Ym5+EnGf/jOqLwLtw5OxnaxxVCQ1Eqt6DwRc/2Ha7V/Ev0z3ru5B5XqpvukvpgZjVcu/w8VgmfM8R+Kqb4DTfosxoDvBEXGxwYAbnwOOwq//Jk7Frs6wW4ivxqIEFOpWeEWknwDojq/KChVTVsvCQAcpXaY0pEvLnlAx07uhNTY+eAIlOra2nFiiLC8i+GpCJ/uTkSFdW1ytpWqEqtnm6YGXkuhIKmVEolEWNNtKp4IitB67UDyRTx3/tMmGYI/mHQRL1/+H8pVFVy7rmlAU7iWDtzlcwSxsCd/rC5Xomj3Ia7NccFEiKSWs38QsSzWPp6w8vGEQ3kxOgnqJZ1OavrnzwsYweX8KdWV2BtPK92ItoclWfhFsLhnok8/+Aq2vXqUzNRC7BbxhSInlt5Bx05uRvexJVGQ1IqJRCKs6DIRq7pM1nrtVl4Cnjy1GYcfXjHJ9JtSVYn3bu7BOzd3a02xjfAKxcsh80yy7YiQcBSpowIYxK+CRsmBk1oJ246PTzF5Xwipy2ZIOACgb9wlrv1kYtM/28PGGRHe4Vzb9wmntXJOCNkafYD7zJaKrfBk8DiD7/Px13Eol9pojsVqFZ6d4l7PFZaBgqQ2YGHQKLzVezFkYn7kpLiqHG9HfYvnzn9q1DLh69kxWHJqs9ZvIwAwxjscr/daCCux6ZfZF5RrJ2w/1gMQbgtUuJOfarMZ1hvWAZY9BEzMn83IvgCAPnGXufbbWUBWM2yr9ljgSO64uLKMcpMI53p2DE4KNkWf5TcUbjZOBt0n82E+dov5UaTxhbcQHOplbBdbHAVJbcQIr1B8MmgNvG3bab0WlRuLpac2Y/3l/+FmblyDRpYYY/gjNx4vXtqG5y58ioclWVrnzA8YgVd7PQZrcdOUod91uwEJ2/cTUH6BErZJ87MdWl2ktNvDW7BRlnKvnUlu+ucHOHphpBe/VcmeuFOUm0QAVCf0/+fOfq5NYW2HJzppp2g8ykffxqPcunaTTLG6CuumW/Y0Ww3L2kSFGKWzkw+2D30e/771I47oqJt0JuM2zmTchpetCwa7d0dPF3/42LnBReYAkUiEwopSpJRm42ZuHM5m3EZicabO58glUrzYcw7Gdmi6StZVamAnH/tgQpCOhO0d/LJ/iZsz7CbwS6QJaQoSV2dIQ4KBm/fRK+EqznWuXShwKhGY0Qz7fD4ZPB4n025qtgMqUynxbcwJrO5G081t3cGki1ozCMs6j4eDtY2eK3RLT87HHsEo0oSi2+gUGqrnCstCQVIbY2ctx2u9FmK4Vwg+ur0f6WV5Wueklebih4TT+CHhtMH37+bUEa+Ezoe/g6cpuqvX4VggpYhvezKMP1YXl6JQsA2Jw/wJlLBNmo3tiL6ouHkffeMucUHS6SRAzbSnhk3Nz8EDEe3DuV+K9iacwbyA4Wgnp02d26riyjJsu/cb1xbg4IkpHQcYfK9PvolDuU1t/ptYrcJfp1t+LlINmm5ro4Z59sRXI17Gk8HjYG/gbw66OEnt8dceM/Hp4OeaPEACgC+i+ONenkC4YPq7aPchsOI60xwiERwX01QbaT42I2rykvjk7axSIDq7efqwNHis1kq3L+4fbp6HE7O048ERrWnXZ7tPNzh3ND0xF3us+ByHicW30SnE8nORalCQ1IbJJVIsDR6HH0e/hjXdpqGDneFzyO1t2+HprpOxZ9TfMdNviEm3GtHnZgZwWZBnLhxFYmo1Cj7/kWuzHT8Y1r7eTds5Quqw6dcTIhsZ2uelwiuPL7d9Ir55+tDBzg0TOvTl2n5JuoBY2tOtTYopTMEP8fwswRCP7ujjavjeau9/m4xya35F219nGlY6wNzRdBuBrZUc8wKGY67/MDwoTMH5zGj8kRuP2MJU5CiLwFCbyO0ktYevvTvC2gWin1sX9HT2M7hsvbE+vcIfe9pX5yPVVXbyCipj+II0iqdmNXHPCOGJZFLYDOqF0mMX0C/mAn7qW/t38GgcsKZf8/RjafA4HE25pikYqAbDR3d+wgf9VzX7zy9pOer/b+/Ow5uq0geOf7M0SfeFQhco+ypbBSyyKMqgKIs6OiOOiLgNjoI/FRQRRFxQFlFxEEVRwXFEFAYdRhBZFBUoiFAWgbKVHVpa6L4kTXJ+f0QKt0mRFpuk7ft5nj6h556bvD20yXvPPYty8tqORZop/wF6A4+2u6XSz3Vgdwb/MWv3aBtUuIuW7Ttddpz+RJIkUUan09E6vBGtw89Pjy912ikoLUGnc/U8XbjdgS/sOwMrDmjL7usMAeV6iXPnLtZ8H9CmKYHXVN9AciEqEnh9EkVrNtJ730+aJGlbBqQXuJL86tYgMIKhLfvy0QW32bZk7Wd9xi56x3ao/gCEX1h6dCO7c7QXj/e0+BMJIZW/izBt8Wkc4ed7jQLsNp76a/UPtfA2ud0mLipAbyTSHEKEKcTnCRK4epEuXKAgzAz3lFthuzTtOEWrtWs2hf/9L3LFLHwi+MaeAHQ+so3gEu1sg1Vp3ovjby2up4ElQlP2z11fUWy3ei8I4TNnrfm8t+drTVmj4PoMLbfP56VIWX+EleHaN967bL/SpE3tGbB9jiRJosY4mgtL92rL7usMoWZtWe6HS1ybuv1GHx5C6F9u9EKEQrgLaNaQgLbNMDod9NifrDm28qD34rAYTDzcdqCm7FTxWebtW+m9IITP/HPXVxTYSzRlYzrcgdlQ+dm+U1ZpV24PthbyxPAWlxWfv5IkSdQYb28GxwXdSIFGuD9RW8eRnUfev7VXS6FDB6EPvvwZfEJUVfBNrrW5eu7TDphNPg55XuzI6dfwSjpHNdeUfXHoB/bnnqjgDFEbrD21nTUnUzRlNzTsQrf6lR+svWbZXjZFatdFut+0j+j48MuK0V9JkiRqhANnYdFubdnQjhBVLvfJ++hLVNEFVzl6PeEP/Ln6AxTiIoJv6gVA0sFNBNjPb/5c6vTuLTe9Ts9THf9KwAVTvR3KybQdn2N3OrwXiPCabGs+M3Zqx2iGBgRWacPx0lIHk7dqV+yNKjrLI/e3q+CMmk+SJFEjvLbBtfjeOYFGGFFuHLaz2ErOB9o3g5Db+sq0f+Fz5ivbYWgQRZCt2G3NpP/ureCkatI0NIZ7WmjHoezNPc78/XLbrbZRSvH6zv+Qa9NuFvhE+9uJModW+vnmzdtFWph238tR0ccICbdUcEbNJ0mS8Hsp6bCi3NiNB66EmHJbkOR/thxnVo6mLGLU3dUbnBCXQKfXE9Tf1Zv0p19Xa46tO+qdDW8vdE/LfjQJ0Q6y/WT/anae9dLiTcIrVp7Ywg/pOzRl18Z25IaGXSo4o2JnMvKZdbaJpqxlzhGGD29fwRm1gyRJwq8pBVPWacsiLPCPcr1Iym4nZ/ZnmrLA65Mwd2xVzREKcWnO3XLrsX89Ftv5leAdCpYdqOis6mEyGHkucahm8Vcnipe3fUp+afFFzhQ1xdGC07y+U7ugbnhAMGM6Vm2m7/SPDpAXqB13NLFbMUZT7V5JSJIk4df+uxc2lRtTOuoq19T/CxX893vsR09pyiL/b2g1RyfEpQu8thv6sBACS0vovVeb+X+V6v142kYk8EDrmzRlp4rO8sq2BTgvWGxQ1DxWRykvbP2EYod2VsCYjndU6Tbbrs3H+MKiXSSyb86vXDfQC7s0+5gkScJv5Vlhcrk9dhuFwrByC7oqu53s1+ZpysxXtsPS68pqjlCIS6e3mAkeeC0AfX9dpTmWkg77z3o/pqEt+9IpqpmmbH3GLj7ev6qCM0RN8M6e/7E/T3t1OTChO9fHJ1b6uRxOxfjlVpwXDPYPsNt4/s7atyaSJ5IkCb/15kbXRqAXmtQHLOV6d/MXr6L04DFNWeQT98jikcLvhNzeD4BuhzYTWaDNij7b6f14DDo9z195DxEm7bLf8/at5Md0HwQkLtu3x39hyWFtT2XTkBie6FC1Wb7/mr+TbRHafZ+Gs5tm7SRJEsJnUtJh/nZtWd+mcIN2iRdUqZ3s1+drysyd2xB08zXVGp8QVRHY+0oM9aMwOh30375cc2zxHiixez+mmMBIXuwyDD3nLyoUihe3fiIDuWuYPTlHmb7jC02ZSW/kxS73VmnHhFNHspmRqe1pjMvPYPTfa/9ttnMkSfIzSsGCna4ZL3VVcSmM/lY75d9sgBf6QPnOofyF32A/rN3NPPKZB6UXSfglndFIyK3XAzBw2/80x3KtsGy/L6KCLtGteKTdYE2ZzWln3OYPOZyf4ZugRKVkleQxfvNH2JzaTPvJDrfTPCyuSs/5/MfHKbBoxzC9eMUZgsNq75T/8iRJ8iPZxfDw14pnv4Mnllo5W0cnmUxdD2k52rLHkqBJhLbMWVDE2WkfasrMXa8gqN/V1RqfEJcjZIhrsHTD7JN0Lbdm0r+2a3bU8aohzfswMKG7piyvtIjHN77DkQJJlPxZkb2EZzd/SJY1T1N+e5NeDGpctffD/y7e47Y/W/+cHfS//Yoqx1kTSZLkJ07kwU2fOPg2zdUDkukw8/TXVp+9YfrKd4fcb7MlxsAj3dzr5ry9AEfGGU1Z1LiHpBdJ+DVz5zaYfluaYvDWpZpj2zLcZ3N6i06n46mOf+HqBtrVk89a8/m/5HekR8lP2Rx2Jvwyn9Rc7bjMLvVa8lj726r0nKeO5jDxgHYR3tCSfF66P6GqYdZYkiT5ieicdBJSt2nKVp8088n2ujMV90gOPP6ttsxihDf6g7Hcb2rp8QyP6yIFXXdV9QYpxGXS6XSE3XsLAL32riM2R3u7+J1ffBGVi1Fv4KUu99I+Qrto4FlrPqM2vM0OGaPkVxzKySvbF/BL1j5NeVxQFC92vRfjBTPSLpXTqRgz7xS55dZEeqb+QWIbR15WvDWRJEl+wpQQw4t5q9xmvEz+QbE3y0dBeVFxKTy8zH2zz2d7QwsPf5dnX56DKjm/BxYGA9EvjareIIX4g4TecQO6IAsG5eDO5IWaYz8cgV2ZPgoMCDSamdF9BFdENNaU55YW8uTGd/nu5DbfBCY0HMrJ1O2fu/1/hJuCmZE0wm3G4qWa9+EO1kdoexOvO7uTofd1rmqoNZokSX5Cp9PRdvojjFs3W1NuxcCo/1opLvVRYF7gcLp6kPaUSwYHtYLhndzrF33/MwVLtFs7hN07GFPbZu6VhfBD+tBgQv7s2j/tpu3LiSjM1hx/c6MvojovJCCQ17s/7NajZHPambT1X7yfulw2xPUhu9PBSyn/ZsXxzZryQIOZGUkjaBxSten52zafYGqeduZaVFE2rz2UgF5fN4cxSJLkRwxR4dzyzE3cvkk7hXNfgZmnV9hr5fgkpeC57+HbcnuztYqC6f3cZ7M5C4vJfGqGpkwfFkLU2AeqOVIh/ljhD98JgMVu5fafF2mOrUqDjcd9EdV5IQGBvHH1P9zGKAF8cmA1T2x8l9PFOd4PrI4rcdiYuOVjtx4ko87Aq93up21E1cYNZWcW8Oi3BmxG7XYGr7Q5RYOEiCpGW/NJkuRngq67iqdaZNEiXTsX+H9pRuZsqV1ZklIwfQMs+FVbHmaC9wdBsIdlPc5O+9Bt+5F6kx7BEF337pWLms3crjlBN/YE4M+b/+PWm/TKT9plMHwhyGhmSrcHuLVJT7dj28+mcd+Pr/HNsc2o2ngF54eySnJ5bMNs1mVo3zRNeiOvdrufbvVbV+l5HQ4nj71zlBOhsZryOwtSGFDHZrOVJ0mSH4qb8CAv7/yI4JICTfm0dbDyYAUn1TBKubYcKT9I1WyAuYOhuYecp3h9Crnvaa+4LT06E3rPoGqMVIjqE/GYa3/BYFsRw3/4SHNsx2n4fJcvotIy6g2M6XAH/3fFbZoNcQHyS4t5dftnjN70HscLfTiQqg7Ym3OMEetmus1isxhMTEt6iB4xVU9mXpz5Kz9FaM+/IvsgLz9etxMkkCTJL+ktZpJmP8bEVdPRXbDRpNLpGPm1w2dThP8odidM+A4+SNGW64C3boKrG7mf4ziTQ8YjL4PzfHvozCbqvzkWnV5+jUXNFHh1JyxJrrVoBm77H42zDmuOv/ITnMz3QWDl6HQ6/tr8Wmb3fIzYQPcrmF+y9jFs7XTe+vVLcmwFHp5BVJVSii/SfuCRDf8ksyRXcyzEaGFG0gi6RVetBwnggw928LFRO/gzvDiXOX8LxRJiruCsukM+XfxUQJN4bh0/kAfXztWU2zDwwBI7O0/7KLDLlGeFB5bCp+VusemAqX+Cm1u6n6McDk6PegXHKe2VauQzD2Bq0dj9BCFqkKgJIwAwOh08unKW5li+Dcat8f1tt3PaRzbho2vG0NfDRql25WDx4Z+467tXeS91GWetfpDd1XCZxTmM/Xkus3b/l9JyA+UbBtXj3V6P07le8wrO/n1fLk7llfz2mjKDw87M9qdo0qZu7M32eyRJ8mNBfbsz8k+hDEj5WlNe4DRy9xd2tp6q4EQ/te8M/PkL1xTnC+l1rrWQ7urg+bwzL75L0WrtdJ/A664iYuTfqilSIbwnsGciwQNcew0mpf3stqfbD0dg1s+ezvSNUFMQL3a5l6lXPUgDS4Tb8UJ7Cf8+sIa/rnmZ13cu5lB+uveDrOHsTgeL0n5k6NppbMxMdTveOao57/V+gqahMVV+jaVLUhlztCXOcmspvRCyg76D687ebL9Hp2TEXZXk5eURHh5Obm4uYWFh1fY6SikyJsxidHYi69teqzkWpHcw91YDvf28M0Up1+DsF38Aa7lZwyYDzOwPA1t5Pjd33pdkjX1DU2aoH0mj7+dhjKlXTREL4V22g0c51vtesDvIt4TwwIh/cSasvqbOewPhJg89rb5UWFrC/P0r+c/hn9x6Oi7UIbIpgxpfzXWxnQgOqDv7flWWUooNp3czN3U5B/M9XwXf3eJ6HmpzMwF6Y5VfZ8niVJ4+2gK7IUBT/pB1CxPHdq3y89YUlfn8liSpiryVJAEop5OjD7/C48EDSGmm/QU24mTSdXqGdXKfLu8PTubD82tdU5rLiw6E9wdD1wr2Xsz7dBmZT0zVFgYYiV/8JoE9E//oUIXwqTMvvUvOrAUAbG3albF3v665yjcbXLM+r2vqowAv4lTRWeamLmf1yRQUFX+kmPRGkuq3oU9cZ3rFtCc0INCLUfovp3KSfHoP/9q/it05nnc3jzKHMjFxaJVnsJ3z9ns7mVHcHlVuEP4dOVuYMbFLnVgPSZIkL/BmkgSgbKUceXgyY4NvYlOrHm7H/9rWyQvX6wnxMG3eF+xO12adM5Kh0MNCmFdEuxKkhAqaLnfuYrIm/NNtt8/6/3yWsL8NqIaIhfAtZ7GV49ffT+lB1+ylRUl38u6Nj2nqmAzwVn8YUEHPq68dKcjgs4Pf8+3xLdjVxRebNOj0tItoTFL9NnSLbk27iMZV2kajJjtrzWfVia18eXgdJ4rOVFhvYEIS/2g3qMqraAMUF9sZ/9YelgR2dDt2a24Kb47vhMFYN9pfkiQv8HaSBKDsdk6Mmsp41ZMfrujrdrxRYCmvDwjwODvMW5SCbw7AaxsgLcdznfs6u7YbsXjoLVZWG1nPzybvoyVuxyLHPkDU0/f/sQEL4UdKftnFicEjwe5AATMGPcM3ie5LXIzsBk9eDQF++pl2ujiHJYfX8c3xzZc8gDvQYKJtRAJXRDThisgmtI9oQj2Ld95bvSmrJI+Np3ez5uQ2tmbtx3mRnrfmobGM6fgXOkVVfXA2QOr2dEYuLeVAmPtCk3fkbuW18Z3rTIIEkiR5hS+SJHDN9Mqc+DYz90fwae/hHusMalbKuOsCKuylqQ52J6w4AO9tca3v4kl0IEztBzdU8PduSz1ExqMvY9u53+1YxOP3EDVhBDp/vKcoxB8od+5issa/BYBDp2faLeNZ3bG/W7229WByX7gq3u2Q37A7HWw4vZtlRzfxc+be3+1dKi/KHErTkFiah8bS7LevRsHRRJhCasR7gVKK9OJsUnOO8Wv2YX7J2kvaJQxkbxhUj/tb96dfwy5ua1NVRnFRKW/MTWWevQ2lRvfbDKNsmxkzuit6Q92awyVJkhf4Kkkqe/0Fy1j0wS9Mv/lpSkxBbscDlIPbWtoZ0cNM62oc33wqH75MhU93wvGLXDDe1d7VexThYcym/fRZcmZ+Qu5HX4LD/U008pkHiBxzX414UxTicimlyBw9nfx/u2a1OnR63hzwNMuv9Lxoau8EeOBK6NMEjH78WZdfWsz6jF9Ze2oHP2emXnSg9+8JNJiIC4oiPqgecUFRNLBEEmUOJcoSSj1zGFHmUMICgrzynqGUotBewhlrHqeKznKsIJPjhZkcLcxkf94Jcm2Fl/xcLcPi+Wuza7mxYdfLuvVYYrXz6cJ9vHeiPhnB9d2OW2zFvBC9l7/dn1jl16jJJEnyAl8nSQAlKXtIGTuXVzoNZ2fjindoTjTn8ueuQdzQJoCGf0Coh3Pg+8OuwdgbjnGRzmLo2AAmXgvdG2rLlcNB8YZtFCxaScGS1Sirzf1kUwAN3hpH6F9uvPyghahBlMNBxkOTKPz6B9f3wFfdbuedGx7DYfA8qyk6EPq3gN6NXQuyRvnxmOgSh43tZw6yOWsfmzP3kVbBTK7LYdQZCA0IJDggkBCjheAAy2+PgVgMJgL0Bow6AwF6429fBgw6PU6lcCgnTpw4lcKpnJQ6HRTZSyiyW11fDiuFpcVkWws4Y83D5rRXOc5Ag4neMR24tUlPOkU1u6zE7sC+M3z2zSm+KoonKyjKY53mOUd5+wYH7XvW3Q3Ba2WSNHv2bF577TXS09Pp3Lkzs2bNIikpqcL6ixYtYuLEiRw+fJhWrVoxbdo0Bgw4P+BXKcWkSZOYO3cuOTk59OrVi3fffZdWrS5tRKQ/JEkAzhIrWdPnMf/nUj7ufR8FgaEXrZ/gyOGq0ELaxRtp1zKMJrGBRAdBkHYmKEq5BlyfzIejuXAgG3ZkwLZ0OHEJQwyahsPTPV0DTHUoHKfPUnrgKLY9aRRv3EHJhhQcmdkVnh/QpikxcyZh7uBnc56F8BJVaidzzGvkf3Z+3aTUuLa8PnAsB2N//30qLgTa14cmEa4JEo3CIDYEIi2uHt3gAP+ZEZttzWd3zlF2Zx9hV84R9uQcpchu9XVY1SbYaKFbdCv6xl9Jz5grsBgqP+NGKTh2PJ/tKRls2FvMels0R0IqmCoM6J127i5IYfz/dSA43I8zaC+odUnS559/zr333sucOXPo3r07M2fOZNGiRezdu5cGDdxXBd2wYQPXXnstU6ZMYdCgQSxYsIBp06axdetWOnRwrVg4bdo0pkyZwscff0yzZs2YOHEiO3fuZPfu3Vgsv7+Oh78kSefY9h/h0NR/M6ekNf/rcqvH+88XY3FYMSkHehQOvYFCnQlnFe6Ft7elc092Mtee2IIu6yyOs7k4Ms7gzL+0Lmed2UT4I0OIHD0cfaAsiS/qNqUUuXM+58zk98HmmiZq1xtY2vU2FvQcxtnQqt9LD9ApwowOAg1OLHqF2aAw6xWW3x4D9K4kSo9Cr3Otiq/XgV6nXP8GdL/9+1yupeO373UXlOlAp1RZQqa74AuPzwEKJ8V2KwWlRRSUFpFfWkxBaRGF9uLfNtNV589VTkChQ13w6Cz7vnxZRfX0mudxXlCv4ucvX0fv8bl1WPRmYoLq0TCoPk1CYokLrAc6HU7litCpzkfrVDocToXdZqeo2EFBiZNCm6KgRJFVpEgvNZFBMCcDIsi3XPyi+JzEM/t46QYDna9pcUn1a7talyR1796dq666irfffhsAp9NJQkICjz32GOPGjXOrP2TIEAoLC/n66/MrVV999dUkJiYyZ84clFLEx8czZswYnnrqKQByc3OJiYlh/vz53HXXXb8bk78lSeeUbEsl7aNvWJBRj6WdbyE3OKLaXzO4pIA+e77npu3f0P74Tqp0cWoKIPQvNxI5ZjgBjSu+GhKiLrLuOkDmE9Owbju/+rLVaGJlp5tY0WkAexq1v8jZoq5KPLOPxzqW0Pf2DnVucPbFVObzu+pLdnqJzWZjy5YtPPvss2Vler2efv36kZyc7PGc5ORkRo8erSnr378/X331FQCHDh0iPT2dfv36lR0PDw+ne/fuJCcne0ySrFYrVuv57t+8vLzL+bGqjSWxLVf8sy0vZGbzxNK1fJd8mm/0zfml2VXkBYX/Ya8TWXCGpIObuHp/Mlcf2IDZ7mFM0SUwdWhFyG19Cb3rZllBW4gKmNu3pOHK9ylc9iPZb/4L2459mO02Bm9dyuCtSzkalUBy615saXYVOxt3wiqrWtdZ4cW53Fy6n7/1CqPz9a1kwstl8vskKSsrC4fDQUyMdo+amJgYUlPd97QBSE9P91g/PT297Pi5sorqlDdlyhRefPHFKv0MvmCsH0n0g7dx54Pwl/xCijbvYucvJ0g+ZWCvI4y0oFiO1mtCien3701HFpwhLvskLU4fpO3JPbQ5mUrTzEO/dS1fOp3FREDzRpg6tCbw6k4E9u5CQLOGv3+iEAKdTkfIoD6EDOqD9dcDFCxZTfG6rVi376Xx2WM03riQIRsX4tAZOFYvgQOxrThcvxkZ4TGkh8eRHhFHdnAEzsvYzkL4n5CSfFoVnKB7SD59OwXTpU8LAoK6+TqsWkP+Wi7Rs88+q+mdysvLIyHBfWEuf6QPDSakbxI9+sK5tbqV1Ybt8Eny0nPIyCjkzBkrpfmF2K12sNoILsonuCiXiMJsAu1WUK7tUYhUEBEFzgjQ6dCZAtCZTa5HUwCYAtCbTeijwjFEhWOoF4G+XjgBTeIxNopBp5cuXyEul7lDy7JJDY68AkpTD2E7cJTSg8dwZGYTejaXNmdOojIOoo7YUFYbTqsNZ4mNQoOFfEsIeeYw8swhWI1mbIYArEYzVqMJmyEAm9GMQ2/AqXONFnLqdCidHqdOj9K5RuM4dTqcesP5SyWdruyY+u08pXON0Dk3IKns+G9l546fq++qc75e2XPo9NrX+e2c87G44iqLT6e/IObzj67jno9V+MgF3+v1rpFGv3uO67Wcej065RrvpFOun1yvXOOozj3qQPO9/lw9FBaHjWCHlSBlI1iVEmZ0EGsuJT4U4qNMtGkbRdP2cehNsiFtdfH7JCk6OhqDwUBGRoamPCMjg9jYWI/nxMbGXrT+uceMjAzi4uI0dRITEz0+p9lsxmyuPQOJdWYT5jZNqd8G3FfREELUFIawEAxJHbEkuW83cbmUUnK75g9Rd1azrm38/rLeZDLRtWtX1qxZU1bmdDpZs2YNPXq472EG0KNHD019gFWrVpXVb9asGbGxsZo6eXl5bNq0qcLnFEKIukYSJFHX+X1PEsDo0aMZPnw43bp1IykpiZkzZ1JYWMj997v28br33ntp2LAhU6ZMAeDxxx+nT58+vP766wwcOJCFCxfyyy+/8P777wOuP/wnnniCyZMn06pVq7IlAOLj47ntttt89WMKIYQQwo/UiCRpyJAhZGZm8vzzz5Oenk5iYiIrVqwoG3h99OhR9BeMdenZsycLFizgueeeY/z48bRq1YqvvvqqbI0kgLFjx1JYWMiIESPIycmhd+/erFix4pLWSBJCCCFE7Vcj1knyR/66TpIQQgghKlaZz2+/H5MkhBBCCOELkiQJIYQQQnggSZIQQgghhAeSJAkhhBBCeCBJkhBCCCGEB5IkCSGEEEJ4IEmSEEIIIYQHkiQJIYQQQnggSZIQQgghhAc1YlsSf3RuofK8vDwfRyKEEEKIS3Xuc/tSNhyRJKmK8vPzAUhISPBxJEIIIYSorPz8fMLDwy9aR/ZuqyKn08nJkycJDQ1Fp9P9oc+dl5dHQkICx44dk33hqpG0s3dIO3uHtLN3SDt7R3W2s1KK/Px84uPj0esvPupIepKqSK/X06hRo2p9jbCwMPkj9AJpZ++QdvYOaWfvkHb2jupq59/rQTpHBm4LIYQQQnggSZIQQgghhAeSJPkhs9nMpEmTMJvNvg6lVpN29g5pZ++QdvYOaWfv8Jd2loHbQgghhBAeSE+SEEIIIYQHkiQJIYQQQnggSZIQQgghhAeSJAkhhBBCeCBJko/Mnj2bpk2bYrFY6N69Oz///PNF6y9atIi2bdtisVjo2LEjy5cv91KkNVtl2nnu3Llcc801REZGEhkZSb9+/X73/0W4VPb3+ZyFCxei0+m47bbbqjfAWqKy7ZyTk8PIkSOJi4vDbDbTunVree+4BJVt55kzZ9KmTRsCAwNJSEjgySefpKSkxEvR1kw//vgjgwcPJj4+Hp1Ox1dfffW756xdu5YuXbpgNptp2bIl8+fPr/Y4UcLrFi5cqEwmk/roo4/Url271N///ncVERGhMjIyPNZfv369MhgMavr06Wr37t3queeeUwEBAWrnzp1ejrxmqWw733333Wr27NkqJSVF7dmzR913330qPDxcHT9+3MuR1yyVbedzDh06pBo2bKiuueYadeutt3on2Bqssu1stVpVt27d1IABA9S6devUoUOH1Nq1a9W2bdu8HHnNUtl2/vTTT5XZbFaffvqpOnTokPr2229VXFycevLJJ70cec2yfPlyNWHCBLVkyRIFqC+//PKi9dPS0lRQUJAaPXq02r17t5o1a5YyGAxqxYoV1RqnJEk+kJSUpEaOHFn2vcPhUPHx8WrKlCke6995551q4MCBmrLu3burhx9+uFrjrOkq287l2e12FRoaqj7++OPqCrFWqEo72+121bNnT/XBBx+o4cOHS5J0CSrbzu+++65q3ry5stls3gqxVqhsO48cOVL17dtXUzZ69GjVq1evao2zNrmUJGns2LGqffv2mrIhQ4ao/v37V2NkSsntNi+z2Wxs2bKFfv36lZXp9Xr69etHcnKyx3OSk5M19QH69+9fYX1RtXYur6ioiNLSUqKioqorzBqvqu380ksv0aBBAx588EFvhFnjVaWdly5dSo8ePRg5ciQxMTF06NCBV199FYfD4a2wa5yqtHPPnj3ZsmVL2S25tLQ0li9fzoABA7wSc13hq89B2eDWy7KysnA4HMTExGjKY2JiSE1N9XhOenq6x/rp6enVFmdNV5V2Lu+ZZ54hPj7e7Q9TnFeVdl63bh0ffvgh27Zt80KEtUNV2jktLY3vvvuOoUOHsnz5cg4cOMCjjz5KaWkpkyZN8kbYNU5V2vnuu+8mKyuL3r17o5TCbrfzj3/8g/Hjx3sj5Dqjos/BvLw8iouLCQwMrJbXlZ4kITyYOnUqCxcu5Msvv8Risfg6nFojPz+fYcOGMXfuXKKjo30dTq3mdDpp0KAB77//Pl27dmXIkCFMmDCBOXPm+Dq0WmXt2rW8+uqrvPPOO2zdupUlS5awbNkyXn75ZV+HJv4A0pPkZdHR0RgMBjIyMjTlGRkZxMbGejwnNja2UvVF1dr5nBkzZjB16lRWr15Np06dqjPMGq+y7Xzw4EEOHz7M4MGDy8qcTicARqORvXv30qJFi+oNugaqyu9zXFwcAQEBGAyGsrJ27dqRnp6OzWbDZDJVa8w1UVXaeeLEiQwbNoyHHnoIgI4dO1JYWMiIESOYMGECer30RfwRKvocDAsLq7ZeJJCeJK8zmUx07dqVNWvWlJU5nU7WrFlDjx49PJ7To0cPTX2AVatWVVhfVK2dAaZPn87LL7/MihUr6NatmzdCrdEq285t27Zl586dbNu2rezrlltu4frrr2fbtm0kJCR4M/waoyq/z7169eLAgQNlSSjAvn37iIuLkwSpAlVp56KiIrdE6FxiqmRr1D+Mzz4Hq3VYuPBo4cKFymw2q/nz56vdu3erESNGqIiICJWenq6UUmrYsGFq3LhxZfXXr1+vjEajmjFjhtqzZ4+aNGmSLAFwCSrbzlOnTlUmk0ktXrxYnTp1quwrPz/fVz9CjVDZdi5PZrddmsq289GjR1VoaKgaNWqU2rt3r/r6669VgwYN1OTJk331I9QIlW3nSZMmqdDQUPXZZ5+ptLQ0tXLlStWiRQt15513+upHqBHy8/NVSkqKSklJUYB64403VEpKijpy5IhSSqlx48apYcOGldU/twTA008/rfbs2aNmz54tSwDUZrNmzVKNGzdWJpNJJSUlqY0bN5Yd69Onjxo+fLim/hdffKFat26tTCaTat++vVq2bJmXI66ZKtPOTZo0UYDb16RJk7wfeA1T2d/nC0mSdOkq284bNmxQ3bt3V2azWTVv3ly98sorym63eznqmqcy7VxaWqpeeOEF1aJFC2WxWFRCQoJ69NFHVXZ2tvcDr0G+//57j++359p2+PDhqk+fPm7nJCYmKpPJpJo3b67mzZtX7XHqlJL+QCGEEEKI8mRMkhBCCCGEB5IkCSGEEEJ4IEmSEEIIIYQHkiQJIYQQQnggSZIQQgghhAeSJAkhhBBCeCBJkhBCCCGEB5IkCSGEEEJ4IEmSEEIIIYQHkiQJIYQQQnggSZIQQgghhAeSJAkh6ryhQ4ei0+mYPHmy27Hk5GSCgoKoV68eqampPohOCOErssGtEKLOO3jwIO3atSMkJIRDhw4RHh4OwP79++nZsyeFhYWsXr2anj17+jhSIYQ3SU+SEKLOa9GiBQ8++CDZ2dm8+eabAGRmZnLzzTeTnZ3NZ599JgmSEHWQ9CQJIQRw8uRJWrZsiclkYteuXdxxxx1s2rSJ9957jxEjRvg6PCGED0hPkhBCAPHx8YwaNYrc3FwSExPZtGkTEydOlARJiDpMepKEEOI3p06dolGjRjidTu677z7mzZvn65CEED4kPUlCCAEopRg9ejROpxMAo9Ho44iEEL4mSZIQQgBPP/00CxcuZMCAAcTFxTF//nz279/v67CEED4kSZIQos576623eP3110lKSmLRokWMGzcOu93OxIkTfR2aEMKHZEySEKJOW7RoEUOGDKF58+YkJydTv359SkpKaNmyJSdPnmTr1q0kJib6OkwhhA9IT5IQos768ccfGTZsGNHR0axYsYL69esDYLFYePbZZ1FKMWHCBB9HKYTwFelJEkLUSbt376ZXr17YbDa+++47unfvrjlus9lo2bIlx44d46effqJ3794+ilQI4SuSJAkhhBBCeCC324QQQgghPJAkSQghhBDCA0mShBBCCCE8kCRJCCGEEMIDSZKEEEIIITyQJEkIIYQQwgNJkoQQQgghPJAkSQghhBDCA0mShBBCCCE8kCRJCCGEEMIDSZKEEEIIITyQJEkIIYQQwgNJkoQQQgghPPh/XLzuiZgTApwAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -483,13 +448,28 @@
     }
    ],
    "source": [
-    "pes_X = pes(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
-    "mes_lb_X = mes_lb(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
-    "jes_lb_X = jes_lb(X.unsqueeze(-1).unsqueeze(-1)).detach().numpy()\n",
+    "# the acquisition function call takes a three-dimensional tensor\n",
+    "fwd_X = X.unsqueeze(-1).unsqueeze(-1)\n",
+    "\n",
+    "# make the acquisition functions live on the same scale\n",
+    "scale_acqvals = True\n",
     "\n",
+    "pes_X = pes(fwd_X).detach().numpy()\n",
+    "mes_lb_X = mes_lb(fwd_X).detach().numpy()\n",
+    "jes_lb_X = jes_lb(fwd_X).detach().numpy()\n",
+    "\n",
+    "if scale_acqvals:\n",
+    "    pes_X = pes_X / pes_X.max()\n",
+    "    mes_lb_X = mes_lb_X / mes_lb_X.max()\n",
+    "    jes_lb_X = jes_lb_X / jes_lb_X.max()\n",
+    "    \n",
     "plt.plot(X, pes_X, color=\"mediumseagreen\", linewidth=3, label=\"PES\")\n",
     "plt.plot(X, mes_lb_X, color=\"crimson\", linewidth=3, label=\"MES-LB\")\n",
     "plt.plot(X, jes_lb_X, color=\"dodgerblue\", linewidth=3, label=\"JES-LB\")\n",
+    "\n",
+    "plt.vlines(X[pes_X.argmax()], 0, 1, color=\"mediumseagreen\", linewidth=1.5, linestyle='--')\n",
+    "plt.vlines(X[mes_lb_X.argmax()], 0, 1, color=\"crimson\", linewidth=1.5, linestyle=':')\n",
+    "plt.vlines(X[jes_lb_X.argmax()], 0, 1, color=\"dodgerblue\", linewidth=1.5, linestyle='--')\n",
     "plt.legend(fontsize=15)\n",
     "plt.xlabel(\"$x$\", fontsize=15)\n",
     "plt.ylabel(r\"$\\alpha(x)$\", fontsize=15)\n",
@@ -507,7 +487,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 8,
    "id": "f7f639bb",
    "metadata": {},
    "outputs": [
@@ -515,9 +495,9 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "PES: candidate=tensor([[0.4279]], dtype=torch.float64), acq_value=0.1326965772287694\n",
-      "MES-LB: candidate=tensor([[0.4050]], dtype=torch.float64), acq_value=0.19125601676432957\n",
-      "JES-LB: candidate=tensor([[0.3982]], dtype=torch.float64), acq_value=0.24631777964460055\n"
+      "PES: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.17330018797192714\n",
+      "MES-LB: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.042861226761573626\n",
+      "JES-LB: candidate=tensor([[0.3879]], dtype=torch.float64), acq_value=0.5383259121881295\n"
      ]
     }
    ],
@@ -572,47 +552,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
-   "id": "0b0dda52",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "from botorch.test_functions.multi_objective import ZDT1"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 13,
-   "id": "fc141f17",
+   "execution_count": 9,
+   "id": "fabc86e9",
    "metadata": {},
    "outputs": [],
    "source": [
+    "from botorch.test_functions.multi_objective import ZDT1\n",
+    "from botorch.acquisition.multi_objective.utils import (\n",
+    "    sample_optimal_points,\n",
+    "    random_search_optimizer,\n",
+    "    compute_sample_box_decomposition\n",
+    ")\n",
     "d = 4\n",
     "M = 2\n",
-    "n_sobol_samples = 16\n",
-    "num_pareto_samples = 10\n",
-    "num_pareto_points = 10\n",
-    "raw_samples = 512\n",
+    "n = 16\n",
     "\n",
-    "if SMOKE_TEST:\n",
-    "    q = 3\n",
-    "else:\n",
-    "    q = 4"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 14,
-   "id": "fabc86e9",
-   "metadata": {},
-   "outputs": [],
-   "source": [
     "problem = ZDT1(dim=d, num_objectives=M, noise_std=0, negate=True)\n",
     "bounds = problem.bounds.to(**tkwargs)\n",
     "\n",
-    "train_X = draw_sobol_samples(bounds=bounds, n=n_sobol_samples, q=1, seed=123).squeeze(\n",
-    "    -2\n",
-    ")\n",
+    "train_X = draw_sobol_samples(bounds=bounds, n=n, q=1, seed=123).squeeze(-2)\n",
     "train_Y = problem(train_X)\n",
     "\n",
     "model = fit_model(train_X=train_X, train_Y=train_Y, num_outputs=M)"
@@ -628,11 +586,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 10,
    "id": "56bd5f5a",
    "metadata": {},
    "outputs": [],
    "source": [
+    "num_pareto_samples = 10\n",
+    "num_pareto_points = 10\n",
+    "\n",
     "# We set the parameters for the random search\n",
     "optimizer_kwargs = {\n",
     "    \"pop_size\": 2000,\n",
@@ -659,14 +620,26 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 16,
+   "execution_count": 11,
    "id": "2c7dfaf0",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hvarfner/Documents/botorch/botorch/models/gpytorch.py:96: BotorchTensorDimensionWarning: Non-strict enforcement of botorch tensor conventions. Ensure that target tensors Y has an explicit output dimension.\n",
+      "  warnings.warn(\n"
+     ]
+    }
+   ],
    "source": [
     "from botorch.acquisition.multi_objective.predictive_entropy_search import (\n",
     "    qMultiObjectivePredictiveEntropySearch,\n",
     ")\n",
+    "from botorch.acquisition.multi_objective.max_value_entropy_search import (\n",
+    "    qLowerBoundMultiObjectiveMaxValueEntropySearch,\n",
+    ")\n",
     "from botorch.acquisition.multi_objective.joint_entropy_search import (\n",
     "    qLowerBoundMultiObjectiveJointEntropySearch,\n",
     ")\n",
@@ -703,55 +676,24 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 17,
-   "id": "90b8c94b",
+   "execution_count": null,
+   "id": "ceac58f5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: \n",
-      "candidates=tensor([[0.0391, 0.0000, 0.3740, 0.0000],\n",
-      "        [0.0352, 0.4789, 0.0000, 0.0000],\n",
-      "        [0.0628, 0.0000, 0.0000, 0.3964]], dtype=torch.float64)\n",
-      "CPU times: user 1min 19s, sys: 6.01 s, total: 1min 25s\n",
-      "Wall time: 11.1 s\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
-    "%%time\n",
-    "# Use finite difference for PES. This may take some time\n",
+    "q = 4\n",
+    "\n",
+    "# Use finite difference for PES\n",
     "candidates, acq_values = optimize_acqf(\n",
     "    acq_function=pes,\n",
     "    bounds=bounds,\n",
     "    q=q,\n",
-    "    num_restarts=2,\n",
-    "    raw_samples=raw_samples,\n",
+    "    num_restarts=5,\n",
+    "    raw_samples=512,\n",
     "    options={\"with_grad\": False},\n",
     ")\n",
-    "print(\"PES: \\ncandidates={}\".format(candidates))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 18,
-   "id": "35b3e391",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "MES-LB: \n",
-      "candidates=tensor([[0.5040, 0.0200, 0.0291, 0.0573],\n",
-      "        [0.6608, 0.1501, 0.0000, 0.1995],\n",
-      "        [0.0000, 0.2371, 0.6427, 0.5805]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
-   "source": [
+    "print(\"PES: \\ncandidates={}\".format(candidates))\n",
+    "\n",
     "# Sequentially greedy optimization\n",
     "candidates, acq_values = optimize_acqf(\n",
     "    acq_function=mes_lb,\n",
@@ -761,27 +703,8 @@
     "    raw_samples=512,\n",
     "    sequential=True,\n",
     ")\n",
-    "print(\"MES-LB: \\ncandidates={}\".format(candidates))"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 19,
-   "id": "ceac58f5",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "JES-LB: \n",
-      "candidates=tensor([[0.0716, 0.0485, 0.1316, 0.1244],\n",
-      "        [0.3201, 0.0000, 0.0165, 0.4576],\n",
-      "        [0.6217, 0.0258, 0.2651, 0.0496]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
-   "source": [
+    "print(\"MES-LB: \\ncandidates={}\".format(candidates))\n",
+    "\n",
     "# Sequentially greedy optimization\n",
     "candidates, acq_values = optimize_acqf(\n",
     "    acq_function=jes_lb,\n",
@@ -811,7 +734,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.8"
+   "version": "3.9.16"
   }
  },
  "nbformat": 4,

From 011ea93c3483fb809d6e4dd7211eca9922e417dd Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 15:46:37 +0200
Subject: [PATCH 15/23] Changed citation in JES and forward to __call__ in
 optimize_poserior_samples - was accidentally left out of previous commit.

---
 botorch/acquisition/joint_entropy_search.py | 2 +-
 botorch/utils/sampling.py                   | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 4fd11595ad..36adfb5fb5 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -59,7 +59,7 @@ class qJointEntropySearch(AcquisitionFunction, MCSamplerMixin):
     This acquisition function computes the mutual information between the observation
     at a candidate point `X` and the optimal input-output pair.
 
-    See [Tu2022]_ for a discussion on the estimation procedure.
+    See [Tu2022joint]_ for a discussion on the estimation procedure.
     """
 
     def __init__(
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 8269b02191..0929983417 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -904,12 +904,12 @@ def optimize_posterior_samples(
     if maximize:
 
         def path_func(x):
-            return paths.forward(x)
+            return paths(x)
 
     else:
 
         def path_func(x):
-            return -paths.forward(x)
+            return -paths(x)
 
     candidate_set = unnormalize(
         SobolEngine(dimension=bounds.shape[1], scramble=True).draw(raw_samples), bounds

From 6866d6c36c5bdf057692306345bc3616053013b1 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 16:33:55 +0200
Subject: [PATCH 16/23] Forgot ufmt on sampling

---
 botorch/utils/sampling.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 0929983417..af768afc5a 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -25,10 +25,10 @@
 import torch
 from botorch.exceptions.errors import BotorchError
 from botorch.sampling.qmc import NormalQMCEngine
+from botorch.utils.transforms import unnormalize
 from scipy.spatial import Delaunay, HalfspaceIntersection
 from torch import LongTensor, Tensor
 from torch.quasirandom import SobolEngine
-from botorch.utils.transforms import unnormalize
 
 
 @contextmanager

From cabaca3639a0f4c1001dc14a7c39c7febb5a9b59 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 16:45:25 +0200
Subject: [PATCH 17/23] Added fixes to info theoretic tutorial and cleaned up

---
 ...tion_theoretic_acquisition_functions.ipynb | 95 ++++---------------
 1 file changed, 16 insertions(+), 79 deletions(-)

diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 4b02dea8d7..e1e440607c 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -250,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "908e289f",
    "metadata": {},
    "outputs": [],
@@ -287,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "5770f703",
    "metadata": {},
    "outputs": [],
@@ -319,21 +319,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "877a342b",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -365,7 +354,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "79e93848",
    "metadata": {},
    "outputs": [],
@@ -393,7 +382,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "320b07cc",
    "metadata": {},
    "outputs": [],
@@ -432,21 +421,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "382e37f4",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkAAAAHPCAYAAAC7lGWmAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAADNxElEQVR4nOydd3hUVfrHv3d6+qQ3QgoQIPSEXkQEQUUUC4IVsIACiqKrsmtBfmvbxbY2dnERXNfCKthQAZEiSO8ltBQCCem9TT2/P8aZ5NyZlGmZmeT9PM99uOfMufe+M2TuvPetAmOMgSAIgiAIogsh8bQABEEQBEEQHQ0pQARBEARBdDlIASIIgiAIostBChBBEARBEF0OUoAIgiAIguhykAJEEARBEESXgxQggiAIgiC6HKQAEQRBEATR5SAFiCAIgiCILgcpQIRNBEFoc5szZ46nxfRJcnNzIQgCrr76ak+L4lauvvpqCIKA3NxcT4vS4bjivQuCgKSkpA47riM4dOgQJk+eDLVabbmP+PLfx5o1ayAIApYtW+ZpUQgHkHlaAMK7mT17douvjR071unzJyUl4eLFi6COLATRNtu3b8eECRMwe/ZsrFmzxtPi2EVNTQ1uuukmXLlyBVdffTUSEhIgCAICAwM9LVqLzJkzB2vXrsW2bds6/QNLV4QUIKJVfO0mSxDewCeffIL6+nrEx8c7fI7MzEzI5fIOO87dHDhwAAUFBbj33nvxySefeFocl3DLLbdg5MiRiIiI8LQohAOQAkQQBOFiunfv7vQ5+vTp06HHuZvLly8DAFJSUjwsiesICQlBSEiIp8UgHIRigAiXYY49MBgMeP3115GamgqlUomEhAQ888wz0Gg0lrXbt2+HIAi4ePGi5Vjz1jx+oXksxWeffYaRI0ciKCgIarXasqa+vh7/93//h/79+8PPzw8hISG46qqr8MUXX9iUMykpCYIggDGGd955B2lpaVCpVIiPj8djjz2GyspKbv2NN94IQRCwefNmm+err6+HWq1GUFAQampq7PrMqqursXjxYiQkJEClUqFv37546623YDQardYePXoUTz/9NDIyMhAZGQmlUomUlBQsWLAABQUFNs9/8uRJ3HPPPUhJSYFKpUJkZCQGDx6Mxx9/HFeuXLFan5mZiTlz5iAhIQFKpRLR0dGYNWsWTp06ZfP8BoMBK1asQJ8+faBSqZCQkIDFixejurrars8BACorK/Huu+9iypQpSExMhFKpRHh4OK677jps2bKlxeN0Oh1WrlyJsWPHQq1Ww8/PDz179sTcuXNx6NAhq/WrV6/G4MGD4efnh5iYGMyZMweFhYWYM2cOBEHA9u3bLWvbitdatmwZBEGwspS2FAN08eJFPPLII0hNTYW/vz/CwsLQr18/zJ8/H2fPnuXWir8Lc+bMwYQJEwAAa9eu5b4zzWNQWosB+vHHH3HttdciNDQUKpUKvXv3xrPPPmv1Ny9+bydOnMBNN92E0NBQBAQEYPz48fj9999tXkOM+TM0u9NfeuklqzjClj5HM+bvbHPM95A5c+agvLwcjzzyCGJjY6FUKtG/f3+sXr26RZkuXbqExx57DKmpqfDz80NYWBiGDh2Kl156yfK3KwgC1q5dCwCYMGEC93mb/19biwFy9L4EAB999BEGDhxo+RudP3++zf+j2tpavPrqqxg0aBBCQkIQGBiIHj16YMaMGdi0aVOL75/4A0YQNgDA7P3zAMASExPZHXfcwQIDA9mNN97IbrzxRhYSEsIAsLvvvtuyNjMzk82ePZsFBAQwAGz27NmW7cknn7SsGz9+PAPA5s2bxyQSCRs3bhybNWsWGzNmDGOMserqapaRkcEAsMjISHb77bez66+/nimVSgaAPfbYY1ZyJiYmMgBs4cKFTC6Xs2uvvZbdcccdLDo6mgFgAwcOZFVVVZb13333HQPAbr/9dpvve82aNQwAe/DBB9v1OeXk5DAAbOTIkSwjI4Op1Wp26623shtvvJH5+flZPg8xM2fOZDKZjKWnp7Pp06ez6dOns6SkJAaAxcbGsvz8fG79wYMHmUqlsrynO+64g914440sLS2NAWDbtm3j1m/YsMHyuQ0ePJjdfvvtbMSIEUwQBObv78927NhhJdOsWbMYAObv78+mTZvGbrnlFhYSEsIyMjLYyJEjGQCWk5PTrs/lp59+YgBYUlISu/baa9nMmTPZqFGjmCAITBAE9u9//9vqmNraWnbVVVcxACwgIIBNmTKFzZw5k40YMYLJ5XK2ePFibv0zzzzDADC5XM4mT57MZsyYwaKiolj37t3ZtGnTrD4X8//V+PHjbcr84osvMgDs448/5ubNf7fN33teXh4LCwtjAFivXr3YbbfdxqZPn86GDBnCBEGwOof5+2Rm1apVbMqUKQwA69GjB/ed2bBhQ4vHmXnllVcYACaTydjEiRPZzJkzWbdu3RgAlpqaygoLC22+t4ULFzJ/f382YMAANnPmTDZo0CAGgKlUKnbixAmbn0tzSkpK2OzZs9mYMWMYADZo0CCL3KtWrWr1czRj/s42Z9u2bQwAu/nmm1lqaiqLi4tjM2bMYBMmTGBSqZQBsJy/OTt37mRqtdrytzZjxgx24403sp49ezIA7MiRI4wxxmbPns169OjBALApU6Zwn3dJSQljjLGPP/6YAWAvvvgidw1n7kt/+tOfmEKhYJMnT2a33HILi4qKYgDYuHHjmNFotKzX6/VsxIgRDACLiIhgN910E7vjjjvY6NGjmb+/v817CMFDChBhE0cVIACsb9++7MqVK5b57Oxsyw3nwoUL3DG2bmzNMf+QqFQqtn37dqvXFy1axACwCRMmsOrqast8Zmam5cbx/fff27xmcHAwO3jwoGW+pqaGXXPNNQwA98Op1+tZQkICk8vlrKioyEoG84193759LX84zTD/qJoVE/PNlDHGLly4wOLi4hgA7keNMcZ+/fVXqx8pg8HAXnrpJQaAzZ07l3vtvvvuYwDYihUrrGTIzMxkBQUFnEwBAQEsMDCQbdmyhVv7008/MblczhISEphGo7HMf/HFFwwA6969O/dDX1RUxPr37295j+1VgLKzs9mePXus5g8fPszUajULDg5mNTU13GsPPPAAA8CuuuoqVlxczL1WWFjI9u7daxnv2bOHCYLAQkJC2OHDhy3zzf/f3akAvfDCCwwAW7RokdV5Ll68aPXdsKXImH/0W/txs3Xc/v37mUQiYYGBgdxn0tjYyGbMmMEAsNtuu83mewPA3nnnHe61xx9/nAFg9957b4tyiGlJWWh+LUcUIABs1qxZrLGx0fLahg0bLH+bzSkrK2ORkZEMAPv73//ODAYD9/rvv//Ofcdnz55t82GhrffkzH0pJiaGnTlzxjJfUlJiUc62bt1qmf/1118ZADZs2DDW0NDAnauqqoq7txG2IQWIsIn5xtLaJv6BNs+Lf0AZa7ohiG9w7VWAFi5caPVabW0t8/PzYxKJhGVmZlq9/o9//IMBYJMmTbJ5zT//+c9Wx5w6dYoJgsACAwO5m8ry5csZAPa3v/2NW5+ZmWlRZNpLcwVo8+bNVq9/+OGHDACbOHFiu88ZHx/PwsPDubnrr7+eAWBHjx5t8/jFixczAOzdd9+1+fpjjz3GALD169db5syWl9WrV1utN1tz7FGAWuMvf/kLA8C+++47y1x+fj6TSqVMqVSy3NzcNs9hVghfeOEFq9fM/+/uVIAeeeQRBoB98803bcrKmGsVIPN7X7p0qdX6oqIiy/coLy/P6r2Zra3NKS0tbdHS1BLuUoCCg4NZaWmp1TFmJbz5/8Hrr7/OALDrrruuXTI7ogA5e1+yZbVasWKF1XW+/PJLBoA9/vjj7XovhDUUA0S0yuzZs1vcbAV6yuVyS5xCc1JTUwHAZtxJe7jpppus5g4dOoSGhgakp6fbDPy89957AQC7d++2GVMza9Ysq7m0tDQMGjQItbW1OHLkiGX+wQcfhEwmw0cffcStX7VqFQBg3rx59r0hAGFhYbj22mut5u+8804AwO+//24ld1lZGT7++GM8+eSTeOCBBzBnzhzMmTMHOp0OZWVlKC8vt6zNyMgAACxcuBDbt2+HXq9vURZzfNOtt95q8/Vx48YBAPbv3w/AFHezd+9eAMDMmTOt1l933XUIDQ1t8XotYTAYsHnzZixbtgzz58+3vL9t27YBAM6fP29Zu337dhgMBlx33XVITExs89y//fYbgNb/392J+f/jz3/+M3744Qc0Nja69XrNMb/3u+++2+q1qKgoTJ48GUajEbt377Z6ffLkyVZz4eHhCAsLc/j77EoyMjIQHh5uNW/rnvPLL78AAObPn+82eZy9L9n6vG29l8GDB0MikeDjjz/GqlWrUFZW5qq30GWgLDCiVexNg4+JiYFUKrWaDwoKAgAuENoebClb5sDflgI+1Wo1QkJCUFVVhYqKCqubZEs/mklJSTh69CgXWBwbG4ubbroJ69evx44dOzB+/HhotVp88skn8PPz435YvvnmG3zzzTdW5xV/li1dPyQkBGq1GpWVlZzcn3/+OebNm4fa2lqbxwGmWithYWEAgD/96U/YtWuXpXZMYGAgRo0ahalTp2LOnDlc9oo5qLOttO3S0lIAJkVMq9UiMjIS/v7+NtcmJiaioqKi1fM15/Lly7jxxhtx7NixVt+fmUuXLgEAevTo0a7zm/8/2/p/dxdz5szB5s2bsW7dOkybNg0qlQrDhg3Dddddh/vvvx8xMTFuu3Zb3xXzfH5+vtVr3bp1s3lMUFAQp3B7itbkA/h7jr1/M47g7H3J1vux9V5SU1Pxt7/9DUuXLsW8efPw8MMPo3///pg4cSLmzJmDgQMHuugddV5IASJcikTiHqOiSqVy6Dhx5ogzPPzww1i/fj1WrVqF8ePH45tvvkFpaSnuu+8+Livt6NGjluyR5jhTU+nixYuWjJm3334bU6dORXx8PPz8/AAAo0ePxp49e7iCksHBwfj111+xe/dufP/999i+fTt+/fVXbNmyBa+++ip+++039OrVCwAsT6KtFb4EgBEjRjj8HtriwQcfxLFjx3Dbbbfh6aefRu/evREUFASJRIJ//etfmD9/vtcVzLT1BN8SUqkUX375JZ599ll8++23+PXXX7Fv3z789ttveO211/Dzzz9j9OjRbpS2ZVr7nrjrO20PrX3O3iCfvbjq837yySdxxx134JtvvsGWLVvw22+/4a233sLbb7+Nt956C4sXL3aFuJ0W3/vLIYg/iIuLAwBLKr2YqqoqVFZWws/Pz6Y7pqXjzPPm85uZNGkSevbsia+//hoVFRUtur+WLVsGZoqv4zYxeXl5Nq9fXV1tkdusWP3444/QarV47LHHsHjxYvTs2dOi/ABAdna2zXMJgoCxY8fi9ddfx759+1BQUIA777wTRUVF+Mtf/mJZZ37qfOONN7BmzZoWtwcffBCAyQWiUChQUlKChoYGm9du6f3Zoq6uDlu2bEF0dDS+/PJLDB8+HCEhIZYfA1vvLyEhAQCQlZXVrmvExsYCaPv/vTkKhQIAWrS6mS0K9jBkyBAsW7YMO3fuRElJCZ544gnU1NTg8ccft/tc7aWt70p7LYDuorXP2WAwoLCw0CXXsfdvxhGcvS/ZS0JCAh599FF89913KCkpwX/+8x9IpVI8/fTTdllguyKkABEexXzjay0+pSUyMjLg5+eHQ4cOcbEhZj799FMAwJgxY2w+Va1bt85q7syZMzh69CgCAwMxePBg7jVBEDBv3jw0NjZi+fLl2Lp1K/r27YsxY8bYLTtgciNt3brVat5cJ2TUqFEWd6L5RmbLPL5z504UFRW165pRUVGWmiUnT560zJtjkTZs2NCu88jlcos1yNbnuHnzZrvcI1VVVTAajYiNjbVyoep0OptyXX311ZBKpdi0aVO7FBFzHFNr/+9iIiIiIJPJkJOTY/U3qtPpsGPHjjav2xrBwcF49dVXIQgC9//REo5+X8zv/fPPP7d6raSkBJs2bYIgCA7/LTuLWTk9d+6c1Wvbtm2DTqdzyXUmTZoEAPjXv/7VrvWOfN7O3pecQSaT4Z577sGwYcOg1WptXp9oghQgwqOYn5bEReDaQ0BAAO6//34YjUYsXLgQdXV1ltfOnTuHv/71rwCAxx57zObx7777LhfoXF9fj0cffRSMMcydO5ezsJiZO3culEol3n77bTDG8NBDD9ktd3OeeuopLngxJycHy5cvB2AKXjZjDoL89NNPufeZn5+Phx9+2Oa5V65ciZycHKv5H3/8EUDT0zBgMqX7+fnhqaeewvr1662O0Wg0+OqrryzVfAHgkUceAQC8+OKLnLWntLQUf/rTn1p519ZERUUhJCQEJ0+e5AJxDQYDnnnmGZs/jHFxcbjvvvvQ2NiI2bNnWwWBFhcXY9++fZax+XN6++23uTijuro6y/+7GIVCgVGjRqG8vBzvv/++ZV6v1+PJJ5+0+fm2xH/+8x+bSs5PP/0Exhj3/9ESjn5fFi5cCIlEgn/84x84ePCgZV6r1eLRRx9FQ0MDbr311nbJ4A6uuuoqAKa/7+bFI3Nyclr8/jrCgw8+iIiICPz000+W73Bz9u7di+LiYsvYkc/b2ftSe9m2bRt++eUXK/dgTk4OMjMzIQhCi/FRxB94JvmM8HbwRwpz8+Jf4u3555+3OqaltNiWUmDfeOMNBoBFR0ezWbNmsQceeIA988wzltdtpRM3p3nBsaioKDZjxgx2ww03WAoAtqcQ4pQpU9gdd9zBYmJiGADWr18/VllZ2eJnc9dddzEATKlU2ky/bYvmhRDT09MthRCnTZvG/P39GQB2zz33cMdoNBrWr18/S52Q2267jU2dOpX5+/uz0aNHs9GjR1t9TuaCdWlpaey2226zKmK3a9cu7hrffPON5fo9e/Zk06ZNY7NmzWLjxo2zFKw0F4kzY64hExAQwG666SZ26623MrVazdLT0+0uhPjyyy8zAEwqlVoKISYlJTE/Pz+2cOFCm38/1dXVlvceEBDArr/+ejZz5kw2cuRIplAorAohPvXUUwwA9/8eHR3dYiFExhjbsmULk0gkDAAbNWoUu+WWW1j37t1ZRESEJU26PWnwN998MwNMRQynT5/O7rzzTjZy5EgmCAKTSCRs3bp13Dla+j4NHDjQUv9lzpw57IEHHmDffvttm8eZP1+ZTMYmTZrEZs2axRISEhhgKszYUiFEe1LTW6O1NHjGmlL1Q0JC2LRp09jEiRNZQEAAmzFjRqtp8C2VBGgphX3btm0sKCiIAWDJycnsjjvuYNOmTbMqhMiYqZioIAhMpVKxm2++mT3wwAPsgQcesHzv21MI0d77ki1svde33nqLAaZCi9dddx27++672eTJky3FFh999FGb5yKaIAWIsIlZAWptGzRokNUx9ipAOp2OPffcc6xHjx5MLpdbnaMtBYgxU92Nl156iaWlpTGlUsmCgoLY2LFj2WeffWZzvflGYzAY2IoVK1ifPn2YUqlksbGxbOHChay8vLzVz+ajjz5iANidd97Z6rqWaF5bprKyki1YsIDFxcUxhULBevfuzVasWMH0er3VceXl5eyRRx5hSUlJTKlUspSUFPbMM8+wuro6m5/Td999x+6//37Wr18/plarmb+/P0tNTWUPPvggV2itORcuXGALFixgvXr1YiqVigUFBbHevXuzWbNmsXXr1nGFEBkz/f+9/vrrLDU1lSkUChYXF8cWLFjAKisr2/V/J2bt2rVsyJAhzN/fn4WHh7Obb76ZHTt2rNUfT41Gw9555x02fPhwFhgYyPz8/FiPHj3Y3Llz2aFDh6zWr1q1ig0cOJAplUoWFRXF7rnnHpafn99qzZcffviBDRs2jCmVShYWFsbuuOMOlpOTY1cdoB07drCFCxeywYMHs/DwcKZSqVhKSgqbNWsWO3DggNU1W/o+nT9/nk2fPp2Fh4dbFLPmn0tr38MffviBTZw4kYWEhDCFQsF69uzJnn76aZt/8x2tAGk0Gvbss8+yhIQEplAoWI8ePdhf//pXptfrXaoAMWYquvnwww+zpKQkplAoWFhYGMvIyGDLly/nChcyxth///tflp6ebqnS3vz/tbX35Oh9yRa23uv58+fZc889x8aMGcNiY2OZQqFg8fHxbOLEiezrr7/mqkYTthEY87K0CoJwM0lJSbh48aLDGUVTpkzB5s2bsW3bthZ7RBG+x5w5c7B27Vr6fyWILgLFABGEHezfvx9btmxBv3796EeSIAjCh6E6QATRDp599lnk5eVh48aNYIzh5Zdf9rRIBEEQhBOQAkQQ7eCLL77ApUuXkJiYiFdffRU333yzp0UiCIIgnIBigAiCIAiC6HJQDBBBEARBEF0OUoAIgiAIguhyUAyQDYxGIwoKChAUFOTSZpoEQRAEQbgPxhhqamoQFxfXZqsRUoBsUFBQ4LGS8ARBEARBOMelS5fabAVCCpANgoKCAJg+wODgYA9LQxAEQRBEe6iurkZCQoLld7w1SAGygdntFRwcTAoQQRAEQfgY7QlfoSBogiAIgiC6HKQAEQRBEATR5SAFiCAIgiCILgcpQARBEARBdDlIASIIgiAIostBChBBEARBEF0OUoAIgiAIguhyUB0gF6PT6WAwGDwtBuHjSKVSyOVyT4tBEATRaSEFyEVUV1ejtLQUGo3G06IQnQSlUomIiAgqxkkQBOEGSAFyAdXV1cjPz0dgYCAiIiIgl8upiSrhMIwx6HQ6VFVVIT8/HwBICSIIgnAxXq8A7dy5E3//+99x6NAhXLlyBRs2bMD06dNbPWb79u1YsmQJTp06hYSEBDz33HOYM2eO22QsLS1FYGAgunXrRooP4RL8/PwQFBSEy5cvo7S0lBQggiAIF+P1QdB1dXUYNGgQ3n///Xatz8nJwdSpUzFhwgQcPXoUjz/+OB588EFs2rTJLfLpdDpoNBqEhISQ8kO4FEEQEBISAo1GA51O51FZGvVAXhVQVu9RMQiC8HGMDRpsW/k+fvjuU1QVFoIx5jFZvN4CdP311+P6669v9/qVK1ciOTkZb7zxBgCgb9++2LVrF9566y1MmTLF5fKZA54pYJVwB+a/K4PB4JG/sZwKYMUeYEs2oPkjtr9HKDAvHbijHyAhnZ8gCDuov5CL7s9/AQAoxT9REKhEyOH/Ii40usNl8XoLkL3s2bMHkyZN4uamTJmCPXv2tHiMRqNBdXU1t9kLWX8Id+DJv6vvzgJT/gv8cL5J+QGArArgma3A/d8BNRTzTxCEHRw78js3rpMZ0SD1TOZ0p1OACgsLER3Na5LR0dGorq5GQ0ODzWNeffVVhISEWLaEhISOEJUgvJbvzwGP/cwrPmK25QIPfG9yjxEEQbSHM8cPQKOQYM7HwzDn42GoTAxFj+A4j8jS6RQgR1i6dCmqqqos26VLlzwtEkF4jLOlwJ+2AO3xzO/LB17c7m6JCILoDJypvARjXiE3F9wz2UPSdEIFKCYmBkVFRdxcUVERgoOD4efnZ/MYpVKJ4OBgbiMcRxAEbpNIJFCr1Rg3bhw++ugjq6C3ZcuWWR1ja8vNzeWO02g0eOuttzBq1CiEhIRAoVAgNjYWQ4cOxaOPPoqNGzd24LvuHGgNwIKfgAaRVeeOtKb9UBX/2hengJ8vuF82giB8m/W5uxBVpAEYw7AD5Rh2oBxxPft4TB6vD4K2l1GjRuHHH3/k5rZs2YJRo0Z5SKKuy+zZswGYAnizsrKwe/du7Nq1C1u3bsXnn39utX7QoEEYPHhwi+cLDAy07FdWVmLixIk4fPgw5HI5Ro0ahbi4ONTW1uLQoUN47733sGXLFkydOtXl76szs+YYcKGcn7uzP/D8OGDdadN49U3A3RuA+maJact3AuMTAT/KBSAIwgaV2lpsLTiCCSWmwMGFH2QBABTv3uoxmbxeAaqtrcWFC02Plzk5OTh69CjCwsLQvXt3LF26FPn5+fjkk08AAA8//DDee+89PP3007j//vvx66+/Yt26dWQN8ABr1qzhxlu2bMENN9yAL774AnfffTduvPFG7vXp06dj2bJl7Tr3Cy+8gMOHD2Pw4MH44YcfEB8fz72+f/9+/Pzzz86I3+UoqQPe2cfP9YsElo037Y/84yNOiwT+OgFYsrlpXX4N8OFBYAk9ZxAEYYMf8vbBoNUiolQDvRS4mGDyyKQndfOYTF7vAjt48CCGDBmCIUOGAACWLFmCIUOG4IUXXgAAXLlyBXl5eZb1ycnJ2LhxI7Zs2YJBgwbhjTfewEcffeSWFHjCPq699lrce++9AIBvvvnGqXN9/fXXAIC///3vVsoPAAwfPtzyN0K0j1VHgFotP/fyNYBKZtq+vN20qWTArX2AkaL71kdHgKrGjpOXIAjfQG804JuLvyOiVAsJAxR6IPFSAxIvNSCoTy+PyeX1FqCrr7661UJJYiuD+ZgjR464USrCUYYMGYKPP/7Y6UDzkpISAEBkZKQrxOryVDUCnx7n527rCwyJsb1eEIDl44HrPgOMf3w963QmF9riEe6VlSAI3+L34tMoaqjAgBK+boZEHQSpOshDUvmABYjoXNTU1AAwBZ47g7lUwcqVKz1aSbSz8J/jJgXGjEQAHhve+jG9I4AbRQ9vq48CdVqbywmC6KKsz90FAIgq5k3E8iRr631H4vUWIF/FyIyo0vpm34AQhT8kgut1Y8YYfvjhBwDAwIEDnTrXQw89hKVLl2LlypXYvn07pk+fjhEjRmDo0KHo1s1zPmVfxGAEPj3Bz03tBSSpm8b1OmDMx6b93XMB/z+CnRcOA74717SustE0vrO/W0UmCMJHyKkpxKHS8wCAqGKTBUgjF1ASpQRK8xBWUw3/IM9kXpMC5CaqtPW4aYtvxqB8d+1yhCoD217YTgwGA7Kzs/HKK69gz549UCqVmDt3rtW6l156CS+99JLNcwwaNAhHjx61jJ9++mlUVFTgrbfewpkzZ/Daa69ZXuvXrx8WLVqEefPmQSIhI2db7MwDrtTyc/PTrdeV26gj2icCuCYJ+DW3ae6/J0gBIgjCxIbc3ZZ9swIEAN3yTdYgxowdLpMZUoAIt2GrjUNQUBDWrl2LHj16WL3WWhp89+7dubFEIsHrr7+OxYsX46uvvsLOnTtx4MAB5OXl4dSpU3jkkUewadMmfP3116QEtcHnJ/nxgChggB1tee4ZyCtAJ4qB40XAwI5v7UMQhBdRq2vAz5cPWMbNXWB/fyoVAPCmUtHhcpkhBYhwG+Y6QBKJBMHBwRgwYABuvfVWhIaG2lxvTxq8mbi4ODz22GN47LHHAACZmZlYsWIFVq9ejW+++Qaff/457r77bqfeR2emrB7YmsPP2Wu9uToRiA8ypcKb+fIUKUAE0dX5+fJBNBhMQYGCkTVZgAQBp/qFmHalUk+JRwoQ4T5sZei5m759++Lf//43KioqsGHDBmzcuJEUoFbYnA3om1mgVTLgplT7ziGVADP7AW/ubZrbeN5UP0juuXsbQRAexMiMluBnAFBX6iDXe1fCCilAbiJE4Y/vrl3uaTEcIkTh72kRnOaaa67Bhg0bUFpa6mlRvJofz/PjSclAkAMJerf04RWgikbgtzzgGs+1+SEIwoMcLD2PS3UlljGXAcYYBh2rNO1OMnhMEyEFyE1IBIlLA4kJHsaYzRgjM+bq4baKJBImKhqA3aJyTDc4WJOse4ipZtCRZn0Ovz1LChBBdFWaW38AIK2abyL4xNumpy/2qBZQeeahm6JDCZ9k9OjR+Pjjj1FXV2f12g8//ICVK1cCAG6//faOFs1n2JwNGJpZpFUyUzyPLSQCMDDKtEla0Dtv7s2Pt2QDGr3ttQRBdF4K6svwe9Fpbm5UY5hlX2AMBQkBuNJDDamEYoAIAt98841Vx/fmPPbYY0hPN+VnZ2Zm4v7778eCBQuQnp6O7t27o6GhAWfPnsWZM2cAmPrCUTPUlhG7v65OBAJaSMhQyYDv72z9fFN7AS/tAMw6VZ0O2JtvapJKEETXYUPubjA0PV0FylToXmaE2Qmm0AN9b7wREcsXeUbAPyAFiPAajh07hmPHjrX4+vTp0y0K0M6dO/Hzzz9j69atyMrKwtGjR2EwGBAdHY3bb78d999/P66//vqOEt3nqNMCv1/m56Y62ZInKgAYLHKD/ZJNChBBdCUaDVpsvMR3Vb4+YTjYxR+4OU9XgQZIASLcgL2tKZYtW2Z3+vvAgQMxcOBAPP3003YdR5jYexnQGprGMgkwIcn5816bYq0ALb/a1DuMIIjOzy/5h1Gj46umTu8+Grqcf3Jz8mTPK0AUA0QQXZAdefw4I7b17K8GHTBmtWlr0LW87toUflxQC5ymRDyC6BIwxrC+WeVnABgR2QfxOiWM1U3l5jVyAXv+shxbx0xDQ22N+DQdBlmACKILsiOXH7flpmIALtc07bdErzAgIRi4VN0090s20C/SASEJgvApTlTk4Hx1Pjd3W9JY6HL5OUilSDpfBQAwGg3wFGQBIoguRl4VkFvFz13lojgdQbC2Av2aY3stQRCdi69Fqe9x/uEYEdUHuhxeAZJ2i8Y/Hu2JfzzaE4LCc60wSAEiiC7Gjov8OMLPtRaaa5L48fFioEpjcylBEJ2EssZq7LhynJu7JWkMJILEygIkT4rD4fRQHE4PhSDzXBo8KUAE0cXYKVKAxiW2XNvHEYbFA8pm9zQjMwVdEwTRedl4aR8MzTq7KyVyTO02HACgF1mA5ImxHSpbS5ACRBBdCCMD9onc8Vd1d+01VDJgaBw/tyvP9lqCIHwfAzPi24t7uLlJ8UMQ9EdbJV1uAfearHsM+pypRp8z1WAGz8UAURA0QXQhzpVZu6NGdnP9dcYm8G02xC03CILoPOwpOo3ixkpubnriGMu+Loc3Actjo/DsvLMAADZPCyipFQZBEG5GbP1JCAbigto+ToApw6tXmGm/LcaKrEpZFUCB57JdCYJwIxsu8qnvfUIS0EedAAAw1jXAUFzOvS7rHoviboEo7hYIQfCcGkIWIILoQuwXKUAj2lmLzE8O/HJv+6/TLxJQq4DKZg2gd18CZqS1/xwEQXg/+XWl2F9ylpubntTM+nOxQHwIgvumYtSRn9wuW1uQBYggugjMRvzPsDjba51FKgFGi1xreygQmiA6HeLYn0C5HybGDbaMrVLgYyIg8ec7w3sKUoAIoouQWwmU1PNz7bUAOYI4tuiA9YMgQRA+jMagw4+X9nNzN3QbDpW0qbaP3ioF3vMtMMyQAkQQXYT9IgUk0h9IUrfv2AYdMOk/pq21VhjNGS6yLuVVAUW1ttcSBOF7bL9yDFW6Om7u5sRR3NhWDaCG2hpsvuYWbL7mFmqFQRCE+xFbYEbEt79JKQNwvrxpvz2khgPBCqBa2zS3vwCYltrOExAE4dWIu75nRPRC98Aobk7sApMnd4PRaECPE6YmgdQKgyAIt3O0kB9nuLkWmVQCZIisQOQGI4jOQX5dKY6UZXFzN3UfZbVObAGSJcdBUCjwz3kp+Oe8FGqFQXQuBEGwbHv27Glx3bp16yzrkpKSuNdyc3O587S0LVu2zOq827Ztw2233Yb4+HgoFAqEhoaid+/emDFjBt577z1UVVVZHdMS27dvhyAIuPrqq9u1fs6cOTblDAkJwciRI/Huu+9Cr9e3+/quokYDXOAzUTE4xv3XFbvBDuTbXkcQhG8hjv0JlvtjbHR/bo5pddBfKuLm5EnxEGRS7BkVjj2jwj3aCoNcYIRb+e9//4tRo6yfCgDg008/bfP4gIAA3H777S2+PnjwYG68fPlyvPjiiwCAvn37YsSIEZDL5Th79izWr1+Pr776CkOHDsXIkSPb/yYcYMyYMejZsycAQK/X4+LFi/j999+xb98+/PTTT9i4cSOE9vqfXMDxYt51JZcAaR3QoV2cZZZZairEGKJ0/7UJgnAPBmbET5cPcHOT4zOgkPIqhe5SIWA0cnPy5G7QwjsgBYhwC1KpFGlpafjyyy/x9ttvQybj/9TKysrw888/Iz09HYcPH27xPBEREVizZk27rnno0CEsW7YMcrkc69atw/Tp07nXCwsL8emnn0KtVtv5buznwQcfxJw5c7i5gwcP4qqrrsJPP/2EDRs24NZbb3W7HGbE7q+0SFPLCnczMNrUF0zzh5ufAThUAFyT7P5rEwThHvYXn0FJI29Jn9p9uNU6vagFhkQdBKk6CExTj+RsU0YEMxg8pomQC4xwG3fffTdKS0uxadMmq9e+/PJL6HQ63HPPPS673vr168EYwx133GGl/ABATEwMnnrqKfTp08dl17SHoUOHWqxZO3fu7NBrixWgjnB/AYBSBgyKbl0WgiB8i40i91fvkG7oGWyd3m6dAWZawzRavPh/mXjx/zLBNJ6zB5ECRLiNu+66C4Ig2HR1ffrppwgMDMTNN9/ssuuVlJQAACIjO8C34yBRUaYMiY6MA2IMOOKkAiQA6BZk2ux13ImvdbTI9jqCILyfCk0tdhed4uamJoywudZKAUo2KUCCIEFFhAoVESpqhdEZYUYjjOXtD7b1JiRhIRAkzv9RJiQk4KqrrsJ3332H2tpaBAYGAgCys7OxZ88e3HvvvfD3d10TvIQEU++Zr7/+GkuXLrUoG97EwYMHAZjikzqKghrrAoiDo22vbQk/ObD7fseub6UAFZqUsg4MgSIIwkVszj8EPWtKXVdIZJgUn25zrTgFXvaHBcg/KBhDM7e4T8h2QgqQmzCWVyG3702eFsMhkjK/gzQi1CXnuueee7Bjxw6sX78e9913HwBTYLT5NVdy991349VXX8WlS5fQs2dP3HrrrRg7diwyMjIwcOBASKWeyTbQ6/XIy8vDe++9hx07diAhIQH33mtHYy0nEVtcQpRAsrrDLm+lbFVpTFWpk13zJ0YQRAey6fJBbjw+diCC5H4219oqguhNkAuMcCu33347lEqlRekBTApQbGwsJk6c2ObxFy9ebDUN/ujRo5a1KSkp+P7775GQkICamhqsXbsWDz30ENLT0xEREYEFCxbgypUr7nibVsydO9cio1wuR48ePfDWW2/hrrvuwp49exAcHNwhcgDAqWJ+PCi6Y60vcUGmqtPNOUJuMILwOXJqCnG+mldqru82zOZaZjRCL2qEKk/uZnOtpyALEOFW1Go1pk6dim+//RaFhYW4dOkSzp49iyeeeKJdFpm20uDDwsK48cSJE3HhwgVs3LgRmzdvxv79+3H8+HFUVlbiww8/xNdff42dO3eid+/eTr+31mieBs8YQ2FhIQ4ePIh169YhNDQU77zzTodZpE6W8ON+DoRINeqBGf8z7f9vhn0ZZIJgcoNtyW6aO1YI3OqZWHSCIBxkSz6fsRuuDEZ6RC+baw2FpWCNfICzOQaosa4W2+4w+dQnrFsNVUCgG6RtG1KACLdzzz33YP369fjiiy+Qk5NjmWsP9qTBm1EoFLjllltwyy23AAAqKyvxxRdf4M9//jOKi4uxaNEibNli8j+/9tprOHPmDHd8nz598Oyzz9p1TTG20uBramowa9YsvP/++wgLC8Py5cudukZ7OS1WgBwIjTIyUy0h8769DI7mFSDKBCMI38LIjPhFpABNih8CaQtBzOL4H8FPCWl0OADAYNAjdf8Vy76nIAXITUjCQpCU+Z2nxXAISViIS893ww03QK1W45NPPkFBQQH69u2L9HTbQXPuQK1W4+GHH0ZcXBxuvvlmbNu2DfX19fD398fPP/+MHTt2cOvHjx/vtAJki6CgIPztb3/Djz/+iHfffbdDFKCiOusAaEcsQM4iDoQ+XQpo9KY0eYIgvJ+TFbm40sCXk58cn9Hiep2oBpAsMc5S/FWQy/HxnCQAwJ/lctcKagd0+3ETgkTiskBiX0epVGLGjBlYtWoVAOCxxx7ziBzXXHMNAMBgMKCyshL+/v7Yvn17h8qQnGyqAFhZWYmSkhK3p+yL438C5O3vAO9KBooCobUGU1XojqpHRBCEc2y+fIgbJwVGo5eN2j9mdDmXubHZ/QUAglyGHeNN976/yD2nhlAQNNEh3HvvvQgPD0dERATuvvtut1yDsdZ9MxcuXABgcpFFRES4RYa2yM42+YEEQXBpCYCWOCVyf/WNACQeSD8PVgI9RM8D4tpEBEF4JzqjHr9eOcrNXRuf0Wo7H7EFyFwE0ZsgCxDRIYwbNw6lpaVuvcbzzz8PjUaDhx9+GD169OBey8/Px/z58wEAN910ExQe6EBcU1ODp59+GoDJzRYQEOD2a4oVIEfif1zFkBggq6JpfIwywQjCJ9hbfAY1ugZu7toWav+Y0bdQBRowZYjF5TdY9j0FKUCEV1NaWmoVTNyc9PR0i0uttrYW77zzDlasWIHU1FSkpaVBpVLh8uXL2LdvH3Q6HXr27Im3337bbjkOHz7cagPVDz74gItr+uijjyzuNcYYioqKcODAAZSXlyMiIgLvv/++3TI4gpUC5MEi2QOjga8ym8Zi2QiC8E625PPur0FhKYj1D2thtemeJw6Cbu4CY40avPLcSdP+nRpAYbuOkLshBYjwaurq6rB27doWX6+srLQoQM899xyGDh2KTZs24dixY/jtt99QVVWF4OBgDB8+HDfffDMWLFjgkOWlpqYG+/bta/H16upqbrx7927s3r3bMvbz80NycjLmzp2Lp556CjEx7g9+qdYAeaJi5M4oQGFO3qPE175QDjToTFWmCYLwThr0GvxedJqba8v6Y6yohrG6lpsTu8Bqgzz/xScFiHA5bcXiNCcmJsbm+qSkJLvOA5hS5u+55x6XVpi++uqr7ZJjzZo1dqftuwtx+rtMAvRq+aGtVfzlwJF5zsnTN8LUR8z8aRoZcKbM5BojCMI72VucCY1RZxlLBQnGxw5s9RhxBWhIpZB1a8qECAhWY1D2ry6V0xEoCJogOiliF1NqmGfTzgMUQIooEFqcpUYQhHex7coxbjwkvCfUitYLF1qlwCfEQPBgtldLkAJEEJ0UqwKIHoz/aUkGigMiCO+lQa/BnuJMbm5C7KA2j7NKgfeyHmBmSAEiiE7K2TJ+3NcJBahRD8z8yrQ1OlG4tb8oC+0kWYAIwmvZW5yJRkNTOwupIMG4mAFtHqdvJQAaMLXC2HjbPdh42z1orONjhToS77NJEQThNAYjcJ4v2ore4Y6fz8iAvflN+44itgCdLQN0BkDeMW3RCIKwA1vur1Bl23272qoBZDDo0WfnRcu+pyAFiCA6IXlV1pYaZxQgVyG2AGkMpmwwZ6xTBEG4nkaD1iH3F9B6FWjA1ArjszsTAABPerAVBrnACKITInZ/hfsBke6vu9gmahXQLYifozgggvA+9hQ55v4y1jXAUMybn2VJYgVIhs2TY7B5smeDo0kBIohOiFgBSvUC648ZcTVqUoAIwvvYLnJ/DQ7v0T7318UCqzl5IgVBEwTRQZwTKUDe4P4yI44DokBogvAuNAYd9hTzxQ/b7/7iA6ClMRGQ+Ku4OWY0IqJUg4hSDbXCIAjCtZwRKUB9PNP71Sb9RQpQZinAGNBKX0WCIDqQQ6Xn0dDM/SVAwFXtcH8BrfcAM8MaNVjxp+Om/Vs91wqDLEAE0cnQ6IGcCn7OFS4wP5lpcxaxMlajBQpqnD8vQRCuYVfRSW7cPzQJocqgFlbziKtAt1QDSKOQQKPwrApCFiCC6GRkVwAGUap6qoMtMMz4y4EzC507h5m4ICBYAVQ3PWDiTCkQH+ya8xME4ThGZsTuolPc3LiY/u0+3roJajerNQHBaqTl73BMQBdCFiCC6GSI3V/dgoAgpWdksYUgAL1FViCxzARBeIbTlXko1/Am2bHRdihAIguQLNk7A6ABUoAIotMhDoD2pgwwM+Kg7DOlnpGDIAieXYW8+ysxMBoJge0r1MV0eugv81kNtmKAvAWfUIDef/99JCUlQaVSYcSIEdi/f3+r699++2307t0bfn5+SEhIwBNPPIHGxsYOkpYAAEEQIIiiWs1zrW1z5syxOtfhw4dx7733IjExEUqlEsHBwejZsyemTZuGFStW4MqVK+2WKzc3F4IgICkpqV3rly1bZlPOwMBADB48GH/9619RX1/f7ut3BOIUeFcEQDfqgTnfmjZnWmG0JBNZgAjCOxDH/9jj/tJfKgQMBm7Olgussb4OP9wzFz/cMxeN9XWOCeoCvD4G6Msvv8SSJUuwcuVKjBgxAm+//TamTJmCs2fPIioqymr9Z599hmeffRarV6/G6NGjce7cOcyZMweCIODNN9/0wDsgxMyePbvF18aOHcuNP/74Yzz00EMwGAxISkrClClTEBAQgOzsbGzatAk//PADunXrhlmzZrlV5kGDBmHw4MEAAKPRiPz8fOzatQvPP/88NmzYgN9++w3+/v5ulaG9uKMGkJEB23Kb9p1FrABlVwBaA6CglhgE4THyaotxsZa34Njl/hLF/0jUQZCqrYOnDXod+m66YNn3FF6vAL355pt46KGHMHfuXADAypUrsXHjRqxevRrPPvus1frff/8dY8aMwV133QUASEpKwp133ol9+/Z1qNxEy6xZs6Zd6/Lz87FgwQIYDAZ88MEHmD9/PiSSJqNlRUUF1q1bh/h495tYp0+fjmXLlnFzOTk5GDlyJA4fPoyVK1diyZIlbpejLRp0QH41P9fLyQBodyB2gemNQBa1xCAIj/KbyP0VrgxGX3VCu4+3zgCzfW8WZDJ8favptUUyqgRtE61Wi0OHDmHSpEmWOYlEgkmTJmHPnj02jxk9ejQOHTpkcZNlZ2fjxx9/xA033NDidTQaDaqrq7mN8Dw//vgjGhsbMWbMGDzyyCOc8gMAoaGhmD9/PsaNG+cR+ZKTkzF//nwAwM6dOz0ig5isCqC5gUYA0CPUU9K0TLASiBc9GJIbjCA8i9j9NTa6HyRC+9WE9qbACwo5vp8Wh++nxUFQeK4XmFdbgEpLS2EwGBAdHc3NR0dH48yZMzaPueuuu1BaWoqxY8eCMQa9Xo+HH34Yf/7zn1u8zquvvoqXXnrJpbITzlNSYuqREBnpvWYBsxtWr/dcR+PmZInq/8QHA36eu7+0Su9wIL9ZsgkFQhOE56jQ1OJUxUVubqwd8T+AtQtMZiP+x5vwagXIEbZv345XXnkFH3zwAUaMGIELFy5g8eLF+L//+z88//zzNo9ZunQp576orq5GQkL7zX62MDKgosGpU3iMUD9A4gVVec3/B1u3bsXZs2fRu3dvD0tkzcGDBwEAffv29bAkJi7wPQi90vpjpm8E8Gtu05gUIILwHPtLzoA1sx/7SRVID+9l1znaawFijCGoWmfZ9xRerQBFRERAKpWiqKiImy8qKkJMTIzNY55//nnce++9ePDBBwEAAwYMQF1dHebNm4e//OUvVm4UAFAqlVAqXVsopaIBSF/l0lN2GIcfAsK9IJ73pptuQlRUFIqLizFo0CDcdNNNuPrqq5Geno709HQoFAqPyGU0GlFQUID//ve/+M9//gO1Wo0FCxZ4RBYxYgtQTy+M/zEjrgUkDt4mCKLj2FucyY0zIlKhkLZfRWBGI/SiRqgtxQCxhka8u/ioaf/GRkCusrnO3Xh1DJBCoUBGRga2bt1qmTMajdi6dStGjRpl85j6+norJUcqNaWWeFLTJJpoLQ3+m2++sawLCQnBpk2bkJaWBo1Gg//9739YuHAhRo0ahdDQUNx99904f/58h8j80ksvWWSUSqVISEjAs88+i0mTJmHv3r1ITk7uEDnaQmwB6unFFqA+okDoK7VAFVWrIIgOx8CM2FfCh5WMirLPqm0oLAVr1HJz8hRygTnFkiVLMHv2bAwdOhTDhw/H22+/jbq6OktW2H333Yf4+Hi8+uqrAIBp06bhzTffxJAhQywusOeffx7Tpk2zKEKEZ2ktDb579+7cePDgwThx4gR++eUX/PTTT9i7dy+OHj2K+vp6fPbZZ/j222/x008/uT0QunkaPGCKTzp69Ci2bNmC559/HmvWrPF4GrzBCORU8nOusgD5y4GLi11zLjMpoYBcAuiaNYM+UwaM8N66aQTRKTldcRE1Oj5mY0RUH7vOIY7/EfyUkEbbrsEREKxGj5Lf7BPSDXi9AjRz5kyUlJTghRdeQGFhIQYPHoyff/7ZEhidl5fHWXyee+45CIKA5557Dvn5+YiMjMS0adPw8ssve+otECLamwZvRiKRYPLkyZg8eTIAk5Xv22+/xdNPP43Lly/jgQcewLlz5wAAH330EXbt2sUdHxERgRUrVjgls600eK1WiwULFuDf//43VCoVPvnkE6eu4SyXqk21dJrjzS4wudQkX2az2J8zpaQAEURHI3Z/pQTFINrPPvOxLpd3f8kS46yK4XobXq8AAcCiRYuwaNEim69t376dG8tkMrz44ot48cUXO0Cylgn1M8XS+CKhfp6WoHX8/f1x5513ol+/fhg0aBDOnz+Pc+fOITU1Fbt27cLatWu59YmJiU4rQLZQKBR46623sHr1avz3v//F22+/jbAwz2kcWSL3V6gKCPPy/8ve4bwCdJYCoQmiw9kjUoBG2un+AmwEQCd7/5OMTyhAvohE8I5A4s7MwIEDER4ejrKyMpSWliI1NRVr1qyx28LkDEFBQYiIiEBJSQmysrI8qgCdd2MAdKMeeGKTaf+tKYDKRXcOcUHECxW21xEE4R5KG6txvppXXhxSgMRd4FvpAdZYX4cti58EAFz7zhtQ+QfYfT1X4NVB0ETXpq2g9fLycpSXm8weHVEN2hbV1dUoLTWZLQIDAz0igxl3psAbGfDjBdPmilYYZnqJFKDz5bbXEQThHsTBzwEyFQaE2p/UoW9nFWjA1P4i7ZtTSPvmlEdbYZACRHgtH374IebNm4fjx49bvVZeXo45c+aAMYahQ4ciMTGxw+XTarVYsmQJGGNITk5Gnz72BQ26Gl9KgTcjbtNR3gCUeVdvWYLo1Ijjf4ZF9oZMYl/CEGPMhgXIdg0gwNQK4/sbY/H9jbEQPNgKg1xghNtoKQDOVsd3M927d8fy5csBmBSMVatWYdWqVUhMTMTAgQMRGBiIwsJC7N+/H3V1dYiMjMTq1avtlu3KlSsYOXJki68///zzmDp1qmX8zTffIDc31zIuLS3FkSNHUFBQAH9/f6xevdqjAX+M+VYRRDMJwYBSCmiaBW+fLyf3MUF0BHqjAQdKznJzIyPtf5AzVlTDWF3LzdnqAm9GUMjx9W2m1+dTKwyiM9HYaCrmEhBg268rDlJuzqBBgywK0P3334+EhARs2rQJBw8exL59+1BeXo6AgACkpaXh+uuvx6OPPoqIiIgWz9cSWq221Qa55jYcZo4dO4Zjx45ZxkqlEgkJCZg/fz6eeuop9OzZ024ZXElpPVCt4ed8wQIklZjS4ZsHQp8vB0Z6d/kQgugUnKjIQZ2eL75lb/o7YB0ADakUsm7Rthd7EaQAES4nOzsbgHVNH3sLUQYHB+O2227Dbbfd5jLZkpKS7JJj2bJlVunv3og4eFgptW426mpqdA3YWXgCF6ryYWRG9AiOw1WxA6BW2BcL1UuUCi+2ZBEE4R7E7q9ewfGIUIXYfR6rFPiEaAjyltULxhgUf5h9qRUG0WlgjOG9994DAFx99dWeFaYLIU6B7xFqsq64A8YYvs7ZhVVnf7J6enz39LeY3eta3NljAqTt7CIttlRRIDRBdAwHSs5xY0eyvwBAl3OZG7cWAA2YWmH86+HDpv1rPdcKgxQgwiWUlpZi8eLFOHHiBE6cOIGgoCA8+eSTnharyyC2APVwo/trxYn/4Zcre22+1mjQ4p9nNuJUxUW8lH5fu3oJiQOhSQEiCPdToamxSn8fHulYw2m9OADaB2oAAZQFRriI2tpafP7557h8+TJuuukm/Pbbb0hJSfG0WF0Gd/cA85MBmQuABeO/wZYC28pPc3YVncTLxz5rl3lbbAEqrqOeYAThbg6V8n0U/aQK9At1LJtW7AJrywLkFxiMmKzvEZP1PfwCgx26pisgCxDhEpKSkmA0GtteSLgFKxeYiy1AggDsLj6EHy7vhDjZbXRUGuQSKX4rPAkjmhSeXwuOor86CTNSrmr13ElqQCYB9M3+fM6XA0NbzqIlCMJJDpTy7q/B4T0hlzimEli5wNqwAEkkEgQEqx26lishBYggfJx6HVDAZ6C63AJU1FCBN098zc3JJVIsT5+NsTH9AQCHS8/j2QOr0WBoSkd7P/M7ZET0QkpwbIvnVkhNSlBzK9YFUoAIwm0wxnBQFP8zLCLVoXMZ6xpgKOafwGRtWIC8BXKBEYSPI+4ADwDJLlaA3j7xPS4WTEdZ8SwwZiqS9uzAWRblBwDSI3phWfq93HEGZsSbJ79u0xVGcUAE0XHk1RWjuLGSmxsa6ZgCpLtYYDUnT2z96UXT0IDvHluM7x5bDE1DQ6tr3QkpQATh4+RW8uO4QNf16gKA4+U52Fl4GnU1w1FXMxyMSTE5PgOTu2VYrR0dnYa7ekzg5o6VZ2NrwZFWr0EKEEF0HOLsrwhlMJICHavbI26BIY2JgMS/9awuvU6Dfp8fRr/PD0Ov07S61p2QAuQiPFnLgOi8tOfvKkeUAZakdu31P8z8npsLlvvh8X63tHjM3NQpiPHjTVD/PrcJBtZyjJg4EJpqARGE+zgoiv8ZGpnqcCV7e5qgmhGkUmy+Nhqbr42GILWv7YYrIQXISaR//OfpdJ5r6EZ0Xsx/V9JWbhJiC1Cy2nXXP1qehZMVudzcPT0nIkjRcq8KlVSBR9Nu5uYu15Vga37LViCxBSi/BqjT2i0uQRBtoDcacKTsAjc31MH4H8C6CnRrPcDMCEoFPrurOz67qzsEpcLhazsLKUBOIpfLoVQqUVVVRVYgwqUwxlBVVQWlUgm5vOV+OeIYoCQXxv98lrXNau7G7i33UDMzLmYAUkP4fhafXNgCYwtWoJRQQCJ6ABU3dyUIwnlOV+ahXs+7nZxTgOxLgfcmKAvMBURERCA/Px+XL19GSEgI5HK5RxtjEr4NYww6nQ5VVVWora1FfHzrNxSxApSido0cOTWFVqXyAbQrVVYQBMzpNRl/PtjUqPZibTEOlZ7HMBvF1lQyoHswkFvVNHe+HBjo/e2ECMKnOChqfpoSFItwleO1eMQp8LIUUoC6FMHBpj+e0tJS5Ofnt7GaINqHUqlEfHy85e/LFtUaoEyUROGqGKDv8/Y4dfzY6H5ICoxGbm2RZW597i6bChAA9AoXKUBlTl2eIAgbiOv/DHMw+wsAmE4P/eVibq49FiBjfQPWzD1g2s9qAIKVDsvgDKQAuYjg4GAEBwdDp9PBYDB4WhzCx5FKpa26vcyI438kAtDd/l6GVmgMOmy6fMipcwiCgFuTxuLNk031g3YXnUZBfRni/MOt1vcMBbY0G1MmGEG4llpdAzIr87g5R+v/AID+UiEg+r0jF1gXRi6Xt+uHiyBcgdj9FR9kKizoLL8VnkS1rt4yFgQtNt5dhlj/cPjZcdeY0m0o/nlmo6VpKgPDpssHMTd1itXaXiKdiGKACMK1HC3L4rIx5RIpBoX3cPh84gwwiToI0tC23Wl+gcFQH/vcsu8pKAiaIHwYd2WAbby0jxtnRPRC/4hwhPvDqhVGa/jLlJgcz9cL2nT5oM2EgRRR8HZeFaAlYypBuIwjZVncuJ86CSqp41lY1hlg7bP+SCQShMd1Q3hcN0gknlNDSAEiCB9GbAFyRQXoooYKqzohN3Yf7vD5pnQbyo3z68twqvKi1TqxAmRgwMUqq2UEQTiIOP09PaKnU+dzJAXemyAFiCB8GHERRFdYgLYVHOPGgXI/jIwciOe2Ac9tAzR6+86Xpu6ObgGR3NxmG/FFIUogwo+fyyY3GEG4hGptHS5U8ynrQ8KdVIBELjBZcrcWVvJoGhrwwzPP4IdnnqFWGARBOIZVDSC18+fcduUoNx4fMwBSQY7/HAf+c9xkmbEHQRAwReQG21pwBDqjtSYl7mJPChBBuIaj5dlgaPryKiQypKkTnTqnoxYgvU6Dvqt/R9/Vv1MrDIIg7KeiAagS3TuctQAV1pfjtChLZELsYOdOClj1DavW1eNw6XmrdWI3GAVCE4RrOFLKu78GhCVDIXU8D4oZjdBfdKwIoiCVYsdVEdhxVQS1wiAIwn7E1h+ZBOjmZELF9ivHuXGw3B8ZEb2cOymAOP9w9BM9be4sPGG1jhQggnAPh0XxP866vwxFZWCNfL8aeXI7FSClAh/PTcbHc5OpFQZBEPYjzgBLCDYpQc4gdn+Ni+kPmcQ1T2jjYgZw411Fp6wapPZQ88eQC4wgnKdSW4vsmivcnNPxP9l8BWjBTwlptHV9L2+GFCCC8FGsMsDUzp2vtLHaLe4vM1eJFKByTQ1OVfDZYOIYoMpGoNxzMZIE0Sk4Kkp/V0kV6KtOcOqc4h5gssQ4CB5MaXcEKoRIED6KqxWgvcWnuXGATOV0mmxzEgIjkRwUg5yaQsvcb4UnMDAs2TLuFgzIJYCumWEoqwIIE2WHEQTRfqzif0KT2tXTrzUcrQEEmFph/HO+KRPUmOm5Vhi+pa4RBGHB1Rlge0SNT4dF9nb6JilGbAXaWXiCK4ookwCJav6YLGqJQRBOcaSctwANccGDjTgFvr3xP2aUWiOUWmPbC90IWYAIwgdhzLVVoLUGPQ6IukSPjkqz7KtkwK65TfuOMi5mANaeb+r4VVBfhkt1JegeGGWZ6xEKXGim9GRXOn49gujqVGhqOKsrAKQ7Gf8DAHonLECqgECodv3Lsu8pSAEiCB+ktB6o5RMwkOREFehj5VloMDSdUICAkVF9LGOJYAqydpbU4HiEKYNQrqmxzO0vOWOlADWHAqEJwnHE8T9+UiV6hzgX/8MYs7YA2VEFWiqVIb53X6dkcAXkAiMIH0Rs/VFKgTgnHqR+L+Ljf/qoExCqDHL8hC0gCAJGRPbh5vYWn+HG4lR4UoAIwnHE6e8Dw5Kdzuw0VlTDWF3LzcnbWQXamyAFiCB8EHH8T/cQQOrEt3lfCa+ENHd/AaampC//ZtqcbVA6Mop/8jtSdgGaZtYnsQJ0sQrQUVNUgnAIcQNUZ9PfAesAaEilkHWLbvfxWk0jfnjpBfzw0gvQahqdlsdRSAEiCB/ElRlgRQ0VuFRXws2NiOKtNHoj8K/Dpk3vZNzi0IhekKCppbzWqMfRsmzLWOwC0xuBvGrnrkkQXZEKTS0u1hZxc0PCezh9XqsU+IRoCPL2R9ToNI3o+9429H1vG3SkABEEYQ+uzAA7JGpJEST3Q2qI+8zZwYoApIXyVaH3lTRloKlVQDg1RSUIpzlRns2N/aQKl3y39VbxP/ZlgAkSKfaMDMOekWEQXFRo1RFIASIIH8SVGWAHS89x4/TwXpAK7r01iOOADpTwMlBLDIJwnmPlOdy4X2iSSyq763L4KtD2psALKgX+Ob8H/jm/BwQVtcIgCKKd2EqBd9QCxBizsgC5ovdXWwyL7M2Nc2uLuMwwKwWIagERhN0cF1mAmhcddQaxC8xeC5C3QAoQQfgYRXVAg56fEysM7SWnppBTPABgaESqg5K1n94h3eAv46u/Hm5WrZZS4QnCOer1Gpyv5l1VA8NSXHJu6yrQ7U+B9yZIASIIH0Mc/+MnA6IDHDuX2PoT7ReKbgERjp3MDmQSqdXN+EhZkyxWClCl20UiiE7F6YqLXLNhqSBBP1HsnSMY6xpgKCrj5mR2psAb6xvwj0eP4B+PHoGx3nPN/kgBIggfI0dkDUlSA4Jgc2mbiON/MiJ6QXD0ZHaSEc672g43S9cVW7TKG4AKaopKEO3mmMj91TukG1RS5+NtdBcLrObkifZbgIJr9Qiu1be90I1QJWiC8DFclQGmNxqsaoQMbSH+RyUDttzTtO8KxP2ILteVoLihElF+aiQEm/qC6UVNUYdSU1SCaBfW8T+ucX+JW2BIo8Mh8VfZdQ5VQCCEn9+07HsKsgARhI/hqgyw89X5aDBouLn0cNsKkEQAUsNNm8RFBqKewXEIlPMajblqrVwKJIbw6ykOiCDah86ox6mKi9zcIFfF/1g1QbU/rV4qlSElYxhSMoZBKvWcHYYUIILwMVxVBPFYGf+EmBgYhXCVCxp+tROpIMHgML4o25EyCoQmCGc5V3UZGqOOmxvgsgywzhEADZACRBA+hZEBeVX8nMMKUDnv/mrNRK41AG/tNW3OtsJoTobIDXa4WVA21QIiCMcQx/8kB8UgROFgpoQIV6TAazWN+PHvr+LHv79KrTAIgmgfBTWARqSAOBIDZGRGHBcVSWvNRK43Am/vM23OtsJojrgvUWFDBYoaTJoOKUAE4Rji77ar4n8A6yKIshT7FSCdphG9//Yjev/tR2qFQRBE+xBngAUqgAh/+8+TW1OEal09NzfYBT2C7CU5KAZBojigE3/cvMUKUF6Va5UvguiMmB5ueAvQIBe5v5hOD/3lYm7OEQuQIJHi8BA1Dg9RUysMgiDah60MMEey1sUm8mi/UET7OVhN0QkkggT9Q/mbs1kBEscA6YzAZWqKShCtkltThBodXzPCZRlglwoBA2+CdkgBUinwj8d64R+P9aJWGARBtA9XZYCJFSBXZYg4woCwJG58vMKkAIX5mRqjNofcYATROubvjxlXPtyIA6Al6iBIQzsuccLVkAJEED6EKzLAGGM4Jqr/40kFaGAof+3s6iuo05niAsRuMMoEI4jWOV7mnv5fgI0UeB/tAWaGCiEShA/hCgvQlfpylGp4X9KgcM8pQH3U3SATpNAzk2ndCIZTlRcxPLI3UtTA4StNa8UxUARB8LjTuuuqFHhjfSNWPHXMtH9VIxCsbOMI90AWIILwEfRGIE8UA+NIBthRUfq7WhGI7gFRjgvmJEqpAr1D+GJqLQVCZ1V2kFAE4YMUNVSguLGSm3NpBpgoBV7msAWIIaJMi4gyLQDmtFyOQhYggvARLldbZ0E5YgGylSHSVv8vpRT4bmbTvqsZEJaMU5VNlWtPVNhWgMgFRhAtI67+HCj3Q2Kg6x5uxCnw8mTHFCClfwB0Xy+37HsKUoAIwkcQx/+EKIFQB3pjnSjP5cbteUKUSoBBMfZfq70MCEvGF9nbLePTFRehNxqQoua1reI6oEYDBHnGYk4QXs3Jilxu3F+dCIngGkcPMxqhv+h8EUQAkMnk6HPVBFeI5RTkAiMIH8EV8T/V2jrk1fF1PFxVIt8ZBoQmceMGgxZZ1QVIVANi25T4cyAIwoRYAeon+l45g6GoDKxRy805agHyFkgBIggfwSoDzIHM1tOVedxYIZGhZ3DbgYxaA7DykGlzZSsMM6HKICQERHJzJypyoJIB3URZtpQKTxDWaAxanK/ig5T7i0pMOIMum3d/CX5KSKPDHTqXVqvBpvffxqb334ZWq2n7ADfhEwrQ+++/j6SkJKhUKowYMQL79+9vdX1lZSUWLlyI2NhYKJVKpKam4scff+wgaQnCPbjCAiR+QuwdkgC5pG1PuN4IvLrLtLmrGrPYEmV21VEcEEG0zdmqy5ZMSgCQQECaurvLzm8VAJ0YB0HimAqha2xAz2Vfo+eyr6FrbGj7ADfh9QrQl19+iSVLluDFF1/E4cOHMWjQIEyZMgXFxcU212u1Wlx77bXIzc3FV199hbNnz2LVqlWIj/dtUx1B2KoCbS+nRUGS/UITHZbH1YjdYOagaLECJP4cCIKwfrhJCY6Fv0xle7EDWAVAO1EDSBAkOJkWjJNpwRBcFKPkCF4fBP3mm2/ioYcewty5cwEAK1euxMaNG7F69Wo8++yzVutXr16N8vJy/P7775DL5QCApKSkjhSZIFyO1mDdBsJeC5CRGa1cYP1dGCPgLGlqXhkraqhAWWM1UtS8D4xcYARhzUlRcoMr438AG0UQU7q1sLJtBD8lVvypNwBgsp/nMhq82gKk1Wpx6NAhTJo0yTInkUgwadIk7Nmzx+Yx3333HUaNGoWFCxciOjoa/fv3xyuvvAKDoeXABY1Gg+rqam4jCG8irwowispl2GsBulhbjDo933nZmyxAiUHR8JPyN8PMyjybFiDmudIhBOF1MMa4MhKA6x9uXJUC7014tQJUWloKg8GA6Ohobj46OhqFhYU2j8nOzsZXX30Fg8GAH3/8Ec8//zzeeOMN/PWvf23xOq+++ipCQkIsW0JCgkvfB0E4izj+J8LP/uKpYhN5tF8oIlQhTsnlSqSCBH3V/HfvdGWeVVPUeh1QWNuBghGEl3Olvhzlmhpurr8LH24YY9YWoGTHLUDeglcrQI5gNBoRFRWFf/3rX8jIyMDMmTPxl7/8BStXrmzxmKVLl6KqqsqyXbp0qQMlJoi2cUX8zylxiqzae6w/ZvqKgjYzK/MQHQj4iZz12ZUdJxNBeDsnRA1Q1YpAxPtHuOz8htJKsNp6bs4ZC5CxvhEv/+UEXv7LCRjrG9s+wE14dQxQREQEpFIpioqKuPmioiLExNiuyhYbGwu5XA6ptKmAWt++fVFYWAitVguFQmF1jFKphFJJldUI78UVGWDiKrHe5P4yI85ayazMA2BEcqgEp0ua5rMrgDFkqCUIANbf7f6hiW1Wd7cHvcj9BbkMsnhnKkwzxBc0WvY9hVdbgBQKBTIyMrB161bLnNFoxNatWzFq1Cibx4wZMwYXLlyA0diUq3vu3DnExsbaVH4Iwhdw1gJUo2tAbi3/IGGPAqSUAl/cZtrc0QrDjNgCVKdvxKW6Eis3GKXCE0QTVhWg3R0AnRgHQer4jUDpH4C6tc+gbu0zHm2F4dUKEAAsWbIEq1atwtq1a5GZmYlHHnkEdXV1lqyw++67D0uXLrWsf+SRR1BeXo7Fixfj3Llz2LhxI1555RUsXLjQU2+BIJzGygJkZxHETFH2l1wiRa/g9vvwpRJgVDfTJnXjXSPST41IUVzS6Yo8K4sXKUAEYaJer0FWNV+jx/UZYK4NgJbJ5Bh4w40YeMONkMnkTp3LKTk8duV2MnPmTJSUlOCFF15AYWEhBg8ejJ9//tkSGJ2XlwdJs2JMCQkJ2LRpE5544gkMHDgQ8fHxWLx4MZ555hlPvQWCcIpGPZDPxzfabQESx/+kBneDQuqdX/++6u4oKTxhGZ+uvIiU0GHcGooBIggTmZV5MDZzI0kFCfqoXesf7owB0IAPKEAAsGjRIixatMjma9u3b7eaGzVqFPbu3etmqQiiY7hYaT2XZGfylnX8T5Jdx+sMwGcnTft39QfkbnSDpam7Y2czBSizMg/XpvJrLlcDGj2g9Ik7GEG4D/HDTa/geKikrg33sFaAnLMA6bQa7PhsDQBg/F1zIFd4JgaXbh8E4eWI43+iA4AAO+5vRma0USPEvgBonRF4Ybtpf0aaexUgcRzQheoCxAdrATS9aSMDLlYBqY61IiKITsMJN8f/ALZcYM5ZgLSNDUj+06em/VtnekwB8voYIILo6lg1QVXbd/yluhLU6vh+O2lemAFmpo86AUKzHvAGZkRBQz4i/fl1FAdEdHWMzGijvU2SS69hqKiGsZL3wTtrARIECc73DMT5noHUCoMgiJZxtgv8SdENMlIVgmg/B1rJdxD+MhWSg6KRXdNU7DSzMg89QpNR0qwUCSlARFfnUl0JqnV8fZ4BLuwAD1hbfyCVQpZguwxNexH8lHj5L30BAOOpFQZBEC2RI/qhtzcA+rTIRC7uueWNiN1gp220xCAFiOjqiPt/RapCEKVSu/Qa4vgfWUIMBHnnsJ2QAkQQXo7YApSitu94sQXImxqgtoRYSTNlgvFrsio7Th6C8EbE5S36hSa5tAAi0Dl7gJnpHGocQXRSarXg3D6AfRagen0jcmr4vnneHP9jRmwBulJfjphujQBUljmxZYwguhqZVXzbJnEvPVfgjhR41qDBCy+dMu2P1wBBlAVGEIQIsfVHAJBoRwr86co8sGY1QmSCFL1DvL+GR3JQDBQSGbRGvWWOSa8ASLaMKxqBigYg1M8DAhKEh9EYdFYFEPuGdG9hteNYKUApLlCAmBEpufWWfU/hEgVIq9UiMzMTJSUlqKyshFqtRmRkJPr27UvtJwjCCcQVoOOD7at9I84Q6RUSD6XU/sqrCimw+qamfXcjk0jRIziOM/FXGHIgkyRD3+x+mVUBDCUFiOiCXKjOh6GZ8iBAQG+16x9u3OECU6j8UPG+qbZfd5XnvsAOK0AlJSVYs2YNNm7ciP3790Oj0VitUSqVGD58OG688UbMnj0bkZGRTglLEF0NcaCvvSnw4vgfRzvAyyTAxOS217mS3iHdOAXoQs0lJIaYlB4zOZXA0LiOlYsgvIHMSt79lRgYBX+ZqoXVjmGoroWxtJKbc4UFSK5QYugdM50+j7PYrQBduHABzz//PDZs2ACtVgvA1LU9IyMDYWFhCA4ORlVVFSoqKnDmzBns3LkTO3fuxHPPPYdbb70Vy5cvR8+ePV3+RgiiM+JMF3jGmNtrhLgTsavubNUlpITyChBlghFdFXEAdB+1691fepH7CxIJ5E6mwHsTdilAixYtwqpVq2AwGDBhwgTcdddduPrqq5Gc3PKjYXZ2NrZt24bPPvsM69atw9dff4158+bh3XffdVp4gujsOFME8XJdKap0ddycPR3gm6MzAN+cNe1P7+3eStBmeofwAZ1X6suRJqoInUUKENFFOVPZ8QHQsm7REJTOh7XodFrs/uZLAMCY6TMhl3smVMYuBWj16tV45JFH8PTTTyMurn1255SUFKSkpOCBBx5Afn4+/va3v+Gjjz4iBYgg2oEzRRDF7S/ClEGIcbAAos4IPLXFtD+1V8coQLYCoVXKcgBNT6BkASK6IrW6BuTVFXNz4sxJV+CuFHhtQz0SFvzLtD9lmm8oQNnZ2YiJcdz8FR8fj3feeQdLly51+BwE0VWoaAAqG/k5eyxA4iaJ/dSJLq8R4k5sBULrJflorgBdrAIMRkBKFc2ILsQZUfq7TJCiR5Drg+Fc3QTVjCBIkJdgCn6O9ZVWGM4oP+44D0F0ZsTWH5kE6Bbc/uOd7QDvDYgDoSsNFwBkWMZaA5BfA3S3ozQAQfg6YvdXz+A4KKSur2rjjhpAgKkVxgvL+wMANvtqK4xz5865Sg6CIESIFaDuwSYlqD006DXIrrnCzTka/+NJxIHQF+vOI1h0v6Q4IKKrcUYUAO0O9xfQuatAA04qQGPGjMG+fftcJQtBEM1wJv7nTOUlrkaIVJCgjxuCJN2NWObCxnIkhhi4OYoDIroa4hR4d3y3jXUNMBSVcXOusgB5C04pQHV1dZg4cSJ++OGHNtf+/vvvzlyKILoczjRBPVmZy417BsdBJfW9oqRJgaZA6OaE+tdyY1KAiK5EWWM1ihsruTm3BEDn5lvNyRJdE2fEGjR49rUzePa1M2AN1jUEOwqnFKCtW7fCz88Pt956K/7973/bXHP8+HFMmzYNV111lTOXIoguhzMp8FbxPz7QAd4W5kDo5igUJdyYFCCiKyEOgPaTKtE9MMrl1xHH/0jjoiBxUbwOY0b0OVuDPmdrfLcVxqhRo/D777/j+uuvx7x583D58mW8+OKLAICsrCw8//zzWLduHYxGIxISfM/8ThCegjHHiyAyxlweAK2QAh/c0LTfkfQJSeACobXCJQBNxVSzKztWHoLwJOICiL1DukHqhkwqXbb74n8UKj+U/P1+AD7aCsNMr169sGfPHkybNg3Lly9HXl4eZDIZ1qxZA51Oh/j4eCxduhQPPfSQK+QliC5BcT1Qp+Pn2qsAFdSXoVLLu4n6O6kAySSm+j+eQBwIXWE4D2CCZVxYC9RpgQDf8/ARhN1YV4B2j3HBnQHQcoUSI+fMddn5HMUleXORkZFYv349Bg8ejDVr1gAwpbo/++yzmDdvHpRKz6W5EYQvIrb+KKVAbFD7jj0pqv8TqghErH+YS+TyBOIGjxWGLAhgYGiqaZRTCfR3vReAILwKxphVCnya2zLA3JMC7004bTerqanB8uXL0b9/f5SWlkIQBDDGkJ6ejoceeoiUH4JwAHFcS5IakLSzhqEt95ezBRD1RmDjedOm72CXvTgQWiLRISJAz62hOCCiK3ClvhzVunpuzh09wAD3FUEETK0wvv3feuzeuB46ndZl57UXpxSgV155BcnJyXjppZeg0Wjwpz/9CZcvX8bMmTOxceNGXHPNNSgrK2v7RARBcDjTBFVsAXJF/R+tAVjwo2nTGtpe70pkEil6igKhQ/yquTEpQERX4LTI/RWiCHC4vU1rGBs0MBTwrTZcaQHafaEe/Re8hZg5b6Gxrr7tA9yEUwrQc889h5qaGsyfPx8XLlzA66+/jpiYGHz++edYsmQJ9u7di9GjRyMnJ8dV8hJEl8DRDLDOUgBRjLgxqlTO35wpEJroCpypsi6A6I72NvqLBVZz8iTXpMAfKQQe3yygMEqJwigl/vyr0OEPVWacigG66667sHz5cqSkpFi9tmLFCiQkJGDJkiUYPXo0vv/+ewwdOtSZyxFEl0GsALW3BtCZKhsFEEN8PwNTHAjdiFwAfS1jsgARXQGrDvBu+m6LA6ClUWGQBPo7fd5L1cDcb4FKQYVnXx9omstWIf0EMHew06e3G6cUoE8//bTV1xcvXoy4uDjce++9uOaaa1BdXd3qeoIgACMDLlbycynttHKL4396BMfBT+b7cXjiQOh68O8zu8JUOsCHer0ShF3ojQacreIVk46L/3He/dWgA+b9AFQ08t/T63oA9w10+vQO4fY2rDNmzMDmzZshk7m+URtBdEYKagCNyCTcXguQrQ7wnQFxILRc5AKr0wHFdR0tFUF0HBdri9Bo4AOG+/pQCvxz24DTJdbzr08CpB5qCN8hWslVV12F3bt3d8SlCMLnEbfACJADke2wPjPGcNIqA6xzKEDmitDmGihSWRXkEgN0xqaqjNmVQHSghwQkCDcjdn/F+IUiVNnO2hh24moL0KYs4KvMZufTa/HEW6Zm6vKrtYCHssXt0rtOnTrl8IX69m3y1ztzHoLo7FwQKUA9Qtvn2nFHAURvIrVZHJAgMASqqrjXKQ6I6MxYF0B0j/sLcG0V6IoG4C+/8nPBMgMGHa/CoONVYEYPRUDDTgVo4MCBuPPOO3H8+HGHLnbkyBHccccdGDRokEPHE0RXIEusALWzhqE4/ketCEScf7hLZJJLgBXXmja5h8zV4kBoQV7IjcWfG0F0JjJFPcDcldxgbNRAf7mIm5P3cPxa//cbUCLKdH/2aj9cWTYTV5bNhELpI60wXnzxRaxYsQLr1q3DgAEDcOedd2L8+PEYMmSIzYKHjY2NOHLkCLZv347PPvsMp0+fRkBAgKVfGEEQ1mSV8+Me7Q6AzuXG/UITXZYiK5cCM9JcciqHEStAeiEfQJNQYtchQXQWNAYdsqr51HR3VYDW5xaYMgqaIU9xzAV2+ArwdSY/NzEZuH2AEsLARY6K6DLsUoBeeOEFPPzww3j55ZfxySefYOnSpRAEATKZDAkJCQgNDUVQUBBqampQXl6OS5cuwWAwgDGGkJAQLF68GEuXLkVkZKS73g9B+DzimjbtVYCOV/D1tjpL/I+Z5KAYyCVS6P4wmcsVolpApAARnZQL1QVceQsBglVmpKvQZvGWJml0uEMp8EYGLN/JzwUpgFev8Z5sTbuDoKOiovDOO+/gtddew7p16/DDDz9g165dyM7OtlobExODcePGYerUqbjjjjugUqlcIjRBdFZqtabmns1pjwJUo2tAVjVfAHFgqHV9LkfRG4Edf3jYxieamqN2NHKJDClBsZZUYJmcTym5VG2qUt3R3eoJwt2I43+6B0bBX+ae31NdNq8AOer++uasqehhcx4bYUpU0Om0OPL7NgDAkNETIJd7ppOxw1lgfn5+mD17NmbPng0AKCkpQXFxMaqqqhASEoKoqCiy9BA+jc6ox/6SszhRngOtUY+kwGiMjemPMDdlXgDWVgyJACSq2z7uVEUuGJrM1nKJ1KVdorUG4P7vTPuZCzyjAAGmQGizAiROhTcw4GIV0Mt3+74ShE2sCiC6MwBaZAFyxP3VqAdeFyV+J6uBOX+E/2ob6hF++19N+1kjfE8BAoD9+/dj+PDhAEwd4UnhIToLB0vP4e/H/4eCer6X3TunNuDOHhMwp9dkyCSuNzWIM8ASggFVO76lx8p5C2xfdXcopXIXSuYd9A7phu//2JdIGyGX1UGnD7C8nlNBChDR+bBugeG+6u66LFEGmAMWoM9OWFuynx/X3DoroEJtuj/FwHP+MKee40aOHImpU6di//79rpKHIDzOD3l78eTef1opPwCgNeqx9vwWPLnvX6jXa1x+bUcDoI+LFKCBYa5zf3kT4p5gEhlvY6c4IKKzUatrwMVa3trpzvY2YheYwk4FqEEHfHCQnxvdDbgmuWks8VfhibcG44m3BkPi77nQGKcUoDfeeAPHjh3DqFGjcMMNN2Dfvn021z3++OOYOHGiM5ciiA5hd9Ep/O34/2AEa3Xd4bLzWHpgNfQurmHhSAq8xqCzihEYGJrcwmrfJjkoBlKh6bYljgOiVHiisyFufyETpOgZ7HxlZlsYa+pgKOafwuy1AP3nhHXa+5OjvCfwuTlOKUBPPPEEsrKy8OKLL2L79u0YPXo0rrvuOvz66684d+4csrKysHnzZnz11VfYu3evq2QmCLdQ0lCJvx75LxdLA5jcLuNjBnA/vIBJCfrnmY0ulUFswWiPBehM5SVLZhRgyhDpH9Y5FSClVI6UoFjLmDLBiM7OGdHDTc/gOCik7mniIC6ACIkE8sT2d4Gv0wIrRdaf8YnAUNc0knc5Tn2KWVlZmDVrFg4fPgz2R92AzZs3Y8uWLdw6xhjmzp3rzKUIwq0wxrDixFeo1Tdy83f1mICH+9wIQRBwuuIint7/Eap0TU2nvsjejsHhPTAmup/TMhiM1l3g26MAieN/egTHIkjuueJi7iY1JB7nq02l+sUWIPHnRxC+jnUFaPe5v7Qi95csIRqCsv0Byp8cB8oa+LklI63XsUYtFr5/wbR/tRYI9EwrDKcUoMWLF+PQoUPIyMjAddddB7VaDQCoqqrChx9+iLKyMiiVSrzxxht46KGHXCEvQbiFXUWn8HvxaW7umrjBFuUHANJCE/G34Q9i0Z73OIvLmye+xpDwnvB3suv65T/SuJvTHgXoRBeJ/zHTOyQBGy+Z4g7FmWBlDUBVIxBCFTeITkKmRzPA2q9sNeqBVYf5uYnJwOAY67XMaMCwgxWWfU/hlAK0Z88eDBgwAPv27YNEwrsHnnzySTz33HP48MMP8d5772HmzJkID3dNWX6CcCVGZsRHZ3/k5sKUQXiy/21WlZTTQhPxWL9b8MaJryxzxY2V+PjcJixMu8kpOcQZYGoVENaGIcfAjDghqgA9yA0KkFwCLL+6ad+TpIY0xT/I5GUADACaMvKyKoD0WOvjCMLXKGusRnFjJTfnrSnwX522tv48McL2WoXSD5f/ZLpfdvdgKwynbmUGgwF9+/a1Un4AICQkBO+++y6++OILnD17Fg8//LAzlyIIt/FrwTFk1/DZRIvSbkKwIsDm+pu7j0J6eC9u7uvc33Clvtzm+vZiFQDdjiao2dVXUCdy27nDAiSXArMHmTa5hwsN9gyOs8RjCYLxDyWoCXKDEZ2FM6L+X35SBboHRrnteuIYoPZmgBmMwL9E1p+rugMDom2vlyuVGP/0nzD+6T9B7qFO8ICTCtDw4cOxc+dO1NXVtbjm9ttvx8SJE7F161ZnLkUQboExhk8v/MLNpQTFYGLckBaPEQQBTw24HfJmdYB0RgNWn9vklCyOpMAfLcvixvH+4YhQBTslh7ejlCqQGNh0Z6VMMKKzIo7/SQ3pZpWM4SoYY9YWoHYqQD9dMBUhbc78DFdJ5j6czgIrLCzE1KlTkZub2+I6qVSKhoaGFl8nCE9xtDwLWTV8C4kHUq+DpI2bTEJgJG7uPpqb23z5IHJEliR7sMoAa0cK/KGy89x4UHgPh6/fGgYjsOeyaTMY217vblKbNUYVxwFRJhjRWejICtDG8ioYq/jqhe2JAWIMWHmInxsQBYxp5VC9QY9jB3fh2MFd0Bv0jojrEpxSgK6//nosWLAAO3fuRFpaGhYuXIgtW7ZYLEJarRYffPABtmzZguTkzpmWS/g2X+fs4sbd/CMwNqZ/u469r9ck+EmbMiSMYFhzfrPDsogtFz3bsADpjQYrC1CGyDXnKjQGYNbXpk3juZhFC807w8sVvAWIFCCiM8AYs7IAdWT8D+QyyBJa8GE1Y/cl4AT/DIJHhrbuvtfU1SLw+qUIvH4pNHW1LS90M07b0t577z0sX74cAPDhhx/iuuuuQ3BwMEJCQhAYGIhHH30URqMR8+fPd1pYgnAlpY3V2FV0kpu7NWlsm9YfM6HKINyRMp6b215wzGYF6baoaLAOIExpQwE6W3XJKv4nPcI9CpC30dwCJHaB5VaaOlEThC9zpb4c1Tq+oqBbU+DF7q/keAjStgP+/imy/iSGANe1wxBd7ydFvZ9nAwpd4kx87rnncPHiRaxYsQKTJ09GREQEampqYDAYkJKSgrfeeguLFy92xaUIwmVsLTgCA2vy5/hJFbg+YZhd55iZPN7KCvRl9g67ZRFbf+QSUx+w1jhUyru/kgKjO338j5lewXEQ/ughJHaBaQxAfo0npCII15Ep6v8VoghArJ/7Gt2JA6Db4/46Vwbs5MXEvHRA2oZmIfH3w4IP0rHgg3RI/H00C6w5kZGRWLJkCX766ScUFRVBo9FAo9Hg/PnzpPwQXsmWfP7RZXzsQATaWUAwSOGPG7vzlb5+vLQfVdqWEwNsIVaAEtVtZ1uJFaCMLmL9AQA/mdKSDSOR1kCQ8OYzcoMRvo5V/E9IglVZDldiHQDddgr82mP8OMwPuD3NlVK5F7dV9JDL5ZDJ3FOumyCcJbemyKrHzuR4x9IWZqaM5zIzGg1abMjdbdc5zom8Zm3F/2gMWpwU1f/JiEi165q+jjkOSBAAuZzigIjOhXUFaPfF/wD2N0Gt0gBfZ/Jzd/YHVD70s+/hkmYE4RnE1p8wZZDD8TPRfqG4Jm4wN7c+dxc0Bl27z3FelAKf2kbN0BPludAam7InJBAw2E0ZYN5K71bigEgBInwZAzPinOgBzZ0B0MxohC4nn5trywX2v1NAQ7MELqkA3DugndfTaPHgR9l48KNsMI3WXnFdBilARJeDMYZfCo5wc5Pi0p2qr3FXjwncuEJbi62ia7SG2ALUlgJ0sPQcN+6tTujU/b9sQanwRGflYk0RGgy8YtDXjQHQhsJSsHo+oaK1GkAGI7D2OD93XU8gNqh912MGA8buLsPY3WVgBh9thUEQvkh2zRWrTK1r49OdOmfP4Hikh/fC4WZ1eb7K+Q3XdxvWpt++WgNcEWWCprYR67iv5Aw3dnf8j0wCLB3btO8NcC0xqCs80YkQu7+i/UIRqmynduEA4gwwwd8P0uiWn8K25wJ5osKHcwe1/3pyhRJ5i64FACQoPFcJmhQgosuxu+gUN47xC+XcKY4yI3kcpwCdr87HsfLsNl1TYveXTAIktxIDVNxQiQvVBdzciMg+dstrDwop8LCXVXb1l6mQEBCJS3UlVjFABbVAgw7wk3tIOIJwgsyqjiuACNjKAOvW6oPbGlHwc1okMDSu/ddTqPww4cUX7BHRLXjJsxxBdBy7CvnaP2Oi+7kku2JUdBri/fmnpv/l7GzzOLH7K0ltUjhaYm8xH3kYKPdD/9CkdkrZuTArrjJ5qdVr1BOM8FXOiAOgQ9zn/gJsZYC1fL0L5dap73MGtd230BshBYjoUpQ2Vlk9XY2Nbl/l57aQChLcljSOm9tVeLLNwohW8T9tuL/2FJ/mxsMje0MmcW9BMYMROFZo2ryhFYaZ3n/8MEgkWkhlvN+L3GCEL6Ix6KwsvO6M/wGsFaDWMsDEqe+hKuDm3vZdT2/QI/PMUWSeOeq7rTAIwtf4vYhXHgJkKgwKd1339BsShsNf1uTTNoJhfe6uVo6wLwBaY9DhoKj+z+go9xfe0BiAm740bd7QCsNM8zggcSA0NUUlfJEL1QVcgVYBgkXRdxdWLrAWagBVuyj1XVNXC8W4R6EY96hvt8LoKN5//30kJSVBpVJhxIgR2L9/f7uO++KLLyAIAqZPn+5eAQmfQBz/MzKqL+QS14XCBchVmJownJvbmLcP9XpNi8ecsyMF/mhZFhqbZYcIEDAiyr3xP95Mr1ZS4ckFRvgiYvdX98AoBMhVbrse0+mhy21fCvxXp4G6ZtU9JAJwTztT38XopQL0Us/6zXxCAfryyy+xZMkSvPjiizh8+DAGDRqEKVOmoLi4uNXjcnNz8dRTT2HcuHGtriO6BjqjHkfKLnBzY6Jdbz25LWmcpU0DANTqG/Hz5QM211Y1AsWiotG9WnGB7Szkc0/7hSZCrQh0WFZfJ0juZ4m7omKIRGcg06oDvJutP7n5gJ4368p7WQddG5m1+2tKDyDege47En8/PPjRUDz40dDO0QrDnbz55pt46KGHMHfuXKSlpWHlypXw9/fH6tWrWzzGYDDg7rvvxksvvYSUFNe5OAjf5WRFrlVtjaERdjqv20F8QISVYvW/nN9gZNbBM2L3l1wCJKttn1dvNGDHlRPc3Njofs6I2ikwuwdspcIzaopK+Bhnqjo4APoCfz1pZBikIdYp99tzgVxR6vscO1LfvRGvV4C0Wi0OHTqESZMmWeYkEgkmTZqEPXv2tHjc8uXLERUVhQceeKAjxCR8gIMlfPHA1JBuCFW6x3pye/JV3PhyXQn2FZ+xWid2fyWHttwD7EjZBVTpeHPRBFEF6q6IOQ5IHANUowVK6m0dQRDeSZ2uEXm1vCXT3Snw2vO8AmTL+gNYp773jQBGxNtc6jN4fR2g0tJSGAwGREdHc/PR0dE4c8b6BwUAdu3ahX//+984evRou65hbtxqprq62mF5Ce/lQMlZbjzMjb2z0sN7IiUoFtk1Vyxz/8vZiVEiy5A9GWC/Fhzlxn1DEhDn30bJ6C6A2QIklVUCgg5gTcV/ciqBqADPyEUQ9nK26hIYmsyWMkGKnsHu1TJ05y9yY0WvRKs12RXADn4ZZjuR+s40Wtz7H9MJ2QQtIPNMMUSvtwDZS01NDe69916sWrUKERER7Trm1VdfRUhIiGVLSHCvyZHoeKq1dTgj6q0zLNL17i8zgiBgRjIfe3ag9Bxyagq5ufZmgOmNBuws5N1fZP0xYbYACQKDXFQPiOKACF9CXAG6R3AsFFL32im0IheYvKe1BUgc+xOiBKY7cftkBgMm/lqMib8We7QVhtcrQBEREZBKpSgqKuLmi4qKEBMTY7U+KysLubm5mDZtGmQyGWQyGT755BN89913kMlkyMrKsjpm6dKlqKqqsmyXLl2yWkP4NodKz3NPVkqJHANCk916zWvj0xGi4M0PX4kKI4qrQLcUAL2v5Ayqdbw/Z0JsxzngZRLg8RGmzVtaYZgJVgQg1s/0wcnk/H1C/PkShDdjHQDtXvcXY6xNC1CNBvjKRuq7M1XW5QolcueOQ+7ccZBTK4yWUSgUyMjIwNatWy2p7EajEVu3bsWiRYus1vfp0wcnTvBPys899xxqamrwzjvv2LTuKJVKKJWe+08g3M8hUe2cweE93P5kpZQqcHP3Ufjkwi+WuU2XD2F+n6kIVgSgosE6RqUlC9APeXu5cT91ImL826iY6EIUUuCJkR12ObtJDemGKw3lkCuK0NAsTOp86zUoCcKrOCMq0trHzQqQobQSxiq+Do+8J/8b+VUmUNssd0QiAPcOdO66CpUfJv7tFedO4gK87FnONkuWLMGqVauwdu1aZGZm4pFHHkFdXR3mzp0LALjvvvuwdOlSAIBKpUL//v25Ta1WIygoCP3794dCofDkWyE8xNHybG7s7uahZm5JGsN1mdcYdfj+D2XmtKh7g1JqaoMhprSxCntE7S9uENUa6uqYO8PLFWQBInyTck0Nihp4n21fd2eAiaw/gkoBWbemeFsjAz4Rub+uTQG6OZD67o14vQUIAGbOnImSkhK88MILKCwsxODBg/Hzzz9bAqPz8vIgkfiELkd4gApNDS7W8j+MbTUodRURqhBcEzsYWwoOW+bW5+7GHSnjkVnCf/16hdt2L228tJ+rDOsnVWBS/BC3yWwLIzP1AAKAnmGmp0BvwtwTTC7nY6yu1Jqq1waTgZfwcsTxP35SBRKDoltY7RrEKfDyHgkQpE1pqL/lAdmV/DGuSH03GA24eCUXAJAYmwSpm1v5tIRPKEAAsGjRIpsuLwDYvn17q8euWbPG9QIRPsPRMt764ydVopebMyuac3vyOE4BKm6sxLcX9+BMKR8k3ddGzL7GoMPXOb9xc9fEDYG/zH2VYW3RqAeu/dS0n7kA8PeyLutNFqASAAYATTfUC+VAeqxn5CKI9nJGFP+TGtKNsx67A63IAiTvycf/fHyUX987HBhlu0uGXTTW1oANnmPaz/oeAcFq50/qAGQ2ITo9R8v5wPcBYUlubx7anLTQRAwM4wOu15zfjJMlfGHENBsK0KbLB1Gh5X30tySNcbmMvk6oMhBRKjUEwWDVGV6caUcQ3ojYAuTuAGgA0IlqACmaxf/kVADbcvn1vtr1vSVIASI6PcfKeAWoo9xfzZnfZyo3rtQ04FwZX6a4j0gB0hr0+G/Wr9zc0IhUi7uH4OlNcUCEj8IYs7IAdYQCpL0gsgA1ywD7hO+6g2AlMN1FbQcFPxUeWJWBB1ZlQPDrWGt2c0gBIjo11do6ZItq7wwK63gFaGBYCsZG97eMddooGBhvhUqL5I/5KncnCup588VdPSa4TUZfp8kNxv9/kwJEeDtXGsqtqrz3cXMPMGOjBvo8/rui+KMGUJ0W+N9pfv3Mfq5zfQuCAINMAoNMAsGDJiVSgIhOzbHyHKv6P+5uLtgS8/tMheSPJqk6bRz3WmwgoG72IFTSUIm157dwa/qHJmGoG6tX+zotBUJTKjzh7YjdXyHyptpW7kKXfdmqWZ68h+ne+HWmqZWMGQHAfU6mvnsjpAARnZqjIvdXv9AkyCWeif1PCorGHSnjAQBakQLUN6LpRqQ3GvB/R/+Ler2GW/NYv+kefVrydlpKhS+oNRVzIwhvxdr9leD277o4/kcWHwVJoD8Ys+77NSkF6B7iumszrQ4zv7yEmV9eAtPqXHdiOyEFiOjUHBfV/xkcnuIhSUw82Ps6JAREQqfhFaBanIPWoEe9XoNlh/+DIyLF7bpuwzokJsCXCVcFI0IZDLmiGAAfYH6BWmIQXozYAuTuAoiAjfifP9xfu/KALNH3xdVd35lej+t/LsT1PxeC6fWuPbkd+EwaPEHYi8agxfnqfG5uYJhnFSClVIEXhtyDG06pufmshr245Zf/QM8MVpafKJUaj6Xd3IFSWiOTAPPSm/a9ld7qBJQWnYJMXgq9Lsoyf74MGGLdOYcgPI6BGXFO1KfQ3fE/gLUFyKwAfSyy/vQMA8a4WBy5QomcWcMAAAnUCoMgXM/ZqnyugKAAwWPxP80JlydA3P9PoSiw6vUFACqpAv+XMRtBCv8Oks42Cinwl3Ftr/M0qcHx2F10CnJFIacAnaNAaMJLuVhThAaDlpvrkBR4URFERa9E5FUBv+bw69yR+q5Q+WHSu2+69qQO4MXPcgThHKcreRNvclB0hxcQtEWmqAWGIGitatcAQKBMhVeH3Y+00ESr1wjb9P5DwZWLm6JSIDThpWSK+n9F+4UiTBnk1msyxqAVW4B6dcfaY0DzsOhgBXCri1LfvRGyABGdlswK/guepvYOReJUCT8O8a+AIPDZGKOi0vBo2s1ICBTlxnsIIwPya0z78UHe1wrDTOofFb4pFZ7wFc6I43/c3P8LAAxXSsDqG7g5XVIi1m3k183oBwS4oX2mwWhAUY3pqSQ6KJxaYRCEqxFbgLzFknKcN07gxpRoLBz5F1yoLgBgSueO9gv1gGQt06gHxn5s2vfGVhhmIlQhCFMGQavhP+T8GlNH60DqhUx4GdYVoN2vAImtP0KAH76rjEC1KPV9tptS3xtra9DQ8zbTvgdbYZACRHRKyhqrUSjqrJzmJVlUJ4r58cBoIM4/HHH+4Z4RqBMhCAJ6hySgrOEcTJlgTV7+C+XAYAqEJrwIrUGPrOor3FzHtMCwzgBbe4w3616TDCSq3S6KR6EYIKJTctqqs7ISSUGe//WraAAuVfNzA6JsryUco686AYJEbxVXRW4wwtu4UJ0PPWvKiBBgUuDdjfYcrwAdHTje6vvh6tT35gh+Kix4fwgWvD+EWmEQhKsRu7/6qhPc3lm5PYitP0op0Mu9BV+7HOZYL3FBRGqKSngbYvdX98BIBMjdrxBoz/KpXl91v5ob9wgFxrnRECUIAur9Zaj3l1ErDIJwNacrxH5173R/pUUCcs/E/3VazK5Oq5YYZAEivIxMqwrQHROn2FwBuqKOxQ6Bb7A8u5N1fW8JigEiOh0GZrR6suoXmuQZYUSIA6DJ/eV6ghT+SAiIRF0NdYUnvBvxfaoj4hQNpRUwllVZxt9m3AKGJm0nUAHc1te9MjCtDtO/MRWpZdfoAJlniiGSAkR0OkyFxfhqyt4SAH1SZAEiBcg9pKkTkVVewM1drjZ1uXZHWi9B2EuNrgF5dfwNoSMs1dqzuZb9BrkKPw65kXv9jjT3Z0syvR7TvzV9P9mb1AqDIFyGOP4n2i8U4apgD0nTRHkDcLmGnxsY7RlZ7EUqAPcObNr3dvqqE/Cz/CgAA4AmH+O5cmqJQXgHZ0XuL7lEih7BsW6/bnMFaGv/a1Gr4osudkTXd5lMgZybTRfqJvPcEwkpQESn41SFqP6Pl1h/xPE/Kpmpz44voJQBf53gaSnaT1po4h+ZYCXQ65o0njOlpAAR3oE4U7VXcDzkEvf/JGvPmOJ/GID1w27nXrs6EUjugBJkSn9/TProffdfqA0oCJrodIhvLN5aADEt0rsbi/oyPYPjoJDIoFDwNVbEbUgIwlNYF0DsmAc17blcAMCRpHTkRvHNoe8f0iEieA10+yU6FfV6DXJr+Owfb2mBccyHA6AZA8rqTRtjba/3NHKJzPREreQVoDOkABFeAGPMRqmODlKA/sgA2yCy/qSo3Zv63hzGGCo0tajQ1IJ58IZCChDRqThbeQnGZu38pIIEvUPiPSiRCcaAQ/xvsU9VJW7QA+mrTFuD52IW7SIttDvkCj4Q+kypbyhwROempLEK5Ro+ILAjFCBDaQWMpZW4oo7Fnl6juddmD+64Hn/1NVUoTrwBxYk3oL6mqu0D3AQpQESn4pToqapncByUUs+n/VysMgVBN2eo++MduzRp6kQrF1iVBiis9ZBABPEHYvdXoNwP3QIi3H5dcwD0txm3wNisAWmgArjdzanvYmQGBpnBs08jFARNdCpOWwVAe4f767DI+hPhByR4PjGtU5OmToRUVgFBaARjTdV1M0uB2KBWDiQIN2MV/xOSAEkHVKrXnss1pb4P7vjU9+YIKiUef9PUa+NLlWdqAAFkASI6EYwxKwtQWqh3ZICJ3V/psV2j0qonifUPg1oZAIWSd4OdpZYYhIfxWAD0mVz8MmAyav2angAEmCo/dySCRILKUAUqQxUQJJ5TQ0gBIjoNxY2VVn51b7UAZZD7y+0IgoC+6u6QUyYY4UUYmBFnqsQtMDpGAdKcy8WGobdxcxOSgCR1h1ze6yAXGNFpELu/gjrIr94WtVrgjMjqkE4KUIfQPzQJWxSUCUZ4D3m1xajX85Xq+3SQArS/Jsgq9X3O4A65NAfT6nD9T6bvJbXCIAgXIK7/01fdvUP86m1xrAgwNov1k0l8pwK0rzMgNAkKxU/cXFYFg9YgQEFNaAkPIHZ/RanUiOiASvWGskp8lTqFm0sJ0GFcd7nbry2G6fWYue6yaf9VaoVBEE4jrqvhLe4vcfxPv0hTFWhfQio0ZYn4QisMM33V3aFS8iW49UYBWeVA30gPCUV0aawaoHZQodbs4wX4PXUMNzcnQ9Jhqe/NkckUyLm2NwBqhUEQTqM3GnBG1Funn5dUgBbH//ii+0spA96Y7Gkp7MdPpkSf0HBcvlQOg76p70hmGSlAhGewtlQndMh1PzkjB2tmEQ/Q1eO2fv4dcm0xSn9/TPrsI49cuzme9w8QhAvIqrkCrZE3pXZUYGFrGIw2MsB8qABiZ6B/WDIUNgoiEkRHozFokVXN/y12xH2qXgdsaOQVrWnVxzo09d0bIQWI6BSIA6C7+UcgRBHgIWmaOF0KVPPxjhju+cLUdsOY6SZar/O9SsoDQpOtMsHOlPrYmyA6BeerC2BgRstYAgG9Q9xvAdpwBqiRNNXCEpgRd4VcaeUI98IYQ4Negwa9hlphEISzWJmVvaT+z97L/DhZDcQEekQUp2jQA30/MG2+0grDzICwZKueYCdLjC2sJgj3kVnB36eSgqLh7+YMKMaAj4/ySsaI83vQM81zPuD6mipcSJmCCylTqBUGQTiL2ALUz0sCoMUK0MhunpGjKxOhCka34HpurqxeioqGFg4gCDfhiQKIuy8B58v5SOdbDn4NRVoPt1+7NfwbDPBvMHhUBgqCJnyeGm098ur4TJ+OyqxoDYMR2J/Pz430QfdXZ2BoTAiOXdABrCnl93QpMKZj4k8JAoB1r8KOqP+z5hg/7l6ai2HFpyBL8FwwoqBS4plXBwAAPqFWGAThOJmiqqoKiQw9g+M8JE0Tp0uAai0/N4osQB5hUHgiFIpCbu5UiYeEIbokFZoaFNTzFVH7u/lBLa8K+CWbn7vlwNdQ9k3xaAsKQSJBUYwKRTEqaoVBEM5wqiKXG6eGdINc4nnj5h6R9SdFDUT7YPxPZ8AUCM3/hxy8omlhNUG4npMiN72fVInkIPfWxPjkONA8+iegsRaTj2+C0sPuL2/B878SBOEktipAewMU/+M9JAVFI8h/P+qatYo7XkSB0ETHIX5Q66vuDqkbK9XXaYEvT/Jz1x/dCD9dg8fjf5hOj4lbi0z7E/XUCoMgHIExZpVZ4Q0VoG3G/5AC5DEkggQDowQUFjXNXalRoV4H+Hd8JwCiC3JSpAC52/214QzvgheYETcfWg8AUPRNaeGojoHpdLj3U9N9m72kA/w8IwcpQIRPU1BfhipdHTeX5gUp8MeKgBpR/I8vK0ASAbihZ9O+LzK+Wyg2nzCiyfMvILMUyPDBytyEb2G7Un2S267HmHXw84jzexBfYSrCqEjzrAIklcqROzYZABAv9dwTCClAhE9zSuRXD1UEItYvrIXVHccOXiz0CgOiPV+X0WFUMuDDqZ6WwjlGxqRALi+GTteU/bInvx4ZsZ5pB0B0HS5UF0Bj1HFz7mzVY0p95+duPfAVAEDWLRrSkCC3Xbs9qAICMHHDJx6VAaAgaMLHsWqAGpoIQfC8iWJ7Lj++OskTUhDNSQmKhb8fnwn2++W6FlYThOsQu7+6B0S5tVL96qP8OLEkFxk5BwF43v3lTZACRPg04gDoNC8IgC5vMLnAmnO158OSujwSQYIeYbxf8myZ1EPSEF0JsQLkTutPdgWwNYefm37wa5gfCz0dAO1NkAJE+Cwagw7nq/hIY28ogPhbHp966icDhnm+LJFT1OuAxHdMW72u7fXeyog4FTcuqwuB1rPFaIkugDgDrL8b438+PsqPgzQ1mHz8Z8tY0c/zClBddRUO9roGB3tdg7pqaoVBEHZzoTofetb06yVAQN8Qz1uAxPE/oxMAJUXbeQU3JEVxY8ak2J1f6RlhiC5BaWM1ChsquDl3KUBVjcD/TvNzUw9+Cz9do2Ws7Ot5BQhgCK3UIbRSB/5xsWOh2zLhs5wWpb8nBkYhQK5qYXXHYGTAjlx+brznjVLEH/SPiIJCXg6trilQ/pfcckzorvacUESnRmz9CZCpkBQU7ZZrfX6Sb1YsBcP0QxuaJhRyyHt4vv+LoFTghZf6AQBWKRUek4MUIMJnsRUA7WlOlQCloiabFP/jPUgECWKCq5FX1qQAHS7yYZ8e4fWI43/S1N0hcUMBRJ3BOvX9WsklRFU39UlU9EqEIPf8z74glSKvu79l31OQC4zwWcSNBb2hA7y4705SCJCo9ogoRAsMiOKzBC9W+IExz5nhic6NdQB0kluu83MWcKWWn7sjdys3Vg7o5ZZr+yqkABE+SbmmBlfq+UIX3lAAcXMWP56Y7Bk5iJYZnxDMjesbo3GhqrCF1QThODqjHueq+J447or/+fcRfpweC6Qe3M7NKQemuuXa9sJ0eozdVYqxu0rBdPq2D3ATnreFEYQDnLZqLKhwe2PBtsirAk6X8nNTenpGFqJlxPE+jCnx08VL6KWmktCEazlXlQ+tkf+Bd4er/vAV4IhIh5+bpoP2LH+fVHiNAqTDg/825eqzP3uuFQZZgAifRGxWdndjwfawSWT9CfcDhnaS31SJAExIMm2+2grDTFSAAH8FH6i141JNC6sJwnFOVPAFeZICoxEkd/2vvdj6Ex8EXKO9ABia1XgQBCj7eccTmVQqx8Wh8bg4NB5SaoVBEPYhDoB2Z1+d9iJWgCalANJO8oihkgFrbva0FK4jNVyHo1eafojOl8nRoNfAz0NdqYnOyfEyPihwQJjrfeL51cBPF/i52YMAw4lz3Jy8RwIkgd7R9kUVEIBrfvrC02KQBYjwPWw3FvRsAHRJHXCwgJ+b4g3lNgibjE3gn8IbGhNwpCyrhdUEYT9GZsTxct4CNDDM9W0o1h4HDM1i+P3lwKz+gPbEeW4dBUBbQxYgwufIrS1Eg4FvaeDpFhi/5PDlvALkwBjPl9sgWmBYLG9212m64feiHzA6Os1DErmG4oZK7C3OxIXqAlyqK0GDXgMjGMKUQYj3j8CAsCQMjUhFoBvcMATPxdpiVOn4XnODXawA1WmBz0/wczPSgBAlcPk4bwHylvgfb4IUIMLnOCkKgI73D0eo0rPdjTfyD1uYkGRyG3UW6nVA+r9M+4fnmZ4yfZlBojp0jMmx41I5nhroGXmcQW80YPuVY/gq5zer0hBi1uXsgFSQ4KqYAZiRfJVbXDKEiePlvPsrSqVGjH9YC6sd46tMoLrZs6AAYO4gU5aV9jRv0fSWDDDA1Arj+OjbAQADf/8KAcEhHpGjE92iia7CqQrvKoBYUgfs5j1yuM47Yg1dSoPnslVdTqgfEBekR0FN0y3wclUQ8mqL0T0wqpUjvQfGGH4rPIH3Mr+zKgnRGgZmxLYrx7DtyjEMj+yNx/pNR2KgeyoTd2WOieJ/BrnY+mNk1n2/JiYDyaGA5vRFMA1vJVcO8B4FCGCIKmq07HsKn4kBev/995GUlASVSoURI0Zg//79La5dtWoVxo0bh9DQUISGhmLSpEmtrid8C3EKvKcLIP5w3nQzMuMvBybRg7XXMzSWr0CraeyOXUUnPSSNfZQ2VuPp/avwl0Nr7FJ+xOwvOYvZO/6O/1z4BQZmdKGExDGRBWhQuGsVoF9zgJxKfu7+IaZ/NSL3lywhBtJQvv6VJxGUCvz1z33w1z/3geDBVhg+oQB9+eWXWLJkCV588UUcPnwYgwYNwpQpU1BcXGxz/fbt23HnnXdi27Zt2LNnDxISEjB58mTk5+fbXE/4DtXaOuTV8f/v7uys3B6+4+81mJwC+Pm4i6grMDiGz+fXarrjt0LvV4D2FJ3GnJ1/x96SMzZfD5T74ZrYwXio9/X404AZ+NOAGbiv5yQMi0iFXGLddsDAjPjXmR+xZO8/UaGhcgCuoLC+HMWNldycqwOgPxKlvveNAEZ3M+17ewC0IJXiQq8gXOgV5NFWGD7hAnvzzTfx0EMPYe7cuQCAlStXYuPGjVi9ejWeffZZq/X//e9/ufFHH32Er7/+Glu3bsV9993XITIT7uF0Jd8AVSGRoUdwnIekAS5Vm4qQNeem3p6RhbCPgSKvj04bg+NlBShtrEaEynuels0wxrAuZyfeP/0dmA23QZq6O+7qcQ3GRPeDzIaiAwA1ugZsvLQPX2RtR5mmmnvtcNl5PLz7H/j78Id8xg3orRwVWX9C5AFIcqGb8UQRsIcvMI37BwPCHzq92AJEAdC28XoLkFarxaFDhzBp0iTLnEQiwaRJk7Bnz552naO+vh46nQ5hYa4NQCM6HnH8Tx91Qos3+47g+7P8WK0Cxnm+IwfRDvpHAlKhuSIhgVbTzSvdYAZmxFsn1+O9099aKT/hymAsS78XK8csxvjYga1+H4LkfpiVcjU+m/As7uoxARLwVrCC+jI8vPsdnBWVmSDsQxwAPSAsGYLgugqi/zzMjyP9gZv/ePBiRiM0J8UWIO9SgJjegGEHyjHsQDmY3tD2AW7C6xWg0tJSGAwGREfz2nN0dDQKC9vXv+eZZ55BXFwcp0Q1R6PRoLq6mtsI78S6AWqSZwT5g29FCtANPQGF5/Qxwg785EDvCLEbLAE7C0+0cIRnMDAjXjn6OTZc3G312rjo/lg7/k+YGDfErh9Yf5kKj/Sdhn+MWogolZp7rUbXgCf2rbTqYUW0H7EC5Mr4n7wq66zTuYMB5R/+HF32ZbDaeu51b8oAAwCm1WLhB1lY+EEWmFbb9gFuwusVIGd57bXX8MUXX2DDhg1QqVQ217z66qsICQmxbAkJVMDFGzEyIzLFAdAezAA7VwacKePnOqv7SyIAI+NNm6+3wmjOYJFXQtvYHYdLz6NG12D7gA5GbzTg5SOfYXP+IavXHup9PV4eOhchigCHzz8oPAX/HPs4eod04+ZrdA14Yu9KZFUXtHAk0RIVmhpcrOXjFF2ZAbb6qHXSxT0DmsaaQ6e59dKYCMhiIlx2fVcglUhxuX8kLvePhNSDFnyvV4AiIiIglUpRVFTEzRcVFSEmJqbVY1esWIHXXnsNmzdvxsCBLRf4WLp0KaqqqizbpUtk/vVGsmsKUatv5OY8qQB9lcmPYwKB4Z4LR3IrKhnw5e2mrTPVNxLXA9JousPAjNhddMozAjWDMYYVJ/6HLQW8v0MukWJZ+r24r9e1LnGrRKiC8e6ohciI4ANlq3X1eHr/RyhtrHL6Gl2Jw2V8Xwo/qRK9guNdcu7KRuALkYd2Vj8gpNmzfeNh/sakyvC+4p6qwCCM37Ye47ethyrQczXcvF4BUigUyMjIwNatWy1zRqMRW7duxahRo1o87m9/+xv+7//+Dz///DOGDh3a6jWUSiWCg4O5jfA+xGblOP9wRKg8U0BLbwTWixSgm1I7T++vroJYATLow2HQB+KX/MO2D+hA/n3uZ2y8xJfvUEhkeHXoA5gYN8Sl1/KTKfHasAeQHs4XsCpurMQzB/6NBr3GpdfrzBwq5f1Tg8JTXBan+J/jfD0uqQA8IPpT0Bzhb0zKIX1dcu3OiE/crpcsWYJVq1Zh7dq1yMzMxCOPPIK6ujpLVth9992HpUuXWta//vrreP7557F69WokJSWhsLAQhYWFqK2t9dRbIFyAuK7GQA9Wsd1xESjh3eyY4X0PWkQb9Ao3tS1pjkaThAMlZ1HuwZTwDbm7sfb8Fm5OIZHh1WEPYERUH7dcUyVV4LVhD1iVlThXdRl/PfoZGPNcwTpf4rBIARJb1hylUQ+sPcbPTe0FdGv2vG5s1FgHQKeTAtQSPqEAzZw5EytWrMALL7yAwYMH4+jRo/j5558tgdF5eXm4cqUpF/nDDz+EVqvF7bffjtjYWMu2YsUKT70FwkkYY1adld3RWLC9fMW72TE4GkgN94wsHUG9DhjyL9NWr/O0NK5DJgEGizzpmsYkGMGwNf+I7YPczJ6i03jr5HpuTgIBL6Xfh+GR7g0y85Mp8crQ+xHvz/8x7yw8gS+zd7j12p2Bwvpy5NfzgYEZ4a5RgDacsX7omp/Bj7WnLgC6ZiYiQYBqsHsUZmeor6nGjozrsCPjOtTXeC7pyGe8+YsWLcKiRYtsvrZ9+3ZunJub636BiA7lSkM5SkV1S1xdWr69VDSYmp825/YuYP0p9464YJeTEcu3MtE0miyLm/MPYUbKVR0qS15tMV468qlVqvuTA27H2Jj+HSJDqDIQfxv+EB7e/Q4XDL7yzA9IC030qOXV2zkkiv8JkQegR3Cs0+c1MmCVyCs7JgHoLyrXpBHF/8hTEyEJcjxI3l0wZkS3vDrLvqfwCQsQQYjjf9SKQCQERHpElm/PAdpmpSuUUlP8D+GbDBUFrmsbE8CYFGeqLiGnpn2lNlxBra4BSw+sRp0o0P/+1Cm4KbHleEd30D0wCi8OuRdCszpBBmbEssOfoEJDoQQtcaiUL0A4JKInJILzP7Nbc4CsCn5uXrr1ukZR/I/KS+N/BKUCf38qFX9/KpVaYRBEW4gbCw50cWExe/ifyP01uQefhUH4FkNiICoHKINWYyqF8d3F9hVbdRYjM+KvRz+zavMyMW4I5vSa3CEyiBkR1Qf39eJrp5U0VuG1Y19QPJANGGNWAdCuiv/5p6gKQp9wYLyNBFhxCry3xv8IUilO9QvBqX4hHm2FQQoQ4ROcqOB9Tp6K/8ksAU6KWtBR8LNvE6wEeovitzSNSQCAny4f6JAMqNXnNlml3vcKjsezg2Z6TNEHgLmpU5AuimH5vfg0frxEzaXFXKwttgqcF2fVOcLBAuCAqBzTvIymthdmDBXV0GXzxStV6XRzag1SgAivp0JT69bCYvYgrv0THQCMpbqZPk+GKEzDHAdUp2/ELwXuDYbefuWYVcZXiCIArwydC5XUc+4BAJAKEryYfg9CFYHc/DunvkGBKNi3qyN2f0WqQlzipn/vAD+OCQSm2XC5i9PfBaUCirQeTl/fHTC9AYOOVWLQsUpqhUEQrXFCFP/jJ1WgpwcaoOoMwDeiBty39aXaP50BcRyQpjEJZi/PhtzdbnP5ZFUX4JWjn3NzUkGC/0ufjRh/7+hdGKYMwtMD7+DmGgwavHL0cxg9GMDqbYgLIGZE9HLaeneyGNiWy889NMR2u53G/XwLF8XAVAhy78xzYlotnnj7PJ54+zy1wiCI1jhWzru/+oUmeaQB6rZcoFSUCdUVsr8AU/uLgVGmrTO1wjAjtgAZDUHQ603tA85X51vFdriCKm0dlh5cjQYD/wPwaNrNGBLhvOvElYyN6Y+pCcO5uWPl2diQa92frCuiNxqs/kbErkNH+OAgPw7zA+4aYHutWAHyG9HCQi9AKpHiSg81rvRQUysMgmiNo+VZ3NhTabifi0rQp8cCPUI9IkqHo5IB399p2jpTKwwz3UNMHbWbY44DAoBPLvAuKmfRGw148fAnuFJfzs1PTRiOW5PGuvRaruLRtOmI9eOtUv888yOKGipaOKLrcLIi1yp7b1ikc6mhF8qBH0V69/2DTb2/xDCdHo2iAGjViJbbP3kaVWAQxu79HmP3fk+tMAiiJaq1dThflc/NDXFBYKG95FcD2/k+rJjVr8PFINyEIJgU2uZomylAR8qycEJkiXSGDzK/t7IYpKm7Y0n/2z0a9NwaAXIVlg6axc01GDR4++T6Lp8VtreYj7/pGRzndJueDw+CqwYVpADuG2R7rebkebB6XgFTDeuYulG+DClAhFdzuOwCVxROKZEjTd3xDVDXneY7MAcqbAciEr6LOA5Ir+EV7Y/PbXLJdX6+fAD/y9nJzYUrg/Hy0LlQSL3bvDYkoiemJozg5nYVncLOwhMtHNE12FfCBweOiHSu+vKlalPl5+bcNxAIUdpe37iP//zlvRIhDVc7JUNXgBQgwqs5XMoHFg4MT+nwHwmDEfhS1Bx8em/bpujOSoMOGLPatDV0olYYzRkmUoAaNVEw6Juynw6UnrN60reXE+U5+Pvx/3FzcokULw+d67HGvvayoO+NVllhb51cz1WN7kqUNlbhQjWfpz4yyrn6OysPAoZmD1wqmXXT0+Y07jvOjVXDvdv601Bbg61jpmHrmGloqPVczz1SgAivxqqwmAfcX9svAldExW/v9O77i8thAC7XmLbO6uzoH2ndGFVh4P+j3zv9LXRGPRzhYm0Rnj3wb2hFxz85YAb6hXa8VdNRghUBeKzfLdxcmaYa/zyz0UMSeZZ9JWe5cYBMZdVQ1h6K6qyLrd7VHwj3t72eMWZlAfLm+B8AMBoNSDpXiaRzlTAaKQ2eIKwoaai0qoybEdHxfidx8PPAKOsePITvI5dau8G6K8Zz44u1xVY1e9pDaWMVntr3L1Tr+G6WtyWNtcqu8gUmxg3GSJGb57uLe5BZmechiTzHPpFVcGhEqlNZqh8cADTNdAK5xHbbCzP63AIYSvhgej8vV4AEhQL/eLQn/vFoTwgKaoVBEFaIGwsGyv3QKyS+Q2UorDX14WlOS2mohO8zqhs/LqiMQp8QvtLlpxe22hUQXdJQicf2fIBCUbbUyKi+WJR2s8OyehJBELBkwO1coUYGhrdOru9StYH0RgMOiAogjoxyPP6noAb4TPTAdXsaENtKolSDyP0ljQyFLLlj75P2IsikOJweisPpoRBklAZPEFaI3V9DwnpA6oLGgvbw5Sk++DlA3rWCnxlj0GZdQu3PuyxzDXuOwVDlOb+9OxkpUoDOlwt4qNcs7u/OwIx47tCadqV/X64rwWN7PsCluhJuvm9IApan3+eRelauItY/DHN6XcvNZVbmYWMXapNxrDwbtaLYJ2cCoN8/wDdalkuAR4e1fkzjnmPcWDV8oNdmEnobpAARXgljDIfd1FiwvRiMwDpR8PPNvU0ZYJ0dQ2kFyl/9CHnDZuLSyLtQPP8ly2tXZj2F3N7TUHDb46j9YQeYsfM88duKAyqpicVs0Q99uaYGj+9d2aoStL/kLObtehuX6/+/vfuOb6rs4gD+y27apoPulrLKLsimlqmIoCCICxRlqIgKuFBkiSgqS1AUURQUF4jCq6iIyJJdNghIoUBbaOmgpSNp2uzn/ePa0pukIyGzOd/PJ0Ke3ps8XJvk5BnnFPLaGwdEYFHPCZCLa9jS40VGtuhvUe7h89Q/oNSp3dQj19pntvutTXBjRMhD7HqsLKXlZotHOwBxQbWfV7H/BO++3+2ePf0FAMxoRNvzSrQ9rwQz0hogQngyVHm4rinhtXV1cQC09yq36Le6hr74mRkMKP7oe1zpNhLFH3wDw5Vc6wcajajYexz5T76B7AFPQXPsX+vHeRlr64BSsoExLQeiR0QbXnu2ugAT9n2IXTmneNM+ueVFWPjPerx6+HOLnVHxARFYnjwJoTL3JX9zJIlQjJc7PMhrK9WrsfrCVjf1yHUYY9iXx5+v6htt//z48iOAvtp3CZkImFLH6I8+MweGq/zXqLxfN7v74CpMq8OMRRcwY9EFMK37SmF4dtIJ4rMOFfAXFkbJQ9EsMMqlffiGP7KMxAigYwNe/KzPuIb8Z9+2KKoIAALG0LQgo+rv1en+vYxrQ55H6GvjEfraeAiE3v29KrkxsKda0stD2YBYKMLbXcbguQMf8xbml+jKMPfEt4jwC0azwCiU6NS4pMzh5a6q1EIRg6VJzyLcr46v9F6mZ0Qb9I/uiD3VRkN+vXIQ9zVJQuvgxrWc6d3SSrMtvqT1szMAyiwBNprt/HqiI1f4tDYV+47z7gvDQyBt555C0bYQCIS43pj7x8W4eFlDdd79TkUaLPN8K7dHtnPpvHZmCbA7k9/2REcuY3BDVHH4NLLvedZq8AMA/iFyrDu6AGv3vw25yMpGeMZQ/P4a5I2bDVNZueXPvYjlOiCgsBxQSP3xUfIkNFdEW5xToCnF0cI0XFResxr89I/uiM96v9jggp9KU9rfD5nw5tyhyQcWRO/L54/+NPYPt/tL2keH+Xl/5GLg+e51n2ceAPn36eoV63/8FUFIPvknkk/+CX+F+14TFAARj1Omr8Bps102ybeYWMxW3/7Dz3cTJANG3FpyV4+l3nYQOQ++DFNRKf8HQiECR96DxjtWo9m539D4ry8Qv/trNLuwGZGfzYGkrWVNtvKt+5H76DSvDoKsrQM6lM39Ge4XhE+SJ6NPVP3mQuUiKV5KHIF53cbBvwGs+alJtH8jjGk1kNd2tjgTf2Ufr+EM72ee/bpPdAe7go9/CyyzPo/rBEQE1H4eY8xi/Y83TH95EgqAiMc5VpgGY7VvjhKhCF1dmABRreNKX1Q3KrFhZn4u//sI8p58A9Dx0ztLWjZB3OYViFoxG7JObXhv7MIAORQPD0L8rq/Q6I1nARF/J5Pm8GnkjHzVa4Mga+uADmbd/HuQNADzuz+Jt7qOQasg69uN5SIZHmneD2vvmIGHm/eD0I3D/K7yaIs7EOcfxmv7LPV3i11SDUFWWQEyVHm8NnumvxgD5u/jf9kKlALP1iOO0Z3PgLGAvwhf3ocCIFvQGiDiccynvzqHtXTpjpmfzwOqauvyBODq8DQ0mhPnkDdulkXw4z/wdkStehvCwJupZyv0wLD13N9/fxSQSwCBRIzQl56ArGs75D/9JkzFyqrjtUfPIn/iW4j+dj4EYu97m+kdz18HtOcq92FVGQcKBALcFdsFA2I6I0OVhwul2SjSKiEXy9A8MBqJoc08vq6Xo8lEEryY+ACmH11d1VasK8NXaVstMkd7u125p3j3G8kUdmXz3nMF2J/Fb3u+G9BIXve5Ffv4oz/i+GiIm8XWcLRnqShTYd/wsQCAvr99C7mbKsI3/K8lxKswxpBiFgAlR7hu+osxy8XPdzUHmnhHmaZ6M+QWIG/sLLAKLa9dMeoeRH+3gBf8ANw31ItF3M18hYt/326I3fQxhOEhvPby7SkonLnMKyuF92vCv5+t5NaFmRMIBGgRFIN743vg8ZZ34cFmfdAlvKXPBT+VekW1R6/I9ry2nzMP4LJZrSxvxhjD9mv8qb1+0R1tHuUzmoD5+/lt0YG11/yqznz9j7xvN69Y/wNwpTASzhQi4UwhlcIgpFJaaTaKtPy957daWNAWB7K4D/nqxndy2dO7hKlcg7yxs2DMv8FrD3xwICI+mmHXiI2sfQLiNn0MYSN+pKj8+leovt98S/11h7bhQIRZ7aW9vlflwS4vJo6AVHjzd8jITFh29hevDIStuai8hitl/BI9d8fZPvW0MRW4wH8J4tXbudHVujCtzkoAVEu9DA8jkErx+cQW+HxiCyqFQUilPWYLCxv7hyM+MKKGox1vFX9UGQmhQJ8m1o/1VoUzPoT2FH/VpbxvV0R+MhsCkf2ZiaVtmnNTXjL+G1rhzGXQnk6r4SzPJBAA/cxmNPZRAFQvcQHheCzhTl7bqaLL2Jlz0k09cqzt1/hvEjHyRuhoY/HTMh2wNIXf1jYMeKie3/UqDp8GU1dbWyUQQN6/jqRBHkQgFiElOQwpyWFUCoMQgBta3pPLr2tzK4nFbJVawFV+r258p4a19V31yw6oftjCaxM3i0PUl+9AILn1aRt50m2IXD6L18a0OuQ9Pcfrymf0NQt8D2YBeveN1nuVJ1rehWh5KK9txbnfUG7QuKlHjmFkJotA7q64LjZPPX10mKv6Xt2svoConp/I5dv50ZOsS1uII0JrOJrUhAIg4jEyy/Itqr/3j3Hd6uPPzHbsNpIDj7S3fqw30l/JQeGrS3htggA5YtYuhCjUcbk4Ah+4C8ETH+G1GTJzUDjjQ4c9hyv04ddAhVoPnMyzfizh8xNJ8YJZoddCrRJfp213U48c4/SNdBRo+OkiBtk4/ZV2A/jqFL+tf1PuVl/lOw7x7vsPTLapD+7GjEY0Ty9D8/QyKoVBCACL0Z9IvxC0C4mv4WjHuloKbDabpRnfqX7z8d6AmUy4PuldmFT8r50RS16DtHUzhz9f2NznIevBz5VTtnE7yn792+HP5SwRAUB7s9nXPVesH0ss9Y3uiJ5m5UN+ytiDK2X5burRrfsz+yjvfoIixmpizJowBszZDRiq5YeUioC3+9e/D/qMa9Bf4s/H+g+8vf4P4AGYVoe576Ri7jupbi2FQQEQ8Rh78vgBkD07K+y16gQ/E6u/hEtG1lAov/sdmiP89VWBI++B4uFB9TpfAKCxgrvVZ7BfIJUgetVbEAbzc/kXTFsCQ15hDWd5HvPdYOZTpKRmAoEALyU+ALHg5hoPb14QrdJXYFfOKV6brYuff0u7mVSz0sSuQHMbZq/Kd/Cnv0QRoZB1alPD0Z5JIBCiONwPxeF+EFApDOLrMlX5uGS2VdZV01+F5ZaJDx/rAIT4ueTpnc6QfwNF81by2sTNYhGx6JV6P4ZcAhx4irvVd1RMHBeF8EVTeW2mYiUKXl7kNR+A5tMSZ68Dud61lMmtmgRGYlQL/vDGscI0iy873mDHtRPQmm7mzBIJhLg3vv4Lj2+UA2/t4bfFKeoueGpOvZW/d95/QJLX1d/zVwShe+p2dE/dTqUwCPnr2jHe/TBZEDo2siy14AyfHgM0hpv3xUJgQj1zcXiDG29+ApOyjNcWsWSaRa4fZwh8cCAC7h/AayvfeQhlP/3l9Od2hB6xXBmU6nZmWD+WWDe21d2I9AvhtS3/91dojO6b+rAVYwy/XjnIa+sT1QGNZPVP4Dd3D1BklhR7Tj/bptmNRaWoOHCK1+Y/uHf9H4DwUABE3M7ETBZbS++O6wqRC4ZGc1XA92ZfRh9oC8S6JzGpw5XvOoyyn3fw2gIfGQT//vWotOgAAoEAEYunQhTFL5FQOGc5DGZp/D2RRATc2Yzftj3dLV3xWv5iGSa3H85ru64pwXcXd9Rwhuc5V3IVl1W5vLbhTeu/8HjLReB3szWGgxOAexJs64f6z/1AtUXDArkM/gOSbHsQUoUCIOJ2/xSlI7+C/2Fo684Key0/AmirbUKQCIEXe7rkqZ3OVK5BwetLeW3CEAXC3p5i82NpDMCwH7hb9dGy+hA1CkbE0mn8vhUrcWPOcpv74Q4DzQYiU7K5enGk/u6M6YSuYa14bT+k/+01C6I3ZOzl3Y+RN0L38FY1HM1XVAHMMVv7H+IHvHun7Sk21Jt38+77D7gdwoB61M3wMBp1Gf4cOhJ/Dh0Jjbqs7hOchAIg4nbmFaNbKKLRMsj5NW2ulgI/Wil62lDKXhR/8A0MV/jfWsPmTrIrX4iJAaevczeTHct3Agb3tpgKK/vfdqjNtvN6ov7NuGnRSlojJUW0lUAgwMsdHuCN6upNRrx/egNM1Qofe6L8imLszuXXxxneNLleGzQYA17dBhSaTX291R+IrKPauzmjsgzle/hLBQKG2bB9zIMYjQa0PpKL1kdyYTTa+I3KgSgAIm5VbtBY7KwYFOeamjYLD/C3o8pEwAsNZPRHm5qOkhU/8Nr8bu8ExeghbuoREP7eixa7wgqnLfH4qvHBMiDJrOj7DpoGs1lzRTQead6P1/ZPUTo2Xz3sph7Vz8aMfTBWC9L8RFLc36R+01+rTwK7Mvltd7cARtixaat8635AXy1YkEoQMKiX7Q/kAQQSCdaMb4Y145tBIHFfrhEKgIhb/ZV9HBXGmwU5hRDYVVfHVgeygD8u8tvG3MYVI/R2zGRC4avvA4bqc3tiRCx51a27RcRRYRbTb4bsfBQtWF3DGZ7DfBpsZyY/eCb181TrwYiRN+K1fZr6OwrNkgt6ijJ9BX6/yh+lHBLfEwpp3RsITuYBiw7w28LlwPwB9mWXV23Yxrvv3787hAobh5E8hEAixp7+EdjTP8IhGejtRQEQcRvGGDaZ7azoFZWISHmIU5/XYLLcjhriZ/t2VE+l+n4zNEfP8tpCpoyGtI1rdtXVRjF6CPz68Is2lq7aCM3xf93Uo/oZ2IJ/v6jCMp8LqZtcLMNrt/GzhKsNGiw7+7ObelS7DRl7oa5WvkMAAR5p3rfO8/LKgImbAX21IFkAYNlg26e+AMCQW4AKs+mvwEfql8OL1IwCIOI2Z4szkW62s2JEU+cP6X53mktHX920ZCDU+9YSWjBcL8KNeZ/x2sTN4hD6ylg39YhPIBAgYslrEPhVK5jKGApeWQym09d8ops1CQY6RvLbfvOu+q4eo2dEGwyO4+9C3JN3xiITvLup9BX4KZ3/TalfdEc0Dqi9OLPGADzzO3DdrNbXpB5AXxvKXfD6smEbt6DoP0JFAALuqTsQ81TMZELstQrEXqsAM7lvKJUCIOI2GzP28e7H+oehR0Rrpz7n1VJgMX/QCe0juMSHDcGNNz+BqdQs58/7r0Iol9VwhutJE+IROu0pXpsuNR0ly9e5qUf1M8zsV3PrJUBHxVHtMiVxOIKl/KGQpWc2oljrvh1B5jak70GZWfHWJ1vXPupiNAGv/MVtFqguuTEw1c5qFYwxqH7aymsLGH6HR72mbcU0Wsx/4yzmv3EWTKOt+wQnoQCIuEW2usByZ0WT+u2ssJeJAa/vAMrNBhrm9a9/FWZPVv73EZT9j19sMvDhu+F/h2Pm9hrJuZsjhDw/CtIO/G3ERR98A11apmOewAnuM9v1XKql3WD2CpEG4sX2I3htxboyvH/6J4/IEn5Do8SPGfzRnztjOiGhlt2pjAEzdwFbLvHbmwYDnw3h7yS0hfbEOegvZPLaFCPvse/BPEiZQoIyhXuLLTaAt33ijdZf3g0Tbr7R+YtlNiUWs8c3/3A5XKob3QHoEWf9eG9iqtBaz/kz7wWHPL6/BDg5kbv5O+A9SyARI3LZdKD6omydnpsKc+OQeG3igoBuMfw28+R2pP7ujuuK3lGJvLZ9+WctCo66w6oLW1BuuDkyIYAA41vVPPrDGPDOPuBHs6VsgVJg9bBbm14v/eoX3n1xkxj43e6aMkHOEhAUgk7pu9ApfRcCgkLc1g8KgIjL3dAoLd7k7m/SCwqJ8xbhnMoD3uPPuCFOAczq47SndKniD76BIZNfSy3szeftyvnjKrJObRAyaRSvTXPkDJRf/+qmHtXNfBps22XbE0MSjkAgwOu3jbSYCvvo31+QW17kpl4BF0qysCWL//40uHF3tAiKsXq80QTM3gV8eZLfLhUBnw8FWodZPa1eDAXFKNu0i9cWNHa419X+8lR0FYnLfXtxO3Smm58aEqEII1v0q+WMW1NcAUz+k78jAwAW3QUovHcavYrufAZKPuGvn/FLug2Kx4e6qUf1FzrtKYib8Yfgbsz7DIZrnpkheGgrQFhtC7Naz60FIvZpJFPg9dtG8trKDVq8c3ItDCbXL7AymIxYemYjWLXRablIhmfbWn8taQzAy38Ba/mbLiESAJ/cC/Rpcmv9UX3/O1Btc4BAJkWQF7yuvQUFQMSlssoK8OvVFF7bPY17INzPOemXNQbgmc1AtpLf/nw3+3dkeBJmNOL6ywstc/4sfc2h3xI1BmDURu7myBEPob8fIj7gl8lg6goUvP6BR6wFMRcZAPRqzG9b79k7+D1ev+iOuLcxf53ameIMfH7+D5f35cf03UgtzeK1jW01EOF+lhXL88uAR/9nuRtQKACWDOJqfd0KptOj1Gw0NHDEAIjCPXdUt7406jL88dAT+OOhJ6gUBvEdqy5s4WVVlQrFGNfqbqc8l9EETNsOHOXPDKFHLPCadyZQtVD65S/QHufX8wiZ/JjDc/6YGHDoGnezpxRGbfz7doNiNP9bbfm2gyj7Zadjn8hBRvGXrSAlG8gscUtXGoyXEh+wSJC4Pn039rpwa3yGKg9fpf3Fa2sSEGmRvRoAjucC963nkh1WJxECK+4FHmx76/1R/fgnjDn87WRBEx669Qf2AEajAW33XkHbvVeoFAbxDScKL+Jvs51fDzfviyi547/RGE3cji/zb2fRgdwblL07MjyJPisPRe99wWuTtGiM0Knj3NQj+4W9PRmiSP4HYOHrSz1yKmxQApc4szrzxa/ENgESP7zdbSwkQhGvff4/65FVVuD05y83aDHn+De8qXkhBJjV+VHIRDdX/RtMwIeHgEc2WOb58ZcAXw0HhtSvRmqtmN6A4o++57X5Jd0Gv84OiKw8gEAiwbrH4rHusXgqhUEaPq1Rh/dPb+C1KSRyPJFwl8Ofy2ACpu0ANqby2wMkwJrhQFRDKHfBGApeWwJWzq+yGPHB616ZH0QUokD4wld4babSMuRPfg/M6FnJdvzEwENmn0MbzgFaL10MzRj3hUFvdPzoni3ahTTBC2Zb49UGDaYfXY1Sndr6SQ7AGMOSMxssKtOPbNEfiaHNqu5nFAMPbwCWHQaMZtcpPgj4ZSTQz0HT6qqN2ywKGYe+Nt4xD+4BBBIxtg2KxrZB0W4theG+ZyY+ZU3aNmSXF/LaJrS5t141dWyh0nILnvdc4bdLRcBnQ7mkhw2B8ptfUbGLX0QyaOxwyHt3cVOPbl3gsDugfnAgyn7eUdWmOXASJZ+uR+gLj7uxZ5Ye7QB8eerm/YJy4NcLwMjEGk9xC8aAbBVw9jr3AZ5eAmSVAjcqgBINdzMv1xAg5bZvB0qBcH8gNhCICQRiFUDLRtyuJkflgzI3omkvnCnOwPZrJ6rastQFmH1sDT5Ieg5SkeM/sr67tIP3fADQKigOE9pwuXY0BmDlMeDTY4DWSizeO54bVXZUJnlThRbF76/htcm6J0Lev3sNZxB7UQBEnO5YYRrWXf6b19YhtJnDy15klnD1dy6Ylbmo3I7avwEsegYA3cUruPHmJ7w2UVQYGr35nJt65Djhi6dCc+QMDNk3v40XLVgNee8u8Ova3o0942sdBtwex62JqvTFCeDh9vxdYu5wTQnsyODWJh3PtZyqqQ0DUKbjbgBwqYbd6OFy7hp0igK6xnC3cAd8lxEIBJjW8RFkqPJwSXlz8d4/Rel459RazO3yBMRm02S34o+sI1h14U9eW6DYD+90GweZSIrdmcCbu4ErVmq1igTAS0nA5B6OnVIvWbEOhiz+4qLQqeMgsKeCqodiJhPCC7VVf3cXCoCIUxVqSjHvxPe8baVigQiv3zbSoVmfN50HZu3itiVXJxMBK4cCA9xfB9QhmE6P/OfmgVXw08dHfDgdomCFm3rlOKJgBSJXvIGcES/erH2kNyDvyTlovGO1R+U1mtiNHwBdLAL+zgTucsPv2nU18L9Ubs3bOecvmUFhBVCYDRyslli0STA3GtKvCdC7CRBs50ysXCzDoh4T8Oz+ZSjU3ty+uTv3HwgAvOmgIGjz1UNYbDYtL4AAszqPhsAUjuf+AP6sIcVB8xCusGnn6FvuBo/hWj5KPl7La/Pr3QX+A+2so+GhmEaLJdO4Be7sQS0gdU8hRgqAiNOUGzSYcfRLFOv42xwntLkHzRWOeee4rgbm7bWekTdMDqwaZpm915sVzv4IutP8f2zQUw8i4G7nZtEGALmL3i3kvToj5KUnULLsu6o2Y8515E94E7EbP3TrmoHq7mwGtGrEBT6VPj0KDGgGuOLLOmPcVO/3Z4BdGZbrUlztail3++EsNzrSJRq4uwUwtDW3RsYWkfIQLO75DCYf/AQVxpvB/t+5/8DETJjT5XHIRNJaHqFmjDGsu7wLK61ss5/c7gGcu9YBEw9blswBuNG98Z2Aab0ckxHdvF8Fry3hf7kRChH+3osNavSnklbq/iXIAuaJyTbcTKlUIjg4GKWlpQgKsvGVSwAAOqMB04+uxrFC/od1r8j2WNDjqVse/TGauPwrCw8ASiu19Fo14nZkNHFOeiG3UH73OwqmLua1SVo3ReMdX3rlwufaMIMBOQ9PheYAP72u4on7EPHB6x7zgbDhHPAav/wavhoG3NXCec9pMAF/XAQ+OwakFtZ9PACE+gFtw7mRi2Yh3G7IUD9uN5ufmPtgFwi4hdCVU2BKLZCnBvJUQE4ZN8V8udi+ArCdo7hAaFgrIMaGgcrjhRcx/chqaE38aKRdcDzm93jK5vxhar0G75/ZgJ05Jy1+1jf0YRzN6IW0G1ZOBDfN9+6dQKKT1hFae30HPfkAIhZPdc4TNlC2fH5TAGQFBUC3pkxfgdnH1uDEDf74cYy8EVb3fQVBZqnvbcEYsD2dq+h+sYb1CY+0B+bd4fhvaO5U/vcR5D4+HdDf3GokkMsQt2UlZB1aurFnzmMoKEb2wAkWuVBCXx2HRjMmuKlXfDojcOe3/ESbrcOAP0c7PtUCY1yhzcUHgEwra1KqC/HjRqj6xHMjoM1CHDMqZTBx62HSbgBnrgMncoF/8q2PllgjFHBr8R5N5KYKJfWYyTpWmIYZR760CIKCJP54pcNDuCu2c50BMWMMB6+fwwdn/ofrmhLez4yGQDTST8SZnMZWzw31A2b24d5XnLW+S3s6Ddfum8Qb/RFFNkL8/u8gCqXPIFtQAHSLKACy39Wy63jz+De4rOJv4QyWBuDTXi+gSWCkXY9rMAFbLgKrTgCnr1s/JlgGvH0H8EDDSJVRRXPsX+Q89DJYuYbXHrnyTSgeck4SSU+hOZmKnGFTwLQ6XnvYvMkIef5RN/WK7+fzwCv8/Hl4oy/wTFfHPcfJPODdvcCx3JqPkYu5ivUPteeSfboq15XBxG08OJjFTckduWZ9t5S5CH8uqBh7W92jQicKL2LWsTVQGzQWP+sY2hzjWg1E94g2EJmNLGuNehy6nor16btxtjiT9zPGRCgr7YPy0qHQGqxPqz7WAZjey3E7vKwx5BXi2tBJMFzl/8+NXrsIAYMaSMZWF6IA6BZRAGQ7IzNh89VDWHHuN1QY+R9W/mIZPrp9EtqGxNv8uFdLgV/Oc4nmrqlqPm5EG2BOP8fsRPEk5fuOI2/sLLCycl578KRHEf72ZJf1Q2MAnvtvycTKody0iauot+xF3pNzALPdIqHTn0Loq+PdPh1mYsDQdcC5atNRcjGw7Ylbn4LNUnIjPuYJPatLCAUmdOEKtXpCbbsKPbcDbVs6Vyet2DJm4REJuBprT3Xh1g3VJEOVh+lHV9dYKDVYGoDEkKaIkIfAaDIiW12IC6XZvDVEVX1Ut0Vp0QPQ6azPZyVGcNNdXZ28ftBYVIqcB16E7lw6r72hT31pytXYMXEKAGDgF5/Az9/+WQFzFADdIgqA6s/ETEi5noqv0v5CWmm2xc9DpYF4P2ki2gRbH162JqOY203z5yXgSE7tx7aPAGb3ufWig56GMQbVD1tQMG0prxgiAAQ+OBCRn81xaUXocj3Q7lPu76mTXD+9qPzuNxRMfd+iXfHovQhf/Krb10AdzeGS5FXXOQrY8AiXhsFWSi23oPqrUzWPpnSM5LZgD05w/9b7muiNXDD0exo3fVemq/34LtHA012AexKsT4+V6tT44Mz/sCv3lH390UWg+MZwaMqtJ2xSSIFXk4Extzl/BE2flYfcR1+DPo2ftMyvRwfEbvoYAmkDmsM3o1aWIC9hGAAg+vLvCAgKcdhjUwB0iygAqluO+gZ25/2DP64ewVW19TmpZoFRWNjjacQFhNf4OCYGpBdzawlO5AGHsoGMkrqfv2kw90Y1rLXnvvnby1hYjMI5y1G2cbvFz+QDkhDz3QKXvzm6OwACgOJP1qHo7c8s2qUdWyFy+SzIEt27Fmr2Lm5HVnUj2wOLB9Z//Y3OCKw9A3x8BCiqsH5MfBC3JmVIS9fsNnOUcj23ePuHs1x+otrEBAKjOwKPJQIRVgYHduWcwsrUzcitqGEhoBmDvhFKiwdBreqOmgogPNiWu66RjhuMqJF6y15cf3kRTMX8Ks2S5o0R+/snEEeFOb8TblReXoZPXuHW8U35cDX8/R2Xnp8CoFtEARBfqU6NLHUBMlV5OFuciTNFmTUGPZWGN7kdLySOgJ9ICoMJKFAD+Wogt3I3SRFwqZhLtKaq41thdV2iubUV9yQAIvfvonQoY7ESym9+RcnydTApLSskBwy7A1GfzYFAZt/231vhCQEQAJSu+QWF0z+8mSOokliE4GceRsgLj7stV5BKC9z3g+UC5Sc6cmvTahtRMP63s2tJivWkewAQJAVeSALG3QbIPCMTgN3SbgDf/MPlLqqopYSIRAjc25IbkekRyw/49CYD/sw6it+upuCCldFnANBpY1BW2g/qsu5gzPpQXKco4K3+zp/uArgkpkXvfg71ln0WPxPFRiLu908gadKA8nbUoMKgxaCtMwEA2+5ZALnYcSO4DTIAWrFiBd5//33k5eWhU6dOWL58OXr27Fnj8Rs2bMCcOXOQmZmJVq1aYdGiRRgyZEi9nssZAVDlZXbVegXGGAzMCL3JCL3JAI1RhwqDjvvTqIXGoEO5QQeVzgCV3gCVzgC1zoRSnQ7FWi1KNDqU6vQo0epQrjeBMQn/ZpKAMbFFu58wADHyaEgF/tAYuJT7heXArfyShfgBw1sDD7VzfOIxd2KMwXDtOjRHzqD8z31Q/3XAIsFhpeAJDyHs3RcgEDkuC64tPCUAAoCy33fj+gvzwdSWQyQCuQyB9w9A4COD4NezI4R+rp0aO1cAjPjRctqqRyy3M9G8FMt1NbA5jZvqyuIPBlQRC7kA4KWezl2M6w4lGmD9WeDrf7gvR7WJU3DB0N0tuKBFXu13MKf8Bs4UZeBqWQGylAyZN+KQUdAEV4trDoYj/IHpvbn3FWeOIhvyClG++yjK/rcdFbuPWj1G0ropYn9aCnFclPM64kEoALLBjz/+iLFjx2LlypVISkrCsmXLsGHDBly4cAGRkZa7ig4ePIh+/fphwYIFuO+++7Bu3TosWrQIJ06cQIcOHep8PmcEQCnpaZj3128QQgiRUASRQACRQAQRRBAJhBAK//sTwv92MgjAIISJCWFkIu4GIYxMXNWmZ0IYmZD70ySEnklgYCIYIeaOgxQmSGBiEpgggRGS/9q4nzF47hxzuESPfiEqDAhVol+IClKBlV9T819da7/K9fn1NjvG6kvC4rnqfhyYTDCVa2AqKwcrK4eprBwmZRkM2fnQZ+fDkHkNxoLiWrsmVAQg4sPpCLz/zrr/HU7kSQEQAOguZCDvqTkW6yeqE8ikkHVpB2nrphA3i4UoLASiEAWEwQoumaJICIFYDAiF3N+FQq4Y1i3ake+PKaciYWSWD9ZOoUVrhR5GBmSoJTinlILV8qR3R6oxrU0Rmgc4uNJqtV9Vi993xqz/3ey8Wl9/tbzurD2f3gRsv6HAt9ca4aSy7p0MYgFDglyDOJkeASITGIBCnRiXK2Qo0Nf+y+kvNGJMVCGeib2OQJGp3v2u9X2CMbAKLYxFpTAVK2EsKILu4lXo065An2F9dKpSwP0DELH0tQaRyb2+yvUaPLxhGgBg4yPvw1/i57DHbnABUFJSEnr06IFPPuHqH5lMJsTHx+OFF17AjBkzLI4fNWoU1Go1Nm/eXNV2++23o3Pnzli5cmWdz+eMAOjbHw9iTh5taaxJmLIAidf+Rfvss+h09RRa5aZBeEvjRt4v8OG7ETbnOYhj7Usd4EieFgABgEmjRcmH36H44+8Bg2dVjN/d7g4suH8O9GL7pivbZ5/Fszs/RcesM3Uf3MBciGmDX7s9gF2JA6GTOG5kQGLQ4v5jm/DYwe8RWl7isMe1lzAsGGFvPg/FY0PcvpPR1TxlEbTHzyTrdDocP34cM2fOrGoTCoUYOHAgUlJSrJ6TkpKCqVP5WwgHDx6MTZs2WT1eq9VCq7059aBU1jAWfQuMPv5hDgBiox5hqkJEleajyY0raFLI3ZoVZiJCed0RX769n1iEwOF3Ivj5UfDr3MASGjmY0E+GRjMnQPHovShe9h1UP24FjJ4RCN2RuhtRpfl4+6F5uB5c/3nb1jnnMfrAd+h7Ya/Pvh7a5F7A65sX4tmdn2JrpyHY0vk+ZIXbX8k4tKwIw078imEnfkVYWQ1pnl1IGKJA0PgRCHlhNERBjlv8S2zn8QFQYWEhjEYjoqL4c6NRUVE4f/681XPy8vKsHp+Xl2f1+AULFuDtt992TIdrYGKe8cZcH1K9FjKDFlK9FlKjDrLK+wYtZHod96fhvz/1WkgNumo/598P0KgRoSpAuKoQQRWlPvumXhthaBD8uici4J4+8L+nD8SRjdzdJQv+EuDKS+7uhXWS5nGI/GgGGs2cANXGbVBv2gXt6bT6TX86UbucVKxZORYbkx7Bzz0eQWlAiNXj5NpyJF88gPtO/oZOV07Ra+Q/wRVKjDq0HiMPrUd6ZAL2tLsDh1r2QnpUAkx1FENVVCiRfPEA+qbuQY/0I5Aa65mq2kmEigDI+3VDwL19ETD8TrenbXC3gKAQJBRYLgR3NY8PgFxh5syZvBEjpVKJ+Hjbk/bVpmlAIwRWcJn8BGAQMIbKCXUB49q4v3PtlW0Sow4Sgx5iowFSow5iowESo77qJjbqIfmvjQtMKm86SA03g5XKgKUyOOECFD0X4PwXuPgZdZAY9fw3YPN3Y2tDtRZtVo4RAgiotoLTyuNYDANbfa46nrs+/bP2CWN2jPUhadsfR+gvhyBQDmGgP4QB3J+imAiIG0dDEh8FSetmkLRo7HND4M4gjg5H6JTRCJ0yGsZSFTSHT0OXmgF9ejYM2XkwlqhgUpbBpFQDegOY0QgYTWAGo9NGjuT6CozZ/y1GH1iLM0064mJ0GxQqwiE2GhCiLkbL/ItIzP4XUqMNWyGdoa7XUfX7Nr4GBXafK6j6b8uyHLQ8tg5PH1uHCokfLkS1xrWQWBQoIqATSQGBACHlJQhX30Dr65cQV5p7cwo9QAYIZDU8R33u1+/fJpBJIQwNgig0CMKQIEiaxkLaphkkbZpBltjSY4r4kps8/v9IeHg4RCIR8vPzee35+fmIjrY+tBwdHW3T8TKZDDKZcyPyu+5LxNn7LNvpg48QxxMFKxAwqDcCBvWu9znOXg7ZyqmPXreG9F5jPY0hIbbx+EwqUqkU3bp1w86dO6vaTCYTdu7cieTkZKvnJCcn844HgO3bt9d4vCsIBAKrN0KIZ6jpNdpQboQQPo8fAQKAqVOnYty4cejevTt69uyJZcuWQa1W48knnwQAjB07FnFxcViwYAEA4KWXXkL//v2xdOlSDB06FOvXr8exY8fwxRdfuPOfQQghhBAP4RUB0KhRo1BQUIA333wTeXl56Ny5M7Zu3Vq10Pnq1asQVquL1KtXL6xbtw5vvPEGZs2ahVatWmHTpk31ygFECCGEkIbPK/IAuRqVwiCEEEK8jy2f3x6/BogQQgghxNEoACKEEEKIz6EAiBBCCCE+hwIgQgghhPgcCoAIIYQQ4nMoACKEEEKIz6EAiBBCCCE+hwIgQgghhPgcCoAIIYQQ4nO8ohSGq1Umx1YqlW7uCSGEEELqq/Jzuz5FLigAskKlUgEA4uPj3dwTQgghhNhKpVIhODi41mOoFpgVJpMJOTk5UCgUEAgEDn1spVKJ+Ph4ZGVlUZ0xJ6Lr7Bp0nV2DrrPr0LV2DWddZ8YYVCoVYmNjeUXSraERICuEQiEaN27s1OcICgqiF5cL0HV2DbrOrkHX2XXoWruGM65zXSM/lWgRNCGEEEJ8DgVAhBBCCPE5FAC5mEwmw9y5cyGTydzdlQaNrrNr0HV2DbrOrkPX2jU84TrTImhCCCGE+BwaASKEEEKIz6EAiBBCCCE+hwIgQgghhPgcCoAIIYQQ4nMoAHKCFStWoFmzZvDz80NSUhKOHDlS6/EbNmxA27Zt4efnh44dO2LLli0u6ql3s+U6r1q1Cn379kVoaChCQ0MxcODAOv+/EI6tv8+V1q9fD4FAgBEjRji3gw2Erde5pKQEkydPRkxMDGQyGVq3bk3vHfVg63VetmwZ2rRpA7lcjvj4eLzyyivQaDQu6q132rt3L4YNG4bY2FgIBAJs2rSpznN2796Nrl27QiaToWXLlvj666+d3k8w4lDr169nUqmUffXVV+zff/9lzzzzDAsJCWH5+flWjz9w4AATiURs8eLF7Ny5c+yNN95gEomEnTlzxsU99y62XufRo0ezFStWsJMnT7LU1FQ2fvx4FhwczLKzs13cc+9i63WulJGRweLi4ljfvn3Z/fff75rOejFbr7NWq2Xdu3dnQ4YMYfv372cZGRls9+7d7NSpUy7uuXex9TqvXbuWyWQytnbtWpaRkcH++usvFhMTw1555RUX99y7bNmyhc2ePZv9/PPPDAD75Zdfaj0+PT2d+fv7s6lTp7Jz586x5cuXM5FIxLZu3erUflIA5GA9e/ZkkydPrrpvNBpZbGwsW7BggdXjR44cyYYOHcprS0pKYs8++6xT++ntbL3O5gwGA1MoFOybb75xVhcbBHuus8FgYL169WKrV69m48aNowCoHmy9zp999hlr0aIF0+l0rupig2DrdZ48eTIbMGAAr23q1Kmsd+/eTu1nQ1KfAOj1119niYmJvLZRo0axwYMHO7FnjNEUmAPpdDocP34cAwcOrGoTCoUYOHAgUlJSrJ6TkpLCOx4ABg8eXOPxxL7rbK68vBx6vR6NGjVyVje9nr3Xed68eYiMjMTTTz/tim56PXuu82+//Ybk5GRMnjwZUVFR6NChA+bPnw+j0eiqbnsde65zr169cPz48appsvT0dGzZsgVDhgxxSZ99hbs+B6kYqgMVFhbCaDQiKiqK1x4VFYXz589bPScvL8/q8Xl5eU7rp7ez5zqbmz59OmJjYy1edOQme67z/v378eWXX+LUqVMu6GHDYM91Tk9Px65du/D4449jy5YtuHTpEiZNmgS9Xo+5c+e6ottex57rPHr0aBQWFqJPnz5gjMFgMOC5557DrFmzXNFln1HT56BSqURFRQXkcrlTnpdGgIjPWbhwIdavX49ffvkFfn5+7u5Og6FSqTBmzBisWrUK4eHh7u5Og2YymRAZGYkvvvgC3bp1w6hRozB79mysXLnS3V1rUHbv3o358+fj008/xYkTJ/Dzzz/jjz/+wDvvvOPurhEHoBEgBwoPD4dIJEJ+fj6vPT8/H9HR0VbPiY6Otul4Yt91rrRkyRIsXLgQO3bswG233ebMbno9W6/z5cuXkZmZiWHDhlW1mUwmAIBYLMaFCxeQkJDg3E57IXt+n2NiYiCRSCASiara2rVrh7y8POh0OkilUqf22RvZc53nzJmDMWPGYMKECQCAjh07Qq1WY+LEiZg9ezaEQhpDcISaPgeDgoKcNvoD0AiQQ0mlUnTr1g07d+6sajOZTNi5cyeSk5OtnpOcnMw7HgC2b99e4/HEvusMAIsXL8Y777yDrVu3onv37q7oqlez9Tq3bdsWZ86cwalTp6puw4cPx5133olTp04hPj7eld33Gvb8Pvfu3RuXLl2qCjABIC0tDTExMRT81MCe61xeXm4R5FQGnYzKaDqM2z4HnbrE2getX7+eyWQy9vXXX7Nz586xiRMnspCQEJaXl8cYY2zMmDFsxowZVccfOHCAicVitmTJEpaamsrmzp1L2+DrwdbrvHDhQiaVStnGjRtZbm5u1U2lUrnrn+AVbL3O5mgXWP3Yep2vXr3KFAoFmzJlCrtw4QLbvHkzi4yMZO+++667/glewdbrPHfuXKZQKNgPP/zA0tPT2bZt21hCQgIbOXKku/4JXkGlUrGTJ0+ykydPMgDsgw8+YCdPnmRXrlxhjDE2Y8YMNmbMmKrjK7fBT5s2jaWmprIVK1bQNnhvtXz5ctakSRMmlUpZz5492aFDh6p+1r9/fzZu3Dje8T/99BNr3bo1k0qlLDExkf3xxx8u7rF3suU6N23alAGwuM2dO9f1Hfcytv4+V0cBUP3Zep0PHjzIkpKSmEwmYy1atGDvvfceMxgMLu6197HlOuv1evbWW2+xhIQE5ufnx+Lj49mkSZNYcXGx6zvuRf7++2+r77eV13bcuHGsf//+Fud07tyZSaVS1qJFC7ZmzRqn91PAGI3jEUIIIcS30BogQgghhPgcCoAIIYQQ4nMoACKEEEKIz6EAiBBCCCE+hwIgQgghhPgcCoAIIYQQ4nMoACKEEEKIz6EAiBBCCCE+hwIgQgghhPgcCoAIIYQQ4nMoACKEEEKIz6EAiBDS4D3++OMQCAR49913LX6WkpICf39/hIWF4fz5827oHSHEHagYKiGkwbt8+TLatWuHwMBAZGRkIDg4GABw8eJF9OrVC2q1Gjt27ECvXr3c3FNCiKvQCBAhpMFLSEjA008/jeLiYnz44YcAgIKCAtx7770oLi7GDz/8QMEPIT6GRoAIIT4hJycHLVu2hFQqxb///ouHHnoIhw8fxueff46JEye6u3uEEBejESBCiE+IjY3FlClTUFpais6dO+Pw4cOYM2cOBT+E+CgaASKE+Izc3Fw0btwYJpMJ48ePx5o1a9zdJUKIm9AIECHEJzDGMHXqVJhMJgCAWCx2c48IIe5EARAhxCdMmzYN69evx5AhQxATE4Ovv/4aFy9edHe3CCFuQgEQIaTB++ijj7B06VL07NkTGzZswIwZM2AwGDBnzhx3d40Q4ia0BogQ0qBt2LABo0aNQosWLZCSkoKIiAhoNBq0bNkSOTk5OHHiBDp37uzubhJCXIxGgAghDdbevXsxZswYhIeHY+vWrYiIiAAA+Pn5YebMmWCMYfbs2W7uJSHEHWgEiBDSIJ07dw69e/eGTqfDrl27kJSUxPu5TqdDy5YtkZWVhX379qFPnz5u6ikhxB0oACKEEEKIz6EpMEIIIYT4HAqACCGEEOJzKAAihBBCiM+hAIgQQgghPocCIEIIIYT4HAqACCGEEOJzKAAihBBCiM+hAIgQQgghPocCIEIIIYT4HAqACCGEEOJzKAAihBBCiM+hAIgQQgghPocCIEIIIYT4nP8DO1arFxJVSt4AAAAASUVORK5CYII=\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# the acquisition function call takes a three-dimensional tensor\n",
     "fwd_X = X.unsqueeze(-1).unsqueeze(-1)\n",
@@ -487,20 +465,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "f7f639bb",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.17330018797192714\n",
-      "MES-LB: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.042861226761573626\n",
-      "JES-LB: candidate=tensor([[0.3879]], dtype=torch.float64), acq_value=0.5383259121881295\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from botorch.optim import optimize_acqf\n",
     "\n",
@@ -552,7 +520,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "fabc86e9",
    "metadata": {},
    "outputs": [],
@@ -586,7 +554,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "56bd5f5a",
    "metadata": {},
    "outputs": [],
@@ -620,19 +588,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "2c7dfaf0",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/hvarfner/Documents/botorch/botorch/models/gpytorch.py:96: BotorchTensorDimensionWarning: Non-strict enforcement of botorch tensor conventions. Ensure that target tensors Y has an explicit output dimension.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from botorch.acquisition.multi_objective.predictive_entropy_search import (\n",
     "    qMultiObjectivePredictiveEntropySearch,\n",
@@ -676,32 +635,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "ceac58f5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: \n",
-      "candidates=tensor([[0.0000, 0.0000, 0.5909, 0.0000],\n",
-      "        [0.0491, 0.0000, 0.0000, 0.4991],\n",
-      "        [0.0196, 0.5491, 0.0000, 0.0278],\n",
-      "        [0.1252, 0.0000, 0.0721, 0.0000]], dtype=torch.float64)\n",
-      "MES-LB: \n",
-      "candidates=tensor([[0.1225, 0.0000, 0.1670, 0.1139],\n",
-      "        [0.0300, 0.0040, 0.9779, 0.2452],\n",
-      "        [0.6412, 0.0117, 0.0516, 0.0337],\n",
-      "        [0.0000, 0.3417, 0.8467, 0.5234]], dtype=torch.float64)\n",
-      "JES-LB: \n",
-      "candidates=tensor([[0.1730, 0.2471, 0.1120, 0.0229],\n",
-      "        [0.0000, 0.2464, 0.3733, 0.4131],\n",
-      "        [0.1596, 0.0000, 0.5558, 0.1183],\n",
-      "        [0.7028, 0.0661, 0.0934, 0.0351]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "q = 4\n",
     "\n",

From 7a1074e7761247703ad3ab83f7e7be3806972cec Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 16:55:33 +0200
Subject: [PATCH 18/23] Added tutorial, sampling and JES reference change

---
 botorch/acquisition/joint_entropy_search.py   |  3 +--
 ...tion_theoretic_acquisition_functions.ipynb | 26 +++++++++++++++++--
 2 files changed, 25 insertions(+), 4 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 36adfb5fb5..495bb8e763 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -5,8 +5,7 @@
 # LICENSE file in the root directory of this source tree.
 
 r"""
-Acquisition function for joint entropy search (JES). The code utilizes the
-implementation designed for the multi-objective batch setting.
+Acquisition function for joint entropy search (JES).
 
 """
 
diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 58c053edb0..4b02dea8d7 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -676,10 +676,32 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "id": "ceac58f5",
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "PES: \n",
+      "candidates=tensor([[0.0000, 0.0000, 0.5909, 0.0000],\n",
+      "        [0.0491, 0.0000, 0.0000, 0.4991],\n",
+      "        [0.0196, 0.5491, 0.0000, 0.0278],\n",
+      "        [0.1252, 0.0000, 0.0721, 0.0000]], dtype=torch.float64)\n",
+      "MES-LB: \n",
+      "candidates=tensor([[0.1225, 0.0000, 0.1670, 0.1139],\n",
+      "        [0.0300, 0.0040, 0.9779, 0.2452],\n",
+      "        [0.6412, 0.0117, 0.0516, 0.0337],\n",
+      "        [0.0000, 0.3417, 0.8467, 0.5234]], dtype=torch.float64)\n",
+      "JES-LB: \n",
+      "candidates=tensor([[0.1730, 0.2471, 0.1120, 0.0229],\n",
+      "        [0.0000, 0.2464, 0.3733, 0.4131],\n",
+      "        [0.1596, 0.0000, 0.5558, 0.1183],\n",
+      "        [0.7028, 0.0661, 0.0934, 0.0351]], dtype=torch.float64)\n"
+     ]
+    }
+   ],
    "source": [
     "q = 4\n",
     "\n",

From 8c3cebd5763571e11e43f74c695e7e1ebd0577ff Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 17:02:54 +0200
Subject: [PATCH 19/23] Modified tutorials - finished

---
 ...tion_theoretic_acquisition_functions.ipynb | 95 ++++---------------
 1 file changed, 16 insertions(+), 79 deletions(-)

diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 4b02dea8d7..e1e440607c 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -250,7 +250,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": null,
    "id": "908e289f",
    "metadata": {},
    "outputs": [],
@@ -287,7 +287,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": null,
    "id": "5770f703",
    "metadata": {},
    "outputs": [],
@@ -319,21 +319,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": null,
    "id": "877a342b",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "import matplotlib.pyplot as plt\n",
     "\n",
@@ -365,7 +354,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": null,
    "id": "79e93848",
    "metadata": {},
    "outputs": [],
@@ -393,7 +382,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": null,
    "id": "320b07cc",
    "metadata": {},
    "outputs": [],
@@ -432,21 +421,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": null,
    "id": "382e37f4",
    "metadata": {},
-   "outputs": [
-    {
-     "data": {
-      "image/png": "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\n",
-      "text/plain": [
-       "<Figure size 640x480 with 1 Axes>"
-      ]
-     },
-     "metadata": {},
-     "output_type": "display_data"
-    }
-   ],
+   "outputs": [],
    "source": [
     "# the acquisition function call takes a three-dimensional tensor\n",
     "fwd_X = X.unsqueeze(-1).unsqueeze(-1)\n",
@@ -487,20 +465,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 8,
+   "execution_count": null,
    "id": "f7f639bb",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.17330018797192714\n",
-      "MES-LB: candidate=tensor([[1.]], dtype=torch.float64), acq_value=0.042861226761573626\n",
-      "JES-LB: candidate=tensor([[0.3879]], dtype=torch.float64), acq_value=0.5383259121881295\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from botorch.optim import optimize_acqf\n",
     "\n",
@@ -552,7 +520,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": null,
    "id": "fabc86e9",
    "metadata": {},
    "outputs": [],
@@ -586,7 +554,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": null,
    "id": "56bd5f5a",
    "metadata": {},
    "outputs": [],
@@ -620,19 +588,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": null,
    "id": "2c7dfaf0",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stderr",
-     "output_type": "stream",
-     "text": [
-      "/home/hvarfner/Documents/botorch/botorch/models/gpytorch.py:96: BotorchTensorDimensionWarning: Non-strict enforcement of botorch tensor conventions. Ensure that target tensors Y has an explicit output dimension.\n",
-      "  warnings.warn(\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "from botorch.acquisition.multi_objective.predictive_entropy_search import (\n",
     "    qMultiObjectivePredictiveEntropySearch,\n",
@@ -676,32 +635,10 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": null,
    "id": "ceac58f5",
    "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "PES: \n",
-      "candidates=tensor([[0.0000, 0.0000, 0.5909, 0.0000],\n",
-      "        [0.0491, 0.0000, 0.0000, 0.4991],\n",
-      "        [0.0196, 0.5491, 0.0000, 0.0278],\n",
-      "        [0.1252, 0.0000, 0.0721, 0.0000]], dtype=torch.float64)\n",
-      "MES-LB: \n",
-      "candidates=tensor([[0.1225, 0.0000, 0.1670, 0.1139],\n",
-      "        [0.0300, 0.0040, 0.9779, 0.2452],\n",
-      "        [0.6412, 0.0117, 0.0516, 0.0337],\n",
-      "        [0.0000, 0.3417, 0.8467, 0.5234]], dtype=torch.float64)\n",
-      "JES-LB: \n",
-      "candidates=tensor([[0.1730, 0.2471, 0.1120, 0.0229],\n",
-      "        [0.0000, 0.2464, 0.3733, 0.4131],\n",
-      "        [0.1596, 0.0000, 0.5558, 0.1183],\n",
-      "        [0.7028, 0.0661, 0.0934, 0.0351]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
+   "outputs": [],
    "source": [
     "q = 4\n",
     "\n",

From 9d6c638bd37000f279068c93ddba6a3a1116077c Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Tue, 18 Apr 2023 17:26:01 +0200
Subject: [PATCH 20/23] Matplotlib import disappeared

---
 tutorials/information_theoretic_acquisition_functions.ipynb | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 7fa73af49f..72a975d9ee 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -257,6 +257,7 @@
    "source": [
     "import os\n",
     "\n",
+    "import matplotlib.pyplot as plt\n",
     "import torch\n",
     "import numpy as np\n",
     "from botorch.utils.sampling import draw_sobol_samples\n",
@@ -553,7 +554,7 @@
   {
    "cell_type": "code",
    "execution_count": 14,
-   "id": "fabc86e9",
+   "id": "34787908",
    "metadata": {},
    "outputs": [],
    "source": [
@@ -707,7 +708,7 @@
   {
    "cell_type": "code",
    "execution_count": 19,
-   "id": "ceac58f5",
+   "id": "d9281308",
    "metadata": {},
    "outputs": [
     {

From e543c550e0f0fca974a3a0fe70e4ee963b44fb89 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Sat, 22 Apr 2023 11:28:38 +0200
Subject: [PATCH 21/23] Formatting changes

---
 botorch/acquisition/input_constructors.py   | 2 --
 botorch/acquisition/joint_entropy_search.py | 9 +--------
 test/acquisition/test_utils.py              | 1 -
 test/utils/test_sampling.py                 | 2 --
 4 files changed, 1 insertion(+), 13 deletions(-)

diff --git a/botorch/acquisition/input_constructors.py b/botorch/acquisition/input_constructors.py
index 05803fd2d6..5ecf3afc03 100644
--- a/botorch/acquisition/input_constructors.py
+++ b/botorch/acquisition/input_constructors.py
@@ -48,7 +48,6 @@
     qKnowledgeGradient,
     qMultiFidelityKnowledgeGradient,
 )
-from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 from botorch.acquisition.max_value_entropy_search import (
     qMaxValueEntropy,
     qMultiFidelityMaxValueEntropy,
@@ -87,7 +86,6 @@
     get_optimal_samples,
     project_to_target_fidelity,
 )
-from botorch.acquisition.utils import get_optimal_samples
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models.cost import AffineFidelityCostModel
 from botorch.models.deterministic import FixedSingleSampleModel
diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 258b131db1..13615e78d1 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -27,9 +27,6 @@
 from math import log, pi
 
 from typing import Any, Optional
-import warnings
-from math import pi
-import torch.distributions as dist
 
 import torch
 from botorch import settings
@@ -43,11 +40,7 @@
 from botorch.models.utils import check_no_nans, fantasize as fantasize_flag
 from botorch.sampling.normal import SobolQMCNormalSampler
 from botorch.utils.transforms import concatenate_pending_points, t_batch_mode_transform
-from botorch.acquisition.monte_carlo import MCAcquisitionFunction
-from botorch.acquisition.acquisition import AcquisitionFunction, MCSamplerMixin
-from botorch.sampling.normal import SobolQMCNormalSampler
-from botorch.utils.transforms import is_fully_bayesian
-from botorch.exceptions.warnings import BotorchTensorDimensionWarning
+from torch import Tensor
 
 from torch.distributions import Normal
 
diff --git a/test/acquisition/test_utils.py b/test/acquisition/test_utils.py
index 8ecad7a2dc..41b4384e85 100644
--- a/test/acquisition/test_utils.py
+++ b/test/acquisition/test_utils.py
@@ -26,7 +26,6 @@
     project_to_sample_points,
     project_to_target_fidelity,
     prune_inferior_points,
-    get_optimal_samples,
 )
 from botorch.exceptions.errors import UnsupportedError
 from botorch.models import SingleTaskGP
diff --git a/test/utils/test_sampling.py b/test/utils/test_sampling.py
index c9f54c2063..85fcc8bbc1 100644
--- a/test/utils/test_sampling.py
+++ b/test/utils/test_sampling.py
@@ -31,9 +31,7 @@
     sample_hypersphere,
     sample_simplex,
     sparse_to_dense_constraints,
-    optimize_posterior_samples,
 )
-from botorch.sampling.pathwise import draw_matheron_paths
 from botorch.utils.testing import BotorchTestCase
 
 

From 9583008b5e71e90e0ad02aec11af46b906a2edd5 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Sun, 23 Apr 2023 12:09:09 +0200
Subject: [PATCH 22/23] Added FB test to JES, smoke test to tutorial and
 excluded one line in sampling.py from tests.

---
 botorch/acquisition/joint_entropy_search.py   |  9 ++-
 botorch/utils/sampling.py                     |  2 +-
 test/acquisition/test_joint_entropy_search.py | 13 ++++
 ...tion_theoretic_acquisition_functions.ipynb | 70 ++++++++++++-------
 4 files changed, 61 insertions(+), 33 deletions(-)

diff --git a/botorch/acquisition/joint_entropy_search.py b/botorch/acquisition/joint_entropy_search.py
index 13615e78d1..10d2f12b10 100644
--- a/botorch/acquisition/joint_entropy_search.py
+++ b/botorch/acquisition/joint_entropy_search.py
@@ -7,7 +7,6 @@
 r"""
 Acquisition function for joint entropy search (JES).
 
-References
 .. [Hvarfner2022joint]
     C. Hvarfner, F. Hutter, L. Nardi,
     Joint Entropy Search for Maximally-informed Bayesian Optimization.
@@ -91,10 +90,10 @@ def __init__(
             optimal_outputs: A `num_samples x 1`-dim Tensor containing the optimal
                 set of objectives of dimension `1`.
             condition_noiseless: Whether to condition on noiseless optimal observations
-                f* [Hvarfner et. al.]or noisy optimal observations y* [Tu et. al,].
-                These are sampled identically, so this only controls the fashion in
-                which the GP is reshaped as a result of conditioning on the optimum.
-            posterior_transform: A PosteriorTransform (optional).
+                `f*` [Hvarfner2022joint]_ or noisy optimal observations `y*`
+                [Tu2022joint]_. These are sampled identically, so this only controls
+                the fashion in which the GP is reshaped as a result of conditioning
+                on the optimum.
             estimation_type: estimation_type: A string to determine which entropy
                 estimate is computed: Lower bound" ("LB") or "Monte Carlo" ("MC").
                 Lower Bound is recommended due to the relatively high variance
diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index 134436b537..d48256b910 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -32,7 +32,7 @@
 
 
 if TYPE_CHECKING:
-    from botorch.sampling.pathwise.path import SamplePath
+    from botorch.sampling.pathwise.paths import SamplePath # pragma: no cover
 
 
 @contextmanager
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index b6e98cc66f..95144001eb 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -10,6 +10,7 @@
 from botorch.acquisition.joint_entropy_search import qJointEntropySearch
 
 from botorch.models.gp_regression import SingleTaskGP
+from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
 from botorch.models.model_list_gp_regression import ModelListGP
 from botorch.models.transforms.outcome import Standardize
 from botorch.sampling.normal import SobolQMCNormalSampler
@@ -123,3 +124,15 @@ def test_joint_entropy_search(self):
                 maximize=maximize,
             )
             acq_X = acq(test_Xs[j])
+        
+        # Support with fully bayesian models is not yet implemented. Thus, we
+        #throw an error for now.
+        fully_bayesian_model = SaasFullyBayesianSingleTaskGP(train_X, train_Y)
+        with self.assertRaises(NotImplementedError):
+            acq = qJointEntropySearch(
+                model=fully_bayesian_model,
+                optimal_inputs=optimal_inputs,
+                optimal_outputs=optimal_outputs,
+                estimation_type="LB",
+            )
+            
\ No newline at end of file
diff --git a/tutorials/information_theoretic_acquisition_functions.ipynb b/tutorials/information_theoretic_acquisition_functions.ipynb
index 5bc14b4fce..ae983ecdd6 100644
--- a/tutorials/information_theoretic_acquisition_functions.ipynb
+++ b/tutorials/information_theoretic_acquisition_functions.ipynb
@@ -252,7 +252,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "908e289f",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "import os\n",
@@ -266,6 +268,7 @@
     "from gpytorch.mlls.exact_marginal_log_likelihood import ExactMarginalLogLikelihood\n",
     "from botorch.fit import fit_gpytorch_mll\n",
     "\n",
+    "SMOKE_TEST = os.environ.get(\"SMOKE_TEST\")\n",
     "tkwargs = {\"dtype\": torch.double, \"device\": \"cpu\"}\n",
     "\n",
     "\n",
@@ -292,7 +295,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "5770f703",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "torch.manual_seed(0)\n",
@@ -324,7 +329,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "877a342b",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "X = torch.linspace(bounds[0, 0], bounds[1, 0], 1000, **tkwargs)\n",
@@ -355,7 +362,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "79e93848",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from botorch.acquisition.utils import get_optimal_samples\n",
@@ -383,7 +392,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "320b07cc",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from botorch.acquisition.predictive_entropy_search import qPredictiveEntropySearch\n",
@@ -422,7 +433,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "382e37f4",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "# the acquisition function call takes a three-dimensional tensor\n",
@@ -466,7 +479,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "f7f639bb",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from botorch.optim import optimize_acqf\n",
@@ -521,7 +536,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "fabc86e9",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from botorch.test_functions.multi_objective import ZDT1\n",
@@ -542,9 +559,11 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": null,
    "id": "34787908",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "problem = ZDT1(dim=d, num_objectives=M, noise_std=0, negate=True)\n",
@@ -568,7 +587,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "56bd5f5a",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "num_pareto_samples = 10\n",
@@ -602,7 +623,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "2c7dfaf0",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "from botorch.acquisition.multi_objective.predictive_entropy_search import (\n",
@@ -649,7 +672,9 @@
    "cell_type": "code",
    "execution_count": null,
    "id": "ceac58f5",
-   "metadata": {},
+   "metadata": {
+    "tags": []
+   },
    "outputs": [],
    "source": [
     "%%time\n",
@@ -678,21 +703,12 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 19,
+   "execution_count": null,
    "id": "d9281308",
-   "metadata": {},
-   "outputs": [
-    {
-     "name": "stdout",
-     "output_type": "stream",
-     "text": [
-      "JES-LB: \n",
-      "candidates=tensor([[0.0716, 0.0485, 0.1316, 0.1244],\n",
-      "        [0.3201, 0.0000, 0.0165, 0.4576],\n",
-      "        [0.6217, 0.0258, 0.2651, 0.0496]], dtype=torch.float64)\n"
-     ]
-    }
-   ],
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [],
    "source": [
     "# Sequentially greedy optimization\n",
     "candidates, acq_values = optimize_acqf(\n",

From 682b2720c5155e558b7325494370aa3e6bfd3775 Mon Sep 17 00:00:00 2001
From: Carl Hvarfner <carl.hvarfner@live.se>
Date: Sun, 23 Apr 2023 12:16:20 +0200
Subject: [PATCH 23/23] Formatting

---
 botorch/utils/sampling.py                     | 2 +-
 test/acquisition/test_joint_entropy_search.py | 7 +++----
 2 files changed, 4 insertions(+), 5 deletions(-)

diff --git a/botorch/utils/sampling.py b/botorch/utils/sampling.py
index d48256b910..8287e64e21 100644
--- a/botorch/utils/sampling.py
+++ b/botorch/utils/sampling.py
@@ -32,7 +32,7 @@
 
 
 if TYPE_CHECKING:
-    from botorch.sampling.pathwise.paths import SamplePath # pragma: no cover
+    from botorch.sampling.pathwise.paths import SamplePath  # pragma: no cover
 
 
 @contextmanager
diff --git a/test/acquisition/test_joint_entropy_search.py b/test/acquisition/test_joint_entropy_search.py
index 95144001eb..1b4d239c2d 100644
--- a/test/acquisition/test_joint_entropy_search.py
+++ b/test/acquisition/test_joint_entropy_search.py
@@ -8,9 +8,9 @@
 
 import torch
 from botorch.acquisition.joint_entropy_search import qJointEntropySearch
+from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
 
 from botorch.models.gp_regression import SingleTaskGP
-from botorch.models.fully_bayesian import SaasFullyBayesianSingleTaskGP
 from botorch.models.model_list_gp_regression import ModelListGP
 from botorch.models.transforms.outcome import Standardize
 from botorch.sampling.normal import SobolQMCNormalSampler
@@ -124,9 +124,9 @@ def test_joint_entropy_search(self):
                 maximize=maximize,
             )
             acq_X = acq(test_Xs[j])
-        
+
         # Support with fully bayesian models is not yet implemented. Thus, we
-        #throw an error for now.
+        # throw an error for now.
         fully_bayesian_model = SaasFullyBayesianSingleTaskGP(train_X, train_Y)
         with self.assertRaises(NotImplementedError):
             acq = qJointEntropySearch(
@@ -135,4 +135,3 @@ def test_joint_entropy_search(self):
                 optimal_outputs=optimal_outputs,
                 estimation_type="LB",
             )
-            
\ No newline at end of file