diff --git a/.gitignore b/.gitignore index 2f319e19c6e6ff37c1e0e8ab49729af9aa040cd3..ce12c01cb5b536c72191410ae6c37b7db342b0d7 100644 --- a/.gitignore +++ b/.gitignore @@ -8,6 +8,7 @@ __pycache__ # Data scratch/ artifacts/ +artifacts_old/ lightning_logs/ LHCb_Pipeline/output/ LHCb_Pipeline/analysis/ diff --git a/.vscode/launch.json b/.vscode/launch.json index f206ccc6b8cd378c9d36c1b4be1dabd00565950d..b3da7cf2d463bbebc5807c97b2ff9f9b2d34d52f 100644 --- a/.vscode/launch.json +++ b/.vscode/launch.json @@ -12,6 +12,14 @@ "console": "integratedTerminal", "justMyCode": true, "cwd": "/home/fgias/etx4velo/LHCb_Pipeline/" - } - ] + }, + { + "name": "anthonyc", + "type": "python", + "request": "launch", + "program": "${file}", + "console": "integratedTerminal", + "cwd": "${fileDirname}" + }, + ], } \ No newline at end of file diff --git a/.vscode/settings.json b/.vscode/settings.json index 2364b7bbfea1dabaebb76063505827875cf1c732..a56d0d3c4948a14ce812af5a8c9eff03c865274d 100644 --- a/.vscode/settings.json +++ b/.vscode/settings.json @@ -4,5 +4,8 @@ "./montetracko" ], "python.linting.flake8Enabled": true, - "python.linting.enabled": true + "python.linting.enabled": true, + "[python]": { + "editor.defaultFormatter": "ms-python.black-formatter" + }, } \ No newline at end of file diff --git a/LHCb_Pipeline/Embedding/build_embedding.py b/LHCb_Pipeline/Embedding/build_embedding.py index d1bc0793fd3762654ed0c10c727589766b303e97..ac2958573daa14924c704d5f209b88014406a54c 100644 --- a/LHCb_Pipeline/Embedding/build_embedding.py +++ b/LHCb_Pipeline/Embedding/build_embedding.py @@ -1,9 +1,14 @@ +from __future__ import annotations +from types import ModuleType import torch from torch_geometric.data import Data from Embedding.embedding_base import EmbeddingBase from utils.modelutils.build import ModelBuilderBase from utils.commonutils.config import load_config +from utils.graphutils.edgeutils import sort_edge_nodes + +from . import building_custom device = "cuda" if torch.cuda.is_available() else "cpu" @@ -35,44 +40,117 @@ class EmbeddingInferenceBuilder(ModelBuilderBase): model: EmbeddingBase, knn_max: int = 1000, radius: float = 0.1, + bidir: bool | None = None, ): super(EmbeddingInferenceBuilder, self).__init__(model=model) self.knn_max = knn_max self.radius = radius + self._bidir = bidir - def construct_downstream(self, batch: Data): - batch = self.select_data(batch) + @property + def bidir(self) -> bool: + """Whether to use a bi-directional graph""" + if self._bidir is None: + return self.model.hparams.get("bidir", True) + else: + return self.bidir + def construct_downstream(self, batch: Data): y_cluster, e_spatial, e_bidir = self.get_performance( batch=batch, r_max=self.radius, k_max=self.knn_max ) - module_mask = batch.plane[e_spatial[0]] != batch.plane[e_spatial[1]] - y_cluster = y_cluster[module_mask] - e_spatial = e_spatial[:, module_mask] - # Arbitrary ordering to remove half of the duplicate edges - # TODO: if one wants to really do that, why not ordering the indices instead? - R_dist = torch.sqrt(batch.x[:, 0] ** 2 + batch.x[:, 2] ** 2) - e_spatial = e_spatial[:, (R_dist[e_spatial[0]] <= R_dist[e_spatial[1]])] + # Remove Edges within a same plane + plane_mask = batch.plane[e_spatial[0]] != batch.plane[e_spatial[1]] + y_cluster = y_cluster[plane_mask] + e_spatial = e_spatial[:, plane_mask] - e_spatial, y_cluster = self.model.get_truth(batch, e_spatial, e_bidir) + if self.bidir: + # Arbitrary ordering to remove half of the duplicate edges + # TODO: if one wants to really do that, why not ordering the indices instead? + R_dist = torch.sqrt(batch.x[:, 0] ** 2 + batch.x[:, 2] ** 2) + e_spatial = e_spatial[:, (R_dist[e_spatial[0]] <= R_dist[e_spatial[1]])] - # Re-introduce random direction, to avoid training bias - random_flip = torch.randint(2, (e_spatial.shape[1],)).bool() - e_spatial[0, random_flip], e_spatial[1, random_flip] = ( - e_spatial[1, random_flip], - e_spatial[0, random_flip], - ) + e_spatial, y_cluster = self.model.get_truth(batch, e_spatial, e_bidir) - batch.edge_index = e_spatial - batch.y = y_cluster + if self.bidir: + # Re-introduce random direction, to avoid training bias + random_flip = torch.randint(2, (e_spatial.shape[1],)).bool() + e_spatial[0, random_flip], e_spatial[1, random_flip] = ( + e_spatial[1, random_flip], + e_spatial[0, random_flip], + ) + else: + # Do the opposite: enforce a direction + sort_edge_nodes(e_spatial, batch.un_z) + # Remove duplicates + e_spatial, unique_inverse = torch.unique( + e_spatial, dim=1, return_inverse=True + ) + unique_indices = torch.unique(unique_inverse) + y_cluster = y_cluster[unique_indices] + + assert e_spatial.shape[1] == torch.unique(e_spatial, dim=1).shape[1] + + batch["edge_index"] = e_spatial + batch["y"] = y_cluster + return batch + + def _get_building_custom_module(self) -> ModuleType: + return building_custom + + # def filter_batch(self, batch: Data) -> Data: + # # at least 3 hits to be classified as valid edges + # # not_reconstructible_mask = batch.n_unique_planes < 3 + # not_reconstructible_mask = batch.nhits_velo < 3 + + # # Apply this transformation to `y` as well + # not_reconstructible_edge_mask = ( + # not_reconstructible_mask[batch.edge_index].min(dim=0).values + # ) + + # batch.y[not_reconstructible_edge_mask] = False + + # # Classify the hits as fake (so that the edges are also classified like so) + # batch.particle_id[not_reconstructible_mask] = 0 + + # # Remove edges in same `plane` and `z` + # edge_index_plane = batch.plane[batch.edge_index] + # no_self_edge_mask = edge_index_plane[0] != edge_index_plane[1] + # batch.edge_index = batch.edge_index[:, no_self_edge_mask] + # batch.y = batch.y[no_self_edge_mask] + + # return batch + + # def build_features(self, batch: Data) -> Data: + # # norm_x = batch.un_x / 14.5 + # # norm_y = batch.un_y / 14.5 + # # xe = batch.un_x[batch.edge_index] + # # ye = batch.un_y[batch.edge_index] + # # ze = batch.un_z[batch.edge_index] + + # # slopes_yz = (ye[1] - ye[0]) / (ze[1] - ze[0]) / 0.17 + # # slopes_xz = (xe[1] - xe[0]) / (ze[1] - ze[0]) / 0.17 + + # # assert not torch.isnan(slopes_yz).any() + # # assert not torch.isnan(slopes_xz).any() + # # # Modify batch definition + # # batch.x = torch.stack((norm_x, norm_y, batch["x"][:, 2]), dim=1).float() + # # batch.edge_features = torch.stack((slopes_xz, slopes_yz), dim=1).float() + # return batch + + # def build_weights(self, batch: Data) -> Data: + # node_weights = 7.0 / batch.n_unique_planes + # node_weights = torch.nan_to_num(node_weights, nan=1.0) + # edge_weights = torch.mean(node_weights[batch.edge_index], dim=0) + # batch.edge_weights = ( + # edge_weights * batch.edge_index.shape[1] / edge_weights.sum() + # ) + # assert not torch.isnan(batch.edge_weights).any(), str(batch.edge_weights) + # return batch def get_performance(self, batch: Data, r_max: float, k_max: int): with torch.no_grad(): results = self.model.shared_evaluation(batch, 0, r_max, k_max) return results["truth"], results["preds"], results["truth_graph"] - - def select_data(self, event: Data) -> Data: - event.signal_true_edges = event.modulewise_true_edges - return event diff --git a/LHCb_Pipeline/Embedding/building_custom.py b/LHCb_Pipeline/Embedding/building_custom.py new file mode 100644 index 0000000000000000000000000000000000000000..2b0fb9b5905496327468ea61f72a8028d34ba4ec --- /dev/null +++ b/LHCb_Pipeline/Embedding/building_custom.py @@ -0,0 +1,57 @@ +"""Custom functions for filtering and alterning an event. +""" +import torch +from torch_geometric.data import Data + + +def edges_at_least_3_hits(batch: Data) -> Data: + # at least 3 hits to be classified as valid edges + # not_reconstructible_mask = batch.n_unique_planes < 3 + not_reconstructible_mask = batch.nhits_velo < 3 + + # Apply this transformation to `y` as well + not_reconstructible_edge_mask = ( + not_reconstructible_mask[batch.edge_index].min(dim=0).values + ) + + batch.y[not_reconstructible_edge_mask] = False + + # Classify the hits as fake (so that the edges are also classified like so) + batch.particle_id[not_reconstructible_mask] = 0 + + # Remove edges in same `plane` and `z` + edge_index_plane = batch.plane[batch.edge_index] + no_self_edge_mask = edge_index_plane[0] != edge_index_plane[1] + batch["edge_index"] = batch.edge_index[:, no_self_edge_mask] + batch["y"] = batch.y[no_self_edge_mask] + return batch + + +def edge_features_as_slope(batch: Data) -> Data: + """Build edge features that correspond to the slope.""" + norm_x = batch.un_x / 14.5 + norm_y = batch.un_y / 14.5 + xe = batch.un_x[batch.edge_index] + ye = batch.un_y[batch.edge_index] + ze = batch.un_z[batch.edge_index] + + slopes_yz = (ye[1] - ye[0]) / (ze[1] - ze[0]) / 0.17 + slopes_xz = (xe[1] - xe[0]) / (ze[1] - ze[0]) / 0.17 + + assert not torch.isnan(slopes_yz).any() + assert not torch.isnan(slopes_xz).any() + # Modify batch definition + batch["x"] = torch.stack((norm_x, norm_y, batch["x"][:, 2]), dim=1).float() + batch["edge_features"] = torch.stack((slopes_xz, slopes_yz), dim=1).float() + + return batch + + +def weights_inversely_proportional_to_nhits(batch: Data) -> Data: + """Define edge weights that are inversely proportional to the number of hits.""" + node_weights = 7.0 / batch.n_unique_planes + node_weights = torch.nan_to_num(node_weights, nan=1.0) + edge_weights = torch.mean(node_weights[batch.edge_index], dim=0) + batch.edge_weights = edge_weights * batch.edge_index.shape[1] / edge_weights.sum() + assert not torch.isnan(batch.edge_weights).any(), str(batch.edge_weights) + return batch diff --git a/LHCb_Pipeline/Embedding/embedding_base.py b/LHCb_Pipeline/Embedding/embedding_base.py index 89bcfb46df906e6fe1ab58efe3654e593000b5a7..27d4ecdce353aed095585dfde47ee7b9ed6272fc 100644 --- a/LHCb_Pipeline/Embedding/embedding_base.py +++ b/LHCb_Pipeline/Embedding/embedding_base.py @@ -28,7 +28,7 @@ from torch_geometric.data import Data from utils.modelutils.basemodel import ModelBase from utils.commonutils.config import load_config from .graphutils import graph_intersection, build_edges - +from utils.graphutils.edgeutils import sort_edge_nodes device = "cuda" if torch.cuda.is_available() else "cpu" @@ -36,21 +36,10 @@ device = "cuda" if torch.cuda.is_available() else "cpu" class EmbeddingBase(ModelBase): """A class that implements the metric learning model.""" - def load_dataset(self, input_path: str) -> Data: - """Load and process one PyTorch DataSet. - - Args: - input_path: path to the PyTorch dataset - - Returns: - PyTorch DataSet - """ - loaded_event = super(EmbeddingBase, self).load_dataset(input_path=input_path) - # Define which column corresponds to the true edges - loaded_event["signal_true_edges"] = loaded_event[ - self.hparams["true_edges_column"] - ] - return loaded_event + @property + def bidir(self) -> bool: + """Whether the graph to build is bidirectional.""" + return self.hparams.get("bidir", True) def get_query_points(self, batch, spatial): if "query_all_points" in self.hparams["regime"]: @@ -161,7 +150,6 @@ class EmbeddingBase(ModelBase): Returns: ``torch.tensor`` The loss function as a tensor """ - # Instantiate empty prediction edge list e_spatial = torch.empty([2, 0], dtype=torch.int64, device=self.device) @@ -182,9 +170,12 @@ class EmbeddingBase(ModelBase): e_spatial = self.append_random_pairs(e_spatial, query_indices, spatial) # Instantiate bidirectional truth (since KNN prediction will be bidirectional) - e_bidir = torch.cat( - (batch.signal_true_edges, batch.signal_true_edges.flip(0)), dim=-1 - ) + if self.bidir: + e_bidir = torch.cat( + (batch.signal_true_edges, batch.signal_true_edges.flip(0)), dim=-1 + ) + else: + e_bidir = batch.signal_true_edges # Calculate truth from intersection between Prediction graph and Truth graph e_spatial, y_cluster = self.get_truth(batch, e_spatial, e_bidir) @@ -194,13 +185,16 @@ class EmbeddingBase(ModelBase): e_spatial, y_cluster, new_weights = self.get_true_pairs( e_spatial, y_cluster, new_weights, e_bidir ) + if not self.bidir: # is it really what I want? + sort_edge_nodes(e_spatial, batch.z) included_hits = e_spatial.unique() spatial[included_hits] = self(input_data[included_hits]) hinge, d = self.get_hinge_distance(spatial, e_spatial, y_cluster) - # Give negative examples a weight of 1 (note that there may still be TRUE examples that are weightless) + # Give negative examples a weight of 1 + # (note that there may still be TRUE examples that are weightless) new_weights[hinge == -1] = 1 negative_loss = torch.nn.functional.hinge_embedding_loss( @@ -223,7 +217,6 @@ class EmbeddingBase(ModelBase): "train_loss", loss, on_epoch=True, - on_step=False, batch_size=e_spatial.shape[1], prog_bar=True, ) @@ -236,16 +229,23 @@ class EmbeddingBase(ModelBase): input_data = self.get_input_data(batch) spatial = self(input_data) - e_bidir = torch.cat( - (batch.signal_true_edges, batch.signal_true_edges.flip(0)), dim=-1 - ) + if self.bidir: + e_bidir = torch.cat( + (batch.signal_true_edges, batch.signal_true_edges.flip(0)), dim=-1 + ) + else: + e_bidir = batch.signal_true_edges # Build whole KNN graph e_spatial = build_edges( spatial, spatial, indices=None, r_max=knn_radius, k_max=knn_num ) + if not self.bidir: + sort_edge_nodes(e_spatial, batch.un_z) e_spatial, y_cluster = self.get_truth(batch, e_spatial, e_bidir) + if not self.bidir: + sort_edge_nodes(e_spatial, batch.un_z) hinge, d = self.get_hinge_distance( spatial, e_spatial.to(self.device), y_cluster @@ -259,7 +259,6 @@ class EmbeddingBase(ModelBase): cluster_true_positive = y_cluster.sum() cluster_positive = len(e_spatial[0]) - # what is this? eff = cluster_true_positive / cluster_true pur = cluster_true_positive / cluster_positive @@ -331,8 +330,8 @@ def get_example_data( metric_learning_configs = configs["metric_learning"] model = EmbeddingBase(metric_learning_configs) - model.setup(stage="fit") - training_example = model.trainset[idx] + # model.setup(stage="fit") + training_example = model.valset[idx] example_hit_inputs = model.get_input_data(training_example) example_hit_df = pd.DataFrame(example_hit_inputs.numpy()) diff --git a/LHCb_Pipeline/Embedding/embedding_plots.py b/LHCb_Pipeline/Embedding/embedding_plots.py new file mode 100644 index 0000000000000000000000000000000000000000..51e914b83efea1ed59a15527ecf4e3fa66971cd9 --- /dev/null +++ b/LHCb_Pipeline/Embedding/embedding_plots.py @@ -0,0 +1,136 @@ +"""A module that handles the validation plots for the embedding phase specifically. +""" +import typing +import os.path as op + +import numpy as np +from uncertainties import unumpy as unp +import matplotlib.pyplot as plt +from matplotlib.figure import Figure +from matplotlib.axes import Axes + +from Embedding.embedding_validation import ( + evaluate_embedding_performances_given_radius_knn_max, +) +from utils.plotutils.plotconfig import partition_to_color, partition_to_label +from utils.plotutils.plotools import save_fig +from utils.commonutils.cpaths import get_performance_directory +from utils.commonutils.config import load_config +from .embedding_base import EmbeddingBase +from .embedding_validation import EmbeddingRadiusExplorer + + +def plot_embedding_performance_given_radius_knn_max( + model: EmbeddingBase, + path_or_config: str | dict, + partitions: typing.List[str] = ["train", "val"], + n_events: int = 10, + radius: np.ndarray | float | None = None, + knn_max: np.ndarray | int | None = None, + show_err: bool = True, +) -> typing.Tuple[ + typing.Dict[str, typing.Tuple[Figure, Axes]], + typing.Tuple[Figure, Axes], + typing.Tuple[ + np.ndarray, typing.Dict[str, unp.matrix], typing.Dict[str, unp.matrix] + ], +]: + """Plot edge efficiency, purity and graph size as a function of the maximal + radius and maximal number of neighbours in the k-nearest neighbour algorithm. + + Args: + model: Embedding model + path_or_config: YAML configuration + partitions: List of partitions to plot + n_events: Maximal number of events to use for each partition for performance + evaluationn + radius: Maximal distance in the embedding space + knn_max: Maximal number of neighbours + show_err: whether to show the error bars + + Returns: + Tuples of 2 dictionary. The first dictionary associates a metric name with + the tuple of matplotlib Figure and Axes. + The second dictionary associates a metric name with another dictionary + that associates a partition with the list of metric values, for the different + ``radius`` or ``knn_max`` given as input. + """ + knn_is_array = isinstance(knn_max, np.ndarray) + radius_is_array = isinstance(radius, np.ndarray) + if radius_is_array and knn_is_array: + raise ValueError( + "Error: Cannot vary `radius` and `knn_max` at the same time but they were " + "both provided as a list." + ) + elif radius_is_array: + list_hyperparam_values = radius + hyperparam_name = "radius" + elif knn_is_array: + list_hyperparam_values = knn_max + hyperparam_name = "knn" + else: + raise ValueError("Either `radius` or `knn_max` should be a numpy array.") + + dict_metrics_partitions = evaluate_embedding_performances_given_radius_knn_max( + model=model, + partitions=partitions, + radius=radius, + knn_max=knn_max, + n_events=n_events, + ) + + dict_figs_axs = {} + + for metric_name, dict_partitions in dict_metrics_partitions.items(): + fig, ax = plt.subplots(figsize=(8, 6)) + for partition in partitions: + ax.errorbar( + x=list_hyperparam_values, + y=unp.nominal_values(dict_partitions[partition]), + yerr=unp.std_devs(dict_partitions[partition]) if show_err else None, # type: ignore + color=partition_to_color.get(partition), + label=partition_to_label.get(partition, partition), + marker=".", + ) + + if hyperparam_name == "radius": + ax.set_xlabel("Radius") + elif hyperparam_name == "knn": + ax.set_xlabel("Maximal number of neighbours") + else: + raise Exception() + ax.grid(color="grey", alpha=0.5) + ax.legend() + ax.set_ylabel(metric_name.replace("_", "").title()) + + performance_dir = get_performance_directory(path_or_config=path_or_config) + save_fig(fig=fig, path=op.join(performance_dir, metric_name)) + + dict_figs_axs[metric_name] = (fig, ax) + + return (dict_figs_axs, dict_metrics_partitions) + + + + +def plot_best_performances_radius( + model: EmbeddingBase, + path_or_config: str | dict, + partition: str, + list_radius: typing.Sequence[float], + knn_max: int | None = None, + n_events: int | None = None, + seed: int | None = None, +) -> typing.Tuple[Figure, Axes, typing.Dict[str, typing.Dict[str, float]]]: + + embeddingRadiusExplorer = EmbeddingRadiusExplorer(model=model) + config = load_config(path_or_config=path_or_config) + return embeddingRadiusExplorer.plot( + path_or_config=config, + partition=partition, + values=list_radius, + n_events=n_events, + seed=seed, + knn_max=knn_max, + building=config["metric_learning"].get("building"), + ) diff --git a/LHCb_Pipeline/Embedding/embedding_validation.py b/LHCb_Pipeline/Embedding/embedding_validation.py new file mode 100644 index 0000000000000000000000000000000000000000..fc338ba74a853d905c5274e69efba2039ebb73a3 --- /dev/null +++ b/LHCb_Pipeline/Embedding/embedding_validation.py @@ -0,0 +1,199 @@ +"""A module that defines tools to perform the validation step of the embedding step. +""" +from __future__ import annotations +import typing +import logging + +from uncertainties import ufloat +from uncertainties.core import Variable +from tqdm.auto import tqdm +from uncertainties import unumpy as unp +import numpy as np +import pandas as pd +import torch +from torch_geometric.data import Data + +from GNN.perfect_gnn import PerfectInferenceBuilder +from Scripts.Step_5_Build_Track_Candidates import TrackBuilder +from Scripts.Step_6_Evaluate_Reconstruction_MonteTracko import get_tracks_from_batch +from utils.modelutils.batches import get_batches, select_subset +from utils.modelutils.evaluation import ParamExplorer + +from .build_embedding import EmbeddingInferenceBuilder +from .embedding_base import EmbeddingBase + + +def get_default_radius(model: EmbeddingBase, radius: float | None = None) -> float: + if radius is None: + r_infer = model.hparams.get("r_infer") + if r_infer is None: + r_infer = model.hparams["r"] + return r_infer + else: + return radius + + +def evaluate_embedding_performance( + model: EmbeddingBase, + batches: typing.List[Data], + radius: float | None = None, + knn_max: int | None = None, +) -> typing.Tuple[Variable, Variable, Variable]: + """Compute the edge efficiency and edge purity of a given model, on a subset + of the train, val or test dataset. + + Args: + model: PyTorch model inheriting from + :py:class:`utils.modelutils.basemodel.ModelBase` + partition: ``train``, ``val``, ``test`` (for the current already loaded + test sample) or the name of a test dataset + radius: Maximal radius for the KNN. If not given, taken from the hyperparameter + in the model. + knn_max: Maximal number of neighbours for the KNN. If not given, + taken from the hyperparameter in the model. + n_events: Number of events to compute the performance metrics on + seed: Seed used to randomly select the ``n_events`` + + Returns: + A tuple of 3 ufloat numbers corresponding to the event-based average of the + edge efficiency and edge purity, and the graph size + """ + # Handle default values for `knn_max` and `radius` + radius = get_default_radius(model=model, radius=radius) + knn_max = model.hparams["knn"] if knn_max is None else knn_max + + n_batches = len(batches) + # Compute performance for each batch + with torch.no_grad(): + efficiencies = np.full(shape=n_batches, fill_value=np.nan) + purities = np.full(shape=n_batches, fill_value=np.nan) + graph_sizes = np.full(shape=n_batches, fill_value=np.nan) + for batch_idx, batch in enumerate(batches): + results = model.shared_evaluation( + batch=batch, batch_idx=batch_idx, knn_radius=radius, knn_num=knn_max + ) + efficiencies[batch_idx] = results["eff"] + purities[batch_idx] = results["pur"] + graph_sizes[batch_idx] = results["preds"].shape[1] + + return ( + ufloat(efficiencies.mean(), efficiencies.std()), + ufloat(purities.mean(), purities.std()), + ufloat(graph_sizes.mean(), graph_sizes.std()), + ) + + +def evaluate_embedding_performances_given_radius_knn_max( + model: EmbeddingBase, + partitions: typing.List[str] = ["train", "val"], + n_events: int = 10, + radius: np.ndarray | float | None = None, + knn_max: np.ndarray | int | None = None, + seed: int | None = None, +) -> typing.Dict[str, typing.Dict[str, unp.matrix]]: + """ """ + if isinstance(knn_max, np.ndarray): + list_hyperparam_values = knn_max + hyperparam_name = "knn_max" + elif isinstance(radius, np.ndarray): + list_hyperparam_values = radius + hyperparam_name = "radius" + else: + raise ValueError( + "Both `knn_max` and `radius` are provided as array but only one " + "is supported." + ) + + dict_metrics_partitions = { + "edge_efficiency": {}, + "edge_purity": {}, + "graph_size": {}, + } + for partition in partitions: + logging.info(f"Compute edge performance metrics for {partition}") + batches = model.fetch_partition( + partition=partition, + n_events=n_events, + shuffle=True, + seed=seed, + map_location=model.device, + ) + + # Move batches to save device as model + # batches = [batch.to(model.device) for batch in batches] # type: ignore + + efficiencies = [] + purities = [] + graph_sizes = [] + for hyperparam_value in (pbar := tqdm(list_hyperparam_values)): + pbar.set_description( + f"Loop over {hyperparam_name} (current value: {hyperparam_value})" + ) + ( + efficiency, + purity, + graph_size, + ) = evaluate_embedding_performance( + model=model, + batches=batches, + radius=hyperparam_value if hyperparam_name == "radius" else radius, # type: ignore + knn_max=int(hyperparam_value) if hyperparam_name == "knn_max" else knn_max, # type: ignore + ) + efficiencies.append(efficiency) + purities.append(purity) + graph_sizes.append(graph_size) + + dict_metrics_partitions["edge_efficiency"][partition] = np.array(efficiencies) + dict_metrics_partitions["edge_purity"][partition] = np.array(purities) + dict_metrics_partitions["graph_size"][partition] = np.array(graph_sizes) + + return dict_metrics_partitions + + +class EmbeddingRadiusExplorer(ParamExplorer): + """A class that allows to vary the maximal radius and compare the best metric + performances of track finding, in the case where all the fake edges are filtered + out. + """ + + def __init__(self, model: EmbeddingBase) -> None: + super().__init__(model, varname="radius", varlabel=r"$r_{\max}$") + + def get_tracks( + self, + value: float, + batches: typing.List[Data], + knn_max: int | None = None, + building: str | None = None, + ) -> pd.DataFrame: + # Run embedding inference + embeddingInferenceBuilder = EmbeddingInferenceBuilder( + model=self.model, + knn_max=self.model.hparams["knn"] if knn_max is None else knn_max, + radius=value, + ) + batches = [ + embeddingInferenceBuilder.process_one_step( + batch=batch.clone(), + building=building, + ) + for batch in tqdm(batches, desc="Graph Building") + ] + + # Run perfect GNN inference + perfectInferenceBuilder = PerfectInferenceBuilder() + batches = [ + perfectInferenceBuilder.construct_downstream(batch=batch) + for batch in batches + ] + + # Run track reconstruction + trackBuilder = TrackBuilder(score_cut=0.5) + batches = [ + trackBuilder.construct_downstream(batch=batch.cpu()) for batch in batches + ] + + # Define dataframe of tracks + return pd.concat( + tuple(get_tracks_from_batch(batch=batch) for batch in batches) + ).drop_duplicates() diff --git a/LHCb_Pipeline/Embedding/models/layerless_embedding.py b/LHCb_Pipeline/Embedding/models/layerless_embedding.py index 7bd08e14092efd44af790008b852ad9b033fb55a..8ea10afbd5d2e64c0ef3199594bdeb66586fe607 100644 --- a/LHCb_Pipeline/Embedding/models/layerless_embedding.py +++ b/LHCb_Pipeline/Embedding/models/layerless_embedding.py @@ -3,7 +3,7 @@ from ..embedding_base import EmbeddingBase import torch.nn.functional as F # Local imports -from utils.modelutils.mpl import make_mlp +from utils.modelutils.mlp import make_mlp from utils.commonutils.cfeatures import get_number_input_features diff --git a/LHCb_Pipeline/GNN/build_gnn.py b/LHCb_Pipeline/GNN/build_gnn.py index d2c40418e836f7706367449d7e28232e0889156e..1a9ad0c3b25e20872c5ac40a7d10588370c5435c 100644 --- a/LHCb_Pipeline/GNN/build_gnn.py +++ b/LHCb_Pipeline/GNN/build_gnn.py @@ -19,4 +19,8 @@ class GNNInferenceBuilder(ModelBuilderBase): particle_ids=batch.particle_id, ) output = self.model.shared_evaluation(batch, 0, log=False) - batch.scores = output["score"][: int(len(output["score"]) / 2)] + if self.model.hparams.get("bidir", True): + batch.scores = output["score"][: int(len(output["score"]) / 2)] + else: + batch.scores = output["score"] + return batch diff --git a/LHCb_Pipeline/GNN/gnn_base.py b/LHCb_Pipeline/GNN/gnn_base.py index 8648c11a665bd4c9d8285c782fe488bb6e650d4d..6b167b123405bad2f078fa06388249be5cf76302 100644 --- a/LHCb_Pipeline/GNN/gnn_base.py +++ b/LHCb_Pipeline/GNN/gnn_base.py @@ -1,3 +1,4 @@ +import typing import numpy as np from sklearn.metrics import roc_auc_score import torch.nn.functional as F @@ -36,7 +37,11 @@ def compute_edge_labels( class GNNBase(ModelBase): - def load_dataset(self, input_path: str) -> Data: + @property + def bidir(self) -> bool: + return self.hparams.get("bidir", True) + + def fetch_dataset(self, input_path: str, **kwargs) -> Data: """Load and process one PyTorch DataSet. Args: @@ -45,7 +50,9 @@ class GNNBase(ModelBase): Returns: PyTorch DataSet """ - loaded_event = super(GNNBase, self).load_dataset(input_path=input_path) + loaded_event = super(GNNBase, self).fetch_dataset( + input_path=input_path, **kwargs + ) # Add `y_pid` column if not already there if "y_pid" not in loaded_event: @@ -53,55 +60,139 @@ class GNNBase(ModelBase): edge_indices=loaded_event.edge_index, particle_ids=loaded_event.particle_id, ) - return loaded_event - def handle_directed(self, batch, edge_sample, truth_sample): - edge_sample = torch.cat([edge_sample, edge_sample.flip(0)], dim=-1) - truth_sample = truth_sample.repeat(2) + if self.hparams.get("shuffle_edge_direction", False): + assert self.bidir, ( + "It was required to shuffle the edge directions, even though " + "the graph is not bidirectional. This is odd." + ) + # Randomly shuffle direction of edges + random_flip = torch.randint(2, (loaded_event.edge_index.shape[1],)).bool() + ( + loaded_event.edge_index[0, random_flip], + loaded_event.edge_index[1, random_flip], + ) = ( + loaded_event.edge_index[1, random_flip], + loaded_event.edge_index[0, random_flip], + ) - if ("directed" in self.hparams.keys()) and self.hparams["directed"]: - direction_mask = batch.x[edge_sample[0], 0] < batch.x[edge_sample[1], 0] - edge_sample = edge_sample[:, direction_mask] - truth_sample = truth_sample[direction_mask] + return loaded_event - return edge_sample, truth_sample + def handle_bidirectional(self, edge_sample, truth_sample): + if self.bidir: + edge_sample = torch.cat([edge_sample, edge_sample.flip(0)], dim=-1) + truth_sample = truth_sample.repeat(2) - def training_step(self, batch, batch_idx): - weight = ( - torch.tensor(self.hparams["weight"]) - if ("weight" in self.hparams) - else torch.tensor((~batch.y_pid.bool()).sum() / batch.y_pid.sum()) - ) + return edge_sample, truth_sample - truth = ( - batch.y_pid.bool() if "pid" in self.hparams["regime"] else batch.y.bool() - ) + def compute_loss(self, output: torch.Tensor, truth: torch.Tensor, batch: Data): + """Compute the loss. - edge_sample, truth_sample = self.handle_directed(batch, batch.edge_index, truth) - input_data = self.get_input_data(batch) - output = self(input_data, edge_sample).squeeze() + Args: + output: network output + truth: true labels (to compare to ``output``) + batch: PyTorch geometric data objects, used to compute the weights + and having access to other columns + Returns: + loss function + """ + # Compute weights if "weighting" in self.hparams["regime"]: - manual_weights = batch.weights + manual_weights = batch.edge_weights else: manual_weights = None - loss = F.binary_cross_entropy_with_logits( - output, truth_sample.float(), weight=manual_weights, pos_weight=weight + # Compute weights on positive samples + if self.hparams.get("focal_loss", False): + weight = ( + torch.tensor(self.hparams["weight"]) + if ("weight" in self.hparams) + else (~truth).sum() / truth.shape[0] + ) + else: + weight = ( + torch.tensor(self.hparams["weight"]) + if ("weight" in self.hparams) + else (~truth).sum() / truth.sum() + ) + + # Compute weighted loss + if self.hparams.get("focal_loss", False): + from torchvision.ops import sigmoid_focal_loss + + loss = sigmoid_focal_loss( + inputs=output, + targets=truth.float(), + alpha=weight, + reduction="mean", + ) + else: + loss = F.binary_cross_entropy_with_logits( + output, + truth.float(), + weight=manual_weights, + pos_weight=weight, + ) + if "triplet" in self.hparams["regime"]: + assert not self.bidir, ( + "Loss for triplets with penalty term not supported " + "for bidirectional graph" + ) + total_angle_diff_norm = torch.abs(batch.diff_angle_xz_norm) + torch.abs( + batch.diff_angle_yz_norm + ) + # Penality term if score is large + pos_penality = (torch.sigmoid(output) * total_angle_diff_norm).mean() + # Penality term if score is small + neg_penality = ( + (1 - torch.sigmoid(output)) * (2 - total_angle_diff_norm) + ).mean() + + loss += ( + self.hparams["pos_penality"] * pos_penality.mean() + + self.hparams["neg_penality"] * neg_penality.mean() + ) + return loss + + def common_training_validation_step( + self, batch: Data + ) -> typing.Tuple[torch.Tensor, torch.Tensor, float]: + """Perform the inference and loss computation step that is common + to the training and validation step. + + Returns: + Network output, true labels and loss function. + """ + # Get true labels + truth = ( + batch.y_pid.bool() if "pid" in self.hparams["regime"] else batch.y.bool() ) + # Handle bidirectional graphs + edge_sample, truth_sample = self.handle_bidirectional(batch.edge_index, truth) + input_data = self.get_input_data(batch) + # Run GNN inference + output = self(input_data, edge_sample).squeeze() + loss = self.compute_loss(output=output, truth=truth_sample, batch=batch) + return output, truth_sample, loss + + def training_step(self, batch, batch_idx): + output, _, loss = self.common_training_validation_step(batch=batch) self.log( "train_loss", loss, on_epoch=True, on_step=False, - batch_size=edge_sample.shape[1], + batch_size=output.shape[0], prog_bar=True, ) return loss - def log_metrics(self, score, preds, truth, batch, loss): + def log_metrics( + self, score: float, preds: torch.Tensor, truth: torch.Tensor, loss: float + ): edge_positive = preds.sum().float() edge_true = truth.sum().float() edge_true_positive = (truth.bool() & preds).sum().float() @@ -109,7 +200,8 @@ class GNNBase(ModelBase): eff = edge_true_positive.clone().detach() / max(1, edge_true) pur = edge_true_positive.clone().detach() / max(1, edge_positive) - # Fix error: "ValueError: Only one class present in y_true. ROC AUC score is not defined in that case" + # Fix error: "ValueError: Only one class present in y_true. + # ROC AUC score is not defined in that case" try: auc = roc_auc_score(truth.bool().cpu().detach(), score.cpu().detach()) except ValueError: @@ -129,42 +221,22 @@ class GNNBase(ModelBase): batch_size=preds.shape[0], ) - def shared_evaluation(self, batch, batch_idx, log=False): - weight = ( - torch.tensor(self.hparams["weight"]) - if ("weight" in self.hparams) - else torch.tensor((~batch.y_pid.bool()).sum() / batch.y_pid.sum()) - ) - - truth = ( - batch.y_pid.bool() if "pid" in self.hparams["regime"] else batch.y.bool() - ) - - edge_sample, truth_sample = self.handle_directed(batch, batch.edge_index, truth) - input_data = self.get_input_data(batch) - output = self(input_data, edge_sample).squeeze() - - if "weighting" in self.hparams["regime"]: - manual_weights = batch.weights - else: - manual_weights = None - - loss = F.binary_cross_entropy_with_logits( - output, truth_sample.float(), weight=manual_weights, pos_weight=weight - ) - + def shared_evaluation( + self, batch: Data, batch_idx: int, log: bool = False + ) -> typing.Dict[str, float]: + output, truth, loss = self.common_training_validation_step(batch=batch) # Edge filter performance score = torch.sigmoid(output) preds = score > self.hparams["edge_cut"] if log: - self.log_metrics(score, preds, truth_sample, batch, loss) + self.log_metrics(score, preds, truth, loss) return { "loss": loss, "score": score, "preds": preds, - "truth": truth_sample, + "truth": truth, } def validation_step(self, batch, batch_idx): diff --git a/LHCb_Pipeline/GNN/gnn_plots.py b/LHCb_Pipeline/GNN/gnn_plots.py new file mode 100644 index 0000000000000000000000000000000000000000..f376217575c595cfa0b7ca346f2d0be442b2de8f --- /dev/null +++ b/LHCb_Pipeline/GNN/gnn_plots.py @@ -0,0 +1,32 @@ +import typing + +import numpy.typing as npt +import matplotlib.pyplot as plt +from matplotlib.figure import Figure +from matplotlib.axes import Axes + +from .gnn_base import GNNBase +from .gnn_validation import GNNScoreCutExplorer + + +def plot_best_performances_score_cut( + model: GNNBase, + path_or_config: str | dict, + partition: str, + score_cuts: typing.Sequence[float], + n_events: int | None = None, + seed: int | None = None, + identifier: str | None = None, +) -> typing.Tuple[Figure, npt.NDArray, typing.Dict[str, typing.Dict[str, float]]]: + if identifier is None: + identifier = "" + + gnnScoreCutExplorer = GNNScoreCutExplorer(model=model) + return gnnScoreCutExplorer.plot( + path_or_config=path_or_config, + partition=partition, + values=score_cuts, + n_events=n_events, + seed=seed, + identifier=identifier, + ) diff --git a/LHCb_Pipeline/GNN/gnn_validation.py b/LHCb_Pipeline/GNN/gnn_validation.py new file mode 100644 index 0000000000000000000000000000000000000000..0f20e4ee34d78e00d872398b9a9b229f6ecb6c98 --- /dev/null +++ b/LHCb_Pipeline/GNN/gnn_validation.py @@ -0,0 +1,94 @@ +from __future__ import annotations +import typing +import os.path as op + +from tqdm.auto import tqdm +import pandas as pd +import torch +from torch_geometric.data import Data + +from .build_gnn import GNNInferenceBuilder +from .gnn_base import GNNBase +from Scripts.Step_5_Build_Track_Candidates import TrackBuilder +from Scripts.Step_6_Evaluate_Reconstruction_MonteTracko import ( + get_tracks_from_batch, + load_parquet_files, + perform_matching, +) +from utils.modelutils.evaluation import ParamExplorer + + +class GNNScoreCutExplorer(ParamExplorer): + """A class that allows to vary the score cut after the GNN, and compare the metric + performances of track finding. + """ + def __init__(self, model: GNNBase) -> None: + super().__init__(model, varname="score_cut", varlabel="Score cut") + + def get_tracks( + self, + value: float, + batches: typing.List[Data], + ): + inferencerBuilder = GNNInferenceBuilder(model=self.model) + with torch.no_grad(): + batches = [ + inferencerBuilder.construct_downstream(batch=batch.clone()) + for batch in tqdm(batches, desc="GNN inference") + ] + + # Run track reconstruction + trackBuilder = TrackBuilder(score_cut=value) + batches = [trackBuilder.construct_downstream(batch=batch.cpu()) for batch in batches] + + # Define dataframe of tracks + return pd.concat( + tuple(get_tracks_from_batch(batch=batch) for batch in batches) + ).drop_duplicates() + + + +def compute_best_tracks( + model: GNNBase, + input_dir: str, + output_dir: str, + file_names: typing.List[str], + score_cut: float, +) -> pd.DataFrame: + """Compute the best achievable tracking efficiency given a choice of + hyperameter ``score_cut``. + + Args: + model: PyTorch model inheriting from + :py:class:`utils.modelutils.basemodel.ModelBase` + partition: ``train``, ``val``, ``test`` (for the current already loaded + test sample) or the name of a test dataset + score_cut: Minimal GNN edge score + n_events: Number of events to compute the performance metrics on + seed: Seed used to randomly select the ``n_events`` + + Returns: + Dataframe of tracks and average graph size + """ + inferencerBuilder = GNNInferenceBuilder(model=model) + inferencerBuilder.infer( + input_dir=input_dir, + output_dir=output_dir, + reproduce=True, + file_names=file_names, + ) + batches = [ + torch.load(op.join(output_dir, filename), map_location="cpu") + for filename in file_names + ] + + # Run track reconstruction + trackBuilder = TrackBuilder(score_cut=score_cut) + batches = [trackBuilder.construct_downstream(batch=batch) for batch in batches] + + # Define dataframe of tracks + df_tracks = pd.concat( + tuple(get_tracks_from_batch(batch=batch) for batch in batches) + ).drop_duplicates() + + return df_tracks diff --git a/LHCb_Pipeline/GNN/models/interaction_gnn.py b/LHCb_Pipeline/GNN/models/interaction_gnn.py index f369106eaef54a0aaec5e0aaadd62b526b171b9c..af6a3d7d9cdc7ccd46cbb5c844149816c0075647 100644 --- a/LHCb_Pipeline/GNN/models/interaction_gnn.py +++ b/LHCb_Pipeline/GNN/models/interaction_gnn.py @@ -3,14 +3,14 @@ import torch from torch_scatter import scatter_add, scatter_max from torch.utils.checkpoint import checkpoint -from ..gnn_base import GNNBase -from utils.modelutils.mpl import make_mlp +from utils.modelutils.mlp import make_mlp from utils.commonutils.cfeatures import get_number_input_features +from ..gnn_base import GNNBase class InteractionGNN(GNNBase): - """An interaction network class - """ + """An interaction network class""" + def __init__(self, hparams): super().__init__(hparams) """ @@ -21,11 +21,17 @@ class InteractionGNN(GNNBase): concatenation_factor = ( 3 if (self.hparams["aggregation"] in ["sum_max", "mean_max"]) else 2 ) + if not self.bidir: + concatenation_factor = (concatenation_factor - 1) * 2 + 1 + + nb_edge_layers: int = hparams["nb_edge_layers"] + nb_node_layers: int = hparams["nb_node_layers"] + nb_hidden: int = hparams["hidden"] # Setup input network self.node_encoder = make_mlp( get_number_input_features(hparams["feature_indices"]), - [hparams["hidden"]] * hparams["nb_node_layer"], + [nb_hidden] * hparams.get("nb_node_encoder_layers", nb_node_layers), output_activation=None, hidden_activation=hparams["hidden_activation"], layer_norm=hparams["layernorm"], @@ -33,8 +39,8 @@ class InteractionGNN(GNNBase): # The edge network computes new edge features from connected nodes self.edge_encoder = make_mlp( - 2 * (hparams["hidden"]), - [hparams["hidden"]] * hparams["nb_edge_layer"], + 2 * (nb_hidden), + [nb_hidden] * hparams.get("nb_edge_encoder_layers", nb_edge_layers), layer_norm=hparams["layernorm"], output_activation=None, hidden_activation=hparams["hidden_activation"], @@ -42,8 +48,8 @@ class InteractionGNN(GNNBase): # The edge network computes new edge features from connected nodes self.edge_network = make_mlp( - 3 * hparams["hidden"], - [hparams["hidden"]] * hparams["nb_edge_layer"], + 3 * nb_hidden, + [nb_hidden] * nb_edge_layers, layer_norm=hparams["layernorm"], output_activation=None, hidden_activation=hparams["hidden_activation"], @@ -51,8 +57,8 @@ class InteractionGNN(GNNBase): # The node network computes new node features self.node_network = make_mlp( - concatenation_factor * hparams["hidden"], - [hparams["hidden"]] * hparams["nb_node_layer"], + concatenation_factor * nb_hidden, + [nb_hidden] * nb_node_layers, layer_norm=hparams["layernorm"], output_activation=None, hidden_activation=hparams["hidden_activation"], @@ -60,8 +66,10 @@ class InteractionGNN(GNNBase): # Final edge output classification network self.output_edge_classifier = make_mlp( - 3 * hparams["hidden"], - [hparams["hidden"]] * hparams["nb_edge_layer"] + [1], + 3 * nb_hidden, + [nb_hidden] + * hparams.get("nb_edge_classifier_layers", nb_edge_layers) + + [1], layer_norm=hparams["layernorm"], output_activation=None, hidden_activation=hparams["hidden_activation"], @@ -76,19 +84,32 @@ class InteractionGNN(GNNBase): def message_step(self, x, start, end, e): # Compute new node features if self.hparams["aggregation"] == "sum": + assert not self.bidir edge_messages = scatter_add(e, end, dim=0, dim_size=x.shape[0]) elif self.hparams["aggregation"] == "max": + assert not self.bidir edge_messages = scatter_max(e, end, dim=0, dim_size=x.shape[0])[0] elif self.hparams["aggregation"] == "sum_max": - edge_messages = torch.cat( - [ - scatter_max(e, end, dim=0, dim_size=x.shape[0])[0], - scatter_add(e, end, dim=0, dim_size=x.shape[0]), - ], - dim=-1, - ) + if not self.bidir: + edge_messages = torch.cat( + [ + scatter_max(e, end, dim=0, dim_size=x.shape[0])[0], + scatter_add(e, end, dim=0, dim_size=x.shape[0]), + scatter_max(e, start, dim=0, dim_size=x.shape[0])[0], + scatter_add(e, start, dim=0, dim_size=x.shape[0]), + ], + dim=-1, + ) + else: + edge_messages = torch.cat( + [ + scatter_max(e, end, dim=0, dim_size=x.shape[0])[0], + scatter_add(e, end, dim=0, dim_size=x.shape[0]), + ], + dim=-1, + ) node_inputs = torch.cat([x, edge_messages], dim=-1) x_out = self.node_network(node_inputs) @@ -119,7 +140,6 @@ class InteractionGNN(GNNBase): # edge_outputs = [] # Loop over iterations of edge and node networks for i in range(self.hparams["n_graph_iters"]): - x, e = checkpoint(self.message_step, x, start, end, e) # Compute final edge scores; use original edge directions only diff --git a/LHCb_Pipeline/GNN/perfect_gnn.py b/LHCb_Pipeline/GNN/perfect_gnn.py new file mode 100644 index 0000000000000000000000000000000000000000..5714c6458ee8e4b1842d8660c4e0582a4a7d3db7 --- /dev/null +++ b/LHCb_Pipeline/GNN/perfect_gnn.py @@ -0,0 +1,22 @@ +"""Replace the GNN by a perfect inference in order to understand +what is the best result that can be obtained with the current pipeline. +""" +from torch_geometric.data import Data +from utils.modelutils.build import BuilderBase +from GNN.gnn_base import compute_edge_labels + + +class PerfectInferenceBuilder(BuilderBase): + """Generate perfect inference, that is, the edge score is equal to the truth. + """ + def construct_downstream(self, batch: Data, pid: bool = False): + if pid: + if "y_pid" not in batch: + batch["y_pid"] = compute_edge_labels( + edge_indices=batch.edge_index, + particle_ids=batch.particle_id, + ) + batch.scores = batch["y_pid"] + else: + batch.scores = batch.y + return batch diff --git a/LHCb_Pipeline/Preprocessing/particle_line_fitting.py b/LHCb_Pipeline/Preprocessing/particle_line_fitting.py index f0969ab97332426dcd7ec8cebfb35a48320ba827..24b34f72630ac9528568f6fe3e526985276b73e6 100644 --- a/LHCb_Pipeline/Preprocessing/particle_line_fitting.py +++ b/LHCb_Pipeline/Preprocessing/particle_line_fitting.py @@ -132,7 +132,7 @@ def compute_particle_metric( @nb.jit(nopython=True, cache=True) -def compute_particle_distances_to_lines_events_impl( +def compute_particle_line_metrics_events_impl( array_metric_values: np.ndarray, coords_events_particles: np.ndarray, event_ids: np.ndarray, @@ -178,9 +178,10 @@ def compute_particle_distances_to_lines_events_impl( event_idx += n_particles -def compute_particle_distances_to_lines_dataframe( +def compute_particle_line_metrics_dataframe( hits: pd.DataFrame, metric_names: typing.List[str], + event_id_column: str = "event", ) -> pd.DataFrame: """Compute the pandas Series of the distance from particle hits to straight lines fitted to these lines. The "distance" actually corresponds to the square-root @@ -197,6 +198,7 @@ def compute_particle_distances_to_lines_dataframe( * ``xz_angle`` * ``yz_angle`` + event_id_column: name of the event ID column Returns: A pandas Series with index ``event`` and ``particle_id``, and for every @@ -204,12 +206,15 @@ def compute_particle_distances_to_lines_dataframe( fitted to the points. The distance is the square-root of the average of the squared distances from the hits to the straight line. """ - hits = hits.sort_values(by=["event", "particle_id"]) - events_particles_group = hits.groupby(["event", "particle_id"], sort=False).size() + + hits = hits.sort_values(by=[event_id_column, "particle_id"]) + events_particles_group = hits.groupby( + [event_id_column, "particle_id"], sort=False + ).size() n_particles = events_particles_group.shape[0] array_metric_values = np.zeros(shape=(n_particles, len(metric_names))) - compute_particle_distances_to_lines_events_impl( - event_ids=hits["event"].to_numpy(), + compute_particle_line_metrics_events_impl( + event_ids=hits[event_id_column].to_numpy(), particle_ids=hits["particle_id"].to_numpy(), coords_events_particles=hits[["x", "y", "z"]].to_numpy(), array_metric_values=array_metric_values, diff --git a/LHCb_Pipeline/Preprocessing/particle_line_metrics.py b/LHCb_Pipeline/Preprocessing/particle_line_metrics.py index dca906a9c14feac071341faae98178c2ea50b5f1..b29f3f90e5f51dfdb1b9492fc75c37c7c5ac1e27 100644 --- a/LHCb_Pipeline/Preprocessing/particle_line_metrics.py +++ b/LHCb_Pipeline/Preprocessing/particle_line_metrics.py @@ -1,6 +1,11 @@ +import warnings import numpy as np import numba as nb +warnings.filterwarnings( + "ignore", ".*type 'reflected list'.*", category=DeprecationWarning +) + @nb.jit(nopython=True, cache=True) def compute_distance_to_line( diff --git a/LHCb_Pipeline/Preprocessing/preprocessing.py b/LHCb_Pipeline/Preprocessing/preprocessing.py index 6241961c1f5902ebf9043c31a71bb7836cad3935..e20f6b8a4be37a9a39ffac247520d21e949034e0 100644 --- a/LHCb_Pipeline/Preprocessing/preprocessing.py +++ b/LHCb_Pipeline/Preprocessing/preprocessing.py @@ -3,6 +3,7 @@ import typing import os import logging from tqdm.auto import tqdm +import numpy as np import pandas as pd from . import selecting @@ -48,37 +49,43 @@ def load_dataframes( **kwargs: other keyword arguments passed to the function that load the files Returns: - A 2-tuple containing the dataframe of hits and the dataframes of particles + A 2-tuple containing the dataframe of hits-particles and the dataframes + of particles Notes: The function also defines the column ``particle_id = mcid + 1`` in both dataframes. """ - particles = pd.read_parquet( - f"{indir}/mc_particles.parquet.lz4", - columns=None - if particles_columns is None - else ["event", "mcid"] + particles_columns, + path=os.path.join(indir, "mc_particles.parquet.lz4"), + columns=( + None if particles_columns is None else ["event", "mcid"] + particles_columns + ), **kwargs, ) - cast_boolean_columns(particles) hits_particles = pd.read_parquet( - f"{indir}/hits_velo.parquet.lz4", - columns=None - if hits_particles_columns is None - else ["event", "mcid", "lhcbid"] + hits_particles_columns, + path=os.path.join(indir, "hits_velo.parquet.lz4"), + columns=( + None + if hits_particles_columns is None + else ["event", "mcid", "lhcbid"] + hits_particles_columns + ), **kwargs, ) + cast_boolean_columns(particles) + # Define `particle_id = mcid + 1` directly in the original dataframes particles["particle_id"] = particles["mcid"] + 1 hits_particles["particle_id"] = hits_particles["mcid"] + 1 + particles.drop("mcid", axis=1, inplace=True) + hits_particles.drop("mcid", axis=1, inplace=True) + # Rename `lhcbid` to `hit_id` hits_particles.rename(columns={"lhcbid": "hit_id"}, inplace=True) - return particles, hits_particles + return hits_particles, particles def enough_true_hits( @@ -133,113 +140,242 @@ def enough_true_hits( return True -def preprocess( - input_dir: str, - output_dir: str, - n_events: int, +def load_and_filter_dataframes( + indir: str, + particles_columns: typing.List[str] | None = None, + hits_particles_columns: typing.List[str] | None = None, selection: str | None = None, - num_true_hits_threshold: int | None = None, -): - """Preprocess the first `n_events` events in the input files, - into the form of the TrackML dataset. - Remove any events that contain only fake hits. - """ - pd.set_option("chained_assignment", None) # disable chaine assignment warning - os.makedirs(output_dir, exist_ok=True) - logging.info(f"Preprocessing: output will be written in {output_dir}") + **kwargs, +) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: + """Load and filter the dataframes of hits-particles and particles. - #: Columns to load from the `hits_particles` dataframe - hits_particles_columns = [ - # Features - "x", - "y", - "z", - # Plane-wise edges - "plane", - ] - - #: Columns to load from the `particles` dataframe - # particles_columns = [ - # # Module-wise true edges - # "vx", - # "vy", - # "vz", - # # For evaluation and selection - # "has_velo", - # "has_scifi", - # "charge", - # "pid", - # "nhits_velo", - # "pt", - # "p", - # ] - particles_columns = None + Args: + indir: directory where the dataframes are saved + particles_columns: columns to load for the dataframe of particles + hits_particles_columns: columns to load for the dataframe of hits + and the hits-particles association information + selection: function to use to filter the candidates. + The latter is defined in the :py:mod:`.selecting` module. + **kwargs: other keyword arguments passed to the function that load the files + + Returns: + Filtered dataframes of hits-particles and of particles + """ # Load dataframes - logging.info("Load dataframe") - particles, hits_particles = load_dataframes( - indir=input_dir, - # particles_columns=particles_columns, + logging.info(f"Load dataframes in {indir}") + hits_particles, particles = load_dataframes( + indir=indir, + particles_columns=particles_columns, hits_particles_columns=hits_particles_columns, + **kwargs, ) # Add truth particle information to the dataframe of hits if selection: - logging.info("Apply selection") + logging.info(f"Apply selection `{selection}`") selection_function: selecting.SelectionFunction = getattr(selecting, selection) hits_particles, particles = selection_function( hits_particles=hits_particles, particles=particles, ) - event_list = particles["event"].unique() # The order is not mixed + # Define `n_unique_planes` + # We'll train with all the hits for the training + # And cut before the GNN + n_unique_planes = ( + hits_particles.groupby(["event", "particle_id"])["plane"] + .nunique() + .rename("n_unique_planes") + ) + particles = particles.merge( + n_unique_planes, how="left", on=["event", "particle_id"] + ).fillna(0) + + return hits_particles, particles + + +def get_indirs( + input_dir: str | None = None, + subdirs: int | str | typing.List[str] | typing.Dict[str, int] | None = None, +): + """Get the input directories that can be used as input of the preprocessing. + + Args: + input_dir: A single input directory if ``subdirs`` is ``None``, + or the main directory where sub-directories are + subdirs: + + * If ``subdirs`` is None, there is a single input directory, ``input_dir`` + * If ``subdirs`` is a string or a list of strings, they specify \ + the sub-directories with respect to ``input_dir``. If ``input_dir`` \ + is ``None``, then they are the (list of) input directories directly, which \ + can be useful if the input directories are not at the same location \ + (even though it is discouraged) + * If ``subdirs`` is an integer, it corresponds to the the name of the last \ + sub-directory to consider (i.e., from 0 to ``subdirs``). If ``subdirs`` \ + is ``-1``, all the sub-directories are considered as input. + * If ``subdirs`` is a dictionary, the keys ``start`` and ``stop`` specify \ + the first and last sub-directories to consider as input. + + Returns: + List of input directories that can be considered. + """ + if input_dir is None: + if isinstance(subdirs, str): + return [subdirs] + elif isinstance(subdirs, list): + return [str(subdir) for subdir in subdirs] + else: + raise TypeError( + "`input_dir` is `None` but `subdirs` is neither a string nor " + "a list of strings, so the input directories of the preprocessing " + "cannot be determined." + ) + else: + # Get the list of all the sub-directories inside ``input_dir`` + + # Filter this list according to ``subdirs`` + if subdirs is None: + return [input_dir] + elif isinstance(subdirs, (int, dict)): + available_subdirs = sorted( + [ + int(file_or_dir.name) + for file_or_dir in os.scandir(input_dir) + if file_or_dir.is_dir() + ] + ) + if subdirs == -1: + final_subdirs = available_subdirs + else: + if isinstance(subdirs, int): + start = 0 + stop = subdirs + else: # dict + start = subdirs.get("start", 0) + stop = subdirs["stop"] + + assert ( + stop >= start + ), f"`start` ({start}) is strictly higher than `stop ({stop})" + final_subdirs = [ + subdir + for subdir in available_subdirs + if subdir >= start and subdir <= stop + ] + elif isinstance(subdirs, str): + final_subdirs = [subdirs] + elif isinstance(subdirs, list): + final_subdirs = subdirs + else: + raise ValueError( + f"`input_dir` is not `None` and `subdirs` is `{subdirs}`, which are " + "not valid inputs." + ) + + return [os.path.join(input_dir, str(subdir)) for subdir in final_subdirs] + + +def preprocess( + input_dir: str, + output_dir: str, + subdirs: int | str | typing.List[str] | None = None, + n_events: int = -1, + selection: str | None = None, + num_true_hits_threshold: int | None = None, + hits_particles_columns: typing.List[str] | None = None, + particles_columns: typing.List[str] | None = None, +): + """Preprocess the first `n_events` events in the input files, + into the form of the TrackML dataset. + Remove any events that contain only fake hits. + """ + pd.set_option("chained_assignment", None) # disable chaine assignment warning + os.makedirs(output_dir, exist_ok=True) + logging.info(f"Preprocessing: output will be written in {output_dir}") + + indirs = get_indirs(input_dir=input_dir, subdirs=subdirs) + if len(indirs) == 0: + raise ValueError("No input directories.") + logging.info("Input directories:") + for indir in indirs: + logging.info(f"- {indir}") + n_output_saved = 0 # Count the number of events outputted event_idx = 0 - with tqdm(total=n_events) as pbar: - while n_output_saved < n_events and event_idx < len(event_list): - current_event_id = event_list[event_idx] - event_hits_particles = hits_particles[ - hits_particles["event"] == current_event_id - ] - event_particles = particles[particles["event"] == current_event_id] - - #: String representation of the event ID - event_id_str = str(current_event_id).zfill(9) - - if (num_true_hits_threshold is None) or enough_true_hits( - event_hits_particles=event_hits_particles, - num_true_hits_threshold=num_true_hits_threshold, - event_id_str=event_id_str, - num_events=n_output_saved, - required_num_events=n_events, - ): - # Save subset of columns - if hits_particles_columns is None: - hits_particles_csv = event_hits_particles - else: - hits_particles_csv = event_hits_particles[ - ["particle_id", "hit_id"] + hits_particles_columns - ] - if particles_columns is None: - particles_csv = event_particles - else: - particles_csv = event_particles[["particle_id"] + particles_columns] - - # Save - hits_particles_csv.to_parquet( - f"{output_dir}/event{event_id_str}-hits_particles.parquet", - ) - particles_csv.to_parquet( - f"{output_dir}/event{event_id_str}-particles.parquet", - ) - n_output_saved += 1 - pbar.update() - event_idx += 1 + n_required_events = np.inf if n_events == -1 else n_events + left_indirs = indirs + logging.info(f"Number of events to produce: {n_required_events}") + with tqdm(total=n_required_events) as pbar: + while n_output_saved < n_required_events and left_indirs: + hits_particles, particles = load_and_filter_dataframes( + indir=left_indirs[0], + hits_particles_columns=hits_particles_columns, + particles_columns=particles_columns, + selection=selection, + ) + left_indirs = left_indirs[1:] + + event_ids_in_df_hits_particles = hits_particles["event"].unique() + event_ids_df_particles = particles["event"].unique() + event_ids = np.intersect1d( + event_ids_in_df_hits_particles, event_ids_df_particles + ) + + # Loop over the events in the dataframe of hits-particles + grouped_df_hits_particles = hits_particles.groupby("event") + grouped_df_particles = particles.groupby("event") + for event_id in event_ids: + if n_output_saved >= n_required_events: + break + event_hits_particles = grouped_df_hits_particles.get_group(event_id) + event_particles = grouped_df_particles.get_group(event_id) + + #: String representation of the event ID + event_id_str = str(event_id).zfill(9) + + no_hits = event_hits_particles.shape[0] == 0 + + if not no_hits and ( + (num_true_hits_threshold is None) + or enough_true_hits( + event_hits_particles=event_hits_particles, + num_true_hits_threshold=num_true_hits_threshold, + event_id_str=event_id_str, + num_events=n_output_saved, + required_num_events=n_events, + ) + ): + # Save subset of columns + if hits_particles_columns is None: + hits_particles_csv = event_hits_particles + else: + hits_particles_csv = event_hits_particles[ + ["particle_id", "hit_id"] + hits_particles_columns + ] + if particles_columns is None: + particles_csv = event_particles + else: + particles_csv = event_particles[ + ["particle_id"] + particles_columns + ] + + # Save + hits_particles_csv.to_parquet( + f"{output_dir}/event{event_id_str}-hits_particles.parquet", + ) + particles_csv.to_parquet( + f"{output_dir}/event{event_id_str}-particles.parquet", + ) + n_output_saved += 1 + pbar.update() + event_idx += 1 pbar.close() pd.set_option("chained_assignment", "warn") # re-enable chained-assignment warning - if n_output_saved < n_events: + if n_output_saved < n_required_events: raise Exception( "Not enough events found with more than " f"{num_true_hits_threshold} true hits" diff --git a/LHCb_Pipeline/Preprocessing/run_preprocessing.py b/LHCb_Pipeline/Preprocessing/run_preprocessing.py index fcbecaa550b047678ad3ccfac08afe8ac3d81733..1a1db4a8e0df5537f0c476ee3cade71d544ae7b4 100644 --- a/LHCb_Pipeline/Preprocessing/run_preprocessing.py +++ b/LHCb_Pipeline/Preprocessing/run_preprocessing.py @@ -18,7 +18,7 @@ def run_preprocessing(path_or_config: str | dict, reproduce: bool = True): """ config = load_config(path_or_config) output_dir = config["preprocessing"]["output_dir"] - + if config["preprocessing"]["n_events"] is None: config["preprocessing"]["n_events"] = ( config["processing"]["n_train_events"] diff --git a/LHCb_Pipeline/Preprocessing/selecting.py b/LHCb_Pipeline/Preprocessing/selecting.py index d9105cf383a92d3c34f37b2d6203adac3359003c..9a0000c0d6a4528b55facbfa9ca0f752a3bac5e6 100644 --- a/LHCb_Pipeline/Preprocessing/selecting.py +++ b/LHCb_Pipeline/Preprocessing/selecting.py @@ -1,5 +1,8 @@ import typing +import logging +import numpy as np import pandas as pd +from .particle_line_fitting import compute_particle_line_metrics_dataframe class SelectionFunction(typing.Protocol): @@ -29,12 +32,15 @@ def apply_mask( """ # About 3 seconds in a dataframe with 5000 events hits_particles_mask = ( - hits_particles[["event", "mcid"]] + hits_particles[["event", "particle_id"]] + .reset_index() .merge( - right=particles[["event", "mcid"]].assign(mask_=particles_mask), - on=["event", "mcid"], + right=particles[["event", "particle_id"]].assign(mask_=particles_mask), + on=["event", "particle_id"], how="left", - )["mask_"] + sort=False, + ) + .set_index("index")["mask_"] .fillna(True) ) # fillna to keep fake hits @@ -80,8 +86,8 @@ def everything_but_long_electrons( long electrons are left. """ # 1. Create a mask of the particles to keep: - mask_particles_to_keep = ( - particles["has_velo"] & particles["has_scifi"] & (particles["pid"].abs() != 11) + mask_particles_to_keep = particles["has_velo"] & ~( + particles["has_scifi"] & (particles["pid"].abs() == 11) ) # 2. Propagate the mask to the dataframe of `particles` and `hits_particles` @@ -91,6 +97,43 @@ def everything_but_long_electrons( return hits_particles, particles +def default_old_training_for_rta_presentation( + hits_particles: pd.DataFrame, particles: pd.DataFrame +) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: + """Selection that was used in the training presented in the RTA meeting.""" + + # Drop duplicates hits + hits_particles = hits_particles.drop_duplicates( + subset=["event", "particle_id", "plane"], keep="first" + ) + # Remove fake hits (there shouldn't be any already) + hits_particles = hits_particles[hits_particles["particle_id"] != 0] + + # Compute distance to line and add it to the dataframe of particles + logging.info("Compute distance to line (that might take some time)") + new_distances = compute_particle_line_metrics_dataframe( + hits=hits_particles, + metric_names=["distance_to_line"], + ) + particles = particles.merge(new_distances, how="left", on=["event", "particle_id"]) + + # Only keep reconstructible particles that are straight enough + logging.info("Apply particle selection mask") + mask_particles_to_keep = ( + (particles["has_velo"] == 1) + & (particles["nhits_velo"] >= 3) + & (particles["distance_to_line"] < np.sqrt(0.6)) + ) + particles, hits_particles = apply_mask( + mask_particles_to_keep, particles, hits_particles + ) + # assert that there is not any nan values at this point + assert not particles.isna().any().any() + assert not hits_particles.isna().any().any() + + return hits_particles, particles + + def everything_but_electrons( hits_particles: pd.DataFrame, particles: pd.DataFrame ) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: @@ -105,12 +148,64 @@ def everything_but_electrons( long electrons are left. """ # 1. Create a mask of the particles to keep: - mask_particles_to_keep = ( - particles["has_velo"] & (particles["pid"].abs() != 11) - ) + mask_particles_to_keep = particles["has_velo"] & (particles["pid"].abs() != 11) # 2. Propagate the mask to the dataframe of `particles` and `hits_particles` particles, hits_particles = apply_mask( mask_particles_to_keep, particles, hits_particles ) return hits_particles, particles + + +def track_weighting_selection( + hits_particles: pd.DataFrame, particles: pd.DataFrame +) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: + """The selection performed in the ``track-weighting`` experiment.""" + + # Only keep reconstructible particles that are straight enough + # Also remove the hits to avoid splitted tracks + # (we will counter-balance by requiring enough clusters / event) + logging.info("Compute distance to line (that might take some time)") + new_distances = compute_particle_line_metrics_dataframe( + hits=hits_particles, metric_names=["distance_to_line"] + ) + particles = particles.merge(new_distances, how="left", on=["event", "particle_id"]) + mask_particles_to_keep = particles["distance_to_line"] < 0.8 + particles, hits_particles = apply_mask( + mask_particles_to_keep, particles, hits_particles + ) + + # assert that there is not any nan values at this point + assert not particles.isna().any().any() + assert not hits_particles.isna().any().any() + + return hits_particles, particles + + +def triplets_first_selection( + hits_particles: pd.DataFrame, particles: pd.DataFrame +) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: + """The selection performed in the ``triplets-edge`` experiment.""" + # Only keep one particles-hits association (drop duplicates) + hits_particles = hits_particles.drop_duplicates( + subset=["event", "hit_id"], keep="first" + ) + + # Only keep reconstructible particles that are straight enough + # Also remove the hits to avoid splitted tracks + # (we will counter-balance by requiring enough clusters / event) + logging.info("Compute distance to line (that might take some time)") + new_distances = compute_particle_line_metrics_dataframe( + hits=hits_particles, metric_names=["distance_to_line"] + ) + particles = particles.merge(new_distances, how="left", on=["event", "particle_id"]) + mask_particles_to_keep = particles["distance_to_line"] < 0.8 + particles, hits_particles = apply_mask( + mask_particles_to_keep, particles, hits_particles + ) + + # assert that there is not any nan values at this point + assert not particles.isna().any().any() + assert not hits_particles.isna().any().any() + + return hits_particles, particles diff --git a/LHCb_Pipeline/Processing/planewise_edges.py b/LHCb_Pipeline/Processing/planewise_edges.py index a0757960b8387448bb34cb26aff9e360edcc0867..dcf4107e4b17938fcbb7310f3c1877bae1a74e84 100644 --- a/LHCb_Pipeline/Processing/planewise_edges.py +++ b/LHCb_Pipeline/Processing/planewise_edges.py @@ -4,6 +4,7 @@ This way, we define the edge orientation using a left to right convention. However, if a plane a multiple hits for the same particle, the edges can be not well defined. """ +import typing import numpy as np import pandas as pd import numba as nb @@ -13,12 +14,12 @@ from utils.tools.tgroupby import get_group_indices_from_group_lengths @nb.jit(nopython=True, cache=True) def get_edges_from_sorted_impl( - edges: np.ndarray, hit_ids: np.ndarray, - particle_group_indices: np.ndarray, -) -> None: + particle_ids: np.ndarray, + plane_ids: np.ndarray, +) -> typing.List[np.ndarray]: """Fill the array of plane-wise edges by grouping by particle ID already sorted - by plane, and forming edge by linking "adjacent" hit IDs. + by plane, and forming edge by linking "adjacent" planes. Args: edges: Pre-allocated empty array of edges to fill @@ -26,46 +27,69 @@ def get_edges_from_sorted_impl( particle_group_indices: Start and end indices in ``hit_ids`` that delimits hits that have same particle ID. """ - edge_idx = 0 - for start_idx, end_idx in zip( + n_hits_per_particles = group_lengths(particle_ids)[0] + particle_group_indices = get_group_indices_from_group_lengths(n_hits_per_particles) + + list_edges = [np.zeros(dtype=hit_ids.dtype, shape=(2, 1)) for _ in range(0)] + + for particle_start_idx, particle_end_idx in zip( particle_group_indices[:-1], particle_group_indices[1:] ): - n_edges = end_idx - start_idx - 1 - next_edge_idx = edge_idx + n_edges - edges[0, edge_idx:next_edge_idx] = hit_ids[start_idx : end_idx - 1] - edges[1, edge_idx:next_edge_idx] = hit_ids[start_idx + 1 : end_idx] - edge_idx = next_edge_idx + particle_hit_ids = hit_ids[particle_start_idx: particle_end_idx] + n_planes_per_hits = group_lengths( + plane_ids[particle_start_idx:particle_end_idx] + )[0] + plane_group_indices = get_group_indices_from_group_lengths(n_planes_per_hits) + + n_edges = np.sum(np.multiply(n_planes_per_hits[:-1], n_planes_per_hits[1:])) + edges = np.full(shape=(2, n_edges), dtype=hit_ids.dtype, fill_value=-1) + edge_idx = 0 + for plane_group in range( + len(plane_group_indices) - 2 + ): # up second to last plane + plane_start_idx = plane_group_indices[plane_group] + plane_end_idx = plane_group_indices[plane_group + 1] + next_plane_end_idx = plane_group_indices[plane_group + 2] + for hit_idx in range(plane_start_idx, plane_end_idx): + n_edges_to_add = next_plane_end_idx - plane_end_idx + edges[0, edge_idx : edge_idx + n_edges_to_add] = particle_hit_ids[ + hit_idx + ] + edges[1, edge_idx : edge_idx + n_edges_to_add] = particle_hit_ids[ + plane_end_idx:next_plane_end_idx + ] + edge_idx += n_edges_to_add - # Sanity check - assert edge_idx == edges.shape[1] + # Sanity check + assert edge_idx == n_edges + list_edges.append(edges) + + return list_edges def get_planewise_edges_impl( hit_ids: np.ndarray, particle_ids: np.ndarray, + plane_ids: np.ndarray, ) -> np.ndarray: """Get the plane-wise edges - + Args: hit_ids: array of hit IDs, sorted by particle IDs particle_ids: Sorted array of particle IDs for every hit - + plane_ids: Sorted array of plane IDs for every hit + Returns: Two-dimensional array where every column represent an edge. In this array, for every edge, a hit is referred to by its index in the dataframe of hits. """ - n_hits_per_particles = group_lengths(particle_ids)[0] - particle_group_indices = get_group_indices_from_group_lengths(n_hits_per_particles) - # Create, fill and return array of edges - n_edges = (n_hits_per_particles - 1).sum() - edges = np.zeros(shape=(2, n_edges), dtype=int) - get_edges_from_sorted_impl( - edges=edges, + list_edges = get_edges_from_sorted_impl( hit_ids=hit_ids, - particle_group_indices=particle_group_indices, + particle_ids=particle_ids, + plane_ids=plane_ids, ) - return edges + return np.hstack(list_edges) def get_planewise_edges( @@ -99,4 +123,5 @@ def get_planewise_edges( return get_planewise_edges_impl( hit_ids=signal_hits["index"].to_numpy(), particle_ids=signal_hits["particle_id"].to_numpy(), + plane_ids=signal_hits["plane"].to_numpy(), ) diff --git a/LHCb_Pipeline/Processing/processing.py b/LHCb_Pipeline/Processing/processing.py index 84b82c36da8c48e587bdd6a60560cc5eebcc5062..4e00f5bfbf3cef116ccb5cbddec06a33a816b88e 100644 --- a/LHCb_Pipeline/Processing/processing.py +++ b/LHCb_Pipeline/Processing/processing.py @@ -12,6 +12,8 @@ import torch from torch_geometric.data import Data from .modulewise_edges import get_modulewise_edges +from .planewise_edges import get_planewise_edges +from .sortedwise_edges import get_sortedwise_edges from .compute import compute_columns @@ -47,14 +49,31 @@ def get_normalised_features( return (array_features - feature_means) / feature_scales +def _get_source_target_columns( + columns: typing.List[str | typing.Dict[str, str]] +) -> typing.Tuple[typing.List[str], typing.List[str]]: + columns_source = [] + columns_target = [] + for column in columns: + if isinstance(column, dict): + first_key = next(iter(column.keys())) + columns_source.append(column[first_key]) + columns_target.append(first_key) + else: + columns_source.append(column) + columns_target.append(column) + return columns_source, columns_target + + def build_event( truncated_path: str, event_str: str, features: typing.List[str], feature_means: typing.List[float], feature_scales: typing.List[float], - kept_hits_columns: typing.List[str], - kept_particles_columns: typing.List[str], + kept_hits_columns: typing.List[str | typing.Dict[str, str]], + kept_particles_columns: typing.List[str | typing.Dict[str, str]], + true_edges_column: str, ) -> Data: """Load the event, compute the necessary columns. @@ -76,11 +95,19 @@ def build_event( particles = pd.read_parquet(truncated_path + "-particles.parquet") hits_particles = pd.read_parquet(truncated_path + "-hits_particles.parquet") + ( + kept_particles_columns_source, + kept_particles_columns_target, + ) = _get_source_target_columns(kept_particles_columns) + kept_hits_columns_source, kept_hits_columns_target = _get_source_target_columns( + kept_hits_columns + ) + merged_particles_columns = list( set( ["particle_id"] # index + ["vx", "vy", "vz"] # module-wise true edges - + kept_particles_columns # other columns to keep in the PyTorch data object + + kept_particles_columns_source # other columns to keep in the PyTorch data object ) ) @@ -94,16 +121,20 @@ def build_event( # Compute columns that are not already defined compute_columns( hits=hits_particles, - columns=kept_particles_columns + features, + columns=kept_particles_columns_source + features, ) # Find the true edges - true_edges = get_modulewise_edges(hits_particles) - logging.debug( - "Modulewise truth graph built for {} with size {}".format( - truncated_path, true_edges.shape + if true_edges_column == "modulewise": + true_edges = get_modulewise_edges(hits_particles) + elif true_edges_column == "planewise": + true_edges = get_planewise_edges(hits_particles) + elif true_edges_column == "sortedwise": + true_edges = get_sortedwise_edges(hits_particles) + else: + raise ValueError( + f"`true_edges_column` is `{true_edges_column}`, which is not recognised." ) - ) normalised_features = get_normalised_features( hits_particles, @@ -112,15 +143,20 @@ def build_event( feature_scales=feature_scales, ) - kept_columns = set( + kept_columns_source = ( # required columns [ "particle_id", # Plots, "hit_id", # matching ] # Other columns - + kept_hits_columns - + kept_particles_columns + + kept_hits_columns_source + + kept_particles_columns_source + ) + kept_columns_target = ( + ["particle_id", "hit_id"] + + kept_hits_columns_target + + kept_particles_columns_target ) torch_data = Data( @@ -128,10 +164,12 @@ def build_event( truncated_path=truncated_path, # To know for sure where the data come from event_str=event_str, # for the file names **{ - column: torch.from_numpy(hits_particles[column].to_numpy()) - for column in kept_columns + column_target: torch.from_numpy(hits_particles[column_source].to_numpy()) + for column_source, column_target in zip( + kept_columns_source, kept_columns_target + ) }, - modulewise_true_edges=torch.from_numpy(true_edges), + signal_true_edges=torch.from_numpy(true_edges), ) return torch_data diff --git a/LHCb_Pipeline/Processing/run_processing.py b/LHCb_Pipeline/Processing/run_processing.py index 0ad2e97e452d72328c1c12756fe9ab22fb1554a6..de7975ba7220d822948aa61330c33bef7ffbb638 100644 --- a/LHCb_Pipeline/Processing/run_processing.py +++ b/LHCb_Pipeline/Processing/run_processing.py @@ -36,16 +36,19 @@ def run_processing_in_parallel( """ if reproduce: delete_directory(output_dir) - elif is_directory_not_empty(output_dir): - logging.warn(f"Output directory is not empty: {output_dir}") os.makedirs(os.path.join(output_dir), exist_ok=True) - logging.info("Writing outputs to " + output_dir) - # Process input files with a worker pool and progress bar - process_func = partial( - prepare_event, output_dir=output_dir, **processing_config - ) - process_map(process_func, truncated_paths, max_workers=max_workers, chunksize=1) + if is_directory_not_empty(output_dir): + logging.info( + f"Output folder is not empty so processing was not run: {output_dir}" + ) + else: + logging.info("Writing outputs to " + output_dir) + # Process input files with a worker pool and progress bar + process_func = partial( + prepare_event, output_dir=output_dir, **processing_config + ) + process_map(process_func, truncated_paths, max_workers=max_workers, chunksize=1) def run_processing_test_dataset( diff --git a/LHCb_Pipeline/Processing/sortedwise_edges.py b/LHCb_Pipeline/Processing/sortedwise_edges.py new file mode 100644 index 0000000000000000000000000000000000000000..53969f3ac85201cfb580ccbb950458646f65519f --- /dev/null +++ b/LHCb_Pipeline/Processing/sortedwise_edges.py @@ -0,0 +1,101 @@ +"""A module that defines a way of defines the edges by sorting the hits by z-abscissa +(instead of by distance from the origin vertex). + +This way, we define the edge orientation using a left to right convention. +""" +import numpy as np +import pandas as pd +import numba as nb +from montetracko.array_utils.groupby import group_lengths +from utils.tools.tgroupby import get_group_indices_from_group_lengths + + +@nb.jit(nopython=True, cache=True) +def get_edges_from_sorted_impl( + edges: np.ndarray, + hit_ids: np.ndarray, + particle_group_indices: np.ndarray, +) -> None: + """Fill the array of sorted-wise edges by grouping by hits belonging to the + same particle, already sorted by z, and forming edge by linking "adjacent" hit IDs. + + Args: + edges: Pre-allocated empty array of edges to fill + hit_ids: List of hit IDs, sorted by particle IDs and z-coordinates. + particle_group_indices: Start and end indices in ``hit_ids`` + that delimits hits that have same particle ID. + """ + edge_idx = 0 + for start_idx, end_idx in zip( + particle_group_indices[:-1], particle_group_indices[1:] + ): + n_edges = end_idx - start_idx - 1 + next_edge_idx = edge_idx + n_edges + edges[0, edge_idx:next_edge_idx] = hit_ids[start_idx : end_idx - 1] + edges[1, edge_idx:next_edge_idx] = hit_ids[start_idx + 1 : end_idx] + edge_idx = next_edge_idx + + # Sanity check + assert edge_idx == edges.shape[1] + + +def get_sortedwise_edges_impl( + hit_ids: np.ndarray, + particle_ids: np.ndarray, +) -> np.ndarray: + """Get the sorted-wise edges + + Args: + hit_ids: array of hit IDs, sorted by particle IDs + particle_ids: z-sorted array of particle IDs for every hit + + Returns: + Two-dimensional array where every column represent an edge. In this array, + for every edge, a hit is referred to by its index in the dataframe of hits. + """ + n_hits_per_particles = group_lengths(particle_ids)[0] + particle_group_indices = get_group_indices_from_group_lengths(n_hits_per_particles) + + # Create, fill and return array of edges + n_edges = (n_hits_per_particles - 1).sum() + edges = np.zeros(shape=(2, n_edges), dtype=int) + get_edges_from_sorted_impl( + edges=edges, + hit_ids=hit_ids, + particle_group_indices=particle_group_indices, + ) + return edges + + +def get_sortedwise_edges( + hits: pd.DataFrame, drop_duplicates: bool = False +) -> np.ndarray: + """Get edges by sorting the hits by ``z`` for every particle in the event, + and linking the adjacent hits by edges. + + Args: + hits: dataframe of hits, with columns ``particle_id`` and ``z`` + drop_duplicates: whether to drop hits of a particle that belong to the same + z + + Returns: + Two-dimensional array where every column represent an edge. In this array, + for every edge, a hit is referred to by its index in the dataframe of hits. + """ + # Exclude noise + signal_hits = hits[hits.particle_id != 0] + + # Remove hits on the same z belonging to the same particle + if drop_duplicates: + signal_hits = signal_hits.drop_duplicates(subset=["particle_id", "z"]) + + # Sort by particle ID and z in order to group by particle ID and z in Numba + signal_hits = signal_hits.sort_values(["particle_id", "z"]).reset_index( + drop=False + ) # produce `index`, the indices before sorting + + # Get edges + return get_sortedwise_edges_impl( + hit_ids=signal_hits["index"].to_numpy(), + particle_ids=signal_hits["particle_id"].to_numpy(), + ) diff --git a/LHCb_Pipeline/Scripts/Build_Triplets.py b/LHCb_Pipeline/Scripts/Build_Triplets.py new file mode 100644 index 0000000000000000000000000000000000000000..85025101e9e5ac8ca9406cf4d0cfd3f0fa27fe15 --- /dev/null +++ b/LHCb_Pipeline/Scripts/Build_Triplets.py @@ -0,0 +1,216 @@ +""" +This script runs step 5 of the TrackML Quickstart example: Labelling spacepoints based on the scored graph. +""" +from __future__ import annotations +import typing +import logging + +import numpy as np +import scipy.sparse as sps +import torch +from torch_geometric.data import Data +from utils.commonutils.config import load_config +from utils.commonutils.ctests import get_required_test_dataset_names +from utils.commonutils.crun import run_for_different_partitions +from utils.modelutils.build import BuilderBase +from utils.scriptutils import parse_args, configure_logger, headline +from GNN.gnn_base import compute_edge_labels + + +configure_logger() + + +def filter_graph_edges( + edge_mask: torch.Tensor, + edge_indices: torch.Tensor, +) -> typing.Tuple[torch.Tensor, torch.Tensor]: + """Filter the hits that are not connected to any edge after filtering the graph + edges. + + Args: + edge_mask: Mask to filter the edges + edge_indices: current edge indices, before filtering + features: node features + + Returns: + Tuple of two arrays. Array of filtered edge indices, reindexed to take into + account the filtering of the nodes. + The second array is the array of unique node indices that remain in the graph, + and that can be used to filter all the node-related attributes. + """ + # Only keep kemaining nodes + unique_node_indices = torch.unique(edge_indices, sorted=True) + + # Reindex the node indices in `filtered_edge_indices` + n_filtered_nodes = unique_node_indices.shape[0] + mapping_new_indices = torch.full( + (edge_indices.max() + 1,), -1, dtype=torch.long # type: ignore + ) + mapping_new_indices[unique_node_indices] = torch.arange(n_filtered_nodes) + reindexed_edge_indices = mapping_new_indices[edge_indices] + filtered_reindexed_edge_indices = reindexed_edge_indices[:, edge_mask] + + return filtered_reindexed_edge_indices, unique_node_indices + + +def edge_to_triplet_scipy(edge_indices: np.ndarray) -> np.ndarray: + """Build the array of edge indices corresponding to overlapping doublets. + + Args: + edge_indices: Array of shape :math:`\\left(2, n_{\\text{edges}})`. One edge + is considered as a doublet + + Returns: + Array of edges, of shape :math:`\\left(2, n_{\\text{triplets}})`, that links + doublets that share a hit. + + Notes: + This function was taken from + https://github.com/exatrkx/exatrkx-ctd2020/blob/master/GraphLearning/build_triplets.py + """ + n_edges = edge_indices.shape[1] + n_hits = edge_indices.max() + 1 + + e_coo = sps.coo_matrix((np.ones(n_edges), (edge_indices[0], edge_indices[1]))) + + # Array (hit, edge) + # Element (i, j) = 1 if edge `j` is incoming from from node `i` + e_in_coo = sps.coo_matrix( + (np.ones(n_edges), (e_coo.row, np.arange(n_edges))), + shape=(n_hits, n_edges), + ) + e_in_csr = e_in_coo.tocsr() + + # Element (i, j) = 1 if edge `j` is outgoing from node `i` + e_out_coo = sps.coo_matrix( + (np.ones(n_edges), (e_coo.col, np.arange(n_edges))), + shape=(n_hits, n_edges), + ) + e_out_csr = e_out_coo.tocsr() + + # 1 if edges are common, 0 otherwise + e_total = e_out_csr.T * e_in_csr + + # extract indices of non-zero elements + e_total_coo = e_total.tocoo() + return np.vstack([e_total_coo.row, e_total_coo.col]) + + +class TripletBuilder(BuilderBase): + def construct_downstream(self, batch: Data): + # Compute edge slopes + un_xe = batch.un_x[batch.edge_index] + un_ye = batch.un_y[batch.edge_index] + un_ze = batch.un_z[batch.edge_index] + + batch.angle_yz = torch.atan((un_ye[1] - un_ye[0]) / (un_ze[1] - un_ze[0])) + batch.angle_xz = torch.atan((un_xe[1] - un_xe[0]) / (un_ze[1] - un_ze[0])) + batch.zdiff = un_ze[1] - un_ze[0] + + # Compute doublet features + doublet_features = torch.stack( + ( + un_xe[0] / 14.5, + un_ye[0] / 14.5, + batch.x[:, 2][batch.edge_index[0]], + batch.angle_yz / 0.16, + batch.angle_xz / 0.16, + (batch.zdiff - 75.0) / 65.0, + ), + dim=1, + ).float() + + # Compute triplet edges + triplet_indices = torch.from_numpy( + edge_to_triplet_scipy(batch.edge_index.numpy()) + ).long() + + diff_angle_xz = ( + batch.angle_xz[triplet_indices[1]] + - batch.angle_xz[triplet_indices[0]] + ) + + diff_angle_yz = ( + batch.angle_yz[triplet_indices[1]] + - batch.angle_yz[triplet_indices[0]] + ) + + # rough_mask = ( + # (torch.abs(diff_angle_xz) < 0.01) & (torch.abs(diff_angle_yz) < 0.01) + # ) + # triplet_indices = triplet_indices[:, rough_mask] + # diff_angle_xz = diff_angle_xz[rough_mask] + # diff_angle_yz = diff_angle_yz[rough_mask] + diff_angle_xz_norm = diff_angle_xz / 0.0076 + diff_angle_yz_norm = diff_angle_yz / 0.0076 + + # Compute true labels: both edges need to be `true` for the triplet + # to be true as well + y_triplet = batch.y[triplet_indices].min(dim=0).values + + if "y_pid" not in batch: + y_pid = compute_edge_labels( + edge_indices=batch.edge_index, + particle_ids=batch.particle_id, + ) + else: + y_pid = batch.y_pid + + y_pid_triplet = y_pid[triplet_indices].min(dim=0).values + + + return Data( + x=doublet_features, + edge_index=triplet_indices, + doublet_edge_index=batch.edge_index, + y=y_triplet, + y_pid=y_pid_triplet, + diff_angle_xz_norm=diff_angle_xz_norm, + diff_angle_yz_norm=diff_angle_yz_norm, + diff_angle_yz=diff_angle_yz, + diff_angle_xz=diff_angle_xz, + hit_id=batch.hit_id, + event_str=batch.event_str, + truncated_path=batch.truncated_path, + angle_xz=batch.angle_xz, + angle_yz=batch.angle_yz, + scores=batch.scores, + # **{ + # column_name: column + # for column_name, column in batch.items() + # if column_name + # not in [ + # "x", + # "edge_index", + # "y_pid", + # "y", + # ] + # }, + ) + + +def train( + path_or_config: str | dict, + partitions: typing.List[str] = ["train", "val", "test"], + reproduce: bool = True, + parallel: bool = False, +): + all_configs = load_config(path_or_config) + triplet_building_configs = all_configs["triplet_building"] + logging.info(headline(" Step 5: Building triplets.")) + + tripletBuilder = TripletBuilder() + run_for_different_partitions( + tripletBuilder.infer, + input_dir=triplet_building_configs["input_dir"], + output_dir=triplet_building_configs["output_dir"], + reproduce=reproduce, + partitions=partitions, + test_dataset_names=get_required_test_dataset_names(all_configs), + parallel=parallel + ) + + +if __name__ == "__main__": + config_file = parse_args() + train(config_file) diff --git a/LHCb_Pipeline/Scripts/Filter_Edges.py b/LHCb_Pipeline/Scripts/Filter_Edges.py new file mode 100644 index 0000000000000000000000000000000000000000..a092f286df87ac9a5251efa2bc34b6fd87d0c5eb --- /dev/null +++ b/LHCb_Pipeline/Scripts/Filter_Edges.py @@ -0,0 +1,63 @@ +""" +This script runs step 5 of the TrackML Quickstart example: Labelling spacepoints based on the scored graph. +""" +from __future__ import annotations +import typing +import logging + +import numpy as np +import scipy.sparse as sps +import torch +from torch_geometric.data import Data +from utils.commonutils.config import load_config +from utils.commonutils.ctests import get_required_test_dataset_names +from utils.commonutils.crun import run_for_different_partitions +from utils.modelutils.build import BuilderBase +from utils.scriptutils import parse_args, configure_logger, headline + +configure_logger() + + +class EdgeFilter(BuilderBase): + def __init__(self, score_cut: float) -> None: + super(EdgeFilter, self).__init__() + self.score_cut = float(score_cut) + + def construct_downstream(self, batch: Data): + edge_mask = batch.scores > self.score_cut + batch.edge_index = batch.edge_index[:, edge_mask] + batch.y = batch.y[edge_mask] + batch.scores = batch.scores[edge_mask] + if "y_pid" in batch: + batch.y_pid = batch.y_pid[edge_mask] + return batch + + +def train( + path_or_config: str | dict, + partitions: typing.List[str] = ["train", "val", "test"], + score_cut: float | None = None, + reproduce: bool = True, +): + all_configs = load_config(path_or_config) + edge_filtering_configs = all_configs["edge_filtering"] + logging.info(headline(" Step 5: Building track candidates from the scored graph ")) + + trackBuilder = EdgeFilter( + score_cut=( + edge_filtering_configs["score_cut"] if score_cut is None else score_cut + ) + ) + run_for_different_partitions( + trackBuilder.infer, + input_dir=edge_filtering_configs["input_dir"], + output_dir=edge_filtering_configs["output_dir"], + reproduce=reproduce, + partitions=partitions, + test_dataset_names=get_required_test_dataset_names(all_configs), + ) + + +if __name__ == "__main__": + config_file = parse_args() + train(config_file) diff --git a/LHCb_Pipeline/Scripts/Step_2_Run_Metric_Learning.py b/LHCb_Pipeline/Scripts/Step_2_Run_Metric_Learning.py index dfc9e35f7e5bf20f76c3da2aba9ed2be7f5bf966..67f8d9a30f3bb05fe151a4e118fee8a27613661c 100644 --- a/LHCb_Pipeline/Scripts/Step_2_Run_Metric_Learning.py +++ b/LHCb_Pipeline/Scripts/Step_2_Run_Metric_Learning.py @@ -21,8 +21,32 @@ configure_logger() def train( path_or_config: str | dict, partitions: typing.List[str] = ["train", "val", "test"], - checkpoint: str | None = None, + checkpoint: LayerlessEmbedding | str | None = None, + reproduce: bool = True, + override_hparams: bool = False, + **kwargs, ): + """Run the inference of the metric learning stage. + + Args: + path_or_config: configuration dictionary, or path to the YAML file that contains + the configuration + partitions: Partitions to run the inference on: + + * ``train``: train dataset + * ``val``: validation dataset + * ``test``: all the test datasets + * A specific test dataset name + + checkpoint: Model already loaded, or path to its checkpoint. If ``None``, + try to find it automatically in the artifact folder given + the configuration. + reproduce: whether to delete an existing folder + override_hparams: whether to override the hyparameters of the model + that is loaded, with the ones in the YAML configuration + **kwargs: Other keyword arguments passed to the + :py:func:`PyTorch.LightingModel.load_from_checkpoint` class method + """ all_configs = load_config(path_or_config) logging.info(headline("Step 2: Constructing graphs from metric learning model")) @@ -32,24 +56,21 @@ def train( logging.info(headline("a) Loading trained model")) device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - if checkpoint is None: # Default loading mode from last artifact - checkpoint = os.path.join( + + if override_hparams: + kwargs = {"hparams": metric_learning_configs, **kwargs} + logging.info(str(kwargs)) + + model = LayerlessEmbedding.get_model_from_checkpoint( + checkpoint=checkpoint, + default_checkpoint=os.path.join( common_configs["artifact_directory"], "metric_learning", common_configs["experiment_name"] + ".ckpt", - ) - model = LayerlessEmbedding.load_from_checkpoint( - checkpoint, map_location=device - ) - else: - model = LayerlessEmbedding.load_from_checkpoint( - checkpoint_path=checkpoint, - map_location=device, - **metric_learning_configs, # Override the hyperparameters - ) - - # Load checkpoint from specified path - logging.info(f"Load model from {checkpoint}.") + ), + map_location=device, + **kwargs, + ) logging.info(headline("b) Running inferencing")) @@ -58,6 +79,10 @@ def train( else: radius = metric_learning_configs["r_test"] + building = metric_learning_configs.pop("building", None) + filtering = metric_learning_configs.pop("filtering", None) + + logging.info(f"Use radius {radius}") graph_builder = EmbeddingInferenceBuilder( model, knn_max=metric_learning_configs["knn"], @@ -70,10 +95,15 @@ def train( output_dir=metric_learning_configs["output_dir"], partitions=partitions, test_dataset_names=get_required_test_dataset_names(all_configs), - reproduce=True, + reproduce=reproduce, + list_kwargs=[ + dict(building=building, filtering=filtering) + if partition in ["train", "val"] + else dict(building=building) + for partition in partitions + ], ) - return graph_builder diff --git a/LHCb_Pipeline/Scripts/Step_3_Train_GNN.py b/LHCb_Pipeline/Scripts/Step_3_Train_GNN.py index d7e062aa17c7f62a0259da79d7a3a0f3a5f19f79..a8980a52d5df23f61944df4f5142adcc7f3467c5 100644 --- a/LHCb_Pipeline/Scripts/Step_3_Train_GNN.py +++ b/LHCb_Pipeline/Scripts/Step_3_Train_GNN.py @@ -18,12 +18,14 @@ from utils.scriptutils import parse_args, configure_logger, headline configure_logger() -def train(path_or_config: str | dict): +def train(path_or_config: str | dict, identifier: str | None = None): all_configs = load_config(path_or_config) + if identifier is None: + identifier = "" logging.info(headline(" Step 3: Running GNN training ")) common_configs = all_configs["common"] - gnn_configs = all_configs["gnn"] + gnn_configs = all_configs["gnn" + identifier] logging.info(headline("a) Initialising model")) @@ -32,7 +34,7 @@ def train(path_or_config: str | dict): logging.info(headline("b) Running training")) save_directory = os.path.abspath( - os.path.join(common_configs["artifact_directory"], "gnn") + os.path.join(common_configs["artifact_directory"], "gnn" + identifier) ) logger = CSVLogger(save_directory, name=common_configs["experiment_name"]) @@ -43,6 +45,7 @@ def train(path_or_config: str | dict): devices=common_configs["gpus"], max_epochs=gnn_configs["max_epochs"], logger=logger, + gradient_clip_val=gnn_configs.get("gradient_clip_val"), # callbacks=[EarlyStopping(monitor="val_loss", mode="min")] ) diff --git a/LHCb_Pipeline/Scripts/Step_4_Run_GNN.py b/LHCb_Pipeline/Scripts/Step_4_Run_GNN.py index 03bd765bde74c0f5a49d1e3d4f27a8c8bf63e298..4d842a24e9de10962048b9bda28b4d02251ec35e 100644 --- a/LHCb_Pipeline/Scripts/Step_4_Run_GNN.py +++ b/LHCb_Pipeline/Scripts/Step_4_Run_GNN.py @@ -22,32 +22,37 @@ configure_logger() def train( path_or_config: str | dict, partitions: typing.List[str] = ["train", "val", "test"], - checkpoint: str | None = None, + checkpoint: InteractionGNN | str | None = None, + reproduce: bool = True, + override_hparams: bool = False, + identifier: str | None = None, + **kwargs, ): all_configs = load_config(path_or_config) + if identifier is None: + identifier = "" logging.info(headline("Step 4: Scoring graph edges using GNN ")) common_configs = all_configs["common"] - gnn_configs = all_configs["gnn"] + gnn_configs = all_configs["gnn" + identifier] logging.info(headline("a) Loading trained model")) + if override_hparams: + kwargs = {"hparams": gnn_configs, **kwargs} + device = torch.device("cuda" if torch.cuda.is_available() else "cpu") - if checkpoint is None: # Default loading mode from last artifact - checkpoint = os.path.join( + model = InteractionGNN.get_model_from_checkpoint( + checkpoint=checkpoint, + default_checkpoint=os.path.join( common_configs["artifact_directory"], - "gnn", + "gnn" + identifier, common_configs["experiment_name"] + ".ckpt", - ) - - model = InteractionGNN.load_from_checkpoint(checkpoint, map_location=device) - else: - model = InteractionGNN.load_from_checkpoint( - checkpoint_path=checkpoint, - map_location=device, - **gnn_configs, # Override the hyperparameters - ) + ), + map_location=device, + **kwargs, + ) logging.info(f"Load model from {checkpoint}.") @@ -59,7 +64,7 @@ def train( output_dir=gnn_configs["output_dir"], partitions=partitions, test_dataset_names=get_required_test_dataset_names(all_configs), - reproduce=True, + reproduce=reproduce, ) diff --git a/LHCb_Pipeline/Scripts/Step_5_Build_Track_Candidates.py b/LHCb_Pipeline/Scripts/Step_5_Build_Track_Candidates.py index a593d52ca0a9387bac2aff4f1d0b46f01db689fd..7874c7a2a7fd45265a81331c791332b306c4b4a4 100644 --- a/LHCb_Pipeline/Scripts/Step_5_Build_Track_Candidates.py +++ b/LHCb_Pipeline/Scripts/Step_5_Build_Track_Candidates.py @@ -1,6 +1,7 @@ """ This script runs step 5 of the TrackML Quickstart example: Labelling spacepoints based on the scored graph. """ +from __future__ import annotations import typing import logging @@ -17,35 +18,61 @@ from utils.scriptutils import parse_args, configure_logger, headline configure_logger() +def get_track_ids(edge_indices: torch.Tensor, n_hits: int) -> np.ndarray: + row, col = edge_indices + edge_attr = np.ones(row.size(0)) + + sparse_edges = sps.coo_matrix( + (edge_attr, (row.numpy(), col.numpy())), (n_hits, n_hits) + ) + + _, candidate_labels = sps.csgraph.connected_components( + sparse_edges, directed=False, return_labels=True + ) + return candidate_labels + + class TrackBuilder(BuilderBase): def __init__(self, score_cut: float) -> None: super(TrackBuilder, self).__init__() self.score_cut = float(score_cut) def construct_downstream(self, batch: Data): - edge_mask = batch.scores > self.score_cut + edge_indices = batch.edge_index[:, batch.scores > self.score_cut] - row, col = batch.edge_index[:, edge_mask] - edge_attr = np.ones(row.size(0)) + if "doublet_edge_index" in batch.keys: + # Come back to doublets + double_edge_indices = batch.doublet_edge_index[ + :, torch.unique(edge_indices) + ] + else: + double_edge_indices = edge_indices - N = batch.x.size(0) - sparse_edges = sps.coo_matrix((edge_attr, (row.numpy(), col.numpy())), (N, N)) + labels = torch.from_numpy( + get_track_ids( + edge_indices=double_edge_indices, + n_hits=batch.x.shape[0], + ) + ).long() + batch.labels = labels - _, candidate_labels = sps.csgraph.connected_components( - sparse_edges, directed=False, return_labels=True - ) - batch.labels = torch.from_numpy(candidate_labels).long() + return batch def train( path_or_config: str | dict, partitions: typing.List[str] = ["train", "val", "test"], + score_cut: float | None = None, ): all_configs = load_config(path_or_config) track_building_configs = all_configs["track_building"] logging.info(headline(" Step 5: Building track candidates from the scored graph ")) - trackBuilder = TrackBuilder(score_cut=track_building_configs["score_cut"]) + score_cut = track_building_configs["score_cut"] if score_cut is None else score_cut + trackBuilder = TrackBuilder( + score_cut=score_cut + ) + logging.info("Score cut: " + str(score_cut)) run_for_different_partitions( trackBuilder.infer, input_dir=track_building_configs["input_dir"], diff --git a/LHCb_Pipeline/Scripts/Step_6_Evaluate_Reconstruction_MonteTracko.py b/LHCb_Pipeline/Scripts/Step_6_Evaluate_Reconstruction_MonteTracko.py index b6feb71677c02d96ae5dee981c70d75a9eaa7755..1992589961383f3add6c0ddfb08afed0f3ac8fd7 100644 --- a/LHCb_Pipeline/Scripts/Step_6_Evaluate_Reconstruction_MonteTracko.py +++ b/LHCb_Pipeline/Scripts/Step_6_Evaluate_Reconstruction_MonteTracko.py @@ -11,20 +11,34 @@ from argparse import ArgumentParser from tqdm.auto import tqdm import pandas as pd import torch +from torch_geometric.data import Data import montetracko as mt import montetracko.lhcb as mtb from Preprocessing.preprocessing_paths import get_truncated_paths_for_partition +from Preprocessing.particle_line_fitting import compute_particle_line_metrics_dataframe from utils.plotutils import plotconfig from utils.commonutils.config import load_config from utils.commonutils.ctests import get_required_test_dataset_names +from utils.commonutils.cpaths import get_performance_directory from utils.scriptutils import configure_logger, headline + configure_logger() +def get_tracks_from_batch(batch: Data) -> pd.DataFrame: + return pd.DataFrame( + { + "event_id": int(batch.event_str), + "hit_id": batch.hit_id, + "track_id": batch.labels, + } + ) + + def load_tracks_event(input_path: str) -> pd.DataFrame: """Load the dataframe of tracks out of track building. @@ -36,13 +50,7 @@ def load_tracks_event(input_path: str) -> pd.DataFrame: Dataframe with columns ``event_id``, ``hit_id``, ``track_id`` """ graph = torch.load(input_path, map_location="cpu") - df_tracks = pd.DataFrame( - { - "event_id": int(graph.event_str), - "hit_id": graph.hit_id, - "track_id": graph.labels, - } - ) + df_tracks = get_tracks_from_batch(graph) return df_tracks @@ -144,7 +152,7 @@ def load_dataframes_given_partition( df_hits_particles = load_parquet_files( truncated_paths=truncated_paths, ending="-hits_particles", - columns=["particle_id", "hit_id"], + columns=["particle_id", "hit_id", "plane", "x", "y", "z"], ) df_particles = load_parquet_files( truncated_paths=truncated_paths, ending="-particles" @@ -172,6 +180,7 @@ def perform_evaluation( allen_report: bool = True, table_report: bool = True, plot_categories: typing.Iterable[mt.requirement.Category] | None = None, + plotted_groups: typing.List[str] | None = ["basic"], output_dir: str | None = None, suffix: str | None = None, ): @@ -186,7 +195,13 @@ def perform_evaluation( histograms are plotted for the reconstructible tracks in the velo, and the long electrons. In order not to plot, you may set this variable to an empty list. + plotted_groups: Pre-configured metrics and columns to plot. + Each group corresponds to one plot that shows the the distributions of + various metrics as a function of various truth variables, + as hard-coded in :py:func:`plot`. + There are 3 groups: ``basic``, ``geometry`` and ``challenging``. output_dir: Output directory where to save the report and the plots + suffix: string to append to the file name of the reports and figures produced. """ timestr = time.strftime("%Y.%m.%d-%H.%M.%S") @@ -194,15 +209,15 @@ def perform_evaluation( if allen_report or table_report: list_reports = [] if allen_report: - allen_report = trackEvaluator.report( + allen_report_str = trackEvaluator.report( reporter=mt.AllenReporter(), categories=mtb.category.allen_categories, ) - list_reports.append(allen_report) + list_reports.append(allen_report_str) if table_report: - table_report_categories = trackEvaluator.report( + table_report_str = trackEvaluator.report( reporter=mt.TabReporter( [ "efficiency", @@ -216,7 +231,7 @@ def perform_evaluation( ), categories=mtb.category.velo_categories, ) - list_reports.append(table_report_categories) + list_reports.append(table_report_str) table_report_global = trackEvaluator.report( reporter=mt.TabReporter( metric_names=["n_ghosts", "n_tracks", "ghost_rate"], @@ -239,12 +254,13 @@ def perform_evaluation( report_file.write(total_report) logging.info(f"Report was saved in {output_path}") - if plot_categories is not None: + if plot_categories is not None and plotted_groups is not None and plotted_groups: for plot_category in plot_categories: plot( trackEvaluator=trackEvaluator, category=plot_category, output_dir=output_dir, + plotted_groups=plotted_groups, suffix=suffix, ) @@ -252,6 +268,7 @@ def perform_evaluation( def plot( trackEvaluator: mt.TrackEvaluator, category: mt.requirement.Category, + plotted_groups: typing.List[str] = ["basic"], output_dir: str | None = None, suffix: str | None = None, ): @@ -260,29 +277,107 @@ def plot( Args: trackEvaluator: A ``TrackEvaluator`` instance containing the results - of the track matching. + of the track matching + category: Truth category for the plot + plotted_groups: Pre-configured metrics and columns to plot. + Each group corresponds to one plot that shows the the distributions of + various metrics as a function of various truth variables, + as hard-coded in this function. + There are 3 groups: ``basic``, ``geometry`` and ``challenging``. """ plotconfig.configure_matplotlib() - fig, _, _ = trackEvaluator.plot_histograms( - columns=["pt", "p", "eta", "vz"], - metric_names=[ - "efficiency", - "clone_rate", - "hit_purity_per_candidate", - "hit_efficiency_per_candidate", - ], - column_labels=plotconfig.column_labels, - column_ranges=plotconfig.column_ranges, - category=category, - bins=20, + + group_configurations = { + "basic": dict( + columns=["pt", "p", "eta", "vz"], + metric_names=[ + "efficiency", + "clone_rate", + # "hit_purity_per_candidate", + "hit_efficiency_per_candidate", + ], + ), + "challenging": dict( + columns=["vz", "nhits_velo"], + metric_names=["efficiency"], + ), + "geometry": dict( + columns=["distance_to_line", "distance_to_z_axis", "xz_angle", "yz_angle"], + metric_names=["efficiency"], + ), + } + + for group_name in plotted_groups: + if group_name not in group_configurations: + raise ValueError( + f"Group `{group_name}` is unknown. " + "Valid groups are: " + ", ".join(group_configurations.keys()) + ) + + group_config = group_configurations[group_name] + + fig, _, _ = trackEvaluator.plot_histograms( + **group_config, + column_labels=plotconfig.column_labels, + column_ranges=plotconfig.column_ranges, + category=category, + bins=plotconfig.column_bins, + ) + if output_dir is not None: + os.makedirs(output_dir, exist_ok=True) + if suffix is None: + suffix = "" + plot_path = op.join( + output_dir, f"hist1d_{group_name}_{category.name}{suffix}.pdf" + ) + fig.savefig(plot_path, dpi=200, bbox_inches="tight") + logging.info( + f"Plot {group_name} for category {category.name} saved in {plot_path}" + ) + + +def compute_plane_stats( + df_hits_particles: pd.DataFrame, df_particles: pd.DataFrame +) -> pd.DataFrame: + """Compute variables related to the numbers of hits w.r.t. the planes. + + Args: + df_hits_particles: Dataframe of hits-particles association. Must have + the columns ``event_id``, ``particle_id`` and ``plane``. + df_particles: Dataframe of particles. Must have the columns ``event_id`` + and ``particle_id``. + + Returns: + Dataframe of particles with the new columns. + """ + min_planes = ( + df_hits_particles.groupby(["event_id", "particle_id"])["plane"] + .min() + .rename("min_plane") + ) + max_planes = ( + df_hits_particles.groupby(["event_id", "particle_id"])["plane"] + .max() + .rename("max_plane") + ) + n_unique_planes = ( + df_hits_particles.groupby(["event_id", "particle_id"])["plane"] + .nunique() + .rename("n_planes") + ) + n_hits = ( + df_hits_particles.groupby(["event_id", "particle_id"]).size().rename("n_hits") + ) + n_repeated_planes = (n_hits - n_unique_planes).rename("n_repeated_planes") + n_skipped_planes = (max_planes - min_planes + 1 - n_unique_planes).rename( + "n_skipped_planes" + ) + + return df_particles.merge( + pd.concat((n_repeated_planes, n_skipped_planes), axis=1).reset_index(), + how="left", + on=["event_id", "particle_id"], ) - if output_dir is not None: - os.makedirs(output_dir, exist_ok=True) - if suffix is None: - suffix = "" - plot_path = op.join(output_dir, f"hist1d_{category.name}{suffix}.pdf") - fig.savefig(plot_path, dpi=200, bbox_inches="tight") - logging.info(f"Plot for category {category.name} saved in {plot_path}") def evaluate( @@ -291,6 +386,7 @@ def evaluate( allen_report: bool = True, table_report: bool = True, plot_categories: typing.Iterable[mt.requirement.Category] | None = None, + plotted_groups: typing.List[str] | None = ["basic"], min_track_length: int = 3, ) -> mt.TrackEvaluator: """Runs truth-based tracking evaluation. @@ -304,6 +400,11 @@ def evaluate( histograms are plotted for the reconstructible tracks in the velo, and the long electrons. In order not to plot, you may set this variable to an empty list. + plotted_groups: Pre-configured metrics and columns to plot. + Each group corresponds to one plot that shows the the distributions of + various metrics as a function of various truth variables, + as hard-coded in :py:func:`plot`. + There are 3 groups: ``basic``, ``geometry`` and ``challenging``. Returns: object containing the evaluation. @@ -316,6 +417,28 @@ def evaluate( df_tracks, df_hits_particles, df_particles = load_dataframes_given_partition( path_or_config=all_configs, partition=partition ) + logging.info("Compute plat stats") + df_particles = compute_plane_stats( + df_hits_particles=df_hits_particles, + df_particles=df_particles, + ) + + if plotted_groups is not None and "geometry" in plotted_groups: + logging.info("Compute particle line metrics") + new_distances = compute_particle_line_metrics_dataframe( + hits=df_hits_particles, + metric_names=[ + "distance_to_line", + "distance_to_z_axis", + "xz_angle", + "yz_angle", + ], + event_id_column="event_id", + ) + + df_particles = df_particles.merge( + new_distances, how="left", on=["event_id", "particle_id"] + ) logging.info("2) Matching") trackEvaluator = perform_matching( @@ -337,8 +460,9 @@ def evaluate( allen_report=allen_report, table_report=table_report, plot_categories=plot_categories, - output_dir=all_configs["common"]["performance_directory"], - suffix=f"-{partition}" + plotted_groups=plotted_groups, + output_dir=get_performance_directory(all_configs), + suffix=f"-{partition}", ) return trackEvaluator diff --git a/LHCb_Pipeline/analyses/README.md b/LHCb_Pipeline/analyses/README.md new file mode 100644 index 0000000000000000000000000000000000000000..ebe04f5e3afed485b9d281d7b1ee08152c4e8948 --- /dev/null +++ b/LHCb_Pipeline/analyses/README.md @@ -0,0 +1,8 @@ +# Analyses + +This folder contains a collection of scripts and notebooks to answer +typical questions about the data distribution. + +How many hits are there in average / event? In average, how many repeated planes +do a track have? This folder contains scripts and notebooks to answer these kind of +questions in a reproducible way. diff --git a/LHCb_Pipeline/analyses/anaconfig.py b/LHCb_Pipeline/analyses/anaconfig.py new file mode 100644 index 0000000000000000000000000000000000000000..8eb1aef1baab8f1e839984e5137c40a42cd2b67e --- /dev/null +++ b/LHCb_Pipeline/analyses/anaconfig.py @@ -0,0 +1,14 @@ +"""Common configurations for the folder analyses. +""" +import sys +import os.path as op + +# Add montetracko and LHCb_Pipeline to PYTHONPATH +sys.path.append(op.abspath(op.join(op.dirname(__file__), "../../montetracko"))) +sys.path.append(op.abspath(op.join(op.dirname(__file__), ".."))) + +#: Directory where to save the plots +PLOTDIR = op.abspath(op.join("..", "output", "analyses")) + +#: Directory where the dataframes that are used for the analysis are located +DATAFRAME_DIR = "/scratch/acorreia/minbias-sim10b-xdigi-nospillover/92" diff --git a/LHCb_Pipeline/analyses/angles.ipynb b/LHCb_Pipeline/analyses/angles.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..bc29161f8d0dff2bd17830410fe5df05b392de11 --- /dev/null +++ b/LHCb_Pipeline/analyses/angles.ipynb @@ -0,0 +1,337 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "configure_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'tqdm' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[1], line 12\u001b[0m\n\u001b[1;32m 9\u001b[0m sizes_doublets \u001b[39m=\u001b[39m []\n\u001b[1;32m 10\u001b[0m sizes_triplets \u001b[39m=\u001b[39m []\n\u001b[0;32m---> 12\u001b[0m \u001b[39mfor\u001b[39;00m filename \u001b[39min\u001b[39;00m tqdm(os\u001b[39m.\u001b[39mlistdir(train_dir)[:\u001b[39m100\u001b[39m]):\n\u001b[1;32m 13\u001b[0m path \u001b[39m=\u001b[39m os\u001b[39m.\u001b[39mpath\u001b[39m.\u001b[39mjoin(train_dir, filename)\n\u001b[1;32m 14\u001b[0m batch \u001b[39m=\u001b[39m torch\u001b[39m.\u001b[39mload(path, map_location\u001b[39m=\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mcpu\u001b[39m\u001b[39m\"\u001b[39m)\n", + "\u001b[0;31mNameError\u001b[0m: name 'tqdm' is not defined" + ] + } + ], + "source": [ + "train_dir = \"/scratch/acorreia/data//triplet_building/train\"\n", + "\n", + "diff_angles_xz = []\n", + "diff_angles_yz = []\n", + "angles_xz = []\n", + "angles_yz = []\n", + "y = []\n", + "y_pid = []\n", + "sizes_doublets = []\n", + "sizes_triplets = []\n", + "\n", + "for filename in tqdm(os.listdir(train_dir)[:100]):\n", + " path = os.path.join(train_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " y.append(batch.y.numpy())\n", + " angle_xz = batch.angle_xz\n", + " angle_yz = batch.angle_yz\n", + " sizes_triplets.append(batch.edge_index.shape[1])\n", + " sizes_doublets.append(batch.doublet_edge_index.shape[1])\n", + " \n", + "\n", + " diff_angles_xz.append(batch.diff_angle_xz.numpy())\n", + " diff_angles_yz.append(batch.diff_angle_yz.numpy())\n", + " angles_xz.append(batch.angle_xz.numpy())\n", + " angles_yz.append(batch.angle_xz.numpy())\n", + " y_pid.append(batch.y_pid.numpy())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "array_diff_angles_xz = np.concatenate(diff_angles_xz, axis=0)\n", + "array_diff_angles_yz = np.concatenate(diff_angles_yz, axis=0)\n", + "array_angle_xz = np.concatenate(angles_xz, axis=0)\n", + "array_angle_yz = np.concatenate(angles_yz, axis=0)\n", + "array_y_pid = np.concatenate(y_pid, axis=0)\n", + "array_y = np.concatenate(y, axis=0)\n", + "sizes_doublets = np.array(sizes_doublets)\n", + "sizes_triplets = np.array(sizes_triplets)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "9.110746876470676" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(sizes_triplets / sizes_doublets).mean()" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist2d(\n", + " x=array_diff_angles_xz[array_y_pid == False],\n", + " y=array_diff_angles_yz[array_y_pid == False],\n", + " bins=300,\n", + " range=((-.05, .05), (-.05, 0.05))\n", + ");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist2d(\n", + " x=array_diff_angles_xz[array_y_pid == True],\n", + " y=array_diff_angles_yz[array_y_pid == True],\n", + " bins=300,\n", + " range=((-.05, .05), (-.05, 0.05))\n", + ");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f3899956050>" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_yz[array_y_pid == False],\n", + " label=\"Fake triplets\",\n", + " color=\"red\",\n", + " bins=500,\n", + " range=(-2.0, 2.0)\n", + ")\n", + "ax.hist(\n", + " array_diff_angles_xz[array_y_pid == True],\n", + " label=\"Genuine triplets\",\n", + " color=\"green\",\n", + " bins=edges,\n", + ")\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "truth = np.abs(array_diff_angles_xz)[array_y_pid == True]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9944294536612657" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(truth < 0.01).sum() / truth.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6206851640087514" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(array_diff_angles_xz < 0.01).sum() / array_diff_angles_xz.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "6.519369284875865" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(array_diff_angles_xz < 0.01).sum() / sizes_doublets.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: -0.0006086131776879624\n", + "std: 0.21332288342745845\n", + "mean: 0.0003985171692728271\n", + "std: 0.22402053515876744\n" + ] + } + ], + "source": [ + "print(\"mean:\", array_diff_angles_xz.mean())\n", + "print(\"std:\", array_diff_angles_xz.std())\n", + "print(\"mean:\", array_diff_angles_yz.mean())\n", + "print(\"std:\", array_diff_angles_yz.std())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: 0.002268124843566985\n", + "std: 0.15293637532876916\n", + "mean: 0.002268124843566985\n", + "std: 0.15293637532876916\n" + ] + } + ], + "source": [ + "print(\"mean:\", array_angle_xz.mean())\n", + "print(\"std:\", array_angle_xz.std())\n", + "print(\"mean:\", array_angle_yz.mean())\n", + "print(\"std:\", array_angle_yz.std())\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/edge_scores.ipynb b/LHCb_Pipeline/analyses/edge_scores.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..53e53e7ba31362b90e76925037742a030ddeadc0 --- /dev/null +++ b/LHCb_Pipeline/analyses/edge_scores.ipynb @@ -0,0 +1,531 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "configure_matplotlib()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyse the edge scores, depending on the track size" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch_scatter import scatter_add" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "test_dir = \"/scratch/acorreia/data/focal-loss-pid/gnn_processed/test/velo-sim10b-nospillover/\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "93a11ac913964b5596a9ed22f4d1cf61", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "list_n_hits = []\n", + "list_scores = []\n", + "list_y_pid = []\n", + "\n", + "dict_list_values = {\n", + " \"n_hits\": [],\n", + " \"scores\": [],\n", + " \"y_pid\": [],\n", + "}\n", + "\n", + "for filename in tqdm(os.listdir(test_dir)[:100]):\n", + " path = os.path.join(test_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " df_particles = pd.read_parquet(\n", + " batch.truncated_path + \"-particles.parquet\",\n", + " columns=[\"particle_id\", \"nhits_velo\"],\n", + " )\n", + " # batch.edge_index, unique_indices = torch.unique(\n", + " # batch.edge_index, dim=1, return_inverse=True\n", + " # )\n", + " # unique_indices = torch.unique(unique_indices)\n", + " # batch.y_pid = batch.y_pid[unique_indices]\n", + " # batch.y = batch.y[unique_indices]\n", + " # batch.scores = batch.scores[unique_indices]\n", + "\n", + " nhits_velo = (\n", + " pd.DataFrame({\"particle_id\": batch.particle_id.numpy()})\n", + " .merge(\n", + " df_particles[[\"particle_id\", \"nhits_velo\"]],\n", + " how=\"left\",\n", + " on=[\"particle_id\"],\n", + " )[\"nhits_velo\"]\n", + " .to_numpy()\n", + " )\n", + "\n", + " dict_list_values[\"y_pid\"].append(batch.y_pid.numpy())\n", + " dict_list_values[\"scores\"].append(batch.scores.numpy())\n", + " dict_list_values[\"n_hits\"].append(nhits_velo[batch.edge_index.numpy()])" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "82136" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.edge_index.shape[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "41102" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.unique(batch.edge_index, dim=1).shape[1]" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [], + "source": [ + "particle_id = 5409\n", + "min_plane = batch.plane[batch.particle_id == particle_id].min()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.5567, 0.6978, 0.5567, 0.6978])" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.scores[(batch.plane[batch.edge_index[0]] == min_plane)\n", + "& (batch.particle_id[batch.edge_index[0]] == particle_id)\n", + "& (batch.y_pid)]" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "first_scores = []\n", + "other_scores = []\n", + "\n", + "for particle_id in torch.unique(batch.particle_id):\n", + " min_plane = batch.plane[batch.particle_id == particle_id].min()\n", + "\n", + " scores = batch.scores[\n", + " (batch.plane[batch.edge_index[0]] == min_plane)\n", + " & (batch.particle_id[batch.edge_index[0]] == particle_id)\n", + " & (batch.y_pid)\n", + " ]\n", + " first_scores += scores.numpy().tolist()\n", + " \n", + " scores = batch.scores[\n", + " (batch.plane[batch.edge_index[0]] != min_plane)\n", + " & (batch.particle_id[batch.edge_index[0]] == particle_id)\n", + " & (batch.y_pid)\n", + " ]\n", + " other_scores += scores.numpy().tolist()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7ff1f015fcd0>" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist(first_scores, label=\"First edges\", alpha=0.5, density=True)\n", + "ax.hist(other_scores, label=\"Other edges\", alpha=0.5, density=True)\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 196, + "metadata": {}, + "outputs": [], + "source": [ + "dict_arrays = {\n", + " name: np.concatenate(list_arrays, axis=-1)\n", + " for name, list_arrays in dict_list_values.items()\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "dict_arrays_true = {\n", + " name: array[..., dict_arrays[\"y_pid\"]] \n", + " for name, array in dict_arrays.items()\n", + " if name != \"y_pid\"\n", + "}\n", + "\n", + "dict_arrays_fake = {\n", + " name: array[..., ~dict_arrays[\"y_pid\"]] \n", + " for name, array in dict_arrays.items()\n", + " if name != \"y_pid\"\n", + "}\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(2, 601088)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "dict_arrays_true[\"n_hits\"].shape" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAtwAAAIjCAYAAAAwbcylAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABvN0lEQVR4nO3deVhV5f7//xcgMgrOaE5oevSoR5xOaGICSVaaaWnHNAdSrLRCS8ssE8ujDeZcWlhqDp3SBnNo0iLFgU6amn6cE5VKj5oIKqDI+v3hj/XdyN6bQRYgPB/Xta+W+77X+743S+jFcq17uRiGYQgAAACAJVxLegIAAABAWUbgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGgJtUXFycXFxcCv0KDQ0t9NiVK1e2W7MopKen6/7775e/v78mTZpUJDUBoCRVKOkJAABKhpubW6H37d+/vy5duiRJWrx4cVFNSZK0dOlSffnll5KkmJgYDRgwQI0bN7bbd+fOnfriiy8kSa1bt1avXr2KdC4AUBQI3ABwk/Pz81Pt2rXz1ffy5cs6evSoJKl79+6FHvOdd94xt4s6cF+9etXpn23t3LnTPAs+ePBgAjeAUonADQA3ud69e2vRokX56hsbG6vhw4fL09NTQ4YMsXRehTVw4ECtWrVK8fHxGjlypJo2bVrSUwKAG0LgBoByZP78+ZKkf/3rX6patWoJz8Y+b29vrVu3rqSnAQBFhpsmAeAmVbFiRQUEBMjf3z9f/RMSErRjxw5J0hNPPGHl1AAANjjDDQA3qdtvv10nT57Md/958+ZJktq0aaPg4GCrpgUAuA5nuAGgHDh37pw++eQTSdaf3c7KytLixYsVGhqqmjVrytPTU4GBgRo6dKgOHTrkcL+YmBi7Sw3auz49uy0yMtJ8b/HixXb3j4uLy7V/enq63n33Xd1zzz2qU6eOPD095eXlpQYNGqhHjx6aNm2aDhw4UBRfDgCQi2EYRklPAgBgrRkzZuiZZ56Rn5+f/vjjD/n4+BRZbdv1ty9cuKC+fftq48aNuuOOO+Tv7699+/Zp165dkiQfHx99/fXXCgkJyVXniy++MJf4i4+P15EjRyRJCxcuzHWDZ/afDx8+rM2bN0uSbr31Vrt1x40bp2bNmpl/3rdvn+677z6zfqtWrdSwYUO5urrq8OHD+vXXX82+wcHB2rZtWwG/IgCQE5eUAEAZZxiGebPkoEGDijRsXy86OlpZWVk6fvx4jpsyFy1apMjISF28eFGDBg3SgQMH5O7unmPfXr16mcv6DRkyxAzE9mSf9V60aJEZuENCQvJcreXixYu65557dOzYMQUEBGjdunVq27Ztjj5btmxRZGSkDh48qISEhHx+cgBwjEtKAKCM+/7773Xw4EFJ0uOPP27pWOvWrdPKlStzrYAyZMgQ3XHHHZKko0eP6ttvv7V0Ho58/PHHOnbsmCRp4sSJucK2dO3a+C+//FKurvwvEkDR4KcJAJRx2TdL3nHHHWrRooWlYz3++OPy9fW12xYREWFux8fHWzoPR3755Rdz+5ZbbnHYr2nTppZ/rQCUHwRuACjD/vzzT61atUpS8SwFaBuqr3frrbea24cPH7Z8LvZ4enqa29k3kTry7bffmk/lBIAbQeAGgDIsNjZWmZmZqlmzph544AHLx/vb3/7msK1y5crm9vnz5y2fiz233367ub18+XI98MAD5trk16tVq5YCAwOLaWYAyjICNwCUUVevXlVsbKwkaejQoapYsaLlYzp7CI/t2eXLly9bPhd7evfurbvuusv88+eff6527dqpefPmevHFF5WQkCAW7wJQ1AjcAFBGrV69WklJSXJ1ddXw4cOLZcwKFRwvfmW7fGBJWrVqlZ577jl5e3ub7+3bt09TpkxRhw4dVK9ePb3wwgv6888/S3CWAMoSAjcAlFHZSwHec889XBphw9PTU6+//rpOnDih+fPnKzw8XG5ubmb777//rtdee01NmzbVRx99VIIzBVBWELgBoAw6cuSIufRecdwseTOqWrWqHnvsMW3YsEF//vmn5s2bpw4dOpjtqampeuSRR8x1vgGgsAjcAFAGvfvuuzIMQw0aNNA999xT0tMp9WrUqKHHH39cW7du1YYNG1SjRg1J1x5TP3369BKeHYCbHYEbAMqYjIwMLVy4UJL02GOPlekHuBT0uvAffvhB8+fPV0pKisM+4eHhOUL23r17Cz0/AJAI3ABQ5qxYsUJnzpxRxYoVNXTo0JKejqVsVz65evVqjrY///xTQ4YM0ZAhQ5ScnCxJWrx4sZ544ok8Q3S7du3MbR8fn6KbMIByicANAGVM9pMlH3jgAdWsWbOEZ2Mt26dFnj17NkfbgQMHtHjxYi1ZskQeHh452lasWOG07q+//mpud+7cuQhmCqA8I3ADQBmye/dubdmyRVL5uFmybdu25vJ+//3vf5WamipJMgxD77//viSpffv28vLyyrHfrFmzNHPmTF25ciVXzY0bN+qZZ56RdO1hPWPGjLHyIwAoBxwvmAoAuOlkn91u3ry57rjjDsvGee2117R///5c7w8ZMkSS1KtXL/Xq1UuSNGbMGJ05c0YnT540++3fv9/sO2zYMIWEhOiLL77QF198IUmKj483+y5YsEBxcXGSpHHjxqlZs2Zmm4+Pj5599lm9+uqrOnPmjFq0aKEOHTro0KFD2rlzp9zc3PTvf//b7N+2bVutXLlSFy9e1OjRozV58mT985//VLVq1ZScnKxDhw7p4MGDkqTAwECtXLlSdevWvdEvF4ByzsXgkVoAUCZcuHBBt9xyi1JTUzVnzhw9+eSTlo0VGhqqH3/80WH7xIkTFRMTI+lacD127JjDvgsXLtSQIUMUExOjSZMmOR33hx9+UGhoaK73FyxYoA8++EB79+7VxYsXVbVqVXXs2FHPP/98jse5S9eW+1u7dq3Wr1+vnTt36ujRo0pJSVGFChVUo0YNBQUFqVevXhowYECOa8QBoLAI3AAAAICFuIYbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEA++KaWysrL0xx9/qFKlSnJxcSnp6QAAAOA6hmEoNTVVt9xyi1xdHZ/HJnCXUn/88Yfq1atX0tMAAABAHk6cOOH0qbQE7lKqUqVKkq4dQD8/vxKeDQAAAK6XkpKievXqmbnNEQJ3KZV9GYmfnx+BGwAAoBTL6/JfbpoEAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACx0w4HbMAzNnTtXvr6+cnFxUVxcXJ77uLi4FPj1xRdf5KoTExOT7/1//vnnPOd17NgxjR49Wk2bNpW3t7dq1qypsLAwLVq0SFlZWfn+mqxbt049e/ZUnTp15OnpqYYNGyoyMlI7duzIdw0AAACUDTcUuI8cOaLQ0FA99dRTunjxYlHNya6AgABL669du1atWrXSrFmzFBQUpOnTpys6OlpHjx5VZGSk7rrrLqWmpjqtkZWVpeHDh6t79+7avHmzBg0apNmzZysiIkLLly9XcHCwZs+ebennAAAAQOlSqEe7G4aht99+W+PGjZObm5s6dOigbdu2FahGr169NHXqVKd9duzYoQEDBqhp06bq2LGjw3779u3Lc7zAwECn4/Tt21dpaWmaOXOmoqOjzbYRI0aoc+fO2rBhg/r376/Vq1c7rDN+/HjFxsaqevXq2rp1qxo3bixJGj58uB544AF1795do0aNUu3atdW3b98851wUDMNQZmamrl69WizjAdlcXV3l7u6e5+NuAQAo6woVuCdNmqRJkyapW7duio2N1fvvv1/gwO3v769mzZo57TN9+nRJ1wKrM3nVycuIESOUlpam4ODgHGFbkqpUqaK5c+cqLCxMa9as0aeffqoHH3wwV429e/fqzTfflCS9+uqrZtjOdvfdd2vgwIFavHixnnrqKd17773y8fG5oXk7YxiGzp07p+TkZGVkZFg2DuCMm5ubKlWqJH9/f3l7e5f0dAAAKBGFPsO9YMECDR06tFCDdunSJc+QfOHCBX300Ufy8PDQ4MGDCzVOfqxfv14JCQmSpKioKLt9QkND1aRJEx06dEiTJ0+2G7inTp2qrKwseXl5acCAAXbrREVFafHixTp16pQWLFiQK9wXpVOnTuncuXOqVKmSatSooQoVKnCmEcXGMAxlZWXp4sWLSklJUXJysurWratKlSqV9NQAACh2hQrc2TcrFlZ+bqxcvny5Lly4oP79+6tatWqFHisvK1asMLe7du3qsF/Xrl116NAh7dy5U4cPH85xBjsjI8O81CQ4ONhhqOjYsaN8fX114cIFrVixwrLAff78eZ07d061a9dW5cqVLRkDyA8fHx/VqFFDf/zxh5KSktSgQQPOdAMAyp1C3TRZHGdK33vvPUnSY489VqD9Ll68qCtXruS7//fffy9Jqly5sho0aOCwX5s2bXLtk+3nn39WSkqKJKl169YOa7i6uqpVq1aSpK1btyotLS3f8yyIlJQUeXt7E7ZRKri4uOiWW26Ru7u7zp8/X9LTAQCg2JXKdbh/+eUXbd++Xc2aNdMdd9yRZ//Fixerc+fOqlatmnx9fVWxYkXVrVtXgwYNcroUX1pamn777TdJUr169ZyOYdu+d+/eHG179uyx289ZnaysLO3fv99p38LI/md8X1/fIq8NFJaLi4v8/PyUmpoqwzBKejoAABSrUhm43333XUl53yyZbciQIapevbreeustrV27VrGxsWratKmWLFmi9u3ba+LEiXb3O378uLm+dl7LDtq2JyYm5miz/fON1CkKmZmZMgxDnp6eRV4buBHe3t66evVqgf4FCgCAsqBQ13Bb6eLFi1q+fLk8PDw0aNCgPPu7ublp2bJl+te//pXj/WHDhunll1/Wq6++qldeeUWVKlXSmDFjcvSxXVc7r4Dq5eVld7+irFMUsn+BcHUtlb9LoRxzc3OTpAI9RAoAgLKg1KWyjz76SKmpqerTp0+eN0uOGjVKJ06cyBW2s8XExCgoKEiS9PLLL+vkyZM52m2voa5YsaLTsWzbL126ZEkde1JSUnK88rvEHyuSoLTh7yQAoLwqdWe4s2+WzM/lJJUrV3Z6Y6Crq6uGDBmi0aNHKy0tTR999JFGjx5tttuebb58+bLTsWzbr19loajq2HP9NeETJ05UTExMnvsBAIDSLyYupnjHCy3e8XBNqQrcO3fu1H//+9983yyZH+3btze3t2zZkiNw2y7fl56e7rSO7Vns65f9K6o69pw4cUJ+fn7mnz08PPLcBwAAAKVHqQrc2TdLFnQpQGdq1qxpbl9/SUn9+vXl6uqqrKwsnTp1ymkd2/brHxNv++cbqWOPn59fjsANAACAm0upuYY7+2ZJT0/PfN0smV+2N2hl37SVzcvLS40aNZJ07UyyM0lJSeZ2ixYtcrS1bNnS3M5vHVdX1xt+JD1KVvYDoG7kdSMWLFiQqx6XGwEAUPqUmjPc//nPf5SSkqJHHnlEVatWzbP/7t279eWXX+qRRx5xeqbY9qx27dq1c7WHh4fr8OHDSk5O1rFjxxw+/MZ2Pe/w8PAcbe3bt1elSpWUmpqqnTt3OpxLVlaWdu3aJenaUydtr/3GzeeBBx4wnzg6evRonTlzRtWrV9eMGTPy3Pe9997Tpk2bbmj8sLAwLVmyRJI0cODAG6oFAACsU2oCd0FulpSuBeAJEyaocePGTgP3tm3bzO2QkJBc7X379jXH3rBhgx599FG7dTZs2CDp2pMkbR/rLl27rrpnz55atmyZEhISdOHCBbsPntm2bZsuXLhgjlsqlPUzohZ+vlatWplPDn3ppZd05swZ+fj46JFHHslz3/Xr199w4L711lt16623SiJwAwBQmpWKS0p2796tn376SX//+9/VuXPnAu371VdfOWy7fPmy3n//fUnXblDs169frj5du3ZVcHCwpGv/RG/Pxo0bdfDgQUnSiy++aLfPuHHj5OrqqrS0NC1fvtxun+z6AQEBGjZsmMN5AwAAoOwoFYG7oE+WtLVs2TJ99tlnud6/evWqRo4cqcOHD0uSpk2b5nBd73feeUdeXl7aunWr5s6dm6MtOTlZI0eOlCT16NFDffr0sVujZcuWGjt2rKRrZzuzHxmf7dtvv9XixYslSXPmzJGPj08BPiXKmu7du+v5558v6WkAAIBiUOhLSpYuXWpu796929z+7rvvzBsDAwICFBER4bTOpUuXtGzZsgLfLFm/fn1VqVJF586dU58+fXTPPfeoa9euqlKlipKSkvSf//xHe/fulbu7u9566y2nYb5t27b65JNPNGDAAD399NPatGmTwsPDdfbsWcXGxioxMVHh4eEOz1xnmzJlis6ePasFCxbotttu02OPPabAwEBt375dCxculKurq6ZPn156LidBienbty9/DwAAKCcKHbgdXTM6ZcoUc7tLly55Bu6PP/5Y58+fz/fNktnCw8P1+++/a/Xq1Vq3bp127NihmJgYXbp0SZUqVdKtt96q559/Xk888YTDGyFt9ejRQ7t27dLMmTO1du1affnll/Lx8VHLli318ssva/DgwXk+Lt3V1VWxsbHq3bu35s2bpw8++EDnzp1TrVq11K9fP0VHR6tt27b5/owoW+Li4hQWFqaFCxdqyJAh5vt79+7VJ598oh9++EH79u1TcnKyfHx81KRJE91777166qmnVL169UKNGRMTo0mTJtltMwwj13uJiYmaMWOGvv32Wx0/flzStZuNQ0JC9MQTT5iXXwEAgPwrdOC29z/rwoiMjFRkZGSh9vXy8tJDDz2khx56qEjmEhgYqJkzZ2rmzJk3VOfee+/VvffeWyRzQtm2ceNGdenSRZLUrFkzPf3006pVq5aOHz+uzz77TK+88oreffddrVu3rlC/rGWvpPL6669r7969evHFF9W0aVO7fT/88EMNHz5cV65cUd++fRUdHS0XFxdt3bpVy5cv1+LFizV69Gi99dZbPKYdAIACKDWrlABlQVZWls6cOWO37fz587neu3z5siTprrvu0rp163KsFT9x4kRFRkZq6dKl6tWrlw4ePChPT88CzadVq1Z6//33tXfvXs2bN8/hQ6VWrVqlwYMHy8XFRZ9++ql69+5ttj322GN69NFH1bVrV82YMUM1a9bUuHHjCjQPAADKs1Jx0yRQVpw4cUI1atSw++rVq5fD/aZMmZLrwUwVKlTQ22+/LQ8PD504cUIff/xxgeZiGIZGjhypOXPm6L333nMYti9duqSoqChJ0kMPPZQjbGe74447zCUzX331Vf31118FmgsAAOUZgRsoQgEBAfruu+/svqZNm5arf0hIiI4ePap27drZrefn52deAvLjjz/mex6GYeixxx7T/PnztXDhQqfLUC5fvlynT5+WJPXv399hv+zLpC5duqTPP/8833MBAKC845ISoAh5enqqa9eudtsqVMj97ebp6ZnjwU1Xr17VhQsXdOXKFfO97Ico/fHHH/maQ1ZWloYOHapFixZp0qRJGjx4sNP+3333nbkdGBjo8JIY26UsExISNHTo0HzNBwCA8o7ADZSwP//8UzNmzNCaNWt08OBBXb161W6/9PT0PGtdvXpVgwYN0rJlyyRdW6d+7Nix8vLycrhP9lr1khQUFJSvOZ88eTJf/QAAAIEbKDahoaG5VvfZvHmzunfvrvPnz6t27dqaOHGimjVrpipVqph9nn322Rxr3Tsza9Yspaena8CAAVq2bJkOHjyocePGadasWQ73SUlJMbe/+OKLfD2UqSBLeAIAUN4RuIEScvnyZfXr188M23v27LEbZG3Dd17S09O1YsUK9ezZU6dPn9a3336rOXPmqHfv3goNDbW7T6VKlczt2267TbVr1y7wZwEAAI5x0yRQQuLj482nsg4ZMqRIzhqPGjVK999/v1xcXPTBBx+ocuXKMgxDkZGRunDhgt19mjRpYm4fO3bshucAAAByInADJcT2Oui6des67Jeamprvmt7e3uZ2nTp1NGfOHEnXniD5zDPP2N3H9mmwW7ZscVp/2LBhqlChgj744IN8zwkAgPKOwA2UENtLN/bv32+3z8WLFx225ccjjzyiBx98UJIUGxurr7/+Olef/v37q0aNGpKkhQsXKisry26ts2fP6pNPPpGnp6fTNcUBAEBOBG6ghHTq1El16tSRJPNpkLaysrL0zDPP6NKlSzc0zvz58xUQECDp2hnq5OTkHO3e3t5asGCBXFxctGfPHj3//PO5bu68dOmSHn74YaWmpuqll17ipkkAAAqAmyaBQtq9e7e5esjFixfN/y5dutTs07t3b4erflSsWFFLlixRjx49dOnSJbVv316RkZFq1aqV/vrrL33xxRc6ePCgatWqpZMnT+rUqVNm7UceeUSnTp3KsYZ29pyWLl2qgIAARUREmH26deumDz/8UL///ruGDBmiPn36yNfX1zxT3bNnTy1dulTDhg3TtGnT9OOPP6pPnz6qWrWqjhw5oiVLluj333/XiBEj9NxzzxX1lxIAgDLNxbj+VBZKhZSUFPn7++v8+fPy8/PL937p6ek6evSoGjZsKE9Pz7x3iIkp/CRvBhZ+vpiYGE2aNMlpn6NHj+Z4sI09hw4d0htvvKHvvvtOf/zxh9zd3RUYGKhu3bpp9OjRGjhwYK6nTBqGobi4OIWFhdmt2aVLF8XFxTnt06BBAyUmJuZ4LykpSbNmzdLXX3+txMREXb58WQEBAerYsaMef/xxh7Xyo8B/NwGgHIiJiyne8UKLd7yyLr95jcBdShVb4AaKCX83ASA3AvfNLb95jWu4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuIFCCA0NlYuLyw2/4uLiSvqjAAAAi1Uo6QkAN6vq1atrxowZud4/c+aMRo8eLUnq3Lmzhg8fnqvPpk2b9N5771k+RwAAUPII3OVcTFxMSU/BUjGhMZbV9vHx0SOPPJLr/cTERDNwN2rUyG6fzMxMAjcAAOUEl5QAAAAAFuIMN1AIt912mxo0aFDo/evUqaNu3bqpatWqRTgrAABQGhG4gUJ44403bmj/iIgIRUREFNFsAABAacYlJUAJeumll3KtXLJo0SJduXJF06ZNU7t27eTv72+2hYaGKiYmJs/VTubOnVvgFVF+/fVXRUVF6dZbb5WXl5f8/PzUvHlzjRgxQvv27bPuiwAAQBnHGW6gBPXt21fNmjXLsbJJenq6wsLC5OLiooEDB6pixYpaunSptm7dKkl64IEH1LhxY+3bt09TpkyxW/euu+7SkiVLnPaxNXXqVL300kuqUKGCBg0apNtuu02XL1/W999/r/nz5+vdd9/VG2+8oWeffbboPjwAAOXEDZ/hNgxDc+fOla+vb77XFU5MTMz3OsVPPvlknvUyMzM1b948derUSdWqVZOvr6+aN2+uF154QSdPnsz3Zzl27JhGjx6tpk2bytvbWzVr1lRYWJgWLVqkrKysfNdZt26devbsqTp16sjT01MNGzZUZGSkduzYke8aKB+CgoL0yCOPqFevXuZ7//73v9WmTRtt2rRJo0aN0ogRI/Ttt9+qcuXKkqRWrVrpkUcecXpJyt/+9rc8+2SbNWuWxo8fr4oVK+rHH39UbGysoqKiNHLkSH366adatmyZsrKyNGbMGP3nP/+50Y8MAEC5c0OB+8iRIwoNDdVTTz2lixcvFtWcCuTMmTMKCQnRiBEj9Ndff+n555/XG2+8oYYNG+q1115Tq1attHHjxjzrrF27Vq1atdKsWbMUFBSk6dOnKzo6WkePHlVkZKTuuusupaamOq2RlZWl4cOHq3v37tq8ebMGDRqk2bNnKyIiQsuXL1dwcLBmz55dVB8dZdSVK1f05ptv5njP19dXo0eP1t13312kYyUlJem5556TJEVHR6tDhw65+jz88MPq1q2bJGns2LHKzMws0jkAAFDWFeqSEsMw9Pbbb2vcuHFyc3NThw4dtG3btgLXmTJlinr37u20T5UqVRy2ZWZmqnfv3kpISNDtt9+u9evXy8vLS5I0YsQIjR8/XlOnTtX999+vn376SU2aNLFbZ8eOHerbt6/S0tI0c+ZMRUdHm20jRoxQ586dtWHDBvXv31+rV692OJ/x48crNjZW1atX19atW9W4cWNJ0vDhw/XAAw+oe/fuGjVqlGrXrq2+ffs6/dwov+677z55enrmev/ll18u8rHmz5+vy5cvS5L69+/vsN+9996rb775RklJSfrxxx915513FvlcAAAoqwp1hnvSpEl66qmnFBISoj179phnvwqqdu3aatasmdNXQECAw/1jY2MVHx8vFxcXxcbGmmHbdp6NGzdWcnKynnnmGYd1RowYobS0NAUHB+cI29K1wD937lxJ0po1a/Tpp5/arbF3717zrOSrr75qhu1sd999twYOHCjDMEr0XwRQ+rVo0aLYxvruu+8kSe7u7qpVq5bOnDlj9+Xn52fuk5CQUGzzAwCgLChU4DYMQwsWLNDXX3+tevXqFfWc8j2HqVOnSpI6deqk5s2b5+rj7u6uIUOGSLoWlnft2pWrz/r1680AERUVZXes0NBQ8+z45MmT7faZOnWqsrKy5OXlpQEDBtjtk13/1KlTWrBggZNPh/LMNtxa7fDhw5KuXcYSEBCgGjVq2H1FRkaa+xTkvggAAFDIS0qylyUrSdu2bdOJEyckSV27dnXYLyIiQi+99JIkacWKFQoKCsrRvmLFCnPbWZ2uXbvq0KFD2rlzpw4fPpzjDHZGRoZ5qUlwcLAqVapkt0bHjh3l6+urCxcuaMWKFbnOpgOS5OpafKt1pqSkSLp2jfjnn3+er33q1Klj5ZQAAChzChW4rQjbmZmZysjIkI+PT776f//99+Z269atHfYLCgqSq6ursrKycuxzfZ3KlSs7fXJgmzZtcuxjG7h//vlnM7g4m4urq6tatWqlLVu2aOvWrUpLS8t1GQxQlK5eveq0vVKlSjp37pwuX77s9BdOAABQeCX64Ju9e/eqf//+ql+/vjw9PeXr6ysfHx/deeedWrhwodPVEPbs2WNuO7usxcPDQzVq1DDHs5WWlqbffvstzxrXt19fJ79zsW3PysrS/v37nfYFnKlQ4f/9vnzlyhW7fbJ/EXQk+1Kpy5cvc6kIAAAWKdHAPW3aNG3fvl1PPvmkPv/8c61YsUJDhw7Vli1b9Oijj6pz5876888/7e6bmJhobju7sdK2PSUlRefOnTPfP378uLm+dn5rXD92Yedirw5QEP7+/uZ2cnKy3T4HDhxwWsN2ne4tW7bk2bdChQrasGFD/icJAABKNnA/+OCD2r17t5577jndd9996tOnj2bPnq0tW7bIz89P27Zt03333aeMjIxc+9quiW1vCTVbtpdt2O5XFDWKsg5QEI0bN5abm5skOXz0+pdffum0xuOPP66KFStKktMbeQ8cOKANGzbolltuUZcuXQo5YwAAyqcSCdx169bV0aNH9dFHH8nDwyNXe5s2bcw1h7dv36758+fn6pOWlmZuZwcGR2zbL126VKQ1irKOPSkpKTle9n75QPnk5eVlrof90Ucf5fq7sXTpUh0/ftxpjbp16+qtt96SJH311VeaM2dOrj5nz55V3759ZRiGXn/99RyXsgAAgLyVyP85K1SooMDAQKd9IiMjNXbsWBmGoQ8++CDXih62Z4qzH9zhiG27t7d3kdYoyjr2XH9N+MSJExUTE5Pnfih+3333nU6dOqUzZ86Y7/32229aunSpJKl37965bgr+7bfftGXLlhz7bN261Qy1ERERTi9Tmjp1qjZt2qT9+/erU6dOGjhwoHx8fLRp0yYlJCRo+vTp+te//mXOLykpSY0bN87xRMknn3xS6enpGjdunJ5++mmtWrVKPXr0kJeXlw4cOKBFixbp/PnzmjJlih5++OEb/0IBAFDOlNpTVVWrVlWjRo105MgR/frrr7pw4YJ8fX3Ndtul99LT053Wsj0DbbtfUdQoyjr2nDhxIse6zPb+RQClw7///W/9+OOPOd7btGmTNm3aJEk6evRorsC9cePGHGtcS9J7772n9957T5L0ww8/OA3cbdu21ZYtWzRp0iRt2rRJzz33nOrWrasHHnhA27Zt086dO82+U6ZMkSQNHTo01yPcx4wZox49emj27NnasGGDXnzxRV29elV16tTR/fffr6eeekpt27Yt2BcEAABIKsWBW5Jq1qypI0eOyDAMnTp1KkfgDgwMNB8nf+rUKadrA586dUrStQeK2D4qvn79+uaSgdl98qqRPbYt2z/fSB17/Pz8LH0QSkxojGW1y5u4uLgC7zNkyBDz4UyF1bp1a4draIeGhsowjHzVadasmd55550bmgsAAMitRG+azEv2CiKSzJvDsrVs2dLczn4Ajj0ZGRk6ffq0pNyPzPby8lKjRo3yrCFJSUlJ5vb1dfI7F9s6rq6uatasmdO+AAAAuPmVSOCePHmyVq1alWe/7HWBXV1dVbNmzRxt4eHh5rbtP5tfb9euXWZwt93n+jrJyck6duyYwzo7duywO7YktW/f3rw8xNlcsrKyzMfLd+zYkYfeAAAAlAMlErgnTJigefPmOe3z559/mgG4bdu2uW4w7NChg+rWrStJTtcFXr9+vbndt2/fXO227zmrk93WunXrHE+ZlK5dV92zZ09JUkJCgi5cuGC3xrZt28w2e3MBAABA2VNil5Rs2bLF6VPwbJcCHD58eK52FxcXjR8/XpIUHx9v96mNmZmZWrRokSSpe/fuCgoKytWna9euCg4OluR4HeKNGzfq4MGDkqQXX3zRbp9x48bJ1dVVaWlpWr58ud0+2fUDAgI0bNgwu30AAABQtpRY4E5NTdXw4cPtLqP37bff6vXXX5ck3XHHHblWccgWFRWlkJAQGYahqKioHCuASFJMTIwOHTqkypUra8aMGQ7n8s4778jLy0tbt27V3Llzc7QlJydr5MiRkqQePXqoT58+dmu0bNlSY8eOlSS99NJL5iPjbT/T4sWLJUlz5szJtVoFAAAAyqZCr1KSvbawJO3evdvczl7rV7p2Jtf20dHZgoKCtGvXLn388cfavn27+vXrp0aNGunixYuKi4vTZ599JsMwdM8992jZsmUOH7RRoUIFff755+rRo4fi4+PVrl07RUZGysfHR+vWrdPatWtVvXp1rVy5Uk2aNHH4Wdq2batPPvlEAwYM0NNPP61NmzYpPDxcZ8+eVWxsrBITExUeHu7wzHW2KVOm6OzZs1qwYIFuu+02PfbYYwoMDNT27du1cOFCubq6avr06VxOAgAAUI64GPldM+z6HV1c8uzTpUsXh0ulJSQk6IsvvtDmzZt14MABnTt3Tu7u7qpVq5Y6duyogQMHqlu3bvmaS2ZmpmJjY7VkyRLt379fGRkZql+/vnr27KlRo0apdu3a+aqTmJiomTNnau3atUpKSpKPj49atmypwYMHa/DgwXJ1zd8/CKxbt07z5s3Tzz//rHPnzqlWrVrq0qWLoqOj872WcUpKivz9/XX+/PkCLQuYnp6uo0ePqmHDhnk+Zh4oTvzdBIDcYuJiinc8lgMuUvnNa4UO3LAWgRtlDX83ASA3AvfNLb95rVSvww0AAADc7AjcAAAAgIUI3AAAAICFCNxlFJfmo7Th7yQAoLwicJcx2SupXL16tYRnAuSUmZkpSXJzcyvhmQAAULwI3GWMu7u73N3dHT5eHigp58+fl4eHh8N19QEAKKsI3GWMi4uLKlWqpPPnz+d68iZQUs6dO6fU1FRVrlw5X2v4AwBQlnCqqQyqXr260tLSdPz4cfn5+alSpUpyc3Mj6KDYGIahrKwspaen68KFC7p06ZKqVKmiKlWqlPTUAAAodgTuMsjNzU316tXTmTNnlJqaquTk5JKeEsopV1dXeXt765ZbbpG/v39JTwcAgBJB4C6j3NzcFBAQoJo1a+rKlSvKysoq6SmhnHF1dVWFChXMG3kBACivCNxlnIuLiypWrFjS0wAAACi3OPUEAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABYiMANAAAAWIjADQAAAFiIwA0AAABY6IYDt2EYmjt3rnx9feXi4qK4uLh87bdjxw6NGzdOISEhql69utzd3VWlShW1a9dOY8aM0aFDh/KsERMTIxcXl3y9fv755zzrHTt2TKNHj1bTpk3l7e2tmjVrKiwsTIsWLVJWVla+PpckrVu3Tj179lSdOnXk6emphg0bKjIyUjt27Mh3DQAAAJQNNxS4jxw5otDQUD311FO6ePFivvZJTExU586d1a5dO73++uuSpCeffFLz58/XmDFjlJGRobfeekstWrTQtGnTbmR6BbJ27Vq1atVKs2bNUlBQkKZPn67o6GgdPXpUkZGRuuuuu5Samuq0RlZWloYPH67u3btr8+bNGjRokGbPnq2IiAgtX75cwcHBmj17djF9IgAAAJQGFQqzk2EYevvttzVu3Di5ubmpQ4cO2rZtW7723b9/v+Lj4yVJM2fOVHR0dI72cePGadCgQVq+fLnGjh2rSpUq6bHHHnNac9++fXmOGxgY6LBtx44d6tu3r9LS0nLNacSIEercubM2bNig/v37a/Xq1Q7rjB8/XrGxsapevbq2bt2qxo0bS5KGDx+uBx54QN27d9eoUaNUu3Zt9e3bN885AwAA4OZXqDPckyZN0lNPPaWQkBDt2bNH3bp1K3CNiIiIXGFbktzc3PTee++pWrVqkq4F8PT0dKe1mjVrlufL09PT4f4jRoxQWlqagoODc82pSpUqmjt3riRpzZo1+vTTT+3W2Lt3r958801J0quvvmqG7Wx33323Bg4cKMMwCvQvAgAAALi5FSpwG4ahBQsW6Ouvv1a9evUKNfD999/vsM3Hx8cM8cnJydq0aVOhxsiP9evXKyEhQZIUFRVlt09oaKiaNGkiSZo8ebLdPlOnTlVWVpa8vLw0YMAAu32y6586dUoLFiy40akDAADgJlCowB0TE6OhQ4cWasD27dvrq6++Ur9+/Zz2a9Cggbl9/PjxQo2VHytWrDC3u3bt6rBfdtvOnTt1+PDhHG0ZGRnmpSbBwcGqVKmS3RodO3aUr69vrnEBAABQdhUqcLu4uBR6wOrVq+vuu+82LxlxJDk52dz28fHJd/2LFy/qypUr+e7//fffS5IqV66cI+Rfr02bNrn2yfbzzz8rJSVFktS6dWuHNVxdXdWqVStJ0tatW5WWlpbveQIAAODmVGrX4T569Kika+G+U6dOTvsuXrxYnTt3VrVq1eTr66uKFSuqbt26GjRokNOl+NLS0vTbb79JUp6Xxti27927N0fbnj177PZzVicrK0v79+932hcAAAA3v1IZuM+fP2+u533fffflGWKHDBmi6tWr66233tLatWsVGxurpk2basmSJWrfvr0mTpxod7/jx4+b62sHBAQ4HcO2PTExMUeb7Z9vpA4AAADKnkItC2i1xYsXKz09XRUrVtRrr73mtK+bm5uWLVumf/3rXzneHzZsmF5++WW9+uqreuWVV1SpUiWNGTMmRx/bdbWdrWIiSV5eXnb3K8o6AAAAKHtK3Rnu//3vf3r11VclSf/+97/197//3WHfUaNG6cSJE7nCdraYmBgFBQVJkl5++WWdPHkyR7vtNdQVK1Z0Oi/b9kuXLllSx56UlJQcr4yMjDz3AQAAQOlRqgL31atXNWjQIJ05c0b9+vXTs88+67R/5cqVVbt2bYftrq6uGjJkiKRrofijjz7K0W57tvny5ctOx7Jt9/b2tqSOPfXq1ZO/v7/5mjp1ap77AAAAoPQoVZeUPP300/rmm2905513atGiRTe0Gkq29u3bm9tbtmzR6NGjzT/bLt+X18N1bM9iX7/sX1HVsefEiRPy8/Mz/+zh4ZHnPgAAACg9Sk3gfuGFF/TOO+8oLCxMq1atKrJgWbNmTXP7+ktK6tevL1dXV2VlZenUqVNO69i2X/+YeNs/30gde/z8/HIEbgAAANxcSsUlJRMmTNBrr72mLl26aM2aNQVadzsv2auQSNdusLTl5eWlRo0aSbp2JtmZpKQkc7tFixY52lq2bGlu57eOq6urmjVr5rQvAAAAbn4lHrhjYmI0efJkde7cWWvXrs3Xdc2StHv3bk2ePDnPpfVsz2rbu947PDxc0rUH7Rw7dsxhHdv1vLP3yda+fXvz8pCdO3c6rJGVlaVdu3ZJuvbUSdtrvwEAAFA2lWjg/ve//61JkyapU6dOWrdund0z2+3bt9ekSZNyvb9jxw5NmDBB27ZtczqGbXtISEiu9r59+5rbGzZscFgnu61169Zq3LhxjjYPDw/17NlTkpSQkKALFy44nEt2m+24AAAAKLtKLHC//vrreumll9SxY0d99dVX8vX1tdtv+/bt5lMn7fnqq68ctl2+fFnvv/++pGs3KPbr1y9Xn65duyo4OFiStGDBArt1Nm7cqIMHD0qSXnzxRbt9xo0bJ1dXV6WlpWn58uV2+2TXDwgI0LBhwxzOGwAAAGVHidw0+dZbb2ncuHGqUaOGxo0bp+3btxe61rJly3T//ffrgQceyPH+1atXNXLkSB0+fFiSNG3aNFWrVs1ujXfeeUchISHaunWr5s6dqyeffNJsS05O1siRIyVJPXr0UJ8+fezWaNmypcaOHWv+ItG1a1fz+nBJ+vbbb7V48WJJ0pw5c4r0OnUAAFA0YuJiSnoKKIMKHbiXLl1qbu/evdvc/u6778wbAwMCAhQREZFjvy+++MJ84uPp06d1//33F2r8+vXrq0qVKjp37pz69Omje+65R127dlWVKlWUlJSk//znP9q7d6/c3d311ltvafjw4Q5rtW3bVp988okGDBigp59+Wps2bVJ4eLjOnj2r2NhYJSYmKjw83OGZ62xTpkzR2bNntWDBAt1222167LHHFBgYqO3bt2vhwoVydXXV9OnTuZwEAACgHHExDMMo1I75WCO7S5cuiouLy/HezJkzc6yFnR+DBw/WokWLcr2flpam1atXa926ddqxY4eOHTumS5cuqVKlSrr11lt155136oknnlCDBg3yNU5iYqJmzpyptWvXKikpST4+PmrZsqUGDx6swYMHy9U1f1fgrFu3TvPmzdPPP/+sc+fOqVatWurSpYuio6PVtm3bfNVISUmRv7+/zp8/z7KAAAAUk7J+hjsmNKakp1Cm5DevFTpww1oEbgAAih+BGwWR37xW4ssCAgAAAGUZgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACw0A0HbsMwNHfuXPn6+srFxUVxcXEF2n/Lli3q37+/6tevL09PT9WrV08PPfRQgepkZmZq3rx56tSpk6pVqyZfX181b95cL7zwgk6ePJnvOseOHdPo0aPVtGlTeXt7q2bNmgoLC9OiRYuUlZWV7zrr1q1Tz549VadOHXl6eqphw4aKjIzUjh078l0DAAAAZcMNBe4jR44oNDRUTz31lC5evFjg/V955RV17txZq1atUu/evTVnzhz17dtXX331lcLCwvTcc8/lWePMmTMKCQnRiBEj9Ndff+n555/XG2+8oYYNG+q1115Tq1attHHjxjzrrF27Vq1atdKsWbMUFBSk6dOnKzo6WkePHlVkZKTuuusupaamOq2RlZWl4cOHq3v37tq8ebMGDRqk2bNnKyIiQsuXL1dwcLBmz56d768PAAAAbn4uhmEYBd3JMAy9/fbbGjdunNzc3NS8eXNt27ZNkvTDDz8oNDQ0zxrz58/XE088IU9PT8XFxSk4ONhs++WXX9S5c2ddvHhRb775psaMGWO3RmZmpsLCwhQfH6/bb79d69evl5eXl9k+fvx4TZ06VZUrV9ZPP/2kJk2a2K2zY8cOhYSEKC0tTTNnzlR0dLTZdu7cOXXu3Fl79+5Vjx49tHr1aoefady4cXr99ddVvXp1bd26VY0bNzbbvv76a3Xv3l2GYejjjz9W3759nX59UlJS5O/vr/Pnz8vPz89pXwAAUDRi4mJKegqWigmNKekplCn5zWuFOsM9adIkPfXUUwoJCdGePXvUrVu3Au1/+vRpjR07VpIUHR2dI2xLUps2bcyQPWHCBCUlJdmtExsbq/j4eLm4uCg2NjZH2M6eZ+PGjZWcnKxnnnnG4XxGjBihtLQ0BQcH5wjbklSlShXNnTtXkrRmzRp9+umndmvs3btXb775piTp1VdfzRG2Jenuu+/WwIEDZRhGof9FAAAAADefQgVuwzC0YMECff3116pXr16B9581a5YuXLggSRo2bJjdPsOGDZOLi4vS09P11ltv2Z3D1KlTJUmdOnVS8+bNc/Vxd3fXkCFDJF0Ly7t27crVZ/369UpISJAkRUVF2Z1LaGioeXZ88uTJdvtMnTpVWVlZ8vLy0oABA+z2ya5/6tQpLViwwG4fAAAAlC2FCtwxMTEaOnRooQdduXKlJCkwMDDXmeBsdevWVbNmzcz+11/5sm3bNp04cUKS1LVrV4djRUREmNsrVqzI1W77nrM62W07d+7U4cOHc7RlZGSYl5oEBwerUqVKdmt07NhRvr6+DucCAACAsqdQgdvFxaXQA/7+++86cOCAJKl169ZO+7Zp00aSlJSUpEOHDuVo+/77781tZ3WCgoLk6uqaa5/r61SuXFkNGjTIcy726vz8889KSUnJcy6urq5q1aqVJGnr1q1KS0tz2BcAAABlQ7Gvw71nzx5zO6/LUWzb9+7dW6g6Hh4eqlGjht0aaWlp+u2334ptLrbtWVlZ2r9/v9O+AAAAuPkVe+BOTEw0twMCApz2tW233a+wdVJSUnTu3Dnz/ePHj5vraxf3XOzVAQAAQNlT7IHbdi1rT09Pp31tVx25fg3soqhTmuYCAACAsqlCcQ9oe91yxYoVnfa1bb906VKR1ylNc3Ek+9rwbB4eHvLw8MhzPwAAAJQOxX6G2/YM7+XLl532tW339vYu8jqlaS6O1KtXT/7+/uYreylEAAAA3ByK/Qy37ZJ56enpTvvanjm+fqm9oqhTmubiyIkTJ3I8uYiz2wAAoLBK4kmaPN2yBM5wBwYGmtunTp1y2te23Xa/wtbx8/NTlSpVzPfr169vLhlY3HOxV8cePz+/HC8CNwAAwM2l2AN3y5Ytze3sB9c4YvtI9xYtWhSqTkZGhk6fPm23hpeXlxo1alRsc7Gt4+rqaj7YBwAAAGVXsQfuOnXq6G9/+5uka09tdGbHjh2Srj11MvvR6tnCw8PNbWd1du3aZS79Z7vP9XWSk5N17NixPOdir0779u3Ny0OczSUrK8t8vHzHjh1zXPsNAACAsqnYA7ck9e3bV9K1daizHzxzvd9//918MEyfPn1yPd2yQ4cOqlu3riRpw4YNDsdav359rnHtzSWvOtltrVu3zvU4eg8PD/Xs2VOSlJCQoAsXLtitsW3bNrPN3lwAAABQ9pRI4H766afl6+srSVqwYIHdPu+//74Mw5Cnp6eeffbZXO0uLi4aP368JCk+Pt7uUxszMzO1aNEiSVL37t0VFBSUq0/Xrl0VHBzsdC4bN27UwYMHJUkvvvii3T7jxo2Tq6ur0tLStHz5crt9susHBARo2LBhdvsAAACgbCmRwF2zZk29+eabkqQZM2bov//9b472Xbt26Y033pAkvfrqq+aZ7OtFRUUpJCREhmEoKioqxwogkhQTE6NDhw6pcuXKmjFjhsP5vPPOO/Ly8tLWrVs1d+7cHG3JyckaOXKkJKlHjx7q06eP3RotW7bU2LFjJUkvvfRSrjP33377rRYvXixJmjNnjnx8fBzOBwAAAGVHoZcFXLp0qbm9e/duc/u7774zbwwMCAhQRESE3f0ff/xxnTp1Sq+88orCwsI0bNgwtWjRQvv371dsbKwuXryoMWPGaMyYMY4nX6GCPv/8c/Xo0UPx8fFq166dIiMj5ePjo3Xr1mnt2rWqXr26Vq5cmesacFtt27bVJ598ogEDBujpp5/Wpk2bFB4errNnzyo2NlaJiYkKDw93eOY625QpU3T27FktWLBAt912mx577DEFBgZq+/btWrhwoVxdXTV9+nQuJwEAAChHXAzDMAq143XXVNvTpUsXxcXFOe2zZcsWzZ49W/Hx8Tp9+rSqV6+ujh07auTIkQoLC8vXXDIzMxUbG6slS5Zo//79ysjIUP369dWzZ0+NGjVKtWvXzledxMREzZw5U2vXrlVSUpJ8fHzUsmVLDR48WIMHDzaXEMzLunXrNG/ePP388886d+6catWqpS5duig6Olpt27bNV42UlBT5+/vr/PnzOdbhBgAA1imJdarLurK8Dnd+81qhAzesReAGAKD4EbiLHoG7hK7hBgAAAMoLAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgIQI3AAAAYCECNwAAAGAhAjcAAABgoRIL3EOGDJGLi0uBXr169cpRIzExMd/7Pvnkk3nOKTMzU/PmzVOnTp1UrVo1+fr6qnnz5nrhhRd08uTJfH+2Y8eOafTo0WratKm8vb1Vs2ZNhYWFadGiRcrKyirolwoAAAA3sZvqDHdAQIBltc+cOaOQkBCNGDFCf/31l55//nm98cYbatiwoV577TW1atVKGzduzLPO2rVr1apVK82aNUtBQUGaPn26oqOjdfToUUVGRuquu+5SamqqZZ8DAAAApUuFkp7Avn378uxz991369ixYxoyZIjd9ilTpqh3795Oa1SpUsVhW2Zmpnr37q2EhATdfvvtWr9+vby8vCRJI0aM0Pjx4zV16lTdf//9+umnn9SkSRO7dXbs2KG+ffsqLS1NM2fOVHR0tNk2YsQIde7cWRs2bFD//v21evXqPD41AAAAyoISD9zNmjVz2r5lyxYdO3ZM//jHP9SxY0e7fWrXrp1nHWdiY2MVHx8vFxcXxcbGmmE726RJk7RixQodPnxYzzzzjMOwPGLECKWlpSk4ODhH2JauBf65c+cqLCxMa9as0aeffqoHH3yw0HMGAADAzaHELilp1qyZunTpkme/9957T5I0fPhwS+ZhGIamTp0qSerUqZOaN2+eq4+7u7t5dn3NmjXatWtXrj7r169XQkKCJCkqKsruWKGhoebZ8cmTJxfF9AEAAFDKlVjgHjdunOLi4pz2OX/+vFasWCFvb28NHDjQknls27ZNJ06ckCR17drVYb+IiAhze8WKFbnabd9zVie7befOnTp8+HCB5wsAAICbS6m+aXLJkiW6dOmS/vWvf8nf3z9f+2RmZurixYv5HuP77783t1u3bu2wX1BQkFxdXXPtc32dypUrq0GDBg7rtGnTxu7YAAAAKJtKdeCOjY2VlPflJHv37lX//v1Vv359eXp6ytfXVz4+Prrzzju1cOFCZWZmOtx3z5495na9evUc9vPw8FCNGjXM8WylpaXpt99+y7PG9e3X1wEAAEDZU2oD97Zt27R79261atVKHTp0cNp32rRp2r59u5588kl9/vnnWrFihYYOHaotW7bo0UcfVefOnfXnn3/a3TcxMdHczmvZwez2lJQUnTt3znz/+PHj5vra+a1x/dgAAAAom0p8lRJHCnKz5IMPPqhly5bJw8PDfK9Pnz6KjIxUaGiotm3bpvvuu0+bN2/O0UdSjjWxPT09nY5ju3pJamqqudTgjdTIS0pKSo4/e3h45PoMAAAAKL1K5RnulJQUffzxx/L29tYjjzzisF/dunV19OhRffTRR3ZDaJs2bfTyyy9LkrZv36758+fn6pOWlmZuV6xY0em8bNsvXbpUpDUcqVevnvz9/c1X9ooqAAAAuDmUysC9dOnSfN0sWaFCBQUGBsrd3d1hn8jISLm4uEiSPvjgg1zttmecL1++7HRetu3e3t5FWsOREydO6Pz58+brhRdeyHMfAAAAlB6lMnBnX07y2GOP3XCtqlWrqlGjRpKkX3/9VRcuXMjRXqlSJXM7PT3daS3bM9m2+xVFDUf8/PxyvLicBAAA4OZS6gJ3QkKCdu3apaCgIAUHBxdJzZo1a0q69pCbU6dO5WgLDAw0t69vu152u5+fX45HxdevX99cMjC/Na4fGwAAAGVTqQvcVjxZMnsFEUlyc3PL0dayZUtzO/sBOPZkZGTo9OnTkqQWLVrkaPPy8jLPojurIUlJSUnm9vV1AAAAUPaUqsCd35sls02ePFmrVq3Ks9/JkyclSa6urubZ7mzh4eHm9s6dOx3W2LVrlxncbfe5vk5ycrKOHTvmsM6OHTvsjg0AAICyqVQF7mXLlunixYvq16+f/Pz88uw/YcIEzZs3z2mfP//80wzAbdu2zXWjYocOHVS3bl1J0oYNGxzWWb9+vbndt2/fXO227zmrk93WunVrNW7c2OncAQAAcPMrVYE7+8mSBblZcsuWLbnWqrZluxSgvctUXFxcNH78eElSfHy89u/fn6tPZmamFi1aJEnq3r27goKCcvXp2rWrec35ggUL7M5l48aNOnjwoCTpxRdfdDhnAAAAlB2lJnD/97//1S+//KKgoCDddttt+d4vNTVVw4cPt7sc37fffqvXX39dknTHHXcoMjLSbo2oqCiFhITIMAxFRUXlWElEkmJiYnTo0CFVrlxZM2bMcDiXd955R15eXtq6davmzp2boy05OVkjR46UJPXo0UN9+vTJ92cEAADAzavUPGmyMEsBBgUFadeuXfr444+1fft29evXT40aNdLFixcVFxenzz77TIZh6J577tGyZctUoYL9j1uhQgV9/vnn6tGjh+Lj49WuXTtFRkbKx8dH69at09q1a1W9enWtXLlSTZo0cTiftm3b6pNPPtGAAQP09NNPa9OmTQoPD9fZs2cVGxurxMREhYeHa/ny5QX74gAAAOCm5WIYhlHSk0hNTdUtt9wiwzD0xx9/5Ov67WwJCQn64osvtHnzZh04cEDnzp2Tu7u7atWqpY4dO2rgwIHq1q1bvmplZmYqNjZWS5Ys0f79+5WRkaH69eurZ8+eGjVqlGrXrp2vOomJiZo5c6bWrl2rpKQk+fj4qGXLlho8eLAGDx5sLiHoTEpKivz9/XX+/PkCfT0AAEDhxcTFlPQUypyY0JiSnoJl8pvXSkXgRm4EbgAAih+Bu+gRuEvRNdwAAABAWUTgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALFShpCcAAADgSExcTElPAbhhnOEGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsROAGAAAALETgBgAAACxE4AYAAAAsVKKBOzQ0VC4uLnm+fH1986y1ZcsW9e/fX/Xr15enp6fq1aunhx56SHFxcfmeT2ZmpubNm6dOnTqpWrVq8vX1VfPmzfXCCy/o5MmT+a5z7NgxjR49Wk2bNpW3t7dq1qypsLAwLVq0SFlZWfmuAwAAgJtfmTjD/corr6hz585atWqVevfurTlz5qhv37766quvFBYWpueeey7PGmfOnFFISIhGjBihv/76S88//7zeeOMNNWzYUK+99ppatWqljRs35lln7dq1atWqlWbNmqWgoCBNnz5d0dHROnr0qCIjI3XXXXcpNTW1KD42AAAAbgIuhmEYJTV4aGioLl26pA8//NBpP1dXV/3tb3+z2zZ//nw98cQT8vT0VFxcnIKDg822X375RZ07d9bFixf15ptvasyYMXZrZGZmKiwsTPHx8br99tu1fv16eXl5me3jx4/X1KlTVblyZf30009q0qSJ3To7duxQSEiI0tLSNHPmTEVHR5tt586dU+fOnbV371716NFDq1evdvqZU1JS5O/vr/Pnz8vPz89pXwAAyqqYuJiSngJuUExoTElPwTL5zWslfobb29tbzZo1c/pyFLZPnz6tsWPHSpKio6NzhG1JatOmjRmyJ0yYoKSkJLt1YmNjFR8fLxcXF8XGxuYI25I0adIkNW7cWMnJyXrmmWccfpYRI0YoLS1NwcHBOcK2JFWpUkVz586VJK1Zs0affvqpk68KAAAAyooSD9w3YtasWbpw4YIkadiwYXb7DBs2TC4uLkpPT9dbb72Vq90wDE2dOlWS1KlTJzVv3jxXH3d3dw0ZMkTStbC8a9euXH3Wr1+vhIQESVJUVJTduYSGhppnxydPnpzHpwMAAEBZcFMH7pUrV0qSAgMD1bhxY7t96tatq2bNmpn9r7+CZtu2bTpx4oQkqWvXrg7HioiIMLdXrFiRq932PWd1stt27typw4cPO+wHAACAsqHUBe7U1NR8reTx+++/68CBA5Kk1q1bO+3bpk0bSVJSUpIOHTqUo+377783t53VCQoKkqura659rq9TuXJlNWjQIM+5OKoDAACAsqXEA/elS5f0yiuvqFWrVvLx8ZGfn5/c3d3VvHlzjR07Vn/88Yfd/fbs2WNu16tXz+kYtu179+4tVB0PDw/VqFHDbo20tDT99ttvNzwXAAAAlD0lHrj/+9//aurUqercubMWLlyoNWvW6I033tDVq1c1bdo0NWvWTF9++WWu/RITE83tgIAAp2PYttvuV9g6KSkpOnfunPn+8ePHzbPyNzIXAAAAlD0VSnoCNWvW1A8//JDjZsXu3bvrySef1H333afvvvtOffv21Q8//KDbb7/d7GO7lrWnp6fTMWxXHbl+DewbqVOlSpUinYs9KSkpOf7s4eEhDw+PPPcDAABA6VCiZ7j/85//aP/+/XZXBvHw8NCiRYvk4eGhy5cv68knn8zRnpaWZm5XrFjR6Ti27ZcuXSryOkU1F3vq1asnf39/85W9ogoAAABuDiV6hrtWrVpO22+55RbdfffdWrVqlX755Rf98ssv5k2HtmeKL1++7LSObbu3t3eOtqKoU1RzsefEiRM5FlLn7DYAAMDNpcSv4c5L+/btze0tW7aY25UqVTK309PTndawPQNtu19R1Smqudjj5+eX40XgBgAAuLmU+sBds2ZNc/vkyZPmdmBgoLl96tQppzVs2233K2wdPz8/8/ptSapfv765ZOCNzAUAAABlT6kP3LZrcru5uZnbLVu2NLezH1zjiO0j3Vu0aJGjLb91MjIydPr0abs1vLy81KhRoxueCwAAAMqeEgvcq1ev1uTJk3M9+fF6tme1a9eubW7XqVNHf/vb3yRde2qjMzt27JB07amT2Y9WzxYeHm5uO6uza9cuM/zb7nN9neTkZB07dizPuTiqAwAAgLKlxAL3p59+qgkTJuR5Cca2bdvM7ZCQkBxtffv2lXRtPevsB89c7/fff9f+/fslSX369JGLi0uO9g4dOqhu3bqSpA0bNjicx/r163ONa28uedXJbmvdurXDx9EDAACg7CjxS0q++uorh22HDh0yg+7tt9+e6xKMp59+Wr6+vpKkBQsW2K3x/vvvyzAMeXp66tlnn83V7uLiovHjx0uS4uPjzXBuKzMzU4sWLZJ0bY3woKCgXH26du2q4OBgp3PZuHGjDh48KEl68cUX7fYBAABA2VLigfuFF14wQ6itv/76Sw8//LCuXr0qb29vzZ07N1efmjVr6s0335QkzZgxQ//9739ztO/atUtvvPGGJOnVV181z2RfLyoqSiEhITIMQ1FRUTlWEpGkmJgYHTp0SJUrV9aMGTMcfpZ33nlHXl5e2rp1a675Jicna+TIkZKkHj16qE+fPg7rAAAAoOwosXW4mzdvLnd3d506dUqtW7dWv3799M9//lMVK1bUvn379OGHH+r06dMKCAjQxx9/bK6/fb3HH39cp06d0iuvvKKwsDANGzZMLVq00P79+xUbG6uLFy9qzJgxGjNmjMO5VKhQQZ9//rl69Oih+Ph4tWvXTpGRkfLx8dG6deu0du1aVa9eXStXrsx1Dbittm3b6pNPPtGAAQP09NNPa9OmTQoPD9fZs2cVGxurxMREhYeHa/ny5Tf89QMAAMDNwcXI665FC508eVKfffaZvvvuO/3666/6888/deXKFVWpUkX/+Mc/1KNHDw0dOjRf61Vv2bJFs2fPVnx8vE6fPq3q1aurY8eOGjlypMLCwvI1n8zMTMXGxmrJkiXav3+/MjIyVL9+ffXs2VOjRo3KcdOmM4mJiZo5c6bWrl2rpKQk+fj4qGXLlho8eLAGDx5sLiHoTEpKivz9/XX+/PkcD74BAKA8iYmLKekp4AbFhMaU9BQsk9+8VqKBG44RuAEAIHCXBQTuUnANNwAAAFCWEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAsRuAEAAAALEbgBAAAACxG4AQAAAAtVKOkJAACAm0dMXExJTwG46XCGGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALBQiQfuM2fOaN68eerVq5caNGggT09PeXt7q2HDhvrXv/6l1atXyzAMh/snJibKxcUlX68nn3wyz/lkZmZq3rx56tSpk6pVqyZfX181b95cL7zwgk6ePJnvz3Xs2DGNHj1aTZs2lbe3t2rWrKmwsDAtWrRIWVlZ+a4DAACAm1uJrlIyZswYvf3220pPT1eNGjU0YMAANWnSRIZh6IcfftDKlSv1ySefKDw8XCtWrFDVqlUtnc+ZM2fUo0cPJSQkqFmzZnr++efl6+urtWvX6rXXXtP777+vlStX6o477nBaZ+3aterfv79SU1PVp08fjR49WmfPnlVsbKwiIyO1dOlSff7556pUqZKlnwcAAAAlz8VwdvrYYrVq1dKpU6fUpUsXrVq1Sv7+/jna16xZo169eunq1au6/fbbtWnTJrm65jwpn5iYqIYNG2rKlCnq3bu30/GqVKmigIAAu22ZmZkKCwtTfHy8br/9dq1fv15eXl5m+/jx4zV16lRVrlxZP/30k5o0aWK3zo4dOxQSEqK0tDTNnDlT0dHRZtu5c+fUuXNn7d27Vz169NDq1asdzjUlJUX+/v46f/68/Pz8nH4uAACKC8sCoqBiQmNKegqWyW9eK/FLSipUqKAPP/wwV9iWpB49emjYsGGSpC1btuiTTz5xWKd27dpq1qyZ05ejsC1JsbGxio+Pl4uLi2JjY3OEbUmaNGmSGjdurOTkZD3zzDMO64wYMUJpaWkKDg7OEbala4F/7ty5kq79MvHpp586rAMAAICyocQDd+vWrVW/fn2H7Q8++KC57eyM8I0wDENTp06VJHXq1EnNmzfP1cfd3V1DhgyRdC0s79q1K1ef9evXKyEhQZIUFRVld6zQ0FDz7PjkyZOLYvoAAAAoxUo0cH/00Ud6//33nfZp0KCBuX38+HFL5rFt2zadOHFCktS1a1eH/SIiIsztFStW5Gq3fc9Zney2nTt36vDhwwWeLwAAAG4eJXrTZFhYWJ59kpOTzW0fH5981c3MzFRGRka++3///ffmduvWrR32CwoKkqurq7KysnLsc32dypUr5/hF4Xpt2rTJsU/jxo3zNU8AAADcfEr8kpK8HD161Nx2tjrI3r171b9/f9WvX1+enp7y9fWVj4+P7rzzTi1cuFCZmZkO992zZ4+5Xa9ePYf9PDw8VKNGDXM8W2lpafrtt9/yrHF9+/V1AAAAULaU+sD9+eefS5I8PT3Na6jtmTZtmrZv364nn3xSn3/+uVasWKGhQ4dqy5YtevTRR9W5c2f9+eefdvdNTEw0t53dWGnbnpKSonPnzpnvHz9+3FxfO781rh8bAAAAZU+JXlKSl//9739atWqVpGtrdt9yyy0O+z744INatmyZPDw8zPf69OmjyMhIhYaGatu2bbrvvvu0efPmHH0kKTU11dz29PR0Oifb1UtSU1NVpUqVG67hTEpKSo4/e3h45Jo/AAAASq9SfYZ77NixSk9PV9u2bfXSSy/Z7VO3bl0dPXpUH330kd0g2qZNG7388suSpO3bt2v+/Pm5+qSlpZnbFStWdDon2/ZLly4VaQ176tWrJ39/f/OVvZoKAAAAbg6lNnAvXbpUH374oWrWrKlPP/3U4VndChUqKDAwUO7u7g5rRUZGysXFRZL0wQcf5Gq3PeN8+fJlp/Oybff29i7SGvacOHFC58+fN18vvPCC0/4AAAAoXUpl4N64caOioqLk5+endevWKTAw8IbqVa1aVY0aNZIk/frrr7pw4UKOdttHrKenpzutZXsm23a/oqhhj5+fX44Xl5MAAADcXEpd4P7pp5903333qWLFivrmm2/Url27Iqlbs2ZNSdcecnPq1KkcbbaB/vq262W3+/n5mddvS1L9+vXNx87nt8b1YwMAAKDsKVWBe/v27erWrZsMw9A333yjDh06FFnt7BVEJMnNzS1HW8uWLc3t7Afg2JORkaHTp09Lklq0aJGjzcvLyzyL7qyGJCUlJZnb19cBAABA2VJqAvcvv/yiiIgIZWZm6uuvv8532J48ebK5kokzJ0+elCS5urqaZ7uzhYeHm9s7d+50WGPXrl1mcLfd5/o6ycnJOnbsmMM6O3bssDs2AAAAyp5SEbh3796tiIgIXb58WV999ZVuv/32XH0mTZqk9u3b53p/woQJmjdvntP6f/75pxmA27Ztm+tGxQ4dOqhu3bqSpA0bNjiss379enO7b9++udpt33NWJ7utdevWPGUSAACgjCvxwL1nzx7deeedSktL07p16xQSEmK339GjR7V9+3a7bVu2bMm1XrUt26UAhw8fnqvdxcVF48ePlyTFx8dr//79ufpkZmZq0aJFkqTu3bsrKCgoV5+uXbsqODhYkrRgwQK7c9m4caMOHjwoSXrxxRcdzhkAAABlQ4kG7v/7v//TnXfeqTNnzmjMmDHKyspSXFyc3Vf2JSH2pKamavjw4XaX4/v222/1+uuvS7r2aPjIyEi7NaKiohQSEiLDMBQVFZVjJRFJiomJ0aFDh1S5cmXNmDHD4VzeeecdeXl5aevWrZo7d26OtuTkZI0cOVKS1KNHD/Xp08dhHQAAAJQNLoZhGCUxcHp6uho2bOg0SNtz/XRbt26tXbt2SZIaN26sfv36qVGjRrp48aLi4uL02WefyTAM3XPPPVq2bFmOlUWud+bMGfXo0UMJCQn6+9//rsjISPn4+GjdunVau3atqlevrpUrV6pLly5O57hmzRoNGDBAqamp6tu3r8LDw3X27FnFxsYqMTFR4eHh+uKLL5wuCZiSkiJ/f3+dP39efn5+BfgKAQBgnZi4mJKeAm4yMaExJT0Fy+Q3r5VY4E5OTnYafh2xN92EhAR98cUX2rx5sw4cOKBz587J3d1dtWrVUseOHTVw4EB169YtX/UzMzMVGxurJUuWaP/+/crIyFD9+vXVs2dPjRo1SrVr185XncTERM2cOVNr165VUlKSfHx81LJlSw0ePFiDBw82lxB0hMANACiNCNwoKAJ3CQZuOEfgBgCURgRuFBSBuxTcNAkAAACUZQRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBCFUp6AgAAoPB48iNQ+nGGGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQgRsAAACwEIEbAAAAsBCBGwAAALAQj3YHAKCI8Jh1APYQuAHAkZiY8jEmAMBSXFICAAAAWIjADQAAAFiIS0oAoDQp7ktKuIQFACzHGW4AAADAQgRuAAAAwEJcUgLg5sHlDwCAmxCBGwBQZrEuNoDSgMANoPA441zkYhRXzOMBAKzGNdwAAACAhQjcAAAAgIUI3AAAAICFuIYbAFBsuIkRQHlE4AYAB4r7BkYAQNlE4AaAcowzzgBgPa7hBgAAACxE4AYAAAAsxCUlQFnCg2gAACh1OMMNAAAAWIgz3ABQnsXFFe94oaHFOx4AlAKc4bbImTNnNGHCBLVs2VK+vr6qWrWqOnbsqNmzZ+vy5cslPT0AAAAUEwK3BX766Se1atVKkydP1i233KLXX39d48eP14ULFxQdHa0OHTrojz/+KOlpAgAAoBhwSUkRO378uHr06KHTp09r1KhRmjFjhtn21FNP6Z577tEPP/ygnj17avPmzfLw8CjB2QJAMeMSFgDlEIG7iI0dO1anT59W/fr19dprr+Vo8/DwUGxsrJo2bart27dr7ty5evbZZ0topgBQDhDwAZQCBO4idOjQIa1YsUKSNGjQILtnr2+99VaFhYVp/fr1ev311xUdHa0KFTgMQH7wqHUAwM2IpFeEVq5cKcMwJEldu3Z12C8iIkLr16/X6dOnFRcX57RvccnIyNDUqVP1wgsvcJnLTSojI0NT4+L0QkiIPPgl7qaUmZml+PjjCgmprwoVuMXmZpOZmaX4RXEK6R+iChX5HrwZZV7OVPzy+OI9hvwrTJEqrXmGnwhF6Pvvvze3W7du7bBfmzZtcuxTWgL3pEmT9Mwzz5Sqv6DIv4yMDE368Uc907EjgfsmdfVqln788Zg6dqxL4L4JXb2apR8Xb1LH2pmq4FGM34PFHaDKcEC8euWqflz8Y/EfQxSZ0ppn+NtUhPbs2SNJqlSpkvz9/R32q1evnrm9d+9ey+cFWIVLPIBSoLgDcHErzs+XkVl8Y6FcIXAXkYyMDJ08eVKSFBAQ4LSvbXtiYqKV00JJK85HrWdkFN9YAICbU0n8ghZa/EOWNgTuIpKammpue3p6Ou3r5eVldz9b2deC//7770pJSTHf9/DwsOSfSLLHsB2rTJo6taRnYJmU/z9wx2T8IA++tW9KGf//2bUMzrLdlDh+Nz+OoTWKM1sUd57JHic7tzniYuTVA/ly4sQJ1a9fX5LUtm1bbd++3WHfrKwsubm5Sbp2tjv7zLitpKSkHJeeAAAAoHQ6ceKE6tat67Cd02BFxPasdV6Pbrdt9/b2ttvnlltu0ZEjR+Tu7i4XFxfzfavOcAMAAKBgDMNQamqqbrnlFqf9CNxFpFKlSuZ2enq6075paWl297Pl6uqqRo0aFc3kAAAAYAlnC2VkY92pIuLh4aFatWpJkk6dOuW0r217YGCgldMCAABACSNwF6GWLVtKunYj5Pnz5x32S0pKMrdbtGhh+bwAAABQcgjcRSg8PNzc3rlzp8N+O3bssLvPjTpz5owmTJigli1bytfXV1WrVlXHjh01e/bsPK8rL4h169apZ8+eqlOnjjw9PdWwYUNFRkbm+FwoHCuPoWEY2rRpk6Kjo/XPf/5TVapUkbu7u6pVq6aOHTtq4sSJ+uOPP4rok5RPxfU9aOvPP/9U5cqV5eLikuN+DxROcR3Dq1evaunSpbr//vsVGBgoT09PVa9eXf/4xz/08MMP691337V7Qz3yVhzHcP/+/Xr66afVqlUrVapUSe7u7qpZs6buvPNOvf322zkuHUXBGYahuXPnytfXVy4uLoqzYCnDYs8yBorMwYMHDRcXF0OSMWHCBIf9IiIiDElG9erVjStXrhTJ2AkJCUbt2rUNSUZERIQxd+5c48033zRatmxpSDLatGlj/P777zc0xtWrV42oqChDklG1alVj3LhxxrvvvmtERUUZFStWNCpUqGDMmjWrSD5PeWTlMdy+fbvRqlUrQ5Ihybj77ruNV1991ViwYIExYcIEo0GDBoYkw9fX11i6dGkRf7LyoTi+B+3p3bu3eVz5kX5jiusY7tu3z2jTpo3h4uJidO/e3Zg2bZqxYMECY+LEiUbjxo3NYzlnzpwi+FTlS3Ecw7lz5xru7u6GJKN169ZGTEyMMW/ePOPpp582KlWqZEgy/va3vxlHjhwpok9Vvhw+fNi44447cvxc++GHH4qsfkllGX46F7GHHnrIkGQEBgYaGRkZudqPHDliuLm5GZKMN998s0jGPHbsmFGjRg1DkjFq1Kgcbenp6UZYWJghyWjXrp2Rnp5e6HGef/558xeFQ4cO5Wj76quvDFdXV8PFxcX45JNPCj1GeWX1MZw3b54hyXBxcTE+++yzXO0XL140x3B1dTXWrVtX6M9SHhXX9+D1Vq5cmeN/SgTuwiuuY3j48GGjdu3aRqVKlYy4uLhc7ZcvXzZCQ0MJ3IVQHMfw66+/Nr/X+vfvn+ukWWJiojmHv//978bly5cL/XnKm6ysLGPOnDmGj4+P4efnZ3To0MGSwF1SWYafzkXM9hv+2WefzdGWnp5u3HnnneY3fFpaWpGMmR3y69evb/eHyOHDh82QP23atEKNsWfPHsPV1dWQZMybN89un8GDBxuSjICAAOPChQuFGqe8svoYZgfuqKgoh32OHz9unrVp2rRpgccoz4rje/B6586dM2rXrm3UrVvXaNu2LYH7BhXHMczKyjI6duxoSDKWL1/usN+GDRuMatWqGQsWLCjUOOVVcRzD8PBwQ5Lh7u5unD592m6fWbNmmd+PnIDKv4kTJxqSjG7duhnHjx83/1yUgbsksww/nS2wbds285+0unXrZrz99tvGtGnTjH/84x/mP0EV1T8t217G8tJLLzns17VrV0OSUaNGjUJdxjJgwABDkuHl5WWkpKTY7RMfH29+c8ycObPAY5RXxXEMswP3mjVrnPa7/fbbzWN48ODBAo1RXhXX9+D1hg0bZkgyVq1aZXTp0oXAfQOK6xguW7bMkGQ0adLEyMrKupEp4zrFdQyzLxlp1qyZwz5bt241vx9Hjx5d4DHKq5dffjnHL5lWBO6SzDLcNGmB4OBg7d69Wy+++KJOnDih5557TpMnT5aXl5dmzpyphISEPBdIz6+VK1eajxPt2rWrw34RERGSpNOnTxf45oOMjAytXr1a0rXP5mjt8I4dO8rX11eStGLFigKNUZ4VxzHs3r27vvrqK4WFhTnt16BBA3P7+PHjBRqjvCqO43e9H3/8Ue+//7769Omjnj173lAtFN8xjI2NlSTdd9993OBaxIrrGGbfdGn7sLvr2T7Q7uLFiwUeo7yKiYnR0KFDLatf0lmGwG2R6tWra/Lkydq7d68uXLigc+fOKSEhQdHR0apYsWKRjfP999+b261bt3bYr02bNnb3yY+ff/5ZKSkpeY7h6uqqVq1aSZK2bt3KXdr5VBzHsF69err77rsdPtk0W3Jysrnt4+NToDHKq+I4frbS09MVFRUlf39/zZkzp9B18P8UxzE8ffq0Nm7cKEkKCgrK0ZaWlqaMjIwC1UNOxfV9mH3sDh8+rMzMTLt99u3bZ243adKkwGOUV1b/ElrSWYbAfZPbs2ePpGtPrHT2pKN69eqZ23v37i3UGNfXcTZOVlaW9u/fX6BxyqviOIb5dfToUXMuzn4g4f8p7uM3adIkHTp0SG+88Yb5sC3cmOI4hjt27FBWVpYkqX79+vrtt980bNgwBQQEyNvbW56enqpVq5YGDx6s//u//yvEpyjfiuv78LnnnpN07Xkb9n7hvXr1ql5//XVJkq+vrwYMGFDgMWCNks4yBO6bWEZGhrlOa0BAgNO+tu2JiYkFGse2v5XjlEfFdQzz48CBA+YPlsjISHl6ehb5GGVNcR+/Xbt2adq0abrjjjs0bNiwQtVATsV1DH/99Vdz+5tvvlGLFi20adMmvfjii1qzZo0WLFigRo0a6cMPP1Tr1q21cOHCAtUvz4rz+/DBBx/U4sWL5evrq7Fjx2rMmDH66aeflJiYqK+//lqdO3fWL7/8ourVq+uzzz5T7dq1CzwGrFHSWaZCkVRBiUhNTTW38wpHtteb2e5XmsYpj0rT1/bdd9+VJFWtWlUvvfRSkdcvi4rz+F29elVDhw6Vm5ub3nvvPa4BLiLFdQz/97//mduvvfaa/vnPfyouLi7HZV6RkZHq16+fVqxYoWHDhqlhw4YKDQ0t0DjlUXH/HB00aJC6deumF154QTNnztRbb71ltgUEBGjy5Ml69NFHCdulTEn//5Yz3Dcx2+uK8rou3Lb90qVLpXKc8qi0fG337dund955R5I0f/581ahRo0jrl1XFefxmzJih7du366WXXlLTpk0LvD/sK65jmH3taLa5c+fmuqfC1dVVc+fOlaenp7KysvTss88WaIzyqrh/jn744YcKCgrSwoUL1atXLy1ZskRr167VO++8o3r16mnmzJmaPn26zp8/X6j6sEZJ//+WwH0Ts/0NLK/H1dq253XjXEmNUx6Vhq/tpUuX9PDDDysjI0PPPfec+vbtW2S1y7riOn5Hjx7VxIkT1aJFCz3//PMFmyScKq5jePXqVXO7QYMGuu222+z2q1mzpsLDwyVdu+6b67nzVpw/R2fOnKnBgwfr1KlTeuedd7Ry5Uo98sgjuvfee/XEE09o27ZtCg8P17Rp0/TPf/5Tf/zxR4HHgDVK+v+3BO6bmO2SNunp6U772v5m52gpnJIepzwq6a9tZmamHn74Ye3atUsDBw7Ua6+9ViR1y4viOn7Dhw9Xenq6YmNj5e7uXrBJwqmS+DnasmVLp31tVzH56aefCjROeVRcxzApKcm8aTIkJERPPPFErj5ubm6aP3++fHx8dOjQIUuXuUPBlPT/bwncNzEPDw9zlYJTp0457WvbHhgYWKBxbPtbOU55VFzH0J6srCwNGTJEX375pfr376+FCxdyXXABFcfx+/DDD7V+/XoNGDBATZo00ZkzZ3K9rly5Yva3fZ9/0s5bcX0PVqtWzdyuUqWK077Vq1c3t22v/YZ9xXUMV6xYYX6v9e7d22G/KlWqmNfef/311zpy5EiBxoE1SjrLELhvctlnSlJTU53+zzUpKcncbtGiRaHGkKQTJ0447Zs9jqurq5o1a1agccqr4jiG18vKylJkZKSWLVumfv366cMPP5Sbm9sN1SyvrD5+2WsFL1myRDVq1LD72rJli9nf9v3777+/oB+nXCqO70Hb/ra/INmT/QAX6drPUuStOI7hwYMHzW3bh4TZYxvSdu7cWaBxYI2SzjJ8J9/ksq/1k5x/U+/YscPuPvnRvn17859UnI2RlZWlXbt2Sbr2pCZnT+LC/1Mcx9CWYRiKiorShx9+qL59+2rp0qWE7Rtg9fF77rnn9N133zl9ZT+kQVKO921XT4BjxfE9+M9//tP8F6TsJewcOX36tLldVE8lLuuK4xja/vJj+0uRPdlrrks5r99HySnxLFNkD4lHiTh48KDh4uJiSDImTJjgsF9ERIQhyahevbpx5cqVAo8zYMAAQ5Lh5eVlpKam2u2zefNmQ5IhyZg5c2aBxyiviusYGoZhZGVlGVFRUYYk48EHH7Rb548//jDatWtnvPvuu4Uao7wpzuPnSJcuXczvPRRccR3Djh07GpIMf39/p/t37drVPJ4nTpwo8DjlUXEcw2nTppnH5bXXXnPa96677jL7bt26tUDj4JqJEyeaX8MffvihSGqWZJbhp3MZ8NBDDxmSjMDAQCMjIyNX+5EjRww3NzdDkvHmm2/mav/111+NJk2aGHXq1DF+/PFHu2P8+uuvhqurqyHJYRCLjIw0JBkBAQHGhQsXbuxDlTPFcQwNwzCeeOIJQ5LRq1cv4/Lly3b7HD161JBkTJw4sdCfp7wpruPnCIH7xhXHMVy5cqV5nFauXGm3z/Hjxw13d3dDktGzZ88b+1DljNXHcN++fWaob9euncN5nDx50vDw8DAkGTVr1jQyMzNv7IOVUwUN3KU9y/DTuQw4duyYUaNGDUOS8eyzz+ZoS09PN+68807zB0RaWlqu/fv162f+pe7YsaPDcZ5//nlDklGjRg3jyJEjOdq++eYb8y/xJ598UjQfrBwpjmP45JNPGpKMxo0bG99++63xww8/2H199NFHBO4CKq7vQUcI3DeuuI5hjx49DElGvXr1cp29Tk9PN8/AVq1a1fjtt9+K5sOVE8VxDIcNG2b2mTx5cq729PR04+677zb7xMbGFs2HK4cKGrhLe5bhSZNlQP369bV69Wr17t1bb731lvbs2aOePXsqLS1Nixcv1q+//qrWrVvryy+/tPt0JdtrzQwn16VNmTJFZ8+e1YIFC3TbbbfpscceU2BgoLZv366FCxfK1dVV06dPZx3nQrD6GM6cOVNz586VJB0+fFh33XWXdR+mHCqu70FbS5cuNbdt76i3fT8iIiLPRxjjmuI6hh9//LEeeOABffPNN2rdurWGDh2qpk2b6uTJk/rwww914MAB1atXT6tWrVLDhg0t+axlVXEcw7fffltpaWlatmyZXnrpJX3zzTe6//77VbVqVR07dkxLlizRb7/9pgoVKujVV1/VsGHDLPu8ZZHtz6/du3eb29999515I2NAQIAiIiJy7Vvqs0yRxneUqNOnTxsvvvii0bx5c8PHx8eoXLmycdtttxkzZ860+89r2Xbt2mU0btw43/+cvXbtWqNHjx5GrVq1DA8PD6NBgwbGoEGDjO3btxflxymXrDqG0dHR5m/++X1xhrvgiut70DCMfB3DorrusTwprmP48ccfG/fee69Rq1Ytw93d3ahatarRuXNnY/r06VySd4OK4xhu3LjRePTRR42///3vhq+vr+Hm5mZUrlzZaNeunfHss88a+/fvL+qPVS7k5+daly5d7O5b2rOMi2Hk83QKAAAAgAJjWUAAAADAQgRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBCBG4AAADAQgRuAAAAwEIEbgAAAMBC/x95aGp06M54vAAAAABJRU5ErkJggg==", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for nhits in range(3, 10):\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " _, edges, _ = ax.hist(\n", + " x=dict_arrays_fake[\"scores\"][\n", + " (dict_arrays_fake[\"n_hits\"][0] == nhits)\n", + " | (dict_arrays_fake[\"n_hits\"][1] == nhits)\n", + " ],\n", + " bins=20,\n", + " range=(0.0, 1.0),\n", + " density=False,\n", + " alpha=0.5,\n", + " label=\"Fake\",\n", + " color=\"red\",\n", + " )\n", + " _, edges, _ = ax.hist(\n", + " x=dict_arrays_true[\"scores\"][dict_arrays_true[\"n_hits\"][0] == nhits],\n", + " bins=edges,\n", + " density=False,\n", + " alpha=0.5,\n", + " label=\"True\",\n", + " color=\"green\",\n", + " )\n", + " # ax.set_yscale(\"log\")\n", + " ax.legend()\n", + " ax.set_title(f\"{nhits} hits\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "dict_arrays[\"scores\"]\n", + "keep = dict_arrays[\"scores\"] > 0.2\n", + "mask_3_hits = (dict_arrays[\"n_hits\"] == 3).min(axis=0)\n", + "keep[mask_3_hits] = dict_arrays[\"scores\"][mask_3_hits] > 0.2\n" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.34167739628040056" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "keep.sum() / keep.shape[0]" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.9903418255310052" + ] + }, + "execution_count": 68, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "scores_3 = dict_arrays_true[\"scores\"][dict_arrays_true[\"n_hits\"][0] == 10]\n", + "\n", + "(scores_3 > 0.4).sum() / len(scores_3)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "particle_ids = df_particles[df_particles[\"nhits_velo\"] == 4][\"particle_id\"].to_numpy()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[2146, 2146, 2146, ..., 5409, 6307, 8481],\n", + " [4975, 2064, 2129, ..., 6307, 6307, 6307]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "particle_id = particle_ids[0]\n", + "batch.particle_id[batch.edge_index]" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([4827])" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.particle_id.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/normalisations.ipynb b/LHCb_Pipeline/analyses/normalisations.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..db887861f1da04c881e6dbbd0a85ccf321325397 --- /dev/null +++ b/LHCb_Pipeline/analyses/normalisations.ipynb @@ -0,0 +1,289 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "import anaconfig\n", + "\n", + "from Preprocessing.preprocessing import load_dataframes\n", + "\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "from utils.commonutils.cfeatures import get_unnormalised_features\n", + "\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "configure_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles, particles = load_dataframes(\n", + " indir=\"/scratch/acorreia/minbias-sim10b-xdigi-nospillover/92\",\n", + ")\n", + "hits = hits_particles.drop_duplicates([\"event\", \"hit_id\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f1e84902620>" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist(hits_particles[\"x\"], alpha=0.5, color=\"b\", label=\"x\")\n", + "ax.hist(hits_particles[\"y\"], alpha=0.5, color=\"darkorange\", label=\"y\")\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: -0.08074610279141962\n", + "std: 14.51331843142442\n", + "mean: 0.02629636994005264\n", + "std: 14.760759458144337\n" + ] + } + ], + "source": [ + "print(\"mean:\", hits_particles[\"x\"].mean())\n", + "print(\"std:\", hits_particles[\"x\"].std())\n", + "print(\"mean:\", hits_particles[\"y\"].mean())\n", + "print(\"std:\", hits_particles[\"y\"].std())" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "cdab97d708ec4e958cdabf240b8c2162", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "slopes_xz = []\n", + "slopes_yz = []\n", + "zdiffs = []\n", + "\n", + "train_dir = \"/scratch/acorreia/data/track-edges/metric_learning_processed/train\"\n", + "for filename in tqdm(os.listdir(train_dir)[:1000]):\n", + " path = os.path.join(train_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " start, end = batch.edge_index\n", + " r, phi, z = get_unnormalised_features(\n", + " batch=batch,\n", + " path_or_config=\"../pipeline_configs/track-edges.yaml\",\n", + " feature_names=[\"r\", \"phi\", \"z\"],\n", + " )\n", + " x = r * np.cos(phi)\n", + " y = r * np.sin(phi)\n", + " z_edge_index = batch.z[batch.edge_index]\n", + " batch.edge_index = batch.edge_index[:, z_edge_index[0] != z_edge_index[1]]\n", + "\n", + " xe = x[batch.edge_index]\n", + " ye = y[batch.edge_index]\n", + " ze = z[batch.edge_index]\n", + " \n", + " slopes_xz.append(\n", + " ((ye[1] - ye[0]) / (ze[1] - ze[0])).numpy()\n", + " )\n", + " slopes_yz.append(\n", + " ((xe[1] - xe[0]) / (ze[1] - ze[0])).numpy()\n", + " )\n", + " zdiffs.append(ze[1] - ze[0])\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "array_slopes_xz = np.concatenate(slopes_xz, axis=0)\n", + "array_slopes_yz = np.concatenate(slopes_yz, axis=0)\n", + "zdiffs = np.concatenate(zdiffs, axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "array_angles_xz = np.arctan(array_slopes_xz)\n", + "array_angles_yz = np.arctan(array_slopes_yz)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f1e867c7880>" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "_, edges, _ = ax.hist(array_angles_xz, alpha=0.5, color=\"b\", label=\"x-z\")\n", + "ax.hist(array_slopes_yz, alpha=0.5, color=\"darkorange\", label=\"y-z\", bins=edges)\n", + "ax.legend()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: -0.0065150103\n", + "std: 0.18471645\n", + "mean: 0.002169753\n", + "std: 0.16960813\n" + ] + } + ], + "source": [ + "print(\"mean:\", array_slopes_xz.mean())\n", + "print(\"std:\", array_slopes_xz.std())\n", + "print(\"mean:\", array_slopes_yz.mean())\n", + "print(\"std:\", array_slopes_yz.std())" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: -0.0049208854\n", + "std: 0.16074418\n", + "mean: 0.0019381851\n", + "std: 0.15437067\n" + ] + } + ], + "source": [ + "print(\"mean:\", array_angles_xz.mean())\n", + "print(\"std:\", array_angles_xz.std())\n", + "print(\"mean:\", array_angles_yz.mean())\n", + "print(\"std:\", array_angles_yz.std())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: 74.665184\n", + "std: 64.93781\n" + ] + } + ], + "source": [ + "print(\"mean:\", zdiffs.mean())\n", + "print(\"std:\", zdiffs.std())" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/particle_columns.ipynb b/LHCb_Pipeline/analyses/particle_columns.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..fb5764aeeeaaf9d824378dc19244510436b0d9ce --- /dev/null +++ b/LHCb_Pipeline/analyses/particle_columns.ipynb @@ -0,0 +1,256 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import typing\n", + "import os.path as op\n", + "\n", + "import anaconfig\n", + "\n", + "import numpy as np\n", + "import numpy.typing as npt\n", + "import pandas as pd\n", + "from montetracko.requirement import Category\n", + "import montetracko.lhcb.category as mtbc\n", + "\n", + "from Preprocessing.preprocessing import load_dataframes\n", + "from Preprocessing.particle_line_fitting import compute_particle_line_metrics_dataframe\n", + "\n", + "from utils.plotutils.plotools import save_fig" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import matplotlib.pyplot as plt\n", + "\n", + "configure_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "#: List of the columns to plot\n", + "column_names = [\n", + " \"distance_to_line\",\n", + " \"n_unique_planes\",\n", + "]\n", + "\n", + "column_labels = {\n", + " \"distance_to_line\": \"Distance to line\",\n", + " \"n_unique_planes\": \"# unique planes\",\n", + "}\n", + "\n", + "column_bins = {\n", + " \"distance_to_line\": np.linspace(0.0, 0.4, 20),\n", + " \"n_unique_planes\": np.arange(3, 21) - 0.5,\n", + "}\n", + "\n", + "#: List of the categories to plot\n", + "categories = [\n", + " mtbc.category_velo,\n", + " mtbc.category_velo_no_electrons,\n", + " mtbc.category_long_only_electrons,\n", + "]\n", + "category_colors = [\"blue\", \"purple\", \"darkorange\"]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Load dataframes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles, particles = load_dataframes(\n", + " indir=anaconfig.DATAFRAME_DIR,\n", + ")\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Compute columns" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "particle_line_metrics = [\n", + " \"distance_to_line\",\n", + " \"distance_to_z_axis\",\n", + " \"xz_angle\",\n", + " \"yz_angle\",\n", + "]\n", + "\n", + "\n", + "def compute_n_unique_planes(hits_particles: pd.DataFrame, particles: pd.DataFrame):\n", + " n_unique_planes = (\n", + " hits_particles.groupby([\"event\", \"particle_id\"])[\"plane\"]\n", + " .nunique()\n", + " .rename(\"n_unique_planes\")\n", + " )\n", + " particles: pd.DataFrame = particles.merge(\n", + " n_unique_planes, how=\"left\", on=[\"event\", \"particle_id\"]\n", + " ).fillna(0)\n", + " return particles\n", + "\n", + "column_name_to_fct = {\n", + " \"n_unique_planes\": compute_n_unique_planes\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Compute particle line metrics\n", + "particle_line_metrics_to_compute = [\n", + " column_name for column_name in column_names if column_name in particle_line_metrics\n", + "]\n", + "if particle_line_metrics_to_compute:\n", + " print(f\"Compute {particle_line_metrics_to_compute}\")\n", + " new_distances = compute_particle_line_metrics_dataframe(\n", + " hits=hits_particles,\n", + " metric_names=particle_line_metrics_to_compute,\n", + " )\n", + " particles = particles.merge(new_distances, how=\"left\", on=[\"event\", \"particle_id\"])\n", + "\n", + "# Compute other columns\n", + "other_columns_to_compute = [\n", + " column_name\n", + " for column_name in column_names\n", + " if column_name not in particle_line_metrics\n", + "]\n", + "for column_name in other_columns_to_compute:\n", + " computing_fct = column_name_to_fct.get(column_name)\n", + " if computing_fct is None:\n", + " raise ValueError(f\"No function to compute {column_name}\")\n", + " print(f\"Compute {column_name}\")\n", + " particles = computing_fct(\n", + " hits_particles=hits_particles, particles=particles\n", + " )\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_in_different_categories(\n", + " particles: pd.DataFrame,\n", + " column_name: str,\n", + " categories: typing.List[Category],\n", + " colors: typing.List[str] | None,\n", + " column_label: str | None = None,\n", + " range: typing.Tuple[float, float] | None = None,\n", + " bins: npt.ArrayLike | None = None,\n", + " alpha: float = 0.5,\n", + " **kwargs,\n", + "):\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + " for cat_idx, category in enumerate(categories):\n", + " _, edges, _ = ax.hist(\n", + " category.filter(particles)[column_name],\n", + " color=colors[cat_idx] if colors is not None else None,\n", + " label=category.label,\n", + " range=range,\n", + " bins=bins,\n", + " density=True,\n", + " alpha=alpha,\n", + " **kwargs,\n", + " )\n", + " bins = edges\n", + " range = None\n", + "\n", + " if column_label is None:\n", + " column_label = column_name.replace(\"_\", \" \").title()\n", + " ax.set_xlabel(column_label)\n", + " ax.set_ylabel(\"Proportion\")\n", + " ax.legend()\n", + "\n", + " save_fig(\n", + " fig,\n", + " path=op.join(\n", + " anaconfig.PLOTDIR,\n", + " f\"{column_name}_\" + \"_vs_\".join([category.name for category in categories]),\n", + " ),\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for column_name in column_names:\n", + " plot_in_different_categories(\n", + " particles=particles,\n", + " column_name=column_name,\n", + " categories=categories,\n", + " colors=category_colors,\n", + " column_label=column_labels.get(column_name),\n", + " bins=column_bins.get(column_name),\n", + " )\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/relative_edge_scores.ipynb b/LHCb_Pipeline/analyses/relative_edge_scores.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..c881f03529e6bb35791542fbc670c848d82ef45d --- /dev/null +++ b/LHCb_Pipeline/analyses/relative_edge_scores.ipynb @@ -0,0 +1,364 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import pandas as pd\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "configure_matplotlib()\n" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analyse the edge scores, depending on the track size" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "test_dir = \"/scratch/acorreia/data/focal-loss-pid/gnn_processed/test/velo-sim10b-nospillover/\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "c231f0031a0a4696bdaa08d887fc1c2e", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "list_df_edges = []\n", + "\n", + "for filename in tqdm(os.listdir(test_dir)[:100]):\n", + " path = os.path.join(test_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " df_particles = pd.read_parquet(\n", + " batch.truncated_path + \"-particles.parquet\",\n", + " columns=[\"particle_id\", \"nhits_velo\"],\n", + " )\n", + "\n", + " edge_particle_ids = batch.particle_id[batch.edge_index]\n", + " edge_genuine_mask = (edge_particle_ids[0] == edge_particle_ids[1]) & (\n", + " edge_particle_ids[0] != 0\n", + " )\n", + "\n", + " #: Dataframe of edges\n", + " df_edges_genuine = pd.DataFrame(\n", + " {\n", + " \"event_id\": int(batch.event_str),\n", + " \"particle_id\": edge_particle_ids[0, edge_genuine_mask],\n", + " \"score\": batch.scores[edge_genuine_mask].numpy(),\n", + " \"genuine\": True,\n", + " }\n", + " )\n", + " df_edges_fake_left = pd.DataFrame(\n", + " {\n", + " \"event_id\": int(batch.event_str),\n", + " \"particle_id\": edge_particle_ids[0, ~edge_genuine_mask],\n", + " \"score\": batch.scores[~edge_genuine_mask].numpy(),\n", + " \"genuine\": False,\n", + " }\n", + " )\n", + " df_edges_fake_right = pd.DataFrame(\n", + " {\n", + " \"event_id\": int(batch.event_str),\n", + " \"particle_id\": edge_particle_ids[1, ~edge_genuine_mask],\n", + " \"score\": batch.scores[~edge_genuine_mask].numpy(),\n", + " \"genuine\": False,\n", + " }\n", + " )\n", + " df_edges = pd.concat(\n", + " (df_edges_genuine, df_edges_fake_left, df_edges_fake_right), axis=0\n", + " )\n", + "\n", + " df_edges = df_edges.merge(\n", + " df_particles[[\"particle_id\", \"nhits_velo\"]],\n", + " how=\"left\",\n", + " on=[\"particle_id\"],\n", + " )\n", + "\n", + " list_df_edges.append(df_edges)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "df_edges_tot = pd.concat(list_df_edges, axis=0)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "genuine_scores = (\n", + " df_edges_tot[df_edges_tot[\"genuine\"]]\n", + " .groupby([\"event_id\", \"particle_id\"])[\"score\"]\n", + " .mean()\n", + ")\n", + "fake_scores = (\n", + " df_edges_tot[~df_edges_tot[\"genuine\"]]\n", + " .groupby([\"event_id\", \"particle_id\"])[\"score\"]\n", + " .max()\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "event_id particle_id\n", + "476545 514 0.838615\n", + " 568 0.904482\n", + " 576 0.867661\n", + " 584 0.887780\n", + " 588 0.903285\n", + " ... \n", + "1200239 13982 0.926008\n", + " 14005 0.830914\n", + " 14006 0.933353\n", + " 14007 0.924459\n", + " 14013 0.914115\n", + "Name: score, Length: 25408, dtype: float32" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "genuine_scores" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "df_diff_score = (genuine_scores - fake_scores).fillna(1.5).rename(\"diff_score\").reset_index().merge(\n", + " df_edges.drop_duplicates([\"event_id\", \"particle_id\"])[[\"event_id\", \"particle_id\", \"nhits_velo\"]],\n", + " on=[\"event_id\", \"particle_id\"],\n", + " how=\"left\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for nhits in range(3, 10):\n", + " fig, ax = plt.subplots(figsize=(8, 6))\n", + " diff_score = df_diff_score.query(f\"nhits_velo == {nhits}\")[\"diff_score\"]\n", + " prop_higher_50 = (diff_score > 0.05).sum() / diff_score.shape[0]\n", + " ax.hist(\n", + " x=diff_score,\n", + " bins=50,\n", + " # range=(0.0, 1.0),\n", + " density=False,\n", + " label=f\"{prop_higher_50:.2%}\"\n", + " )\n", + "\n", + " ax.set_yscale(\"log\")\n", + " ax.legend()\n", + " ax.set_title(f\"{nhits} hits\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0, 0, 0, ..., 4641, 4642, 4653],\n", + " [ 229, 231, 232, ..., 4826, 4826, 4826]])" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.edge_index" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "keep = torch.zeros_like(batch.y)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 0, 0, 0, ..., 25, 25, 25])" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.plane" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for plane in range(26):\n", + " # get hits\n", + " for hit_id in batch.hit_id[batch.plane == plane]:\n", + " # get next edges\n", + " " + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/slopes.ipynb b/LHCb_Pipeline/analyses/slopes.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..70668f9203ccd02fed301017df8d2f27502f4b35 --- /dev/null +++ b/LHCb_Pipeline/analyses/slopes.ipynb @@ -0,0 +1,268 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "\n", + "configure_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "089fe97d81f147bd9b1c656607c35f10", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/100 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "train_dir = \"/scratch/acorreia/data/triplets-first/triplet_processed/train\"\n", + "\n", + "diff_slopes_xz = []\n", + "diff_slopes_yz = []\n", + "y = []\n", + "y_pid = []\n", + "\n", + "for filename in tqdm(os.listdir(train_dir)[:100]):\n", + " path = os.path.join(train_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " y.append(batch.y.numpy())\n", + " slopes_xz = batch.slopes_xz\n", + " slopes_yz = batch.slopes_yz\n", + "\n", + " diff_slopes_xz.append(\n", + " (slopes_xz[batch.edge_index[1]] - slopes_xz[batch.edge_index[0]]).numpy()\n", + " )\n", + " diff_slopes_yz.append(\n", + " (slopes_yz[batch.edge_index[1]] - slopes_yz[batch.edge_index[0]]).numpy()\n", + " )\n", + " y_pid.append(batch.y_pid.numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "array_diff_slopes_xz = np.concatenate(diff_slopes_xz, axis=0)\n", + "array_diff_slopes_yz = np.concatenate(diff_slopes_yz, axis=0)\n", + "array_y_pid = np.concatenate(y_pid, axis=0)\n", + "array_y = np.concatenate(y, axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAsgAAAIBCAYAAABUTEkKAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAAEAAElEQVR4nOz9baxlW1bXj4+99zmnqm7dx773djcN3bY/gf4LhrRBo29sgQiRqGi38EeMGo3aimjQoGhQY1RM7ICCzygxBlD0D2hHNPGFLd3mJ7wwoaPYRrERGmj63u77VFW3nk6ds/f6v1jzO9acnzHH3qcuR7iNc7ypOmuvNdecc82HMcf4ju9YTdM02ZAhQ4YMGTJkyJAhQ8zMbP2LXYEhQ4YMGTJkyJAhQ15PMhTkIUOGDBkyZMiQIUMqGQrykCFDhgwZMmTIkCGVDAV5yJAhQ4YMGTJkyJBKhoI8ZMiQIUOGDBkyZEglQ0EeMmTIkCFDhgwZMqSSoSAPGTJkyJAhQ4YMGVLJ0S92BX4pyG63s0984hP22GOP2Wq1+sWuzpAhQ4YMGTJkyBDINE326quv2lve8hZbr/fbiIeCfAnyiU98wt761rf+YldjyJAhQ4YMGTJkyAH52Z/9Wfusz/qsvfcMBfkS5LHHHjMzs9+w/m22mfZ06bQzM7PV0fH853bbvW21XjW/6349vxQ3Nffz+r462Gq991leD79vNk15fGf9vLcT79T19clJe99SSPcd/vwF2r8+PrpQ2X75aL5/9+DsQu/iO71f6rLLu/x7lnu8/VdL+8s7w/1656Hr52ehfayv3r07O29+X50ct3VAOcu30lic2nJ67U7qsvTVfN37Gv3idWOdy9+r43L9/oPQPv02JWVnorpp3IR+qttpS7/V9VC71Ed8Z2hnGXNW3rGUg/vUNvRj0pBuGdkcXCrXt6iE+6v72F4rXrTpvDM2Ou9U+3U/67CMc9UB48ssXRt9/u/ab7G+dsXMzHb3Tts6cj1A3TUe6rL5G8dOmN8qW98d/XaRfuS45FjQPPW+SsZD6KdkjeqNC72bdenc2NQhW3vDO1DnXv0k3tel3Tv0tfdH6cus3VzvmuqpT87bdfrQ9V479r4TekKvPmxntk953TD+s/Wwuy4k7fG6cexh/Hsx6CfqQb3xE/QK1ps61TnW+87z59OZ/b/bf+162z4ZCvIliGAVm+nIjo+uzhel1FUDbXV8tb1WBl5YUI/nBXU3lY3SymA/OmnuW22yjXJ+txTP3jNcpDhYOWj9Hb5XabKXyXLUV2bNzNZXH5nvfFAUmV155/GV5m+vU1AEN+07iqyO+pv2tKsWx3NNurmPuSBOExa5s/n6Bt/RShVWpU9390+b8npKavjepY+9T1elj7SOrK90fw+bmspfQVm7snzvVBEs7d0UpWZ1ZX7ndFoUhSvXm/Y5ZEiLNfa0o/J82Ozmhsw/qU8mfZ9tU/+joqyY2qd261uVcXNU6mal7qrz0cm1pXnaIKbSN8ftwjlNUHQxXtcn7fhQ2fruqovp+bOln9er46Zd0xYbpuajvk0Z/76ol+ftBJuantfk05g9Wr6/+krfTR9Ka8a0m+u9LpvCdPduU3Y4CGlcS3mVwrGWUrd875Umh9yVvsm29ZWsH2nHmMaUK8o8jPrcPG/aVIv6cH1t/l67e/easv0+9eXZXPbRI2WTlOIEBYJK77Sp2uL1LsqK5kqZzxo7u1OtvWV+Y1yvrpR1gofTZaKX9i9jLVuffA3d6vu3a5DW0mnS4QxKifYBfQPN+0p5XZST8urNOtxT37c+6h9SVhushzSA+HuqcjX+du289f4o3bE2KKXaIo7bvcjXiXVfUaZSO1cH+5D250fm7+1rhO5X/Vt90dYnc118bfJ3xn19fQV7iT477/XtvdSbeysUx6Ckcr2vy1ZRm+W3uX1Qus/btZOHMY1Jf1560FFPscbBztfpVhcK4x390e77u7ate2QoyJcp066rIDa/W1wAeBracYJpYdlhhqFcTupmoHm9NLm3uN63RoUT54GTaO8UuDu939QvswwvJ23dBsswlL5p297XVQozy0linfd3JtYN39R6fUw5P+te1jfIrZlJXWVB5KLWsQbQor3cyzq29XfFmAejqSggWJhoDaif9U2IVmz87e+kheWstSh6+877lvb62lJIYhHsKfR1WX7YKuPdFc8i2wfxfRrP51C6pWyG79nWmevA0qT2UMv+NTNboU84XvX37vadTqujLBsxLK9+6I5Wvel8nuf1WGgLLeublFcqVFyDVGeMj6bdHDPlt6Bk+9qIKpVDVuqd2jPPUyvcgTUxfJN7c78Fr8Vm09y3OopjLR3viSXUlTFvb37An59Xo6pvk8wdGoVWULZTT8jBPaZ+RfudDlorsbeEcZG0xetWGzy4dqDvs3VM9T+0z3Os+h7dedavZx5drgfY7zOvNMvtlZ3pDMGollmnOc/VHx1PRLZXRg9Ku17zXbtqzk1TX9fpyWCxGDJkyJAhQ4YMGTKkkmFBvkxZrTtY1eiiqe83qyxNcqOEU/4FMIe9+2o3KC0tdKHpOlys2SkwQDSIt2qsJnDrJNhKWk4DLo44UFg9lnKr+nZcZGZm6yt9HHiK0ZPb+7w9RftzqlsHN8bvkmGIo4ehrVPALgPeYVPd58CssS/lFoaVN7W4Ta0VjPhLueLne0ufJZZR9qkkG7/BssRv0vvegmE8KO0FlMTvF0SE+NCDeEphtysYkyxIpW9WiaUkWG/Qzt1Z60bk8wu8o7KaJdjiQ/hfjr0Mixrd3nFtWbG+nPeCqWTWPtYNY9L7tYdJTTCIjq3Xd08w1h4Hcd5iOr2O6xYm0JQNHGh2PeAh1R71OeEcXMd7OGBY1QP2lLhYfSN6KQ+MlwYqeCBWIIPvhXUQ/y5rDdbWalzJk0OomySzKHNvzdriHrIHHQ+RP7RO/sbcSPbIiVMwjP/DmNxlv1V7+tCJ8Dy8rlpr0vWu8+6L3peWqbWmfBOO3WaOJXrUMi7Lfdzn+U2SeX9IhoJ8ybJPmT0IjM9c8tniBTxO2Lw6uDFfKLQAHIBncONYBj/dyO1Arheopd7tYst6Z24ULnqCmqTKb72gBldTKRtQieCSdIWjdVm5YgnYiH/vzkaSudKWdxUc3aMzNnNb3OAZxGR97Wp7Xw8nh+9kmxb/SkXC6wZ8ZFXpuS3cePQNoXjWzyxKd1m0NZY0rqEgZIrxshGfdJ9v6r2F+/5BhII09U6CGgMGd+oHmDT1FpauuM6DYixJ3P6b6wUnic3fxxNgML16S/H3OiT3sW6cFyEYBofZtuItVji0m650Hwfzz+urV5r2EefPckuDmrLYLkOAW4RWJcGHSWBt4/YuY0e4Z4d3HFKM0R/Z5h2wys3BoG1nOBAg4Nf7Q+1JYikyOMT6ajXHMkWe9c8Cuak4pwGB26bOzTu5pmbBx5ynhPclBoNe21LIDJVr3xvK3ljGdVZnHghCORbXiLCHHoCOZPjuQ9+9V1YQKbzEBSfv9v35QLBffS2DH1F3yJTuWlbTivajVAbEYsiQIUOGDBkyZMiQSoYF+RJltV6lwSFmFk9aDCjJAohgpQxutGD96Lg4Vu0JOZSdQQ2CpRHQgwyKcYETqJ/WE5q3LEAmCwKQFbtHd8a6RCqmlkkhBAzIgqo6P1IikBHkU7fVLWOAIwQrVhEG62Sn/l1hIFgozaJVJYwxBpAkwWt0f6cu+IR+p67nAgloGSDodZhCX+8PQlwdK0DnSqxzRimHQLnQPtUd9y+W42L1kvVjj7tR35HvpHU2WMg1JksQ2wIXab+NPAg168ECY2ghBd11qG4P5nkGsaBnqLFey0qn9rnVrn2Xv5prCtpH61ZgkthFu07mXXM4ShIQO8Giyjr4N9wDW3NLf0brCAaUYDFn0CI8EG6BrL1ySTBh15PTE35feMwEKdmhP8w6cJQArWg9A4u1vm/VDm1gEG491xKvRBivHRap3jt9TAFa06OvzDyWsu7K4sv+cCu9e9vul7pZUwcFYQbvZlVfWsZ797Z101pjTbt8buH53l6cQX0YIJdZd5fnjrt14Fiu90vVL7NKezuz/siCMy8oQ0G+RJl2kxk9mJ2FOYM3PPyCQffnnrplsI5DcI9ORG19367n9mRdsPhSDkEQDip1VGqTxWIuou27oBgCB0xso5dzmmDfmgj7cm/mzkmwhVlU91Iw7u9E2GdKBvHN+2A5e+/Xe8578IH2wEaFL7hDCetJsOehvXtYS1yJgmtZwnfRVU+mgbAhO51cpSgmLBwBo+mbtzW/850uxLJDaW/qf4D32fvy6Mr++7ODAzDJZh1FCdjqFB+pfsigNSnLS5QInZjrRGaBrJ29OWRmEd7QwwGLC3vbV8qysl2xppHiFLEInTU2YkeT+iVu7IyL9iIKRYYZnbbJOg54nh+M8Y5gvOm0wdfCLE6HuOiMq5kKdEJz2IUKZn2UsDQFVp8M1gfscRe6AkONJI13SZivsr0y/QbNy9o1NoulYZ3DGMNaqutdZqikzGytSA12h+AikAGxGDJkyJAhQ4YMGTKkkmFBvkRZrVfmROwd60ewhO3aUxBPnCGYgVbbpeDmnbx/LirJvBSCb6wpw58PcAYNHV1PrJ1mwdUcAuHUfLdEKfAg4Tr0YLVSx9OcyzkEL23aAAh/d+LCCmwWBwJTagtOljExDUpD4BDvp1s/D6Cq6sfgS7jB3ZqTuaATQvlg3e2czFeAlqTu/iKEhWQW9HUJYpvkmu5XfC6DCT7wLlpvmGjioCW2eWU/UEbjVtAIQjAmWHPIuOF9Xa6vnLu6cv+W35bATQWqwqKm4L0C0wlWLySnWaRvza+fDWXjdw9wPN4ftMSxu7lOiEEMhPW+UNIKp9CG9R7tYWDgUmUwyWi8NGOulAku8dRKn60Hbu1M2Cs6c4uBnIGtApbl8E4GjBJClEDxZsFcIYQAHoUQ8B2CsttvE+ZJXdcMUuHVRF+R8QXjPHjMkjrX7cogkQyuCxz7hyCUgTmmgvMAQpDt25I0cF9tSRilliqtwr2qZxa4r73kIDPGqu+V3ZdhOGNOCeMg88ZXrB0Pw4M8FORLlGk3eVaZ7HezzsDh4E0mf4rFxQBeJsVhvA0XuTTKHddJgxMmdbXwZJuPvwIKc+b+CdHCiNC/CH7Kle5wiCB0AEwLxDgdoMdr7iUFXKLYphuLtRIOGB3Ko6AQJxgzHtIyxToe3vKxRWxmwLuh78KB8ECk9e4OFLCOC5aKDxd1vttdkhp7wKQueNkyx05buqn5Xim01tTBMcjCjgOzu2xWc1lSclVnYRPJjtB0wWnbzsyVmNGdZYwiKc69PgiqDz0bY2m3stNpXAcsbju3wrfxeX6vua9pv9pJtpFk/Aa8d6oYY026H/stO1T6+C/rk9hpGDtAfHSEC6DcmlJQfYK5nyafYfs6mGqz+N17hoA1sPKL9KEDPPj6Gjlh3uudIaNgpSjyMJEo/j6WkjUkHOwzWETNJAH4js9zri0JRjd814QqtLf/Z8ok+851BEICE93jYJrwTr0yGEbYtxNIpN9HqFWHWcmhfbv+gYYH/Ix1pq7batqFrIaZDIjFkCFDhgwZMmTIkCGVDAvyJcpqvTLbY72P5POty1mnn82jj5qZ2bZYyjyyOLGGZEwSPbcYXWiZ5ZhuwozTdYnUbqPn9xHLUzL3SQi4KhITg8BltweIH/kUi5UOUb6sG91omQWmeVdxFbolje1LoDEpe4OseXSPwlJj1rFek8VBVg5aDGkpnGBxgvQI6QNHpxgSCvMH2TqWwtqAUHcjZ6wOaqMslmZLwo9kbqzcKjtfD5zTGyR5YL8pKBFW0rq9mguyGAbLYIj+B4TELWywwMDq2fQfmQ/K2PN36PtpPICTfAVrJi3H+gbO+VvNk9AejXe1G5ARHzOrdg6ty7rnMIbEM9asVbIcs2xYpVS2nSkIs2+Ndysn4QMdJgl3OZPnVtePUTf1Ka2+Psb0fIE/XWvvqyEpvlYcCEymFdOvZ+nPM+7mHtc4LaUaB5wbSfAlvT2hLb21FWPhUKDf6kr/G9AyqfU/WGI7LFSh3YcYUq60UBu2xe/XWO0lNSEcUWtswrGcehC0RuG7hyDcajxlkBHugfROZvvzwwThhsBu94j2YZiB1xzlTOdnNk34DntkWJCHDBkyZMiQIUOGDKlkWJAvWfZhvBx7RDoUWFKI7VpOXrqtPd0HCi+m7qzKdp7PA0FmfgILVGv9oKzAB9z8mNA3TRFz1JUEB51ht2tJ8c6wMPH+mAa1T022Dye+whhYxkSf5ijj7Ax1B891jxYntBtWn4zWKf1WXiV8347Vnqd9f1bWTaZzLeK8mOSX1fN6F+tQWXHTTIAqQ9ezIBXyyGbt72F5ZZmApWlJic3gpNaan2V99G/J4KCmXcjeRmuVtwfPBXo0UDDR6tMba8Rrg2Iry+rGcT/dvt3cx4CrENxq5gGLaVCx+rasqQEnmeFl6Vnr9L3Xm2MtoRDz61zfZRUDx/a29Ef3eydZV/mujEpxxXXdq97nvO1S1WUevh4NYaeOvp+R45b42SamBJk8M+9pEQ/0y2hNkziXh7FyZrhX77uEmzoEvjOGphPMTEs/ObQzujt/njzfqLOP6T25BMK+BR7kLEAuZHdV8dQtOkKLfuBFTijjMkv6RWUoyP+nJOGVrSULjMpIsNNBz8CqdVT+0qjlUPbFiLVj8Fs/GriuB91YzKOuxe+ipN4pD+Ue2EOWnjvyvCaT3NeuVjl19/o+doMMMsEFBK70xTXbuv/57paDuR1biwIA96W7g8lp2t8o0qQnTbAaNjG4UN2VCAgKy2QARoAcdJJ2TD3XaN0OBl9msCVG5HuAWJ/bt77H211YVshaEQ+ypQ5rwF1SXmFrnq/vDQwR6gdw6gbFgMp5usHEzXu1aVMGe5lQsj1okWOSqZoZkMODdLXZHTqwcn0i5MiTryBpR5ibncOLJ2wh24iPg3aM7U77AYQpDzb+7TILcK0D9zT7IwS8ZmONh5mmHIx9udgBS8nWPa413It2D/qBhb13hbUmS2TEw1jPiFS3uyO+BhxIQhIfbOFsPPhn7B69w5gXeYDV4eDaecgo01POAaXivs3veFBRvsgh5BCshXzIu3Y8h/uOjmf70gjSGzJkyJAhQ4YMGTLk4WVYkC9Rpt1kq5P+6dqsY9XLguwSt8CF0jrX95dTtlk8adOty+AzDwxMUjjKEslgsOWFS7sVdLDcCyqdJDDuULDawrso1+7hLDmBcijhyWUwY2ZZpLRWvfIv+ka0TwoQc2sPM2epnCTYx2mVZFWpA2nIHdwLMrJ4qk/5RRV4Uzgkae3qUcyR5ox1cz7fAxRdmcsxZDmbC2/ri0AhScZ/eyjQxK3AqnNNNUirK9I9e7CO6L4AB3FuavDAUnrzfaXvS+otzyRY2qfAR8AZgsWdVG271grWjCPBHMCD7BY3Wmtleb23ba5zzDLoy99ZtX8Fa5T3w50kIPZc/dFatWU5TrO9qT+2yzhyz4Bb1FTxdgxqXGsdjO0Tr3cLB+D8bniv6dEiZCSl1rO9kvGA133uAbBX2wDOEHQIz0cWzEhqtgyCZVb1YfCMJdy8yXovGrQlOLf1TvSoRjMaQsP8JcWaP09vB62hgB7V+8bqpPVWhCBC8DtnqaQpMWi94xmDx1dCaKfnGDhAHZdx51/EopztTwEKmN33kEF6Q0G+ZAnKXuV2zSKFAzYRGNPeAlk/n6aorOuSuYXIPcwyEhfOIRd1U0+QmxOLHRT/dKEAllOMAhmOrmkm+pJR7kwtmkVen/ddVaxzT1TG9tVX+/WmO4iu1+Wl5f6WaaLrHgT2PMc1Z5HZpf3AD+9zRbqEcd1/JmD0iMmlkPuyA3MgBjebc4ffmRxeenAnsGuEPoXCS8XY6+SP913RhPmYRW7oEOWuet8H24M/gMMlmFeWF+XwJ/L8LutdqzAFRgH2OQ9IPBhWcK7AeCPFLnDKorkam1QEicX0w1xsr7/bxwZcyRjXvnYweU9QjPXAnhiLFBeKdZhJdzLjCuNfaKSp11TsJVSqAn4bh+iMmcCFymvNPU2u4QNK1SEji+97F4nBIPyAkKAEppRBBh2WmEAzuvEs+vsQn/UeBbGpIxMDdfaxGK/SH3t+Cs/uS/aa8HstCe9xGkOl2w4o0BeVAbEYMmTIkCFDhgwZMqSSYUG+RFltNma76v8PXUCSJaZIFlAWrAIdAL5bkpLTfTzdtVaCJfgBluYLwD1CUFqSUYviLiwG+xzgfQ6BF037St8xfbdccICDkD+akfoSD5jrwBwW/mJYFmjdOE+sAEdtENTBfrD6+3hl2nYQOqK03c4KQMaB8i6mW3X3WqfT1W62J1iGEOjnVt5yW+Bm7ruw63csFzQhC3wBsA9asfz7JcwSDn8o1lJxO5tVGfBUBqAjDgGCOzflj3WLaR9yU0NX0nTkSbR3kCRolwFG5NFuntX3JjyDmbNQF7+euWT1H++PKigTga2B5/uoXd98nB7p/l37PD1IJ7BE1Va9JGW8p9LlWgn4hpfD+QDmDL6veWdmSc7YGbKshYFhqO+dmwUWYwQ6pnAmWvcZ9EVu5j1c8we9D2RKAJzPs+Ax6HjHda/6Vqs2+MzbFyAh/TVodXS1+TuDIhB6Odc3CdLbteMg5Ezg87TeZoF09driQXeYnxnXcqL7OATDPWxtZsJepkxmX32tsMx2nqxtX76KWoaCfIkynZ+Zrcum3dmIMmzVITaGlC4IkzxCNZZB4UT/J8QJJW68JDLZhcoNcFW7DrzDF1a6lhN6K2JMs0G/EKx3klbQXYd2rq8/Nl8Aw0JYgIkzSyAlzaEEeD5CZ+ia25eLvmkny+3dy0ULh41wmDjHhpswJoRo4Q6GewVFRmPBU+4y6QzZCZiA4YybwKqpc9cdiHbTves42ActxCbAlqCEUwmuccKuIHhlsAprvCbQipCcZAX4DlKV13NszbmQYUlZF82DougTN+33AT8smJBZhN0wQUpgK3EoSntgWp20bBZ+UNI3QbR83U4lVfLkMvze5fr21lxvuk4DXdZJe2A0rEFzYYSfleqd98eUKy/CapOCDMpeYIWo940DzC48yIsZIo2lKMqKHyjO+0w5vXpy/maQi0wIX1rc/RFixQPtIVe6cNIpe4u+jb73aZ+Bo1tvZydpE2mEOoClxa8jLTz7ulFSAQnR+pvFxGS0ZzEeCNBDjIOmHjyoEAoK4f6esS49DByCCnPGlBMYcVSn9cpW0yqcYTIZEIshQ4YMGTJkyJAhQyoZFuRLlNXRsa2s74Yw61gWLggcj65JFZ1xH/ZOdvuDGWgxCnyquC8P0usB8MGIAOssrZBZ1GwWrBcCTWo3aMKLugROtW6/EFjFYBBae8/bSPbme2cJBMjJetBdqLqJV7dvFaxPy24RfKDUurSA9632weXmrntwVCMgrU737PCD8l19vJ/TQgQYD1JRh6AYVVH39yzp/H6wXjtnLRJ9ZKl1adUN7vLKakyrpfH7JvXOLK0+Lw4Q9ZeL87Ur7bwNkAJZRPWsjENgEFnGeWtRDSmd63q6lRnfhd4JupBleUagoZevupLtpHqHf98khbTmuSejgRU3eMrEVkHvRluxuWx6LeBlIhSDVvow9jRekoDh5plkvIcxJ2sly4b4miped/1Q1zHjm09gSYtXseUejmvm4aBeQtl4L9lpwpxEO93iyEDQVQzmXSyfss6WuiA1dBacmHp6zdrnet87K7tYr9lXZFZJvRsJJK3ZS5K+preY+1lI+w0reFh7O4nDMuiE/34gEJSBg/MeenG78FCQL1Gm87MFpgOS+/pahk1bhIP2YhnnAsazJwlGaymkKJkH3GLhnQ/BJBEoWYI7pHUPhXzrmFh5P8Z37xhpDleU0zslON9wf0JhN99rKLt1uYboX9UVi/RS3sX72hXjBJ7DBTUkXFB/JYt72LzO46EkYzzJxrEU60X24yL9oEBGBuuMMSnEgH+kmGX2Nb5ZN6sbWA2oVLFPeT1kv9M3gbufB6am3lOrOPmGx+xmhCll+HDdf56sF2YhliAcIr3sBO+I++n+dVxoRznXgptlTOvFI5hZYJgIzAvO/pJjM5mUoPqhrUMCjQvfyJXeRGGoFQcpcH6oBgyNLnf14a6vGGeyl0oxyb4YDrSH1mlCKTIF3PrfoalD5rY/7++hXEP27SEZpWlQBDkGE9xsVN76+kFdr31KdCOHGDSS+J3e/SH2aS1DFPanhFUrvDPZg7oUcwk+OzB3Ee5EqORuWeemQ1yHlQyIxZAhQ4YMGTJkyJAhlQwL8iXKarOx9RW46qpT0qFo1Sztp7vk6Tao3rv/eueEtW2vu5vIT5atBXUJDmjdwcEd3pEsgC/AGuSZRtTzUlB7nmOgVdeCjgDBkAjC720DnxhAwTrwpBpI8DvtCoEfSdn0Pih4yQMJaZFF8I9ZZY095J5P+C+zIBVa+Xr9FNz6xVoXgxbX7XVa8VQexuxKCXDU141VD/WmNTdxEy7juq3j+loLH2AbnYu6fjdcxeyPFZJvsJ1qnyf9AH/uYi2u+lzuX/QtxxiD8TKR1Xq1bgML/ffO2kJYj48pWsCRMj28G+uCJzcpEIx9rC0BQkCe1826rQssrlxr3QJdnqtHZuBW3rXzd3UlSYDDOYYUxovAolZZf71Pt7D8HYNVJoGIpGmgk2QePVEdAo8z4Ffe7pP+XOJYDQl0OtAS7iVM+x3qSu+Ve+cSy7vGXhWcyLmUQfyWZu33bHIPTZml6t8OSFy3kwB/QMTIB77PiktIDO8jrCd6p/az2Uyn96vfrPkteBGTcRrur9rwMEF6q2liqPWQh5Vbt27ZE088YV+8eY8d4eM3H25PMo351gSTlrgqssj03nsyN2B4BoObmK+AN0pog/Ym64g/dOudMk8g61/msqnLuCh+KlMsUoaJ5L76t4N9mFHUZDRHXAx62c3otgNkJAipxwIGudTF4QDY/DouWNY3uDkT2EdKNXXofss3mcBKkOCaVTYjzzOFwss1M88yCNqrAKkIB+Bk02e0t7M9gJHE4vimhE08aT/7KYwD3d+hO0thG4cOhBmLQZEQ7V6Vk8GX0vkMlgpmwwtK0AVgW2FtSfDa3h9ZX3LskVmnl3SqN/etM06J4xYWP1lTs3J77U6ZfajMJCwNbmQQZSLGXvNNspgQHAhCUpIEmhHqxoRRnXsDSwVheAcMIYf29+4cpmKbQd4SQ1WGc0/33E4dUsx0iFvAXpnBQS647/eeSanlsuQ61b5/Pp3ZB7f/ym7evGmPP/54/i4bEIshQ4YMGTJkyJAhQxoZEIv/09JxPU8k/sfpJz3FMtqXnJbkBKzcQyRzX9zZ+y2lmdXTm0cmCq9zFf2bnLDFWeqWEj/s9dkNlKo3Bn2IeaO4sKuTKmEadM14HZKkJeHbJPCPXuSuyl5lJ2+/Ee4/nrxhMSS3b9fyBlJ3T/dLYaS1mBQEW2EKcgRm7LM0LVK+4wHLGK1dq0fn0/105177+77IZgYMSc5RP7nalSjC3cPgTfYxpQaXunmwWyeQSHMmYbUgowjnIC3HGnPOUHE3Qg3IABI4pGml8eh2WCJh9fR2ywK1aT0wzW+Zp8D72pp3cQ6tH310vn6nTVmd8WGbmW2ut5CAMD+LK339+Fz2VHisvZ30kMjSdL2M1Vu3+/dZtT5hXC/JdhI376oNyuQ6ls6lei/hWNIaQh5kwFkE7+F4CWsqPEQNWwtZdOhF8+sJXCuB/cQA0w6rAdhHJD4XsCdq7Hn74fFMPWt7guDoyYnW6n5/MMiNsuznfRaI+t2ElhCmEd7JZrwGy3EGEVV7evzNvTKzYNyeBz3zsmZ15HPZ3xeVoSBfoky7iYxm7e8BByyFlnf2XZOZGzUMtD2D6VDiAC5eGcYnuGj3uNwzl1KW6CK4s0mL5K65fqKJbYeBw9+JRWdLaim6oMEk4Zv3BdxixKGn7rCE7cGrxGxobB+j462zqGVub441KpLAcNN93MUJJlCRQ4eK4FqXcqKNJ8lcJtql5t4DUdurRJkLfa26afEHHVQDLdLYZ8YpQAj24TrrdnkbSt13RbnjPJ/riXZw3jobR1GcDlBNhsO2FIg9bBYSursD1jiDeWhtgjIaE0hUEAu1M4MpqR1SjLkWJXhxjT1/D7PlWWfM0L2bMCeEmIlCqUlmigAtqsuAQi8JcJ4E16tDVqDe0jxPFMlue9h3GV49YfEg5WLOXJDPgcCY44p+a2zQnpFljuMa3dCdueJa3pHMnbDuMblFwurxsPSvZjHWJGOC8rodwEVfiAmLz2RsU0nZh8pp59F+rLGE7bpIopeLyIBYDBkyZMiQIUOGDBlSybAgX6Ks1qsICt/DJFE/15NDp7lQDk/T3SC91vIV0l+z3quHO932XFYhSjWxmKYpp9MAA0aDx/NeVm+m6CRchZCSHmzFrOo3ELD32hfc952I4Z5kFpU08rx+J4MvmfY3CdJknd2K14EUNOVY5c4DJCi0F2ONrCQLP2prFXXX9ab8W1soZX1QvUPymWTs0cLsY7VcAOOAW/kq5hDBLRjwFpJXZIEmsJyuTmANlmwIZ7LAXqBnApRI8BZCpgAXCPzX+9zkxY29JN1oGQWyIC4GjvmYVL+4Z6i8pwPzyWALboVnQhAlwBCEolgkMy/P3rUpDXTsp3WnZViwp30MIXVb7Kgaa/AYMN1xgCFpHRe0AunAQxp4SO39Ca509YNYWrA+BRYarAMp7IdMHFVfBDYdQaHKHpBxFmdr0r40z5lksMUAb8P3ZJ3S4O3Ovh9YOOitIpwB3OMsJw06r8gGfD3nHpEFrvu7EcwJjwi/N+u279kYAKgg036inKaJD8FLMSzIQ4YMGTJkyJAhQ4ZUMizIlyjTdmvrR3QSL4FFFWaPlhQ/SdEqpVMsMKzM8pZhl7r4GwYd4ITlGeGKJUKnfVqQvC7FIrW99WrTB91Tr6e/hXUnwQ0GED+pemjN8zp3rLykx4HlOPBFqs6ZdTexgvU4PoPVEhaHLLV2hi+k9WMNTG4vo5wsDDqth2AOcbWegkqKmakYSJdRr9XVlQX1Hi2CD5q6BQ5TWO9Ii6Vyt8X6VwcQeRDVrrWYLRjdto5h7JXvKGy6W171DWWxUmBWbaHgHNu2fxP3u4I3x4MwZfUETpQcvw23J7HHxZq3ToIwJ7fWWlu2vjf7XDc6j3CNA265wL3dGI/kXnWrJCyv3r5Ve3+33UxzrZTTspA+aD1lPq6FZaW1l3SGSJ9dxyzQW+bfCZzaIeiO31FeiKkdu/4eWcXqbJUJ1VoaVKy9RI5CtVtWXHzDjHKvFlqjmemRWOP1I+249nJQx7A+VvemAbrkUk6s8JyDBz1JHWsmA/p8jMASHPZOr0o/uD5rY30tC5YPlmPHgycBdqT3S/DyvfodtLLzWyQZNXte9qxcYqtDfgaOhzRwdPdLhwf5xRdftL/1t/6Wvf/977ePfexjdnJyYu94xzvsa77ma+yP/tE/aidwd1+GPPfcc/Yrf+WvtJs3b5rZxczx4kH+otW77QjE4z15mBTJzX0H3A37yrsoB7HX8SKMAR3Zy2WYLGJhATkYNXuAL7paLDLYhiRbxMggwSQWhw4nvfpnckgZrwrce71hNch4YVV0EvCZjaXs76WqPbd3khjhUIAjeY7xDcP37/GkHhg7QbIgxoSjl4dZMwsu9WxOpUF6ySF2dSTWh/v9+3rvPPBdw3MMJNTPhOp0+jFVMoK7V0whOkBgzhxYF3rfLtzjCTQSpoBsPUgUq33BPhnP6yF+9oyjOXPz71tHsrUzW9dYVsoDD2m+9yH++cyIkPRt73DdlNv7ncpVlmNgTwKrve/oXT/E28s5BxgjFb9D62GjIHMNPQBLpGRj7iLcw6l+QkNf9i0Oza09OQgO1e+Q7tQbo+fTmX1oev+nNw/yf/7P/9m+4Au+wL75m7/Z3vKWt9j73vc++6Zv+ia7ffu2ff3Xf739+l//6+0Tn/jEpb/3677u61w5HjJkyJAhQ4YMGfJ/n7wuIRY/8zM/Y7/1t/5We+GFF+xP/sk/ad/2bd/mv/2JP/En7Mu//Mvtgx/8oH3FV3yF/fAP/7BdqQNlfh7yL//lv7T3v//9r/n51WbjblO/1rUw4WR1gLKG6TBd+Lxcmgg8q3+L9E3iVdx/2g/wEP+hPfV1UzTTOpdAKLwMubDCSZpW7MOwiJCNLAli8fvh/p1o1UEwXgw4qwrLTs6JJcHbQX7nxPLm0rPqy/oI6ihySrPsEPh51H6D9dXIB2tmnTS51W8aEx1ez6bskL4cgUhuxS2BVh6AsocGqwjLpis5dRfCSqjAwNXUQjLMzCFRDNKT69yhFmoP0kIH3lxArcjV3GZOzPjIrdtechEvEBNkHPR2q+6lwHptcZjOadsntBDTcgxICengHOYh7mnN5VcXWJf3mQcb7pp6e3/syt9Ta513tz7WrTBmO5YoztPF4l/qoj5MLOark5Yf2qEaWUD00bJde19r73P4ReLh83a1UJEMvsY21muMjwG2J3CiJ15I8n+v+kGcDEKuy87o2dJgcnqfOK+TLIjd782ik2C1AC0glPIALWsXIplYm7k/LY8hEHIN2MOBTKFm+7L2JR7rEIRn3fYHy/o+a3/mZUQdd/T0hWGw+vSHWHz1V3+1fd/3fZ+97W1vs//1v/5XUID/9//+3/aOd7zDttutfeu3fqt9wzd8w8/7nTdu3LDP+7zPs81mY2984xvtwx/+sJnZQ0EsvnjzHjtal8W+s+FSqcq4akkGHhQsRkNroEEB6bkfspz1Ke4XrpzMLcJ0s7seowL/hus4c1URkxYUTCxAPVJ7QiKy1KIp5EJ1B5/o8kMH5sBo/swF6/e3DAKp6ylTNGplja5Tba5QIIIoFS2TGBAnKizuY4/Nf9e4QoyJwC2cbQQHXJcp/KPGCe7B0tVlBHwo2BAcR5t9b2J+q3oKn+8KMw8nGg/CcIpJQcUk7BfER9dtDDjOJIFA1pepEsd5TgXCKgXXcdotd+7mqSfmv5HWOSRSKZJBC3r4yzBnsA4R9xz5oYWpPu/eHxhnOrzXYX2Cwug43ySpUmr4ABa9UdZQdmArIewlS1vNOYckN66010mnErgZ691TMnt1OwTnqiWDih1Kb3wIBpTtcz1WIq9LUlbAKiesNUF4qKvjWTKdgAe3A2mtswNEdl/9Tq9LFjt0wToGLn3goXeddu9jpWgrdwCWt93OEAv715+eEIuPfvSj9v3f//1mZvb7ft/v61qHf8Wv+BX2xV/8xWZm9r73vc/OmdzgNcif+TN/xp577jn7e3/v79ljZdMfMmTIkCFDhgwZ8n+fvO4gFj/wAz/gVtvf9Jt+U3rfl37pl9oHPvABe+GFF+xDH/rQ3nsPyX/8j//R/vE//sf2lV/5lfYVX/EV9jf/5t98bQV13DH1tRhpyZNzzIhWC0/Lfh1Wka4VDVmLUrjDARcUM/T0XK5mLZNE5oJhhjyegr1uzP7HoBfwHzfZpFDvcLoNvM+qA06gtOrBGrxYNpY+d3f+AbefhFAD/1Y8Da/ggZD1pDp5BwuiLMdKvXoKd7bar1S0Ib1vG2Hv7e9Yt9wqpTEFi1KwAtGqlY0xZvVTOb1AGsJRHHICaw6D8E5al33m5g4u7uqas88w2FBjR5ZBMSkA3uCMAhgHjPKvoTZkSNnBWhssg/y+tI7ByrN+9Frbto54+9SHp2UcoC4h89ymhXVk/MiyjtacvLRmKqBR2TT1jKzuaQpit8i2kJs1UtHXayo5lvXb+lpZt8RCondqbCaBVj7+xTyCueX9WtVb31Gzj5n0AtQGXozM0hwgSFW5KSTA1+sWxmS0MG9O+s9zznUCboPXiGth5lrP6pywgQSPkVmEDiXWTHp8gsU9YdDwdaLjWcjqLZaKkOVPY/GCrB3cgxsrbgL9vKjnZ7mhBKNiX5TQi1tf0x5AuJ3XEXtBBgldbTYzHPCCEIvXnYL8Qz/0Q/7/d77znel9v/pX/+rmmdeqIN+/f9/+8B/+w/bEE0/Y3/k7f+c1lSGZttuAB+255JiS8SBDAF3LqauZ76kV0/aZsGAEgnAuAv1JwTr631W7uQAEEvfMPQQ8VXxpP3K5cYslbrswmTtpi+e6l/+ctxunK8JJ+tTuO0M94UrEAhTwzckGsuAvl7KpjDqhPphflne0G48fShwvuOq+i/Q7dRn+jgetgp+ylOB78yAYxh7bb8vhwcvUu/S36nveujOXB8q3IlZXi/cRlsyKLSEcXLONhIlD9I3AUhFckxovTJhSSYDn8Do3Ox6+jlsojiuBWYp1W8aa1/e83eCphC8Y3JPm/rD+bTG/O/0Z5hYUR43jwAyxFNDU0eeYHwxVl/agNZfdfi9fA2SvYPv1SjIPZAwkgR2gGtuubADHTsgMlFMqxv29wuKBqaf0JCwWaxzGAlwvc+8T9sV+rX/qYEsvUnaAloR9q42DaZgkyr8ZPM/xvckamu17McZi09zfa6criPx+NLokFHPSQVIFusdSk7EHoQ6ZnsI2xINQy+ZSvyNLohL280ApF+s8ZRbIjrzuFOSPfOQjZmb22GOP2RNPPJHe99a3vtX//9//+39/ze/7y3/5L9tHP/pR+0f/6B/Zm9/85tdczpAhQ4YMGTJkyJBfGvK6UpBPT0/t+eefNzOzN73pTXvvrX//2Mc+9pre91//63+1b/3Wb7V3vetd9of+0B96TWXUsl3vbK0D6tnW1rZ2l24tObdwe6JaGCba06JH/6q85MTWc9FkrpXVkRIIAJ6RRKqGVJ9J8guzKpCGUIlEsiCWLGKZ/pKmrgjWUMS9rD88xarPaYFhIEGwvME93rQH8IsYlKPAkD6HL4PdUqaNOtobsJs0tTbSOwcYj4+lPjsCg6LqMgLM40QMEGX8KpkFXdUHOC/l9narpnXGuRKkIKhwsSABWgEXvQdckcXkQesO73mIvJ3r1iWr6+56BwPBAodA0JeC/BRYuHTI8uriOjekCg6u2SQi3fsciTIWTuY2aLGGOagdKwR4qn5eb60VSmtc2CiW4FokYND9jz86/30/Bn25h4f1p0WtQCo4sjZveMrMzLav3CxVRoCdLOmAJsxFyxKYMPyQ1cK9Da33KbjilTacqajrdjtso/U++DMJ2wMThFAClGzP/OYekFmUU48ogrjI/x0SrDSFYF1XHwpKgwA5T8nsHoK+d84DYW/fbto4vzLnxK6fZbDmlFiOBcWht6/HlkFrtb+TgXC4Tqs0k3QEr3YnGJVwwsAMBcs59+cUDiHht6y6N7JStGWr3tmY6wcArqtFdL+8rhTkVyv6nqtXr+6991pZdPncRWW73dof/IN/0Dabjf2jf/SPbLXqb8oPI//v9l+bLfuG/XL7lfbZR1/gf2eupIyVwbOgJe6jmAyiLbcXDZq5+y0hHE8TYpCq5ax1k647Uc+sC0ULAqmX6JoKbBDc5Gvc93nrSlsyY4HNA/jWg/Q37CdSXDXtTiKoGa3u2L2i7EBJk2yxCXAhNrOAlV2Ut0KRBsaBzPUeIqrl4rtf/kZ/zmUXtxgxmICpeAIM3BdwpY79m//Zlc2LildTNpSLcOjy7GfWtk+YWxzqJkAy9mcvBFxF9UPZHGOOXQ0YzhYGsH4UCqOZY8FXhBKs+0pnoAYki4UUiIS9pMHiauxoDuBAF9Y3KfGAyHCd8IPgzVvN/U2WvwOJApg4xDdMKeml7JBxTnXWPOKB2qqDWhmPi8u8tDPZ3DP4S9gXMD42jy5zzBViZnXLDrj6PVOcEYOQ4sUtjvkUQx9gCu27Mpq8cLjvsBLRrT+BvcW/N/DdYc6xjnvnNSF9BeebsEhllKleHNbeZb9ulTqzPXtgAlMI+OgMvqJ1jUaZTvySlw2aOsLsDinzQcktf/cwyF5d6CeZ0h0V6Km53zHIF+R1eF0pyPcqq8ShLHn173eRuvIi8m3f9m32oz/6o/ZX/+pftXe84x0P/XxPfsPmt9umPvW9/khChgwZMmTIkCFDhhyQ15WCXFuFHyRJBXq/PyL34gXlp37qp+wv/aW/ZJ//+Z9vf/bP/tmHq+Qe2WzNjgVVYKCVdU59RXiSYiBB4OjtlF3/vQ9ioWjXDOzv9/PkrbIZ5JDxanZdNAjSyqzPOoGezlaSTbGY0dKSRtFeWYa1EgOEkyUsvqyDt+dQpLWud6KfA8TAYxVbywkj0gN3M5IYrK9db8vtBtAgOYXmSOB7RUBNwl3sfLFbJITRuyuqxRAwou8iy+md9kDL6HC1xyPuYWkRBMEDsKp1Q6OYfMds34psFBpL+jZg4PD2AS7RpDT2QCB4BFQ/uMMFHRAsghZYr7MgG+Xf7a3ZY9ZYWmidEceyxhL7EBbjyNFd5u+mteqL03h36/bSbFkdyfOsd8lbo/GqQMfCcqE6OJTijurcWv976+fqOtg1aJMQRELfS2gA1YUMK7Q4s99qJgmMPyUjCd4kWrkBRQkwJ0FLMHYbeEfy/SIkIvF8MYhPbaI3UmtOWYPNKmiTxqV+IAOO6sZgWvBCi0tdkBu1W56yek0NHi3COoKX6rh735JkqKyDPl/ud++vxffXjCOdQugRhF5K3x+qPTQLpqOniwGf+zjj69/JFtG0m/ANwssApTrIk821BtLMb0BAGbiYcmhnjBrTLlrT98jrSkGu+Yfv37+/587W2vywvMXvfe977f79+/ad3/mddnzccaW8Vlmtc7e/WTpo6S5gJrygzLq0rnp3O/liGAdgLzK2V0YoK7sP5e6jtwvtSaAXdPttEUGf0aXR1VtfCxACfaeOC3FuT8K0sMO7CJeoFyDQVoUo/QMu1RB5r3KQ5KW3iAdGDMGQmIyGyRqSaPaAzZQAo21mwb3rt5IJ4RyHM1DybQsNGl1uEw51jTLvZZW5Jdw72Tu0WcGVzEyYaTa0PVhzwnYCrEEH36JkEntJ5cc3fb2HlIS1yF2p5CPYzP17wY1N2E7A9JXr25dfmf+u+1PrGBOeaFMv133OJRH3tdLdlCMqr12cq65MA6ftZZ6Vb3GKTdEpMTEG+bfeQ/aLuj3ctDmmqPiAxSQoZaq7xq4OaZ3DWDCSMJlK0teUTFlxl3Z9qAVdF5UuzvOlP/pK2g4QyYwWbS4DEJCMIhWKYsqUoXcCu5/uf1YpqwkML0BoDmTvJI64lxk0S77BPTTsKVSMOcaQQdef68VWgBHJfwY05hBrBWlZw+Gto5xnOPfMSLhPGX+Y3HivKwX5ypUr9uY3v9mef/55++QnP7n33vr3t7/97Rd+x3d/93fbBz7wAfu9v/f32ud8zufYiy++GO45O1sGR/378fHxXmaNIUOGDBkyZMiQIZ/+8rpSkM3MftWv+lX2/PPP26uvvmo3b95MFdKPf/zj/v/P//zPv3D54ln+nu/5Hvue7/meg/c/++yz/v/f+Bt/o33oQx9K711tNu0p38zqxBGBEPy0DVZJGSb8ehuJ34s4ne+z5vnmnZnrwZ/d/3u4D5GnhHKYRWusWxjJc8xUnXC9uyvnSsu4kQUkNb85VASBAM7NXN6pgBCc8kMwxyYhje+5pjKmi+S7e3Qz+XLJIw23as0s4Ja0C6TEbiSLxEeiELKdrCuYk7dPp/ZNa4HIUvHW7mszW9gugkXO2udrC5NDR5hauLXeSdYnCuqBNwblrRRgpDEpq/Wm+t7I6BnZWMo75c712Al4OZLAQndhA7oz12/Tf0b1lxufwXxZimJ9bx/vSfnWcanzu2iMnCAIS3VH8g6b+lbREEhni+UwJMspZTlsA1ZsdyVn1itZoAg5qoPVkrTWgTHAk5JgbUVQn48DQGzcE1UnXyIjSEhXjqBKvJNWTHqrlhdFiyvnQCj70NqiAFr2V4DMlds7QXope4MgM2Tl8TXWmuvrK0hRzbbWwagZvC54E9t9bvEcHIBiGOrW8Pkf2I9YBuGKga0HkMCMR7tXZsKIFMZBsr9nXmiyeMz1ZpB8e29uIe8HRq7Wq5nhKBmilNedgvwlX/Il9oEPfMDMzP7Lf/kv9ht/42/s3vfhD3+4eeai8o3f+I32e37P79l7zzd8wzfYj/3Yj5mZ2b//9//erz/11FP7C592jj/sJbnYJbgpLvwhCnQFehUuTBIN8qMI7zio+JJCjm4VvNOxiIgw94lbtZ8ZsDImCMeeJhhbx+yGTIGtklpHILtrRgtLoKOzpt68L8BAGN2dfMNe+5aNrs0cRugND1nO7sCkB6UfgivW4sIXNhK9C/g4bu6unEjRYFY0p1XrUOtlrBToQ1f4pLzp+wH2sWBxS/ulYFbJOzxafwfWCX5/Z+sAhaJ+d2gGsMZF0XaFs970OolL6v7wpBPChwOKktXZnxfrB93BdX30ffC3j3cdZPS9jlplLECkMkqr6rqvW1DWIjyppUxzpQ7MIt7u8u/micfn++8ColOVpXayDlKM/fuKxlHf8eq15vmgMPuhtXMoUReIrnAtt6/cu8JqZlCrcuAvEMGt1lKVT4VjV81hfTdCp6DQE2MdDjFIShMOqb0xjUPoAtOy/vUTKMBQ3sI6cQLFsmZj6hzQzCL+dXkARhdidjOsrrPcxHGeMWAEVqHAMAHowREUSVCNNowpLBuxMoF2VF1NWCb2A2aazBTLWjLIJNksmLSDh7BgZMM+V/9GWaATfYhktu89rLzuFOSv/MqvtD//5/+8TdNk/+E//IdUQZYS/cwzz9gXfdEXXbj8z/u8z7PP+7zP23tPrQj/fFJYDxkyZMiQIUOGDPn0k9X0MIjlXyD56q/+avu+7/s+e/vb324//uM/HijffvInf9I+93M/17bbrX3Lt3yL/ek//aeb3z/ykY/Ye97zHrt796597/d+r73rXe96qPd/0Rd9kf3H//gfzcwuBOi+deuWPfHEE/bFR19pm13fKlr+mP/N3LiZRTiJBo2JRnLJTnuZeyxLZpKlcMy4D5vmJKwTqbvoIU+B3Sj3XkKH3jtYBmEryTfKTvB1vTM30KEAigyCEQIQOm62YJ0k/2k2HhCAQoYJb1riBWjKTFyRacAQIBV00YckJT1vSGbFZRAS+yVjRGE5hHt0ODtTbt4wv1uLMpN0hL/5nRuuUgSA8TvC9Zx6ktj3lD0WxVBvfs9MOJZgMc8CJetnFmYcpPuGZyQdYwnTAu/vWRS9KlwjMwhGtgZndeoF5IFD3ZkzsnTniUs6+/0iEuZMssZme8nSlNbiSmtpsy4SAnMgtXBYz/l8CPbL+yFbI8J6fmBPrRoe3tH+XDFgJfttSLWc7SWHhGtyD1oT+Jqzoug5ShgmknHQY9/K6pLCefbI+XRmH5rebzdv3rTHH398772vS6Leb/mWb7Fnn33WPvaxj9k3fdM3Nb+dnp7ae9/7Xttut/aFX/iF9sf/+B8Pz/+1v/bX7KMf/aj93M/9nP25P/fnfqGqPWTIkCFDhgwZMuSXgLzuIBZmZm9729vs3/ybf2Pvfve77W/8jb9hH/nIR+wrvuIr7N69e/Zd3/Vd9t/+23+zd77znfaDP/iD3Yx7uwqrdVED+T/9p//U/18zZNTXv/RLv3R/CuxpZzpz9LO69bOWZZa1zHIcgztsf7m2YHUyruQsMDBgtGTc8Dq3VHUZ1U2vXr2gum57znf965kV8wIUc4esGLQsbK4DV0cLXecbepDJMS2HbYBECGoCLjgNNMmy/JktAU/IjLVk1gI+Tp/7EPesvp1BKhzwwj0LqxuC0Jb7+7hPWtBpmXW8cG3J8yCUFq8bcJFl7AXMpgLKCuaaVGzO4dubY7Tww7pnnjEM4xXBjG4xpQVVf5c1rcVmtlzJC2YaXghDhkTgfbOAsxBAV3tpEgypp/dNrPcuPndE/wcstmO2o5dKmGIFWzJzpAd4ycKO+eDrFueoB5aC0qvKuLpgZdvAN/IaBy5tdcO10j5m75OEWJVljgXrNTmXkVrbafCUhVEYe8QiKAtm5nmay26/l7eTfOYBL9y/7kG3yf61Oln2+EAt596Vtm5a30K8ilt1rfk7xt60XlozW/jX2fcMOk+8kqnVk57ijvcqYG7dEo6MtocsqlgPlGuA1Gt1GwIv+4EAucwLEbITJhb2Zm++ILaYHuxDOSMuKq9LiIXkxRdftG//9m+397///fbTP/3Tdnx8bJ/7uZ9rv/t3/2772q/92jTb3o/92I/Z7/ydv9Pu3bt3YYjFRVJNf/CDH+zinQWx+KLVuz1RiEsnRechsusAOcg4OTGgAhdxU41+2YfcJgfTPXMx7ETqZjnqD03qEFh1IAqYDAa9Z0K9keY5vc8DCEtQj6LAk0WxLiODxHDShkCgBEoR+pqKZPXsEmzVKl8pZETtQ0Bl5spcXtdxSTLQRWONfMj+AANqkEAhSX/dfG9yjDIgEv3hrBYILFzSOl8v9z1oy+nBBvROBQKVFMTkYGbQIZW6oEAW8bEKxoJeO4NyDgkHRs5FwD/SFO29evOAwwBCtDtyVDMFd1lTiyKqRClmZkfPvMHMIocy1xQ/8JRAOGcYCEmamJr7rN82s0Wp1BrJ4MQEGsSAV38XjQwnberxLpQOSgnTX6dBTgqUZJBfAgNYVfzSS1IWBNEhqYgntEGiIy9H8xxK+16YD9LTe9kJgwaVO2drYVKXhP2iZZLAAR1lZ0oZ9y/uxZId1rMmQQr2gIuWHfoj2TuqRjb31e1LoSNaQxIYVwqhYVt6dWbwaaIDHGLSqPfch4FYvC4tyJJnnnnGvvmbv9m++Zu/+aGe+4Iv+AL76Ec/+lDPvI7PCUOGDBkyZMiQIUN+AeV1bUH+dBEP0tu8xzZTe+ZoqNaSdI8pr2KSxpnl8SQqqa3CWarK6Hrqg/3pJsyCILpWXAZXJfCEiwbpZRCLHtWarE9bWHfSoKwscIBuJtzX448M8Au8K1htEotMRoPD683pGu54t27KCukcvN6A/e3JYACSHu2XYBqAMSyWo2KdFX0XrNdelwwO4HCHClJFy3HiMpYEax7LxvLoVhLUuak3Xar0YqgM8NuurpTve+NmU87y4B4vF1Mqy/LLYEuI96nGuWf7KpbTQ3APM1sdxzTrjWRBe3qn0kXfab0WzDzWC4hklsJgadOzpC9bY72TlfuOviHm5tRawXrvOjhHVGdYxp1qMIUmlPdV7ec6dCiA19tBWkdwkfNdIeW8mTEdu1+GJTjwnQOmFYI7vXFQSaY4v7NA3xAgnFCs+RgDJ/m+vTlQxOmdgJYcChDMgpj38kIngd0MCM32p2xfJ3yTOQb21juDhiT7eeDmPuBRv4hk0InMSr1ar+x8OrMPbv/Vp78F+dNZ9kYF0/2dsRLsi2K2OJACGXgPH5ngl32CJMTiaR75MPmRXrfTLleUnNPxvHsf88Ivgx0bh9ZbLFzztT5vr+PhGMV81HfVdbF49XvkHqsxyEn76P7xdohg3t8BKIbqgAMT+9PMbHXeKqM+luDOTyPvd61inUbgd9yhfg8TuQhyoXaJm1X9dKdV2gPBvtqQKK9mHaWDrnFGv4Mnd8FBt0ke/G8msajGufeJUiNvsfDrACA+VR4IcXgNfLM6GHUOzMvm00ICvKwkLa7XXfclPLJLf2zav81sOr/X3BtgOP69Wg5iK8mzJ0KKWHdAlBoFivAzxZ9QIQC3+MSDExOJiP89w7xW9QlKOJNFAWoR1hAojiGFsTMW5MwE5Ipf+gUGET7YY4qwPbzYdX2pILHeiVIa6rBtf/f7M3anTn3DAR+QsNQFj/UwrJf1es4DSwYF8fTIgCAgpwCZKMh/zNibpp4wSHHuXBQnTEWyC9N0fUUJyqytp09Tzcs+ZJJjapckSmskMQpmOlT6HW0ZBw9jE35dslgMGTJkyJAhQ4YMGfKLJcOCfIky7SZbn+QpIMOJOoFQZO4BZr2h9S8E4HVdcqFSzb17LQeVyKq1LcEgYrPoPpectAOX4/n+iFy6rNYM7tm29zVlAIYR3IPILJXxpmZ8wh5IVLlV6SL2djBTlE75WaAIy0lSdfaCEz0YSVZIBO+EjFroL0JmQqYqtanK4ueBYnLnMhBGFkMGmpzB6uusBq01fKNsaSXAqE3B2++7JSslA8r0YBuMNPk8kEWi9Yx4BrdeUCqDTWT18MC3XXMfLYibJ5+cH4NHxANE3XJZeQzcbd3PwugZ4ZB62dNAK3tlue7juYi75PFN6zIEU5AVWs+sCwRDdfOxWALm1I4up7SZZ5pzC2UNXcAY8TGWQEy8/krbre8obwYYJXyedBhT3CNylKz5tGoiaNUZVsh6Qe5xtNFsCcbzcar2ld99/Kvv7va9M/431lxPNd7hw/U1AYGPGUREZa2VEZHZV9G39Jj0GBVc4FWl9zHAdPS39i2meecnrKA5/r3I01zEv0kp29djWnkRtOx9rXd2vJghoFfvTAL9xCA0nSX3451syz4oUQa/yXIE0CqdebFoYd9bdrA294NRM37si8rAIF+CNIlCNK462KdDEIn094zFInH37yU5J54XiS5IxRJcLmQaSBazWnkN+OSEpSNExSZJPvL0mpt4/wVxzHvdeZ13ZpO/7r+IwRJWE8kaWMfM1aoFNZnse11UCVyn5zo2s3yzyw5SdfR/xvQACIHj/+TGzrCKmZQ27DpwHtJ7SQjryLDKruyVdmdMAvUG6oobXeNQ/L1PwQawIj4Uaa99Q+0oqT3sv1lHSefhw6EjbayBMPuOIwcTRT1eAraQ2OuEGcLnDA4bOpSQ9SQwilT1d6VbxgMdQoWPVh+KeYLUbKXskO55HyY1O7jyME3YUpKshCw1QTHuzTGunVTas/HO5DQHmHbqfqCydijJRpgHSWINUtVpXssw1JQBFposhiTUIWH+SfGzNYzpAK73UMKTQCmJtZPKb72X+BonI5rm3B68dt3OrM8vsod091WLfXWIQSNNjJUljuqU4e/Oku0sNzTP178/DAZ5QCyGDBkyZMiQIUOGDKlkQCwuWRgcUJ+OBMLfIdgqnA7lSsX1NHKXRP2wNM5FCArQRuIGbllYgVKYAAIz0jpb52Tp1gzUG5YEZ0MAfOEQh3PvFExi+GCtSTiaA2E+2DwCg0htccBv5H1dLMRzWZvHizuULBV0uem6tSf3OgEFg09WJ4qsh5sP39H7I3EbB2vZUScJgr/zpG1PsdKZAqKYBpgWZlkMC7OA5olbSUsdBLmoy+wGdFV1W1/vJBmp68zriWu35+5fPzl/x92NW009VxtZ40u7Oa4ftNdlrV3mbtuftQSXe2GGsHuJW1RDRXUTbKVYUEOCjTKemEBlrnfCRiNrrVuUlayiZS/xsh8r8I+7pX0FkqF3mnNWV9AS1TOBI+0e9K3PtER6AGSxjvo6KfYbWU3vLfOBjCkeIJlZa7W+F9iDrNWc5942hz2UuVaPNXoyCBV4QO+aKq1gZMxvbVdaa+ApW1dzbAd4jiEJVeDmBb8v4X6Z58hd7jWshUGXhC1ADiZ0AtwpsHZ0oIK+59EDpv12AquDLMGJRdW4DiLJkZmFfASZVTp8A7L2wLrLchnEXP9GLynZJ0LOhAChaL+VghgZMN/soYk3OUBCEus0Objn+y5uFx4Qi0uQXqKQrmvgwGSOt/exS5lbxfGmPfdJFg1aJMMPZS4Oumz2tg2Rt6SSOZTdL3XBHKJ/szhxGCGfRTdn7ewdPprb6/7KDjQHqHaypBxhwQVDQ8NicYFEHmZxcyc2+RChfDhodOoTYBx06x5gVoiJUpD8oyMplR7rn0ETkAjGFSZkUmw2vUP0VRntEbGmdH9foM4ZHCeycOCwfYhii8+jLmYWsPNZohO/n/M0w+4yeQtYI+qyQn0zGkLCdzLoCWENbH9VPyqrWaxAODBn9HVkMynStDVxIYc1Qu/K5lJC85ayBNieuXVBKrIudVzdhn142ASLGjK5ZjjZrK4XXC/rZ8M4dcUPB8Zs7eV+lzCKNPdkUJBD+1ayvx+C1jS/Zfvz0qD+9UTCt+i0JYWCZJjiBGJS3/8wiUIGxGLIkCFDhgwZMmTIkEoGxOISZX1yHCwNLcyBnJ37T695yum+eyScYDuWnMwS6tyMh1JLe0R+cVUDNuKumytLFHw4UZPNghaiC1sUrft7U3YIGJA7E9Z2WCAYkBDSpSYn9nWVOOKipO3ra3DRJsIgFqb/rVMQy53PvnfXG6P0ryHgApCSwESR8CmbmelMv/BYIyDMoSDlWQVa8Vvpk2kcixcU1j0P6qqeXQPGwqCehVGgPCf2B7mgae0jvEPQA+tIZo1UXyfzgIFjGavDSu+uraTqi6QvCedguzzhSQap4TpQu1fdEiQIUcsE4vVWHQB/CQwK6icktSETRVtRWB2ZopYsJuBi9rWTsK5JAWNIrGG2jE9YoQMXdzIO0jTBejfSoDdBekwMAxYPBSfuwC3u33Fq1z2H6LjHqA0YbSRZ+wL0C/A9w34XrN1T6+VgOvC53a0HwOuvezg+yZQBKEKoiyB0nXYvewOZjlbNuxlA51CSA5ZXm1pYzGsSelUxbx2OiCDE6HFY5nfgSk50BddLyPKRWdy9762pY6/9gmdkQp0gTbW9Xs1j/2JG7qEgX6bsTk/t6JFisu/RP2UMCcGtccDFxoUkce00yjkVh7J47c6gjGtRSxRjL4fURFgsagVTUciOewZeMLqey+IOWp2AaWJ2v04kc3DBYAENbh4tflAEgysTOd6Z5c7MIkwFSrRj604TknPWmYlgVJdSxybaO1OME8jEUkfAH6gYa+Nw3OQenGDinnfMqZQyp16609xHbDL72hWLelxonK523XtJtbVAKYCl37XK/GoNhXPPRpq1m9naAn5QdU4YI5YNumXLMDNbP9pmBAsYbClQyiz5ys35b0FsCi46HCC40UB5revpbBSqt/ddwfmKGUPKmJfZH4tLtkL0RyXh+0oZU59yvDtOtMUJ71i2FOMyn4UbFrWgWVQqArQow4eeYD5rHmB9DGwR1VjzPiQeHfR2gZ7R4xU0tx409weGlD3QOT/AeBZKUEvqEfUHWFm8n1BugDP1KLxoXEKmR8LQ/DuSKpF7hugcuUeZBQrMoIwKO5ytsWSByIwNPfiAM9xAr0j2jPDdScNK2GbCUNGUzaQbB1gtYmyUXl3GKBJ+9ZTaDFu86CWgXdWyB5hTRh17SAbEYsiQIUOGDBkyZMiQSkaQ3iWI8yBv3mObqTXKd3mQk2CsLBgvJA7JOB8ZuNFlc0h+2wOUb9qRWR51X8eNdDBAANaAwEqRvDt1WTUV7PdpSGebSBYMkQUY9KzXwXqfBdYQipFwVvLU3wusCN4GBinBopZBTDhG3XMAzs5GEstJZgG27LoErAC0djdpzckhy4A3WncZOMi/vRH9gKwQYGYWU2FnZcHq5ZIF8YLTuZdqO4NnhKQt7gYudUn6I/CIAibSLSPrq6yPkzGYBsh2ghND+8EgkQU5haBLyQG4Vy20Qocg0iQd7lLphLv2UABl7x4VyYRGe4KwzCzls8+8nr0ys4RQhziK/b4suK/iGndvYRbAfiiw2/RzH9YYrLf7AuayYHlABZx9J0kwkgab7wsU1KMdCAEuNNdTbuKMk79Tj0OBc3x3+P4H5sFFgs0P5YDYN24HD/KQIUOGDBkyZMiQIa9RBgb5EmXabiNF16bKKLfrW0gkMTtOgkUm9g2yn4oMWB635ranQmKVQ/pTvWvdPxXX1oJwei3vJjVPsGokJ+6s/3oW6IwP0k+aDBABRjkNJPG+LXVB8OL8XwUjFDynLF/EGgJLHfCBO1hz3Apa/pUlssbDulWutFMYNOLewJ9qsCSsgE2fGOSl8VLxpC5WHuG/CjZaFl+38sFinNB+hfTPJxj/tWXVMdRTU1aK90t4j6P1rtwvC7rwtAWb2pRN0XBFmmrvJzVDXL3i3hU2tfTjkoq4E9SpADEGW5HWTGNF/yoFsYL8Ah+6xkHL5dr1vOjeE8UnIDPeSTu3fBxPsPoIc32l9JNiEcTVXOP8hXNUBj2n32uDFf1+WPcZEOjfsNy3RuBkveYsfYU4DAmDCRmb5etbG3zKtNbehqMYU5JZ/jNrHgPpeD2jpGus17QAIvCRVjym8yZ22b+B5gm9FnU1GJS3atflQxSZwWrpdH8IpC3rpWJS6rJdJnrZVJV+cF5Y190rhxwCbvXtUOtBDgbE8Xl6BpBSnFjepv7UV5JAuOWlbZm0ECvAf58VPHrTL+b5pSX8IpblngwF+TKlVo467n8qndm9KzIm6L4s9XJIPKFBH+EdGtQKzjMqwE6w36b53GoDSlwx+1xcVHAZBRtSRsOFIyV3y4hsyD5+WElQxj1RRhvUFALpsPBww+x9mxDgePt2c33pQ0Tzh6Qlbd96+5hgop78dEFebRUnXzC0EXjZjzTt6/IcV+JKS82gwdSxUox3CcMC0lmHlMpUXtVEKE51PRalAnAHphrm+JCiBHe5JyBRQFIv3TMYIxSM54qjFGPNEefY3TbtZIIVfavNE7M7UIFi9bxaSylFEhLVl+wMIa2txiravQRgtQGEzSHG69FCXtTHekbJRagAeh14cFAdlcxDAYg1D/Jxy0bj7ZBxAcF7ZGXw9QoHCtVF44l935QtBaf0PRkmmEiCwYw+H1SuxoH6rbyzx4Ps65KWXY1fHWQJrZC7/9GSlKWMsZ3WpiSpRT3/lwBQHBrOFYRc6q3Dl3/HTb8/tCchQZK/rxqrSqa0sHMAhoEDvPcHg1etVYy9DhiTIRFUXQYD5JKg+TXXNyRvCbzQHaiBt4f7F5Ruvy+BVGQMIjoIaG9WP5vV69B+uAbXccL1MnhjBq0pDUM9wfRBpTswa7Qy7SZ7GFTxgFgMGTJkyJAhQ4YMGVLJCNK7BPEgvaOvtI1OWRcIkHNIQJKaMc2CAwtkyFTUo5gDDyItwYEm5lBAQRIE4ZbI6uSdgfndkgzKuIxaKA1aQwBRa2FCqtHgJkOQXeKiCwEoovQplgnnSe5RjjGddxJIlQUpBSsogzV78Bd3HcKSnLg3swxktKQ5ZAWBWXXg1A7ehmAhVtmk80uoq9xC5+mA91D24Pu4e9/HhmjMZBnuQxHceg0u28US16ZNNqus6AlnsFs5rreW5GCJTIIUJSFY0WzxQpD6EEFrgbaPlsYku59fBydxfU/4joGSSvSExSJMyIzGN+5zzwOyHZqZe7zcS6E+5drCdiKNebBqe4rbvgfCzEIfZ4Gs/k00FjV31L6Q7lzWMtS54lhnPf066e7oWteck3U3CcbjvG9+S+AXqcWbdI2YzyEocQ+dWgZLyyAEvkdg/AcI2Vnfktx19180YBspmWmNJh1gRhNoZhF+kWQ6PRSEv5dKrr699nyj3gHmwutZIPehYNXOu9M6kNI22WN6JALn05l98PwHLhSkNyAWlyjTdhs+eu9jL2wU/esHFUOfoK3yQwWrxuKSL7D6oXmGTBkumoBel/5iwEWifjb9+7x11S3JSNrJG9xj/q5yO9pkZsHF6LcQ1pEscsEVp/vOtRi0CRYa5RyKUohCp/JKjuWjVnEI3M3qR+JMO9cEIZng3vTvZxBFYMulrO+vBVkKpN5T8yAjfW3gogXHsv8NRcHHAd3kxCrX7UZq4N0DwpHgQnZOTsBZyCyhb6Dr4KBu3kGGBD8oQClnogwp0tisA59uJ8U2x+WhjWJyvlgw5PDwJlypQy/AEmJmTK4SDh0SzEFvX8D5lrqQeYM80PU7gPddeL+RbEN1INRC8AiyeDB9dr2m4uCrWINF0V839Q8KApUYYLI5vpukHzjwBraOzM2dYVEhVIxXvbVFVdHfpGR2nmPsKQEKmHPwNvdZNf6SNPMphEBjCAaQAG8AFLGBCmbxKGHf6iurad9jz70Qe0USv0PjW562u9yXKNq10KgWmCWI985iMQ7goxcluGLIwbjNWGUIjUn7Ydq1+sEBGRCLIUOGDBkyZMiQIUMqGRbkS5YlCC6x2FbCKFamJmammZCZRiwJPBUzmMviCYtCtgJGB/t9nk4VQWzLDWnZtKhlQYvMvJfxJQY3W+90idP8+ioCxOhiK89u5ILlaTgJ1lvcZBUn77U2ECbjg0wtBmrnCdIAJ5HodQpeWllTFpIkuIVMGbrPrX3qz547nZmzBGsAPCFEcSOIRd8quPAfV78CJmK2QD98nF5v7vV2utu7WEUmMScoQx7gAUSiAbIxX2uj+b3PVD+NNWTScynPbZ5+qtyXpAkGdMPMbKXgpVduzH9r/Gp+eia9PjNGgOQQaqL7OmmudY8HbJZgPDJjMHud2Cl8HDDgs9wvppCutR6wlBAgibVisUQh6JDpwAGhWtIlV+vhpvU++bhWRsTr15q6EEpCnl/PmJfwRzdZ3VRWeacHYZb5uNrBSg3rbrBWF/H+YGbBat1IU2J75kQGG5frWK8XmF8LewtwiI6QY57rdcgx4GwdpS4qBxztwcpZZXlcJRZj1oHwlaWAFh7hcLcy3jMGKbPIdEFrNT260cu6bcvmnpNkBzTL++ZgDgHAHpb7k+e83Afh2rLGt/tZZjmm1MF7D4MqHgryJcpqvTpMPzLfOP+jPYmKMfGvdG+rGER2MiK1vp8uo/BMEvXp73JX3Vz2tkQ9U7npDtAEz0uFSO32aOaEtUPCiPSQTrkqk66kjBhfwtSzhA0EChstQIrEN7hEreMWApbLFXymuS7lZHVeX+tsKMD9BSyq+g5pn30sCkKCPpXb2/sBWNX5JijnwvsyxSzx4aqD+g0YZh+DUDiadtN9h3TNomsLlGmrvnswYNjIcnG9woWWejl8AfRWBnc94Sq+6N+4Nf+NA4a/h8qPLWPEFUZiR6Xo6rCy5obYulwDzj1hnpjbU/qUfSKFERCJ3W25c9tDyQ7Yc80lx7Tuw8UetYcPn5/8Bhp7Ul5VZ6Ty1RiU0h7GUfVMUDKlyEJx9HFB3KT6FNf1DXxOdsZaiGMgNpkQEc3bJDmNM43sSeoRMKa+1iBRDHDPZOvxdf5EkDEchHl4sWr9xnoV5m3GFMXU8IQOck2puilSZM4i5WsrBh2nrevjgP0wQ2jCtr2vXsu8nVR0qeDr/kCHB6U2YWPqGpmoNLN+GXSCjEkHFO0eVjtAPgX9I0Y8qYsfBKp+Wk275rvukwGxGDJkyJAhQ4YMGTKkkmFBvkxZraPLo+YqzeAXtOKEILv2pJmmGuapuWJscF5jRd3rNOucpW3ZCzSkH2CgYCY/DdN6W58mYTG3xIJIS6q3r5zcV4hYpsV9C0urmS0BIuhzv5dWCgbM6fshUnuie9itu4vlOQbIWCOE37AP/fvB4kirfWCkqOrLskNq3XJf+I4qmyd1uqdkRaNLtiqDQXYe6KQ6yp2NZA9MMECLsrNaVFb7qVMPs+pbFNiSWwZVt+PWzauy5d53Dl71tfMBd1zuTJSh73LUWqnXTz7R1lkWRgbO0Op5p7W0mllIwuGwBOfKbgPnJs1PwSOeecP8qhdfbvtD92t8FHhLbcV13l5YTn1uPPv0/PfLN+b7NIdkFRMTzNNzHWT99v7TmtVJyEGeW0JLvK8LBMVhKywLgXGbp9pvE5glbLFG+ljy8d7CUUIQ4hWm/e6zVniiHcGY6kBYeIJ8/dY38DIw15iEJVlTXTxRTIelhl411U1QCnnA6K0hmw15sjVXOxALXxMYZJlABtJ1j6no6UEKrn1r57qZrcWNfXP2+GTWWvL4B4+h4GCAXmhM12V6e8ueQuiF799HbR2y+2PwfQzEU84E/w3sHN4fSOKRcWqrDu6FBuyj54UPLFywRi/79bp73et8et8mBIXuk0HzdgkimrcvWr3bjlYtcX1XEpLr5ed+BGqqQBJvhXKaayQaz9wlh+oeLh/OUHMoB314B39PsE/h4LBngjFTXngnysw3jracve/m97kg5U7momNE77qm3IKQrD7QQiW0f5SM9q4LrfEsfu2hIyzOwLcGjKbqLgUYSxUzkDX1J2XUHpfx/BzGr9O7gVaJDBp1ciDCV8hiAtxoqD+j34n7Tu5v6scDqivtOlQUZRxMCmQ/WDIqqh91v8ZsFd0vPC/w6YEaz8d/khgAjBR0i1P52/suwBlCUhocPkJ7ySQhqXD+QblWnTLXcrZGJvR3ZBjqSkLn6H0oeBMURMZOBBYT9lsN50kMFKGdjmdvKSQDxCphXNGaVcNIQsxLyAjb3zN4/RB9aY8yNXwHufuZEIRjhnE8yR6c7s09SSAF3EvIEJGxU6X9tu8dXANJc8f2eNF9itleApLAjpX02VLVvjpb98v5dGYfmt5/IZq3AbEYMmTIkCFDhgwZMqSSAbG4RFmfHJvJet85mR06UcXTUJ/XeHGjtJbJ1EVf1ePgqRV1pQROxCRStWtxSJ5h8Flwl0DSxCJwvZt1TqCqf3Iy9TSphC2AkzUwL/B9ZsGSulhc0CCwUoRkHnK9bdrgHdmjlv6sXEcTrMv+vVsrR5rMIzCFtIkT3D2suglyYLYEEHnQ0dWmTpQl5WwbMOqWYyRUcEvzUkDVblmUWtYCwjX8mySBcAwwcoskIvFri+I+d7yZNRy6zbvvtKwHK6Tcdku0rjPJidlihSR7Bfvcvzf4u2UFZkIRpsfufEMGlUXPhyyG+G7bdrwvMJCyZsJi7HW7H9dUpu12S7DPrSJgr+BYDZZmjQu3KFeWNn4HfQP1GVNJ09pNWA+YKARlYABZXY+l3mXNJ1sHx7VbnLEeqmww0Bjbb2YrMCT4GsDkOtjXdoCkePAlPGABekjvTl1fQOOiZ8sLbepKizrZfhgwWpexBH63bEyZBJYp7sHJ2tt4iJLkWM4QkljjHdaZJCO7iAc581BHi3J5ZwjcD0X26+Lv6zBhATqi9vj6fkVQScBOuSatpocK0hsK8iXKdH5u6+OiYJGA3MxCYo+E1iXigGehmyRMliSne12f6M5vB9DuwQEXjLvLZywicUQ2EVfdce/QpbKPAcMiLtaVVEW1l41oh0xr9TNelhRgYRbpYj5tNylnXnAYQFTCzaJSa1ZtJKqL05q1dXBXpLOVtLjCJZkFDiHqP+FlC6bVzGwrvOe63bSFHfXroOYK0dDChwpvJwovLe6qc42L1W8o2/HenuAEGwQj8OXGJ33htRlP6rjnjrtfm7RjiIWZ3fRdqMsCqsUeblHV0Wmk2oNCXbbXx8uC0qXN2VqRgi0s7u6ll5v2h0x7nQQKHNecMxy/QfkC00CAGKiuFd3ZCoeHkFHwqFVKpCAJk7na4LByfq+5X4okx56ZBQq4VRmnU8FST9sWH+3fe2oVQc5nb7fGUZlbu5uvLn1AeJXGHqjhAvsQDgSejZHrI5WemlpPBz7FQnhSDlVuaspW34XxTkhKOaSxr9dVFr/dmYwErTGBcBWO0zXiN8Laq30Aa1WNxWWiEO1rgWJN3QBmCB6uAyQJf6+rg38om3uL9gzh3H3PbHG9ZCsKxpiesuq0q208S4BG6XYedNnXoA7kgaDBIHP8ylBT6iKM8pprKlioCDliEpDNoyW+oYLRLHtdS0MbjE1Q9Kl/ZUr6IRkQiyFDhgwZMmTIkCFDKhlBepcgTZBesRr2APu0+GbBeqkbRAIu4xBg1rHEhiAryKHgPT2XJUDZlx6T916UD/hQYo2D7qLq2sFARp7E0edZMhcGJnTbSU7i4CbDuPCqX3C8dIL8GDATvAu6j3XwVMx9UvwQBa776rrLckpLOAOKWBemVOaYRTrhLmSDZV80WA8BYlm6X283EkuYVX0uiykgF0wQEZ6DxZm/e3/qGzQR9m2QVYDI6N0MqNthbdE7E1YPt37W1kwGrDId9QW3GH+edaY1qMOTmgUEOmwHyWpqr0P97lQYzGcWk/CwTuScBSuPs2DAQ+bCYLfOu12yNNacp6yjP36xtegikgYVIoDQBWtI1zuzVHT+7cDeELyOyV6ZSXe/TILKQhUxBi+aBnp5eWdOZgFyWf2T7xjgmgd+7/22t56dOncq19YR/dXlQU7uPSS9vn6YIL0BsbhEWW027lZ/mEx6AYOcDLxlkJT3HbWbWJoNqFMPV0qB52V2o5BZD3VZqG32LKAHIotD3vviuonZ7Po4JKfHEezj1uIG9bKp8PYywFndT8LPls3PF3WR4wsO0VLa1C48rzej85PMf2E8cPEiHlbjQN+9jrhmAgHgvamEBly3xF1z7WVGpK9rGijg+1zh0WInt59j1co7PQkJxoVjT3E4Uds6iUJCljpCY3QfkloEjCbwjwE3XMN53LV41Jbth87+IUTt15g0JI5YIBZXm/b3EsOswJRhwIfa3dJ+MWS4AiEsagsL8LYgA1+DC9U9qAuV0gA5kOKsuhBHrOf0LkBummfQV6TvksidvRFkSBAi0cDdRbIXZtCrFWtdw8EnJDgpY2a1Q8wI1zdk5mMWvzpTprdXFIlMUsE5Vx4LCWLIdgK4zLIeVH2esFUQax2w5eeYMw6dkhEDh9OOgpXF23jdnEkGSXjW+o599orM6NKswYQ+MtseYw5A+brAGA+wXnhbIlQwUKh53QDPC4QbraKYvhuKeP0usjCFbLoH8MxMZJbhhHsHh0NGNkl2cKq/2UgUMmTIkCFDhgwZMmTIa5RhQb5MmXY2TfmZIz31ZicpuOiyUyFd1/vcI25ZQ5KJkMSEoP4kgDBLG4yKWrm5aZdHa5dAP7dCC2ifBrv0o+VlOd7IElc9w0CpHRKFMLiJzxuDWxg9PXU4HBER7ad2/Y5obUavEx7i1i6d3GUNlTWhZg6hhRhBh15HfTdZjjhG2W9IHNILEgnuWUENFBlPC6P4XxnVLsgBgoDcvqAAqicWN5kHI+k7MHiJ1kxZ3mRxo8VY93miEEBNaguM+koBQ596oX0n01QrAEhEAWonA4lOW87aXqrlkFJc9btz3tTJIRZM5vHGZ0qdX2zbhQA7/4aV9XoirzFZHZimmnPorLXW7jxZA8bY/dbSalaP67ZPp9sI6FX7N/PfnO+7V240dfPgtpIEYvl21fzRd9V3vNMmZQlWXHgCPCizWK93r95u61wFxtXPm1WWYOwZPp/JqKLvXZ4Pe5GKBhMF1w8zi+nGyRlPzm1YXDl+60A4s2ot6cDDQpprtxC3yVjcQ0qvBCTj8u3eG3jd2zWRZbpnszDGLEGpsFIzGHPV8ZSAtcITfyBQPbOwk+2CvNnMreCsENU1rxfSPXsdE/hDSPdMLxXHT8/rju9ziEua724syoegIZUMC/KQIUOGDBkyZMiQIZUMC/JlC04yNVYoUkolqRUdewU6L/IoikZs25bbxTLrpMj0kLLaJEEqFw2gC1bxDgez08FcncuSxTfFQW9oOS5lMyhGdTyJJ3rHweJe4jhDgBUDovguWVRIl1UFJNE6EU7c4CCWJT21CogGR5YI4Z6Vgri2zMByEizmsl6d4MQtPHBCRZQFFHUDp/QbMMQ+R8BNrPZ5muCQDU0Wh/KNELxmZguWElZLD0bT+NVclJUOtF5LoCECzxiAV1m/hJV1mi+1T/RQ+N7kRXbrtcaeLJBHrdcn5W62yhrnQXnIjKc+LfRobgku2NvFqg3MI9Jce93MFo8AKfC0XtHiSKwmMifS8hzaXa0Hi9Vt1b6r/O1eGdEYEhePwDC39uobCCfv5VbWa31ftMdTJxMX7LECrTdup5gJtZvvVLnXK4syMPPTFl4aYeiRpZKZ9bxsWjHpIepYzmmF9Hrr3hB8WtZOWfOdnrNdWyS9wGJ6FYXjl9dB39X3TAVCkpKuSEjVnM1NM+c9dk9ttp6v2z1D960ZF8Hy4a21miYUeGbFBIX+KBLo65gHAHE/SzxL1AdCuu4kVsqt1MRHk5oNuQh2sCTXc2zRM6z5LdVDsuC9h7Aa1zIU5EuWwNBwWk3IBCohmbh5kznCy27B8uQ03hepSwB84NRN0lxmAy9VoM/j5p0p0+SB9DLO2oXFoSOM1EfwQ/MN6EKzxP0ztQqUT9aEeULKrCupWrhq1hJCZOCW93djce5Gb1vVbw5VKT+Ig7heWFxZgbs+41iVbLCgYvPnIunfuXKLRR7MhL8Z7aQCrQ1iggue8InGFUlOZV2XYrBtFSgGo2VMEyG1uDbzqn9C+l4PvmoVo1B/BdjwnZgnE5T3Ot0z2TccvnLcHvjIe+tlOwd1nxFngmJRH0pWx1PTHj/YIIBOCqMfsjw5CRItqN8egGkCh7e6XlQMXXEqEAm/X+/kmHQu+vPmHa5Qdw4lDnEi48vd9roHoR1I62wb8AdrLqqcekzrnUzTnKTQXiAIbXIlMjMs6+AeyAHWr3U4jLbB5BIfSzowemAl6s5AsXo95/5F9z8C/NTnWxxWgsHIOejbNOG1KBBZPNABSsb1HsHWwXBw1L6TPMh1HWQc8H2W3MKo67JfHUgEkoyDVWc95zPsIxm+gnLO9vjeAlhEhxEqJo1J6olgvIdhXdknA2IxZMiQIUOGDBkyZEglw4J8ibLabMzIaLaJbhIG0fEEHihKGDCX8aiSVqV2g4IabEcrrKw4zCR0AuvsITdxkbqOTPMbLOGweMcAA1DKSZROGC7LkIrYbMnaBsspg1iywMdoDVFlS39cgTvdqj7yTHm6t3wXUqolVnoG2HlWu2IdkyV581SVSe+Vm/N/wIfL9NyRHgu2CGU5evqp+ecC1XC3YSfltgcXMeCN7ntCKHw84DvjGB94UuvgRFk6BbVAVrvgOpZVFxnTrARM0XLs5fBboh7NPaUOSwBZsWZpnJK+jHRXor2jS7+2tLBs8v2SWgxQBBfwCgeLMtI/1/eun3y8X3bpc7m5FTBoypSmtaVY+Zkuef3YDL1R2uPakrrQ7t1r2idxF7vq5umbd839Ye09KpYojYsr0YLs6w3c9A4ZUpa/qbUAhyCtLJhPVl/dV3NTXy2/6Xsn7vs1stK5VZrzXu5xrNULtWYFoVKfPIKgU8E4JlgS1U+C6WiOwpvlf8ul70FtVYNgVc8oBMnXviZF4oPo+ZrLbf+sYR+7e9FTV//tKZJhCQ37FzmqfSvOee0Jc/BXd4Kkm3rTAyqPIv7eyytMujqVQes9MsKGLH3uQS86hVPhJuXW9cacSSEznmnxrNu+6fzMpmlPWyFDQf4/LPWHzeAMAdvDMjIXDSAJHAz14OGECWwUdG/BhR6wynCjc1Fosdf9KFjhI901I8VJk90X8fldIaUlXPTLIlm7f8HNWRRAYmnThCEoxxcWpnqVYlwvnlx0tBcR/uBwDmvqsDLhIVu8bJPW2ZaNyZVi6zBiPKDLHSwVScppV7zutG7RkKr5kSrKnRumFkqlr1W9keY3pFLWfVSIFbmud9b9rAPBMdL5SsFh+mcwCjiOWwoB+HD9QKW5VWOvs5TCPg/vt+3xMakx1SoQVBS8n47jpjaJbcGhBi38xLHkSvsthVFwAPAGh7rpcKMDRc1aIsUHivEENgofk4A9+CFL7dGBQtCqgtF1HuhKUdT3Wj/1ZFuHUsb68UfbMkrfS+n2cX2EeaG6eTxA6fsaJysYB1gZNC63pZ0er6CDjXCyHB/E8jK5SXWYcSy4FHyM29VJ6TukR3YGnFeFe277OqQkF2yiWmtD2nUc9ALmXONB69YGCqZDjVq8c5fNAAl6prIn+OEDKZaprAlq4coqoCQ0/NQpmCObEuI3oJQtuN62CVlMTWCcqHUHcP4TgxuMStjXHBqYlBPhIlX9HOrZslEEeA7v13fMdARCK4BVniXReXQIBZaaZQTD3mYz8yBfUEceEIshQ4YMGTJkyJAhQyoZFuRLlN2DB7Y5fqS51qT/hYU35TXWs7I4uhXsavN8CJBjoEVdFqNXt+IHLu8GfGNXMsS5ywIg+GBhLpaJVS8LTpJCeE3XGoPYZDGmC9PTIgPC0OHs3JF7Ehbz4B6lRRnuI7fq9bhorf2m66ffMN/70svtPRwHcmMyeh0wD+d5Lrypdg/ZASvrFgM9ewwAzTuLdUcZxmT9moqlyd37zjBRvnu5vw7iWtpVopRltZSVWpzCcMEGFgMGLbp1rL0uHtm5XgqyarNzuSUosYhm1u51gZbsbtxsyjVAc+p6u9tezBAqm/V2HvAylnS/LIvwLC1sJ3CXW2VVletZ9UPQoVvMTx80/eX9Ade1zxdBamR5fXXxBiweA60VSK0rnt/Shw4RevlG0x8rQYk8yA2wELdeL32+fubp+ZqYIGD5390p4xRcwyuk2CYDBz0L3r+1Z6m0c/3EY829XrdivfY+1Rqp7/7SK+27kHnT54vGXmVZ8zX1PuaGvAv0ygiekmSxJItDsKR3uMYDPE3jnIwn6xbWEVg/WA6t4vUe2kl1blZbI1tvKr1UGZNEBkELjAxzg/rPHEhFPQGC4L/LGuxZ7iKUMsvw556yEMhvbRnlncoR4NbdjE+49gCjPVlmvdVJO46ZMdHr3mGbauq8q7xTiQU8eM8B03BLMuvcIQ/YJ6tpmqJGM+Sh5NatW/bEE0/YF63ebccb0K1cIJoyxRYzGQeVtgORyI2LpkeY3asL3SFkeQD+KrjBekwVWBACK0dG/o13BFL3pXFteZ36hBSjWJyIRcugF5EVo/zZYYUIriRd77qS9ojelaTbDFHDSX2aOnj0vnBfgLUkKVkX+jil3i3ftFrs/FDljBhgmwDGdvnuYCUBuwlxxd3+lTuXTApMPRyi+lGX7Ns5hAjlmoUxEmA6wGA2qYOrsnqwlbnOoDKr3612oR28nvUP8dzZ5kYF1Gz5bhRXKjUOyKThTBtID6wDkp6nMttRHIKiL2VaY0rvIGxBZRIPjzTS3e/N+gBzHmBrwMUGRQJ48AB3qL8FGFCy756xcuwASQh1ZgKOej3nukU2FsY5qP1Ya8K+tqePXRJ2mYDfVp9xDmZKK6S3J4e1Idmf0702qSv3bxql9tUzjUfS3wegg0GZ76SaDu+m7pAxZKCsrL2UHrSGfU9cN6/vS752Pp3Zh6b3282bN+3xx5eDX08GxGLIkCFDhgwZMmTIkEoGxOISZX1yHMDfzYnughZfnkTXx6vu/YH9wbk8W47Eph6wDIfguwSmkaW/zqxmPReNv5OJQej+YODIWWtxUH8QYtKzbqXiljVEccvKQZcTglZ03w4BNo11hWOB7Br8jkig4ZYWt0SB65Zu0do64JZgBJ8kfRMC5JJU0oFPmFYPsxAYGaw+gDnQRe99DHcooQaLG/1uvEdJFWC1dFG/wP3r12WJJNcnYQB1dD/YGNZon9dRrAX8Fs6gADe/XM1rcPLeqQOISj3A2hFSLSO98TKeT5q6McBOwYj+fG3d9uQaD7rvcnGITMdtbdH6uWLgnK+P1bqn71WziZg5BGbtwTvJmqBgPkFHfD7DcgwXft0Owcp24PdN+1TcyhrfsnaLcUP955ZWjEmrIEAhjbe1dSh/Bg5teo7ciq11kIF44KquROwzTN6xulYYRZLkK+YBla3HgHCQeqz5mg+GBI2dmPiDay7geGBD2Odh9bK2Zfx5AC/gVr4X6H5UAVZOjo99HkYG5V3Ys0tLMXQNF3pKe/cwOPEA339sRGGQYYDdHiaN7LcIW+l7s+oU2uvJzProjiBDQb5E2T04s6MrBTfmGNDoJuFHzKJYmRCCWc1ipr32PZsai4uFRM8SD5xl9QsuZ8d23m+e7zFuUNFdsrjBlaSIYzAwpAeHBLtXL+bEPQu/62VjMnvdtHBq09O3Ubvce9rSfbXR3i0u1MvOFAgpo9xogbvz8aIsfswKZ2bMpLUkkEB0c1nEPdOeFEBhjZW9zvF2wDATL1jXB4q+/65vgmx0/reUW8E4/NBWFsOjMga1gVaKgx/GFK1eaNuk0BIiQeXLFSUpwIAo8Bs2Ue6Ebegb+BwrfUvmBCkhpRyvg2ONyzgQTaTmcr35OwNAWz/joUPfV3VU354A5gDKxIyibP6xzEf1dcEDL/AGwHIkpJTD4dS/FTDdXXo7KV+rFnIxiXdT7v+CSTbpg+g34mn9PYL9gBVivohxCoXW1xqxc+g7Ct+vfhPtndOotRj1+kC0cWx8YS8hfEOHFX3v2wm1otZxYcz9AFjqrINHnSGUWee0djIRDPqKdHYhSylw075mddbUoJSFvbH8TGMC8bOn7WGcjFLN2lLudSUdB3Xd60lJACUJBhPV+S72uY7Bw8ej8sAgO1+AQh61+1GahIsHhF6isISGNdC3aX8O8U7b7n07QJBoOGvqASMSjYHLutSHqyp+a3d633bTxXHIA2IxZMiQIUOGDBkyZEglI0jvEkRBel+8eY9tJrnB+66P+dL+dIgXtuYmwPoAPbAY/SnJAuL4zixAYYeTuZfbCW7I2p25qAIQn5alHk9mIhkh+qFAivA3YRwIauu5gtJgvOydkkPvXtHTUPU5gi3DOMxSadNySMt6J4AkEy+TbCWEczgriYK6WqveoYDKRhjgJZE1N4WYtMFdtGY63CWJyO7VIXg2ZBk7NLay32mhrl9J2AUDJBnEJ2uNLGZedhvsRtiIIXitqQMhJRpLspSz75lIBhynizW05fAOcBmzaI2WkMXDAz4RKMgyBePYtXO08aBMXMf6ac49uNSZRhCkBa5qLxewn9qyFoJs+T3UD9vWgu5rB4NtsRaFAOAGOoZgK1jx0pTwhKupbzG3AmtRPeewH7lwnTuwvvWCt+bH9wSEkyuZqZNTTuG+BTUNgO+kcg7Bd2CRWn7ol5EmE6NluRecfCj4jum/D+zPIUV1ZgXf066eXmVmEabZqcP5dGYf3P6rCwXpDYjFZcpqbUvao+I2qN39cC0tm1Or6IYJJfdeh/TarBpYiaJsFiniDmF6mEiDg9YXsytX2+s9/JRP1v7EWjKpgWidSUzUFrrmEkWsFNKtf0YovyL0RN+PmzyUVUZPm1lQ6Jzexl2u/esBOhIOKS2DhLDJzVLgGyLaLSYFue/dvUXqnpZKT8vRktXvfnN/jRN0tx6UMl8Wg5LZKsa+2XOcb1ssNjGLc9miYcPCyIxwgAotuOcWFsPMeaLuU2KOmmrNqdBE5wUojerpfQh89OpKURwEwdD3XbfKDBWIpl3AXvu4vNpidL39CTUb3eghQUrNwKF5KjetEp6cQsFRX2lNAfQiwDtKOeZUa5GZZcG7Y8MUDlbtRhKTJfGP5lKL3TawYizQpOo9PMCor8FW4t+LiY1wSPHytKY4LKaMp3pN1RxT+9QnUOx9vSoJkng45dwTTMKx1z0DD8tIsLS+bvle0ipzC7VewYs/CppLJXWp8OUOBXC6zTb5kGf3IyvLCsoXEwpx/e7MLVtpvQGEQJBIYiiOOutyXZzjgalwC7ZXxzcA3zy1OoPfB8iksvuFfZljF7jgRnfosahYVGgZ1xQMN76PWVMXKrVd5ZdMV1TkE4VZUusGI1HIkCFDhgwZMmTIkCGvUYYF+RJltVnbetPCI3bVSZT51CPXYhtZu0S1tqc7d4foxFYsUkok4QEGxxWXIdJgBouqB1C01hxPTRrSh7YnU7eSnLeWK7MeuwaC8WQFoAVdnuVHS7rYO50AmbotTCBStcPrwqAEkL0zCQnb7Zb1HVxYyHFvZsHlHNy5OmHfa5N0hDSwYMwIFmZYcJr2yKLwRAnakvUDVgGPGFcdZEmSxQ1pjxnl3wteWoJNztr6Zd4LBJR4IBys3QyGU1Cb2WJ9DYFEu9YinCYcYOCcrKF3i1UPaZKtcnv7u0ICgNY168FMCsaTpVVBaBof4PL1pCxMD12JWy1V9s0ylgidUNBiUjYtzl5nrQed780EKd7XSjIh6zPGksq0YindffLFuRxa3DUX6/TeGr8FWuJJO5SevqyJTBk90Sp9r+37ABfR+2pOZnAs+z1gZQlJapDOmM+554QJN6pv4uPUgwvLev3YY02ZYZ7Ly6EU3CHt99Wmrm5ZfGQpN01HnST68OA7BB0uluM2gZB7GrawglvtfelDBn1d9wQRCsaFt0b3u9en77Wr4VzZOyUBnpFwT3tbsuvOUNGBYII9SklFGLTndU5Ypxi0SJNq4/nOYByQTL9hXcic5Zb0DrSEZbv3SLqC39uHzPDf1Xpl03RB87HZwCBfhjSJQo60wOzBaCYYngybpEFMHDFdjnsTT6TuDsA3srL1NxeJjOWifjUmWEhCwGQFB3BmGQk8cWdmy6IcGCOSiNu4oPaTXXi5OsRog6qhBigj4t36lFxetpR7baxQMInZ21abnWcTJP0eNsCFAaNsEMKwqq+1eYlWipHGG0E0FgaNmtnBrPpeWXucakqR2nK5IUkLqKpcUerR22ksqN0ZEwKgMl4nLcjK0Ka2IBOdyjVblGcvg4kTAm69de8z619wnxOKcbfqZ5VxpVXCHSKh7646CJ6iAw/YLFyQpZJ0YWZm66eenH/TAV0HFin+GmPc5Aj/ACRpgXdN7fOnHfe3BHhtJmPx9c/XCh2uga12V7QgC1P7e1U2Dwt++AJLC/sw4N4lgrMAT94c/KHgR8WHVItlPkPpVj+sMc8Zg9BASwC38T2jHCZ3OpSxbM0PrG9M/EPFsqFSFOMDMgH6d8kSc0HpJqUmmYNCoqj5j7asJLlQik2mwgij1T4a1xSGWYQKfsiyS3w0Y2dUlx6DRkZ9t2mV86A7MFEODhBZPFSTpCSBUmQUuRnWvL7vfDqzH3rw/SNRyJAhQ4YMGTJkyJAhDysDYnGJstps9ltS/TTe8hsvQSw4Jek0xEQiPLk5o0T77m66yAue5gIMBKfBxcrdz0NfnzaDy8T5nkv7Mpd7EpFK2ETgmazfLUsaLeAIBHQuTwQlro/7AVEh4OaohUE0ZZ/re8tlWFznIQVt4UdVnRkNrXeC9YH8o2ZWpSOGNSIwo5Q+hRvXLTNKXqDrsna5W2xq6lDXywOGyGMMa5x/k4yBwFkRYIlXP9VJImSl01yQpRTfKzBNSBQg9XKxVNECiQCqhjWB98rSuYLr1VktEKRFBg71Ncul1ax61r+DflN9wansVmn2OS2qjJ4nZMXMdi+/Uv5T3nm39SA4+wYhEudgfqHFWDyxDrGJHqIl8Pm4qZ8zIJy31moDNzktri7JmlSL89fSI4Yg08VNX9ZljWvNOXAYG1g7mPa6+xu4mCemGC8SYBwIUjXCBDowBwadBW50uPnrtaGpg/4O60J5JzwNTZkIdCYkInhVyfyj/Qr7WkioUdeT81f78Bn2SliGQ/IKls3AQXrcrNIVdn1vMSEkmkvBoqq6ESaxoqek2kPd6Yz9qGdlr64v71Y5+wkCImyi1lv6+kYQ5I4I5AK7yR4GNDEsyEOGDBkyZMiQIUOGVDIsyJcp087WJ8Uq1AtWAyXa7vR+cz1gdYlZRYAdsUHh70cXfI3jIwPNSxuMl9G6MR00g9tiwOEiIXudWy+SUz+tvUyLqjollDyeibB6l8pm0GFIWapT/3GLlySVXMAuq46nVb+5R6DFO27e8FTTHxOstBRSs7HvFytxdZL3QLFidSUGVWVn/LlKBlf6afNUyfa1a/GWS3DmUq4HVwl7+PKNpg6L1aZgFBUYyIxjaif4Ulcl85hbqCuqNbeuqwz16bn4UEExBmudU4tt2jo4flLtFqa5Hu8Jf7EHwr3xmbmsF14qzS/1JgXbcRvc6DhqBQzK2lfhhT1r4c1tc+/uVWFKCxZZ9S7Xve9gWXVstdoiq58H+VXpvdV3mluv3JjbizIWTG7pY1mMyC9bMiV6QFnJGueY6woPu0Yg3KoE6fm3OEffgaPZgxk1l/QcKOhWT5YgxhsLzn9ZS9ug0RUoAWVhdyu35uKmzdrHuhEXXQcpb559ev5JcQfE9QOT7t6MNO6jpZxc4hzwbWwZz0yFziyV9BgpgDBY9yHkSa7xz7KMM0OeByHzO7JsBcZpvJi8XVqj8UBtqd3167vcK6rQpExZNx+0sSOM2eCeY7ZkxfV6E+erDHLI8ud6yHlCk6a5K9q4TqBcHew/v0rv6gfjac9dX23r7L+TxtVjadpMhHXZS6yUAv3av0OQHrmW676+AIe/v38E6f38pQnS22hyt0kuzCzAGQL0IPlw4f5DxN17YB4H65IEBh6Kjg3v7qR79uomKSgJz8iU9p4Lqr5eRwWnwYVZYGCWR55JOrKkHbW7id8XQVvaGB0GIFiLlFZE1r8W8XZfgfKNtNUOA5BLHlHxZIXwvvcNdFHWQiAXk1UUWYGbOPapXNQtt6srA1J66gQKCAgjUwDr4u3ROODmTgGXbxOkJwYIlSHoE9N4A1IQ5owOkAyA5Rwks4xZ5CBW4GfZfAKUSocubURSGJmy1+cRgletM35Vh6KE+waolMpiXihKtl+HcuPlSPF0uEw179FXfthWXbIAUSkcYrlgumcEEPZSbXv9pLiqD/kMgvn8sMJ05ypX6xghHPVBkC51HM5Ydjq+MfYmMHN0mRs27QEmjEvMOT8oF3aeLJFIxk3ftBvrjZSpNYIVubcEpowsmK8T6C3J9p0sYRONMSEhlh7Pknh02JhCQD+/H+9LEoz42sQAO0JWqncQrpfxGKcJwdhOQQrJNFW1O0twlulA1F8CA4c9XKKQAbEYMmTIkCFDhgwZMqSSAbG4TKlONb1T1ALqB9CemWjAJyiA+uIeaV+bpnyswe7lJLWRRbCcpKO1uT0VBm7DJIuf0+6Ah9bMAo3NAnconMSylCTwhsDBywCipNy5HbDwIltboNhBMKP3j7KYCQ5wq83gFKy+VZ84dEDX5dZS8JLcZsyQ5gElrSWWnK4HKY6a+rUcrS4q2ymZFOwGKiZZYJTlSryzdWCWXMygVpMVcweLG601DklQXW7cbOusgLRioVwXyErdjgk81x6stoN3QtYqWfPBL0vLjFuB9Lo6yE/fyeEKCBQk7Z/gHAxqE/WSfLPqn8JdO71ys2lr3U6nnyuu9SXbF9YGeTHKcyuWzec0z/W9q/GvOe91kBVWfV0gVoH2TN9K4+Mz3zz//fwL878X4M9eXS1uflLMrYtrWd/N+awLD7LgG7Bq+zwo13cvFXiEMhRW4u2W1V1lsz+YlVBUfIK/yLqvNUec5KXfHB5UW9oSjxYpABcu5tL3ah88BcGLQShWnc1OawCDplUHp+3bNe0JlmOtE4+XeY5+kzQwRViC16SCm9r1e8m4J9rDZC7Ck8S92KyyjAueU77PVmME3scA44PHJ9v/I3wiit9LuF2RzOO7EgQU0EjVYXc2lytIh1m0wtJ6vfRVUm/upYBMpt5pi9+XQdUZD3KgrWXw6QVlQCwuQWqIxdEK7AgdoZuEirMk5R/0GzDwUF4toWzWD1GhTFed1iVxt+xj8QjvShYK/x0TKssb722qI9KJc7soj2LCF9njqGyu18JNTJIohqnwXRv83cPy8Rl3nZUxIoVXmxgXzGT8kid6SfXbUV6Se13BBZer3w/mAXKeatNzhaJuP+sRcODld8I2QlQ4uHsDqwvYPCxu7EymEhb3DhyprmOqKCARSSNcAwSdoRIuZUbtARaV4ty9Uqir/vJ6MT2zK+EnTRmh3hy/qhuUdK9DDefRd2DKaKa1JsxH49YP/uvm3S4cL73fUG9X/ME2ooOtKxaEA0lQ5y5kjrzHHOdFvM+4HgPnnCkOAQbVeXeAUh1Q9AjnIAd5D8YTZNvWm/sZlXEf54gdyZTWLrQQeFhC/8K+1YEr1HUiZNCwrzVlMfYlyZlQvbytA9+dwSEYz9SpD+Gjh1gp0j3Tb4Ou0WHfijkE+rzQob2dbzIgFkOGDBkyZMiQIUOGvEYZEItLlPXxkZkfKnMXDXkBPcU0T2S0bh6wwAZXTnWqDOmrGUSYWDWzbDdLmxXcBQtkfQJFVO7m0Tbdc5AQjAf3EdNFy2rWywLEtKeImA1ZsHgClSWhpLv2wChmZtLztTVQ1rvMSYPAQAbUuQVOYyjj7u0ECIZMWm7dK65icLYyhbaXAwuqW1GOp+b+JoOgWwoV8IO6lHaIGcPdn3KD32gzbrkLetfCCKapjKuzZXwwc9zEspUWF9Zo/47KDKhxo34TN7Fcsgj2qusVgswEewDvMYO1lGpZMAexOxisKO7arkLuA3OA6qQ5Ipe6+kNQCbFZHLDaerY8WqLNnFVkKuwVbkkFj7PXURZU9ZfgLVznjlvP0eoIHN1mkaUB8zJkUNSYVJ2utSweIUOd4CDkGzYzO7rWtJPj28dMecahZGTQyNhKBDlQXQW5sIopBPCOwGYxYZ6W+x3eQatosOa2wY1mFgP7BCVAMJ4LrdcaB3cBRfFMk8hUV3lSmPFuTcgALK3+nLV7Ki3JzOK4plfHqj7CGrlY4xFMfq30NdmbwIvtdUyC3Zr68Z3b1oNAmIaXzax2tMgmEMu997oe0tdLwvOZhb3Imhk1zap9qs/UdYjRy3Wtag1dTVNkK0lkKMiXKNN2a+urZUGWUsgoeqvcGufCQ5aJxKh0Jgw5EEVLnLBt6ihYEmwXnJRwu2xLFi3rClLroloSSZS61TQxoFLzyGO6YrU4CSeNzUp96fgzYXG1aAILZ7YoBB7NfO24LQORxhJnmFA5ZJRI3MI9Bg0eOtQ+Tw2thRPpq30REPtFdqCQUif8pS0bqNeF+GZdR1pcQitE/7YWRlWYRcd2os62fCc9E7CFwuiJ3UEYVcdNthheZ0NwSqfHm7o0Lmq5XvXbG56c/y5Uc34gSCiW1o8VCr6XXi51QWIMzQPVoUrvTVoqKi2uCIKtwuem0vyKUk84Xyq9hBWYmalvXSnF5ivFWAqV6MoA5wjpnaWA6htKkazHuZQtsXQID6w6+YGmVU6XzQ/JG7SOaa1Sncs3seN82/LxWL6LKAZ9/EqZ1fiQAq3xqzGneaC6aBwVvGndPj/IOMQAyjkSZQQWCGfrKHuG+pqMJBXNmzOi8MCiQ7Tmpw5wig0BlSIZZzQXtX64IeXxZW0JlJBFPCHIEZRUHSqP20PIkha+TVKxulb6VXEytUGA0CHhtcuaqnXdY2iw7q2YUltKKpTyHnNMmlJZRhekUt/dLu9AnAvhe0F57UBTVifad9p1SJIxRixxTIBUoH+CUa3HYoGyU9E8F0UmDVmkjGUsUf0+JHYJxrMElpop47sHD2w3tQa3fTIgFkOGDBkyZMiQIUOGVDKC9C5B6iC9k5NyYu3AIdJIygMBX0wQ4sJggT1CC69bjnEK9nepKkibeYh/sAsDoRsEVgC3ZtAyjgA5nsCDVXsfD7JcaidoH6zXGY8m+THdOnSnteDU0e60tJAvlidt8iOTSJ+pd5ckJdGzsLAagL/Vx0zLLRuCdTzBQrFUZemeleTkmTf4u2V98gAfWh3BmOFl69voe8tiLGuZp8OVG73lfp1fKvc2AgSvKAECUgyDY3axpCu6vdRd4+dK61Z2JgrrWMBVz3ME18mC6kFK5XclyBAkQ1bPW6073NSWig94wlgKdVI9FVAlC5wSoMjSuG77Iaa0fdC2zRYLvr9LFn1ZErM6nLUQDLe0MsmFvqE8TrUnRfMxgxrouqAksu4q0YYYUq62iXSChZlWYGu/fdNOBogB3kZ+66UABHUCYlN7dwIjiCBCzh2uPm5hGw73kDU6JBhpeaR7HOYM3JvohSBHOi2tZP0AW5FDTvR84yFqrYxZ8F3cYy8WSOjrnSzRNQsVU4JPi9u+eScZY2StVdlI8BTYPSR1Ocm+G/ohs/ZmuoOnWm/3xZ44MwQDIg9YbalbHOI2ruvCYMmFleWeXtKta7DCV3rKwwTpDQX5EkQK8hdv3uMsFj2F86IUI1kkZno9IxqvqXnKgqqBtuPESJgyIub4qHudda/bGqjUcG91Yb4PrpfsQJExhfTqlsEdOOEOYrmIXcuSndT14yKOyOGsLHf7kapOcgE2A1/MgUFmhL3XmTg7Yqz9+7e/1/3kBzYupJ5Ao38gIo42jBfgKtm2Rlw5A7xDmzue5Safsl2AJWHVc0UeepbvItQCZQfsH++vnvGxQCyp5rcfFHEweNAfD+EgRTaQqiwernjgcWVOMAdtiGAjWYFJYq8SgIQXIQsdMKZLMgowMFA4t/yAXM2HNHofCW4oTo+VGA5YPg+ElXCuBaWDcBY9BxYW4on9OpVes+X7woARFEi9CzRvVDAzxXIpYOnzME8l+i4ZexS/4wX/rpNY9HDJZp39KoMnYq/NEnple2tdZsYQQYNWVrfqZd069yAWB9mmMqxywhR1yNhW35sxZrBM4rgl9fODxWLIkCFDhgwZMmTIkNcoI0jvEmW12dgScBJPSYQ5ZKcjuiK8/CR94nJS9Qvzv5VljVYKz9WOxBg89a2vtbCFzJorN7gHJvSA/LRwhyhfBAioTkft6difJ1BfJ9UOj6JbLchrzHp6oES0lNXtVNDeYgXW/VVRgBAQ3uEBVYgKd/fRtu1bTyiCwLie5WaxEJWfrrUuVq8j4RkKJFPAUAgQQ9IDD3Kq3P2lns5sQZf5ad9yTMuDMyeUoK+MV7hhkkCwpQd8IggrsDogPbTmsQeeMVBQ7e5YcVePlyA7BQYKAoQUzA49IcMCk1rIistU1bXbG2mYmYbbxx5hWbLaitXi5qttf9BSrn67tQQnLskWkCpYc0PfR99GLvPyXSe5TwXTUbsBc1AQbmMjJFsJU2IXCWmhCcVB4Njq2iPt/UUaBg0f120Qsr4F4Tkh7Tes+YEXWUw7CgStrNfOBc5AL6SY9r3hLubF03Nf+7hGsqKQ5KNOvsRYYTf8tUwZS1+v234gNE7sLYKkqc4d6ODmySfn6gnyksDUlgdUOe2tYMyARZoBZV2rsfYxsYtMfVaHNOV0wo8syZL7zPWWRVjtSyCBXljrhQp18f2vfb7HvhWs0xhjWbrqkNgsyWuwPFftk+Rt1vatsQE9a33latNeb0M15lbTbrBY/GJJRuFi1omCXUNZSaJdM8WYcAfeN+0i/nlx77XwjIAvEjOGFk4sIGtE4ruS20tSIqUie4Ybq2TTz11PVgxvYwdH5dl9GO3KRAGsN91HzvaAjYSHmBpqANwi8bwLdrptp7M0EMPMjVR11oJT9dM6ic53ERbXtOi1/UFsokeLg0FiJ4WqWlD9GVDquSKoiHlgEZntTwqU6K2kKDu8Q/1WKzHsU70zSYzhmbYKztcPjmXhJUsA6c5q5dz7GMwHjhV+0Cq6rhAz85jKvtK6pIN7ufrerkT3cLpmZjqs3LnT3OeH6DvttwkH4ULN6M/XG7HgF47LLu/S4UpjSkp4OTh4uzVexLyitanQx5kOFFJ26gOwMNQJjnMVqOKUmauFYgS4i8YeD7nHyxqzApNEODQSt5zAu7wuUwtB8gySqnONxSVUhiwrqifu83Vc36CMgzUYM8gs0bCWcJ46fGWupzLLaZ0mBnt99ZGmrlrniB/29bFqtyvGTuc3/5PRvJG+jslq3ChBKBYSkcz3il3HWgnQmPmfJeNpayAJSjzL2QPFJMUaYXsuOjiAbcp1kASj6/pAnREWh4QUcnEAGunwPjBCTWfac6Rox3ZIySYtoZetcV2+46bQsu5oyDpamxn6ao8MiMWQIUOGDBkyZMiQIZWMIL1LkJrF4vioWFqy9NBmy2ktyWmeBd1lwXqh+Cy4rXp3kAPpINOAAlkJ96WdTNJRZ5IFO5ClInVVdUD+mVuH7wxBG3CnMWht4So+fPqnBIgIg/J4Sia0AEk/Wv5IRG0nwUhhrOjdsriuWxedu6ZVdyWeqSz0shgz4IsBQyHVcgj+QXAbmDZ645yMJuR5ZbCVW14ZKAVO2xDc11s2V62rcWl3yxxC6MEET8hSHII13cpfLHe1JUrQGCYM0TiWlbIwZixR+4DegHnDPRCAiTTWa80BBWxqrnG8HrdW/cWyiCQfZBjQ95bVrGZrAfdsCFbLAp7I1oBg3PAuwUDq4CUmxHEIHbwyKCMwqTD4VOV7IHUnCUzCB+z1z7hq6Y0ILCX9tPB1wOGS6AbB1wiYzFJKe1WYIAT7oN9X73cHAlddGDxNzl2Ut5eFqVePTl38csYccYCtKqxrHRaLwEZEC3CSWvpgQD+D9ffwIAc5kGo7C9LP1vGefpPqPp3AvuZn7LEK0vvQ9P4LBem9riEWL774ov2tv/W37P3vf7997GMfs5OTE3vHO95hX/M1X2N/9I/+UTtJokovItM02X/6T//JfuAHfsB+5Ed+xH7iJ37Cbt++bY8//rh97ud+rn3Zl32Z/ZE/8kfsLW95y0OVG2hjahaLRDEkDmhhOWg/PjPIBUYJDO71I5HFIs29ThgHBp67npnth5O5M2CZ4S/gXjG5Q0S12kB6tGvIbufKj0XR5q3sbFKUiYuzBBeHTGvLZiXMYnRtxwyICa0dlbJVqyisn5wn8U5YXCQa8OxPwmpa5YpUXaCETkxmIHcuNjXHFapsULCtsFHX7V0rw5oSSVDhEVZTUAJglEMGQUFQipKmbGDC1ZlZcKUG3LOmSEhWURZgUKtRqfH7eokaVBao4EwK4tNPNf3BZB4+Rh16Uty+dPSpLhWmfaWFXklz/GCjLG1t2av7ZHsQFR/gP4K3qM7acOv4Bn2nJ4vrXPeCSSMkWVFdgb0mDdzqDU+15U7VtrWDUvbkG5p7w0FAc0zfsWBx9Y18/j5SIAl6D5OVWDXOvT046PihBX1dxuvqfmmH1hqNOayDkobdAxAih1AAM58p7d5eUOitn2iTN+1192vtAMyFTCeO1S79pLUpZO2Te1z3KSNfR1l1CJlDI5CwCIdL4YQD1lhTUHvmo2VtURKjGotLOJ3m3ylw0KxDJvoWDv8RPaT6r2LQYKInwq2yw4dDIsGAI5pXUm1mFIR12dBxQtbg5HASkn3gsLJRHFPHYBDitIg5T5KscJ9arY9sPU1mYJTN5HULsfjP//k/2xd8wRfYN3/zN9tb3vIWe9/73mff9E3fZLdv37av//qvt1//63+9feITn3hNZX/4wx+2d77znfaud73L/vbf/tv2zDPP2Dd8wzfYd3zHd9jXfd3X2XPPPWd/5a/8FXvHO95h/+yf/bNLbtmQIUOGDBkyZMiQ17O8LiEWP/MzP2O/5tf8GnvhhRfsT/7JP2nf9m3f5r+dnp7al3/5l9sHP/hB+8Iv/EL74R/+YbtCTsQD8h3f8R32tV/7tbZarexf/st/ae9+97ub3+/evWu/9bf+VvvgBz9o6/Xa/u2//bf25V/+5Wl5glh8ybWvto2MxJ7aeIn+VYrlwIPL6M8sAUjiFiGZduA47rwzkJSTUBuSJedIrde9KNg9LpS2mXAHJdCDkOxBUrt6PJhDFsA+ObunzMZJladjZzEQO4KsYEU8QKn+TadbBmkkaTOzYJU04YaCQSqrsVuO4A7NgrgImQhQCqZqLUE+bkWrg9XU54zSl9WK/K+qQ7HSKdGIs2BkqbY7sJZgvZZVT2POUzG31huvg9YSvpPpjXetJdLMYgCY6nQKazsDCPW8rPSqE1NW65vovqo/mJTCuYZlvVbAoDwiJWDOnA1AUIy2X9zCqCCuLN25LePWNB9lxWHgmOavgnSdraRixjCLwYjqt16ikAzWA1gHITb+zWjFZdtU52oN9rmu9OseGCU4F7mH2wA4n6MeGAfuYQ9ObANPzapkQeCM9nvlxThDam3ulYBUBbgWPWe2WMwVROjj8mr7veJekew5hAMRJlOvE/DGhXpK6HIHZIzBass4QiBZR8g2FRI7OUNSyzGeQQkCb3IHThD2AsKXuE5r78f+t8Da2r0oS9rRXkJOBATLZzkV9nEsm1mEv1R16SX66JWR6Tehzicndj49sB86/b5PXx7kP/Nn/oy98MIL9ra3vc3++l//681vV65cse/8zu+0zWZjP/qjP2p/9+/+3df8nj/0h/5QUI7NzB555BH7ru/6Ljs+Prbdbmd/6k/9qdf8jiFDhgwZMmTIkCGfXvK6wyB/9KMfte///u83M7Pf9/t+X9c6/Ct+xa+wL/7iL7YPfOAD9r73vc++/uu/3o54kr6A/Pbf/tvT39761rfar/21v9Z+5Ed+xH78x3/cPvrRj9rnfM7n7C1venBmq+OChSqnoq1wVLZYxJzuJlgrW66/zNI84ZS/ISdrBwe8OyvWxmt9jNlCF9RmN0pTNnqjhY9u+RWbdM+wkNMqy6C7kIHnpNSZ1j6dWBlYUVk7eHKmJdgxyeARXSMg0AOHEsxXCJqwxYq5FaXSen5WuC9R0rhVGhi9SOHU4oFlwRFWr7YOkUrHqaNgMQwpqYE5nRCE6Jao0o/r0l+N9VrWaliOHXsqOi+mcxZuUnNZVrAET+nzqFggzcysWCXDM8i05ljjQlNnoI5b+IFLncmz60D3ysrjnKwF7woLotN0CVtb0h2Lzs7L0e+yUMpC51bg4pmoxrlj5lVPUaTdKO2S5Vh4b7Vb1m69S1ZLcfXKik0cdaHymutZ2gt+a58zV6+21/VOYVVFHSfLuOYcLMf+vvrvp56Z/33xlaZ9Tv2ntUVYY41rgdHVH4h3UP+5VVvfrhrnoa/LvYu1GlYuzWd9K/Fko33uxWFGwSowMksNLepEcxw/PEbkAVfA57ad555OetNafc0WXma/Brq2tcYp+b21FnEdd6soAgLdOhyDj308OqVk6yH028vv8t4K5+pjSOsg2tIV9U3Au5b5Cq+d2sk9x8V5lFsL+rpQKrZrKryMAd+PPka2Ted1RhxTtr/Xnu8QvwSvq4vjm5FZUVjqwm/s1JrMmbDCd6+LVr3hsZUEHem8HQd1DNU0dTKvJvK6U5B/4Ad+wJMT/Kbf9JvS+770S7/UPvCBD9gLL7xgH/rQh/beS/ktv+W32L/7d//O3vWud+2975f9sl9mP/IjP2JmM+zjoIK8m0KecSW5MOu4WqSM+sct9yHxhd8nfkUEzO3gyu8xSiyE8m2goL971boi/N1J3nTWnUru1Li9rflN/wZORud0hHtEiqT+3mGB9eQOqvM2/qa6CO6hssBJ7OlPkVAjlC2lzvkVW9etWcURrD4RJ2NC7r59RYFySjCgxa0oKUrWwmDHTuCUL75UUpGUg6mWl+Cm8m5vf79ffHxUC6rfC7iGKxQ8TOjdTDWdBiXCRVfxIKt9PiceQAnXgUmbD9gb3K0tpZRwn127mblyaBY5hVUn1R9u8emTL8x/awNVQgj1A/lTFUjZCYw0Qh9utkr3kgCldf86M0hR7ryu5B6WkNu3KnNxmWOzBnuHnbd8xj7WmKJYytx5njjCPvni/K+7vQFH0DvVHsK7pNQXRXml8SH4gObWA3ybWuRiVlASf1cZap9z+WJMMRHOuu3Hpv36jg+0ZpZ3IxGK2r3iQbkcUjPFkAwzzdqC7+1zX4qTFH9w7weuak8PLKaZxI1eK73kAT4/j/dYtT+VeeEBYAkD0rSF8opy5odbzmEaqhwy5Ik+WjiHxJ/3NblleZgAxTSLCqzrGRmDRqLoB5jnWb/va0WU+kfKksX5CR3B6yTjTWAkad9nVvUNWVoSmCZZSFyX8NwQU0h+tU9edxCLH/qhH/L/v/Od70zv+9W/+ld3n7mIvPWtb7Xf/Jt/sz1S4UV7cuPGDf//9evX8xuHDBkyZMiQIUOG/JKR150F+SMf+YiZmT322GP2xBNPpPe99a1v9f//9//+3/+P1OWnfuqnvC77lHXJ+uTYVjvwDHb4BFfro+YeQguY1S7QuRUh1UngOKzeHVwpug5qmRCsFqzcbuY2s+VkHl00i0uOdDAhkyAD/USdRqgFs6SBTmfVCeIh3Q2hIyG7Faw1IZuTW71bV7y7uOpsVxlvLwLF/Blk68ospv4tRcHWC9I7Lu+SlUJ9qXYnwWkhcA7prz3tNVKP18+FQD9m3lImPcE5ZHlBimUGpS0W5XVT58a6sBFd0/Wmnp7tjfWVC1p1UJkOLUGQZ3GPB4iC2WIpJX1bgVq4tVnQEpVNCAWsmj7mkO65gQXIcuqcwqUOcqHLUqg66l0FKuGuWvH9aszpX40bue7roEVwT3u9z9px7mXQwk5uZX1fXdc36wQn+rs0ngVrUd9ebfvQ57VnjpMVr8yXu61nxb+J+roOBnNLIILsAIEKKdMFQRIcxKFx4Oq+V6xeynZZBcKS4pCczORQ97XiCtz98N6Qm9lp1CoqxTC3RBmWtDNQ8Qnmpwx6j7R7iPZH/1Y1jaPmgmAqWtfLO0QRty3GrUCVh2BbXzsFU8u49us+gTcuSNjPyrsIKdS8QZ26XMzw8IYU2Bk/NNNe87kQjFd0kJrXXn1C3SHJard4NFu9hLkImOVvhWWzaQ84lYOn3q32tPKrmZO3ZT2ZGdAhmbyuFOTT01N7/vnnzczsTW960957698/9rGPXXpdfvzHf9z+5//8n2Zm9gf+wB+wq8TRdWT34MyOS3S48DX1AOwSgJuFCFRCJJiqeYnchYtD7hEtWHs4HP06+X+pIAE37BNNqRzrNL9mrjjXnM8Lm4YwIkrGkTgw6Hqki7G4XBlx7OlCT2rlPInS5bvcldpik52LU7pdmeRMrb0o550UndvWjb8u+FfnA0WEeWCYcPjC/b11duyfLThB70PxYGIz9s0KMA3/u/QpUywTu1e75Hio8Pb4dyxjRJs8+JJDlP8dfFcpRVLWiqJtZq4g+fcB7tdF45kuaW28L7w0X37jM23dCstBl3lBhyQpMlCc/LtJoSfeX+XoeY0PtRPMEw0mlSwVcNe74iTlWm5wtVsbDKEaUpBVrsZi3Z9aWx4FBy+Ubi9bhwyvQ3mHUlF/6sX2eZUr3HPN/6yxBCXa2Si0Gctb6NCbsi4IPwxIijC6XueieNnN6ntrDoH32rlnOXagUPh3dS7aAsFCSnKN0RpKtAY2PhxkcGAXfMdx8lBSzdf1VvkNcRB1/cCIs3vxpfYZKv7a1/ROwn40Zn1NutPUpfdOzaHNU/N3dHw0lbeElcfXdxmnoLw2ac1hVCBUxPcGwPYInZQy53Aw3t9JSc3YIe2vHvtD1o2NlNH+/ufKa8Jita6UdhrsAtcwoBeSkKSDezGNbnvhLq1hLuRlCBjkBVLB+z9tMcivVgFthxTSa9Wpsn7usuQf/sN/aGZmb3jDG+wv/IW/cKFnzqcz20xl4k1ntra1rXvHoiFDhgwZMmTIkCGvW3ldKcj3qlPQoSx59e93k8jG1yr/43/8D/v7f//vm9nMmfzss89e6Ln/ZP/W7Oby9/+z+nz77CsLVtpPbZ61TuwErUvFLcA6aSYZeiJsAmwRdUrWhKXC68b0v3JzMe1rqRstqMG1sydVZzg5q508WTJ4T65JZqJDFqTGittzw5vZatNmjGMWqAnWaLoc6yhfs8W60LgDZWVTuxUoIhaH0l5Fnu/IlKC+ZnBXiB5GgJlVTBeyMDHzkk7/ssQgMNA5lgWDCOmB24BBWYHNFquWW6EUMQ8IibenuGSZnc6/e7GOugURXJ6NdUuWMFl4ZXU7WixB9X2exU9WLFn/PEvYq+19gmooMKtm0CCnMIKX3NKq6+45uNZeVzmC4Kh8ffdiFXSYj9kShFayLhqDEPXdb9xq7hOjyGpX2qdvpYBAWaDV1+SurZ6RFTZYZWV5Ux1kOVV79S/Gi1vcBVGRp6Bmy9BYUl+obH4vphR/vLXGW7FA2osvt3VW++U5qd3q6lutIfrt0UeaZ4I1Gp6GCV64cF3joHiezJY55qwzPs/FpFLWN9WbHjTdp7XXszfCEtlJrb6kvC9riNgaxMJD740CH+kZg0fJ1xYyB12v1lS1W95DsSbJs0O9gbzeepeu652lXHn3JsCAmnY7ZKSFYRG+F+B62K/p6WUQagNbI3e+oAaaM8yEq/0oeK1bDucJXPVLevTKeq3vyGA7ZNMlZDTLtDfRw00oSu0Bls6E7MKEoaTpvpFWd3V0PLOG7CErqeV1pSDXVuEHCSSg9/uhYLuHkbt379rXfM3X2OnpqX3jN36jfdVXfdWFn/0N699mm0kYvpWtbd18fEZzLvjeViGWostI3IAxPpQjvcY/EwdMYm09kkARyKyR5UBfBm5VLp8hk4azV4CNAguGK2VZCk+5KOs2QTH2CQXlmu4zF30DMIX4/YzQrt2BXBCLcuLfoMzSHdy7WZQtDxSBBqnavN19q3olCR78gOCLeKt0Kr314hZusZirjnLuG7rclnJ7+obJ6PVV+y7gIU1wB9K8PWgPIPX/3aXcwUg37Qe5f6B/8kNbGcPqRylgFUWbv8vHiJQTHWjLpkRlRn0OJcyVASSUUGvbdM9X2zKExVXf1N/HLLBRTPjbx67GnPDATNFttigf2iBx6HIlS2PnuO1j71OW7Vj9VlGuMd6EyCzxCWXsSIHA5rwSW4sUCTHI4ABocKM3Y00uY6caK98fbDN+sAFTTojEFzsE26S5Vycx0b3OiNGurd5+QGx8ToJKkrh/L9/ZQSqX+91+/VwxFlOGlFYm2SHTkcOdBA/CnlKPzQ6dZnMv10TCIDSuNXdAjao6hHih+hnidrENh8Qhvv/14Yrcm42pmasyDfRlXjfqAkjznOGEyWbR7VemiHZjG9i2oNdI1oBaOBTUE16JtYp6UFSEeT1L7GUT5o7KmXafvhCLxx5bsIT37/c3dEltba6f+/nI+fm5fc3XfI391//6X+33/t7fG5KUHJKj1bFtSpeSsmjIkCFDhgwZMmTIp4e8rhTkK1eu2Jvf/GZ7/vnn7ZOf/OTee+vf3/72t/+8373b7ez3//7fbz/4gz9ov/t3/277J//kn7wmJTfw7lanKQLtA3sFXA+BiHt5SVN2BtRvTo2TiMLn09y2nPYDQ4af5loYxwLNaMv2kxyJvPcEJ3qAgQLhshTCdLHJg02oCuAhCiA065yI3erRJrPY9fhdLQZIOnQBuPdeIhW3Runk7KwkSFYCKI1/R5EcyHoj9ofyvRWp7VHkVaIQEqqvPXi0hQH4NxB0RC5bWSsVMCeXrSxTskCQecIW65uCj1RfT+Igq2tIUduyOqyL21swB7f+EQZQwzvIYwzrnrselfCCfMFgFDFyFAvm41bNjjVCAXPPf2r+V9Y9WdZlCX2yjFNPqFDmoFzyWn8UvPPmZ5v7V2fV/JaVRnzGCnxUkhpZoBB576uVvvtLBWKg766AQQQxOlTDbIFAXAWkRO+S9ZkBZbKoMekBk7bob7KDmNlKkBL1oVzF5Xf3MjBwEl6OpS2lLuo/jTHBHmqmmEcAjZGHyBO9VBzZtsyRJSivXfcmwECUSMahRfV+5DzWZcxobgASxYQasvKui1GJXhy3kMM67AwiZst3RNCdQ+BKu+WV8vGQeHGYYMOt2rvWS2VmMd04Ehl5Oxx21ybR8nU624sIrduT9ngJQi7tB6uUW1zBMrTs+2DYEO/1lc6+yABBBNk5B7WSdCyFNs8tsAgV1MIiPBiu9hjQg03rs+sAbbIwfx6ME75/ucehrPcMvLNlj48MGGBj0fe+ygBCQDEekgf5daUgm5n9ql/1q+z555+3V1991W7evJlSvX384x/3/3/+53/+z+udu93O/sAf+AP2z/7ZP7Pf9bt+l333d3+3bTLWgz2yOjryLDISfTCzarFC5GhwF2SsFXxfEnmb3W9W0XWxbGYgIn4KST78PtUZbasXcx4I7KjFBaeZhvS8qHwQuRuigjswB99ItMAg3zujmJnEYskPX5J5FEUpy0jUZJyqXaK2LNaeEIR10ULrzAvF7eX45tb969Rsnf4jM4Q2TO87wVUYva6NVYugyiYGWVDUB1EZ8HeS3g4QAkZrk/3B8b8nOAhJadE7641EcAbHVLf4df/+hA5oE5YCBWyi42UFKXH4Q4VF17Oqn7K33cHhS2VJUdZceaooe2KBkKIthcQzr0XYjB9kpMioT4VbRTIKr0MZi15nYapVtuaNY5vLwauiHHPImOr9eLlXMAXVW+Nam2/IKNiyPSzKzqppd/dQQmw92u9jBt/R2TgcR10Uf6ce1JjsUHtpbiCpih/g2B96l+oG44Mr91pTxeahvq4w5zqw8YDKBCCkIstoGl250UH5yZYVwmpssme6EzsP6BzvtuvYglku40FzU3WAoYCJgWp6O2KQnUrTFSetFS022WCMmlaF9u64pcmrjSt1Hep6+XjXb2hfwNy60t2yXKzRP7o+EUpXvZM0qky2tYKhi4plWJP5t4xSFZ0hdYUlfqPUv9yXJQsjo0iafKwDLVkSdIGFaIvDCnDPC3NWW87q+Iqtp5VZhJh35XWXKORLvuRL/P//5b/8l/S+D3/4w91nHlamabI//If/sH33d3+3fdVXfZX903/6T1+TcjxkyJAhQ4YMGTLkl4aspoexN/8CyEc/+lF7xzveYdM02V/8i3/R/spf+Svd+77sy77M/v2///f2zDPP2HPPPWdHGWn3Hpmmyf7IH/kj9p3f+Z32O3/n77R/8S/+RSjnueees9/2236bvfe977X3vve93XJu3bplTzzxhH3x5j12tGpTENcSTm0JHCMk6UgA6T8fYbBesD4DmB+TfKy65Xj5dR0TgD3TfaaJTvg3kzc4r3Jk6Aj1xIna68RTP6zZZPNIuS97KTBVbwREhHvJTtIJkJl/aMeWp3+urzPAR1YrWGNDMBphRWAMcQu5rGUMeqyeCcF2qp9csQgYWiPYNjxHfmUyFpgtnLEISpIw0I980G6RkrVPgXRqi3si2jY29aQg0QvTWxNy4NYiJKchI0PXZc06qGxG8cviSkuqnle79LvqvIXVu35G8xEsHd4O9R2StiwQClkQwb18gvtrpgJ3sZb6XGk9WG7d5fyVVQxBbiuuMWqbc/lWlim46+l18LmlOiHQVdZNZ8QBh7GPzd66T++Sf892LfQ+dxYScBNzvHD+K1ivDpimFxHeRsLuwjtgQfZAX8zZXuA01ykGS2fB4yHJh/qLadK1xvTYj7in0ztJOAO/Bfcxrv+w0O5jggoplRm4zcQhST4DL5drSQ2RBAOW33II6pjAN1NPd4eRgjpC+K5gLQlpvaFTTLvJzqcz+9D0frt586Y9Lu9OIq87iMXnfM7n2Fd91VfZ933f99n3fM/32F/4C38hUL795E/+pKeX/rN/9s8GpfYjH/mIvec977G7d+/a937v99q73vWu7ru+7uu+zr7zO7/Tfsfv+B32z//5P+8q2aenp/ajP/qj9olPfOJC9fcPxrzkVitE7WAM+F0+h0xVwT2WZOKpFQ7lYF/Dfe91YnIOZq87QiSrUza11HO9LH6EIwRF33FkUpz6mfKoGDOjHpVcs2Xh82tSyoKbEy4oxwN33F1mi7JbynHXZY0DdyiB8LsFUpJgEF15dxcmFhAqUnqug/Fz+I420IoqqS5bY8T7mgqxcGO6z6PDy4IjtpLGHVi+p+iuXmpdq9xQPaGCcK3IuOUuTPWXqL127WJpVo1LtRvubleUnNaqTRwhjO1Km/qjpbw7rdvYIQcvvrK8XN9PsI2K4cLMzARvEU6YGeT0fa+3bv1FocZcrWQqGPPVvdP2XriBnSpNfan7riBLnd6hNgk+ou9cj0EpRm+a3fKrl262z+o7qj80LgTXULulSIomUN9QCVK07tVJad7wVFu2FFgxomjtuAaXq8oWpERl6nl9Zym76rc6UYjWSiY40fcT5l6QKodQzO/QOuCYZEEyeFCQolwrKKU+K9A1+pw5Rp863R+UEI1zKaeIk1E/rSuKOT/QFgjRTiwzerfWYyivntyEjDlesDC7ZZ6U9cDXRbN0fVoBQ8wkVK4YY71zBUrzQwwcpY3KzFdfW/ZGZXUre8CjSGICZoWYGRYwCSYWqdZ/QT/8UHHE/bZVgNePa61pYX7UQbg39/bvsA8520xCb0elFjQfO9LZIQFJLYuOo4NBeSZhxsh0i4Xe9MxW087sgkQWrzsF2czsW77lW+yDH/ygfexjH7Nv+qZvsm/91m/1305PT+29732vbbdb+8Iv/EL743/8j4fn/9pf+2v20Y9+1MzM/tyf+3P2Iz/yI+GeP/En/oT9g3/wD+yzP/uz7Y/9sT9mP/zDP9ytizL7DRkyZMiQIUOGDPm/Q16XCvLb3vY2+zf/5t/Yu9/9bvsbf+Nv2Ec+8hH7iq/4Crt3755913d9l/23//bf7J3vfKf94A/+YDfj3q5OHNBxe377t3+7/d2/+3fNzOwnfuIn7Mu+7Msupd6ro6Pgmq9dF85SgWhNRs5mnMM7WI4DZAMR3NuKaWF9BRHmfrLqM0k4yF11ANTCAw9IUK731QkzEBCmCNQQaXveug2Xdik4oiW334Gb2F2RtWWRvJmyiMrV7pHSgCTIwqDrsN4zgjlAEKqyPfWsGDBkZSY/rgIoFWHOgCO37rTQAz8d164peArcY6AgLrpoZbUBf7KzV8BCRQtTE0hTAmTcAsTI+q0gAuW739ZYKsvRUWsFYPs8QEnWnQbeAT5c3atEEOI5VbAPLWynbd+KBcJdr0p7/MliLewlb/C6tG76xXJc+moLCzgZNMB+4UF9uq9KmLESG4e+gyydWn/0jDh2NU41FlXWFXjA7pTo/xIw6Bbqus9lOXr5VvsuWdycF7mU/Wq57glEWsuxJ0JhnWXlq6E4aqf6WpZkjRmkGPdx7Cmpb+HvYnFTwKzeVYL8GriMvDKeTAawFb1L419l7vpj1J8TWwesu1Z7xpzHuHhTwJjjf4Pf2K10k+A8ZQ1hgN311mNUe7t8HXPGE0BBPDWxrNgJSwUDhWUFrhlS6n4xc4iQ10HfS+1jQKBDJpSEqN1rXRyK0gZKNl5dJQR50HIsL97DPhuT+O4XSEbL8x/gEWp2tYcSfhGgY7Ksi2NY6x7gD34/vK9VQRYEnMoh6VTpO+kn1G8yGCbTQgevti0WY39GekkG58ggolWa69W0/fS2IJuZ/bpf9+vsx37sx+zbv/3b7f3vf7994zd+ox0fH9vnfu7n2rd/+7fb137t16bZ9v78n//z9uEPf9ju3btn73vf+8LvH/vYx/4P137IkCFDhgwZMmTIp6u87oL0Ph1FQXpftHq3HR9Fi7bET6UAkntqRXA6Rg7fFvPj2GOemnV7B6vovL/IYhMwt+ImFPZJliaeMJFdh1zMTT0QnMD0zaGdonWTRVUWB1prhYc8h5XUbMnOtEG9ty3mbgeLjAsCMBbLDNLD0vpvHYsxA34w9dZI95oGmqmvWYceNlVeC6Vrds7dMtYQGCRL0k54SPCgLqlrS3/I6vPygsX1VNJ6Rn1buIdFYxYC5TTuiRtDtjtm4qp5kD1jHAPg1B/yDJAnWJZXWf01l95UuIef+1Rpb7HqTB3staywwqvK6ii50lqIpzfP9GarTxVLnONHgftVex8vmFVhfGscMDiCd8/M7Vv/7Cfbsv3+Uu9ind29ecaBr59/sf2dY7VjvXYLMIPw5PF66rG2neprWdyEnxSOWhZEx82qfOBmzRb87/MvzM8Kr0y6woJzd1o7lXmKNVbvkMfB+a/habBqLKnsMpYCHhi0diYsbpkzvg5q7CK1tM+fOjMq54gsZ5pzwgWTztOtvQU/ewvWbwniGhpPibwq+m6I5wgpoxlTwYBB7F+kQa0DYUlr5x4w7plar2EpZYpq56Yvc3ZbOKd93aut9ghk1Xq98Bu3wYaGAMpAVeYFt97ZNeg8u2X0sMJmYZ8LnMzgTfb7GPTXWHH7Vuul+m3sT6CdBX2b7tsixbrHCVV1o3ec2XVD0J5ScLsXA3tLCdL74PkPXChIbyjIlyC1giwWC0lvoHGgZPy/h5glsvsuwoecKtvJO7wNdJckKS1rFo8sEjVATjgRWQdG5iasF7uqPzdyf5HpISOvD64obDBZ9HCR5ltmUc3cfJIocKY9XsrFgUCuuHpxlPuePKHabMAMMYFPc0kcUPocrmp3nzIVc30PEgDwnV5fLXqM4qcSz3S/ZCapBalyXcAQsPRhq0AG/mTdz0DeWjFlCnVtyhoHZKVQ2QxO8d+xmTFIs2633k2GC/J/OxsDYBv6FlJaBV+5mxzuah5kjXkFbsqNnQXQkYXGDwSl3foW2kClzEKpb9qlPmJZDlvAuNd30wH6COMYyh95dJuyycqhpBRSSq61h6pJWWI1xjQuCMkhi0M9vtAehxZoLWTZgsbp9wcYJ1onuId4kN5j/urlkMy+b+fvBIaRFcYv07yHcVGknt/+PaAIrnAQ9vvRD0zGov6jUtetS8b4lAXjeSV2+LPPauEQlT0B/j12rLou3MdDsBogkZnu0Ktvqlck7BRUxrN2hzbWUEEkUUtTZl+Qmnfabh+KxaI/qoYMGTJkyJAhQ4YM+b9UXrcY5E9HWZ8c22rbsTRIyPfL0w8z9ejE1QPOd96x77QVAyjkaotuDTNb3F6kQysZbJZU1LAkk2/ULFgIViezhWgtiIDqYjyBwoIKi2Fw7ZU6r+sTu6y0tAgd0fKrLH0t5V6H1Xi+HqyjcHnW70L61mDNQprX9dWWMi64PyXiGxYXc50GlwF9sBx6vYvlSKmo65TRZrYE6xS4wLrQYnlgkb5pzUWsIEt9H7l9ZdVjcJq+nyAmSq3rFIMtB/HCVatKVl9JFtESTLe6DSuk5hb5gGFh49gLbXlxhgt4Fri6XYLGCOojN76sk+SHZfDd5ry9j8E/aksN1ZIV04PswGtMS+FjpX/uPWjvR3rkYHFWebWnRJYiZZ9Tn6h+biGFx0cQjOK+96+oeSPLqyBK7matUtGqXbJoaw6o75iF7xTWedYR3g7PZshvUJcN74oH7ymADEGLYb3X2Ltf5nux3qs/PHD2sQXmQCv1Yo3dNfeKF5zUiZPBI6T+wpo63ZmfE+TKrKJrk4dEaX85t8CZ7sHKolqDhXxJOX/WllfvTYCIBP5iufkZ6NfjijczwrucDlPevOp+Zrxj5j9RhQb+Y3Ari1LQ91Dn+QakrrKSk8fe4RzY65nWOQvGY/CeB7+R27luZ8qd3EIpQiAdvM5O1QaLs99XZcEjVIIwjsxinvFFr4+PbD1NZn2nfZChIF+iTOfntrqi3O9SJCPUwCMzxd3HHOaZy4IDMoFQrDlxzZaFgFGtZVIrEnfHBTUhIA+50UvbyHHYlAGWClf84XphOlSJ94PayTp3DhT6TXVYF/7agDVDX2fY65DOGopxs+gDUqGxsHkKaVwzcnryXyPq2zfWs5JwoMZeO4duWXSut7hAxwlrAZUCwOQeZWP01NVIvez90PBmtnhmT5wgRVjX9W0Kzlc8soS9cHNwnKV4Z48qd782Y2GLpVQofbUWXEEI1KfaaKQQaUypn3SoEWZTuNOKF5fpbl1x0uGsjL2VMJxSZu8AxiAc7e0KSmC2QCoqZcXfLZzvbTBGEEusQ5VwzAFidN6/rvcIB32rSp8t7O1b5u+4evFG+5Dwq0VhnJ6doRcrKRp02bsyU/5Fmus6xsDnvMavsMNSTgn90WHkXvluwIW7qC5iB3mmwEV6vNfqYz90lnYJ96+1Rt+b8CTBO7R2qC5QWqf6AKxxrbEghR7sFYQW+BqqNVaJdaSEl752BhrW1Wzha5YxQfO43BvSWYuLHmw2Cwfxqmmn9+u9iDn3tZCxLmV8C1PNJBzOQe8ptMFRrr1Zc1EKWXUo2XHeeWIf7eMtpzANYWS5cIgl98wOvIM8+1OSfOpQXFJI/EVYR0enEAtHYBXSfo59N9NLMj7oAEE5X/4m84Vwy5mi3INp1O+czs9sIjXGHhkQiyFDhgwZMmTIkCFDKhlBepcgnmr66CuXID1YgWtJUy/CFbHjqVDPM5AiSaPcS/ecgf0DRyEiiQ+lng4BdRWEwS2AzASm+h21FmavAyJ3yWqxg8vSWUIq60KIiC5l0irrnJbkIEZwGy0R28IF6rzBNQ+y834eN78t/M3Fqg+4RqhbEbd+yAIpK4dclpXbW1a2nZgU9C72B929qrvcoYqkZ4pa9wKUcqsgN1mjQjpmpK11a60sM4jmd5crWQw0buSCr1zcbuGW1VHWSYdS9OEdvcyXjai9aqeshbU1U+9ioKPulXVzgtVT/aXfQ4pmwp/Ktzqt3OSE8XhmrPIuWXH1zJXj9j4JrGJuzZJVXG2sghMF15Dsrs313rxwo5TZWrt8rOndcmsjtfT0SJmrsnbLsi4milqczxrcwYSO6Ds/Vr6bOJnJQc21iTzRZoslWPOUmeFUBrmlHWqD8asxRou0+q0OJFU9BaUAY0qdOcysWscIDfN1ocC05DEqAZaCUjWBU6UeTDMf1rcdrNqyrGYZQwkDUoBg7Rm733rXuNdlKaTDGiQoiqAaWnsTrnmzxQLu8A3teZ5ZDmsL91Stb+A5D3ARjr26bAR+0kNKbyUtrV6XJLg8ME5ZNTaQd8DLvtd6BAjxpG6RBdb1rgcdKAk+zNi1lkYsvw8Wi19gcQV58x7bTEi3uE8yxogkujNL0XiRaFD/LWPGYJlFiFEixueQEo/Cy4/J4SHBEZH2LhwMiNmqFO1wGAFdTAYhOcig0WNOMGsWSbqvAmYtoT1avg3GEDDLYYGpcWPZhkAmBGxSfh8ZFMgw4Zju8k0qOqQFMtNG2Eup8s1IioPaAcx25qoL7a6i+7n5ujtXkAomBJGQBhC490VZhZJTK0WgflPSCaeh25X2SOElwwQi671O2PQd/lFH7ntiGOBhVT8u8+ozPSfXtFNOqi3qz8QNbhZZRjpKdHP9elF4yN4DzKoriOynnqLoLBSlDlRaicXm2CILAhgnunEApMADK4PPR7rMM1pDrMW+1kDBbKrAmAIyogjupIQ/SBwS5r+v90f98swCA0ZQriSkXoPi5zjazB3eWwends0P8ISA/+3Te4a9IuxFYN6o38VnM3YpGHhSlgqy8iBeyCw3WDHN80Vp0MIee4C9qpYejNKsw0aVreN81x69wBOTZfjnxMiYyWCxGDJkyJAhQ4YMGTLk5yEjSO8SZdpNttZJHamXzeIJm9ZX//tqe4IUppyg/szCuiupMD299Fy5+RlZQhSchBNXiPoUnEFpqzNGDbn55UY7ivcxytVdNx4VXE7tUwsDWT/apslO4R2qep2i011LLSOCTuuCJ2w92Kr0HcnaBWe4BkYGuKRr15WnmC1BOm5pEVm9rAFM5iF3KV2uCLhzizPSy8712Ta/yU0Z+Zxb17wH48nSpKAuRXDfv9O0NyRDscWavNq06T9Xjz9Z2ou5IUuS+qe4w709CJwJ1uGKScL7Tu98tLVWCpbjLmRBMmSB1BxTkJKgGgo4UoR+B97h1imxMnhAmCynBYqgCHkFqymozVlOBKEQ+0Xhan22JP8AA4mZ2VTGxOpmKVt9eA9uelkh162VdnrT3IcefEce5bKm7Eqd169ULAFKfPKGEoSo2EJZmgRvONFCBuvlGu0W5EZ10DdU/1ZMK9PTc5+sXinrE1k8CLEAS4vzPRO2UcpZXQUbRv295RpXu1+u+sQsQt50XbAIpahW8gvxI2ueI1izcYvLOnm7/V4M9CUDjFtvFfSl53WdnicFQdUwh8QSLq+CJ51SumMGdTnfe1kzBbEhN3PPA5pY092CSkujBwQrELbdK5agbCQ1Iv999Q6tdQ7HE/SALBfaYwRTc9gToBkMdpOFuk4MAxiKr+sKVL9dvFWASJAQgAHSaV/X8A7AWDytM6y7qVXa+kwZSzCjpeLvRDK1LDCQPM8uid5ySAbE4hKkxiAfb8rE6pCGu4KY4UDxsX1wSFHARMpYLkj1MhfdT+yxhrJG7NKitLQKcIAaiBx+H3E3GR+0iKNsZhR0YaIIXsd75vphoTtESk/FOMEJL1HFpT927QJkVi3KRcSgIYwuM0cFKqYssl7jQ99Gm1fl+vJ2O+VaiSRXX3vfX2vaKff/RFcbKfaIF6+gBg6h0CJLOArd9MQgMkGCIAoeoY7I+lpp0W/alO8UBYCKEDPL6bDCRCAqm22RovVE5aLTIYuQCPWtxpzK0velG1uKNTGtxBnX/aR7pWTSlU5mDdKasRyvG+ifvC7V5n2tKJMF3zwVfPPqxqtNGRPGgZT36Xo5UN0udVb7peyWuuw+Y1bi1zcqBg1CRXh4AHWYs5w8UQ4xUmo5RtX+TgIclxqPbLbMP40tKfpMJKLvz6yEa3wrZZwUfrhiVHBmDCXwEEuFlA6tsXqnyijZLP0A6MlqyjcSplWGHlJV2jLXJ2RCMzDihEyYiINw7OqhJB/XF4OH1tRAAeo4YB3CxJC0a/+G4SBk2sP6WO8tAb8tDDGzdSLehclNAkWbyiVjUrUueCKTdduHAfaRJcJKIJUBUtFTmDMlOknclUEsAoMWE6X0EpEkSdGCMGFZlhDlITPpDYjFkCFDhgwZMmTIkCGVDAvyJUgdpCcWi5BW0XJLcZYyOUtR6WD4cjry672ACghJuQmsv7Bkde25MrIAObQ7A9iH/gHBvr+GLp6qPgxmcGttchL3wIoDaUO9vbSwmYXI44MWcTKL0IqfRP2GYKHevWofLRBJiukVOToROOYR7LAO1WXVwXNmtaUbkfXqQwXxMa212gLLFflV5z9KvWQRorci4xZ3K2/5XfANwSLAzOFWvtqKSyYFLq36mwF/hCIQBqA6yLIqa3ed7lkWL5XlcA6xj4BxQRY43c90x4TBaCyfdNrNeVgYIlYMhGTCFI05JRDJAqd6QYmSNeafzzlZFrFW0LLG5whBIjdzLbBOhjTG9HSoXRrHcud7EpvEWq021MxAgi8kiV3IUuGBrw6BK5AKcqyjnW4drT0rHsDaruvOciAhuxI9KioOTEHen7Iw18xAtPwiMDIEuCUW0zRYW/3nHsTq+Yt6LpErYGLwdZJimp6hBt4heAK49YOgvcGbnFhkM2astuhV/15YpzMoRiAAOBBQ16tvVZnm98yrvib0ZrV+KAvywCBfpqzWy0B25TUu6u4mWbesBiECFYNgI5oZbRjummgfC7RvVikIwv9qYGkggQ7GKVroVlLVjqFAqS2dqFPHajEDUTJBhNnaiezfN86yuB1h0Ou5XiSvFsSEVWTBdrXfaSM8sCAUDwCP0eawr5+0sDs0hjiwoggx06CUL2W5K9nrdnKrihSdGZoaeEe7WTEhiG+QTxeXohRC4eXU91oM5d4VNrGXWUzv1hhSxi25mrWZOV67de+68u7Y1PIvKJdWby4JKUR3V7dbFHHabItSvoLi58wSwGBKSV05DARu9HMolHU3SMGRwoPEAtMzb5jLLtjTqWBMV4G+DvCPUufdk/P965fO27qb2e6Nc9nCBjvsQZCZAmOYni5lCKZQ+n73WMlu+cp8fXq09MO2jE0lLUHSn7q9uyeUna/0HQ+A5b7ts/O42Dxfkm6UOborsAevm5I/fOb8vdd3ytyq5phDJV6Yy9q9ZU7gsn6xQGk0147LXBHGWvNYVHKiv9O41mGuzAvHi9c4Y6daU7sxJ/gd7/TXGk9888JLczl6N5lj6gOwkuso6yQyzPlBFxh8wX8Cw46uSwkCrWPt7mdWSc++d9TuZ+FQLWqyV240dXUFOGCa27V2LqPNQun3XintUQZUZ0Rp4QGe3ESHEyrGUtZF21l9Q9+PMiUbyaIIT1l56k8czhwWUcotMI9VB+YQEn8w462/osQQ0Wi2ATsRYXuAQ9TtnTKjUhHvS/RPUOaJE1f/MDanvpfKd6Cv6+sC/g7COy4oA2IxZMiQIUOGDBkyZEglA2JxCXLRRCEOa9Ap1nOytxCJNJFIwtV76PmmDFh4wzO6HxYGndg81aOsmDr1KRq+xxPMQDjmh1f0b+kPsW8ElgsmGkgYJOqTbeZyI3whWLt40gSsg+4zP7FXbm8mMgmn14Tc3q0ZDgs5bussiAGf71nJaQkqFlIlBFD9N7JIlUA4WgvcCqKofsEk4PI0q6zLsnAjQtzLKpYSMmq4FVjuY1l/Ced4BDACq9yydHOLdULt1twq1vkAa5DliMFaDLiqx7n6WtYLDxRsE8N4kor7ZezJNV0nHanvh2UyMDeYLck29IyzkIido01WsSsW4rUC44obf1fuW9+oyjbzZCCre6XOFXzC01wroYfar7GjILs3PjmXfete2y59ZwVhqo8ZeNcb36V90+OlfnfLvbL8ykovNg+NFX0DBW0inbV/b8JeagiCPAWEkhBqo78ZZIrnHaIB7ma3atZczAhkDRZfBBu7dRfB1Ex85B4mMWtoranmmDM+CDogqBMtgLLyXm+9VD4+mHxIbUkSRtXtdqYMrilX2nV9H2d6/RwTRbHcuqwAV+P6zkBwQku2fe+t762yXtdWe0BB+K7gwTwETXBPAfbFzl7l7B3wLgeoyAUhFCQMIAyk124+G0gQuG+z7OqdA2LxiyTTdlu54CMJOhkEnErtBLgZuA8y14YGx/qRFmcpabBbyHYUMucl+KqQLYeDu9DLaGHRZt/UBVgrX/C1oJayN57FrriUpTCTTofZvtDGBqt31rrMnGII/REUZUEQxAxSNo5NyXbmMBcsku6Gs2ojoVts1fahZ4wSLZw2SrgoPcuVoAvKctXbDPxAVGAaopa62yqQ66fLdUWvK5tb5b7vicMotJHWmNVEMVYEvSsK6hcooz5umd0MTBLTreLu/oxn/dUrKTDEe8vtKcVY1HAqW99EdSljy5kTPv6pUm4bDd+T3TOFju1nPzlfUB9JySxu+rP/501mZnb8HCAl3FiF8XxDgSDcLHPsiUqh1l6lufPsk/O9RRmdBFd4ai5jc6P9vtvHisJ8D9+kyOp+UYZEJ1d979WDsokpW58nzpj76PyzZtjD0admZXRX+mGN8b1969wfm5fL+CAO2hXpZY7tPqO0s/TJrtRvrTkk5fPxtu9dERZ06LRV1py67dW7bdterfpNY0fjmhCLbekXMooIMw9s9UJBWT6mMtap2FqRPOormc5S8eLLbZlFlkM1IARUrHEgWFdsLcrkudbhA89w3jOJia+V25KtExlCnSZS8IHa0KN1TIdoKoxSrqWcs25JQg1fUwkDrA1c2iPWbV9pzXdmI2ecaNkq3F8PwxcZKhYatIo6U2sA2SwyBih/FQ1fOBAI9gLFel3B1pgpz5Xoc8TYKP4qYchiW4hlduW3NnAlVLaBtUJlHCr7IrjnSgbEYsiQIUOGDBkyZMiQSgbE4hKkhlhsdnA3dMi+D6WhbgDy1nET8P4smrQmy0b+9IWdoO8mCTCNJB3kIU7mWtLo1wORtcH9o3bRtbOHDDyNbj6UWpMnU53gE5hI4/pU/a7LUt4PbMsjifsQm5AuWlJPZbAyuGtSFhUEXbr3QlYQjQ8mK0mi4XsMAw6RkFVTBPuCoTh0Qvywm+bvkIKXPMIaH3Waa1kGnb0A0AjCWJRK2Pl+MW5lSeL3VZ17y6dDC+619dO/qmMRt1YKopBxuNKlX48nle0BnuKDFQMI+kzzoST0WZ2iXYLQCD5RLMgGDlgz86Qk08lcpuAZnqxEVldZhGvWkbqdsP75GHYLZGlbzT+se5lqWdfVfvUHOaj1To3Vc3gGyFZSB9ipDLWHKcQlWnMA+3GvDRgZ3LPmSUBa5hizymskCzASfJBrnCmmU9gXUooz8Kx5t9ZGQigEDdnHiV/Xmf1F6VlxKUgNHTyEWkvJWUxLshIfyfpdQw24zxxKEc1U3NjXU1amA6xOZhZhDomQQSItcw8LFWEMTFSWvSNjqcqe86p02DsyXSHTW7KkJSPV9JAhQ4YMGTJkyJAhPw8ZGORLlNXxxux0z6mPeFVgiXmq38flZ7ZYHjxI7QpO5NWJlfdWlWr+ZOCXsLee/loY3iRYzU9s1amQmGnPNicL21GbcYj0MLR2rx8tNHC3hUWUlReBc/U1WnqFUcO7M05itxyBookY5garJwsQKeKIyZKV5h6wirDEOKaL2bFAXWQWLSHBioPMUo5RlpVPZQsXLQwfqJz8W9VWPadz2za/rcUxjUAbt6Rdf7I8D/q7NwCzyex2tSVV30dBecKty2qtPhIWH1Zr7xfNF1lrmSVNAUpPLt97JQuavi+xprJGPlrqoqxgd+b6bwtWd/NiscCKak2pqIvsSpDe+ma1fItD2i3epa+dx7Z4kG7fb66vCo5QtHBOh3YqDO95U65w8aJHq8tSwN/5Z8yUc0cvFLyv5rvaLSmW5d0zT87PC+97jr7WvCltXNU4YM3vUobjoYuVfvdUofnTmBNVHILvtm+an998/MX5uvrzWsHD3mwDz8zMTHh9jQ19d9VbY01rguNEy9qjOVPGngfAcn3QGl17SmRJU9/oXczGScuxY+zL2iqvDlOvPwKvV52VNazPZ+0z8rIR16xvIGpB4YgZUMvg40p8ndX6prWD85Z8zqTWdErNdm/1fSJQs8WYkhA4x4Ay59rOaN3KfUxRXcpbX1nm92JBBZ+3JNC9lRiTqyq75ZR2fLfHx6CudTuEf1Zfg6Z12srDfdT8Tsu5U9CRwIDY471e98Tz4Q8UHSHJ77B59LpN0wOzV8OTXRkQi0uQJlHIGpP6kAvfquA9KGlM/5xFiWYJJDY1owISQgTXUlnEtmWBXDNIgTyJSKNZR57W95tZDDA4kBglpOLGYFfdPWBOwWq9fmLZUjIRMR7SfAoWoQWVaX4ViayABAYSmi0sDQoQEyNICfjZlgj6kD4UrA4eSKFvw+A/KatiZDCz6cWZUzUEGyL4bg2+5xXcgr6ZexALlNeeaIy8cVb4PChPGx6hJlKcFJR6CvexRPPjSSgc1X2TOFalbEgREiexK/iAd2iDVV0YGEi+ZLEg1G1BUJ0x8FMKkeALjxfl7baUkKLUKhDuFhRG1U1zt2JPOHv7HKh4/ByYJHzTKUF6j5dgPAXpScHclDFYFObdI+VQ86r6oYyLAqNwRbR6x1YBgK+IQ7uUJSW1PHP+1NyO458tY1QKlOogpowyHnZvLhzPYr/oBIRKPADwU3OQmgdIXi2btHidpThqfLBPkQZdcBH7xCf9XW50kALszCF9FzzTmTu8R5zcGqOETgkOVAdGgsc7JNsAJ7crygz4TtYQXz9KG+tgP1+HSrt3N8o6Ji7lJNDPg/fEJIN1TkquDuXOl1y9O7I1tEwZ/gy4lZ2tQywVWsf0vO7fgWFCB23rJEKBIcOVdqWcJ2MEDUXXAaVRsT1DCuEoGRtFERmRuK+F3AEyrpApqpJDDFeUsJ9Rj4HRagIhQA9GIyVbcNPs3mB8JNPISDU9ZMiQIUOGDBkyZMhrl2FBvgSRBflLTr5qCdLbE6SWpr8UJAKWVboZ0sA4BOLUJz/StWW8h37iAsQiZBwq1jw/yZGXscm8hFMeuJMDVY/+pTXEG9MPVgw0epUwcMIhBXKVKwMTyqip8np1yyhsmjKYQpV8p3IHkpqIqZplDaKrtnP/qlAwTeJ51XXQvWVQCi9bFji1RVy9xbLugXQVh6+7adU+9ZXz3BYrJC1nsjDLUqalSRY6Pc+5VVvcmApafLjF6rwq9Fc+tkjf5RzLCjAs3xeQilXJYDa96emlGjdLOzyLV6mLvpcCxgTrgAVqWyj3Nj83W+8cSlGgB4I1CAbh1l2r6M0Kt/ICoShUa6XsoxtzWdsn5vZtXirWvAKx2F05bsqRRXn7eCm/QBTcEluX9XKBTDw613NdMuqpTNvA4lbqr7rLwqw6b0tmPlmkPetdZb2WRdv/Vt+8VLxKxUrvWThl7X5yvr75xAypcHjLJ2/M9zNlN8aBmS1WZo1H/SZLv8aUPAdM/yxhcKI8T1qrPdV61VYFeqpsrS1ax+QZY/priHsAxY8uCrdCg0johpmFDJn+DkFAkGrdLcegC2OgsCUBdk1/MQ051s5IBwYLIuBf9PJxf6uFlk/y1xMKGLysWqfhQfP9T23RflcHwpIaFhbU1FrL4Fx/6YEg9UpHCTAUQEvkGQ5e5yRgjnVL04LX1SHfscpGwH6WO6LOFXE+ndkPPfj+C1mQh4J8CdJALFbC27Sm/vpamtP8ghGm+6I+zexCaRVTZdtTZPcjUTmIMwW7iURNGC9C/Q+8g/cHdxBwWL1nXRJi8ZCC1ZXPsvAgZXemrNdlB5eZxgHwvL7YaaMRjIMbZSeVuJk1keYrYGXDppzwBJOtwkX9QXiH8O8193Qv4r+uN+A4/j2vwjU7oZ1yXZPloMYbHrd9EvCsglToWX0TuFhDimlgPg11rH9TWmfHDiONtWOS9Z31/Qsfeq18mtmiYDvTBuAhVkEn7raKgY8h4RlRtmOKxWYhblMxiVxr+0F4aV6fX656aYNvFeLAzqHpLl7jx5ZDlpm1yqiZTVIGj6rNuxxKpqLIrpi0g/0gTDHTezuuXwf9Xfu8pB4XUMIWppTyrJTY64BxaPx7qmod0ko/XC9zTNCFDQ5WZgsMiYoD54jGljNiIF6DGGMqoB08MPGsS6XKO3eJ0qXfyUIDOFCazKP3Tsap0KV+hrXIY0+wBqndSBg1dfZv/5twD4lzpUPRhapFRXPvuw8wP2QwRf9WML5lEARJrbcIz5sZ7mjgO8QyFZRaSU9ZhyEvZdI4ZHwcEIshQ4YMGTJkyJAhQ37+MlgsLlNW69SialZZlcFrTM5hQgV2Z3IP9C3Pwb1CyIVZbs1U3U5aq7Pe5VALBSjghLqU2/KF1pyPbpVVEJay38gqoTJglQ1WXFlvJ3D8ShAsYVYFlNQR4FX75WLbvdqGtWapWlcl+CGNIq7cZ+sS8OKBIwr4kEXhQQslcJYKMG74cwp2YRBMuW8tC2X9m9ojqITYKK60lhjZNpzTVIEmXoerbR3U9+rrqt1eNl3Pj4DHlwFAU2tB8b4mv6zGnubHW97o7/YUybKAiGnALWUlS9VTs+Vg/cIMlZA114O5bhTL5JNzHTxwTBbXcr3mf17dEsRg7qvNK3KNH7dl70pArCAVhbViVRhwdo+1wYl6w/23zm25+jM3jDIh/fquWLHFWqG/ZUHe3GxTKm8LdGSj+0sb9PL1q6WvSxBcbcV1+IL65lpp59n83R68aW7nySfmdu4E17hVvkkZLwreO/pUGXtaS2U5VRDf/cXCuHu6fEfBOQp0wgP6Sp12T88QovVLChjVWlPGntbKUwVQFou0uKkFmzitrJtKz606vFDu1Vooy7DGrdZS1eVjz5VGILjzToEoKduj5mKHazyk4y6c2lagEmS1cBH0QPuB1m3VWZAiZ4VZns+sag63yqzTYo5wBgVBxMraZG22u14gsO+vHuDFbG4tFNADmgOEIoHGySKNYLCmHb5flXasH7R/c/8lKxEzn9IDfOWR0P6wh2qf1v7FAEIEBHrfb7QG7c9f0LSb30Hf2fWXxOObBfgzI7BbmNtAvLmstv0h0F/3yQNWxp73hyzKbs3eLfrDBWQoyJcoq/Wqi3mReASmY476yTh88msSyF3ChCF0zROqUU88pYZOcrWHKFakWA7uE3fzt64cf11NURMYM641z/BvvcuTVmCwB7YH5KNv6M6QtlsTLURxq2wpSsQxZ32t+6C8mpltC041wDzk7lUa16C8og5MMFC+yUJ+r0jtatGn2xLMEKqbNhDHNwPn64q1U7G16VR9s6hcVc4kIUXhUSndOIQcF4Ve9WY/6R3cxOW6LOW6kluXJcW4YLCnkoJXFGFrKT76XhofYmsoaZyl9LpbWFRjJWWxknyYmSsVm599Yf4bTBcqS4wIwuxygxRMYnf1pHn+6k+1sId6mZcy6uwTUhDhinUFuCjhwgFvCrZYGF5P96yNSQq3UldXNG+7ohCvhW9+ZG73USnzysdvoozSH+VbbQuN30aYarF8CDahA9KDCHtQu4WR9j7VM8JUf7KMEacBa5klnFFE1HufnHHg0xtnBg1XlOtvpZTI95MEJ9O2uU/f0dOWO2MK4DpS1sTOAzpHM1vStEvp0t8vzPX2Q+eqXRs8NkEKtLDqmueiXhNFYfl79/Iyx3Tw15qw4Hnb2BKJK8xS7rA/OTZZB8k7UPbqRCFkUUrgHhNx3eoHJCUJjElH2JsruMha7yx/SwkjTZsLjUZ63pXTtn2+T562e1X9m+/PR63hKksZHWCH68KktIcxoqmLVd/vtIW+LMwfZY8hZJS0dwnmeMEkl0NN3e5SJnWDAOM4oK8oLfbqypW5b5J8M5QBsRgyZMiQIUOGDBkypJIRpHcJUqeaVpCepIZYhKC5JGozDeJ7yL975YeAviTlqOogsP6aJ/QksC4k5jALAQIpC0fGB0wXTxJgF67X9UKEbZqyFG4gb+8ZTsmCB8iqywjkqj5MHc1AEQaILNHgCFqghYourE6Q3gSX1JKMpXwT8uVSPEgTlhimm+255JJgUofWwO3p/6os8srSJZml3DaLTBFIoRz6UO9UmbLEML2zLHOyPBaLnJktwWbqKzEg8DuqbAbtwQ3urA3FSuqMDT4v6nuLVfkBXMnoG4dByMUuL0SBkAgGwoA6h3BoSanKPX9srufmzllTX6+LoBGyxsvSKLcori+NwrxHwF1d39UrxeJ9HWWQ55oJg9SXTPcrcc7qArWpU1G79wn1InuJ2qEgPo01BeXpOlzxYazW3xJBeGGMMWU2AsV8bZVlMQtm7oivKWW8Bu50ztPE+xYCCcWG0YOSUMAiFFgqmHoa6cydrYj7gL5hJ3htArwsy1uQQQgO7Xt7mSWwjwU2qiwNNjzah3IQ9ALps2D/APVcJ/tSAtHISAd2neDETE/JSAYyooLVejUH6W3/1YWC9AbE4jJl2tnqChXEauFh3nBgb91tsGldqD4I4Hr3gbfSv63LQll0zKrJy8FYrm+Kq12JQpQVZw3GAcdJg2Dc/3a3U4VBBr0NcUWZeGKN6+1iRoyTu3LUTzXlmOjIXKloF7mFzg5MEVqA1R5lINIBgMk/lHBDm57ZkoQB2ZscF+fuINDjONa2bP5azOX+RAQ24RBzvVtKJfXJqizqDm8R7ZuVujCzojaUKunM/CA2kGrznoprefXk7J4WPdsKSomPf2CsBcVYiYJNCqU2TkEXRKNVK+dM8KGDgOjumOjjVvW9zOz82VnhPfpZKVL6JmVuFRYEE0a1djtqnEtpu1vmaYFEnL9hfufxp+b2TVfEeFPaVb7Z7tkn5+YWOISek2wEc6jm9/lj8zuOWhSLK8LrU1CuFVndK8k7nikwh/LOszeULH7FNbl+0LJ/OFuGmUNezp8o8I4ChdjcKYfsArc6KmWdPVMgGDfLtxJMS9jlgpNW4pDzAp84/pToAKvxD2YE0dltXinzdlUw1oUybn2vzIf7SNbyajtHtyhH8BCHnpgtUCkpz4AKCUrj16VQYTzrkLX61AyPcOiF1scO5ZgfpnS4kgLoLDTlbynfyD7ph3MpcTroib3kPtaDet/QGqr1hol9hPv2PaeseyVbn89/ZO2z20goIqhctU+wPh4jokOX1hpBR7RnlhgTX0u19jqTTCm39Ie76itDie/HeqdgDeUbrD2ZEqAWTs3WrvNenpR0HtYq5U7JpXZlvUqNYE4x18ITMzankAn3JB5OXF/RXscsrQ77ELa80L5pXSeN26bVkZYYq6O2vKreVLI9XkeGKyjGzLzX6isXB04MiMWQIUOGDBkyZMiQIZUMiMUlSJ0oZH0u106fX9BsOQ0xCE/CYLwUBnHUWoMyt4mZhcQfwY1zgLMwBAEUYRAcr5tZIC8PAQIH0mgaghlJwB44e+t+Yo56BukFsvqOO7O+H2wIdKvWUAOmqQ7cm0q2Am5hD4QrlglGLDOCm7zJc33bwJglAAhjRjzGCt4p1luP4lYCEU8GUKyksmbr3RX/sAf06V2y7ty41V7XuD9r3bwhwQoC6dySLKt2HdSj7wamC3ffA7ahIDvnLD7GO8GgsXuyMBB0LLJMbxy4iUtZu0fL9ZIAxOtSLKOyoCrgziELsnrKQl0lzNg+VspEgg8F3dE6K4vz8QslCKtYxrePzHU4KdZawTpO3ziP0ZOX22BcM3OohCAfKuP4pRKUWPpoe719p1tgFfioBCFPCZpSuqe005OA3Ip18KBD9bXSXCtpiQIACccp43xbrPaeJltWULFiiPWjgjFN5TuubisFtrjEZQFEUKHGs8Y7rbsa3xp7SMVce0qcI1mJLpAaXowZsiBqLVpXkCCziuWnJO0hy40H/ta89vI6MaD3euvp8utgYEjTRcvKJ8sxmDaa+sq7RG5p7a3ac7TG6n6xc5BRAbARDwyv01x7oqeWczlAbLRPuZVT1lml/WbK6navdW9lDXNAEpIACcr2fnhZQyIwBsB3GETIIOHXEYRIazZzKjg5AaAZOwbz9azdHT7j5u+Ek5nP22pt59MD+6HT7xuJQn6hpMYgH19plZgmI02Ck3EhyTciUsNgSAZ1yExnlXsky6iHwZ5m4jmQ0z0QrltnQdR1UbI49KKlpNHitimMBIG94RhKoCZ/heV0JRV9G9xFiKReFj1NPMBcEpqghm4HWZxI08SMeu4mZKYlLSSKWH56hi74Jqk6dbBi/v20qYH+iRjjVaH7cmUWUAVXXvVcYYewF15eXpolT1HmPNFWAZvpm7PqrPu1Eav/9K++QYG3mNkCu3Dc8rp5h4+tovg5dlXwDinMhaVi96a5fetXlBVN8wRJDszMinJ6/hlzfY5+ZmazmJ56rHmnlDhBDY4/XhgCjtrxrwx1Umrvv3leWx758Tn721S9e/tkOQCI5u1o/veo0LMtbA+Cs5TvXRTp+2+er1/7uaIwOw3aXI5gHffeOvfPtZ+56e+WAiwohSikRL324Om53sc35jJcUX6uMIyUTHoPnp3vO/lkqcPV1nAg+MdUUcydfsbct1c+Pn+vc71LSnjpD88EWPrDvz/w7EqE4ocbteGNharuuVtLhUrfbJ8sGf8+Pn8XH89KGFMoA51KUJkDX77VlOM4d80Lz1p5tyl3rhAS3GjN0Fy40bK0OJxB+5GYZcS0Qxo44kZrbDfWpwkHV1egPaMm9iNkRvX9AdSUZJxo6ilF98BeELKrEp4GRblmQKrrbhYNOmRCWgXGiL7hxhVGwhIdxqc9qkp4te7vu4femSnGzBQbjFj1HkpdBvuz6iSYZoBZZrFHWcKQun3QCYxjAvoI9RtCUabzs4fCIA+IxZAhQ4YMGTJkyJAhlQwL8iVIk2p6XawGHStayjqBk5bfT/eJBNx/WZTpPgYNujcIrUhTW+LEGpgzVH7lymfq0CxBysKrWNxkcDmFtLF8dy9VNWEaXqk2qIXuMz+RkvcXrqsQYFf3MyLGaRlYkZ1BohM6gvhiexNWC6usHYJQkLVC/cGobyZUUR08UQii4Is0AZfoa6+L4C2ekhf1VzuDi/W4aUtIJFPDRlQ2otbd0iZWCl2Xew8BR34fmQk6Vq2loVNblqfeBasH+6dAJiYFM8GKSTYHWYObwMij1tYhOII/g8A3wReU3npdWCz8PpWH1NSCamxuLta+XWGxcGjIldZK5/zGgi2Iq7nwB3sSFn9g3bxLVly2aa5/GVPFKu9JSsjmIXhGqYun9da76d2RNfwUqYrvVFbOE3ib9C+smG611HcXBAEQpJDmWbzhmpOVRTGkbdYzukceDvF6a80hAwO9XBKwt9TzPTBGhKDb1hqt+b4rniDBtnaEaSXzpPGo0RNIdgpZ3bU/HYBDMOjaE2+A179+ZmkXLeNgjDjBOneAzYHX68C0CzFdPMzvkoQRqqtTJOwTaQKQJDBwwnhZg7WqpzuF+k/QARJ+5FB3s8Fi8Yslq6OjahK1LAlmVtECiZ4KEyahIAsf35U0uXuBcXK6ncVFyUE4gb7NlVEqmxJnIJBLK0aczo9NzX31PcvC0eK+GJHqbA8ncI955sDS7lMsWHSnWaVcMjsdImkn32h0+JAbqSgOxcXobkOPFm+Tu9TfeyFElwJbyt4B1iC3kCKwSxm+0ZDNQ4sXMw3WWfx071m7iS2HKmQzdLaGMj60ET3z9Py3kn945jy4sGocvdqt7/3GZ+a/BZWQKGuXXKuFWULUY+HgoD7XuwXvqJlD9Kwwh7eLe1rMAGS+IP5d2MurrfKzKnjhXUlqsX6pQDCeecJfvS6JMdydL8VOSpywxFLKNB6KQrx985Pzc3eB579dor2Lwrx9rCipt5f7dlKyRZ12ps2sNO/6XIdNUUqnK/N9m1tl/JcI+/Mrc58fFco23ef94GwJywa0LUqp4BxSwo8KpOL8iTI+BdeQYlyUWGKOPekJGDd2hQ3EswDWv5U+V9IOYrAdg1zG5q4wKmyKUr8tmQOFdybUwsut1zuOzzL/dm98ci5LyUkeKe3QOBcOWPNYCrVDbMq/Be7kSu+Vis2EyTTInKCyBHtQmZpzBWrla6lgDmJJkGL9aktdNtdPSooOUUXRUbwC4zqOQB0m5fsWrhdYkKAWDp+ojS2ap1rHBQkkJle/l+cc3yx4l8MFyp6SZLlrDgZQprv0kraMEYd9OP1byxiRxtoom91Jh2otM4YxLoeZNcU2JRgHlXvUpck2RxjH0tD5H1WTEE/gpn0MiRkHugcTgfXK2EdH15QRlOzlvtW0M+t3Y5ABsRgyZMiQIUOGDBkypJJhQb5Emc7PbXVcXDQ6NXaSVvjxRaeidRsIR1dFcGEgQpdE7X66qlw0uwdtqkY/iek0V6y4W1gmPPKUKZllgYU7yU/0NYejrI6KqJZFVJZP8DqvGRAGvsmQ5loWC3JbdvpkjT50zk0G84FI3qOcwWHsbSyWmV1lzWQiED0jPlBP33oKKw360FO7Fm7S4KJXcFvNgywrBziVQ6IQWR4QUOMn7DvlerHWKqjHLbWySFWRyN5XHjBUrDayHMnlqOsKACplex3FUiFLjdye+r6CYtTWLY1T8RuD39XTVisJh5gkBDkSa0FhM5hU5/ItZYncfsYcKLl5oQraOm6D8OSeX90sQWfF2izbhiykq2JhPnr+hpmZnX3m3NeywIpH2WEPnut28aCcPjO355GfuFHa1yYOWd8VA0axJBcO4l35e3dcLMrFUprBJB6Iw7j67aikjhZf8fq0DWxVvY8LA4agE3KDr85L+wShkFGrPH9agveuPlesm+eV5+isfdf5k+JMVrBwy4O8uTHft3lx9macfcb8TdTX4q729NdKza1vdbdjNVy3HiKNkd0zT85/KxU6E8cIKvaUeJBfbvrFIRjO1FBZ1JUKWsF4Es0lWFIdciDL8eNioih9Ks+g+Nw/VQIONfdquJ7WWWe4afvaIWJal+V9UBCyAoVVnlJQC+ag9a54rWqIEYPM1E7x0O9eerm5zy2oWt8AwQiJUzyxkLxzy5q6IzsPZP1YgY5on0uSmHhQW+FN9vu13h+XNvbSPWPtd4YJ8B2TB9nzGWjfl/fRLcllnzvrJArRPEUir8BqUbi3d2UN2ZTxrvuWdN4FciOmJK3fglZV8JbFmtxCGAN/c3l3Cg2tLc3TBc3HNizIQ4YMGTJkyJAhQ4Y0MoL0LkFqHmRPNU0KNltOUinOlwB7AOYDbzLoVjIKt+adRZgyOeMgJk2MP59hgJDS1MwCbipkM0Iww86xyaCOY+Y1nPq7FHOwUjt2GFmq/J2yENNKj34i3nnB0VW2NVhvGRgnjB0DAQPPqMRxz+Vb6NuozhVNkltrFAgjPLP6Q5YjWUiBpXYrfRa8phS86p9n3rDUs1iGfYzJasPAOVnYlbVL1mhZJmT1lSVaVvukP+fCWuo45y9+erYUrm+2NE4mKjFZ2K61/SHuYbduFOou4Y3Pn1wyDB4Va7JovLbFiisrpFOOibO3lL26pyxnwCQ/WyjnihV4R1z0g2VeTcUCLPzvpmTI2xWr7P03zvW+8kpppwyD53N/PXii4Jrvt2vSUcGgijdZJpXjF5ex9uCNhVrt5ml51zxmju4VS1n5V3VrLMBmbhHfFfyzLNC7ktVLeOi7n1lo7n668tKU7/vgzbP17viVMpaE/1agn7iTyxg8f1OxHL84l/XgLfPf4m728sU9raC9qs9DSmh5/MpY8xTa5ClHVjsjZpcpyDX3nlrw7lPxPq1EhehZ/Nbt35pzCkIU1lgBgLIKik+ZdUM8QfMOBM163RiUrbWIcRqac7jua6/2u9qKK4uo1gpZgGHV3okCU+syqVBl1ZVFtXgQPdZEf1feSLdakm6Ueys8n4EHOdkzAr1nTTFHC7ck2Y+Yapu6h1uO4c0IQXs9URnMZKt6Sw+5A6t2h362+3wH5+/WZ42dhO4tTaFdBfMNHuRfYKl5kI+sDxo3s6AQp0qmHpXbV64ITZgkmI8K9b5o0CyFY1CEybmc5JUPkkXRVmWlpOdcgCWoW6b0N64pLowItEgThuj5TgBcXZfAQ7npHEpUBw84ALsFydzlJsX93k4tzCSur9+tQ5QveCJQR7ISP1S0C4lvSjqE+SGFh7pOFHzGxUn2Fnd3gv+V40CbwpUKSmG2KAF1m3SvR/kj8Inua313Z7log928fWIzQDT81AnUWWHB90Cv01Zx8FTT5fqqKN1S2s9L8JqgUh4oVvpPbBDNu4tyKSjFpEBAufNVbwVEiS/2QRvUJ6VVQXlinDh/vCgxVZCeK7RFSVfssVgtNkjSIR5kXfcAuQKXWAIN278lU8U4sXn1XvObH2AEcykBkZ6c5bR1rXtQqtaFqwioVMCks0TUh7HSZ57wBvOQm7gn6wHUiIlCpJQJ9qUA01rxzBLi7DA/EXTr81f3gVlGSX5cCZIiWq1/geGAKkSWMplzk+u3B7OddK+bWQiOdvGAPsAQwWPPOqQMQf7umObbjQ06fEv5ZM4A7muZ8pnxAPf2b0BAXJgQizkXEMQXWDEk+xg09LcgFvfuNfeuwYAUoIDs44xB47we51B0mXLaFf0WUhEYwKp2nk9n9sHzHxg8yEOGDBkyZMiQIUOGPKyMIL1LFmZuqU+BbhF2d0d73dM6P1oCvm4XNzhPkrT6JqfDJlNfknoyULDg9LtmimqHjrSnP6+D4ANn1QmU2XB0/bh1qfH+HdKEeiAdLIvMIuRpRc0qTl19D9RBJ+9JZbfuI7cUl9OxZ/9jxiW55ipLi2eI0jVRDx23rlUv+zG42uTmv9JmefIgPwWkFItGk0FQZWhMyBLOwAoF+yDVqlukaGnZwX0q+MNp9Q3J26tnRVv13Kfa+2R5OIdlRXVRW8qY3X7ms2Zmtvnp5+a/P+Npf2Tz3EttmRJZzmRZUmAUxo6y1ymIa1eCu5aAs3bJrNM9y9qqwK/jn36h3DOPmbNn5nEpN/79N81lX/vY7A7evrG1ZqyL1VrBa/c/Y7a4X/vEbaOcPTG39/jW3L4HT7Z/b6+29b7/9Fyna5+av/Pps/P9m3vFUgPTycmN8p5CMXd0d/lWu0JHJQuysvhtCtXcrV8+j9cn/8cMQTl7/KR5bqNsdW8oAXYFqnFe+JXV90flulXL2t1f/qSZmT3yv+cKnj49l3FS5s5RgXOcPTN/15NPtfRv4nmWVV7UfE7V516N+Z9VPbZLoPJOFvAX5jpMJW33ip6jUqftG+bvuHleNHBVljqzZX3X3JJVt+YX1jrNYFyljPa1oXgvdrAcy0N0B+uY4BBaxwst2upNzy43vVDmGPmftRcooFdBuJ55TsHXLf2le5IEB1Oqdr27TvfsqaDb9VqWcK+3Av5K1lEFRBPmQP5jWp5XdQZBrRXyPoqOM+G5ZwptBl8HC7Pa6PtGJ1jNoSHkVEZQGj29Zf3T3rgTxE5oT2T39f3dOhAI/eu6TutNdrii2sFsfsiguwgo55pnyrh06lR4oV2/US6FPmxjd3Zu00ME6Q2IxSWIY5CvfbVtztsP17iLgCV2QeIPiUMrrraK5KJwbrrXA7fhHkmxxQfcRYsrvs9E0UsU4oNd2Kx77SJHF5u7csCsEeqm68LR1e4n4MaIzSK2S9CCoABjkdPiuNUiLldlzYMMrJkv7ki56huHlFfgo708plUt/afo6cYVKVyyFF2+CwT6jmFDVPyKkfeOHyyuayjtZua4Z+f51WbMpQbcy+ZR7q807fSUu8TJaUxWvNd+aHpi3ghWL83tcYVYaX+1SD82t299+177jqtwm6POrmBVB67VLaUEnr+fK0IlqYbgDedighBzQoEB3H/7vJmfvDCXsy1wBt3n7A9FdhVPqrDGYqGQci3c8vZa+f3OfP3uZ859ff1n26Qs54+KjUYu6dIN5fC2fjBfl+JtZvbgibmvhDkWfEPQi01h0LgvrPLts6ZdZ28o3wAwDynSwlMLLiJc9PyQNb9t7pTfxKUMfmR9Zx18PHGIQ3FanLQnNfnUjfL78r19jN3UeAcTyo077bteKHPLldR2TfGxpsOd1gMpXDrMmi3c34BG+DqluSTWmSJ+oC3zVspqiFlQHERQYjqKruY5sLSuZDIRiITrt/PB327eUx/8d4ypAO9vwAkjeYljlRP8b1BOqz05wOmQbGqJLUkgB0WCkidlFvt4zaAxAc6QJiHJEmN5QX2Mbs+gl9Wb8EzyHmcwzSyZB6EXexOFFNlhXQ5QC6azLvKwGOQBsRgyZMiQIUOGDBkypJJhQb4EaYL0CotFAIvX17II0QNBduHkRiA+Lcu9gJIk2C7UkZZkBgfQPXSBoDxvV2IBpsU7S49NcH/gPOylmoYwcCyN6tW7ZVlgQIbKk1WgdgeC/5IuOLKP+LMMKAHrxQrplAOUo1eWBDAXRnVTJgSDMGhnidiu3L9qpzLeqS4MTvJAKVjOyKvKlNy63gtYUZmytuked8mWslRfpJJWANhKXgu5vxXkViyNq5KRb/fswizA9MaezU1BZmqHuHuLtdKD1MBmsRYHr6zZ5bos0buryzcThOL4VhvFvr2COVO+99njBSpxZ66LrLLb62X9Ku11Zoli3V0XFocasuG8x0X8mQKxEORCEAnBHY5vnHbbo8BBBfs51ERMIpXlXPCMTeFifvCmx0p7yrgsvyt4T8F3Hqx3LktzgSKUbxbSX3tjq/WkQL4mZYBUWubChLKSV4LZGiWar5z/slDSe1cLA1s1zlUWWSzk+ZE1GkG5LmSGkRW3w4sbLMcMaGPdJNxDJFkAWv08vGvy2DkPMIOuNZaQWS7sLfQo9oTtoEcr2TNDoGAWQOZZXIsnoobrMcCZe3+W5jkjBujxA/fqVguCLtPARliMd/R8Q9JsvFU9epkN63eQrSLVpVbrhwrSGxjkSxZXtOhGqf4/7YDJAfn5GnQodLlMhBxw4JHCzSxQa/nknoqSRtoyQQaobJPiZfuguU4C8rkeotLCpsNFqyx6m0Jn5Bg0ptFUuXJBaTF0WEskcve+LXAEh0Y4pu1u87u7vaQIapI7ZVM7UddvnDF6wuyZ2RIhjrpIwaWiuyy0uq+lpFsizBMl94lqsoucPYkcDpRydF0KkqFEGxo3pQ6eilo0U3WfqyxPSw1FQO5h/S0llLhCbepqb3EL7woGea2Uw1Od5hoKQKFcW2ETc6YEPVf64/Rz3jS/+ufmy+dPz/Pi6KWSarooWjvBJG5Wh5JS7zMlq3hZ9Zvfee8z576+8kJhbyjKqJROMSi48nldSuzcJuFrVxouZ8smduct873XBU94VPje+Z4rL87vvP32gmN+QetTaf5nFIzuKwXuUTDJ2yvzDY/+zPz8nc8qSTteWuby9tpc31tvn7/Do58oWHFXeOf7pDg/eKysIWetEr4taa2Pb83tPX9kLvfs2bncR56b6yAYSd0nV4tie/7IXNZRYTFzNo+Tdo3cFkjKtkBKTn6uQHGUlEWUejrkkC7ObIFvnYhdqKznRQk/L8lkjgqe3Q9ZUqiFa3+ywH8E0RFbizNOCG9crTk84Gk9YoIQlSXImJS0Mu9XHqORuMV7qeSTtUMHf8HUHN5FDDKZdUjbqHTvUvJ7Rg5PFFFgiKoLntG+5vRwgOE5Xlj7mu+PpT8rCNWS6KLFOyspB/cMPyiD5k9rLxOL8OBQ7+vrEr+xE65b7VNfE56hmBjE4NTY4vr+wIjVHIgS6IcneGnxy45JLnVYMz00EoEJEuz45/Wyrk07Gkf6sA5vD2AcQcfqsJLskwGxGDJkyJAhQ4YMGTKkkgGxuATxIL0r/1/bbFuIwrqypAauPnIMXzCBSHCzZID8pogD72RiEESarhlQIkn4F2uC9RBkJ4sBXFThNMh0kgjEYBQso2bNLCYu0Tfwe2GVVr150oS7jNHQflsTad5GjhOm4dYJuu7UHySrV1tUN1koGNltVpHzK/ARwXlwf/rvsOK6lUipWvEur1sdUCKSfo39KnDRzHLXMS3MspjJiq3vred4v9nSp25hK2XIWq92y6Uqd/iNYuUr/SYWg81LCoYq41zBeaUcJf0wW3h9ZVF0uIYCxooVUhZTwQP0O8fBgzcUKEKBTTgX8ROlbneXMXpWWCtktT26Lc7k1kq7K1ZOWVpPXi2JNh6TW7h0w88VT0EZc6/+8tlKdv0ThWHiWmXdKgF9KluW1PVpGfeFKeL8+vzMcanbUUnqcfuzZ+vY1RdKOx+0dZbFUYlGrnxqCaD1VNmwEDMA8ORTxcopy3H5bkr8QRYLzTFPOS1vReU52j4z/0bOZQ8+lYWtBIKulHJaY1FjFAHBnpK6l6RDwoQegm0hRbIHm8laK4jUg9bz5+ub5jW9mHWa6yK7ksjIA5PpnZKnjPC0Mp+nV262dVZb4Mrv7SVrJEcK6zIgFm5JPsA+RItzc28GJaCXlVZLBQDS6ikvXOohrViJZG0tzyq5FD2ZLDt4dpkYTM8BarerLMry6GoPCBBPh5CIa7+FPaTJxzLYRJMWGtbn7JkkxXS47+RkDtK79/8bEItfcJkmWx21dGn1B1qoZKTgtC4HKXzK0T4hR7uEVHKrEyTW6DBoLNnpCkuDomK1N2+ANRP9jSapK1TtYHel9fE2ArnODhUm5dQqqWwXccBaDPl8YNDQJlfRvO3gQlxJeSEDBNgeItar9MdTT87lvnKj+d0hBnWSEimpgiU8AF4M2DTfvJR56XEwh/jm10Zk+/XHlnbHxCaIUtbahWjw1TNPz3+L/slp/NqMc67MEUZhVZ8owl6bTaGKWr18Y/6bkdhwd07PzswYrng4FlkHhcKk8VlvXJr5iRfn/2isaPMpCpTKOn967qujn52p2KTUOB64KD3bcp/+lnhCitNqoyl9cvbUXMaVj88KgDDEYnc4utEqhtd/eu7rbYEUCLIg9gbhYu+9dR6rVz55r9xfMcWIxqi84+6b53ee3CpMEkXp9Ex7RXmVYnzv6bn9j//M3M67b5nXqvNr8/1XX5rr8vL/Z27b9eeXNckhD8JUn5S6lO90dn3+99oL8333CmTiSqGFe+Tn5vaIWeORTxQlrczF80cLS8ar8/gQhMXM7KxkADwuiv7WMdNz/Y5LX99/67zJn3yqKFhlHEh5V7KW7WNlzp6IgaQwioiJ4t6yrmlMeMIXZd0rSvj06PxOsVkI1rCwWtyYr2sOFYVzEjRL66AMDPV6OZWtW8o41xDBnPwwiXUc1GqutNNYscY8r+q5Ljh/zxSn/agw2jjcTAddzVvRdZb5vOb9EmWBq5Rap7gU002Z374XkN1ACu89HOjBJLQWPZ76g/CIqn0qi8q0U8IpQyBge650C2u87ic9CfCIqp2+F4DxiSwXITur9utj4YKRIdZp7+b+2FSMKdxLmLF3UWgTA58nqTHcj987rFveHuz12X3hEIKMxtND0rwNiMWQIUOGDBkyZMiQIZUMiMUliCAWX7R6tx0fXW1+a6J/weJwyNVA98I6WB6Tk1fn+sGoVlh502hXuMfdMi3u4l6+9QtEljbtTdJbe50RJcv0vzVzA4MQmMaUZZIn2QAHYaBGKKdyXTHwcam3glbatKhZCtaQzplWHn+uGgd0md2FaxJ1YSrpAAdRHeTaAzSlCeJxOAvT2iIo8QzWaP2uf9kv+iayZsuypjrV4lH45V61Q8+yTPUd0lwHBgpZ6u7JeliNA7BskDnhrEAjTl4sFuPi5vekHOrjLVK0FsvsrniKjm4Wy/m1Cr6laVqsuYIc3PnMEsT2MqBRRTxgTssC0D4T/j66q2C4Knip1O+4/CZL78KtXILtyjNXXinrnvqyBOs9eLJYgwuzxka8yrJMC5pyP7bFAx2RREgQCn3HzZ12PDtkxttbnlOKbVmJFdR5vqyfO1mO5cG5L9hDKROBzT7mBGM6wjw/hqdNljt5eeo1R9ZFBvRpThESoTlGr5PWN/WH3o0EQ42VE+mswzqktVRlJ1zFgkusmDZ6hT2nWs8DF6/2UEIAybgAiEFg5wHUxBMDVW0N6/U5rJTO99yy7zBxSGBv8hdEa6cL2TiK0NO5JCHbtGWpTgmDSMixUOsUCXfyIQYsv55BR734/fAJ3Nz+neV6IPtFxc5xPp3ZB7f/akAsfqFlfXxk9hDHDVf89DFDtK4WFCinSwHt8z4YOolHMMhDlDIne9mMnYrsSkvEvSTWaF13C9tF7pzwzHjCtWLRWpGijHRuCV2MS43l1Ib3SEeJMlsSfwAq4Yqh8GNqp8oGfrhHd+auN2UlLG68XYEYeN8qu5GSbghiIwWQGw6w26tHitJbu+QA7wgKfcjeVOqtxby4RZesWDNcICQx2OAgUf3m2LtShm/4wiZLsS1lT6UfRKHmyq3mhcao+l7PN+O8jMPym9OxvfHJ+dEXSzvKd1IWtNV9KULl8MIDU6FwcwhGed2DNy6u55NPFpxrgfEoOYWUrQ0wxF7lonw9eHx+7uqLBd5RFMLjgqc9L+86fXZ+/ujOsoGeX5+fPX26HFSFtioVPX1S7ZrKuwpjxO3SX1piCmvF9Z8rUJRHgV0uOOI6k969Z46asu581ly/x35K47cotg/0rhbmc/bUSVM3KakPCnxC8JBdicA/ulMpTFKekUTFM4dpndMacqJ+KjCYkpTl9NlHmr91n3DjjhOv7UlafjW3rgPucLuUpSQ1hbbPx/UGhy/NgzfO7Beete+o44ondaKzJpW/NU8LHMLvL3jSleAMWgc0Zp0mURk1y7w4q5IQERql6zpUi0kCuGd31ZPFR88rY2iBOayZYdBsgSfoWa01YBmaqCgmMScOk3i14KkFJXkApbb6/2I8KX2tPWHXVwCdQm4HRVO/EzJHRgkzc/iCPyQmkDIumaV1h/2YNK+k4pSBC4p2fS3Lthdih6gouwGrzCnhvR3uUsaYKBarDMAZNeyEf4PxEHrORZKm9WRALIYMGTJkyJAhQ4YMqWRYkC9RdmfndlxOoAKw1z7KjLtvicgViB+wACcSl1up5Uv2/ONJ6k6z5aToVkf4TnVydu5hK7yfbhVowfHrRwufcLGGxsQZZ9W9pWxZOMFGEPgyFdyl9oshAek/F0L19hRcW5BZtvgyFWTn1lqd3mV5oDsN0AMS6tM6PJfRWlqci7lYVFWHxf1X3ql+0ulZwTAVS0X9u1u5rywwB3Jlu7vvfvsdp3ONh9IechLLyv/GZ+a/GXl+tVhc6nL125ufbZ5xK5a+f7GwiaVidbcdo3YFFnMllChJHTz4qbby6PsVa83Z2+c6HP/sS/PvsqwU17rz2goG89Q8HuQu9wQSd8WwUFgfijVXMIC6TKV3XpcytoWL+eyxAiEoaZqVSvno7lzmtU/O/XLvTQWKcWN+/sEzBarjKZzLWKya/eCJwkpxc67PvWeLNfqV+e8Hj5aAuRL4eXKnwCHul34qgXSCUNx/RglD5pccnRbWDvEsX18sWnrHjc+en3niY3N7xKWswMGrL8/tufX2+fq1F7flnfO/4kHWWFTg3e23zd/g6ouy6i3tVl8p0O/Bk3OfHt8ufVS+19nT5XuVpCZXXpzvv/dZ83pwtQQ+yqptgrmUv0/fPI/Rqz/5or97dQYIgNYdjdM3lSBTJSVhauJizdyVMbe+U/r81TIvtMbIClzDmDzgDRy6V2A5LhZje7EwaGjN0H2ai3peqajBt7s6qRgVtN5o3yJLUdkLQoC02CtulrqJ3QfeLl9LtRfVHiKVrfYVCcF4SW4AD1IXp7r2XCRp8aRMNZOEEsMwz4CCxmGNlsh7KSjOtG3Ldss6jPvHkwABAABJREFUx0eVrIqMGC6CyAFKIs+ut89Zq8qr3AMIKErHS8t0zRp7bgn2xCjr5n5yNBMqGnIJ4P7y0Pyv1m2HhLaeEyYjWazexXtX9vntjRv2MDIwyJcgnklv8x7HIPeyzKSRlmSdQOKMLPOc7t+WhWVT3MpbKkdmMVd5lj+dWCwmGMky6S2NnB+vqL00kTI8c6C5Ad6K+CkmVnGFWQvOnUWRXCH61b8HIQcJdi1AKnbttwrusPqgINyyoryJwVW9RYwviiVStBH+8f9n719jLcuu8m58rL3Pre5V3VVd3bbb2BiDuRkwKPmHBDAWSEG2jHFweEkQciLsgCMwAkQQQSLJBxzuyZcAsiXHIkHBtrAIhETIbhxeBxxkeA1pEnOx8aXd3dV1v57b3nv9P8zxG2vOZ655TrUpcPt915Ba1Wfvteeaa6255hxzjGc8D46kTOL5piSer5LWU52stFBbQt/G5M+GgHt63GENOLdKQWdWMHnk11lhk/mc54jQCQ61Yi+Fuiic/gwHPGCDPWXorAP9EccDL0i1z4u2cKRI7yMwoan1YDNw5xfGCrMMYoGjDIWc42B3z7sYx5XUp1C/c7GRGy9Mz+bEX6TFe/ccNG/pXHfOp2tYcwcZB9IsU8xjM+bQA5zqnTNAI9L3+8fT5yc+lu7X7Wenvu6dSJ8f/ySsEL4YkuUHXpy998stxxbjnN+XzrV1zQUzvI35vp/7qDNpQE7iNHE4yuzdwVzP/HfgpTev5cwh9KtMb0OBBxYbbPLcRVf27kv3cuvJdK+BvaxflGe4iZiLnzNLoweUxr/DsQ1aN8Yi4+Cyj2ugQYpJ5p095VCjKyWrQ5+x88RmkuAJ7AvZJjl1HIYj6A7LTWqsU8AgCHjcf5/3za9pN5vngDkojZkw4lRMC/p3iHEotNCNeWRkTo05k3MLHCvwzcy5cwkQAJeItWevOD7m7AzWUqn2yfqkanyV+p06uayVUquidRB5f6s1k3VNhb6kb+pLqKqrKscWWF9Z+1c44aGMKlRsCofAMVb2C0Q91K/JqXEPo35VnwJHulHP1c3ntuj37ZG9d9wVBnmCWEw22WSTTTbZZJNNNllmUwT5HlgRQV4nOlAD9itBDzkmIoUN+ceAFDTYL6oocbYz73U3p7t47ethbR6iy77Kdn4z5Z6Uc0S0WXexIg8cO2rle9bUTHafqx2nRs43yl3swHoxnhbVgotOoqP5M+tEIKOqnKYwIsRWxooz8gYk6sG9H9O610g4JsWFEYlRwRQtahDi9U7TgHkUSBgfoqK+UWEfhSIqFED0nsgUkRcpTMmjZiEtfcPTu3CwEvkmQkz075anTY8SYfZoCPdnIVEuYT8Ilgsz64lGE3X2rxYn/Hn5+F277UV4yBd72n95DP7j8pnteREbBXdL2CxuZ1zEuzyH4qchCEJUluK9hUd9l1vwJ6fPN26WcxQ8yJseDd65ryy4y9s+9kmX676f/nrb/riBf9An4BuwVvD5ilcKdoxbPhd5JFlZPtL1O1OIw1g2LntkUSLqRO3XbgGd8jaJtG2UmQPkn/sTIwVjbsHTTXaCwk+H5cTYuimZvWCt8OdIBFHZeMYERRTqxfhk3hWe3/ieCOmO3x/S4syl8ndcY/bODjC0UiI65rfIulFIVkKkKtYdlcvmnDLPFb/leQUbx0bxuRYQxnxPdJJ5XyALd8WkoFlY7bdkJ3XeV1anSsyqk/uWtyUMUNUaqsXyKt4h1oJ9Fr5JQ+gjvj6EIUtJBA77PveTWkV4LSGQw1gtrJslFovFO6cI8mSTTTbZZJNNNtlkkz1dm4r0/opsLIobwHlwUw1Ow5niouS4TjC6oZpDJG6EjzCOdXwcBYGxo5ZdK22o0hy7R91Fzk+fTtfmBQq5xHa1M6RtlUNtcFHOTqdd3soLR3TX2wvlWHcso9FqSEYPFGneBzB8yAMrlRERRWiAkDgVXuQialw9tzJiEEUfs9RGKAZKQV2n1HMoNrlqYTz/HIPMPec6wRjKPYw+qgwsxXki0Vxh31xZMFfSCzx3RL7KYjyoo6JNrpvPlVIPvlg+p+/e7ur0QLUWRXdBpVXSe5lHiPddxnkD/Kh/HhLT173o66E09kKq2CPGISedRZBpY8cLv458LGFO1y+ne7n9vNOpj4v029vPTveSyCtUaiuPghIxhif40pelazr3QRnTZrZ7xotQPaCycwZcsHMMn0h/R0T4OpG29M/1z0mfn/4Tb++U44Sh9t1Ov7/1HC+4u5hlp2CK9Oezeb2M3l19YfrtA/9POuedc+nvI5ecvs1x0jefkxo6+bH0TOY7XmDohYVrM8cq3xyuf/sBCv58ruA5HvPovN87MNprN8vIcY+ctYetZ15Qh0T1Gs/EccRrF66b2vJMet7zSze8zZJbGIwyY3Ll/NezJ1LhaH+fF4ZKvUd/0rHMYJfzyGRkcMpIcbR13aPNRCejANbnN1eko8gvniYYVeYmIm9ZliYU/ijo1WilR+VCcr6hhBoR0ny+Nqv50bMoIfOTZXUmZlZxD8e9Z87QAmeVdd6ULKfIvhf9p+CNuTDmSqEn1T6wXsk5eymkmzkGfXVtGGvK3x9YYsaK4JeHSHh5CVVhoJrgoov+QR8rVHJVJjekxuvnl19nSOuJacG/mQ1re6XxIJoIjPcoiCy/PzAzMNaXCWLxl7ccYrHWMTkewEUs1hLGaBFohyOtBWgHDIJgo+AlhdMwwPqNYj3VuFcYQFXUJg6mDSmm6hyaiuI6gB5wThxDnD0Vt9A0Yz6hysQSDq3CHypQv/I9e/UzGwAvKMtlUPO+FU1pcSF9UDES7g/V4TjtSrDPhMy5RiaUqtiECUV4jHtd1G7cKNum+IPFTsdcJ9dgVi9WfMc5KQSkwp4FluM4N4saxUk3yvsRDnNR9SxsHL4QrO5LC+vsauk4rI47IwYOBVXynhaf3YKNJrW7OJ/6PIeb+P5hIZnfLN+N5YmN4nMK/3bPOkvFVa/AdsllIAZr28AZ0v2AWQK7+dz0+fEnhk3qzun0272TXnz3CTiY/TcPO3zD2ShwxnFugUzcedCL9B7z63UIBr/Dk5pnlxqQCNYmL8LbuNEXbeO0bzhfcvQFfZjb5XUufYHdupzG8K7fj42sSA+4yq3PSu8McIxNL4TcO52eI8whFFdSlEcxX8A2RCAEmXBktLvtwbHqgcjApuLjfekbtvlNdzIRFHHIBZCK1al03AzoBRtExi7F1jhrudQ0c6KKkkSBlKw1OFDKUjMr5wXmnGAOEp7h9B1zANzLfm8kUBPzGcW3snbAdxzzPb9HcptnQV/MKslo5TtWZiSFbVWsRPm8lVmvgRWr574K+ieF3sGYFHz/FGMLs4SKl2ixm2UBKRXFqtaWccaJirN6reQk1uL60YJvXb/jHOM+QPgYLd0CpLtjPWR9H+FB1mDiYnyDE1BK4W6O49bWbdHv2SO7b58gFpNNNtlkk0022WSTTfZ0bYog3wOLCPLaNw8RZLdaHa+OGLe+r8DvTeU82XFG0cTILliizHqOViHhUAQh0drqBCVFXdGGnlsj5SJ3Xd0fLdqT9kcL01pt8LVwMlbKQ1KMFjzIKkk6VmBHZEUV4SIa0NifqiJTaweutGn5q6xwFe75luy0hUezpiYSaWa+BybEmMsj5zx7olsUIdEWKdSGXHcVSRa564ikEf3Iqa1E7jl+S0QdujdNubaeq0gML+7zqJ9HHknRmw1RSH4zc+U0qOGAEqxBNeYUcRSYrYBv+HFEeYnahpLcduoLCnZmFpzIRGFvPZS+O3ah5EGeeR93Tvu5YD28U0aIMSLFXNvuae5HfgyFcOnv2aL8PK6Dvq4ozoOuzov0jhEFh5LOOUy9OC/uX6biF/RuZHv9HVu/IXRewByYn+S5hmy0vEshLY3KV/5uMg9JdDYKPImw8s74+9DBA6zS6Uq5xTvH2MyLvRjXWqxHG5rFUQVMPteIY6h1+nyoWbqsXxGd1d8Iz301TwllZqwVEu3ULF/6rcyhGhmWvg2FzGVksUW1OlBKjrhFrCuR0SsznApb06LxlipcKwI7SrXWkqtW2lWlXtN1Xtf/w9rP2hr5omirLlqUomyNLKu6b04uINejn8fzlHW9lZVf7S9s0e/be/t3TVLTnw5rcRYXxzQc277BLxgyk8pFTHs8/J1SQGR2fODNXN26VfbPLeAakdZPk3flEGOz0ulT/G84kplTNzvucATaDh5bUiplumjmuFbI4DudcBj0wf9bclgWXKUy+cZ1acW1W6e8vixWc+WJLB3jMWyXwjsidebQgh6+X8EmV8wainVr8Ira2TPDuTLBEjMbFjEmFHU2gYo43rvjuXIvGTdwM/O3YvfMBsfY2woMMnbMMYmevoZhAEaJWLSZOJGghl/VhTg6v/6lwyfMzOaku932n/9A6tJVx1o648DqdPpNJ5uR5fFNbyf1ZelCIfRxDgOFwycWR4f3afNCOsceMsYwYgADfVZq++jjVny+3IK9IZ0D0Q8cyJlLLd96XrruzWvuOO4O7+aN58I9nNpYeFYaxxjsMdjiravpt9v3p7/vnE//Hrnov/NHB+/xpre74/S4HGdmtn+sK36z4fS9810/5+n098mPpX7f+KzUp2MX+F25Ady46ThxFy/ZA0l0u+RDNjOb7zmjxzZ4ZQib0z9d8CM7htjZK3p/54Ba4NTCSc04WLuSxtPes9J42XxswIXCpd2fSO8z8IuVs5bMcMLBufv8vjqX3tPZtTS/Lc+mtueX3HHGnxBmmXxD2bs0drwzuz7vAKGAUYN3hw0hHMy8Y0fEOQPjCx8y8IasLzGnOoQAruSQkGY+Ckd5VvQfCAVzZsydQK8QRoJpI9cSUD5nHF+fx5SFSIUjgHtUYkwbJRNSHJ856bFZECYfakjiOkSMKeZ1WVOo7wGCMfAF1+wYMecH00nJLNFiADER+Ao2JtZQr2eJ+yHOv1m2ibDSV6gEUeScLVhmOMzi1M62XMchE4EZfKHBwTUbNB+A3ATWmvuict7AeFZ9wjELaUfLJojFZJNNNtlkk0022WSTZTZBLO6BHQixGNn9DgUFEqV0W8mOS7mIK9iDpGqqyGJmLW7l+F7YNxT+oDvYQwH8eb+5Hi300kJBTVVJ6lGLGiLyHvCBmos4Igobmu7xc7Kzlp169KnB5axWSJOKatOQiix5P6M4hQgK19EqUNBoAcUO2wNsgAKRiCQxJmCzIKLEOei3TgdEBSJ6L8+XCGyeDt0tYQ0RpSZSzvPkuohIwVV883bxN5zD3VWPLPDeaBV93j9gHaQUT6aoRzAC8Fva8jFKcZ4W2M12XB76nDMWeCQ52DHMrNspwxKLUx6Nhuf4SDp2/0T6lyI94AvIJlNoBuQApTmK1vZOOkPFtWEcLI6kz7bvT/+qSh3whH0fFku4ib3uER7kXY8QH3vMj+PxS3R4L8tMzj1QuE49IwkRj3AHH7KfY+saXNN+zlPOanG5hEvA0RzQFW/n5EeGjARQid370vPins79WVCkh63fLBX21m6kzsNVvXbT5ySgFxTi3fbP94Z7HpLnl72o7Jgrhfm/MKFEFo73lnlLFPeiSO+EZ1iQdSeF/9ADw4UA0yDiSwEr7xjvM5kk5h4YJSgADOlpXytghyCySLt5NBMoyWEFwMytOr/5uSjSC7Yi5ibmA40WZ/cCOepeCxn5jc5jkn3tZd6DUSgyqcx3OQwOSAjzWwMipmsNx1dSyqw5wL+y+Tt9MRK/VMYIfjMiT53aphivVK/TIkeFceZrTCjgMQ5nZTT3IP2FvK1m5rzB1jX62wZ0woTNI6LZqv63tZmK9LZ/eYJY/HVbv1zWTmmGnalwT4sylYwpKXbtKAnDhDqBvAS5c+6DcKaylpqKWC8Hd8AfFDqhLBcy2PN2K8o0cGJ6r+ZlX3j5q1SUONZxPC/BqWHQV1hZoBFAS7gf6MXTf1JNNIQwiMpcc42bMuGYBRvFinQlL/G+YLBoWySmNQUV13J/StGuLiaaKJzevNpbccwVY4T0MZxUjiM9Sh+2SkcjFlKO17Si2QC14Hq04h7jueMY0/fAcvqiBpsFkAwXA1k8+/7hlJ4Sj7G2Vo69/uzpdAp3fOZXylQrjvH6pfT5/tljxTlnTj0WQiHZhmHmbdx5fronRx5LDgD4VozPb35OGqdblxw6Aiz0lItZONYWgYybLgd98mOOYc6gCWCDj15M9+7a57gTfbXEMQOZ2MdPesi8j+kcm5ccouHf7/itXfPbdOMF6bgTHxuuGwjF0n2yTZBDfq5rL0z/nv1fJcTi+OOpLRxj+nz6z0tHGUc78NMPDJtQNg3HPpnG452HHN5y1TcKLqACU8jKMePBXuGOMFhmnuv2s52q73EfB/c7S8a1DEIFJdzDaVcBjGfuTjfOezjM/vn+s9P7u/6JK36BJcQqnBx/N4fNefZOB3UaNG+OY38oPTAo5MKB5v2EntI/7y55H3gnoXm8fDV9j+MFNMOGebliAoIyzucnu3qt/DzgH6W4h7L2hPM2IoPM3A78osI1K8UaTBLOwhNzJPM8ayaOcshfj7Ax4fi7gzeH2Sigb8DYSgy5UqXG2gKdpwQMoi8ZQ5IGkfQZKHtFFbjStqF55fcC2wTuUJxLoZEqPqY0tlDR0Q7HAY+4PWx0cyugJYKR7gRaEk67sm2J5PbcYTur23esV+67A2yCWEw22WSTTTbZZJNNNllmE8TiHhgQi5dtvCYgFs2KT2unDbTStPped5Hyu0p+coxP8BAOQ+13lS45jHFihA2jIhbXPunOVHmfQ4xDOCuVkSIgGQcg8IUJo+KgjMaEgaIl2azy2VnkNq6L3bzKmrZYHFrpQa16VinXPGpMlF4KRyoWDg5flJEG5RGO70U4RHlHzbLIknB1RoaDaJRWTGvbITjifVFWDCzPPHAu779KDUdkCFYDrg8Ixq7wjQJRcTGDXBgk9T17VrwCkWXx91HEaYbiPE9/bnqfPIq5QkraC8+WHv3cO12yO/TZ+IdjOIRhfHwDU0BCeunDedf5knc8a7+RAoa258G/dTLrELCQ7CI4lt0GCvaIJBMyWrtTHgukYtP5kde2y2gf38N+AVsHDB0UK+bXvThKpBz2hrLNNY/4ro6VbCxdvDP+MQV1ZHOiwNLZP3aFHcJskKVelNFn/ibCHMIhzHfBjOFjy+egbhtokr/vFCt59Msy4YiYE0QYo2KxYP5SaBTHKZOOsFeMZcxCjlqhfIxvIoj8ljUBeATRb8RNgLNx7/Waxth+BBpVpdYFahFtayH3TK6ltSZnn4W1CthbbA76eYsVg2zmyDoW69VdRoxbML2KtUPW8bEo7mFtVRALLa5vtQe7lWfUC99B/ZUG89eYOFrR16yPT0dqeoJY3EsbUd8pyL6BOfAiQHfCi6UKcQw4f+lVgU8d45ioeMEymrcxPHLZUVax9BsYMIL9Qs6p6SMqWodK3Kz6t0WlQ//mkgaXKmGl3oqJV2EAXXkf88+qyYoUuZKzC26M1y2EQoB9gMtyyi4m3lle9cw5mbTEWa0YRJRSSSZ50oXDIujH4byB6TOz7r7T6TPHKoZjzD0VKrZKIS+EB3zxxmkF+4agCPc8n2i0ctphLN0WC4OPA7CWOKnuOHeBK/RngaLY9eH6zGzAcN7Jzkc/mUe5hc6YAfVaKOKdSf0GY8zCuUTNyhkm5tvpfixcoW3jQrqvu885Fadeu75X/IZ0fohykBbcwIlNv9u8nPp/47PT9QRV27N8niCrCITV8cbLjYwOibbRKaLq21/X6y9If296Rv3mC1Nj69fSAXce9gVkw510HxcbNxy77D4aGOQuW4dufLYVbeN0LmXK4Tc45x2vh7Ng4IQPwiKpD0euOHTlgXRxRy4NjsPcnWg2QPvOYgF13O75o962v0NBOeabEH9/l74pmd+B9g1Ilh8+L8eP2bDJwgFGxXHl7yNOOH2b7eKU+zyHgtw+af103PJM6vOc9wgH4/Qw1sAQ92ccKoHYyJpvJplreddoQ9cBwf/3zuLRca6b5TtnZoFPDlYGnE7+pk3WpZnUXgRetMQPV/OgW7eV1XWAY442RMlU2YQCAlhuUtRiXSPwA9tJjsUFKhEbfmGvcNjZat83Ag4Ji+CEsDzwClWMUHyeO4eIjzD/gltWoZQIpvl1wH6nzi3rfbA06fqebQQ1uCaiIuGXqACYBF24zsBDN9iYuuyeVw6v1kLFF8BK/W9h98gDe13fTywWk0022WSTTTbZZJNN9qnYMzqCfOnSJfu3//bf2rve9S776Ec/ahsbG/Z5n/d59q3f+q32nd/5nbZxWFT0Lu03fuM37Od//uft93//9+3y5cv20EMP2Utf+lL77u/+bnvJS15y1+2s9vbNjpDiQdIyS1VIKkEB6FXahLSB75aC+08LouL3wn6R8SBrhaxWkkaEkdqHiOLNiuMjwiyFcxqBztNDVQGfFGlUGvctSU/6ToEBO1CqixdlpDZddwlrmAHW9wKS6AMbZ7iYkZImUkNfiHKHRKdEnvNno6kk+nBfWWQXRXkNi+K9O2WxBKlLoknwh5rZUH3OvQmBAOGFPnk6/Y2UtEd7K2gFhTfAJIiGEKkYizRRIMR3ZAKI5lxL4cjVg2dT15B7xogKkd6GB9l5ZLvb3sdMKCTGs0fUKOAL1olZWTg1c7YD0uMLZ6lYcx7k1ZZHyzzCvOb3c+fh0+lSbsi7aBasC+uXkBr2wq8HU1tHnkyf755Lf++edX7kp9L1RaTUI6dwGfPvkVtEeTOIhRfTbXhWfkEigxrLS+nfa5+f2ty8JMwo697ny860cdarv7eRqE7H3Xl2+v2xj2a/99fz9ovSPTr+v0nrp3/WqZuclX09dsGLnUJohEiyFwx6xPXms1IfTn/EI285xOIYke5075DnJjo/36FIr4xSz/y93T2bngEZAqJXkTlwFpPF6TSnzO7kcJ4SSkGUtnOe7pCchpub+c/fHdgrFvf7mPtYeh/m/qziPSHKl81lUYx34aoVNgOe5JEzivGuSxswxsBm41zlZJ6CF515Yn1E5hqoBO832SZhrQnIhbBZRNtSlBfZLG+3iCKyJgZXOhksj+6ybkkhuDJHxHxOYTfRa9ZrP25WFCf6fCMZwZgTPbLOvYsiu5B19uuOdcqzkszfLRGT7FwrOKeVuUqFU5ZlVqKb+bwovoautSuNSKeTFW0Ohe3+DESvIVg7yELzTBQqeTcsTfgEfgzRagoCA1KHTyUwVI1222Jh9jSK9J6xGOTf+73fs1e96lX2xBNP2Nd//dfbN37jN9r29ra97W1vs0cffdS+7Mu+zH7913/dnvWsZ33K51itVvad3/md9uY3v9nuu+8+e/3rX2/Pf/7z7QMf+IC97W1vs9VqZT/90z9t3/M933NgO4FBPvp/xWSPjeqQjynljFgLe4wFrZlilVqKc3mbLUySOKlAJyqKGqyh4FNQ4KgDDPVMhUkDcyw0OZpy0yrfBobLrJ4Q4nMmM+AsQvfWa5ownkH5IqpoS6F6p7AO2CeeTKDNcOZYOJicVChEVPFwqOlL0CNlZP5BHSSMGAGFuH27PAefQ7wui1WkTc+liv2ea8A5PZOlfy9eKc4ZwiCx4XGn/YHUVlCvwVLBIi7CCp1ATuK538o2f4yh4xmjh5ntn01tbzyezgWdW+844BnMA0eYvPvie3CjOFSbT6X7d+e5w6Zk64LjXT1d389J46dnsHOe9Hf6B0cQ27k/nWvzukMKzqXrW79V4on3XfRjfXv4/c59zj7BZeMg+uPfSXuQYKPYfigdsHYr9XH/IQ70VO4pX8we93dtHZYLp1U7M5x7dTS1tXkh/Xb3wfTcjn7c7x3IGh8qWz48EP6AiQKWiq0rLhTiGwLux/Z9qf2jlzJ6uy2/xztghx2/7NCJ/eM4zOnzDYfB7J904ZDbPsYc571+2ZlRHOYALhqBkbw+IDDI+yW2OBx9Fw5ZHnfFxCsOQ5OxGXh45iKEcHZKFgegRmZm3UV3jBWvq2wzzAn0G6fb8c3h7AHJgnHnwXPp76cuefPZxoC5EyccQY8tcVqCdcfnjNiElxv+pior11qwMe2XbdwqN9WRxr8jTidrBvdYMMsBfyQIFYGfjKWGNZB5TChD4znRFixGOMAC81CI3dJp/Wb6DLNjW1BAVVutaFcVuyuqhVgXznwGJRpx2M3scKy1KPmqH6P0cbQzzzclI6xY6QvxV8SnaPo3Zrbo9+2RvXd85mKQP/7xj9srXvEKu3jxon3v936v/ezP/mx8993f/d32Dd/wDfZbv/Vb9spXvtL+x//4H7Y5Jkl5F/bDP/zD9uY3v9nOnj1rv/u7v2uf8zmfY2Zmr3/96+3Vr361vfzlL7fv/d7vtYceeshe85rX3JNrm2yyySabbLLJJpvsmW3PyAjyt3zLt9jb3/52e+5zn2t/+qd/WjnAH/7wh+3zPu/zbLlc2k/91E/Z93//9z/tc/zxH/+xvfjFL7bVamU/93M/Z9/5nd9ZHfPa177W3va2t9n58+ftwx/+sB0jEiZGBPml3TfZ+pz0Yhve3WKtiO9VP91oshv/viE3KT9Ov/VdXeyGtaJW2SiUmFvO2WKYGOUyxBrS2JFSJw0uUJIQGBF5Ua1Azn9XyXhL1D3SZBK9rgr/JFJTCY80WC0KUzYKERDppQiTz0MIxKMikeJi3BC9PyASE20HpKQs0ug0agFThGQjOGdVyX48ezdCxpYUpGQdpKgnJLRF3CRYK6Lwbl78LviVcxYL+uVRu+BQ3iyjfSsv2otCK48GAocIpgF/3ovjg1SpmdncoRXwJufHaiQRtoo4jOj0Wvm8gA5QhAeHL39rIV5ueydmfqz/7QH9GbWH8pv9k94HyAA8Ctzt+fje8uvfdxYML+bbO+fvzU7Gc77wiPZNj5xCBAKax1/Hoxf8emDWIDK+KWw0JKG8AA+GCqK8y63h3FH4xnvp93TtFpAJL7p0kZb1GxIJDoEJ2C18HoA/VaTLie6aDWMpGDAYa+sHx506xjdMCoxz5i1lFuCdzVlqiAzzHX+ryEbAHcj0+efwmPOOaqQ5ihnbc0tVTM3n+l5qGyq+xNwiHPRDUXYme6xtS9Q2Cv4k46kZwjBh4VHWojLdTxG4wOk0GquZW+W3VtaHlnDYfMSH0HMwh7bgmYcUubV0DUbtEFaK6GKDCasWSivbG41Iix91KONXgz0sovXra08rgvyMK9L7sz/7M3vHO95hZmbf/u3fPhodfsELXmBf+7Vfa2ZmP/7jP24LTXPfhb3pTW+y1WplR44csX/4D//h6DGve93rzMzswoUL9pa3vOVpn2OyySabbLLJJptsss88e8ZBLN75zncaQe2v+7qvax739V//9fbud7/bLl68aO9973sPPFZtd3fXfu3Xfs3MzP7m3/ybduLEidHj/tbf+lt2/Phxu3Xrlr3jHe+wN77xjQe22826oRBvjHdYaNmGzx03RUS1gS1WqWmw5rONrfL7kYjyYSD2phRn8EoKXprdtF9v4K0C+5WFrPS3ROGk6DC4SeGqBTdL2zdKyrlKohIqHLCslkVOaWtT7m0UQjYkpXlmWgjJ77TgMMOsVcp4gp2NCAnR+TOn08fwn4KXow88CyILTm8WkdecZtAjQrFz/qznpM8vS1EPz10kowODvF5G2Lu+jFiALyyw2LPy3kZhzH1pt9494VVI4JafRbFPqazUO9Vad83vh0faIhrsx61ODZi12XUff9C5edFsSAd75Hh11JX0PIIM/+1qXkoLbz/vtJmZbT2ext7iZLofRI5RYDMzm91Jz/nGi9Jvjj2WonT7x/35Me4dL7vtxXhbV8nipO/h9uXfQZLZI7V3SuyumdmdB9O/m/AZn/aiO4/q7t6XzjnfJsrt0e3zqc/HzqS+3r6WxuzakfR852vpdyefn+7nc04mnOQffeLZce7FbegYHc+9m9qmMPD2c/y6dx3v7I8L2jdo8LYT7NXu+5BH+T0afPPh9Ay3XFq7y6aT3ftctttxytyriCRfS9eHjDeY4+URMgX+DhLN23eMtRdOHmFceIZhfmeInvUwaZ1P43TzL7zo1nHsFSb5pstan0vrzdolV1r0gtEOTLNjj4ObGxrDPNnLe0vkl6g0+E0KozRyzFx02iNnYG0Vy8y/REmzAmDwyxSZVep1Ijk9ZIA4R8m12z+c5By7jz2e/mXe3CkLhc2yCChzo9ZKUERNZBFVVVT6wNiyTsFz7Vm5KKRjbs4izkN20efUU2WhehT6Kc45iqpLikFUa2NtCWluZKQzHHBESIku+5hiDV369Wn2QqO9PBvuqRT5VZSx+fWoGi9tqK+gxXusb2RagiK1xIm3Mud5P2sZa05V0suqVkROrft0lPSecQ7yI488Ev//pV/6pc3jvuzLvqz4zdNxkD/wgQ/YDedxPegcs9nMXvziF9vv/M7v2O/+7u/a9va2HcnlfMW6tbWK7JrqUTMb0iJaSWpD+D99LoNanG4G3EwqUBmgS17Y7GXRQq8YWaLhPshGeoWt6K+HUcENFyLVtZHiOKBA0Ce5pb8gc3Guo89HyokiitrEQe47mWhyiU4cPv87eIz1nNwXUlb7ZaoyJkrlYlb4QEZqHxXVInsaxSnLclFDDnWAsZSwjcrhVrGPnAcZTklSVF58E5XlLF70DYiEymBjwCIYBzBK0OdsUxL9ATrhz7G74iS6pEzhYHbJ6P60V9w/4QWAXogUFfue7o7iJf/9LHNaBq5Vb5uJ0ovyZu6Ez3b9nULcwRkFZv733gOpL1tPlCl20vxre+mZLDezAqIunQPHGGjFES/eg0MZiMCxJ8qxs3uKorbez+UOsbNWIPZx69lrxd9mZkefcCfzfPr7xEdwjNPfIfCx4U74MV/cFqkvWxvpnr7ohU+ZmdmdRerrjd00x/ytBz5qZma//uEvTO1cGJhi5ufS9a0/vu5tlxCSE3/hffH90NGn+qL/1z4nfX/mT9mEmd+n9PnmDS+QdGntoxeGdPK6TEs41fM76frgQT72MS++AxLDMHEhkeVJHx8Om9i66M4Z4wPHJIM5rI6mtjae9A0c8xObLhzdEz5POzwDOfT+iG+yfFOH89o7P3j3pO8weGddJt3MrLvN+wtThDtIzInn0zsT75zMNeEgrcYDJEAzYs3JNtYBW7vubeO8UGwMgw7OVszjJYdxrCE4xvH7m8V1F3LPrAU47JXYULmera6kflcFdkByssLmdG0IceyVx1s253MuWIUEclExRMj61VvpoCn/PXzKhYYCmwkJmq0WN8q+7ZbjooIoAK3hcxH3iGeVwxSlaDw2CvNyoxNjpxILg4vaNyfqGFPMN9LnCOzxQUMMbBBQkaI+nHTfOXfzuXX9yuwufeRnHMTi0UcfNTOzEydO2KlTp5rHPfzww/H/f/zHf/wpnUPbOeg8q9XKPvShDz2t80w22WSTTTbZZJNN9plnz6gI8u7urj355JNmZnb+/PkDj82//+hHP/q0zpMf/3TPk0eu1fYXu2ZrHlFd7tvMZjbLb7FwOKryTHwuKYeVKvDB1Skcv6bt5vQ4pFD8707aCk5KPV7V/aBiIQIbxV/s8oXuLetHZ2VUkgj3SgrIgmLOIxEV5IRguPBgx+55JC0WxXgecSAtVqWkPPKgEQdV7tH0WQXBMBtogIjOk5okEuyHBSdzFAyWkJSKFkmLHIhkZPzPVTEHfdCIOApapCADxiEFclwLylWqPJWPRfhQgX7wHfeayHfQPAldG33wSPPsyq3i9z3RYaR58+wGqWSCGSdQnvL+HimhMFGk5xFmCq82/yzNQ/0pj+Z5xHjTo16LU14EmBWFQOu145CRzSteyLdVRoY3r5D2T+dcu+1tX0192T/hxaYe3aVYjYjskUvOxXx6iG9QlHc0dTu4hhlkc+fvXZwpIy/zo6nPX3buk8Xn7/js3zEzs13nNX/DYy81M7OzJ9OzeCzLpHWXPXMFNfa1MqxL34Bc7JzxIj2PIB97PP17/bPTdZ/+c59jdtLn+0eJJHumbW8I/xCNJ0IeUAn/d80jyUuP3sN3vHfG55pT/gyuA/PyzIBf32zH51ov8suzFfMr8NxKMbVDIuDnRmEPSekYe7e2i+NI90cRnxTUFnSGUmwW/OVkuIBlaKEr7228kyK9TApe5/U8o6RzakD//NzMV3DIM9cqD7JKMxNZdFhE8CDn0ULmWYdfVFzKu+OQgoDjHSvnuzBVAWQc5Rlj5Kq5F8xHSi1GWwtZQ7nHogyrRX2VboBl8/IhRWgBZ+C6Rf+giqxKND+Uc7Oi+4rvmKy4ylM3aOAqOlv/e7U3AkOV47X4n4w28MwB/gEksLx3kcl3eMdqb89W/d3XrD2jHOSbzrlrZraVyUuOWQ51yH/36TzP/7381SJ0/9mzL7IXrL54+GDVeDBVdWuJwR2AdfKCKvuFVHjm+KlgduCdk/RGS4patd2jjziIgXfm5YH1IKtyh13CJTjDCVdORwb5WjmxaIVtxQnZcHLz/miaK9JDTFqSqouFgXuok7k775EuE+y22bDgDUwfJUxDJTaj30ygcS9LbHbFXTnGF01b/FbgKabPTSRHA9uo1c1aeT8irz5U37uDrDhHxSTGPRQMvRLsxCJf3p9CKIT/WS8n/m5VVsiDKZ3xQoA19bS5HUnYhH13oDYuk5osrxcHysxsdcy5de+AhwXP6d87HqCfMw7Ky1seTX2DtQIo947z/+4fhfPXMb0Zj/LatsBt5nxOR70Pzj6x2irnjk/cPp2u0/GVH9xL78sf7yae+SPzNB52930BmmedP+GO/THYLBxq4VMnLBY40CtgkA6hQEL7yKXSuYVPmo1FYI+zZwALRzi+JzxAseEsFM5BHSwkPh42rvrnJ+BJ9nHiGySeK38vT7sjbZn5+7s6dTod64Ih4aQLG0u3EkeBuQbHImAcwiSB5U6qsjnEZtzPiQOsnwvsK+ZUNr4ilKHOv1k2l27CJe9QEhEAGUQ8HFpGDUkwKQCRk+sNyOBGcZyZZRAX7xfzrghlDMf7XMt1aT0I18T6qAwSI6wOQ31ROZ9F0Mlhe9XaIo5xxZghQainw4QVa41CZ4QneGCtsuJ6lf1BuY3NBmf1rvmPZzir3leOE0np0XotvV7YtyRYFsHDFlfzIRzbh9kzykHeznY7h6nk5d/fEezqp+s8XzX/xqB561e9zZ55CJbJJptssskmm2yyyQ6xZ5SDnEdr97T4SSz//ijppU/zedY3tmy+gC+4hE+Y2bDblV1tF1X5AoZvKen1ZWFBmMhC95lDHzus6txS1UpTCsEggqosHRr9BQyfbSyiMpjdbKTrPWrD7tePV8nolReDxA42rkWiB7My0p5MeJtX5TkxvR9RQRzRXIHBUGlMdJRq2VwFiOg7O2ZV6RPJUTXuQ8hrwnJBpCbgD36vs41fFX0hMnJ8vN8BhxBp6pCYvu7ZE54dKloU9eXXQDTG5WupgO8vXfFjSc16nzYE1iHQoeA0hrXDC+16T+V2eYRpr4x8d0uBUHiaunPmC1gt4Ludo5j37JTm3Xw8jT14klebsBmk8+zdN1z3xkW/XmfI2D/lRVxX/fntpT7dedCjkXd8LDLwPYK+4VACIs6o4fH33gmHWlzOUpH+mt54vsMXvH6KqOve6fTv+nVnaTjp9+VK6stHt1LE/O+/8P8xM7N/9pG/l45bpus9tp46cXvXx/JuzkXs7++aQyK8furIBTqX/tn3OtCty/47gp33cz0li8cKRI6/u/tE1veGc6/fTI1sP5CuY/Ma/MfelkeU57eZnzw67XCVjUvpmS2Pc5xHtV1afOkFdlvOUGF54ZQXlc6uCgQIJbxgn5AoFtkZ3gPeE+YvYA+RBfEbdTRLNwtHfPzNewijwmWXLWQuCq5xURCV+SIKzK7XWdMo6BU5+iqbFCwHJVdx9f4DLVmTKCC/V+5is+FeqVYAawbFw8h6E3ms4BAUfY1LLxdyz8JwpKqqob5Hphe2ByLiFPMxT2tGNFgfyFoO16XKgKpCN3RSeJHnpabAoCxYFuMN7BVenJ+tJQPDh0A6A66BP+J9kwL/IVMMo0pf/r4Tn2SEQaOlpFdpKAQ7R+kzrXaRqD5is74zE+RJy55RDnJOt7azs3PAkWUUuEXT9td+nuUqvLyVpz/vKoYc5Oz+YoUTIk6rpBFisCveiMGUU60txoUyqtQ6XVLpTfBhoe1epugrepUcPyUOfkwYTOY4rcAAoOIhJaciJOF4itwmman8BZO05pAG8vtx2gGSPrlF35T8fkcnOR83a+ULGrrzlj2X237skZIpIyYpEd9QaEXQB4ETpoKbCUiqgs2yCZK+OCVR4AEFDzks2u50MiZj4ZVFjWs47n3Jz8ex/MtihbONQ6viBmslxKI/5o7xDRYen0ihf0P0I6d5cyqtOJYJVMbB3tn0m62Ppip3HOj90+mcMBPsn0vnWnMnN4Qn3FnB+TUzWzm91845pyV7Kt27nQfKDdCRiy49fb87m3fA1jq++bhg9X0juXfCndUn0vH7x4bZ5faD6Z4dfSL9fctrj9eBWvrlQ/dmTs22Opra+v8952NmZvaOP0s1FseOpL7f2nZmji2ng9tM/+a5NBz8zkVFcMqXIVqSDoDNAugFNHVgqm+fT9dz4pM+d/ocuuaS2khRA70wM7v2eek6HviD1KPbzyohc9DwXfni9BxPfSRdF2wkiK8Ai4CSbYcNkrNZLB5If69dza4cZ/tManvm1ILAdGbAewRCsXhW2oysXYStwd9B5i3wk7C6MH/cyVZ13q3tcrxHW8AgZH4LWNNxsPW8g+K8iuy9uRS1mQ1S8l6/0OHgA0tg3nPnmnUp6jpiDgLOVAoKBQRPRIrMbNg0KKSCOYN6DKlniblzvVxLIrAhwiLhrOcwAuYQfuMBixW1JVJjobRowZgklG0VzRkBo9w5Zw1lXZWATMWmxD1jA8Q498BOq74nBLUyX6eq11G6WZivBP8bY4euKXxHWC8i+JZdd9C0NehXexkzVTDRjfqt1c6urVoBxhF7RmEANjc37cEHE6HnhQsXDjw2//55z3ve0zpPfvxf5Xkmm2yyySabbLLJJvvMs2dUBNnM7Iu+6IvsySeftJs3b9r169ebVG+PPfZY/P8XfuEXPu1zYJ/4xCcOPJbzzGYze9GLXnTgsav9hc3nG83vK3iDyDVjCitXbj+VboxInMpEZ9Xe8ZmkZDotqhNyb03BhCkfIUVvFP3lUd+Q6ISj0iN/HvmcqeSoymBGZL2EfVScj26rEQ7HlhHNCBiDSi5rMYfwZlY8nHnUfx9+UI/KijzzUMXsBWKR7kQetnwG8bzJFETktSwkTP1J/yhpf1elquT6bgiv5p0yF6VsIBGZGlOs15RcFA7JO6KFRUSmLl+X430c7JRRr1kecYjiSn9X9ohSUDCX/iVyHET6Xoy08ZQXX/pxa9eplvcx7FHMtWvOdXxiiFguj6bnAEsFz2PzskctkbH2NtadvYJIWU/tHskZj5QG9/J2GeXcvJ4VCK5TyOfXd5nP/fLu8K+zWXimfe94uj/v/V+fl/p0JXXi8lHPWmx61NOZNRY3PTK3PjzvjSfKuWHpt2SOmvGd8nsizEcvetueWTn9F0vvk3MzXya96u3tUcQ2tHX6ww7rOJ76vb5dZgrWL6fxeWa/FO3YuAysQd6HjmcmMB//3eK+QVJ97YKPT2BJOuZoGogEcJ6bEhHmnYpsjs8DcBhj+dwThd0CswI6QUqeykhlqwA6wfxA1JNIK33i/mQ8yDF/Mc6lINauj8MWA4oxk0wZxY4RqSwLCzULaGYVF34ld9yCfRDllkxnZCVjLZLiZbMQ+gA6sboGD7TA9chOqvhII/I6sBKNs0EUv8V0DSVSLswZCq3oFb4W818J/yu0BER4bIh0l/d2JetUK/qqLF6VzkMGkZxJ1DruGYQHvp6teH5a4DhCfND13V3zID/jHOSXvexl9u53v9vMzD74wQ/a13zN14we9wd/8AfFb56OfcVXfIWdOHHCbt68aR/84Aebx61WK/vDP/xDM0uqegeJhJj5wwz/ssZIhSDIVnpxEMpo4oND3GNW/q364w16uGLSmMmjFtU9VdabHS0FQMLhZcCRiiH9r05t/vII9noWdGYMZsEOK9vDfumEVlW03A/wZn09rCOFpBXHTLBa5RtV3t62qBvNRN0vnlmOU2eS5twsDLz0eyWGLSwWjtJhVme3B3cFfjDfGACp8IUwNgocSypyszy3piADb8hmBAonqOmYiI5n180kvOltufCBISBA1ftph0pc903Kc1LqeXYptR0V9Py7XzoF/Ql3pDMFvo6FnqnN+7J8MME75tdLh391f0qdd07RttoUARFRUiO9v+7PZpUJhaDK1vtCB10b6m04WThz/I2y3q3nuAPl43254c7uFac9203t7ZxJ7c/3MjaHwMr736Cs/LHtnEttHn08HXf7BV4VfsPvE46wK+vNrqX7sFp6H11Rb7lg4zBc9/aD6bvjH/XFyofU5vV0zu1z7lxGHtSK64f2rfNF7MjldL13Hkx9O3ox/X3rWanhIxdrBwK1wg3HJLMJ2b8P2T7utTNunE7jeN03QEBmYL3gGfb+DNZu1Gp2y/sdWuGiHVABrhwzP7uS3r0VUAmcF1ftXJ1PY3J2C4iY//4Bfw9UKMQ/NzPrrjp84f4UQIrNpM/z3cmTfmMIngi+mevge6VmVChDNi8E/GBXNt3MLSqQFHAFn2uPgr0BJ+u4b9YSrSPIgxzKXMRcuCjXIwOnrjSVQnepMIlwUkUxNfWjZKkI3GsDtoFjzPVUwRcJLqm6XW6x3uKDcIwGT9SJVWpN1jMJVim16CynDG3AGQK2qSxSVq7P4TvgEOOdqopfbBRqaChWUeAhmiY+lMIvS5/q7oETzyiIhZnZN3/zN8ci9573vKd5HE702bNn7aUvfenTOsfm5qa98pWvNDOz//k//6fdunVr9Lj3v//98d1rXvOap3WOySabbLLJJptsssk+M63r+7Hc6KfXvuVbvsXe/va32/Oe9zz7kz/5k4qK7SMf+Yh97ud+ri2XS/vJn/xJ+4Ef+IHi+0cffdRe/epX2507d+yXfumX7Ku/+qurczz66KP2JV/yJbZarewXfuEX7PWvf311zD/+x//Y3vrWt9r58+ftwx/+sB07dqw6xszsxo0bdurUKfva+attfcs5H1W0IzPlD2RX2IooD1Hdspo0oBaafpGIampcuZbLKHPoo0MULlW+zZ2pRKIr3kkzmzkPJmwUM4nEa/RapUlVDhtTEngF8KeDgLH4Lp6iBlJPWuDo56J4L0Q8hO1DhVQgoF/lcs8CHYkIuBfZIYMaBSUbUqQgx/dZAWB+3fH7LBocHKPAEO5L0apeIBEdzBjXiECVad7gTyYiFelC4WzOixqJSlEgpAUkRLqJvBB91oIjkWY3j9wsXpC4eaPIKU+jku52JoHVMWcnuOzPxaNxq5MuBOGFVUT3l2dSX+ZXYcrw4g4iyguK9Hyc7A9jkogo/Zl5pHDfZYxhoVjbTs91cYzKa48Yb6bvgVYcfTL1DVGLbedDXtv1dyy7bArc1n2IAHNYkCn3x3nzi9Kz2PikXxev1lH4or2PzuawImnlvMfLB9Kz3XhsGGtAKXbv92K8j5TR7BAr8cd+x7WXHvhg6tTOGfifvdDwKY+Ye2Sd6DAMFbkR0d+8lO7VjRekOfrkh0uJcMRa1m74GON5HylZSSqOcc8U7J9Nc9jGJ67EdxR2xrFADBZwJ6e+zG9KybyP89XZU8U5Z5c9ZU+U0+fNEMTJo2m8M0AliMqSpeKdYw66KaImRAiRoGee9ELaTrI9xftNka1nqUxFN4h4KzzrjF8vcscinAV8LeYq2s3XS6K28Jn7nBDRZ5k7g1mkkfnrhAWhilhmrEQRZea7yPASnS8zg7FGAH8AzqFrkcA8dI3K21i5FkO1PseBFNFLJBxjvVdIivIK59FuFTJpSE9rZreKUnOuhtiJMmLlbc2EXaQFy9DrAnqRC5st+n37rcU77fr163aSda1hz0gH+eMf/7h9xVd8hV28eNG+//u/337qp34qvtvd3bWXv/zl9p73vMe+/Mu/3N73vvdVYh/f+q3fav/pP/0nM0vQiN/5nd8ZPc8P/dAP2Y//+I/buXPn7P3vf7999md/dnz3m7/5m/YN3/ANtlqt7O1vf/uBEWQc5JdtvMbmq5JqbTbGs6zVuWPVumYVnrci1AbTuigHaLw0eXuROhJ2AxUM4QUCg6oTRoMk3BT7k+OyxDnXSlPFCVeqOCIMEn1RcvC5pNVsZCIQCEVMJMGkoZrujeNYiJgcuW85DZTivXnJt8tFOiASOtFEms+P8/Rn7xuNcF5x3vNnwoLHRgDnmf6Ci2QsReW0jA/eLRZFFtZ9cShIzZqZsZAEllqcbq7PVersiYvpXA+cTX+zmLN5gTZr2/vAJsUXkhBkMBvSmw6/mLl4A8wCQCnAKPfi+OLkQusWzATuaO+dSde/eSkt8ghSmJl1+6XzjK3dSv3ePetO+X6JJSZneeeBdJ1Hn0p9vP1g+vvYE+nvO/43Ahu5ih/YYywcXx6X+zJb6VbbnhOKAFGd+5BcHHWMteOGERxZHHMH2enhjv15prS1Jm34Yz36uF8eDBp+znV/vPNd2CrS3xs3/f759e2eTM/o+BO+eEPNljnKiKvgyNPmuuNgQ2wEZT2HSuw8lMbr1uM3i78DexzMQjwrHyf72cZ/B/69cgO8eCA5gmtXnRmH95fx704qrCeqtBfjWWsVZtlchmIkn3Gsrje7JXwDysVBxVIEMVgfYK0Qdh8zCbyYDZtlNrzQvzHf+xwSSqLMY2COFQctG+WAZNiAU5652l44o8GMJNSgsPKI0mnMtZKK75TNIl8/lBKOe8fnyvwhc6pCMWJ9EAxzJSySf9ZyLpXhSmjthmuAahVaPxkfKgxlmS8garJ8vgphFH+fNXClYiVsBAjKedAl/JxFtgZJzUz1G4GVhkMNBnuEzWLR79kju2+/Kwf5GYdBNjN77nOfa7/2a79m3/RN32Q//dM/bY8++qi98pWvtO3tbXvb295m/+t//S/70i/9UvvP//k/jyrhrTJQ/0H+/4/92I/Z5cuX7S1veYv9jb/xN+yf/JN/Ys973vPs93//9+2tb32rzWYz+5mf+ZkJXjHZZJNNNtlkk032/yF7RkaQsUuXLtm/+Tf/xt71rnfZxz72MVtfX7fP/dzPtX/wD/6Bfdd3fVdTBe+P/uiP7O/9vb9n29vbTYhFbr/xG79hP/dzP2cf+MAH7OrVq/bggw/a13zN19gb3/hGe8lLXnJoP4kgv9S+0dbXqEhuw7ur1AOR4BF5x9HfE5FrpIUqvXWr0xotCUZ2XAq8b/ELRkqGZ0GkWnabZiPRXKmGDcJ12R2GjexuvQE5ro5eV6maljCKREYrQnnd9VP0oLvmkf5XBYAqOarV2kQoVLJU0oy9SI6nU5BdKKPrEcWYjT+nochyVpwrImnOGx7FiCEkk91z+qnRZqLQjaKWuE6i3Yw1IlYqb71Xtwcn8uz6nbLfCIV4ypwIcUSlGbdRSOn3lqiWFO1FOj0v2nJGi9l2GfmnjZWn82dezMXnd56dolYbNzwd6LLJu/el+7B3UniRPQKdR42BZ2zcLN9zREWiaI+gJzVYx4vDbeGPdfNa+vf2Q+btlsev5QgG78Yx5y/mHBTnrftvkcjm3EBO1m+nexkR5UUZQVu7Xb7vy61hrPFdvwasBXiGz2NeQEcGgGI8eK0DBgIs5o5HGDdkjuZdmw/3vDqWLATZh6fgC6ZwrDH+ieZGNqqcWyqucrPq/e2k+C4ipERf9d2Bu1izdyEjLUJD+XqhMDtlndiXjKZGPSMDWhaO6VwV7382t0SU9hgc+tJ2FIRLyp37ohnAVvS3LyOShbUyv4fIGg/RTmHI0CI9yQybWVUkX62FrYI3PV5gm6PZ5vx7q9dp9REUCqr+h0Z59RyjkWNMo88KGVFmLyLJB2TfF/2+/dbyVz5zIRafaVZgkN1BHsPZtDA56iBrikJZLSoddk2BjDiS/GZ++rSZDVgmZZaoHFuFcQRetmROCGzXzRKnlR+7kkkoREiADDQcfkjLx9SNCvOJJiqZzQYcHI6OVO0GPjqEUErohEJSOL6X6ulwcrO0WCeMERU7SUzS/pKTihSscUygTFQserJ4jU7mOPDcEzC6KoiidFEKodC0Kovh2dOpnRuZx8TEz4IBHppjrzm2MFgqBGNO9TfHu5NDe+EEe/X/MqPemjv1Vu8OEQ5wOMhOEbfzvMQIsPVRd2JQnHIqLhgHEApZv+BsJY5lDacomz5xxm5+XsISHHvMVdo8lb53Kv1m41rqw62H0/MGUrF30p12f84rd8bWXCjkyuem77euuCOaDc07Z53x4mr6LpghWLtKNEeoVqJmd/Oz0yen/jQdsX0ufb5/PH1+DPaL5zgbxieHcQ6kAiyy9u+6q/vd93/Sdezc5xjrp9gwpn8CY+2ONI7znkMttq6m49dvDu//zYfTcz3++J73O93rzSvpGKAwt56f5pCjT5Q0V0tnIVm76Rt9x/uGQIxDMhaOI1+/PLybbLagfps7VCLmX4djhBgHIjPnEwRjfsnnYCBEsLEwF7MpuwXkINsI857yzjMXhKACsAcfp9QY8K7hCCrUgu/VEckgVNQrBBxN6jligwvWmPcc6AiwBpzx8w6tupRqMoYgS7l5TecolfIqvK4EFZgrVUBE10rmx6g54VrG1hoJVASlHutw4GJ9bVWhELEqELRR3lezYV2qGa5knZL6oyoAQl+AtyjEErVaNiBm1vMclQK2AfkM0w2DCIVUfWsE4cxGoBURVBJoRUNhML5/mhCLZxyLxWSTTTbZZJNNNtlkk306bYog3wOLIr3Nv2/zZblrygUzas114TfGhJu4EgaB+4+CBHbiWrSW96NRXKepi2ahnxT5KSxCeRjz6lrdzc1hZZCIsrJzVPKaMEyg9R6MDLJrziLQdxt1rwr9JP01sF3sFH0b0or+rPKdN/1TvsxVmVKksERFPFQQJSq1uZ9ANKToxSyLnBCF4djTvmMmxVrxYAsUJ9qh2K+8bxH1pqLdzDoq62mL6LVGxkVa16gYJ9oFawyRCH7vEarVmXQts1tZtTznVNnX9TLVGoc773Hn6XIktpfOZTsneucFWXufdX9q3gUocqEQZKh7YUhYd1GRxUm/Vw4HmN+G5SL1AehASOySgd6EUaIsnJtlr3lAJhx2QRSWY249O32+6UG63dPpX6So4S6G9eLUR9O13Dmb+rTtzBNHn/SuZcFMCv02PXoNnGPjVl8cC3/zxq2Vn9vPcS5d0Na1VXE818Lx2PqNTBjG79XO/ekenviLdEHBHBIsF56V4B56VBOmkXg/pFgTXuyZF3fmYy2yEjfLCFt/3AvDgNJs+vuP8AdZJjJBjEkirPCH35L3ZS1bJ6TgrxLhUUiUcvjvl1HtiPpqMS7t5HML7ymZIeYxPleXgndRRSqCzaYsNo4iPdrNivQG/naJkFLgqIIYyjShEAwixcK9XBXimWViGiLsJXoEsWYIvKP5e2WcGIFcVkV4ko3uYk0sWagiYqzsFxoFVjYrnatHrJl1dlN/pQUtrZi1ssjzSvySWPvJMqrMtbRR9WE+nyLIk0022WSTTTbZZJNN9qnaFEG+B1ZgkDfBegpw3azG3hAJBosLDlblFR0fNDvueNkWV7GcM1d16wX/pBjpwHLBc1tJEkuxm7cd19LgKjazinKmUvfhFBJRDQqfUORZGz0uOC1HVPy6nL/T6h2y7kgDmxy8iUSH5DVRfmWipPmuP7ilS7xX4P+0cFKL7ojWOzcpEaWgT9IowLn7o63+4uX0L9Fn+I6JKPF8UdxzKVmweEHBBPaQSIvKR2thkdnAcyzKf0Exxb2kLS3mC2le/z04Se4PCnyoiZ0c8JEdeO+Tfh1QbKFK6OfeP5u+X7+Q2lgdT+danABrCheZ8ID7eFqeSBE3osRmZhuX07n37vOiuytEjuFBTn1Zu+U0bs9Jx833Sl7jOw84LnZbsLgn4Drui9+ZmV1/vnMFexR397RHqYFmesDxzoPp303ofKn/8lt49Mn0+zvnKSQ170P6l0jyxrU4tW14YPSGs2Qe/0R5TiLKFN/deTC1ffrPXKVwvZwHUMPjftw+n+7xyY+n+0YRo5nZ/qn0LoFLBse9edWPdQzxvlPsbTiWHIW9fh0KttQXKPl2Hkjfbz2RLnz3wTRejvzJU3FucO7Bte3c2UvHyEMJB9UgFlHpq+nGMVaDQk7n0D2J6lo2rpGAJjulEWXeXyLDUSBW4kHjndQsDt/nWU7aEM7lmJcbxclBGUlUWgoCtQ4i6Cwza2UsI9PFXEMfhTJz5nMk813QeEq2MubNE0NmLM5JhtLvDfP73KnnFGusdR6xhrLGZNF5M6uL+WzER9BaGTKhRFSl7cFXKKlQm5nlbN1UvmPF+UbGF9o34ZwO30N8ikoOWzLJRdutgv1G0aFm0fMI/Gc8D/JnmoWDvPbNtmZK3J0VGAggvjKtyFRxDtIgUrGpx1ck2ung0XOstOpV+9qCZOjvFJB/AAdz1f8GxKSqDh4TAsn7qjAJs7pgTE0qqZvXoX3StBBOb15gCLRC4Ri6kMTLLtAL4TeuNhAqF54XdXBO5SAW7mU15aCOTRpOucJEOD4j1I+FTopVTDYrseDDm0r6lLZmsklrPZv8WmjrTFrYOlLi4uAHhzJpUcY1hVEU922JNC/3z4v9FvcPzjlpeKRzI13vbeJMIy4CPKB3TmbgAEscaQRFkKb2y1+/4UV9pzP5X4gfqHO837l25ZYj/6zsFhs3aCD9g8y1whxuP+iQhWvD+00x3ub11N/dU+ncsFLQFn1c23bH2KEm/A2sgSJFrpdCQiS787kFB3d+x7mSKbq7gfyzp9QRljhWjvtgHHGLjdSSMSxMA3nRrhSE9T4O2YQFn3fFQb4o22K84xjg5AKxAL6UQ9VweIF00bZCC4IZQZgjlDFnrUx/x1wjQYncYi7wDW3FptOYO5XfvmLcid8jHDVsDMLhUyYQTJ+TQixa7o6KWdC3nClL4HQV775y5ivssFXEdrfMEnm/dC5sBbQOY69qwBzywJ5uHqr1bCwYaFbAS4vvG33Fcu7iFttWyz+pIBdKcLDqn5aDPEEsJptssskmm2yyySabLLNnpFDIZ7JV3L7r9S2uCp2Ua5c0j1CwRYHByK7IzGqalHwXKFyDfWxqu+LYViR5kAXdK9pTJaIKkJ/1R4vvTAoOopjPI2+oJQ3cw/PyutnBRmS5jFSbjRQSNCIKCvuINiR9FM9swyM3wvnZ5XRIng6LVCLRnkhZ+b0UeIbu0CNqKZHjKnqfRTsi5YhcK/0jWhW0SP5bot1H5uV1EsXm/lEQ+KSnmoU31MyGqBWRBSRmr14vz8l45v5QQCjFLpE+DklxH9cU7+SwD56fckUHj7EXViEH7BFg0uOonfVHPBp4E8lpv58e7eV3RH3NzObQj3mh7h5UYbf3it/unE5tb130fqPA55HiaHPH++gRWCAVdx5K13Dk0jDObz5cRka3rqY2iQCjvtdLSAS4BpHjW8/yQjrnU0bWetuL9aBwi9/ZQNs235EUqkdhKb67+RyXdd6lkDB9vjji0JFbnnp2nmeKFpHiXvjY3Lg2RH2Z4XbP+j153J+XP+/F8XRfiDDPbkONWPZx/0x6vutXPePg8yQUgnAed9lYW55NkV3o2uDI5jmHciZFaIxr5uej5RwywAL8WfJuKYWb2fDuuGIkcKOY34BOPZHe08gY0YYU6YbFfChUY1nEOWBYKiUNlI4CLyKq6/75fllQN2SnxtXfIoqdK6M21EdN1gCNmMc8ABSBuZb5jePJCjAPjMg9xzzNsUJbFwWArBnQwAmEYMZ9WVE46Ne5KiWnzUaK5qLgz2EPTiUJvIP1mc+VrrRlSqeW2pLiOtYfVAeBfbQKAGWNaWWSVQUv/y760oiAD5+LtsRqUX6ePtTLbtrkIN9L61c220CIQl5cs5i8lK2Bh4mDOBMOxnihgmtX8MOKN6LdebZo4mzDKYw8ZMvZno1jesIRVOYJJj0q+fMJNRggSk7i6Lf3JfifcSBvk3I/Uvzd20j6yywqj2dZSs5k86FyzzOp8jW5vl6c2RkMHExYTN4qJGKDM4rEanweoirgW31CxbkGe40DrRhuFigweiwCWbX3IMrhizOYcSRY6YPg4kOalTSYSHCHjDRV4/cnPuHALObG9fg5+wcS/i8cBfrNBkErypXlAsf4hB+Pw40Dnn02u71TXL/i3Rfn0nNce8rvoS+si7PJSZ/fTL9fnj+d2rspnJ2+iVvbHhae5Yl07xD+UB5kHDwgEjsPpLEIfna56Y6mO4iLY2AX0z/wBG/ecOf3+DB9A63ofLq59oJ07KmPLIvvcZQDOuGO8PXnpXMffwLmCYdiHPPPP5naufIFqd2zfzTMaxs3nTsZJ9qd85U79tvexonHFsV1zBal43/7wXQ9Ry/6O4d+gjvQM5zZk8N7v3s6tXXyQ+k57p1L43zTsca2TPd++9np86Mfd2fWnx8S5IEPded271waU+tXSicwh3fNL1xL/XtWegfWnIPbNkqsbRgO1P2p7eAOj3HOuPe5B8gGjmgOQYD55pb0DziGwzs6/sYp5xxnU11Df+FSOk4hCwEPg+Uic85VTIQ2fdPZIVMt9Qoxb/E5wQevrempJWEeG+Gir9qOAEbJdxxBhWPlvBfzu+CCI6DAvA4TxZgAEn2hBoZ1V+Eo/i+BnjhO1pYITjFXyxplluF5heEjPo/AjfADa72T6hWE0+p9YZ07ngV62LBEYKb8PO6HYpBVz8H7EloMgb2uHePh5B4so1ZIcc8S0JudEJ5n8bH65fJAdWW1CWIx2WSTTTbZZJNNNtlkmU1FevfAggd54zU274U1IUsJHCa1GJx/7I5UglElpBuSjqPnawDoVSr6UK7mxrkrsP+IqlvFfNEC6x/Stl7fGIwlTKEUGhFXCcsG/3OkHFVGlb6QNsqlW4XfUquTg4OTcylHZ8VpWlb7BqSG32X8mrOMwaT4jntFRInrJ3sBrCWUp0YKPi2LMK+V9yFdB3yuG+UxPAuiPJHGJSLl94OoDREKbYdo1+5wvWHcf9pQpgwtgAL2QkoVbts7ZTpYpYc7kRU2G9L6/EtafnHao/IeAQ0IBeOXGpe5RLm3YLNI54QFY+WR5j47nN+u3fFCudNr/tvUz7nDGfjt7Qd4JumfTeEgXhzxLA9oLV5/Xqdcctkj3hTdwVax5Wp2fI5xHyhS5HiOi2K+O2XR1r5H1PPPibIf+WSKPsIYAtPFaoNnURZQYgG92aGI1f/xDEKzAC9vg3FNW9fIskAuLel/TGXrQ0KdiKz3CT7wMb5ZLfzjb5Vrl+815R4QDGGogEe9gMwJ5C3m1oZCWnVO5QnWIm0t1pPsT2G851rAzXXI/BZNqjKdwtpUeTXrV8WkIWtFxUKi0toiKV3B+xSiZlbDApRdpwW7axUIttbSkeK3Sm1Pi/ZaUtINGzLcUlw/UsTXJAuQoniVmFZ/Jl+vF/2+PbL3jrsq0psgFvfQ+uVyeLg6IDNTwuyWxHRLq1xTHXEupTTLX9S+TDXwAlWOMb9VkY4ZffYDYrInD1oO1C5PyeHgCTtDXbVc9g2c70DJtlUer6l6wZmZjaT1+LzhGNdYY6S1gZBAzC5pMF763Fnn/msFuVvllDpeOCZrxZwHhlk2O2DV8vZF5lpxzpWENn3YLh0DFucOqh42OTccqrHyc2bYayN1xvOV6wkHFyYJPqePck8RIemuXCv6bMf9unNKH+4ZDo0rYCxDDtjT3E4VZ0vZZPnCuTrjVHJ75RiFwot0+jJjsUAYAkd2eX86du60bnv3pzGzdtvfY9gr/LntnE335dgnUx/3zuOU+aUddXaL2z4e8n45Xnf/GAwSJVPE6rhjct3xXTrU4uTHXazE256FUAZ9S+0jXR3Y5AyDvHvKmS2uM96t7AuY4nXacOfVyuvCYabvsHRsPeEbKhdUgQXEbHC2t5+VnsOGw1dWLs7BsxiOd7z30dQWEtMr/3vm7CSwl+QboHSi4b2B3m22AwTIn//96V2aXXEKwbMJUjG75uIyPrbmN0uIVUCJgrXC/2ZMn84W8wsX0/Ug1MPcCpWaCocwNwCdUCeOefJS4v9jTgkYRbYZ7aBrFKwwm89uXooURVu0oaxLOC/KcqO1CFbPW9XGYC4Os9Ke+RxLECIgCgQ4FDaRw/gU6hYOvhXXY5L+xwGcHS8DROEYet9V8Cs3XTMV31zV2nQj9Hx5X+T4CMoJs1C6BwQdSqebPnS6SZGgVBWM4m+gkrGBoJ5lGJsawIvr0A1eK0imflg3s3LmPNgmiMVkk0022WSTTTbZZJNlNkWQ76V1M6uhBvK9WcW5WPH4Gk0QpfEIs4haVLsmogJEnjN50SAYZ0PZ6oNHqauCQTGOj11v7FRrsntluuCqog1Jf0Who1/nUFlbnmt2/mw61eMX/HopxMukSTW1BuE6xWaSqqqKHyiYkwi08nFWxXs2RCmGDzya4X1YekGZSlJrVGQGcwRRDq0WZ0efCWaE0AdjRERXImJO5PdWWWltQIVgwYjin1vlNRFxyOEORA7OpuKliPwqpILj6QPPhPvgBTndU5fT3x5BC4YJpHvz4kTSln7vYRoA7hDpbo8MdowPv9eRovfIIlLS8+seqXEWhL3npCKntWvDuOi3vE3qW68SCbfCYGVYevEZwiFHnvJitWdv+d/+Lq4DnyjHE6IYZgNMIaAUXiAXXMP++d4JZ4Jw3uM5kIxTsHzAKFFGg7c8A0UEmvbMzNYdxgFs48Rj+8W5iSTDUnHrWen5HX3K3zWPMBO9nsPe4ZzGt5/roh1XfPxnqVzgJ8AvgFxsPIXoUhlBQzp8ftkhGedTdJeizBi7Pj5mN1zsxcfR2vXh/Z77WFo5LGfmjCdEtfeefy715aM+fj26GfLlPqcsH0rvyfyij2eJHEeh7CKbsxEFuuaZHI2U8Q7xfsY4X5afE3GkHX9n412k2C2HWLD+3OeFfo+jP07mr8y2RRbL56cVUWoySevl+hDRUeaqHLKhMA4ixC6mtLp6zfuwURwXRdYUZfv8GPP4SGFcfk1mNmSqhPd44IIfLyYn8qpiVHHOvRLG0gnbQ2qjfL4rmd9jneJ+6PpM2zPpMxlBCkj1+m0EMiMc2yvRAhiYNfz6uG+N4+ISff7MGTQicqwQUYlGK1NWBfFcGzLDsKbcjU0O8r02fZBZikPp2GIgdDJwGJCKUWZiUrozgQn0vuD0twZnpoVPVpo3bKb4WGXciNSOTwr7dzHocF6YvHDCJd1TVcHiAMoEsnKqMaV+yZ3iGZOyVzGTYlMoRZg/A5xXfj9MhiXuKiYzFoEcBqKTDcwfVGuzkMiEE5XX4QCXGHNw0AM1kfft+sCWAaQiFgwWOpxtrptJKhgkvOJYMNW9s1TE5oO++WIQDnTWRkd/gIDslveuUtoDYsF1Xbqa/qVynUmQ6n/YLEbGHvCF+eNpMd5/XnJW1i/4hEpaExovZ6mYg1UF7RMUbe6AnXGYhAtRkJo3s1Bj69051WM3rqV/F8fTb3AESXfv3odjnM555yF3JJ/cK/q8cLgEinNmZsvNEr+L0wle98ZnpbaOXUi/2TnDBaZ/UOvbPVnSvIXjDRzcGTRgojAbIBTHnkzn2rl/rWiTNvZxzm+6I7y7LK4LXDNQi90zji++4PfNnd/ZznDd/Gbzajpm6YusrZXXZ3KO7eenzfWRj6ZxvXIFRZzbzp1UHOM5G6zMUVmdTO/C7LZgct02/iLBIPpTDtcBm4yz6XPQ/Ik0RivFyd1y89ZvDO0HewXvFu+asOoo60xAKS67k8pxwLfcUQ740gg9WDi2AgmLeUs2/AHT8I1ybPh9PgjIgh/HXF0pj9rgwIVz6b9lnos6l6AjLaFTMe8J5WisRWzWUeTM4XqKle5l3ValWGUIYuzQF3Feg+0h6PFyuF4pOhJrI3MidSl9yaSha2s40P6ehEOsIiU5BlkhkfgEPN+ogSnrc5Stq1LOk3V7pdAVs2Ft2xconNK/Sdtcd6jy0be19VRHUJdIjdoEsZhssskmm2yyySabbLLMJhaLe2AhNT1/ta3NAK77zmeksrPaibopsXYvFagHtZl/H5x/uaS1slFwzsX+6OdVn8bkq0fOOUrCzbnZzcLBrFFsOV5J7Acicqn2pa8UIGSwEJUFjV28VjuTWs2YIIrjohNd0U4VOc/6XAnAaIRByekxrcim8ET15bmfIrhhZhkjhPdXWCeiLxFhKYt4Ij0qTBHdmdPpf26nKNFY5iAi41IYFPc6KszLVKxJ5GUo1vO+81zpk6RyizaJsgP10eITImb8ncM0LIviANU4nSJTM0+PR0He0QyC5NFJ4By0sXQWC7BFSFIvT6To1eJYGVGeexHf4kTJnBDsDyR9sgI0OJaJHGPAESjim1G8t1n+HawUFMrtAF0o24WrOadiX7+1KPqgbBQBLdojuun3aQ/mDBcfuZSidkuHuQRrhcMo1m55VPdYzhTj/d2Wd4PiSn/83Ou1ayUXO2wlq+PONCJjFLaSGMv5eA/WCR+PvHMcQ4aQrAvvHpkwoEfK/817vy/ZnRxiEcw2Ph4pzpPlPKKXvBe8SxINDJloyRjGPJLNtbEGCBNOSEaryBC/W5TRzpjHSe/zvcIdMpiDinNooXYFfxC4WicaA70yU7Tm6Oy6qyJq4YqPNaTFvjEi2+0XV54njyCLmIayOOg6VWWXW8a6ILLZ+e9CMlqZL1oMII3rqZixGnCIQqJaJLBbrBaHylhn/smi37ffWv7KxGLx6TB1YnPnL6AVmmKItEY04v/C/wTtl8MZFFer1aH4kVnl5zDgywE2CH+UrBWDip8QdCvdG32IlI9QFJnV1a/CDAFmS53YSsREXwrBNEVfcphDJ5XWAlOI62YyblX9emoyqpxDcAMcndCnWX1PY9FhAcAJlfRekN2rQiBpMxfn6AUPTB9TB8sJ1bziPtKf83KhCcyywwJ6webFfYHNgnvv2L/eU5x5P7vTCd8Z8IwHUlo7KNZYzHSxY5EWBckQWjjjKegnUgp79cKH49zzT14ufwuzgGOJZ6RONz0lidOBsp5ALhCSQC0tHClS8bnKl/9m9zmnzcxs3aEVAR1YKzd+2w+kZ6KCIrvn0znWbpcL6Z0HXS3uYumAmw1iGscvpraufV66js1ry6IPtxy2ceIT6V7P3Um98vnp/hx7Ih2/2CoVEsE2334QnPHQt6U76tyTje0SOrF9Lr0bxxxiAjvFjFvnU8n1L0zj5cRH0zOCkQLBkKBsWwz3fPuBdD1HHK7BMeu3ys3V8gjpYMeU33Rn3FlIZjslfKc/3qD/y5dMH6/7n+XwnSeu+zn9uQB/4B3kHGvlxnnYlPqN4J1knH/SayxyMY8tFCFLCEG8Sw65UEW8YLNBGAPsMdACqcWIzWzOUqOiQNFvX0u8bYWzBRwN9guwqoGnvl5ep7IAWTZ3KjRO51+/Hzqnxv0Atsa9Z+0RJql8DeVd59xRdwIsZS795RwBV3RnT9aiiu1C1od0rG8qWetZG4HMMK+HU1qu4xW+WaAmurEaEwoJWyv9DZM1EhGSrlxKB8d4Q58vsI8xFT8oTWXzpRS49Dtw3f55f3BQ8TCbIBaTTTbZZJNNNtlkk02W2QSxuAcWEIu1b7Y1k23TAXzIBxX0jR8uUWlhgWhxGudtq+iIFghEekNSLkOkdbs4R3wuVaQFkwS/EU7KXopQKoJ1jL5UUWA5pwqRZNet4P3oGzvNQ8jcK4gGKTzORcFCDu8ITmG/bi/4i8pbj8Z2eeQ375sUpERkVVNSAV3Jdt4UzEgBDM8zWE00mi/pv0jdKpxlV4pg8usOxhQfzxTwVRzLHmEjEi4pWYV9UOQT1+usFkV1P/eGKMVNKegjek2kyPlygUzENcDp6m3zd3DfbntR2MlhnK89kfrXH0/92zvn3LwXbxXHLo56EdvNMhLcOzRhDlMGPMo7sD2k+7ZzLrW/cT2Tud4kbeR9uelMEh552b1vw3/jlefOjIF8M7btXMwwaMAssXcqfb5xrYY57J1M59665NCRo+nvNYde0AcYNLYuw85Rci/nxXdmZosT6RzrXoAXhZe3h/d77wGP+HsEee16OcZWRzx6SfSPe+3nhr0CMZf1J28Uv4flYu2KR5YzOFSwlhAZBvqj8y/vAZE4vmeO3JXPEfkJPnxgDwesJfsCz+BY2mDugIs3K+g1s4EBh3eJcxL13B/GmhYmRySUOUcyW5UgkptGgUPumeI9mCecLcMsi5Riwr07RID3izaqbF4UwpWwiJhbxniQBSoXmV3l2g+u/CPldfhxyyup+Diio8J+EZZDDBtFaU3BK4VOVOIrJQyzyiTnUCIymBS6NSCRCg1R+J1mghVSqn0wq4kJ1J9aSdG8niss87UmoZBPl/Ur69YOcFKVbUEgFS2cDb+r0gc4XqSXRMVunjleFR0b54y0zpGy3+Ig6os3O+WTgtDBhfOXp0kY8HvlAjJAQkrYRqeVyEAueDkC/lHej6py2cxUQY8JdCCCLx3DcIBHnG0zq6t8oZwTCr6iHzxPnkHQtokSkdAIRWqSBZNK5KhUl4nLIQ1mVjNoyCIL1RxCAuHUClylmljZCNAe2N2delNi55wyCqc0MJr75W9ogw0S3+NA8B6wgCIc4n3uuRbL3jFva3X2dLreO+VzXB3bKj/3e7+E9uuxS6nt+9Pf3TYwmfRP0IDtDI4DjvHuQ858ILjYnXPp+o9+PDkny+N+P3jefvnbz07jA+wttntfOn7doQdd5tzeek56bic+kfq5/eCWtwkLRWocJgkgE1DO7Ttl3PGPpfG7/VD6/cIFRbYup2vZvd83CLvDgrNxw+nbHnbWjQvldQP/wDHePePO9s2SUWTvzEZx3fR9z68bFpA+o27DMca53nlWuvdbTyQnbe7iHPsPuaPrDvRy3QVkYKLAOeed2iyf785zT5uZ2eZjN+LcOMbhKIcCns9v7nR2OJKMc94dMKw+RoO2cFfeC96TnDZSMPOBvWct4P2HEQM2C+YKNq30Ld5Ff5cIaojYR96PgFcBMQC2po4u7y/zHs65OrXKBMRm5np2zyVYEPhfDRIEg0b5jillpgnuOZhyCBxkm/ZKCGStxI7jyK/cAdaN0iB4BSbdHUl1xjX4YmYzn9tXfu9irQiWBw1s+D1tBac8ODP3PsPahIeS459XuiHYKB3/UK9rwDFbdUsd4mME60SIJf9O1914PgT8BGusvlO+Iej72jdr2QSxmGyyySabbLLJJptssswmiMU9sDEWi7EIMlYVuknaQKs7qypShRg0CufydiuGDE3ZVNFtYdBopSxUGIV2s740q2ClDwHS1yJGIrGR9pMhq2kklSy1ITI8yrWYtVEdF8IZZXW0RqbjmvLnLhLYcUyjyrs6x0jhn5kN6dNVmTHo8hQsERTSXezK4UNeK1NyEfWRNHBEVrinROuJJmhKV/8/a6tiBCEiRlpXpcQFvhK/5z7R1zzqTWRtUUbjByYNjzyReiea5RCM5an0+zkpdYrViNZ69LK7nSJ0q1NDZA1RiYhCepSZiGe3rzCOdNzilBeO3SJN7uMG2WfhwQUOEkV/ZgM8Y5tIr7e5Q5Gej2uHVgB72LxccjMTkQWSse6y1sA7KPbbOzG8Y8A2gFYgPgJ0Yt8looFcwNKx9HOuX3LRhi3PZlD0R0YNJglgE1vD857fKqPKK7/n8BbDZsFzhbOY4ksYR+IcjEXGZrDelM/UzKy7XkKDApZDdBI4ANFXfS+AIhBRZL6LDGEDcmZWZYTi7wY0IqBSkSGUiPluCT2IaxxjQxDWiugS75xmCGGM4bp07lFmIdobyQhW/OzBkDA+P1dzsJ5DuYhl3itgDw1WpSp6K20NXxwM3xtYMcqitdG2ZH3WQnhdhyuIgmSblVli1HdQOGYDXjnmA5jVfkBVhN9itcr6oxDRJjOGsn5k0exFv2/v7d91VxCLKYI82WSTTTbZZJNNNtlkmU0Y5Htp3SxTpqujhzXPMV+Uinm6q9Nd0HA6iTQrN2Iexa2o4IRjF9lIMMla8IdcpkR3O9SdVuzoHI904sRw3SH3WUbEg45Od6bKQdngeoz2wYAJRY+ZDQUUt0vZ6krWm8iERjFpJ3bL++N/g0U+OkQUA6OF+hE4byIF4N+IQKEgCF0OlGr0QdSjwNnOwBOOJIOGghLBLROdDRW/ZdHnwMMprzCKTSJdXdw371fvuMfOlfAo3oloFpEjZiHpY3xPVFjUrZC6LeSviYRRlEhfoGe7dC3969fT30ehn6u7qQSxR4U7ivKOpePnez5msyiuRt8o6CKyDO6ZaOfMo5so7e17JHn9ih/vKn2h0AcdtkeHNy8O42Oftv29DO5gx9zunaPgb1kcBzfz+o1038A5r90pccBwFkfk+crwjlF0yDGEXeLYS6kPFBfynLnu7eeke4oa3szniaVf//r1dD/2Hjju1zDCI4ss+66/j0T4/bnzXBlbQevmdHD9CR8f1FAwfqjJ3S1p4MysynhENoJ3h7kHijgfezFOznjNANLSjGNww+BplTc8N6KrzBUUI55P1GndE46lhy855kPvixbYUYtARok+ZVHcSgpZ+YvBtzNXIO+8k7C5QVUW6m5CuUZ7ZMEyirmgk2SNaBRJV9RkgmFVTuaq6FwziFnb4HX1c9aCWGPJiEp9x1Br5L+nxob2RnDFUUwH9vaIZPw68QWCQlB4rPEJ1sosQKzzSjmYtVVx3kvEV2uogmJNfIjwA7TWCr9gFP+8P/qbVuS4IiXAH5t11vXdXSvpTQ7yPbYI7ZNmyBj1NSWhKYWmo8tglvS/OtbhDOhAzc4ZEowwKPRl6mVImePgl203tdGZDHyhLTTdZ/Vmwcwq4RCTIrx+4dW/p9ICSjFDpKBIXTIx+UQ7Q8zCBgnSePFFnhmHlqK9cJTXy4miNz73+yECI8Eokjm1URDii0xUM/vn8IRGX7zoZQUfqEBFoiBSGCoqtous3+HoMsY4lja4d1oxjnOPU8uinVWzmw0LbgEDiSKe+4q2wqGlYKglOd35PcaBoMhPi30uuVzug+eGc8NawaKDc+IOU4g1IP971fuCzK07VGtPpcKg4EWmyMdT9Isz6f512ULSH/HCLy++gyEBx3h1zDmVr6brufM5p9OpL6f7g/Ty4pT/3mWigVZEkd8n0u9Xm1nqGcEML7rbPu8cyy6dvTjKouUME0An3Em/8bnp+R59HO5mdyQdFsJ1Lp0/eu12VpwIbMNfrY1r+8Vvrn1euten/jz1e+9Uxgxgg2N8+9np3sMLPXO4yM7DaRwA/8ihKrBPBMuEwzSWZ9yZdgd453lpLG4+5cchjHKiLHYLyAwO961y3OTFqPx/jKWFML6w4APFQA73ft+UfeyJ9C/zlcKDmN+Qdc9Tz0AkKApmHvJ3o3vqSvl3FEj7u/mch9LPnrpUXO/AyFAyVOTnjjmE9YwvaCO4iss5JHjaha1odqR8BtEezn62AWZuD4ef+U0gVFGUDVdxVuiXfx/c8t4uc2/AHbKgQ39jPBgSTAvcjwgI+Xvt81gIotDgvEzg4/Sy/q+yPmsRfQSBlF0JX4DnJYEvCvcHnmCB8UjQJj92gDyWTCEDx3JZXBhF5qzrLWERYdRajRR8d+sCvxRYRhy/Xq6Zs0025blvdPfAiQliMdlkk0022WSTTTbZZJlNRXr3wCjSe9nGa2zeS9TvALq3SopYuYgVSD80kP6RHVfQvWnaJDu24kmUPjWL90KaWYZLqzgvb18KBcYi3AcafThMDWcM3N+4d62CwUgLipR0KOi5SlBAKbivys9pww66gjNI4YhSzwUVj8IjouGyEEWlTseOjZ21cpgqBQ+RA6GQqySrhSd77NkMEJKSviii7yIHGxFzIuE7ct9ULQw4RU55xRiguCYKPCVNTSQ8shbwJxOR8nMCJfHoMKl2/d7MIi0PBd4KtT653iigWpfxTwGlR0hX0IcRMRXZ5C5TlCMSTJvwInfyWIAvrNbL9z8i0B6l5ff83Uu0a3mkfnc3HPIRxYcuGU20dv2qR9Q98t2H5DRUbYviurne+XVXGvSofd4XOKO7XZEcJvMTqnVl4WP1TpHV82h/ZBxCmrlME5vZQKXGeGU8KgViKGkCZ1qUn2fFWHnfDyzSU9l2KdyN95F7RZtkUIS+jYhx8ALfkajoAUXnWEQON8oMQYx3zc7FmlIWn8f9GynuHYM+mFkFVxsK4co5puLcl+K2ap3LxpoqvA7Xpy/ZeMFcXHejiC3gLrpu5P07hMasJRmtynNV4bj0MYdTtHiPq/7frT2N37f8kVb2vfJrFJIxSU1/ek0fYFGJqrhXHrIJW8XQmP+PPHxxOA9yjKOpwBaJQ6QToEtUzoTkfHBuBcvESx19rJ20flE6zd26OLw6SckGoHKkGpioSHllMIfWBN8dKaEBMQUwCYZzJi9cYHNLholR3sxIg/lzUkJ5jtsvHcS4rnm5oAYuEOfWF4mZEtiPXPcgNetOFwvMyq8DJ5a0qNzruA/AGzJp6dRuJnbCucC/gSGkf8Hz6jAFUqjcW66P5w7v8Q0/LgQVxAExGxwdsMXOLbs6l+Ads1veNo4Aju9eOZZWLvs8W5TO6QreXOATp4frhhEBhoRwxujafSXnLk4tDBn74H9dQATp6RljEmGNXVnsbWB22HdxDRxbYAqwVPQQJbjc89HHHHIgjjXvJH/jlAKbWL80VPfvPCc9X9g4EBXZeiods3CHfu/+dP0bl13m2THGYLX5PedcbabPjzisZe90uj+b2blxxpdHHQqzDbwDx35e/I3jEKwW/szgsGYcxLjgGTL+c4gF7zpOxVE2BP6+X3P4TkimA4twZ96x+chCh5PrYh7GeMe5cwiWmQU0IgSZcCqPlRCRAc7kbSOu46I7AX9yR4H3OqAJOM75+808ddkhTsheA60ICIbPMbzXwLWYx5gHhRUDhpxIyedQs40SOhZQQY5RuCLPIniEbxTHRb0HXMQ8KzbGhWCGOM8EDdThD7Eiv27mQ7k//b5ABRmzyr1vmdMc11VufALfLJhshWYE7AFIIM+qAYMs+hVOaYljrrjyG1aJtTR+PyYLrU56VVNVbYwaGwmbW9ev7hqDPEEsJptssskmm2yyySabLLMpgnwPrV8urfNIBpWr5QHjKQVVpqnkqYmosiNHJYzdvbBfDKwJQ9HWSvke2RkLhCAKCCX6WRUGShpI+5CD5TUaHYwXsgseYA6z8njl2yTiLkV+wB8KDke2irQNVMKjM6HGJxGHThkxFmWkeCgk9CIPLbwzs4rVgEiCR1A4tlMOz+DD9KJDoh9eQBL3k2KQzvtGUZtZqFVRhBcFg0BB+vJ+DClVH2OuHBcROCIUl6+Wvyf6kUXF415SlEfVt0SUegpiHnogHe9FdxFZ8PvUcU4i5c6Q0l2+XnxuZoOalyvkoVI2u+qRI6ITzs0arAREdR5IxVxVJPFmKQO79GKu+dVSVtfMrJ95NHLpffF7OYd71yOIwY/s0aqNJ9Mz278/zSHrV8sCrGXIXHu7WbHa9mel61yjsI9IGpEyoBIecT36SYdDeNRy94xHr2G5oEjNx+Aa/MGw1mSv5MaV9N3uWS8i/Iv0XFCpow+bT6Z7FWp3H0/HId/NewDzBn3YfXaKbm59Mj3DgLnYELVdu52e4+5z0juw+fFr6ViDBzk9r1mf+jq/gcR0+nwNlgtVsXPbO5/6vH4xS7kTZQQa42Op834vz51O53rSxzVQAjIqXlAakumMc94X3gPmHKK+ZkNhXxQAl5HzIaLsWSsyPo9fSMdJ4bNRGOzZmt7nx3jv83ltVUZxh2xbCakKeepQ+vRzEjGPObeMBkdUd+lzShZhrPjaY83wNigu5D338bryezdzdcMoytaCQ4dmhRrtqSEFv/Toc0RbPUO2EvahIRsrXNPAvnwN1WLruMYWj3J+L4T/mOcfxXhjMA2zYQ5l3ZaI8ZhOQBXRJYNA21Lgr4wb0aZk1eNZKQfzmIZCXKdktLlHu6vxz2knGx9PR0lvwiDfAyswyKvSmcsrdGOgaHpghJzbzEJnfCYpnMAcA9+4C3xYZS3MUkt8pJGy0JdgaD6retbKYiVlZ3KSFyba0vul7Be0Owa9iHtbTiQtxzj6LJi1ShCD+5ZhUPO+pH6UNEg4ujij/VgK0awpEKKLQ/yORSzDQVcLiWCRY0FVfDD3EIo2FnOu0x3LWEDpa86gwSYLpzvaKMUIelLMTzyVPiaFDMSCe0nbXB+fI0CQQ1aAToAl517jbJO2pg+nvcofKWlw/UdKqBCp+P0H3FF6/Fo67vjwfkMxhmOH4xdOtOM/gWBEH9ZLGAPO2t6DTikHrZlDMXCCwDjn5146Uway1bzXOLbgfRfHXO7ZccH7jhdebkHj5mwdR2GtKJ9dDh/ZPetUasg1M5Rc+CSo8HgVmQ8ENx1tI+HsUIu492eTA8JGwmy41/2REq4BbnnljCIBoaHbYJJ9I7V4IL2b4Shz35Akv1VukPJjwmnBkWBeBnsLNh2GFZVS5/c4HIqT5z3P5J6DwcUdvpgrcMKBRODYjgn6WPaeA6lQmjfe4ZwdAAfpZvkuxW+E+pJzrvxcyhgBtreisWQTnm1WeplvVcikgl7QBzbn3CdhH4rfb8qamrtHUb8BbVsJq1vF/ORQKKSXCWRJXUtcA/O3UGeOwjM1QKXYanHnqnMptZpiepVBKx1U/EatwlaLM1sF/IR9K/ycEYaslbBvVdhqreMS/2VM5nrR79sje++YhEImm2yyySabbLLJJpvs6doUQb4HFlLTa99s66SLNBI7Zg1paGWciII/4fhrnmMMyqFpDA4Vku5mlWtLFrIl3nEXDBpV5PwQtgpl7Ri4iqWIMS+sa0hCV1LSws3ZZGnQPsrfeaRlKLZTxhDZkUtltXI5RvSD6IlIUUfBRQbrGXgxVYSlweOsEQiRqo6oFpX6VMMTLcrlYJWVQi2gJJKClGKNitWC69f7kd+vqBBvXBfn0OgdxjmJzupzxkiXZtX0qxNHi0OI6gaECN5ijfLAdrGPiIe/H0BteIYIjNymEGcYV0ST4zs/dv90unc5b7GZ2Qp4h0eCOxmLvcoiz8vobpddA/LOSxcMUSaMteu7Zf+JHHub0XeHjsDSsXZNOH7JFBHtLy4IlhJhEVqTd88jxlVEkXFA1I6sBPMCmZZ8HiHTwXc6lmCtIDJMdDIYUOQ6eLfiXZOIcj5uOBdRN83OqPCRRLmVWSdgEby7B4hUtd7TKK7jvdSiNWHxqeZSgQh2yloz0v+YIzQiLEXWnY5nrkXFLxqyz2YZJEKfW+v6dE1prG/NrOz2kLWoII0tv0KEPqrn58+o5TuMyTyPFc3lbSm5QCUH3bBWlLfwX1QIRNd6Zc1q+FT55xOLxafRIj2iTs6YwfhQaZar48dijyPhMAFNScSklv4cS9FotWubOcNtrXTCTB3lEcyxmZnlFfxKEN6glNE+DgpNJYY51PCkMjcm94zuDKcxhFKouAabSRqMKmZRRYrr7AR3t6vQBZkcLcPSkWLTNGcoLnmq7oSn6sAm6ySoqUyECvg6e956roqNglSVwjyAKOBscz0iEBKpWIdFFBhFjLa4fp6j3OvYxGxtye/HoSZD9bMvqC7UYGYDLlkVEfvScQ7lNBEKCZovZ79YPOdsOuWT19L3sB0400DugM2cGmzxQJp0g8WAMeOOZOeOYGBrP3bVv/exJvAO4AGo4W26ql/uxOKc4mTvnk/Hbj2RngviJUGphgCIO/HgnteuOSbT5xygGIiWLM64w31jgFQt/Zils06gqIejvPNQavvIJxyb7Pd+7ZKn3B1Ccef5aSwd+WTJ6jBgtesN59Kfx9wx4oEpvupjbMeFUs4lCMEa8xJjh+eN081c5Jud7qLjgknz57UlbBIRo9kV2rKZLM5QYvo472CYgDJys5wf45wI5eTOC3Nc1HX4bxxz311zzD3vkDq155O4DlANpXPs1dHIndTWBph5nXoHNhnAnfz4mGuBKIDdBXIhani5GE8nm5HYCAD9us1c4/eYeg/Hd0fbIu6hzBp9BCsyqCBOtziyCu/otV6HzTgbAKFQCDGuuEY2aTWsRzG5CjGpamV4jtFnZ28xocEUtdqCqk+vR2CVFSREg3DKNhVCMjVbR8sUhjlGR2dmVS3UOMXs3QMnJojFZJNNNtlkk0022WSTZTZBLO6BRZHekW+x2a4UpBWpqTIqqWkOhQysJOpZAfW1SrQBiziwDRElqUDxQqiuMIlqN3gAzEELIaJgjqrWxnUQUV565CHkMjWlOcafKCnGioNR0mAVe0XDquiBFoOY1ZFPTa3zW5VrjmKO/eJ3nUZFhZmjLKwoU60RxdfojJD6V5Fx5Tal+l0ixjlPakSIBSKB3Gv0Nz73QiGvoDfhiY40skJSaCfvC8+B6JtwRsf4RGKbIj2PGPM7iu+C/YJxIlFvCrDMzDotlFovI930e3XCC7/ulNE/IshEM+FYDtiE94EI9drFoViNYrQYO7BQeIQYjuH5zXJcA5UA7kCUm75F5NkjsVGcl2VKlrBzUCjov1l/yplUPMpO0SKG5DYMEwiqRPEeEXdvl9/PbmZ83/4bCh/hp47xv0Wxpv+G537yWPF578+7uzbcU7MhOxEsJnnUizFPcRbjmaI8LQhTMSF+TyRZim5j7PJ5zorD3MC7sS+wBmkjIq3MnSL3HhALivK0yDezgUPdCxk9qhfZOCliCwgVxeV6HNHeEaiY2ZCJy/unDEEVKw+RYOZYOPKZm5Sdh4wq9wcI1cg6FnMjGYJO0v8KrRDTorQWpDIXQ1G55ygMVAaNO+W9O6yIXiGWlfCXZdFXoBNDI8Vv4mNl0MBX0HVeCgQjEp2vSQ0xFW2jYtFqFenN57bo9+yR3bdPEIu/buv3lzY/7tXAY+kDBhQDRtXNRGmIVzOgBUwsQnETA0oEN2ZHhollIFTnRUB8w51Un0BiOmAyaKjoBF3ODXGU8G37+gULnfiAQgimeDbulGGzwGaVk0KkrgL7lk1qOMbcE6FM60S1jhROME4gnKG4Z1FHg+5sRWrTRtJ+YIbV0VVs8apMC4VTioOJ80eaGOc1azcc2LXynH3gHP06cEpxUvXec30wTrBACdVTrvoVEzupQuAq0NCxeAEloW0mM9LHCCaQYmYhOuM0b085fdaJAWJhskj196dzDil0v9ewWuyVoiOVEMjZ9PvZdekDaeNc7czH3d6z0m82nrhR/GZx1tP8zpQQzttO+fz3Hk5Uc1CzwV4R2FxxLM3MFqfSd5tOhbb7UBoz61AFQt8GXIF+u5BID/TIoRc4uRi/Q+xkLXO0wRTzHYp6OLRxTscvLxwXPb/SF+cM5hAcY3fGYQ7ZuOTOzfYwt/ZH3GmG6cKZP9Y/cTkdywaA50XqHBpDIBY3/Pkyx8Be8WQS5Fi84Fnpup8a3u94F2CS2IXWr8S/BraYzdW6OK8PJhhPbNKYD5xZwoTVwcyGMU/bgest4Vvmc0fn1HHBFKQBHBxM2Cx0k7uWBXpEhS/WKeZY2qBvBEKgpquYdUr1Po7rhYrNrHa+AjrXEPzohJJs7nNQtBmO9ZGir4MIyIjwFfcwYAy+DkP1yeZD1Phoi/tVBWOYqwl0ZI52OMB+bNC24jA6xWmsGcDZBJIQ85ffj9kJBGFkrR2hiMWRhfou7nVFxebP+zhQm9QHddIjGMdGQdg8/KTlOYTCNpg/FPcs0IpobrFvfX93wiZmE8Risskmm2yyySabbLLJCpsgFvfACh7kXjh+x/iAFWAvn1fQCk3jq3CG7J4qdofsHGqa5qi+Vz7k4Yej1znKKyywi4rLknvEDpo0cQvmoJyHLa14syqqXsmFahWs/k4LCpX9Ic5Zinzk1xORAGXGkFRdXA+RJmVg4NwS9amI6M2qtGVVtT62W88+j7S/PIOAlrBD9/uWy3sTQYp+EklijASURN4DEVKp+FQxIk47iN9kUR6O1QK/NXnuPAtlUCG9q/zQWi3PcRk3bTx7jRBSOOUFgSGDDcsFfeTe73h0k0JCYW0INoysSA8YQy4eoseYmXW3S3nfgFbw7pGN2SwjZ0TQOTeFdulH6Z+5s070W2UEOOANFLUFQ4h/78IfK4rdohjPx4dwVBcpbC2+JCpPZoB3BngD0U3gLNdKLt8YFzxDYVqJsZyfm/eViLJCa054posImvKEM9Z4VvAnC9NOUZBE5HOzjGJWPLBRtCXvu8wtAbGQiLS2Y2YDXEt5i/Wd42855xA5He9LVQyXFwPKPWry/jYK6UzhC8y9GlnXgrusTaxK48saGvd8Ic+kgt6NQzLGYA66njXZpPpyrWiulY31sIAm3CUbRZwaKGlwSkuRqrJWHMKzPNbvVjGefg+cJWcIWfR79sj2L08Qi0+njWqbd6UjPCjQ+Pco7KgwhuKDBMs8QBhKqEY+aEJ9jck5nOr1og+DeEc5oVZYLd5XxRVFumTAEa1uoRg3jrXWSayXSaqCYCgmFRuhvmlikZR6js8bIiRKWaSpu+hTft2CqY5jBPYRzpdMnNEHxgkLsYqYKHYxM8UDqgBAXDcpPFGi6iSVFelCK6nZwim2zLFlEUPQ47Y4BHq8QGZiXJNW5X4wJhEWybGdIqpjmiIGArPt9/6st0GKkb7hIHE8vw+1wqPlebJ+xfNFIY3UOY5PMF/4uwdUBkfBoQlBf7YoJ/9eKd3MzBb+PMAQg9vd5D74Od0JXZyGSSLdu5k7sXtAMy57+tTPDW6aPsESYWa2POVjaqt03DvfRCwdWsJ4pd848zBMgEnmfqyAEsXmE3hElg7mPUSND7gKQh/ORjHblfd8WW5SY9MCBplz0Afe1Vwx8oH7028QAAmYA4EMf244CDI+Yvz6GOsXfl8YNytZ9E8N71g42+HgCW6fDTLpcVLyqqipcyabFq1ZySFU0J0pvrnFbCT0Zzidqu4am3oRwMrZebQWYnXlatF2wNq4buZgrdNQZ5w5Vuea7P4oY0Q4p8J8NNTtzIrr6FvBFhL5Wg+TMWgM0DEr+7WEQaPBDNFyOhvO+phoWQuDXKvKIsIlUFCFSXTjzvhBdVuViNpuCTHhnEufc2ZAquT3/d6e9b1gqQ+wCWIx2WSTTTbZZJNNNtlkmU0R5Hto/XJpNmvfUo1aRuSY3U2VLhHidOX+04j0QtIo3RBRrEQrlgKRiKiuHy8MEy1pR42SxnlyoRCNUgjcYazS1GzYYSvvsTJpDDvQxvmyc3USZY+iPYraiDAIPyTRAYoZKzYM5ZO0oSBkpdXrEvmNIsyzqTgr5F8l6ks7UUBImn+E3D0KR+BY9cjK6uLl4twRBeA5bpE2LYUSIiVJZI6d+n0eBRuLVBBBIZLgEbDgO/UoLRXmlZjHMY8oEwUnZUdfvLCwf/YDccruQrq+iHh5pIkCqhhzwRfrz13T3ESJHvICqpt+r4manYAHeXjfiTYs7k9RurXHL5dte79n19JzJLoZUrtkd46k4+H2JSq8+2Bqd/NJL/LLeZCJCD+eChd3Pyfdk43H/R451ypsD4hwwLm8dH7U9St3inP23JYr3s7506Y28+I7REk2nioLd1cOyyBaHTzPHsUNae3zXoz3RBlxp2Bw7YJzXGfjffGsM8V3CrGYOY/x4rnpfqw9loruotDT34sBBgLziv/rRciRDTg+QGqQLV/5WAre632BDggrQxTlUWTq80THe8K/FOKpaInZkOHQYjMK3C6ntiMqy7vD3HMuRb95hwYucmG5IauTyz0rp7BEZaOgjGI+meci6+THIZcNm40KK+UwsIiAU7C8JlFq7lGw8AjrDPOC8v62+IBHBJC0UD2i2kTzJTrN/BZRbckMxLURSafY78q14UvtH8VqsHNEHyQC3N/dGhpGRHYzu26F4TWEQSJLLVnoIWpf9kX1ASoxkPycCj/d3CrOvQqGFM90RZG5XF83s6cTF54iyJNNNtlkk0022WSTTZbZVKR3DyykpuevtvU139moJGJmWvjWa8GYWfm5W2CTG223ZKTzYw8tyhvBIOV9C7zwIYUGq+z7Q9vU4sMRLsaiHS0s4Hu9P/kxYGdFYW7YSZfyoEp/18vOXQvwFDeXH6PyoFUhiR4XePFGkZrwb8Y5c2o9UYZqFreoGpYWM6r8a0UpKAWImXX6nFSeGuU88KEScQgMPjhoaIWICotSV3F98W9fHqNcyhRSge+8LdhDpZ7jOvm+oCQqca3xW/CP+gy0sFOK+4JXVwvPiMSdHGgcgztYJXX5k9eTwjfH8xIp1vvSCe45KAUdw0xxn5nZ7AbRaFEMpNguqMcYW36OXZVmpmBwVvyOa5rtoBaWv2P+HJwKsPeoXhd8ud5WSIz7s2gVWwr3eJyLa8jwsMFfHO++jD3l6tVCQOHHjnNG0Zc/I5kvChMp9AoHLBFWrT2oMMe8UyMRVKzimpUCYOW7r7JLzNNEPRv1HERac5noXscpBbvMKRyrRbXMY0oLd7PkvT7QtIhc+letiS2TAjq9P6oMO9a24oJ1XW6t882ie7F8/VbF3qb0tNiB/shIn0ZlzYXAQP8O07VV1YW5T2vrSWp68c6pSO+v3brZMHiUUcKGh1dBChQSEY5j+zzpexnsOkGNMUmoU6r68CJNOVT9bhR9V2hGt1ZWJs+z6v5wQhXmwITYIhY/Vqb7hkHOPRWuZj7PCu904hiquh2+wIKJo4OTQuZSK7aD05gqWU//q+NlNkBeNrNF1cw6IZYPhw9e4EYR24ziGBEgqBa37LsYa6Q1RQY20mAibx4V9nAUC09yOLFReJLBeXYkXY3Do3tx0rYheoA0dVm8E5zFKgyDY5I755zbYSgU8EWKHAeBeyj3uirSAx6jxWBeaEZxl5kNbAuxydgq+hd8wDiKwTWevl/elxbtuTt9+2fT3+tPOLTA78fy3On0s5wPGEc3CgFLTtXF/WnsrF9wqMQR4a/mn5Mlk0TwIruE8/yWc5BfGWAUe5+d4AsU9i1cMn3tmo8Nme+ir2IU51JgiBM+u+7tPpSuO6AW+W/hu769U36BA71ZQhJ6f5eCU5zj2HzwPU4s4yYv6lWeYvrCWHMoQu/FeBQtKgygkqZm7kTOnffg2LAhCsGSYD4RIQhxzmOu9b7FhmJRbmIC1ga8Y4RbvpONbjiOUZQ3K36rDh8QglhzmJvge4/3v5SoNhs2yTPk5QloSKCjKp5mvfP3PoqXgXdJAGAlghtm2TwLW5BCAiRIMBT17Ze/R6wm+IKBpOwWn+cbojFmqvRFGSwZePqBa1rRx4p1Spm1WBdzJ1gZIiTgNcbYlbfdCq4pbELZrMxskBmnjZbj341vBMLRzwKEXT+y0WzYBLGYbLLJJptssskmm2yyzKYI8r20fmVwgkY6YgRqELu52OWV0dkq5aCcjkKfMkhcSmQ6pxwTQHzsCle+sxIat4pPk8hKKNmMq/rF+bKIhqbaNXK8Ejqz2XEH2qssqEpQQx+Gmg6RhyxiG6p7W2UUN4oLW0UbQvfW3yqL95SjlOMLmVTgF5pClVTdSgpqgouUaM6xssgj7hvRTaIHeSHNrmQRlENWZVKVk5XjJdIcCn1yzl5otPLrVL7i6BNROSJMeVGK2ZARuXqt/B2RmohUl8/WzMy8ENA8At5d8oIo3gmeyb48VySIoWYTar3uql+nc9vm0sQBeZh5FIaIMhEhIukiKc57O7+YzonE9NqNETVOG4r3csqx5QMpSjmnmO6EjzGPvq47nGHvOafTbfi43w/S3R7dnt3YKfvqfYTWLTiMsygPRXVQxG189GL6gizGiTIau1p3lTqR0O6P+fP14jfmryXS2qjYZXMN/QmIiUfGuyt+HcpjzDvpY291f2p79smLlltErvx9iEK8J7Lj6AdZFd6hp7w489x93pdrRVvDPODXyxgDssH36/LOLW8M/YtitRIioDCzUIijuFQyQRENFhU76NOqIjizIdpKH7zfoDWjqNgjrRGVZs2gUFjgQFGETJEa151TzMW8LG1TrMZaIlHdyPxBA0dmSWgwtaC6UCcVKr3IhOqaSNuypkChGYp0XigZxXgKvRg7VxMyUUJJ4nqg7exknW8U4Y9pD6i/QnZ4KLoUmXPJnkeb4s+sFDayVvat+E7aUlq38JGUQpasVFYY2PdtvuXqvBMG+S9vgUFe+2Zby5gjWlYRa7dYKji+heEV4YWQX8TJzZkkVLtdZK7VQQxTrmLhUa6c+REe5F7Tf3qdTGLiOOsEGtARgXtUeLQcYiH41TDFqHE8E5GQu1esFuJYV33Kfhv9Dq5hn2iFR7Mi4MfxZ1JQBg3uD/jqbHwg5KH3Hme72qwgoLAjiwDnpGpcqqHjGnKoQuA2G6ksfa4481SFI18e0uO+yGsqOjC72aYkOKG9P3qv+Js0L5+LhHZsEOC0XQkWWeWDc5PUszKjhOwx/Lk4YS4dPbvsjvJ96Zkgex33Fccqf7bej6UzaMyveNv+nJa05U7p8kw619pFd2426dtacVyMk61yXgt8sVlISoNF3n8owR3WL/pzZBwfFaiRbyCWZ1KfZyHV7HK6yD37JqT3tHq+KYnnERse4U3lOe7KRp7xynPnvcApo12eL+Pi9shY4zs25nMZU0hRM655d2CI4DkyTpS9gmvKJdXpR4xHn/PZuAPbIp2P845TuyNz0GYZfInN9ki6n3cGBzbmfGlD3yXmPYV5BW82TozzQgd8Lwt4VHjnhqiI8veH0RdlX6LdBnY53RN3wmUtiXWX5yd8x8GwoM4ojjWczsyx2doZJnVHo/U2I+fWoFsEypTDWCScV9lmQNdrDdipTkGlx9BqR1m9RLI6Pzb6N1brk05eXq/6TJnAyqLft0f23nFXGOQJYjHZZJNNNtlkk0022WSZTRHke2BEkF9q32jr63C61lWilaqbMkscILWYG6mOJqvFARWqrSpQlb2Oz5U5QtIt+vvRSteGTHVViSrft35fsXuomt9YiqoRnW9+30p3SepSI7RFP2VXPshijt+7qIomKiSME1XVdAOSY2ZVYWDsuIW9I+4VkZb9MiIeWQpNe2lRYq44RXQO5gORpcY0atP83aZE8bCICmd9I3pH/zWaK4VxEaWDxUKfJylWokZEMHhGeUqSe8ExtK3RZu4V3xNhDMleef5EprgPnDMfR/STNrle+iQRVmAPkX0BDiKKggFZIKLM708P0cz4zu/96nh6N2a3RHpZJYgpmKMIU99NjZgzLo4NYzuYPURyOp6XMr4wLiQSWZne+/WRzKDyHROF5jkKG0X1LGYS5eb6JIuDjfK7V/2W5ZzsnLBT6HwQ742wYoTlz0aZUvitFg8rG4O8v5GlWxuPdlasMFn/lRnItPBZ58Slzh2N4nTmIimwMxuJ2h7AVDVmOZNC0Vddi1UeO7dGdFatKurTubehPTAckN2vESaIsTaq3zaYs1pczaN9E0KCw85ZaUno57MusVgsf2Visfjrtm4+z+hXakexJWRROZstOEQc4GINPiHNPT0e+FdluUgnKfow0ADJxN+XtDEDNgvsaWPQu4NVEZabWb8q00IKLegFJxWTulb5Bl6sFK0IZ28kJafHKBYRsndNb9V68V5RTzoMfPR66YjkUp9zr14PaiWhhItUGxAZhDQUz0tKXinlaJcFKYe1AMtg0QY3BmYLGAsYYsRJNP3J/IoDiVOzT5qtZJ4ws8qx6VZ+b84nzF33xKXyunA+mPyhbHI8ZKS9436I1HguwYtjpHRdO6UTBzY52uCeC54UPPBMHWd1uMyGewNbBYxa9GGjTOsvn30udekJx6wqRlWZCKB78z4jNJJ/1u34vXY4QzBm0Ma6O6NIMvuzWp5N43quOMuQbnbRjmenZzi/nD0TWeBnt8uNQUAunI0DGreoLfDjFg+eNrNBzCMcri1/vozz7eH96B2GAXvFCriGpsh1Q6PSw+q8b5bjII4X0Q8zG0RnnvTnSG0Ez4/NBrj4ZyXWj3gPcDgV1hXn3C6Py68Hp5PrdEz2MFf6/RFWm+6kiw0xj8Xc69eE08KcExLrFrUC4QArS5HC2tT5Eic94By3S2aNbgQGp0JVYbJZDjGSE742ag0O1wIUgzVGNlYFC5XQ7s0EMtdcl4CI7QlTBO2y/nGNgvE1s4pWNEQ3AnZXvqd1IMuDNawHnLNFNXd0mFtirRNfQQN7s+O+lgr7itYzxXwRa2ZJqZpDWMJnEh+oYuNgv4e/wr337/PPn05MeIJYTDbZZJNNNtlkk002WWYTxOIeGBCLl228xmb7HuXw3VYRSW2lNRopmia/YItwm9THQgpVzKo0xmHCIVXhAc1oat7b0R3bWDqwiloT1WYXvFumJolQLKlujmitpAW5JCGNL0x23tXOWZgyqmclUctWkV4hvEFBn8iCDhXDZSHJUKzpfwMZCX7R8d3+6OfKKUzUgggx0SyiuI2UZER3GAdE2Km4J9KSM2gQdaN4UOSrI1pFhEygFvF70v8hUe1Rfu6xc7r2MFRYFsWhP0REufdcN+OUwicVUIBzdruM0kdhlUaczWrRCSyKMlfShvDnwvbg8tdwLHeXrxd9iIjlU8N1A9+INoj8aqGUcBB3NyjmW5XXI31enUvZkBmSzFm6PIoONe2rcwdFdsh+e5FicBhfp4htVVxTZAMUYpK37bCOkA6X6K0JM0zcW6K4wc3r458sCONIx4fZAP0IWVvJKqhQDNLozHvIQjtLi8q6V0VOeaZEoRQU6fG+M3/vlFCSaIMMCXMrRboiThR9yOFbRDgFSqLFxfGbBnwruIglKhyRUzKNx4a5Ja6beVgL46QoL+bYBjyC6C5RTy2ky9fQZhG9ZBG5rpBe1mJ0+qS8vyJlPSa+FOsN8xn3kHNpNFoK6SLyzPFSMKjrXN6fFoeywloqn6LFg6zMWQqPGLEoNlR/4zABs+w5TkIhnybrl0ubHXUHZAwj1MIcN0iuq58HrlJwstn58/MAHzCziqImXgyHP7QqbBWjFS+BvHgHMWjgGA64P7BH3WjfIt3lbc/5W0jrQ6wD+McIE8fg+EGA7ym3OyXUICZaoBSSPhvU30hdu/MreLtVNkEFrZn/HeeEYsk/j5QiC6lMINyPoAPi+pkU/L7OsrRYtAmUgupk6JuEci2ccRwFHAoWfVK63AfdQBX4Zx+nggOuMMhUwXNO2dhEO+I4mENX7KLT4+Fw2rBABE3X0TKlGIuZijzQV4FYVEwD/Os0bwU2U4USXIwBR2p1NtF+zS5c9c9JIfv1uVO7etCPuwXMxZ0BHGMcyey6F+eTk7n20QvpWHeEFNe78hR8UMX5fVq5kwo8AowxEA0c415gM2ZmnQuWrO5zeAOsG2x4gHvcuFMeB/XWVd9sKWME9G9Q792s4Q3KIhIQECjhSNdyr3AgcfTP+lgCxoBjJGqN/Rm/nxevZifzMY8oTYjQ+DhmjAXUgPdWcO0OubCPPZ7+FVaHgFyNKQhCpcb7/sDZ9LdvBOPvpy7550DJ0jhgngsHmhoFZf3JHE+luOyXpeNXGY6P05r10LxxTmjhfD6Y+f2E/jLvSwWBI/jgvwn6N1XhxGmFxo4NPptwro85tysdr3R9MOIIY4ZCQuT4gPxFIMPXIhUIkSBNTpU69/G4dCigiRDKSunO1IEWMbJYt2EO8narPmf9xcIZ93PORcAK5zWgn74+a9u9BAhY53MGjUoRr8FmUfXbn8lqH2q6wb+ZhEImm2yyySabbLLJJpvsU7QJYnEPrOBBtjL6m0eDKaqr2Cfi4ENYLbTqU45XycaDNM3j8wajxmHWC99iVS2bRberY7FGCqYqeJMddUS7VaISyyPwWpV9GDxB/9Z0VwhtHFwFXRivmKQB9fqUw1KLYCpu5oOkxZV1JOAtJVyj4gFVURMiK8qvuScp/HwaUe7REMoQEneiQQr/0XMFu0NZYR59zSIccY8iDbxTXjdjTIv3iFYrxzARtjE+WDURl4gIIVFsjbbTf84J53KLYYH7Kmnl1E8/h8BTqvGs17tZRmKq6+Sa1soxpwWERb/GuKHNzDx6GfdUpcMxvW7OpdeWG8+TrBnRVokURtvBj1xCL0zej4gGH8RiwXf6XPk+ivBKdpYKFkCK3vscsAcitrnksjBDtPjJlYM7nqvCBFSuPuYkmZvN6qK81pwQAhnwHUtUVll6GhDE4vMWy0bj+4oXGaEQMgaa/tf5LB9rGkmVInNdY5uQAU37S9GaQvPKk5YFrlUxGtFdHQeimVDJRwuLVbGmNqB9Csu8Wxhnk/FqhAFLj20xgTUjzeJr9aveFv2+vbd/1wSx+Ou2bj4zlOnC8pejQTHWxAMfQnGin8/yino5PiZh0pZC2TL8qDHQ3OHQCtWYWJgkaDdL0UQFNRuEUIYrScsPo1ibjeGjst+rYlHRhlT1Vhhr1bRXxTUhu4/UHX/Pyz6YmSlNj6b7OJZUW1QLoyRFOo3rF6gJ16nMGsX17ZQTi1bMMxUpLVyVDtNq/oC7lItk3r9IKec43ew3wXIhm8rhIvz35zwNeNnT21vCQFBM5n59QCCgzIr0vV8xzwZ8I44jx23IAqnsBxx/OptgEYKgX6TYcdL4Lc4sjgPOHI4W94e+KG0YuNidbHzx/zxHxsLS2R0eSowZs6v+LgJbAIPMuekbzoDiSHm2ORxG5p3FGVcCdGVAnnPvOObACWOck2vYps8pJT+7fqe8tnwhVppC2lCYgwrFcL04SgEtAqvZl5/j3N4Y3kmw9RUlHJAL3l9YDG7DGDEuZgOMC7hA3GvGIPfJLJQA1TnvRLykl41Oty5zLfcFaAXKdDDwOOyh2MTym2BrKN/3gcbOnTaHFoXYEJAKIGMNpdjeyloUM6sdfuYxgiU4wLTBhpn5OxhBOGeJ3a3EnMbihxEsgYXDnwtjK+pSyjW3YnpirylraKwLuRKusugIO0MTty6fDw6n4IhZFzPFuWijUSPVCuQNgZ39ou1wuhvQ0NHAnlL/STCphW8Ox3iEtrbru2BnOswmiMVkk0022WSTTTbZZJNlNkWQ76Gt9vZtPi93QXkUcSZVvi0miNg59mW0N6K6UsmrO7nYieUMGqq97m2qzDU7K76fSZUvFikeB+BrIV4OwFdGD3b3RD6XV6+XbQsUY4hiljzPsy0hmOf4fOetWvQifEHEYRXRP4rQPLJAxIJCOI/uLOEC1UrkkeLEKKwgOi2FgUSKo4CQSAuRGm87Kq1hSQCKQkQii7RENJmiw4jae9GRRJzi72PyHOEgJhLh9ymiXRpxMRsiv4xr+k0kicjRYl70AYsqfwpvuNeSuo/oEBE3MzMvRiKa20mkMNr2giGYFCJSpBFS5bTleyKLt8r3wiyLzl65UbZNX5zNINguaJNnRsSRe884UIaJPFrEdx6t7h9I97q7kAqiZhSX+Tm7W9nzys8RktveZ6JlLl3dP3i2vLb8Nx4pXvv4U8V1B0sFrBtEdYUf3Lb8vSUzAj809z4i50MmTu91nOvStXQAsA4i/dwz/lUmFZV7JvqPgEQOcwC+o8Vn/Ibn7vNWRDm5DhEaiUjdXjn2Op53PtZ4LkBEmIfgXOad4b1flVHqYLNhvPA+U5zIs2Ge5JlZlk3CZuW7EQXBrBkx13pfYlz73EQxF1zsUqyZr6FamFzB1oJ9xSOiXqy6knNGRjGktb1v/g5qptEsWwuICLM28t6yXiurg2QOY31WCBnXKMV/ZjWsMCKlUhy/ks9XumaKlLTCE0Nsa0ze+y4z2hV0KqAT8vtFGe0+SOisYheJpsuMYMU2VYnP1G0fZFMEebLJJptssskmm2yyyTKbivTugYXUdPdNttaV9FmjxWqCra0iwC2pSdlhaXsHyUWuRM1Gd3EV/6Hu5pSrsXVNY1LTcp2VKa7oU7Wx9vV6tFivtWttFOvFrl+oqEaLAFv3kN8IXV1V3LIru/nGrlgp6vLvIjJI2yITS7QilKbWy4KhqlilKk6USOPI9UUEici5SE9X3KRahBlFjXtFn1XtK/8uLCgFKVah6HJefq5FWkR1iCCD2YxCuWX5u/z/uYdEs4hCaV80SkufOPdMxqy+H/l4135TVKdRZyk06r2orSODInR+0VeNrObzgHDtxndklXhO3LNO3hWuk3MqXjw6K2Muv04iqUINOGBU69qIoi+qvMcpxwoi+SnXyxjhHus9xLRgSouwmEs3Syyuclmnbs/K/jGXqBSxFOVVa4u+B2oy5+RW1WFI21UxsfK6670XqwrNsuuJuY/raha+S7Ep90kkyLUAuprf04fF9VQFgfrbRhFqxQ9MHZBGt/NitUYxfFO+Wo7XNaPyBxp6CMV1cW4tMtQCuhHc79h1H0pKUDZS/lY+D6ICxp5oLeR9mor0Pk3WzefWWVd9NpgMAE09CNC8xTyBAcWIVEUvAy0D17eO7RqFfbOjJdCeCWUlYh8UGlSDPr9srZiFuxGnLJwaqepuVDdHs6STNPWeF0Oqo0tT6qyqY8WkTWo1CinGi/RUftQsTwOWqSUtiNFJukoniXPX4k8uUnXqrGgVO/y3pLMpDISbWDhKw7kRsvtID+dV/vNVcU+iSI9jeQY85zt+nFTixyTP88XZEaaKwhGhH1pMR4FTcEnPx49jQRXHMsaUinRkqeco0tkXZ1L4UwMqoPAOFm0VhomF2P885fLXOS+wilQgeOFp+ZX3e4boiN+PDrhHwHnm5e957oxrjsuZQ1y2u0P4g2K8Pf8t7wH3lOslNc1zlOdsR/xvIAu6ecuNe43xPF0iOfigcaQ5FzCAowJrUUgF151zt8bmUwQTAqZg4/3FURR54+D95t9w6qVg2LLNokjI27wvPg/ec8aFMqHA405fKMIWueicYz2KLu+U83dsZBU6gtM+Q3rZ0/zAoJT1Rjbl3bGsyLfBiKOb6crpZs7V4kTeMdrdoHDYm8k33wonU6YMEVkyZdCgsN1wWr1dgUkMRXrZIsoaYeVvbEfWFpYMETpREbGAjogTXznilt1T2qbf4Tj75w0WD217YKMSVqMR4bTYAIQPJA7+jE3LRtGG9m22Prw7s76PaznMJojFZJNNNtlkk0022WSTZTZBLO6BBQ/y/NW2cSJFT0I9Jk+TaCRY0/bC66s7spZsZEtierTAQKIdLZqU6GIDkK/FAS06tYOupwlj8LYpbgsqG71PRCw0DZqn+5VizlPKRC9myh/K9UG9RmSGSIveD65JlH3S9Y5wBI+0HbteKHZCFcnvB9Fd1LGUam1M9UlUipTPOKiIPNoV0tH8XtShiCQTYYo0aqTRs2uEO5VImqSaq6IUlPGQ4iWiQMSGIiciD66GNaT2s4gDEX6ex1GBSPB8kPMmesfY8uI2e+JieX1+DZGqv9+Puz0SxdUCKoW7aNEehTSMRS3y04iyFAul3zhUgqI0lWUm+u73OiLHOm5FYjmU84h2E80sshWz8pwUccV1ev8Zr8gdU3TWgP/EuFE58DHObdrWAjieAUVpLkse7xDHc9+YmyLi6M/bFelQbzTL3hGViuc5Mf4p0pWoZURroVSjyC9oK0sYRUG3BQxD74nwtXfIsXN9AuPSDFMVeebzLEvXKwRIn59CaDAZB0rNphATVbszGzJVFSWav6dkxDRqG4p7FEJLYV0UZevclK+hd+6U30n21RqFghX8jnuqUW1Ms3RWK+mNRXrT5ZR0bUtV2BPowaAAK2q2OdWaFNM1fQVd55V6rsVlrO2OSMkrNESLFg/jSc4/fzpS05ODfA8MB/llG68JDPIY3lgdWLVqgjUOH3es9Xfq7BXVv+JEV+mMhvCFDvbgUa5wsNJuft36IsmLo7zITRGS+P04ji5SXTmDhkiTKiwj2mDSqvBW/WjblbTpGAxEJkhltQgpcDYtIh8afVMnXBa5CotsmUMLZEIltXPsrFntEGyUKSuqoYFi9CKw0GUp7nC2BaYRz4XFm89xUnHWcYh90p7hnGj1/MiGKJwJkRaO9D5jMdL4gtFVjGoIJ5SMIuF4Zdy0FcZ2DDNrVmGLYQbpHKpQidYoByoLc873jeOK070riwxOiDulIZ0MTIPrCkzvfnkOYBAKRcnPjdPhsAaDnUbly5lLbsu5tR2uhZT+UVgdsvuxkvdOeaBxgHkG3ofYUOD48z7QR+4D7xzjJt/sESQAv40TwsaO58qGQOaKwEMHZnVZnLPXuoBjw1iDEzwgFsAdmAtEjKQS52GDy/UxvwExaQkomVkFGWlhiJlLcGqBlsBVPMK+k/ctTjci0hJOtAcNYq5pcOXH9d0px1w4qdwfgc4VzrnC7Brcw82aAeYQxSarP6C1Cvn1CDQwZJ0ZB4dIL6sDXUExCNLcGrjKqzW9Ub+j63bLgcYqTDLHjfA/K1Zag4XK31z5N9k5Fv2+PbL3jrtykCeIxWSTTTbZZJNNNtlkk2U2RZDvgR3EYlGo2YWk5CHVn1olKr9vSlYfIBfdUqTRimONfGvUu6meo9WxB0nytqAlIVkqVdCNiHkrsp6nhA6NnDesOofsniMlFypY5TWMWisSzDk1LcjnRGmluE85QSsWk6zfwXN6RKK5WsWtRUlEMygc1cxB3KfsfirjiUYePPISlfihbib81zFG/b4Q9RDu1wOVl9bKtK5GZ1pZm16qvOPzA3g0q0hXKwVNm0QjNZqvcsfKtKFpcrMh4iksFXEsUVtgDUS+g3v3kKqVXrIcedEWFhEyol0SeSKqq5zhtK281lr0dKCqmVy3MkjQB8YY0S2VhcZm49fSZ5H56l3n+Y9AYFKbEkHTyCMMC/peSMFw/lnFR66ZHQriAkokjDkKa1G5bIVN2AHzTVeuDXouzcrFz8huSQZtjEGjlZ6v5t+unBsqVo8We0mDoaI4RqLPVZRT1rXWHBM2xoBkNg7P7GRejndDMrvKaiF8/dXYEyv66m2r3xFfq0pt4/vDmCjuyhpKv3p/moWCs+5pRZAnFot7aN2ss25Wpr2L7xsvt1rgpG6CwSoHkMoo1u2OnIeB45MP2KQYzJE6doEIxnRjsgoBkUi5zsr2cqdFHV66pOkwTT2KTKimU8I5jfThvOhbcQ+4h5KiigXE77VOcmEyOUa6EGdPZFLztoeUYYNKShazChcoKbm49/RZYCRm2aKD+EzAF0rsnpLShxMq+F76FrLhwGOcxaHPsbjAUpTWTfCQPXsV2tD0mP++W5UOYlW5vzU4pnGs4j17f17Qq3CvSSljQEv4m+NcaERlV3NYi635uYEYhJSu/4YUOedko4TTyiQfAiJl+rM/5YwMiH7kjgaOnGKNFcZAul+o1fr70rPprgKPEQcRh+r8ufLa8uvQDQJY0/udMUPFObg+FaNgjOomLWovhuvuT/t1PpnwuyaMCPF8YNYA162blxAhgd5PnhXvom5mzILJJPDNQEUEk9rN/F1zwZxOGVV4FsxnQG6AxWSORTcX5oioKfC+5M/Hsg0sbQOV4l4HY4S/W4rFPTrMqTEvg18NMQqHkmnbzAcq8oEJG0Q4r/qvWSYpXtKwBUOE0r+xcdgroWO9bIhiw8f7s2TOzqEl4pT6uO9kUzEwZfj92CohhJUxbbNGK22gWQ3XkOvWNTbmcd7/cE7FYVSIJBjlvI5nUQbyWpSvwDwGdirWRgmQrJUMWQfWQfl3A8ZcBI7iQtz/AGohdVrDcetmdkDwTmyCWEw22WSTTTbZZJNNNllmE8TiHlgU6W3+fZsvlTQ8u72t1EIDUhHRWgDpkgYlWhupD47b3Sn60OyPZakJOWdEd9kVS1qtKRASPMpDCraqkG2l0mXnrYwYAdCXlFzrvqXrEF5MiVIP8qECndAIClXBXoA218jEWORcxBYGUY7yfkSRoha1aJSDCF1LMOSAVKSS2CtRfhRnUCXN81N5cIoTKf5jnGwOhRVVkd5GWaQTn1OJT6U1kacQtZDCov7uIhnFd400dowHzok0L/fpIS8MfDzJJkd0i+tl7OWSrEjJcu84VyXNC99x+TyjLeUgVi5r7YPZEGXjO+YK2iaq7cVdduxY2TaRUS1aVNEPjf7l/QZSQV802qOFjtwXopNaWKiRYwovNeqf9++2czHzXiIpTsEg10eE7YKzlRC9VsiUMMYUUVz6c5uIt/BcS6FXFNIRcee+wbUdrEQUBO8Vv+9yjnXe060yGhfzHXOIsM7AALOiyI/IKwWzUZQq8J7Mguni6rWyfxG1JEvlUT1Ye5gzhGOZ8RB9uzQwhZhZyEWP9a8pOd2AjPXyXoTENFF+jcjmBYS0QTG5MGMMbRMRlSI+Yaeo4Hta5JZlKxQSoSxSlbaAQimV7UHYLMJUvCnr55iISNGmFEpGllpZqKS4vgXzzPvRyVoSUtlSvFeZwi672f87WCwWi4W9+c1vtv/wH/6DfehDH7Ld3V177nOfa9/4jd9ob3zjG+3BBx/8S5/jT/7kT+yXf/mX7b//9/9ujz76qF29etWOHDliDz/8sH3VV32Vve51r7OXvOQlh7aT07ytb+I4iaKLZYNOqzYbONmW4k5F0aaf0242aLRyWl+4u6ZzC6hGOVBbVbFm2cSpLBU6QZCicyc12B4CqqAOo1TLHlT9K+mroHkTBo1WdbNi1vR+VbRw2TGBF1TsMAtjwFYyQvzseocFxiEV6sSzEOVV7q1UlGKpZWGMvimBPMfpIq94UxtxeJnE6TcLo6p/CV1fbDp0Ynb8bDjpeWo/sKPeFlRbOEgYqehr5eedL9KRLueeBo2WQDRy51cdWWWfwEnFwWNToQwaW6XjFM4rrCek3LOUbcdEz3uKU3G93KwEmwXsDUJ7Z8LqEs+Vd4w+5nMY9wC6voBI+Dvigh+dinLcEEcX516EJqLPwAby8XCsHFPdfVAG3ijbVsYI2laqPaHg63f8vXAmldXHPxlNhihQSxGOd4nnLY5ubKhkk4YFM0xQDLZZakJESHD6HbSWDQq5cPyFxUHx07lC5YBDp57BNxWilBfznUBvKkU9PifQc6qkYivqG6SmolIM1eCBsHZEqp7nrU5pYHilFsOsgkjoPKwMEHGvFc+sLCC6wdeajfxc9EFxuxJUCscfRiBZB/k72C8quGJGYaeQUHFsowv0sVJAddhmCxIKjEJhmzbi+Gr9Ev1WX0l8KNbG1a1byUFe/spnLovFpUuX7O/8nb9jb3jDG+zKlSv2z/7ZP7Of+ImfsOc///n2r//1v7YXv/jF9tu//dufcvtXr161V7ziFfaiF73IfvRHf9QuXrxo3/Ed32H/7t/9O/uRH/kRO3HihP38z/+8fcVXfIV93/d9nz1D9xCTTTbZZJNNNtlkk/0V2DMugrxYLOxrv/Zr7X3ve5995Vd+pb373e+2I1nR1Q//8A/bm970Jjt9+rT93u/9nr3whS982uf40Ic+ZJ//+Z9vZmbf933fZz/xEz9hcykg+6Ef+iH78R//8fj/N73pTc32chaL9TWPdo4xLRxSedkU/jC+7sd/NxxQ/D6HZOhvWoWCVcpCuQ5baX1l0MjuZxTXaXGhpKAOqjwt2hwRI8n7VES3tFiysRseOjvOzVhZo4J7zFrR+kroRL4fpEvLCutOU1NjxQ0qGCDMGVUKUuRdq+p2vT5lIMijHSLbPQgqSFGmFDHNBJqgKeYwZa9opf4su0caGYOVQIotK1YPooQeKY+IosI8LIusyT3Vqv6IsBNJVahIayxpdFyfkdkQEVUOZu65/kYZNTSSrMcdBGdRZoSQ76Xwh7SvFABq1FqvU7MU+TUQGb4Nn3FfHqsMEFxnFMSWzzVsKXAH5tZcBrfigi/fqXgnhBe34i1vMXGo4EYecY20vc8JPpaCF1jFg3SZr1gbDuFFzyOpDYGPqvhYBZy4LOEabs2Dw/WPzMWsFQ22mZbkdAXja8z3VXG3ZRFvjVKvlRFybaMS0Bhbp4rOj6zRh8AzdT7SArgWU0RTxCu/jobfsWoV3wvTVQWJ5DiJ8o75JC2oYNa50evKOlMd/3QiyM84B/nnfu7n7A1veIN1XWePPvqofcEXfEHx/f7+vn3BF3yB/fmf/7m94hWvsF/7tV972ufAQf78z/98+6M/+iNbkwXdzGy1WtkXf/EX2//+3//b1tbW7CMf+Yg9/PDDo+0FBvnIt9haL9iekYEZrAyCF1rJy17BHZRZQTHMstCOYYZ08AZ+ilTMIc5r01p9MauoaJTku4JrjOB5C9NJDViEL+45zEHxvUN3S8o0rQquqHsEmoGy0UrTblk6sVpcDluM2EiQFiXFKBCUCrKh15JdN/eKfoLzqxTxBA7SCa40oBUCtYjrHhMKYZHmN5oW5fidMmW7EozpjLS5YjW3toprMcuc0zW51yLqMDBlgOcVgYiKiq0vj+dZZNCScLZwgDNcdv59QCjU0dVUPX/Tt63ymRQYX001a1vqhAXM4WbZNg4VMBjaUdhHPhfty3Vw3QElEfGVmVwXY5VzinhF9XmxEdQF098N3YRwHwJT7WPSGVWC/YF3jvkMR2ts81IJJ5QsJMB3AlLhcJfoE5tVrXdgUxYCIgLdMRugFbDoCDuPKgzqRlHp4HQDVNHDjVHMKT5U54bWxk/wwNG2Ku0JfM3MbOkKf2ymqxqSgADJHKlwN84NfM0hOfPTp4vrzq1aG7QmphHo0HVO18MmzVnu/DXqlQ6lkFMRj1bgS9b9vE6GepuBrWRWnLOCdjZo7pRhYibsSweyfCkMQ9fdFk3tCOz0M1YopO/7iNT+7b/9tyvn2MxsfX3dXvva15qZ2a//+q/bH/7hH37K53v5y18+6hybmc1mM3vVq15lZimq/d/+23/7lM8z2WSTTTbZZJNNNtlnjj2jeJDf//732yc+8QkzM/u6r/u65nFf//Vfbz/yIz9iZmbveMc77Eu+5Eue1nkefvhh+6//9b/aF33RFx143Gd91mfF/3/84x8/tN1+fwnT7Wj0dibVnQftcpJJpK0C2ovMZAOwXjZOKtl30lrMxY4y0sVSQNiofmXnufSd99jOK1Ip7CC1WEV3gU4QCYcv0YPoA/eBIoDg5s2imVEQVqbjeTpRWEHBEIVjkk7Tor6I/msxX8GgURbjEfmKczIORKI2oheSBo0ULlGSeN7CTJG1HREhilO4hwLXiMixRHEjekNUIOc7Nhsq2i9drq5bf4OUtPYhYA0atT9ZRvUiSkSfiEg7r6yZWf/UJf8fzyoQZaYNIolE0iRa3WnEUKNgRJS51yMFofSn9+uM1DoMIEQWKaS7Vd5TG+NBNRvgDxS7ZtCd7pRIaROtA76gkVSeI1HMUy69DMeywhy4f8HcMPQ5sgswQXiktDVeKxgIbfF7CiqZB+O6d8q+5ddF/4jSEymkb4iPcM94Fxk7RNKZO08KL7JADswsOMEDrkGxGs+X+Yn7wXjthGtYC+aYW06W3OVdvqao5PCOz7vwnY9EQM3yZ7JRtq2sB8o8lPEgx28kWrvy62T+5fq0WC+um3mPIkWeQZzUhbGygsu4Pom6kwmlsFvn1IBzBNfyrPh8dtyzdjelDyNQwWhbi6UF9sFYmsm8PhSvUYwqLE1ESYuC7/TvAOuQYjVlqQg4W3k5WrQ4RIP956yhWYZoKZnMyEILBFQhdHE9szJjPkfnQYrUh+MzcgHmTl/zl7JmDhFjKz9XGEx8btb3IxHqhj2jHORHHnkk/v9Lv/RLm8d9yZd8ic1mM1utVsVv7taOHTtmf/fv/t1Dj7t27Vrxm6djY5CEwOzwnaRLupmmXPwhi3M6/N4nEKV2GXGMa+WzcpBXDlODgiVUdagKDnoZyPBrHLFeL20FS0Xg5FTdx4/zBbOorDUbXkRh8cgXh7hepYJjoQRaEVXA45immQpocJ2C1VzllebrwlrCpCyOYLQVEyhCA4LZ5Z7itCgBf445j7Slqnv5PYoDBbahVExCVWWScVndKJk1zDJHQLDXXF843QL/UJogdYxjTPI5lfv5wjor039678IxEJaDobpfztEQjhnDZsY9xDEOdhXvC/eWc5ByB5JAW+oIcgoVGsidc84lYyPGvzh6Jhu77oJvcMaEMPLfwYqRM67MvG2cRzaZLC+7cu4W68MNaVvhEnqfzMwQnWFD785WJ5RagVFek3EhQhnhlDtVWUUtmFNQ7ft1KcVaYCpRfCxZZnrZnFQKdEsfH5ed7mwskAKMTlVIRZxDaTdJk/dK7yhBCrUC9sSceQxIRInrXckmularY71zLCuba+boBs2nmQ2UevPyPVehpzg1c21LQY45iDGmMIgRytBogw0Az83XY2Xf0QCQSU1GQBFW5XgvrmMEE533b1jfrWgznM4GrFOd3INo3qIvjdofddK1LimeVQOqka+dd2tNWIbep+y6ng6q+BkFsXj00Ufj/1t4XzOzzc1NO3cuKTr98R//8V9Zf/7iL/4i/v+rv/qr/8rOM9lkk0022WSTTTbZM8eeURHkj370o/H/58+fP/DY8+fP24ULF+zGjRt29epVO3PmzD3ty2q1igLAF7/4xfaVX/mVd/dDZXMoTKp8Azgv3H2yq5ttCj8uUV+NHGqUYwTkH6kUiUpXO7DVovidtp3LOZtZwCECFjJS1BH9kp1jtKHRC6J3nUQg2A3K/Ysob16sdrSEnwznKlPk3bwsvlIi8rj+iKjX8s55H8xGUnINGeeAbRDV1GI+olsRFSvZKyqJU8siJiqJnQm4FG2JIEJEiTwit3KO1pmn8iuJ2rwgTavvpQgxJKOJ9tEHImxEpbk+Lf7RaG4eFeK5BryFdLXDbpCMhh+ZKBVRW6L4fL8rUSLG/bZEHrN+RPQ9bodfvwhBdMLW0cEjTPSae6oSyyrBnPeDYknGNZE/MgmMKWRytUiL8avpbp7hwsdTloKn3yG2gkSyRkopxoviPM8kbEvUk0i7Q1Aivc9zH2FriecVmRK/19xDvXdEA4ni+/jotsu5SjNPRUSRTAjQiH2BLxCV5L2X8asRyWBx4XOVaj49FBTBazwDzsM7w7zr9wyZ+oC13e/HM9f4fUIAiDkoBIEQA8lshmT8HXjtV0X/g61AIVQ6b0VB4JHiuHiGzP95caLytQuscHZEorzBay3ZDN5B+kKUFxjIsjzOLFsL1pVlSSSyBZ7V78EtTKGsd02L8jWbm2VMq+hsRNmLrtSQixCdkayl+APZxfj/ZF8E64xGeCV6q+u6iHQom0WLQWMsixHPV8TRIuteXUYJ74jfb2zYrDezEb2jMXtGRZBvZvifra2tA460gvrtpuKG7oH9+q//un3yk4kU/qd/+qfv6jeLfr/4b/U0sC6TTTbZZJNNNtlkkz0z7BkVQd7OMHYbijcVy7+/c6fG7Pxl+/GDP/iDZmb2T//pPz2wYDC3/3v5q8Xfz7cvsM9Z++LquGGHNK7205JO1h2XYll7wfAUKn5aZCdYI1TcVnIvlXOX3822RIFOd4sH8EcGFlmlJ2mbvjTU4KI4kQIMoiTK3Zp9p9GIlUqLyg597qpnFOetDiusFOUiM6vwbBHFQSmK4h36wg4bLOcCZSmP2IgMdERqwINnxYkm8qbDDZFCSVWtEtUreFWhuauKd7gfGe1bjCmK7CjqaWFLtUhHuUtVeloicl0WtTfB8UWRjlLmKe0XUbpoW3CDtKsFVKLEl/czMibr4AA9sgyXcnAs+/hF/pfivZYa4mJk4w22VnG8RMS4HmiNtKiN6VR5golei/JiIeHNvT6f1Obs0tWybygfEmF+MMHj7CIY21nR145IHOdW1cIx5iGeI2OB33J9UpRGWxG196i1SjZHlO+4R7Nz/KXgtYd5uIyYraCS8+voZO4dJJqlaJc+U8x0ebivM8m2xHzEfRBMts32i88jokqRH5FjCsoY10H/lUVxVTrdzxk45lb2KqSay7k3TNT8mHvzXOwwp5bFmJGF4x4SpY/Mn0fpz96fjnPcc9+o4wiluZxiTgsAha50JutR9M2frxbnq/pszWWc1ZTIuWwp0XjmJ9QI/R5qgV1FTSjre++Z41kevVb+4jHe/fTj9A+JwyOlDxfvVmsNHcEiV9zLgq1u4qFbKsSLfev7u8c6f0oO8mKxsHVZSD8Ve+tb3xqUbWZlVHhvxNnJLf/+qKSN/7L2Pd/zPfYnf/In9lVf9VX2Mz/zM3f9u6+af6OtwRLRr2xmsyJd0BLniElYCMebROPyglZk6WNFeloQINyElZiFiI2EDDKLOY6CaMCPWRQGcH0qYqHV0DHRCmNGJZQxXkWbS1XG9XHduyXXcMVy4WmjKDTxez1bL9upJlT6nHG+VpLgsWBel3P6YTjEUvUcEwttL+R5a0GdZc6oylkrB+tu+Z4pV3EU93iWhmrxaiOVFW11+w5TIVUu92pIVbKQlg5jpG6DgaOEWMTCK8enD/3dCClpX9TU4dHjN8p3L5wYHWNb8OeyccjkvRkzMU7lPeR6mDuBVrCZ3PT7osV9LLj8Dkcrh0FwDxgjFBlxDvivPWUezrntledQIZEosFqVf+cbL+4B7BM4djxXdYiQVJZ7Hm3u+HsDBzfjiGsbE0jhXsEIIgV9IQSiGyHdlAincTzfcM6z+Xy/DAbwTsDbjfMKDCKKumQ+UI7xcJBwfkWi3myYn4LvnHGK08541zmE5y5wrlkwzFzzazidfifvsFnmMAW8yuE6OLYhfy3FXSIwEu9xxY/sfWW8ZOMkNro+L3EGngXrVLy3a9I2fdOCYPrCPEbxXlbwHZsSLc7DsRPmkNlGGbiaCwNScNMzx/KeBA96xkqkXNni2AY8Z3dVtIWDXznKbuHkRuCr5Ho2s0rgq4KGNBLlLa5inNxoV4oxc+c8SAH0N8peoexDwkFdrj13D5x4RkWQT/jia2a2o8pGYnm0Of/dX9Z+8id/0t7ylrfYF3/xF9uv/uqvHhrJzm2tWx8cZDtE4WWyySabbLLJJptssmekfUoO8tramv2f//N//tInf+ihh4q/n/e859n73/9+MzO7cOGCPfvZz27+9sKFC2ZmdvLkyXtWoPfzP//z9oM/+IP2RV/0Rfbud7/76bfbr6ybe/Rsn9D/yPaKnSH8hwo14LAR+q789wpNqCPUw99RKBARUYEWaNvalgD0Y9enMI8R2cgqei3XUynqNFI40CpppDyi3bLLzj/TFFOk7xT+0VIj1Otig1bR4mURR5HI7qVNig+DDopIlNKbca8VQiNqWYXKV2Qlyl36SlXuiKgJRympR4WoqPoV15vzktJWRHck4qRFe50qy6lkrUR9ouiHz/OUO/dc0sAKkVGZ1IhSE1GvpLfhapaNe86LKynxGrZRZl2ir1rQS6GoR6lnWtymYzU3zq3RWYkgoSg4KCdKQaBkljqJ9nRZjQjQCYWtRGS8LyNPes44x0IihpIpieKeEeWxfrekJwxOYknFDz+AX5VorSgs0mflE1bIktnA50tbRG0ZzwKDiPlNCl1VgW4ooC0LovN+xj1V6WhgXXFOiShLJiXOzTgXeM8ofE2uRxUww2KOLAtiNRNYwd24r9mpm9mouF5RqSMrecufr2QxK4igwAnybCzHHiYx3YLtVetZ0FwK3O+g7HmjaD70B4CWQLknmT7NalaqeAJhyPupxAMVba3CNlsR4pYiMOdT6rm8f60svGb6rIzuRx8W+9ZXdLJt+5QjyC960Ys+1Z82LRfu+MQnPmEveclLRo/b3d21ixcvmpnZF37hF96Tc7/lLW+xN7zhDfaFX/iF9sgjjwSN3KdqYxgZxdbOhC9xOO4QOcVG1WiV0s/TYg0+TGXdUExPOK9aYasCIkccsjDC4djJhB8vcQsi0pUvYgWTkL7EeehbhklVvtoK9xRpzjvlcXwvOOIqlaMLUzahdpt+r3FO2JzAPQr0xPsQz12ejTppM5glSH9qRXZmcc9pOxZ8v0Jh1miR2kdae1UuvAFVySaoWLxIvYoIiYoTDHzQMsFSSR8wGMjxfezR7v3DRra/dCW/uiFtvVtOworrjnGi4jXgo3ECGbu8u7njFWwD3u8bnsZeCNaUjYEIoYST6mn8kAVnnJC6D8GcbPqO1LCPPyAD4Hxp+7bMKdwfHCggKSvf5Ah8B7aHHjiF2cA9zTkE9xliHozXdXCTZS2CwURB2+Hskv728ZMLKMB0wQdgbuFrxsnmeePksNkIuFfJD94d83Z4VsIOYpaNS4EbDu+jwHpkfKyeSmsY72bFiAPjhDLq2OB8KztBJ1zLM4Uh+VyidRDAHJo46QyLGxs3gV8N/O1+3bdLp7tr8GBXfUEoJwIq2SZUoWOygTdx2oOtAg0BeQeV/ULhfQVkLgIRfdGXmCtkbYi2eSaMPXEUI6ikc3URdBCnmza4HsavMoUoU5Y44VWwacQnqdZMb7tTqXHGsWw6otZKA0Z3ERCssNP0SVk93LSWanhnuM7Oun41Grccs2cUi8XLXvay+P8PfvCDzeP+8A//0FY+uea/+VTtrW99q73+9a+3F73oRfae97znL+0cTzbZZJNNNtlkk032mWtd/3RkRf6Kre97e+5zn2uPPfaYfdVXfZX99m//9uhxP/ZjP2b//J//czNLjvTTlZrO7Rd/8Rftta99rb3whS+09773vfbggw9Wx7zyla+0hx56yH7hF35htI0bN27YqVOn7GvXvtnWhBuwAJxHyrHB3UcRV6RoVVnPRtuOXb7CBXKTHXakTVQdKLoq6k5SMBeg+VDB05Redt3Kyyz3IaK4pOslLRg7clUTkvYiMntAkV78RqRaq3OKol4oERFR0p14FmnAInUYVenyfOkj7BOaggsuzzIjEPdhVUYycplUiukq/kvlxSTCMlLoZ2bNyMxKorpEtVM/iBRKOhMOYiL8wo9aVYHLGFWmjZDFzpgk4joZ12RrHkgMC0RI43qAL8B2QJSDMUnamAgbEVRS8nkBkRYXEekG3qEFksAzyE4QpWP8NiSn4/nn1d5E1hjPqgCHjLMwggQHM9dBn4HiEDFHspvobZblicix38Om+hwFbguJdhHd1XsdBWgeUeKZiApi6t9meS6dO4TVJbIQZA54L0TFMCLH8GGPwLiCEYLnr4p5qpQn74W+9xVvOH3OM4IaKVQoCdffaFuteseYD3hns7R4cKPzHAIyIzy3RBaZ92TOUJhL9E0gZXkBcGTuuKcB3/J7xBogmUyNtMY4EcVFhQuUGcHy+mIN1XW3xUIlyqnV/KbrwgGc+lXbCvcQH6OlxKdEAGM6DsoIUWWd1aeoIGMNbQgYpTTam/VR4RrV9XAKgXgGxEQhI93MFv2+/dbinXb9+nU7CatPw55RRXpd19kP//AP2xve8AZ73/veZx/60IcqKMdisbB//+//vZmZvfzlLx91jm/dumWvetWr7AMf+ID9y3/5L+2Nb3zj6Pl+6Zd+yV772tfaC17wAnvkkUdGnWMzsz/6oz+yGzfqSbnq/6yz2WaZHikeZCd7EcHQKo7IulLEQyWmK5YLxahmg0phDKRcgqReaHIGB1IcB/5UHKVvDIaq4qEvOIAxoapgiqQQ1dFVWrxo9zjp/RJvWFy3EskLtU6k4HgWTNIcRypPXzSZmCqxj6zfMYFQ5Y7ziuxr0CHpYud9ErGTaLdbFZ/PT58erltxv0piL6nTSG8KpCLOuSWLn05YORsGDt9pvycwBeDwhbPizztSc+POeThx4rQEk0S+gOo4P/9AOhbBA5wvHB82ZVyn0/uFoAhOO1AMHGMVLzEbnBOcLb4TMQ5lLYgxBpTCU+tBxcYChbgHzzK/XzjAbE76kikGSWYo14LdAicUPDBUbDjrOCIwUoQzky12bC64p9zr2JQJ/ZlDRTreFcYUmxrmTjYWbCCZJ7J0v+LRY2zslHNKJdLTCXRA5b1pN4Rj/P6OOMiBa196G1wnz4SNEO+5PPda8Kl09uLzLJYV7wxOy6J0jAMyBdxHMMYqW99vuyPCeI/70RXtmg33GrYOREtMAgHR7wY7z9BgSaEItKgSyDEbRKBUSvu4MGMo0xObcGXh6cXJVdqwMYgF3yluV+F3cly0Q3BJWDHUgc4hlpUDyMaVNsUXqBidGlBKmDV0nSwd6aX8poQIYhqwC0YRFVtaK+9TrKFbdbsVa0Xg/YXhSk3gpxVE5S7tGeUgm5m97nWvs1/6pV+y973vffa6173OfvM3f7Ogf/sX/+Jf2J/92Z/Z6dOn7Wd/9mdH2/iP//E/2nve8x4zM/uBH/gB+47v+A47duxYccwv//Iv27d/+7fb1taW/eiP/qj96Z/+qf3pn/7paHuHMWpMNtlkk0022WSTTfb/HnvGOchra2v2rne9y17xilfY+973PvvyL/9y+0f/6B/ZsWPH7Dd+4zfsv/yX/2Jnz561d77znfbCF75wtI2VELgriuQDH/iAfdu3fZstl0u7c+eOfdu3fduh/bqbosR+1Q+7H5FDTqbVnf47Lzprcfzl7Y9930yf5LulqOqV1APRDyLHQCiIbrDjrKSaOcc4UXfBoEEU5pA0kOm5pM+6C9Y0WvQhTw8pV6U8n25Zpo1ix63sHJrSiWh+SbRfFGVuyevlspcaQaEPVbEL5yaaMy+jW9q3HGIRbRBpEfnXiIxqREzZG6SaX/sWP8s5mIGjUMzDuSI16RFmonREsVTKlMgTEXTSoVotn79jUujXP/5E+jzknUtGBDUixBEp1yLMmUQss+j1EAkuo28hS35H4AmtiNTlK8Xfw3WuivYDsmEWkeOhMyWsIaLwyjHtxXgRrZ5J34QNI36XSYv3TGTB7y0FsbyDzIkUGQI1AHJB27nwi1lVWJgzS1SFqQI/iTlQK+d5jhTzyXMeIFR+H27Vc02M2xv7Zb9DyImIsoxvZblQJhwV49Fsng0MAnEMkU6Rig+oTLRdQqs0UxhjOKJ9tYsQzzU4kks4k0IHaFvnXsZJZAo1g7BTZ6tUbIJ/l3BOVzL0ZWSUyHFEfTVy3IIm5N9JAWMcs1cepxLSWHwuRXudZGPH+hFraAU3TOeAPavTNivml8YzEbGP3GaNqLT2UX2ImhFrvMhehVTGfjv062BYx0pYuwqIZSvqPGLPOAfZzOzs2bP2vve9z9785jfbL/7iL9qb3vQm293dtec+97n2gz/4g/a93/u9FUVcbt/2bd9mb3/72+0P/uAP7F/9q39lx48fL75/7LHHbFHpiv/lrZt1Zn05aIpBUGGKDy6ljBergV3WtMFhVChVX7N/qwrqBhVLrw7Dskz7a9/SMeWLU6ncCJsFqacOhyDwYcLOIZPfWBpFSdjDMdZ0GJ83JkzFsHWC5R2qoTOHqTHGqrSPspIINVuoWAn1Wixekto3swxDKOIVmyV0ZFCvKlOUOGNVylUXayrRMxW/cOC4Z4IbrGjOuHfxrLbL68LxwDGSivsKmmHZvaHimmN5V3Ryl030TMSH4p6DXR2j1uPcgoMeaM+8T/QFp5Z7CdyB6xfKQZPNXsHmsFa2HbAOYCmq+qasDPQRyAFOqTq3bIzzDRG/UfVGxmuwWThERPHPXPcteV9aGO58HgSOIKqElZPNc5r79XKfmFsqVpOuOGdsqDIMbyhFyjsTv1HxidjollAyTd3T7kqUJYs6B/rTqJmAGSIcXsX544QGvEXo02JO9r5lfawgczq34ITKex/zm6TeIxUf2GOh4co2aZ3AGQIiyLytm0pYO7gegfMNtI8O72AeFHhI3v/hTx8j64jzMI97jQSBAh+/LThDBSmEJeOAOh6FUAzsUuII46w2KNnUZxillhWV3PhYYA4KzxjgnCV7RXRN6oIGaGmGQV7IZkPXytl4XVOIsoyKunyGCoXktra2Zt/1Xd9l3/Vd3/W0f3vixAn7rd/6reb3r3rVq6oFcbLJJptssskmm2yyycyewQ7yZ6Kt9vZsLkTdeco9/l8jw/L9ENWNL4rjY9dUFe8JR20RBZY0XkRZx5khBqC9cDL2cu5KKKMUvUhtlBGDYRdbpotUfARTvsnoe1TJl+nUnFlAK4Ojv0SaKo17ui8pG+EJ7pVHemNWnY9IeKT/IrrcF23S3ypaq6lqiSStRPwhIs2WR939OTTSoPHc9Pq0an9NU5ceuSGapIU3ZtYty+Ks4PUl8inCERHlWJc0IlEA2ok+liwIZjYIIUimI6J0fD7G52tZZIpCOgqtgllDooRZtGvgjPVIkRcnRoSNiGHAMzwiOt8r+h7RT4ks2nFhtdjLooaMeSKL9I9zKaNEFI76dRJx9PtRsdEw9qRAsug341sixyEIopLKM7+nvAcqh818KIWSRSRVRDaCQYLr5l7SBgWjyuKTy3abDYWBFGtGVmeIrPUi4w2vsUnEOwrklKuYCKzCmfz42bn7/X6UzyRvK4xxqXLIPANhqQjYksy5+v5HwW2WGQuRJZ2vgERJIVzMQcCfZH6L+wQHN5k17kcOsZnX86xZtsYEawkR83J+qjj1RapZo/mjpuxLwqQRkVZfQyJyzDkFLqEMFcqYlH+G4JdFpH+96EO/KovJo/BdIuytYrVBCCpbQ3d3is/CP5GIsvJ5V6QB4mtUug2irZAfW7EpBUuF8DxzT5VzWhmg7tKeUTRvn6lW0Ly1mCdyUxL2BrXMoZCJw9rJrUGxpm3puTHFLOsG4K7OHX82hpy8KDoRKR1Mi4LuINNz1ymmMnUX1yXKcdVEK5W7ZiOsJHFSEcRoUdEJ7COwuyw0pM2XB1w3bckEEyZ0d5VSmKigDc74evF9vmBXJPTxb0lfNWD0ys1KpaQXghJ+ThErKWFMh0xnYJG5p6Sg5d7q8QOby6zoQ9FPnifpPXUcsVAKK2mtwvkUUYeAoujGMDOFBlXpbY6Tex5OCu8tC487QUq9N8ApMkexsdg2zyWbsjC9tzpmdeyZ1bRsvEtCsaYUidEH3g9xjGI8ANFp0GEWv1GWGaV10+MY7wrTYQwLY0NxSECjBGbUet6Kd485p8Qsx/c6Z41YizVJGYIqKk2lyBRRi+EEQslpVgU2FK6gTBAV+5AyTzRgimH5+i10ZnHdSr0mcIiKgUEYKSoboXdt0rs16M1a6nUVvFHqgkb9FupzFKYh19tS1KuuW+uCdByN+EwtrHGLgk5V/HJb9Pv2W8tfuSuat7sHY0w22WSTTTbZZJNNNtn/B2yCWNxL61fWzUuu4hxoPwDqzf+dx+8KC4lhKebTnZm0U4lZ5LthjexKsVoNRSgPb6UotFI3fpefT1JPzUghfwrnclW5HAUX20WfxrTstQBw+FwkpONZlJEIjfJWLA/aXl7Es1UWb0RKXVJLFam/FN9FdOOYFNL1kibOCkpUBjZMI8a0IelxFVRA/CO4TIU1IR9rFfF/QxjDBErB71SMpRNO6pDmVoGJvD+MayKh950uju0l8t1Jmjvuh0Rkq3R/Bu/oiGbxvIACMMYYDxoJZ7h6nzuifTzvEFjwvpL+z7mnRaRDLXh8nY0hroO2N8sxN8u5hs2GQjoZk+k6HabEGNFIOM+xVeirESaef8VRDMtNFg2l7YBOedtkCgRqEmMS0ZLbfi7S5UTW4hmW8JAimquFyfF8/F47bKOCmCDnTAQtpMa9iFGKdKOYLRPjKZ69mSmzTSVeEkIw5fs/QLCEaUWfRR5R5lytKB1zv7B0dHDlKzNGRPn9/UfcRwSFzEYyI1osvrFVtDFIcCNT3pC5V75/zpePc97PVsYuWJckOquZruDcH8kum1lAD/Om71IYYziASKoW5dHgeHH+GDQU+GDFEBLHCBxLIuMV2YAyfGnWOvcdpEhe4ZgqJa1FfEBOou9ra9b1ndk4AVZlk4P8V2RByZbjiDR9IwNDVV+o4NSq0IrNQujR1GE2q1NNAx7aB1ADMqCpqyFtwoLqA1irf/NUfTiVZUq5SqEKi8MSXByTN/cUQnlwYwcRsys7h1QSD864H0dXcG523YkRJyUmYFmgy+pfSTmp6h7HyiLWYsaoBEW47hGnJmjncPC1Ojk2SDg3jpNGfAUsL2NJU7nKHJKTxoN7Q6SAe8X3qmIm2DUs/r49/nwDw5lP3IxfFtn7XcwAXKvggYMpgGp3wUlXIg04PbSLSELeNvda2CcQ4wDXOjiKPj4QazlaOsYBf+D1F9y0mVl3/lz6H+9PjCW/H/Qzrk9I/iMNrgwpYD79/vHOFXOL36sKY66UgopdRegFhzKcTx//sgkJhonMQdZNY+e4XXOscTBgRB2D33vGHvOBO5yBSWVM8nvvA/fBLNtUqeNAv9koqEIgKWsgWP6eBCuEUtfRbu4UiwpfqEsGFKycawIny7wvMKXAtDKniqNcQKi4dzgt/n72OEpSc4JVUKOY9wS+1hIryfqh71bMW4jtqKPLuxTCSOX8WIl+hODGiFJmQ4SkYvGQwE0Fb5O6gGFtrR1wFdHoV2WAa1BGhUFDISbjMMc6QFbDtzR4Nhece+U4SyCsgmMq25Syg+RjbbEqj+UYwSuro6w0iKHat71jq/4ucOZuE8Risskmm2yyySabbLLJMpuK9O6BUaT3so3X2LwvI6uj1uI1ll1Riycxjm/xDDaKCYpjG8bOSyEV0TetPM0ryi1Lj2VREN2lE0kIYYwGn2Jz5y38sHGfVC7b6t1qqyDSJOU2RMIPKW6Lghr/N7u/FU8x0WcibsLVGkwZRGCIWBB50fRiJW2cXfdmCQmJZ6AysFqcJxCTIcohcsmyQ5+NMElEOpu2I6Um0BCuU9PhcTEegSDVzLkoVswFY6QgMJposVmIdHJEnlvZCY8KrlzMA85aM8vkfCW60ygICmiBFMgp80AFOeBZLLIxSaSLsbGPhDY8v85SIcwnVXES942IMu85WZBIH2dRI0nPE4WEUSPOAXsF0VqiXsA3tPgyJMjLtHiR9j7sfRUYR2Q+iIIRIQYGIRy8Om7y7yu5Z35DhgRIBRFRxrU+VykM7SRjNGaDxLJAnrg+5haeJ+O+mjtL+E9EBbk2osAjgiHVnCjy9NEX5T1uRHGb71y+ljSitXGsQofk3dK+R0QZKJbKe+eFckAYGY8CKagK3BoZUmWKUshhVXA40vYwj++Pt6nrtViryL4qesv6VxVfS9+afo1m1mTtGC225rtWUb1GjhtczWMFkot+3x7Ze8dUpDfZZJNNNtlkk0022WRP16YI8j2wnOZtvip3UUUktUXrMhxgZtkuqSF/id0tDVx+zNgubawPeo4wjVI32s2pW2YiwdpS1Kt4oTXyPFJAUPRV8Fjld1KsV3FLj0eWqyIIosAS3Zk1cIPpN1K0gjUi4VXkvLUzl+h9Pg46jeaogmD8qIx+VDKxHKZRTY1mZ4UrnUZhMImyD+Ncxn0jUj4UvSnHsZzHcr5qkSk+jDJOKPQU27mSaGZuSiWmRUqVCY40Iu5EzInYKC+yRL2LNqpzlMWnSh3WiYpZYFobnMZYgc3Uc2shq94HnTskOtlVtIcUBkqRb962Rjhn5biscLMi/xxzjFBKRp907JlVNH2abYm2W0V5I/jeoq86FsciqY1xrM+gEwn2qlBOiy8l4j5eUyKZLOwwrlmRmo7ft4r98o9GCrHNsncvsivjY67FwVvV+ahEcXbumoby7ijmeok0Y7F2oHo3QjnXokhr4Zz1XCETvVtmeFtrcB6J1bWtaluKNYOLWGjhRnmOR67lIKvu9WH0tWrdLNG8Ld55VxHkqUjvHlq/XGZwAYisM0exxS0ZPINw6frg3SmB9810yd1wGfbilOggbaVR1GHUxbBB5D27iwLBqvBAXuZ4sRAruSWiB9oHXwxzmeAhNSoiIixesD1QMHNE+H2Vq9MXlplW4N4Ng0aDQYJ7Nz9VFqcME2V5nSHO4WnBYJyY1RuigI6ofLVyKfNMPBW/omCMyu3Y5JTObFUElN0DLezTgrkxXlszG8ZQFFSWsAgtfuK4/Pqi/wJPCYeXlDpiDwKLaIpXMDZHnPNwiBjXQbovhZxcB0WMV/x+xEZgXIo7ICghEx6nrjiUYbqg8M8klR5pYQooz6bitt6hIzFG6QsbJMZwXuXO+7gm7yVjy597f8GFNBhTVrK3VMIawe3s51GOajPrYCehADDeQxExOHtf+pz74cephHzMQRTOIYgyxvcNZIAxIkwZsUmTOYjjV15IGGwswD0YiypRnW2wO3HOeY+5ztWFS97frvg+fh9FqvS5FJvq5v7cWQayArsW5zLjn+sJQRHhXI5iPGHWCPiPpuJzZ155ySvu5LIgPOagKLL2z0OyOY05xl4871UdUKjGVGxcS9GOanPl5zAJzui6znpX8eJnxwwflOwOylyVC9qkA71t1sbgph7nNgZio/0ojhUfR6W0wykP2W6Eg8o140BYiEI5WzzkreCi9LlfLg93ojObIBaTTTbZZJNNNtlkk02W2QSxuAcWRXqbf99mUP5pAZ2N0LhJuqAFIbjbFESk8NjBZVFc3ZXTl2ZUu0F7o4D8qm8NhR4zq4D1h6kBNYsaGhKfVRFU9lkl56mFEVowgakkrRaQZPQx+fnytuPYBoVSC/aiUYGgtEL9jWc4QquE3GuLamnpVGEhRUrkmEgL0fiIgklhhRYQ5t/RP7/+OREy7YtERCsqrgZ8R1PORd8a/a5o6gS2ERK1yFmTtQjaqFlx/CjUQiASTciIKuOJjLPCBiKiqjLXOXwkIvplZDzaVglmLy4Mqjyi3Jtl9kqLM1WxLzciZ1FsxfNWujcihUQDGdfQ12lxp5tycpuNRPQbKeiBBmut+N2g4lhKsVeFY0SdCl7cjfHvFHohnOvxe+U7FkjNwEFcwihGr1OhIpptkLEZsC6ZU2tueoFsWH1vseBeZ35rzJ3xDgnURCnHlJIxXY8UPkY25e7Whuq6MJn/R4v0VE1RVUeDKlF4f/tyvloJfan2qVqjrF4LWlatsQ11Qr1PB8E6FTJR9btRMFet20JnGzCPBuQi749GuNWXqiAWLTW/jQ1b9Hv2yPYv3xXEYnKQ74HhIL+0+ybbOOLp7xGOwBamuAVvaBFpN6UuxanNZY9DplnEC1RiucLJVhX2MnE0HOKch7ASGWnhfzml9/EwqeawltCKjbwgOjG0+IFFpKFyoP0ZcJ1zdzgKBo3GZDbmyKcLlUprYA8NSMVwkSxENUaxwoEKFllFODQVO9b2WPuj6W+VCA/IiU+o62UfVtecPzYjdTfLNhSKoxYWj6K/fIbDh1PFb1ScRR1MZRBQYZhGKj+1JdhifiPp/HCYuOc44UBRnnwq/S1OYPAmZ/ykOLyrK562xwHmXut7rH2TVHQ4ILqpWR/Z+AJTAUqRcQUX58ZwNAQfHtASZV7ZKmEyxXUH3n2/7Lc6/lyfMElo32JcixT57P77yt/n/WacBn95yQ1fPS9ZcqsNT2yktI4gY8gRLvHqPeXe+cZo6XCOllR8bAhgaTlACCiOdajI8qkE56iEPdS1EPaOigGItUSYJUZlrwVrWwUJwlkrsegxlzKvt1hctO7BynGXWy0xL1BAGR9V8OiA9as6lzqjAvUKHmTZlFSy3lrHofNBwUUs0BIJHuhvWhDKZlCN349gvFsMGS1YqZoKffV7e5PU9GSTTTbZZJNNNtlkk32qNkWQ74EFi8X81cGDnPPuYVqd2pJ5zD5I/zZ2mByv6YaWlHN+zhas4TDewerzw5g58n7qLlfSI7E7bqnkNCqQlUc5txZsQyPLrVRORJyFmaAFNRmzqtJYMwkKZ+E4LYJR2Vit1M6fRSMaHZ8rQ0RExssK/LADIsXpUrKUnB9TwRCUk1QjRw058yplLxGZ0X4SYWtwdwZTRDybOo091pcq+pcziYyko82sjmZxb3mOomqpz73iVRbGifycAT/RlHojxa6SvRHlEoaUigVjpH8KKei1cEhV+oiQ7st7zudEGimsGpnXtOhUi1Irzlode25RpCuFRq1xU3zUUk5UBgVhrdExqO9iJc2em0jBjz6XrM1e2UtUzj7mM2GlUaaJ3ORdI3t2GAygmUFrMAcVUdxW5g/Tex5Ny3src6yq5I1FJFuR31aUMyKpXG8D7jCcoISD5ExJFZRA22hEWBXu0VLjbUGT8t9Wxf+H9KUF91DWjuHndYa9pQXRXLcbfcrvx9OJIE8sFvfSulnIj47qisdhvITl33k7uVUvWuBmy99H6iOwayOPdyUOkUhLVxKdis3i+IYEdVxCPkk2qHSGtqksLl/e6rg1rw5vCaeMTJqaelNntXJKBTrBkwj8mN4/rlsdT7OMOaGB2xTHqSJUl+dYUW+RPg5Gigwf2XQi50XfBgYQWdTVFLPLGAR36lX/ZkMleKSYRf6WxbcJlWjhIAXDGwtn7swrFAJ4glSpc3+CQYCUcuC9vdqbtDfjhnT4bu1AxdNVB1gdAWEzCWiBCqcInjjGLinoS1eG6/R3YiaCHqbvKWNSWC8CSiApaO5x5ZzntH6Kb16X61ZWBnH4SOsHywHjXplTeGdzPKzit/3eBR4ayAXvOePd5xyuP3DyI5SB6QDZ5GQWjjFOq4y12ODtyXMMtp4SShFj7Iq/u8zvuZS84LgrSXQZe9XmQ5zvSrRH15oRcZZgyAC3r7hgjlf8P6bBiLUS7jVsqDPInEIqfGyAW5436MuqOVghcwqxUKc3ayOeI++WpvtdHhlWh9ikqbgH7eraegDNWy3kZeX9aDBDqPRykyYtDqivW3+rzvfgzCqFoMNbuH8SCIs+jAS4ZrKmqw8UfdK24r3YHz3+bm2CWEw22WSTTTbZZJNNNllmUwT5XpvspnKy0jG2AbM6HaK7RU37VPAIlcAcSTPFsVQKa/S1QYKu4hvKVawFClQZ55CMiJQowTiS0xpZ0Iiz7CKrHagUEHYZhyNpv6rfFDISjSMiQ7RGq57ZwWr0WqR4iark/Yh70pDEjlSiFqdEGqkh7nBDop4ZZ2dUgmtxohbrBXOEFHFyDRJRXl4vC+m6EUGOapyqxCz9VqnsqLgvI2ZVwVxUkZdFMGNtRIRNpHiVe7Xii77hPMrBWlGyG8S1ZdHMGCNe0LW6eNnb9syHyPcGkwT3jugu7xJMFHwO5y9sD3kkNdKaZYQYSey+K7NMcd1uVeRYBEY0qr3azoq4VK7Yr2clUWktiIxCK94DovZjkALLImzZeIB9pZdIP5HegE7c5wWEFO8ptEQisDOJsGMFZI62TzvvrxeZxrHKeAI/snCvdwK1WTkvtr6b8d7Y8P7F++htDPNwyQwTxcO8iydK1hqNHA8nSvdp7mPPbCjg0/e7YqngnZG5tZespc7BsS5QnLs9jIdqDuHzSlxmnK1BI6VRTK/rwAgLU8WE1BDniOMlchyZJeX2XZYR1IoNxEYixXBJ67o7IlOd/92CKgzR25p9q8qqiKZCRLU3t8rjW8JfGjGXQrrCN2nANIbr83u/KNmHqrZjXM8TB/ZdBpQnDPI9sJzmbb4SmMAB+ClerEo5p4UrqiAHB+OMCmW1Q6ji1AmPgabppAZF3aBcdUCqXr5r0d1UppiuVjppRLRiSG+WmvVKsaZqbsG8ELRJ5cKjfQvLnTXBDKuaVaT5gMbgKAgtVFWJK2pXY6IVnaR1mZyV/q3CAcp1qWOt2MWwnFD/ti8MDQUx7XeMA6mCr9T7lPaNfxUvnV+G0nUJjjkWN95NPy76xiInjBtjEIsYM617JIIh0UfB/VbUYyqUwvgfwSAHLGEBDEsgQKTU2Xww5iQFrXCAgKLwDHMKSZxz7q3SmrVo+RS2o7Rweq8JBOSOItdLalzT1zgQ6uieKUVaqg2kMItgBXxLIAWx6WYjI5sQhT8ETloczqEmYZwWc/RYoeuKZyAp5rhOmccqB1HEPYrNWIMSTrHoMT6VdQdTqJWydigFndXzUDVmBJ7WUpoLk/oNpdgr6M50DsFUIbZBGVcJR30K1oI3VL5Bq+ZG554GNLIIcLV8hwbbhrah2OMWDd4Yq9VKagEqMZGWyrBS02U48KejpDdBLCabbLLJJptssskmmyyzKYJ8Dyx4kO0bbX2tFk5oWiMFUR8mxQyNQqoWb7JZO0p9WJFdS9O9gjVoVC9PN8nO+jBBkMNI/1vsHlWVrB2+o9brbfHEVsdJVDu+z1NTumtvsHVU1pLC1B27VOQXu35tmyiORluVR1MjMUTSiAbK/akKTK2OoAydkmMV7qFy3QFbITK1Gv07TwtrQV/AO8iItCIpGpWXKJkKo1QRu7HrDNlbYZI4pCAyIodbZQq2YnvI4R1abIopWwGpVef5HqJfZfFS1WftW86H3IgYVjCNBpNC9UwU3qQQmzya2RD8qVhaeJ6M10bxTvRJhDeigPL2EImO8arXVaX1pXCb+8EzEzn0uMyDeNL1XWpwCjc5dTXjJ8dVTBN5FFjfQ/08+tTIrslc0uyz9tHqtaPFPnS3XPlNZoYD1oGK8ekuWSs0S9tkThqRXK6K5xuaCs31bWSezo+vGERGiuwrn0Cj2C0mCWmnuQ4ewEJ1mLUy22M+xKLft/f275pYLP7arZsdCmUorDGJVS+gplEkddGk1ckrURVSsJAXokGbo7rrMeBMaN46Jv1aIKVKY81qBz617f9DKprPGy9JBZ/QdFrW30ovXpkSBOtUpRwrB3qciiivUJ4dVZU2cM+Ob+ReCwUbbWMtxg19VtyP/Jxxz6E9oy/++fyE492E3qlyGKUSfZQhhX6AOQdLGIT/4oxznAiKqCCIUs7psymEQsShDWgAjg2LuooWtCgSY+OnsBh3asYW0K16LJjZkO53fHNFzQX+VXCkkT7GWVWH0zIcrKfrow1xLvW4cHS5L9KnYNJwiMKYSABtKG5XHfr4V+Ea3KdMMS2dRO6HOspmg7KajyHYVCpBD5zXub873aI4HsYJxpri32PeHIELKKVgwJnoi4oN+XUG41HUkAj7A5sY8JTZexDvgPe7gqXoRogNgY45DU5I3cRBohUqMhSf894LxnqYg8CLa4ON9z7rAwwJytSkuO4W/EzrPAYIhmyIfQ4O/Hx+nTw32ejMjpT1OrrxH4JGAplrUQoWDmMDXrmUY8Exy6ar6Tiq0uwBFH2qgNeyUFDlXisriVsVrBth3GjdE1XlqzYbHKebj1lnXd/dNQZ5glhMNtlkk0022WSTTTZZZhPE4h5YXqQ3i6xDTTjeFLzQ7xspm5VEq5pSxmNFHS1+Y60ObQiGKONEM+Uz0rfDrlMjzE0Rj8ZuUlP6eRVsFH41UolVG1pxvCbpXiKTWg08wiRRpVIbu/VWhFhZSaroDiYRutTPEqagzCEVn61GXLRoEZ5RL26KSI0Ut6TP/J5Gsdm48IEypGgUPpgy4JW9frO4bKKhwfZgNkQKaVvemSrtrUILTIc61jheZJKLAiLuuf62IcqhEIwqrc07plzlAr1Ibcq41sg2bVMQSXSTaLb2zS04mnmmEtU2s4qFITiYhQe56mMwY4gkOeOZz286o8gIq0kUT+rzlkh/RMxVMp13UQrFqvEghaPp3DI3aEFosOp4H+DghmVHRWl0nKiIT37/BBpDgW/Md7y3UvhbRbulUFghNJphMbO6QK4FheL4Y8xbO8X1xDxGxlD7xu+zdyyi0lpUqtnDljCSMEZUhbEScc7XtZny0OsYaUAu4jrUJ2hAy8YgBwp1nMOAI8WErUJmhcQ1RUtGCuV0TtCIdyVUJuQBTbGPQwoLD/pOs+naF2wMevN0ivQmiMU9tNXevs26EvtZYEEbhNgt9Z6mul1FzRJfpI9F9S4dKt/FIFyOHqeDVxcvPSewiVGrVHukia58+YefidOuynr8fq2cWIvvlYKnH6/+7TZqXKeZ1YIabkrzFpCVEWiNUus1YTgoDnKcEtBrZbZuLLqRZ8CkJRCZCi8YE3C5OHE3Qg3xhqaucZwyp31NFq+R1Hjel3jOOAS6kRDHkEUcWq1iU8K99cVYGTLUWW+qfynUINqlz37dGRVTODKithhQEmGlqJwRSeHGq8l9QXDDx+JqP3MUVywY45uSWCZwqK5eS5+Lqp2qM4ZIiSrs5bhQ7TemzqZYjEUcLd5RXkVVigxWk8zJZQxJmr8XWEIFIRPRmXB8G4wLAW/JawwUnxtOdHnPenFC4/cKuZDPoz1RFEwflk5ZOG98HTAmYULRlHtsysrNa2/75fWO4ICbokLym4DSsD5VMD7/XGAdFZ48u57qHWsFWQKaMO44KbuRwhrz9bF6nhpcCkd3/Ptok/WO9UzgXaP1LwIZCNo+Nb131XokwanGeVY5zK9Rb3IYM0asX/gcGvi6i/qg1jnr53UwFr2p3niITRCLySabbLLJJptssskmy2yKIP9VW2unZlkhm8j9tuALrerYZupihEkiuAhbKZZI1dA1otilAIpGQbXgIAfaq+iGijJUxSkKrNeUnKSN2OXHjjWLtES6PorsSj7MSga1Ve0rxQ8BNdEob7b7VUGQqihDpJY7gXNE9FMKLmpJcamSN7OVsixoBXl0soz2ROpdhTFEGAbrjozIywq7hKaeoxhPj5OIXEjrCjetinTkEUXlcdW0aCUxK59HUR/PV8UetBgqu+6AL9BvIolEcTfLKKYKipCK7nR802e4e10oJL/uSC1v+z1xWIrdKvl8KwgNbdA3ituAfWyWUfEQCsmK4DphtglohQqIEAkFOiOMESFWQlSf9luQFbNBECUEMzaK38ZxyrGtnPRu8Wyqoq9Z0efiM43SYsogosWpyhAinL4z0uiIHeXRr4g6NuTaQ5SihByZFiEG7KHMJOh7znthlt1rpKEjqicsHmQd9R6rYIzAe+J4KXrMv4vVK6KyUmzIGKMvAs0YIAd+vHIcj0RHK2gE9xDxmVZkWaBkWBS7iSyyrhtmVsEuWlzLevxqd6c81xjLVN7uWEbC52nlJB4iwL42yvwemWIVT5Os8+BTWGXKTNUpsYHyISvDFdeVwdR6TWEfYFMEebLJJptssskmm2yyyTKbivTugVGk97XzV9tcMbzZTu1QnkC3w4DpzSKAERWc6jvhC20W+gnQnqjlUjCbTWWfnGqtVVwoRXotbt0WBlsB+VVBnlkd8ZbrWQmuV9tQfFllelyOh20VwAU+clwyW9vGqmhBKxpgVhXMaBFLpb7XwPAFxda+jCnBhx5USFNFRFUGWoryIlJD9CDogqCHWpWf5zhgImicWySYVZ2LNkMWWdT/FLOtFFR5RFHp6CpOXaI4RDFbstj6bkqkkWebR6+5nkoBkCgnhY4h+9vA2mpBJJzGUrRVFGUSAZTC1sBnExHNaAjNRsae4kqFT7gq9jSLqGWMBZ2fyK4F1aA/L6H5i7YFD91J1qfAw8acIvMQkTSegbatmGTw7LwHGnHXQjOzYTxq/3hnXIJbC1tVvjo+Jxoq1InRp7Girdb81KA41fdBP1clPY3m5/2Jd0D7p2tJFKs1jteIeyvTlrWhfNVaXFy9v6xzUtxYcXh/Kpz6GrU+RKXusHVuOOFw/Uq/1vRjhK5N/ZAKY93Irh9EbND6TVUw2CoANEtFestfmYr0/rqtXy4HPkW3vHitKfMoA00lGYd0Cqm88QlIi57yNEnFySpk5JUMpLxYLbaGKq3I70YGeQtgT5HeMJGUE45KLNPH4DSWiuzccY7UEhAJ5yBe3WpUtTMps3hxTjggG1r2A3ftSLEahVEKmaiKNhtOqqc3Y5HXTY04WGbZIjQiGlO0feZ0apuCNxwIoDW6yKuIB33N0ofhGAs0Rivlw3FsLPKxqLGgzMrU5igzgRZtqeCHpuTc5n6PcSCWDntQmEf0mWeYb4CFAaPiAXbnExhDJ4VV4ewJfEOd0nCcRoqXlCkhnEl4jP15R1oY4/fuUEXhWIMvunCOGFt6LJvlkFRObQeMReS9K/5zRF7gKtY+Wz7GfINzrIRG9LeEO3y/3NgEi4lylXs7Ab1RyIXZAPERTuwYI+tlaj3eT8aHchVLCr7YhJgVafSuYueBCcXbhmVFhG1asuYhD8+z0ALJ3MIJL+el6JtuvoPlotwIxTvJOBZpeeU0L0zgWbrZDpNivGqebrEV8dx5/y3bVKjAF+PU78fSIVBq0TedO1tiXJl1myUcMSAHLearI+Pr80wZMwKSVK6deR9WAt+ooHLRyVlxfOXHNArkFEI6KnBWwTHkulubErrWKow/xCaIxWSTTTbZZJNNNtlkk2U2QSzugeUQizWheRtTgWvSpUhqosVRfFi6oSm/OfLbCgrSArvfpXxki7Ju9Ji7lUWV1A2mRQMH9o8uaCT1EP5npeDRYq1WO/5HeYzeE+Xi1IJCbCxqZ1m0h0iLykibVdFY5QGt+t+CvzQ4Okc5qhvS6BW/b6uvcr2t1NyBmRKuV+We6ZNH9yqaN0nFqoqbRuTGIqnD89wrzlXRECr3sDzHTjIQmqItL0h4XgUaoWMnivQa3LNxvETWor3sfsZ1VVAQMiKrst/MA0LbV3HvSmp6FNIgY0bvWQXjINLa6Gt17uAg9+eeSU03oTGMV4rUGA9azCZFypE5gBZPKfeyCFytzlb2SWEvB1KI5dcbJ5D703pn8z6odLRS5jUoM5tRwBHa0iZvv86NkTnS4nOBJEgW9zDoYXEOpSu7ywzxcMAh93yEB7nVr4g+C0ztMA0BtTE+YdVhqBTwWjRvCutsQUhU7nos+9xSAmxpJRzART1BLD5N1s3nZryPI+mSw17GeNhS9amDvokrCpYLGcgjvx0wsyzOZTpM2StaxNw2L1PvwX6RY1KplKY7wjHZ2hgMJi8F8qLC6hHwh1wGtzERxvez8l7OjpHeLsU4dBMTKVscjZFUXaQ1pX9DmtfbCiEFga/we2RPxVmLxV+YGFIb4AGBn1jR7+ijyqQG5taPx/nk+iH9DyyrVNNn/Y57faR00qoJdb+EWsTnDf7kwLT62C3gHYw78Izh2IoAjKRQK9luUuyr0uGsxD3yFCyQCHGMo41ghhBIibBxxPWIcxoMBFTcZ45iOJkiT6yY62CMAIrgfMhY3D99BwU2kvOFa8o1JKeBuQj0ROE60bcQIfF38YhgzMewr5AY0KbAUeL5sHFCMIN0MOMYJ3yj3ISHwIr0Lb8u5dK1dWlDjte2u0UJvZiJRHuMVcZkfp0KoQg5ex/XHM87phhk3lHB3lbMMmNzC+NankHA16ysrRjWu/I2DO+zOPEiPFF8plzCsR6xoRdoAXOn9y3WPwlOVLC9EVMe6E4+P5TXuBVUOkBsS/UKKhaphhM7Wy/rdYY1s7FJGatncav8EGWn4Dit7xEmCnVuK6GRAzYnLaiEQh/D7xKxkqdrE8Risskmm2yyySabbLLJMpsgFvfAAmKx9s3BYoHlKfdmNPMQqARW7RIPqSaVjhS/acEwKq7HFkuFpjpU/WzkupuSlI3Cqfi9yD+30kaV3KhZlZbXvijHcDNd1ohS6zUU1x1MCSXPc3yvLCVSQFExY0h0J/pGtCOPODYkVSvOaU2XEXm6XUbQK5gHfSairMePXE9LKlujOHFKl5LWKGf8jgKTDGIRhVwKYxCLCCqFjyHRWzJEBC+0F9YNqmgeicuKtqrrEelgLbJTLlpNwWvqOgrsXB66KNriHSEaTUGgF2tpBPFQxgi5f5XUeK7kFYWLR4p+Ka93K/Uaz5E5hMhpRJKPFMfnGQOi1VGcuClZCAqo4JzmuEbfWtcS4yAv0qP/WjzZj0cCK+5phWSIDLqqQhbRa2HIaTG+DCqNpUrdIMF9s+hDJbUshcL5dUbbFN0CS3I+a+5VzJ1SIBefczxzyAFwsOAr1gIxjToqC4lmPnjektVQhbqCSULXzBbjhWZpVRabqLfAQCpNgRE4jDJJRLRW7mkLvqDR3cpkvTAbMjgKcax8Cd5fWRsrmGMLrjjiD2kWvYJVKmRU1uMxqOei37f39u+6K4jF5CDfA8NBfmn3Tba+Vlam5y/YoTrhwxfp3wY2V+EbDBpNDxUUcw2aN3W6lfWhTs2UFbdNdoQWLVp2PerQjkpF5223nPoWftasxnfqpKWft0RaDpi0inPmEAtlDmnhwKSPLfJ3ZcVoYv2yc1VMAUxquhhhLQqjFq5MKNryfoVjL5LDvVSrx98CD1DGiHBm2WBp+jzvp4pQ4DjgfLFgSOX5TAUlWphmuT9mVqWtwwEWzHDlKPWymO/KcxeGhdiU5ItcX74D6nxW917bEFzs6HMtLjx7T3h/xXFShoUYB2xCYE5onKNjEwPrhzhk+fUqFV7lpOsyJ45/OGniOKh8eGvDVZxDseWyGcFmIk5RYZhxIMTpz39TUQfGnHow9rwKNsgmvKJQzBlTVEykok50SB3vaZOuTzZpImYy9Lldx6N1LJWIktQWVPObOGvBcoSjPEJ31pRIliDSwKhyq/h95TAe0XdR1gWzyqGvPndr4p5bNUfy/ZiT2gpwDT8VFgp5vsFqIT7EodR0I203WSgatVVj8I1Fv2+P7L3jrhzkCWIx2WSTTTbZZJNNNtlkmU1FevfaGgV06aNyl69SjMNvD67YjN2RpFtix6bVptmxWAsw34RStEDuWnAwAqKvP5PocxXlGD9XFSGO+wZfNB9naTG5FxSItMRLWoWCGs2tIujK8Wkjz+luI+Uixar8wBFx4z4samhKLxGinlSqRqM0kiRRkQqSsTVOuD9a1NJio4jIk+zPIdpXtgqFb3Bf+LxgDvHIoMjcVlytRLtCorjB5kDxlkbNGKMjxUuYRt86kXuO3/rnK4dOKDPBICcs92MMviUFTsrFHJ8rHEBTzowxiaTHGM4jcUTZdSzIdVc815pBI0oJb/g14DJlBiKPBlfQiDXJDJVnqKOz8SwkqteCTYxEkKPIlnvFvWkJYnB9wDUkYhjMKsLhOxZZM4niDtHMElLRhEjNyohy9IGxG89quI4K0tUQAIk+SrGyyRiN+UtZO5Q5x/L1iXeiFFuqoAO8M7vlcTFuhKs5or2xZmVNHVJchnX6HAWaoFHQXiLM0e5ItLSTaHWTsUpZO6RtbPAD5HfZHBRF/9X7ynxWXlcFoWsUIapPEn5Bdh6NOg99Ugas8j7odcbvlk9PanpykO+1KXxghParW2vgZhqphk4WrV5TFgKbUJW7snviCPO5quXM5XiBIigJ+IFE3MJa0dJeb2KRFCYBjOOI9GEsVbtqpfFI85OCLjclupCGiAffy0Q1I424qhfvThanQWnLU5FSoRyTFOwVkopVG+7Hkeoz2Elikhaqpbh+ocPSDYTiZcNE3CF1H2zhiXSdODruQMyErcJEGGPAVTbegxZeNjuHcb0qoCBpXd3YmVKNcU0CWxq9H/TTn1cnDl+nzBFCXxZ92BQnDwdJnfV8gUEB0Matwk7Tb928AP/gGcV4bsOFYEqZnXCcruCeFf6gTCgmc4duhGcnSix6sckTthIT6FQLghHjnvkg2Bp8zuGeg/tXdpCsTRzfJZstSTVXVII4lsy1vN8h3rBeHD/MqcM1zISeb4COMQLmRd9i7pCxVol5qCqivh9mtgRDz2firDRrQwRSheBVwPHkfTionkUdxJkGDeIH5Zo7bPAkqCIO8dicugx8sjNEVO+I/9kKgChLgzq7rCUq2pX1Q5VsYfKpIJHxPksdkwpdIRB0q+xzLnBWsWU1FBM1IFTBXWar0eMPCirinA++Tvnb3jdXNXzDirYmoZDJJptssskmm2yyySa7BzZFkO+hdfP5sIse4fQbgz6Y1SD24Xh2x542YOfeAKxXLAj515E6GY+kVFAElWalyrkVLWhUquZtYBW8oyoglAi5wiGIdktldlVYNXIdERGSyHGV5tRUHbtb7kdInNKXkuy/aNPTgcpvHJERidoG3+lOWbyjVdOMpznRzBF4h+l1SjReIwmaao7iRCALRFS4P1L1b2Zm/lwi4ifFaFWxGcVayrBAao/r45xS/FWMD947TZGrNC/9VmndVqR1De5teYbZ847iMeXEZlwT/dHiLJgWIrMg6X9EPyq+7AzSwT0gAshcArMAkuJXrta/zYxMSAUPUf7cbA6bnfBMAZzCcBBLcV5EM3kmIr2sQikhZewZiJCozotfiXirkEcDvlFxVDc4uONnfE7UcwRSo5K7UeDmEeVKbEZ+r+wV+nlAM7L1AchQzo08dr0DB72PGaTUKUol86BFvcI4k2cr5nLOPkjTvX8SfQ5eZ+2LFtDB5tCXUeHRNdTHKfzzMY8JNEjZPirYhgoDSdQzXweqQu0WA4ys/bHOWRk5rgrnNBOcM0lo0SGfS7Rav68ip30Zca2eSWSM6zbCWNeUrWNWromVsFUDMqrwjlkxpwpUQqPMI1Hnsk/CA721mdAYNenSqE0O8j20frkMkY8DFeXUmTzoWKvxNJUyDe2RPo7BUadJqnTGCOOF2UiaTPFCjZe8efyY8YItyj41MV6NlyHOvZDjs35UE4XglStsqXZVICnKfqHnK9qE1H5bJgZ+u5LnyzPhnHzdmliFLcMsW7QadDex4YnjxtNfFV1O47kWkASdxGXxirZCSAKcoLchdEi2XUJUel308mejmyU5V6dOmTjt0RddkDhON06r7L5xjN4rFh9Jd1eUWrHw9MW/QzqxFm0Y+iEbVxHnWF28VF634nll8xamdGIjrBCDqmCJkY5NlzBoqPOqmOX4XMbHwCyQvXNx3aLSp7hY5oYGXKu/LfdUqbvcCgpJYR2oaOpkjh1w4eUmu7puYUMZxtPIe66baF1bBP9KGzquA7PPWOPaFEaR9b9SzovpqYR7jCp85r8X7HH1bLJ3bnA214tzDbC0cg1orRXRjjh76ogW6X5xrmM+03emBbOUZ7MawVgXfcngWy0nVR3b+FohlDqfC654uI81SEuhnzVTxnL0cx2Tup63WL3G1tC+OxjsUGGxJSCYw3ZWff0etWyCWEw22WSTTTbZZJNNNllmUwT5HttBfH2RotHCikZaRGUSKyD6jCK/reKcY1Wjw7FajFeC8nVHrpLTGi1RCIYSrZsNKbmVRlw06sx1sUPnOOGqrBgzGgWH3kj5m40ypaZp8CaYX7gthwijf69V4jZSjKfPmQg/xSme9tXqZy1umZ06nU51+Ur6fS/RPbMhmhk8pw3ZU0x5fuNZCMn9/7+9bw+2u6ruX99z7r0h7wDJRMojOBBJQwwqviIoClK1UB6/FkfxAUyJVdspqC2o4FCpCggqFgUpOFgebQcZmSqPIi+ZUouOOERg0KAVeQkTLCSBJDf3nLN/f5zvWt+9P2uv7/fcm5tLHuszw5B7zvfs797fvb/7sdZnfRZScZguEAerYeCXJAopKRQ98G+h4D4niJg5Jylb3Krg2mbtUiJt+WXVDZWmGIOX2C1apjcmoAtgZLZYZmMrD+qA4m+YIsHPh58de37Y8soBYezWZ8oBJ8UQ9YPo/YYUyQWne34ptUZi0h25fijvcmVPhKQWZypNLsIeU4UzVQQSgRRA41DBa0z/YdoS0ggiq30BdAZlbS+hEr7wmMRgS1TYEMpN2e5YD5j/XyZlYb1mtJArqyWsA0jnkefFz4n7O47uH0lTTEtgH5fN/cVzBwY44zyGlBvxqKUJgYiicSoKR0DDk7kmpRwVQJmwEghJXTCglqpENVIH8S6C0ouRSrqaB9hKWQa7cR0wsVQu6ZRUBigTRhpsCfDmcng9n7ZLch1apmN6h0rKAe8MKp3YClhGcH0PPCxxEC4mjYH8C0jvwPZEjUjv0QHaUgHXE8n6LXsInFP5MuwLUyyh3d9XGMsgwi3IDofD4XA4HA5HBM+kNwmIU00PEZ/IDH3C/of9a/B0Z6Retqy+Sg+YUZNqWp2wLeI8yp5ZqaStLH9R+t8AAS5KIg7ah+22pHuwvSiFQ5SRtTEk88yy+WMjGFFdlwtObJCrUyk8jZTTLciU2Jh5j0jxwqwgFhXMaFjvpa7IP4wy8qmU0VZGKRlDoO8NGsbCJwWrpQTUlBrPMVBzubKUgOYq9je/i4ZEl1jkOqnVjIhUOl/OzlZpLZfXYvAeWwEhXbSUi32SSc0t/Qoc42zwaHSd0tjG4ERIQS4849i6hd4kDr7kFNog+yRSciKtB2mflZZtWrdY01osp/gOSDAucKsxRTq3E4O6GOhZiS3IILUmn4MVDi2p6n3G7H0QEMljuD1vnlwjYx69L9YYgUBPc26CdzGghnHcPlxLRK87n+lTPGA8J6tg1AHmR7Dsq9iZhgypal0zgk+V/F3UvoA8bm4fjjGRGEzrnMvuFrc3J63XxCk29w6KewzPy9A2zuVvwGtMSb2mPmgIsIvFCpqy91kpta06hl4YV6ppp1hMJkKPiiFO/QkBdBQPTiNwAHWQ+XeddGLJvbzxvVCrOFe2UCoa3Cbye0hKotQvIhdG//po8RbifJG9B74gbY6Kh42S1kFO3WK5BByiDAFamypQSm2+ymhvdlU2HQhgI04UbxxY1J91TkfSewNtAQ8hssEsN2u4sFb6qTnlkG5SF5UoACkE6KKCqPHKNZ9XO4k/Q6oBqx3I+OVodXaTsytZjf98eli1saTM5nxG3jUnG2AIIMSIdB4HkniF+5vrHFOKMBEEqFbIIdPYMAuVAuvMm5vSrc6bI76OqNrA9l7oqxPwwl904fA1Ddz7Q2lfVe8cR/nzpoUXnkzAEW+qUM8a3dygAy6bLwigRJqEbGJQcYWiTSqXwXUI5eGSNzOQzpdd9KJnLYF0ELxcavWKaz8OGIP6KBUCruemdBMqGq18cOCD1LqU/oGaxfJ+UOYwham2IcW8tMegCaiNFGyMk/UA9L4J51IMyuP01Ww0kbTm4FLne3Gdy/ammzWkGZZjD95bywAk7zNfBwGRan6MKRawAcb01ThHVoGA6ebcXIvAcBAfvKw1UGkp8z2gndUB31hzRElLq1hoLeW8MYUhabuncX/368aqXHjAMg8KcdlF+o6hMkouyUj5AXze7fdHXg9BwSkWDofD4XA4HA5HBKdYTAKYYvF2OpaGh8vTb03GlkEyyPQ/tvJipTDdJjm6gEGxGOAm/euR7mEFDzRQEZL6orXaCJBD3WDrNJ11TVkuGLgnBllWrvl6SoqUE7siJWtfR31XB8ttZPWzpa+d1AvaJ8DfNLjFrCxQSZCPkY1LgM8MpZnq6ElxnZXcUGpdjOutJNOMlNLoHlbts9JAU2S9Nt5ry4qPOrBStuiuplndVHmU6XvI4qf6T+qceqPQTa7eRXSn112LaZnFcggSbFZq+VxmTIDqR3wOSAFCjWpG01jNpJi25MksmStlMS2h9L/Rypt7D3AMZYKEiUgFcVlzhJrPasq15nqTzoB/W++BgURqTQWdGfMz0PdU4BhIjzGsPADxPevql9TB2gOgXKdRx0EkYjGoHjPoWdkprbqocsle45r639rXMFQm4KZ5PweLOgrjI6ZqdMIY3d39nlMsphpFu61d9bHbGzddndTFINGuxiC2BrtSrbA4QlDXBMYkLq4X5A3DS1C5ZjK8McwLD5Oa0tos8i+KpRusNtBRu5ULSVyO6WZGROnZbQji/8gLtvjRyXOFjTFy2LBsSQRTKimgvqbF7WphEgwitegg91hcb+BKrOqaV7XATV0R2HUX0zsMnUngc6pNJ38v7QalDO4THkcZzt+fC88AAGZFSURBVK4SjGeqREnvUBsh7j+Vgjt1d0q/Ti/78KVMNLVsJuDjXVKKgVogh8t28CsjKhelcsD6sr+ZkjKS0j76RXFZaapsRR0BOg4n80C3uCxaTFFiKgL3QWxXgc2jUGBESxcUNPg6LmM60CQMDq/iz+buCfrOKgEIls33ZAoGcLLlQDCsD1ZI26jqwgdjji0BpQGc18DNL/QdpAUNR4cxS1scN7Zg/1KxF0YyD3GjZ+IaFOfcSoyBBxxWjgCNcnH7I3UQ+NREREUHnp3afBmKCoaKj9A+LM56UnRKT8A4DZXQqmHzLtdh+uuOPswo4wi8Y+1SyQcTXFnGODR8aKUsnXQKDxNYl8I4IIpRBiiEFnKUOcvAow/+aR1yB6Ai9Jxi4XA4HA6Hw+FwTARuQZ5EhF6gYgiCHTJZvnp4KoeAPnS54OlJRcGyJQ70CnPutCa3vCL784kNAwAhEpm1aCUwKRecyCdLowxT75nr0INAKUlhbNNG1GmcA6HAssSn2lAGQOnMe4arCi2RsfUa+yWTCYuosjxIymgMBuEyQbWCyxXLc8ZbwWCrtAqEQwpFaUGR4ER2ObJFisdPaWka2m3X/vUvvKDajUGpMva4vmg5ZisOaCxzUJoKYsHgGKIqOx/XZSi1CElgFKct5ueBwUqQcleC8cByl9VBBmukWMbErR/S69Dqw+OfNXv5XcUAo8g60oKxo7R1ZdyG5HP5/Zz0/WXLaQvLYUt0bHGGFMniycAgUw5OZI8AW3t5PJRt4DTIymPC94ve72Ia6HAr+k75/g+nbmu5ShQW0iC2Nqe5hvGRlM31hiA70ZIeSdPQy3zNHiLJOJgqcPRQw5jTKUcBocpyjPreTKnA+ZvHDNJCAni5ICtrrEUtesVKbz8NaOTnIXVAj494a/IB370yQLKIxhpf20V1GVkjUv13tS6h5RSek/LaZQK+q3U3TUttWmUhRTUG0Vs0p6QukiEyTeNcWf7B22AoQ7WmpXuLipZISd3jtQT3K1JvVuXg9wBTcYvnmLJ1VlrsbGGGuSm+p9o7Ed8K1nUZ1+l80BvrUC8MKIJM5BzkyYDIvLX/Hw21eBLQlAXl/jU2XRaPxuSkTkTujf80FDTMjbSxGa3jXZnuLkvNQkWe5uuOz6/atFSTRQs2K5KTHV01OJkZHFWRKoLNinJtEqlI4YF5gjDZm1JTyOmMJ1SDe8guZ0zoIu3mTQvIv6l00aheEm8guH1AnVHjHVPvokwUloOydpgumTLPXBqY57Up+TfkKgtlCMaLJGiIDiXoIsaNP7gaZWPMG0k+EGCSEpQRQw4vEaE8l6gaQLuEiiEKI5vSugEFR5LYoEpCJsLepHlwv/LYUYcYoCDw5/yOAS0kRPQnTHCBKeNVu0D2TLnW8RBbF2GP1BJ49qgUYvHBlWselWVEgSDatLCijaLvlPUt64CbN0k+Apt4fLbqIFRD35J1htuJKhYgRaek1QxViFzMhsw3xr2ULCUqBhkKULg24aav/2GpTgO0Q5zHpC44V1oUCzCI4edEUf8ircNStOIyjHU8l0wsLj/+XCU/s/YITQlygKqBBj+sc7Y9hmxdU1xXvB50whjd3blhIA6yUywcDofD4XA4HI4ITrGYRIReICrgBNPJu9XN32eAJ6zK/ZFXvciJgosFoUn5QKJ7DUsaaHnKzwwhc6hg/1rDTaIjTvOptZUlvgx2RHoIUXSql2DCtEylzgHpsOVkDsECWkC/rFMn1ocFi/9Y2r9yUu7m21V9z43JRxpnn6cRtCOWY6TzoKalFYFsRaZnoh5UWmrDkt6opJJTECAiFUBI2vqOWqTVhUx3SpMVYIIRKQdcr2IFiS03im7D1nUILlOp5suxB651TFIizc5Y9SqLUhoIZiVIwZlGu3lHst8LnSXjelb6rTzm2CoJqXTF5czPFj0O4p0py824XqUO0F/4zM13i99NdK3DOFDl9z9Nv2uDpwCD0cSqz7/LK3BggiB+t1Tq8ty1EpQM1LJWakGX95fbjclpwJKeaBGDO76yzkL6YqSz8LOW5CwwPzKlAj2ncT14nbECvjFInGkAKlgrrZMAKAbZgFCheMEzhrlTJdXiIHzDAo9tydEJCrRWNyTtsJQhlMpFjdW2B2tDMZQGwJll99LvTWUkS2Qg+q6H4xz2M9W+htf1/FhsDQ/ptaAGvkGeRBStQkd8xpxUUD6w6AmKa4xuEaBD4CYt91JYFAiL9oA8I7me64hcnyJ1EyUT6pAR1WrIIamIalDQkHJBHD63ebdcU1VEdf4gw+5uTBSiZNIgi1+yWVVqBYaSxEg6DtAV15oOSS1kPLA7rNz8l1xIooj/h7QOHHsY1Y7cRKaTYlY43uyM8KEnen7WM8GsXyWQSqBckrjYszt8LWT3i+rN705bFAGASoCHUS6b64hufVisJHFErGYhGTEhixnnXoGEEq1W/hCiosIHYMHJBljqkHKkpb8zWfj6DYJ+50MJPy/eaOak2WThBPd9+VtM6CP3wk05Ui14HptZuuRzyiFcz/L/rVkpb11leeOxJ5kDOaMelM3lcjsxCxhFizO+Q5BIQzIKoixc+d4y5aBbvls83+E8GG8YWzNTGoZ1yJSMgRB7wO2WPoDngZzdeNMidDRuH290IJufgGMFQI1GKW9IpfNUOiLS8TkYzwJUMHnGrTRZi6k4IfeCeI/Mb5RaAz87pmeAMQYPWxZnN0cxVNQYPKQoudX892qvges8qDoRZfYhFs0BNsqqT1rpuLAk6pLDTDDk/JBjXaQHRDGaZdoZQjrf1sEpFg6Hw+FwOBwORwQP0psESJDe0F/QEKREzLkucuLVOZhRsBmdxLIg/mH6N+kTprqXZd2Fe5li4MZ1SX24LkZZ1t9NbcBAsVwAEVpfVd0aknJgHyjrDorfR2Xa6TEp+a1YTlGk3tDbVGm/Yysnn/bZkrghddc3PkNoJ6Z1zuqEElcXAidwfPO7AdYqM0BSglTBTYxWwf7Ny+/gmUBQD2ryKtoCBhZhn7C2bzyejKkUNYXRk8BQKhD8e0ypnbkP1gtRWVbS9itqgRUwCprEcXAUWgYLSCVd6TrD5xBQpgJEeTxgSuc4MAvLBv1yKxEOp+Zmy6r8jWmyMUApfm8giYhSRMD+xqBqy5qJXiqwYiftQAsgft4QOFaneJQgnsPRE4TJVCDITllKjcQ4KtgNPFFEpIPSDHUlRT3JJP4gyrSbqTmKQqeVFBqTriC1DPIBoGqTUqeKaUzYT0YSIrRem2NswOQfuXtlg//j9hhWaUyAgnRPq27Jd1BGk9c9t/fohDG6a/N3PVHIVCN0u0Tseq5RdUDZK3OzUsIS/9a/g4EbDQ6RzEE3icELEuk5KSqd3CsvRTd7XcpZA4qIom00tQteGOR68UuR2fwLdzKTRGSge/LkAAsKSjfl89KnLkRL9Fy57rAdyN0GF6TiTUdlyCINrnXlJuNJCyOUsZ2ZhSP+PoGl2sH99uKLaftw0QYeoXI98gKbbAoN7qlaAFJVB7WZgeh4PGAJDSCm6uLGldsxDehI8uyAL8uuZ6XAkB8/STY7SAyhshMiz92KXjfc3qi4kXyH3GBUMSjRA+lA9l8qeg/XGVQcsok2+LsGRQSpKz/bzamLHuUBJRZjY0rjSea1kM4R8lM0fBiuaHUdw3Jd9zTNISDPlY0v+DnMIWZmUKReyXjRB69qU07ZsuQ9537k9xd/b6gwoXEjuRbmVukvVO0Aw4WV5W2Qg4JlmNJJLHBDDHWH5FrKUJZJcoEbQJXxFbi4eGDC+RrXXGxLvJYIlxg257rfynspCTnmxaeGD7Xu5/ZK2E+4nmO9LUTPdDwyb06xcDgcDofD4XA4IrgFeRJRtAqTLlD+QeWX6e+MU7xSqUBieok2C/HDST1rxbU0Fw2LMouhi+XBOHmqtkWRolaUKrqFrPyPnAxArJmQDru6p3bJYRIStGZj0g05/aO2MKRkFUsdajlHlhYMUuD+wIQgSksYx4Gc1NNEGSpob4D03mzxbHIHY7vQIidBmvyc4oQZLYjKtrRZkTIgySnyQV0SQIrBMJFWqUpv3ErVGKqU2albHBPHsL2FA6jE4sh1KPsway1liwkrhiCtgZ/hrvP61z3/Qv861hw2qBqY9CGhOUBAJCd2wOAzocwApUQlLTG8NpjkIqnPUJ4aIOnbIYmJKMNwG9AdjIkkuG6x25uDMDmZDNAw5J0rE9pw8Cq6phlV+vNeWmd89kRan5ifNT4HLpupI2XgHMl8BnNN+XeLnwfXIR6jSHXhscPX9DIBjUTVPDYr1SIWPWTQcCZ8/+N7cpGSWrsc15icAyyP+CxxfmcougAR0VBKDarWlrJdQLEQipn8nV//2nNm9z+Xtajs2+gaFchWtjOghRyCp1XCGJnW87QGeZ4ZcSK0ECv6Clrh5fl0stdbNIc4UQjxs4IA78orTWnZYOW1qCOKgpGjRfCzxoA/WW+BzoOeDy4msrQXoRg41bRvkCcTRUub+uPoX4OXrCJRMaq9YUDJoKmRpmEgf0pTK1rJ/6286crVA26VXLurBqVu8Dq+EFHFn62Qd8nI5BdzkHkTJnJGfI+ybGMDTeCCbU2H7EbQTkULiOqBCwhPlNYkZ44DUIyo45kpuTOLMwx1UO7QEXaT9ussqhDAaY45vUgFEGUJlNbDDTNSTkCRQdyFyLtjqgYRoTwZ8ly7G/vXtnji5cPlS7BR4GeKmfasBBsUHyLzUe1SF160X1ibtAs30LgI9ICLSzkuLm+2kJYFySfkXlx3/hyVBvj33O5cZjk+FKJUGPdXuXmtNhQs85U+D6FQyGbc4KhH74WMQ1RMgWfK2fnkebTA9W6olcj73cscAkQRI+UU4+FZEsBw+ziDHmRjlLmH5wlUb4nBYwQzPcKGGfnA1TuTqvNUUpP5eIfQ0XEdBdPwQJ0jfh/7n0PyDaYU8XyA7YQ5OllL+FqDQ48UkgASg6ZhCA43ap5PftRKf2PQWlB6URnCjBgSfA+IYvkyQ5ZUqpankChaDygloZJEVp4WY2qmlTE1vM7BGiiUFKSMWvJwiqoSbdxh32Lxlps4yOOFUywcDofD4XA4HI4IbkGeRIRutwoskJNM/rr+l5C8AtzhEhAG1lptJctbe2M3iWjqGtqMeIrFoD4rwEAFe+Q0mEuaRpctQfBbhFJrAAsKpvpk2kdWWB1oHZa2qNKNxGcMlhXU280pMCBVwLIsmumRWexc0qemutCCHJ3HstorLek8fQUToogLEnVXi9TCHNdD3PGltYrd4WKdbIjyL9qQ/EI0XFMXPcWKFBJZX/4E9b1Lq4dYq8F63ZpduoeZ9oABWJAwI1FUKJ9JCzVL+XmwlZ41qkF7WagXbHFEeoQRoU8UW2HZNc7ehnIclC55ZWnl32MaZ0gxjXSWeK6RZ8fa4ayVDfOVsqiW9+L/a2pN6pJHz0LSbu5HQwkFPQWm+gUGMRfgaSjbVj6c/v8xPflY2o+KSoVucngvpHgIMIu9AqZqB9eJLczi8diYtlvR+sqfj+Q9ZbmU6spD0k1pDELzKq9nKqAVnIieIbFQx7kEIOEJo3pnQCEIxh7WTe7N7xJo6ufqVxWeWnG5fbzOFXC9olJAkqaKzqbVmNT6AtQDlegH9ICjhvbrvBm8l4YQQP8noFc8PV3P1TxWo3DUr6IhTpAJ1rMC9Ae1EDdRL5rgFmSHw+FwOBwOhyOC6yBPAmId5HYPTnDxiaUmU05yrUG0Vxgw6C/7U+MaS77Lut7iBOWuadRPxFOele4Y6mbeL704XxaeSEs0peK25OFy9bA8A6Y2tZE2VAWAol5q1DY89SvLgiF7pCwrTWMy97smfVcsE9NbI//Nan8my5cpLQdlMer0yokiC5TUOdV6jcsTSyfo+aK+q+IeQtkqHXCG317eqPo3j1NDa1fqbQUA4vuN5Vj3IVLBtmiFtKx2KmZC5MxS3V+0zCa8b5x3oAyUxMNnq56PpXstlsuMl4qtq1CGcDAzEnFJHYzUw3VziwWlPW68Bzg/KA42rlER99p8hlbGOH4+A7bLnCeiMswcAmaQmnHPhvkx7jP0vqp5C+U7LclEY86xNI7je5leV5VJL+/5Nee7uuyF1rWGPJ8p2wfzWVMehOw1hhzfeHIodMIY/Sjc6DrIU43Q7ZqpHIl0gJwWFC/LsTYA1ka4A0F7QMkgosr9gQFUarOe1klRRdTLW0/FiMsWBQwg8YsKx6Z8YAS+DGYijcymtQqEgeAzcKXK9aV7vErziyLn5YX8e9Q6zkxqqMFsbnTlt00KIal2b06xQAVyYcQ9qBWogM/yc3RdigoCjyNIVR63Q41fQ8XESuFqLfbigoV0yv32aiUToqhf+P+iGAL3hE2u0reGMcbBm0Skk25MS4PKTM1R2RBS2j6mkrBiBG4YM5s13PDwuEf6gk58wpVmGkD5Nw9vI/V8XM8C2ymKEOU4R3oHB+nB5lWeV8i/J8l4ESWEDOWFoncDg5NRrYXr1gH1B9zExIcUUUpJA/mq5Cowj8Emx0zWwmMX019HqMZfPvmQ9DMm0+ExJPSFdEwR/p/HZqyYgtQP4yCsKCVjkMyD3zFMSsNjLKcGUn6FCa1wA9lojDCSL1VzDdwnupes07DuKk3lhkMH10VRMyCAvg9+Qa31Gb4HdQ/LIIIaxUrLOYahFoUJzKz9CgcaqkQouK+J37EOzAk54xfpZ1qXCKUIPaIBpZCdYuFwOBwOh8PhcERwC/JkA7UQI3cxpqpUcjZcBJ6sjIACCZZAmbBcgAG4O/n0W0nHgTwMpo205HFYZ3RmKafEp+Akqx9YziAjUfUbON2OpC5lsZKgzB2fTMVDVZ0eTa1gsCBIHdA1g5I1aL0Dq0ISUFIGJ6KUXAuoESrwy3KxG7JASm80KoPRmjaUXCt1ZLm7zaWlEYNdQKJIAs/KvmkNZ4K+oP+kPSA1plzyUGfTwsxtLMe0aFNTFfBl0ovQOs393QYPgLJi5b0aaLGMf4NWPa5ntwxalKClHtM1wJWJ2qTcNyy1lqsPtwesb0oaDyWpeOxhAKX0TTlGM3WQMQUUEaU1jFQjIzNgYVj3cpKT7V3n9r/jwEceM6UljSXHULMWU5CrwEew7udc0xwAWQUGluPXsHKpIF0I4lQ66DAfxEHIspaIjnEpvabWDqADsEeAg/zKOqhn2zWoFlH91FrHVjoMDCyBXir5HL1dNVJrEiz5Ige6ll/I+5xaM835m7uXg08ha1/V3mhONb2KeWoFls11wLXVCsaNPzez94Fnp+oDHktGMC7o/qNMWiK1BgGOuG5jvdGzZQXjmfrI0V5D2oMyfTn5vagsk1ISemo/VQffIE8iinZbuXoSgJIEDpCQSecp5WauV6l4+focD8dSMUAXIqa7HE2VEywt5trNucE5QvdQNamVzwHS4yItQuksZlzPlt6z5abGTZmeWOvd5bFrv1LtYEoAbMIU/y+fvAOhBPQz0cN4EFBKAbABwI2xuTmHVMw9WMzj7zA1sERKcyIEdk2jEghviJgewJsbSBQhtI6IV4u6zAF1cssy5BkaiTNkAsYNMG88QWmDKHqmrEYBZVeHyRnp9TIOyut5Yw2bHdEDzy3eorkNOs1MGYJnjRsp1LWW58AKDfz8+LpoAZV78viTtLepOgkfwtTGAmg7avFr59V+iDIbY4PmgYkvcHygeoW0DXXeo2eOusxIjWH1FqFMlN2K6atlwZbDGl+XKu3wuCEipX0vdAeut0HfqLSKUx1ktblpp4eTHG1NUSt447Rufb9M2LQHVrlA9zfPe4aCRpzEp9IrB3UKrgOWAZtZFQ9gUSKB6xx/p4xL3A44TLWAUiR1AO1hhqyLqBRE9tpvUSOwfUIL4c8hnqFO7UFx6A0lCVyXcH23kpIoJPTM1Eio3hmD/1xtiHPc7MGJE9ssxaLT6dBll11GhxxyCO2+++40a9YsWrp0KX3mM5+hZ555Zqvdt9fr0YoVK6goCiqKgn70ox9ttXs5HA6Hw+FwOLY9bJMW5Oeee46OPvpo+slPfkJLliyhM888k2bNmkU333wznX/++fTtb3+bbrjhBnrb29426fe+5JJL6L777pvQb0O3q9xridvbCGyzTlTm92gNBndCSA+2Zn3i32iSO2TsadCurFNmkFOvpcZhuKysqG/UdpR7ZazY/J15auWAAwjakXtiAEYvpXPUKW5gVLJJmYF7KloIPFN1Qq+LCgeLoErVye3aaIwDtJxjjs6MpRXHkGRa4/5ni2qRfm5ZpNjqi9bBnMtdrFugDys0ABxraGHDaG4M+uiChyiuM/6W24meIrye2zmatpO6Kd0ppwuL91bWJ7Z2GXVE6IyaZZ2BJsSu7H494Tc4RxjzlMoYieMAI/AhJXn2N2CFswKjKmstUG2gTSoIKnp++C4JTae0zoq7uoDxi9Y/VHlACl5pBctmNUUqEI/P0fw7g5rpMragWFPNIvrOsjpalkVTXSmkdVZW8dgjCColao00LMNUcDvzngK1jmUCyCxvYlS59Ht4hui9NZWSoE7JLaBeljJEVUa26PwcYpST0iXj74z1GS3rQOPEsYfl1alYqPoalAumrWV1lLdnikWn06Hjjz+efvKTn9Bb3vIWuuOOO2h66ar4+Mc/Tp/97GfpvPPOo2OPPZZ++tOf0uLFiyft3o8//jidffbZE/590SqihZf5srpjzQEBk5FyUaD7HzezSJeIxd2NNMaK14ouNUtyDPlyXGeIFo9/Y8q1oZuLI7OZFgDJV1SiDHRZFZH7KAANw9ggND1rcfcNYxRwWUANzQGfdcVBNFytBSzWwK8TdzBK+uQijw21Ekkcg5xjUOdQbnBDBD7ngpXvpN92ScqsNqupO1ipeyCHDRbkmIOskoowv1HoHqkCBqpxtGYADxwXL+5DbAtRlEym3AABrUXGiKJKwC04nTe4wVF5IX7mrTnlPV4EebcSFac4TW5BQOtCuot8Xv4/2ychbTfSVVTSHQQrLKDqAz833qzi+0JElXwdbz6npfVTMl6U3EtxyVlZo52Om2Jm6S6PuNdCqcBDZNneFhpLYC2IKRNEmU3pSDrHJmUBb1cpQZT9yuO5omvw71OeMCaCQf57cu+yjNb0sgxW7+jCRgqpccMpPUnAfQZ9ULtuhPQ9b3OyFUOlqVKhydMSVVyIqIRUlDl87xTNw1Jj4WduKODg9Ug1I4pifJh7DXxged+NZDwCeB7qOlzn4vZyOyCOwSwbaDv6IABrDKSuToqGg5DQXYxDGm6+4035eJSNtzmKxRVXXEH33nsvFUVBV1xxhWyOGZ///Odp//33pxdeeIE++clPTuq9P/rRj9LGjRvpqKOOmtRyHQ6Hw+FwOBzbD7YpC3IIgc477zwiIjrkkENo6dKl6prh4WE6+eST6eyzz6abbrqJVq1aRQcddNAW3/u6666jW2+9lT75yU/S7Nmz6eabbx53GUW73RhlSRS5yCGS1KJIWC5lsayOQppgjpaNrlcKGlAXpakqLtbyRDnCagebk7qiux/rnNzTSK2NwJTKyprNLjk4LbZUQI224qqIY07sAm4kFeUPbj/U9pQUpZm0x5UlARQzDP1MdRpGl/Mg7kC0oMgDSS1pKpLeElgH96eO9q6AQSliUcXUyxjcxRZWTBcLOtLKZRtZtbUGKXgXWBeU26MCqFK9Z7a0cp9JgB0ocxARdTf2g5NED5hTTsuzSgPp5HO0XonlObXaV5rFaeANUfWuSzAdUyLArY96uKiko3SuQWFCLJaxxwADoyzrNernoqegk1qvRQWBgzoxWDO6JwalVVa+cgxykKLMc+z2TuctaQMHmPH8xsGAsbKO0G2gjCJ9T61AIqWDLZSb1MqPmsdEWk2m4HYYqiyKGofBWpgIpcZ6K3MCBjLDHIkWQ1m/MDgN1hocY/EzrwL6QOEEg5At1zsq5aBHVbS7tXIKzrMq0A/SVPN8jwGe8kxH0yDtqo7agoo5AjRlKH1mXVC6sWgcysLMn8fBiYY6h6UtreoslQANahwfvG5kKBbomcZrA7xDqKwSW5KLUCA7xMQ2tUG+77776IknniAione+853mdUceeaRQIb773e9u8Qb5D3/4A33iE5+gRYsW0bnnnksXXnjhhMrpjXWoXb4UuHklIuk8i9cmVAnYOClZOC4HXRdGVqDkWoNDbL14FscYy8V7Jhtm3BjDYMY6sHtHycMAH7oqHjZp0aRoccvMDaQBNWkZ7uNkAjZ4YrjhU8/ecg8y8Hl2NB0A3XkmtUZx2Op5cex6VbyyyO1d4E9BxUGoIEBfQdk27aqEgnOKMQ1ZnZDeEV7KLxC8wIgCibEpoI1V34ibFmTM1MKK760k0ijbzVJrPJaG0g1krJxRNbMsG/jaOFcIPQnk4GRjCO+9ADctcV/gd+A6RQkyFQ9g8fiFxsWSmTpxhhyAgWLAfG2UXpOxAkoJsqlB/isoVChVk6QyvAkHWhcknxAYvFGZzXDDEW9m4F7yMXcLvHNI41LzwmaMsQCua06dCDehajOSN2SoRBhW5jV4j5L24DsFm7fqB1A2zgfI2cXkU/HagvOwKF0AH9pYEwflaAsya5O1PltzI7bbklxTh7YIWdpkpiz83NxryM3zm9q43VWsT8M9DWNb7rpQF6QF2KY2yHfddZf8+zWveY153UEHHUStVot6vV7ym4ni9NNPpzVr1tAtt9xCM2fO3OLyHA6Hw+FwOBzbL7apDfJDDz0k/957773N66ZNm0YLFiygZ599lh5++OEtuudtt91G1157LZ144on0nve8Z4vKIopOdplTl+VSVxa3odQVWQlp5ykHGPQVVaa6t0EVwBMZqlUo/WOASkGdsWaiZUi+44QKosHKdQBLA1rIIamJctnVRcGinmLbssRo2gIRUWv27P7HYHHDAKr42t769UkdlN41KisYovZSNyN9ds5yblqC0KIgwS71wXgy5jDV6wBozymfHY5TCZhKA+SsNLpoUc0G6UnZ5TPEpBulux7VLThoRayAbNUt+1A9x3ici7UOxoIEBqY0gNactA5Ks5lpEqNjSZ0D9jtRlayiW5Y9d07/b3G1cmRVXoNWngcHAaGluURrJtAfIoiVlYOsROQ/tVIjpUS0uPl5rF2n2pf9m6J2M22J78XWdvZwwHXye0zFzH3Ic6okpAALNEVzKqS5Fv1naJ9Yyjjgr0whrlQCIFiLhNYW1RufNVJn2Chv6WCPgLWb6VBAteJ7cmIRIoo0tsH7wOO8laftKbUOCbLFFOSGhzQuQx5E6U2bliqDqL4B+oNaF9roOUjLj+sttxbvBbj7wcOHad/l99wW9O5CXWLgWtCGVOrSX4a1VyUtAVpfNXDitYSSz9AzIH0CqkO4PqsU01I+0OIyqeQleQrSO5T3OZ9jotqDEBG1iPKGaIVtaoP82GOPyb8XLlxYe+3ChQvp2WefpXXr1tHzzz9Pu+6667jv99JLL9FHP/pR2m233ejiiy8e9+8RRbtNJF4CrZpgycIoDq0hPWVJranIVphwpW6kJy3l/jEoFNbGyqR3RFxctcFh14oxaclloLjQlN0vlygEn7HUF7i1iqsGfSV1ZPc3HFKUK5OIuuVCr+XeQGkBM+hJZH2e29fUh/2i02fH4Mhz5ANKRkFWTsDIc+A2KhduzgULY4oTCFRi97BII/e6k9I9pLyQbjgSDrIsfKkKiep3VkRQWQ1TznIPngceBOMFW6gDmLWS+wukxWQjyODNHSaB4MWPF1hQkIl/g1JjjBYspCj3RbBZUdnOUEEjujdGwhe4EWJaQqbe8fWSnQ+4uJgFNOHaQz/iXGNl8WM1A6X+wK5cLreOV8vKPTAnyKYF6Eii9FPymVGtQGV/Q6WFeJMqqiz8AUgqokoLPw+R/4O4But5dNL3IG4Hf1e9G6mMo6IY8DtjJO1R815GHjRrgCG9WZM5BNYYlZwKOLzV57zWRkYmVHpqTPxVHjJAfSWhXcb35P7O0PdUTEz5G4xnUYpQcMjSiUWA/oIZ6+L2NVBHLO65JU+KlMuQoZpIvZAiiUYk4Cpb8UvbNQd5PVtpiGiXXXapuZISdYv169dPaIN81lln0WOPPUbf+c53aMGCBeP+PaITxiiEcvCEglrUotY4LGwOh8PhcDgcjpcf29QGeWPkghhp0M6Mv99gRGLW4ac//SldcskldMQRR9BJJ5007t/n8F/d/6j+6BK9kpbSfmGZfGSJfDOaknFYuc7NYK5MGcpSagXMYZ3hXq1dUi3E6royWCKy5Fh0BV12auVVOppcjHF6RBddWm2mmKQR95b1Gt2BDGXlxnSqMcUCXcmYnlsswqmV17Req+AlQ82CtOVYrBeYQAG0PE1KjVBU8vqSubHH41VSbhtlo5Uag9fwubEbXSlwECm1BdYUtlLuYlAOunvF8irW23L8Ty/pItHcYwbKQN0CWNjE6gHazVbq5Sx9C5VhwIKoLDDiSoXf4VzTY+pB3r1MRErhRKe5La13kDqc6QvBUkTp5PskeR6gvqDoZpIoCBWASm/bLmUfYB3gHcu5yavxmGrromqHUttBfVhu34uG4grPb9FYM7XUS1TUmXT8K48KBDPKeB8D6kWkJCGKEUxH4rIxUJKtk+AJU2sG0tiw3AGCcHEek/mtKa05Uu74NuhBi8vma1ilppyHmELG41oF1YPaFFpDMVg79uKwV6IHQbiWIpRYa1XSKVRWSi3r2bUE12HUf8Z1GL1roP9t0VwwgU78naJS4FoCawQGAjcpZ1mY0Aa50+nQ8PBw84UNuOqqq+jkk0+Wv2Or8OaM1EmM+PsZketpEIyNjdGpp55K06ZNo8svv3xcv63DofSnNFRU1IIWteDlN5QBEEbGKeX2bFKkyA5yuNYoS6keGJH4qvxMNh1xd8PYtNQaJGIVlBKQLhG6RranzGYNJcWqgwFQJYwofivRiLjbajbn1cUNBwS5LC1DRWaX7UZqRlJnIzGI+k1DNieCSS+rYmDAyqCF0f3WgonjAClIWWpJN12UZFNhbIiryRplwMrLkO8Lmcpqed9cJyNrnySUMNQKrHiBLJ3FcNOjqL/exKfvoLwX/BysKPeY/4w0BmNekmcN2f6qgx8YRXhzi5vX+Hn10oOeXItJeuCwKocrUCmRdoEiQ473XT0LlKFMN+1KKQYWb3keTEsT1Q6gXEQZRJHPar2fPaDaVD9IJTOr6/Oca860Gdczu4GN24cbROjH3mZcW9JNa04+TPUrGiYMqpz0lVzGfZJeV6fmgJB5iNvD/HZjE8+JMFCdyjJCxe+RenbyjPPJhlT9LeOMsb4nNCZUjsDxq+hLeTpLD+dePNQBtSa+t5L6HIPNtWFUy2XSHU+ikG3Kgjy7DGoiItq0aVPNlam1Of7dILjgggvowQcfpPPPP5/222+/8VWyBkM0TEMFHBzGkdbQ4XA4HA6Hw/HyY0Ib5KGhIXrkkUe2+OZ77LFH8ve+++5L9913HxERPfvss7Tnnnuav3322WeJiGjOnDnj4h+vXr2avvCFL9CrXvUqOumkk+i5555T18SUjbVr1ybXzJ8/3y68aGUsjdHp0DrFWQFvXCzQF6xgtmIIUjXGJ2+D3tEUpKevwyYbOrOxpQVPoJY2Jd6zBS5KPB1aEbtxAJHheuPEJ1VdSosbBt3hqRhSsqI1KDn9NtBVMFECJthQ2tWgViFqCKUHJRaHVy45CXbIazPLODUOdFynFlBUcum/VSBNAw/fHGOYshSfNadDjSxrlsSlSvcqzWY6B7gYkS4gKcbT4M44GLXAZ4dUEfhcUaWQSoKuyGGwFsXjCyPEJalM+TW7ztkbAWoHlqVVWa8xYU5S/TyFAIMTlRucnyFQT5R+cIYGJtrxkGIaaWnK1YzqFUNpu4VyIOogOkBWjRFMugFpu/HZi6oJWxQhQRL2ZZz22PTO8DjnOQVpe+hJwbaglzLjpUG6jVIzEAuwEcyFuv8yZ+bpbsm8aWjLK48ZjgOgVqiUxWitz3gS1bg2ghCx3uIRxLUFtejBW5fMm+BVs7T/zXXcsOpae40kjf1I2j69DvMzQg92WkX1rFHVCegyRFR5sqCduBdSdEa5PH22Rbvdn6dr5MxjTNiCvGTJkon+1MSyZRVf94knnqDXve512etGR0dpzZo1RER04IEHjuseP/7xj2l0dJRWr16tNug5HHfcccnf4zHPOxwOh8PhcDi2P2xTFIvDDz9c/v3AAw/Qsccem71u1apV1CuDR+LfDIJ3vetddPvtt9dec/XVV9M111xDREQXXXTRwJn6ilYRnbz0Sa7pJK3I8PC5KofJ8MxtQtmzCEicF04OB2kYp/aKL2akqAYrbpa7ZVklDau0kmbBIBiLFw0WLCLKBjTFZYiFCYPXUO4GJeYwGxhI8SXXghUuamhaFmpJW1Z+4CRy0Fd8ilZpySFtMVo/uN5tCErje1RBSin1KadtrCzHYjFLOcQB9K7RU9AUUCMWuigGQQXuYUAjWu0NviQGq/VA9quypOb47hBkJ1JaqfUOdZ5Ru1Uyp4nXA66Px3SRWkpYU5jl3phbKgFvGMQCFmYrcCgbBMOcePTWIHr5/uZnqH7PcwsEXibpnjloFNJct4ZTr4OyqELVMPudpbua/qYMDAR96t6m1Dqp9OmLVB5OuOhgBSsMObRce8TKXOpfd59fm9Sh8iiU47oM3mOOcg940NXYTaXZkmv5XQD+bvXOsbQYWExl/YL3AjxomKI5vqfSFM7EvsTtx3dGyYVBwJ3K+krVs+Z7tGfPSH4j18k4p+y9okon5TXKmGZgehvlFunfaj7DdzGkcxBRNF9bfGW+l8EDRvEBjBdQc280f6B3QlnA4TqU0sN9zHadSe/Nb34z7bXXXvTkk0/SnXfeSeecc072ujvuuEP+fcIJJ4zrHnvssUej5fjee++Vfx988MH09re/feDytesniv5FtxZy8xvoDhgUYkfBQpBDdK0VGGANepUWVtUlfclzE4t6AbAM+LtaKBpcV/CcWkBVSMo2Nt1qowt1qVw4ELTYEF0b1xspNDoqOK+sgXXJ6cASkQooisuQg80oHDbQDQzJR1Rq2rF0cyKuSkwsQZR1v8ftq9z1aVm4KdEatelCnNO+VXQUUP6QFMTcbqaiQMIQfm9lg4TpkoFqQxSNGUlvzK7DNPmC2kBXlU/agxsva3wkRXDZINbP+tcBgu/4kEJjrKubLmJ4eFPJaaJ/K0oBUr1k45T+joH3qhQqQCc7CnaUYETcTI7Bs7JS8yKdi+uAEfq5AExJ95y63PmQKeotmFSHDwRwYFKqRqhxmzkY4LsRIEW6ZVzB4L0q2I0VJ1IKSqLOw88a5zFDz130zrkuRkCkogECvS2pB4wdizqg6Aw4lxSg/1xj6JHv+F3YsAF+k14ndUOFIHwvYN3OrdGqHbAxthSu1AYaNpyqndC2uB4WZc4K/Fe60BCk2mggi+sPB8EAGtzqeRjGqfHqIG9TIr1FUdBnP/tZIupvUn/5y1+qazqdDn3nO98hIqKjjjoqa9198cUX6Z3vfCfNmzePvv71r2/VOjscDofD4XA4dixsUxZkIqKVK1fSv/7rv9K9995LK1eupB/+8IeJ/Ns//MM/0KOPPkrz5s2jr33ta9kyrrvuOrrzzjuJiOjv/u7v6NRTT6WZM2du9bqHXiAa4kAqTfLX7gy09IJFFWVujECECvaxyNJBRmskuoe0HBZI+igrsFkFO6BPvs9bZREqSAAstbky8RlmAyEy11nP2gpUSNov6S8hUMBI9yt1w3ZgnaWqZXk5aR421qBFX2T64BkX9rjN1RWt/Yn7V9oHlm+wlAg9gaV70O0nWa4M3j9KOBERex3QO4PuUXkuRlBSZb3MP4ec9KIaK1awYje1FFnWPrEc9/LWwiTNNQa44XsNGfCUpQ0l6ECCST7PpKDGAD9LUk4FNxnvZuW1gH7PydzxtRgAF2AuKYFatYqWhQFmEEiWppqGenI7kEog731+/lPeGhg3aBVLfmt4myzKnKUhX7UptdpjuUSRVQ3mzq5hlRb5Ni5LSYTm21TVJXK54xyakTSNy5JgbKZpwPNhqVBVXiajHN4bpUKxn1GKTHkfYa01g9lz98RAN57fcJ0yqBfKM4xBgLH1Wnlf6z3BQvdBOqfxnqu2ZdYxDORUc4Xhjc712XYr80bUV8i48cYb6eijj6Z7772XDj74YDrllFNo5syZdMstt9DNN99M8+fPpxtuuIEWL16cLYP5yYxBHsjtt98uyhi/+MUvks+ffPJJIiJavnw5LV++3CyjaLejST/DWUPqBGygrFSVVQrplA+sFl7k4mYmVLVRbOA9o6sCXTyhYZFPrkUXeRPH1qBxqBSkuBDVuaZgEa82r9ZLCxtlq06Z9LCWlnQxAul8Gw4hSoEAJirpqwwXF9N64kbY4uLJ5rXN7U/d6NJGph7kDifAHcXNuEqlXRfFTdG4Bp50QnNAwXvWuS3yC6uVulY458CDRv5wiOgdck/QieX3tb1bX21H3OCGOge2z+RLx5HmyDFnVYYuvM9A20C9ZNmM8PsC6iaivICJV6J244FGNvZq48iHNV7s8y7nAt3BoBNOVPWjtE8OLsCHZNoCq7IYCjJVwVCH6ECkqFMcE8BlYWpiY6MsKbVRF5jni8yciv2t5hjexIgSCJeRp+fgHML64bj2EEXxCnzYQCoJUkdgnVKUQOBeC+2JE27E3zVQR9TBwVJ3MJJ1MdTcRBQdyMu6wLhE7rDFJUblBXNtjX6HSlZYlqUYgemho8Zk61DdsKWuxcMI8nwrpM9eraVGfJOkrN+oJX6baInW4QOxXaeaZsyfP5/uvfdeuuKKK+iaa66h8847j0ZHR2mfffahM844g04//fRaHvEHP/hBuv766+nnP/85nXvuuTSrnDTr8MUvfpHuuece9fmXvvQl+fc555xTu0F2OBwOh8PhcGz/KILrlm0x1q1bR3PnzqW3F8dXiUIygWlWIFx1QYNVq4GaoCyQsYsGI0ehTuoUawUrGJQElTYyqrtK+winW3HTN0SoqgA7wyJfB1vDkZK6WBb2qqDUMpfTY7SoIti/lju7KThRPh9Am9ZEU1YjfNZ4cs8oh5iZ34xsbNh/OC5M/dxMUKaVbU7RExiYkhkpFjh2a9QNLB1g042N/QiWZ9QHrhu7GHwpdbKydYGVD9uH1mrlqoxd7kYqaBy/fF3XCj4zMsiZ82XUDuzXJm158/3G9sLn8VxmBUviM1Lprw39XMvqmQ1ybpgLUcdXnjV4I1RgtBU4mMsYaXjIlEvemLfUnAn3NufeCE16wPIx0n8Ma23dfInrlgSHgw69Rf+wqJVIg6sNEDTmAMtymtMBztUBrx8EVkZFU+XC8CRbtBmizFwAn0vZhhc593w6YYx+FG6ktWvX0pw5c2rbuE1akLdXFK2CqJeZzBiNk3T5sTEhWBtjhlLJiBdvg75hbYQ0r6pIr8eXHqOKY0H9hg2vKX+GHL2GZBa1CynUpclFR0W+3dUPgPtWXp8soMZkY0U5m5NZCbPO6HqP62e5nCxONpYNE4ySS2o1P3PrIGNxLBVvupt3EyrVA6reITUx4oIPknNVoSn32OTRgtpFeZN+ezA1OG5wUEgfFQTgb2ujkdQNN/QNmxPh88KGCXngqg3C8dY0JpNCwJtLpjWV9ABM2y0HPYtHneHwo+oKuqItqSzFUUe3vxHfkKPzWFAqFbjhx1TMSIeSgmoO/mZyGsPYYKwRFd8f0gjLZlc/R4m3aDBMIHUQx39FnTGURtIKQb1wjs1v1hXdwzqs23txRW3k9uDGWHGRN9ev29bGOLnOSJCiDAHGu2cpYuG6X3dAUGMF4xZqFECISCdSgt9h3XL1s9AYGxUf2saR3XibUrFwOBwOh8PhcDhebrgFeRIResEMtCIiJYRvuUuQON+UxMMST88ClQQwCAdO2Dq6F6w7Emho0yTEUigWkrLerE4iFuWUnlG5YPvtU65ZxUCx3YHK3YNkf4jaNq254O5H1Y7Y+oPi89XpX27S/80u8BqilqX0SfrcROWAx00NzcFOuZuOHRUgwv3O1l0CsAU1VjWwXGZi5UzrIPVGugsGngGkbWyRpMqaI/3AwWoQKMhBhz0MaIWgJpW0g5udo7XIswJda8MKgvOBcoODlrG4NMu65BRyqsBVSINsuamN8YF9xvYnpY8c1x8pInzPoTTwU549XCfzhFjg0+dRcGRN1Jb23LlJHQi9FVwG9KMKtsVgJw5ODRD0lqhYFNl2y3OxFIGMRDAqqYORSCZuVzXXwVqS8yrFUN4MgwaRmVsUbQe18LneG3C+zlMN8F0q2hDcFs3nSNNR7YF6K5rSgJQz5SHMXUPpOyftAKpRa3o+cRCumYxscB96VWR9NoIWca3hz6EPlHePr4uCE3FOwNTTylsprxZ4q2EtrSzr+TrE95BkaLBXUDA8onF/FqG3fQfpba8o2u1aTo+VOaaRP2Zyd8rfY1YhEM3ul513VzKsDW5Vt/zvrZc8hvWduFzFtQquJn4+4LI25XJ4sshE/8pEgdw95NJasmj8rDEBQZ0CxehotgyTKmAkVFHi57gxzvFrhZtZZrMyJNT42VpcPN68Y/asivfbTT4nIpHYkvZxvTr5xdqK+kcXHpYnE20U9az6b5Td+ilPFhOkSNkw/jGiGhPMJFSDTko/Ee4pJz7BemM8wEgr+VzTH8ryc5vzbtoP2YQeMYB7LeMYxxIsJLkkPJWiDSih8KGEFVHkfYXDOBoI8LDC73cujgLarebO4bSduViBfl3STYmVpCaReYPDtZ6vwRDC7Wk4ODGCNX+QflaKzgH8fEtiEjd7ylBCsOEmzalWGeMaXO9K3QY35TUqF5J8BQ/PUG+WWCNMxmPJeFob6swmtdrwwVyB2Utl7iwT/wiHuZv8vioe6Hw11BU0OpncYuRkI0VS5nu4V5wYBgx2XH/1OcgyqrgkQ4XLjAOKyrASnFmxEWZ8wDg3yE6xcDgcDofD4XA4IrgFeRIRul0ljp2lWoC1ziKpN1EvzCA3dktkFBVU4BukgS3wOiOgYOATLGn3rXa1pFYpvB5TTyvXHFq1chQLgBLf7+StQHxaFk1WPJkCBSG15qcuSAwQU24/w6phalGDNTjnBsV64rOv0jVDsFNDYJVpBY8gVh7UVMUgTLQ4olWL78F1x+trIP3YoCHN3gt0a1uqDkqbmCo3YPUOoN53OdbYfc/tYotRyKtgoN53zpqJKbOVlRnoH+j+Rt3kyiILWsWWGkhUtjVGBKDNjDQPtqxhenMV/EjRM+BnxbQtfg/5e1YcAMUEKspni1rdDP59+XyKeMx1uH75tL3yPhYc+AmWQXa1w5gzdYTjsmfO7v8GUqRrukIaRKyTXIAXE+kiGSsupl9vUhCxFHDwWaMqBI/RJBkPBrDi59a6ZamVAN1N1S2nHGKs14oaiQlRcF1uosPEKlRgGVeUCKQ3oEIKPg+gLmCgeOIZg7HClnErOYmifgpFoz6QDvcUZeH972C/guNaBTEaNL/Q7VKoy2YG8A3yJMPKUJN+ZkipWW6f3MCpAWb4ST9LJ2dcYJDTZkXDqokIOb4ZBY2oMtl6V5NfXtVBUStwAspl4jFE2eV7g6uEm3asOy4CihNHpKO0mXpgTNYWf10Jzcv5yK5DnTRSfM8eZGtDF5z0I2S9q+qS4T9zf2E2LnQdhl72OuUWRP4dHCxy3DVx56GYvSWlyJ9DXXKbMiKqEo/UPGdzU9lJN5Ay+YPrVh18DZcskd4oSR1AISfARlCeofyg7JMGDmtOrYX5utEXUKZ+P+PfKxk0fs/rsvyhegfQj4T/ixshQ+0D6yTjBNsW3QMT+IgSyhiMEdyU8fVMuVBJPWzIQQg2RtacqOY/QylENv0Zmp6UiUYUaR9IpeE6h1KK3BZRuUgpCdU4iOZzg16nONjIc4Y+MDnLsJ4l60WmPkkZ+L6iMgauHZTWUR3OQqbdRvtUkrEmiVBY5zRfWMsZWvx0CyipZ3OW0/GUjEljv2I9U4RS1hknnGLhcDgcDofD4XBEcAvyJKJoFUQh+jcR5VJ7yul8FE/KeeWEXD7x+HtlBchYB6xrLdqGsgxbFgfjJJ5Lc43i7GaikIbEH/h7FQQQBQuY4u7oFlXtzmv2opusLkGKOhFDEpnK9Zi6ouTZhfSErZ4Dutli5RAjPXFOhQB/m6ubuJpRZzXT7t4Y0hnQGpVGu4t1Gu8NShuqLRmNZ3Hz89/YDrFW8AV5i7KpboK0p8hyroLu2HJsWJbMd6kNyjCY3CATrJZY8Ml+hpV7HAOl6gOHZazlrPb4G0u1AwO/+HuuI2pTt2HsQduISFJh47MuRvJ0FKFKZZLMxO2qFBmmJ3/H16v5GZ61eOUMC6FQhThXFzwPCQhuAS2ESCl6FOY8DNQD9FIZSXfk+fH9ov4uhiGluND08ioOA3slDSugPCciSe2Oz1j6gKlT4G1h5aSKopBfB9VYjh6DZYXFZ2ytGcra3UrvqaykNUk7VJpqw8usFaSGknZpDXN77VXvhrVuM1DtA5PaYPIP9nZMq1SJZI8E+utWzgdrryTXuYrFy4e+zFu6YUiUJHCj0ECpsKSI0FXXLvmH4mIPOgoWBcQtFwwOdosvrSJwoc61iUJ4k4kyRsoVmb6IsrBavKqM7Jdy31cXJ2WIi7KBs4zPupqo9O+RS8dQ4uzlM+eykfZgun9xcx8dSnDxapXp1tk1q3hzeCjrpK52JR8FbYklBi2OeVOCCJVBq5VuEOWesPmP+ZFqQ2tJqSGPGaXUWP0C+fOYWCdHNbAyTEG9lbQayB0p3vT0fh+iag1RNBZwk8XjAPmskJ2vNaNJqiw9OORoTOowVUItnCIdl25iox/0yzUOzMncxQfZXnq4wDmFOdpCh2iIduf3BeXjstdyP3K/8G+QM47GA+gDaRKPDzzE59zemBGPVS0w2Qi/zz2WHkul2Ag2LQGMF8LtJqLeiy8mdcB6q3UOD+ewqZV5AWMygFJFlIkJgOeB98S4AMVVRiUVRTWsoGJlpoGhxljnkC9rUVREHYIlzbJqTOkB36I/mFTIBgphRcmJ6FvGZlTtFfDAiJKwuObiHgRULuIyrXlc7RWAU43tCr0O9cJgVFUip1g4HA6Hw+FwOBwJ3II8iSjabX2SAzcCX0ekT31IB5DrlaU0dcFqa2bG2oFuXcMlh3QApcGL1luwZte5aJT7Q6X5heAd63RsWbvBOhaXqcvKR15j0grlTgJVBxTxj/sbg01UkA63B5UkLCu9EYGO6ZTjMsRigFYfk76RurIERsR9XokF3fOg2oHWG6QDwL1RixnVDer6W+nk8m/5N3JdqRcNyRtIWYcMWlPULqXfDIFvpgVcghvLe0rkdtlXPD7Ymhdb1lEr2EgZjdQQtqiiTrAaa9Y7G10rVlZWfOBnxH+3OBAytSBiOUoNg8vJ0HmqhrFXovROgSUVg9ow+VBFa+ql19ekfRaN1pfQQwQWcLZio1vcmCurFMVAIYvmFnnvYq9RDoalvAfKMlIuur/hecT1tVzrlfJPSWdTuskQOWlY0pXnlCiincCz4/kJ+rEpkKwqF1RMMu83WnbRam/1l0UFRFjrXfwZvp86PTnsKVBZw6AImkpZmXpZgZ+NgXIGPU3pR8f0TNElty37cdlW0GG8LhShcB1kh8PhcDgcDodjInAL8iQidLtieU0+kz/yAW+SpQ0shniC1sFondq/0xPdgEcmK7ufRebnpikLdBQox6dbQ97OJNijpQXupaRpDC5Y3W/UdczpA8uoerajaUCdnHRRNq7/o3xdkPcG34s1m9uXK5uq8ZPwQoVziNmN8rrVeG8MGBGLI2auQj3tTPtUUI5h1QwQ+KcC6NDalbNm4tji3xjjmcAaL+UYY061LXPvqJDy/2BBgcyByBdX1m600IE1tP9THYxCRIoHKxZB0L1GqHEDPMSchanyKqEue5kJUMmCQVwEv/9g3Rd5uG6GNwleFJUqHcc3twst6WihEglCI+07kdKAV54BQwIT6y4xI9gmlLLKWUPxswZJPR1rkM/aZnFa4zJ0O/JBd7nsi7l7qXfXCKTM/tZYM6xcA9bv5fNM/Ac+KyVPBr+15EoVUB84M9+NV+YNf6fqZngnc1KyEthqyK5WsVIN4gEAFVvCa60E5kXtVQGOhmABYZ3SQNHQdR3klw1Fq6DWMFARElUD43dW4ICKsE+TkGgXXd69kvuNWlAhOMOOSE3rrF9M2BTF7RB913yARaH2F/UKGpjKN+eiUkFG4qZNv68W1NItCMEdGIEtfQUbxSSwwlCMsAJN1OKcCUKL71W5k0r3YhkUSERRelPbbZfU25hIqzTgRkR1ZhKUhCCYltrQ+eTrWHGichuW90Q1gzIQi9grmllIZJPBSSaslNGo1oAUBVG/gCC/zFiTesOhSe45AqL8Gd3uuJ3qHQQFkRgq9a4RVGmmvx6BgwQqcKgkBno8KKUM3ITJhel8Jc+U3wtI8lGb7hkXYx4bXTjwWOmNmf7BYwjoItKnuJGmzGZEpYw3xhhu3pTCCm6G+AZVH0gQoUGlkbm0naqx8DtlbdZUwGEuYUbZb+1ZM8tr03dL6gDPB8ee2pRDIqBcgDWmCJdNGRxOcmpKyT3NMcl/ZuY1Y52uOzSngPUZKAbqkBcHfFtzitpA5uuqDl18HaqXZOgfuIYK5Y3rjYdsntc5EBrT2Vt7EP48k+hLj++UhqjUp1A9TNZtIqIWkXFWQTjFwuFwOBwOh8PhiOAW5ElEMTSkrSU5C5ucoFJrpEmcb5AusQLOctlwUHIFrRxYhtLaNSTprOC/uN6N1zYE6WFwgLJyZMrBQIKekd3KttrnLYaK1pI7yaNGJ/8GM4YZdZF+hAASDJSspNYi1xQGOsHnYXPeBY2nfPkesr9VYwtcWRGUGz8TTNgvwpA95GcJVoKw2XaRqXfJCpjrpM9a+hGpGQxLLza6Dp+ZGlNIy8EgXbDeKfoKtw1TExNV+rDyjOCZQrpmZSmUtMmG/jNa6KJxzl4KrLeyXmFGQR4zXGdMRd9K6QLV76t5EIODrVTBksUNPAWK3rQ57f+c5Zih3nnDm2QGa4FUIAYbo7s78QhCEKFpheTgS/EMMG3LcLGD54Tb3YveOakfylfWBJklZTdYYmVcI40rA03tS+chnJ9zEqjZumQysGEGU3T3N3pZYZ5H3fs6GldMOyDSz6TSeU69tLWB+1EdsM61QXoWXQ0CJXHsIdTzyFAkcY+kPH/GHkF7ryqPQisEonrWj8A3yJOI3uYxag/tknxWF5GqXmbUas3oAsafNwqKZ1wV8pXhYlZ1bdI0VeLm9kZZ3auBm4cTS5N7UAuyp4eE3L2tqG2Gmtywqri5zTxH0/1puBiRkybfo6vWmLiIqJoAjFSyVfvzdWFoCg2M5wz9xeKS4yYbF7Xq0JEX888l3SEiyuqFGpsW1NLGiVbVGSmeyMWt0SqtkD9Mqv7DzZrBn8xxr+U70SCFTWonrTfSIHATrw5psOFOXN0Gj10ddCzOplIl4WeaPi9UhYjLQl1YdZhEChQeXg1KCR7GckoS1ZfpYs7AhEhI6zLd4TWKQPhMkHqgNi14OEH+N9wbn3Xsmrc2PBY3WZVtJH7RCir2GtKoEd9LKQVaCUkqnS0/RwOw1770nUADV1NMjalaFSf6wvUJ1l1RH8KyrSQeVtrs3DpmUSOgjCqWKm2/Od/hUpIxMlnGRIszXj2f/H6mN+Y6yA6Hw+FwOBwOx4ThFuTJRHwazekoom6gcuvoiMv4e6tstI5Y1It+0Yb1FgNnDCulRWew3Ma5MpRGr2FhwTqrUyJXAcptjWgLk+n+tCJu4XRcWXMwe5JqblWEEaSn+pf1Qg13GGoXW4F1sRUJT/nyuVG2cmEZNI7q92lwV0LvQP1TSW+cd2sjpB0QaGZZmOL00uhit4KvMLNgVPmkfVbQklKJiMq2gow05aCsEyuO8NegboGBdIpGkNyExzFYX3tpvZVrfji1VmqXJiW/S7LlGa5wDEITWgo+H/79cEoLGsSiyhkAZfyh/jXXqQzeKwIGEXeT6wX8nCD9d9ynWLbUW1n+81QayXyKKieWFyCGRRHggFfJ2ka116Hyj6kkFGvTGlZrFdCIGdiQnsTPmOeJUqtdNTW+D9cPPYBmUFqeGofAOmc9Zmh1NeiJFtVCPIOGmo98XjdPwvupPQf6J/2iIegaKZaWN4P0M7YUUDBQWFl/oQ7oDYgqG7W3pDoBhQTrxjAD96NxPR4dZN8gTyJaIyNEPZDHiiYWTIOJLid7I5zfYIprw5D/ykakNm2QmmRi8PfsFh9NU7smCTOstJaGlJpKLY33hGh5+RwW/aR9/BKaUml58XNpg5WUpAbIC0RqgTXhqEmKr8M6Kz50xAuFtM64URqUYmIeKCRNcHpAIqr6G9uvJnzc4HG72f1tpRrG1M3xRhQ4tzJZw+ZNEqdg2m/LLQobYqlbRIeRa+UDoB9JFDikr8ZNiaTmLhOCiGoHUxF0Smdzo8CPBZUg8NAGdRTOKS7+GcnB6jeQnpg/B94zHhy4ncFIsR6AcpEs3hu7+fbJ8yivG4XFfBeDmwnybgXwKXP0DqQt5BRtiKI5pEEqU80HmY2yxZkl7FeRAUvnN+xXbXwAWk8m/a8VG6KUJCCVtOJk99KkJSoZVWacKxiSiipxhMx36QEaKURZaoJ6nyltt5XACWk7lgGLv0f6E+n5V6laNCTQsGRItbSspvdZ9A5Fw6qhfsXX4zpfqVtpo47UG6hdFhXGSkU9UTjFwuFwOBwOh8PhiOAW5ElEb6xDQ9P62pChtKj2sifv8gOgJ1j6xlZwW1OQXuwWw4jZHpzy8ZSoPpc2YFvAUpMRhzeDyYzkDLn0kPHvpC1sMbYsjnGZEMRjCqvzMzVckHiKttpIlKGdWO3ZnD8NI9D6gZaL9sxp6tpG1+LcOf06rF1XNgSoCdw+tIqp9NlRu9mCiJZ+y7LCdVaBYMZ4ABd97IIV6xUrRrB1kssG17mZSECeQ/qMmWrRZh3a2CqOQUjgklXqE4arVWkaIzJWNCv1eWXpB/qHUbakokX9WFQgyaRcVtYdsJhbiXwk3XN5ndADuC7ch2Id1e1H+gbSU3AcWCnjGVJHbksuaQVa7UCVQ0fcU/b6ysqXp3nlrKYWJcD0fFhqMwWsIW2Y93LufqTUQMCroiGx5Zjd35j2W1l3wauT8fpV83gaACpVBAqCjNEZ6fi31GzwPkn7ABZthef1ah1If6dSLRu0EKJIyWo0rzltef5M763lMVVWbiIrOYfcy9p/GBQja53PqXWpAGUY1yhsoBRwMpSh8SQKKULAtEeO8WLdunU0d+5centxPA2XKhY44Iho8A2hsRmxIlFNt1MOhhwO1kU2nw2b9kHQmEkIrquqWl8Xq7xkg2y4A63vzcnacGWZCiKDwEiAoj43eN+DTFRqgrEOH02bcmuiqov2Nrj0avFqoAdEBUPlbMUUe6OQ1h/Ltn5ncvCz1RxQZYYBmzGLzlNXXlOMgDXWLDqA+XlmI4H9XW22ynZZLmZrHBt9lYtRMPn68L2lUjLomMu5bJuMC3Kd9Z42jCWlqFIzzs2NnXEIs8a/PGvkqsa/reOMRt9b77fcy8hMJ0achliF/k+NTRv2Nyor4O+N55Ers2kNZdRttpN7GnNxUp5lkKjZVNfV1RwXmXurz7AuKjYk//ege4+6+XLQumR+2L+83aZOGKO7u9+jtWvX0pw5c8x7ETnFwuFwOBwOh8PhSOAUi0lE0W7XWjSUSxmD80qVAmU5hpMrBgngvXLW68rKAac14zemax5Pnqb6Q3QCxUhTtAgbKhdNuseNJ1YiFYSAloVBg++U3qYRaZxEe1tBaWjFQzoHRnuje1dFUzefc1VghDKY5K1VygoEliVJKx0XZkWYYxCioZtKRWrtYVekphagIkFUf7ReWpQKsF5Z1i5815R+LpEZtZ+jRMRlcNIGoRjgs7aCVFlZI6knWIRKFzK6c1WaW/5dSSkR3WRM8sG3i+qk6sm0FAyQlGBTftb9jy0NX6FFyJgsR9lmHSBo01KM9xkpRJySHdNFS6X0u8ZUJ8uqZ41fS40H62ZZO3NA67qi80kzjHm/4R7xdWgxx+RL/K7oYKzU/Y1Q8wRQVZLv4P1U+s4G1HxmUMly1mv9rMDjC5SQOmWn/u9TZST5PDNkcT028xiA/m9OS7r8Qfl9Ogfj2hy3YxDlprguONaKVkqJRLon1q0sJFtW9UwNizmUNUhQfQ6+QZ5EhG7XdmlTfvCVFyV/NkXWD+omTOqiXCrGhAIvjkm1MJI8WK6s+Bq9WctPILiBNrlO8HmScaohqtt64SxudcvgJgufONq0II/Tck0qtQfMnAcyZ63pqbSateD061XWhTcQnN1INo4GvQcXc1yIAAlvDCZxmRBnzOiXyZsYU0AeXOqwadGZyjIbZEtKiYGKGZZbmDdOrOqALs14fPE70QaZNqW6kefNCZ8UMqwxLM5iv56g2sFc3LIIHGPJ5pqIimkzys9TfjQDYxiS54qUApTa43oz9xQ2UlrFJ32X1OE0plDxmOKsbkgBA+ksbkd7Zvm7UnWI1Vhk7I5MT+pQJdSJqESgbELwfks94V1CzrEa/8C97spzq8q23NYyh4DEnvXeRgXm64KbfCJ98AflC9ysWQcHPHyhAYARzy3cb12QZ8Q1QNNYoA5sODESydTSYBqokLiGIu9fzTVWYpGMYQgPGY10FBgfSmoW7pFLjIVKILou9TFT1dpaHmaBa6zKjWldg1Lf+PImOlrRovEQJ5xi4XA4HA6Hw+FwRHAL8iSiNTxEpAyy1QnGCjLTJ8X6qE9MLCEnsRph+epe+aA7JWbfRIMASoJE1+ZcGniKHYEIVMsybgRQWHXLXW9RQZTbyKJYgIvd0m7OugPxdCsWh7xWNlovVKptQ5O1LlCuUhWBYCvwBFg0CGmLRYeosdQq918nT3cxrQBGsJPoBIM6QvzbAqzPiiJhpXeFclAfWFlJknFeJGWrZ2h8roDpXlmb1bCoElFlARVlAbAEQX8pVYfSAltZnqGvhgxFHdJjQ3lVWHMaxpi8W5zopQvWUKSoZCy1YWM672CyJPTioAfIcrXLs7Zc2dFnMnViogfw/EjZlgeB6wyJRLKeM8vjg4oK6H0xqGGozVuNMe0p4THSA6t95Q6HICz0ALC3ovw9prVWNK9YjansF0tLXHsl0zkEFYMUvc0ITu1fm3ppUKdaWUTZQwjKMta6hmtQzmOAz0bpPCurLtJhcM3MB7cla2gDzdJar6rreV2D/YoVWDgAZdCqW2OgX+ipvUAd3ILsmDB6oUu/HltFvXHIpji2X/RCl37d+YX3904C7++dC73Qpd90H/L+3kng/d0MtyBPInpjHWrBiS2Ble3GOu1YcjjAH22UKiJtda1OovkAOEsnOLmGevS/3QdpES2moaHS8pSROlKnPBVQYXMMc583cZxy99IWVbAgGhZh7Efr2ct1NadTLc2Tfo5W/uim/bqB9UNx+iIIx9qQw1EAT0KON9gNY/S/4SFaVCyJJg499lQgSUePiX4d68eYtmIDdz1jkVX9W2fxzXyuPAKctrybXp+VcQRY8lwWF13p4JYQ7fFayUGoj5JSSvuAs3Xh9cJhbrfL9/shWkSvolarDMbMcTMDZucy2mvMNeIRsQLE2CpE6XtCRDplNnvXIECqwOBki/doBEbn5NRM+ckGeTIzjgPk/qIfJHVPPgOLucDg86pAwagtvRDofzc/TPu2l2qJsthyvjnP25V05hA8jPNbgX/L2EzbJvfLWHNR/9mUcTP0ceV9R24+ZIRNyhs1pMQa+N1mQLtcgPN4vo9iNPGV0SOQ+31/Pn+Y9um9qprPM3sUU9ZP9Mrz/a28zODNwNwE2LbctdaaVz1jHItaam48Osi+QZ5EFK2CWkNGIN4AyIlalx8QUU1QG6gaqMAq0m4NdL1YdTDdHUh2NyK543s2bYisSFVrEpAUpkbQVx95eoZF9rdc9Mrt3aABqeuh66fuycFd6A5jFyP0IT5PSU1MUSAX1ptgwcC6QECJTHLD06gVCqI0tksF1CX1KlMkF5R3W8pvGrQs0X0q1+c2XMamw9R9lcMIBCNZm3mmu5jKGlHZ3F7D9Z5NPhFdZ6VNVm0l0tQIcMFKAJUx9qRIbs7QUL/8zUTFyDCFDrwvmVTT5oYIg2yHINGL8X5jMg9uW+5AKGMDgierdpbBhXBQQGqFPFMI4uTnG8+GKpjUUBuxDuPWHKSDFsvfxfOmChJN6yKB0BxkCgc8FazVzSdQyAVI47NDWhauXxb9AZVHcBzlgris91mlXua6wsZZJdRpCABPghPhWeO7IHXAAEpjXjOD9jNo3ghDvY3gvXizXoSCqNv/rMB1IUOhyo2ZuEytb27pHRsHoAw9UzbR0H5snzUm1UZ5nMZyp1g4HA6Hw+FwOBwR3II8CeBkhGPdzTpgJZeRht19nMQQ5H5IDmLpCa3bTa0fpgRbK+NOF3e+Ia2Cll84ucnnXHRnjDqlO6MTxjIWycjCxJafAO0ndp3yheVzYNdNC06kIb1HZ8P6pI4564JyjaIhEVyvlfs+TZ+qXK5sxe2m5WaDE7EuaM1XgUVl0AcHN4yy/Bef4Nl9ytbhfjljL66Ve3EZgQOfjBTRRcGn/9IqsAFS7kqqYpL+7g71RD5Mrova2gtlfTdB8E1Ix5j8RroZ5I7Ess6WSbCGizW/eue4P+TdKF2m8jx4LOKz5sC/birJ1ttUmsxxbGZoAcqiQuD23di/R3smp04ug334eXFdNvaD2lq7QDYz/v9waWHbFAUnbiqtWLP6qe67615M68fBuWyGjt7juM5cdhjdUL3fnVGiVmmxyaS6bbVBli4zV8TtCZtgjJXBOwHaWQyV894oy5yVdSsy0nrs5sVxyWV0IAV3m59LqptcUTLayXW9cq6JIXOFkfE0bN6Y3pP4lmVd2Ho9Vp8xFWUxiYgC9gMryokHofzbyOYmFjZeS0ZGqBt6RN3+OjZUUmrUuCGSZxLKZxrYel3w53lLeAefxyagTiBtiR9DvKRKYBw/e5ZrM7yNvfIe5ZrYgX7kpbI3msoYipV0Y/WOSX8XaT2LkVZZ/bz8nekZ5nuy147bwu1tRfZLfCZWttXy767QHqAOveod7ZT91umNUghDSR3jZ87vEPeffC7rLewpxMkKz6kcU7wOWNfHa4lcG9JreVzLngDmOZl7uA7l//pUooJoLNp/1cBTTU8CnnzySdp7771f7mo4HA6Hw+FwOBrwxBNP0F577VV7jW+QJwG9Xo+efvppmj17NhVF0fwDh8PhcDgcDseUIoRA69evpz/6oz+iVqueZewbZIfD4XA4HA6HI4IH6TkcDofD4XA4HBF8g+xwOBwOh8PhcETwDbLD4XA4HA6HwxHBN8iOgdHpdOiyyy6jQw45hHbffXeaNWsWLV26lD7zmc/QM888s9Xu2+v1aMWKFVQUBRVFQT/60Y+22r0cFaaiv3/1q1/RueeeS0cccQQtXLiQRkZGaO7cubRs2TL62Mc+Rj//+c8n5T47K5577jn63Oc+R8uWLaNZs2bRbrvtRitWrKB/+qd/os0NGd/Gg1tuuYWOOeYY2nPPPWmXXXahV77ylXTKKad4/00xtmZ/hxDov/7rv+i0006jN7zhDbTrrrvS8PAw7b777rRixQo655xz6Omnn56kljgGwVS93zF+//vf07x582Q93qERHI4BsGbNmvCmN70pEFFYsmRJuOCCC8I3v/nN8Kd/+qeBiMKCBQvCPffcs1XuffHFFwfqKzMGIgp33333VrmPo8LW7u//+7//C0cddZT06atf/erw2c9+NlxxxRXhy1/+cnjzm98ciCgURRE+8YlPhF6vN4mt2znwk5/8JOyxxx6BiMKRRx4ZvvGNb4QLL7wwLFu2LBBReO1rXxueeuqpLbpHt9sNK1euDEQUdtttt/DpT386XH755WHlypVhZGQkDA0Nha9//euT1CJHHbZmf99///1h+fLl8r6++93vDv/4j/8YrrzyyvC5z30uLFq0KBBRmDVrVrj22msnuWWOHKbi/c7h+OOPT9bjHRk7dusck4KxsbFw6KGHBiIKb3nLW8KGDRuS7z/zmc8EIgrz5s0Lq1evntR7/+53vwuzZs3yDfIUYir6+5FHHpH+/OQnPxk6nY665swzz5RrPv3pT0/oPjsrfve734UFCxYEIgqnn3568t2mTZvCO97xjkBE4eCDDw6bNm2a8H24j+bPnx8effTR5Ltbb701tFqtUBRFuP766yd8D0cztnZ/X3bZZXJg/d73vqe+f+mll+QerVYr3HLLLRNui6MZU/V+I2644YZkLfYNsmOnx6WXXiqT48MPP6y+37x5c9h///0DEYWjjz56Uu/9nve8J7Tb7cTa6BvkrYup6G/eIP/xH/9xGBsby17T7XbD0qVLAxGFoaGh8Pjjj0/oXjsj3vve9wYiCvvss092gfz1r38d2u12IKJw0UUXTegeDz30UGi1WoGIwmWXXZa95qSTTgpEFBYuXBhefPHFCd3H0Yyt3d+8QV65cqV5zeOPPx6Gh4cDEYUDDjhg3PdwDI6peL8Rzz//fNhjjz3CXnvtFV73utftFBtk5yA7ahFCoPPOO4+IiA455BBaunSpumZ4eJhOPvlkIiK66aabaNWqVZNy7+uuu45uvfVWOu200+j1r3/9pJTpqMdU9/dRRx1FQ0P5jPetVouOO+44Iurzof/zP/9zwvfZmfDoo4/Sd7/7XSIi+vCHP0zTylS2Mfbbbz96xzveQUREF1xwAXU6HXVNE8477zzq9Xo0ffp0+sAHPpC9ZuXKlURE9Oyzz9KVV1457ns4mjFV/U1EdOyxx5rf7b333vSGN7yBiPqxBY8++uiE7uGox1T2d4y///u/p9///vf0zW9+k2bPnr3F5W0P8A2yoxb33XcfPfHEE0RE9M53vtO87sgjj5R/88u7JfjDH/5An/jEJ2jRokV07rnnbnF5jsEwVf299957y+GnDosWLZJ/P/744+O+z86IG264gUKZ/2mQPlyzZs24A19HR0fpBz/4ARERvelNbzIXzBUrVtCsWbOIaHLmBYfGVPT3UUcdRbfeeqtsuiz4+7r1MRX9jbjnnnvo29/+Nv3FX/wFHXPMMVtU1vYE3yA7anHXXXfJv1/zmteY1x100EGStjH+zURx+umn05o1a+iyyy6jmTNnbnF5jsEwVf09c+ZMeve730177bVX7XUvvPBC8htHMwbtw9e+9rXZ3wyCn/3sZ7Ru3brGe7RaLVq+fDkREf3P//wPbdy4cVz3cTRjKvp77733pne/+900Y8aM2uv8fd36mIr+jrFp0yZauXIlzZ07ly655JIJl7M9wjfIjlo89NBD8u+9997bvG7atGm0YMECIiJ6+OGHt+iet912G1177bV04okn0nve854tKssxPrwc/V2H3/72t/Lvt73tbVvtPjsSuA9nz55Nc+fONa+L+3e8fTjoOIm/7/V69Mtf/nJc93E0Yyr6e1Dw+zp79uzazZtj4pjq/v785z9Pjz76KH35y1+mV7ziFRMuZ3uEb5AdtXjsscfk3wsXLqy9lr9ft24dPf/88xO630svvUQf/ehHabfddqOLL754QmU4Jo6p7u869Ho9ceMvX76c3vKWt0z6PXY0jI6Oikb1oP1HlPb7IJjIOJnIfRz1mKr+HgS/+tWv5AB0yimn0C677DLp99jZMdX9vWrVKrrooovobW97G5166qkTKmN7hm+QHbVYv369/Ltpwps+fXr2d+PBWWedRY899hh99atfFQulY+ow1f1dh5tuuomeeuopIiL6yle+Munl74iYqv7blsbJzoxtqR8uv/xyIiLabbfd6Oyzz5708h1T29/dbpf+8i//ktrtNv3zP//zjp8UJAPfIDtqEXMGR0ZGaq+Nv9+wYcO47/XTn/6ULrnkEjriiCPopJNOGvfvHVuOqezvpnqcccYZRET013/917XBKI4KU9V/28o42dmxrfTDI488QpdeeikREX3rW99y48ZWwlT299e+9jW6//776eyzz6YDDjhg3L/fEeAb5B0EnU5HUj9uyX/f+c53knLjU2hT6sr4+6ZgDsTY2BideuqpNG3aNLFEOGxs7/3dhL/927+lX/3qV/TWt76VvvrVr05q2Tsypqr/tpVxsrNjW+iHDRs20Pvf/34aHR2lM844g0444YRJK9uRYqr6+7e//S2dc845dOCBB9KZZ545vkruQMgLkDocJWL5pk2bNtVeG59ux6uTeMEFF9CDDz5I559/Pu23337jq6Rj0jBV/V2HCy+8kK688kp69atfTf/xH//RaClxVJiq/tsWxonj5e+HTqdD73//+2nVqlX0oQ99iM4///xJKdeRx1T190c+8hHatGkTXXHFFTQ8PDy+Su5A8A3yDoKhoSF65JFHtricPfbYI/l73333pfvuu4+I+mL/e+65p/nbZ599loiI5syZQ7vuuuvA91y9ejV94QtfoFe96lV00kkn0XPPPaeuiV1Ea9euTa6ZP3/+wPfaUbA993cdvvWtb9EZZ5xBy5YtozvuuGPSyt1ZMG3aNHrFK15BzzzzjPSPhfj7fffdd1z3ia/fmvdx1GOq+juHXq9HJ598Mn3/+9+nE088ka666qqdkqc6lZiK/r766qvpjjvuoA996EO0ePHi7Ho8NjYm/46/Hx4erlXW2N7gG+QdCEuWLJn0MpctWyb/fuKJJ+h1r3td9rrR0VFas2YNEREdeOCB47rHj3/8YxodHaXVq1erDVsOnF2NwaLpOxu21/62cOWVV9LHP/5xOvDAA+muu+5yHuMEsWzZMnrmmWdo/fr1tHbtWnPBevLJJ+Xf4+1DHCd14Pu0Wq2tMmZ3dkxFfyN6vR6dcsopdN1119H73vc+uvrqq6ndbm9RmY7BsLX7mzWTr7nmGrrmmmsar4/n6cMOO2yLk5JsS/ANsqMWhx9+uPz7gQceMFONrlq1inq9nvrNIHjXu95Ft99+e+01V199tbysF110ER100EHjuodjMExFf+dw1VVX0Uc+8hFasmQJ3Xnnnb453gIcfvjhdMcddxBRvw8PO+yw7HU///nPk9+MB69//etp9uzZtH79enrggQfM63q9nqQiX7FiRcKhdEwOpqK/Y4QQaOXKlXT11VfTCSecQNdee61vjqcQW7u/zzjjDPrgBz9Ye82nPvUp+sUvfkFElKzdO5zHLzgcNej1emGvvfYKRBTe+ta3mtd98YtfDEQUiCg88MADk16Pc845R8q/++67J718Rx8vR39fffXVodVqhQMOOCD8/ve/z17zZ3/2Z+EjH/nIFt1nZ8Hq1atDURSBiMLnPvc587ojjzwyEFGYP39+GBsbG/d9PvCBDwQiCtOnTw/r16/PXvPf//3fMk4uvvjicd/D0Yyp6u8Q+vPDypUrAxGFP//zP8+W8/TTT4eDDz44XH755RO6h6MeU9nfFg477DB5r3dk7Nitc0wKLr300kBEoSiK8Mgjj6jvx8bGwuLFiwMRhaOOOipbxvr168MRRxwR5s6dO6GF0jfIU4ep7O/rrrsutFqtsHjx4vDUU0+Z1y1atCgcdthh427Lzor3vve9gYjCvvvuG0ZHR9X3v/nNb0K73Q5EFC688EL1/YMPPhgWL14c9txzz3DPPfdk7/Hggw+GVqsViMjcDJ1yyimBiMLChQvDiy++uGWNcpiYiv4OIYSPfexjgYjCcccdFzZv3py95re//W0gonDOOedMuD2OekxVf1vwDbLDUWJsbCwceuihgYjCoYceGjZs2JB8f9ZZZwUiCvPmzQurV6/OlvGtb31LXqihoaFxL5a+QZ46TFV///u//3tot9thxowZ4dprrw133323+d/ChQt9gzwO/O53vwsLFiwIRBQ+9alPJd9t2rQpHHHEEYGIwsEHHxw2btyofv++971P+m/FihXmfc4888xARGHBggXhN7/5TfLdbbfdJhvo66+/fnIa5shiKvr7b/7mbwIRhf333z/88Ic/NN/Vf/u3f/MN8lbGVL3fFnaWDbJzkB2NGBoaohtvvJGOPvpouvfee+nggw+mU045hWbOnEm33HIL3XzzzTR//ny64YYbaPHixdkymK/KCAME1t1+++0Sict8J/6cAxCWL19Oy5cvn2jTHBlMRX//7Gc/ow9+8IPU7XZpw4YNjZw3oq0TlLijYp999qEf/OAHdPzxx9NXvvIVeuihh+iYY46hjRs30r/8y7/Qgw8+SK95zWvo+9//fjYjV9x/de/ql770JfrDH/5AV155Jb3xjW+kv/qrv6J9992X7r//frrqqquo1WrRV7/6VdfG3crY2v198cUX0ze+8Q0iIvr1r39Nf/Inf7L1GuNoxFS93zGuvfZa+XeskBF/fuSRRzamwN6u8LJuzx3bFcbGxsKll14aVqxYEXbdddcwY8aMsGTJknDGGWeEp59+uva369atC29/+9vDnDlzBqZYxKdU6z+3Umw9bM3+vvHGGxv7Fv9zC/L4sWbNmnDWWWeFpUuXhpkzZ4Z58+aFN77xjeHiiy/OumYZq1atCvvvv//ALtibb745HH300eEVr3hFmDZtWli0aFH48Ic/HO6///7JbI6jAVurv0877bRxv68+N299TNX7HUIYqM93NO9uEcJOqpHlcDgcDofD4XBk4KmmHQ6Hw+FwOByOCL5BdjgcDofD4XA4IvgG2eFwOBwOh8PhiOAbZIfD4XA4HA6HI4JvkB0Oh8PhcDgcjgi+QXY4HA6Hw+FwOCL4BtnhcDgcDofD4YjgG2SHw+FwOBwOhyOCb5AdDofD4XA4HI4IvkF2OBwOh8PhcDgi+AbZ4XA4HA6Hw+GI4Btkh8PhcDgcDocjgm+QHQ6Hw+FwOByOCL5BdjgcDofD4XA4Ivx/vKHCz0Zb2aQAAAAASUVORK5CYII=", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist2d(\n", + " x=array_diff_slopes_xz[array_y_pid == False],\n", + " y=array_diff_slopes_yz[array_y_pid == False],\n", + " bins=300,\n", + " range=((-.5, .5), (-.5, .5))\n", + ");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist2d(\n", + " x=array_diff_slopes_xz[array_y_pid == True],\n", + " y=array_diff_slopes_yz[array_y_pid == True],\n", + " bins=300,\n", + " range=((-.5, .5), (-.5, .5))\n", + ");\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f0822003a00>" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_slopes_yz[array_y_pid == False],\n", + " label=\"Fake triplets\",\n", + " color=\"red\",\n", + " bins=500,\n", + " range=(-5, 5)\n", + ")\n", + "ax.hist(\n", + " array_diff_slopes_xz[array_y_pid == True],\n", + " label=\"Genuine triplets\",\n", + " color=\"green\",\n", + " bins=edges,\n", + ")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.011936023423773843" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_diff_slopes_xz[array_y_pid == True].std()" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f08224f1cc0>" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_slopes_yz[array_y == False],\n", + " label=\"False\",\n", + " color=\"red\",\n", + " bins=500,\n", + " range=(-5, 5)\n", + ")\n", + "ax.hist(\n", + " array_diff_slopes_xz[array_y == True],\n", + " label=\"True\",\n", + " color=\"green\",\n", + " bins=edges,\n", + ")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/slopes_after_gnn.ipynb b/LHCb_Pipeline/analyses/slopes_after_gnn.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..5f002d654a8abdd94c5e8bbf7165aa3747543230 --- /dev/null +++ b/LHCb_Pipeline/analyses/slopes_after_gnn.ipynb @@ -0,0 +1,397 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import torch\n", + "from utils.plotutils.plotools import save_fig\n", + "\n", + "configure_matplotlib()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "3f2fc36a6170419d824525bd707eaca5", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "test_dir = \"/scratch/acorreia/data/focal-loss-pid/triplet_building/test/velo-sim10b-nospillover/\"\n", + "\n", + "diff_angles_xz = []\n", + "diff_angles_yz = []\n", + "y = []\n", + "y_pid = []\n", + "min_scores = []\n", + "\n", + "for filename in tqdm(os.listdir(test_dir[:100])):\n", + " path = os.path.join(test_dir, filename)\n", + " batch = torch.load(path, map_location=\"cpu\")\n", + " y.append(batch.y.numpy())\n", + " angles_xz = batch.angle_xz\n", + " angles_yz = batch.angle_yz\n", + " scores = batch.scores[batch.edge_index].min(dim=0).values\n", + "\n", + " diff_angles_xz.append(\n", + " (angles_xz[batch.edge_index[1]] - angles_xz[batch.edge_index[0]]).numpy()\n", + " )\n", + " diff_angles_yz.append(\n", + " (angles_yz[batch.edge_index[1]] - angles_yz[batch.edge_index[0]]).numpy()\n", + " )\n", + " y_pid.append(batch.y_pid.numpy())\n", + " min_scores.append(scores)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0.8058, 0.9442, 0.9453, ..., 0.1108, 0.9200, 0.9075])" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.scores" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "array_diff_angles_xz = np.concatenate(diff_angles_xz, axis=0)\n", + "array_diff_angles_yz = np.concatenate(diff_angles_yz, axis=0)\n", + "array_y_pid = np.concatenate(y_pid, axis=0)\n", + "array_y = np.concatenate(y, axis=0)\n", + "array_scores = np.concatenate(min_scores, axis=0)\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([-2.95289799, -2.95099742, -2.94795341, ..., 0.51473529,\n", + " 0.48531203, 0.5169795 ])" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "array_diff_angles_xz[array_y_pid == False]" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure was saved in output/analyses/triplet_angles.pdf\n", + "Figure was saved in output/analyses/triplet_angles.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_yz[array_y_pid == False],\n", + " label=\"Fake triplets\",\n", + " color=\"red\",\n", + " bins=500,\n", + " range=(-1.0, 1.0)\n", + ")\n", + "ax.hist(\n", + " array_diff_angles_xz[array_y_pid == True],\n", + " label=\"Genuine triplets\",\n", + " color=\"green\",\n", + " bins=edges,\n", + ")\n", + "ax.legend()\n", + "ax.set_xlabel(\"$y$-$z$ angle\")\n", + "save_fig(fig, os.path.join(anaconfig.PLOTDIR, \"triplet_angles\"))" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure was saved in output/analyses/true_triplet_angles.pdf\n", + "Figure was saved in output/analyses/true_triplet_angles.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_xz[(array_y_pid == True)],\n", + " label=\"Genuine\",\n", + " color=\"green\",\n", + " bins=200,\n", + " range=(-0.01, 0.01)\n", + " \n", + ")\n", + "ax.hist(\n", + " array_diff_angles_yz[(array_scores > 0.8)],\n", + " label=\"Score > 0.8\",\n", + " color=\"purple\",\n", + " bins=edges,\n", + ")\n", + "ax.set_xlabel(\"$y$-$z$ angle\")\n", + "ax.legend()\n", + "\n", + "save_fig(fig, os.path.join(anaconfig.PLOTDIR, \"true_triplet_angles\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure was saved in output/analyses/true_triplet_angles_0p2.pdf\n", + "Figure was saved in output/analyses/true_triplet_angles_0p2.png\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_yz[(array_scores > 0.2)],\n", + " label=\"Score > 0.2\",\n", + " color=\"purple\",\n", + " bins=200,\n", + " range=(-0.01, 0.01),\n", + " alpha=0.5,\n", + " \n", + ")\n", + "\n", + "ax.hist(\n", + " array_diff_angles_xz[(array_y_pid == True)],\n", + " label=\"Genuine\",\n", + " color=\"green\",\n", + " bins=edges,\n", + " alpha=0.5,\n", + ")\n", + "ax.set_xlabel(\"$y$-$z$ angle\")\n", + "ax.legend()\n", + "\n", + "save_fig(fig, os.path.join(anaconfig.PLOTDIR, \"true_triplet_angles_0p2\"))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Figure was saved in output/analyses/true_triplet_angles.pdf\n", + "Figure was saved in output/analyses/true_triplet_angles.png\n" + ] + }, + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fc9ff0ee8f0>" + ] + }, + "execution_count": 35, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "save_fig(fig, os.path.join(anaconfig.PLOTDIR, \"true_triplet_angles\"))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_xz[(array_y_pid == True) & (array_scores < 0.8)],\n", + " label=\"Genuine triplets as Fake\",\n", + " color=\"blue\",\n", + " bins=500,\n", + " range=(-0.05, 0.05)\n", + " \n", + ")\n", + "ax.hist(\n", + " array_diff_angles_yz[(array_y_pid == False) & (array_scores > 0.8)],\n", + " label=\"Fake triplets as True\",\n", + " color=\"purple\",\n", + " bins=edges,\n", + ")\n", + "ax.set_xlabel(\"$y$-$z$ angle\")\n", + "ax.legend()\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7fe3489d4580>" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "_, edges, _ = ax.hist(\n", + " array_diff_angles_yz[array_y == False],\n", + " label=\"False\",\n", + " color=\"red\",\n", + " bins=500,\n", + " range=(-5, 5)\n", + ")\n", + "ax.hist(\n", + " array_diff_angles_xz[array_y == True],\n", + " label=\"True\",\n", + " color=\"green\",\n", + " bins=edges,\n", + ")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/track_length.ipynb b/LHCb_Pipeline/analyses/track_length.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..2731a06ff07fdd44c1dc36a9fb66170561aed455 --- /dev/null +++ b/LHCb_Pipeline/analyses/track_length.ipynb @@ -0,0 +1,196 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "import os.path as op\n", + "\n", + "import anaconfig\n", + "\n", + "import montetracko.lhcb as mtb\n", + "import montetracko.lhcb.category as mtbc\n", + "\n", + "from Preprocessing.preprocessing import load_dataframes\n", + "from Preprocessing.particle_line_fitting import compute_particle_line_metrics_dataframe\n", + "\n", + "from utils.plotutils.plotools import save_fig\n", + "\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "configure_matplotlib()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles, particles = load_dataframes(\n", + " indir=\"/scratch/acorreia/minbias-sim10b-xdigi-nospillover/92\",\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Abundance')" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist(particles[\"nhits_velo\"], bins=np.arange(3, 27) - 0.5)\n", + "ax.set_xlabel(\"# hits\")\n", + "ax.set_ylabel(\"Abundance\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n_particles_velo=1,561,846\n" + ] + } + ], + "source": [ + "n_particles_velo = (particles[\"nhits_velo\"] >= 3).sum()\n", + "print(f\"{n_particles_velo=:,}\")" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "$f \\times \\sum_{n = 3}^{26} \\frac{1}{n} = n_{\\text{hits}}$" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "nhits_max = 10" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "factor = 1 / np.arange(3, nhits_max)\n", + "norm = n_particles_velo / factor.sum()" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "<matplotlib.legend.Legend at 0x7f20e7086140>" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAxYAAAIpCAYAAAA/5a5rAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAACBz0lEQVR4nO3deZzN5f//8eeZxaxmBsPYGaFC1k8Nso0lyRJFm4RCRaiQUj62SlEhSjXKXpGiMPoglG0IIbIba5FlNmMWY96/P+Y37++MOXNmOWdWj/vtNrfPe851vV/v15nzOTqvc72v67IYhmEIAAAAAOzgVNAJAAAAACj6KCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2M2loBPA7Ss5OVl///23SpYsKYvFUtDpAAAA4BaGYSgmJkYVK1aUk5PtMQkKCxSYv//+W1WqVCnoNAAAAJCFs2fPqnLlyjb7UFigwJQsWVJSyv9RfXx8CjgbAAAA3Co6OlpVqlQxP7fZclsVFqNGjdIHH3wgSRo3bpzGjx+f5Tnbtm3TrFmztGXLFv37778qW7asmjVrpsGDB6tNmzbZum5SUpJCQkK0aNEiHT58WAkJCapataoefvhhDR8+XOXLl89WnNOnT2v69OkKDQ3V2bNn5e3trbp166pv37565plnshyeShUaGqrPPvtMu3fv1pUrV1ShQgW1adNGQ4cOVePGjbMVIzY2Vp988omWLFmiEydOyDAM1ahRQz179tTQoUOzVSik3v7k4+NDYQEAAFCIZee29dtm8vaePXs0bdq0HJ0zceJEtWzZUj/++KN69OihmTNnqlevXlqzZo2Cg4P12muvZRnj8uXLatGihQYPHqyrV69q9OjRmjJligIDA/Xee++pfv36+u2337KMs3r1atWvX18zZsxQgwYN9NFHH2n48OEKDw9X//799cADDygmJsZmjOTkZA0aNEidO3fW1q1b9cwzz+jjjz9Whw4d9PXXXysoKEgff/xxlrkcP35cTZo00ejRo+Xs7Kzx48dr0qRJ8vT01FtvvaWGDRvq4MGDWcYBAABAMWLcBm7cuGE0atTIkGT+jBs3zuY5s2fPNiQZ7u7uRlhYWLq2PXv2GF5eXoYkY+rUqTav26JFC0OS0bx5c+P69evp2t944w1DkuHn52ccPXo00zi7d+82PDw8DEnG9OnT07VdvXrVqFu3riHJ6NKli83nNHr0aEOS4e/vbxw7dixd25o1awwnJyfDYrEYS5cuzTRGZGSkUbt2bUOS8eijjxpJSUlmW3JystG7d29DklGtWjXj0qVLNvOJiooyJBlRUVE2+wEAAKBg5OTz2m1RWLz33nuGJOPhhx/OVmHx77//Gt7e3oYkY/To0Vb7jBs3ziw8zp49a7XPp59+akgyLBaLcfDgwQztiYmJRs2aNbMsCoKCggxJRlBQkNX2jRs3ms9r2bJlVvscOHDAcHJyMiQZs2fPttqnb9++hiQjICDAuHbtmtU+r732miHJ8Pb2Nv79998M7VevXjX8/PwMScZLL72U6XMyDAoLAACAwi4nn9eK/a1QJ06c0IQJE3Tvvfdq6NCh2TpnxowZunbtmiRpwIABVvsMGDBAFotF8fHx+vDDDzO0G4ahyZMnS5Luv/9+1alTJ0MfV1dX9evXT5K0atUq7du3L0Of9evXa8eOHZKkgQMHWs2lTZs2qlWrliTp7bffttpn8uTJSk5OloeHh3r37m21T2r8ixcvas6cORnaY2JiNHPmTElS9+7dVbZs2Qx9SpUqpZ49e0qSPv/8c12+fNnqtQAAAFC8FPvCYtCgQbpx44ZCQkLk7OycrXOWLVsmSapevbpq1qxptU/lypV11113mf0Nw0jXHhYWprNnz0qS2rdvn+m1OnToYB5/9913GdrTPmYrTmrb3r17dfz48XRtCQkJWrlypSQpKCgo01n9zZo1k7e3d6a5rFq1SnFxcVnmkvqcbty4oRUrVmTaDwAAAMVHsS4svvzyS23YsEEjRoxQgwYNsnXO+fPndeTIEUlSw4YNbfZt1KiRJOncuXM6duxYurYNGzaYx7biNGjQwFzNKe05t8bx8/NTtWrVsszFWpxdu3YpOjo6y1ycnJxUv359SdL27dvNIsJaXFtxbOUCAACA4qnYFhYXLlzQqFGjdMcdd2jcuHHZPu/AgQPmcVabt6Vtv3UVpOzGcXNzM28pujVGXFycTp48mW+5pG1PTk7W4cOHcxXHVi4AAAAonoptYfHSSy8pIiJCn3/+uTw8PLJ93qlTp8zjgIAAm33Ttqc9L7dxoqOjFRERYT5+5swZJScnF0gutuK4uLiodOnSmcZwd3c396W4NQYAAACKp2K5Qd6PP/6o77//Xv369VO7du1ydG7avSDc3d1t9k1bsNy6h4Q9cUqVKlVocrEWJ6sYqXGio6N17do1GYZhc1OV1Nu0Urm5ucnNzS3LawAAAKDwKHaFRXR0tIYMGaKyZctaXa0pK2nnFZQoUcJm37Tt169fd3icwpRL2jhZxUjbJzk5WQkJCTaLkVtvq8rurugAgOwxDEM3btwwR8EB3B6cnZ3l4uKSrV2zHaHYFRavvfaazp8/r6+//trm7TqZSfuNfWJios2+ads9PT0dHqcw5ZIaJzY2NssYaeM4OTllOfpw9uxZ89YpSYxWAICDXL9+XVFRUYqJidHNmzcLOh0ABcDNzU1+fn4qVapUnhcYxaqw2Lx5s7744gs9+OCDevLJJ3MVI+1SrPHx8Tb7ph0JuHUJV0fEKUy5pP4eGxubZYy0cby9vbP8P7GPj0+6wgIAYL+YmBidO3dOrq6u8vPzk5eXl5ycnPLtm0sABcswDCUlJSkqKkoXL15UYmKiypcvn6fXLDaFRWJiogYOHKgSJUpo0qRJVjdmi4qKMo+vX7+ero+vr69cXV1VvXp187GLFy/avGba9rTnpf4eFhZm9qtUqVKWcXx8fMz5FZJUtWpVOTk5KTk52e5crPXLTZwLFy4oKSlJV69ezXREKD4+3pw3cWsMAEDeu379us6dOycfHx9VrFiRYgK4jZUsWVIRERG6cOGCPDw85Ovrm2fXKjarQv399986cuSIEhISdO+996ps2bIZfrp37272nzp1arq2rVu3SpLq1atn9knd4C4z586dM4/r1q2bri27cRISEnTp0iWrMTw8PFSjRo18yyVtHCcnJ3MDwJzGsZULACDvRUVFydXVlaICgCSpVKlS8vT0zLBgjqMVmxGL8uXLa926dTb77Nu3TyNHjpQk9enTR88884zZlrqBXqVKlVS7dm0dPXpUe/futRlvz549klJ24a5Vq1a6trZt25rHe/fu1cMPP5xpTqmT6dKekzbO8ePHFRkZqdOnT2e6SV5qLtbi/Oc//1HJkiUVExNj8zklJydr3759klJ24b51md62bdtqzpw55nPKbNNBW7kAAPKWYRiKiYmRn58fRQUAk7e3ty5fvqzk5GRzc2ZHKzYjFu7u7mrfvr3NnyZNmpj9a9Soka4t7S1IvXr1kpSyB0PqBnW3On/+vLmBXM+ePTP84920aVNVrlxZkvTLL79kmvf69eszXDettI/ZipPa1rBhQ9WsWTNdm5ubm7p16yZJ2rFjh65du2Y1RlhYmNlmLZcuXbqYxUZ2npOrq2umBRUAIG/cuHFDN2/elJeXV0GnAqAQcXd3V3JyspKSkvLsGsWmsHCkYcOGydvbW5LMb+hv9eWXX8owDLm7u2vEiBEZ2i0Wi8aMGSNJ2rJlS4ZdrCUpKSlJ8+bNkyR17tzZ6ghA+/btFRQUZDOX3377TUePHpUkvfnmm1b7vP7663JyclJcXJy+/vprq31S4wcEBGjAgAEZ2kuWLKmhQ4dKklasWKErV65k6BMVFaVly5ZJkgYNGmTuKg4AyB+po+B59Y0kgKIp9d+EvFx2mn91rChXrpymTp0qSZo2bZp+//33dO379u3TlClTJEmTJk0yRyZuNXDgQLVo0UKGYWjgwIHpVlySpPHjx+vYsWPy8/PTtGnTMs3n008/lYeHh7Zv365Zs2ala4uMjNSQIUMkpYwo9OzZ02qMevXqadSoUZKkt956K8NIzNq1azV//nxJ0syZMzP9pmvMmDGqXbu2YmJi9OKLL6b7P6dhGBo6dKgiIiJUrVo19qIAgALEbVAA0sqPfxOKzRyLzOzfv1/79++XJB06dCjd44sWLZKU8g19hw4d0p33wgsv6OLFi5o4caKCg4M1YMAA1a1bV4cPH1ZISIhiY2M1cuRIc86GNS4uLlq+fLm6dOmiLVu2qEmTJurfv7+8vLwUGhqq1atXy9/fX8uWLcswRyOtxo0ba+nSperdu7eGDRumzZs3q23btrpy5YpCQkJ06tQptW3bNtORiFTvvvuurly5ojlz5ui+++7T888/r+rVq2v37t2aO3eunJyc9NFHH1m9DSqVr6+vVq9erc6dO+u7777TmTNn9OSTT8pisWjp0qXaunWrAgMDtXLlSvn7+9vMBwAAAMWHxTAMo6CTyEvjx4/XhAkTbPZp3bq1Nm3aZLVt27Zt+vjjj7VlyxZdunRJ/v7+atasmYYMGaLg4OBs5ZCUlKSQkBAtXLhQhw8fVkJCgqpWrapu3brp5ZdfVoUKFbIV59SpU5o+fbpWr16tc+fOycvLS/Xq1VPfvn3Vt2/fbA97h4aGavbs2dq1a5ciIiJUvnx5tW7dWsOHD1fjxo2zFSM2NlazZs3SkiVLdPz4cUkp81Z69uypYcOGZWtfiujoaPn6+ioqKir/9rHYPz7vr1E/H64BAJmIj49XeHi4AgMD5e7uXtDpACgkcvtvQ04+rxX7wgKFF4UFADgehQUAa/KjsGCOBQAAAAC7UVgAAADkgVWrVslisZjzEJHeqVOnzL9P6k+bNm0KOi3YodhP3gYAAJmbtu5oQaeQp17pULvArr1gwQLzeP78+Xrsscfy/Jp79+7VihUrJEkvv/yy/Pz88vyauVW2bFktXLhQkvTOO+9YXZofRQsjFgAAAA4WFRWllStXmr+vXbtWFy9ezPPr7t27VxMmTNCECRMUGRmZ59ezh5eXl55++mk9/fTTCggIKOh04AAUFgAAAA62ZMkSxcfHq0yZMpJSVojMall4oKijsAAAAHCwBQsWyMvLSzNmzEj3GFCcUVgAAAA40MmTJ7V161Z1795dvXr1UqlSpSSl3Kb0559/FnB2QN6hsAAAAHCg1JGJ3r17q0SJEurZs2eGtqzcuHFDISEh6tChg8qVKydXV1f5+fnpP//5j4YMGaL//e9/Sk5ONvuPHz9eFotF/fv3Nx8LDAxMt+JS9erV0/VN+3PrRsGzZs3Ksk+qqKgoffnll+rZs6dq1KghDw8PeXh4qEaNGurTp4/CwsKy9ZxR9LEqFAAAgAMtWrRIZcuWVYcOHSRJTz31lEJCQiRJixcv1nvvvSdnZ+dMzz916pS6du2qAwcOqHr16ho8eLAqV66s8+fP68cff9Snn36qTz/9VHXr1tWBAwckSY888ohq1qypzZs364svvpAkTZs2Tf7+/mZcb2/vdH0PHTqkd99912oODzzwgBYuXGizT6pGjRopPDxcnp6e6tevn+655x7FxMRox44dWrx4sRYvXqyJEyfqrbfeyuZfEEUVhQUAAICDbNmyRSdOnNCQIUPk4pLyMat169aqXLmyzp07p3/++Ufr169Xx44drZ4fGRmptm3bKjw8XM2bN9fatWvl5eVltv/3v//VSy+9pE8//VTnzp0zH69fv77q16+vpKQks7Do3r27OUqRVmrfTZs2ZVo01K5dW7Vr17bZJ1ViYqJKliypsLAw1alTJ11baGiounTporFjx6px48Z66KGHbMZC0catUAAAAA6S9jaoVBaLRU8++WSGPta88cYbCg8Pl5OTk7766qt0RUVqrI8++khly5Z1cOb26du3b4aiQpIeeughPf7445KkqVOn5ndayGcUFgAAAA4QHx+v7777TjVq1FCzZs3StaUtNFasWKGYmJgM50dHR2vevHmSpPvuu0933nmn1eu4ubnp4Ycflq+vr+OSt0NYWJgmT56caft9990nSdq2bZtu3LiRX2mhAFBYAAAAOMBPP/2kyMhIPfXUUxnaGjRooLp160qSrl+/rmXLlmXos2XLFsXHx0uS7r33XpvXCgkJ0enTpx2Qtf0qV65szt+QpNjYWF25ckWXL1/W5cuX5erqKinllqkrV64UVJrIBxQWAAAADjB//nxJslpYSOlHLVL7pnX8+HHzuHLlyg7OLu/cvHlTc+fOVXBwsEqWLClvb2/5+/urbNmyKlu2rIYOHWr2TS2cUDwxeRsAAMBO//77r9auXas6deqobNmyunz5coY+DzzwgMaMGSNJ+u2333T69GlVq1bNbE97e5S7u3veJ+0AsbGx6ty5s3799Ve5uLjo6aefVqtWrVSpUiU5OaV8f7127VrmV9wmKCwAAADstHjxYiUlJemvv/7K1sRqwzC0cOHCdEuwlixZ0jwuLN/s37x502b7xIkT9euvv0qSFi5cqCeeeCJDn7SrV6F4o7AAAACw04IFC+Tt7a3vv//e/Kbemh07dpjFxK2FRc2aNc3j/PgwnrocrqRMJ1VHR0fbjPHNN99IkipUqGC1qMDthcICAADADgcOHNDevXs1YMAAPfDAAzb7tmjRQh9++KEiIiJ09OhRhYWFqWnTpmabu7u74uPjtWvXLptx3n//ff3xxx8aNWqUmjRpYj5usViynXfaVaUiIyOt9jly5IjNGBcuXJBke06ItRWwUDwxeRsAAMAOqROxBw4cmGVfd3f3dJO70+5p4ePjo/79+0tKGdk4duyY1RjR0dGaOHGifvrpJ9WoUSNdm6enp3mcdhRi8eLFqlmzpj7//HPzsZo1a5o7gB86dMjqtX766Sebz6dChQqSUiaeZ3bbVFZFEooPCgsAAIBcunnzpr7++mvdc8895n4NWXnuuefM4yVLligxMdH8/d1331VgYKCSk5P13HPP6fr16+nOTUpK0rPPPqvr16/r1VdfValSpdK1165d2zxOuxzt5s2bdeLECfn5+ZmPeXh4qF27dpJSbmlKSEhIF2vRokU6c+aMzeeSuvldRESEJk2alKH9119/1eLFi23GQPHBrVAAAAA5FBsbq+XLl+vkyZP6+++/FRQUpEWLFumOO+7IsDleWosWLZIk+fv76/Lly7p69aomTJigu+++W82bN1eNGjW0YcMGdenSRZs3b9Y999yjvn37qlKlSjp79qy++eYbHT16VD179tS4ceMyxG/QoIEaNGigffv26dVXX9WLL76o06dP66uvvlLFihXVpUuXdP0nT56szZs36/Dhw7r//vvVp08feXl5afPmzdqxY4c++ugjs3hYt26dzp07p5o1a5q3b40dO1a//vqrdu7cqQkTJmjLli3q2LGjPD099fvvv2vRokWqWbOmeUvVihUr5O/vr+bNmysgIEDLly+XJF28eNH839S/UY8ePTLsPI7CzWIYhlHQSeD2FB0dLV9fX0VFRcnHxyd/Lrp/fN5fo34+XAMAMhEfH6/w8HAFBgZma8nSaeuO5kNWBeeVDrWz7pQLp06dUmBgYIbH+/bta+6ebY2tORBz585Vv379JKXcxjR37lwtXbpU+/btU2RkpHx9fdWkSRM999xzeuyxxzKNc+7cOY0ePVrr169XRESEKlSooJYtW+qdd95Jt7xtqr1792rChAnavHmzYmJiVLlyZT3yyCN68803tXfvXgUHB6fr/9xzz2nOnDnm7wkJCZo5c6a+/fZbHT58WImJiSpbtqyCgoL0wgsv6O+//zZv8Ur7XNu0aWP1b5gqPDxc1atXz7QdOZPTfxtS5eTzGoUFCgyFBQA4Xm4/PAAo3vKjsGCOBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAADkQr9+/WSxWNL91KhRQ9HR0Vmee+t5aX9OnTqV98kXcadOncrwd2vTpo3VvpGRkWratKn8/f21Zs2a/E3UTtWrV8/wPAszl4JOAAAAFKD94ws6g7xVf3yehX7++efVvn17SdIrr7yiy5cvKzw8XIMGDdK3335r89yFCxdKkg4dOqR3331XgwYNUsuWLSVJZcuWzbOci4uyZcuaf8N33nlHhw8fzrTvL7/8oh07dkiSZs+erU6dOuVLjo4wffp0Xbt2TT/88IOWL19e0OlkiRELAACAXGjWrJmefvppPf300/Ly8jIfX7Jkib788kub56ae16FDB5uxYJ2Xl5f59woICLDZt23btrr33ntVunRpDRgwIJ8ydIzu3bvr6aefVv369Qs6lWxhxAIAAMABfHx8zNughg0bpubNm+vuu+8u4KxQqlQp7dy5s6DTuC0wYgEAAOAAjRo10osvvihJun79uh5//HHFx8cXcFZA/qGwAAAAcJBp06apUaNGkqQ///xTI0aMKOCMgPxDYQEAAOAgbm5uWrp0qXx8fCRJn376qUMm3f7888967LHHVLlyZbm5ual06dJq1qyZJk+erJiYGKvnVK5c2eqKQsePH9egQYNUvXp1ubm5mW3z5s3T008/neGcTZs2KSIiQiNHjlRgYKA8PDxUu3ZtjR49WhEREeb1zp49qwEDBqhKlSpyd3fX3XffrcmTJyspKSnT5xUVFaUvv/xSPXv2VI0aNeTh4SEPDw/VqFFDffr0UVhYmF1/t1ufS/Xq1TPt+/PPP+uRRx5R5cqVVaJECXl7e6tevXp67rnn9MMPPyghISHTc69du6b33ntPQUFBKlWqlNzc3FSpUiU9/PDDWrJkiZKTk23mGRsbq/Hjx6tevXry9PRU6dKl1bx5c3322WdZnluYUFgAAAA4UM2aNRUSEmL+/txzz+nMmTO5ihUXF6devXqpU6dO+t///qdevXrp008/1RtvvKGEhASNGTNGtWrVsvoBfObMmVq4cKF69OhhPrZ161Y1a9ZMTk5OevPNN/Xmm2/Kz8/PbB88eLAWLlyoMWPGmI9dvHhRzZs3V0xMjMaMGaORI0cqMjJSU6ZMUXBwsKKjo3X06FF16dJFFSpU0NixY9W/f38dO3ZMY8aMsTlhulGjRhowYIDWrFmjTp06adq0aZo4caIaN26sxYsXq3nz5nr77bdz9beTUlbfWrhwobniVmZeeeUVderUSVu3btUTTzyhmTNn6u2339Y999yjefPm6dFHH1WTJk2snrtnzx7deeedeuONN+Tq6qr//ve/+vTTT9W7d28zXvv27dMVYWmdOXNGDRs21IQJE3Tx4kUNGzZMH3zwgTp37qzp06fr4YcfLjLFBZO3AQAAHOyxxx7Tpk2bNHv2bEVERKh3797atGmTnJ2dcxSnd+/eWr58ucqWLavt27frjjvuMNteffVV9evXT4sWLVKHDh20e/du1a5d22xPLSiOHz9ujpr07dtXP/74o5o3b272u+OOO/T0009Lkpo3b67mzZtr06ZNevfddyVJI0aM0KxZs9S9e3fznL59+6pevXrat2+fZs6cqa1bt2rFihUKDAw0+9x333169tlnNX/+fA0dOtTqB/PExESVLFlSYWFhqlOnTrq20NBQdenSRWPHjlXjxo310EMP5ehvJ8l8XuvXr9fmzZut9tmwYYOmT58uT09P7dy5U9WqVcsQo2vXrrp27VqGc0+dOmUWDS+//LKmTZuWrv2VV15R8+bNtXHjRj311FMKDQ1NtxfFjRs31LVrVx0/flyVKlVSWFiYKleubLaPHDlSXbp00eeff57j514QGLEAAADIA2nnW2zZskXjx4/P0flLly41C4J33303XVEhSc7Ozvrkk09UqlQpXbt2TQMHDswyZufOndMVFZIUHBysvn37qmbNmlbPqVWrVrqiQkoZlWnbtq0kadKkSQoKCkpXVEhKt3TuihUrMs2pb9++GYoKSXrooYf0+OOPS5KmTp1q83nZY9WqVZKku+++O0NRIaX8zZo2bWr13CFDhigiIkKVK1fWlClTMrRXqFBBkydPlpRyq9XatWvTtX/xxRfav3+/JOm9995LV1RIKbfWzZkzR1euXMn5EysAFBYAAAB5IHW+RcmSJSWlFAebNm3K9vkzZsyQJLm6upofsG/l4+Njjkz89ttv2rt3r82Yjz32WIbHKlasqHnz5qlFixZWz+ncubPVx++8805JUkJCgtU+rq6uZrFy6NAhqzHCwsLMD97W3HfffZKkbdu26caNG5n2s0fqbUZHjx7VhQsXrPb57LPPNH/+/HSPHTt2TKGhoZKkXr16ydXV1eq5aTfkW7RoUbq21Fvm3Nzc9Mgjj1g9v1q1amrWrFk2nknBo7AAAADII2nnWyQnJ6t37966fPlylufFxMSYu0XfddddZnFizb333mser1+/3mbcunXrZiftdGrVqmX18bQ5ZdYndRJ7VFSU1fbKlSvL29vb/D02NlZXrlzR5cuXdfnyZfPDemJiYp59a9+6dWtJKX/z5s2b68svv8wwIb5+/fpmv1Rp/9a1atUyc77158aNG+bITeprKqX8TVJHK+666y55enpmmmNR2SCPwgIAACAPPf7443rhhRckSX///bf69euX5Tnh4eG6efOmJKlSpUo2+6a9feb48eM2+6Z+0M+JzIoaJyenbPfJbLTh5s2bmjt3roKDg1WyZEl5e3vL399fZcuWVdmyZTV06FCzb17tCdKjRw9zLkZ4eLgGDBigcuXKqUuXLgoJCcm0oEn7tx48eLCZs7Wf2NhYSUo3InLq1CkZhiEpZdTIllKlStn1HPMLk7cBAADy2PTp0xUWFqa9e/dq9erVmj59ul5++eVM+6f9xtzDw8Nm7LTtmY0MpEpbDGRXds7JTdzY2Fh17txZv/76q1xcXPT000+rVatWqlSpkhlv7dq1eTq/ItXChQvVq1cvzZgxQ5s2bVJ8fLxWr16t1atX66WXXlLfvn31/vvvp/uAn7rLuiRNmDAhw9wVa9JO3E77Gru7u9s8z8WlaHxkLxpZAgAAFGFubm767rvv1LhxY8XExGj06NFq1apVpv3TjgBk9U19XFyceezr62t/svlk4sSJ+vXXXyWlfLB/4oknMvQ5d+5cvuXTrVs3devWTf/++69+/PFHLV26VL/88osSExMVEhKisLAw7dq1SyVKlJCU8Vaw9u3b5+h6OXmNU0evCjtuhQIAAMgHaedbJCYm6oknnrC6hKkkBQYGmkvTZvXhOm17Zis7FUbffPONpJSVk6wVFQWlXLlyGjhwoNatW6cjR46Ycyv+/PPPdBO4084rOX36dI6vU716dXME4/z58zb7ZrYHRmFDYQEAAJBPHn/8cT3//POSUlYVGjVqlNV+JUuWVFBQkCTpyJEjmRYgkvT777+bxzn91rwgpc43uHWJ1bQy21XckX744YdMV6aqVauWli9fbt6KtG/fPrMt7d9627ZtNq+xcOFCubi4qG/fvuZjvr6+5qTsw4cPm/MwrPnzzz+zfiKFAIUFAABAPpo+fboaNmwoKeUDZWaGDx8uKWV0Y8mSJVb7xMTEmHtEtGrVyoxbFFSoUEFSyiTozG712bVrV57n8dNPP+nNN99MN2ciLT8/P3PFprST32vVqmVu2rd27VqdPXvW6vmGYeiLL77QzZs39dRTT6VrS92VPDExUT/88IPV88+dO5dl4VJYUFgAAADkI3d393T7W2TmscceM/eoGDNmjE6ePJmuPTk5WUOHDtXVq1fl7e2tL774Is9yzgupe3NERERo0qRJGdp//fVXLV68OF9yMQxDb775ptW277//XtHR0XJyclKvXr3StX366acqXbq0EhIS1KdPnwwjS4ZhaOzYsdqyZYs6duyojh07pmt//vnnzVGLN954I8MtUYmJiRo0aJC9Ty/fMHkbAAAgF7Zv364TJ05ISlnh6OLFi+YGaPXr17e590CtWrX0xRdf6Mknn7R5jcWLF6tPnz76/vvv1ahRIz333HOqW7euIiIi9O2332r37t0KCAjQihUrzA3rUq1bt04XL14090qQ/m+DNm9v7wy7aUvS/v37tX///nQb2q1bt07nzp1T8+bNVaNGDZtxe/ToIS8vL/P3ixcvmv+7aNGidNcdO3asfv31V+3cuVMTJkwwP3x7enrq999/16JFi1SzZk0dOXJEUsru3f7+/mrevLkCAgLMXclvvYa1PFKLstjYWPOxDh06KCAgwByFmDVrlrZu3aqHH35YlSpVUkxMjMLCwrR8+XI5Ozvro48+MndST1WtWjVt2LBB3bp106+//qo6deromWeeUWBgoP755x/9+OOP2rVrl5o3b27OKUnL1dVVK1euVNu2bXXixAk1bNhQAwYMUK1atXThwgUtWrRIzs7OGjJkiLlhYmr+zZo1y7Abe0GzGKkL6AL5LDo6Wr6+voqKisrVutq5sn983l+jfj5cAwAyER8fr/DwcAUGBma5hCXs069fvwy7MacaN26cxo8fn2WMF154QZ9//rnmzp1rc3+LNWvW6Msvv9T27dt1+fJleXp6qnbt2nr44Yf10ksvWf3vaJs2bcxVl25VrVo1nTp1KsPj48eP14QJE6yek5qjrbjh4eHpJiVndd2EhATNnDlT3377rQ4fPqzExESVLVtWQUFBeuGFF/T333+rf//+GfJo06aNAgMDrV4jO3lI0saNG9WmTRtJKbuWr1ixQtu2bdOxY8cUHR0tV1dXVa1aVa1bt9bgwYPVoEGDTGNdv35dn332mX744Qf99ddfiomJkZ+fnxo2bKjevXurT58+5mR8a2JjY/XBBx9o6dKlOnnypEqUKKE77rhDjzzyiEaMGKH3338/w+sSEhJi3kqVHbn9tyEnn9coLFBgKCwAwPEoLABYkx+FBXMsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAohgzDKOgUABQi+fFvAoUFAADFiJNTyn/ak5OTCzgTAIVJ6r8Jqf9G5AUKCwAAihFXV1c5OzsrNja2oFMBUIjEx8fLyclJLi4ueXYNCgsAAIoRi8WikiVLKjo6mtuhAJiuXbsmT09PRiwAAED2+fr66saNG/r7778pLgAoIiJC169fl4+PT55eJ+/GQgAAQIHw9PRU5cqVde7cOcXFxcnHx0eenp5ydnaWxWIp6PQA5APDMJSUlKSoqCjFxMSoVKlS8vX1zdNrUlgAAFAMlSxZUtWqVVNUVJQiIyN15cqVgk4JQAFwc3NTQECASpUqlefXorAAAKCY8vT0lKenp8qXL68bN26wUhRwm3F2dpaLi0u+jVRSWAAAUMxZLBaVKFGioNMAUMwxeRsAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANiNwgIAAACA3SgsAAAAANitWBYWkZGRWrx4sZ599lk1atRIfn5+cnFxkZ+fn+6991698cYbOnPmTLZibdu2TU899ZSqVq0qd3d3ValSRY899pg2bdqU7XySkpI0e/Zs3X///SpTpoy8vb1Vp04dvfHGG7pw4UK245w+fVqvvPKK7rzzTnl6eqpcuXIKDg7WvHnzcrSbamhoqLp166ZKlSrJ3d1dgYGB6t+/v/bs2ZPtGLGxsZoyZYqaNGkiPz8/+fr6qlGjRnrnnXcUHR2d7TgAAAAoHiyGYRgFnYQjbdu2TW3btlVCQoIsFot69OihoKAg+fj46Pjx41qwYIEuXbokT09PzZ07V4899limsSZOnKgJEybI3d1dAwYMUL169XTo0CGFhITo2rVrGjVqlKZMmWIzn8uXL6tLly7asWOH7rrrLvXv31/e3t5avXq1QkNDVbZsWS1btkytWrWyGWf16tV66qmnFBMTo549e6pt27a6cuWKQkJCdPr0abVr107Lly9XyZIlM42RnJysF154QSEhISpdurQGDRqkwMBA7dq1S/Pnz1dycrI+/PBDDRs2zGYux48fV5cuXXTkyBHde++9euqpp+Tk5KQlS5Zo27ZtCgwM1MqVK1W3bl2bcaKjo+Xr66uoqCj5+PjY7Osw+8fn/TXq58M1AAAA8kFOPq8Vu8Li559/VqdOneTs7Kw1a9aoQ4cO6dojIyPVqlUr/fnnnypRooT27t2ru+++O0Oczz77TC+++KLc3d21adMmBQUFmW1//PGHWrZsqdjYWE2dOlUjR460mktSUpKCg4O1ZcsWNW/eXOvXr5eHh4fZPmbMGE2ePFl+fn7auXOnatWqZTXOnj171KJFC8XFxWn69OkaPny42RYREaGWLVvq4MGD6tKli1auXJnp3+b111/X+++/L39/f23fvl01a9ZM93fr3LmzDMPQkiVL1KtXL6sxoqKidN999+no0aN69NFHtWTJEjk7O0uSDMNQnz59tHjxYlWrVk27du2Sv79/pvlQWAAAABRuOfm8VixvhZKkfv36ZSgqJMnPz09Tp06VJCUmJmrOnDkZ+ly6dEmjRo2SJA0fPjxdUSFJjRo1MouJsWPH6ty5c1ZzCAkJ0ZYtW2SxWBQSEpKuqJCkCRMmqGbNmoqMjNSrr76a6XMZPHiw4uLiFBQUlK6okKRSpUpp1qxZkqRVq1bp+++/txrj4MGD5vOeNGlSuqJCkh588EH16dNHhmFo6NChio2NtRrn3Xff1dGjR+Xt7a3Zs2ebRYUkWSwWzZw5U35+fjp9+rQmTJiQ6XMCAABA8VLsCgs/Pz8FBQWpZ8+emfZp0qSJeXzo0KEM7TNmzNC1a9ckSQMGDLAaY8CAAbJYLIqPj9eHH36Yod0wDE2ePFmSdP/996tOnToZ+ri6uqpfv36SUoqCffv2Zeizfv167dixQ5I0cOBAq7m0adPGHO14++23rfaZPHmykpOT5eHhod69e1vtkxr/4sWLVguumJgYzZw5U5LUvXt3lS1bNkOfUqVKmX/7zz//XJcvX7Z6LQAAABQvxa6waNq0qcLCwvTggw9m2sfT09M8dnNzy9C+bNkySVL16tUzfLOfqnLlyrrrrrvM/rfeURYWFqazZ89Kktq3b59pLmlHVb777rsM7WkfsxUntW3v3r06fvx4uraEhATzFqmgoKBM52E0a9ZM3t7emeayatUqxcXFZZlL6nO6ceOGVqxYkWk/AAAAFB/FrrDIjt9//908btu2bbq28+fP68iRI5Kkhg0b2ozTqFEjSdK5c+d07NixdG0bNmwwj23FadCggZycnDKcc2scPz8/VatWLctcrMXZtWuXuVKTrVycnJxUv359SdL27dvNIsJaXFtxbOUCAACA4um2Kyzi4+M1ZswYSdI999yT4VanAwcOmMdVqlSxGStt+8GDB3MVx83Nzbyl6NYYcXFxOnnyZL7lkrY9OTlZhw8fzlUcW7kAAACgeCr2hUVCQoIuXryov/76S3PmzFGTJk20bds2PfbYY9q8eXOGCdWnTp0yjwMCAmzGTtue9rzcxomOjlZERIT5+JkzZ8z9KfI7F1txXFxcVLp06UxjuLu7m6sG3BoDAAAAxZNLQSeQ17755hv179/f/L1q1apavHixnnzySVkslgz9Y2JizGN3d3ebsdMWJWnPszdOqVKlCk0u1uJkFSM1TnR0tK5duybDMKz+rVPduqGem5ub1bkvAAAAKLyK/YhFx44dtW7dOq1YsUJTp05VmTJl1Lt3b9WuXVuhoaEZ+qedV1CiRAmbsdO2X79+3eFxClMuaeNkFSNtn+TkZCUkJNjsW6VKFfn6+po/qatpAQAAoOgo9iMWFSpUUIUKFczfR4wYodGjR2vq1Knq0qWL5s6dq759+5rtab+xT0xMtBk7bXvalaYcFacw5ZIaJzY2NssYaeM4OTllOfpw9uzZdBuuMFoBAABQ9BT7wuJWFotF77//vn755Rft2bNHL774ojp27Kjy5ctLUrqlWOPj423GSjsScOsSro6IU5hySf09NjY2yxhp43h7e9u8DUqSfHx88m/n7Xwwbd3RPI3/SofaeRofAAAgN4r9rVDWWCwWc5O4uLg4ffPNN2Zb9erVzeOLFy/ajJO2Pe15uY3j4+Njzq+QUuaDpC5Fm9+52IqTlJSkq1evZhojPj7enDdxawwAAAAUT7dlYSFJd955p3n8559/msf16tUzj1M3uMvMuXPnzOO6deuma8tunISEBF26dMlqDA8PD9WoUSPfckkbx8nJydwAMKdxbOUCAACA4qnYFRZr1qzRr7/+mmU/Z2dn8zgpKck8rlSpkmrXTrnVZO/evTZj7NmzR1LKLty1atVK15Z24z1bcfbt22cuKXvrZn1pH4uMjNTp06ezzMVanP/85z/mbU22cklOTta+ffskpezCfetSvNl9TrZyAQAAQPFU7AqLF198UUOGDMmy3/Hjx83jqlWrpmvr1auXpJQ9GFI3qLvV+fPnzQ3kevbsmWEeQdOmTVW5cmVJ0i+//JJpHuvXr89wXWu5ZBUnta1hw4aqWbNmujY3Nzd169ZNkrRjxw5du3bNaoywsDCzzVouXbp0MYuN7DwnV1dXPfzww5n2AwAAQPFRLCdvHzp0SKdOncr0/n7DMLRgwQLz965du6ZrHzZsmGbMmKFr165pzpw5evfddzPE+PLLL2UYhtzd3TVixIgM7RaLRWPGjNHgwYO1ZcsWHT58OMOtRUlJSZo3b54kqXPnzmrQoEGGOO3bt1dQUJB27NihOXPm6Nlnn83Q57ffftPRoykTht98802rz/n111/XN998o7i4OH399dcaNGhQhj5z5syRlLJJ3q07kkspk7eHDh2qKVOmaMWKFbpy5YrKlCmTrk9UVJSWLVsmSRo0aJC5q/jtpGnszDy+Ql7HBwAAyLliN2IhpdzS06dPH124cMFq2yuvvKLff/9dkvTkk08qKCgoXZ9y5cpp6tSpkqRp06aZfVPt27dPU6ZMkSRNmjTJHJm41cCBA9WiRQsZhqGBAwemW3FJksaPH69jx47Jz89P06ZNy/T5fPrpp/Lw8ND27ds1a9asdG2RkZHmCE2XLl3Us2dPqzHq1aunUaNGSZLeeuutDCMxa9eu1fz58yVJM2fOlJeXl9U4Y8aMUe3atRUTE6MXX3zRvI1LSinYhg4dqoiICFWrVk3jx4/P9DkBAACgeLEYhmEUdBKO9PDDD+unn36SlLIPwxNPPKG77rpLZcqU0ZkzZ7R06VIdOnRIkvTMM8/oiy++yHTfhAkTJmjixIny8PDQgAEDVLduXR0+fFghISGKiYnRyJEjzQIkM5cvX1aXLl20Y8cO3X333erfv7+8vLwUGhqq1atXy9/fX8uWLVPr1q1txlm1apV69+6tmJgY9erVS23bttWVK1cUEhKiU6dOqW3btlqxYkWGJWLTSk5O1vPPP685c+aoTJkyev7551W9enXt3r1bc+fOVXJysj744AMNHz7cZi7Hjx9X586ddfToUQUFBZm7mC9dulRbt25VYGCgVq5cmeXE7ejoaPn6+ioqKir/lpvdPz7PL7H95JU8jd+sOyMWAAAgf+Tk81qeFRaHDx/WypUrtWPHDp09e1ZRUVHmnARJWrp0qUqXLq327ds7/NoHDhzQ8uXLtXnzZh0+fFiXL1/WjRs3VLJkSQUGBqp58+Z65plndO+992YZa9u2bfr444+1ZcsWXbp0Sf7+/mrWrJmGDBmi4ODgbOWTlJSkkJAQLVy4UIcPH1ZCQoKqVq2qbt266eWXX063gZ8tp06d0vTp07V69WqdO3dOXl5eqlevnvr27au+ffuaS9NmJTQ0VLNnz9auXbsUERGh8uXLq3Xr1ho+fLgaN26crRixsbGaNWuWlixZYs5XqVGjhnr27Klhw4Zlq1CgsMgdCgsAAJBfCrSwOHHihAYPHpxuUrJhGLJYLLp586b5WJ8+ffT111+rXr16+uSTT9SiRQtHpoEigMIidygsAABAfsnJ5zWHzrHYsGGDGjVqpPXr18swDPPHGk9PTxmGoT///FPBwcHm/f0AAAAAih6HFRbh4eF69NFHFRsbaxYTFSpUUJMmTdLtJp3q888/19atW9WhQwfdvHlTAwcOTLf/AQAAAICiw2GFxdixYxUVFSVXV1eNHj1a4eHhOn/+vH7//Xfdd999Vs9p1qyZ/ve//2nUqFFKSkrSa6+95qh0AAAAAOQjh+xjce3aNS1dulTOzs766aef9MADD+To/Pfee0/r16/Xxo0bdf78eVWqVMkRaQEAAADIJw4Zsfjtt9+UlJSk3r1757iokFI2k+vfv7+klN2fAQAAABQtDiksTp8+LYvFkmEH65yoV6+eDMPQ2bNnHZESAAAAgHzkkMIiMjJSkhQQEJDrGKkTvuPj4x2REgAAAIB85JDCws/PT5L077//5jrG0aNHZbFYVLp0aUekBAAAACAfOaSwqF69ugzD0IoVK3IdI3Ufi1q1ajkiJQAAAAD5yCGFRZs2beTu7q6vv/5aP/74Y47PnzRpksLCwuTl5cUO3AAAAEAR5JDCwsPDQ/369VNycrJ69uypV199VefPn8/yvD179qhHjx4aP368LBaLnn/+ebm6ujoiJQAAAAD5yGKkzpq20+XLl1W/fn1dvHgxJbDFovr166thw4b69ddfderUKY0ePVrXrl3TmTNntHfvXnMFKMMwVLVqVe3du9ecr4HiLzo6Wr6+voqKipKPj0/+XHT/+Dy/xPaTV/I0frPuM/M0PgAAQKqcfF5zyAZ5kuTv7681a9aobdu2ioiIkGEY2rdvn/bt2ycppXh4//33zf5p65kyZcooNDSUogIAAAAoohxyK1SqBg0a6I8//lDLli0lpRQPqQWExWKxek5wcLD27t2rOnXqODIVAAAAAPnIYSMWqapWrapff/1Vv/32m+bNm6dff/1V4eHh6frUqFFDrVu3Vr9+/cwiBMgPeX2bEgAAwO3K4YVFqlatWqlVq1aSpKSkJF29elWSVLp0abm45NllAQAAABSAfPmE7+LionLlyuXHpQAAAAAUAIfOsQAAAABweyqwwmL//v3atGlTQV0eAAAAgAM5rLCIjIxUxYoVVbp0afPn4YcfzrT/9u3b1a5dO911111auXKlo9IAAAAAUAAcVljMnTtXFy5cUFRUlCIjIxUZGambN29m2t9iscgwDB09elTdu3fXO++846hUAAAAAOQzhxUWS5cuTQno5KSXXnpJf/75p1atWpVp/+eee06bNm3Sww8/LMMw9N///tdmfwAAAACFl0MKi6tXr+r333+Xk5OTli1bpo8//lh169a1eY6zs7NatWql5cuXa9q0aTIMQ6NHj3ZEOgAAAADymUMKiz/++EPJycnq2bOnzXkVmRk+fLjat2+vw4cPa9++fY5ICQAAAEA+ckhhcezYMVksFnXr1i3XMXr37i3DMLR7925HpAQAAAAgHzmksIiMjJQkVa1aNdcxatSoIUm6dOmSI1ICAAAAkI8cUli4ublJkmJjY3Md4/r165KkEiVKOCIlAAAAAPnIxRFBypcvL8MwtHPnTnXs2DFXMXbs2CGLxaLy5cs7IiWg2Jq27mieX+OVDrXz/BoAAKB4cciIxf333y9J+vTTT3X16tUcn3/lyhXNnj07XSwAAAAARYdDCouqVauqSZMm+vfff9W2bVsdO3Ys2+ceP35c7du317///qsmTZrYNU8DAAAAQMFwyK1QkvTOO+/owQcf1J9//qm6devq4YcfVpcuXVS/fn1Vq1ZNXl5eslgsunbtms6cOaP9+/dr9erVWrFihW7cuCGLxcLu2wAAAEAR5bDC4oEHHtCrr76qjz76SDdv3tQPP/ygH374IcvzDMOQJL366qvq0KGDo9IBAAAAkI8ccitUqg8++ECjRo2S9H8Fg2EYVn9S2ywWi0aPHq2pU6c6MhUAAAAA+cihhYUkvf/++1q/fr1at25tFhDWGIah4OBgbdy4UZMnT3Z0GgAAAADykcNuhUorODhYwcHBOnPmjH799VcdOXLEXC2qTJkyuvPOO9W6dWtVqVIlLy4PAAAAIJ/lSWGRqmrVqurTp09eXgIAAABAIeDwW6EAAAAA3H4KTWHx0Ucf6dlnny3oNAAAAADkQqEpLNatW6f58+cXdBoAAAAAcqHQFBYAAAAAii6HT96+cuWKVqxYoT179ujvv//WtWvXdPPmzSzP27dvn6NTAQAAAJBPHFpYjB8/Xu+//74SExNzfG7qZnkAAAAAih6HFRbjxo3TpEmTHBUOAAAAQBHikMLiypUrmjJliiwWiwzDUIUKFdShQwfVrl1bpUuXlru7e5ajER9++KEOHjzoiHQAAAAA5DOHFBYbNmxQQkKCLBaLhg4dqg8//FAuLjkL/e2331JYAAAAAEWUQwqLM2fOSJICAgL00UcfydnZOccxDMOQYRiOSAcAAABAPnNIYZE6OnHvvffmqqiQpJ9//tkRqQAAAAAoAA7Zx6JmzZqOCAMAAACgiHJIYdGhQweVK1dOe/bsyXWMAwcO6LfffnNEOgAAAADymUMKixIlSuj999/X+fPn9cknn+QqxqhRoxQcHOyIdAAAAADkM4ftY9G3b19FRERo1KhRunjxokaNGqWSJUs6KjwAAACAQsxhhcXEiRMlSV27dtU777yjDz74QM2bN9fdd98tPz8/ubq62jz/+PHjjkoFAAAAQD5zWGExfvx4cxM8wzAUHx+vjRs3auPGjdk63zCMLDfRAwAAAFA4OaywkJRhHwr2pQAAAABuDw4tLAIDA9WqVatcnbtu3Tr9888/jkwHAAAAQD5xaGERFBSkuXPn5urcTp06UVgAAAAARZRDlpsFAAAAcHtz2IjF8OHD1aRJk1yfP2LECD3xxBOOSgcAAABAPnJYYTFt2jS7zm/fvr2DMgEAAACQ3wrNrVCXLl3SmTNnCjoNAAAAALlQaAqLZ555RjVq1CjoNAAAAADkgkNXhbIX+14AWWsaOzMfrpIf1wAAAMVJnhUWly5d0r59+3TlyhUlJCRk2f/8+fN5lQoAAACAPObwwmLt2rUaN26cdu7cmaPzDMOQxWJxdDoAAAAA8oFDC4vJkyfrrbfeksRtTQAAAMDtxGGFRWhoqN58801JkrOzs+rVqyc/Pz/t379fkZGRatWqVbr+8fHxOn78uK5cuSKLxaKGDRvKx8fHUekAAAAAyEcOKyzGjh0rKWU/innz5qlixYqSpE6dOmnt2rXauHGj1fNWrVqlwYMHy8PDQ6GhoY5KBwAAAEA+cshysydOnNAff/yhKlWqaMWKFWZRkR1dunTRb7/9pkOHDmnixImOSAcAAABAPnNIYZE6Ufu5556Tp6dnjs+vXr26XnrpJc2YMUPXr193REoAAAAA8pFDCouLFy/KYrHo3nvvzXWMli1bKj4+PtNbpgAAAAAUXg4pLFJHGUqWLJmhrUSJEun6ZMbV1VWSFB4e7oiUAAAAAOQjhxQWvr6+kqQLFy5k2nbo0CGbMQ4ePChJunbtmiNSAgAAAJCPHFJY1KxZU4ZhaPv27Zm2ffXVV5men5iYqE8++UQWi0WlSpVyREoAAAAA8pFDCovGjRvLYrHoyy+/zHArU/PmzSVJn3/+uWbOnJlh47xLly7p0UcfNUc0GjVq5IiUAAAAAOQjhxQWZcuWVaNGjRQTE6P7779fs2fPVmxsrCSpbdu2qly5sgzD0Msvv6zKlSurR48eeuaZZ9SuXTtVq1ZNoaGhslgsqlGjhl0TwAEAAAAUDIcUFpL0xBNPyDAMXbhwQS+99JK2bt2acgEnJ02ZMsUcqfjnn3/0008/afHixdq0aZPi4+PNtg8//FAWi8VRKQEAAADIJw7bebt///66efOm+fudd95pHj/xxBMKDw/X2LFjZRhGhtuhXFxcNGPGDHXr1s1R6QAAAADIRxbj1k/5eeiPP/7QF198od27dysqKkr+/v5q3ry5XnjhBd1xxx35lQYKiejoaPn6+ioqKko+Pj75cs3tK4bmy3WKumbdZxZ0CgAAoBDIyec1h41YZEejRo00e/bs/LwkAAAAgHzgsDkWAAAAAG5fhaaw+OWXX7RgwYKCTgMAAABALhSawuKDDz5Q//79CzoNAAAAALlQaAoLAAAAAEVXtiZv58ctSufPn8/zawAAAADIG9kqLPr165fnG9cZhsHmeAAAAEARlaPlZnO65YXFYsn0HFttAAAAAIqWbBcWpUqV0j333JNlvxMnTujcuXMpwV1cVKNGDfn5+cnd3V2SlJCQoIiICJ08eVI3btyQxWJRzZo1VbFixVw+BQAAAAAFLduFxX333afQ0FCbfT7//HO9/PLL6tSpk4YPH67g4GC5urpa7ZuUlKRNmzZp+vTp2rp1qyZNmqTHHnssZ9kDAAAAKBQctvP2ypUrNXjwYH3wwQd65ZVXsr6wi4vat2+v9u3ba8aMGerdu7fKlCmjdu3aOSolAAAAAPkkW8vNPvTQQwoKCrLZZ+jQoerUqVO2iopbDR8+XB07dtTzzz+f43MBAAAAFLxsFRarVq3SuHHjMm3ftm2bzpw5o6eeeirXiTz11FMKDw9XWFhYrmOkunz5smbPnq3u3burWrVqcnd3l6enpwIDA/X4449r5cqV2Z44vm3bNj311FOqWrWq3N3dVaVKFT322GPatGlTtvNJSkrS7Nmzdf/996tMmTLy9vZWnTp19MYbb+jChQvZjnP69Gm98soruvPOO+Xp6aly5copODhY8+bNU3JycrbjhIaGqlu3bqpUqZLc3d0VGBio/v37a8+ePdmOERsbqylTpqhJkyby8/OTr6+vGjVqpHfeeUfR0dHZjgMAAIDiwSEb5B06dEgWi0VVqlTJdYwqVarIMAz99ddfduUycuRIValSRYMHD9a2bdv0yCOP6KOPPtLUqVPVpEkTLVu2TN26dVP79u119epVm7EmTpyoli1b6scff1SPHj00c+ZM9erVS2vWrFFwcLBee+21LPO5fPmyWrRoocGDB+vq1asaPXq0pkyZosDAQL333nuqX7++fvvttyzjrF69WvXr19eMGTPUoEEDffTRRxo+fLjCw8PVv39/PfDAA4qJibEZIzk5WYMGDVLnzp21detWPfPMM/r444/VoUMHff311woKCtLHH3+cZS7Hjx9XkyZNNHr0aDk7O2v8+PGaNGmSPD099dZbb6lhw4Y6ePBglnEAAABQfDhkjsWlS5ckpXyIzq3Uc1Nj5daiRYsUHx+v1q1b68cff5Svr6/ZNmTIEK1atUrdu3fXhg0b1LVrV23evFlOThnrq88++0zjxo2Tu7u7NmzYkO5WsD59+qhly5aaOnWqypUrp5EjR1rNJSkpST169NCOHTvUvHlzrV+/Xh4eHpKkwYMHa8yYMZo8ebIefvhh7dy5U7Vq1bIaZ8+ePerVq5fi4uI0ffp0DR8+3GwbPHiwWrZsqV9++UVPPfWUVq5cmenfZsyYMQoJCZG/v7+2b9+umjVrSpIGDRqkRx55RJ07d9bLL7+sChUqqFevXlZjREVFqXPnzjp69KgeffRRLVmyRM7OzpJSbofr06ePFi9erM6dO2vXrl3y9/fPNB8AAAAUHw4ZsShdurQMw9CKFStyHWP58uWyWCwqVaqU3fm4uLhowYIF6YqKVF26dNGAAQMkpdzmtHTp0gx9Ll26pFGjRklKmf9x6/ySRo0amcXE2LFjzeV1bxUSEqItW7bIYrEoJCTELCpSTZgwQTVr1lRkZKReffXVTJ/P4MGDFRcXp6CgoHRFhZSyDPCsWbMkpdyy9v3331uNcfDgQU2dOlWSNGnSJLOoSPXggw+qT58+MgxDQ4cOVWxsrNU47777ro4ePSpvb2/Nnj3bLCqklL1JZs6cKT8/P50+fVoTJkzI9DkBAACgeHFIYdGgQQNJ0uLFizP9YGvL999/r8WLF0uSGjZsaHc+DRs2VNWqVTNtf/TRR81ja9/wz5gxQ9euXZMkswi51YABA2SxWBQfH68PP/wwQ7thGJo8ebIk6f7771edOnUy9HF1dVW/fv0kpRQF+/bty9Bn/fr12rFjhyRp4MCBVnNp06aNOdrx9ttvW+0zefJkJScny8PDQ71797baJzX+xYsXNWfOnAztMTExmjlzpiSpe/fuKlu2bIY+pUqVUs+ePSWlLD9szygWAAAAig6HFBZBQUG64447lJycrMcff1yDBw/WsWPHsjzv2LFjevHFF/X4449LkmrVqqX77rvPrly++eYbffnllzb7VKtWzTw+c+ZMhvZly5ZJkqpXr57hm/1UlStX1l133WX2v3UyeFhYmM6ePStJat++faa5dOjQwTz+7rvvMrSnfcxWnNS2vXv36vjx4+naEhISzAIqKChIJUuWtBqjWbNm8vb2zjSXVatWKS4uLstcUp/TjRs37BrFAgAAQNHhsH0sZs2apU6dOskwDH3++ef6/PPPFRgYqHvuuUdVqlSRl5eXLBaLrl27prNnz+rPP/9UeHi4pJRv952cnPTJJ5/YnUdwcHCWfSIjI81jLy+vdG3nz5/XkSNHJGU9etKoUSMdOnRI586d07Fjx1S7dm2zbcOGDeaxrTgNGjSQk5OTkpOT051zaxw/P790BZG1XNKek7Yg2rVrl7lSk61cnJycVL9+fW3btk3bt29XXFxcutu3svucbs0ls1EfAAAAFB8OKyw6duyomTNnatiwYZJSioWTJ0+axcOt0n7Db7FY9Mknn+Tb5nhpc2rVqlW6tgMHDpjHWa1ylbb94MGD6QqL7MZxc3NT2bJldfHixQwrKcXFxenkyZO5yiWt3Dyn5ORkHT58OF2RkN04tnIBAABA8eSQW6FSDRkyRKGhoTbnN9wqMDBQ69aty9fN8ZYvXy5Jcnd3N+c4pDp16pR5HBAQYDNO2va05+U2TnR0tCIiIszHz5w5Y+5Pkd+52Irj4uKi0qVLZxrD3d1dPj4+VmMAAACgeHJoYSGljFwcO3ZMS5Ys0aOPPqqKFSvKMIx0PxUrVlTPnj313Xff6ciRI2rbtq2j08jUv//+qx9//FFSyp4XFStWTNeedi8Id3d3m7HS3iZ06x4SjohTmHJJ+3tWMdLGuXbtWpabEUZHR6f7SUhIyDI+AAAACheH3QqVLqiLi3r16mXuhZCYmGh+E1+qVCmVKFEiLy6bLaNGjVJ8fLwaN26st956K0N76uRkSVnmmbb9+vXrDo9TmHJJGyc7r19qn+TkZCUkJNgsRm69rWrcuHEaP358ltcAAABA4ZEnhcWtSpQokeUtOPlh0aJFWrBggcqVK6fvv/9ebm5uGfqk/cY+MTHRZry07Z6eng6PU5hySY0TGxubZYy0cZycnKz+ndM6e/aseeuUpCz7AwAAoPDJl8IiOy5duqS4uLgczc/Iid9++00DBw6Uj4+PQkNDVb16dav90i7FGh8fbzNm2pGAW5dwdUScwpRL6u+xsbFZxkgbx9vbWxaLxWZfHx+fdIUFAAAAih6Hz7HIrWeeeUY1atTIk9g7d+5U165dVaJECf3vf/9TkyZNMu2btuC4ePGizbhp228tVHITx8fHJ93O41WrVpWTk1OB5GIrTlJSkq5evZppjPj4eHN528wKOAAAABQvhaawkJTlJN/c2L17tzp27CjDMPS///1PTZs2tdm/Xr165nHqBneZOXfunHlct27dXMVJSEjQpUuXrMbw8PAwi638yCVtHCcnJ3MDwJzGsZULAAAAiqc8uxXq0qVL+vvvv3Xt2jXdvHkzy/62vgHPrT/++EMdOnRQUlJStooKSapUqZJq166to0ePau/evTb77tmzR1LKLty1atVK15Z2pau9e/fq4Ycfthpj37595pKy1lbHatu2rY4fP67IyEidPn06003yUnOxFuc///mPSpYsqZiYGJvPKTk5Wfv27ZOUsgt32rkZqXHnzJljPqcGDRrkOBcUEfvH5238+nkcHwAA5DuHjlhcvnxZI0aMUJUqVVS+fHk1btxYrVq1UnBwcJY/v//+uyNT0f79+9WhQwclJiZqzZo1at68eYY+EyZM0H/+858Mj6euZnXq1Clzg7pbnT9/XocPH5Yk9ezZM8M8gqZNm6py5cqSpF9++SXTPNevX5/hutZyySpOalvDhg3T7botpUyG7tatmyRpx44dunbtmtUYYWFhZpu1XLp06WIWG9l5Tq6urpkWVAAAACheHFZY/PXXX6pbt66mT5+u8+fPZ9i7IqsfRzpw4IDatWunuLg4hYaGqkWLFlb7hYeHa/fu3RkeHzZsmLy9vSXJ/Ib+Vl9++aUMw5C7u7tGjBiRod1isWjMmDGSpC1btphFSFpJSUmaN2+eJKlz585WRwDat2+voKAgm7n89ttvOnr0qCTpzTfftNrn9ddfl5OTk+Li4vT1119b7ZMaPyAgQAMGDMjQXrJkSQ0dOlSStGLFCl25ciVDn6ioKC1btkySNGjQIJUtW9bqtQAAAFC8OKyw6N27tzlXIFWJEiVUrlw5Va1aVdWqVbP5k51N17Ljr7/+Urt27XT58mWNHDlSycnJ2rRpk9WfCxcuWI1Rrlw5TZ06VZI0bdq0DKMp+/bt05QpUyRJkyZNMkcmbjVw4EC1aNFChmFo4MCB6VZckqTx48fr2LFj8vPz07Rp0zJ9Tp9++qk8PDy0fft2zZo1K11bZGSkhgwZIillRKFnz55WY9SrV0+jRo2SJL311lsZRmLWrl2r+fPnS5JmzpwpLy8vq3HGjBmj2rVrKyYmRi+++KJ5G5eUMkdm6NChioiIULVq1diLAgAA4DZiMRwwXPD7778rKChIFotFZcuW1dixY9W5c+ccrQjUqVMnrV27NlvzMTITHx+vwMDATAuGzGT2J5gwYYImTpwoDw8PDRgwQHXr1tXhw4cVEhKimJgYjRw50ixAMnP58mV16dJFO3bs0N13363+/fvLy8tLoaGhWr16tfz9/bVs2TK1bt3aZpxVq1apd+/eiomJUa9evdS2bVtduXJFISEhOnXqlNq2basVK1ZkWCI2reTkZD3//POaM2eOypQpo+eff17Vq1fX7t27NXfuXCUnJ+uDDz7Q8OHDbeZy/Phxde7cWUePHlVQUJCefPJJWSwWLV26VFu3blVgYKBWrlyZ5cTt6Oho+fr6KioqKt+Wm92+Ymi+XKeoa1ajTN5egDkWAAAUCTn5vOaQwuKzzz7T4MGD5eLiot27d+uee+7JcQxHFBaRkZHplmvNLlt/gm3btunjjz/Wli1bdOnSJfn7+6tZs2YaMmSIgoODsxU/KSlJISEhWrhwoQ4fPqyEhARVrVpV3bp108svv6wKFSpkK86pU6c0ffp0rV69WufOnZOXl5fq1aunvn37qm/fvubStFkJDQ3V7NmztWvXLkVERKh8+fJq3bq1hg8frsaNG2crRmxsrGbNmqUlS5bo+PHjkqQaNWqoZ8+eGjZsWLYKBQqLwovCAgAASAVQWLz33nsaM2aMmjZtqm3btuUqxuLFi3X8+HGNGzfO3nRQRFBYFF4UFgAAQMrZ5zWHLDdbsWLFdP+bG71793ZEKgAAAAAKgEMmb6fOr8jp3AYAAAAAxYNDCos777xTDz30kHbu3KkzZ87kKsbo0aPVrl07R6QDAAAAIJ85bLnZr776StWqVVPPnj2t7m+Qlf3792vTpk2OSgcAAABAPnJYYVG2bFmFhYXpzjvvVO3atfXmm29qy5YtunLlil0rPQEAAAAo/BwyeVuSnJ2dzWPDMPTee+/pvffec1R4AAAAAIWYwwqL1FVrLRaLLBZLuseyK/U8AAAAAEWLwwqLVA7YFgMAAABAEePQwqJr1676+OOPc3Vu3759tXnzZkemAwAAACCfOLSw8PLyUrVq1XJ1roeHhyNTAQAAAJCPHLYqlL3KlSunqlWrFnQaAAAAAHLBYSMWERERKlGiRK7Pnz9/vqNSAQAAAJDPHFZY+Pr6OioUAAAAgCKm0NwKtWPHDv30008FnQYAAACAXHD4crO5NX78eK1du5ZdugEAAIAiqNCMWAAAAAAouhw2YrFgwQK7zj9//ryDMgEAAACQ3xxWWPTr108WiyXX5xuGYdf5AAAAAAqOw+dYGIaRrX4WiyXbfQEAAAAUbg4tLEqVKqV77rnHZp+EhARFREToxIkTSkpKkpOTk5o1ayYXl0IzjxwAAABADjn00/x9992n0NDQbPVNTEzUzz//rLfffluRkZGaN2+emjRp4sh0AAAAAOSTAlsVqkSJEurWrZu2b9+u2rVrq3379tq/f39BpQMAAADADg4rLCZPnqz+/fvn+DxnZ2d9/vnniouLy9X5AAAAAAqew26FGj16dK7P9ff3V8OGDfX7779r69atuv/++x2VFgAAAIB8UGhmTHt5eUmSDhw4QGEBFHf7x+f9NernwzUAAICp0Oy8ffToUUlSZGRkwSYCAAAAIMcKRWExd+5cc+ftgICAAs4GAAAAQE457FaoM2fOZLtvQkKCrl69qiNHjig0NFTff/+92daqVStHpQQAAAAgnzissKhevbosFkuuzjUMQxaLRd27d1eNGjUclRIAAACAfOLwyduGYeTqvPvvv19z5851cDYAAAAA8oNDC4vsFhVOTk7y8vJSxYoV1bhxY/Xq1Uvdu3d3ZCoAAAAA8pFDC4sHH3xQoaGhjgwJAAAAoAgoFKtCAQAAACjaHDZiUb9+fd1xxx2OCgegAG0/eSVP4zerUSZP4wMAgPznsMJi7969jgoFAAAAoIjhVigAAAAAdnP4crNpxcbGaufOnTpx4oQiIiIkSaVKldIdd9yh++67T15eXnl5eQAAAAD5JE8Ki40bN2ratGlas2aNkpOTrfZxdnbWQw89pFdeeUWtW7fOizQAAAAA5BOH3gqVkJCg/v37q3379lq9erVu3rxpdW8LwzCUlJSklStXqm3btnr22WeVkJDgyFQAAAAA5COHjVgkJiaqS5cu2rBhg6T0m+VltnFe6uPz58/XuXPntHr1arm6ujoqJQAAAAD5xGGFxdtvv61ffvlFFotFhmEoKChIDz30kOrVq6cqVaqY8yliY2N19uxZ/fnnn1qzZo127NghwzD0yy+/6O2339aECRMclRIAAACAfGIxMhtOyIHY2FiVK1dO8fHxqlGjhhYsWKBmzZpl69xt27apb9++OnHihDw9PfXvv//K09PT3pRQBERHR8vX11dRUVHy8fHJl2tuXzE0X64D2/JlH4v64/P+GgAAFHM5+bzmkDkW69evV1xcnMqVK6ctW7Zku6iQpObNm2vz5s0qV66c4uLitG7dOkekBAAAACAfOaSwCA8PlyS99NJLCggIyPH55cuX10svvZQuFgAAAICiwyGFRXJysiwWi4KCgnIdo2nTpjIMI9OJ3gAAAAAKL4cUFhUqVJAkWSyWXMdIPbdixYqOSAkAAABAPnJIYdGiRQtJ0t69e3MdY+/evXJ2djZjAQAAACg6HFJYVKlSRQ8++KBmzZql69ev5/j82NhYzZo1S126dFGlSpUckRIAAACAfOSwfSxCQkLUuHFjdezYUd9++222C4Tz58/rySeflCTNmTPHUekAuN3tH5+38VnOFgCAdLJVWJw5cyZbwZYtW6b+/furdu3a6tGjhx544AHdddddKlWqlNzc3CSl7NAdERGhw4cPa926dfrhhx9Up04dff/994qNjVWZMvmwvj0AAAAAh8rWBnlOTk45mphtGEa2+6fta7FYlJSUlO3roGhjg7zbV75skJfXGLEAANwGcvJ5LUe3QmVnKViLxZKuqMjsnLTFRHZjAwAAACicsl1YZPeDv6P7AQAAACj8sr0q1IMPPqjk5OQ8++nYsWNePk8AAAAAecghy80CAAAAuL0VmsJi3bp1BZ0CAAAAgFzK1hyL5OTkvM5D7du3p7gAAAAAiqhCM2KRk+VsAQAAABQuDtt5O7d2796tefPmaevWrQWdCgAAAIBcKpDC4uLFi1q4cKHmz5+vv/76S1LONtUDAAAAULjkW2GRmJioH3/8UfPmzdO6det08+ZNcy8LCgoAAACgaMvzwmLHjh2aP3++lixZosjISElKV1AYhsFmeQAAAEARlyeFxd9//60FCxZo/vz5Onr0qKT0xURqQWGxWNSuXTs9++yz+uKLL/Trr7/mRToAAAAA8pjDCouEhAT98MMPmjdvnjZs2KDk5OQMxYSUUmAEBgaqX79+6tevn6pUqSJJmj9/vqNSAQAAAJDP7C4stm3bpnnz5um7775TdHS0JOu3Orm7uyshIUFt2rTRhg0bMsQpV66cqlatam86AAAAAApArgqLs2fPmrc6nThxQpL1W50kqWXLlnrmmWfUs2dPlSpVSu7u7lZjMmIBAAAAFF3ZLizi4uK0bNkyzZ8/X5s2bUo36TptMWEYhmrXrq2nn35affr0UbVq1fIseQAoMPvH5/016ufDNQAAcJBsFxYBAQGKjY2VZP1WpzJlyujxxx9Xnz59FBQUlDfZAgAAACiUsl1YXLt2Ld1qToZhyNXVVV26dFGfPn3UuXNnubgU+EbeAAAAAApAjiqBtLtj16lTR99++63q1auXJ4kBAAAAKDqcstvx999/15AhQ1S6dGkZhqFDhw6pUaNG6tixoxYtWqTr16/nZZ4AAAAACrFsFxZNmjTRzJkz9c8//+iHH35Q165d5eTkpHXr1qlv374KCAhQ3759tW7dOnbSBgAAAG4z2S4sUrm4uKh79+5asWKF/v77b02fPl0NGzZUbGysFi5cqAcffFBVqlTR6NGjdeDAgbzIGQAAAEAhk+PCIq0yZcpo2LBh2r17t/7880+NGDFC5cuX199//60PPvhADRo0UKNGjTR9+nRdvHjRUTkDAAAAKGTsKizSqlu3rqZOnaqzZ88qNDRUvXr1kpubm/bt26cRI0aoSpUqslgsio2NVXJycobz+/XrpzvuuMNR6QAAAADIRw4rLMyATk568MEH9e233+rChQv67LPP1LRpUyUlJckwDG3ZskVVqlTRmDFjdPToUfO8ixcv6tSpU45OBwAAAEA+cHhhkZaPj48GDRqkrVu36tixY3rzzTdVtWpV/fPPP3r//fd19913q2XLlvrqq69YVQoAAAAowixGASzhtHHjRs2bN08//PCDYmNjzb0xJOnmzZv5nQ4KSHR0tHx9fRUVFSUfH598ueb2FUPz5TqwrVmNMgWdQtFQf3xBZwAAuM3l5PNano5YZCY4OFjz58/XxYsXNXfuXLVu3bog0gAAAADgIAVSWKTy9PRU3759tWHDBj3wwAMFmQoAAAAAOxRoYZEWm+oBAAAARZdLQSeQaurUqbp69WpBpwEAAAAgFwpNYXHPPfcUdAoAAAAAcqnQ3AoFAAAAoOgqNCMWAG4f209eyfNrsKQtAAD5ixELAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHYr9oWFYRiaNWuWvL29ZbFYtGnTphydv23bNj311FOqWrWq3N3dVaVKFT322GM5ipOUlKTZs2fr/vvvV5kyZeTt7a06derojTfe0IULF7Id5/Tp03rllVd05513ytPTU+XKlVNwcLDmzZun5OTkbMcJDQ1Vt27dVKlSJbm7uyswMFD9+/fXnj17sh0jNjZWU6ZMUZMmTeTn5ydfX181atRI77zzjqKjo7MdBwAAAMVDsS4sTpw4oTZt2mjo0KGKjY3N8fkTJ05Uy5Yt9eOPP6pHjx6aOXOmevXqpTVr1ig4OFivvfZaljEuX76sFi1aaPDgwbp69apGjx6tKVOmKDAwUO+9957q16+v3377Lcs4q1evVv369TVjxgw1aNBAH330kYYPH67w8HD1799fDzzwgGJiYmzGSE5O1qBBg9S5c2dt3bpVzzzzjD7++GN16NBBX3/9tYKCgvTxxx9nmcvx48fVpEkTjR49Ws7Ozho/frwmTZokT09PvfXWW2rYsKEOHjyYZRwAAAAUHxbDMIyCTsLRDMPQJ598otdff13Ozs6qU6eOwsLCJEkbN25UmzZtsozx2Wef6cUXX5S7u7s2bdqkoKAgs+2PP/5Qy5YtFRsbq6lTp2rkyJFWYyQlJSk4OFhbtmxR8+bNtX79enl4eJjtY8aM0eTJk+Xn56edO3eqVq1aVuPs2bNHLVq0UFxcnKZPn67hw4ebbREREWrZsqUOHjyoLl26aOXKlZk+p9dff13vv/++/P39tX37dtWsWdNs+/nnn9W5c2cZhqElS5aoV69eVmNERUXpvvvu09GjR/Xoo49qyZIlcnZ2lpTyd+/Tp48WL16satWqadeuXfL39880n+joaPn6+ioqKko+Pj6Z9nOk7SuG5st1UPCKxT4W9ccXdAYAgNtcTj6vFcsRiwkTJmjo0KFq0aKFDhw4oI4dO+bo/EuXLmnUqFGSpOHDh6crKiSpUaNGZjExduxYnTt3zmqckJAQbdmyRRaLRSEhIemKitQ8a9asqcjISL366quZ5jN48GDFxcUpKCgoXVEhSaVKldKsWbMkSatWrdL3339vNcbBgwc1depUSdKkSZPSFRWS9OCDD6pPnz4yDMPmCM+7776ro0ePytvbW7NnzzaLCkmyWCyaOXOm/Pz8dPr0aU2YMCHT5wQAAIDipVgWFoZhaM6cOfr5559VpUqVHJ8/Y8YMXbt2TZI0YMAAq30GDBggi8Wi+Ph4ffjhh1ZzmDx5siTp/vvvV506dTL0cXV1Vb9+/SSlFAX79u3L0Gf9+vXasWOHJGngwIFWc2nTpo052vH2229b7TN58mQlJyfLw8NDvXv3ttonNf7Fixc1Z86cDO0xMTGaOXOmJKl79+4qW7Zshj6lSpVSz549JUmff/65Ll++bPVaAAAAKF6KZWExfvx4Pffcc7k+f9myZZKk6tWrZ/hmP1XlypV11113mf1vvaMsLCxMZ8+elSS1b98+02t16NDBPP7uu+8ytKd9zFac1La9e/fq+PHj6doSEhLMW6SCgoJUsmRJqzGaNWsmb2/vTHNZtWqV4uLisswl9TnduHFDK1asyLQfAAAAio9iWVhYLJZcn3v+/HkdOXJEktSwYUObfRs1aiRJOnfunI4dO5aubcOGDeaxrTgNGjSQk5NThnNujePn56dq1aplmYu1OLt27TJXarKVi5OTk+rXry9J2r59u1lEWItrK46tXAAAAFA8FcvCwh4HDhwwj7O6jSpt+62rIGU3jpubm3lL0a0x4uLidPLkyXzLJW17cnKyDh8+nKs4tnIBAABA8URhcYtTp06ZxwEBATb7pm1Pe15u40RHRysiIsJ8/MyZM+b+FPmdi604Li4uKl26dKYx3N3dzVUDbo0BAACA4smloBMobNLuBeHu7m6zb9pVnm7dQ8KeOKVKlSo0uViLk1WM1DjR0dG6du2aDMOweXvarRvqubm5yc3NLctrAAAAoPBgxOIWaecVlChRwmbftO3Xr193eJzClEvaOFnFSNsnOTlZCQkJNvtWqVJFvr6+5k/qaloAAAAoOhixuEXab+wTExNt9k3b7unp6fA4hSmX1DixsbFZxkgbx8nJKcvRh7Nnz6bbcIXRCgAAgKKHwuIWaZdijY+Pt9k37UjArUu4OiJOYcol9ffY2NgsY6SN4+3tneUqXT4+Pvm28zYAAADyBrdC3aJ69erm8cWLF232Tdue9rzcxvHx8THnV0hS1apVzaVo8zsXW3GSkpJ09erVTGPEx8eb8yZujQEAAIDiicLiFvXq1TOPUze4y8y5c+fM47p16+YqTkJCgi5dumQ1hoeHh2rUqJFvuaSN4+TkZG4AmNM4tnIBAABA8URhcYtKlSqpdu3aklJ2sbZlz549klJ24a5Vq1a6trZt25rHtuLs27fPXFI27Tm3xomMjNTp06ezzMVanP/85z/mbU22cklOTta+ffskpezCnXZuxq1xbcWxlQsAAACKJwoLK3r16iUpZQ+G1A3qbnX+/HlzA7mePXtmmEfQtGlTVa5cWZL0yy+/ZHqt9evXZ7iutVyyipPa1rBhQ9WsWTNdm5ubm7p16yZJ2rFjh65du2Y1RlhYmNlmLZcuXbqYxUZ2npOrq6sefvjhTPsBAACg+KCwsGLYsGHy9vaWJM2ZM8dqny+//FKGYcjd3V0jRozI0G6xWDRmzBhJ0pYtWzLsYi2lzFWYN2+eJKlz585q0KBBhj7t27dXUFCQzVx+++03HT16VJL05ptvWu3z+uuvy8nJSXFxcfr666+t9kmNHxAQoAEDBmRoL1mypIYOHSpJWrFiha5cuZKhT1RUlJYtWyZJGjRokLmrOAAAAIo3CgsrypUrp6lTp0qSpk2bpt9//z1d+759+zRlyhRJ0qRJk8yRiVsNHDhQLVq0kGEYGjhwYLoVlyRp/PjxOnbsmPz8/DRt2rRM8/n000/l4eGh7du3a9asWenaIiMjNWTIEEkpIwo9e/a0GqNevXoaNWqUJOmtt97KMBKzdu1azZ8/X5I0c+ZMeXl5WY0zZswY1a5dWzExMXrxxRfN27gkyTAMDR06VBEREapWrZrGjx+f6XMCAABA8VJsl5tdtGiRebx//37zeN26debk4oCAAHXo0MHq+S+88IIuXryoiRMnKjg4WAMGDFDdunV1+PBhhYSEKDY2ViNHjtTIkSMzzcHFxUXLly9Xly5dtGXLFjVp0kT9+/eXl5eXQkNDtXr1avn7+2vZsmUZ5mik1bhxYy1dulS9e/fWsGHDtHnzZrVt21ZXrlxRSEiITp06pbZt22Y6EpHq3Xff1ZUrVzRnzhzdd999ev7551W9enXt3r1bc+fOlZOTkz766COrt0Gl8vX11erVq9W5c2d99913OnPmjJ588klZLBYtXbpUW7duVWBgoFauXCl/f3+b+QAAAKD4sBiGYRR0Enkhq70TJKl169batGmTzT7btm3Txx9/rC1btujSpUvy9/dXs2bNNGTIEAUHB2crl6SkJIWEhGjhwoU6fPiwEhISVLVqVXXr1k0vv/yyKlSokK04p06d0vTp07V69WqdO3dOXl5eqlevnvr27au+ffuaS9NmJTQ0VLNnz9auXbsUERGh8uXLq3Xr1ho+fLgaN26crRixsbGaNWuWlixZouPHj0uSatSooZ49e2rYsGHZ2pciOjpavr6+ioqKyrd9LLavGJov10HBa1ajTEGnYL/64ws6AwDAbS4nn9eKbWGBwo/CAnmJwgIAAPvl5PNasb0VCsDtbfvJjIsLOFKxKFwAAHAgJm8DAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsJtLQScAAEXR9pNX8vwazern+SUAAHAYRiwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdWG4WAAqpaeuO5mn8VzrUztP4AIDbCyMWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOzGztsAcJvK6529JXb3BoDbCSMWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOxGYQEAAADAbhQWAAAAAOzmUtAJAACKr2nrjuZp/Fc61M7T+ACA7GPEAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2M2loBMAACC3pq07mufXeKVD7Ty/BgAUB4xYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu1FYAAAAALAbhQUAAAAAu7kUdAIAABRm09YdzdP4r3SonafxASC/MGIBAAAAwG4UFgAAAADsRmEBAAAAwG4UFgAAAADsRmEBAAAAwG4UFgAAAADsRmEBAAAAwG4UFgAAAADsRmEBAAAAwG4UFgAAAADsRmEBAAAAwG4uBZ0AAAC3s2nrjub5NV7pUDvPrwEAjFgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVgAAAAAsBuFBQAAAAC7UVjALpcvX9bYsWNVr149eXt7q3Tp0mrWrJk+/vhjJSYmFnR6AAAAyCfsY4Fc27lzp7p3765//vlHHTp00Isvvqi4uDjNnz9fw4cP17x587Rq1SpVrFixoFMFgNtaXu+VwT4ZACQKC+TSmTNn1KVLF126dEkvv/yypk2bZrYNHTpUnTp10saNG9WtWzdt3bpVbm5uBZgtAAAA8hq3QiFXRo0apUuXLqlq1ap677330rW5ubkpJCREzs7O2r17t2bNmlVAWQIAACC/UFggx44dO6bvvvtOkvTMM89YHY244447FBwcLEl6//33lZSUlK85AgAAIH9RWCDHli1bJsMwJEnt27fPtF+HDh0kSZcuXdKmTZvyIzUAAAAUEOZYIMc2bNhgHjds2DDTfo0aNUp3jq0iBHkn8cZNLfh+l5559D8q4epc0OkgjyQlJmr9t5+r/RPPy6VEiYJOB3moML7WeT05XLr9JognJCRo8uTJeuONN5inWMwVp9eaEQvk2IEDByRJJUuWlK+vb6b9qlSpYh4fPHgwz/OCdTdu3NRXS37XjRs3CzoV5KGkG4lau2iWkm6wzHNxx2t9e0hISNCECROUkJBQ0KkgjxWn15rCAjmSkJCgCxcuSJICAgJs9k3bfurUqbxMCwAAAAWMW6GQIzExMeaxu7u7zb4eHh5WzwMAIKfYiwMo/CgskCNxcXHmcYks7u1N2379+vUM7akTwM+fP6/o6GjzcTc3tzy7xzD2+u1360Dqc74dn3tRF69r2e97/Vq6/0XxxWudNyav2FPQKaST+vp+uGqv3D29Czib/zOkbc2CTqHYSf0MlPazUGGSmlfq5zZbLEZ2egH/3+XLl1W2bFlJUr169fTnn39m2jc+Pt4ctQgMDNTJkyfTtZ87dy7dPAwAAAAUTmfPnlXlypVt9mHEAjlSsmRJ8zg+Pt5m37SjG2nPS1WxYkWdOHFCrq6uslgs5uN5OWIBAACA7DMMQzExMapYsWKWfSkskCNubm4qX768Lly4oIsXL9rsm7a9evXqGdqdnJxUo0YNR6cIAAAAB7K1CmharAqFHKtXr56klAnZUVFRmfY7d+6ceVy3bt08zwsAAAAFh8ICOda2bVvzeO/evZn227Pn/ybCpT0HAAAAxQ+FBXKsZ8+e5pyIX375JdN+69evlyT5+/urTZs2+ZHaba9NmzayWCxZ/nh7F54VRmCbYRiaNWuWvL29ZbFYtGnTphydv23bNj311FOqWrWq3N3dVaVKFT322GM5joO8lZvX+dSpU9l6v1ssFr300kt5/yRg0+XLlzV79mx1795d1apVk7u7uzw9PRUYGKjHH39cK1euzNaqOxLv68LM3te5qL+vKSyQY7Vq1VKvXr0kSQsXLlRiYsZlTE+ePKkNGzZIkkaPHi0XF6bzADl14sQJtWnTRkOHDlVsbGyOz584caJatmypH3/8UT169NDMmTPVq1cvrVmzRsHBwXrttdfyIGvklL2vMwq/kSNHqkqVKho8eLC2bdumRx55RB999JGmTp2qJk2aaNmyZerWrZvat2+vq1ev2ozF+7rwcuTrXGQZQC6cPn3aKFu2rCHJGDFiRLq2+Ph4o127doYko0mTJkZcXFwBZXn7ad26tXHvvfcahw4dsvlz5MiRgk4VNiQnJxszZ840vLy8DB8fH6Np06aGJEOSsXHjxmzFmD17tiHJcHd3N8LCwtK17dmzx/Dy8jIkGVOnTs2DZ4DssPd1Dg8PNyQZ7777bpbv+QsXLuT9E0KmAgICDElG69atjcjIyAztK1euNJydnQ1JRvPmzY2bN29ajcP7unBzxOtc1N/XFBbItbCwMKNChQqGJKNjx47GJ598YnzwwQfGPffcY0gyGjZsaJw/f76g07yttG7d2mjdunVBpwE7jRs3znxfnTlzxvw9ux84//33X8Pb29uQZIwePdrmNdzd3Y2zZ886+BkgO+x9nVM/gMydOzfPc4V9AgICDBcXF+P06dOZ9nn++efN1/+bb77J0M77uvBzxOtc1N/X3AqFXAsKCtL+/fv15ptv6uzZs3rttdf09ttvy8PDQ9OnT9eOHTuyteYxgPQMw9CcOXP0888/52oTyRkzZujatZRdewcMGGC1z4ABA2SxWBQfH68PP/zQrnyRO/a+zihaGjZsqKpVq2ba/uijj5rHK1euzNDO+7posPd1Luq48R128ff319tvv6233367oFMBio3x48en2zQyp5YtWyYpZf+YmjVrWu1TuXJl3XXXXTp06JCWLVumjz76yK5rIufsfZ1RdHzzzTcqU6aMzT7VqlUzj8+cOZOhnfd14eeI17moY8QCKOZiYmKUnJxc0GkgB+z5IHD+/HkdOXJEUso3Z7Y0atRIUsqeM8eOHcv1NZE7efGBLykpiQnghVBwcLDq169vs09kZKR57OXlla6N93XRYO/rnJmi9L6msACKmevXr2vixImqX7++vLy85OPjI1dXV9WpU0ejRo3S33//XdApIg8dOHDAPM7q9pq07QcPHsyznJC3Dh48mG7pUW9vb3l5ealdu3aaO3eukpKSCjpFZEN4eLh53KpVq3RtvK+LD1uvc1pF9X1NYQEUM7///rsmT56sli1bau7cuVq1apWmTJmimzdv6oMPPtBdd92ln376qaDTRB45deqUeRwQEGCzb9r2tOehaPnggw+0e/duvfTSS1q+fLm+++47Pffcc9q2bZueffZZtWzZUv/8809Bp4ksLF++XJLk7u6ufv36pWvjfV182Hqd0yqq72vmWADFTLly5bRx40bVqVPHfKxz58566aWX1LVrV61bt069evXSxo0b1bx58wLMFHkhJibGPHZ3d7fZ18PDw+p5KFoeffRRLV68WG5ubuZjPXv2VP/+/dWmTRuFhYWpa9eu2rp1a7o+KDz+/fdf/fjjj5JS9kK4deET3tfFQ1avc1pF9X3NiAVQjHz77bc6fPhwuqIilZubm+bNmyc3NzclJiYWyh07Yb+4uDjzuESJEjb7pm2/fv16nuWEvFG5cmWFh4frm2++sfrBolGjRvrvf/8rSdq9e7c+++yz/E4R2TRq1CjFx8ercePGeuuttzK0874uHrJ6naWi/76msACKkfLly6tUqVKZtlesWFEPPvigJOmPP/7QH3/8kV+pIZ+k/bYyMTHRZt+07Z6ennmWE/KGi4uLqlevLldX10z79O/f35wk/tVXX+VXasiBRYsWacGCBSpXrpy+//57qx8meV8Xfdl5naWi/76msABuM//5z3/M423bthVgJsgLJUuWNI/j4+Nt9k37LWja81B8lC5dWjVq1JAk/fnnn+Y+CCgcfvvtNw0cOFA+Pj4KDQ1V9erVrfbjfV20Zfd1zq7C/L6msABuM+XKlTOPL1y4UICZIC+k/Q/WxYsXbfZN227vf+hQeKW+5w3DyPL/E8g/O3fuVNeuXVWiRAn973//U5MmTTLty/u66MrJ65wThfV9zeRt4DaTdk8LZ2fnAswEeaFevXrm8dmzZ232PXfunHlct27dPMsJBYv3fOGze/dudezYUYZhaO3atWratKnN/ryvi6acvs45UVjf14xYAMXEypUr9fbbb8swDJv90o5SVKhQIa/TQj6rVKmSateuLUnau3evzb579uyRlDJZsFatWnmdGhzs7bffNleYsSX1Pe/k5JRuxBIF448//lCHDh2UlJSkn3/+OVsfNnlfFz25eZ2lov++prAAionvv/9eY8eOzXJINCwszDxu0aJFXqeFAtCrVy9JKWvYnzx50mqf8+fP6/Dhw5JSljDMi12gkbfGjh2r2bNn2+zzzz//6PTp05Kkxo0bM5m3gO3fv18dOnRQYmKi1qxZY3XJ7wkTJqSbC5eK93XRYc/rXNTf1xQWQDGzZs2aTNuOHTum9evXS5KaN2/OMHkxNWzYMHl7e0uS5syZY7XPl19+KcMw5O7urhEjRuRnenCgbdu2KTo6OtP2tEtRDho0KD9SQiYOHDigdu3aKS4uTqGhoZl+sRMeHq7du3dneJz3ddFg7+ssFe33NXMsgGLmjTfe0P33328Om6e6evWqnnzySd28eVOenp6aNWtWAWWIvFauXDlNnTpVL774oqZNm6YePXro3nvvNdv37dunKVOmSJImTZqkypUrF1SqsFNMTIwGDRqkBQsWZNjfYO3atXr//fclSa1atVL//v0LIkVI+uuvv9SuXTtdvnxZ//3vf5WcnKxNmzZZ7ZvZohq8rws/R7zOUtF+X1uMrG7IBlAkTJkyRW+99ZZu3LghDw8PPfHEE7r33ntVokQJHTp0SAsWLNClS5cUEBCgJUuWqHXr1gWdMmxYtGiRefzDDz9o+fLlkqQxY8bo7rvvliQFBASoQ4cOmcaYMGGCJk6cKA8PDw0YMEB169bV4cOHFRISopiYGI0cOVJTp07N2ycCm+x5nRs2bKh9+/ZJkmrWrKknnnhCNWrUUGxsrDZt2qQffvhBhmGoU6dOWrx4sc09bpB34uPjFRgYmONV+DL7eMb7unBy1Otc1N/XFBZAMXLhwgX98MMPWrdunf7880/9888/unHjhkqVKqV77rlHXbp00XPPPcfa5kVAdu6Nbt26dabfhqXatm2bPv74Y23ZskWXLl2Sv7+/mjVrpiFDhig4ONhB2SK37H2dd+zYoRUrVmjr1q06cuSIIiIi5OrqqvLly6tZs2bq06ePOnbs6OCskRORkZG5+vBn6+MZ7+vCx5Gvc1F+X1NYAAAAALAbk7cBAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAAIDdKCwAAAAA2I3CAgAAG7p37y6LxZLhZ968eQWdGgAUKhQWAIAio27durJYLHJyclJERES6tmPHjpkf+ps3b+6wazZu3FgdO3ZUx44dVapUKYfFTeurr75SmTJl1LhxY506dSpPrgEAec2loBMAACA7oqKidPjwYUlS7dq1M3zIDwsLM4+bNWvmsOv+97//NY/btGmjX3/91WGxJen69et68cUXlZiYqKtXr+q///2vFixY4NBrAEB+YMQCAFAk7NixQ8nJyZKkpk2bZmjPq8IirxmGIcMwzN9v3rxps3+bNm24HQtAoURhAQAoEtIWDkFBQTbbrRUehZWXl5dmzpypUqVK6Z577tG4ceMKOiUAyBUKCwBAkbB9+3bz+NbCIS4uTvv375ckValSRZUrV87X3Oz1/PPP6+rVq9q/f79q165d0OkAQK5QWAAACj3DMLRz505Jkqenp+6555507bt27VJSUpKkonUbFAAUJxQWAIBC78iRI7p69aokqUmTJnJxSb/2SFGdXwEAxQmrQgEACr2s5lfs2LHDPC6I+RXR0dFav369Tp48KScnJ91xxx0KDg6Wj49PvueSlfDwcO3cuVPnz59XXFyc/Pz8VLt2bTVp0kSlS5cu6PQAFGUGAACFxLhx4wxJDv+ZO3euQ/Jr3bp1hpjvv/++4ePjk+GaPj4+xieffJJprI0bN1rNtVq1anb/XTZu3Jghxo4dO4wWLVpkeo6Tk5PRtGlTY/r06cbly5cd8vcCcHthxAIAgFx6+eWXNWPGDNWoUUNt2rRRYmKiduzYoYiICEVHR2vIkCFyd3fXs88+m+Hc0qVLq2PHjpKkq1ev6vfff8/0OjVr1jT77ty509wcsF69eqpUqZLV2GmtXLlSjz76qG7cuKGAgAANHDhQjRo1UunSpXX27Flt3LhRCxYsUFhYmMLCwvTHH3+wlC2AHKOwAAAUGv7+/rrzzjvTPZaYmKjw8HBJkoeHh6pWrZqu/erVq7p06ZIkKSAgQH5+fhni+vr6OjzX9evX64cfftCSJUv02GOPmY9fv35dffv21bJlyyRJr7/+uvr06SNXV9d059evX18///yzJGnTpk0KDg7O9FpPP/20nn76aUnpN+kbMWKE+vXrZzPPmJgYPfvss7px44bKly+vXbt2ZShG+vTpoxdffFFt27bVtWvXsvcHAIBbMHkbAFBovPTSSzp8+HC6nw8//NBs79OnT4b2rl27mu1ff/11hvbDhw+rR48eDs918eLFmjFjRrqiQkpZterzzz+Xu7u7JOnSpUvatGmTw6+fXT///LMuX74sSeratavVEQ5JuvfeezVs2LD8TA1AMUNhAQAo1NatW2cep94OlNYvv/wiKWU04/7778+3vCpWrKjnnnvOalvp0qXTTSLfs2dPfqWVwYkTJ8xjZ2dnm33btm2rgICAPBnhAVD8UVgAAAq11MLC2dlZ7dq1S9d29OhRnT59WpLUqlUrubm55VteHTt2lJNT5v8ZrVWrlnn8999/50dKVnl6eprH3333nc6ePZtp33bt2unChQuaMWNGfqQGoJihsAAAFFqnTp3S8ePHJaUsM3vrN+nr1683jzt06JCvud19990229NOoC7IeQsdOnSQxWKRJF25ckWNGzfWlClTzNujAMBRKCwAAIVW2tugHnjggQztBVlYWJsknlbqHAtJunnzZh5nk7m7775br7/+uvn75cuXNXr0aFWoUEEPPPCAZs2aZY76AIA9KCwAAAVu3rx5slgsGX4GDRpk9hk/fnyG9uXLl5vtDRo0yNCel0um3rrKU2H27rvv6quvvlKFChXMx5KSkrRu3ToNHTpU1atXV7NmzbRw4cICLYIAFG0UFgAA3Ab69++v8PBwLVmyRD169Eg3oiKl7G7+zDPPKCgoSGfOnCmgLAEUZexjAQAocL6+vhn2r4iPjzdv0fH29s6wTOqVK1fMeQLly5e3upIRqxul5+bmpscee0yPPfaYrl27ppUrV2rBggX63//+J8MwJEm7d+/WAw88oH379uXrZHgARR8jFgCAAtejR48Me09MnjzZbB84cGCG9k6dOpntS5Ysybf9K4oLb29vPfnkk1qzZo0OHjyYbqneI0eOaMmSJQWYHYCiiMICAFAo/fbbb+Zxq1atMrSn7j7t5uamoKCgfMurqDl37pzCwsLM3cmtufvuu7V69WoFBASYj+3cuTM/0gNQjFBYAAAKpdTCwmKxqGXLlunaTp48ac4DCAoKuq1u2XFx+b+7mJOTk9O1Xb9+XT///LN+/vlnxcfHS5LmzJmjZs2aafHixTbj+vr6phu1SF2iFgCyi8ICAFDoXL58WYcOHZIk1atXT2XKlEnXnjpaIUmtW7fO19wKWqlSpczjW/fHOHjwoDp16qROnTrp+vXr6drS/s0yExERYR7Xq1fPzkwB3G4oLAAAhc7mzZvNycTWboPatGmTeWytvTi75557zOPU4itV6ihPhQoV0m3QJ0k//vhjuuV5b7Vp0ybzfH9/f/Xq1ctRKQO4TbAqFACg0Ek7v8LaiETqt++urq5q1qxZnuayaNEiLVq0SJK0f/9+8/EPP/xQ3377rSRp/vz5CggI0MWLF9W3b19JMncMl1I2+nvwwQclSU8//bSefvpp7d+/X6+99pok6erVq2bfixcvmn3r16+vKVOmpMvnySef1Ntvv60bN25owYIFuvPOO1W/fn3t379fEyZMkCQ999xzZv/UW5oMw9Cjjz6qRx55RF27dlX16tV18+ZNnTt3TqGhofr+++918+ZNeXp66uuvv85QmABAlgwAAAqZxo0bG5IMScaFCxfStYWHh5ttTZs2zfNcxo0bZ14vs5/w8PAMuWX2M27cOMMwDGPjxo1Z9m3durXVnObNm2d4enpaPeepp54yEhISzL7Xr1835s2bZ7Rr185wdXXN9FrOzs5G165djUOHDuXxXxRAcWUxjP8/1gwAAIqMiIgI/fLLLwoPD9eNGzdUrlw5tWrVSrVr1870nJiYGO3du1dHjx7VlStXdOPGDZUsWVJ33HGHgoKC5O/vn4/PAEBxQ2EBAAAAwG5M3gYAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHajsAAAAABgNwoLAAAAAHb7fxhuLTNtjSPkAAAAAElFTkSuQmCC", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "ax.hist(\n", + " particles[\"nhits_velo\"],\n", + " bins=np.arange(3, 27) - 0.5,\n", + " label=\"Actual\",\n", + " alpha=0.5,\n", + ")\n", + "\n", + "ax.bar(\n", + " x=np.arange(3, nhits_max),\n", + " height=norm * factor,\n", + " width=1.0,\n", + " color=\"orange\",\n", + " label=\"Normalised\",\n", + " alpha=0.5,\n", + ")\n", + "\n", + "ax.set_xlabel(\"# hits\")\n", + "ax.set_ylabel(\"Abundance\")\n", + "ax.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analyses/visualisation.ipynb b/LHCb_Pipeline/analyses/visualisation.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..d379cac1a87fd7ced74ddf198baccd03f31e60be --- /dev/null +++ b/LHCb_Pipeline/analyses/visualisation.ipynb @@ -0,0 +1,245 @@ +{ + "cells": [ + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# A notebook to visualise the tracks" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import anaconfig\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import os.path as op\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "import pandas as pd\n", + "\n", + "from Preprocessing.preprocessing import load_dataframes\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "from utils.plotutils.plotools import save_fig\n", + "configure_matplotlib()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles, particles = load_dataframes(\n", + " indir=\"/scratch/acorreia/minbias-sim10b-xdigi-nospillover/92\",\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "event_ids = hits_particles[\"event\"].unique()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "event_idx = 15\n", + "\n", + "event_hits_particles = hits_particles[hits_particles[\"event\"] == event_ids[event_idx]]\n", + "particles = particles[particles[\"event\"] == event_ids[event_idx]]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_event(hits_particles: pd.DataFrame, show_tracks: bool = False):\n", + " fig, ax = plt.subplots(figsize=(30, 6))\n", + "\n", + " df_hits = hits_particles.drop_duplicates([\"hit_id\"])\n", + " \n", + " ax.axhline(y=0, color='k')\n", + " ax.scatter(\n", + " x=df_hits[\"z\"],\n", + " y=df_hits[\"x\"],\n", + " color=\"grey\",\n", + " s=2,\n", + " )\n", + " ax.set_xlabel(\"$z$ (cm)\")\n", + " ax.set_ylabel(\"$x$ (cm)\")\n", + " ax.set_ylim(-50.0, 50.0)\n", + " ax.set_xlim(-290.0, 760.0)\n", + " ax.grid(color=\"grey\", alpha=0.5)\n", + " ax.set_aspect(1)\n", + "\n", + " if show_tracks:\n", + " for (_, hits_particle) in hits_particles.groupby(by=[\"event\", \"particle_id\"]):\n", + " hit_coordinates = hits_particle.sort_values(by=\"z\")\n", + " ax.plot(\n", + " hit_coordinates[\"z\"],\n", + " hit_coordinates[\"x\"],\n", + " linestyle=\"-\",\n", + " linewidth=1.0,\n", + " marker=None,\n", + " )\n", + " return fig, ax" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plot_event(hits_particles=event_hits_particles)\n", + "save_fig(fig, op.join(anaconfig.PLOTDIR, \"hits_xz\"), dpi=300, exts=[\".svg\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "fig, ax = plot_event(hits_particles=event_hits_particles, show_tracks=True)\n", + "save_fig(fig, op.join(anaconfig.PLOTDIR, \"hits_tracks_xz\"), dpi=300, exts=[\".svg\"])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles[\"z\"].min()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "def plot_xy_graph(\n", + " df_hits_particles: pd.DataFrame,\n", + " n_tracks: int,\n", + " n_events: int = 10,\n", + " seed: int | None = None,\n", + "):\n", + " fig1, ax1 = plt.subplots(figsize=(12, 12))\n", + " fig2, ax2 = plt.subplots(figsize=(12, 5))\n", + " axes = [ax1, ax2]\n", + "\n", + " for ax in axes:\n", + " ax.axhline(y=0.0, color=\"k\", linewidth=0.5)\n", + " ax.axvline(x=0.0, color=\"k\", linewidth=0.5)\n", + "\n", + " event_ids = df_hits_particles[\"event\"].unique()\n", + "\n", + " rng = np.random.default_rng(seed=seed)\n", + " rng.shuffle(event_ids)\n", + "\n", + " for idx, (_, hits_particle) in enumerate(\n", + " df_hits_particles[\n", + " df_hits_particles[\"event\"].isin(event_ids[:n_events])\n", + " ].groupby(\n", + " by=[\"event\", \"particle_id\"]\n", + " )\n", + " ):\n", + " hit_coordinates = hits_particle.sort_values(by=\"plane\")\n", + " ax1.plot(\n", + " hit_coordinates[\"x\"],\n", + " hit_coordinates[\"y\"],\n", + " linestyle=\"-\",\n", + " markersize=5.0,\n", + " marker=\"o\",\n", + " )\n", + " ax2.plot(\n", + " hit_coordinates[\"z\"],\n", + " hit_coordinates[\"x\"],\n", + " linestyle=\"-\",\n", + " markersize=5.0,\n", + " marker=\"o\",\n", + " )\n", + " if idx > n_tracks:\n", + " break\n", + "\n", + " for ax in axes:\n", + " ax.set_ylim(-50.0, 50.0)\n", + " ax.grid(color=\"grey\", alpha=0.5)\n", + " \n", + " ax1.set_xlim(-50.0, 50.0)\n", + " ax2.set_xlim(-570, 470)\n", + " return fig1, ax1, fig2, ax2\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "plot_xy_graph(\n", + " df_hits_particles=hits_particles,\n", + " n_tracks=10,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/LHCb_Pipeline/analysis.ipynb b/LHCb_Pipeline/analysis.ipynb index cc0fe9e76fc910f37ad37da63ebfd4e51cd8d451..5adeae21cf3708adf740f6f1d831dc560e09c19f 100644 --- a/LHCb_Pipeline/analysis.ipynb +++ b/LHCb_Pipeline/analysis.ipynb @@ -40,6 +40,32 @@ ")\n" ] }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.03448266360631707" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(\n", + " (df_particles[\"has_velo\"]) & (df_particles[\"has_scifi\"]) & (df_particles[\"eta\"] > 2)\n", + " & (df_particles[\"eta\"] < 5.0) & (df_particles[\"pid\"].abs() == 11) \n", + ").sum() / (\n", + " (df_particles[\"has_velo\"]) & (df_particles[\"eta\"] > 2)\n", + " & (df_particles[\"eta\"] < 5.0)\n", + ").sum()\n" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -50,7 +76,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -65,7 +91,7 @@ " **kwargs,\n", " )\n", " ax.set_xlabel(\"# hits in the velo\")\n", - " ax.set_ylabel(\"Origin vertex coordinate z-position\")\n", + " ax.set_ylabel(\"$v_z$\")\n", " fig.colorbar(im, ax=ax)\n", "\n", " return fig, ax\n" @@ -73,12 +99,12 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 11, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "<Figure size 800x600 with 2 Axes>" ] @@ -88,6 +114,9 @@ } ], "source": [ + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "configure_matplotlib()\n", + "\n", "fig, _ = compare_nhits_vz(\n", " df_particles=df_particles[\n", " (df_particles[\"has_velo\"] == 1)\n", @@ -95,8 +124,8 @@ " & (df_particles[\"pid\"].abs() == 11)\n", " ]\n", ")\n", - "\n", - "fig.savefig(\"nhits_velo_vs_vz_long_electrons.pdf\")\n" + "fig.tight_layout()\n", + "fig.savefig(\"nhits_velo_vs_vz_long_electrons.png\", dpi=300, transparent=True)\n" ] }, { @@ -161,6 +190,7 @@ } ], "source": [ + "\n", "fig, _ = compare_nhits_vz(\n", " df_particles=df_particles[\n", " (df_particles[\"has_velo\"] == 1)\n", diff --git a/LHCb_Pipeline/full_pipeline-focal-loss-pid-fixed.ipynb b/LHCb_Pipeline/full_pipeline-focal-loss-pid-fixed.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b10c97baf089dfc18fc58a1033e24d1c678e67bf --- /dev/null +++ b/LHCb_Pipeline/full_pipeline-focal-loss-pid-fixed.ipynb @@ -0,0 +1,1714 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 0. Setup" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Imports" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div class=\"bk-root\">\n", + " <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n", + " <span id=\"1002\">Loading BokehJS ...</span>\n", + " </div>\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + "\n", + " if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n", + " root._bokeh_onload_callbacks = [];\n", + " root._bokeh_is_loading = undefined;\n", + " }\n", + "\n", + "const JS_MIME_TYPE = 'application/javascript';\n", + " const HTML_MIME_TYPE = 'text/html';\n", + " const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n", + " const CLASS_NAME = 'output_bokeh rendered_html';\n", + "\n", + " /**\n", + " * Render data to the DOM node\n", + " */\n", + " function render(props, node) {\n", + " const script = document.createElement(\"script\");\n", + " node.appendChild(script);\n", + " }\n", + "\n", + " /**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + " function handleClearOutput(event, handle) {\n", + " const cell = handle.cell;\n", + "\n", + " const id = cell.output_area._bokeh_element_id;\n", + " const server_id = cell.output_area._bokeh_server_id;\n", + " // Clean up Bokeh references\n", + " if (id != null && id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + "\n", + " if (server_id !== undefined) {\n", + " // Clean up Bokeh references\n", + " const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n", + " cell.notebook.kernel.execute(cmd_clean, {\n", + " iopub: {\n", + " output: function(msg) {\n", + " const id = msg.content.text.trim();\n", + " if (id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + " }\n", + " }\n", + " });\n", + " // Destroy server and session\n", + " const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n", + " cell.notebook.kernel.execute(cmd_destroy);\n", + " }\n", + " }\n", + "\n", + " /**\n", + " * Handle when a new output is added\n", + " */\n", + " function handleAddOutput(event, handle) {\n", + " const output_area = handle.output_area;\n", + " const output = handle.output;\n", + "\n", + " // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n", + " if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + "\n", + " const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + "\n", + " if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n", + " toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n", + " // store reference to embed id on output_area\n", + " output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " }\n", + " if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " const bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " const script_attrs = bk_div.children[0].attributes;\n", + " for (let i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + " }\n", + "\n", + " function register_renderer(events, OutputArea) {\n", + "\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " const toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[toinsert.length - 1]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " /* Handle when an output is cleared or removed */\n", + " events.on('clear_output.CodeCell', handleClearOutput);\n", + " events.on('delete.Cell', handleClearOutput);\n", + "\n", + " /* Handle when a new output is added */\n", + " events.on('output_added.OutputArea', handleAddOutput);\n", + "\n", + " /**\n", + " * Register the mime type and append_mime function with output_area\n", + " */\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " /* Is output safe? */\n", + " safe: true,\n", + " /* Index of renderer in `output_area.display_order` */\n", + " index: 0\n", + " });\n", + " }\n", + "\n", + " // register the mime type if in Jupyter Notebook environment and previously unregistered\n", + " if (root.Jupyter !== undefined) {\n", + " const events = require('base/js/events');\n", + " const OutputArea = require('notebook/js/outputarea').OutputArea;\n", + "\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " }\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " const NB_LOAD_WARNING = {'data': {'text/html':\n", + " \"<div style='background-color: #fdd'>\\n\"+\n", + " \"<p>\\n\"+\n", + " \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n", + " \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n", + " \"</p>\\n\"+\n", + " \"<ul>\\n\"+\n", + " \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n", + " \"<li>use INLINE resources instead, as so:</li>\\n\"+\n", + " \"</ul>\\n\"+\n", + " \"<code>\\n\"+\n", + " \"from bokeh.resources import INLINE\\n\"+\n", + " \"output_notebook(resources=INLINE)\\n\"+\n", + " \"</code>\\n\"+\n", + " \"</div>\"}};\n", + "\n", + " function display_loaded() {\n", + " const el = document.getElementById(\"1002\");\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS is loading...\";\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(display_loaded, 100)\n", + " }\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls == null || js_urls.length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length;\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + "\n", + " function on_error(url) {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error.bind(null, url);\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error.bind(null, url);\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n", + " const css_urls = [];\n", + "\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {\n", + " }\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if (root.Bokeh !== undefined || force === true) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " }\n", + "if (force === true) {\n", + " display_loaded();\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " } else if (force !== true) {\n", + " const cell = $(document.getElementById(\"1002\")).parents('.cell').data().cell;\n", + " cell.output_area.append_execute_result(NB_LOAD_WARNING)\n", + " }\n", + " }\n", + "\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n", + " run_inline_js();\n", + " } else {\n", + " load_libs(css_urls, js_urls, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + "}(window));" + ], + "application/vnd.bokehjs_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n const NB_LOAD_WARNING = {'data': {'text/html':\n \"<div style='background-color: #fdd'>\\n\"+\n \"<p>\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"</p>\\n\"+\n \"<ul>\\n\"+\n \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n \"<li>use INLINE resources instead, as so:</li>\\n\"+\n \"</ul>\\n\"+\n \"<code>\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"</code>\\n\"+\n \"</div>\"}};\n\n function display_loaded() {\n const el = document.getElementById(\"1002\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error(url) {\n console.error(\"failed to load \" + url);\n }\n\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n const css_urls = [];\n\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {\n }\n ];\n\n function run_inline_js() {\n if (root.Bokeh !== undefined || force === true) {\n for (let i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\nif (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n const cell = $(document.getElementById(\"1002\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "<div class=\"bk-root\">\n", + " <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n", + " <span id=\"1003\">Loading BokehJS ...</span>\n", + " </div>\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": [ + "(function(root) {\n", + " function now() {\n", + " return new Date();\n", + " }\n", + "\n", + " const force = true;\n", + "\n", + " if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n", + " root._bokeh_onload_callbacks = [];\n", + " root._bokeh_is_loading = undefined;\n", + " }\n", + "\n", + "const JS_MIME_TYPE = 'application/javascript';\n", + " const HTML_MIME_TYPE = 'text/html';\n", + " const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n", + " const CLASS_NAME = 'output_bokeh rendered_html';\n", + "\n", + " /**\n", + " * Render data to the DOM node\n", + " */\n", + " function render(props, node) {\n", + " const script = document.createElement(\"script\");\n", + " node.appendChild(script);\n", + " }\n", + "\n", + " /**\n", + " * Handle when an output is cleared or removed\n", + " */\n", + " function handleClearOutput(event, handle) {\n", + " const cell = handle.cell;\n", + "\n", + " const id = cell.output_area._bokeh_element_id;\n", + " const server_id = cell.output_area._bokeh_server_id;\n", + " // Clean up Bokeh references\n", + " if (id != null && id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + "\n", + " if (server_id !== undefined) {\n", + " // Clean up Bokeh references\n", + " const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n", + " cell.notebook.kernel.execute(cmd_clean, {\n", + " iopub: {\n", + " output: function(msg) {\n", + " const id = msg.content.text.trim();\n", + " if (id in Bokeh.index) {\n", + " Bokeh.index[id].model.document.clear();\n", + " delete Bokeh.index[id];\n", + " }\n", + " }\n", + " }\n", + " });\n", + " // Destroy server and session\n", + " const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n", + " cell.notebook.kernel.execute(cmd_destroy);\n", + " }\n", + " }\n", + "\n", + " /**\n", + " * Handle when a new output is added\n", + " */\n", + " function handleAddOutput(event, handle) {\n", + " const output_area = handle.output_area;\n", + " const output = handle.output;\n", + "\n", + " // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n", + " if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n", + " return\n", + " }\n", + "\n", + " const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n", + "\n", + " if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n", + " toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n", + " // store reference to embed id on output_area\n", + " output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n", + " }\n", + " if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n", + " const bk_div = document.createElement(\"div\");\n", + " bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n", + " const script_attrs = bk_div.children[0].attributes;\n", + " for (let i = 0; i < script_attrs.length; i++) {\n", + " toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n", + " toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n", + " }\n", + " // store reference to server id on output_area\n", + " output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n", + " }\n", + " }\n", + "\n", + " function register_renderer(events, OutputArea) {\n", + "\n", + " function append_mime(data, metadata, element) {\n", + " // create a DOM node to render to\n", + " const toinsert = this.create_output_subarea(\n", + " metadata,\n", + " CLASS_NAME,\n", + " EXEC_MIME_TYPE\n", + " );\n", + " this.keyboard_manager.register_events(toinsert);\n", + " // Render to node\n", + " const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n", + " render(props, toinsert[toinsert.length - 1]);\n", + " element.append(toinsert);\n", + " return toinsert\n", + " }\n", + "\n", + " /* Handle when an output is cleared or removed */\n", + " events.on('clear_output.CodeCell', handleClearOutput);\n", + " events.on('delete.Cell', handleClearOutput);\n", + "\n", + " /* Handle when a new output is added */\n", + " events.on('output_added.OutputArea', handleAddOutput);\n", + "\n", + " /**\n", + " * Register the mime type and append_mime function with output_area\n", + " */\n", + " OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n", + " /* Is output safe? */\n", + " safe: true,\n", + " /* Index of renderer in `output_area.display_order` */\n", + " index: 0\n", + " });\n", + " }\n", + "\n", + " // register the mime type if in Jupyter Notebook environment and previously unregistered\n", + " if (root.Jupyter !== undefined) {\n", + " const events = require('base/js/events');\n", + " const OutputArea = require('notebook/js/outputarea').OutputArea;\n", + "\n", + " if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n", + " register_renderer(events, OutputArea);\n", + " }\n", + " }\n", + " if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n", + " root._bokeh_timeout = Date.now() + 5000;\n", + " root._bokeh_failed_load = false;\n", + " }\n", + "\n", + " const NB_LOAD_WARNING = {'data': {'text/html':\n", + " \"<div style='background-color: #fdd'>\\n\"+\n", + " \"<p>\\n\"+\n", + " \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n", + " \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n", + " \"</p>\\n\"+\n", + " \"<ul>\\n\"+\n", + " \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n", + " \"<li>use INLINE resources instead, as so:</li>\\n\"+\n", + " \"</ul>\\n\"+\n", + " \"<code>\\n\"+\n", + " \"from bokeh.resources import INLINE\\n\"+\n", + " \"output_notebook(resources=INLINE)\\n\"+\n", + " \"</code>\\n\"+\n", + " \"</div>\"}};\n", + "\n", + " function display_loaded() {\n", + " const el = document.getElementById(\"1003\");\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS is loading...\";\n", + " }\n", + " if (root.Bokeh !== undefined) {\n", + " if (el != null) {\n", + " el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n", + " }\n", + " } else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(display_loaded, 100)\n", + " }\n", + " }\n", + "\n", + " function run_callbacks() {\n", + " try {\n", + " root._bokeh_onload_callbacks.forEach(function(callback) {\n", + " if (callback != null)\n", + " callback();\n", + " });\n", + " } finally {\n", + " delete root._bokeh_onload_callbacks\n", + " }\n", + " console.debug(\"Bokeh: all callbacks have finished\");\n", + " }\n", + "\n", + " function load_libs(css_urls, js_urls, callback) {\n", + " if (css_urls == null) css_urls = [];\n", + " if (js_urls == null) js_urls = [];\n", + "\n", + " root._bokeh_onload_callbacks.push(callback);\n", + " if (root._bokeh_is_loading > 0) {\n", + " console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n", + " return null;\n", + " }\n", + " if (js_urls == null || js_urls.length === 0) {\n", + " run_callbacks();\n", + " return null;\n", + " }\n", + " console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n", + " root._bokeh_is_loading = css_urls.length + js_urls.length;\n", + "\n", + " function on_load() {\n", + " root._bokeh_is_loading--;\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n", + " run_callbacks()\n", + " }\n", + " }\n", + "\n", + " function on_error(url) {\n", + " console.error(\"failed to load \" + url);\n", + " }\n", + "\n", + " for (let i = 0; i < css_urls.length; i++) {\n", + " const url = css_urls[i];\n", + " const element = document.createElement(\"link\");\n", + " element.onload = on_load;\n", + " element.onerror = on_error.bind(null, url);\n", + " element.rel = \"stylesheet\";\n", + " element.type = \"text/css\";\n", + " element.href = url;\n", + " console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " for (let i = 0; i < js_urls.length; i++) {\n", + " const url = js_urls[i];\n", + " const element = document.createElement('script');\n", + " element.onload = on_load;\n", + " element.onerror = on_error.bind(null, url);\n", + " element.async = false;\n", + " element.src = url;\n", + " console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n", + " document.head.appendChild(element);\n", + " }\n", + " };\n", + "\n", + " function inject_raw_css(css) {\n", + " const element = document.createElement(\"style\");\n", + " element.appendChild(document.createTextNode(css));\n", + " document.body.appendChild(element);\n", + " }\n", + "\n", + " const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n", + " const css_urls = [];\n", + "\n", + " const inline_js = [ function(Bokeh) {\n", + " Bokeh.set_log_level(\"info\");\n", + " },\n", + "function(Bokeh) {\n", + " }\n", + " ];\n", + "\n", + " function run_inline_js() {\n", + " if (root.Bokeh !== undefined || force === true) {\n", + " for (let i = 0; i < inline_js.length; i++) {\n", + " inline_js[i].call(root, root.Bokeh);\n", + " }\n", + "if (force === true) {\n", + " display_loaded();\n", + " }} else if (Date.now() < root._bokeh_timeout) {\n", + " setTimeout(run_inline_js, 100);\n", + " } else if (!root._bokeh_failed_load) {\n", + " console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n", + " root._bokeh_failed_load = true;\n", + " } else if (force !== true) {\n", + " const cell = $(document.getElementById(\"1003\")).parents('.cell').data().cell;\n", + " cell.output_area.append_execute_result(NB_LOAD_WARNING)\n", + " }\n", + " }\n", + "\n", + " if (root._bokeh_is_loading === 0) {\n", + " console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n", + " run_inline_js();\n", + " } else {\n", + " load_libs(css_urls, js_urls, function() {\n", + " console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n", + " run_inline_js();\n", + " });\n", + " }\n", + "}(window));" + ], + "application/vnd.bokehjs_load.v0+json": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\n\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n const NB_LOAD_WARNING = {'data': {'text/html':\n \"<div style='background-color: #fdd'>\\n\"+\n \"<p>\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"</p>\\n\"+\n \"<ul>\\n\"+\n \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n \"<li>use INLINE resources instead, as so:</li>\\n\"+\n \"</ul>\\n\"+\n \"<code>\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"</code>\\n\"+\n \"</div>\"}};\n\n function display_loaded() {\n const el = document.getElementById(\"1003\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error(url) {\n console.error(\"failed to load \" + url);\n }\n\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n const css_urls = [];\n\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {\n }\n ];\n\n function run_inline_js() {\n if (root.Bokeh !== undefined || force === true) {\n for (let i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\nif (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n const cell = $(document.getElementById(\"1003\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "%load_ext autoreload\n", + "%autoreload 2\n", + "\n", + "from __future__ import annotations\n", + "import typing\n", + "import logging\n", + "import os\n", + "import sys\n", + "import warnings\n", + "\n", + "sys.path.append('../montetracko')\n", + "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n", + "\n", + "import yaml\n", + "import numpy as np\n", + "import torch\n", + "\n", + "from Preprocessing.run_preprocessing import run_preprocessing_test_dataset\n", + "from Preprocessing.run_preprocessing import run_preprocessing\n", + "from Processing.run_processing import run_processing_from_config\n", + "\n", + "from Scripts.Step_1_Train_Metric_Learning import train as train_metric_learning\n", + "from Scripts.Step_2_Run_Metric_Learning import train as run_metric_learning_inference\n", + "from Scripts.Step_3_Train_GNN import train as train_gnn\n", + "from Scripts.Step_4_Run_GNN import train as run_gnn_inference\n", + "from Scripts.Step_5_Build_Track_Candidates import train as build_track_candidates\n", + "from Scripts.Step_6_Evaluate_Reconstruction_MonteTracko import (\n", + " evaluate as evaluate_candidates_montetracko\n", + ")\n", + "\n", + "from utils.plotutils import graph as graphplot\n", + "from utils.plotutils import performance as perfplot\n", + "from utils.plotutils import performance_mpl as perfplot_mpl\n", + "from utils.commonutils.ctests import get_required_test_dataset_names\n", + "from utils.commonutils.config import load_config\n", + "from utils.modelutils import checkpoint_utils\n", + "from utils.scriptutils.loghandler import headline\n", + "\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "\n", + "configure_matplotlib()\n", + "\n", + "warnings.filterwarnings(\n", + " \"ignore\", message=(\n", + " \"TypedStorage is deprecated. It will be removed in the future and \"\n", + " \"UntypedStorage will be the only storage class. This should only matter to you \"\n", + " \"if you are using storages directly.\"\n", + " )\n", + ")\n", + "\n", + "CONFIG = 'pipeline_configs/focal-loss-pid-fixed.yaml'\n", + "\n", + "run_training: bool = True\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Pipeline configurations\n", + "\n", + "The configurations for the entire pipeline are defined under pipeline_config.yml." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Download data\n", + "Uncomment if you do not already have the data" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# path = 'data/input/0'\n", + "# os.makedirs(path, exist_ok=True)\n", + "# ! xrdcp -r root://eoslhcb.cern.ch//eos/lhcb/user/a/anthonyc/tracking/data/csv/v2/minbias-sim10b-xdigi/0 data/input --parallel 4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Telegram notification bot" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import requests\n", + "import json\n", + "\n", + "# from datetime import datetime\n", + "\n", + "# def send_telegram_message(message: str,\n", + "# chat_id: str,\n", + "# api_key: str,\n", + "# ):\n", + "# responses = {}\n", + "\n", + "# url = f'https://api.telegram.org/bot{api_key}/sendMessage?chat_id={chat_id}&text={message}'\n", + " \n", + "# response = requests.post(url)\n", + " \n", + "# return response\n", + "\n", + "def send_telegram_message(*args, **kwargs):\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "chat_id = \"5027012918\"\n", + "api_key = \"6268687426:AAE1P7WQofCBuQPiYZlYaKU-p1GNn6OvAxM\"\n", + "\n", + "send_telegram_message(\"======================\", chat_id, api_key)\n", + "\n", + "send_telegram_message(\"Starting.\", chat_id, api_key)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocess the test samples" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for required_test_dataset_name in get_required_test_dataset_names(CONFIG):\n", + " run_preprocessing_test_dataset(\n", + " test_dataset_name=required_test_dataset_name,\n", + " path_or_config=CONFIG,\n", + " path_or_config_test=\"test_samples.yaml\",\n", + " reproduce=False,\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Preprocessing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "run_preprocessing(CONFIG, reproduce=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Processing" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "run_processing_from_config(CONFIG, reproduce=False)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for required_test_dataset_name in get_required_test_dataset_names(CONFIG):\n", + " run_processing_from_config(\n", + " test_dataset_name=required_test_dataset_name,\n", + " path_or_config=CONFIG,\n", + " reproduce=False,\n", + " )\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 1. Train Metric Learning" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## What it does\n", + "Broadly speaking, the first stage of our pipeline is embedding the space points on to graphs, in a way that is efficient, i.e. we miss as few points on a graph as possible. We train a MLP to transform the input feature vector of each space point $\\mathbf{u}_i$ into an N-dimensional latent space $\\mathbf{v}_i$. The graph is then constructed by connecting the space points whose Euclidean distance between the latent space points $$d_{ij} = \\left| \\mathbf{v}_i - \\mathbf{v}_j \\right| < r_{embedding}$$" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training data\n", + "Let us take a look at the data before training. In this example pipeline, we have preprocessed the TrackML data into a more convenient form. We calculated directional information and summary statistics from the charge deposited in each spacepoints, and append them to its cyclidrical coordinates. Let us load an example data file and inspect the content." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from Embedding.embedding_base import get_example_data\n", + "example_data_df, example_data_pyg = get_example_data(CONFIG)\n", + "example_data_df\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "graphplot.plot_true_graph(example_data_pyg, CONFIG, num_tracks=50)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Train metric learning model\n", + "\n", + "Finally we come to model training. By default, we train the MLP for 30 epochs, which takes approximately 15 minutes on an NVidia V100. Feel free to adjust the epoch number in pipeline_config.yml" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "! nvcc --version" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "! nvidia-smi" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "tags": [] + }, + "outputs": [], + "source": [ + "if run_training:\n", + " send_telegram_message('Started metric learning training.', chat_id, api_key)\n", + "\n", + " metric_learning_trainer, metric_learning_model = train_metric_learning(CONFIG)\n", + "\n", + " send_telegram_message('Finished metric learning training.', chat_id, api_key)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the case you want to continue the training of a certain network, you may\n", + "use the code below." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### From checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "embedding_metric_path='artifacts/metric_learning/focal-loss-pid-fixed/version_0/metrics.csv'\n", + "embedding_artifact_path='artifacts/metric_learning/focal-loss-pid-fixed/version_0/checkpoints/epoch=16-step=170000.ckpt'\n" + ] + } + ], + "source": [ + "from Embedding.layerless_embedding import LayerlessEmbedding\n", + "\n", + "embedding_version_dir = checkpoint_utils.get_last_version_dir_from_config(\n", + " step=\"metric_learning\", path_or_config=CONFIG\n", + ")\n", + "embedding_metric_path = os.path.join(embedding_version_dir, \"metrics.csv\")\n", + "embedding_artifact_path = checkpoint_utils.get_last_artifact(\n", + " version_dir=embedding_version_dir\n", + ")\n", + "print(f\"{embedding_metric_path=}\")\n", + "print(f\"{embedding_artifact_path=}\")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To continue the training of the network, you may use the code below" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pytorch_lightning.loggers import CSVLogger\n", + "from pytorch_lightning import Trainer\n", + "\n", + "\n", + "def continue_embedding_training(\n", + " path_or_config: str | dict,\n", + ") -> typing.Tuple[Trainer, LayerlessEmbedding]:\n", + " config = load_config(path_or_config=path_or_config)\n", + "\n", + " metric_learning_model = LayerlessEmbedding.load_from_checkpoint(\n", + " embedding_artifact_path\n", + " ) # you may change `metric_learning_model`\n", + "\n", + " save_directory = os.path.abspath(\n", + " os.path.join(config[\"common\"][\"artifact_directory\"], \"metric_learning\")\n", + " )\n", + "\n", + " logger = CSVLogger(save_directory, name=config[\"common\"][\"experiment_name\"])\n", + "\n", + " metric_learning_trainer = Trainer(\n", + " accelerator=\"gpu\" if torch.cuda.is_available() else \"cpu\",\n", + " devices=1,\n", + " max_epochs=40, # you may increase the number of epochs\n", + " logger=logger,\n", + " # callbacks=[EarlyStopping(monitor=\"train_loss\", mode=\"min\")]\n", + " )\n", + "\n", + " metric_learning_trainer.fit(metric_learning_model)\n", + " return metric_learning_trainer, metric_learning_model\n", + "\n", + "\n", + "# metric_learning_trainer, metric_learning_model = continue_embedding_training(CONFIG)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "metric_learning_model = LayerlessEmbedding.load_from_checkpoint(\n", + " embedding_artifact_path,\n", + " # map_location=\"cpu\",\n", + " # If importing model from another experiment\n", + " hparams=load_config(CONFIG)[\"metric_learning\"],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot training metrics" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can examine how the training went. This is stored in a simple dataframe:" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# embedding_metrics = checkpoint_utils.get_training_metrics(metric_learning_trainer) \n", + "\n", + "embedding_metrics = checkpoint_utils.get_training_metrics(embedding_metric_path)\n", + "\n", + "embedding_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "perfplot_mpl.plot_loss(embedding_metrics, CONFIG, \"metric_learning\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "perfplot_mpl.plot_metric_epochs(\n", + " \"eff\",\n", + " embedding_metrics,\n", + " CONFIG,\n", + " \"metric_learning\",\n", + " \"Edge Efficiency\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n", + "perfplot_mpl.plot_metric_epochs(\n", + " \"pur\",\n", + " embedding_metrics,\n", + " CONFIG,\n", + " \"metric_learning\",\n", + " \"Edge Purity\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate model performance on sample test data\n", + "\n", + "Here we evaluate the model performance on one sample test data. We look at how the efficiency and purity change with the embedding radius." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "from Embedding import embedding_plots\n", + "\n", + "embedding_plots.plot_embedding_performance_given_radius_knn_max(\n", + " model=metric_learning_model,\n", + " path_or_config=CONFIG,\n", + " radius=np.linspace(0.01, 0.05, 10),\n", + " n_events=20,\n", + " partitions=[\"train\", \"val\", \"velo-sim10b-nospillover\"],\n", + ");\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot example truth and predicted graphs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "metric_learning_model.load_partition(\"velo-sim10b-nospillover\")\n", + "graphplot.plot_predicted_graph(metric_learning_model, CONFIG)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from Embedding.embedding_plots import plot_best_performances_radius\n", + "plot_best_performances_radius(\n", + " model=metric_learning_model,\n", + " path_or_config=CONFIG,\n", + " partition=\"velo-sim10b-nospillover\",\n", + " # list_radius=[0.015, 0.020],\n", + " list_radius=[0.015, 0.020, 0.025, 0.030, 0.035, 0.040],\n", + " n_events=200,\n", + " seed=0,\n", + ");\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Track lengths" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "metric_learning_model.load_partition(\"velo-sim10b-nospillover\")\n", + "perfplot.plot_track_lengths(metric_learning_model, CONFIG)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "metric_learning_model.setup(stage=\"fit\") # load train and val datasets\n", + "\n", + "perfplot.plot_graph_sizes(metric_learning_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 2. Construct graphs from metric learning inference\n", + "\n", + "This step performs model inference on the entire input datasets (train, validation and test), to obtain input graphs to the graph neural network. Optionally, we also clear the directory." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "graph_builder = run_metric_learning_inference(\n", + " CONFIG,\n", + " checkpoint=embedding_artifact_path,\n", + " # checkpoint=metric_learning_model, # here directly use the model\n", + " reproduce=False,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 3. Train graph neural networks" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have a set of graphs constructed. We now train a GNN to classify edges as either \"true\" (belonging to the same track) or \"false\" (not belonging to the same track). We train for 30 epochs, which should take around 10 minutes on a V100 GPU. Your mileage may vary." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:------------------------- Step 3: Running GNN training -------------------------\n", + "INFO:----------------------------- a) Initialising model -----------------------------\n", + "INFO:------------------------------ b) Running training ------------------------------\n", + "Missing logger folder: /home/acorreia/Documents/tracking/etx4velo/LHCb_Pipeline/artifacts/gnn/focal-loss-pid-fixed\n", + "INFO:Save hyperparameters, metrics and artifacts in /home/acorreia/Documents/tracking/etx4velo/LHCb_Pipeline/artifacts/gnn/focal-loss-pid-fixed/version_0\n", + "GPU available: True (cuda), used: True\n", + "TPU available: False, using: 0 TPU cores\n", + "IPU available: False, using: 0 IPUs\n", + "HPU available: False, using: 0 HPUs\n", + "INFO:Load 10000 files located in /scratch/acorreia/data/focal-loss-pid-fixed/metric_learning_processed/train\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "bbbe40dfdf7143e085e7a813d5787d6d", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/10000 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO:Load 500 files located in /scratch/acorreia/data/focal-loss-pid-fixed/metric_learning_processed/val\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9edd7c25454547c6a782b3302caa67ad", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/500 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", + "\n", + " | Name | Type | Params\n", + "------------------------------------------------------\n", + "0 | node_encoder | Sequential | 332 K \n", + "1 | edge_encoder | Sequential | 462 K \n", + "2 | edge_network | Sequential | 793 K \n", + "3 | node_network | Sequential | 659 K \n", + "4 | output_edge_classifier | Sequential | 529 K \n", + "------------------------------------------------------\n", + "2.8 M Trainable params\n", + "0 Non-trainable params\n", + "2.8 M Total params\n", + "11.111 Total estimated model params size (MB)\n" + ] + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Sanity Checking: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "5ee6357167424736846d37949bf55de0", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Training: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + "Validation: 0it [00:00, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "if run_training:\n", + " send_telegram_message('Started GNN training.', chat_id, api_key)\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " \"ignore\", message=\"None of the inputs have requires_grad=True.\"\n", + " )\n", + " gnn_trainer, gnn_model = train_gnn(CONFIG)\n", + "\n", + " send_telegram_message('Finished GNN training.', chat_id, api_key)\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### From checkpoint" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from utils.modelutils.checkpoint_utils import (\n", + " get_last_version_dir_from_config,\n", + " get_last_artifact,\n", + ")\n", + "from GNN.interaction_gnn import InteractionGNN\n", + "\n", + "gnn_version_dir = get_last_version_dir_from_config(step=\"gnn\", path_or_config=CONFIG)\n", + "gnn_metric_path = os.path.join(gnn_version_dir, \"metrics.csv\")\n", + "gnn_artifact_path = get_last_artifact(version_dir=gnn_version_dir)\n", + "print(f\"{gnn_metric_path=}\")\n", + "print(f\"{gnn_artifact_path=}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from pytorch_lightning import Trainer\n", + "from pytorch_lightning.loggers import CSVLogger\n", + "\n", + "\n", + "def continue_gnn_training(\n", + " path_or_config: str | dict,\n", + ") -> typing.Tuple[Trainer, InteractionGNN]:\n", + " config = load_config(path_or_config=path_or_config)\n", + "\n", + " gnn_model = InteractionGNN.load_from_checkpoint(\n", + " gnn_artifact_path, **config[\"gnn\"]\n", + " ) # you may change `gnn_model`\n", + "\n", + " save_directory = os.path.abspath(\n", + " os.path.join(config[\"common\"][\"artifact_directory\"], \"gnn\")\n", + " )\n", + "\n", + " logger = CSVLogger(save_directory, name=config[\"common\"][\"experiment_name\"])\n", + "\n", + " gnn_trainer = Trainer(\n", + " accelerator=\"gpu\" if torch.cuda.is_available() else \"cpu\",\n", + " devices=1,\n", + " max_epochs=50, # you may increase the number of epochs\n", + " logger=logger,\n", + " # callbacks=[EarlyStopping(monitor=\"val_loss\", mode=\"min\")]\n", + " )\n", + "\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " \"ignore\", message=\"None of the inputs have requires_grad=True.\"\n", + " )\n", + " gnn_trainer.fit(gnn_model, ckpt_path=gnn_artifact_path)\n", + " return gnn_trainer, gnn_model\n", + "\n", + "# gnn_trainer, gnn_model = continue_gnn_training(CONFIG)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gnn_model = InteractionGNN.load_from_checkpoint(\n", + " gnn_artifact_path,\n", + " # map_location=\"cpu\",\n", + " # hparams=load_config(CONFIG)[\"gnn\"],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Plot training metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# gnn_metrics = checkpoint_utils.get_training_metrics(gnn_trainer)\n", + "\n", + "gnn_metrics = checkpoint_utils.get_training_metrics(gnn_metric_path)\n", + "\n", + "gnn_metrics" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "perfplot_mpl.plot_loss(gnn_metrics, CONFIG, \"gnn\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "perfplot_mpl.plot_metric_epochs(\n", + " \"eff\",\n", + " gnn_metrics,\n", + " CONFIG,\n", + " \"gnn\",\n", + " \"Edge Efficiency\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n", + "perfplot_mpl.plot_metric_epochs(\n", + " \"pur\",\n", + " gnn_metrics,\n", + " CONFIG,\n", + " \"gnn\",\n", + " \"Edge Purity\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Evaluate model performance on sample test data\n", + "\n", + "Here we evaluate the model performace on one sample test data. We look at how the efficiency and purity change with the embedding radius." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "gnn_model.load_partition(\"velo-sim10b-nospillover\")\n", + "perfplot.plot_edge_performance(gnn_model, CONFIG)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "performances_for_various_score_cuts" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from GNN.gnn_plots import plot_best_performances_score_cut\n", + "_, _, performances_for_various_score_cuts = plot_best_performances_score_cut(\n", + " model=gnn_model,\n", + " path_or_config=CONFIG,\n", + " partition=\"velo-sim10b-nospillover\",\n", + " score_cuts=[0.4, 0.5, 0.6, 0.65, 0.7, 0.71, 0.72, 0.73, 0.74, 0.75, 0.76, 0.77, 0.78, 0.79, 0.8, 0.85, 0.9, 0.95],\n", + " n_events=200,\n", + " seed=0,\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 4. GNN inference " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "run_gnn_inference(CONFIG, checkpoint=gnn_model)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 5. Build track candidates from GNN" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "build_track_candidates(CONFIG)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 6. Evaluate track candidates on the same data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "scrolled": true + }, + "outputs": [], + "source": [ + "evaluate_candidates_montetracko(\n", + " CONFIG,\n", + " partition=\"train\",\n", + " allen_report=True,\n", + " table_report=True,\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "evaluate_candidates_montetracko(\n", + " CONFIG,\n", + " partition=\"val\",\n", + " allen_report=True,\n", + " table_report=True,\n", + " plot_categories=[],\n", + ")\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# 7. Evaluate track candidates on unseen data" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "for test_dataset_name in get_required_test_dataset_names(CONFIG):\n", + " logging.info(headline(test_dataset_name))\n", + " evaluate_candidates_montetracko(\n", + " CONFIG,\n", + " partition=test_dataset_name,\n", + " allen_report=True,\n", + " table_report=True,\n", + " plot_categories=[],\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trackEvaluator = evaluate_candidates_montetracko(\n", + " CONFIG,\n", + " partition=\"velo-sim10b-nospillover\",\n", + " allen_report=True,\n", + " table_report=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "vscode": { + "interpreter": { + "hash": "31f2aee4e71d21fbe5cf8b01ff0e069b9275f58929596ceb00d14d90e3e16cd6" + } + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/LHCb_Pipeline/full_pipeline.ipynb b/LHCb_Pipeline/full_pipeline.ipynb index a6a2278b78a7a54166efd602757a81cf770a349c..994a0a5fcbb85070bd3327c13954ea2bb27f2b8a 100644 --- a/LHCb_Pipeline/full_pipeline.ipynb +++ b/LHCb_Pipeline/full_pipeline.ipynb @@ -18,64 +18,31 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div class=\"bk-root\">\n", - " <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n", - " <span id=\"1002\">Loading BokehJS ...</span>\n", - " </div>\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\nconst JS_MIME_TYPE = 'application/javascript';\n const HTML_MIME_TYPE = 'text/html';\n const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n const CLASS_NAME = 'output_bokeh rendered_html';\n\n /**\n * Render data to the DOM node\n */\n function render(props, node) {\n const script = document.createElement(\"script\");\n node.appendChild(script);\n }\n\n /**\n * Handle when an output is cleared or removed\n */\n function handleClearOutput(event, handle) {\n const cell = handle.cell;\n\n const id = cell.output_area._bokeh_element_id;\n const server_id = cell.output_area._bokeh_server_id;\n // Clean up Bokeh references\n if (id != null && id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n\n if (server_id !== undefined) {\n // Clean up Bokeh references\n const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n cell.notebook.kernel.execute(cmd_clean, {\n iopub: {\n output: function(msg) {\n const id = msg.content.text.trim();\n if (id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n }\n }\n });\n // Destroy server and session\n const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n cell.notebook.kernel.execute(cmd_destroy);\n }\n }\n\n /**\n * Handle when a new output is added\n */\n function handleAddOutput(event, handle) {\n const output_area = handle.output_area;\n const output = handle.output;\n\n // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n return\n }\n\n const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n\n if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n // store reference to embed id on output_area\n output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n }\n if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n const bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n const script_attrs = bk_div.children[0].attributes;\n for (let i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n }\n\n function register_renderer(events, OutputArea) {\n\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n const toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[toinsert.length - 1]);\n element.append(toinsert);\n return toinsert\n }\n\n /* Handle when an output is cleared or removed */\n events.on('clear_output.CodeCell', handleClearOutput);\n events.on('delete.Cell', handleClearOutput);\n\n /* Handle when a new output is added */\n events.on('output_added.OutputArea', handleAddOutput);\n\n /**\n * Register the mime type and append_mime function with output_area\n */\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n /* Is output safe? */\n safe: true,\n /* Index of renderer in `output_area.display_order` */\n index: 0\n });\n }\n\n // register the mime type if in Jupyter Notebook environment and previously unregistered\n if (root.Jupyter !== undefined) {\n const events = require('base/js/events');\n const OutputArea = require('notebook/js/outputarea').OutputArea;\n\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n }\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n const NB_LOAD_WARNING = {'data': {'text/html':\n \"<div style='background-color: #fdd'>\\n\"+\n \"<p>\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"</p>\\n\"+\n \"<ul>\\n\"+\n \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n \"<li>use INLINE resources instead, as so:</li>\\n\"+\n \"</ul>\\n\"+\n \"<code>\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"</code>\\n\"+\n \"</div>\"}};\n\n function display_loaded() {\n const el = document.getElementById(\"1002\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error(url) {\n console.error(\"failed to load \" + url);\n }\n\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n const css_urls = [];\n\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {\n }\n ];\n\n function run_inline_js() {\n if (root.Bokeh !== undefined || force === true) {\n for (let i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\nif (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n const cell = $(document.getElementById(\"1002\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));", - "application/vnd.bokehjs_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "text/html": [ - "<div class=\"bk-root\">\n", - " <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n", - " <span id=\"1003\">Loading BokehJS ...</span>\n", - " </div>\n" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\nconst JS_MIME_TYPE = 'application/javascript';\n const HTML_MIME_TYPE = 'text/html';\n const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n const CLASS_NAME = 'output_bokeh rendered_html';\n\n /**\n * Render data to the DOM node\n */\n function render(props, node) {\n const script = document.createElement(\"script\");\n node.appendChild(script);\n }\n\n /**\n * Handle when an output is cleared or removed\n */\n function handleClearOutput(event, handle) {\n const cell = handle.cell;\n\n const id = cell.output_area._bokeh_element_id;\n const server_id = cell.output_area._bokeh_server_id;\n // Clean up Bokeh references\n if (id != null && id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n\n if (server_id !== undefined) {\n // Clean up Bokeh references\n const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n cell.notebook.kernel.execute(cmd_clean, {\n iopub: {\n output: function(msg) {\n const id = msg.content.text.trim();\n if (id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n }\n }\n });\n // Destroy server and session\n const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n cell.notebook.kernel.execute(cmd_destroy);\n }\n }\n\n /**\n * Handle when a new output is added\n */\n function handleAddOutput(event, handle) {\n const output_area = handle.output_area;\n const output = handle.output;\n\n // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n return\n }\n\n const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n\n if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n // store reference to embed id on output_area\n output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n }\n if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n const bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n const script_attrs = bk_div.children[0].attributes;\n for (let i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n }\n\n function register_renderer(events, OutputArea) {\n\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n const toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[toinsert.length - 1]);\n element.append(toinsert);\n return toinsert\n }\n\n /* Handle when an output is cleared or removed */\n events.on('clear_output.CodeCell', handleClearOutput);\n events.on('delete.Cell', handleClearOutput);\n\n /* Handle when a new output is added */\n events.on('output_added.OutputArea', handleAddOutput);\n\n /**\n * Register the mime type and append_mime function with output_area\n */\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n /* Is output safe? */\n safe: true,\n /* Index of renderer in `output_area.display_order` */\n index: 0\n });\n }\n\n // register the mime type if in Jupyter Notebook environment and previously unregistered\n if (root.Jupyter !== undefined) {\n const events = require('base/js/events');\n const OutputArea = require('notebook/js/outputarea').OutputArea;\n\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n }\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n const NB_LOAD_WARNING = {'data': {'text/html':\n \"<div style='background-color: #fdd'>\\n\"+\n \"<p>\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"</p>\\n\"+\n \"<ul>\\n\"+\n \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n \"<li>use INLINE resources instead, as so:</li>\\n\"+\n \"</ul>\\n\"+\n \"<code>\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"</code>\\n\"+\n \"</div>\"}};\n\n function display_loaded() {\n const el = document.getElementById(\"1003\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error(url) {\n console.error(\"failed to load \" + url);\n }\n\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n const css_urls = [];\n\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {\n }\n ];\n\n function run_inline_js() {\n if (root.Bokeh !== undefined || force === true) {\n for (let i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\nif (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n const cell = $(document.getElementById(\"1003\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));", - "application/vnd.bokehjs_load.v0+json": "" - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "%load_ext autoreload\n", "%autoreload 2\n", "\n", "from __future__ import annotations\n", "import typing\n", + "import logging\n", "import os\n", "import sys\n", "import warnings\n", "\n", "sys.path.append('../montetracko')\n", + "# os.environ[\"CUDA_VISIBLE_DEVICES\"] = \"\"\n", "\n", + "import yaml\n", + "import numpy as np\n", "import torch\n", "\n", + "from Preprocessing.run_preprocessing import run_preprocessing_test_dataset\n", + "from Preprocessing.run_preprocessing import run_preprocessing\n", + "from Processing.run_processing import run_processing_from_config\n", + "\n", "from Scripts.Step_1_Train_Metric_Learning import train as train_metric_learning\n", "from Scripts.Step_2_Run_Metric_Learning import train as run_metric_learning_inference\n", "from Scripts.Step_3_Train_GNN import train as train_gnn\n", @@ -87,9 +54,15 @@ "\n", "from utils.plotutils import graph as graphplot\n", "from utils.plotutils import performance as perfplot\n", + "from utils.plotutils import performance_mpl as perfplot_mpl\n", "from utils.commonutils.ctests import get_required_test_dataset_names\n", "from utils.commonutils.config import load_config\n", "from utils.modelutils import checkpoint_utils\n", + "from utils.scriptutils.loghandler import headline\n", + "\n", + "from utils.plotutils.plotconfig import configure_matplotlib\n", + "\n", + "configure_matplotlib()\n", "\n", "warnings.filterwarnings(\n", " \"ignore\", message=(\n", @@ -99,7 +72,9 @@ " )\n", ")\n", "\n", - "CONFIG = 'pipeline_config.yaml'\n" + "CONFIG = 'pipeline_config_default.yaml'\n", + "\n", + "run_training: bool = True\n" ] }, { @@ -123,7 +98,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -142,12 +117,13 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import requests\n", "import json\n", + "\n", "# from datetime import datetime\n", "\n", "# def send_telegram_message(message: str,\n", @@ -168,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -190,80 +166,10 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Preprocessing: output will be written in scratch/__test__/velo-minbias-sim10b-xdigi-nospillover\n", - "INFO:Load dataframe\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "5b70e7143df143c4a6383dac2607528f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Preprocessing: output will be written in scratch/__test__/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n", - "INFO:Load dataframe\n", - "INFO:Apply selection\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0227464fa17c4891862e586ba3136027", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Preprocessing: output will be written in scratch/__test__/velo-bu2kstee-sim10aU1-xdigi\n", - "INFO:Load dataframe\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "88f6e3994b964f248154137797a26f78", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "from Preprocessing.run_preprocessing import run_preprocessing_test_dataset\n", - "\n", "for required_test_dataset_name in get_required_test_dataset_names(CONFIG):\n", " run_preprocessing_test_dataset(\n", " test_dataset_name=required_test_dataset_name,\n", @@ -283,43 +189,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, "outputs": [], - "source": [ - "from Preprocessing.run_preprocessing import run_preprocessing\n", - "from Processing.run_processing import run_processing_from_config\n" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Preprocessing: output will be written in scratch/velo-minbias-sim10b-xdigi-nospillover/preprocessed\n", - "INFO:Load dataframe\n", - "INFO:Apply selection\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6c548297cecc41478eacd64449cbea66", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/100 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], "source": [ "run_preprocessing(CONFIG, reproduce=False)" ] @@ -334,136 +206,18 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Input directory: scratch/velo-minbias-sim10b-xdigi-nospillover/preprocessed\n", - "INFO:Writing outputs to scratch/velo-minbias-sim10b-xdigi-nospillover/processed/train\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f668e8d341214a418d0f524abec68216", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Writing outputs to scratch/velo-minbias-sim10b-xdigi-nospillover/processed/val\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "affb051c8867453ab938d065c560be13", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Splitting was saved in scratch/velo-minbias-sim10b-xdigi-nospillover/processed/splitting.json.\n" - ] - } - ], + "outputs": [], "source": [ "run_processing_from_config(CONFIG, reproduce=False)\n" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Input directory: scratch/__test__/velo-minbias-sim10b-xdigi-nospillover\n", - "INFO:Writing outputs to scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-minbias-sim10b-xdigi-nospillover\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d04d349bf0374da6aa1fe890f4dcb353", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Input directory: scratch/__test__/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n", - "INFO:Writing outputs to scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "17224ac601724b7181a511ac485e902d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Input directory: scratch/__test__/velo-bu2kstee-sim10aU1-xdigi\n", - "INFO:Writing outputs to scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-bu2kstee-sim10aU1-xdigi\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6a84abe37d8b4a2d8600f5083c3819a0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for required_test_dataset_name in get_required_test_dataset_names(CONFIG):\n", " run_processing_from_config(\n", @@ -501,141 +255,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>0</th>\n", - " <th>1</th>\n", - " <th>2</th>\n", - " <th>3</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>0.379526</td>\n", - " <td>-0.562705</td>\n", - " <td>-1.440705</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>0.468974</td>\n", - " <td>-0.762697</td>\n", - " <td>-1.434295</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>0.809876</td>\n", - " <td>-0.545168</td>\n", - " <td>-1.434295</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>0.338967</td>\n", - " <td>-0.681292</td>\n", - " <td>-1.440705</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>0.436733</td>\n", - " <td>-0.800723</td>\n", - " <td>-1.434295</td>\n", - " <td>0.000000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>...</th>\n", - " <td>...</td>\n", - " <td>...</td>\n", - " <td>...</td>\n", - " <td>...</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2501</th>\n", - " <td>0.635943</td>\n", - " <td>0.085912</td>\n", - " <td>3.753205</td>\n", - " <td>0.961538</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2502</th>\n", - " <td>0.646183</td>\n", - " <td>-0.155981</td>\n", - " <td>3.746795</td>\n", - " <td>0.961538</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2503</th>\n", - " <td>0.622268</td>\n", - " <td>-0.197432</td>\n", - " <td>3.746795</td>\n", - " <td>0.961538</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2504</th>\n", - " <td>0.479986</td>\n", - " <td>-0.175648</td>\n", - " <td>3.746795</td>\n", - " <td>0.961538</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2505</th>\n", - " <td>0.273867</td>\n", - " <td>-0.018543</td>\n", - " <td>3.753205</td>\n", - " <td>0.961538</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "<p>2506 rows × 4 columns</p>\n", - "</div>" - ], - "text/plain": [ - " 0 1 2 3\n", - "0 0.379526 -0.562705 -1.440705 0.000000\n", - "1 0.468974 -0.762697 -1.434295 0.000000\n", - "2 0.809876 -0.545168 -1.434295 0.000000\n", - "3 0.338967 -0.681292 -1.440705 0.000000\n", - "4 0.436733 -0.800723 -1.434295 0.000000\n", - "... ... ... ... ...\n", - "2501 0.635943 0.085912 3.753205 0.961538\n", - "2502 0.646183 -0.155981 3.746795 0.961538\n", - "2503 0.622268 -0.197432 3.746795 0.961538\n", - "2504 0.479986 -0.175648 3.746795 0.961538\n", - "2505 0.273867 -0.018543 3.753205 0.961538\n", - "\n", - "[2506 rows x 4 columns]" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "from Embedding.embedding_base import get_example_data\n", "example_data_df, example_data_pyg = get_example_data(CONFIG)\n", @@ -644,30 +266,11 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Applicable driver not found; attempting to install with Selenium Manager (Beta)\n", - "WARNING:Unable to obtain driver using Selenium Manager: /home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/common/linux/selenium-manager is missing. Please open an issue on https://github.com/SeleniumHQ/selenium/issues\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<IPython.core.display.Image object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "graphplot.plot_true_graph(example_data_pyg, CONFIG, num_tracks=25)" + "graphplot.plot_true_graph(example_data_pyg, CONFIG, num_tracks=50)" ] }, { @@ -682,428 +285,38 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "nvcc: NVIDIA (R) Cuda compiler driver\n", - "Copyright (c) 2005-2023 NVIDIA Corporation\n", - "Built on Mon_Apr__3_17:16:06_PDT_2023\n", - "Cuda compilation tools, release 12.1, V12.1.105\n", - "Build cuda_12.1.r12.1/compiler.32688072_0\n" - ] - } - ], + "outputs": [], "source": [ "! nvcc --version" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Wed May 24 17:35:26 2023 \n", - "+-----------------------------------------------------------------------------+\n", - "| NVIDIA-SMI 525.60.13 Driver Version: 525.60.13 CUDA Version: 12.0 |\n", - "|-------------------------------+----------------------+----------------------+\n", - "| GPU Name Persistence-M| Bus-Id Disp.A | Volatile Uncorr. ECC |\n", - "| Fan Temp Perf Pwr:Usage/Cap| Memory-Usage | GPU-Util Compute M. |\n", - "| | | MIG M. |\n", - "|===============================+======================+======================|\n", - "| 0 NVIDIA TITAN RTX On | 00000000:5E:00.0 Off | N/A |\n", - "| 40% 28C P8 10W / 280W | 701MiB / 24576MiB | 0% Default |\n", - "| | | N/A |\n", - "+-------------------------------+----------------------+----------------------+\n", - " \n", - "+-----------------------------------------------------------------------------+\n", - "| Processes: |\n", - "| GPU GI CI PID Type Process name GPU Memory |\n", - "| ID ID Usage |\n", - "|=============================================================================|\n", - "+-----------------------------------------------------------------------------+\n" - ] - } - ], + "outputs": [], "source": [ "! nvidia-smi" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": { "tags": [] }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:-------------------- Step 1: Running metric learning training --------------------\n", - "INFO:----------------------------- a) Initialising model -----------------------------\n", - "INFO:------------------------------ b) Running training ------------------------------\n", - "INFO:Save hyperparameters, metrics and artifacts in /home/fgias/etx4velo-3/LHCb_Pipeline/artifacts/metric_learning/velo-minbias-sim10b-xdigi-nospillover/version_2\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/lightning_fabric/plugins/environments/slurm.py:165: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/fgias/.conda/envs/etx4velo/lib/python3.10/site ...\n", - " rank_zero_warn(\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/lightning_fabric/plugins/environments/slurm.py:165: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/fgias/.conda/envs/etx4velo/lib/python3.10/site ...\n", - " rank_zero_warn(\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params\n", - "---------------------------------------\n", - "0 | network | Sequential | 201 K \n", - "---------------------------------------\n", - "201 K Trainable params\n", - "0 Non-trainable params\n", - "201 K Total params\n", - "0.807 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Sanity Checking: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "bd89a1d626f14d5ebbfab5c96e546b49", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_epochs=20` reached.\n", - "INFO:-------------------------------- c) Saving model --------------------------------\n" - ] - } - ], + "outputs": [], "source": [ - "send_telegram_message('Started metric learning training.', chat_id, api_key)\n", + "if run_training:\n", + " send_telegram_message('Started metric learning training.', chat_id, api_key)\n", "\n", - "metric_learning_trainer, metric_learning_model = train_metric_learning(CONFIG)\n", + " metric_learning_trainer, metric_learning_model = train_metric_learning(CONFIG)\n", "\n", - "send_telegram_message('Finished metric learning training.', chat_id, api_key)" + " send_telegram_message('Finished metric learning training.', chat_id, api_key)" ] }, { @@ -1115,40 +328,6 @@ "use the code below." ] }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# from Embedding.models.layerless_embedding import LayerlessEmbedding\n", - "# from pytorch_lightning import Trainer\n", - "# from pytorch_lightning.loggers import CSVLogger\n", - "\n", - "# version_number = 6\n", - "\n", - "# HPARAMS_PATH = f'/home/fgias/velo-gnn/LHCb_Pipeline/artifacts/metric_learning/velo-minbias-sim10b-xdigi/version_1/hparams.yaml'\n", - "# CKPT_PATH = f'/home/fgias/velo-gnn/LHCb_Pipeline/artifacts/metric_learning/velo-minbias-sim10b-xdigi/version_1/checkpoints/epoch=19-step=1600.ckpt'\n", - "\n", - "# load_configs = {}\n", - "# with open(HPARAMS_PATH, 'r') as f:\n", - "# load_configs = yaml.load(f, Loader=yaml.FullLoader)\n", - "\n", - "# metric_learning_model = LayerlessEmbedding(load_configs)\n", - "\n", - "# logger = CSVLogger('artifacts', name='metric_learning/velo_data')\n", - "\n", - "# metric_learning_trainer = Trainer(\n", - "# accelerator='gpu' if torch.cuda.is_available() else 'cpu',\n", - "# devices=1,\n", - "# max_epochs=40,\n", - "# logger=logger,\n", - "# # callbacks=[EarlyStopping(monitor=\"val_loss\", mode=\"min\")]\n", - "# )\n", - "\n", - "# metric_learning_trainer.fit(metric_learning_model, ckpt_path=CKPT_PATH)" - ] - }, { "attachments": {}, "cell_type": "markdown", @@ -1159,28 +338,21 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "embedding_metric_path='artifacts/metric_learning/velo-minbias-sim10b-xdigi-nospillover/version_2/metrics.csv'\n", - "embedding_artifact_path='artifacts/metric_learning/velo-minbias-sim10b-xdigi-nospillover/version_2/checkpoints/epoch=19-step=1800.ckpt'\n" - ] - } - ], + "outputs": [], "source": [ "from Embedding.models.layerless_embedding import LayerlessEmbedding\n", "\n", - "version_dir = checkpoint_utils.get_last_version_dir_from_config(\n", + "embedding_version_dir = checkpoint_utils.get_last_version_dir_from_config(\n", " step=\"metric_learning\", path_or_config=CONFIG\n", ")\n", - "embedding_metric_path = os.path.join(version_dir, \"metrics.csv\")\n", - "embedding_artifact_path = checkpoint_utils.get_last_artifact(version_dir=version_dir)\n", + "embedding_metric_path = os.path.join(embedding_version_dir, \"metrics.csv\")\n", + "embedding_artifact_path = checkpoint_utils.get_last_artifact(\n", + " version_dir=embedding_version_dir\n", + ")\n", "print(f\"{embedding_metric_path=}\")\n", - "print(f\"{embedding_artifact_path=}\")" + "print(f\"{embedding_artifact_path=}\")\n" ] }, { @@ -1193,7 +365,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -1221,10 +393,12 @@ " devices=1,\n", " max_epochs=40, # you may increase the number of epochs\n", " logger=logger,\n", - " # callbacks=[EarlyStopping(monitor=\"val_loss\", mode=\"min\")]\n", + " # callbacks=[EarlyStopping(monitor=\"train_loss\", mode=\"min\")]\n", " )\n", "\n", - " metric_learning_trainer.fit(metric_learning_model)\n", + " metric_learning_trainer.fit(\n", + " metric_learning_model, ckpt_path=embedding_artifact_path\n", + " )\n", " return metric_learning_trainer, metric_learning_model\n", "\n", "\n", @@ -1233,11 +407,16 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "metric_learning_model = LayerlessEmbedding.load_from_checkpoint(embedding_artifact_path)\n" + "metric_learning_model = LayerlessEmbedding.load_from_checkpoint(\n", + " embedding_artifact_path,\n", + " # map_location=\"cpu\",\n", + " # If importing model from another experiment\n", + " # hparams=load_config(CONFIG)[\"metric_learning\"],\n", + ")\n" ] }, { @@ -1258,242 +437,9 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>epoch</th>\n", - " <th>train_loss</th>\n", - " <th>val_loss</th>\n", - " <th>eff</th>\n", - " <th>pur</th>\n", - " <th>current_lr</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>0</td>\n", - " <td>0.009331</td>\n", - " <td>0.008854</td>\n", - " <td>0.981461</td>\n", - " <td>0.052457</td>\n", - " <td>0.000125</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1</td>\n", - " <td>0.008846</td>\n", - " <td>0.008726</td>\n", - " <td>0.977990</td>\n", - " <td>0.065469</td>\n", - " <td>0.000250</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>2</td>\n", - " <td>0.008646</td>\n", - " <td>0.008260</td>\n", - " <td>0.975066</td>\n", - " <td>0.115246</td>\n", - " <td>0.000375</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>3</td>\n", - " <td>0.008594</td>\n", - " <td>0.008224</td>\n", - " <td>0.977431</td>\n", - " <td>0.119500</td>\n", - " <td>0.000350</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>4</td>\n", - " <td>0.008593</td>\n", - " <td>0.008143</td>\n", - " <td>0.975767</td>\n", - " <td>0.128147</td>\n", - " <td>0.000625</td>\n", - " </tr>\n", - " <tr>\n", - " <th>5</th>\n", - " <td>5</td>\n", - " <td>0.008575</td>\n", - " <td>0.008300</td>\n", - " <td>0.981175</td>\n", - " <td>0.111195</td>\n", - " <td>0.000750</td>\n", - " </tr>\n", - " <tr>\n", - " <th>6</th>\n", - " <td>6</td>\n", - " <td>0.008562</td>\n", - " <td>0.008318</td>\n", - " <td>0.981980</td>\n", - " <td>0.109136</td>\n", - " <td>0.000875</td>\n", - " </tr>\n", - " <tr>\n", - " <th>7</th>\n", - " <td>7</td>\n", - " <td>0.008502</td>\n", - " <td>0.008320</td>\n", - " <td>0.982643</td>\n", - " <td>0.109381</td>\n", - " <td>0.000700</td>\n", - " </tr>\n", - " <tr>\n", - " <th>8</th>\n", - " <td>8</td>\n", - " <td>0.008484</td>\n", - " <td>0.008126</td>\n", - " <td>0.979342</td>\n", - " <td>0.129930</td>\n", - " <td>0.000700</td>\n", - " </tr>\n", - " <tr>\n", - " <th>9</th>\n", - " <td>9</td>\n", - " <td>0.008474</td>\n", - " <td>0.008101</td>\n", - " <td>0.977593</td>\n", - " <td>0.132546</td>\n", - " <td>0.000700</td>\n", - " </tr>\n", - " <tr>\n", - " <th>10</th>\n", - " <td>10</td>\n", - " <td>0.008469</td>\n", - " <td>0.008078</td>\n", - " <td>0.977144</td>\n", - " <td>0.135049</td>\n", - " <td>0.000700</td>\n", - " </tr>\n", - " <tr>\n", - " <th>11</th>\n", - " <td>11</td>\n", - " <td>0.008436</td>\n", - " <td>0.008046</td>\n", - " <td>0.976337</td>\n", - " <td>0.138554</td>\n", - " <td>0.000490</td>\n", - " </tr>\n", - " <tr>\n", - " <th>12</th>\n", - " <td>12</td>\n", - " <td>0.008428</td>\n", - " <td>0.007944</td>\n", - " <td>0.974389</td>\n", - " <td>0.149568</td>\n", - " <td>0.000490</td>\n", - " </tr>\n", - " <tr>\n", - " <th>13</th>\n", - " <td>13</td>\n", - " <td>0.008424</td>\n", - " <td>0.007950</td>\n", - " <td>0.974593</td>\n", - " <td>0.148910</td>\n", - " <td>0.000490</td>\n", - " </tr>\n", - " <tr>\n", - " <th>14</th>\n", - " <td>14</td>\n", - " <td>0.008416</td>\n", - " <td>0.007949</td>\n", - " <td>0.974523</td>\n", - " <td>0.149105</td>\n", - " <td>0.000490</td>\n", - " </tr>\n", - " <tr>\n", - " <th>15</th>\n", - " <td>15</td>\n", - " <td>0.008389</td>\n", - " <td>0.007967</td>\n", - " <td>0.974943</td>\n", - " <td>0.147168</td>\n", - " <td>0.000343</td>\n", - " </tr>\n", - " <tr>\n", - " <th>16</th>\n", - " <td>16</td>\n", - " <td>0.008380</td>\n", - " <td>0.007942</td>\n", - " <td>0.974692</td>\n", - " <td>0.149762</td>\n", - " <td>0.000343</td>\n", - " </tr>\n", - " <tr>\n", - " <th>17</th>\n", - " <td>17</td>\n", - " <td>0.008376</td>\n", - " <td>0.007953</td>\n", - " <td>0.974729</td>\n", - " <td>0.148579</td>\n", - " <td>0.000343</td>\n", - " </tr>\n", - " <tr>\n", - " <th>18</th>\n", - " <td>18</td>\n", - " <td>0.008373</td>\n", - " <td>0.007932</td>\n", - " <td>0.974497</td>\n", - " <td>0.150832</td>\n", - " <td>0.000343</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " epoch train_loss val_loss eff pur current_lr\n", - "0 0 0.009331 0.008854 0.981461 0.052457 0.000125\n", - "1 1 0.008846 0.008726 0.977990 0.065469 0.000250\n", - "2 2 0.008646 0.008260 0.975066 0.115246 0.000375\n", - "3 3 0.008594 0.008224 0.977431 0.119500 0.000350\n", - "4 4 0.008593 0.008143 0.975767 0.128147 0.000625\n", - "5 5 0.008575 0.008300 0.981175 0.111195 0.000750\n", - "6 6 0.008562 0.008318 0.981980 0.109136 0.000875\n", - "7 7 0.008502 0.008320 0.982643 0.109381 0.000700\n", - "8 8 0.008484 0.008126 0.979342 0.129930 0.000700\n", - "9 9 0.008474 0.008101 0.977593 0.132546 0.000700\n", - "10 10 0.008469 0.008078 0.977144 0.135049 0.000700\n", - "11 11 0.008436 0.008046 0.976337 0.138554 0.000490\n", - "12 12 0.008428 0.007944 0.974389 0.149568 0.000490\n", - "13 13 0.008424 0.007950 0.974593 0.148910 0.000490\n", - "14 14 0.008416 0.007949 0.974523 0.149105 0.000490\n", - "15 15 0.008389 0.007967 0.974943 0.147168 0.000343\n", - "16 16 0.008380 0.007942 0.974692 0.149762 0.000343\n", - "17 17 0.008376 0.007953 0.974729 0.148579 0.000343\n", - "18 18 0.008373 0.007932 0.974497 0.150832 0.000343" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# embedding_metrics = checkpoint_utils.get_training_metrics(metric_learning_trainer) \n", "\n", @@ -1504,65 +450,66 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<IPython.core.display.Image object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "perfplot.plot_training_metrics(embedding_metrics, CONFIG, \"metric_learning\")" + "perfplot_mpl.plot_loss(embedding_metrics, CONFIG, \"metric_learning\")\n" ] }, { - "attachments": {}, - "cell_type": "markdown", + "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ - "## Evaluate model performance on sample test data\n", - "\n", - "Here we evaluate the model performance on one sample test data. We look at how the efficiency and purity change with the embedding radius." + "perfplot_mpl.plot_metric_epochs(\n", + " \"eff\",\n", + " embedding_metrics,\n", + " CONFIG,\n", + " \"metric_learning\",\n", + " \"Edge Efficiency\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n", + "perfplot_mpl.plot_metric_epochs(\n", + " \"pur\",\n", + " embedding_metrics,\n", + " CONFIG,\n", + " \"metric_learning\",\n", + " \"Edge Purity\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n" ] }, { - "cell_type": "code", - "execution_count": 22, + "attachments": {}, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "metric_learning_model.load_testset(\"velo-minbias-sim10b-xdigi-nospillover\")\n" + "## Evaluate model performance on sample test data\n", + "\n", + "Here we evaluate the model performance on one sample test data. We look at how the efficiency and purity change with the embedding radius." ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABwgAAAJYCAYAAAB2JbLWAAEAAElEQVR4nOzdd3iUZdbH8e+0ZJJJB0IgBEKvCVVBwcUCroq9i20VbNgolrVtiNjWlWKlKLoqutZ37e6KrAUEURHp0nsSEhLSM8mU5/0jZiQmQAKZzCT5fd4rl5mnnvtZXznMee5zmwzDMBARERERERERERERERGRFsEc6ABEREREREREREREREREpPGoQCgiIiIiIiIiIiIiIiLSgqhAKCIiIiIiIiIiIiIiItKCqEAoIiIiIiIiIiIiIiIi0oKoQCgiIiIiIiIiIiIiIiLSgqhAKCIiIiIiIiIiIiIiItKCqEAoIiIiIiIiIiIiIiIi0oKoQCgiIiIiIiIiIiIiIiLSgqhAKCIiIiIiIiIiIiIiItKCWAMdgL899NBDrFu3jqKiIsLCwujUqZNvX2lpKT179uSee+4BYMWKFbz44ouUlJTgcDhISkri/PPPZ/bs2eTl5REbG0tkZCQpKSm8/fbb3HPPPYwYMaJOcbzxxhv1PkdEREQkGP0xv2rfvj179uyhVatWnH766Vx++eVYLJZjvk9eXh533nknrVq1YsaMGZjNerdNRERE5GB/zMu6dOnCrFmzAh2WiIiINAHN/luWadOm0b9/fwC6dOnCs88+6/u54447fMd5vV6mTZvG1q1bueuuu5g1axZJSUk88cQTbNy4kZtvvplnn32W7t27s2rVKsrKyli/fn2d4ziac0RERESC0R/zqzlz5jBjxgyysrL45z//yT//+c8GuU9GRgZZWVn8+uuvlJWVAbBhwwZGjx7N6NGjqaioaJD7iIiIiDRVf8zLVBwUERGRumr2MwgPp127dpxyyikAFBQUUFJSAkBsbCx2u52rrrqK119/HYC4uDjMZjPjxo0jOzubH3/80XduXdx11131PkdERESkqejRowc9e/Zkw4YNfP3114wbN+6Yr9mvXz8eeughYmJicDgcDRCliIiIiIiIiIhACy4QTpkyhbvvvpvjjjuOoqIi7r//ft++Rx99lJCQkGrHz5w5k/j4eI477jj+9a9/kZ+fz8qVK3nwwQcB2L9/P/Pnz2f16tXEx8cDkJiYyIQJE/jPf/5T6znr1q3jlVdeobS0FLfbTbdu3bj55puJiopi2bJlpKen4/F4iImJ4dJLL+Wdd97B5XJxxhlncPPNN/ti+/LLL3nvvfcoLS2lY8eOOJ1OzjvvPDZt2sR7772H2+0mPj6eRx99lNDQUO677z6cTid33XUXQ4YM8fejFhERkRaiakafzWbjf//7Hy+++CL79++nb9++zJo1i5kzZ/L5559jGAbTpk1j2LBhXHnllWRnZwNw7bXXsnr1alavXk3fvn0pLS1ly5YtAMyfPx+LxcL06dN995s8eTLR0dF06dJFOY+IiIjIYWzdupWXX36Z3NxcLBYLNpuNsWPHcvzxxwPwzTff8MYbb2AymYiLi6OgoIBTTz2Viy++mK1btzJnzhxycnJo27YtxcXFdOrUybdkj4iIiDRNLapAuHnzZq677joA3xdRAJGRkTz66KNcdtllADzwwAN07NgRj8fDGWecAcCkSZPo168fALt27eLTTz/1ne9yubjnnnvYvXs3t9xyCxdeeCFOp5MbbriBkpISLrzwwhrn7Nq1i7vvvhuTycR7773Hli1bmDx5Mvv27WP69OmccMIJ3HvvvTz22GMUFBSQmJjI/Pnzueqqq3j//fcZMWIE/fr144svvuAf//gHbdq04aWXXiI8PJyPP/6YH374gSlTppCdnc3//vc/OnfuTHJyMgAnnngigwcPZvDgwX593iIiItJyLFu2jK1btwJw5plncuqpp5KZmVmt3eikSZP43//+h9Pp9G2bN28et956K3v37uU///kP999/P6WlpbzzzjvV8jOofPlqypQpvjbxM2bM8L3UpZxHREREpHbbt2/n9ttvx+Px8PbbbxMREcH111/PAw88wEMPPcSgQYN47LHHcDgcvPfee5jNZlauXMkHH3zAxRdfzPTp09m8eTNz586lS5cuFBYWcuuttwZ6WCIiInKMmv0ahAfr3r07r7zyCq+88gq9evVqsOv+9NNP7N69G6j8IgrAbrdzzz33EBkZWes5n376KS6Xi3bt2hEWFub7Imv16tVs2rSp2rGhoaGceOKJREVF0bZtW6AyuQP497//DcCAAQMIDw8H4LTTTvMVNs855xwAfvjhB7KysnC73axatYqBAwc21PBFRESkBdu2bRs333wzzz//PKmpqdx1111cfPHFdT7f4XBgMpkAOOmkk+jTpw9Dhgzh3nvvrVccynlEREREavfxxx/7voOKiYnBarXSrVs3AN5//31KS0vxer0UFRXx8MMP89lnn9GpUydfPlZUVATA9OnTefvtt8nLy2POnDkBG4+IiIg0jBY1g/Bg48aNIzY2tkGutW/fPt/vERERvt9TUlKOeE5mZiY33XQTADExMQBkZWXRo0cP37F2u933u9lcWdN1uVzVrnPwfcPDw+nbty9QuXZPly5d2LZtG59++ik9e/Zk6NChvuuIiIiIHIsuXbowa9asBrlWQkKC7/dWrVqRl5dX53OV84iIiIjUrqqL1sHfL1V1YcjJySE+Pp7LLruM9957j++++47vvvsOs9nM+PHjueSSS7jhhhuYOXMmmzZtYtOmTbz00kuMGDGChx56SLmWiIhIE9Zi/xTv06cPhmGwcuXKY75W1aw+gOLiYt/vmzZt8r1ldahz4uPjmTt3LnPnzuXdd9/l+eefZ9iwYfW+98H3LSoqqjYLseqN+s8//5xPPvmE008/vc7XFxERETlaVV88eb1eAAzD8K1TWJtj/YJJOY+IiIjI71avXs327duJj48HqNbmvaysDKj8XqqiooIzzzyT9957jwcffJCBAwfi9Xp55ZVXMAyDpKQk3nnnHZ588knOPvtsAJYsWcLGjRsbf1AiIiLSYFpsgRAgPz+fBQsWHPN1Bg8eTFJSEgDff/89UFmkmzp16iHP+fOf/4zZbCYjI4PMzEyg8o2uO+64A4/HU+d7X3DBBQCsWrXKl+h98MEHLF682HfMqFGjCA8Pp6CgAK/XW+3tfBERERF/6dSpEwD79+/HMAzWrVvnKxYerYPbt5eXl/P666+zdOlSQDmPiIiIyMF++eUXtm7dyjnnnIPNZiMzM5OCggLcbjdbtmwB4KKLLiInJ4eHHnoIq9XKyJEjueaaawCIi4vDZDLx0EMPsW/fPgYOHMiECRMIDQ0FaLDOXCIiIhIYJsMwjEAH4U8PPfQQ69ato6ioiLCwMN8XVVDZptPhcPDYY48xceJEX3LUpUsXLrvsMj7++GPWrl0LQMeOHTnvvPNwu93861//Ij8/n8jISC655BKuuOIK9u/fz8svv8yaNWtISEjAZrNxySWXMHDgQP7v//6v1nNWrlzJq6++Sk5ODp07d8ZsNnPFFVfQu3dvVq9ezfTp08nIyMBisXDeeecRGRnJW2+9RXl5OfHx8dxyyy2MGDGCRYsW8d5771FRUUG7du1o06YNEyZMwGaz+cb63HPP8eGHH3Lfffdx6qmnNu7/CCIiItKs1JZf3XTTTfTr16/acYZhMGvWLL7++ms6derEiBEjeP3113E6nXTo0IH777+f//u//+Obb77B5XKRkJDAn//8Z6666irKysqYPHlytfzs73//OzExMTz11FMsWbKE9u3bEx0dzQMPPOBrt66cR0RERFqSw33vlZOTw/jx4xk1ahRbt27l5ZdfJi8vD6vVitls5sorr+T4448nPz+fRx55hMLCQuLi4sjIyKBt27aMHz+enj178ve//51NmzbRpk0b8vLyMJlMXHLJJYwaNSqAIxcREZFj1ewLhFJpx44dTJw4kXfeecfX7ktERESkuVHOIyIiIiIiIiJyZC26xWhL8Nxzz2EYBjk5OYwePVpflImIiEizpJxHRERERERERKTurIEOQPwrMzOTm2++mfDwcP72t78FOhwRERERv1DOIyIiIiIiIiJSd2oxKiIiIiIiIiIiIiIiItKCqMWoiIiIiIiIiIiIiIiISAuiAqGIiIiIiIiIiIiIiIhIC6ICoYiIiIiIiIiIiIiIiEgLYg10AP507733cueddwY6DBEREQmQkJAQWrduXe/zLl3yFD8d2MKsQeM4N/E4P0TWdCm/EhERadmUXwUP5WUiIiLNQ6DyK5NhGEa9z2oiTCYTDTm8jIwM2rdv32DXa4pa+jNo6eMHPYOWPn7QMwA9g6Y0/vrGWuAs4aolT/FZ7hq8Xg9t7NHMO/4Wzk8c6scomxblVw2vpT+Dlj5+0DNo6eMHPQPQM2hK41d+FTyUlzWMljpu0Ng19pZHY295Y28q4w5UftWsZhCmp6czderUQIchIiIiTYTbW8CO3NmUVmzFYjIYvzCP7z0ucNgAyHEWcMHiR3ms2xQ6RbQjIS6Wk9q0xmYyBThyERERkeCk/EpERESkYfkrv2pWBcK0tDTS0tJ8n01KLkVEROQQDFws3XoKBWUrMQGhFiv7XadDaAj89iZ239i2RBf35/6lGyAuE0Js9IqKYtHJJ9Hebg/sAERERESCjPIrERERkYblz/zK3EhjEBEREQkqBaUrKHSu9H2ODRtMYnTPytenDLip+ylcEnMtPxfFQrt4sIcC8GthIc9s3hKgqEVERESCl/IrERERkYblz/yqWc0gFBEREamr7JL9lJaDIxS8BkTb+2GxObAYFv459FbaWVMZ9dUiiAwFr9f3VhbA9pKSAEYuIiIiEpyUX4mIiIg0LH/mVyoQioiISIvkLdjF7jzo1Q5MgM3WjdHJvXkq+XoGxnQmr8LFr+ePYUtREZuKCtlcVMSGwiI2FBVjt6gJg4iIiMgfKb8SERERaVj+zK9UIBQREZEWx9i3mJ4/PEpm/HA2FH5HcjSEhHTjrwPO8x0TF2IjLsRGzwgHufmRrNxXTFRxOfH5Jaza52V/bxetI2wBHIWIiIhI8FB+JSIiItKw/J1f6fUsERERaVGM7GV4vr4aj6uQU4rcDGo9lYJyiLL3OOQ5IzuG8lOZi40mKI9yUGwPZ8LiHApd3kaMXERERCQ4Kb8SERERaViNkV+pQCgiIiItimfprRjOXAzAXbiOYdnZHNftE0KsCYc8p5PDyguj2oMJTBawhVtZU+Lh5iU5jRe4iIiISJBSfiUiIiLSsBojv1KLUZFafPPNN7z55puYzdVr6CUlJTgcjgBFFRxa+jM41vEbhsF5553HmWee2YBRSUtTXFyMcdCCw40tJCSEoqKigN0fwGQyERERcXTnth6CUbgZAANwbXuNbu1Pgej4Q57jKnWRvOxXxqZ04c01eRjeyuf/S27FUcUgIiIigVdSUoLH48FkMgU6FOVXyq/qJD09nalTpwY6DBERkWo8Hg+lpaWBDqNWgc6xgj2/UoFQpBYTJkzg/PPPJykpqdp2j8eDxWIJUFTBoaU/g2Mdf25uLjfccAN79uxpwKikpTEMg8jIyIDdPyIiIuBfpB1Lcmc54VmMov14d/8XU4gJzCZc312HLa4HxKbWeo6zqJw37v6M1Kv6smLkSfy6t5Bws4knjmt11HGIiIhIYFXlVIHOa0D5lfKruklLSyMtLc33OdD/zoiIiAB4vV6sVithYWGBDqWGQOdYwZ5fqUAoUouQkBAuueQSBgwYUG27y+XCZmvZC6a39GdwrOPfuXMnL774YgNGJCL1ZgnFevI/KZ9/CkbpAcxtO2CKcuDd/SHmQyRYB3YdwGYPZ+Xc7+mzp5Adfz6VpwZFc1r74Et+RURERBqd8isRERGRhtUI+ZXWIBRpBr7++muuvPJKRo8ezccffxzocEREgl9YFEbMJVRsaEX5xg649gzBtas97pVf4c3chlF8AADvthw8j77D/h25eL0eHK3icX78Mw/mbNaXVyIiIiIHU34lIiIi0rD8nF9pBqFIHRUVFfHxxx+zYsUKsrKysFgsxMbGMmzYMM4880xiYmICFtvJJ5/MiSeeyJgxY6ptLykp4brrruO6665rsmvefffdd7z++ut4vV48Hg9jxozhwgsvrNO5O3bs4IUXXiA3NxePx8PgwYMZP358tenuv/zyC//973/ZunUrJpOJ8vJyevbsyXXXXUdCwu8LvmZlZXH11VfXep+PPvooKKfQi8gRuMvwFuVB0XI8m5ZXbjObMNwuwu96BlN2V0pvnIct0U3OZZX93Q3DIC4mnuTwkAAGLiIiIhKklF+JiIiINCw/5lcqEIrUweLFi5k5cyYnnXQSN9xwA127dsVms5GXl8fSpUu59957ufbaaznxxBMDHWo1VquVtm3bBnStsmPxww8/8Mgjj/D3v/+d1NRUMjIyuP3226moqODyyy8/7Lk5OTlMmTKFiy++mCuuuAKn08l9993Hww8/zOOPP+477t///jcVFRXMmjWL8PBwiouLuf/++7n33nt56aWXqrUT7dq1KxdccEGNNQhDQvQXWZGmyNy6w+8ffutH73VXEHLqDXjeA+fcZzBhotxczv7NORiYwDAIsYQSl9g2QFGLiIiIBC/lVyIiIiINy5/5lVqMihzBV199xfTp00lPT+e2226jV69evqJRXFwcZ599NrNmzeLDDz/kp59+CnC01YWGhvLss88yYsSIQIdyVObOncvw4cNJTa3sqdy+fXsuuOACFixYQHFx8WHP/de//oXVauWyyy4DwG63c/311/PTTz+xYsUK33HJyclce+21hIeHA5UL144ZM4aMjAx27NhR7ZqtW7fm1FNPZdSoUdV+/lgwFJGmwXbKZVg69wPAcHlwHSjGZDsR72thOOd+BpgwDBeFu/aQuTITflvTOrpDFB2HdDj0hZuZ9PR0TCaT70dERETkUJRfiYiIiDQsf+ZXmkEochjZ2dnMmDGDe++9l5SUFFwuV7X9TqeTNWvWMHDgQP72t78xefJk+vfvX23W2cHS09NZsmQJAM899xxvvfUWP/30E06nkzvuuIMzzzyT1157jR9//BEAj8dDt27duOGGG4iNja12rQ8//JB33nmHwsJCunXrxm233VZt/+7du7n77rvJz89n5MiR3Hffffz000889dRT5Obmcuutt3L++edTVFTEDTfcwIEDBzj99NOZMmWK7xoffPABn332GWazGa/XS48ePTj//PPp1q3bMT/bI9m1axe7du2q0U50wIABvPrqq/z444+ccsophzx/8eLFDBw4ELP59/cg+vTpg81mY/HixQwePBiA6667rsa5paWlAERFRTXEUEQkSJkcUUQ8+iGeDT/gztqDNyOf8kkrcVdsBpOByWTB4y7FHWqm75jeGJiIbhvJwItTsNlbTgqVlpZGWlqa77OKhCIiInIoyq9EREREGpY/86ugzr42b97MrFmzSE1N5aabbgp0ONICvfXWW3Tu3Nk3A2/r1q3MnTuX7du307FjRy6//HLS0tJ47733iI6O5pRTTuH777/npJNOqvV6d955J0OHDmX69Om8+OKLnHXWWVxzzTXMnDkTqCw4fvLJJ7zwwgskJCTg9XqZO3cuDz/8MDNmzPB9Kfu///2P5557jltuuYWzzz6b7Oxs5syZU+1eSUlJvPXWW0yYMMG3bciQIbzxxhucccYZvm2RkZG89dZbjB8/vtr53333Ha+99hrz588nNjaWkpIS7r//fn766afDFgg9Hg9lZWVHfLZWqxW73X7I/du3bweotg4gQLt27QDYtm3bIQuE+fn55Ofn1zjXYrEQHx/Ptm3baj3PMAzWrVvH22+/zdixY2nbtvoU7JycHB5//HH27t1LeXk5vXv35oorrqBjx46HH6yIBDVL7+Ox9D4eAFvSRkpuno83Mx9MYD2pN8kv30LXhPjABikiIiLShCi/EhEREWlY/sivgrZAuH//fr7//nt69+4d6FCkhTIMg8WLF3PNNdcAUFRUxP3338/IkSN55JFHKCwsZPr06dXOGTRoEF999dUhC4QxMTHExMQAcOKJJ3LqqacCcPvtt2Oz2QgPD2f27Nm+wpTZbObss8/m+uuvZ/fu3b5C1GuvvUaPHj18s+s6dOjAOeecw/Llyxts/Bs2bCA8PJzo6GgAHA4H48aNo6Ki4rDn/fjjjzz00ENHvP6QIUOqrQX4RwUFBQC+1p9Vqj4XFhbW+9yqbbWdu3DhQl544QWcTieXXXYZV111VbX9ZrMZwzC48MIL6dOnD2VlZTzzzDPceuutPPPMM3Tu3PmQ8YhI02H9U08cc8dResdrmLvFE7HgNghVG2ERERGRo6X8SkRERKRhNVR+FbQFwtatW3P11Vczd+7cQIciLVRhYSH5+fm+otzixYtxOp3cfPPNhIaG4nA4uPrqq1m1apXvHLvd7mtPeSR9+/b1/d69e3ff7zt37mT69Ons3bsXqJyRB5CZmUnHjh0pKipi7969nH/++dWud/A1GkJKSgpvv/02d955J+eddx4nnHACqampNdqs/lGfPn146qmnjnj9yMjIo4rLMIyjOu9I548ePZrRo0eze/dunnrqKX744Qf+8Y9/4HA4AIiPj2fevHm4XC7MZjMOh4OJEyeyfPly/vnPf5Kenn5McYlI8LCe1JOolY8GOgwRERGRZqO55VeZmZnMnj2buLg48vLymDBhQo0ONlXeeusttm7dimEY9OjRg0svvdS3T52zRERE5Gg1RH4VtAVCkUBzOp0AvrX/srOziYuLIzQ01HdM69atq52zZ88e2rRpU6frR0RE1Ni2cuVKHnjgAa655hoeffRRbDYbWVlZXH311bjdbgByc3NrPb+26x2LoUOH8vjjj/POO+/w5JNPYrVaOfnkkxk/fjxxcXGHPM/hcNC1a9cjXt9qPfx/fqpmLv6xXWnV58OtD3ioc6u2He7cpKQk7r33Xq699lreffdd/vKXvxzy2LCwMDp16sSGDRsOeYyIiLQsXq+32vq3IiIi0vzMmDGDyy67jCFDhrB8+XKefvrpWjvkrFmzhqVLl/L0008Dld2DUlJS6N27d9B3zlJOIyIi0vw1iwJheno6U6dOrXWfyWRiypQpTJ48uUHulZGR0SDXacpawjNwu93YbDagsl2ly+WiVatW5OXlUVxc7CsSZmZmAuByuXC5XHz00UeMGzfusLPsqgp9VeccbNGiRdhsNt8bhQcf43a7cblcvuJWVVxVDhw4AFTOODx4u2EYeL1e3zav11vrcWVlZdWOA+jfvz/9+/cnJyeHzz//nHfeeYeysjLuv//+Q45v+fLldZpNN3jwYKZNm3bI/R06dAAqi64pKSm+7bt37wagU6dOh3zODoeDmJgY9u7dW+0Yj8dDTk5OtZmQTqezxlqIbdq0ISwsjE2bNvmOKykpISQkBJvNVu2aJpOpxnM7HJfLhdfrbfL/f9RQ8XvcHizWY2svdKzX8Hq8mC31/4tv1TM42vMBXrrrTTYs2Uy3wcnc8vy1dT4vJCSEiIgIXBVuPC4PZrOJkLCQet/f4/bgKndjMpkICbP51jmtC8Mw8Hq8VJS7MAEh9hBM5rqfD2B4DSqcFRgG2Ow2LPV4juXl5RQVFR3xuPqMSeRYeL1e/nr6NPZuyeLPfzmFa6ZeeuSTREREpMnJzc1l3bp1DBw4EKj8u216ejr5+fm+JUWqfPnllwwdOtSXkw4bNoyFCxfSu3fvoO2cVVHu4r4zHiFz6z4umnw2F008O9AhiYiIiJ80iwJhWloaaWlpNbabTKZjbkd4sIyMDNq3b99g12uKWsozsFqtxMbGEh0dza5du0hJSeHkk0/mlVdeYf78+YwfP56ioiLeeustoLId6SuvvELPnj2P2OqzauaczWbzFSGrVBXvbDab7029qvXyrFYrNpuNuLg4EhMT+fXXX6udv3PnTgAsFku17SaTCbPZXG1bVFQUxcXFvm0lJSXk5uZWO+6jjz6iR48e9OrVi/bt2zNu3Dj27dvHli1basR9sNTU1Dq3GD3cdbp27UrHjh1Zs2YN5557rm/7unXrCA0NZdiwYb7zi4uLcbvd1f4ydtJJJ7F06VIsFovvWW7cuJGKigpGjhyJzWajoqKCsWPH8sEHH2Cx/F5gKioqoqysjOjoaN89Zs+ezaBBgzj11FN92yoqKti1axc9e/Y87FgOVvW/bUP8/9H67zeydslGUk7qRe+hPep9fs7u/Xz11nd06NmeE889rs7nVf13wOPx8O+nPyOmbTSjrvxTve//y1drmT7uBcxWC/9YlEZ8Uusjn3SQ7N37ue+MR3CWVnD3yxMYcEq/ep1fVlzG5JFp5GXlM/7xKxl9zcg6n5uRkUG7du24e9TDZG7N4pQrhjP+8auOfOJB/nH98yx+q3Ld0P178ggLC+P+NyfW6dyioiLcLg+eCjcG4PEYlJdVYA8PPeK5VdyuyuKgYRgYhkFFaQX2CPuRT6SyOFhZ3HNV/g6++9e1SGh4K2Ou+nPa5XRhsodgsdatSBgaGlpjFndtmnoxXpqO24fdx6aftgHw5hP/h9lq5qoHLw5wVCIiItLQsrKyiIqK8v0d0mq1EhUVRVZWVo0CYVZWFj179vR9jouLY/369Y0Zbr14vV5uGnAXezZW5tAv3vs6gIqEIiIizVSzKBCK+IPJZOLEE0/k22+/ZcyYMURGRvLYY48xd+5cxo4dS6dOnbjiiivYsmULL7zwAueccw4jR9a9wFCbE044gYULF/Kvf/2LK6+8krKyMl5//fUax11zzTU8/vjjfPDBB5x99tns37+ff/3rX3W+T2pqKt999x2XXHIJdrudN954g/Dw8GrHbNu2jZUrV3LfffcREhJCSUkJW7dupX///oe9dlRU1BGPqasbb7yRqVOnsnbtWvr160dWVhb//ve/ueqqq6q1VL3tttsoLCzk7bff9hXqrrjiCr7++mveeecdLr/8cpxOJ/Pnz2fIkCEMHjzYd67T6WTevHmMHz8em82G0+nkmWeewWKxVCtMArz99tv069ePxMREvF4vc+fOpbS0lCuvvLLacXfeeSfh4eG1tpg52JL/W87ezZmcfPlw2naqW2vaKhu+38SDZz9BUV4xkXERPPbZA/Q6vludz8/LOsCdwx8kZ08ujmgH97x6a72KhBXOCsb1nUTW9mzCHKHs3ZTJtemX1fn8lYtW88jlsyjMrZwBdtvx9zH966kkdmtXp/P3bslkyslTObAvHwODaZfO4L4FdzBoVGqdzndVuLi+90T2783DwOCZW+fhrnDz5+tOqdP5Xo+XO4bdz68/bgHgvRkfk59dyDk3n05JQSnF+SW//bOU4vxi3+8lBaWU5JdQnF/CzvV7ql3zq7e+46u3vqvT/R/6v0kMOW1gjZhKi2q21a0rr2Ec0/mGYVBW4jzk/s//8znLli8jxGbDarVy7dV/YfbcF4iNjWPv3j1MuHkCPXv3woLaGEnTs3PDHgr2/z6j1VPhYdVXa1UgFBERaYYO9SJ6bZ0rajv2aDpcNFbnrG2rdlGYW+j77HF5+e6jHzjh0kHHfO1g15JfLNTYWyaNvWXy19gNwyAqKqpBJ2sdi5UrV/Laa6+xa9cu3n///YDGFewdsExGsPyvVot58+bx888/AzBo0CBuvPHGep2vGYQNr6U8g4EDB/LKK6/Qpk0bbrjhBh5++GGGDBmCy+Wq80yx2rz88st8/vnn5Ofn06pVK7p06cJjjz1W7Zj333+fDz74AJfLRUJCAqeeeirPPvss0dHRnHXWWVx//fVA5Qy/t99+m8LCQpKSkrjxxhu5++67iYyMJCUlhRtuuIF7772XvLw83xuNb7zxBgD79u1j+vTpbNmyhbZt2/KXv/yFF198kX379tGqVSv++c9/snbtWt5//3127drla6t5/PHHc+WVVzb4eoeHs2TJEhYsWIDX68Xj8TBmzBguvPDCasfcc889FBQUMHv27GprJGzfvp3Zs2eTm5uLx+Nh0KBB3HDDDYSFhQGVf3h9+eWXfPXVV+zbtw+LxYLb7fYVf3v0+H1W3tatW/n0009ZvXo1ZrOZoqIikpOTueqqq+jbt2+1eC6//HLOOOOMWtcv3LlzJyNHjmTBzLd5atxsSvJLiEuI4YWf/k6r9jXXdiwrcVL6h4JT0YFinr/zFYp+K65hGDiiHYy5aVSd14hY9Ma35OzOBZMJDINQRyhnjT+N0LAjz0ArKipi3beb2LFmV+X5QGhYCANHpRIeaafC6cJV7qLC6ar2u8tZQUW5G5ezgpLCUlzl7t/ir/yHyWyq8x+GVTPYqk43HdP5BiZMYDJhruvst4POx1QZQYg9hOR+STiiw4mIcfz2z3AiYiJ8vzuiw3HEOIiIcfDmY+/zzTvLfNc87cqT+Ovrd9Tp/kVFRdhDw3CXu6oeHxaLmdB6zCD0uDxUlLt8f06azCbCHPWbQXjwDECTyXTIGYSlpaVccMEFvPXWW8TGxvLZZ5+xft16IiMiufqqa1i7bi2t4lrRuWtyndu1FhUVERkZecTjer67C4CNl3Ss03XlyJRf1e62oX9l449bAbBYLVybfilX3HfhEc6q1FyewdFq6eMHPYOWPn7QM4DAPIPi4mIcDkeDfSFjGMZRX+tYzm0oyq/qZv/+/VxzzTV8/PHHvr9DnnvuubzxxhvExsZWO3bmzJnEx8f7XipdsGABeXl53HHH73l/VYvRm266qd6xNHRetnfvXv52+j/YtWGvb9u1D1/W7F96asn/DdbYNfaWRmP3z9hdLhdut9v3nWtDONa1cFetWkV6ejrvv/9+QHOsYM+vgnoGYX0LgiINLTExkTvuuIPHHnuMRx99lG7dap+hlZubS6tWrY54veuvv95X4DuUiy66iIsuuqjatj/OZKva9sftCxcurPa5qiD4R23btuXJJ5+stm3o0KHVPvfr149+/Wq2bKzrWnsNZcSIEYwYMeKwx/xxLFU6d+58yH1Q+Zep0aNHM3r06CPG0bVrV+64444jFomXL19OaWkpZ5111iGPMbwGM2+cS0l+CQB5Wfnc2H8KXVKT/zD7rISQUBvhNQpODrxuz8EDwRpiITK27oXbEHuor7iHyYTFYiEiNoKQ0CMXwL1mDyH2EDCZfMU1s8VM1wHJJPVoT4jdhi3URojdVu13mz2EkFArNnsI21Zt55HLZ1J8oBRM0LpDHE9/92id24zm7N7PHcMfYP+ePExAZFwE6R/cQ8qI3nU63+P2cG2329i3az8mTISGhzDlpVs45fLD/7tWJSMjg39cPpu1S34FTFitFi6afDbXP3JFnc4HePCtyYRHzeHnhasZcGo/7po/oc7nAthCKv8I97jcmMxmQuu5BqHFZuGzZz/jozlf4K5wExJq47zbz+T8286s0/lmS+U9K5wV8NszPFTClZubi9fr9X1hctZZZ/H111/TuUtnzGYzqSkphNhDjnotR5Fg8Myyx7g0YTxFB0oYc9OoOhcHRUSk6fvm3WW88ch7lBZWdmM464ZRjL1ffw40V61bt6ZPnz6sXLmSIUOGsGLFClJSUny57rJly+jduzcxMTGcdtppvPTSS4wdOxaA77//nltuuSWQ4R+WyWRi9s//4P6zHiVjcyaX3XsBbz76PikjetP/5L5HvoCIiMgxenrCiyx+/3usIVa6pnZi/BNX0jmlU6DDaraCukAoEgzOOOMMrFYrDzzwAKeccgpnnXUWnTtXfqmdnZ3Nf/7zH9asWcMTTzxRbR07af4Kcgpxu93ExsdgtphxuVzMmTOHBx54gPj4eADcFW7Kyyoqf0rL2b01g8LcIkrcpdWu1bpDK8Y+cOEfZp85sFhr/3cqc9s+Jp70EHmZB2jVLoZZ3z1KQnJ8nWM/68ZR3NT/Lgr2FxEWEcoD/5pU5/acGRkZXJ9+Jdf1upOcPblExjq48M4xXP7XC+p8/8GjBzDto/uYPn42thArj//nQVq1iz3yib9pk9Sa55Y/wX1/foSKChd3zZ9Av+G96ny+xWph/oZZPDDmcTK37eOGJ6/m5EtPrPP5ADO/ncZ9ZzzCro17Of2ak+vVYrXK5Hk31/ucg9lCrL5CYX3Nu/t1Pp7zX5wl5b5t8//6Bjm7c7nh73VbT9FsMWP/bdbhF198waJFi4iOjqaoqIjx48fTtWtXNm/e7Hsr+sEHH/Sdu3XrVnJzc1m5ciVXXnklvXvXrbgrEqzMZjNlxeWccO4QUk/qE+hwRESkkXzw/Oe8fP+/KDuoVfvbT35A5vZ9THmx7oWg/Px8Zs2axdKlS/nLX/7C6tWrOXDgAB06dGDSpElERkby7rvv8uGHHzJ06FBuv/12fv75Z+bNm4fNZuPZZ59l9erVPPbYY+Tm5jJ16lReffVVtm/fzrhx47j88sv9MfwWa9KkScyZM4fFixeTl5fHxIkTffsWLFjA2LFjGT58OKmpqQwbNoxHH30UqHwB9uAONPPmzWPlypW+34PhRfmQUBtPLZqKx+PBYrFw3q1nMOWUNE7dNIIxNx755VoREZGj4XF7uCF1Mtk791NeVgFA7t48Vn2znllLptFtQOdjur7b7ea1115jx44dhIaG4na7ueWWW3zf4f7000+8//77REdHc+DAAXr06MG4ceNwuVzMmjULp9OJxWKhsLCQcePG0b1792MeczBQgVCkDkaNGsWQIUP48MMPefbZZ8nJycFut5OQkMDJJ5/MVVdddUxTniUw8rLyMQyjXoWpKjl7csnPLgTDoCCniE59OuBxefnHo09heAz2bMqgvKwCs9lESFgooWEhRMQ4aNupNdFtonj85Qd4/KpnKMorJrp1JE/9b2q9ZgC269KWJ/77IGu+XU/qyD71Kg4CRMVFMnfVU3z77jI69GjHgFNS6nW+xWrhtS3P8em8hcQmxNRr/cIq/Yb3Yv66mUf9/zut2sUyb/X0o245EBoWylP/m3pMLQse/8+DQdEOqr7+75lPaxQHAZyl5Xz4/H+I79ia8249o87X+/7775kzZw6vvvoqkZGRrFixgr/+9a+8/vrrdO/enTvuuINx48bxyCOP+M655557GDZsWI2WwXJ0MjMzmT17NnFxceTl5TFhwgQSEhJqPfbHH39kyZIlhISEsHPnTi699FKGDBnSyBE3P+uXbaTrgGS6DejM9rW7GFnPlw5ERKTpWfbxT7yW9k614iBAaWEZX772DXHtYrnu4boV5mJiYkhPT2f06NFkZmby97//Ha/Xy9SpU3n66ad58MEHueSSS9i79/fWj4MGDeKCCy7gk08+ASrXmn/yyScZN24cO3bsYN68eXz99dd1WvdG6icxMZFp06bVuu/555+v9rlq9mBtgqEgeCgHvwA9/at0Zt40l91TXuXm6dcGMCoREWmu7hn1MLt/rblGYnlpOZP+9BBvbH+BqFZRR339l19+me3bt/PYY49hMpn4+OOPuf/++5k7dy4Wi4Unn3ySf/zjH3Tq1Amn08nkyZMZN24c//3vf3E6nTz00EMAvPfee2zevFkFQpGWJiYmhrFjx3LttUqGm4M9mzNxFjsxvAZFecUk902qcYzH48Xr8eJ1e/B6vHg8XlwVLtzlbgpyi+C3tR48Lg/bVu0kNDyEkLAQQsNCccQ4CA0LqTEDMK+osg3kwFNTeOjtSez6dS8nXzYcR1R4vcfQuV9HOvc7+r7UUXGRnH3T6Ud9PnDMb5A2RGH9WK9xrOc3teIgwAfPfF6jOFilvLScD577vF4Fwk8++YRhw4b5eqoPHjwYj8fD0qVLOfXUUxskZjm8GTNmcNlllzFkyBCWL1/O008/zeOPP17juOzsbD7++GPS09MxmUwcOHCA8vLa/12Q+vn5yzUMGpVCct8kvnzj20CHIyIijeCdf3xIUV5xrfvcLg8fPfefOhcID3b66ZU5utls5owzziAtLY177rmHkJC6t5QfM2YMACeffHK97y9Sm0lzb+K9GR/z4DmP88jH9wU6HBERaUaydmSzacXWQ+53Fpfz2YuL6tW97I8++eQTbr/9dt/3eKNHj+aZZ55h9erVDBw4kLCwMN58800uv/xyOnfuzAsvvABAWFgYq1atYtGiRQwfPpyLL25e6/KqQCgiTZJhGORmHsBsMhFXxxmAXo8XV4WbwtwiyoqcvgKfy+li+9pdmM3myoLgbz9mi9n3Y7GYMVvNYPqtIPSHdeBj2kbTpsOR16E8WMpJfUhRGzrxo9fT3+W19Hfqfd6ejRmMNl9SY/s1aZdydVrN7dnZ2WRmZlabIdi2bVtKS0trHCsNLzc3l3Xr1jFw4ECgskCbnp5Ofn4+MTEx1Y795JNPSEpK4uWXX8bpdNK5c+fDrpkqdbdy0RquSb+UVu1i2bF2d6DDERGRBvTJ3IU8fcu8ep9XnF9Sa0519k2juXP2oWeOVb10BRAdHQ1U/nnfrl27Ot/7jzmASEO4ePI5dOjRnr/0uJ1/bno20OGIiEgTdEPKZHasq//fmeff/ybz73+zxvYX18yodeLHwYqKiigrKyMq6vcZiHa7nZCQELKzswF44oknePPNN5k4cSJxcXFcddVVnHbaaZx66qlUVFTw/vvvM336dE466SRuvvlm39rDTZ0KhCISEG6Xm7ysfGwhVmLbxtTrXMMw2Ll+Dy6nC5PZRGlRGR16tMfj9uCqcOMud1f+s8L12z/duMrdGBjYQmyYTCZMJl99EEwQEeMgqlXk78VAS+2zylwuFzabjYL9ReRm5OH1erGF2OpdHBRpDFenXVJrQe+abreRuW3fIc9L6pXIy+tn1fk+8fHxxMfHc8cdd/i2OZ3OJtd62fjtPwomk4kfV/wCwHGDB1TbHoyysrKIiorytYGyWq1ERUWRlZVV48vBXbt2sWPHDubMmUNISAgPPPCAb3bCH6WnpzN16tRa72kymZgyZQqTJ09ukDFkZNRsI9KUeD1e1izZQJvulX9ByNq+j107d2O11X1t4qb+DI5VSx8/6Bm09PGDngE0/jOw2WyEhx+5k8eYG0cx5sZRNbZPHvk31i759ZDnRcQ4+L/cV2rdZxjGIbcVFhb6fj9w4AAAcXFxGIaBzWajoqLCt7+4uLjauX/8Z32Ul5c3eDvSpppfyaENO3swHXq2Z7T5El7eMIuknomBDklERJqQF9fMqLEta0c2N6RMPmS3K4Bxj4096hmEkZGRhIWFUVBQ4NvmdDqpqKjwrUEYERHBlClTuP322/nPf/7DE088Qa9evYiJieH000/nzDPPZNeuXTz55JPMnTuXv/71r0cVS0NoyPxKBUIRaXRul5tdG/bicXkwmUxUlLto27FNtWM8f2jtefDMvuKCUlxOFwCG16CsyMmWldsxmU3YQqxYQ6zYQm1YQ22ERYb5th3c7nP/3jwK9xdhYBAeGVbvAl9060hsoVY8Lg+RcXVfO1AkGFxw5xheum8BFaUVNfaFhodwwR31m1F2zjnnMGvWLMaNG4fD4cDtdnPPPfcwceJEunTp0lBhNwqTycSqtevZsn07ACGhIfTv1+eovmRrLIeKrbaEsKysjEGDBmG32wE46aST+Oabb2otEKalpZGWllbrdRvyeWRkZNC+ffsGu14g/PTfXxg0KtU3juS+Hak44KbjgMO/xVilOTyDY9HSxw96Bi19/KBnAIF5BsXFxb+9PHh0RarL7r2AHeueofhASY19VpuF828/s87XPnhd62+++Yb+/ftjGAYLFy5k5MiRhIaGApVr33399deYTCa8Xi8//PAD8Puf+3/8Z32EhobSunXrOhy5q17XbYr5lRxeh+7tWOh9l+t63cmN/7iaE87RetYiInL0EpLj6T64K2u+XV/r/tDwUMbcfGzLHI0ZM4ZFixYxatQozGYzCxcupGPHjqSkpODxeJgyZYrvZepRo0bxwgsvYLFYeOedd+jSpQsjR46kY8eODBgwgLy8vGOKpSE0VH6lAqFIC1WUV0xJYSmO6HAiY+tf4CordlKwvxB7eCgx8dFHPN4wjMqZfBVucvfm4XF5fNsL9xdRVliGYVCjvafFaq7W6tNsMWMyASZ8bT4tNgttklrVaxytE+MIi7BjGAYRMY56jx8gPDLsqM4TCbQLbj+T/Xtz+fC5/1Be+vvbWaFhIVxwxxjOubl+a1MOHTqU66+/nocffpiYmBjKysq46KKL6NKlC1u3buXFF18EKmeknXzyyaxdu5bt27dTUFDAli1buOeeexp0fEejKoFa8csqdu7ei9vtBmDr9h24XS4GDUit9sVdMElISKCwsBCPx4PFYsHtdlNYWOh7C+5gbdq0qTaz02az4XK5GjPcZunnRWsYdFqK73NyvyR2rN1NtwGdAxiViIj427Axg7j+sSuYd/frOIt/z6nCIu2cesUIrk2/7Kiu27FjRx588EH2799Pu3btuPPOO337Ro8ezfLly7nrrrto164dvXv35qOPPmLmzJlceumlvvVy0tPTufDCC0lJSTnUbfyuKedXUjev/Po0D537BHs2ZnDJXecGOhwREWnC/rHob9yYOoWs7dlUOH//niI0LIRnlj5KZEzdv/ddtWoVr776KmVlZTz88MM89NBDXH/99bz66qukpaVht9txuVw89thjWK1WDMOgR48ePPDAA0RHR3PgwAHuuOMOEhISSE1N5a233mLp0qV4PB7cbje33367Px5BnTR0fqUCoUgLVHSgmH07czC8BiX5pZgwERFb9yKZs6ScjK1ZeN1eivKK8XoNYuKjfK08qwqBv7f3dOFxeypn9oVY8Xq91a5nsZhp3aEVoeGhh23vebCsHdmUFpYBENMm6qiKnI7oI7cTEmmubnjiKuKTWvPBc5/jcroICQvhgjvO5Jyb/3xU1xs9ejSjR9d8m6tr16488cQT1baNHDmSW2+99aju4w9VidOvm7awY+fuav+N8rjd7Ni1G4cjnF49ugfll1itW7emT58+rFy5kiFDhrBixQpSUlJ8/fCXLVtG7969iYmJ4eSTT+all17yjWPt2rW+tQvl6P385Wrumj/B9zm5b9JRrakgIiJNzzk3/ZnY+BheT3+XkoJSTCY4+6bTueze84/6mv379+f882s/3+Fw8Pjjj1fb9pe//MX3+x/zrkBp6vmV1N20j/7K3LtfY8aNc5g87+ZAhyMiIk2UxWJh/rpZPHv7S3z77jIsNgvdBnTmxievpmPvDvW6Vv/+/Zkxo7KVaVWeYTabGT9+fK3Hm0wm7rrrrlr3DR48mMGDB9dvMH7ij/xKBUKRANm/NxdXhZvWia2whdT//xXzsvIpLy0nJj6asAj7EY+vWp/PVe4ie+d+DG/l2wYej5esHdmE59VtNpzhNXCWluNxezEBGJC7N4+8zAO+AqA11IotxEZEdPjv2/4wxt0b9+Iqr3zDoW1yGxxR9SvWJSTHV/4F3GzSTD6Ro3TerWdw3q01W0u2NFUJU7eunenVoxuFhUV89Pl/AfjzaacQFRWJ2+OpdmywmTRpEnPmzGHx4sXk5eUxceJE374FCxYwduxYhg8fzpAhQ9i2bRtPPvkkYWFhWCwWLr300sAF3gwUHShm344cug38fbZgcr+OfDL3iwBGJSIijWnEBUMZccFQvF5vk1uD2V+aQ34ldXfTP67hsxe/ZPLIvzH963ReefBfmC1m/vLw5YEOTUREmpjbnx3P7c+OV15VC3/kVyoQihwFwzDI3lVZZIvv2JoKVwUvvPACa9euBSoXPp02bRrr16/n5ZdfBirXfbryyis544wz2Ls5k7Jip2/9vKReifUqEubsySU/uxAMg9LCMhK7t8MaYvnD7D0X7go37vLKz5Xr89mwhlg4+L8PJirXx4hqFVmne7vdbrweL0737y10rCFWkvsl1esvdkk9EykpKMVqsxAaHlrn8w6mGYAi0hB+3bSFrp07YbPZgOpJVNXvVosFl8vF1u076dWjW0DiPJzExESmTZtW677nn3++2mcVBBvWykVrGHha9fZtVS1GRUSkZTmWL7Hy8/OZNWsWAC+88AK33HJLk1vL+WDNIb+S+jnrhlF06NmeM0Iux+upnNGw9KMfmffL9ABHJiIiTZGKgzX5I79SgVDkKOxcvwfXb72QS4vKWPLLN6xYsYL58+djsViZNGkiO7bt4NFHH+WGcTdy8kkn8+3ib1mzai39ewz0FQcNwO3ysPvXvYSGhdTp3oZhUFZSXjlNmMo1+3b/uheLzYItxIrT7eTt/3uLTZs3YjabaZ/YngkTJtChw+9Tsb0eLzvX78YwKv/j0bF3B8wWM/v27eOll15iw4YNWK1WHA4HV199NcOGDfOd63K5mPfyXBYuXFgjtosvvpibbrrJ9/mSSy4hPz+/1nH07t2bZ555pk5jFhFpaFWtFlasXMXGzVuqJU0Wi6XW3202Gz//soqSkhIGD+yvdlgCVLYXHTQqtdq2hOR48rMLcJaWYz/Kl2BERKRliYmJIT09PdBhHBPlV7JpxTZfcRBg94a9fPbSl5w1flQAoxIREWm6/J1fqUAoUk8H9uXjrnD7PntcHn5c9hOJ8R3YvS4Ds8XMHeMmsXHLrzidTjq1S6a0qIwhA49jyMAhWK1WTGYThreywIepchH7qLi6zeADg4qd+/F4Pb4tEbEO2nVpi9frZdKkSURGRjL/5flYrVbmzp3L3Xffzdy5c4mKigLAbDHTqW8SZUVOwiPDMJlN5Ofnc+edd9K7d29eeeUVbDYb3377LWlpaUybNo3jjz++WhTXXHMNcdFxWEOsWKyV/wHq1KlTjWjvueeeGv8Bevvttxk0aFAdxysi0vBMJhO/rFnHzj17sVqtFBUV+/aVlJT6Fn0uLCzC4/n9v7dWq5Wde/ZisVoZkNK30eOW4LNy0VouuevcGtuT+3Vkx9pd9Dq+ewCiEhERaXzKr/wvPT2dqVOnBjqMQ4qMiyAswk5ZsROAsAg7kbERAY5KRESk6fJ3fqUCocgRuMpdlBU7KS0qo6zIWW3xTwCT2USFp5x2bRLoPvj3FjB783cBkNQ9kbi4uGrnhEeFk7UjG8NrEB4ZRrvObesVU8deoezeuBfDqGwPmtA5HoDFixezfv165s+f75tq/Je//IVPP/2U9957j+uvv953DbPZXK1F58cff0xubi433XST79w//elPfPDBB8ybN69GgXDo0KH06NHj8HF27Mhpp51WbUp4fn4+M2fO5KyzzqrXmEVEGtJPP//C5m3b8Xg8eL1ePvzsP759Bvj+W7/wm285+BUHr9eL2eViw8ZNuF0uhgwa0KhxS3DZtzMHt8tNYrd2NfZ16tuBnev2qEAoIiIthvIr/0tLSyMtLc33OdhmW/752pPZtmoHn837Ekxw9s2nc9JFw458ooiIiNTK3/mVCoTSIuVmHmDG+NmEOkK5b8Ed2EJsvn27ft1LSUEpOXvz2GrawcJvvuC7HxZXFrlMcNZZZ/HnU88gLyOfrJxMZs2bQWFhIXsz9nL55b8vwF1RUQHALbfcgslkYvz48YwaVdlWIzwyjA7d2+NxewiLsNc7fmuIlaReHahwVhAeGebbvnjxYmJjY+nYsaNvm91up3fv3ixevLhagfCPNm3ahN1uJyEhodr2Ll268OGHH5KZmUm7djW/AD2c6dNrrjXw+eefM3jwYOLj4+t1LRERkWBT2/qDVTr368j2tbsaOSIRERGRwLplxl/wur3s272f6x8dG+hwRERE5DCaVYEw2FstSHDI3r2f24feR15WPgC/Lt/MxVPOYc23G1jz7QaiWkXgKncRHmHnv0s+44v/fcHMmTPp3LkzW7du5e6776asrIwrLhtL++4JvDPqHSZMmEBSUhL33Xef7z5fffUVjz32GLNnz64xgxAgxG4DKguTZWVl1aYAH0p4eLhvNp7VZsFqC6u2f/v27bUW8dq1a8cvv/xCRUUFISG1r3Vot9trzI6E399I3LVrV7Vrf/bZZzz77LOUlJQQERHBqaeeyrnnnnvYBWS9Xi+ffvopd9555xHHKiLiT0MGDcBqs7Ftx07cLhdnjj7Nt6+kpJSFX38DwOiRf8Lh+H229ecLF2G12eiS3EktsISfF61h2JjaW2Yn9+vIT//9pXEDEhERCSDlV1Klx5CuFBeUBDoMERGRJs/f+VWzKhAGe6sFCQ6vP/yurzgIsH9vHj98+jNjbhzNnbNvIKZNNAMHfovLqODDjz7kggsuoHPnzkBly8yzzjqLd999l0suuQSHw9EgMU2ZMoXNmzcf8bhnnnmG3r17H3J/QUFBrTPzwsPDMQyDoqIiWrVqVeu53bp14+uvv2bXrl3VZiBu3boVgNLS0mrXczgcPPHEE4SHh7Ny5UqmTZvGpk2buOeeew4Z348//ojJZGLw4MFHHKuIiD8ZhsGAlL543G42bt5CZOTva6NYLBZfDhEVFUl4+O8vY7jdbrp2TmZASt/DLvIsLcPKL1dzy8y/1LovuW8Hdqzb07gBiYiIBJDyK6lid4TiLCkPdBgiIiJNnr/zq2ZVIBSpzdrvfmX1N+tZ/e16Vn+znrh2MVisFjzuyhl7MfHRXJN2CX1O7FXtvK1bt+L1eunbt3qFvVu3blRUVLBhwwaGDBnSIDFOnDiRsrKyIx53cOGuPqoWKz2cc889lw8//JDnnnuOhx56CIfDwRdffOErXIaGhvqOve2226qdO2jQIC6++GL++c9/ctFFF9G1a9da7/Hxxx8zZsyYw84yFBFpDFWJ0eCB/XE4HLhcLt/6qwfP6D74d5fLxaAB/enVo1u1a0jLtH3tLmLio4mNj651f+vEVjhLnBTnlxAR0zAvFImIiAQz5VdSRQVCERGRhuHv/EoFQmmS1izZwIv3LqBNYhwPvDXJV3DyeDzVioFrvt1AnxN6kDqyDxdPOpuHP7iHEHsIrz/8Lh/P/i8Wm4UpL91SozgIv8+Ye/bZZ5kzZ45vu8fjweFwcODAgQYbT1JSUp1ajIaFhR12f3R0dK2FxrKyMkwmE5GRkYe99syZM3n11Ve57bbbCA0NpV+/ftx6661Mnz6dNm3aHPbevXpVPsMNGzbUWiDct28fK1eu5K677jrsdUREGltVwuT2eLBaLNVeqqj63e3xYLPZfMeKrPxyDQNH1b7+YJXkvknsWLebfsNr5hkiIiLNmfKrls3usOMscQY6DBERkWbFH/mVCoTS5Pzy1Vr+dsGTlBWWsQHY3m8SJ553PGu+Xc+vy7eQOrIPqX/qwzVpl5Lyp961zla7+m+XcPLlJxLmCKN1Ys31AaGyjSbAXXfdxfHHHw9QrULfkBqqxWjnzp1Zs2ZNje2ZmZkkJiYecv3BKm3btq3RIvT9998nPDyc5ORkoHIdwaKiohrFxqrnXNs6hgCffvopw4cPJyYm5rAxiIg0tqpWC1u2bmfdhl/xer2+xOq/i77CbDbTt3dPevXorrZX4vPzotWcfdPphz0muV8SO9aqQCgiIi2P8quWTTMIRUREGp4/8isVCKXJ+fD5/1BW+Pssucxt2RQfKObGf1xD3xN71vk6ST0SD7u/W7dumM1mtm3b5isQQmWR8Mknn+SWW24hLq724mJ9NVSL0ZNOOolvvvmG3bt3k5SUBEB5eTm//vor559/frVjc3JyiIqK8rUOdTqdbNiwgYEDB1Y7btmyZYwePdpXGM3MzOSBBx7gjTfeqHZcVYGze/fuNeJyu918/vnn/O1vfzviGEVEGpvJZMIwDHp270pJaQk7d++F8sovNCxWK506JNKzezd9eSXVrFy0lofemXzYYzr368j2tbsaKSIREZHgofyqZQuLsFNWrBmEIiIiDckf+ZUWApMm5ecvV7NpxVY46N/vuIQYrn9sbL2Kg3URHR3NpZdeyr///W927twJVLYXnT9/PkVFRQ1WHATo0aMH/fv3P+KPw3H4NYxOOukk+vTpw4svvojL5cIwDF599VXCw8O5+OKLfcdlZWVx9dVXM23aNN+2/Px8HnjgAbZt2wZUvpHw/vvvs3//fq699tpq98nOzubdd9/1vaGwdetW3n33XY477rhaZzguWbKE6OhoUlIO34pNRCRQfD3dB/Sna+dkrFYrVquVrp2TGTywf7VjWpr09HRMJpPvR2Dd0o10G5hMaFjoYY/r1DeJnet2N1JUIiIiwUX5VculGYQiIiL+0dD5lWYQSpOw/LOfWTDtPcIi7Nzzz9tY9uGPfPX2UkLDQpj13TSi4g69tt6xGDduHLGxsUydOhWTyYTVaqV///489NBDAOzZs4d7772XvLw8du/ezZVXXskll1zCpk2bWL58OQC33norkZGRzJs3zy8xHsxsNvPII48wd+5cbrjhBkwmE4mJiUyfPp2oqCjfcXa7nZiYGOLj433bIiIiGDp0KA899BDh4eGVU5L79mXWrFnV2onGx8dz55138vXXX/Pf//4Xj8eDYRiMGTOGsWPH1hrXxx9/zNlnn+2/gYuINBDDMOjfrw8V5RUA9O/Xp1pP95YoLS2NtLQ032d9kQcrF61h4GlHfumlqsWoiIhIS6b8quXRGoQiIiL+1VD5lQqEEtS+++AHFkx7j7iEGCbM/Au9h/UAoP/Ivlw05Rxat4/z+xeVF154IRdeeCFQcw3CDh061Gi1GWiRkZHcddddhz0mJiaGt956q9q2iIiIal8AH4rNZuPss8+uV8Fv+vTpdT5WRCRQDv7z5LjBA2rdLgKVHQ3+Mu3yIx4X0yYagPycAt/vIiIiLYnyq5ZJMwhFRET8pyHzKxUIJSh9885SFkx7j/bdEpj84s10H9SlxjFtElsFIDIRkcAzmUwUFRUF7P7l5eW+9UsDRV8qSaB43B7WLd1I6p/61On4qlmEA05RgVBEJNhU5VTBkFcov5LmxGqzYjKZcFW4sIXYjnyCiIg0aWazGbfbHdDvqg4l0DlWsOdXKhBKwNS2WOaXC75lwbT36Dogmfv/NZHO/ToGKDoRkeAVERER0PsXFRXRunXrgMYgEih1bS9a5fcCYT8/RiUiIkfjSGu8NyblV9LcVM0iVIFQRKT5s1gs1ZaoCibKsQ5PBUIJiJcf/BffvLOUTn068PAH9/L5/EW88cj79BvRi0c+/isderQPaHxdu3blmmuuqfF2gdfrxWw2Byiq4NDSn8Gxjt/tdtO9e/cGjEhERBrTii9XM3hUap2PT+7bkS0rt/kxIhEREWkp0tPTmTp1aqDDqJOqAmFkbGBfbhQREZFDU4FQGt38+97gvRkf43Z5yNiSxZn2Kxh11Z946qupJCTHBzo8AF566SW2bNlSY3tOTg5t2rQJQETBo6U/g4YYf+fOnRsoGhERaWwrF63hrvkT6nx8cr8kvnz9Gz9GJCIiIi1FWloaaWlpvs/B3LbM7rDjLHEGOgwRERE5DBUIpdGt/W4jbpfH9zk+qRVX/+1i4jsGT9EpJiaGIUOG1NiekZFB+/aBnd0YaC39GbT08YuItGSFeUVk79xPt4F1f9EjuW8SO9bt9mNUIiIiIsGnagahiIiIBC8VCKXRdR/cmXXfbcAwKj9Hx0cFVXFQRESaj6+GW1XUlwazctFaBp5Wv7UEI2Ic2B129u/NpXViKz9FJiIi0niUX0ldhEXYKSvWDEIREZG6CFR+pQKhNDpHdDg9juvGgax84ju2Zua30wIdkoiIiMgRrVy0moGn1X39wSrJ/ZLYsXa3CoQiIiLSYmgGoYiISPBTgVAa1ZJ/L2f76l089/3jeDweLBZLoEMSERERqZOfv1zDpXefV+/zqtqMDvnzgIYPSkRERCQIaQ1CERGR4KcCoTSajK1ZzLv7dV7b8hyAioMiIiLSZOzbmYPH7aF914R6n9u5X0dWL17vh6hEREREgpNmEIqIiAQ/c6ADkJbjxtQpzFs9PdBhiIiIiNTbz1+uZtCo+rcXBejUtwM71+1p4IhEREREgpfWIBQREQl+zapAmJ6ejslk8v1I8LjjxAd48su/YQ8PDXQoIiIiIvW2ctEaBp6WclTnJvfryI61uxo4IhEREZHgpRmEIiIiwa9ZtRhNS0sjLS3N91lFwuAw6+a5nH7tyfQ5oWegQxEREQHgrfc/4LwxZ/Ddsh+xhNhoH9+aiAgH6zZuoaSoiAvOOYsD+fms/3UzGVlZlJeXExnhoENiIv379cFqtWIYhnKNFuTnL9cw4enrjupce3gosW1jyNy+j3ad2zZwZCIiIsFB+ZUcTGsQioiIHDt/51fNqkAoweejF/6L2WLm7JtGBzoUERERn7CwMFwVLk4cNgQMsNqsmE0mYqKjAdi8bRs//7KGsLBwnE4nYXY7xSWl7N6bSXbOfo4b1J/WrVoFeBTSWLav2UlsQgwxbaKP+hpVbUZVIBQRkeZK+ZUczO6wk5eZF+gwREREmjR/51fNqsWoBJe1Szbwv38t4Y7nbwh0KCIiItWcPOIEIiIchIeFER4eRojNhtVqxREeTkFhET/+vAoDSIhvzTln/pmz/jyK0089mciIcFxuN18vWUpRcXGgh9Eo1MIdVi5ay8DT+h3TNdRmVEREmjvlV3KwMEcoZWoxKiIickz8nV+pQCh+UVpUxv1nPcasxdMCHYqIiEgNm7dup6KiAsMwMAwwDAMAj8fDL2vWEh4eTsfE9hw/eCAx0VGEh4XRpnUrRg4/AYvJhMViZcPGzQEeReNIS0v77TkZvufU0qz4cjWDR6Ue0zWS+yaxY93uBopIREQk+Ci/koPZI+w4i9ViVERE5Fj4O79SgVD84sbUKcxbPT3QYYiIiNSquNSJ01n+26y43xOs4pISCgoKKCkupl+f3hgYeL1eDMDj9WK1WunTuyeGAXszMgM7CGk0KxetYeBpKcd0jeR+SexYqwKhiIg0X8qv5GB2RyhOzSAUERE5Jv7Or1QglAb30Hl/59anryMhOT7QoYiIiNQqItyO3R560JbK1pnl5RVYrDbMZhNhYXYwwGw2YwJMJhOGYRAeFobH46G0rCwgsUvjWvvdr/QY3IUQe8gxXadzv45sV4tRERFpxpRf+V9Tav1ud9hxlmgGoYiIyLHwd36lAqE0qH/+7S16DunKCeceF+hQREREDql7187YbL8XfKq+X7FarbgqKjCAAwcOYDKZ8Hg8la0cvF5MJhP7c3MxmUyEhobWfnFpVhpi9iCAxWqhXZe27NmU0QBRiYiIBB/lV/7XlFq/awahiIjIsfN3fqUCoTSYb99bxq4Ne7nqoYsDHYqIiMhhfbt0OcW1LNIcEeEgKjKC0JBQVq1ZT0WFC4vFgslkwmKxcCA/nw0bt2AYBm1atQpA5NLYGqpACGozKiIizZvyKzlYWISdMq1BKCIickz8nV9Z/Rm8tBx7NmXw8gP/4p8bnwl0KCIiIkdUVlqK2fz7e1Imkwmv1yDEZqNtfDw7du0mKyeHL/73NV2SO+EIDye/sIBNm7fi8XrxeDz07tk9gCOQxuB2uVm/bBOpf+rTINdL7pvEjnW7GXHh0Aa5noiISDBRfiUH0wxCERGRY+fv/EoFQmkQN6ZO4YOC1wIdhoiISJ1cdN7Z1RIsr2FgNpvIzNrHnr0ZuN1uLGYz5RUVrN3wK06nk7DwcDCbMRkGQwYOIL5N6wCOQBpDQ84ehMp1CL99//sGu56IiEgwUX4lB9MahCIiIsfO3/mVWozKUXFVuPjlq7V43B5uG3ofM759mJBQW6DDEhERqZPPFy6ipKQUAK/Xi9lkIjfvAEuW/4jJbCEqMpKB/VMIsdkoLy8n1G7HVVFBTGQkp5w0nJ7du+L1egM8CvG3n79czaBRqQ12PbUYFRGR5kz5lRxMMwhFRESOnb/zK80glHorKy7j+t4T8XoNSgtLueHJq+h1vNqAiIhI0xFiD8PtdgNgNpspKCzk26XLMJvNmEzwp+HDiIqMpFuXzhQVFeFyuQkNDSUmOsp3jYPf4JLmaeWitdz1yoQGu16nPkns2rCnwa4nIiISTJRfycFUIBQRETl2/s6vlHlJvU3609/YvzePvMwDOEvK+frtpYEOSUREpF5SevUgIjICgNKyMr79bhlerwFeL386sTK58nq92KxW4mJjaRvfxpdcGYZBWZmT73/8KZBDED8rzCsie9d+ug3o3KDXTe6bxPa1uxr0miIiIsFA+ZUczGKxYLFZqHBWBDoUERGRJsvf+ZUKhFIvXo+XA1n51bbt25GjNiAiItKkFJeUYPy2WPP/vlmC22vg8bgZPux44mJjKts2mM0YhlHtByoXhHY6yyl1ugI8CvGnlV+uYeCohlt/sEqnvknsXKc2oyIi0vwov5I/0ixCERGRY+Pv/EoFQqkXs8XM+CeuwmK1ABAaHsINf79KbUBERKRJ2ZOVTUlJKWazmQ7t22G1WDjx+ONIaBvvS64AMJkwHfRjGJVvYIWFhRIVER7YQYhf/bxoDYNOa/gCYed+HTWDUEREmiXlV/JHdocdZ4kz0GGIiIg0Wf7Or1TVkXobfc1IbKFWhpwxgCkvTeDky4YHOiQREZH68XoIC7NjMpkYkNqPUSNH0CGxPVC9N7vpD6eZTJVvYIWEhNC9a8O2npTg8vOXqxk0KrXBr5vcL4kdazWDUEREmiHlV/IHmkEoIiJyjPycX6lAKPX27XvLOO6MgTz+2QOccrmKgyIi0vSccNxgXG43Ho8XZ3k5ZouFMqcTj8dLcUkJRcXFGIZBSUkpJaWluN1uKlwuSkvLKC0ro7i4hK+XLAv0MMRPsnZkY3gN2nVp2+DXVotRERFprpRfyR+FRdgpK9YMQhERkaPl7/zK2ohjkWbi03lfcund5wY6DBERkaP27oefEBUZxcnDh7Fxy1bKKtyEhVjp2a0r337/A0UFBVx20fl8+fW3hDsi6NOzK8XFJWRk78dT4WL4CcdRVlYW6GGIn6xctIaBfmgvCtChezv27dyPq8KFLcTml3uIiIgEgvIr+SPNIBQRETk2/s6vmlWBMD09nalTpwY6jGYtZ1cuGVuyGDy6f6BDEREROWpXX3ax7/fjBw+stu+cP4/y/X7emDOq7evZvZvv98svOt8/wQWZlphf/fzlak4873i/Xb9T3w7sXLeHbgPVRk1ERJoP5VfyR1qDUERE5Nj4O79qVi1G09LSMAzD9yMN76sF3zHmxlFHPlBERESahZaYX61ctJaBp/Xz2/WT+3Vkx9pdfru+iIiINE/p6emYTCbfT7DTDEIREZHg1qwKhOJ/X72xlDE3jQ50GCIiIiJ+sW31TuLaxRDTJtpv9+jcryPbVSAUERGRempqL26pQCgiIhLcVCCUOvv2vWX0Gd6DyNiIQIciIiIi4hf+XH+wSnLfDuxYt8ev9xAREREJtLAIO2XFajEqIiISrFQglDr7ZO5CTr16eKDDEBEREfGLl+57g3enf0zX/sl+vY9ajIqIiEhLoDUIRUREgpsKhFInmdv3kbl1H31P6hnoUEREREQa3N/Of5L/m/UJuRl5vPjXBeTsyfXbvdp2akPh/iLK9IWZiIiINGNhDrvyHRERkSBmDXQA0jR8MnchZ2vtQRERaabWrl1bp+P69evn50gkEH5etJr1S3/FVe4GIH9fAf/821vc/fKtfrtncr8kdqzdTe+h3f12DxERkUBSfiV2RyiFeUWBDkNERKTZaOj8SgVCqZPP5n3Ja1ufo6isMNChiIiINDh9MdWyxbaNwRYW4vtsC7XSOrGVX+9Z1WZUBUIREWmulF+J1iAUERFpWA2dX6nFqBzRN+8uY9CoFCJjIwIdioiIiEiD69yvI3e/PIGIGAe2UBv9T+nHddMu9+s9k/smsWPdbr/eQ0RERCSQ7I5QnCXlgQ5DREREDkEFQjmiT+ctZMyNai8qIiIizdeg01I599Y/c9wZA3j8swf8fr+qFqMiIiIizZXdYcepNQhFRESClgqEcliZ2/eRuXUfg0alBjoUEREREb9yRIWT2L1do9xLMwhFRESkudMMQhERkeCmAqEc1idzF3L2TZo9KCIiIs1fWYmTMIe9Ue7Vqn0cFWUVFB0obpT7iYiIiDQ2FQhFRESCmzXQAUhw+2zel7y29blAhyEiIiLid+WlFcS0iWq0+1W1GW3VNbrR7ikiIiJ1k5mZyezZs4mLiyMvL48JEyaQkJBQ67FvvfUWW7duxTAMevTowaWXXnrEfUVFRcyePRuHw4HL5SIpKYmLLrqoUcbWWMIi7JQVq8WoiIhIsFKBUA7pm3eXMWhUCpGxEYEORURExC8Mw6j22WQy1dhfl23SPJSXlhMaHtpo9+vUN4md61QgFBGR5qW55FczZszgsssuY8iQISxfvpynn36axx9/vMZxa9asYenSpTz99NMA3H777aSkpNC7d+/D7ps/fz5t2rThuuuuA+Cee+6ha9euDBgwoNHG6G9ag1BERKRh+Cu/UotROaRP5y1kzI1qLyoiIs1TVaJ08E9t+wFy8w6QkZXFgQP5vm1/TM6k6XOWlmNvxAJh534d2b52V6PdT0RExN+aS36Vm5vLunXrGDhwIACDBw9m1apV5Ofn1zj2yy+/ZOjQob7xDhs2jIULFx5x344dO0hKSvJdJzk5ma+++sr/g2tEajEqIiJy7PyZX2kGodQqc9s+MrftY9Co1ECHIiIi4hcmk4nsnP1s3LwFq9VKrx7diY2JrrY/Ny+PlavWcqCgkFB7KM6yMtrGt2FgSl+iohqvFWUgpaenM3Xq1ECH0SjKSysIDQ9ptPsl903i2/eWNdr9RERE/K255FdZWVlERUVhsVgAsFqtREVFkZWVRUxMTI1je/bs6fscFxfH+vXrj7gvJSWFn3/+mVGjRuF2u1m3bh3R0bV3FThcPmYymZgyZQqTJ08+2uFWk5GR0SDXAXCWlFNWXNag1/SXphCjv2jsLZPG3jK11LE3hXEfbqafP/MrFQilVp/MW8jZmj0oIiLN2Ko169i4dStWiw2T2cSu3XsZkNqPnt27ArA/L49vliyjoqKC1L59iImOIic3l01btvHV4qWcOnIEkRHNvw13WloaaWlpvs/B1v6rITlLnNgd9ka7X9UahCIiIs1Fc8mvDvWmfW15UG3HHu6N/ap911xzDe+++y7PP/884eHhpKSksH///lrv+8d87OBrNeSsy4yMDNq3b99g14PKF7Aa+poNzR/jbio0do29pdHYW97Ym8q4D1fE9Gd+pQKh1OrTuQtZsP2FQIchIiLiFzt37Wbztu2EhoTQr3cv3G4PazdsYPW69cTFxtCmdStWr10HmBhxwlCSEiuTycT27YhwOFj760bWrN/AiccfF9iBSINq7BmE0a2jMFvMFOQUNom/sIiIiBxOc8qvEhISKCwsxOPxYLFYcLvdFBYWEh8fX+PYdu3aceDAAd/nvLw82rZte8R9NpuNsWPH+vbNnz+fjh07+mtIARMaFtLobdxFRESaC3/nV1qDUGr45t1lDB6dSkSMI9ChiIiI+MWGjZswm82cdMJQunZOpmf3rgwdPBiLxcrWHTsxvF6y9uUQHhZKUmJ7vF4vhmFgGAbdunTGZrGwe2/wt6iQ+gnEl1fJfZPYuymrUe8pIiLiD80pv2rdujV9+vRh5cqVAKxYsYKUlBRiY2MBWLZsmW89wtNOO43ly5f7xvL9999z2mmnHXHf0qVLfdd3Op0sW7aMMWPGNPJI/c/usOMscQY6DBERkSbJ3/mVZhBKDZ/M/YKx910Y6DBERET8pqC4hLjoaOJiY1m7/ldCQ0Po3rUL3//0E5mZWXi8XqByvRmAys5NBmDCZALTb/8nzUt5aTmhjV0g7JfEno2ZjXpPERERf2hu+dWkSZOYM2cOixcvJi8vj4kTJ/r2LViwgLFjxzJ8+HBSU1MZNmwYjz76KAAjRoygb9++AIfdZ7PZeOmll+jTpw8HDhzg5ptvplWrVo07yEZgd4TiLCmHNoGOREREpOnxd37VrAqEh1u0Weomc9s+srZnM/C0lECHIiIi4jc2mw2HI5yc/bls3LINEwZtWrXC4XBQXFSMxWLBER5OUXExOfv306Z1a9+5u/dm4KyoIDys8daqk8bR2C1GoXIG4S/frmnUe4qIiPhDc8uvEhMTmTZtWq37nn/++WqfD24V+keH2nfcccdx3HGBb6fqb74CoYiIiNSbv/OrZlUg/OOizbUtHi2H98ncLzj7ptMDHYaIiIhfGYaBx+slLMzOqJNH4PUa2EJsGN7KNgwmk4kunZPZtnMX33z3Pb16dCM2Jpr9+/PYuGUrZpOZ3n17BHoY0sCcJU7sjsb9YjK5X0c+efGLRr2niIiIPyi/ktqERdgpK1aLURERkaPh7/yqWRUI5dh9Ou9LFmx/IdBhiIiI+JXZZMJiMVNQWMR3y5ZjsVr40/ATMJvM8NsLRr16dOPAgQNk7Mvm101bMZkq39zyer10Tk6iS+dOAR6FNDRnaQX2xp5BqBajIiLSTCi/ktpoDUIREZGj5+/8SgVC8fnmnaUMPr0/ETGOQIciIiLiVwZQXl5BYrsEuiR3wh5mp02rVpS7yn2d2W1WK52TO7H/QD4hFgv2MDt2eyiDUvvRIbF9IMMXPwnEGoSOqHDCIuzk7MmlTYfmt+6QiIi0HMqvpDZqMSoiInL0/J1fqUAoPp/MW8jY+y4MdBgiIiJ+5yovx+12ATBk0ADfdrfLhcVi8X3euHkLbreb4ccPoW18m8YOUxqRx+3BMAystsZPjzv0aseOtbtUIBQRkSZN+ZXURgVCERGRo+fv/MrcYJFKk5axNYt9O3IYeFpKoEMRERHxu8jICAqLSziQn+/btjczC5PZ6kukCoqKyM7ej81ioVVsLIZh+H6k+QnE+oNVEnu0Y8e6PQG5t4iISENRfiW10RqEIiIiR8/f+ZUKhALAp/MWMubG0YEOQ0REpFH07tkDwwtLlv3Anr0ZbN+5ix9+WonX66Fbl2QAMrP24YiMoFNSB9+sMpPJhMlkOsyVpakKxPqDVapmEIqIiDRlyq+kNlqDUERE5Oj5O79Si1EB4JO5X/LmzhcCHYaIiEijSO7Ukdy8A+zYtZtlP/2M2WSmoqKclL69aBsfj9frZdeuPXhcLpI7JQHoi6tmLhDrD1bp0LMd37zxfUDuLSIi0lCUX0lt1GJURETk6Pk7v1KBUPjmnaUM+XN/HNGOQIciIiLSKEzAkIH9adc2nq3bd2C1WunSOZmE39ozVFS4KCopxh4aSkxMDIZhBPUXWJmZmcyePZu4uDjy8vKYMGECCQkJNY7btGkT99xzDzabzbftzTffrPa5pQpkgTCxRwI71WJURESauOaWX0nD0AxCERGRo+fv/EoFQuGTuQsZ+8CFgQ5DRESk0SW2b0di+3Y1ttvtoZwx6lTcbg9mkyno18WZMWMGl112GUOGDGH58uU8/fTTPP7447Uee9tttzFq1KhGjjD4BbLFaEhYCHHtYsjcto92XdoGJAYREZGG0lzyq2CUnp7O1KlTAx1GvdgdoeRnFwQ6DBERkSbNX/mV1iBs4TK2ZrFvZw4DT00JdCgiIiKN7uCFm/+YRDnCw4mOigSCu/1Vbm4u69atY+DAgQAMHjyYVatWkX/QAtYHW7JkCbNnz+aZZ55h9erVjRhpcHOWOLE77AG7f3LfJHas2x2w+4uIiDSU5pBfBau0tLRDPttgFRZhp6xYMwhFRESOhb/yK80gbOE+nbeQMTeODnQYIiIiAdEcvpjKysoiKioKi8UCgNVqJSoqiqysLGJiYqodGxcXx5lnnsnQoUMpLi7m1ltv5YEHHqBHjx41rnu4N9RNJhNTpkxh8uTJDTKGjIyMBrnOscjck4lhNgIWS+tOsaxeto5Og9sH5P6BFgz/DgRaS38GLX38oGcAegZNZfxHyp+aQ34lDUctRkVERI6dv/IrFQhbuE/mfsmbO18IdBgiIiJylA719nhtyWPr1q1p3bo1ABEREQwbNoxFixbVWiBMS0sjLS2t1us25BvrGRkZtG8f+KLYZvsOouOiAhJLRkYG/Yb14YfPfw6KZ9HYguXfgUBq6c+gpY8f9AxAz6Apjb+pFDIlONgdoThLygMdhoiIiNRCLUZbqEfHzuKqzhNo360tjmhHoMMRERGRo5SQkEBhYSEejwcAt9tNYWEh8fHxNY7NysryHQcQEhJCRUVFo8UazJyl5djDQwN2/+R+SexYqxajIiIi0ryoQCgiIhK8VCBsgaacksbXb33Hvp05bP1lBx+98J9AhyQiIiJHqXXr1vTp04eVK1cCsGLFClJSUoiNjQVg2bJlvvUI/+///o9169YBlTMPV61axYABAwIRdtApL60gNDwkYPdXgVBERESaI61BKCIiErzUYrSF2f3rXnIz8nyfDa/B4ve/59wJZwQwKhERETkWkyZNYs6cOSxevJi8vDwmTpzo27dgwQLGjh3L8OHDGTBgAG+88Qbfffcd+fn5DB06lJEjRwYu8CDiLHFid9gDdn+LxUL7bgns3riXpJ6JAYtDREREpCFpDUIREZHg1egFwszMTGbPnk1cXBx5eXlMmDCBhISEGsc5nU5mzpyJ3W7HZDLh9Xq54447sFpV0zwWSb0Sq61JZLGZ6dQ3KYARiYiIyLFKTExk2rRpte57/vnnfb+feOKJnHjiiY0VVpMS6BmE8PssQhUIRUREpLlQi1EREZHg1ejVthkzZnDZZZcxZMgQli9fztNPP83jjz9e47gvvvgCp9PJfffdB0BaWhoLFy7kzDPPbOyQm52X1s7k2h63k59dwBnXn8ptz4wLdEgiIiIBtXbt2jod169fPz9HIoHiLHUS1SoqoDEk901izZINnHTRsIDGISIi0hCUXwmoQCgiItKQGjq/atQCYW5uLuvWrWPgwIEADB48mPT0dPLz84mJial2bFxcHAUFBXi9XgAKCgqqzXyTo2exWrhkyrls+WW7ioMiIiLoiykBZ2kF8UmBm0FoGAb/+9cSDuzLZ/OKbcz8tvYZoSIiIk2F8isBtRgVERFpSA2dXzVqgTArK4uoqCgsFkvlza1WoqKiyMrKqlEgHDFiBGvWrOGvf/0rAN26dWP06NG1Xjc9PZ2pU6fWus9kMjFlyhQmT57cIGPIyMhokOsE2u6tewiLCT2q8TSXZ3C0Wvr4Qc+gpY8f9AxAz6CpjF8vF0ldBXoNwntGPUzGliwA1i75lb/++RGe+O+DAYtHREREpCHYw0MpL6vAMAzl5iIiIkGmUQuEhmHUur22BOHf//43WVlZPPHEEwA89thj/Pzzzxx33HE1jk1LSyMtLa3W6x7qnkcjIyOD9u3bN9j1Asld5qVb/471Hk9zegZHo6WPH/QMWvr4Qc8A9Aya0vibSiFTAi+QaxB6PV4ytmZV27Z70159kSYiIiLNQtUswrCIsECHIiIiIgcxN+bNEhISKCwsxOPxAOB2uyksLCQ+Pr7GscuXL2fIkCGYzWbMZjP9+/fno48+asxwm7WCnEKi2wR2nR0RERGRYFFeWk5oeGhA7m22mDnlihFYbJVdNsxWM6OvHqnioIiIiDQLWodQREQkODVqgbB169b06dOHlStXArBixQpSUlKIjY0FYNmyZeTn5wPQoUMHdu3a5Tt3x44dtRYS5ejkZxcQEx8d6DBEREREgoKztBx7gAqEAOMfv5Lzbz+TmPhojj9zIH95+PKAxSIiIiLSkFQgFBERCU6NWiAEmDRpEh9++CEzZ87kk08+YeLEib59CxYsYN26dQBce+21HDhwgFmzZjFz5kzy8vK45pprGjvcZis/u5CYeM0gFBEREYHAthitcvNT13Lp3efRoXu7gMYhIiIiwSk9PR2TyeT7aSrCIuyUFTsDHYaIiIj8QaOuQQiQmJjItGnTat33/PPP+36PjIzkwQcfbKywWhy1GBURkZbs1TffxmKpbOfo9XoP+SWL2WzGZDLh9Xrxer0YhoHZXPl+lcfj4dqxlzVq3OI/zhIndoc90GHQJbUjP/33l0CHISIiUm/Kr/wvLS2NtLQ03+emUiSsWoNQRERE6sff+VWjFwgl8DweDyUFpUTFRQY6FBERkYAwm82cctJwIiMiWPbjTzgc4aT26YOBgYnfEy2bzYbX68FrGKxas5bi4lJOHHocRcXF/O/bJQEcgTS0YJhBCNAltRPbVu8MdBgiIiL1pvxKDkUtRkVERI6Ov/MrFQhbILUXFRGRls5kMhEVFUlkRARWixV7aChRUTVfnFn240/YbCF075JMZGQkZc5yoqIiMZmbVlsnObJAr0FYJbZtDIbXID+ngJg2Wi9aRESaDuVXcigqEIqIiBwdf+dXjb4GoQRefnYBMfH6wklERFouwzDweDy+371er+/3g+3NyKSopJSSkrJq+z0eT41jm6umutZNfZWXlhMaBAVCgM6pHdm+elegwxAREakX5VdyKGoxKiIicnT8nV+pQNgCaf1BERFp6SoLXb8XuwzAaxh4DQPjoB+v14vVZsMwvH+8QrMulh0sLS2t2jNproKlxSiozaiIiDRNyq/kUMIi7JQVq0AoIiJSX/7Or1QgbIE0g1BERARMpt+LXVazGbPJhOW3RZ2rfnr37EHr2GjiYmMPea40fR63B6/Xiy3EFuhQABUIRUSk6VJ+JbVRi1EREZGj58/8SmsQtkBag1BERAR+68qA2WKmqKSUjMwsDMOo9mZVu7ZtMQwvBYUF7N+fh81qrXauNA/Bsv5glS6pnfjg2c8DHYaIiEi9Kb+S2qhAKCIicvT8mV+pQNgCHcjOJzY+JtBhiIiIBJTFXNlIoV/vnvy4chXfLf8Rw+ut1kbTaxiYzWYsZjPh4eEcP3hAtXOleQim9QdBMwhFRKTpUn4ltQlz2CkuKA10GCIiIk2SP/MrFQhboIKcQtp1SQh0GCIiIkEhvk0bxpw+KtBhSAAF0/qDABarhcTu7di1YQ8de3cIdDgiIiL1pvxKDhYWYSdnb16gwxAREWnS/JFf6fWsFuhAdiGxajEqIiICUO2NqyMe68c4JHCcJU7sDnugw6hGswhFRKQpU34lB7M77DhLnIEOQ0REpEnzR36lAmELlJ9dQEx8dKDDEBERCQoH92w/4rF+jEMCx1lagT2IZhCCCoQiItK0Kb+Sg2kNQhERkWPnj/xKBcIWSAVCERERkd8F2xqEoAKhiIiINB8qEIqIiAQnFQhboIKcQqLbqMWoiIiICARrgbAj21bvCnQYIiIiIsdMLUZFRESCkwqELUyFswK3y0N4ZFigQxEREREJCsHYYjS+YxtK8ksoKSwNdCgiIiISJNLT0zGZTL6fpiIswk5ZsQqEIiIiwaZZFQibaqLUmNReVEREpH4LO/vzGhIcnCVO7A57oMOooXNqJ7arzaiIiDQRyq/8Ly0tDcMwfD9NhVqMioiIHB1/51fNqkDYVBOlxpSfXUhMvNqLiohIy2YymbBYLEd9vsVi0ctIzUh5aQWhQTaDENRmVEREmhblV3IoKhCKiIgcHX/nV9ajvrI0Sfk5hcRo/UEREWnhDMOgoLAQj8dzVOcXl5ToZaRmJBjXIATokprMlpXbAh2GiIhInSi/kkPRGoQiIiJHx9/5lQqELYxajIqIiIDX6+V/3y455mtI8+AsLccelAXCjnzx6teBDkNERKROlF/Jodgj7Di1BqGIiEi9+Tu/UoGwhVGBUEREBK4de1mgQ5Ag4iwtJyo2ItBh1KA1CEVEpClRfiWHEhJqw+P24vF4jqlNmoiISEvj7/yqWa1BKEd2ILuAWBUIRUREpI7S09MxmUy+n+bIWVKO3RF8MwjDHHZi2kaTuW1foEMREREROSZah1BERCT4qEDYwhTkFBKtNQhFRESkjtLS0jAMw/fTHAXrGoQAXVI7sU2zCEVERKSJU4FQREQk+KhA2MKoxaiIiIhIdSoQioiIiPiX3WHHWaJ1CEVERIKJCoQtTH52ITHxmkEoIiIiUsVZWoE9PCTQYdRKBUIRERFpDsIi7JQVq0AoIiISTFQgbGE0g1BERESkOmeJE7vDHugwatU5tRPbVSAUERGRJk4tRkVERIKPCoQtTH5OITFag1BERETEp7y0gtAgnUHYoXs7snftp6LcFehQRERERI6aCoQiIiLBRwXCFqS0qAyrzUKIPTi/ABMREREJhGBegxA0i1BERESaPq1BKCIiEnxUIGxB1F5UREREpKZgLxBqHUIRERFp6uwRdpxag1BERCSoqEDYgqhAKCIiIlKTs7QCe5C2GAUVCEVERKTpU4tRERGR4KMCYQtSkFNItNYfFBEREanGWeLE7rAHOoxDUoFQREREANLT0zGZTL6fpiTMEUqZCoQiIiJBRQXCFuRAdiGx8SoQioiIiBysvLSC0CCeQdg5tSPbV+8KdBgiIiISYGlpaRiG4ftpSrQGoYiISPBRgbAFUYtRERGRQzvUFy1N8QsYqTuPx4PX48UWYgt0KIcUFRdJSFgI+/fmBjoUERGRelF+JVVUIBQREWkYDZlfWRsqKAl++TkFJHSKD3QYIiIiQamqTVNBYSGlpaUAhIeHEx2l2ffNWbDPHqzSJbUj21bvonViq0CHIiIiUmfKr6RKWISdfTuzAx2GiIhIk9eQ+ZUKhC1IfnYhvY7rFugwREREgtL2Hbv4dfNm9ufm0ap1awBy9++ndas4enXvTufkjgGOUPwh2NcfrNI5tRPbV+/k+DMHBjoUERGROlN+JVXsjlCcWoNQRETkmDVkfqUCYQuiFqMiIiK/MwwDk8mE1+tl6fIfyc7No9zpJCE+nvbt2gJgM5vZn5fHyrXr2JuZwQnHH4fZXNmhveqNLWnamsoMwq6pnfj+058DHYaIiMhhKb+SQ1GBUERE5Oj4M79qVgXC9PR0pk6dGugwgpYKhCIiItV5vV6W/vATBcUlhNvtjDxxKK3i4nz7+/buRV7eAX5Y+Qv5RSX8sGIlJxw/pEWtmdPc8ytnaTn28NBAh3FEnVM78a/H/x3oMERERI5I+ZXURmsQioiIHD1/5VdmfwfemNLS0nwLMSqxrKkgp5DoNurzLyIiApVvUHkNg/YJbUnp1YNTThpOq7i4armEYRjExcVyyogTMQOZ+7LJzNqHyWRqMblGc8+vykvLCW0KBcJ+HdmxbnegwxARETks5VdyKGERdsqKVSAUERGpL3/mV82qQCiHl59dSEy8CoQiIiJVrBYLXZI70TGpA6GhIb62DQf/eL1eQkNDGXbcIAzDYM36DYEOWxpQU2kxCtA5pSPbVu8MdBgiIiKHpfxKaqMWoyIiIkfPX/mVCoQtRGFeEY7ocCwWS6BDERERCRrfLf+Rn1auAn7v6f5HZrOZ7Tt3snL1WpxOJ9k5+/li0des37ipscMVP3CWOLE77IEOo066pHZSgVBERIKe8iupjQqEIiIiR89f+VWzWoNQDk2zB0VERH5nYLDsh5/Ym5mF1+vFYrEwMLVf7ccaBkmJiWTn7MdisWC12bBaLXRNTm7coMUvnKUV2JvIDEIVCEVEJJg1t/wqMzOT2bNnExcXR15eHhMmTCAhIaHWY9966y22bt2KYRj06NGDSy+99Ij7nE4nM2fOxG63+976v+OOO7Bam+dXdVqDUEREpP78nV9pBmELofUHRUREfrdm7Xr2ZmRS7nRiBrZu38H2HZWFlz/2ZjeZTFitVoYOGUynpA7ERkdx8knDsduDf906ObKmsgYhqEAoIiLBrbnlVzNmzODcc89l4sSJjBkzhqeffrrW49asWcPSpUu5//77eeCBB/j222/ZsGHDEfd98cUXOJ1OJk2axMSJEykoKGDhwoWNNr7GphmEIiIi9efv/EoFwhYiP7uAmPjoQIchIiISFLp0TmbUySMxmUxEOBycd9afaffbG+G1tWmocsLxQzj1TyMwm82HXeRZmo6mVCDsnNqJ7SoQiohIkGpO+VVubi7r1q1j4MCBAAwePJhVq1aRn59f49gvv/ySoUOH+tb/GTZsmK/Qd7h9cXFxFBQU4PV68Xq9FBQUHPY5NXVhEXbKijWDUEREpD78nV81z74FUoMKhCIiIr+LcDgAiG/TmuLiUoqKS4iLjcHr9WI2V39/ymsYmE0mysvLKXe5MP+WlDXnL3BakqbUYrRVu1jcLg8F+wuJbq3OECIiElyaU36VlZVFVFQUFosFAKvVSlRUFFlZWcTExNQ4tmfPnr7PcXFxrF+//oj7RowYwZo1a/jrX/8KQLdu3Rg9erQ/hxVQVlvlV5Bul9v3u4iIiByev/Mr/YncQmgNQhERkd9VLeic0rc3S39YwfKfVnDKn0ZgDw2t8WaV2WTCWV7OV98uwWNAau9eRDgch1wUWpoWZ4kTu8Me6DDqrKrN6MBTUwIdioiISDXNKb861Jv2tcVW27FVxx1u37///W+ysrJ44oknAHjsscf4+eefOe6442qck56eztSpUw8Z05QpU5g8eXLtg6mnjIyMBrlObULDQ9i+ZQeO6HC/3eNo+XPcwU5jb5k09pappY69KYz7UPmPv/MrFQhbiPycAjr27hDoMERERIJCVWLUrm1bEtq04kBBMd8sWcrgAf1p3Squ2rH7c/NY8csqPF6IjY6kY1Ji0Hx5JcfOWVpOVGxEoMOos86pHdm+epcKhCIiEnSaU36VkJBAYWEhHo8Hi8WC2+2msLCQ+Pj4Gse2a9eOAwcO+D7n5eXRtm3bI+5bvnw5w4cP9739379/fz766KNaC4RpaWmkpaXV2G4ymRq0LWtGRgbt27dvsOv9UVhEGLFRsbRu38pv9zga/h53MNPYNfaWRmNveWNvKuM+VBHT3/mV1iBsIdRiVEREpDrDMDAMg2HHDSEmKoKSMicLv/qGhf/7mrXrf2Xt+l9Z+L+vWfjVN5SUOYmJimDYcYODZm0caRhNaQ1CgK6pyWxdvSPQYYiIiNSqueRXrVu3pk+fPqxcuRKAFStWkJKSQmxsLADLli3zrUd42mmnsXz5ct/Yv//+e0477bQj7uvQoQO7du3y3XPHjh21FiCbE61DKCIiUn/+zK80g7CFUItRERGR6qreoLJYLIw4YSjbduxk4+atZGXn4PZWHrN/fw6tW7WiZ/eudEnuFMBoxV/KSysIbSJrEELlDMIPn/9PoMMQERGpVXPKryZNmsScOXNYvHgxeXl5TJw40bdvwYIFjB07luHDh5OamsqwYcN49NFHgcq1Bfv27Qtw2H3XXnstTz/9NLNmzcIwDAoLC6vdozmyO0JxlpQHOgwREZEmxZ/5lQqELcSB7AJiNYNQRETkkLokd6JLcicKCosoKS0FwBE+mOioyABHJv7U1NYg7JzSke1rdh35QBERkSDQlPOrxMREpk2bVuu+559/vtrnsWPHHvI6h9oXGRnJgw8+ePQBNkEqEIqIiBy7hsyvVCBsIQpyColuoxmEIiIih1LVeiE6KrJaUlW1PVjWxJGG5SytwN6EZhDaQmwkdI5n98a9JPVMDHQ4IiIih6X8Sg5md9hxlqjFqIiIyLFoyPxKaxC2AIZhUJhbRHRrFQhFREQOxWQy1ZpEHWq7NA9NbQ1CgC6pHdm2WrMIRUQk+Cm/koNpBqGIiMixa8j8SgXCFiA/u4AYtRcVERERqaFpFgiT2bZ6R6DDEBEREamXsAg7ZcWaQSgiIhIsVCBsAVQgFBERkaOVnp7uewutOb7pX15aQWgTajEKmkEoIiIiTZNmEIqIiAQXFQhbgPycQmK0/qCIiIgchbS0NAzD8P00N84SJ3aHPdBh1Evn1E5sX70z0GGIiIiI1IvWIBQREQkuKhC2APnZhcTEq0AoIiIi8kfO0grsTWwGYUJyPIW5RZQWlQU6FBEREZE6C3PYKVOBUEREJGg0qwJhc2+BdbTUYlRERESkdk1xDUKALqmd2KZZhCIiItKE2CPsOLUGoYiISNBoVgXC5t4C62gdyC4gVgVCERERkRqaaoFQbUZFRESkqQlzhFKmNQhFRESCRrMqEErtCnIKidYahCIiIiLVeL1e3C4PIaG2QIdSb11TO7FVBUIRERFpQuyOUJwqEIqIiAQNFQhbALUYFREREanJWVKO3dH0Zg+CZhCKiIi0RE19aR27w45TaxCKiIgEDRUIWwAVCEVERERqaqrtRQE6p3Rk+5pdgQ5DREREGlFTX1pHMwhFRESCiwqELUB+diEx8WoxKiIiInIwZ2k59iZaIAyPDCOqVSRZO7IDHYqIiIhIndgj7DiLNYNQREQkWKhA2ALk5xQSozUIRURERKopL60gNDwk0GEcNbUZFRERkaZEMwhFRESCizXQAYh/uSpcVJRV4Ih2BDoUERGRoGMYhm/9lj0ZmezNyGD3nr2UV7gACAmx0bFDIont29Ohfbsa50jT5ixxYnfYAx3GUeuS2pFtq3dxwrnHBToUERERH+VXcihag1BEROTo+Cu/UoGwmVN7URERkdpVJUoFhYX8/Msa8vILcHvchNpsREdXrt1bUlrKjt172ZOxj80x2xg0IIXoqCh9idVMNPUZhF1Sk/n23aWBDkNERMRH+ZUcTpgjlDLNIBQREakXf+ZXKhA2cwU5hUSrvaiIiEg1VQlSZtY+lnz/IyaTicR2benTqwfRUdX/3CwsLGLdrxvZm7mPL/73LcOHDqF9u4Sg+hIrMzOT2bNnExcXR15eHhMmTCAhIeGQxxcUFDB+/HiuvPJKzj///MYLNMg05TUIoXIG4T8feivQYYiIiADNL7+Shqc1CEVEROrH3/mVCoTNXH52ATHx0YEOQ0REJKiYTCYKi4pZ9uMKzGY4ftAAkjokUlJWxvKffiY37wAWi4W42Bj69OrJCccPYfeevfzw80q+/+lnRp38J6IiIwI9DJ8ZM2Zw2WWXMWTIEJYvX87TTz/N448/fsjj582bR9u2bRsxwuBUXlpOaBMuECb1TCRrezauChe2EFugwxERkRauueVX0vC0BqGIiEj9+Du/MjfiWCQAVCAUERGp3fIffsJrGBw3sD9JHRLJLyjgP18sIitnP/tzc8nLz2dv5j4+X7iIvPx8kjokctzA/hiGwfc//BTo8H1yc3NZt24dAwcOBGDw4MGsWrWK/Pz8Wo//6quv6Nmz52FnGLYUTb3FKEDn1I5sX70r0GGIiIgAzSe/Ev+wWCxYrGYqyl2BDkVERKTJ8Gd+pQJhM3cgu5BYrUEoIiJSzd7MLApLSkho05qOSUkArF67Hnt4OPYQG5ecfy6nnzKSiopyLFYrGzduxjAMOiYlkRDfmqKSEvZmZgV4FJWysrKIiorCYrEAYLVaiYqKIiurZnwHDhzgu+++45xzzmnsMIOSs8SJ3WEPdBjHpEtqJ7at3hnoMERERJpVfiX+Y3fYcZaozaiIiEhd+Du/UovRZi4/p4CYNppBKCIicrDtOysLKv369AIqe7qXOp2YTSZ69+xBWJidsDA7MdFROCtcVLhcvn7tfXv3Iit7CTt27iSxXeBn4RmGUev22vrLz507lxtvvLFOa/ukp6czderUQ157ypQpTJ48uV6xHkpGRkaDXKe+srNycHtdAbv/wY42htbJsaxeuo7UM3o1cESNKxj+Nwi0lv4MWvr4Qc8A9AyayvgPlUc0p/xK/KeqzWhUXGSgQxEREQl6/s6vVCBs5vKzC+jYMzHQYYiIiASVzMx9WENsREf+/sXEyOEn4PZ4CAutXJNu1+495B7IJzwsjPg2rYHKRCwyIgKz2UxGkLzhnpCQQGFhIR6PB4vFgtvtprCwkPj4+GrH5eTkcODAAd58800ANm3aRG5uLhkZGUyYMKHGddPS0khLS6ux3WQyHbIoeTQyMjJo3759g12vPkKtdlrFWwN2/yrH8gwGjEhhwVfvBXwMxyKQ/w4Ei5b+DFr6+EHPAPQMmtL4D1XIbE75lfiPPcKOs1gzCEVEROrC3/mVCoTNXH52ITFqMSoiIlKN2+0mNjYGk9mM1zAwm0yE2X9vNblz9x6+/3EFITYbMVGRdOvS2VcUs1gsRDjC2b+/LFDhV9O6dWv69OnDypUrGTJkCCtWrCAlJYXY2FgAli1bRu/evWnTpg1///vffec98sgj9OvXj/PPPz9AkQees7SciOjwQIdxTDqndGT7Gq1BKCIigdec8ivxn6oZhCIiInJk/s6vVCBs5vKzC4iJV4tRERGRI6lKoFwuFz+sWInZbCY5qQODB/b3HeM1DEwcurVWoEyaNIk5c+awePFi8vLymDhxom/fggULGDt2LMOHD/dtmzNnDlu2bCEvLw+LxdJi1yQsLy2nVbvYQIdxTKJbR2G1WcjNPNDkxyIiIs1PU86vxD/CHHbKtAahiIjIUWvI/EoFwmauIKeQ6DaaQSgiInIwq9VCUXEJXq8Xs9kM/J40FRQVEWq3U1ZaQmpKXwDfcWaTCa/XS1FxCVarJWDx/1FiYiLTpk2rdd/zzz9fY9vNN9/MzTff7O+wgp6zpBy7IzTQYRyzzqmd2L56pwqEIiISUM0tvwpGh1sjuqnQDEIREZG683d+Zfb/ECSQNINQRESkpsT27fB6vRQWFtVYTy86KophQwYy+pSRWH5LvqqSMMMwKCwswuv10v4QCzxL01FeWk5oeNMvEHZJ7cS21TsDHYaIiLRwyq/8Ly0tDcMwfD9NkdYgFBERqTt/51fNqkCYnp6OyWTy/bR0ZSVOTKb/Z+++w5sq+zeA30maNm06oZOyyqiWXVoZAqJCBUGRLXuDCMoeAkIpoCgbXgotCCKCghMEFQRF2avsoYyy29LSkqYjo03y+6O/Rkv3ysm4P9eV6yXnPOec+wTsm+ab7/OIILOCD76IiIgqUq2aNQEAV//+B6L//1ZV7hut+ITHuHErFtf/uYns7GzjMXq9HiKRCFf//hsAULtWLdMHpwqlztRYxfskFgiJiMgc8P0VlQQ7CImIiEqust9fWVWB0Bq+SVWR2D1IRERUMH8/X7jK5UhITMKDR48gFouNb7KSU1KgN4hx/1EcdDodDAYDdDodxGIxHjx6hITEJ3CRy+HPb7hbPE2mFg5O9kLHKDcWCImIyBzw/RWVhEwug5prEBIREZVIZb+/sqoCIeXF9QeJiIgK17JFKEQiEU7HXMCDR48gkUggEong4+0NmYMd6tSqCalUCpFIBIlEggePHuF0zAWIRCK0ahEqdHyqAOoMNWRymdAxyq1Ok1q4c/m+0DGIiIj4/oqKxQ5CIiKi0qnM91d2JroHEoAiUQl3bxYIiYiInmUwGODq4ozWL4Tg6MkzOBVzAQ8fxeP5wHrw9/M1frtKr9fjqUKBf27ewsP4xzDoDWjTMgSuLs4wGAyc0tzCWUsHIQDUblQTdy7fQ0BjTs1GRETC4PsrKglHuQwqdhASERGVSGW/v2KB0IpxilEiIqKCiUQiGAwG+Pn64LVXX8K5C5cRl5CIew8fwdHBAY6OOV1larUGmWo1pHZSVHV3R/NmjeHm6soPr6yEtaxBCAB1mtRE7KX7LBASEZFg+P6KSsLRWYbEB0+EjkFERGQRKvv9FQuEVowFQiIiosLlvslyc3XFKy+1wcO4eDyKi8P9h4+Qnp4OALB3sEdAzerwr1YN1av5AQA/vLIimkwNHKymQFgbsZfuosPAdkJHISIiG8b3V1QcTjFKRERUOpX5/ooFQiumSFLC07+K0DGIiIjM1n/fKFWv5ofq1fzQMjSkxMeQZbOmKUbrNKmJH1b/InQMIiIivr+iIsnkMqg5xSgREVGpVNb7K3G5k5HZYgchERERUeHUGWrI5DKhY1SIOk1qIfbSPaFjEBERERWJHYRERETmgwVCK8YCIREREVHB9Ho9srN0sHeQCh2lQlStVgVZ6iwoU9KEjkJERERUKEdnGVTp7CAkIiIyBywQWjFFohLu3q5CxyAiIiIyO9a0/mCugCY1cefSfaFjEBERERWKHYRERETmgwVCK6ZIUsLdiwVCIiIiKruIiAiIRCLjw1qoM7WQWcn6g7k4zSgRERGZO65BSEREZD5YILRinGKUiIiIyis8PBwGg8H4sBbW2EFYp0ktXDn2t9AxiIiIiArFDkIqyJ6o37B2wibcvcrZMIiITMlO6ABUOdIVGZDJHWAn5V8xERER0bPUGRrI5NZVIDy47TCunbiBkQ0nYcOl5ZBIJEJHIiIiogoUERGB+fPnCx2jXFggFMaZM2fQsWNHZGZmCh0ln5wvIgKAARMjRRCLrWfWEltRr149/Prrr6hdu7bQUYiolFg9slLsHiQiIiIqnLV1EC4dEYlLf10DANy//gjvNJuGzy6vFDgVERERVaTw8HCEh4cbn1vi9O+OzjKo0jnFqKkdP34cw4YNw/Lly/Nsz8rKglQqFSgVkJmmQvztx9Dr9MZt9k728K/nW+lND0Lfu5Aq+t47d+6MW7dusUBIZIFYILRSXH+QiIiIqHDqTA1kVlQgfHgjPs9zdYYGSQ+ewKuGp0CJiIiIiPLjGoTCEYlEsLPL+1GwwWDIt60sMpSZUD5Jg0zuAA8f9wLHaDI10GRqoVZpoM3UQqPSQiwRQyKRQCz6dxUskUGEuJuPYTAY4OBoD3tHezjI/v9/He0hluRdMSs7KxvxsYkw6A3wq+sDqX3J7qei7t0SVfS9W+KXFYgoh23+FLQB7CAkIiIiKpwmUwsHJ3uhY1SYjoNewj+nb0GXrQMAPN+iPouDREREZHZEIhHsZfbQqDRwcLSeL2vZsozUTCTcSYRep0e6IgPZWTrI3ZxyCoIqLTSZWmhVOe+97R3tIXNygIu7HA5ODhBLxFBnaBAXmwAYAImdBDWD/JGYmIgpU6YgJSUFLUJbYNyo96BMToNGpYXETmIsHNpJJUhJUECXlfMe+MHfj1D9uWqwd7DNzkAiotIyeYEwPj4e69evR5UqVZCSkoJx48bB19e3wLFnzpzB0aNHYW9vj3v37qFv374IDQ01cWLLpEhUwt2bHYREREREBVFnqCGTy4SOUWHeHPsaDHoDfvnsIJIeJOPDHZOFjkRERERUoNx1CFkgFJZOp8Pvv/+O48eP4969e9DpdHB2dkaTJk3QpUuXEk8XmRz/9N8pQg2A4nGqcb1vJxdHePi4w8Gx8C/myeQOqF7fD1p1FuRuThCJRPDx8cH27dvx/vvvQ+oghU8tL+P4D2Z+AFcXV4wdNQ7K5HRjcRAAdFk6ZDzNgL2ve1leEpO4e/cu1q1bh+TkZOh0OoSEhGDUqFFwdHQs9ti0tDRER0fjypUrEIlE8Pf3x7hx41CtWjXjmIyMDOzevRunTp2CVquFVquFnZ0d3nrrLXTp0iXP+ZYsWYIDBw7ku07v3r3xzjvvlP9micjsmbxAuGLFCrz99tsIDQ3FqVOnsHr1aixevDjfuMTEROzZswcREREQiUR4+vQpNBouYlxS7CAkIiIiKpy1dRACQLdxndBtXCf0r/EOkh4mw6t6VaEjEREREeWTuw6hmye/2C6Ue/fuISIiAl5eXujZsyeaNGkCR0dHqFQqnDt3DqtXr0ZwcDCGDBlS7LmenVxS6iBFjeeqFTi2MPYye9jLSvbe3MvbC25ubqji6w5HZxniYx//WyQUAWmKDMicZXB0Nr8vAyYlJWHq1Kno3bs3+vfvD7VajVmzZmHBggUFfj7+X3q9Hh9++CFcXFywceNG2NnZITo6GlOnTkV0dDRcXXP+e0pISMAXX3yBBQsWoGXLlgCAv/76C4sWLYJYLEbnzp3znHfo0KH5mndq1apVgXdNROZMXPyQipOcnIyrV68iODgYABASEoKLFy9CoVDkG7t3717UqFEDmzdvRmRkJE6cOFFopyHlp0hKhbsXC4REREREBdFkauBgRWsQ/lebHi1w7MfTQscgIiIiKlBuByEJ48GDB5g4cSLefPNNLFq0CC1btjR2rzk6OqJNmzZYsWIF1Go1tm7dWuS54u88hkQqgb2TPSRSCSRSCWo8X7riYGlNnToVo0aNysnrLEO1uj6ws8+5tn99P1T188CTh8l4eCMemWmqSs1SWl9//TXs7Ozw9ttvAwBkMhlGjBiBs2fPIiYmpshjjxw5gmvXrmHMmDGQSqUQiUQYNmwY0tPT8d133xnHyWQydO3a1VgcBID27dvD29sbx44dy3feFi1aoGPHjnke9evXr6A7JiJzZ9IOwoSEBLi6ukIikeRc3M4Orq6uSEhIgLu7e56x9+/fx927dxEVFQV7e3vMmTOnwG85UMEUiUo0avO80DGIiIiIzJI6UwOZtRYIu7fAVx/9gO7vvy50FCIiIqJ8ZHIZ1BlqoWPYJL1ej4ULFyIsLAw9evRAVlZWvjEXL15EzZo1MWbMGMyaNQuxsbGoU6dOnjHpigzExz6GRqzC5OmTAADt27XHi21exPwRcxEfHw93d3d8++232L9/P/bt2weNRgOdTgc3NzeMGTMG9erVy3fd9evX4/79+/Dz88PIkSPzZRszZgzi4+Mhl8uxY8cOAMD8hfNx7do12NnZ4YcffgAAfPvjN/hp909IS0/DsoUrUC+oLuRuToiLi0NUVBQeP34MIKeY1r59e/Ts2bPcr21JHDlyBMHBwRCL/+3ZadCgAaRSKY4cOYKQkJAij/Xw8EDNmjWN22QyGYKCgnDkyBGMGDECAODv748JEybkOdZgMEClUsHNjc0kRJSXSQuEBoOhwO0i0bPN6IBKpULz5s0hk+W0g7dr1w5//fVXgQXCiIgIzJ8/v9BzT506FVOmTCl78P+Ii4urkPNUtscPEqGTZFdKXkt5DSqLrd8/wNfA1u8f4GsA8DWwlPsv6D0GEWCdU4zmCn61McK7L0FmmgpOLsWvZUJERERkSuwgFM6RI0fw6NEjrFixAgCgUCgQHR2Nc+fOwcXFBaNGjUJkZCTGjRuHl156CUOGDMEvv/yC9957z3iO+DuPYdAbUC84ADqdDl9++SXmzZuH+w/vQ3xKjA8//BB37tzBZ599BgD44YcfMGzYMLRu3RoAcPToUUyfPh2ff/65sWEkISEBs2bNQtu2bbF06VIAwLp165CYmAgfHx/jtTds2IDo6GgcOnTIuO2TTz7B559/jj179hi3DRs2DHXq1MHChQtRxdcdiqRUJMelYOHyCLRp2wYLFixAVlYWTp48iSVLlhRbIExPTy/2tRWJRJDL5YXuVygUUCgU+WbIk0gk8Pb2RmxsbJHnv3PnDvz8/PJt9/Pzw4ULF6DVamFvn//3m/T0dHzxxRdwdHTEwIED8+3/5Zdf8L///Q8ZGRlwdnbGq6++im7duuUpYhKR9TJpgdDX1xdKpRI6nQ4SiQTZ2dlQKpXw9vbON9bLyyvPDyKpVFrgt1oAIDw8HOHh4fm2i0SiQouSZREXF5dn0VdzpkpVo25QnQrPa0mvQWWw9fsH+BrY+v0DfA0AvgaWdP+WUsgk01NlqOHs5iR0jEqTO81o2JD2QkchIiIiyoMFQuEcPnwYrVu3hrOzM4Cc4lpWVhaioqLg5OSETZs2QalUGsc///zz2LRpEwAg/WkG4u88hm9tb7hUyTnezs4Ovr6+sLOzQ1JSEiIjIyGVShEYGGj8XHf+/Pl5Cltt27bFmjVrcOTIEbz55psAcqbeNBgMeP/99+Hi4gIAePfdd9GvX79y37NMLoOXlxeUijTcvXcXL7d+BWkp6ZC5OKBdu3a4e/cuMtNUkNrbQeogzXe8SqVCjx49ir2OVCrFL7/8Uuj+1NRUAICTU/7fQZycnPK87oUdX9Bn6E5OTjAYDEhLS0PVqnnXIB87dqyxA/TZv4fcY+VyOT755BM4OTnh/PnzWLhwIW7cuIEZM2YUmYeIrINJC4Senp5o0KABzp8/j9DQUMTExKBx48bw8PAAAJw4cQJBQUFwd3fHyy+/jM8++wwGgwEikQhXrlwxrl1IxUtNUsLNi4s9ExERERVEk6lBVT8PoWNUmjbdW+Dgl4dZICQiIiKz4+gsgyqdU4wK4fbt23j11VcBAI8ePcKlS5ewbNkyY+Fp3Lhx2Ldvn3G8SCSCTqfL0zVY2CwtgYGBkEr/LbCFhYUBALRaLRYtWoRbt24Zmz9SU1MRHx9vHHv9+nXUqFHDWBwEAFdX1zzdg+Xl6u6CwMBAfP3jV3ic/BghjUMR/EIzvNyiAxLuJAIAqtX1hUyedxkCBwcHLFu2rNjzl2f2mvI0uBR1bFRUFLRaLX777TdMnDgREydORKdOnYz7/9sZCgDNmzdH7969sWXLFvTq1Qt169Ytcy4isgwmLRACwOTJkxEVFYUjR44gJSUFkyZNMu7btm0bBgwYgDZt2iA0NBSxsbFYsmQJHB0dIZFI0LdvX1PHtViKJCU8vDmvNBEREVFBNJkaOFjpGoQA0LZHS0T0Kv6DDCIiIiJT4xqEwklPTzc2aiQm5hTF/jvlpVQqzbNO3eNHichSZ8PZTW7sGixMblfifykUCkydOhVBQUH43//+ZywADhw4ENnZ2cZxycnJqFWrVonOWR6ffvopdu7cif379+PXA7/Ax9sX3cLeQnDj5gCAhDuPUf25arCT/vuRuVgsLlGhrLgCYe7rqlKp8u1TqVRwdS260cPNza3QY0UiUZ7i6n/Z29vjjTfewJUrV7B27Vq0bdu2wKlIcz3//PMAcoq2LBASWT+TFwj9/f2xcOHCAvdFRkbmec6CYNkoklLh5snuQSIiIqLCqDO1kFnpGoS5WncLxfHdZ/DiWy8IHYWIiIjIiFOMCsfZ2RkZGRkAYOwaTEhIgI+PD9QZGmRnZxmnwoyPfYzdv+xCx04dii0OFiYmJgapqal4++23Cy1gAUDVqlWRlpaWb3t6enqJuggLWi+voGKas7MzRo4cieHDh+PEiRP4fNPn+OyrDZg9YS78/fyh1+mhy9LlKRBW1BSj7u7ucHd3z9M5CQA6nQ5JSUlo1qxZkecPCAjA5cuX822Pj4+Hv7+/seiXlZUFsVgMiUSSZ1zdunXx+++/4+HDh6hTpw70ej0yMjLy/b3kvpZ6vb7IPERkHUxeIKTKx+lFiYiIqKJERERg/vz5QseocNbeQQjkTDN6bNdpFgiJiIjIrLBAKJyAgADExsYCyGniaNKkCTZt2oR3R46HXq3HD798D5FIhHt/38fDew8Re/82Ro0dWebr/bdLMJdOp4NCocizLSgoCL/99hvS0tKMBau0tDQ8fvy4RF1s7u7uyMjIQHZ2Nuzscj7uvnfvXp4x6enp2Lp1K8aNGwexWIwWLVqgmm81jBk7BvGJcfCv5g9dth56Xd7CWEVOMdquXTscP34cer3eWIi7fv06tFot2rVrl2fso0ePUK1aNeN527Vrh7/++gsPHjxAjRo1AAAajQZ///03unfvbjzuiy++gLOzc771G5OSkgDA2KkYHx+PGTNmYPv27XnG3bx5EwBQv379Yu+HiCxf/q9XkMVTJCrh7s0CIREREZVfeHg4DAaD8WEt1BmafOuLWJu2PVrg6I+nhY5BREREFSQiIgIikcj4sFSOzo5Qpefv7qLK17ZtW5w+fRpqdc4Urx988AE83Dwwa95MfLRyIZ4LeB5V3avi8JnDENmJ8NFHHxkLbmURHBwMBwcH7Ny5ExqNBgaDAVu3boVWq80zrn///hCJRFi7di0yMjKQkZGByMjIEl+7cePG0Ov1+OOPPwDkFAfPnTuXZ4xWq8VPP/2EK1euGLdd/+c6HBwc0KhxQ1TxdUe95gFIjnuK5LgU4xixWIymTZsW+2jSpEmxOfv37w+tVotvvvkGAKBWq7Fp0yaEhoYiJCTEOO6PP/7AsGHD8N133xm3tWvXDg0aNMDGjRuRlZUFg8GAL774Ak5OTujdu3ee63z//fe4c+eO8fmlS5fw66+/olWrVvDz8zNuT0xMxLfffmv8Pe/27dv49ttv8cILLyAoKMg4bvPmzejSpYtV/T5IRDnYQWiFFImpcOf6g0RERESFsoUOQrmbHPWCa+Pin1fR9OWGQschIiKicgoPD0d4eLjxuaUWCWVyBygSU4WOYZNefvllbNu2DV999RVGjBgBd3d3THh3ElLinxrHNG8WAp+aXiWaVlShUGD8+PFISUnBgwcPMHDgQEyePBmhoaEAcqYxjYiIwMaNG9G/f3/4+fnh5ZdfhpeXF/bt24c7d+5g6dKl8PX1xSeffIJ169ahT58+8PT0RL9+/fDo0SOcPHkSAwcOxJYtW/D+++8jPj4earUaAwcOxIcffoigoCDUqVMH7777LrZs2YIvvvgCTZs2Rc+ePbF06VJMmDABAwYMQOfOnTFw4ECsXbsWQE4no4uLCz7++GM0btLIeE/Vn6uG5PinePBPHKoH+lXof2deXl5Yvnw51q9fjwMHDkCn06F58+YYPXp0nnEeHh5wcnJC1apVjdvEYjEWLVqE6OhojB49GiKRCP7+/li+fHme9Qtff/116HQ6LF68GEDOVKESiQRDhgzBW2+9ZRzn7e2NiRMn4s8//8T+/fuh0+lgMBjQtWtXDBgwIE+ehIQEPPfccxb7M4eICscCoRVigZCIiIioaOpMDWRWXiAEgLY9WuLoj6dYICQiIiKzIZPLoM5QCx3DJkkkEsydOxeTJ0+Gt7c3OnXqBHdvV6QkKID/7w6T2ttBJ87OM11nYdzd3fNNUfmskJCQPN1xANCnT59845o0aYKoqKg827p06ZLn+bP7/6tnz57o2bNnnm2vvfZanueDBw/G4MGDAeSs1SeVSgs8V1U/Dzi5OOLW+TuoVs8XclenQq9bWgEBAViyZEmRY4KDg7F79+58211cXDBt2rQij/X398c777xTbA6pVIo33ngDb7zxRpHjkpOTcfLkScyYMaPYcxKR5eEUo1ZIkaSEO9cgJCIiIiqUJlMLByd7oWNUujbdX8CxXWeEjkFERERkxDUIhVWnTh0sX74cO3fuxPz58/HHvkPw8HOFs4ccEicxrt+/ijlz5iAxMVHoqIJydJahfvM6UDxOxZNHyULHEUxkZCR69eqFtm3bCh2FiCoBOwit0NPEVNRrWlvoGERERERmS52hhkwuEzpGpfOu6QU3TxfcPBeL+s3rCB2HiIiICI7OMqjS2UEopHr16mHz5s347uvvceDP37B15xeQSCTw8PBAy5YtsWTJEsjlcqFjmgX/+n5ISVDg/t+PUL2+H8QS2+q3+eCDD2Bvb/1frCSyVSwQWiFOMUpERERUNFvpIASANt1b4Niu0ywQEhERkVlgB6F5SE1KQ8cOYeg/pJ/QUcxeFV93OLk4IvbSPfgGeMPZ3XaKpywOElk32/rKg41QJCrh7s0pRomIiIgKYytrEAKcZpSIiIjMC9cgFN7TxFQYdHp+flgKMrkD6gUHQJmchqQHT4SOQ0RUIVggtEKpSUq4cQ1CIiIiogIZDAZkabJgL7ONb8MGNK4FTaYGcbcThI5CRERExA5CgaWlpEOdoYFXDU+ho1ikanV9Yecgxb1rD6HL1kGZnIYnj5KRmaYSOhoRUamxQGiFOMUoERERUeFsqXswF7sIiYiIyFywQCicDGUmlMlp8AvwFjqKRfPwdoNvgDfuXLmPxPtP8DQhFfG3HyNTySIhEVkWFgitjC5bh8w0FVw8nIWOQkRERGSW1BkayOQ2ViDs0RLHfjwldAwiIiIiODrLoErnFKOmlq3VIflRCvzr+wkdxSrYO0ghFoth0BsAAHqdHomcepSILIyd0AGoYrF7kIiIiKhomkwNHGysg7BRm+fx4J84pD5Rws2TU9ETEREVJz4+HuvXr0eVKlWQkpKCcePGwdfXt8CxO3bswO3bt2EwGBAYGIi+ffsWu+9///sfDh8+bByXnZ2NkJAQfPjhh5V7Y2aAaxCaXpoiA6lPlKgZVF3oKFZDJBZBLBZDB51xm51UImAiIqLSYwehlVEkKeHO9QeJiIiICmWLBUIAaNOjBY79eFroGERERBZhxYoV6NatGyZNmoSuXbti9erVBY67fPkyjh8/jtmzZ2POnDk4fPgwrl+/Xuw+R0dHfPnll/j222/x7bffolevXnj11VdNdn9Ckjk5QKPSCh3DZmjVWny16Hvopdno168fwsLCcOYMp56vCNWfqwaJvQR29hKI7cQQiUVCRyIiKhV2EFoZdhASERERFU2TqYWDk73QMUyuTfcW+ClyH7qM7ih0FCIiIrOWnJyMq1evIjg4GAAQEhKCiIgIKBQKuLu75xl78OBBtGzZEiJRTmGgVatWOHDgAIKCgorcN2rUKOM5dDodzp49iwEDBpjmBs2AzMkBqgw1HOUyoaNYvV5eIzHio/54GPcQU6ZMwciRI4WOVGnu3r2LdevWITk5GTqdDiEhIRg1ahQcHR2LPTYtLQ3R0dG4cuUKRCIR/P39MW7cOFSrVi3POL1ej507d+LAgQOws7ODnZ0d+vcZgLbt2yBDmYkH/8TB4Jhd5Ovcr18/q/57ICLLYVUdhBERERCJRMaHLVIkKuHuzQ5CIiIiosKoMzWQ2WAHYcsuzRFz4BKys7KFjkJERGTWEhIS4OrqCokkZ7pAOzs7uLq6IiEhocCxHh4exudVqlQxjitq338dPXoUrVu3hlhsVR/TFUnmLIOa6xBWukEB47Dx8nJIHaRCR6l0SUlJmDp1KoKDg7Fp0yZERUUhNjYWCxYsKPZYvV6PDz/8EAqFAhs3bsTmzZtRvXp1TJ06FUqlMs/YzZs3Y+/evVi6dCk2bNiAQYMG4aNPF+HqtatwdpfD078K4m4lwN/fHzNnzszzmD59OqRSKZo3b15ZLwMRUalYVQdheHg4wsPDjc9tsUjIDkIiIiKioqkzNJDJba9ACPw7zWj7vi8KHYWIiMhsGQyGArcX9DlTQWNzxxW177/27duHWbNmFZonIiIC8+fPLzTT1KlTMWXKlEKPL424uLgKOU9xpDI73Iu9D5Uu0yTXK46p7tuU5nddjrGRg6G3z0Zqaip0Oh2ysrIA5Kx5mfvn3P+1dNu3b4ednR169uyJrKwsSCQSDBkyBDNmzMCpU6cKLMrl3vvhw4dx7do1REVFAch5fQYOHIiff/4Z33zzDYYOHQoAePLkCb777juMHTsWrq6uyMrKwgsvvIBGjRphw4YNWL58OewcJPCu4YkafjXRvn37PNc7fvw4vL290bBhQ8Ff94q8vl6vR3JyssX8d2QpOSuDrd67Jdy3ULUsqyoQEqBISoW7FwuEREREVDGK+kDKUtnqGoRAzjSjx3axQEhERFQUX19fKJVK6HQ6SCQSZGdnQ6lUwtvbO99YPz8/PH361Pg8JSUFPj4+xe7LdefOHVStWhWuroXPBvXsF+JziUSiQouZZREXF5dvOsXKIneVw83ZzWTXK4op77syZSgz8fSxAtXrV8Ocrh9j5EcD0bJLTlHMzc0NKSkpkEpzOgnt7OwglUqRlZUFqVSKhw8fYuPGjbh16xZEIhH8/PwwcuRIPP/888bznzt3Dlu2bIFWq4Ver4e3tzfefPNNtGzZEkDO6xgVFYXHjx9DJBLBwcEB7du3R8+ePU1y/8eOHUNwcDAcHP59n9+kSRNIpVKcOHHCmDNX7r0DwIkTJ+Dh4YG6desa90ulUgQFBeHYsWPGKYHPnj0LnU6H0NBQ47EAEBwcjC1btkCpVKJq1aqoU78O5kXMw/2rD1G3WW3juF9//RVvvvkm7O2FXe7gv/deEcRiMapWrWoR/x1Zy3/vZWGr924p9y1UEdN25i6wEZxilIiIiCpSeHg4DAaD8WENbLlA2LZHCxz98bTQMYiIiMyap6cnGjRogPPnzwMAYmJi0LhxY+N0oSdOnIBCoQAAdOjQAadOnTK+Vzp58iQ6dOhQ7L5cu3btwltvvWW6mzMTMrkD1BkaoWNYjdhLdzE+dCYmvzQPIxtOwstvtzEWB4uTmJiICRMmoEqVKvjyyy+xbds2hISEYMqUKbh58yaAnHU5586di2HDhiEqKgpRUVGoVq0a9uzZYzxPREQE6tSpg+joaERFRaF37974/PPPi71+enp6sY+MjIwiz6FQKKBQKODr65tnu0Qigbe3N2JjY4s8/s6dO/Dz88u33c/PD48ePYJWqzWOA5Cv0J97bO5+AJDa26F245q4GRMLvU6PuLg4XLlyBa+99lqRWYiITIkdhFaGU4wSERERFU2dqYXMSdhv7QrFXmaPJu0b4Oz+Cwjt1EzoOERERGZr8uTJiIqKwpEjR5CSkoJJkyYZ923btg0DBgxAmzZt0KRJE7Rq1QofffQRAKBt27Zo2LAhABS5D8gpjMTHx6N+/fqmuzEzwQJhxUm8n4QP3/wUSQ+eAACUT9Lw9LGixMd/9dVXUKvVGDVqlHEdzL59+2L37t3YvHkzFi9ejNjYWGi1WmMhTCwW4+2338apU6cAAFqtFrGxsejRo4fxvO3atcPdu3eLvLZKpcpzTGGkUil++eWXQvenpqYCAJycnPLtc3JyyreOYEHHF9Qh7OTkBIPBgLS0NFStWhWpqamQSqX5uu9yr/vsdSQSMeqH1MGtC3dw8MR+vPTSS3BxcSkyCxGRKbFAaGVYICQiIiIqmjpDDZlcJnQMwbTt0RJHfzzFAiEREVER/P39sXDhwgL3RUZG5nk+YMCAQs9T1D5nZ2csWbKkbAEtnKOzDKp0tdAxrMKjm/HI1v67npxep8eNmKI75v7r3LlzqF69OuRyuXGbWCxGYGAgzpw5A71ej7p168LR0RHTpk1D9+7d0b59e3h7e6NLly4AAHt7ewQGBmLt2rW4d+8eOnTogHr16mHw4MFFXtvBwQHLli0rNmN51uYqzywoJT22uHG1GlbH/vn7MX9+RJmzEBFVBhYIrYwiSQl3L04xSkRERFQYTaYWDjbaQQgAbbq/gC/Cd2JS1DtCRyEiIiIbJZPLoM5ggbAiNHu1MTy83fD0cU4XnUsVZ/SZ9maJj1cqlfD09My33cXFBVlZWVCpVKhSpQoiIyPx9ddf44svvsCGDRvQtGlTjB8/HgEBAQCATz/9FDt37sT+/fvx3XffoXr16hgxYgTatWtX6LXFYnGedf8KU1yB0M0tp1lCpVLl26dSqYpc4zP3+MKOFYlExq4/Nzc3ZGVlITs7G3Z2dnnGASj0On/99Rd8fH3gbu8BVboajs62+2VFIjIvLBBaGa5BSERERFQ0daYaTi75px+yFR4+7vAN8Mb1kzcQ1CpQ6DhERERkgzjFaMURiUTIUKrQ6s0QZKaqMG71cNRtWrvEx7u6uiItLS3f9rS0NEilUjg6OgIAatSogRkzZuD999/HoUOH8Pnnn+ODDz7AV199BYlEAmdnZ4wcORLDhw/HmTNnsGXLFixcuBDR0dHGIuKzKmqKUXd3d7i7uyM+Pj7Pdp1Oh6SkJDRr1qzI8wcEBODy5cv5tsfHx8Pf3x/29vbGcQCQkJCA6tWr5xn33/3P2rNnD958803UalADD/55hCq+HpC72e7vI0RkPlggtCIalQZ6nR6Ozo5CRyEiIiIyW5pMLTx83IWOIajcaUZZICQiIiIhsEBYcVa9uwH9ZnbHG2NfK9PxzZs3x2+//Yb09HQ4OzsDAPR6PW7evImmTZtCLBbj8uXLePjwIV5//XU4OjqiS5cuMBgMWLVqFZRKJaRSKbZu3Ypx48ZBLBajZcuW8Pf3x/Dhw3Hv3r1CC2cVOcVou3btcPz4cej1euNaitevX4dWq83Xxfjo0SN4eXnlOfavv/7CgwcPUKNGDQCARqPB33//je7duxvHtW7dGpGRkbhw4UKeAuHFixfRoEEDVK1aNV+u2NhY3L17F6+++ioAoMZz/nh0Kx56nR4uVZyLvS8iosokFjoAVRx2DxIREREVT52pgczJQegYgmrT/QUc23VG6BhERERko7gGYcU4vvsMUuKflrk4COSskymTybBp0ybo9XoAwLfffguFQoERI0YAAJ48eYKvv/4aKSkpAHIKiFevXkWtWrXg4eEBrVaLn376CVeuXDGe99KlS3BwcEBQUFCh1xaLxWjatGmxjyZNmhR7H/3794dWq8U333wDAFCr1di0aRNCQ0MREhJiHPfHH39g2LBh+OGHH4zb2rVrhwYNGmDjxo3IysqCwWDAF198AScnJ/Tu3ds4ztPTE71798aOHTuMr8WJEydw6dIljB49usBce/bsQceOHY2dmADgX88P6akZUCSmIu52Ah788whatbbYeyQiqmjsILQiqUlKuHH9QSIiIqIiqTM0kMltu0BYPbAaJHYS3Lv2ALUa1BA6DhEREdkYR7kM6amZQsewaFq1Fov6rcQvqq9KND4pKQkzZswAACxZsgSvvvoqRo0aBW9vb6xevRobN27E4MGDIRKJ4Ovri+XLl6N+/foAgIYNGyI0NBQzZsyAnZ0dsrKyULt2bSxatAhAznqFAwcOxNq1awHkFBCdnZ3x8ccfw8fHpxLuPj8vLy8sX74c69evx4EDB6DT6dC8efN8hTsPDw84OTnl6fYTi8VYtGgRoqOjMXr0aIhEIvj7+2P58uX51hUcMWIEnJycMG3aNNjZ2UEqlWLRokVo1KhRvkwqlQq///47Vq9enW+fb21vxF68B70upyj74J84VK/vBwcb/yIjEZkWC4RW5GliKjy83YSOQURERGTWNJka/uKNf7sIWSAkIiIiU5PJZXgSlyJ0DIs2q/NHWLxvTonHe3l5YdWqVXm2ZWVlAchZX3DBggWFHuvt7Y0JEyYUul8qlWLw4MEYPHhwifNUhoCAACxZsqTIMcHBwdi9e7fx3nO5uLhg2rRpxV5DLBZjwIABGDBgQLFjHR0d8dNPPxW4LyM1E2KJCHpdznN9th7K5DR48fcUIjIhTjFqRRSJqXBngZCIiIioSCwQ5shdh5CIiIjI1LgGYfns+ORHBLUORNP2DYWOQmVkL5PCYPjPBhFg72gvWB4isk0sEFoRrkFIREREVDx1phYyJ/7yHRhaFynxCjx5lCx0FCIiIrIxLBCW3a0Ld/DnzuMYtXig0FGoHOxl9qhWzxd2DnaQSCVwdpcjU6kSOhYR2RhOMWpFFEmpqOLjLnQMIiIiIrPGDsJ/5U4z+tb4zkJHISIiIhvi6CyDKl0tdAyLNKvTImy4vKLUxyUnJ+PixYt5tmVnZ8POzjY/HjaXezfoDdDpdUhLs0NGaiauXLkM71pelXrNir73zEyuJ0pkqYT/KUgVRpGYijqNawkdg4iIiMisqTM0kMlZIARyphn9avEPLBASERFZgIiICMyfP1/oGBVCJpdBncECYWl9OvR/GLN0CDxKucTQm2++iS+++AJDhw7Ns91cimRCMNd712RqkPokDd41PSvtGhV97/7+/mjatGmFnY+ITMf8fgpSmXGKUSIiIqLisYPwX8EdGmNe9yVQpavg6OwodBwiIiIqQnh4OMLDw43PRSKRgGnKh1OMlt4fXx+FLkuHsCHtS31snTp1cO7cuXzb4+LiUK1atYqIZ3HM+d5vnL2NRf1WYuuttZVyfnO+dyIyLa5BaEVSk5Rw82KBkIiIyBLs2LEDR48eFTqGTVJnaiBjgdCoTY8WOPbjaaFjEBERlduBAwewZcsWaLVaoaNQMVggLB1lShrWvrcJs7+aJHQUMoHA0Lr4ZP+H6FFlmNBRiMjKFVogVKvZ5m9pFImpcC/lFANEREQkjO+//x4JCQlCxyhWREQERCKR8WENNJlaODjZCx3DbLTt3gJHd7FASERElm/fvn3w9/eHSCTCyZMn0bVrV4wfPx7x8fFCR6NncA3C0pnV+SMs3jdH6BhkQtXq+mLr7bUIE/dBuiJD6DhEZKUKLRDOmzcPW7ZsMWGU8rPGD7BKgwVCIiIiy1GrVi10795d6BjFCg8Ph8FgMD4sncFggFathYMjOwhzsYOQiIishaenJ8LCwiCVSrFlyxa0aNECb731FtasWSN0NHoG1yAsuS3zdqD1m6F47oV6QkchE3PxcMYB/bcYFDAO8bGPhY5DRFao0AKhh4cHhg0bBgCIiYkxVZ5ysbYPsEojQ5kJqYMU9g5SoaMQERFRCfTt2xe//vqr0DFsDqcXzU8kEqHVm6E48dMZoaMQERGVm16vx+3bt3H79m2MHTsWr732GgICAqBQKISORv/BKUZL5sqxv3HhjysYNLe30FFIQLuefoEZYQtwI+a20FGIyMoUWiAUiUS4fTvnh87evXtNFojKhusPEhERWZZvvvkGkZGRmDVrFn777Tc8fpzzjdAlS5YInMy6aTI1cGCBMB9OM0pERNbgxRdfxMSJE7Fw4UKEhobCx8cHACCXy5GWliZwOvove5k9srXZ0Ov1Qkcxa5xalHJ9eTsSq97ZgHMHLwkdhYisSKEFwn79+mH27NkYO3Ysbt26hWPHjuV7M/XHH39UekAqGU4vSkREZFnkcjkWLFiAOnXqYM+ePRgyZAgGDhyIs2fPCh3NqnH9wYJxmlEiIrIG7du3x8iRI9GuXTtMmjQJAHDgwAH8/vvv8PLyEjYc5cMuwqIt6LMc0z8fB0dnR6GjkJlYd/ZT7Ph0F/765rjQUYjIStgVtiMmJgZDhw6FTCbDli1bEB0djYSEBAQEBKBp06Zo2rQpDhw4gFdffdWUeakQikQl3L3ZQUhERGQpxo8fD29vb7Ro0QIAoFKpcOXKFWzcuFHgZNaNHYQFc3aXo27T2rj411U0bd9Q6DhERERl1qxZMzRr1sz4XK/X4/XXX4dMJhMuFBXI0VkGVboaTi4sgD3r102/Q+7mhJd6txY6CpmZJQfmYeHbK5D2NANvvBOGu1fuw6WKM6pWqyJ0NCKyQIUWCM+ePYvx48ejevXq+OuvvxAREYGkpCRcvHgRFy9eRHR0NOLj402ZlYrADkIiIiLL4u3tnee5o6MjXnjhBTx69EigRLZBnaGBTM4CYUGeb1UfS4dH4oXOzTBx3Rih4xAREZXahg0bcP36dSxatAhOTk74559/0KpVK7i58fMScySTy6DOUAsdw2ykJDzF5cPX4V/fD1vnf4OvH0QLHYnM1NydU7BqbDSmtJ+HR7fiIZFKMHv7JDRq87zQ0YjIwhRaIHR1dYW/v3+ebV5eXujYsSM6duwIAJg/f36lhqOSUyQp4c41CImIiCzGjh07IJfL0bRpU9SsWdO4PTQ0VMBU1k+dqYGMHYT5xF6+h18/O4i0lAzsjTqARzfiseRguNCxiIiISuXmzZuYNWsWnJyc8O2332Ljxo2wt7dHeHi4cdYGMh+cYvRfiqRUjA+dCbFEjOR4BZb9wfdhVLRaDWrgl89+h0FvAAB81H8lFv86B7Ub1izmSCKifxW6BmGDBg0wffp07N+/HxkZGQWO6d27d6UFo9JhByEREZFluXDhAg4dOoSxY8eib9++WLRoEfbs2YOVK1cKHc2qcYrRgn05/xukpfz7nj/20n1cOfa3gImIiIhKz8vLC97e3jAYDPjhhx8wdOhQbN68Gd9//z30er3Q8egZLBD+a0bHBXgS9xSJD5Khy9Zh9TguO0BFe3gz3lgcBAB9th4JdxIFTERElqjQDsK33noLTk5O2LNnD/755x8MHDjQuPZg06ZN4evri++//x6NGjUyZV4qhCIxFc+3rC90DCIiIiqhDh06ICwsDFqtFteuXcPJkyexadMmaLVaoaNZNU2mFg5O9kLHMDv+z1WD1N4OWdpsAIDEXgKfWl4CpyIiIiodg8EAhUKBa9euIS0tDT169IBcLkfjxo2RlJQEHx8foSPSf+SuQWjrsrOzkalU5dmmSlMhKysLUqlUoFRk7nq8/zqO/nASKfEKAIDU0R4tu4YIG4qILE6hBUIACAsLQ1hYGObOnYtu3brh4sWL2Lt3L1asWAFPT09kZWWZKicV42liKjzYQUhERGQxwsLCAAD29vZo1qwZmjVrhq5du+LYsWMCJ7NunGK0YKM+Hoj42wm4dPg6lE/SMGXDO/CqXrVCr7FhwwZs2bIFEokkz3Z++MXXoLz3r9fr0bNnT0ydOrUCUxGRJerVqxfeeecdpKWloVOnTpDL5QAAtVrNDkIzxDUIc9jZ2WHC+tEIf+tTZGfp4OTmhMkbxtr0ewMqXvXAalh1ZBFWjY2Gu7cbjv5wClq1Fg6O/F2HiEquyAJhrvfeew8+Pj544YUXAAAqlQpXrlzBxo1sdzcXqUlKuHENQiIiIotx7NgxeHl5oV69ehCLc2Z9r1GjBq5cuYK0tDS4uLgInNA6qTM0kMn5S3NB5u6cipvnYhHz20Wc+vkcWnap2G8gr127FpMnT0b9+nlnvcjOzoadXYl+LbFatv4alPf+ExISMGXKFBYIiQj16tXDpk2b8Pfff6Np06YAgJUrV+L06dMYNmyYsOEqQEREBObPny90jArDKUb/1aJzMHTZOrw94y00fikIIWFNhY5EFsCvjg8+/W0eAOBGzG1MbjcP685+KnAqIrIkJfot7NkpGBwdHfHCCy/g9u3blRKqorRp06ZCz2dvb77TUSkSlXD3rvwCoTm/BqZg6/cP8DWw9fsH+BoAfA0s6f7NOeuuXbvw999/QyKRoFGjRmjYsCE8PDxw/fp1ZGRklKpAGB8fj/Xr16NKlSpISUnBuHHj4Ovrm2/cpUuX8N1336F69ep48uQJnJ2dMX78+HwdXUWx9PdX5rgGoTn9O63fvA7qN6+D7h5DMeKjAXB2l1fYuSUSCYKDg9GsWbM82229OAbwNSjv/d+7d8/4RQtLZU4/B4Ri66+BJd2/uWd1cHCAn58fdDodpFIp+vbtiw4dOljFz9nw8HCEh4cbn7dt27ZCz2/qv1tzKRCaw7/pvVG/ocuYMIz6ZJBJr2sO9y4Ua7v3wJC66Dj4Jayb9DnGrRpe5Fhru/fS4L3bHku5b6Fylui3qBs3bmDUqFHo3LkzIiIikJ2djYSEBPTr16+y85VLRU/RZc5rAikSU+FugilGzfk1MAVbv3+Ar4Gt3z/A1wDga2BJ92/OWevWrYtdu3bh448/RsOGDXH58mXs2LEDrVu3LvX6OCtWrEC3bt0wadIkdO3aFatXry5wnEKhQL9+/TBmzBjMnj0bV65cQUxMTKmuZenvr8yxQGiO/04HzO6Jrz7+wSTXMhgMJrlOaf35558YOHAgwsLCsGfPnkq9lrm+BqZi6/cPmOfPAVOz9dfAku7fnLNevXoVffr0wbBhw9CjRw8sWrQIIpEITZo0ETpapbD092XmMsWoOfyb3h25D2+N72zy65rDvQvFGu+958SuSHqYjCPfnyxynDXee0nx3m2Ppdy3UDlL9PWpzz77DG+99Ra8vb2xd+9eGAwGLF68GGPHjkVQUFBlZ6RiKJPT4Owht/hvzRIREdmSsWPHAgAaNGiABg0aoH///mU6T3JyMq5evYrg4GAAQEhICCIiIqBQKODu7p5n7EsvvWT8c1paGlQqFfz9/ct2AxZKnamBTC4TOobZ6zv9LXSSvo2RHw+AxK7kHaallZaWhj179iAmJgYJCQmQSCTw8PBAq1at8Prrr+f7N2xKL7/8Ml588UV07do1z/aMjAwMHz4cw4cPx+uvvy5QuvI5duwYvvzyS+j1euh0OnTt2hU9e/Ys0bF3797FunXrkJycDJ1Oh5CQEIwaNQqOjo7GMRcuXMD+/ftx+/ZtiEQiaDQaPPfccxg+fHie7uaEhAQMHjy4wOv89NNPec5JRFQSX3zxBSZMmICaNWvi0aNHOHbsGCZOnIglS5YgICBA6Hj0DEdnGVTpwhcIhXbp8DW4VHFGQKOaQkchKxD+3TT08RmJRu2C4GGCZhIismwlKhB6eHjgzTffBADs27cPUqkUn376KT799NM8UxuQMBRJSrhz/UEiIiKLkpmZiR9//BGPHj2Ct7c32rdvX6YPrhISEuDq6mqcJtTOzg6urq5ISEgotLiyadMmHD9+HEOGDLG9AmGGxiSzLliD3C7CwfP6VMr5jxw5gpUrV6Jdu3YYPXo06tatC6lUipSUFBw/fhwzZ87E0KFD8eKLL1bK9cvKzs4OPj4+FrtO6OnTp7Fo0SJ8+umnaNKkCeLi4vD+++9Dq9UWO0NMUlISpk6dit69e6N///5Qq9WYNWsWFixYgMWLFxvH/fjjj9BqtVi1ahWcnJyQnp6O2bNnY+bMmfjss88glUqNY+vWrYsePXrkm+rYUqYCIiLz4u7ujldffRVAznqE7du3x40bNxAdHY1PPvlE4HT0LJlcBmWyUugYghOqe5Cs18qjizC57YfYcuN/QkchIjNXogKhTqdDRkYG5PJ/1yCRyWSoU6cOkpKS4OXlVWkBqXimml6UiIiIKs7SpUsRGxsLf39/XLt2Ddu3b0fnzp0xYcKEPB+eF6ewqflEIlGhx4wcORIDBw7EtGnT4OjoWOD6NREREZg/f36h5546dSqmTJlS4pxFiYuLq5DzlERK0lO4V3cx6TVLwtzyAMDLw1pjbNAMdBhVMetOZmdnIzs7G1lZWfjrr7+wdu1ahIeHo1GjRsYxWVlZcHFxQadOnfDSSy9h0aJFEIvFCAkJqZAMpZWVlQUg5/eh3D+LxWKsWLEiz/6KvFZli4qKQuvWrREUFISsrCx4eXmhW7du2LZtGzp16gRnZ+dCj92+fTvs7OzQs2dPZGVlQSKRYMiQIZgxYwZOnTqF5s2bAwBq1qyJli1bQiqVIisrCw4ODujcuTNWrlyJW7duoV69esZ7rlq1qvHD/P/S6/XQ6/UluqesrCzo9Xqz/O+oNCw9f0Ww9dfAUu6/qPcYQjMYDFAqlXB1/fdL1IGBgahTpw7S0tIs9ssd1komd0DifeHXIBRS6hMlLvxxBXN3Vsz7aiIAqF7fD/0+6IFlI9dh2qZxQschIjNWogLh66+/jqlTp2LcuLw/UB4/flwpoah0WCAkIiKyPPHx8Xk6ae7fv48NGzZg/fr1mDBhQonP4+vrC6VSCZ1OB4lEguzsbCiVSnh7e+cb+98vfMlkMrRs2RJHjx4tsEAYHh5e4EwRIpGoQtcLi4uLQ7Vq1SrsfMWRiCTw8fMx6TWLY+rXoDS6v/c6jn0dgz5T3yz3uezs7GBnZ4enT59i9erVmDlzJoKDg5GVlZWnKK5Wq3H58mUEBwcjPDwcU6ZMQUhISKGF84iICBw9ehQAsHbtWuzYsQNnz56FWq3GhAkT8Prrr2Pr1q04c+YMgJxiX7169TB69Gh4eHjkOdfu3bvxzTffQKlUol69enjvvfcAABKJBFKpFA8ePMD06dOhUCjQvn17zJo1C2fPnsWyZcuQnJyM8ePHo3v37khLS8Po0aPx9OlTvPbaa5g6darxGrt27cIvv/wCsVgMvV6PwMBAdO/e3Vg0q0z379/HgwcP0KtXrzyvZ0hICLZt24YLFy7glVdeKfT4Y8eOITg4GA4O/67j2aRJE0ilUpw4cQItW7YEkPMlhGdpNDkfAFepUsV4balUaiw0lOaLEc+SSqUQi8Vm+99RSZjzzwFTsfXXwJLu35wLmV27dsW0adPw7rvvolmzZsafMZmZmVCpVCwQmhmZ3AHqDNsuEP4UuR/dxncSOgZZoc4jXsXlI9exf8shdBpW+Ps7IrJtJSoQhoSEIDExETNnzoSdnR3mzJkDjUaDjIwMdg+aAUWiEu7enGKUiIjIktSqVQt2dv++FatZsyYWLFiA999/HyqVqsRrb3l6eqJBgwY4f/48QkNDERMTg8aNGxsLHydOnEBQUBDc3d2xatUqjBw50rgG2N27d1G7du0KvzdzpsnUwsGJUxeWVP/ZPTGs/oQKKRDm2rFjBwICAoyF6du3byM6Ohp37txBzZo10a9fP4SHh+O7776Dm5sbXnnlFZw8eRLt2rUr8HwTJ05Ey5YtsXz5cmzcuBFdunTBkCFDsHLlSgA5Bce9e/di3bp18PX1hV6vR3R0NBYsWIAVK1YYPzz+448/sHbtWrz77rt44403kJiYiKioqDzXqlGjBnbs2JHni5OhoaHGDuBcLi4u2LFjB0aNGpXn+GPHjmHr1q3YtGkTPDw8kJGRgdmzZ+Ps2bNFFgh1Oh1UKlWxr62dnR1kssLX2Lxz5w4A5FkHEAD8/PwAALGxsYUWCBUKBRQKRb5jJRIJvL29ERsbW+BxBoMBV69exc6dOzFgwAD4+Pjk2Z+UlITFixfj0aNH0Gg0CAoKQv/+/VGzJtdhIqLSa9asGXr16oU5c+ZALpejbt260Gg0UKvVBX55ioTFNQhzphf97OoKoWOQlZr++XgMrf8+GrV9Hv71/ISOQ0RmqEQFQiCni7BVq1Y4ePAgbt26hZo1a6JPn8pZj4RKJzVJCTeuQUhERGRRQkJC8OWXX2LQoEEQi8UAcqYurFevHlJSUkq1NuDkyZMRFRWFI0eOICUlBZMmTTLu27ZtGwYMGIA2bdqgRYsWWLVqFWrVqgWlUgm5XI6+fftW9K2ZNXWmBjInh+IHEgDAtYoLXurTCnujD+CNd8LKfT6DwYAjR45gyJAhAIC0tDTMnj0b7du3x6JFi6BUKrF8+fI8xzRv3hyHDh0qtEDo7u5uXG/zxRdfNE5X+f7770MqlcLJyQnr1683FqbEYjHeeOMNjBgxAg8ePDAWorZu3YrAwED07NkTAFC9enW8+eabOHXqVLnvO9f169fh5OQEN7ec2T/kcjlGjhwJrVZb5HFnzpzB3Llziz1/aGhonrUAn5WamgoAcHJyyrM997lSWfg6UIUdm7utoGMPHDiAdevWQa1W4+2338agQYPy7BeLxTAYDOjZsycaNGgAlUqFNWvWYPz48VizZk2Z1mUlIurUqRNatGhh/PyqSpUq/PzKTMnkMqgzbLdA+Ne3J9D05QZw9+KsYFR5Vh5ZgLHBM/BN/EahoxCRGSpxgRAAPDw8zPpNVVFr5Vizp4kK1G7Ib9gSERFZkt9++w0XL17EgQMH0LZtW9SrVw/Z2dnIzMw0TjGWmJhYom+7+/v7Y+HChQXui4yMNP45LCwMYWHlL/JYMnWGBjI5C4SlMWB2T0xqN69CCoRKpRIKhcJYlDty5AjUajXGjh0LBwcHyOVyDB48GBcvXjQeI5PJkJmZWaLzN2zY0Pjn+vXrG/987949LF++HI8ePQKQ05EH5Ez1W7NmTaSlpeHRo0fo3r17nvP99xwVoXHjxti5cycmTpyIt956C61bt0aTJk2KXX+wQYMGWLZsWbHnL+vUeeWdNriw43N/5jx48ADLli3D6dOnsXTpUuNUx97e3tiwYQOysrIgFoshl8sxadIknDp1Clu2bEFERES5chGRbViwYAGqVauGJk2aoFGjRnBycjL7z68oh61PMfpT5D4MibCtL+uR6VXx9cD4NSOwsO9yzP1mavEHEJFNEQsdoCKFh4fDYDAYH7aCU4wSERFZHmdnZ2MHYWpqKj7//HMsW7YMDx8+RHR0NE6cOIH169cLHdPqaDI1cGAHYal41/RCk5eCcHDb4XKfS63O6RLInQI3MTERVapUybOmnaenZ55jHj58WOJlDZydnfNtO3/+PObMmYPGjRtjy5Yt2L59O1atWgUAyM7OBgAkJycXeHxB5yuPli1bYvHixXB0dMSSJUvQp08fLFmyBGlpaUUelztNXnGP4tYvy+1cfHa60tznrq6F/05R2LG524o6tkaNGpg5cyZu3ryJb7/9tsiMjo6OqFWrFq5fv17kOCKiXCkpKUhJScHq1avRo0cPjB8/Hhs2bMCpU6eQkZEBANi7d6/AKakgtlwgvHv1AVKfKNG0fcPiBxOVU/s+rVHFzwM/rvlF6ChEZGZK1UFI5kmRmAp3b05HQEREZEnmzJkDqVQKX19fdOrUCQDw+PFjXLx4ERcvXkRkZKTNrQ9oCiwQls2A2T0xv9cydBz0UrnOk7s+Xu4Htt7e3khJSYFGozEWCZOSkvIcs2fPHowZM6bM1zx06BCkUikGDhxonM73WVWrVgWAfIW69PT0El0jdx3DZxVUTAsNDUVoaCiSkpKwd+9e7NixAyqVCuHh4YWev6KmGM2dsjM+Pj7P9tznderUKfTY3Klcnz1Wp9MhKSkJzZo1M25Tq9X51kKsVq0aHB0dcfPmTeO2jIwM2NvnXxNULBZDr9cXmoWI6L969OiB9u3bAwASEhKM76XWrFmDJ0+eoG7dukhNTcUbb7whcFJ6li1PMbo7ch/eGt+5+IFEFWT86hEY23w6GrcLgpMPfx8iohwsEFoBRZIS7lyDkIiIyKJIpdJ823x8fPDaa6/htddeAwBOr1cJ1JlayJzyFySoaDWDqqPGc9VwbNdptOneoszncXV1hZubG2JjYxEUFIR27drhs88+Q1RUFEaNGoW0tDRs27YNQE5X34YNGxAYGFiutehyuwT/K7djMJeLiwv8/f1x7dq1PNtv3bpVomuIxWK4uroa1+kDcopfz17np59+QmBgIJ5//nl4eXlh+PDhiI+PL/Y6FTXFaM2aNVGzZk1cuHABXbt2NW6/ePEiHBwc8MILLxi3paenIzs727i+IwC0a9cOx48fh16vNxZbr1+/Dq1Wa1wjUqvVok+fPti1axckEonx2LS0tHydhmvWrEHz5s2N60bmHn/v3j0899xzxd4vEREAY3EQAHx9ffN9+erChQv4+uuvhYpHRXB0lkGVbnsFQoPBgL1Rv+GAvuiueqKKturoIvT2GoENN5cKHYWIzIRVTTFqq9hBSEREZJ1GjRoldASro85QQyaXFT+Q8hkwuye++viHcp1DJBLhxRdfxOHDOdOVuri44OOPP8bdu3cxYMAAfPzxx+jVqxfkcjnWrVuHFi1aYPjw4eW6ZuvWrZGVlWX8cFilUuHLL7/MN27IkCG4efMmdu3ahezsbCQkJJTqA+UmTZrg2LFjyMzMhF6vx/bt2+Hk5JRnTGxsLHbu3AmtVgsgp4h4+/ZtNG3atMhzu7q6omnTpsU+iuoAzDVmzBgcPXoUV65cAZDTbfPjjz9i0KBBeaZUfe+99zBixIg86yP2798fWq0W33zzDYCcTsFNmzYhNDQUISEhxnFqtdq4tmDu8zVr1kAikaBbt2558uzcuROJiYkAAL1ej+joaGRmZmLgwIF5xk2cOBGzZs0q9v6IiP7Lx8cHnTp1Qtu2bYWOQgWw1SlGf4rch27sHiQByJwcMP+H6Vg6kEtZEFEOdhBaOL1ej/SnGXCtWvS3hYmIiMjy+Pv7Cx3B6mgytXBgB2GZPPdCPcjdnHDu4CU079ikzOd5++23MXr0aJw9exahoaGoW7cuVq5cmWfMrl27Sny+zZs349dffwUATJ06FXXq1MHHH39s3N+uXTuMHTsWu3btwp49e+Dr64tXX30VMTExWLlyJf755x+MGDECr776KtLT07Fz505s2rQJNWrUwJgxYzB9+nR8/vnnOHv2LEaPHo2ZM2ciJSUFDx48wMCBA7F9+3YAwNixY7F8+XIMGjQIPj4+GDZsGE6fPo0///wTly9fxpYtW9CxY0d8//33ePfddyGVSpGVlYUWLVrkK4ZVppYtW2LOnDlYu3Yt9Ho9dDodBgwYgJ49e+YZ5+3tDQcHhzxdgF5eXli+fDnWr1+PAwcOQKfToXnz5hg9erRxjFQqxYwZM3Do0CGMHTsWEokE2dnZqFWrFtasWYPAwEDj2L59++Lnn39GeHg4xGIx0tLSULt2bSxfvhwNG+Zdk+nx48fo3JkfphJR2VjLl64iIiIwf/58oWNUGFstEO5etx/zv58mdAyyUaGdmuH4L6fx1UffY8CcXkLHISKBsUBo4dg9SERERFRyWrUWDo5cc6OsBs7pha0R35SrQOjv748JEybg448/xkcffYR69eoVOC45Odm4NmBRRowYgREjRhQ5plevXujVK+8HIM92suVue3b7gQMH8jzPLQg+y8fHB0uWLMmzrWXLlnmeN2rUCI0aNcp37H+79Eyhbdu2xXbTPHsvuQICAgrdB+R0iYaFhSEsLKzYHHXr1sWECROQlZVV4LTLuU6dOoXMzEx06dKl2HMSEVmz8PDwPGvWFrYGrqWQ2ktzvqySrYPETlL8AVbgwqErqOLrjppB1YWOQjas98w3sHxANKQyKRSJStQNro1X+7HTmsgWsUBo4VKTlHDj+oNERERExVJnauDgyO7B8mj6ckNkzc7GtRP/oEHrsq8R17lzZ9jZ2WHOnDl45ZVX0KVLFwQEBEAsFiMxMRH79u3D5cuX8cknn+TpYCPbk5WVhaioKMyZMwfe3t5CxyEiogqWuw6hs7tc6CgmsTtyH97i9KJkBgbM6YkPOi0CAMjdnGBnJ8FLvVsLnIqITI0FQgunSFTC3ZsFQiIiIqLiaDI1cHBi92B55a5FuGhP+daD69ixI0JDQ7F7927873//Q1JSEmQyGXx9ffHyyy9j0KBBEIu5ZLqtk0qliI6Ohr09i/tERNZIJpdBnWEbBcKnjxW4cvRvhH/H6UVJWAaDAWsnbDY+z0jNxNoJm9HqzVDYOxQ+qwMRWR8WCC3c08RUeHCKUSIiIqJiqTM0kMlZICyvVm+EYNPsr3Dn8j0ENK5VrnO5u7tjwIABGDp0aAWlI2vE4iARkfWypXUI2T1I5kIkEsHFI29RXu7qyOIgkQ3iV3ItHKcYJSIiIioZdhBWnNwuQiIiIqLysKUC4U+R+9FtfCehYxABAD7ZPxfeNT3hVb0qRGIR5n03VehIRCQAFggtHDsIiYiIqDJFRERAJBIZH5ZMnamBjAXCCvFKvzb4+/QtxMc+FjoKERERWbDcKUat3aEdxxDyWhO4VnEROgoRAMDJxRGbrq3Eu6uGYc7XkxE54XOhIxGRAFggtHCKxFS4s0BIRERElSQ8PBwGg8H4sGSaTC0cnDhVYUVhFyERERGVl6OzDKp06y8QcnpRMkcyJxna9WyF9n1awzfAG/s2/yF0JCIyMRYILRwLhEREREQlwylGK9brIzvg5J6zeJqYKnQUIiIislC2MMVo7KV7yFRmolHbIKGjEBVq2qZxWDNuI7SaLKGjEJEJsUBo4bgGIREREVHJqDM0kMlZIKxI/Wf3xNfsIiQiIqIysoUCIbsHyVJ8sG0CPhm0RugYRGRCLBBaOEWiEu7eLBASERERFYdrEFa8nhO74peNB6HOtO4P9oiIiKhyWPsahLpsHfZt/gNdx4QJHYWoWC/1bg1dtg7Hdp0WOgoRmQgLhBaOU4wSERERlQynGK0cA+b0wlcffS90DCIiIrJA1r4GIbsHydKwi5DIttgJHYDKTqvJQpYmC3JXJ6GjEBEREZk9TaYWDk72QsewOgNm90SYuA9GfDRA6CiCOXbsGL788kvo9XrodDp07doVPXv2LPIYg8GAM2fO4JdffkF8fDwMBgMAICwsDN27d4dUKs13zO+//46ffvoJGo0G6enp8PDwwNtvv422bduWaRwREZHQHOUyqKy4g/CnyH1Y9PNsoWMQlZijXIaxK4Zi5TvRmBz9jtBxiKiSsUBowbj+IBEREVHJqTPUkMllQsewSv0+6I6vF/+I/rN6CB3F5E6fPo1Fixbh008/RZMmTRAXF4f3338fWq0W/fr1K/Q4pVKJOXPmYMiQIZg1axYcHBxw48YNTJ06FTdu3MCcOXPyjN+2bRtOnjyJiIgIVK1aFVlZWVi0aBEuXbqUp/BX0nFERETmQCZ3QMpjhdAxKkXMgYvwqe2N6vX9hI5CVCpdx4Th4EtzcfnIdTRuFyR0HCKqRJxi1IJxelEiIiKikuMahJVnwOye+OrjH4xdcLYkOjoabdq0QZMmTQAA1apVQ48ePbBt2zakp6cXeayrqysGDRoEsTjn17LAwEB07NgRf/75J1JSUozj7t+/jy+//BJTp05F1apVAQBSqRTjx49Hp06dSj2OiIgsU0REBEQikfFhDWRyB6gzrHMt45/W7Ue3cfz/X7JMs7ZPxOKBq4WOQUSVzKoKhNb4RqkoLBASERERlRwLhJXH0dkRrd4MQV+/URjf4gMoklILHPf555+je/fuCAsLw8WLF/Hee++hR48eGDhwIPbs2WMct3XrVvTq1QthYWG4c+cOAODUqVN4++23ERYWhoMHDwIA7ty5g7CwMISFhWHx4sU4dOgQhgwZgrCwMPTp06fS7/v+/fu4f/8+goOD82xv1qwZNBoNzpw5U+ixbm5u2LFjR77fW3ILe/8tLu7fvx/e3t4ICAjIM9bb2xt169Yt9TgiIrJM4eHhMBgMxoc1kMllUFvhFKPJcSn4+/QttOneQugoRGXiXcMTb77bCZtmbxc6ChFVIqsqEFrjG6WiKBKVcPfmFKNEREREJcE1CCvP5aN/4+z+81AkKnHj7G2MDZ6OpwVMFzZ8+HCMHDkSALBp0yZ88MEH2LlzJ3r06IE1a9bg8OHDAIAhQ4bkm2KzZcuW2LBhQ55tNWrUwJdffomAgADcuXMHJ06cwIcffohp06YVmVen0yE9Pb3Yh1pd9AeWucVLX1/fPNv9/HKmEouNjS3y+ILWGXz48CGqVq0Kf39/47Zr167Bz88PBw4cwIQJEzB8+HBMnjwZf/31V55jSzqOiIjIXDg6y6BKt74C4e7IfXhrfGehYxCVS/9ZPXDip7O4e/WB0FGIqJJwDUILpkhSwp1rEBIRERGViCZTAwd2EFaKcwcvIv1ppvG5Kl2Ns79dRNjg9oUeM3DgQFSvXh1ZWVno3bs3Dh48iK1bt+Kll14q8XXt7Ozg6+sLOzs7JCUlITIyElKpFIGBgcZpOwty5swZzJ07t9jzh4aGYvHixYXuT03N6ZR0cnLKsz33uVKpLMltGCkUChw/fhzjx4+HRCIxbk9MTIRSqYRer8fChQvh4uKC33//HYsWLUJaWhreeOONUo0jIiIyF9Y6xejuyP346t46oWMQldsH2ybgk0FrEHV+qdBRiKgSsEBowRSJCrh7uwsdg4iIiMgiqDM0kMlZIKwMz71QD06ujshUqgAADk72aPjic0UeExgYmOd5w4YN8dNPPyEzMzNfwa0kAgMD83TkhYWFFTq2QYMGWLZsWbHndHFxKXUOAGWazUSv12P58uVo27ZtvvUCtVot1Go13n33Xbi55SwxEBYWht9//x1ffPEFunTpArFYXOJxRERE5sIaC4S/bz+CVm80h9xNLnQUonKr1ywAwR0b49tlP6HPtG5CxyGiCsYCoQVTJCpRM6i60DGIiIiILALXIKw8rbqGYO43U7BkeCTUaWr0m9kD1er6FnmMXJ73Q7PcYlxycnKZCoTOzs4lHiuXy0u0Jp+dXdG/LuUW4VQqVZ7tuc9dXUs+28f//vc/iEQiTJ06Nd8+JycnKJVK1K5dO8/2evXqISYmBomJifD19S3xOCIiInNhTWsQ3rl8D+unfoE7l+4j4sfpQschqjDvLB2Cvn6j0WFQO1Tx9RA6DhFVIBYILZgiMRXu3m5CxyAiIiKyCJxitHKFvtYM22Ij8eRhCma+thA9J3YtcnxGRgbs7f9dEzJ3Os6qVasCQIGdbs8W4sqqoqYYDQgIAADEx8fn2Z77vE6dOiXKExUVheTkZMydOzfP1KK5atSoke8awL+vUW7HYknHERERmQuZswxqK1iD8NaFO5jVeREUiTnvZzbO/BIrDy8SOBVRxZm1fQIWD1yDpb+HCx2FiCoQC4QWjGsQEhEREZWcJlMLByf74gdSmdk72KNaXV80aB2I37cfQYeB7Qode/PmTbRo0cL4/Nq1a6hVq5axe9Dd3R3Av+v8AcC9e/cqJGdFTTFas2ZN1KxZExcuXEDXrv8WRC9evAgHBwe88MILxm1ZWVlITk7O18EXGRmJxMREzJs3zzhF6g8//IDq1asbX5/WrVvj1KlTuHv3bp7Ox7t378LNzQ0+Pj6lGkdERGQuHOUOUFnBFKM7PtllLA4CwKObCTj/x2UEv9pYwFREFSf41cY4uO0w9n9+CJ2GvyJ0HCKqIFyAwoKxg5CIiIgqW0REBEQikfFhyTjFqOkMntcHXy74tsgxe/bsQUJCArKysvDDDz/g9u3bGDJkiHG/v78/PDw8cPDgQRgMBmRkZOC3336rkHyurq5o2rRpsY+SdACOGTMGR48exZUrVwAACQkJ+PHHHzFo0KA8056uXbsWgwcPxt9//23ctm7dOvz5559o1aoV/vrrLxw8eBAHDx5ETEyMsaMSAF577TXUrl0bn332GTSanA9Rz549i1OnTmHYsGHGDsGSjiMiIjIX1rIGYb3g2rCz/7cPQywRw7uWp4CJiCre9M3jsWrsBmRps4SOQkQVhB2EFkyRqIS7NzsIiYiIqPKEh4cjPPzfaWQsuUioztBAJmeB0BSqB1ZD/eYBOLTjGF7p16bAMcOGDcOnn36KW7duwdXVFRMmTMBLL71k3C+VSjFr1ixERkaib9++qF27NkaMGIHDhw9j/fr1OHfuHMaMGYPx48cjJSUFDx48wMCBAzF58mSEhoaa6lbRsmVLzJkzB2vXroVer4dOp8OAAQPQs2fPPOO8vLzg6upqLBo+fPgQP/74IwBg1apV+c77yiv/fjNbKpViyZIl2LBhA4YPHw57e3vIZDLMnDkTr776aqnHERERmQtrWYOw38weuHnuDo58dxI+Ad4I/3Yq/Ov6CR2LqMJ9sG0CPhm0BnO/yb9uNhFZHhYILZQqXQWxRAwHR37IRURERFQSXIPQtAbP64P5vZYVWiCsUaMGVq5ciaysLOPUms8KDg7GZ599lmfbgQMH8jzfvn17xQQuh7Zt26Jt27ZFjhk0aBAGDRpkfF69enXjvRT1GuTy8PDAzJkzi81S0nFERETmQGIngVgsRpY2C1L7ov+/0Nx1GNAOqUlKfLhzMty9OOMXWaf2fVrj9+2HcXz3Gbz41gvFH0BEZo0FQguUnZWN8B5LocvKxrUT/6BB6+eEjkRERERk9lggNK2aQdVRu2ENHP7uBF7q3VroOERERKUSHx+P9evXo0qVKkhJScG4cePyrSOba8eOHbh9+zYMBgMCAwPRt2/fEu07c+YMjh49Cnt7e9y7dw99+/Y1aRe8uXB0lkGVroa0imUXCK+e+AcvdGrG4iBZvVnbJqCv3xjsjN+AxHtJqN2wptCRiKiMWCC0MDqdDu+GzMDdKw8AALNe/wgLds1E05cbCpyMiIiIyLxpVFquQWhig8P74OP+q1ggJCIii7NixQq8/fbbCA0NxalTp7B69WosXrw437jLly/j+PHjWL16NQDg/fffR+PGjREUFFTkvsTEROzZs8e43vPTp0+N68famtx1CF2ruAgdpVz+PnkTQyL6Fj+QyMI5Ojui7/Ru6F/9HTg6y9D4pQaY89UkoWMRURmwQGhhYg5cRFpKuvF5plKFnzceYIGQiIiIqAjqTA0cHO2FjmFzAhrVhH99Pxz98RRCQ0MxcuRIuLi4QCqVomPHjrh37x5SUlKEjklW4PXXXxc6AhFZkeTkZFy9ehXBwcEAgJCQEEREREChUMDd3T3P2IMHD6Jly5bGdZpbtWqFAwcOICgoqMh9e/fuRY0aNbB582ao1WoEBASgS5cuJr1Pc5FbILR010/eQFCrQKFjEFU6RVIqfvviEDKVKmQqVTj24yl8Nms7Ri0eKHQ0IiolFggtTN2mtQHRv88lUgkavvi8YHmIiIiILAGnFxXOoHm9sWz4OkSdjYJKpcq3Pz4+Hn5+fgIkMx+2/hpUxP3LZLIKSkNEBCQkJMDV1RUSiQQAYGdnB1dXVyQkJOQrECYkJOC55/5d+qVKlSq4du1asfvu37+Pu3fvIioqCvb29pgzZw7EYjE6d+6cL09ERATmz59fYFaRSISpU6diypQp5bllo7i4uAo5T2lI7MV4cPch7FxFxQ+uJOW973tXH8Kvng+eJCdVUCLTEeLv3Fzw3svm1vm7yFBmGp9nabJx/cw/FvN6WkrOymCr924J9537ZSJTY4HQwlT1q4L1MUsxssEkZGmzMHhuH7w1Pv+bRyIiIiL6FwuEwqnXLABeNT1x+udzaN3thXz75XI5nJ2dBUhmPmz9NbD1+yci82MwGArcXtCHdwWNzR1X1D6VSoXmzZsbv+DQrl07/PXXXwUWCMPDwxEeHl7guQrLWhZxcXGoVq1ahZ2vpFw9XOHs6CzItYGKue9zP11B43YNBLuHshLq79wc8N7Lfu/VqlXDnia/4cKhqwByGliGRwywiNeTf++2d++Wct9CFTFZILRAHt5ueG3oy5C7O6Hv9LeEjkNERERk9tSZWsicOMWoUAbP641V72wosEBIRERkbnx9faFUKqHT6SCRSJCdnQ2lUglvb+98Y/38/PD06VPj85SUFPj4+BS7z8vLC2Kx2LhPKpUiKyursm7JrFnDFKPXTt5As1caCR2DyGSW/j4fK8dGI+5mApTJaTDoK+7LCkRkOuLih1Ss+Ph4zJs3D6tWrcK8efOQkJBQ5PjU1FT06dMHu3btMk1AC5H6RAnfWvnfmBIRERFRfuwgFFZgSF14+Ljh1C/nhI5CRERULE9PTzRo0ADnz58HAMTExKBx48bw8PAAAJw4cQIKhQIA0KFDB5w6dQoGgwEGgwEnT55Ehw4dit338ssv48qVK8YOwCtXrhjXPLQ11lAgvH7yJoJa1Rc6BpFJTY56B0t/D8enB+YiotcyoeMQURmYvINwxYoVePvttxEaGopTp05h9erVWLx4caHjN2zYYPx2Ff0rNUkJNy9XoWMQERERWQR1hgYyOQuEQhoc3gdr39+Mll2aCx2FiIioWJMnT0ZUVBSOHDmClJQUTJo0ybhv27ZtGDBgANq0aYMmTZqgVatW+OijjwAAbdu2RcOGDQGgyH2hoaGIjY3FkiVL4OjoCIlEgr59+5r2Js2ETC6DOkMtdIwyS1dk4OljBWo85y90FCJBuHu5YdiCt7Hq3Q2YtH6M0HGIqBRMWiBMTk7G1atXjd+ICgkJQUREBBQKRb5FngHg0KFDeO6556DRWPa3iCpD6pM0uHm6CB2DiIiIyCKwg1B4z7eoD2cPOc7uv4DQTs2EjkNERFQkf39/LFy4sMB9kZGReZ4PGDCg0PMUtc9WC4LPsvQOwusnbyCoVaDQMYgE9cbY1zAjbAHOHbyE5h2bCB2HiErIpAXChIQEuLq6QiKR5Fzczg6urq5ISEjIVyB8+vQpjh07hjlz5uDSpUtFnjciIgLz588vcJ9IJMLUqVMxZcqUirgFwRaLfFZKwlOo9SpB8pjLayAUW79/gK+Brd8/wNcA4GtgKfcvEomEjkBmQp2pgYwFQsENntcHG6ZvZYGQiIiIjGTOMqjTLbeD8NrJG2jAAiERwr+fhgE1xmJ36lahoxBRCZm0QJg7r/qzCvrwLjo6GmPGjCnRB3vh4eEIDw8v8LyFXbMs4uLiUK1atQo7X3mkp2QgsFF9OMplJr2uOb0GQrD1+wf4Gtj6/QN8DQC+BpZ0/5ZSyKTKp8nUwsHJXugYNq/hi8/BwcmB3ywmIiIiI0e5DCoLnmL0+smb6D35DaFjEAlO7uqEcauGY+mISEzfPF7oOERUAmJTXszX1xdKpRI6nQ4AkJ2dDaVSCW9v7zzjkpKS8PTpU3z11VdYtWoVbty4gb/++gvr1q0zZVyzpVFpoNcbTF4cJCIiIrJUnGLUfAye1wdfLvhW6BhERERkJix/itGbCGpVX+gYRGah0/BXoEhU4tTPMUJHIaISMGkHoaenJxo0aIDz588jNDQUMTExaNy4MTw8PAAAJ06cQFBQELy8vPDpp58aj1u0aBEaNWqE7t27mzKu2UpNUsLNy1XoGEREREQWQ52hgUzOAqE5aNwuCBI7CS4cuoJmrzQSOg4REREJTCaXQW2hHYT3/36Eqn7ukLvJhY5CZDbCv5+G7m5D8Iv6a6GjEFExTNpBCACTJ0/G7t27sXLlSuzduxeTJk0y7tu2bRuuXr2aZ3xUVBRu3bqFw4cPY8+ePSZOa54USUq4s0BIREREJhAREQGRSGR8WCquQWhe2EVIREREuRydZVBZ6BqE10/eQBDXHyTKw95Bimmbx+HjgauFjkJExTBpByEA+Pv7Y+HChQXui4yMzLdt7NixGDt2bGXHsijsICQiIiJTeXatZ0stErJAaF6avtwQ+nl6XD5yHVXrugkdh4iIiARkyVOMXjtxAw1as0BI9KxXB7TD4e9P4ugPp9C2Z0uh4xBRIUzeQUjlxwIhERERUelwDULzMyS8L7ZGfCN0DCIiIhKYJRcI2UFIVLj5309HRO9lQscgoiKwQGiBUp+kwc3TRegYRERERBaDaxCan+AOjaFVaXHz7B2hoxAREZGALHUNQo1Kg0c3E1CnSS2hoxCZrXnfTmWRkMiMsUBogRRJqXD34lRMRERERCXFDkLzNHheH+xauU/oGERERBbBWtaGfpaldhBeP3kTQa3qCx2DyKy169UKUns7/PH1UaGjEFEBWCC0QJxilIiIiKh0uAaheQrt1AyZqSpcP3VT6ChERERmLzw8HAaDwfiwFo7OMqjSLa+DkAVCopKZ/dUkLB0WiSxtltBRiOgZLBBaIEWSEu4sEBIRERGVmCZTCwcne6FjUAG6T+mMbQu+FToGERERCcRSOwivnbyBBlx/kKhEwr+fhohenGqUyNywQGiB2EFIREREVDqcYtR8NX21AZ4+TsWNmNtCRyEiIiIBWOoahH+fvIHnWSAkKpFWb4TAzdMV+7ccEjoKEf0HC4QWiAVCIiIiotJRZ2ggk7NAaK4Gh/fBlxHsIiQiIrJFlthBGH/nMWRyGTy83YSOQmQxpn8+HpETNiMzTSV0FCL6fywQWiBOMUpERERUOlyD0Ly1fjMUSQ+ScfLnGDz4+6HQcYiIiMiExGIxpA5SaFSWUyTk+oNEZcOpRonMCwuEFkaXrYMqXQ1nd7nQUYiIiIgsBqcYNX8tujTHwr4rMK1DBH783y9CxyEiIiITsrQuwusnbyCI04sSlVpIWFP41fHG3ugDMBgMQschsnksEFqY1CdKuHmye5CIiIioNDSZWjg42Qsdgwpx/tBl/LblELQqLVLiFdg8+yv8/tURoWMRERGRiVhegZAdhERlNSnqHWyatR3Dnnsfo5tMwZNHyUJHIrJZLBBaGK4/SERERFR67CA0b0n3nkCVrjY+V2dokHgvScBEREREZEoyuQzqDHXxA82AwWDAP2du4fkWLBASlcWtC3cAGBB36zHuXnmA91vPRsLdRKFjEdkkFggtDNcfJCIiIio9daYGjnKZ0DGoEB0GvwQXT2fjc1dPF3QZ3VHARERERGRKltRByOlFicrnzL4LSFdkGp8/eZiCmAMXBUxEZLtYILQw7CAkIiIiKh2NSgN7GacXNWcSiQSfXV6Jl3q3QuN2Qajq58Fp9YmIiGyIo7Msz2wC5uzaiRto0JoFQqKyatg6EC5V//1yoIevG4JasiOXSAhWVSCMiIiASCQyPqwRC4REREREpcP1By2DzMkBc7+ZihV/LUCdJrVwcNthoSMRERGRibCDkMh2NGnfEBE/zIBPLU+4ebrgudB6qNOkttCxiGySVRUIw8PDYTAYjA9rxClGiYiIyJSs4QtY6kwNZFx/0KK8u3IY1k/eInQMIiIiMhFLWoPw+smbCGrFbiei8mjcLghbbq7Ft483QZGYiuunbgodicgmWVWB0BawQEhERESmZA1fwFJnaCCTs0BoSdw8XdF1TEd89fEPQkchIiIiE7CUDsLkuBTodHp41/AUOgqRxbOzk0AkEmFi1BisHrtB6DhENokFQgvDKUaJiIiISkeTqYEDOwgtzoiPBmD7ou+hUZn/h4VERESmYA0zOxTGUtYgZPcgUcWr1ywAz7esh73RB4SOQmRzWCC0MKlPlHDzZIGQiIiIqKRYILRcnGqUiIjoX9Yws0NhLKWD8NrJG2jA9QeJKtykqHew+l12ERKZGguEFoYdhERERESlo87UQuZkL3QMKoM33gnDxT+v4cE/j4SOQkRERJXIUS6DygLWILx+8gaCWCAkqhQT143GKhYJiUyKBUILwwIhERERUemwg9CysYuQiIjI+snkMqgtokDIKUaJKssbY1/D9RM3cPviXaGjENkMFggtjCJJCXcWCImIiIhKTJ2hgUzOAqGlavF6MHTZesQcuCh0FCIiIqokljDF6M1zsQhoXBN2UjuhoxBZrUlRY7BqLLsIiUyFBUILokxOg0sVZ6tbiJqIiIioMrGD0PKxi5CIiMi6yZxlUKebdwchuweJKl9Qq0DUeK4afvviT6GjENkEFggtCLsHiYiIiEpPnamBjAVCi1a7YQ0EtQrEr5t+FzoKERERVQJHuQNUZt5BeO3kDTTg+oNElY5dhESmwwKhBeH6g0RERESlp8nUwsHJXugYVE7sIiQiIrJelrAG4d8nb+B5FgiJKp29zB6jFg/EusmfCx2FyOqxQGhBWCAkIiIiKj11phoyJ5nQMaicnFwc0WdaN3wRvlPoKERERFTBzH0NQmVKGpTJ6ahe30/oKEQ2oeekrjjz6wU8+OeR0FGIrBoLhBYk9YkSbp4sEBIRERGVhjpDA5mcU4xag8Hz+uDHNb8gXZEhdBQiIiKqQOa+BiHXHyQyPU41SlT57IQOQCXHDkIiIiIqSHx8PNavX48qVaogJSUF48aNg6+vb75xhw4dwrFjx+Dt7Y1Hjx6hdevW6Ny5swCJTUuTqYED1yC0GrlTjU7/fLzQUYiIiKiCmHsH4bUT/6BB6+eEjkFkU5q+3BAeUe74c+cxvPx2G6HjEFkldhBaEEWSEu4sEBIREdEzVqxYgW7dumHSpEno2rUrVq9eXeC4w4cP47333sOYMWMwc+ZMREVF4eHDhyZOa3rqTC1kXIPQanQa9gpunotF7KV7QkchIiKiCmLuaxCyg5BIGOwiJKpcLBBaEBYIiYiI6FnJycm4evUqgoODAQAhISG4ePEiFApFvrFz586Fu7s7AMDJyQkuLi5ISUkxYVphsIPQ+uR2ERIREZF1MPcOQhYIiYTh7C5Hv5nd8dms7UJHIbJKnGLUgnCKUSIiInpWQkICXF1dIZFIAAB2dnZwdXVFQkKCsRiYSyz+97th9+/fh6OjIxo1alTgeSMiIjB//vwC94lEIkydOhVTpkypkHuIi4urkPMUJjUlFRnqjEq/TnmYczZTKO39+zxfFQaxAb9s/Q3NOhb8b9jS8N+Abd8/wNcA4GtgKfcvEomEjkBWyFEugzrTPAuEd68+gE8tTzg6Owodhcgm9fugBwbWfhdvjn0NPrW8hI5DZFVYILQgLBASERHRswwGQ4Hbi/rwTq1WIzo6GvPmzctTNPyv8PBwhIeHF3jewq5ZFnFxcahWrVqFna9AOhGq1fCr/OuUkUleAzNW1vufvP4dzH79Y3QZ8lolpDIt/huw7fsH+BoAfA0s6f4tpZBpjYr6Apc1kDk5QJWhhqNcJnSUPK6fvIGgVoFCxyCyablTjS7+dY7QUYisCqcYtSCcYpSIiIie5evrC6VSCZ1OBwDIzs6GUqmEt7d3geNVKhWWLVuGUaNGoXr16qaMKhh1pgYyTjFqdfzr+SHktSb4ad1+oaMQERGZRHh4OAwGg/Fhbcx1mlEWCImE90LnYEgd7HB89xmhoxBZFRYILQg7CImIiOhZnp6eaNCgAc6fPw8AiImJQePGjeHh4QEAOHHihHE9woyMDCxbtgxDhw5FQEAAbt++jf37rb+4osnUwsHJXugYVAm4FiEREZH1kMllUGeohY6RD9cfJDIPuV2ERFRxrKpAGBERAZFIZHxYk8w0FaQOdpDaS4WOQkRERGZm8uTJ2L17N1auXIm9e/di0qRJxn3btm3D1atXAQDLly/H6dOnMWXKFPTp0wfTp0+HSqUSKLXpaDI1cGAHoVWS2ksxbMHb2PjBNqGjEBERUTmZYwehKkONhDuJCGhUU+goRDaviq8Hur7TEV9GfCt0FCKrYVVrED67Vo41FQnZPUhERESF8ff3x8KFCwvcFxkZafzzvHnzTBXJrKgzNJDJWSC0Vm/P7I4+vqPQe/Ib8PBxFzoOERERlZHMWQZ1unl1EP598iaeZ/cgkdkYOv9t9PEdhTfGhvG9P1EFsKoOQmvG9QeJiIiIyoYdhNaPU40SERFZPnPsIOT6g0TmZ1LUGCwdHokf1/yC07+eEzoOkUVjgdBCsIOQiIiIqGzUmRrIWCC0aq/2b4tHtxJwcNtfOLP/gtBxiIiIqAzMcQ3CaydvoAELhERmpWGb53Dh0BWsm/Q5lg6NxPGfzggdichisUBoIVggJCIiIio9rVoLqYPUqqaep4K90q8Nlo+KwqdD1uCDTgVPuUtERETmy1HuAJXZdRDeRBCnGCUyK0uGrEWWJhsAoHiixKp3opEc/1TgVESWiQVCC8EpRomIiIhKj92DtuHetQf4fuVeZGuzkZqUhkuHr+GzWduFjkVERESlYG5TjMbdToDczQlunvw8jsiciMTPfPlTJOIXQonKiAVCC6FISoW7l5vQMYiIiIgsijpDA5mcBUJrl/pEiSxNlvF5liYbTx6lCJiIiIiISkvmLIM63XymGL124gYatOb0okTmZubW9+HpX8X4fMrGsaji6y5cICILxgKhheAUo0RERESlp8nUwIEdhFavyUsN0bhdA0jt7QAAEqkEoz8ZKHAqIiIiKg1zW4Pw+skbCOL6g0Rmx7WqC6IuLMO41cPRafgruHz4mtCRiCyWndABqGRSn6TBzdNF6BhEREREFkWTqYWDk73QMcgEwr+fhh2f/ICHtxLgU9MLO5fuxriVw4WORURERCXkKJchMy1T6BhG10/eRKfhrwgdg4gK4FbVBT3e7wIA6O09En2mdePse0RlwA5CC8EOQiIiIqLS4xqEtqXfBz0x7bNxGDyvD1KTlPh9+xGhIxEREVEJmdMahLpsHW5fvIvAkLpCRyGiYryzbAiip20VOgaRRWKB0EKwQEhERERUelyD0HbN2jYR2xZ+hwf/PBI6ChEREZWAo7MMKjNZg5DTixJZjrAh7XHr/F3cuXxP6ChEFocFQguhSFLCnQVCIiIiolLhGoS2bd3ZTzAu9AOhYxAREVWIiIgIiEQi48PamFMH4fWTNxHUqr7QMYiohN5ZOhjR078UOgaRxWGB0AJo1VrosnVwdHYUOgoRERHZGEv/IIoFQtvm6OyIRXs+wNRXwoWOQkREVG7h4eEwGAzGh7WRyWVQZ5hHB+G1kzfQgB2ERBYjtFMz6HV6nDt4SegoRBaFBUILwO5BIiIiEoqlfxClztRC5mQvdAwSUNOXG6JV1xBET+e6JEREROaMHYREVB5ci5Co9FggtABcf5CIiIiobNhBSADQZ1o3JD1Ixp87jwkdhYiIiAphLgXCpIfJEIkAT/+qQkcholKo27Q2AhrXxMFth4WOQmQxWCC0ACwQEhEREZWNOkMDmZwFQgI+3DEZm+d8jbjbCUJHISIiogI4OsugShd+itHrJ28giNOLElkkdhESlQ4LhBYg9Uka3DxdhI5BREREZHHUmWrInGRCxyAzse7spxgXOlPoGERERFQAc1mDkAVCIsvl4eOOjoPa4dvle4SOQmQRWCC0AOwgJCIiIiobTaYWDlyDkP6fs7sc876dihlhC4SOQkRERM8whylGddk6XD3+D9cfJLJg7ywbig1cf5yoRFggtACKpFS4e7kJHYOIiIjI4qgzNZBxDUL6j+Ydm6B5h8b4bNZ2oaMQERHRfwhdILx5PhZDA9/H9ZM3kZKgECwHEZXfmCWDEc0iIVGxrKpAGBERAZFIZHxYC0WSEu7sICQiIiIqNU2mBg4sENIz+n3QA49uxuPI9yeFjkJERET/z8HRAVmaLOj1epNfO/byPXz4xmI8vpsEAFgxaj3fJxBZsD7TuuHgl4fx9LFC6ChEZs2qCoTh4eEwGAzGh7XgFKNEREREZaPO0EAmZ4GQ8gv/bhqipn6Bx/eShI5CRERE/0+oLsLYS/eg1/1bmMxIzcSdy/dNnoOIKs47y4Ygehq7CImKYlUFQmvFAiERERFR2bCDkIqy7uynGBc6U+gYRERE9P9kchnUGWqTX/fFt16AvUxqfO7sIUfbni1MnoOIKk7HQS/hzuX7uH3xrtBRiMyWndABqHicYpSIiIiobDSZWjg42Qsdg8yUm6crPvjyfcx6/SMs/nWO0HGIiMiMxMfHY/369ahSpQpSUlIwbtw4+Pr6Fjh2x44duH37NgwGAwIDA9G3b99i9924cQMzZsyAVPpvUeqrr77K89wWCdVB6OTsiOgLy9G/5lh416iK8O+no+bz/ibPQUQVa8zSwdgw/Ut8+ttcoaMQmSV2EFoAdhASERERlY06UwMZOwipCC90DkajNs/j87lfAwDSFekCJyIiInOwYsUKdOvWDZMmTULXrl2xevXqAsddvnwZx48fx+zZszFnzhwcPnwY169fL3YfALz33nv49ttvjQ9bLw4CwhUIc6+dpc7CpqurWBwkshIhYU0hEgFnf7sodBQis8QCoZnT6/XISM2Ei4ez0FGIiIiILA7XIKSSGPhhL8Reuoehge/j3eYzsPb9TUJHIiIiASUnJ+Pq1asIDg4GAISEhODixYtQKBT5xh48eBAtW7aESCSCSCRCq1atcODAgWL3AcDRo0exfv16rFmzBpcuXTLJvZk7R2cZVOmmn2IUAG7GxKJ+SB1Brk1ElYdrERIVjgVCM8fuQSIiIqKy4xqEVFKPbsYj7lYCEu4m4efPDmLN+M+EjkRERAJJSEiAq6srJBIJAMDOzg6urq5ISEgocKyHh4fxeZUqVYzjitpXpUoVvP7663j33XcxYsQILF++HDdu3KjM27IIQq1BCAA3YmIRyAIhkdUJaFwL9YJr48DWv4SOQmR2uAahmeP6g0RERERlxwIhlcTDm3HQZemNz7M12bh37YGAiYiISEgGg6HA7SKRqERjc8cVtc/T0xOenp4AAGdnZ7Rq1Qq///47AgMD8x0TERGB+fPnF5pp6tSpmDJlSsE3U0pxcXEVcp4ykxgQ9yAefnFeJr1sXFwcLh69gsAX6gj/GpiYrd3vf/Hebcdb0zph9isfY+2lj23u3v/LVu/dEu67oPcYpsACoZljByERERFR2akztZA52Qsdg8xc9frV4FWzKuJu/9sZ0q5XKwETERGRkHx9faFUKqHT6SCRSJCdnQ2lUglvb+98Y/38/PD06VPj85SUFPj4+BS7LyEhAV5eXsYuRXt7e6SnF7wObnh4OMLDw/NtF4lEhRYzyyIuLg7VqlWrsPOVhXtVNzg5yE2aI/e+H11PwMAPegv+GpiSOfydC4X3blv3Xq0a8PrIDvh53e8YvWiw0HEEYYt/74Dl3LdQRUxOMWrmWCAkIiIiIUVERBjXzRHqG23lwQ5CKqllv89H2x4tUbthDXQe8SouH74mdCQiIhKIp6cnGjRogPPnzwMAYmJi0LhxY+N0oSdOnDCuR9ihQwecOnUKBoMBBoMBJ0+eRIcOHYrd98MPP+Dq1asAcjoNL168iGbNmpn2Rs2QUGsQ6nQ63L3yAHWb1jb5tYnINEZ/OhjffPxThX6xgsjSsYPQzHGKUSIiIhLSs99Yt6QioVathZ29HcRifieOSib8+2nGP3+77CdET9+Kd5YOETAREREJZfLkyYiKisKRI0eQkpKCSZMmGfdt27YNAwYMQJs2bdCkSRO0atUKH330EQCgbdu2aNiwIQAUua9Zs2bYvn07jh07BoVCgZYtW6J9+/amvUkzJNQahDdjYlGf6w8SWb3+87ojetpWjF0+VOgoRGaBBUIzp0hKhbuXm9AxiIiIiCyOOlMDGbsHqYz6TOuG/733GXZH7sNb4zsLHYeIiEzM398fCxcuLHBfZGRknucDBgwo9DyF7XvxxRfx4osvlj2glZLJHaDO0Jj8uiwQEtmGzmNeweTQcPSZ1g1V/TyEjkMkOH6d2sxxilEiIiKistFkauHA9QepHN5fOwqnfz2PUz/HCB2FiIjIJjjKZVAJ0EF4IyYWgSwQEtmEd5YNwQevLcSHbyzG6V/PCx2HSFAsEJq51CdpcPN0EToGERERkcXh+oNUET7aOwuffbAdd67cFzoKERGR1WMHIRFVtn/O3MLdqw9w6pdz+GjAShz98ZTQkYgEwwKhmWMHIREREVHZcIpRqigbL6/AhNZzoEpXCR2FiIjIqsmcZVCnm7aD0GAw4PbFu6jXLMCk1yUi01MkpuLID/8WBDNTVdi5ZLeAiYiExQKhmWOBkIiIiKhs1BkayOQsEFLF2H5vHQbWGid0DCIiIqsmk8ugNvEUo3cvPWD3IJGNcPd2g9RBmmebd42qAqUhEh4LhGZOkaSEOwuERERERKXGKUapIrlWccGnB+bi3ZAZQkchIiKyWkJMMXr38gOuP0hkQyJPfwLP6lXg6ukCiVSCD3dOEToSkWBYIDRz7CAkIiIiKhtNphYOTvZCxyArUr95HQz8sBfm91wqdBQiIiKrJESB8M7FBwgMqWvSaxKRcJzd5fji5v+wYNdM9J/VA9sWfCd0JCLBsEBoxpQpaXB2l0Ms5l8TERERUWlxDUKqDG17tETjdkFYP2WL0FGIiIisjqOzDCoTr0F49zKnGCWyNfYO9mj44nMYOv9t/LRuH54mpgodiUgQVlV5ioiIgEgkMj4sHbsHiYiIiMqOaxBSZek1+Q0Y9Ab8sPpnoaMQERFZFSHWILx35SHqN2eBkMhWTVw/Bqvf3SB0DCJBWFWBMDw8HAaDwfiwdCwQEhEREZUd1yCkyjRu1XBcOHQFx3efEToKERGR1TD1FKM3Ym6jduPqJrseEZmftj1bIlOpwrmDl4SOQmRyVlUgtDapT9Lg5ukidAwiIiIii8QCIVW2BbtmYuv8b3Drwh2hoxARkQ2wtpmzCmLqAuHNmFjUblzDZNcjIvM0cf1orH53o9AxiEyOBUIzxg5CIiIiorLjGoRkClHnl2LaK/ORrsgQOgoREVk5a5s5qyCmnmL05rlY1G7CAiGRrfOv54fW3ULx3Yo9QkchMikWCM2YIkkJdxYIiYiIiMqEHYRkKtvvrcfAWu/iz2+OY/modTjywymhIxEREVkkewcpdDo9dNk6k1zvBjsIiej/jV0+FJ9/uAMalem6mImExgKhGVMkpcLdy03oGEREREQWSZWhgaOcBUKqfHJXJwyZ3xcfD1iFfZsPYfnIdVybkIiIqAyS459CIpXgj6+PmuR6N2PYQUhE/+JUo2RrWCA0Y5xilIiIiIRmyWvdsIOQTCUrKws/rP4ZBn3OdG8ZqZlYP2ULdDrTdD8QERFZg6ePFXi/5SxkqbOw9v1N+GXTwUq93q3zd1C3WW2Le49LRJXntaEv48E/cbh+8obQUYhMggVCM8YCIREREQnNkte60WRq4eBkL3QMsgFSqRRyd6c82+RuTpBIJAIlIiIisjyfDluLpIfJAIBMpQpfzN2JpEfJlXa9GzGxCAypU2nnJyLLxC5CsiUsEJoxrkFIREREVHbsICRTWvHnAlSp5gFP/ypwreoCexmL00RERKVhZ/fMF2tEgJ208r5scyPmNgJD6lba+YnIMtVrFoDnWtTDzxsOCB2FqNKxQGjG2EFIREREVHbqTA1kLBCSiTi7y7H52kpMXD8a2++tw+hPB+GdZtOEjkVERGQxZm2fiKrVPCCRSCB1sMO0TePg4e1eade7GROL+uwgJKICsIuQbAULhGYs9Uka3DxdhI5BREREZJHUGRrI5CwQkunIXeVo9UYoZE4yNG4XhBlfvIfBdccLHYuIiMgiyF2dsPnv1Rj+cT/Yy+zxQufgSr3erXN3UK95QKVeg4gsk1gsxvg1I/C/9z4TOgpRpWKB0Eyp0lWQ2Ek4NRERERFRGXGKURJa3aa1seTAPPTyGiF0Z7bgNwAASjVJREFUFCIiIovg5OyIt6d3h399P/xz5lalXef2xbuo3agG1wsmokK9Nb4zLv55FXevPhA6ClGlYYHQTHH9QSIiIqLy0WRq4eDEL1uRsPzq+GDz9VXoIuuP7KxsoeMQERFZhFZdQ3Dy55hKOz+nFyWikpi4fgxWv7tB6BhElYYFQjPF9QeJiIiIyodrEJK5cPN0xa7UrXhDPgjK5DSh4xAREZm9ll2b49TP5yrt/DdibiMwpG6lnZ+IrEPjdkHwql4Vf3x9VOgoRJWCBUIzxQIhERERUflwDUIyJ/YOUuzT7sCw5yYg4W6i0HGIiIjMWmBoXSTdf4KniamVcn52EBJRSU1cPxqr390odAyiSsECoZniFKNERERE5cM1CMkc/fDkc0x7ZT5iL90TOgoREZFZa9G1OU5XUhfhjZhYBLJASEQlIHeTo/8H3fHZrO1CRyGqcCYvEMbHx2PevHlYtWoV5s2bh4SEhALHHTp0CIsWLcKGDRsQHh6Offv2mTipsNhBSERERFR2Wk0W7KQSiMX8PhyZn2131uGTwWtw5djfQkchIiILEhERAZFIZHxYu8pahzD20j3UalAdEjtJhZ+biKxTvw964I+vjiLxfpLQUYgqlMk/MVmxYgW6deuGSZMmoWvXrli9enWB4w4fPoz33nsPY8aMwcyZMxEVFYWHDx+aOK1w2EFIREREVHbsHiRzt+Hicnw2cxvO7DsvdBQiIrIQ4eHhMBgMxoe1q6x1CG+ei0X95uweJKLS4VSjZI1MWiBMTk7G1atXERwcDAAICQnBxYsXoVAo8o2dO3cu3N3dAQBOTk5wcXFBSkqKCdMKK/WJEm6eLBASERERlQULhGQJVh1dhB9W/4JTe1gkJCIiepa9zB4NX3wO5/+4XKHn5fSiRFQWLbs0h0gswsm9Fd/ZTCQUkxYIExIS4OrqCokkp4Xfzs4Orq6uBU4z+t/poO7fvw9HR0c0atTIZFmFxilGiYiIiMpOnaGBTM4CIZm/xb/OwdmfL+DXTb8jOysbf317AveuPRA6FhERkVmojC7CmzGxqM8CIRGVwaSoMVg1dgMy0zLxNFEhdByicrMz5cUKm/6gqHnT1Wo1oqOjMW/evELXkImIiMD8+fMLPffUqVMxZcqUUuctSFxcXIWcpzhJj5KRJdKY7HqlYY6ZTMnW7x/ga2Dr9w/wNQD4GljK/dvC2ixUMHWmBjJ2EJKFGB81HNtm/4AN07+Eo7MMer0eC3/6gNOfERGRzWvZtTnmvbUEY5cPrbBzskBIRGXl6V8VzTs2xoBa70LmZI/hHw1Ap6GvCB2LqMxMWiD09fWFUqmETqeDRCJBdnY2lEolvL29CxyvUqmwfPlyjBo1CtWrVy/0vOHh4QgPD8+3XSQSVeic7HFxcahWrVqFna8omakq1AuqC79qPia5XkmZ8jUwR7Z+/wBfA1u/f4CvAcDXwJLu31IKmeasqC9imTNNphYOTvZCxyAqMWVyOtIVGUhXZAAAInovw+d/r4bUXipwMiIiIuHUeM4fumwd4m4noFpd33Kf786V+6ge6Mf/fyWiMvn79E2c/+MyMhSZyFBkImryF7B3kOKVfm2FjkZUJiadYtTT0xMNGjTA+fM5a2zExMSgcePG8PDwAACcOHHCuB5hRkYGli1bhqFDhyIgIAC3b9/G/v37TRlXUJxilIiIiMxBeHg4DAaD8WEpuAYhWRplsjLPc3WmBhnKTIHSEBERmY+KnGaU3YNEVB73rz9CtlZnfJ6uyMCjm/mXTyOyFCYtEALA5MmTsXv3bqxcuRJ79+7FpEmTjPu2bduGq1evAgCWL1+O06dPY8qUKejTpw+mT58OlUpl6riC0GqykK3NhpOLo9BRiIiIiCwS1yAkSzNt83i4eDgDAKQOUqQmKXHvykOBUxEREQmvZdcQnPo5pkLOdSPmNgJD6lbIuYjI9rzUpzXsZf92IDu5OqJ939YCJiIqH5NOMQoA/v7+WLhwYYH7IiMjjX+eN2+eqSKZHXYPEhEREZUP1yAkS1PzeX8s+X0eDn55GAGNayJsSHtM7xCBRr8/j+EL+wsdj4iISDChrzXFh28sRnZWNuyk5fso82ZMLKcCJKIykzk5YMPFZfh4wGpkKDORkqCAQW85M+0QPcvkBUIqHguEREREROXDKUbJEtVrFoB6zQKMz5cfisD2Rd9jYps5WPp7OOxlXFeTiIhsU+40o226tyjXeW6eu4P6zQOKH0hEVAi5mxwf/TwbAJCS8BRjg2fgm/iNAqciKhuTTzFKxUt9ooSbJwuERERERGWlydTCwYnFFLJ8Az/shTFLh6C7x7AKm16NiIjI0lTENKP3rj2AXx0ffuGGiCpMFV8PvLNsCBYPWi10FKIyYYHQDLGDkIiIiKh82EFI1qThi8/hF9VX+Gn9b1g/ZYvQcYiIiEwut4OwPG7GxKJ+SJ0KSkRElKPDwHaws7fD/s8PCR2FqNRYIDRDiiQl3FkgJCIiIiozVYYajnKZ0DGIKtRHe2fBu4YnxjSditQnSqHjEBERmUxVPw94+Lrj1vk7ZT7HjZhYBLJASESVYPrm8dga8Q0e30sSOgpRqbBAaIZYICQiIiIqH3YQkrXqNfkNfPDlBIwImoS/vjkudBwiIiKTKW8XIQuERFSZlv4ejukdIoSOQVQqLBCaIU4xSkRERFQ+6kwtZFyDkKxUnSa18H3SZhz+/iRWvhMtdBwiIjKRiIgIiEQi48PWtOoagpPlWIeQU4wSUWWqVtcX/WZ2x4oxUUJHISoxFgjNEAuEREREROXDDkKyBXN3TkFgSB0MqfeecTqjA1v/xJn/a+/Ow6Iq3z+Of4ZFQRQQAQGXNPd9TSnNSjMzW2y1bLMsLa2vuGRafUVSs9QMytwqLcuyPUtbfpp9y1zI3HPfNRFlH9m38/vDnDIRAQfODPN+XReXzZxl7vtxPHPHPc9zfthibmAAgHIRGRkpwzBsP66mRXhTHd97Qtbk06U+9uiuP1W7QZCqelMfAig/Nz1+vTKtWfrfx2vMDgUoEQ+zA8D5WGIUAADg0tAghKvoN6S3OvRqo1HXTFB+XoGyMrLk41tND08coBsf7Wl2eAAA2FWXfh312/JNuv7Ba0p13L5Nh9SkY8NyigoA/vbCkpG6K3iw2vdsLf8gP7PDAYrFDEIHxAxCAACAS5OdkSMvHxqEcA1hjULU+YZ2Sj6RoixrthL/TNaC5z7Uga2HzQ4NAAC7Cu/XUevLcB/CvRsPqGmnRuUQEQCcb/qPE/RMrxfNDgO4KBqEDigt0Sq/QBqEAACgZE6cOKEJEyYoOjpaEyZMUHx8/AX33bdvn4YPH6558yr3fcuyM3PkxQxCuJC83LxzHmdn5SgvJ+8CewMA4Jy69uuo2DI0CLn/IICK1LDNZeo7uKdmRyw0OxSgWDQIHYxhGDqdnC7fWjXMDgUAADiJmTNn6tZbb1VERIT69eunmJiYIvdLTEzU+vXr1aJFiwqOsOLlZOaqarUqZocBVJjhMY8qILSmJMmrelXVaRSimY/P1c51e0yODAAA+/Gu7q0mHRtq2y87S3UcDUIAFe2OEf104uBJrfvmd7NDAS6IBqGD4f6DAACgNJKSkrRjxw516NBBktSpUydt3bpVqamp5+0bGBioBx98UJ6enhUcZcXjHoRwNT5+Pnp3T4wefWmgnnp9sOZsmq5x7/9Hc0cv0rRBs5SbnWt2iAAA2EXXfp0Uu3xjifc/tue4AuvWkrePVzlGBQDnm/T1OE259zVlZ+aYHQpQJA+zA8C5uP8gAAAojfj4ePn6+srd3V2S5OHhIV9fX8XHx8vf37/M542KitLEiROL3GaxWDR69GiNGjWqzOf/p7i4OLuc55/SrRmypqeVy7nLg7PEWV5cPX/JfmNwzUNdbefzCvTUuM+G69dPf1P/mg/rnudu1Q2Dr7HL69gb7wHGQGIMnCV/i8VidghwceE3d9SLd8/U4688WKL9mT0IwEzTV03UMz0n6o31U80OBTgPDUIHQ4MQAACUhmEYRT5/qb+8i4yMVGRkZJHnvdBrlkVcXJzCwsLsdr6z8nMKVL9hPdWs7W/3c9tbeY2Bs3D1/KXyH4N7RvTXPSP6a3bEQr3Q6xWNmDtE7a5pVW6vV1q8BxgDiTFwpvydpZGJyuuylvWUk5mj+MOnFNIg+KL77914UE1pEAIwSYuuTXTlrVdowfMf6tEpA80OBzhHpVpiNCoqShaLxfbjjFhiFAAAlEZISIisVqsKCgokSfn5+bJarQoOvvgvSyozlhgFzjcs+hFN/HKsFkV+opcGRivDmml2SAAAlEnXfh0Vu3xTifbdt+mgmnSkQQjAPAOfu0O7Yvdp84/bzQ4FOEelahBGRkbKMAzbjzNiBiEAACiNwMBAtWzZUps3b5Ykbdy4UW3atFHNmjUlSevWrSvyfoSVXU5mrqpWq2J2GIDDqd+8jl79X5TCb+msgfWe0CfTl5odEgAApVaa+xCyxCgARzB9ZaTG9n7R7DCAc1SqBmFlQIMQAACU1siRI7V06VK99tprWrZsmSIiImzbPvjgA+3YscP2eP78+dq8ebM2b96s+fPnmxBt+cvLzZObu5vtvowAztfzvu5amrZIqQlWPdhouDau2KpTxxI1pmekJvSfppysHLNDBADggrr07aAN32+56ASBP/edUECIv6rV8K6gyADgwqb/GKnH247Soy1H6IVbpio3J8/skODiuAehg0lNtKp+M+e47wAAAHAMderU0aRJk4rc9uabb57zeMiQIRURkqmyM3Lk5cPyokBJDJn2oG554gZNe3iW9vx+QHl//ZLisdaj9O6e1+XuQaMdAOCYzi4zGn5zpwvuw+xBAI4k83SWju87obycfB3bHach7cbonR0z+XIrTMMMQgfDDEIAAIBLw/0HgdIJvby2Ot7Q1tYclKTUU1at+nC1iVEBAFC88H6dtP4iy4zu3XhATTs1qqCIAKB4Py5erbycfNvjLGumtv2808SI4OpoEDoYGoQAAACXJjszV17cfxAolbDLa58z8zYvJ08fvfyVvn37RxOjAgD8U1RUlCwWi+3H1XXp11G/Ld9U7D7MIATgSNr2aCkPz79nCxoy1LxLYxMjgqujQehgUhOs8qdBCAAAUGbMIARKr9f9PfToSwPlF1RDtcJq6pUfXtCz7z2l3bF7dYP7PYoZ9pYObD1sdpgA4NIiIyNlGIbtx9UF1wuUj7+PDm0/csF9aBACcCS3Db9Rj097UDVr+6tu01BlWrMkvvABE3EPQgfDDEIAAIBLQ4MQKJvbn75JV93aWVV9vOQfeOb/SZpd0VgR84Zq+bwVmvbwLFXx8tTNQ29Qn0euMzlaAAD+vg9hwzaXnbft+P4T8g/2k49vNRMiA4Ci3TGin/o+fr28q1VVdmaO7gp6VMsyFpsdFlwUMwgdDA1CAACAS5OdkXPOUokASq72ZcG25uBZbm5uuuXJPpq3ZYaGxTyqbat36sYq9+qNp94+b9bG9tU7tXHl1ooMGQDgwsL7ddT6Cywzun/TITXu2LCCIwKAi/P+6wutXtWq6p2d0bq/wZMmRwRXxQxCB3I6JV3VfL3l7u5+8Z0BAABQJGYQAuWnRdcmatG1iUbOG6rl81fqpftfl3d1L908tLcSjiXpm7k/KD+vQN1v76KIuUPNDhcAUMm17t5Ch7YdUYY187yZgns3HlDTTo1MigwASqb2ZUGK/GyMhl3xrGZveMXscOBimEHoQJg9CAAAcOmyM3PlVa2K2WEAlZqHp4duG36j3tr2qp549SGteP9nvTthiZLiUpSWYNUP7/6k5fNXmB0mAMAFnF1m9N/2bjyoptx/EIATaNq5kQa9eK+eu2mK2aHAxdAgdCBpiaflF1jD7DAAAACcGjMIgYrV8spmuuHha85Z2jc/t0B//LrLxKgAAK4i/OZOWr9s43nP79t4UE1oEAJwEl36dtC1A7pp2qBZZocCF0KD0IEwgxAAAODScQ9CoOL1fvBaXdayru1xQKi/MqxZurfuUC15+UtlpWeZGB0AoDIragbhiYMnVSOguqr7+5gUFQCU3g0PX6uGretr3jOLzA4FLoIGoQNJTbDKnwYhAADAJWEGIWCOWbEv68HIu3XHiJv0waHZevGrZzUr9iWlp2XqntAhmjZolvb+fsDsMAEAlYyPn48atq6nP9bstj3H8qIAnNXdY26Vm5tFH09banYocAE0CB0IMwgBAICjiYqKksVisf04g+zMHHnRIARM8VDkPXrytUfkWcVTkhRYp5Yem3q/vjn9vtpf11rRT87X0+HjtfKDX0yOFABQmXTt10mxy/9eZnTvxgNq2qmRiREBQNk9/sqDOrr7T/2w8CezQ0ElR4PQgaQmpMk/yM/sMAAAAGwiIyNlGIbtxxnQIAQc0w0PX6vZG17RsJhH9fsPW3Sb/8Na8MJHSj1lte3z4+Jf9PnMb1RQUGBipAAgnThxQhMmTFB0dLQmTJig+Pj4C+67ZMkSTZkyRZMnT9Ynn3xS4m2SlJaWprvvvltfffWVvVNwKf9eZnT/pkNq3LGhiREBwKV5ZsFw/fL5+nO+/ADYm4fZAeBvaQlWNenI8gcAAACXgiVGAcfWomsTtejaRBlpGVo663tN6DNNba5uKS8fL635cr2y0nP01azv9faOmarqzb9lAOaYOXOmBgwYoM6dOys2NlYxMTGaOnXqeftt375da9euVUxMjCTp6aefVps2bdSiRYtit501f/581a5du2KSqsQub3uZTienK+HPJAXVraV9Gw+qCUuMAnByU5aN11Ndx8svyFfNuzQxOxxUQswgdCDcgxAAAODSZWfkyMuHpgLg6Hz8fDTw+Tv1+ubJatLpcv1vya/KSs+RJMUfPqU3nnrH5AgBuKqkpCTt2LFDHTp0kCR16tRJW7duVWpq6nn7rly5Ul27drUtxx4eHq4VK1ZcdJsk/fTTT2rWrJlCQkIqJK/K7uwswvjDp1TN11u+ATXMDgkALtms2Kmacm+0Thw6aXYoqIRoEDoQ7kEIAABw6ZhBCDifTte3VY2A6uc8t3nVdv36RaxJEQFwZfHx8fL19ZW7u7skycPDQ76+vkUuMxofH6+aNWvaHgcEBNj2K25bSkqK1qxZo1tuuaU8U3EpZ+9DyOxBAJXN+wff1JC2Y5SVnmV2KKhkKtUSo1FRUZo4caLZYZRZWuJp+QXy7SYAAIBLkZ2ZK69qVcwOA0ApNLuise4Y0U9fxCzX6ZR0BdUN1OPTHtDKxb/olYfe0PUPXaPeD/ZQyyubmR0qABdwofsuWyyWEu17dr/its2bN09Dhgwp8pz/VtzvuywWi0aPHq1Ro0Zd9DwlERcXZ5fzmKFehxDFLt+kwMtqKqRpUKlycea8LxW5uyZydz5vbJmkO4MH67aRfbR7zT616tFMNz3Rq1TncNbcL5Uz5F2SeqA8VKoGYWRkpCIjI22PzRrUsmIGIQAAwKVjBiHgnO4dd7vqt6yrlJOp6vd4b0nS1XeEKysjWysX/ay5oxcpLcGq3g9do94PXaPalwWZHDGAyiokJERWq1UFBQVyd3dXfn6+rFargoODz9s3NDRUKSkptsfJycm2ewpeaFtCQoJSUlL04YcfSpL27t2rpKQkxcXFadiwYee9xr9/33WWxWK5YDOzLOLi4hQWFma385nBN7CGvn/rf+p+e5cS51IZ8i4rcid3V+Psufd/qq8+nfq1JGnX2n2qUb2GBoztX6JjnT33snKWvM1qYrLEqIPIysiWm5tFVb35ZRYAAMCloEEIOK+rbr3C1hw8y9vHS7c82Uevr52il757Tvl5+Rp1zQSNumaCvnvnR+Xl5tn2XbHoZ707YYkO/3G0okMHUIkEBgaqZcuW2rx5syRp48aNatOmjW250HXr1tnuR9irVy/FxsbKMAwZhqH169erV69exW4LCgrSK6+8ooiICEVERKhp06a65pprimwOouSe7TNJaQlW5efma/UX6/X2+MVmhwQAdlOQX6Cflqz5x+NCfT37B7t+UQSup1LNIHRmzB4EAACwj+yMHHn50CAEKqM6jUM16MV7NejFe7Xtl51asehnvT7sbXW7vYtq1PTRyg9+UXZGjr5fsEozVk1U3aaO/21hAI5p5MiRmjt3rlavXq3k5GRFRETYtn3wwQcaOHCgunXrprZt2yo8PFxTpkyRJHXv3l2tWrWSpGK3nTV37lzt379fycnJcnd3556EZXTqaIISjibaHhfkFWrHmj0mRgQA9uXu4a6wRrWV+GeS7bmwxiFOt4oiHAsNQgdBgxAAAMA+sjNz5MUMQqDSa9ujpdr2aKnRbz+pZfP/T2/+Z6Hyc/MlSUlxKZr2yJt6fc0Uk6ME4Kzq1KmjSZMmFbntzTffPOfxwIEDL3ie4rZJ0hNPPKEnnnii9AHiHMH1g1QjoLrtsbunu5p0amhiRABgf9NWTNDQDs8oLSFNNQKqa8uqP3TqaIKC67P0PsqGJUYdRGqCVf40CAEAAC5ZTmauqlarYnYYACrQ9Q/0UGBYwDnP7Vq3V2N7v6hPX/1Gh3ccMykyAEBFif51sjr0aqPg+oG6eWhvDXvtEbNDAgC7cvdw19vbZ2rqdy9owc4YrSj8VBFXT9COtcyYRtkwg9BBMIMQAADAPrgHIeB6vKp56YVPRiry9unKz81XVe8qWrArWjvW7NGG7zdr8oCZSk/N1BU3ttcVN7ZX5z7tVa2Gd5HnSjmVqprB/hWbAADgklksFk1bMUEFBQVyd3c3OxwAKDeNO/w9Q/rDI3M0otvzuv0/N+naAd1MjArOiAahg6BBCAAAYB/cgxBwTc06N9aUZeN1dNdxXX1nV3l4eqjj9W3V8fq2GjrjYSUeT9KG77fofx+v1YxHZ6thm/rq3OdMw7B5lyaSpHE3Tlb8oVMKaxSil759zuSMAABlQXMQgKuJWTNFk+99TQl/Juvu0dzLFiVHg9BBpCZa5R9IgxAAAOBS5OXmyc3djV8MAS6qUbsGatSuQZHbAuvUUt/BvdR3cC9J0o61e/T7D1s06+kFOr7vhDyreijlZJok6fi+ExrXZ7Je/uGFigodAAAAKLMXlozUvDHvaXbEQg2LZolllAz3IHQQzCAEAAC4dNx/EEBJtbqqmR6OGqBZsVP13v43VFhQeM72nev36NcvYpWRlmFShAAAAEDJDZ3xsEIaBivqrhlmhwInQYPQQdAgBAAAuHTcfxBAWfgG1FCvB3rIw/PM7GN3Dzc17dRIKz/4RQMvG6YnO43V/LHva8P3m5WXm2dytAAAAEDR7hjRTz3v666nuo43OxQ4AZYYdRCpCVb50yAEAAAOJioqShMnTjQ7jBLLzsyRFw1CAGXw5MxBKiwo0LZfdqndta007LW/l2bat+mgNv+4XV/EfKsJt01TsysaqX3P1urQs43aXdvKtt9Xs77T9wt+0mUt6mj84hFmpAEAAAAXd/Wd4QqqV0sD6gzRR8fmys2NeWIoGg1CB8EMQgAA4IgiIyMVGRlpe2yxWEyM5uKyM3Lk5UODEEDZDI8ZXOTzTTperiYdL9c9z9wmSfpjzW5tWfWHFkV9ou29dql9z9aq4uWpDd9vUWFBoQ5sOaT01AxNWf5cRYYPAAAASJKad2mi2Rte1o2e9+qDQ2/SCUKRaB07CBqEAAAAl44lRgFUhNbdmuuB/96lV3+K0vd5S3Tvs/11cOuRc+5juHP9Xq1c/IuyM3NMjBQAAACuqlZYgP6v4BNFXD1BezccNDscOCAahA4gLzdPudl58vGtZnYoAAAATi0nM1dVq1UxOwwALsTNzU0dr2+rLv06yrPK31/NdnN30/+9+z/dFfSonujwjF4f/pZWfbha8YdPFXu+fZsPKulEcnmHDcAJRUVFyWKx2H4AACiJD4/M0SdTvtaqj1Zr0j0zFXH1C9q3iYYhmFjqEJg9CAAAYB/cgxCAWSLmDJGbxaINP2yRj181vbnhZbm7u0uS9m85pJ1r92r98k1a8PxHysvNV6urmql1t+ZqeVVT+db1kSRNGRitLav+kFcNLz3/wQg179rEzJQAOBhnW/odAOA4nvviP3qq7fPKSM2UJD17wyRNXjZeLcObmhwZzESD0AGkJZ6WX2ANs8MAAABweiwxCsBM/5n9uNJT01Xdv/o5zzdu31CN2zfUrcP6SJKS4pK1Y+0e/bFmt1Z99Kv2bTqoWmE1lXQ8WYWFhnQqTRPvnK6YNVNU+7IgM1IBAABAJbJj9V5V9a5qaxCeTk7XV69/S4PQxdEgdADMIAQAALCP7IwcefnQIARgnn83B4tSKyxAPe66Uj3uulKSdOzoMUU//LYSjiXZ9kmOT9WU+6LVqXdbNel4uRp3bKjgeoEXPXdOdq48PNzl7uFe9iQAAABQqYQ2CpbHv+rDsCYhJkUDR8E9CB1AaoJV/jQIAQAALhkzCAE4I3cPdz096zH5Bf29skyL8CYa+NwdcnN30/cLVymi2wu6M+hRjeszSW+PX6yfP12nuAPx55znt+8368HLh2lQs/9o/5ZDFZ0GAAAAHFRg3QBN+Xa8Qi8Pln+wr256vJdWLvpF3y9YZXZoMFGlmkEYFRWliRMnmh1GqTGDEAAAwD6yM3PlVa2K2WEAQKk1aFVPM//3omZHLFTo5bU1Ys4QSVL4zZ1s+6QlWrVv0yHt33RQv3y6Vu+MX6y0BKsad2woH79q2rRiq3Ky8iRJz9/0kl767nk1atfAjHQAAADgYBq0qq+3d7ymlJNpql3/zDL2MwbP1uZV2zX+gxEmRwczVKoGobPerDk1IU3+QX5mhwEAAOD0sjOz5VXNy+wwAKBM6reoq5d/+O8Ft/sF+qrzDe3U+YZ2tucyrJnav+mQlrzyla05KEnJJ1M187E56nxje9VvXlf1W9RRveZ15HWRWdbfvrVSOZnZun3EzZeeEAAAABxKlapVbM1BSRrzzjD9uHi1BoQ9rumrJqp+8zomRoeKVqkahM4qLcGqxh0uNzsMAAAAp5edkaOA2v5mhwEAFcbHt5raXdtK1Wv6aM9v+3U6JV2S5B/kq1uG9VHS8RT99t0mfTbzGx3bfVy+tWrYmoX1m9dR/RZ1Va95mAJCamrSgJlau3SDDMPQD4t+1tyN003ODgAAAOWt1/1Xq33P1nqm50T1f/om3Tqsj9khoYLQIHQA3IMQAADAPrgHIQBX1ahdA8Wsnawp90XLs6qHpix7Tr61apy336ljiTq667iO7T6ug9uP6n+frNWx3XHKtGYqLzdfhQWFkqQDmw/r9eFv6YH/3qWAkJoljuPXL2OVEp+qW57kF0sAAADOolZoTS3YFaPXh7+lqLtmKPKzMWaHhApAg9ABcA9CAAAA+8jJzFVV7kEIwEXVa1ZHczcVP+svuF6ggusFnrNMqSSt/OAXvT78LWWdzpYkWdwsil2+Sb9+8ZvSU9IV0jBYtRsEq3aDIIU2rK2QBkF/PRdku2XGl28s15KpX8makq5PX/1GC3fHyN3DvXySBQAAgN39583Htfrz9bo9YJCmr4pU4/YNzQ4J5YgGoQNISzwtv8Dzv9kJAACA0snOzLno/bUAAOe7/oEe2rNhv35YsEqGRWrcoaFe+3mSJCk3J0/xh07p5OFTOnk4QScOndTejQf+ei5BOZk5qhnir4Q/k5Sfmy9JOnHwpP572ysaHvOIAusEqKp3ya7Ns/7zjo7tidMND12jXvf3KLd8AQAAULSr7wz/a8nRKF3/YA/dNeoWs0NCOaFB6ACYQQgAAGAfLDEKAGU3POZRtQhvqpysXPV9tKft+SpVPc/cr7B5nSKPy8rIVuzyTYoeMtfWIJSkfRsP6rm+LynxeLKqeHkqsE6AaoXVVK06AQqsE6CgOrVsj/Pd8/Rx1Dda8d7/lJebrz0b9stisajnwKtLlcOfe+O09ecdat29hS5rUbdsAwEAAODiatSsrrmbp2vu6Pf0/M1TNWXZeEnS8f0nVM23mmoG+5kcIeyBBqEDsCadll8gDUIAAOB4oqKiNHHiRLPDKLHsjBx5+dAgBICy6nlf91If4+3jpWvvuUpHdhzTZzO/VnZGrkIaBOvtHTNtMwdPp6Qr8XiykuJSlHQ8WYnHk7V/62HFfrdZSceTFX/4pE4nZ9jOmZGaqTmj3tOBrYflH+wv/yBf+QX5yj/Y1/bf/56VeOpogkZfG6nTKRmqEeCjmDVTFNIguNT57N6wT43bN5SHJ78yAQAAru2JVx9W7PKN6lftft08tLdWf75OhiE99+EItbm6pdnh4RJR7ZosNSGN5iAAAHBYkZGRioyMtD22WCwmRnNxzCAEAPM8HDVA9VvUUcrJNN321I1yd//7/oM1alZXjZrV1bB1/SKPjYuL07geL+nEwZO25+o0CZFvLV8ln0jWwW2HlZZgVeopq1ITrEpLsMrN3e2cxuH21buUac2SJCWfSNWIq57XhM/GyC+whnxrnfm5mFHXRurEgXi5e7pr7qZpqu5fvdTjcGj7EfnX9ueb9QAAoFLo2q+TnowepNeHvSWj0JAkTRrwmiZ9/ayadW5scnS4FDQITcbyogAAAPaTnZkrr2pVzA4DAFzWdfeWfgbiWfO2zdDjrUcrPzdPdZuFacaPE4vdPys9y9YsTDqRoj0b9tsahJKUkZapeWMWyZp0Wtak0zqdnK4aAdVtzcK/G4fV5Rfoq3XLftfOtXttxw9t/4zmb3tVPr7VSpxD9BPztearWHlX99KEz8aocfuGpR6HNUtj5VnFU136diz1sajcnG1lBwBA5ZH4Z5KtOShJeTn5OnHgJA1CJ0eD0GSpCVb50yAEAACwC2YQAoDz8q7mpfcPzNLBbUfUqF2Di+9f3Vve1b0V2rC2JKlmbX+9cPNUWyNw0jfj1OrKZuccc7ZZaE06rbTEs/+drrREq+IOnDxn34Q/k3Rv3aHKTs9WjZrV5eNfTdX9fVTd3+ec/z7788evu7T6y1gV5hcq9ZRV42+crEnfjNPlbRuoSlXPEo3BzMfnav2y3+Xu4a7eD12rR6fcV7LB+0tWRram3h+jzLRMjVk4vExLrMJxOdvKDgCAyuOGh6/Vt2//qJT4VElS1uksHdtz3NygcMloEJqMGYQAAAD2Q4MQAJybxWIpUXOwKC3Dm2ryN+O09eedatO9+XnNQUnFLjXavGtjTR/0pjKtWfLw9FDfR6/Tf+YMkWEYOp2SrozUTKWnZig9NeOc/05PzdCf++K067d9KswvtJ3Pmnhaz/aepLzsPBUWGqpWw1vVfL3lXcNb1Wp4/fWnt7xreMmwFColLk2bVm5XYcGZc3z5+nLJYqj9ta1VxbuKqv71U+Vff569V2J+Xr6GtB2t+EOnJEkjuj2v6F8mKbRRSJnGEwAA4KywRiF6Y91LmjF4tmrUrK5x7z+tD1/6Qo+2jNDzH0WUuX6DuWgQmowGIQAAgP1kZ+TIy4cGIQC4qpZXNlPLIhqDJdG9f1dV/biKvoj+VvVb1tWTrz4s6UzT0jeghnwDir+H4Y2P9tS4PpOVlmA9E8tVzfTaL5MknWneZZ7OUqY1S1mns5R5OvuvP7OUdTpbJ47HKzkuzdYclKTcnDxt+HazdsfuV25WrnL++sn9159GoaEq3lVksUjZmTm245NPpGrlh6v14H/vLtN4AAAA/FPty4I0feXfM9kHvXivet7XXVPui1bnPu30+CsPmhgdyoIGocnSEk/LL/DiN0oHAADAxWVn5siLGYQAgDK6ok8HXdGnQ5mObdy+oaavnKA5o99TaINgjZz/hG2bh6dHsU3GuLg4DXrhPj3acoSO7Y6TZ1VPNW7fQK+ve+mir1tQUKDcrFxt+2WXpj/ypq1BWdWnqkIvr12mXAAAAEqifou6mrdlhj6etlQD6z+h5z6KUOtuzc0OCyVEg9BkqQlpqtskzOwwAAAAnF5+Xr4sFovcPdzNDgUA4KIatrlM0/5vQpmPX7AzRu9P+lRVqnpqwNj+JTrG3d1d3tW91fWmjpr4+RhNvvc1FRrSA8/foevv71HmWAAAAEpqwNjbdN193fTSfdFq1L6Bnp71mNkhoQRoEJosLcGqVlfRUQcAALhU3H8QAFAZXMqSoK27t9C8LdOVnZGr2pcF2TEqAACA4gXXC1T0r5O19M3vdXvAID3/UYQ692lvdlgohpvZAbi61ASr/LkHIQAAwCXj/oMAAEh+gX40BwEAgGluG36jFh2Ypc9eW6Zpg2aZHQ6KQYPQZGkJVvnRIAQAALhk3H8QAAAAAADz1ahZXS9//4LaX9daN1a5V6s/X6+FL3ykQc3+o6i7ZpgdHv7CEqMmo0EIAABgHzmZuaparYrZYQAAAAAAAEk3PHyteg7srsfbjNLxfSdkGNLxfSf0ws0vafKy58wOz+Uxg9BkLDEKAABgH9yDEAAAAAAAx+Lh6SEfv2oyjL+fO77/pJLiks0LCpIqWYMwKipKFovF9uPo0lMz5F3dS+4e7maHAgAA4PRYYhQAAAAAAMfTtHMjeVT5e0HLuAPxWvf17yZGBKmSNQgjIyNlGIbtx9GlJVrlF8jsQQAAAHvIzsiRlw8NQgAAAAAAHMl/3nxcfQZdq9oNgtTyqmb6Immh9m89rAcaDtP/Pl5jdngui3sQmoj7DwIAANjP/s2HlJWeZXYYAAAAAADgXyLmDlV2Vo68vM98sTdizhDFHz6lt8ct1pJXvtLjrzygTr3bmRyla6lUMwidDQ1CAADg6JxlCff3oz7R568t0851ezVn1LtmhwMAAGB3zlKXAQBwIWebg2eFNAjWC0tGasw7w/TJ9K/1zPVR2rvxgEnRuR4ahCZKTbDKnwYhAABwYM6whPvarzfom7n/p4y0TOXl5Ovr2d/r+wWrzA4LAADArpyhLgMAoCwad2ioV/7vvxo4/g5FD52vF+9+VScOnjQ7rEqPBqGJmEEIAABw6axJ6crJzLU9zs8tUFqS1cSIAAAAAABAaXXo1Uazf39F1w64SmN7v6jXhs5TemqGJGnVh7/qw5e+UGJcsslRVh7cg9BEqQlWBdYJMDsMAAAAp9at/xWa+dgc2+PQy4N1z5jbTIwIAAAAAACUVY+7rlSPu67U8vkr9EDDYWrepbH2bjyg08kZWjb3//TmhpdVs7a/2WE6PWYQmoglRgEAAC7Noe1H9FCjp7TUukh3jb5Ftz99kxbufp378gAAAAAA4OT6DemtuZumaef6vTqdfGYmYcKfSXrp/tdNjqxyYAahiVhiFAAAoOxiv92kt8ct1pfJ70qShk5/yNyAAAAAAACAXXl6eapaDW9lnc62PXfiwAkd3fWn6reoa2Jkzo8ZhCZKS7TKL5AGIQAAQGktm7dCX7/5vd7a9qrZoQAAAAAAgHJSKzRAo95+UrVCa8qzioeC6tXSXaNv1cQ7Z2jcjZP1+w9bzA7RaTGD0ETMIAQAACi9BS98JGuiVVOWP2d2KAAAAAAAoJx1ubGDxn84QicOnlLvB3vI3cNd/Z/qq99/2KLPXlum2RELdefIm9VvSG+zQ3UqNAhNRIMQAACgdKYNmqW6TUL16NyhZocCAAAAAAAqSLtrWqndNa3Oea5zn/bq3Ke9ju4+rs9fW6bZ1e7XnSP76Y6IfvIP8jMpUufBEqMmyc7MkSR5VatqciQAAADO4ZleUWp/XWsNfP5Os0MBAAAAAAAOon7zOho5b6i+SFogLx8vPdZqlKY+EKND245JkgzD0LsTlmjumPdUWFhocrSOgxmEJmH2IAAAQMkNavq0Rswdog4925gdCgAAAAAAcEBVvatq4HN3aOBzd+jHxav17rNL9OmUZTp5JEGJfyZJkn77drMW7Iw2N1AHwQxCk9AgBAAAuDhr0mnd5D1Qk5c/R3MQAAAAAACUSK/7r1bUd8+oRXhTJR1Psj1/bPdxffn6chMjcxw0CE1w6liiou6aoaO7juvorj/NDgcAAMAh7d9ySIOa/Udfpbyruk1CzQ4HAAAAAAA4mWadL1f1mtVtjy1uFi18YYmmP/KmVn++Xrk5eSZGZy6HXmJ0yZIlOnDggAzDUNOmTXXPPfeYHZJNQUGB3N3dS31c3IETGn1dlG06a8TV/9VL3z2n5lc0sXeIAAAA53GW+mrdN7/rvQkf64vEhSZHBQAAAAAAnNW1A7rpwNYj+r/3flJ+br76Du6lu8fcqvXLNmrVR79q6v0xan11C4Xf3EnhN3dSWKOQIs9T1p6QI3PYBuH27du1du1axcTESJKefvpptWnTRi1atDA5Mmnjim16bchceVf30rSVE1Sztn+R+2VYM3XqSILiDyf89ecpbflph5KOJ9v2OZ2cri2rdtAgBAAA5c5Z6qteD1ytHWv2aO7m6WaHBQAA4DCioqI0ceJEs8MAAMDpDH5poDrd0FZGYaE69GwrSeoz6Dr1GXSdJGnTym1av2yjxvWZLHcPd4Xf3FHhN3dWu2tbSZI+efVrfRXzrcIah2jq98/Ls4qnabnYk8M2CFeuXKmuXbvKYrFIksLDw7VixQrTf4G14YctevmB12VNOi1JGtJ2tAZNvk/Z6dk6+VcT8NSRRJ08kqDCgkIFXxakkAZBf/0ZrOsfuFonjybodFK6JKlGrepqGU5zEAAAlD9nqa8WT/5c7+yINjUmAAAARxMZGanIyEjb47M1HQAAuLj217a+4LaO17dVx+vbalj0Izq257jWL9ukRVGfaO/NBxTWJESHth+VUWgo4c8kDe3wjN7547VK8TnssA3C+Ph4NWvWzPY4ICBAO3fuLHLf4r5BZbFYNHr0aI0aNcouccX+30bbL68kKS3ptL6atVzNujZWYL0AdWnXXrXq1lRgnQD5+Fcr8hyNr2ygaffNVmF+oYbOelCBTWoqLi7OLvFVBGeKtTy4ev4SY+Dq+UuMgcQYOEv+laFYsydnqa8sbhb9/NWv6nZXF7uc3xk4y7+p8uLq+UuMgavnLzEGEmPgLPlTXwEAgMqsXrM6qtesju4efYuyMrIV0e0FGYWGbXt6crr2/H5Aza9obGKU9uGwDULDMM577kJF6L+/QfXP/Ys6T1nFxcXpqr5X6KdFv8r61wzAWqE1NfXb/yqwTkCJzxMWFqbFh+YoPz9fHh4O+1dQpLi4OIWFhZkdhmlcPX+JMXD1/CXGQGIMnCl/Z/lFW0VxlvrKx7earruzhwLDSl5fOTNn+jdVHlw9f4kxcPX8JcZAYgycKX/qKwAA4Cq8fbx0w8PX6K1nP1BBfqEkybdWjUrRHJQkN7MDuJDQ0FClpKTYHicnJ6t27domRnRGx+vb6oUlo1S7QbAatK6n2Runlao5+E/O1hwEAADOzRXqKwAAAAAAAHu5c+QteuyVBxRUr5baX9dKczZNMzsku3HYBmGvXr0UGxsrwzBkGIbWr1+vXr16mR2WJKlDrzZ6d2+M3to2UzWD/cwOBwAAoESorwAAAAAAAErnrpG36P2Db2r6jxPlWcXT7HDsxmGnsLVt21bh4eGaMmWKJKl79+5q1aqVyVH9jdl/AADA2VBfAQAAAAAAlJ67u7vZIdidQ/8WZuDAgWaHAAAAUKlQXwEAAAAAAMBhlxgFAAAAAAAAAAAAYH80CAEAAAAAAAAAAAAXQoMQAAAAAAAAAAAAcCEOfQ9CAAAAAAAAoKKdOHFCc+bMUUBAgJKTkzVs2DCFhIQUue+SJUt04MABGYahpk2b6p577rnotm3btumzzz5T3bp1lZiYqOrVq2v48OFyd3evkPwAAABoEAIAAAAAAAD/MHPmTA0YMECdO3dWbGysYmJiNHXq1PP22759u9auXauYmBhJ0tNPP602bdqoRYsWxW5LTU3Vvffeq5YtW0qShgwZoo0bN6pLly4VlyQAAHBpLDEKAAAAAAAA/CUpKUk7duxQhw4dJEmdOnXS1q1blZqaet6+K1euVNeuXWWxWGSxWBQeHq4VK1ZcdFuPHj1szcHTp08rKytLderUqZgEAQAAxAxCAAAAAAAAwCY+Pl6+vr625T49PDzk6+ur+Ph4+fv7n7dvs2bNbI8DAgK0c+fOi24765133tHatWv10EMPXbBBGBUVpYkTJxa5zWKxaPTo0Ro1alRp0yxSXFycXc7jbFw1b4ncXRW5uyZXzd0Z8rZYLKa8Lg1CAAAAAAAA4C+GYRT5fFG/vCtq37P7FbftrMGDB+v+++/XmDFj5O3tre7du593TGRkpCIjI4s814ViLYu4uDiFhYXZ7XzOwlXzlsid3F0Pubte7s6St1lNTJYYBQAAAAAAAP4SEhIiq9WqgoICSVJ+fr6sVquCg4PP2zc0NFQpKSm2x8nJyapdu/ZFt2VkZNie9/LyUteuXfXrr7+WSz4AAABFoUEIAAAAAAAA/CUwMFAtW7bU5s2bJUkbN25UmzZtVLNmTUnSunXrbPcj7NWrl2JjY2UYhgzD0Pr169WrV6+LbouOjlZ8fLztNQ8fPsw9CAEAQIViiVEAAABcUHH3vAEAAKisRo4cqblz52r16tVKTk5WRESEbdsHH3yggQMHqlu3bmrbtq3Cw8M1ZcoUSVL37t3VqlUrSSp2W5cuXRQdHa3LLrtMVqtVPj4+uueeeyo2SQAA4NJoEAIAAOCC/n3PG7NunA0AAFCR6tSpo0mTJhW57c033zzn8cCBAy94ngtt6927t3r37l32AAEAAC4RS4wCAAAAAAAAAAAALqRSNQijoqJksVhsPwAAAAAAAAAAAADOVakahJGRkbYbPxuGYXY4AAAAAAAAAAAAgMOpVA1CAAAAAAAAAAAAAMWjQVgKM2fONDsE07n6GLh6/hJj4Or5S4yBxBi4ev6wL95PjIGr5y8xBq6ev8QYSIyBq+cPx+Cq70NXzVsid1dF7q7JVXN31bxLymJU4rU4LRaLXZcatff5nJGrj4Gr5y8xBq6ev8QYSIyBM+UfFxensLAws8OoVKiv7M/Vx8DV85cYA1fPX2IMJMbAmfKnvnIc1GX24ap5S+RO7q6H3F0vd2fJ26z6yqPCX7ECdevWTRaLxa7ntPf5nJGrj4Gr5y8xBq6ev8QYSIyBs+Q/duxYvfLKK2aHUalQX5UPVx8DV89fYgxcPX+JMZAYA2fJn/rKcVCX2Y+r5i2Ru6sid9fkqrk7Q95m1VeVegZhccrSOeaYynWMo8bFMY59jKPGxTGV7xhHjasyHgP7ceS/Z47h2sUxjnuMo8bFMZXvGEeNqzIeA/NVln9TleU1HDWuyvIajhoXr+H8cVWW13DUuCrLa1RUXOWBexACAAAAAAAAAAAALoQGIQAAAAAAAAAAAOBCXLZBOHHiRId9HUc+piwcNR9Xz7+sx5SFI+dTEWPgyLnwHnDcMXD1/CvyGNgP7yfGwNXzL+sxZeHI+VBflf6YsnDkfBx1DFw9/4o8BuarLNdiR33Pknv57V+Rx5T3azjq+6S0HPXvsLLkXlne72U5htzN57L3ICwLR1kX1kyuPgaunr/EGLh6/hJjIDEGrp4/7Iv3E2Pg6vlLjIGr5y8xBhJj4Or5wzG46vvQVfOWyJ3cXQ+5u17urpp3SbnsDMKycJSurplcfQxcPX+JMXD1/CXGQGIMXD1/2BfvJ8bA1fOXGANXz19iDCTGwNXzh2Nw1fehq+YtkburInfX5Kq5u2reJcUMQgAAAAAAAAAAAMCFMIMQAAAAAAAAAAAAcCE0CAEAAAAAAAAAAAAXQoMQAAAAAAAAAAAAcCE0CAEAAAAAAAAAAAAX4mF2AM4gNzdX0dHR8vT0VFJSkvr376/OnTubHZbdnDhxQnPmzFFAQICSk5M1bNgwhYSEFLnvkiVLdODAARmGoaZNm+qee+6RJP30009as2aNgoODdfz4cV155ZW68cYbKzKNS3KhvP6tJGP1/vvv68svv9QXX3xREaHbRWne4xs2bNDSpUsVEBCg/Px8jRw5Up6enpKk48eP65NPPlHVqlV18uRJNWvWTAMHDqzIVMqsuLz+qbixOnbsmObOnas6deooJSVFrVq1Uv/+/Ss4E/so6XhI0s8//6zZs2dr5MiRCg8Pr+BI7ac018J9+/YpOjpabdu21dChQ23Pu8q1MC8vT5988okWL16szz//XN7e3uft44zXQlQs6qu/UV9RX1FfUV/9G/UV9RX1FSpSaa5PzsQen0MLFy5UYmKiqlevrj///FP333+/WrZsWdGplJqr1mGuXH/ZK/fFixfr4MGDCgwM1MmTJzVs2DAFBwdXZCqXzJ6fvY7OHvWls17n7Flbb926VWPGjNH8+fPVsGHD8g7dsRi4qPfff994++23DcMwjNTUVGPAgAFGVlaWyVHZz5gxY4wNGzYYhmEY69evN8aNG1fkftu2bTOefvppo7Cw0CgsLDSGDx9u7Ny50zAMw5g4caKRkpJiGIZhZGRkGLfddptx7NixCon/UhWX179dbKz2799vjBs3zrj99tvLPW57Kul7PDMz0xgwYIBhtVoNwzCMefPmGR999JFhGIZRUFBgjBo1ykhPT7c93r17dwVlcGmKy+vfihurF1980fj8888NwzCM/Px848477zT+/PPPCsjAvkozHhs2bDB+/PFH48knnzTWrVtXkWHaXUmvhQkJCcaiRYuMN954w5g7d+4521zlWvjll18aW7ZsMa6//nojMzPzvO3Oei1ExaK+OoP6ivqK+or66t+or6ivqK9QkUpzfXIm9vocGjVqlFFYWGgYhmFs2bLFGDBgQAVEf2lcuQ5z5frLHrkfPnzYuOOOO4z8/HzDMAzj888/N6ZOnVpBGdiHPT97HZ296ktnvM7Zs7bOzMw0JkyYYNx+++3GwYMHyzVuR8QSoyWwcuVKde3aVZLk5+enevXqKTY21uSo7CMpKUk7duxQhw4dJEmdOnXS1q1blZqaet6+Z8fBYrHIYrEoPDxcK1askCT997//lb+/vySpWrVqqlGjhpKTkysqjUtSXF7/dLGxysvL06JFi/TII49UZPh2UdL3+Lp161S/fn3VqFFDknTllVfaxmrz5s3y9vbW0qVLNX/+fL333nu67LLLKi6JS1BcXv9W3FgFBAQoJSVFkpSRkaHc3FxZLJYKyMC+SjMenTt3Vs+ePSsyvHJRmmthYGCgHnzwwSK/leQK10JJ6t+/v5o2bVrkNme+FqJiUV+dQX1FfUV9RX31b9RX53KFa6FEfQXzlOb65Ezs9Tk0ffp02+dOaGioUlNTlZ+fXwEZlJ0r12GuXH/ZI/fq1atLOlNzSVJKSorT1V32+ux1BvaqL53xOmfP2vqdd97RQw89JHd393KJ1dHRILwIwzB08uRJ1axZ0/ZcQECA4uPjTYzKfuLj4+Xr62v7B+Dh4SFfX98i84uPj7/gOLi5/f1WOnr0qLy9vdW6detyjt4+isvr3/sVN1aLFy/WnXfeKS8vr4oJ3E5K8x4vaqxOnjwp6czf+4YNG9S9e3cNGTJEVapUUUxMTPknYAfF5fVPFxurwYMHa9euXZo6darGjRunJ598UmFhYeWfgJ2VdDwqk9JcC4vjCtfCi3HWayEqFvXVuftSX1FfUV9RX1VG1FfUV3AOlfX6ZK/PoX9eg2JjY3XTTTfJw8Ox79jkqnWYK9df9sq9Vq1aGj58uMaNG6epU6dq9+7dGjJkSPknYEf2+ux1Bva6fleW61xZct+4caNq1qypRo0a2TM8p0KDsIyc7dsTF2IYRpHPF5VfUfv+e7/s7GzNmzdPEyZMOOfi4shKkteF9ju77549e5STk6O2bdvaPT6zlGYMJCkrK0t169ZV/fr1JUnXXnutfvnll2KPcRSXGuPZsXr55Zd15ZVXavz48Zo2bZq+++47JSQk2CPECuUMf2f2VpprYUlU5mthcSrjtRAVi/qq6P0q8zWF+or66kKor5wf9RX1FZxDZb0+2etz6Kxjx44pNjbWKZol1GHncqX6699Km/vevXu1cOFCTZ8+XePHj1eXLl20bNmy8gzR7uzx2ess7P2edPbrXGllZGTo66+/1r333muHiJyXc1TVJrJYLKpdu7ZtWRtJSk5OVu3atU2Myn5CQkJktVpVUFAgScrPz5fVai3y5rOhoaHFjkNWVpZmzJihxx57THXr1i3/4O3kYnmdVdxYrVu3TmlpaYqOjtaiRYuUnZ2t6Ohobdq0qcLyKKvSvMeLG6ugoKBz/kfd09NT+fn5KiwsLMfo7aOk74GLjdVvv/2mK664QtKZZRmCg4P1888/l3P09lfS8ahMSnMtvJjKfi0sjjNfC1GxqK/+Rn1FfUV9RX1VWVFfUV/BOVTW65O9PoekM780f/fddzV+/HinmE3nqnWYK9df9sp948aNatasmXx8fCRJXbt21aefflrO0dtXZb2mFcWeuVbW61xxtm7dKjc3N73xxhuKjo5WZmamFi9erK+//tre4To0GoQl0KtXL9uazWlpaTp69KhtTWdnFxgYqJYtW2rz5s2SznwQtGnTxjZFd926dba1x8+Og2EYMgxD69evV69evSSd6bjPmDFDDz/8sBo2bKgDBw7ohx9+MCWn0iour5SUFNvffXFjNWjQII0dO1YRERF66KGH5OXlpYiICHXs2NG0vEqjuPf4vn37tH//fklSeHi4jhw5otOnT0s68/44O1bh4eFKTEy0XZz/+OMPtWvXzinWby4ur4KCAq1cudJWCBY3VnXq1NHRo0clnfkmy5EjR8r0CxCzlWY8KovSXAuL4wrXwuI4+7UQFYv6KlUS9RX1FfWVRH1FfVU8V7gWFsfZr4VwfMVdn5yZvT6HDh8+rPfee09jxoyRj4+PvvnmGx07dsyEjErOleswV66/7JF73bp1dfToUdvsrMOHDztd3WWPz15nYa/60hmvc/bI/aqrrlJkZKQiIiIUERGhatWq6f7779ett95a7vE7EovhjPOjK1hOTo6io6Pl6emp5ORk3XbbbbZvsVYGx48f19y5cxUQEKDk5GQNGzZMoaGhkqThw4dr4MCB6tatmyTpww8/1MGDByVJjRs3tk3BffHFF7VhwwbbNwwKCgr00EMPqX///hWfUBlcKK9ff/1VS5Ys0axZsyQVP1bSmRsZf//991q9erX69u2rAQMGOMUHaXHv8Tlz5sjNzU1Dhw6VdGYt6m+++UYBAQHKy8vTyJEjVaVKFUnS77//ruXLlys4OFhJSUkaMmSIU+QvXTivxMREDR8+XLNnz1atWrWKHav9+/drwYIFqlu3rhISEhQaGqrHH3/cKZcyKOl4JCYm6qOPPtLPP/+s5s2b66qrrtJNN91kdvhlUppr4fz5823fnOzYsaNt+QVXuRZu3bpVq1at0rfffqubbrpJPXv2VLt27WzncdZrISoW9RX1FfUV9RX1FfUV9RX1FRxDcZ9Dzswen0N33nmnDMOwNYdycnIUExOjhg0bmpnaRblqHebK9Zc9cjcMQwsWLNCJEycUEBCgI0eOaPDgwWratKmZqZWavT57nYE96ktnvc7Zq7Y+deqUPv74Y/3www+66qqr1LdvX3Xo0MHEzCoWDUIAAAAAAAAAAADAhbDEKAAAAAAAAAAAAOBCaBACAAAAAAAAAAAALoQGIQAAAAAAAAAAAOBCaBACAAAAAAAAAAAALoQGIQAAAAAAAAAAAOBCaBACAAAAAAAAAAAALoQGIQAAAAAAAAAAAOBCaBACAAAAAAAAAAAALoQGIQAAAAAAAAAAAOBCaBACqNTmzJmjwYMHa8WKFbbnVqxYoePHj5sYFQAAgPOivgIAAKg41F4AygsNQgCV2pAhQ3Tq1CldfvnlkiTDMPTtt98qJyfH5MgAAACcE/UVAABAxaH2AlBePMwOAADK0549e+Th4aGGDRtKkiwWi1577TWTowIAAHBe1FcAAAAVh9oLQHmhQQjA4Xz66afauHGj2rdvr/T0dK1evVoFBQWaP3++fvrpJ23atEmenp5KSEjQHXfcoW7dutmO3bt3rxYuXKicnBwFBQUpLCxMbdq0kZubm2JjY7V06VL5+fnp2Wef1Z49e7Ro0SJ5eHgoKipKeXl5mjx5stLT0/X8888rICBAaWlpevfdd5WTk6PU1FT5+Pjoqaeekp+fn4kjBAAAUDrUVwAAABWH2guAM2CJUQAO5+6771Z6erpiY2PVt29fvfXWWwoNDZWXl5fWrFmjsWPHaty4cXrssccUHR1tO2737t0aO3asHnjgAc2cOVP9+vXTxx9/rLZt20qSunbtqssvv1wWi0WS1KxZM7Vu3VoFBQWSJE9PT91+++06duyYAgICJEkvvviiunTporFjx2rKlCk6ePCgvLy8KnZAAAAALhH1FQAAQMWh9gLgDGgQAnA4WVlZ2rdvn4YMGaI6deqoSpUqmj59utzc3BQVFaX4+Hj98ccfOnr06DnHvfrqq+rfv79atWolSWrYsKHy8vLUrl072z5bt2696OOzRVdubq62bdumAwcOKDs7WxaLRTExMapatWp5pg8AAGB31FcAAAAVh9oLgDOgQQjA4fzxxx8KCgpSixYtznl+xYoVGjZsmFasWKFdu3bpxx9/VJMmTSSdWX7h8OHDuu6662z7Hzt2TD4+PmrUqJGkM8XZ3r17bUVTQUGBduzYcU4RtW3bNtvjKlWqaNiwYVq6dKnuvvtuRUdHy82NyyYAAHA+1FcAAAAVh9oLgDPgHoQAHM6/v/kknSmIpk+frnnz5tluyrx161a1bt1aknTkyBF5enqqXr16tmPWrVun1q1b2wqfP/74Q4GBgQoJCZEk7du3T4WFhWrcuLEkyWq1aseOHRoxYoTtHLfffrtuvfVWrV69WjNnzlRoaKgGDBhQfskDAACUA+orAACAikPtBcAZ8HUBAA7nn0shnLV9+3Z5eXmpQYMGkqS4uDht3LjRVmxVr15dBQUFysnJkSTFx8frm2++KXbJhbi4OPn5+cnNzU2GYejdd9+Vr6+v6tevL0kaM2aMJMnd3V09evSQn5+f7fUBAACcCfUVAABAxaH2AuAMmEEIwGGkpqYqJiZGe/fu1cqVK+Xn56fw8HBJUvv27VW1alVFRkaqXr16yszMVH5+vj7//HM9//zz6tSpk1q0aKExY8aocePG8vf3V35+vtasWaOOHTvqs88+06ZNm+Tn56f169crPDxcjRo10unTpxUREaGgoCC5ubmpsLBQixcv1m233ab4+HjNmDFDdevW1a5du9S3b1917drV5FECAAAoOeorAACAikPtBcCZWAzDMMwOAgBKIjc3VwkJCQoKClKVKlWK3Cc+Pl4+Pj6qUaNGic6ZmZmplJQUhYWFyWKxnLPNMAwlJiYqJydHwcHBF3xNAAAAZ0V9BQAAUHGovQA4EhqEAAAAAAAAAAAAgAvhHoQAAAAAAAAAAACAC6FBCAAAAAAAAAAAALgQGoQAAAAAAAAAAACAC/l/fR1VopplXMcAAAAASUVORK5CYII=", - "text/plain": [ - "<IPython.core.display.Image object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "perfplot.plot_neighbor_performance(metric_learning_model, CONFIG)" + "from Embedding import embedding_plots\n", + "\n", + "embedding_plots.plot_embedding_performance_given_radius_knn_max(\n", + " model=metric_learning_model,\n", + " path_or_config=CONFIG,\n", + " radius=np.linspace(0.01, 0.05, 10),\n", + " n_events=20,\n", + " partitions=[\"train\", \"val\", \"velo-sim10b-nospillover\"],\n", + ");\n" ] }, { @@ -1575,26 +522,34 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<IPython.core.display.Image object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ + "metric_learning_model.load_partition(\"velo-sim10b-nospillover\")\n", "graphplot.plot_predicted_graph(metric_learning_model, CONFIG)\n" ] }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from Embedding.embedding_plots import plot_best_performances_radius\n", + "plot_best_performances_radius(\n", + " model=metric_learning_model,\n", + " path_or_config=CONFIG,\n", + " partition=\"velo-sim10b-nospillover\",\n", + " # list_radius=[0.015, 0.020],\n", + " list_radius=[0.015, 0.020, 0.025, 0.030, 0.035, 0.040],\n", + " n_events=20, # for a real training, use more events to have enough stats.\n", + " seed=0,\n", + ");\n" + ] + }, { "attachments": {}, "cell_type": "markdown", @@ -1605,56 +560,22 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "<IPython.core.display.Image object>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ + "metric_learning_model.load_partition(\"velo-sim10b-nospillover\")\n", "perfplot.plot_track_lengths(metric_learning_model, CONFIG)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cba0eb252c7a45019f1dbf261dd43c79", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 1000x500 with 1 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "metric_learning_model.setup(stage=\"fit\")\n", + "metric_learning_model.setup(stage=\"fit\") # load train and val datasets\n", + "\n", "perfplot.plot_graph_sizes(metric_learning_model)" ] }, @@ -1670,126 +591,16 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:------------- Step 2: Constructing graphs from metric learning model -------------\n", - "INFO:---------------------------- a) Loading trained model ----------------------------\n", - "INFO:Load model from artifacts/metric_learning/velo-minbias-sim10b-xdigi-nospillover/version_2/checkpoints/epoch=19-step=1800.ckpt.\n", - "INFO:----------------------------- b) Running inferencing -----------------------------\n", - "INFO:Remove directory `scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/train`.\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/processed/train to scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/train\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f3c42a35a4c9483db8f45981264e77dc", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Remove directory `scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/val`.\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/processed/val to scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/val\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f3dfa17371d84d53ae2a515d99e537cb", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Remove directory `scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover`.\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-minbias-sim10b-xdigi-nospillover to scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e39bfa75bb8a41f5b715d139b1a01513", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Remove directory `scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons`.\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons to scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "10a125cd19d6455d803490e7f61c78a4", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Remove directory `scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-bu2kstee-sim10aU1-xdigi`.\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/processed/test/velo-bu2kstee-sim10aU1-xdigi to scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-bu2kstee-sim10aU1-xdigi\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9a9447471bbb4f0aa45bb179a99f57c9", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "graph_builder = run_metric_learning_inference(CONFIG, checkpoint=embedding_artifact_path)\n" + "graph_builder = run_metric_learning_inference(\n", + " CONFIG,\n", + " checkpoint=embedding_artifact_path,\n", + " # checkpoint=metric_learning_model, # here directly use the model\n", + " reproduce=False,\n", + ")\n" ] }, { @@ -1810,976 +621,19 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "import warnings\n" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:------------------------- Step 3: Running GNN training -------------------------\n", - "INFO:----------------------------- a) Initialising model -----------------------------\n", - "INFO:------------------------------ b) Running training ------------------------------\n", - "INFO:Save hyperparameters, metrics and artifacts in /home/fgias/etx4velo-3/LHCb_Pipeline/artifacts/gnn/velo-minbias-sim10b-xdigi-nospillover/version_1\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/lightning_fabric/plugins/environments/slurm.py:165: PossibleUserWarning: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/fgias/.conda/envs/etx4velo/lib/python3.10/site ...\n", - " rank_zero_warn(\n", - "GPU available: True (cuda), used: True\n", - "TPU available: False, using: 0 TPU cores\n", - "IPU available: False, using: 0 IPUs\n", - "HPU available: False, using: 0 HPUs\n", - "LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "\n", - " | Name | Type | Params\n", - "------------------------------------------------------\n", - "0 | node_encoder | Sequential | 529 K \n", - "1 | edge_encoder | Sequential | 1.8 M \n", - "2 | edge_network | Sequential | 2.1 M \n", - "3 | node_network | Sequential | 1.3 M \n", - "4 | output_edge_classifier | Sequential | 2.1 M \n", - "------------------------------------------------------\n", - "7.9 M Trainable params\n", - "0 Non-trainable params\n", - "7.9 M Total params\n", - "31.599 Total estimated model params size (MB)\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Sanity Checking: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c4d734ebcf1c43d58e18534c79a2fc71", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Training: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "2a5af4451be94821a2149b2e4d300835", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fe0dc0d1dc784314bfa50eef598c1b73", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "3bb63a6a19b9438085104dba1748f7ce", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "02162a7fb5394ad78b45ebbbf57f96b2", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "591536b8afb74244887ff8d1f6b83286", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "eb84f26e12fe4e50841e6ac537767c24", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "cf125bceb74a40c3916b8cf8bb27540e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "258c67fb11ff45f2acf7989a29b001d0", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b890510270fc43269fb691d89eb98a49", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "97550b9b8cec43209d4725c853955138", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "7a77d2f297034dcaa44a5d8225ff667b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c3cf2e99087046d8823f2a7691d5e29a", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "17a86e6140db45aabbf45954c5903c1d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ac6939837fbb47df9f6e3e85276b37cc", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "15a058c04c924b2488b900041948374f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0012e38be2274677ad54f6754e56f5da", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/data/dataloader.py:560: UserWarning: This DataLoader will create 16 worker processes in total. Our suggested max number of worker in current system is 14, which is smaller than what this DataLoader is going to create. Please be aware that excessive worker creation might get DataLoader running slow or even freeze, lower the worker number to avoid potential slowness/freeze if necessary.\n", - " warnings.warn(_create_warning_msg(\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "a5dafb90431f45d29ad7ab58257f3eca", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - "Validation: 0it [00:00, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "`Trainer.fit` stopped: `max_epochs=40` reached.\n", - "INFO:-------------------------------- c) Saving model --------------------------------\n" - ] - } - ], - "source": [ - "send_telegram_message('Started GNN training.', chat_id, api_key)\n", - "with warnings.catch_warnings():\n", - " warnings.filterwarnings(\n", - " \"ignore\", message=\"None of the inputs have requires_grad=True.\"\n", - " )\n", - " gnn_trainer, gnn_model = train_gnn(CONFIG)\n", + "if run_training:\n", + " send_telegram_message('Started GNN training.', chat_id, api_key)\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " \"ignore\", message=\"None of the inputs have requires_grad=True.\"\n", + " )\n", + " gnn_trainer, gnn_model = train_gnn(CONFIG)\n", "\n", - "send_telegram_message('Finished GNN training.', chat_id, api_key)" + " send_telegram_message('Finished GNN training.', chat_id, api_key)" ] }, { @@ -2792,18 +646,9 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "gnn_metric_path='artifacts/gnn/velo-minbias-sim10b-xdigi-nospillover/version_1/metrics.csv'\n", - "gnn_artifact_path='artifacts/gnn/velo-minbias-sim10b-xdigi-nospillover/version_1/checkpoints/epoch=39-step=3600.ckpt'\n" - ] - } - ], + "outputs": [], "source": [ "from utils.modelutils.checkpoint_utils import (\n", " get_last_version_dir_from_config,\n", @@ -2820,7 +665,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -2834,8 +679,8 @@ " config = load_config(path_or_config=path_or_config)\n", "\n", " gnn_model = InteractionGNN.load_from_checkpoint(\n", - " embedding_artifact_path\n", - " ) # you may change `metric_learning_model`\n", + " gnn_artifact_path, **config[\"gnn\"]\n", + " ) # you may change `gnn_model`\n", "\n", " save_directory = os.path.abspath(\n", " os.path.join(config[\"common\"][\"artifact_directory\"], \"gnn\")\n", @@ -2846,25 +691,32 @@ " gnn_trainer = Trainer(\n", " accelerator=\"gpu\" if torch.cuda.is_available() else \"cpu\",\n", " devices=1,\n", - " max_epochs=40, # you may increase the number of epochs\n", + " max_epochs=50, # you may increase the number of epochs\n", " logger=logger,\n", " # callbacks=[EarlyStopping(monitor=\"val_loss\", mode=\"min\")]\n", " )\n", "\n", - " metric_learning_trainer.fit(metric_learning_model)\n", + " with warnings.catch_warnings():\n", + " warnings.filterwarnings(\n", + " \"ignore\", message=\"None of the inputs have requires_grad=True.\"\n", + " )\n", + " gnn_trainer.fit(gnn_model, ckpt_path=gnn_artifact_path)\n", " return gnn_trainer, gnn_model\n", "\n", - "\n", "# gnn_trainer, gnn_model = continue_gnn_training(CONFIG)\n" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "gnn_model = InteractionGNN.load_from_checkpoint(gnn_artifact_path)\n" + "gnn_model = InteractionGNN.load_from_checkpoint(\n", + " gnn_artifact_path,\n", + " # map_location=\"cpu\",\n", + " # hparams=load_config(CONFIG)[\"gnn\"],\n", + ")\n" ] }, { @@ -2877,442 +729,9 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "text/html": [ - "<div>\n", - "<style scoped>\n", - " .dataframe tbody tr th:only-of-type {\n", - " vertical-align: middle;\n", - " }\n", - "\n", - " .dataframe tbody tr th {\n", - " vertical-align: top;\n", - " }\n", - "\n", - " .dataframe thead th {\n", - " text-align: right;\n", - " }\n", - "</style>\n", - "<table border=\"1\" class=\"dataframe\">\n", - " <thead>\n", - " <tr style=\"text-align: right;\">\n", - " <th></th>\n", - " <th>epoch</th>\n", - " <th>train_loss</th>\n", - " <th>val_loss</th>\n", - " <th>eff</th>\n", - " <th>pur</th>\n", - " <th>current_lr</th>\n", - " </tr>\n", - " </thead>\n", - " <tbody>\n", - " <tr>\n", - " <th>0</th>\n", - " <td>0</td>\n", - " <td>0.847782</td>\n", - " <td>0.835718</td>\n", - " <td>0.606771</td>\n", - " <td>0.561668</td>\n", - " <td>0.000200</td>\n", - " </tr>\n", - " <tr>\n", - " <th>1</th>\n", - " <td>1</td>\n", - " <td>0.840699</td>\n", - " <td>0.828294</td>\n", - " <td>0.650663</td>\n", - " <td>0.551916</td>\n", - " <td>0.000400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>2</th>\n", - " <td>2</td>\n", - " <td>0.814449</td>\n", - " <td>0.819903</td>\n", - " <td>0.697715</td>\n", - " <td>0.546762</td>\n", - " <td>0.000600</td>\n", - " </tr>\n", - " <tr>\n", - " <th>3</th>\n", - " <td>3</td>\n", - " <td>0.808856</td>\n", - " <td>0.783907</td>\n", - " <td>0.828007</td>\n", - " <td>0.512144</td>\n", - " <td>0.000800</td>\n", - " </tr>\n", - " <tr>\n", - " <th>4</th>\n", - " <td>4</td>\n", - " <td>0.757131</td>\n", - " <td>0.795749</td>\n", - " <td>0.616819</td>\n", - " <td>0.609769</td>\n", - " <td>0.001000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>5</th>\n", - " <td>5</td>\n", - " <td>0.841196</td>\n", - " <td>0.719712</td>\n", - " <td>0.762973</td>\n", - " <td>0.614555</td>\n", - " <td>0.001200</td>\n", - " </tr>\n", - " <tr>\n", - " <th>6</th>\n", - " <td>6</td>\n", - " <td>0.739529</td>\n", - " <td>0.779560</td>\n", - " <td>0.702113</td>\n", - " <td>0.575488</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>7</th>\n", - " <td>7</td>\n", - " <td>0.648295</td>\n", - " <td>0.672503</td>\n", - " <td>0.782566</td>\n", - " <td>0.646786</td>\n", - " <td>0.001120</td>\n", - " </tr>\n", - " <tr>\n", - " <th>8</th>\n", - " <td>8</td>\n", - " <td>0.540547</td>\n", - " <td>0.599143</td>\n", - " <td>0.860576</td>\n", - " <td>0.645966</td>\n", - " <td>0.001800</td>\n", - " </tr>\n", - " <tr>\n", - " <th>9</th>\n", - " <td>9</td>\n", - " <td>0.462206</td>\n", - " <td>0.495675</td>\n", - " <td>0.819526</td>\n", - " <td>0.772188</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>10</th>\n", - " <td>10</td>\n", - " <td>0.390897</td>\n", - " <td>0.376769</td>\n", - " <td>0.884214</td>\n", - " <td>0.800133</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>11</th>\n", - " <td>11</td>\n", - " <td>0.354644</td>\n", - " <td>0.322055</td>\n", - " <td>0.895604</td>\n", - " <td>0.844770</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>12</th>\n", - " <td>12</td>\n", - " <td>0.303603</td>\n", - " <td>0.290172</td>\n", - " <td>0.932382</td>\n", - " <td>0.824411</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>13</th>\n", - " <td>13</td>\n", - " <td>0.270316</td>\n", - " <td>0.334157</td>\n", - " <td>0.889905</td>\n", - " <td>0.826773</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>14</th>\n", - " <td>14</td>\n", - " <td>0.268074</td>\n", - " <td>0.229994</td>\n", - " <td>0.939393</td>\n", - " <td>0.867535</td>\n", - " <td>0.002000</td>\n", - " </tr>\n", - " <tr>\n", - " <th>15</th>\n", - " <td>15</td>\n", - " <td>0.208173</td>\n", - " <td>0.228011</td>\n", - " <td>0.928939</td>\n", - " <td>0.887602</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>16</th>\n", - " <td>16</td>\n", - " <td>0.198963</td>\n", - " <td>0.169362</td>\n", - " <td>0.953345</td>\n", - " <td>0.908930</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>17</th>\n", - " <td>17</td>\n", - " <td>0.179942</td>\n", - " <td>0.162437</td>\n", - " <td>0.965979</td>\n", - " <td>0.893533</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>18</th>\n", - " <td>18</td>\n", - " <td>0.168318</td>\n", - " <td>0.167323</td>\n", - " <td>0.960488</td>\n", - " <td>0.896721</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>19</th>\n", - " <td>19</td>\n", - " <td>0.163581</td>\n", - " <td>0.147069</td>\n", - " <td>0.966788</td>\n", - " <td>0.906295</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>20</th>\n", - " <td>20</td>\n", - " <td>0.160301</td>\n", - " <td>0.139857</td>\n", - " <td>0.964095</td>\n", - " <td>0.916123</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>21</th>\n", - " <td>21</td>\n", - " <td>0.148940</td>\n", - " <td>0.138042</td>\n", - " <td>0.968433</td>\n", - " <td>0.911560</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>22</th>\n", - " <td>22</td>\n", - " <td>0.152121</td>\n", - " <td>0.137196</td>\n", - " <td>0.975356</td>\n", - " <td>0.901749</td>\n", - " <td>0.001400</td>\n", - " </tr>\n", - " <tr>\n", - " <th>23</th>\n", - " <td>23</td>\n", - " <td>0.132580</td>\n", - " <td>0.145505</td>\n", - " <td>0.961802</td>\n", - " <td>0.914907</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>24</th>\n", - " <td>24</td>\n", - " <td>0.119087</td>\n", - " <td>0.115247</td>\n", - " <td>0.971732</td>\n", - " <td>0.929652</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>25</th>\n", - " <td>25</td>\n", - " <td>0.115420</td>\n", - " <td>0.114022</td>\n", - " <td>0.970458</td>\n", - " <td>0.934912</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>26</th>\n", - " <td>26</td>\n", - " <td>0.109508</td>\n", - " <td>0.113390</td>\n", - " <td>0.971275</td>\n", - " <td>0.934489</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>27</th>\n", - " <td>27</td>\n", - " <td>0.109359</td>\n", - " <td>0.112889</td>\n", - " <td>0.973337</td>\n", - " <td>0.935166</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>28</th>\n", - " <td>28</td>\n", - " <td>0.105726</td>\n", - " <td>0.119013</td>\n", - " <td>0.971684</td>\n", - " <td>0.935247</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>29</th>\n", - " <td>29</td>\n", - " <td>0.108074</td>\n", - " <td>0.109331</td>\n", - " <td>0.974781</td>\n", - " <td>0.930926</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>30</th>\n", - " <td>30</td>\n", - " <td>0.107911</td>\n", - " <td>0.112318</td>\n", - " <td>0.970788</td>\n", - " <td>0.934250</td>\n", - " <td>0.000980</td>\n", - " </tr>\n", - " <tr>\n", - " <th>31</th>\n", - " <td>31</td>\n", - " <td>0.092714</td>\n", - " <td>0.107155</td>\n", - " <td>0.973383</td>\n", - " <td>0.936992</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>32</th>\n", - " <td>32</td>\n", - " <td>0.086805</td>\n", - " <td>0.097335</td>\n", - " <td>0.977432</td>\n", - " <td>0.938593</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>33</th>\n", - " <td>33</td>\n", - " <td>0.088135</td>\n", - " <td>0.088208</td>\n", - " <td>0.978923</td>\n", - " <td>0.946520</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>34</th>\n", - " <td>34</td>\n", - " <td>0.086349</td>\n", - " <td>0.092444</td>\n", - " <td>0.976368</td>\n", - " <td>0.947216</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>35</th>\n", - " <td>35</td>\n", - " <td>0.084271</td>\n", - " <td>0.092907</td>\n", - " <td>0.976333</td>\n", - " <td>0.947210</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>36</th>\n", - " <td>36</td>\n", - " <td>0.087265</td>\n", - " <td>0.093572</td>\n", - " <td>0.976155</td>\n", - " <td>0.945150</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>37</th>\n", - " <td>37</td>\n", - " <td>0.084715</td>\n", - " <td>0.098950</td>\n", - " <td>0.973790</td>\n", - " <td>0.948907</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " <tr>\n", - " <th>38</th>\n", - " <td>38</td>\n", - " <td>0.078550</td>\n", - " <td>0.094507</td>\n", - " <td>0.974446</td>\n", - " <td>0.949921</td>\n", - " <td>0.000686</td>\n", - " </tr>\n", - " </tbody>\n", - "</table>\n", - "</div>" - ], - "text/plain": [ - " epoch train_loss val_loss eff pur current_lr\n", - "0 0 0.847782 0.835718 0.606771 0.561668 0.000200\n", - "1 1 0.840699 0.828294 0.650663 0.551916 0.000400\n", - "2 2 0.814449 0.819903 0.697715 0.546762 0.000600\n", - "3 3 0.808856 0.783907 0.828007 0.512144 0.000800\n", - "4 4 0.757131 0.795749 0.616819 0.609769 0.001000\n", - "5 5 0.841196 0.719712 0.762973 0.614555 0.001200\n", - "6 6 0.739529 0.779560 0.702113 0.575488 0.001400\n", - "7 7 0.648295 0.672503 0.782566 0.646786 0.001120\n", - "8 8 0.540547 0.599143 0.860576 0.645966 0.001800\n", - "9 9 0.462206 0.495675 0.819526 0.772188 0.002000\n", - "10 10 0.390897 0.376769 0.884214 0.800133 0.002000\n", - "11 11 0.354644 0.322055 0.895604 0.844770 0.002000\n", - "12 12 0.303603 0.290172 0.932382 0.824411 0.002000\n", - "13 13 0.270316 0.334157 0.889905 0.826773 0.002000\n", - "14 14 0.268074 0.229994 0.939393 0.867535 0.002000\n", - "15 15 0.208173 0.228011 0.928939 0.887602 0.001400\n", - "16 16 0.198963 0.169362 0.953345 0.908930 0.001400\n", - "17 17 0.179942 0.162437 0.965979 0.893533 0.001400\n", - "18 18 0.168318 0.167323 0.960488 0.896721 0.001400\n", - "19 19 0.163581 0.147069 0.966788 0.906295 0.001400\n", - "20 20 0.160301 0.139857 0.964095 0.916123 0.001400\n", - "21 21 0.148940 0.138042 0.968433 0.911560 0.001400\n", - "22 22 0.152121 0.137196 0.975356 0.901749 0.001400\n", - "23 23 0.132580 0.145505 0.961802 0.914907 0.000980\n", - "24 24 0.119087 0.115247 0.971732 0.929652 0.000980\n", - "25 25 0.115420 0.114022 0.970458 0.934912 0.000980\n", - "26 26 0.109508 0.113390 0.971275 0.934489 0.000980\n", - "27 27 0.109359 0.112889 0.973337 0.935166 0.000980\n", - "28 28 0.105726 0.119013 0.971684 0.935247 0.000980\n", - "29 29 0.108074 0.109331 0.974781 0.930926 0.000980\n", - "30 30 0.107911 0.112318 0.970788 0.934250 0.000980\n", - "31 31 0.092714 0.107155 0.973383 0.936992 0.000686\n", - "32 32 0.086805 0.097335 0.977432 0.938593 0.000686\n", - "33 33 0.088135 0.088208 0.978923 0.946520 0.000686\n", - "34 34 0.086349 0.092444 0.976368 0.947216 0.000686\n", - "35 35 0.084271 0.092907 0.976333 0.947210 0.000686\n", - "36 36 0.087265 0.093572 0.976155 0.945150 0.000686\n", - "37 37 0.084715 0.098950 0.973790 0.948907 0.000686\n", - "38 38 0.078550 0.094507 0.974446 0.949921 0.000686" - ] - }, - "execution_count": 34, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ "# gnn_metrics = checkpoint_utils.get_training_metrics(gnn_trainer)\n", "\n", @@ -3323,66 +742,35 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "perfplot_mpl.plot_loss(gnn_metrics, CONFIG, \"gnn\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "WARNING:Retrying (Retry(total=2, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f183340de70>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n", - "WARNING:Retrying (Retry(total=1, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f1833358190>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n", - "WARNING:Retrying (Retry(total=0, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f182b316740>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n" - ] - }, - { - "ename": "MaxRetryError", - "evalue": "HTTPConnectionPool(host='localhost', port=44379): Max retries exceeded with url: /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f1822df0370>: Failed to establish a new connection: [Errno 111] Connection refused'))", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mConnectionRefusedError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:174\u001b[0m, in \u001b[0;36mHTTPConnection._new_conn\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 174\u001b[0m conn \u001b[38;5;241m=\u001b[39m \u001b[43mconnection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_connection\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dns_host\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mport\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mextra_kw\u001b[49m\n\u001b[1;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m SocketTimeout:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/connection.py:95\u001b[0m, in \u001b[0;36mcreate_connection\u001b[0;34m(address, timeout, source_address, socket_options)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m err \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 95\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m err\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m socket\u001b[38;5;241m.\u001b[39merror(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgetaddrinfo returns an empty list\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/connection.py:85\u001b[0m, in \u001b[0;36mcreate_connection\u001b[0;34m(address, timeout, source_address, socket_options)\u001b[0m\n\u001b[1;32m 84\u001b[0m sock\u001b[38;5;241m.\u001b[39mbind(source_address)\n\u001b[0;32m---> 85\u001b[0m \u001b[43msock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnect\u001b[49m\u001b[43m(\u001b[49m\u001b[43msa\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m sock\n", - "\u001b[0;31mConnectionRefusedError\u001b[0m: [Errno 111] Connection refused", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mNewConnectionError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:703\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# Make the request on the httplib connection object.\u001b[39;00m\n\u001b[0;32m--> 703\u001b[0m httplib_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 704\u001b[0m \u001b[43m \u001b[49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 706\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 707\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 708\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 709\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 710\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 711\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 713\u001b[0m \u001b[38;5;66;03m# If we're going to release the connection in ``finally:``, then\u001b[39;00m\n\u001b[1;32m 714\u001b[0m \u001b[38;5;66;03m# the response doesn't need to know about the connection. Otherwise\u001b[39;00m\n\u001b[1;32m 715\u001b[0m \u001b[38;5;66;03m# it will also try to release it and we'll have a double-release\u001b[39;00m\n\u001b[1;32m 716\u001b[0m \u001b[38;5;66;03m# mess.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:398\u001b[0m, in \u001b[0;36mHTTPConnectionPool._make_request\u001b[0;34m(self, conn, method, url, timeout, chunked, **httplib_request_kw)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 398\u001b[0m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mhttplib_request_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;66;03m# We are swallowing BrokenPipeError (errno.EPIPE) since the server is\u001b[39;00m\n\u001b[1;32m 401\u001b[0m \u001b[38;5;66;03m# legitimately able to close the connection after sending a valid response.\u001b[39;00m\n\u001b[1;32m 402\u001b[0m \u001b[38;5;66;03m# With this behaviour, the received response is still readable.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:244\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[0;34m(self, method, url, body, headers)\u001b[0m\n\u001b[1;32m 243\u001b[0m headers[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUser-Agent\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m _get_default_user_agent()\n\u001b[0;32m--> 244\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mHTTPConnection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1283\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[0;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[1;32m 1282\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Send a complete request to the server.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1283\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_send_request\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1329\u001b[0m, in \u001b[0;36mHTTPConnection._send_request\u001b[0;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[1;32m 1328\u001b[0m body \u001b[38;5;241m=\u001b[39m _encode(body, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbody\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m-> 1329\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mendheaders\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1278\u001b[0m, in \u001b[0;36mHTTPConnection.endheaders\u001b[0;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[1;32m 1277\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m CannotSendHeader()\n\u001b[0;32m-> 1278\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_send_output\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1038\u001b[0m, in \u001b[0;36mHTTPConnection._send_output\u001b[0;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[1;32m 1037\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_buffer[:]\n\u001b[0;32m-> 1038\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1040\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m message_body \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1041\u001b[0m \n\u001b[1;32m 1042\u001b[0m \u001b[38;5;66;03m# create a consistent interface to message_body\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:976\u001b[0m, in \u001b[0;36mHTTPConnection.send\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 975\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mauto_open:\n\u001b[0;32m--> 976\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnect\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:205\u001b[0m, in \u001b[0;36mHTTPConnection.connect\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconnect\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 205\u001b[0m conn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_new_conn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_conn(conn)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:186\u001b[0m, in \u001b[0;36mHTTPConnection._new_conn\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 185\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m SocketError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 186\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NewConnectionError(\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFailed to establish a new connection: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m e\n\u001b[1;32m 188\u001b[0m )\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m conn\n", - "\u001b[0;31mNewConnectionError\u001b[0m: <urllib3.connection.HTTPConnection object at 0x7f1822df0370>: Failed to establish a new connection: [Errno 111] Connection refused", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mMaxRetryError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[35], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mperfplot\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_training_metrics\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgnn_metrics\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mCONFIG\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[38;5;124;43mgnn\u001b[39;49m\u001b[38;5;124;43m\"\u001b[39;49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/etx4velo-3/LHCb_Pipeline/utils/plotutils/performance.py:65\u001b[0m, in \u001b[0;36mplot_training_metrics\u001b[0;34m(metrics, path_or_config, name)\u001b[0m\n\u001b[1;32m 61\u001b[0m \u001b[38;5;66;03m# show(row([p1,p2, p3]))\u001b[39;00m\n\u001b[1;32m 62\u001b[0m filename \u001b[38;5;241m=\u001b[39m op\u001b[38;5;241m.\u001b[39mjoin(\n\u001b[1;32m 63\u001b[0m get_performance_directory(path_or_config), \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mtraining_metrics_\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mname\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m.png\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 64\u001b[0m )\n\u001b[0;32m---> 65\u001b[0m \u001b[43mexport_png\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m(\u001b[49m\u001b[43m[\u001b[49m\u001b[43mp1\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp2\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mp3\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 66\u001b[0m display(Image(filename\u001b[38;5;241m=\u001b[39mfilename))\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/bokeh/io/export.py:111\u001b[0m, in \u001b[0;36mexport_png\u001b[0;34m(obj, filename, width, height, webdriver, timeout)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexport_png\u001b[39m(obj: LayoutDOM \u001b[38;5;241m|\u001b[39m Document, \u001b[38;5;241m*\u001b[39m, filename: PathLike \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, width: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 74\u001b[0m height: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, webdriver: WebDriver \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, timeout: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mstr\u001b[39m:\n\u001b[1;32m 75\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m''' Export the ``LayoutDOM`` object or document as a PNG.\u001b[39;00m\n\u001b[1;32m 76\u001b[0m \n\u001b[1;32m 77\u001b[0m \u001b[38;5;124;03m If the filename is not given, it is derived from the script name (e.g.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 109\u001b[0m \n\u001b[1;32m 110\u001b[0m \u001b[38;5;124;03m '''\u001b[39;00m\n\u001b[0;32m--> 111\u001b[0m image \u001b[38;5;241m=\u001b[39m \u001b[43mget_screenshot_as_png\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwidth\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwidth\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdriver\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwebdriver\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m filename \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 114\u001b[0m filename \u001b[38;5;241m=\u001b[39m default_filename(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpng\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/bokeh/io/export.py:237\u001b[0m, in \u001b[0;36mget_screenshot_as_png\u001b[0;34m(obj, driver, timeout, resources, width, height)\u001b[0m\n\u001b[1;32m 234\u001b[0m file\u001b[38;5;241m.\u001b[39mwrite(html)\n\u001b[1;32m 236\u001b[0m web_driver \u001b[38;5;241m=\u001b[39m driver \u001b[38;5;28;01mif\u001b[39;00m driver \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m webdriver_control\u001b[38;5;241m.\u001b[39mget()\n\u001b[0;32m--> 237\u001b[0m \u001b[43mweb_driver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaximize_window\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 238\u001b[0m web_driver\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfile://\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtmp\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 239\u001b[0m wait_until_render_complete(web_driver, timeout)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/webdriver.py:592\u001b[0m, in \u001b[0;36mWebDriver.maximize_window\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 590\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Maximizes the current window that webdriver is using.\"\"\"\u001b[39;00m\n\u001b[1;32m 591\u001b[0m command \u001b[38;5;241m=\u001b[39m Command\u001b[38;5;241m.\u001b[39mW3C_MAXIMIZE_WINDOW\n\u001b[0;32m--> 592\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/webdriver.py:438\u001b[0m, in \u001b[0;36mWebDriver.execute\u001b[0;34m(self, driver_command, params)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msessionId\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m params:\n\u001b[1;32m 436\u001b[0m params[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msessionId\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msession_id\n\u001b[0;32m--> 438\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcommand_executor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdriver_command\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 439\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m response:\n\u001b[1;32m 440\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39merror_handler\u001b[38;5;241m.\u001b[39mcheck_response(response)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/remote_connection.py:290\u001b[0m, in \u001b[0;36mRemoteConnection.execute\u001b[0;34m(self, command, params)\u001b[0m\n\u001b[1;32m 288\u001b[0m data \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mdump_json(params)\n\u001b[1;32m 289\u001b[0m url \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_url\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mpath\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 290\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand_info\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/remote_connection.py:311\u001b[0m, in \u001b[0;36mRemoteConnection._request\u001b[0;34m(self, method, url, body)\u001b[0m\n\u001b[1;32m 308\u001b[0m body \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkeep_alive:\n\u001b[0;32m--> 311\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 312\u001b[0m statuscode \u001b[38;5;241m=\u001b[39m response\u001b[38;5;241m.\u001b[39mstatus\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/request.py:78\u001b[0m, in \u001b[0;36mRequestMethods.request\u001b[0;34m(self, method, url, fields, headers, **urlopen_kw)\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrequest_encode_url(\n\u001b[1;32m 75\u001b[0m method, url, fields\u001b[38;5;241m=\u001b[39mfields, headers\u001b[38;5;241m=\u001b[39mheaders, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39murlopen_kw\n\u001b[1;32m 76\u001b[0m )\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 78\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest_encode_body\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfields\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfields\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43murlopen_kw\u001b[49m\n\u001b[1;32m 80\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/request.py:170\u001b[0m, in \u001b[0;36mRequestMethods.request_encode_body\u001b[0;34m(self, method, url, fields, headers, encode_multipart, multipart_boundary, **urlopen_kw)\u001b[0m\n\u001b[1;32m 167\u001b[0m extra_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mheaders\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mupdate(headers)\n\u001b[1;32m 168\u001b[0m extra_kw\u001b[38;5;241m.\u001b[39mupdate(urlopen_kw)\n\u001b[0;32m--> 170\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mextra_kw\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/poolmanager.py:376\u001b[0m, in \u001b[0;36mPoolManager.urlopen\u001b[0;34m(self, method, url, redirect, **kw)\u001b[0m\n\u001b[1;32m 374\u001b[0m response \u001b[38;5;241m=\u001b[39m conn\u001b[38;5;241m.\u001b[39murlopen(method, url, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw)\n\u001b[1;32m 375\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 376\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest_uri\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 378\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n\u001b[1;32m 379\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m redirect_location:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:787\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e, (SocketError, HTTPException)):\n\u001b[1;32m 785\u001b[0m e \u001b[38;5;241m=\u001b[39m ProtocolError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConnection aborted.\u001b[39m\u001b[38;5;124m\"\u001b[39m, e)\n\u001b[0;32m--> 787\u001b[0m retries \u001b[38;5;241m=\u001b[39m \u001b[43mretries\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mincrement\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 788\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43me\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_pool\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_stacktrace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msys\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexc_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m 789\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 790\u001b[0m retries\u001b[38;5;241m.\u001b[39msleep()\n\u001b[1;32m 792\u001b[0m \u001b[38;5;66;03m# Keep track of the error for the retry warning.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/retry.py:592\u001b[0m, in \u001b[0;36mRetry.increment\u001b[0;34m(self, method, url, response, error, _pool, _stacktrace)\u001b[0m\n\u001b[1;32m 581\u001b[0m new_retry \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnew(\n\u001b[1;32m 582\u001b[0m total\u001b[38;5;241m=\u001b[39mtotal,\n\u001b[1;32m 583\u001b[0m connect\u001b[38;5;241m=\u001b[39mconnect,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 588\u001b[0m history\u001b[38;5;241m=\u001b[39mhistory,\n\u001b[1;32m 589\u001b[0m )\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_retry\u001b[38;5;241m.\u001b[39mis_exhausted():\n\u001b[0;32m--> 592\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m MaxRetryError(_pool, url, error \u001b[38;5;129;01mor\u001b[39;00m ResponseError(cause))\n\u001b[1;32m 594\u001b[0m log\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncremented Retry for (url=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m): \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, url, new_retry)\n\u001b[1;32m 596\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m new_retry\n", - "\u001b[0;31mMaxRetryError\u001b[0m: HTTPConnectionPool(host='localhost', port=44379): Max retries exceeded with url: /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f1822df0370>: Failed to establish a new connection: [Errno 111] Connection refused'))" - ] - } - ], + "outputs": [], "source": [ - "perfplot.plot_training_metrics(gnn_metrics, CONFIG, \"gnn\")" + "perfplot_mpl.plot_metric_epochs(\n", + " \"eff\",\n", + " gnn_metrics,\n", + " CONFIG,\n", + " \"gnn\",\n", + " \"Edge Efficiency\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n", + "perfplot_mpl.plot_metric_epochs(\n", + " \"pur\",\n", + " gnn_metrics,\n", + " CONFIG,\n", + " \"gnn\",\n", + " \"Edge Purity\",\n", + " color=perfplot_mpl.partition_to_color[\"val\"],\n", + ")\n" ] }, { @@ -3397,77 +785,30 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ - "gnn_model.load_testset(\"velo-minbias-sim10b-xdigi-nospillover\")\n" + "gnn_model.load_partition(\"velo-sim10b-nospillover\")\n", + "perfplot.plot_edge_performance(gnn_model, CONFIG)\n" ] }, { "cell_type": "code", - "execution_count": 37, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", - " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n", - "WARNING:Retrying (Retry(total=2, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f1822dda380>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n", - "WARNING:Retrying (Retry(total=1, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f177073a200>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n", - "WARNING:Retrying (Retry(total=0, connect=None, read=None, redirect=None, status=None)) after connection broken by 'NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f17707cc370>: Failed to establish a new connection: [Errno 111] Connection refused')': /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize\n" - ] - }, - { - "ename": "MaxRetryError", - "evalue": "HTTPConnectionPool(host='localhost', port=44379): Max retries exceeded with url: /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f17707cc610>: Failed to establish a new connection: [Errno 111] Connection refused'))", - "output_type": "error", - "traceback": [ - "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", - "\u001b[0;31mConnectionRefusedError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:174\u001b[0m, in \u001b[0;36mHTTPConnection._new_conn\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 173\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 174\u001b[0m conn \u001b[38;5;241m=\u001b[39m \u001b[43mconnection\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcreate_connection\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 175\u001b[0m \u001b[43m \u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_dns_host\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mport\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mextra_kw\u001b[49m\n\u001b[1;32m 176\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 178\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m SocketTimeout:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/connection.py:95\u001b[0m, in \u001b[0;36mcreate_connection\u001b[0;34m(address, timeout, source_address, socket_options)\u001b[0m\n\u001b[1;32m 94\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m err \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[0;32m---> 95\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m err\n\u001b[1;32m 97\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m socket\u001b[38;5;241m.\u001b[39merror(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mgetaddrinfo returns an empty list\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/connection.py:85\u001b[0m, in \u001b[0;36mcreate_connection\u001b[0;34m(address, timeout, source_address, socket_options)\u001b[0m\n\u001b[1;32m 84\u001b[0m sock\u001b[38;5;241m.\u001b[39mbind(source_address)\n\u001b[0;32m---> 85\u001b[0m \u001b[43msock\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnect\u001b[49m\u001b[43m(\u001b[49m\u001b[43msa\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 86\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m sock\n", - "\u001b[0;31mConnectionRefusedError\u001b[0m: [Errno 111] Connection refused", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mNewConnectionError\u001b[0m Traceback (most recent call last)", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:703\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 702\u001b[0m \u001b[38;5;66;03m# Make the request on the httplib connection object.\u001b[39;00m\n\u001b[0;32m--> 703\u001b[0m httplib_response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_make_request\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 704\u001b[0m \u001b[43m \u001b[49m\u001b[43mconn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 705\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 706\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 707\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout_obj\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 708\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 709\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 710\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 711\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 713\u001b[0m \u001b[38;5;66;03m# If we're going to release the connection in ``finally:``, then\u001b[39;00m\n\u001b[1;32m 714\u001b[0m \u001b[38;5;66;03m# the response doesn't need to know about the connection. Otherwise\u001b[39;00m\n\u001b[1;32m 715\u001b[0m \u001b[38;5;66;03m# it will also try to release it and we'll have a double-release\u001b[39;00m\n\u001b[1;32m 716\u001b[0m \u001b[38;5;66;03m# mess.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:398\u001b[0m, in \u001b[0;36mHTTPConnectionPool._make_request\u001b[0;34m(self, conn, method, url, timeout, chunked, **httplib_request_kw)\u001b[0m\n\u001b[1;32m 397\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 398\u001b[0m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mhttplib_request_kw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 400\u001b[0m \u001b[38;5;66;03m# We are swallowing BrokenPipeError (errno.EPIPE) since the server is\u001b[39;00m\n\u001b[1;32m 401\u001b[0m \u001b[38;5;66;03m# legitimately able to close the connection after sending a valid response.\u001b[39;00m\n\u001b[1;32m 402\u001b[0m \u001b[38;5;66;03m# With this behaviour, the received response is still readable.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:244\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[0;34m(self, method, url, body, headers)\u001b[0m\n\u001b[1;32m 243\u001b[0m headers[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mUser-Agent\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m _get_default_user_agent()\n\u001b[0;32m--> 244\u001b[0m \u001b[38;5;28;43msuper\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mHTTPConnection\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1283\u001b[0m, in \u001b[0;36mHTTPConnection.request\u001b[0;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[1;32m 1282\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Send a complete request to the server.\"\"\"\u001b[39;00m\n\u001b[0;32m-> 1283\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_send_request\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1329\u001b[0m, in \u001b[0;36mHTTPConnection._send_request\u001b[0;34m(self, method, url, body, headers, encode_chunked)\u001b[0m\n\u001b[1;32m 1328\u001b[0m body \u001b[38;5;241m=\u001b[39m _encode(body, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mbody\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[0;32m-> 1329\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mendheaders\u001b[49m\u001b[43m(\u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1278\u001b[0m, in \u001b[0;36mHTTPConnection.endheaders\u001b[0;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[1;32m 1277\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m CannotSendHeader()\n\u001b[0;32m-> 1278\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_send_output\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmessage_body\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mencode_chunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mencode_chunked\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:1038\u001b[0m, in \u001b[0;36mHTTPConnection._send_output\u001b[0;34m(self, message_body, encode_chunked)\u001b[0m\n\u001b[1;32m 1037\u001b[0m \u001b[38;5;28;01mdel\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_buffer[:]\n\u001b[0;32m-> 1038\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msend\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmsg\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 1040\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m message_body \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 1041\u001b[0m \n\u001b[1;32m 1042\u001b[0m \u001b[38;5;66;03m# create a consistent interface to message_body\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/http/client.py:976\u001b[0m, in \u001b[0;36mHTTPConnection.send\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m 975\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mauto_open:\n\u001b[0;32m--> 976\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mconnect\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 977\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:205\u001b[0m, in \u001b[0;36mHTTPConnection.connect\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 204\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mconnect\u001b[39m(\u001b[38;5;28mself\u001b[39m):\n\u001b[0;32m--> 205\u001b[0m conn \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_new_conn\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 206\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_prepare_conn(conn)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connection.py:186\u001b[0m, in \u001b[0;36mHTTPConnection._new_conn\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 185\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m SocketError \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[0;32m--> 186\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m NewConnectionError(\n\u001b[1;32m 187\u001b[0m \u001b[38;5;28mself\u001b[39m, \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mFailed to establish a new connection: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;241m%\u001b[39m e\n\u001b[1;32m 188\u001b[0m )\n\u001b[1;32m 190\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m conn\n", - "\u001b[0;31mNewConnectionError\u001b[0m: <urllib3.connection.HTTPConnection object at 0x7f17707cc610>: Failed to establish a new connection: [Errno 111] Connection refused", - "\nDuring handling of the above exception, another exception occurred:\n", - "\u001b[0;31mMaxRetryError\u001b[0m Traceback (most recent call last)", - "Cell \u001b[0;32mIn[37], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mperfplot\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mplot_edge_performance\u001b[49m\u001b[43m(\u001b[49m\u001b[43mgnn_model\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mCONFIG\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/etx4velo-3/LHCb_Pipeline/utils/plotutils/performance.py:281\u001b[0m, in \u001b[0;36mplot_edge_performance\u001b[0;34m(model, path_or_config)\u001b[0m\n\u001b[1;32m 277\u001b[0m \u001b[38;5;66;03m# show(row(figures))\u001b[39;00m\n\u001b[1;32m 278\u001b[0m filename \u001b[38;5;241m=\u001b[39m op\u001b[38;5;241m.\u001b[39mjoin(\n\u001b[1;32m 279\u001b[0m get_performance_directory(path_or_config), \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124medge_performance.png\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m 280\u001b[0m )\n\u001b[0;32m--> 281\u001b[0m \u001b[43mexport_png\u001b[49m\u001b[43m(\u001b[49m\u001b[43mrow\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfigures\u001b[49m\u001b[43m)\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfilename\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfilename\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 282\u001b[0m display(Image(filename\u001b[38;5;241m=\u001b[39mfilename))\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/bokeh/io/export.py:111\u001b[0m, in \u001b[0;36mexport_png\u001b[0;34m(obj, filename, width, height, webdriver, timeout)\u001b[0m\n\u001b[1;32m 73\u001b[0m \u001b[38;5;28;01mdef\u001b[39;00m \u001b[38;5;21mexport_png\u001b[39m(obj: LayoutDOM \u001b[38;5;241m|\u001b[39m Document, \u001b[38;5;241m*\u001b[39m, filename: PathLike \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, width: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m,\n\u001b[1;32m 74\u001b[0m height: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, webdriver: WebDriver \u001b[38;5;241m|\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m, timeout: \u001b[38;5;28mint\u001b[39m \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m5\u001b[39m) \u001b[38;5;241m-\u001b[39m\u001b[38;5;241m>\u001b[39m \u001b[38;5;28mstr\u001b[39m:\n\u001b[1;32m 75\u001b[0m \u001b[38;5;250m \u001b[39m\u001b[38;5;124;03m''' Export the ``LayoutDOM`` object or document as a PNG.\u001b[39;00m\n\u001b[1;32m 76\u001b[0m \n\u001b[1;32m 77\u001b[0m \u001b[38;5;124;03m If the filename is not given, it is derived from the script name (e.g.\u001b[39;00m\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 109\u001b[0m \n\u001b[1;32m 110\u001b[0m \u001b[38;5;124;03m '''\u001b[39;00m\n\u001b[0;32m--> 111\u001b[0m image \u001b[38;5;241m=\u001b[39m \u001b[43mget_screenshot_as_png\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mwidth\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwidth\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheight\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheight\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mdriver\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mwebdriver\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 113\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m filename \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m:\n\u001b[1;32m 114\u001b[0m filename \u001b[38;5;241m=\u001b[39m default_filename(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mpng\u001b[39m\u001b[38;5;124m\"\u001b[39m)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/bokeh/io/export.py:237\u001b[0m, in \u001b[0;36mget_screenshot_as_png\u001b[0;34m(obj, driver, timeout, resources, width, height)\u001b[0m\n\u001b[1;32m 234\u001b[0m file\u001b[38;5;241m.\u001b[39mwrite(html)\n\u001b[1;32m 236\u001b[0m web_driver \u001b[38;5;241m=\u001b[39m driver \u001b[38;5;28;01mif\u001b[39;00m driver \u001b[38;5;129;01mis\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;28;01mNone\u001b[39;00m \u001b[38;5;28;01melse\u001b[39;00m webdriver_control\u001b[38;5;241m.\u001b[39mget()\n\u001b[0;32m--> 237\u001b[0m \u001b[43mweb_driver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mmaximize_window\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 238\u001b[0m web_driver\u001b[38;5;241m.\u001b[39mget(\u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mfile://\u001b[39m\u001b[38;5;132;01m{\u001b[39;00mtmp\u001b[38;5;241m.\u001b[39mpath\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m)\n\u001b[1;32m 239\u001b[0m wait_until_render_complete(web_driver, timeout)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/webdriver.py:592\u001b[0m, in \u001b[0;36mWebDriver.maximize_window\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m 590\u001b[0m \u001b[38;5;250m\u001b[39m\u001b[38;5;124;03m\"\"\"Maximizes the current window that webdriver is using.\"\"\"\u001b[39;00m\n\u001b[1;32m 591\u001b[0m command \u001b[38;5;241m=\u001b[39m Command\u001b[38;5;241m.\u001b[39mW3C_MAXIMIZE_WINDOW\n\u001b[0;32m--> 592\u001b[0m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/webdriver.py:438\u001b[0m, in \u001b[0;36mWebDriver.execute\u001b[0;34m(self, driver_command, params)\u001b[0m\n\u001b[1;32m 435\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msessionId\u001b[39m\u001b[38;5;124m\"\u001b[39m \u001b[38;5;129;01mnot\u001b[39;00m \u001b[38;5;129;01min\u001b[39;00m params:\n\u001b[1;32m 436\u001b[0m params[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124msessionId\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39msession_id\n\u001b[0;32m--> 438\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mcommand_executor\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexecute\u001b[49m\u001b[43m(\u001b[49m\u001b[43mdriver_command\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparams\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 439\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m response:\n\u001b[1;32m 440\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39merror_handler\u001b[38;5;241m.\u001b[39mcheck_response(response)\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/remote_connection.py:290\u001b[0m, in \u001b[0;36mRemoteConnection.execute\u001b[0;34m(self, command, params)\u001b[0m\n\u001b[1;32m 288\u001b[0m data \u001b[38;5;241m=\u001b[39m utils\u001b[38;5;241m.\u001b[39mdump_json(params)\n\u001b[1;32m 289\u001b[0m url \u001b[38;5;241m=\u001b[39m \u001b[38;5;124mf\u001b[39m\u001b[38;5;124m\"\u001b[39m\u001b[38;5;132;01m{\u001b[39;00m\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_url\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;132;01m{\u001b[39;00mpath\u001b[38;5;132;01m}\u001b[39;00m\u001b[38;5;124m\"\u001b[39m\n\u001b[0;32m--> 290\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_request\u001b[49m\u001b[43m(\u001b[49m\u001b[43mcommand_info\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m]\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mdata\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/selenium/webdriver/remote/remote_connection.py:311\u001b[0m, in \u001b[0;36mRemoteConnection._request\u001b[0;34m(self, method, url, body)\u001b[0m\n\u001b[1;32m 308\u001b[0m body \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;01mNone\u001b[39;00m\n\u001b[1;32m 310\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mkeep_alive:\n\u001b[0;32m--> 311\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_conn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 312\u001b[0m statuscode \u001b[38;5;241m=\u001b[39m response\u001b[38;5;241m.\u001b[39mstatus\n\u001b[1;32m 313\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/request.py:78\u001b[0m, in \u001b[0;36mRequestMethods.request\u001b[0;34m(self, method, url, fields, headers, **urlopen_kw)\u001b[0m\n\u001b[1;32m 74\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mrequest_encode_url(\n\u001b[1;32m 75\u001b[0m method, url, fields\u001b[38;5;241m=\u001b[39mfields, headers\u001b[38;5;241m=\u001b[39mheaders, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39murlopen_kw\n\u001b[1;32m 76\u001b[0m )\n\u001b[1;32m 77\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m---> 78\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest_encode_body\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 79\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mfields\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mfields\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43murlopen_kw\u001b[49m\n\u001b[1;32m 80\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/request.py:170\u001b[0m, in \u001b[0;36mRequestMethods.request_encode_body\u001b[0;34m(self, method, url, fields, headers, encode_multipart, multipart_boundary, **urlopen_kw)\u001b[0m\n\u001b[1;32m 167\u001b[0m extra_kw[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mheaders\u001b[39m\u001b[38;5;124m\"\u001b[39m]\u001b[38;5;241m.\u001b[39mupdate(headers)\n\u001b[1;32m 168\u001b[0m extra_kw\u001b[38;5;241m.\u001b[39mupdate(urlopen_kw)\n\u001b[0;32m--> 170\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mextra_kw\u001b[49m\u001b[43m)\u001b[49m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/poolmanager.py:376\u001b[0m, in \u001b[0;36mPoolManager.urlopen\u001b[0;34m(self, method, url, redirect, **kw)\u001b[0m\n\u001b[1;32m 374\u001b[0m response \u001b[38;5;241m=\u001b[39m conn\u001b[38;5;241m.\u001b[39murlopen(method, url, \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39mkw)\n\u001b[1;32m 375\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 376\u001b[0m response \u001b[38;5;241m=\u001b[39m \u001b[43mconn\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mu\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mrequest_uri\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mkw\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 378\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n\u001b[1;32m 379\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m redirect_location:\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:815\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 810\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;129;01mnot\u001b[39;00m conn:\n\u001b[1;32m 811\u001b[0m \u001b[38;5;66;03m# Try again\u001b[39;00m\n\u001b[1;32m 812\u001b[0m log\u001b[38;5;241m.\u001b[39mwarning(\n\u001b[1;32m 813\u001b[0m \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mRetrying (\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m) after connection broken by \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m: \u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, retries, err, url\n\u001b[1;32m 814\u001b[0m )\n\u001b[0;32m--> 815\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43murlopen\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 816\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 817\u001b[0m \u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 818\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 819\u001b[0m \u001b[43m \u001b[49m\u001b[43mheaders\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 820\u001b[0m \u001b[43m \u001b[49m\u001b[43mretries\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 821\u001b[0m \u001b[43m \u001b[49m\u001b[43mredirect\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 822\u001b[0m \u001b[43m \u001b[49m\u001b[43massert_same_host\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 823\u001b[0m \u001b[43m \u001b[49m\u001b[43mtimeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mtimeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 824\u001b[0m \u001b[43m \u001b[49m\u001b[43mpool_timeout\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpool_timeout\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 825\u001b[0m \u001b[43m \u001b[49m\u001b[43mrelease_conn\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mrelease_conn\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 826\u001b[0m \u001b[43m \u001b[49m\u001b[43mchunked\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mchunked\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 827\u001b[0m \u001b[43m \u001b[49m\u001b[43mbody_pos\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbody_pos\u001b[49m\u001b[43m,\u001b[49m\n\u001b[1;32m 828\u001b[0m \u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43mresponse_kw\u001b[49m\n\u001b[1;32m 829\u001b[0m \u001b[43m \u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 831\u001b[0m \u001b[38;5;66;03m# Handle redirect?\u001b[39;00m\n\u001b[1;32m 832\u001b[0m redirect_location \u001b[38;5;241m=\u001b[39m redirect \u001b[38;5;129;01mand\u001b[39;00m response\u001b[38;5;241m.\u001b[39mget_redirect_location()\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/connectionpool.py:787\u001b[0m, in \u001b[0;36mHTTPConnectionPool.urlopen\u001b[0;34m(self, method, url, body, headers, retries, redirect, assert_same_host, timeout, pool_timeout, release_conn, chunked, body_pos, **response_kw)\u001b[0m\n\u001b[1;32m 784\u001b[0m \u001b[38;5;28;01melif\u001b[39;00m \u001b[38;5;28misinstance\u001b[39m(e, (SocketError, HTTPException)):\n\u001b[1;32m 785\u001b[0m e \u001b[38;5;241m=\u001b[39m ProtocolError(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mConnection aborted.\u001b[39m\u001b[38;5;124m\"\u001b[39m, e)\n\u001b[0;32m--> 787\u001b[0m retries \u001b[38;5;241m=\u001b[39m \u001b[43mretries\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mincrement\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m 788\u001b[0m \u001b[43m \u001b[49m\u001b[43mmethod\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43murl\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43merror\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43me\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_pool\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43m_stacktrace\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43msys\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mexc_info\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m]\u001b[49m\n\u001b[1;32m 789\u001b[0m \u001b[43m\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m 790\u001b[0m retries\u001b[38;5;241m.\u001b[39msleep()\n\u001b[1;32m 792\u001b[0m \u001b[38;5;66;03m# Keep track of the error for the retry warning.\u001b[39;00m\n", - "File \u001b[0;32m~/.conda/envs/etx4velo/lib/python3.10/site-packages/urllib3/util/retry.py:592\u001b[0m, in \u001b[0;36mRetry.increment\u001b[0;34m(self, method, url, response, error, _pool, _stacktrace)\u001b[0m\n\u001b[1;32m 581\u001b[0m new_retry \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mnew(\n\u001b[1;32m 582\u001b[0m total\u001b[38;5;241m=\u001b[39mtotal,\n\u001b[1;32m 583\u001b[0m connect\u001b[38;5;241m=\u001b[39mconnect,\n\u001b[0;32m (...)\u001b[0m\n\u001b[1;32m 588\u001b[0m history\u001b[38;5;241m=\u001b[39mhistory,\n\u001b[1;32m 589\u001b[0m )\n\u001b[1;32m 591\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m new_retry\u001b[38;5;241m.\u001b[39mis_exhausted():\n\u001b[0;32m--> 592\u001b[0m \u001b[38;5;28;01mraise\u001b[39;00m MaxRetryError(_pool, url, error \u001b[38;5;129;01mor\u001b[39;00m ResponseError(cause))\n\u001b[1;32m 594\u001b[0m log\u001b[38;5;241m.\u001b[39mdebug(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mIncremented Retry for (url=\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;132;01m%s\u001b[39;00m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m): \u001b[39m\u001b[38;5;132;01m%r\u001b[39;00m\u001b[38;5;124m\"\u001b[39m, url, new_retry)\n\u001b[1;32m 596\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m new_retry\n", - "\u001b[0;31mMaxRetryError\u001b[0m: HTTPConnectionPool(host='localhost', port=44379): Max retries exceeded with url: /session/216aa782-d1d1-47dc-a868-fc064e41882a/window/maximize (Caused by NewConnectionError('<urllib3.connection.HTTPConnection object at 0x7f17707cc610>: Failed to establish a new connection: [Errno 111] Connection refused'))" - ] - } - ], + "outputs": [], "source": [ - "perfplot.plot_edge_performance(gnn_model, CONFIG)" + "from GNN.gnn_plots import plot_best_performances_score_cut\n", + "\n", + "_, _, performances_for_various_score_cuts = plot_best_performances_score_cut(\n", + " model=gnn_model,\n", + " path_or_config=CONFIG,\n", + " partition=\"velo-sim10b-nospillover\",\n", + " score_cuts=[0.4, 0.5, 0.6, 0.65, 0.7, 0.75, 0.8, 0.85, 0.9, 0.95],\n", + " n_events=50,\n", + " seed=0,\n", + ")" ] }, { @@ -3480,121 +821,9 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:--------------------- Step 4: Scoring graph edges using GNN ---------------------\n", - "INFO:---------------------------- a) Loading trained model ----------------------------\n", - "INFO:Load model from artifacts/gnn/velo-minbias-sim10b-xdigi-nospillover/version_1/checkpoints/epoch=39-step=3600.ckpt.\n", - "INFO:----------------------------- b) Running inferencing -----------------------------\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/train to scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/train\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "449ae081348b45a59a036f585ca77680", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/torch/utils/checkpoint.py:31: UserWarning: None of the inputs have requires_grad=True. Gradients will be None\n", - " warnings.warn(\"None of the inputs have requires_grad=True. Gradients will be None\")\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/val to scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/val\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "6e567db527404b2a83b5b499fc689a4e", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover to scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-minbias-sim10b-xdigi-nospillover\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ff680ea179ef4a1b8b8b072845a5bd7d", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons to scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "e7ee06f3f6184534b5aae4042ecd0871", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/metric_learning_processed/test/velo-bu2kstee-sim10aU1-xdigi to scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-bu2kstee-sim10aU1-xdigi\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "ba8bcf65fb34438d87e387a86a102f00", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "run_gnn_inference(CONFIG, checkpoint=gnn_artifact_path)" ] @@ -3609,116 +838,9 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:----------- Step 5: Building track candidates from the scored graph -----------\n", - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/train to scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/train\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "f3df351acebe4264bf81a772a4c7b574", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/val to scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/val\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "0135fe4bb33f45a9b7e7f362d666ca50", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-minbias-sim10b-xdigi-nospillover to scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/test/velo-minbias-sim10b-xdigi-nospillover\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "df38b26086f845898e414e3d4d0f8e88", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons to scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/test/velo-minbias-sim10b-xdigi-nospillover-only-long-electrons\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "c24b1b46a4cb46238d3fa9abc99c5b1f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Inference from scratch/velo-minbias-sim10b-xdigi-nospillover/gnn_processed/test/velo-bu2kstee-sim10aU1-xdigi to scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/test/velo-bu2kstee-sim10aU1-xdigi\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "30e83bcf22014b19adc6645e161e1f70", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "build_track_candidates(CONFIG)" ] @@ -3733,179 +855,11 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": null, "metadata": { "scrolled": true }, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:------------------------------ Evaluation for train ------------------------------\n", - "INFO:1) Load dataframe of tracks, hits-particles and particles\n", - "INFO:Load tracks in scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/train.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "14aa74c4b1da48fd9bf10285f32623dd", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Load truncated paths for train in scratch/velo-minbias-sim10b-xdigi-nospillover/processed/splitting.json\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "d5dbfb0591f145c0b15c901a6abbf014", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "257aa0e2d3fd43cbb4cc0536bfbfe626", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/90 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:2) Matching\n", - "INFO:3) Evaluation\n", - "INFO:Report was saved in scratch/output/report-2023.05.25-11.31.53-train.txt\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TrackChecker output : 565/ 36219 1.56% ghosts\n", - "01_velo : 17906/ 19310 92.73% ( 92.84%), 172 ( 0.95%) clones, pur 99.48%, hit eff 94.77%\n", - "02_long : 10614/ 11198 94.78% ( 94.87%), 102 ( 0.95%) clones, pur 99.53%, hit eff 95.59%\n", - "03_long_P>5GeV : 6973/ 7280 95.78% ( 95.85%), 74 ( 1.05%) clones, pur 99.58%, hit eff 96.15%\n", - "04_long_strange : 506/ 587 86.20% ( 87.39%), 5 ( 0.98%) clones, pur 99.18%, hit eff 92.27%\n", - "05_long_strange_P>5GeV : 252/ 288 87.50% ( 90.52%), 4 ( 1.56%) clones, pur 99.12%, hit eff 94.42%\n", - "06_long_fromB : 7/ 7 100.00% (100.00%), 0 ( 0.00%) clones, pur 98.90%, hit eff 97.07%\n", - "07_long_fromB_P>5GeV : 7/ 7 100.00% (100.00%), 0 ( 0.00%) clones, pur 98.90%, hit eff 97.07%\n", - "08_long_electrons : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "09_long_fromB_electrons : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "10_long_fromB_electrons_P>5GeV : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "\n", - "*** Benchmark score: 93.76\n", - "\n", - "| Categories | Efficiency | Average efficiency | % clones | Average hit purity | Average hit efficiency |\n", - "|:---------------------|:-------------|:---------------------|:-----------|:---------------------|:-------------------------|\n", - "| Velo | 92.73% | 92.84% | 0.95% | 99.48% | 94.77% |\n", - "| Long | 94.78% | 94.87% | 0.95% | 99.53% | 95.59% |\n", - "| Velo, no electrons | 92.73% | 92.84% | 0.95% | 99.48% | 94.77% |\n", - "| Velo, only electrons | nan% | nan% | nan% | nan% | nan% |\n", - "| Long, only electrons | nan% | nan% | nan% | nan% | nan% |\n", - "| Categories | # ghosts | # tracks | % ghosts |\n", - "|:-------------|-----------:|:-----------|:-----------|\n", - "| Everything | 565 | 36,219 | 1.56% |\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Plot for category velo_reconstructible_acceptance saved in scratch/output/hist1d_velo_reconstructible_acceptance-train.pdf\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "INFO:Plot for category long_reconstructible_acceptance_only_electrons saved in scratch/output/hist1d_long_reconstructible_acceptance_only_electrons-train.pdf\n" - ] - }, - { - "data": { - "text/plain": [ - "<montetracko.evaluation.trackevaluator.TrackEvaluator at 0x7f1732aeb4c0>" - ] - }, - "execution_count": 41, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "evaluate_candidates_montetracko(\n", " CONFIG,\n", @@ -3917,183 +871,16 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:------------------------------- Evaluation for val -------------------------------\n", - "INFO:1) Load dataframe of tracks, hits-particles and particles\n", - "INFO:Load tracks in scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/val.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b1240f1f9c504f2fac37b0e19abc9464", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Load truncated paths for val in scratch/velo-minbias-sim10b-xdigi-nospillover/processed/splitting.json\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "b77595105f8d4c7ab31cebeef9720d2f", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "30a5e820dfb74e04b3ff56bd93549f08", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/10 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:2) Matching\n", - "INFO:3) Evaluation\n", - "INFO:Report was saved in scratch/output/report-2023.05.25-11.32.09-val.txt\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TrackChecker output : 65/ 4029 1.61% ghosts\n", - "01_velo : 1968/ 2109 93.31% ( 93.40%), 19 ( 0.96%) clones, pur 99.24%, hit eff 94.52%\n", - "02_long : 1154/ 1215 94.98% ( 94.97%), 13 ( 1.11%) clones, pur 99.21%, hit eff 95.07%\n", - "03_long_P>5GeV : 783/ 814 96.19% ( 96.26%), 8 ( 1.01%) clones, pur 99.14%, hit eff 96.06%\n", - "04_long_strange : 48/ 59 81.36% ( 82.20%), 0 ( 0.00%) clones, pur 98.70%, hit eff 93.93%\n", - "05_long_strange_P>5GeV : 29/ 33 87.88% ( 78.00%), 0 ( 0.00%) clones, pur 98.24%, hit eff 96.42%\n", - "06_long_fromB : 15/ 18 83.33% ( 83.76%), 1 ( 6.25%) clones, pur 96.98%, hit eff 92.97%\n", - "07_long_fromB_P>5GeV : 12/ 14 85.71% ( 93.33%), 1 ( 7.69%) clones, pur 96.28%, hit eff 91.35%\n", - "08_long_electrons : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "09_long_fromB_electrons : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "10_long_fromB_electrons_P>5GeV : 0/ 0 nan% ( nan%), 0 ( nan%) clones, pur nan%, hit eff nan%\n", - "\n", - "*** Benchmark score: 94.06\n", - "\n", - "| Categories | Efficiency | Average efficiency | % clones | Average hit purity | Average hit efficiency |\n", - "|:---------------------|:-------------|:---------------------|:-----------|:---------------------|:-------------------------|\n", - "| Velo | 93.31% | 93.40% | 0.96% | 99.24% | 94.52% |\n", - "| Long | 94.98% | 94.97% | 1.11% | 99.21% | 95.07% |\n", - "| Velo, no electrons | 93.31% | 93.40% | 0.96% | 99.24% | 94.52% |\n", - "| Velo, only electrons | nan% | nan% | nan% | nan% | nan% |\n", - "| Long, only electrons | nan% | nan% | nan% | nan% | nan% |\n", - "| Categories | # ghosts | # tracks | % ghosts |\n", - "|:-------------|-----------:|:-----------|:-----------|\n", - "| Everything | 65 | 4,029 | 1.61% |\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Plot for category velo_reconstructible_acceptance saved in scratch/output/hist1d_velo_reconstructible_acceptance-val.pdf\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "/home/fgias/.conda/envs/etx4velo/lib/python3.10/site-packages/matplotlib/axes/_base.py:2503: UserWarning: Warning: converting a masked element to nan.\n", - " xys = np.asarray(xys)\n", - "INFO:Plot for category long_reconstructible_acceptance_only_electrons saved in scratch/output/hist1d_long_reconstructible_acceptance_only_electrons-val.pdf\n" - ] - }, - { - "data": { - "text/plain": [ - "<montetracko.evaluation.trackevaluator.TrackEvaluator at 0x7f173112f940>" - ] - }, - "execution_count": 42, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "evaluate_candidates_montetracko(\n", " CONFIG,\n", " partition=\"val\",\n", " allen_report=True,\n", " table_report=True,\n", + " plot_categories=[],\n", ")\n" ] }, @@ -4107,153 +894,41 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:-------------- Evaluation for velo-minbias-sim10b-xdigi-nospillover --------------\n", - "INFO:1) Load dataframe of tracks, hits-particles and particles\n", - "INFO:Load tracks in scratch/velo-minbias-sim10b-xdigi-nospillover/track_building_processed/test/velo-minbias-sim10b-xdigi-nospillover.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "9c1699093f91492a9b6b7998c785ea36", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Load pre-processed test datasets in scratch/__test__/velo-minbias-sim10b-xdigi-nospillover.\n" - ] - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "fc500dcde87a441487da86e729696e7b", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "application/vnd.jupyter.widget-view+json": { - "model_id": "75aae0fd7a4544bf91a5c4ebb7ff8d63", - "version_major": 2, - "version_minor": 0 - }, - "text/plain": [ - " 0%| | 0/1000 [00:00<?, ?it/s]" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:2) Matching\n", - "INFO:3) Evaluation\n", - "INFO:Report was saved in scratch/output/report-2023.05.25-11.32.50-velo-minbias-sim10b-xdigi-nospillover.txt\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "TrackChecker output : 7868/ 208626 3.77% ghosts\n", - "01_velo : 93076/ 100530 92.59% ( 93.62%), 954 ( 1.01%) clones, pur 99.16%, hit eff 94.86%\n", - "02_long : 54220/ 57018 95.09% ( 95.97%), 513 ( 0.94%) clones, pur 99.29%, hit eff 95.82%\n", - "03_long_P>5GeV : 35149/ 36528 96.22% ( 96.98%), 293 ( 0.83%) clones, pur 99.33%, hit eff 96.64%\n", - "04_long_strange : 2535/ 2969 85.38% ( 86.67%), 35 ( 1.36%) clones, pur 98.55%, hit eff 91.16%\n", - "05_long_strange_P>5GeV : 1241/ 1426 87.03% ( 87.77%), 12 ( 0.96%) clones, pur 98.53%, hit eff 93.32%\n", - "06_long_fromB : 79/ 85 92.94% ( 92.27%), 1 ( 1.25%) clones, pur 99.21%, hit eff 95.09%\n", - "07_long_fromB_P>5GeV : 56/ 59 94.92% ( 95.28%), 0 ( 0.00%) clones, pur 99.07%, hit eff 96.30%\n", - "08_long_electrons : 2738/ 4141 66.12% ( 68.61%), 39 ( 1.40%) clones, pur 96.10%, hit eff 81.16%\n", - "09_long_fromB_electrons : 8/ 9 88.89% ( 85.71%), 0 ( 0.00%) clones, pur 100.00%, hit eff 83.93%\n", - "10_long_fromB_electrons_P>5GeV : 6/ 7 85.71% ( 80.00%), 0 ( 0.00%) clones, pur 100.00%, hit eff 82.74%\n", - "\n", - "*** Benchmark score: 91.21\n", - "\n", - "| Categories | Efficiency | Average efficiency | % clones | Average hit purity | Average hit efficiency |\n", - "|:---------------------|:-------------|:---------------------|:-----------|:---------------------|:-------------------------|\n", - "| Velo | 87.25% | 88.64% | 1.27% | 98.87% | 92.77% |\n", - "| Long | 93.13% | 94.13% | 0.96% | 99.13% | 95.11% |\n", - "| Velo, no electrons | 92.59% | 93.62% | 1.01% | 99.16% | 94.86% |\n", - "| Velo, only electrons | 60.21% | 62.33% | 3.25% | 96.67% | 76.81% |\n", - "| Long, only electrons | 66.12% | 68.61% | 1.40% | 96.10% | 81.16% |\n", - "| Categories | # ghosts | # tracks | % ghosts |\n", - "|:-------------|:-----------|:-----------|:-----------|\n", - "| Everything | 7,868 | 208,626 | 3.77% |\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:Plot for category velo_reconstructible_acceptance saved in scratch/output/hist1d_velo_reconstructible_acceptance-velo-minbias-sim10b-xdigi-nospillover.pdf\n", - "INFO:Plot for category long_reconstructible_acceptance_only_electrons saved in scratch/output/hist1d_long_reconstructible_acceptance_only_electrons-velo-minbias-sim10b-xdigi-nospillover.pdf\n" - ] - }, - { - "data": { - "text/plain": [ - "<montetracko.evaluation.trackevaluator.TrackEvaluator at 0x7f173119c940>" - ] - }, - "execution_count": 43, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "<Figure size 3200x2400 with 32 Axes>" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ - "evaluate_candidates_montetracko(\n", + "for test_dataset_name in get_required_test_dataset_names(CONFIG):\n", + " logging.info(headline(test_dataset_name))\n", + " evaluate_candidates_montetracko(\n", + " CONFIG,\n", + " partition=test_dataset_name,\n", + " allen_report=True,\n", + " table_report=True,\n", + " plot_categories=[],\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "trackEvaluator = evaluate_candidates_montetracko(\n", " CONFIG,\n", - " partition=\"velo-minbias-sim10b-xdigi-nospillover\",\n", + " partition=\"velo-sim10b-nospillover\",\n", " allen_report=True,\n", " table_report=True,\n", - ")\n" + ")" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -4272,7 +947,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.10.11" + "version": "3.10.10" }, "vscode": { "interpreter": { diff --git a/LHCb_Pipeline/pipeline_config_default.yaml b/LHCb_Pipeline/pipeline_config_default.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a6c437c07f411b3fa97c0c6f92a4ae5e7d713a9d --- /dev/null +++ b/LHCb_Pipeline/pipeline_config_default.yaml @@ -0,0 +1,122 @@ +common: + experiment_name: example + data_directory: /scratch/acorreia/data # where the data are saved + artifact_directory: artifacts # where the checkpoints are saved + performance_directory: output # where the plots and reports are saved + gpus: 1 + # Name of the test datasets to use (defined in `test_samples.yaml`) + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + # Can be + # - Integer: Last subdirectory that can be used (starting from `0`). `-1` for all. + # - String or list of strings: sub-directories that can be used + # - `null`: use `input_dir` directly + # - Dictionary with keys `start` and `stop` + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection # Selection function, defined in `Preprocessing/selecting.py` + n_events: null # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 # Minimal number of genuine hits + # Columns to keep in the dataframes of hits-particles and particles + # (excluding `event`, `particle_id` and `lhcbid`) + # `null` means keep everything + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 # Number of processes in parallel in the processing stage + features: ["r", "phi", "z", "plane"] # Name of the features to use + feature_means: [18., 0.0, 281.0, 7.5] # Means for normalising the features + feature_scales: [9.75, 1.82, 287.0, 12.5] # Scales for normalising the features + # List of the columns to keep in the PyTorch batches, in the dataframe of hits + kept_hits_columns: ["plane", {"un_z": "z"}] + # List of columns in the dataframe of particles that are merged to the dataframe + # of hits and stored in the PyTorch batches + kept_particles_columns: ["nhits_velo"] + n_train_events: 100 # Number of training events + n_val_events: 100 # Number of validation events + split_seed: 0 # Seed used for the splitting train-val + # How the true edges are computed + # - sortwise: sort by z + # - modulewise: sort by distance to production vertex + # - planewise: hits belonging to same particle and belonging to adjacent planes + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 # Number of hidden units / layer in the MPL + nb_layer: 4 # Number of layers + emb_dim: 4 # Embedding dimension + activation: Tanh # Action function used in the MLP + weight: 2 # Weight for positive examples + randomisation: 2 # Number of random pairs per hit + points_per_batch: 100000 # Number of query points to consider + r: 0.015 # Maximum distance for hard-mining + r_inference: 0.020 # Maximum distance for inference + knn: 50 # Maximal number of neighbours during training and inference + warmup: 8 # Start with small increasing learning rate for `warmup` epochs + margin: 0.1 # Loss for negative examples is max(0.1**2 - d²) + # Multiply the initial learning rate by ``factor`` every ``patience`` epochs + lr: 0.001 + factor: 0.7 + patience: 4 + # Available regimes + # - rp: random pairs + # - hnm: hard negative mining + # - norm: perform L2 normalisation + regime: [rp, hnm, norm] + bidir: true # Whether to use a bi-directional graph + max_epochs: 30 + + filtering: edges_at_least_3_hits + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 # Edge cut for validation + + # Model parameters + feature_indices: 4 + hidden: 256 # Number of hidden units per layer in the node encoder + # Number of layers in each MLP of the GNN + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 # = `nb_node_layers` if not specified + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 # = `nb_edge_layers` if not specified + nb_edge_classifier_layers: 6 # = `nb_edge_layers` if not specified + layernorm: True # Whether to use layer normalisation + aggregation: sum_max # Message-passing aggregation + hidden_activation: SiLU # hidden activation function + weight: 0.25 # if focal loss, `alpha`. Otherwise, weight of positive samples + warmup: 10 # Start with small increasing learning rate for `warmup` epochs + lr: 0.0002 # initial learning rate + # Multiply the learning rate by ``factor`` every ``patience`` epochs + factor: 0.7 + patience: 8 + # Existing regimes + # - weighting: use `edge_weights` as weights + # - pid: any edge belonging to the same particle is considered as a true edge + # - triplet: use the loss for triplets, with penalty term + regime: [pid] + max_epochs: 50 # Number of training epochs + gradient_clip_val: 0.5 # Gradient clipping value. Avoid exploiding gradients. + focal_loss: false # Whether to use the focal loss + bidir: true # whether to use a bi-directional graph + +track_building: + score_cut: 0.7 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/edges-slope.yaml b/LHCb_Pipeline/pipeline_configs/edges-slope.yaml new file mode 100644 index 0000000000000000000000000000000000000000..e20862145aa55985947f006ca8469bd0863877b9 --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/edges-slope.yaml @@ -0,0 +1,96 @@ +common: + experiment_name: edges-slope + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: track_weighting_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 1500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 3 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 6 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + # weight: 2 + warmup: 10 + lr: 0.002 + factor: 0.7 + patience: 8 + truth_key: pid_signal + regime: [pid] + max_epochs: 200 + gradient_clip_val: 0.5 + +track_building: + score_cut: 0.95 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/focal-loss-pid-2gnns.yaml b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-2gnns.yaml new file mode 100644 index 0000000000000000000000000000000000000000..2813b94c79171630cfca9c032afdcacf1f4f10a2 --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-2gnns.yaml @@ -0,0 +1,136 @@ +common: + experiment_name: focal-loss-pid-2gnns + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes", "nhits_velo"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.0002 + factor: 0.7 + patience: 8 + regime: ["pid"] + max_epochs: 50 + gradient_clip_val: 0.5 + focal_loss: true + +edge_filtering: + score_cut: 0.2 + input_subdirectory: "gnn_processed" + output_subdirectory: "edge_filtering" + +gnn2: + # Dataset parameters + input_subdirectory: "edge_filtering" + output_subdirectory: "gnn2_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.001 + factor: 0.7 + patience: 8 + regime: ["pid"] + max_epochs: 50 + gradient_clip_val: 0.5 + focal_loss: true + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_building" + +track_building: + score_cut: 0.7 + # input_subdirectory: "gnn_processed" + input_subdirectory: "gnn2_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/focal-loss-pid-bidir.yaml b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-bidir.yaml new file mode 100644 index 0000000000000000000000000000000000000000..a752568d5aef95e5d429cf3f2b0573353f255678 --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-bidir.yaml @@ -0,0 +1,102 @@ +common: + experiment_name: focal-loss-pid-bidir + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes", "nhits_velo"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: True + shuffle_edge_direction: True + + # Model parameters + feature_indices: 4 # mmh I'm actually using the plane number, which is not deliberate + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.0002 + factor: 0.7 + patience: 8 + regime: ["pid"] + max_epochs: 50 + gradient_clip_val: 0.5 + focal_loss: true + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_building" + +track_building: + score_cut: 0.75 + # input_subdirectory: "gnn_processed" + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/focal-loss-pid-fixed.yaml b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-fixed.yaml new file mode 100644 index 0000000000000000000000000000000000000000..20cdef02a0838282c026619c4c3dd50a89546aaf --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/focal-loss-pid-fixed.yaml @@ -0,0 +1,101 @@ +common: + experiment_name: focal-loss-pid-fixed + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes", "nhits_velo"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # mmh I'm actually using the plane number, which is not deliberate + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.0002 + factor: 0.7 + patience: 8 + regime: ["pid"] + max_epochs: 50 + gradient_clip_val: 0.5 + focal_loss: true + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_building" + +track_building: + score_cut: 0.73 + # input_subdirectory: "gnn_processed" + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/focal-loss-pid.yaml b/LHCb_Pipeline/pipeline_configs/focal-loss-pid.yaml new file mode 100644 index 0000000000000000000000000000000000000000..043a6e732f3616862f9196b495b01dbdaa157729 --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/focal-loss-pid.yaml @@ -0,0 +1,104 @@ +common: + experiment_name: focal-loss-pid + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes", "nhits_velo"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + # Building + building: null + filtering: "edges_at_least_3_hits" + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # mmh I'm actually using the plane number, which is not deliberate + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.0002 + factor: 0.7 + patience: 8 + regime: ["pid"] + max_epochs: 31 + gradient_clip_val: 0.5 + focal_loss: true + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_building" + +track_building: + score_cut: 0.73 + # input_subdirectory: "gnn_processed" + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/focal-loss.yaml b/LHCb_Pipeline/pipeline_configs/focal-loss.yaml new file mode 100644 index 0000000000000000000000000000000000000000..311a3c5bcff25da64cec57158b61eea03e2658dc --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/focal-loss.yaml @@ -0,0 +1,100 @@ +common: + experiment_name: focal-loss + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: track_weighting_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + weight: 0.25 + warmup: 10 + lr: 0.0002 + factor: 0.7 + patience: 8 + regime: [] + max_epochs: 50 + gradient_clip_val: 0.5 + focal_loss: true + +# triplet_building: +# input_subdirectory: "gnn_processed" +# output_subdirectory: "triplet_processed" + +track_building: + score_cut: 0.5 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/track-edges.yaml b/LHCb_Pipeline/pipeline_configs/track-edges.yaml new file mode 100644 index 0000000000000000000000000000000000000000..06db0d87a155a122b413c4057303def592e04a6a --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/track-edges.yaml @@ -0,0 +1,100 @@ +common: + experiment_name: track-edges + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: track_weighting_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 1500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", "z"] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 4 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + # weight: 2 + warmup: 10 + lr: 0.002 + factor: 0.7 + patience: 8 + truth_key: pid_signal + regime: [] + max_epochs: 200 + gradient_clip_val: 0.5 + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_processed" + +track_building: + score_cut: 0.95 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/track-weighting.yaml b/LHCb_Pipeline/pipeline_configs/track-weighting.yaml new file mode 100644 index 0000000000000000000000000000000000000000..c8cbae47f5795cc7a56afdf27402f8a1bcc08e8a --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/track-weighting.yaml @@ -0,0 +1,96 @@ +common: + experiment_name: track-weighting + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: track_weighting_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 1500 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", "z"] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + + +gnn: + # Dataset parameters + input_subdirectory: "metric_learning_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + + # Model parameters + feature_indices: 3 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 10 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + # weight: 2 + warmup: 10 + lr: 0.002 + factor: 0.7 + patience: 8 + truth_key: pid_signal + regime: [pid] + max_epochs: 200 + gradient_clip_val: 0.5 + +track_building: + score_cut: 0.95 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_configs/triplets-first.yaml b/LHCb_Pipeline/pipeline_configs/triplets-first.yaml new file mode 100644 index 0000000000000000000000000000000000000000..242207b207c1d7cf7911a79e743b91985f2abda8 --- /dev/null +++ b/LHCb_Pipeline/pipeline_configs/triplets-first.yaml @@ -0,0 +1,102 @@ +common: + experiment_name: triplets-first + data_directory: /scratch/acorreia/data + artifact_directory: artifacts + performance_directory: output # plots and reports + gpus: 1 + test_dataset_names: + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + +preprocessing: + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover + subdirs: 10 + output_subdirectory: "preprocessed" + selection: triplets_first_selection + n_events: 11000 # if `null`, default to `n_train_events + n_test_events` + num_true_hits_threshold: 1000 + hits_particles_columns: ["x", "y", "z", "plane"] + particles_columns: null + +processing: + input_subdirectory: "preprocessed" + output_subdirectory: "processed" + n_workers: 32 + features: ["r", "phi", "z", "plane"] + feature_means: [18., 0.0, 281.0, 7.5] + feature_scales: [9.75, 1.82, 287.0, 12.5] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 10000 + n_val_events: 500 + split_seed: 0 + true_edges_column: planewise + +metric_learning: + # Dataset parameters + input_subdirectory: "processed" + output_subdirectory: "metric_learning_processed" + + # Model parameters + feature_indices: 4 + emb_hidden: 256 + nb_layer: 6 + emb_dim: 4 + activation: Tanh + weight: 2 + randomisation: 2 + points_per_batch: 100000 + r: 0.015 + r_inference: 0.020 + knn: 50 + warmup: 8 + margin: 0.1 + lr: 0.001 + factor: 0.7 + patience: 10 + regime: [rp, hnm, norm] + bidir: False + max_epochs: 20 + +triplet_building: + input_subdirectory: "metric_learning_processed" + output_subdirectory: "triplet_processed" + +gnn: + # Dataset parameters + input_subdirectory: "triplet_processed" + output_subdirectory: "gnn_processed" + edge_cut: 0.5 + noise: True + bidir: False + n_train_events: 5000 + + # Model parameters + feature_indices: 3 # just r, phi, z here + hidden: 256 + n_graph_iters: 8 + nb_node_layers: 6 + nb_node_encoder_layers: 6 + nb_edge_layers: 6 + nb_edge_encoder_layers: 6 + nb_edge_classifier_layers: 6 + layernorm: True + aggregation: sum_max + hidden_activation: SiLU + # weight: 2 + warmup: 10 + lr: 0.002 + factor: 0.7 + patience: 8 + truth_key: pid_signal + regime: [pid, triplet] + pos_penality: 0.01 + neg_penality: 0.01 + max_epochs: 50 + # gradient_clip_val: 0.5 + +track_building: + score_cut: 0.95 + input_subdirectory: "gnn_processed" + output_subdirectory: "track_building_processed" diff --git a/LHCb_Pipeline/pipeline_config.yaml b/LHCb_Pipeline/pipeline_configs/velo-sim10b-nospillover-lot.yaml similarity index 51% rename from LHCb_Pipeline/pipeline_config.yaml rename to LHCb_Pipeline/pipeline_configs/velo-sim10b-nospillover-lot.yaml index 76dbc0bed2273153e2b99ef13feed583cc88978c..d272fc50b8c1c4e913a529a68da16a3104fdd503 100644 --- a/LHCb_Pipeline/pipeline_config.yaml +++ b/LHCb_Pipeline/pipeline_configs/velo-sim10b-nospillover-lot.yaml @@ -1,59 +1,60 @@ common: - experiment_name: velo-minbias-sim10b-xdigi-nospillover - data_directory: scratch + experiment_name: velo-sim10b-nospillover-lot + data_directory: /scratch/acorreia/data artifact_directory: artifacts - performance_directory: scratch/output # plots and reports + performance_directory: output # plots and reports gpus: 1 test_dataset_names: - - velo-minbias-sim10b-xdigi-nospillover - - velo-minbias-sim10b-xdigi-nospillover-only-long-electrons - - velo-bu2kstee-sim10aU1-xdigi + - velo-sim10b-nospillover + - velo-sim10b-nospillover-only-long-electrons + # - bu2kstee-sim10aU1-xdigi + # - smog2-xdigi preprocessing: - input_dir: scratch/datasets/minbias-sim10b-xdigi-nospillover/0 + input_dir: /scratch/acorreia/minbias-sim10b-xdigi-nospillover/0 output_subdirectory: "preprocessed" - selection: everything_but_electrons + selection: default_old_training_for_rta_presentation n_events: null # if `null`, default to `n_train_events + n_test_events` - num_true_hits_threshold: 2500 + num_true_hits_threshold: 0 processing: input_subdirectory: "preprocessed" output_subdirectory: "processed" n_workers: 32 - features: ["r", "phi", "z", "plane"] - feature_means: [0., 0., 0., 0.] - feature_scales: [50, 3.14159, 200, 26] - kept_hits_columns: ["plane"] - kept_particles_columns: [] - n_train_events: 90 - n_val_events: 10 + features: ["r", "phi", "z"] + feature_means: [18., 0., 281.] + feature_scales: [9.75, 1.82, 287] + kept_hits_columns: ["plane", {"un_x": "x"}, {"un_y": "y"}, {"un_z": "z"}] + kept_particles_columns: ["n_unique_planes"] + n_train_events: 1000 + n_val_events: 1000 split_seed: 0 + true_edges_column: sortedwise metric_learning: # Dataset parameters input_subdirectory: "processed" output_subdirectory: "metric_learning_processed" - true_edges_column: modulewise_true_edges # Model parameters - feature_indices: 4 + feature_indices: 3 emb_hidden: 256 nb_layer: 4 - emb_dim: 4 + emb_dim: 3 activation: Tanh weight: 2 randomisation: 2 points_per_batch: 100000 - r: 0.035 - r_inference: 0.035 + r: 0.015 + r_inference: 0.015 knn: 50 warmup: 8 margin: 0.1 lr: 0.001 factor: 0.7 - patience: 4 + patience: 10 regime: [rp, hnm, norm] - max_epochs: 20 + max_epochs: 40 gnn: # Dataset parameters @@ -63,11 +64,14 @@ gnn: noise: True # Model parameters - feature_indices: 4 # indices in `batch.x`. If `null`, everything is taken. - hidden: 512 - n_graph_iters: 8 - nb_node_layer: 3 - nb_edge_layer: 6 + feature_indices: 3 + hidden: 256 + n_graph_iters: 12 + nb_node_layers: 4 + nb_node_encoder_layers: 4 + nb_edge_layers: 4 + nb_edge_encoder_layers: 4 + nb_edge_classifier_layers: 4 layernorm: True aggregation: sum_max hidden_activation: SiLU @@ -78,10 +82,13 @@ gnn: patience: 8 truth_key: pid_signal regime: [pid] - mask_background: True - max_epochs: 40 + max_epochs: 200 track_building: score_cut: 0.9 input_subdirectory: "gnn_processed" output_subdirectory: "track_building_processed" + +triplet_building: + input_subdirectory: "gnn_processed" + output_subdirectory: "triplet_processed" diff --git a/LHCb_Pipeline/test_samples.yaml b/LHCb_Pipeline/test_samples.yaml index 7e085267dfe8fb54119b7e8606cc8e882f88bacd..b76aeb12dc4fea9c89b8f6bba0f3ef7dd6f9ec58 100644 --- a/LHCb_Pipeline/test_samples.yaml +++ b/LHCb_Pipeline/test_samples.yaml @@ -1,17 +1,33 @@ -velo-minbias-sim10b-xdigi-nospillover: - input_dir: scratch/datasets/minbias-sim10b-xdigi-nospillover/102 +velo-sim10b-nospillover: + input_dir: /scratch/acorreia/data_validation/minbias-sim10b-xdigi-nospillover/500 selection: null n_events: 1000 - num_true_hits_threshold: 0 + num_true_hits_threshold: null -velo-minbias-sim10b-xdigi-nospillover-only-long-electrons: - input_dir: scratch/datasets/minbias-sim10b-xdigi-nospillover/102 +velo-sim10b-nospillover-only-long-electrons: + input_dir: /scratch/acorreia/data_validation/minbias-sim10b-xdigi-nospillover/500 selection: only_long_electrons n_events: 1000 - num_true_hits_threshold: 0 + num_true_hits_threshold: null -velo-bu2kstee-sim10aU1-xdigi: - input_dir: scratch/datasets/bu2kstee-sim10aU1-xdigi/198 +bu2kstee-sim10aU1-xdigi: + input_dir: /scratch/acorreia/data_validation/bu2kstee-sim10aU1-xdigi/500 selection: null n_events: 1000 - num_true_hits_threshold: 0 \ No newline at end of file + num_true_hits_threshold: null + +smog2-xdigi: + input_dir: + - /scratch/acorreia/data_validation/smog2-digi/432 + - /scratch/acorreia/data_validation/smog2-digi/433 + - /scratch/acorreia/data_validation/smog2-digi/434 + - /scratch/acorreia/data_validation/smog2-digi/435 + - /scratch/acorreia/data_validation/smog2-digi/436 + - /scratch/acorreia/data_validation/smog2-digi/437 + - /scratch/acorreia/data_validation/smog2-digi/438 + - /scratch/acorreia/data_validation/smog2-digi/439 + - /scratch/acorreia/data_validation/smog2-digi/440 + - /scratch/acorreia/data_validation/smog2-digi/441 + n_events: -1 + num_true_hits_threshold: null + new_event_id_per_file: True diff --git a/LHCb_Pipeline/utils/commonutils/config.py b/LHCb_Pipeline/utils/commonutils/config.py index 1b984a1be53bf0ec44cb0f26e00db59602b4ece8..48a77e28217db76a5f0470c2596e77752d75ad21 100644 --- a/LHCb_Pipeline/utils/commonutils/config.py +++ b/LHCb_Pipeline/utils/commonutils/config.py @@ -3,15 +3,15 @@ import os.path as op import yaml -#: List of the steps in the right order. -STEPS = [ - "preprocessing", - "processing", - "metric_learning", - "gnn", - "track_building", - "evaluation", -] +# #: List of the steps in the right order. +# STEPS = [ +# "preprocessing", +# "processing", +# "metric_learning", +# "gnn", +# "track_building", +# "evaluation", +# ] def get_data_experiment_directory(path_or_config: str | dict) -> str: @@ -42,18 +42,17 @@ def resolve_config_paths( """ if data_experiment_dir is None: data_experiment_dir = get_data_experiment_directory(configs) - for step in STEPS: - if step in configs: - for inoutput in ["input", "output"]: - if f"{inoutput}_subdirectory" in configs[step]: - assert f"{inoutput}_dir" not in configs[step], ( - f"`{inoutput}_subdirectory` and `{inoutput}_dir` as both " - f"the configuration of {step}, which might create a clash." - ) - configs[step][f"{inoutput}_dir"] = op.join( - data_experiment_dir, - configs[step].pop(f"{inoutput}_subdirectory"), - ) + for step in configs: + for inoutput in ["input", "output"]: + if f"{inoutput}_subdirectory" in configs[step]: + assert f"{inoutput}_dir" not in configs[step], ( + f"`{inoutput}_subdirectory` and `{inoutput}_dir` as both " + f"the configuration of {step}, which might create a clash." + ) + configs[step][f"{inoutput}_dir"] = op.join( + data_experiment_dir, + configs[step].pop(f"{inoutput}_subdirectory"), + ) def load_config(path_or_config: str | dict, resolve: bool = True) -> dict: diff --git a/LHCb_Pipeline/utils/commonutils/crun.py b/LHCb_Pipeline/utils/commonutils/crun.py index 74d3bf31b656c7ca1b3d2eeebcb8b3c79e8e485c..672ee1e877cd110e613702fc164303beb567ca7c 100644 --- a/LHCb_Pipeline/utils/commonutils/crun.py +++ b/LHCb_Pipeline/utils/commonutils/crun.py @@ -1,5 +1,6 @@ import typing import os +import logging class InOutFunction(typing.Protocol): @@ -16,6 +17,7 @@ def run_for_different_partitions( partitions: typing.List[str] = ["train", "val", "test"], test_dataset_names: typing.List[str] | None = None, reproduce: bool = True, + list_kwargs: typing.List[dict] | None = None, **kwargs, ): """Run a function for different dataset "partitions". @@ -37,12 +39,22 @@ def run_for_different_partitions( directory. **kwargs: keyword arguments passed to ``func`` """ - for partition in partitions: + for partition_idx, partition in enumerate(partitions): + if list_kwargs is None: + supplementary_kwargs = {} + else: + supplementary_kwargs = list_kwargs[partition_idx] + logging.info( + f"Use the following parameters for {partition}: {supplementary_kwargs}" + ) + if partition in ["train", "val"]: func( input_dir=os.path.join(input_dir, partition), output_dir=os.path.join(output_dir, partition), reproduce=reproduce, + **supplementary_kwargs, + **kwargs, ) elif partition == "test": @@ -55,6 +67,7 @@ def run_for_different_partitions( input_dir=os.path.join(input_dir, "test", test_dataset_name), output_dir=os.path.join(output_dir, "test", test_dataset_name), reproduce=reproduce, + **supplementary_kwargs, **kwargs, ) elif (test_dataset_names is not None) and (partition in test_dataset_names): @@ -62,6 +75,7 @@ def run_for_different_partitions( input_dir=os.path.join(input_dir, "test", partition), output_dir=os.path.join(output_dir, "test", partition), reproduce=reproduce, + **supplementary_kwargs, **kwargs, ) else: diff --git a/LHCb_Pipeline/utils/graphutils/__init__.py b/LHCb_Pipeline/utils/graphutils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..1f1811ab81152ec0f34dd59cb94647359b037eb0 --- /dev/null +++ b/LHCb_Pipeline/utils/graphutils/__init__.py @@ -0,0 +1,2 @@ +"""A package that defines common utilies to handle graphs in PyTorch geometric. +""" diff --git a/LHCb_Pipeline/utils/graphutils/edgeutils.py b/LHCb_Pipeline/utils/graphutils/edgeutils.py new file mode 100644 index 0000000000000000000000000000000000000000..8a91c70e53571c9c396a29f703eb3ec5d4b06bb5 --- /dev/null +++ b/LHCb_Pipeline/utils/graphutils/edgeutils.py @@ -0,0 +1,15 @@ +"""A module that defines utilities to handle edges exclusively. +""" +import torch + + +def sort_edge_nodes(edges: torch.Tensor, ordering_tensor: torch.Tensor) -> None: + """Sort the nodes of the edges in ascending value of a certain tensor + + Args: + edges: Two-dimensional array of edges, with shape :math:`\\left(2, n_edges)`` + ordering_tensor: Tensor of values for the nodes. The first node of an edge + is required to have a lower value that the second node. + """ + not_correctly_ordered_mask = ordering_tensor[edges[0]] > ordering_tensor[edges[1]] + edges[:, not_correctly_ordered_mask] = edges[:, not_correctly_ordered_mask].flip(0) diff --git a/LHCb_Pipeline/utils/modelutils/basemodel.py b/LHCb_Pipeline/utils/modelutils/basemodel.py index ed7770272216fb66ba0b0a0faeeb13a4c9c3270b..027e39acb8eac64687029c1a1ab030ab12926894 100644 --- a/LHCb_Pipeline/utils/modelutils/basemodel.py +++ b/LHCb_Pipeline/utils/modelutils/basemodel.py @@ -1,9 +1,13 @@ """Define a base model for GNN and Embedding, to avoid copy of functions. """ +from __future__ import annotations import typing +import logging import os import os.path as op +from tqdm.auto import tqdm +import numpy as np import torch from pytorch_lightning import LightningModule from torch_geometric.data import Data @@ -15,14 +19,38 @@ from utils.commonutils.cfeatures import get_input_features class ModelBase(LightningModule): def __init__(self, hparams): super().__init__() - + self._trainset = None + self._valset = None + self.testset = None self.save_hyperparameters(hparams) def setup(self, stage): - self.trainset = self.load_datasets(op.join(self.hparams["input_dir"], "train")) - self.valset = self.load_datasets(op.join(self.hparams["input_dir"], "val")) + self.load_partition("train") + self.load_partition("val") self.testset = None + @property + def trainset(self) -> typing.List[Data]: + if self._trainset is None: + self.load_partition(partition="train") + assert self._trainset is not None + return self._trainset + + @trainset.setter + def trainset(self, batches: typing.List[Data]): + self._trainset = batches + + @property + def valset(self) -> typing.List[Data]: + if self._valset is None: + self.load_partition(partition="val") + assert self._valset is not None + return self._valset + + @valset.setter + def valset(self, batches: typing.List[Data]): + self._valset = batches + def train_dataloader(self): if len(self.trainset) > 0: return DataLoader(self.trainset, batch_size=1, num_workers=16) @@ -41,25 +69,58 @@ class ModelBase(LightningModule): else: return None - def load_datasets(self, input_dir: str) -> typing.List[Data]: - """Load""" + def fetch_datasets( + self, + input_dir: str, + n_events: int | None = None, + shuffle: bool = False, + seed: int | None = None, + **kwargs, + ) -> typing.List[Data]: + """Get the datasets located in a given directory. + + Args: + input_dir: input directory + n_events: number of events to load + shuffle: whether to shuffle the input paths (applied before + selected the first ``n_events``) + seed: seed for the shuffling + **kwargs: Other keyword arguments passed to + :py:func:`ModelBase.fetch_dataset` + + Returns: + List of loaded PyTorch Geometric Data objects + """ all_input_paths = [ entry.path for entry in os.scandir(input_dir) if entry.is_file() ] + if shuffle: + rng = np.random.default_rng(seed=seed) + rng.shuffle(all_input_paths) + + if n_events is not None: + all_input_paths = all_input_paths[:n_events] + + logging.info(f"Load {len(all_input_paths)} files located in {input_dir}") return [ - self.load_dataset(input_path=input_path) for input_path in all_input_paths + self.fetch_dataset(input_path=input_path, **kwargs) + for input_path in tqdm(all_input_paths) ] - def load_dataset(self, input_path: str) -> Data: + def fetch_dataset( + self, input_path: str, map_location: str = "cpu", **kwargs + ) -> Data: """Load and process one PyTorch DataSet. Args: input_path: path to the PyTorch dataset + map_location: location where to load the dataset + **kwargs: Other keyword arguments passed to :py:func:`torch.load` Returns: Load PyTorch data object """ - return torch.load(input_path, map_location=torch.device("cpu")) + return torch.load(input_path, map_location=map_location, **kwargs) def load_testset_from_directory(self, input_dir: str): """Load a test dataset from a path to a directory. @@ -68,17 +129,79 @@ class ModelBase(LightningModule): input_dir: path to the directory that contains the PyTorch Geometric Data pickles files. """ - self.testset = self.load_datasets(input_dir=input_dir) + self.testset = self.fetch_datasets(input_dir=input_dir) - def load_testset(self, test_dataset_name: str): - """Load the test dataset into this model from its name. + def fetch_partition( + self, + partition: str, + n_events: int | None = None, + shuffle: bool = False, + seed: int | None = None, + **kwargs, + ) -> typing.List[Data]: + """Load a partition. Args: - test_dataset_name: name of the test dataset + partition: ``train``, ``val`` or name of the test dataset + n_events: number of events to load for this partition + shuffle: whether to shuffle the input paths (applied before + selected the first ``n_events``) + seed: seed for the shuffling + **kwargs: Other keyword arguments passed to + :py:func:`ModelBase.fetch_dataset` """ - self.load_testset_from_directory( - input_dir=op.join(self.hparams["input_dir"], "test", test_dataset_name) + if partition in ["train", "val"]: + datasets = self.fetch_datasets( + op.join(self.hparams["input_dir"], partition), + n_events=( + self.hparams.get(f"n_{partition}_events") + if n_events is None + else n_events + ), + shuffle=shuffle, + seed=seed, + **kwargs, + ) + + else: + datasets = self.fetch_datasets( + input_dir=op.join(self.hparams["input_dir"], "test", partition), + n_events=n_events, + shuffle=shuffle, + seed=seed, + **kwargs, + ) + + return datasets + + def load_partition( + self, + partition: str, + n_events: int | None = None, + shuffle: bool = False, + seed: int | None = None, + ) -> typing.List[Data]: + """Load datasets of a partition. + + Args: + partition: ``train``, ``val`` or name of the test dataset + n_events: number of events to load for this partition + shuffle: whether to shuffle the input paths (applied before + selected the first ``n_events``) + seed: seed for the shuffling + """ + datasets = self.fetch_partition( + partition=partition, + n_events=n_events, + shuffle=shuffle, + seed=seed, ) + if partition == "train": + self._trainset = datasets + elif partition == "val": + self._valset = datasets + else: + self.testset = datasets def get_input_data(self, batch: Data) -> torch.Tensor: return get_input_features( @@ -107,3 +230,46 @@ class ModelBase(LightningModule): } ] return optimizer, scheduler + + @classmethod + def get_model_from_checkpoint( + cls, + checkpoint: LightningModule | str | None, + default_checkpoint: str | None = None, + **kwargs, + ): + """Helper function to get a model at inference step. + + Args: + checkpoint: the model already loaded, or path to it + Mode: Model class + default_checkpoint: path to fall back to if ``checkpoint`` is None. + **kwargs: other parameters passed to :py:func:`Model.load_from_checkpoint` + + Return: + Loaded model + """ + if isinstance(checkpoint, cls): + model = checkpoint + elif checkpoint is None: # Default loading mode from last artifact + assert ( + default_checkpoint is not None + ), "Both `checkpoint` and `default_checkpoint` are None." + checkpoint = default_checkpoint + model = cls.load_from_checkpoint( + default_checkpoint, + **kwargs, + ) + logging.info(f"Load model from {checkpoint}.") + elif isinstance(checkpoint, str): + model = cls.load_from_checkpoint( + checkpoint_path=checkpoint, + **kwargs, + ) + logging.info(f"Load model from {checkpoint}.") + else: + raise TypeError( + f"Type of checkpoint is {type(checkpoint).__name__} " + "which is not recognised" + ) + return model diff --git a/LHCb_Pipeline/utils/modelutils/batches.py b/LHCb_Pipeline/utils/modelutils/batches.py new file mode 100644 index 0000000000000000000000000000000000000000..8c43e7cca4b46f7e3f08f88e57fef049b2cfc613 --- /dev/null +++ b/LHCb_Pipeline/utils/modelutils/batches.py @@ -0,0 +1,62 @@ +"""A module used to handle list of batches stored in model. +""" +from __future__ import annotations +import typing +import numpy as np +from torch_geometric.data import Data +from .basemodel import ModelBase + + +def get_batches(model: ModelBase, partition: str) -> typing.List[Data]: + """Get the list batches for the given model. + + Args: + model: PyTorch model inheriting from :py:class:`ModelBase` + partition: ``train``, ``val``, ``test`` (for the current already loaded + test sample) or the name of a test dataset + + Returns: + List of PyTorch Geometric data objects + + Notes: + The input directories are saved as hyperparameters in the model. This is why + it is possible to get the data input directories from a model. + """ + # Use correct batches + if partition == "train": + batches = model.trainset + elif partition == "val": + batches = model.valset + elif partition == "test": + batches = model.testset + else: + model.load_testset(test_dataset_name=partition) + batches = model.testset + + assert ( + batches is not None + ), "Error, list of batches is `None`: no batches were loaded" + return batches + + +def select_subset( + batches: typing.List[Data], n_events: int | None = None, seed: int | None = None +) -> typing.List[Data]: + """Randomly select a subset of batches. + + Args: + batches: overall list of batches + n_events: Maximal number of events to select + seed: Seed for reproducible randomness + + Returns: + List of PyTorch Data objects + """ + if n_events is not None: + n_events = int(n_events) + if n_events < len(batches): + # Randomly select a subset of ``n_events`` events + rng = np.random.default_rng(seed=seed) + indices = rng.choice(len(batches), n_events, replace=False) + batches = [batches[idx] for idx in indices] + return batches diff --git a/LHCb_Pipeline/utils/modelutils/build.py b/LHCb_Pipeline/utils/modelutils/build.py index 710ea92825ed1a01627753ab32af0e69173df083..6fc1d779bfd009e6b6216b56a7ef2537976b9851 100644 --- a/LHCb_Pipeline/utils/modelutils/build.py +++ b/LHCb_Pipeline/utils/modelutils/build.py @@ -1,45 +1,154 @@ """Define the base class to infer on data. """ import typing +from types import ModuleType import abc import os import logging +from functools import partial from tqdm.auto import tqdm +from tqdm.contrib.concurrent import process_map import torch from pytorch_lightning import LightningModule from torch_geometric.data import Data -from utils.tools.tfiles import delete_directory +from utils.tools.tfiles import delete_directory, is_directory_not_empty class BuilderBase(abc.ABC): + """Base class for looping over input files located in a directory, processing + them and saving the output in a different directory. + """ + def __init__(self) -> None: pass - def infer(self, input_dir: str, output_dir: str, reproduce: bool = True): + def infer( + self, + input_dir: str, + output_dir: str, + reproduce: bool = True, + filtering: str | None = None, + building: str | None = None, + file_names: typing.List[str] | None = None, + parallel: bool = False, + ): """Load the torch datasets located in ``input_dir``, run the model inference and save the output in ``output_dir``. + + Args: + input_dir: input directory path + output_dir: output directory path + reproduce: whether to delete the output directory if it exists, + and run again the inference + filtering: name of the function that filters the event. This would only + be applied to the train and val sets. + building: name of the function that compute columns for the event. This + would be applied to all the samples (train, val and test samples). + file_names: list of file names to run the inference on. If not specified, + the inference is run on all the datasets located in the input directory. + parallel: + Whether to run the inference in parallel. This seems quite unstable... """ # List paths to the input files - file_names = os.listdir(input_dir) + if file_names is None: + file_names = os.listdir(input_dir) assert len(file_names) > 0, f"No input files in {input_dir}" if reproduce: delete_directory(output_dir) os.makedirs(output_dir, exist_ok=True) - logging.info(f"Inference from {input_dir} to {output_dir}") + if is_directory_not_empty(output_dir): + logging.info( + f"Output folder is not empty so the inference was not run: {output_dir}" + ) + else: + logging.info(f"Inference from {input_dir} to {output_dir}") + + with torch.no_grad(): + infer_one_step_partial = partial( + self.infer_one_step, + input_dir=input_dir, + output_dir=output_dir, + building=building, + filtering=filtering, + ) + if parallel: + process_map(infer_one_step_partial, file_names, chunksize=1) + else: + for file_name in tqdm(file_names): + infer_one_step_partial(file_name=file_name) + + def infer_one_step( + self, + file_name: str, + input_dir: str, + output_dir: str, + filtering: str | typing.List[str] | None = None, + building: str | typing.List[str] | None = None, + ): + """Run the inference on a single file and save the output in another file. + + Args: + file_name: input file name + input_dir: input directory path + output_dir: output directory path + filtering: name of the function that filters the event. This would only + be applied to the train and val sets. + building: name of the function that compute columns for the event. This + would be applied to all the samples (train, val and test samples). + """ + input_path = os.path.join(input_dir, file_name) + if not os.path.exists(os.path.join(output_dir, file_name)): + batch = self.load_batch(input_path) + batch = self.process_one_step( + batch=batch, + filtering=filtering, + building=building, + ) + self.save_downstream(batch, os.path.join(output_dir, batch.event_str)) - with torch.no_grad(): - for file_name in tqdm(file_names): - input_path = os.path.join(input_dir, file_name) - if not os.path.exists(os.path.join(output_dir, file_name)): - batch = self.load_batch(input_path) - self.construct_downstream(batch) - self.save_downstream( - batch, os.path.join(output_dir, batch.event_str) + def process_one_step( + self, + batch: Data, + filtering: str | typing.List[str] | None = None, + building: str | typing.List[str] | None = None, + ) -> Data: + """Process one event. + + Args: + batch: event stored in a PyTorch Geometric data object + filtering: name of the function that filters the event. This would only + be applied to the train and val sets. + building: name of the function that compute columns for the event. This + would be applied to all the samples (train, val and test samples). + + Returns: + Processed event, first by :py:func:`BuilderBase.construct_downstream`, + then by the filtering and building functions provided as inputs. + """ + batch = self.construct_downstream(batch) + + # Apply filtering and building + for processing_step in [filtering, building]: + if processing_step is not None: + processing_fct_names = ( + [processing_step] + if isinstance(processing_step, str) + else processing_step + ) + for processing_fct_name in processing_fct_names: + processing_fct = getattr( + self._get_building_custom_module(), str(processing_fct_name) ) + batch = processing_fct(batch) + return batch + + def _get_building_custom_module(self) -> ModuleType: + """Return the module where the building and filtering functions are.""" + raise NotImplementedError() def load_batch(self, input_path: str) -> Data: """Load a PyTorch Data object from its path. @@ -47,6 +156,33 @@ class BuilderBase(abc.ABC): """ return torch.load(input_path, map_location=torch.device("cpu")) + def filter_batch(self, batch: Data) -> Data: + """Filter the batch. This should only performed in the train and val + sets. + + Args: + batch: PyTorch Data Geometric object + + Returns: + filtered batch + """ + return batch + + def build_weights(self, batch: Data) -> Data: + """Builder weights in the batch for training. + This should only be needed in the train and val sets. + + Args: + batch: PyTorch Data Geometric object + + Returns: + filtered batch + """ + return batch + + def build_features(self, batch: Data) -> Data: + return batch + @abc.abstractmethod def construct_downstream(self, batch: Data): """Run the inference on a PyTorch Data. In-place.""" @@ -59,6 +195,8 @@ class BuilderBase(abc.ABC): class ModelBuilderBase(BuilderBase): + """Base class for model inference.""" + def __init__(self, model: LightningModule) -> None: self.model = model model.eval() diff --git a/LHCb_Pipeline/utils/modelutils/checkpoint_utils.py b/LHCb_Pipeline/utils/modelutils/checkpoint_utils.py index b8b442a713ed51adb6fadc453d3d607e3b69a86c..2ccfabfa087ad569e0941f0ba83615056f1a8c95 100644 --- a/LHCb_Pipeline/utils/modelutils/checkpoint_utils.py +++ b/LHCb_Pipeline/utils/modelutils/checkpoint_utils.py @@ -30,7 +30,7 @@ def get_last_version_dir(experiment_dir: str) -> str: for version_folder_path in version_folder_paths ] if not available_versions: - raise ValueError(f"No version with `metrics.csv` found in {experiment_dir}.") + raise ValueError(f"No version with `metrics.csv` found in {experiment_dir}") last_version = sorted(available_versions)[-1] return os.path.join(os.path.join(experiment_dir, f"version_{last_version}")) @@ -114,13 +114,12 @@ def get_last_version_dir_from_config( return get_last_version_dir(experiment_dir=experiment_dir) - -def get_training_metrics(trainer: Trainer | str) -> pd.DataFrame: +def get_training_metrics(trainer: Trainer | str | typing.List[str]) -> pd.DataFrame: """Get the dataframe of the training metrics. Args: - trainer: either a PyTorch Lighting Trainer object, or the path to the metric - file to load directly. + trainer: either a PyTorch Lighting Trainer object, or the path(s) to the metric + file(s) to load directly. Returns: Dataframe of the training metrics (one row / epoch). @@ -133,17 +132,34 @@ def get_training_metrics(trainer: Trainer | str) -> pd.DataFrame: log_file = os.path.join(log_dir, "metrics.csv") elif isinstance(trainer, str): log_file = trainer + elif isinstance(trainer, (list, tuple)): + return pd.concat( + (get_training_metrics(trainer=log_file) for log_file in trainer), + axis=0, + ) else: raise TypeError( - f"`trainer` should be str or a pytorch trainer, but is " + f"`trainer` should be str, a list of str or a pytorch trainer, but is " + type(trainer).__name__ ) metrics = pd.read_csv(log_file, sep=",") - train_metrics = metrics[~metrics["train_loss"].isna()][["epoch", "train_loss"]] - train_metrics["epoch"] -= 1 - val_metrics = metrics[~metrics["val_loss"].isna()][ - ["val_loss", "eff", "pur", "current_lr", "epoch"] + + train_loss_column = "train_loss" if "train_loss" in metrics else "train_loss_epoch" + val_loss_column = "val_loss" if "val_loss" in metrics else "val_loss_epoch" + + train_metrics = metrics[~metrics[train_loss_column].isna()][ + ["epoch", train_loss_column] + ] + # train_metrics["epoch"] -= 1 + val_metrics = metrics[~metrics[val_loss_column].isna()][ + [ + column if column in metrics else column + "_epoch" + for column in ["val_loss", "eff", "pur", "current_lr", "epoch"] + ] ] metrics = pd.merge(left=train_metrics, right=val_metrics, how="inner", on="epoch") + for column in metrics.columns: + if column.endswith("_epoch"): + metrics.rename(columns={column: column[: -len("_epoch")]}, inplace=True) return metrics diff --git a/LHCb_Pipeline/utils/modelutils/evaluation.py b/LHCb_Pipeline/utils/modelutils/evaluation.py new file mode 100644 index 0000000000000000000000000000000000000000..a9445a06c96ceb2d57084cf3c0e163f8d42215d9 --- /dev/null +++ b/LHCb_Pipeline/utils/modelutils/evaluation.py @@ -0,0 +1,246 @@ +"""A module that defines :py:class:`ParamExplorer`, a class that allows to vary +a parameter and check the efficiency that is obtained for this choice. +""" +import typing +import abc +import os.path as op + +from tqdm.auto import tqdm +import numpy as np +import numpy.typing as npt +import pandas as pd +from torch_geometric.data import Data +import montetracko as mt +import montetracko.lhcb as mtb +import matplotlib.pyplot as plt +from matplotlib.figure import Figure + +from Scripts.Step_6_Evaluate_Reconstruction_MonteTracko import ( + load_parquet_files, + perform_matching, +) +from utils.plotutils.plotools import save_fig +from utils.commonutils.cpaths import get_performance_directory +from .basemodel import ModelBase + + +class ParamExplorer(abc.ABC): + """A class that allow to explore the track matching performance for various choices + of a given parameter of a trained model (e.g., best efficiency as a function + of the maximal radius of the kNN) + """ + + def __init__( + self, model: ModelBase, varname: str, varlabel: str | None = None + ) -> None: + self.model = model + self.varname = str(varname) + self.varlabel = str(varlabel) if varlabel is not None else self.varname + + def load_preprocessed_dataframes( + self, + batches: typing.List[Data], + ) -> typing.Tuple[pd.DataFrame, pd.DataFrame]: + """Load the preprocessed dataframes of hits-particles and particles associated + with the PyTorch DataSets given as input. + + Args: + batches: list of PyTorch Geometric Data objects + + Returns: + Tuple of dataframes of hits-particles and particles + """ + truncated_paths = [batch.truncated_path for batch in batches] + df_hits_particles = load_parquet_files( + truncated_paths=truncated_paths, + ending="-hits_particles", + columns=["particle_id", "hit_id"], + ) + df_particles = load_parquet_files( + truncated_paths=truncated_paths, + ending="-particles", + columns=["particle_id", "has_velo", "has_scifi", "pid", "eta"], + ) + return df_hits_particles, df_particles + + def compute_performance_metrics( + self, + values: typing.Sequence[float], + partition: str, + metric_names: typing.List[str], + categories: typing.List[mt.requirement.Category], + n_events: int | None = None, + seed: int | None = None, + **kwargs, + ) -> typing.Dict[float, typing.Dict[typing.Tuple[str, str], float]]: + """Compute the performance metrics for different values a hyperparameter. + + Args: + values: list of values for the hyperparameter of interest + partition: ``train``, ``val`` or the name of a test dataset + n_events: Maximal number of events for the evaluation + seed: Random seed for randomly selecting ``n_events`` + metric_names: List of metric names to compute + categories: list of categories to compute the performance in. + + Returns: + 3-tuple of the Matplotlib Figure and Axes, and the dictionary of + metric values for every tuple ``(value, category.name, metric_name)`` + """ + # Load PyTorch Geometric Data objects + batches = self.model.fetch_partition( + partition=partition, + n_events=n_events, + shuffle=True, + seed=seed, + map_location=self.model.device, + ) + + # Move batches to save device as model + # batches = [batch.to(model.device) for batch in batches] # type: ignore + + # Load associated pre-processed files that contains information + # used for matching + df_hits_particles, df_particles = self.load_preprocessed_dataframes( + batches=batches + ) + + dict_performance = {} + for value in (pbar := tqdm(values)): + pbar.set_description(f"Loop over {self.varname} (current value: {value})") + df_tracks = self.get_tracks(value=value, batches=batches, **kwargs) + dict_performance[value] = self.get_performance_from_tracks( + df_tracks=df_tracks, + df_hits_particles=df_hits_particles, + df_particles=df_particles, + metric_names=metric_names, + categories=categories, + ) + return dict_performance + + def get_performance_from_tracks( + self, + df_tracks: pd.DataFrame, + df_hits_particles: pd.DataFrame, + df_particles: pd.DataFrame, + metric_names: typing.List[str], + categories: typing.List[mt.requirement.Category], + ) -> typing.Dict[typing.Tuple[str, str], float]: + """Get performance dictionary for given tracks. + + Args: + df_tracks: dataframe of tracks + df_hits_particles: dataframe of hits-particles + df_particles: dataframe of particles + metric_names: List of metric names to compute + categories: list of categories to compute the performance in. + + Returns: + Dictionary that associates the 2-tuple ``(category.name, metric_name)`` + with the metric value for the given category + """ + trackEvaluator = perform_matching( + df_tracks=df_tracks, + df_hits_particles=df_hits_particles, + df_particles=df_particles, + ) + return { + (category.name, metric_name): trackEvaluator.compute_metric( + metric_name=metric_name, + category=category, + ) + for category in categories + for metric_name in metric_names + } + + @abc.abstractmethod + def get_tracks( + self, value: float, batches: typing.List[Data], **kwargs + ) -> pd.DataFrame: + """Get the dataframe of tracks""" + raise NotImplementedError() + + def plot( + self, + path_or_config: str | dict, + partition: str, + values: typing.Sequence[float], + n_events: int | None = None, + seed: int | None = None, + metric_names: typing.List[str] | None = None, + categories: typing.List[mt.requirement.Category] | None = None, + identifier: str | None = None, + **kwargs, + ) -> typing.Tuple[Figure, npt.NDArray, typing.Dict[str, typing.Dict[str, float]]]: + """Plot metrics in differences categories for different hyperparameter + values. + + Args: + path_or_config: pipeline configuration + partition: ``train``, ``val`` or the name of a test dataset + values: list of values for the hyperparameter of interest + n_events: Maximal number of events for the evaluation + seed: Random seed for randomly selecting ``n_events`` + metric_names: List of metric names to compute. If not set, + ``efficiency``, ``clone_rate`` and ``hit_efficiency_per_candidate`` + are computed and plotted. + categories: list of categories to compute the performance in. + By default, this is "Velo Without Electrons" and "Long Electrons". + identifier: Identifier for the figure name + **kwargs: Other keyword arguments passed to + :py:func:`ParamExplorer.compute_performance_metrics` + + Returns: + 3-tuple of the Matplotlib Figure and Axes, and the dictionary of + metric values for every tuple ``(value, category.name, metric_name)`` + """ + if metric_names is None: + metric_names = ["efficiency", "clone_rate", "hit_efficiency_per_candidate"] + if categories is None: + categories = [ + mtb.category.category_velo_no_electrons, + mtb.category.category_long_only_electrons, + ] + if identifier is None: + identifier = "" + + dict_performances = self.compute_performance_metrics( + values=values, + partition=partition, + metric_names=metric_names, + categories=categories, + n_events=n_events, + seed=seed, + **kwargs, + ) + + fig, axes = plt.subplots( + 1, len(metric_names), figsize=(8 * len(metric_names), 6) + ) + axes = np.atleast_1d(axes) + + for metric_idx, metric_name in enumerate(metric_names): + axes[metric_idx].set_xlabel(self.varlabel) + axes[metric_idx].set_ylabel(mt.metricsLibrary.label(metric_name)) + axes[metric_idx].grid(color="grey", alpha=0.5) + for category in categories: + metric_values = [ + dict_performances[value][category.name, metric_name] + for value in values + ] + + axes[metric_idx].plot( + values, metric_values, label=category.label, marker="." + ) + + axes[0].legend() + + performance_dir = get_performance_directory(path_or_config) + save_fig( + fig=fig, + path=op.join( + performance_dir, f"performance_given_{self.varname}{identifier}" + ), + ) + + return (fig, axes, dict_performances) diff --git a/LHCb_Pipeline/utils/modelutils/mpl.py b/LHCb_Pipeline/utils/modelutils/mlp.py similarity index 100% rename from LHCb_Pipeline/utils/modelutils/mpl.py rename to LHCb_Pipeline/utils/modelutils/mlp.py diff --git a/LHCb_Pipeline/utils/plotutils/graph.py b/LHCb_Pipeline/utils/plotutils/graph.py index e89a035cd059bdde9073ba7265503e35897d6ca3..64e1353b1d27879320ca4d64aadf55938f235d2f 100644 --- a/LHCb_Pipeline/utils/plotutils/graph.py +++ b/LHCb_Pipeline/utils/plotutils/graph.py @@ -36,8 +36,9 @@ def plot_true_graph(sample_data, path_or_config: str | dict, num_tracks=100): path_or_config=path_or_config, feature_names=["r", "phi"], ) + x = r * np.cos(phi) + y = r * np.sin(phi) - x, y = r * np.cos(phi * np.pi), r * np.sin(phi * np.pi) cmap = viridis(num_tracks) source = ColumnDataSource(dict(x=x.numpy(), y=y.numpy())) p.circle(x="x", y="y", source=source, color=cmap[0], size=1, alpha=0.1) @@ -93,7 +94,8 @@ def plot_predicted_graph(model, path_or_config: str | dict): path_or_config=path_or_config, feature_names=["r", "phi"], ) - x, y = r * np.cos(phi * np.pi), r * np.sin(phi * np.pi) + x = r * np.cos(phi) + y = r * np.sin(phi) cmap = viridis(11) source = ColumnDataSource(dict(x=x.numpy(), y=y.numpy())) p.circle(x="x", y="y", source=source, color=cmap[0], size=1, alpha=0.1) diff --git a/LHCb_Pipeline/utils/plotutils/performance.py b/LHCb_Pipeline/utils/plotutils/performance.py index a5e099e39de14200936d4446c45376609ee661bd..20c6d54e63a907441ec4e1a873019527695d7e0c 100644 --- a/LHCb_Pipeline/utils/plotutils/performance.py +++ b/LHCb_Pipeline/utils/plotutils/performance.py @@ -216,7 +216,11 @@ def plot_graph_sizes(model): plt.xlabel("Number of edges") -def plot_edge_performance(model, path_or_config: str | dict): +def plot_edge_performance( + model, path_or_config: str | dict, identifier: str | None = None +): + if identifier is None: + identifier = "" all_cuts = np.arange(0.001, 1.0, 0.02) results = {"eff": [], "pur": [], "score cut": all_cuts} model.to(device) @@ -276,7 +280,7 @@ def plot_edge_performance(model, path_or_config: str | dict): # show(row(figures)) filename = op.join( - get_performance_directory(path_or_config), "edge_performance.png" + get_performance_directory(path_or_config), f"edge_performance{identifier}.png" ) export_png(row(figures), filename=filename) display(Image(filename=filename)) diff --git a/LHCb_Pipeline/utils/plotutils/performance_mpl.py b/LHCb_Pipeline/utils/plotutils/performance_mpl.py new file mode 100644 index 0000000000000000000000000000000000000000..b630a9a8c26bc59fa917348dd1600fd2d81a8ede --- /dev/null +++ b/LHCb_Pipeline/utils/plotutils/performance_mpl.py @@ -0,0 +1,113 @@ +"""Plot general performance metrics using matplotlib only. +""" +import typing +import os.path as op + +import matplotlib.pyplot as plt +from matplotlib.figure import Figure +from matplotlib.axes import Axes +from matplotlib.ticker import MaxNLocator +import pandas as pd + +from utils.commonutils.cpaths import get_performance_directory +from .plotools import save_fig +from .plotconfig import partition_to_color, partition_to_label + + +def plot_metric_epochs( + metric_name: str, + metrics: pd.DataFrame, + path_or_config: str | dict | None = None, + name: str | None = None, + metric_label: str | None = None, + ax: Axes | None = None, + marker: str = ".", + **kwargs, +) -> typing.Tuple[Figure | None, Axes]: + """Plot a metric as a function of the epoch number + + Args: + metric_name: name of the metric to plot in the dataframe of ``metrics`` + metrics: dataframe of metric values computed during training. It must contain + the two columns ``train_loss`` and ``val_loss`` + name: Name of the step (e.g., ``gnn``, ``embedding``). If not given, + the plot is not saved. + metric_label: Label of the metric. Used in the y-axis + marker: Marker format used in the plot + ax: Matplotlib Axes to plot on. + **kwargs: Other arguments passed to :py:func:`matplotlib.axes.Axes.plot` + + Returns: + Figure and Axes of the plot + """ + + if ax is None: + fig, ax_ = plt.subplots(figsize=(8, 6)) + else: + fig = None + ax_ = ax + + ax_.plot( + metrics["epoch"], + metrics[metric_name], + marker=marker, + **kwargs, + ) + ax_.set_xlabel("Epoch") + ax_.set_ylabel(metric_name if metric_label is None else metric_label) + ax_.xaxis.set_major_locator(MaxNLocator(integer=True)) + ax_.grid(color="grey", alpha=0.5) + + if name is not None and fig is not None: + assert path_or_config is not None + save_fig( + fig=fig, + path=op.join( + get_performance_directory(path_or_config), + f"{metric_name}_{name}", + ), + ) + + return fig, ax_ + + +def plot_loss( + metrics, path_or_config: str | dict, name: str | None = None +) -> typing.Tuple[Figure, Axes]: + """Plot the training and validation loss on the same plot. + + Args: + metrics: dataframe of metric values computed during training. It must contain + the two columns ``train_loss`` and ``val_loss`` + name: Name of the step (e.g., ``gnn``, ``embedding``). If not given, + the plot is not saved. + + Returns: + Figure and Axes of the plot + """ + fig, ax = plt.subplots(figsize=(8, 6)) + + for partition in ["train", "val"]: + plot_metric_epochs( + metric_name=f"{partition}_loss", + metrics=metrics, + color=partition_to_color[partition], + label=partition_to_label[partition], + ax=ax, + ) + + ax.set_xlabel("Epoch") + ax.set_ylabel("Loss") + ax.legend() + ax.xaxis.set_major_locator(MaxNLocator(integer=True)) + ax.grid(color="grey", alpha=0.5) + + if name is not None: + save_fig( + fig=fig, + path=op.join( + get_performance_directory(path_or_config), + f"loss_{name}", + ), + ) + return fig, ax diff --git a/LHCb_Pipeline/utils/plotutils/plotconfig.py b/LHCb_Pipeline/utils/plotutils/plotconfig.py index 39438b4b08812c18c35161d7c0c85625e26a5700..42ed7d56b935c1cf59eb82a85963557ac119bc28 100644 --- a/LHCb_Pipeline/utils/plotutils/plotconfig.py +++ b/LHCb_Pipeline/utils/plotutils/plotconfig.py @@ -1,22 +1,56 @@ """A module that defines common configurations for the plots. """ - +import numpy as np import matplotlib as mpl +#: Associates a partition name with a color +partition_to_color = { + "train": "blue", + "val": "purple", + "test": "green", +} + +#: Associates a partition name with a label +partition_to_label = { + "train": "Training", + "val": "Validation", + "test": "Test", +} + + #: Associates a column name with its label for the plots column_labels = { "pt": "$p_T$ [MeV/c]", "p": "$p$ [MeV/c]", "eta": r"$\eta$", "vz": r"$ovtxz$ [mm]", + "nhits_velo": "# hits", + "n_repeated_planes": "# skipped plane", + "n_skipped_planes": "# hits in same plane", + "r_squared": "$R^2$", + "distance_to_line": "Distance to line [mm]", + "distance_to_z_axis": "Distance to the $z$-axis [mm]", + "xz_angle": "Angle to $x$-$z$ plane [Degree]", + "yz_angle": "Angle to $y$-$z$ plane [Degree]", } #: Associates a column name with its range for the plots column_ranges = { "pt": (0, 2000), "p": (0, 50000), - "eta": None, + "eta": (2.0, 5.0), "vz": (-200, 700), + "r_squared": (0.0, 0.02), + "distance_to_line": (0.0, 0.05), + "distance_to_z_axis": (0.0, 0.05), + "xz_angle": (0.0, 1.5), + "yz_angle": (0.0, 1.5), +} + +column_bins = { + "n_repeated_planes": np.arange(4) - 0.5, + "n_skipped_planes": np.arange(4) - 0.5, + "nhits_velo": np.arange(3, 19) - 0.5, } diff --git a/LHCb_Pipeline/utils/plotutils/plotools.py b/LHCb_Pipeline/utils/plotutils/plotools.py new file mode 100644 index 0000000000000000000000000000000000000000..fb2008dba844e01394ca33ac5380167ad754fbc8 --- /dev/null +++ b/LHCb_Pipeline/utils/plotutils/plotools.py @@ -0,0 +1,26 @@ +"""Define some global utilies for plots. +""" +import typing +import os +from matplotlib.figure import Figure + + +def save_fig( + fig: Figure, path: str, exts: typing.List[str] = [".pdf", ".png"], **kwargs +): + """Save a figure. + + Args: + fig: Matplotlib figure to save + path: path where to save the figure + + """ + os.makedirs(os.path.dirname(path), exist_ok=True) + fig.tight_layout() + + path_without_ext, _ = os.path.splitext(path) + + for ext in exts: + overall_path = path_without_ext + ext + fig.savefig(path_without_ext + ext, bbox_inches="tight", **kwargs) + print("Figure was saved in", overall_path) diff --git a/Monitoring/gitlab-ci/testing_config.yaml b/Monitoring/gitlab-ci/testing_config.yaml index 11dd476f2ff49bed423418551041193a6d24ed8e..814d4ccb72ac9c83ec56b045ea8c4f8804708c5c 100644 --- a/Monitoring/gitlab-ci/testing_config.yaml +++ b/Monitoring/gitlab-ci/testing_config.yaml @@ -25,12 +25,12 @@ processing: n_train_events: 10 n_val_events: 10 split_seed: 0 + true_edges_column: modulewise metric_learning: # Dataset parameters input_subdirectory: processed output_subdirectory: metric_learning_processed - true_edges_column: modulewise_true_edges # Model parameters feature_indices: 3 # indices in `batch.x`. If `null`, everything is taken. @@ -63,8 +63,8 @@ gnn: feature_indices: 3 # indices in `batch.x`. If `null`, everything is taken. hidden: 128 n_graph_iters: 6 - nb_node_layer: 3 - nb_edge_layer: 3 + nb_node_layers: 3 + nb_edge_layers: 3 layernorm: True aggregation: sum_max hidden_activation: SiLU @@ -75,7 +75,6 @@ gnn: patience: 8 truth_key: pid_signal regime: [pid] - mask_background: True max_epochs: 1 track_building: diff --git a/exploration/check_tracks.ipynb b/exploration/check_tracks.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..879f7aceafddc1666b6b0f3408f18ae47a76c8d5 --- /dev/null +++ b/exploration/check_tracks.ipynb @@ -0,0 +1,2088 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "import os\n", + "from tqdm.auto import tqdm\n", + "import numpy as np\n", + "import pandas as pd\n", + "import torch\n", + "from utils.commonutils.config import load_config\n", + "\n", + "#: Path to the configuration file\n", + "config_path = \"pipeline_configs/velo-sim10b-nospillover-lot.yaml\"\n", + "\n", + "config = load_config(config_path)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "application/vnd.jupyter.widget-view+json": { + "model_id": "9c5ae4ce3390435bb39c16ff2f76df63", + "version_major": 2, + "version_minor": 0 + }, + "text/plain": [ + " 0%| | 0/1000 [00:00<?, ?it/s]" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "input_dir = os.path.join(\n", + " config[\"track_building\"][\"input_dir\"], \"test\", \"velo-sim10b-nospillover\"\n", + ")\n", + "input_paths = [entry.path for entry in os.scandir(input_dir) if entry.is_file]\n", + "\n", + "batches = []\n", + "\n", + "for input_path in tqdm(input_paths):\n", + " batches.append(\n", + " torch.load(input_path, map_location=torch.device(\"cpu\"))\n", + " )\n" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "batch = batches[0]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles = pd.read_parquet(batch.truncated_path + \"-hits_particles.parquet\")\n", + "particles = pd.read_parquet(batch.truncated_path + \"-particles.parquet\")\n", + "\n", + "hits_particles = hits_particles.merge(\n", + " particles[[\"particle_id\", \"nhits_velo\"]],\n", + " on=[\"particle_id\"],\n", + " how=\"left\",\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "edge_indices = batch.edge_index\n", + "\n", + "particle_id_edge_indices = batch.particle_id[edge_indices]\n", + "\n", + "true_edge_mask = particle_id_edge_indices[0] == particle_id_edge_indices[1]\n", + "\n", + "true_edge_indices = edge_indices[:, true_edge_mask]\n", + "true_edge_scores = batch.scores[true_edge_mask]\n", + "true_particle_ids = particle_id_edge_indices[:, true_edge_mask][0]\n", + "fake_edge_indices = edge_indices[:, ~true_edge_mask]\n", + "true_plane_edge_indices = batch.plane[edge_indices][:, true_edge_mask]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_true_edges = pd.DataFrame(\n", + " {\n", + " \"edge_idx_left\": true_edge_indices.numpy().min(axis=0),\n", + " \"edge_idx_right\": true_edge_indices.numpy().max(axis=0),\n", + " \"score\": true_edge_scores.numpy(),\n", + " \"particle_id\": true_particle_ids,\n", + " \"plane_left\": true_plane_edge_indices[0],\n", + " \"plane_right\": true_plane_edge_indices[1],\n", + " }\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_true_edges = df_true_edges.merge(\n", + " particles[[\"particle_id\", \"nhits_velo\"]],\n", + " on=[\"particle_id\"],\n", + " how=\"left\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>edge_idx_left</th>\n", + " <th>edge_idx_right</th>\n", + " <th>score</th>\n", + " <th>particle_id</th>\n", + " <th>plane_left</th>\n", + " <th>plane_right</th>\n", + " <th>nhits_velo</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>385</th>\n", + " <td>279</td>\n", + " <td>298</td>\n", + " <td>0.999993</td>\n", + " <td>1529</td>\n", + " <td>14</td>\n", + " <td>13</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>410</th>\n", + " <td>279</td>\n", + " <td>319</td>\n", + " <td>0.999993</td>\n", + " <td>1529</td>\n", + " <td>15</td>\n", + " <td>13</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>411</th>\n", + " <td>298</td>\n", + " <td>319</td>\n", + " <td>0.999992</td>\n", + " <td>1529</td>\n", + " <td>15</td>\n", + " <td>14</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>434</th>\n", + " <td>298</td>\n", + " <td>339</td>\n", + " <td>0.999886</td>\n", + " <td>1529</td>\n", + " <td>14</td>\n", + " <td>16</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>435</th>\n", + " <td>319</td>\n", + " <td>339</td>\n", + " <td>0.999770</td>\n", + " <td>1529</td>\n", + " <td>15</td>\n", + " <td>16</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>457</th>\n", + " <td>339</td>\n", + " <td>360</td>\n", + " <td>0.999197</td>\n", + " <td>1529</td>\n", + " <td>17</td>\n", + " <td>16</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>477</th>\n", + " <td>339</td>\n", + " <td>372</td>\n", + " <td>0.999621</td>\n", + " <td>1529</td>\n", + " <td>18</td>\n", + " <td>16</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>478</th>\n", + " <td>360</td>\n", + " <td>372</td>\n", + " <td>0.999989</td>\n", + " <td>1529</td>\n", + " <td>18</td>\n", + " <td>17</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>506</th>\n", + " <td>360</td>\n", + " <td>390</td>\n", + " <td>0.999974</td>\n", + " <td>1529</td>\n", + " <td>19</td>\n", + " <td>17</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>507</th>\n", + " <td>372</td>\n", + " <td>390</td>\n", + " <td>0.999976</td>\n", + " <td>1529</td>\n", + " <td>18</td>\n", + " <td>19</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>552</th>\n", + " <td>390</td>\n", + " <td>428</td>\n", + " <td>0.999986</td>\n", + " <td>1529</td>\n", + " <td>19</td>\n", + " <td>20</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>553</th>\n", + " <td>428</td>\n", + " <td>442</td>\n", + " <td>0.999991</td>\n", + " <td>1529</td>\n", + " <td>21</td>\n", + " <td>20</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>571</th>\n", + " <td>442</td>\n", + " <td>463</td>\n", + " <td>0.999987</td>\n", + " <td>1529</td>\n", + " <td>21</td>\n", + " <td>22</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>609</th>\n", + " <td>463</td>\n", + " <td>487</td>\n", + " <td>0.999978</td>\n", + " <td>1529</td>\n", + " <td>22</td>\n", + " <td>23</td>\n", + " <td>14</td>\n", + " </tr>\n", + " <tr>\n", + " <th>655</th>\n", + " <td>487</td>\n", + " <td>553</td>\n", + " <td>0.999557</td>\n", + " <td>1529</td>\n", + " <td>23</td>\n", + " <td>25</td>\n", + " <td>14</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "</div>" + ], + "text/plain": [ + " edge_idx_left edge_idx_right score particle_id plane_left \\\n", + "385 279 298 0.999993 1529 14 \n", + "410 279 319 0.999993 1529 15 \n", + "411 298 319 0.999992 1529 15 \n", + "434 298 339 0.999886 1529 14 \n", + "435 319 339 0.999770 1529 15 \n", + "457 339 360 0.999197 1529 17 \n", + "477 339 372 0.999621 1529 18 \n", + "478 360 372 0.999989 1529 18 \n", + "506 360 390 0.999974 1529 19 \n", + "507 372 390 0.999976 1529 18 \n", + "552 390 428 0.999986 1529 19 \n", + "553 428 442 0.999991 1529 21 \n", + "571 442 463 0.999987 1529 21 \n", + "609 463 487 0.999978 1529 22 \n", + "655 487 553 0.999557 1529 23 \n", + "\n", + " plane_right nhits_velo \n", + "385 13 14 \n", + "410 13 14 \n", + "411 14 14 \n", + "434 16 14 \n", + "435 16 14 \n", + "457 16 14 \n", + "477 16 14 \n", + "478 17 14 \n", + "506 17 14 \n", + "507 19 14 \n", + "552 20 14 \n", + "553 20 14 \n", + "571 22 14 \n", + "609 23 14 \n", + "655 25 14 " + ] + }, + "execution_count": 160, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_true_edges.query(\"particle_id == 1529 and score > 0.999\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "def get_reco_hits(df_edges: pd.DataFrame) -> pd.DataFrame:\n", + " return pd.DataFrame(\n", + " {\n", + " \"hit_idx\": np.concatenate(\n", + " (df_true_edges[\"edge_idx_left\"], df_true_edges[\"edge_idx_right\"])\n", + " ),\n", + " \"particle_id\": np.concatenate(\n", + " (df_true_edges[\"particle_id\"], df_true_edges[\"particle_id\"])\n", + " ),\n", + " }\n", + " ).drop_duplicates()\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "nhits_per_particle = df_true_edges.groupby([\"particle_id\"]).size().rename(\"n_edges\")\n", + "average_score_per_particle = (\n", + " df_true_edges.groupby([\"particle_id\"])[\"score\"].mean().rename(\"avg_score\")\n", + ")\n", + "\n", + "score_cut = 0.9\n", + "\n", + "df_true_edges[\"accepted\"] = df_true_edges[\"score\"] >= score_cut\n", + "n_accepted_edges = (\n", + " df_true_edges.groupby([\"particle_id\"])[\"accepted\"].sum().rename(\"n_accepted\")\n", + ")\n", + "\n", + "n_reco_hits = (\n", + " get_reco_hits(df_true_edges)\n", + " .groupby([\"particle_id\"])[\"hit_idx\"]\n", + " .nunique()\n", + " .rename(\"n_reco_hits\")\n", + ")\n", + "n_reco_accepted_hits = (\n", + " get_reco_hits(df_true_edges.query(f\"score >= {score_cut}\"))\n", + " .groupby([\"particle_id\"])[\"hit_idx\"]\n", + " .nunique()\n", + " .rename(\"n_reco_accepted_hits\")\n", + ")\n", + "\n", + "df_particle_stats = pd.concat(\n", + " (nhits_per_particle, average_score_per_particle, n_accepted_edges, n_reco_hits, n_reco_accepted_hits),\n", + " axis=1,\n", + ").reset_index()\n", + "\n", + "df_particle_stats = df_particle_stats.merge(\n", + " particles[[\"particle_id\", \"nhits_velo\"]],\n", + " how=\"left\",\n", + " on=[\"particle_id\"],\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "df_particle_stats[\"score_efficiency\"] = df_particle_stats[\"n_reco_accepted_hits\"] / df_particle_stats[\"n_reco_hits\"]\n", + "df_particle_stats[\"hit_efficiency\"] = df_particle_stats[\"n_reco_accepted_hits\"] / df_particle_stats[\"nhits_velo\"]\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "nhits_velo\n", + "2 1.000000\n", + "3 0.958333\n", + "4 0.944444\n", + "5 1.000000\n", + "6 0.958333\n", + "7 1.000000\n", + "8 1.000000\n", + "9 1.000000\n", + "10 1.000000\n", + "11 1.000000\n", + "12 1.000000\n", + "13 1.000000\n", + "14 1.000000\n", + "15 1.000000\n", + "17 1.000000\n", + "19 1.000000\n", + "20 0.650000\n", + "Name: hit_efficiency, dtype: float64" + ] + }, + "execution_count": 152, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_particle_stats.groupby(\"nhits_velo\")[\"hit_efficiency\"].mean()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(8, 6 * 2))\n", + "axes[0].bar(\n", + " x=df_particle_stats[\"nhits_velo\"].unique(),\n", + " height=df_particle_stats.groupby(),\n", + " width=1.0,\n", + " fill=False,\n", + " edgecolor=\"blue\",\n", + " \n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "<div>\n", + "<style scoped>\n", + " .dataframe tbody tr th:only-of-type {\n", + " vertical-align: middle;\n", + " }\n", + "\n", + " .dataframe tbody tr th {\n", + " vertical-align: top;\n", + " }\n", + "\n", + " .dataframe thead th {\n", + " text-align: right;\n", + " }\n", + "</style>\n", + "<table border=\"1\" class=\"dataframe\">\n", + " <thead>\n", + " <tr style=\"text-align: right;\">\n", + " <th></th>\n", + " <th>edge_idx_left</th>\n", + " <th>edge_idx_right</th>\n", + " <th>score</th>\n", + " <th>particle_id</th>\n", + " <th>plane_left</th>\n", + " <th>plane_right</th>\n", + " <th>nhits_velo</th>\n", + " <th>n_edges</th>\n", + " <th>avg_score</th>\n", + " <th>accepted</th>\n", + " </tr>\n", + " </thead>\n", + " <tbody>\n", + " <tr>\n", + " <th>0</th>\n", + " <td>8</td>\n", + " <td>48</td>\n", + " <td>0.968121</td>\n", + " <td>805</td>\n", + " <td>0</td>\n", + " <td>2</td>\n", + " <td>3</td>\n", + " <td>3</td>\n", + " <td>0.955308</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>1</th>\n", + " <td>11</td>\n", + " <td>78</td>\n", + " <td>0.999993</td>\n", + " <td>368</td>\n", + " <td>0</td>\n", + " <td>3</td>\n", + " <td>4</td>\n", + " <td>6</td>\n", + " <td>0.999993</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>2</th>\n", + " <td>2</td>\n", + " <td>20</td>\n", + " <td>0.999983</td>\n", + " <td>240</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>6</td>\n", + " <td>14</td>\n", + " <td>0.806738</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>3</th>\n", + " <td>3</td>\n", + " <td>21</td>\n", + " <td>0.999993</td>\n", + " <td>1059</td>\n", + " <td>0</td>\n", + " <td>1</td>\n", + " <td>4</td>\n", + " <td>6</td>\n", + " <td>0.999993</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>4</th>\n", + " <td>5</td>\n", + " <td>22</td>\n", + " <td>0.999775</td>\n", + " <td>245</td>\n", + " <td>1</td>\n", + " <td>0</td>\n", + " <td>4</td>\n", + " <td>6</td>\n", + " <td>0.544625</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>...</th>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " <td>...</td>\n", + " </tr>\n", + " <tr>\n", + " <th>697</th>\n", + " <td>527</td>\n", + " <td>554</td>\n", + " <td>0.999993</td>\n", + " <td>866</td>\n", + " <td>24</td>\n", + " <td>25</td>\n", + " <td>3</td>\n", + " <td>3</td>\n", + " <td>0.999993</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>698</th>\n", + " <td>528</td>\n", + " <td>555</td>\n", + " <td>0.999993</td>\n", + " <td>868</td>\n", + " <td>24</td>\n", + " <td>25</td>\n", + " <td>6</td>\n", + " <td>9</td>\n", + " <td>0.999991</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>699</th>\n", + " <td>531</td>\n", + " <td>556</td>\n", + " <td>0.999969</td>\n", + " <td>642</td>\n", + " <td>24</td>\n", + " <td>25</td>\n", + " <td>20</td>\n", + " <td>17</td>\n", + " <td>0.999379</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>700</th>\n", + " <td>534</td>\n", + " <td>544</td>\n", + " <td>0.979185</td>\n", + " <td>558</td>\n", + " <td>25</td>\n", + " <td>24</td>\n", + " <td>3</td>\n", + " <td>1</td>\n", + " <td>0.979185</td>\n", + " <td>True</td>\n", + " </tr>\n", + " <tr>\n", + " <th>701</th>\n", + " <td>535</td>\n", + " <td>559</td>\n", + " <td>0.999988</td>\n", + " <td>1286</td>\n", + " <td>25</td>\n", + " <td>24</td>\n", + " <td>8</td>\n", + " <td>14</td>\n", + " <td>0.999989</td>\n", + " <td>True</td>\n", + " </tr>\n", + " </tbody>\n", + "</table>\n", + "<p>702 rows × 10 columns</p>\n", + "</div>" + ], + "text/plain": [ + " edge_idx_left edge_idx_right score particle_id plane_left \\\n", + "0 8 48 0.968121 805 0 \n", + "1 11 78 0.999993 368 0 \n", + "2 2 20 0.999983 240 0 \n", + "3 3 21 0.999993 1059 0 \n", + "4 5 22 0.999775 245 1 \n", + ".. ... ... ... ... ... \n", + "697 527 554 0.999993 866 24 \n", + "698 528 555 0.999993 868 24 \n", + "699 531 556 0.999969 642 24 \n", + "700 534 544 0.979185 558 25 \n", + "701 535 559 0.999988 1286 25 \n", + "\n", + " plane_right nhits_velo n_edges avg_score accepted \n", + "0 2 3 3 0.955308 True \n", + "1 3 4 6 0.999993 True \n", + "2 1 6 14 0.806738 True \n", + "3 1 4 6 0.999993 True \n", + "4 0 4 6 0.544625 True \n", + ".. ... ... ... ... ... \n", + "697 25 3 3 0.999993 True \n", + "698 25 6 9 0.999991 True \n", + "699 25 20 17 0.999379 True \n", + "700 24 3 1 0.979185 True \n", + "701 24 8 14 0.999989 True \n", + "\n", + "[702 rows x 10 columns]" + ] + }, + "execution_count": 117, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df_particle_stats.groupby([\"nhits_velo\"])[\"accepted\"]" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Build tracks" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "import typing\n", + "import scipy.sparse as sps\n", + "from torch_geometric.data import Data\n", + "\n", + "\n", + "def get_track_ids(edge_indices: torch.Tensor, n_hits: int) -> np.ndarray:\n", + " row, col = edge_indices\n", + " edge_attr = np.ones(row.size(0))\n", + "\n", + " sparse_edges = sps.coo_matrix(\n", + " (edge_attr, (row.numpy(), col.numpy())), (n_hits, n_hits)\n", + " )\n", + "\n", + " _, candidate_labels = sps.csgraph.connected_components(\n", + " sparse_edges, directed=False, return_labels=True\n", + " )\n", + " return candidate_labels\n", + "\n", + "\n", + "def update_next_labels(\n", + " labels: np.ndarray,\n", + " edge_indices: np.ndarray,\n", + " scores: np.ndarray,\n", + " score_cut: float,\n", + "):\n", + " unique_labels, n_labels = np.unique(labels, return_counts=True)\n", + " consistent_unique_labels = unique_labels[n_labels >= 3]\n", + "\n", + " hit_mask = ~np.isin(labels, consistent_unique_labels)\n", + "\n", + " n_hits = hit_mask.sum()\n", + " # Only keep edges between TWO remaining hits\n", + " edges_mask = torch.from_numpy(hit_mask[edge_indices].min(axis=0))\n", + " new_indices = np.full(fill_value=-1, shape=labels.shape[0], dtype=int)\n", + " new_indices[hit_mask] = np.arange(hit_mask.sum())\n", + "\n", + " reduced_edge_indices = new_indices[edge_indices][:, edges_mask]\n", + " reduced_scores = scores[edges_mask]\n", + "\n", + " # Build again\n", + " reduced_labels = get_track_ids(\n", + " torch.from_numpy(\n", + " reduced_edge_indices[:, reduced_scores > score_cut],\n", + " ),\n", + " n_hits=n_hits\n", + " )\n", + " reduced_labels += labels.max() + 1\n", + " labels[hit_mask] = reduced_labels\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "labels = get_track_ids(\n", + " batch.edge_index[:, batch.scores > 0.99], n_hits=batch.x.shape[0]\n", + ")\n", + "edge_indices = batch.edge_index.numpy()\n", + "scores = batch.scores.numpy()\n" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "update_next_labels(labels, edge_indices, scores, score_cut=0.98)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([560])" + ] + }, + "execution_count": 255, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.hit_id.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(172,)" + ] + }, + "execution_count": 256, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_labels.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2, 2, 5, 0, 6, 8, 8, 11, 12, 9, 9, 11, 9,\n", + " 3, 3, 13, 5, 13, 1, 14, 14, 1, 5, 18, 13, 14,\n", + " 1, 5, 19, 19, 14, 35, 36, 37, 22, 22, 43, 23, 22,\n", + " 50, 53, 62, 53, 54, 62, 54, 57, 57, 66, 65, 51, 62,\n", + " 56, 56, 63, 80, 57, 69, 74, 75, 75, 76, 102, 91, 104,\n", + " 91, 91, 109, 109, 113, 141, 131, 139, 116, 139, 131, 140, 141,\n", + " 155, 162, 170, 162, 160, 169],\n", + " [ 11, 12, 1, 6, 1, 2, 3, 8, 8, 2, 3, 9, 12,\n", + " 11, 12, 1, 13, 6, 14, 5, 6, 18, 18, 6, 18, 18,\n", + " 19, 19, 6, 13, 19, 22, 22, 22, 38, 39, 22, 44, 46,\n", + " 27, 59, 53, 65, 59, 54, 65, 25, 64, 58, 59, 60, 65,\n", + " 63, 67, 67, 68, 69, 64, 70, 64, 69, 71, 91, 103, 91,\n", + " 105, 106, 107, 111, 141, 114, 115, 115, 131, 116, 139, 155, 145,\n", + " 144, 150, 150, 151, 164, 167]])" + ] + }, + "execution_count": 236, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([2, 84])" + ] + }, + "execution_count": 220, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_edge_indices.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(560,)" + ] + }, + "execution_count": 216, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reduced_labels.shape" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "NumPy boolean array indexing assignment cannot assign 560 input values to the 172 output values where the mask is true", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[214], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[39m# Assign the labels to the remaining hits\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m labels[hit_mask] \u001b[39m=\u001b[39m reduced_labels\n", + "\u001b[0;31mValueError\u001b[0m: NumPy boolean array indexing assignment cannot assign 560 input values to the 172 output values where the mask is true" + ] + } + ], + "source": [ + "# Assign the labels to the remaining hits\n", + "labels[hit_mask] = reduced_labels\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ True, True, False, ..., False, False, True],\n", + " [ True, True, False, ..., False, False, False]])" + ] + }, + "execution_count": 232, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "hit_mask[batch.edge_index]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 0, 1, 2, ..., 473, 474, 475])" + ] + }, + "execution_count": 176, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "get_track_id(batches[9], 0.999)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ True, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, True, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, True, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " True, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, False, False, False, False])" + ] + }, + "execution_count": 167, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.labels" + ] + }, + { + "attachments": {}, + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Merge tracks into doublets" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "from torch_geometric.data import Data" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([False, True, False, ..., False, True, False])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.y_pid" + ] + }, + { + "cell_type": "code", + "execution_count": 81, + "metadata": {}, + "outputs": [], + "source": [ + "score_cut = 0.3\n", + "\n", + "# 1. Filter edges and hits with the given score_cut (needs to be conservative)\n", + "# Filter edges \n", + "edge_mask = batch.scores > score_cut\n", + "edge_indices = batch.edge_index[:, edge_mask]\n", + "y_pid = batch.y_pid[edge_mask]\n", + "\n", + "# Filter hits not connected to any edge\n", + "unique_edge_indices = torch.unique(edge_indices, sorted=True)\n", + "features = batch.x[unique_edge_indices]\n", + "\n", + "# Reindex edges given the filtering\n", + "n_hits = unique_edge_indices.shape[0]\n", + "mapping_new_indices = torch.full((edge_indices.max() + 1,), -1, dtype=torch.long)\n", + "mapping_new_indices[unique_edge_indices] = torch.arange(n_hits)\n", + "reindexed_edge_indices = mapping_new_indices[edge_indices]\n", + "\n", + "# 2. Compute doublet features\n", + "new_features = batch.x[reindexed_edge_indices]\n", + "doublet_features = torch.cat((new_features[0], new_features[1]), dim=-1)\n", + "\n", + "# 3. Form edges between doublets\n" + ] + }, + { + "cell_type": "code", + "execution_count": 83, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,\n", + " -1, -1])" + ] + }, + "execution_count": 83, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.full((edge_indices.max() + 1,), -1, dtype=torch.long)" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [], + "source": [ + "node_features = batch.x\n", + "edge_indices = batch.edge_index\n", + "edge_mask = batch.scores > 0.2\n", + "unique_edge_indices = torch.unique(edge_indices[:, edge_mask], sorted=True)\n", + "filtered_node_features = node_features[unique_edge_indices]\n", + "\n", + "# Reindex the node indices in `filtered_edge_indices`\n", + "n_filtered_nodes = unique_edge_indices.shape[0]\n", + "mapping_new_indices = torch.full(\n", + " (edge_indices.max() + 1,), -1, dtype=torch.long # type: ignore\n", + ")\n", + "mapping_new_indices[unique_edge_indices] = torch.arange(n_filtered_nodes)\n", + "reindexed_edge_indices = mapping_new_indices[edge_indices]\n", + "filtered_reindexed_edge_indices = reindexed_edge_indices[:, edge_mask]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 108, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['plane',\n", + " 'signal_true_edges',\n", + " 'truncated_path',\n", + " 'scores',\n", + " 'x',\n", + " 'y',\n", + " 'particle_id',\n", + " 'edge_index',\n", + " 'hit_id',\n", + " 'event_str',\n", + " 'y_pid']" + ] + }, + "execution_count": 108, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.keys" + ] + }, + { + "cell_type": "code", + "execution_count": 104, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor(False)" + ] + }, + "execution_count": 104, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "(filtered_reindexed_edge_indices == -1).any()" + ] + }, + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "triplet_index = torch.from_numpy(\n", + " edge_to_triplet_scipy(reindexed_edge_indices.numpy())\n", + ").long()\n", + "y_triplet = y_pid[triplet_index].min(dim=0).values\n" + ] + }, + { + "cell_type": "code", + "execution_count": 89, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([False, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, False, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, False, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, False, False,\n", + " True, True, False, True, True, False, False, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, False, False, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, False, False, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, False,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, False, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, False, False, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, False, False, False, False, False, False,\n", + " False, False, False, False, False, False, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, False, False, True, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, False, True, True, True,\n", + " True, True, True, True, True, True, True, True, True, True,\n", + " True, True, True, True, True, True, True, True])" + ] + }, + "execution_count": 89, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pid" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ True, True, True, ..., True, True, True],\n", + " [False, True, True, ..., True, True, True]])" + ] + }, + "execution_count": 79, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pid[triplet_index]" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ True, True, True, ..., True, True, True],\n", + " [False, True, True, ..., True, True, True]])" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "y_pid.numpy()[triplet_index]" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 13, 13, 46, ..., 661, 639, 680],\n", + " [ 0, 1, 2, ..., 702, 704, 707]])" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "edge_to_triplet_scipy(reindexed_edge_indices.numpy())" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[44],\n", + " [28]])" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices[:, reindexed_edge_indices[0, :] == 44]" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "# Sort edges by plane\n", + "edge_planes = planes[reindexed_edge_indices]\n", + "\n", + "flip_mask = edge_planes[0] > edge_planes[1]\n", + "ordered_edge_indices = reindexed_edge_indices.clone()\n", + "ordered_edge_indices[:, flip_mask] = reindexed_edge_indices[:, flip_mask].flip(dims=[0])\n" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[[ 8, 8, 8, ..., 8, 8, 8],\n", + " [ 8, 8, 8, ..., 8, 8, 8],\n", + " [ 11, 11, 11, ..., 11, 11, 11],\n", + " ...,\n", + " [445, 445, 445, ..., 445, 445, 445],\n", + " [446, 446, 446, ..., 446, 446, 446],\n", + " [447, 447, 447, ..., 447, 447, 447]],\n", + "\n", + " [[ 44, 44, 44, ..., 44, 44, 44],\n", + " [ 45, 45, 45, ..., 45, 45, 45],\n", + " [ 74, 74, 74, ..., 74, 74, 74],\n", + " ...,\n", + " [466, 466, 466, ..., 466, 466, 466],\n", + " [455, 455, 455, ..., 455, 455, 455],\n", + " [468, 468, 468, ..., 468, 468, 468]]])" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ordered_edge_indices.unsqueeze(-1).expand(-1, -1, ordered_edge_indices.shape[1])" + ] + }, + { + "cell_type": "code", + "execution_count": 114, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 10, 31, 43, 13, 17, 18, 11, 36, 19, 36, 12, 16, 6, 25,\n", + " 10, 31, 0, 23, 42, 1, 26, 7, 2, 16, 43, 3, 20, 22,\n", + " 22, 14, 14, 19, 30, 30, 11, 11, 53, 53, 37, 37, 13, 32,\n", + " 18, 18, 34, 34, 16, 43, 39, 18, 18, 34, 34, 12, 12, 38,\n", + " 38, 40, 40, 17, 33, 33, 35, 15, 15, 27, 27, 27, 2, 2,\n", + " 2, 19, 47, 47, 47, 3, 3, 3, 20, 20, 20, 20, 20, 48,\n", + " 48, 48, 48, 48, 0, 0, 0, 1, 1, 1, 27, 26, 26, 26,\n", + " 7, 7, 7, 14, 24, 24, 46, 46, 46, 5, 5, 5, 21, 21,\n", + " 21, 22, 22, 49, 49, 50, 50, 50, 21, 21, 21, 21, 49, 49,\n", + " 49, 49, 31, 50, 50, 50, 50, 27, 27, 27, 63, 63, 63, 14,\n", + " 14, 14, 30, 30, 30, 30, 51, 54, 30, 31, 31, 31, 31, 52,\n", + " 12, 60, 39, 19, 85, 7, 2, 7, 2, 38, 103, 95, 83, 103,\n", + " 24, 59, 103, 67, 82, 47, 19, 64, 30, 60, 16, 19, 85, 57,\n", + " 2, 59, 103, 46, 38, 103, 95, 111, 1, 26, 100, 99, 43, 88,\n", + " 82, 86, 83, 103, 2, 94, 102, 64, 14, 85, 12, 103, 95, 111,\n", + " 103, 16, 39, 39, 100, 88, 127, 57, 57, 100, 99, 126, 103, 94,\n", + " 94, 102, 1, 1, 43, 67, 67, 98, 100, 100, 100, 88, 127, 124,\n", + " 100, 99, 126, 118, 114, 95, 111, 106, 106, 107, 107, 107, 108, 108,\n", + " 108, 110, 110, 113, 113, 127, 124, 146, 126, 125, 118, 111, 120, 121,\n", + " 142, 121, 103, 103, 122, 122, 122, 122, 122, 122, 104, 109, 109, 125,\n", + " 125, 148, 124, 146, 158, 106, 106, 126, 132, 128, 105, 105, 143, 142,\n", + " 135, 131, 131, 131, 131, 119, 115, 137, 137, 140, 140, 140, 140, 141,\n", + " 141, 148, 146, 158, 139, 111, 126, 132, 163, 143, 143, 143, 143, 143,\n", + " 143, 142, 135, 181, 109, 125, 144, 144, 144, 144, 158, 139, 105, 105,\n", + " 155, 129, 129, 159, 177, 148, 157, 177, 119, 163, 177, 135, 135, 115,\n", + " 133, 124, 124, 151, 170, 135, 181, 157, 157, 177, 157, 157, 155, 173,\n", + " 109, 109, 158, 158, 139, 159, 177, 155, 160, 163, 177, 161, 132, 132,\n", + " 149, 181, 151, 170, 196, 133, 152, 161, 161, 173, 182, 142, 142, 156,\n", + " 156, 197, 155, 197, 161, 171, 178, 179, 179, 154, 168, 167, 183, 196,\n", + " 169, 210, 152, 171, 151, 151, 169, 169, 149, 149, 166, 166, 197, 190,\n", + " 197, 175, 182, 174, 174, 156, 171, 172, 172, 193, 193, 196, 169, 210,\n", + " 196, 196, 166, 166, 188, 188, 190, 187, 175, 213, 183, 183, 200, 200,\n", + " 200, 200, 200, 210, 216, 185, 185, 185, 186, 186, 189, 189, 174, 174,\n", + " 187, 189, 213, 208, 191, 173, 189, 189, 172, 172, 193, 193, 172, 216,\n", + " 211, 211, 211, 188, 188, 209, 222, 213, 213, 223, 208, 189, 205, 201,\n", + " 185, 185, 202, 202, 167, 183, 183, 240, 216, 224, 241, 216, 216, 172,\n", + " 221, 203, 203, 198, 206, 206, 223, 228, 205, 214, 222, 220, 244, 220,\n", + " 244, 223, 209, 191, 219, 207, 208, 224, 224, 240, 254, 241, 238, 221,\n", + " 219, 225, 225, 212, 227, 227, 201, 214, 218, 217, 202, 215, 232, 232,\n", + " 229, 235, 233, 226, 244, 257, 273, 244, 248, 214, 228, 237, 237, 231,\n", + " 257, 237, 241, 249, 243, 249, 250, 230, 247, 267, 219, 267, 266, 254,\n", + " 242, 254, 243, 238, 267, 265, 220, 235, 251, 251, 245, 257, 273, 287,\n", + " 231, 257, 274, 259, 275, 246, 243, 261, 281, 250, 279, 280, 247, 267,\n", + " 247, 295, 242, 283, 267, 266, 295, 267, 265, 270, 242, 283, 265, 243,\n", + " 246, 266, 234, 287, 251, 251, 290, 255, 252, 271, 239, 256, 255, 285,\n", + " 273, 272, 273, 287, 302, 274, 261, 277, 275, 288, 303, 268, 269, 261,\n", + " 281, 279, 280, 246, 266, 247, 247, 295, 266, 295, 265, 270, 283, 265,\n", + " 283, 262, 287, 302, 251, 290, 270, 284, 270, 271, 286, 252, 271, 255,\n", + " 285, 255, 285, 272, 272, 287, 302, 261, 277, 288, 303, 288, 303, 277,\n", + " 264, 280, 266, 281, 295, 295, 270, 262, 265, 290, 284, 271, 286, 285,\n", + " 272, 302, 302, 303, 303, 276, 282, 277])" + ] + }, + "execution_count": 114, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ordered_edge_indices[0, ]" + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 44, 45, 74, ..., 466, 446, 447]])" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 111, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 0, 0, 0, ..., 24, 24, 24],\n", + " [ 2, 2, 3, ..., 25, 25, 25]])" + ] + }, + "execution_count": 111, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "planes[ordered_edge_indices]" + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, 2, 3, 5, 4, 0, 23, 7, 6, 1, 15, 8,\n", + " 28, 28, 9, 14, 10, 13, 17, 18, 11, 36, 36, 12, 16, 6,\n", + " 25, 0, 23, 42, 1, 26, 7, 24, 2, 19, 3, 20, 22, 22,\n", + " 14, 30, 10, 31, 11, 53, 37, 13, 32, 18, 34, 16, 39, 18,\n", + " 34, 12, 38, 40, 17, 33, 35, 15, 27, 2, 19, 47, 3, 20,\n", + " 48, 0, 1, 26, 43, 7, 24, 46, 5, 21, 22, 49, 50, 5,\n", + " 21, 22, 49, 50, 15, 27, 63, 14, 30, 51, 72, 10, 31, 52,\n", + " 12, 38, 59, 75, 35, 62, 13, 32, 55, 18, 34, 56, 17, 33,\n", + " 61, 37, 54, 40, 60, 16, 39, 57, 7, 24, 46, 68, 1, 26,\n", + " 43, 67, 86, 2, 19, 47, 64, 14, 30, 51, 2, 19, 64, 12,\n", + " 38, 59, 16, 39, 57, 82, 83, 94, 94, 1, 26, 43, 67, 85,\n", + " 88, 98, 100, 100, 100, 101, 101, 102, 102, 103, 103, 103, 106, 106,\n", + " 107, 107, 107, 108, 108, 110, 112, 113, 114, 88, 99, 118, 118, 95,\n", + " 120, 121, 121, 103, 122, 122, 122, 122, 104, 109, 125, 125, 111, 126,\n", + " 127, 106, 128, 128, 105, 131, 131, 119, 115, 137, 123, 140, 140, 140,\n", + " 141, 124, 111, 126, 143, 143, 143, 109, 125, 144, 144, 144, 146, 105,\n", + " 129, 148, 119, 132, 135, 115, 133, 139, 124, 142, 126, 157, 157, 157,\n", + " 109, 158, 158, 159, 160, 163, 163, 132, 149, 150, 135, 151, 133, 152,\n", + " 161, 139, 155, 142, 156, 177, 177, 177, 178, 179, 154, 181, 168, 167,\n", + " 183, 170, 152, 171, 151, 169, 149, 166, 155, 173, 174, 156, 175, 161,\n", + " 172, 193, 196, 196, 196, 166, 188, 197, 197, 182, 167, 183, 200, 200,\n", + " 200, 169, 187, 171, 185, 186, 189, 174, 190, 175, 191, 173, 189, 172,\n", + " 193, 210, 211, 211, 211, 199, 188, 213, 213, 187, 201, 185, 202, 167,\n", + " 183, 216, 216, 216, 203, 198, 209, 206, 189, 208, 222, 222, 190, 205,\n", + " 223, 191, 207, 224, 224, 172, 225, 225, 212, 227, 227, 201, 214, 218,\n", + " 217, 202, 215, 232, 232, 233, 233, 206, 220, 236, 205, 223, 237, 237,\n", + " 209, 219, 208, 221, 240, 207, 241, 241, 229, 226, 244, 244, 214, 228,\n", + " 231, 248, 215, 249, 249, 230, 234, 219, 238, 254, 254, 220, 235, 221,\n", + " 239, 256, 257, 257, 259, 259, 245, 231, 246, 243, 250, 243, 247, 267,\n", + " 267, 267, 242, 242, 234, 251, 238, 252, 235, 255, 239, 256, 273, 273,\n", + " 274, 274, 275, 268, 269, 264, 279, 246, 261, 247, 266, 265, 283, 283,\n", + " 251, 270, 252, 271, 255, 272, 287, 287, 288, 288, 264, 277, 278, 261,\n", + " 280, 266, 281, 295, 295, 262, 265, 282, 270, 284, 271, 285, 272, 286,\n", + " 302, 302, 303, 303, 276, 290, 277, 291, 278, 292, 282, 298, 308, 309,\n", + " 296, 284, 299, 285, 300, 314, 314, 286, 301, 315, 316, 317, 317, 304,\n", + " 290, 305, 291, 306, 307, 280, 293, 322, 294, 323, 323, 298, 308, 324,\n", + " 324, 299, 311, 312, 301, 315, 329, 329, 330, 330, 313, 334, 334, 335,\n", + " 335, 318, 336, 319, 337, 321, 338, 293, 322, 339, 339, 340, 340, 341,\n", + " 341, 320, 320, 320, 320, 320, 320, 320, 320, 320, 320, 320, 320, 320,\n", + " 355, 355, 327, 356, 357, 357, 357, 358, 359, 360, 361, 313, 332, 362,\n", + " 362, 326, 363, 364, 364, 365, 365, 366, 366, 366, 367, 367, 367, 368,\n", + " 368, 369, 369, 370, 370, 370, 371, 372, 372, 372, 373, 374, 374, 374,\n", + " 332, 378, 378, 379, 379, 380, 381, 381, 381, 382, 382, 382, 383, 383,\n", + " 383, 383, 384, 384, 385, 385, 385, 386, 386, 386, 387, 387, 387, 388,\n", + " 388, 388, 389, 389, 390, 390, 390, 391, 391, 391, 392, 392, 392, 392,\n", + " 393, 393, 394, 394, 394, 395, 395, 395, 396, 396, 396, 397, 399, 401,\n", + " 401, 402, 402, 403, 403, 404, 405, 405, 406, 406, 407, 407, 408, 408,\n", + " 409, 409, 410, 410, 411, 411, 412, 412, 413, 414, 414, 415, 415, 416,\n", + " 416, 417, 417, 418, 418, 419, 419, 420, 420, 421, 421, 422, 422, 423,\n", + " 425, 426, 427, 428, 429, 430, 431, 432, 433, 434, 435, 436, 437, 438,\n", + " 439, 440, 441, 442, 443, 445, 446, 447]])" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices.gather(\n", + " 0,\n", + " torch.min(edge_planes, dim=0).indices.unsqueeze(0),\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 93, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([2, 708])" + ] + }, + "execution_count": 93, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 94, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "torch.Size([708])" + ] + }, + "execution_count": 94, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "torch.min(edge_planes, dim=0).indices.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 82, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 8, 8, 11, ..., 445, 455, 468],\n", + " ...,\n", + " [ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 44, 45, 74, ..., 466, 446, 447],\n", + " [ 44, 45, 74, ..., 466, 446, 447]])" + ] + }, + "execution_count": 82, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices[edge_planes.argmin(axis=0), :]" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0,\n", + " 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1,\n", + " 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0,\n", + " 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 0, 0,\n", + " 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0,\n", + " 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 0, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0,\n", + " 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 1,\n", + " 1, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0,\n", + " 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 1, 1, 0, 0, 1,\n", + " 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1,\n", + " 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1,\n", + " 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1,\n", + " 1, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0,\n", + " 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 1,\n", + " 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 1,\n", + " 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0,\n", + " 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 1, 1,\n", + " 0, 1, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 0, 0, 1,\n", + " 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,\n", + " 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0,\n", + " 1, 1, 1, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0,\n", + " 1, 0, 0, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 1, 0,\n", + " 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 0,\n", + " 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 1, 0, 0, 1, 0, 1, 1, 0, 1,\n", + " 1, 1, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 0, 1, 1, 0, 1, 0,\n", + " 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1])" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "ordered_reindex_edge_indices = torch.cat(\n", + " (\n", + " \n", + " )\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,\n", + " 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,\n", + " 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,\n", + " 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3,\n", + " 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,\n", + " 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4,\n", + " 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5,\n", + " 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,\n", + " 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6, 6,\n", + " 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7, 7,\n", + " 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8, 8,\n", + " 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9,\n", + " 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10,\n", + " 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,\n", + " 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,\n", + " 12, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,\n", + " 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,\n", + " 14, 14, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,\n", + " 15, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16, 16,\n", + " 16, 16, 16, 16, 16, 16, 16, 16, 17, 17, 17, 17, 17, 17, 17, 17, 17, 17,\n", + " 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18, 18,\n", + " 18, 18, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19, 19,\n", + " 19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,\n", + " 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21, 21,\n", + " 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21,\n", + " 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22,\n", + " 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,\n", + " 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23, 23,\n", + " 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,\n", + " 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 25, 25, 25,\n", + " 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,\n", + " 25, 25])" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "batch.plane" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 44, 45, 74, ..., 466, 446, 447]])" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 44, 45, 74, ..., 466, 446, 447]])" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "reindexed_edge_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [], + "source": [ + "new_batch = Data(\n", + " x=features,\n", + " edge_index=reindexed_edge_indices,\n", + " particle_id=batch.particle_id[unique_edge_indices],\n", + " signal_true_edges=mapping_new_indices[batch.signal_true_edges],\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/tmp/ipykernel_28393/2550153991.py:3: DeprecationWarning: Importing display from IPython.core.display is deprecated since IPython 7.14, please import from IPython display\n", + " from IPython.core.display import Image, display\n" + ] + }, + { + "data": { + "text/html": [ + "<div class=\"bk-root\">\n", + " <a href=\"https://bokeh.org\" target=\"_blank\" class=\"bk-logo bk-logo-small bk-logo-notebook\"></a>\n", + " <span id=\"2677\">Loading BokehJS ...</span>\n", + " </div>\n" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "application/javascript": "(function(root) {\n function now() {\n return new Date();\n }\n\n const force = true;\n\n if (typeof root._bokeh_onload_callbacks === \"undefined\" || force === true) {\n root._bokeh_onload_callbacks = [];\n root._bokeh_is_loading = undefined;\n }\n\nconst JS_MIME_TYPE = 'application/javascript';\n const HTML_MIME_TYPE = 'text/html';\n const EXEC_MIME_TYPE = 'application/vnd.bokehjs_exec.v0+json';\n const CLASS_NAME = 'output_bokeh rendered_html';\n\n /**\n * Render data to the DOM node\n */\n function render(props, node) {\n const script = document.createElement(\"script\");\n node.appendChild(script);\n }\n\n /**\n * Handle when an output is cleared or removed\n */\n function handleClearOutput(event, handle) {\n const cell = handle.cell;\n\n const id = cell.output_area._bokeh_element_id;\n const server_id = cell.output_area._bokeh_server_id;\n // Clean up Bokeh references\n if (id != null && id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n\n if (server_id !== undefined) {\n // Clean up Bokeh references\n const cmd_clean = \"from bokeh.io.state import curstate; print(curstate().uuid_to_server['\" + server_id + \"'].get_sessions()[0].document.roots[0]._id)\";\n cell.notebook.kernel.execute(cmd_clean, {\n iopub: {\n output: function(msg) {\n const id = msg.content.text.trim();\n if (id in Bokeh.index) {\n Bokeh.index[id].model.document.clear();\n delete Bokeh.index[id];\n }\n }\n }\n });\n // Destroy server and session\n const cmd_destroy = \"import bokeh.io.notebook as ion; ion.destroy_server('\" + server_id + \"')\";\n cell.notebook.kernel.execute(cmd_destroy);\n }\n }\n\n /**\n * Handle when a new output is added\n */\n function handleAddOutput(event, handle) {\n const output_area = handle.output_area;\n const output = handle.output;\n\n // limit handleAddOutput to display_data with EXEC_MIME_TYPE content only\n if ((output.output_type != \"display_data\") || (!Object.prototype.hasOwnProperty.call(output.data, EXEC_MIME_TYPE))) {\n return\n }\n\n const toinsert = output_area.element.find(\".\" + CLASS_NAME.split(' ')[0]);\n\n if (output.metadata[EXEC_MIME_TYPE][\"id\"] !== undefined) {\n toinsert[toinsert.length - 1].firstChild.textContent = output.data[JS_MIME_TYPE];\n // store reference to embed id on output_area\n output_area._bokeh_element_id = output.metadata[EXEC_MIME_TYPE][\"id\"];\n }\n if (output.metadata[EXEC_MIME_TYPE][\"server_id\"] !== undefined) {\n const bk_div = document.createElement(\"div\");\n bk_div.innerHTML = output.data[HTML_MIME_TYPE];\n const script_attrs = bk_div.children[0].attributes;\n for (let i = 0; i < script_attrs.length; i++) {\n toinsert[toinsert.length - 1].firstChild.setAttribute(script_attrs[i].name, script_attrs[i].value);\n toinsert[toinsert.length - 1].firstChild.textContent = bk_div.children[0].textContent\n }\n // store reference to server id on output_area\n output_area._bokeh_server_id = output.metadata[EXEC_MIME_TYPE][\"server_id\"];\n }\n }\n\n function register_renderer(events, OutputArea) {\n\n function append_mime(data, metadata, element) {\n // create a DOM node to render to\n const toinsert = this.create_output_subarea(\n metadata,\n CLASS_NAME,\n EXEC_MIME_TYPE\n );\n this.keyboard_manager.register_events(toinsert);\n // Render to node\n const props = {data: data, metadata: metadata[EXEC_MIME_TYPE]};\n render(props, toinsert[toinsert.length - 1]);\n element.append(toinsert);\n return toinsert\n }\n\n /* Handle when an output is cleared or removed */\n events.on('clear_output.CodeCell', handleClearOutput);\n events.on('delete.Cell', handleClearOutput);\n\n /* Handle when a new output is added */\n events.on('output_added.OutputArea', handleAddOutput);\n\n /**\n * Register the mime type and append_mime function with output_area\n */\n OutputArea.prototype.register_mime_type(EXEC_MIME_TYPE, append_mime, {\n /* Is output safe? */\n safe: true,\n /* Index of renderer in `output_area.display_order` */\n index: 0\n });\n }\n\n // register the mime type if in Jupyter Notebook environment and previously unregistered\n if (root.Jupyter !== undefined) {\n const events = require('base/js/events');\n const OutputArea = require('notebook/js/outputarea').OutputArea;\n\n if (OutputArea.prototype.mime_types().indexOf(EXEC_MIME_TYPE) == -1) {\n register_renderer(events, OutputArea);\n }\n }\n if (typeof (root._bokeh_timeout) === \"undefined\" || force === true) {\n root._bokeh_timeout = Date.now() + 5000;\n root._bokeh_failed_load = false;\n }\n\n const NB_LOAD_WARNING = {'data': {'text/html':\n \"<div style='background-color: #fdd'>\\n\"+\n \"<p>\\n\"+\n \"BokehJS does not appear to have successfully loaded. If loading BokehJS from CDN, this \\n\"+\n \"may be due to a slow or bad network connection. Possible fixes:\\n\"+\n \"</p>\\n\"+\n \"<ul>\\n\"+\n \"<li>re-rerun `output_notebook()` to attempt to load from CDN again, or</li>\\n\"+\n \"<li>use INLINE resources instead, as so:</li>\\n\"+\n \"</ul>\\n\"+\n \"<code>\\n\"+\n \"from bokeh.resources import INLINE\\n\"+\n \"output_notebook(resources=INLINE)\\n\"+\n \"</code>\\n\"+\n \"</div>\"}};\n\n function display_loaded() {\n const el = document.getElementById(\"2677\");\n if (el != null) {\n el.textContent = \"BokehJS is loading...\";\n }\n if (root.Bokeh !== undefined) {\n if (el != null) {\n el.textContent = \"BokehJS \" + root.Bokeh.version + \" successfully loaded.\";\n }\n } else if (Date.now() < root._bokeh_timeout) {\n setTimeout(display_loaded, 100)\n }\n }\n\n function run_callbacks() {\n try {\n root._bokeh_onload_callbacks.forEach(function(callback) {\n if (callback != null)\n callback();\n });\n } finally {\n delete root._bokeh_onload_callbacks\n }\n console.debug(\"Bokeh: all callbacks have finished\");\n }\n\n function load_libs(css_urls, js_urls, callback) {\n if (css_urls == null) css_urls = [];\n if (js_urls == null) js_urls = [];\n\n root._bokeh_onload_callbacks.push(callback);\n if (root._bokeh_is_loading > 0) {\n console.debug(\"Bokeh: BokehJS is being loaded, scheduling callback at\", now());\n return null;\n }\n if (js_urls == null || js_urls.length === 0) {\n run_callbacks();\n return null;\n }\n console.debug(\"Bokeh: BokehJS not loaded, scheduling load and callback at\", now());\n root._bokeh_is_loading = css_urls.length + js_urls.length;\n\n function on_load() {\n root._bokeh_is_loading--;\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: all BokehJS libraries/stylesheets loaded\");\n run_callbacks()\n }\n }\n\n function on_error(url) {\n console.error(\"failed to load \" + url);\n }\n\n for (let i = 0; i < css_urls.length; i++) {\n const url = css_urls[i];\n const element = document.createElement(\"link\");\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.rel = \"stylesheet\";\n element.type = \"text/css\";\n element.href = url;\n console.debug(\"Bokeh: injecting link tag for BokehJS stylesheet: \", url);\n document.body.appendChild(element);\n }\n\n for (let i = 0; i < js_urls.length; i++) {\n const url = js_urls[i];\n const element = document.createElement('script');\n element.onload = on_load;\n element.onerror = on_error.bind(null, url);\n element.async = false;\n element.src = url;\n console.debug(\"Bokeh: injecting script tag for BokehJS library: \", url);\n document.head.appendChild(element);\n }\n };\n\n function inject_raw_css(css) {\n const element = document.createElement(\"style\");\n element.appendChild(document.createTextNode(css));\n document.body.appendChild(element);\n }\n\n const js_urls = [\"https://cdn.bokeh.org/bokeh/release/bokeh-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-gl-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-widgets-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-tables-2.4.3.min.js\", \"https://cdn.bokeh.org/bokeh/release/bokeh-mathjax-2.4.3.min.js\"];\n const css_urls = [];\n\n const inline_js = [ function(Bokeh) {\n Bokeh.set_log_level(\"info\");\n },\nfunction(Bokeh) {\n }\n ];\n\n function run_inline_js() {\n if (root.Bokeh !== undefined || force === true) {\n for (let i = 0; i < inline_js.length; i++) {\n inline_js[i].call(root, root.Bokeh);\n }\nif (force === true) {\n display_loaded();\n }} else if (Date.now() < root._bokeh_timeout) {\n setTimeout(run_inline_js, 100);\n } else if (!root._bokeh_failed_load) {\n console.log(\"Bokeh: BokehJS failed to load within specified timeout.\");\n root._bokeh_failed_load = true;\n } else if (force !== true) {\n const cell = $(document.getElementById(\"2677\")).parents('.cell').data().cell;\n cell.output_area.append_execute_result(NB_LOAD_WARNING)\n }\n }\n\n if (root._bokeh_is_loading === 0) {\n console.debug(\"Bokeh: BokehJS loaded, going straight to plotting\");\n run_inline_js();\n } else {\n load_libs(css_urls, js_urls, function() {\n console.debug(\"Bokeh: BokehJS plotting callback run at\", now());\n run_inline_js();\n });\n }\n}(window));", + "application/vnd.bokehjs_load.v0+json": "" + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import os.path as op\n", + "\n", + "from IPython.core.display import Image, display\n", + "import numpy as np\n", + "from bokeh.plotting import figure, show\n", + "from bokeh.models import ColumnDataSource\n", + "from bokeh.palettes import viridis\n", + "from bokeh.io import export_png, output_notebook\n", + "\n", + "output_notebook()\n", + "\n", + "def plot_graph(batch):\n", + " p = figure(\n", + " title=\"Truth graphs\", x_axis_label=\"x\", y_axis_label=\"y\", height=500, width=500\n", + " )\n", + " q = figure(\n", + " title=\"Predicted graphs\",\n", + " x_axis_label=\"x\",\n", + " y_axis_label=\"y\",\n", + " height=500,\n", + " width=500,\n", + " )\n", + "\n", + " true_edges = batch.signal_true_edges\n", + " true_unique, true_lengths = batch.particle_id[true_edges[0]].unique(\n", + " return_counts=True\n", + " )\n", + " pred_edges = batch.edge_index\n", + " particle_ids = batch.particle_id\n", + "\n", + " nr = batch.x[:, 0]\n", + " nphi = batch.x[:, 1]\n", + " r = nr * 9.75 + 18\n", + " phi = nphi * 1.82\n", + "\n", + " x = r * np.cos(phi)\n", + " y = r * np.sin(phi)\n", + " cmap = viridis(11)\n", + " source = ColumnDataSource(dict(x=x.numpy(), y=y.numpy()))\n", + " p.circle(x=\"x\", y=\"y\", source=source, color=cmap[0], size=1, alpha=0.1)\n", + " q.circle(x=\"x\", y=\"y\", source=source, color=cmap[0], size=1, alpha=0.1)\n", + "\n", + " for i, track in enumerate(true_unique[true_lengths >= 10][:10]):\n", + " # Get true track plot\n", + " track_true_edges = true_edges[:, particle_ids[true_edges[0]] == track].cpu()\n", + " X_edges, Y_edges = x[track_true_edges].numpy(), y[track_true_edges].numpy()\n", + " X = np.concatenate(X_edges)\n", + " Y = np.concatenate(Y_edges)\n", + "\n", + " p.circle(X, Y, color=cmap[i], size=5)\n", + " p.multi_line(X_edges.T.tolist(), Y_edges.T.tolist(), color=cmap[i])\n", + "\n", + " track_pred_edges = (\n", + " pred_edges[:, (particle_ids[pred_edges] == track).any(0)]\n", + " ).cpu()\n", + "\n", + " X_edges, Y_edges = x[track_pred_edges].numpy(), y[track_pred_edges].numpy()\n", + " X = np.concatenate(X_edges)\n", + " Y = np.concatenate(Y_edges)\n", + "\n", + " q.circle(X, Y, color=cmap[i], size=5)\n", + " q.multi_line(X_edges.T.tolist(), Y_edges.T.tolist(), color=cmap[i])\n", + "\n", + " show(p)\n", + " show(q)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 445, 455, 468],\n", + " [ 44, 45, 74, ..., 466, 446, 447]])" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "reindexed_edge_indices" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "tensor([[ 8, 8, 11, ..., 531, 544, 559],\n", + " [ 47, 48, 78, ..., 556, 534, 535]])" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "edge_indices" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "etx4velo_updated", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + }, + "orig_nbformat": 4 + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/exploration/test.ipynb b/exploration/test.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..2b7d742735c89a4ae72425e4cb23ce4fa111987e --- /dev/null +++ b/exploration/test.ipynb @@ -0,0 +1,333 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2023-05-14 04:30:22,422 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-v1exanh9', purging\n", + "2023-05-14 04:30:22,422 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-_3n17svj', purging\n", + "2023-05-14 04:30:22,423 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-pecvj_nz', purging\n", + "2023-05-14 04:30:22,423 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-8mxforuv', purging\n", + "2023-05-14 04:30:22,423 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-cfdom5ui', purging\n", + "2023-05-14 04:30:22,423 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-fijvmhzu', purging\n", + "2023-05-14 04:30:22,424 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-dwrafs7q', purging\n", + "2023-05-14 04:30:22,424 - distributed.diskutils - INFO - Found stale lock file and directory '/tmp/dask-worker-space/worker-8avxlnms', purging\n" + ] + } + ], + "source": [ + "import os\n", + "import pandas as pd\n", + "import pyarrow as pa\n", + "import pyarrow.parquet as pq\n", + "import dask.dataframe as dd\n", + "from dask.distributed import Client, progress\n", + "\n", + "client = Client()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles = pd.read_parquet(\n", + " \"/scratch/acorreia/minbias-sim10b-xdigi-nospillover/0/hits_velo.parquet.lz4\"\n", + ")\n", + "particles = pd.read_parquet(\n", + " \"/scratch/acorreia/minbias-sim10b-xdigi-nospillover/0/mc_particles.parquet.lz4\"\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "import sys\n", + "sys.path.append(\"../montetracko/\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from Preprocessing.particle_line_fitting import (\n", + " compute_particle_distances_to_lines_dataframe,\n", + ")\n", + "\n", + "hits_particles[\"particle_id\"] = hits_particles[\"mcid\"] + 1\n", + "particles[\"particle_id\"] = particles[\"mcid\"] + 1\n", + "\n", + "hits_particles = hits_particles.merge(\n", + " particles[[\"event\", \"particle_id\", \"has_velo\"]],\n", + " how=\"left\",\n", + " on=[\"event\", \"particle_id\"],\n", + ")\n", + "hits_particles = hits_particles[hits_particles[\"has_velo\"] == 1]\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "new_distances = compute_particle_distances_to_lines_dataframe(\n", + " hits=hits_particles,\n", + " metric_names=[\"distance_to_line\", \"distance_to_z_axis\"],\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "hits_particles = hits_particles.merge(\n", + " new_distances, how=\"left\", on=[\"event\", \"particle_id\"]\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "particles = particles.merge(\n", + " new_distances, how=\"left\", on=[\"event\", \"particle_id\"]\n", + ")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0 0.000002\n", + "1 0.010684\n", + "2 0.155721\n", + "3 0.032444\n", + "4 0.034152\n", + " ... \n", + "5345106 0.025152\n", + "5345107 0.005537\n", + "5345108 0.855370\n", + "5345109 NaN\n", + "5345110 5.439347\n", + "Name: distance_to_line, Length: 5345111, dtype: float64" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "particles[\"distance_to_line\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Abundance')" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "ax.hist(particles[\"distance_to_line\"], range=(0., 1.))\n", + "ax.set_xlabel(\"Distance to a straight line fitted to it\")\n", + "ax.set_ylabel(\"Abundance\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Abundance')" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 800x600 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fig, ax = plt.subplots(figsize=(8, 6))\n", + "\n", + "ax.hist(particles[\"distance_to_z_axis\"], range=(0., 1.))\n", + "ax.set_xlabel(\"Distance to the z-axis\")\n", + "ax.set_ylabel(\"Abundance\")\n" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "\n", + "\n", + "def plot_xy_graph(\n", + " df_hits_particles: pd.DataFrame,\n", + " seed: int | None = None,\n", + "):\n", + " fig, ax = plt.subplots(figsize=(12, 12))\n", + "\n", + " ax.axhline(y=0.0, color=\"k\", linewidth=0.5)\n", + " ax.axvline(x=0.0, color=\"k\", linewidth=0.5)\n", + "\n", + " n_lines = 20\n", + " event_ids = df_hits_particles[\"event\"].unique()\n", + "\n", + " rng = np.random.default_rng(seed=seed)\n", + " rng.shuffle(event_ids)\n", + "\n", + " for idx, (_, hits_particle) in enumerate(\n", + " df_hits_particles[\n", + " df_hits_particles[\"event\"].isin(event_ids[:10])\n", + " & (\n", + " (df_hits_particles[\"distance_to_z_axis\"] < 0.5)\n", + " & (df_hits_particles[\"distance_to_z_axis\"] > 0.2)\n", + " )\n", + " ][[\"event\", \"particle_id\", \"x\", \"y\", \"z\", \"plane\"]].groupby(\n", + " by=[\"event\", \"particle_id\"]\n", + " )\n", + " ):\n", + " hit_coordinates = hits_particle.sort_values(by=\"plane\")[[\"x\", \"y\"]]\n", + " ax.plot(\n", + " hit_coordinates[\"x\"],\n", + " hit_coordinates[\"y\"],\n", + " linestyle=\"-\",\n", + " markersize=5.0,\n", + " marker=\"o\",\n", + " )\n", + " if idx > n_lines:\n", + " break\n", + "\n", + " ax.set_xlim(-50.0, 50.0)\n", + " ax.set_ylim(-50.0, 50.0)\n", + " ax.grid(color=\"grey\", alpha=0.5)\n", + "\n", + " return fig, ax\n" + ] + }, + { + "cell_type": "code", + "execution_count": 44, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(<Figure size 1200x1200 with 1 Axes>, <Axes: >)" + ] + }, + "execution_count": 44, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "<Figure size 1200x1200 with 1 Axes>" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_xy_graph(hits_particles)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.10" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/montetracko b/montetracko index 15ca87819f350195715152e9f6e4c73ce8654f5d..e033e8a998cfa59df42f4e39c068e6ce4671ffae 160000 --- a/montetracko +++ b/montetracko @@ -1 +1 @@ -Subproject commit 15ca87819f350195715152e9f6e4c73ce8654f5d +Subproject commit e033e8a998cfa59df42f4e39c068e6ce4671ffae