diff --git a/README.md b/README.md index 217ee83..375ddf4 100644 --- a/README.md +++ b/README.md @@ -1 +1,151 @@ -# kangnn-experiment \ No newline at end of file +# Experiments on using Kolmogorov-Arnold Networks (KAN) on Graph Learning + +This repository contains some quick experimental results for comparing the performance of MLP, GN (GCN), KAN, and KAN+GNN on several benchmark datasets on graph learning (specifically, node classfication). + +## TL;DR (for now) +- **Using KANs or KAN + GNNs usually introduces a lot of model parameters.** This makes really skeptical to use KANs or KAN+GNNs compared to MLPs or GNNs. **(Perhaps we need a more effective way to merge KANs with GNNs)** +- Make the model (especially the KAN part) as light as possible. +- KAN+GNN generally performs great on homophilic datasets, but really suffers on heterophilic datasets (even worse than GCNs). +- KANs shines more on heterophilic datasets. +- Learning rate is the most important hyperparameter for KANs and KAN+GNNs. + + +## KAN and KAN+GNN (with reference to the original repo) +To build KAN and KAN+GNN, I have used the implementation of [Efficient-KAN](https://github.com/Blealtan/efficient-kan) for all KAN and KAN+GNN experiments. For KAN+GNN, I have combined the Efficient-KAN with [GraphKAN](https://github.com/WillHua127/GraphKAN-Graph-Kolmogorov-Arnold-Networks), which defines each KAN+GNN layer with (KAN $\rightarrow$ `torch.sparse.spmm` with the adjacency matrix). The detailed settings are all set as default unless mentinoed explicitly. The utility functions including data splits are also from [GraphKAN](https://github.com/WillHua127/GraphKAN-Graph-Kolmogorov-Arnold-Networks). (I do not claim any ownership of the Efficient-KAN and GraphKAN code.) + +## Datasets +The following datasets are used in the experiments: +- `Cora` +- `Citeseer` +- `Pubmed` +- `Cornell` +- `Texas` +- `Wisconsin` + +Note that `Cora`, `Citeseer`, and `Pubmed` are homophilic, while `Cornell`, `Texas`, and `Wisconsin` are heterophilic datasets. + +## Hyperparameter tuning +The following hyperparameters are tuned for each model. For all cases, the maximum number of epochs is set to 1000 except for GNNs. For KAN and KAN+GNN, I have also considered the option of projecting the input features to the hidden dimension as the first step +### MLP +- Hidden dim: [16, 32, 64] +- Num. layers: [1, 2, 3] +- Learning rate: [0.01, 0.001, 0.0001] +### KAN +- Hidden dim: [16, 32, 64] +- Num. layers: [1, 2] +- Project with MLP to hidden dim as the first step (`Proj`): [True, False] +- Learning rate: [0.1, 0.01, 0.001, 0.0001] +### GNN +- Architecture: GCN +- Hidden dim: [16, 32, 64] +- Num. layers: [1, 2, 3] +- Learning rate: [0.1, 0.01, 0.001, 0.0001] +### KAN+GNN +- Hidden dim: [16, 32, 64] +- Num. layers for KAN in each layer: [1, 2] +- Num. layers for message passing (`spmm`) in each layer: [1, 2, 3] +- Project with MLP to hidden dim as the first step (`Proj`): [True, False] +- Learning rate: [0.1, 0.01, 0.001, 0.0001] + +## Result 1: Best performers + +Results after hyperparameter tuning for different datasets. + +- KAN+GNN generally performs great on homophilic datasets, but really suffers on heterophilic datasets (even worse than GCNs). +- KANs shines more on heterophilic datasets. +- Using KANs or KAN + GNNs usually introduces a lot of model parameters. This makes really skeptical to use KANs or KAN+GNNs compared to MLPs or GNNs. + +### Cora +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | 0.712177 | 0.737274 | 10,038 | 2 | 16 | 1 | 0.1 | +| KAN | 0.804428 | 0.760263 | 921,600 (`Proj`=`False`) | 84 | 64 | 2 | 0.001 | +| GCN | 0.889299 | 0.866995 | 95,936 | 18 | 64 | 2 | 0.1 | +| KAN+GNN | **0.907749** | **0.875205** | 458,560 (`Proj`=`False`) | 105 | 32 | 1 (KAN) / 1 (spmm) | 0.1 | + +### Citeseer +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | 0.760902 | 0.723056 | 22,224 | 3 | 16 | 1 | 0.1 | +| KAN | 0.801504 | 0.757162 | 593,440 (`Proj`=`False`) | 65 | 16 | 2 | 0.01 | +| GCN | **0.831579** | **0.815825** | 119,584 | 38 | 32 | 2 | 0.01 | +| KAN+GNN | **0.831579** | 0.809004 | 458,560 (`Proj`=`False`) | 104 | 64 | 1 (KAN) / 1 (spmm) | 0.1 | + +### Pubmed +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | 0.890439 | 0.885932 | 36,675 | 80 | 64 | 3 | 0.001 | +| KAN | 0.884098 | 0.881115 | 80,480 (`Proj`=`False`) | 319 | 16 | 2 | 0.01 | +| GCN | 0.887649 | 0.864639 | 8,560 | 191 | 16 | 3 | 0.1 | +| KAN+GNN | **0.906416** | **0.905703** | 80,480 (`Proj`=`False`) | 330 | 16 | 1 (KAN) / 2 (spmm) | 0.01 | + + +### Cornell +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | 0.918919 | **0.914894** | 27,381 | 37 | 16 | 2 | 0.001 | +| KAN | **0.972973** | 0.829787 | 1,093,120 (`Proj`=`False`) | 46 | 64 | 2 | 0.001 | +| GCN | 0.810811 | 0.723404 | 27,536 | 5 | 16 | 2 | 0.1 | +| KAN+GNN | 0.891892 | 0.617021 | 275,840 (`Proj`=`False`) | 78 | 16 | 1 (KAN) / 3 (spmm) | 0.001 | + + + +### Wisconsin +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | **0.98** | **0.9125** | 109,509 | 4 | 64 | 2 | 0.1 | +| KAN | **0.98** | **0.9125** | 546,560 (`Proj`=`False`) | 39 | 32 | 2 | 0.01 | +| GCN | 0.84 | 0.6125 | 55,584 | 3 | 32 | 2 | 0.1 | +| KAN+GNN | 0.82 | 0.65 | 32,368 (`Proj`=`True`) | 148 | 16 | 2 | 0.001 | + + + +### Texas +| Model | Validation accuracy | Test accuracy | Number of parameters | Best epoch | Hidden dim | Num. layers | Learning rate | +| --- | --- | --- | --- | --- | --- | --- | --- | +| MLP | 0.972973 | **0.852459** | 54,757 | 48 | 32 | 2 | 0.01 | +| KAN | **1.0** | 0.704918 | 1,093,120 (`Proj`=`False`) | 23 | 64 | 2 | 0.01 | +| GCN | 0.918919 | 0.754098 | 55,584 | 25 | 32 | 2 | 0.0001 | +| KAN+GNN | 0.918919 | 0.737705 | 74,976 (`Proj`=`True`) | 1 | 32 | 2 | 0.1 | + + +## Result 2 (SHAP analysis): Rule of thumb on hyperparameter settings + +For this, I fit an XGBoost model to predict the test performance of each model based on the hyperparameters. Then, I have used the SHAP values to get the 'imporatnce' of each hyperparameter. Some trends are: + +### KAN+GNN +- Learning rate is the hyperparameter to tune if you want the most bang for the buck. +- The number of KAN per layers is more important than the number of message passing layers. In general, make the model as light as possible. + +Figure: SHAP analysis for Cora on KAN + GNN +![alt text](/kangnn_experiment/images/Cora_KANGNN_SHAP.png "Cora_KANGNN_SHAP") + +### KAN +- Similar to KAN+GNN, learning rate is the most important hyperparameter. +- Also similar to KAN+GNN, make the KAN as light as possible. + +Figure: SHAP analysis for Citeseer on KAN +![alt text](/kangnn_experiment/images/Citeseer_KAN_SHAP.png "Citeseer_KAN_SHAP") + +## Result 3: Test performance vs. Number of parameters + +I have also plotted the test performance vs. the number of parameters for all cases during hyperparameter tuning. Some notes on the figure: + +- I have used the log scale for the x-axis (number of parameters) to make the plot more readable. +- During tuning, there may be some cases where there may have multiple models with the same number of parameters. In such cases, I have highlighted the best performer with the most non-transparent color. + +Here are some observations: + +- In general, it is very easy to build a heavy model using KANs or KAN+GNNs. +- For homophilic datasets, introduce GNNs to the mix. The performance usually depends on the specific dataset. +- For heterophilic datasets, non-GNN types (MLP, KAN) usually perform better with a larger margin. + +Figure: Test performance vs. Number of parameters for Cora +![alt text](/kangnn_experiment/images/Cora_Param.png "Cora_Param.png") + +Figure: Test performance vs. Number of parameters for Wisconsin +![alt text](/kangnn_experiment/images/Wisconsin_Param.png "Wisconsin_Param.png") + +## Note + +This is an ongoing investigation, and some results may change in the future. Thanks to all the authors of the Efficient-KAN and GraphKAN repositories for their awesome work! diff --git a/images/Citeseer_GCN_SHAP.png b/images/Citeseer_GCN_SHAP.png new file mode 100644 index 0000000..0e56c5b Binary files /dev/null and b/images/Citeseer_GCN_SHAP.png differ diff --git a/images/Citeseer_KANGNN_SHAP.png b/images/Citeseer_KANGNN_SHAP.png new file mode 100644 index 0000000..050d0ae Binary files /dev/null and b/images/Citeseer_KANGNN_SHAP.png differ diff --git a/images/Citeseer_KAN_SHAP.png b/images/Citeseer_KAN_SHAP.png new file mode 100644 index 0000000..d736f74 Binary files /dev/null and b/images/Citeseer_KAN_SHAP.png differ diff --git a/images/Citeseer_MLP_SHAP.png b/images/Citeseer_MLP_SHAP.png new file mode 100644 index 0000000..0c2f45c Binary files /dev/null and b/images/Citeseer_MLP_SHAP.png differ diff --git a/images/Citeseer_Param.png b/images/Citeseer_Param.png new file mode 100644 index 0000000..635431a Binary files /dev/null and b/images/Citeseer_Param.png differ diff --git a/images/Cora_GCN_SHAP.png b/images/Cora_GCN_SHAP.png new file mode 100644 index 0000000..edbbba4 Binary files /dev/null and b/images/Cora_GCN_SHAP.png differ diff --git a/images/Cora_KANGNN_SHAP.png b/images/Cora_KANGNN_SHAP.png new file mode 100644 index 0000000..40160dd Binary files /dev/null and b/images/Cora_KANGNN_SHAP.png differ diff --git a/images/Cora_KAN_SHAP.png b/images/Cora_KAN_SHAP.png new file mode 100644 index 0000000..b5f5e8f Binary files /dev/null and b/images/Cora_KAN_SHAP.png differ diff --git a/images/Cora_MLP_SHAP.png b/images/Cora_MLP_SHAP.png new file mode 100644 index 0000000..e0251dc Binary files /dev/null and b/images/Cora_MLP_SHAP.png differ diff --git a/images/Cora_Param.png b/images/Cora_Param.png new file mode 100644 index 0000000..f57e812 Binary files /dev/null and b/images/Cora_Param.png differ diff --git a/images/Cornell_GCN_SHAP.png b/images/Cornell_GCN_SHAP.png new file mode 100644 index 0000000..d9cd7a3 Binary files /dev/null and b/images/Cornell_GCN_SHAP.png differ diff --git a/images/Cornell_KANGNN_SHAP.png b/images/Cornell_KANGNN_SHAP.png new file mode 100644 index 0000000..575acb3 Binary files /dev/null and b/images/Cornell_KANGNN_SHAP.png differ diff --git a/images/Cornell_KAN_SHAP.png b/images/Cornell_KAN_SHAP.png new file mode 100644 index 0000000..21e218e Binary files /dev/null and b/images/Cornell_KAN_SHAP.png differ diff --git a/images/Cornell_MLP_SHAP.png b/images/Cornell_MLP_SHAP.png new file mode 100644 index 0000000..8544306 Binary files /dev/null and b/images/Cornell_MLP_SHAP.png differ diff --git a/images/Cornell_Param.png b/images/Cornell_Param.png new file mode 100644 index 0000000..0ccfa97 Binary files /dev/null and b/images/Cornell_Param.png differ diff --git a/images/Pubmed_GCN_SHAP.png b/images/Pubmed_GCN_SHAP.png new file mode 100644 index 0000000..f28688c Binary files /dev/null and b/images/Pubmed_GCN_SHAP.png differ diff --git a/images/Pubmed_KANGNN_SHAP.png b/images/Pubmed_KANGNN_SHAP.png new file mode 100644 index 0000000..8153f25 Binary files /dev/null and b/images/Pubmed_KANGNN_SHAP.png differ diff --git a/images/Pubmed_KAN_SHAP.png b/images/Pubmed_KAN_SHAP.png new file mode 100644 index 0000000..c86d866 Binary files /dev/null and b/images/Pubmed_KAN_SHAP.png differ diff --git a/images/Pubmed_MLP_SHAP.png b/images/Pubmed_MLP_SHAP.png new file mode 100644 index 0000000..878cf7a Binary files /dev/null and b/images/Pubmed_MLP_SHAP.png differ diff --git a/images/Pubmed_Param.png b/images/Pubmed_Param.png new file mode 100644 index 0000000..a4b5994 Binary files /dev/null and b/images/Pubmed_Param.png differ diff --git a/images/Texas_GCN_SHAP.png b/images/Texas_GCN_SHAP.png new file mode 100644 index 0000000..6dde907 Binary files /dev/null and b/images/Texas_GCN_SHAP.png differ diff --git a/images/Texas_KANGNN_SHAP.png b/images/Texas_KANGNN_SHAP.png new file mode 100644 index 0000000..bd5eeb2 Binary files /dev/null and b/images/Texas_KANGNN_SHAP.png differ diff --git a/images/Texas_KAN_SHAP.png b/images/Texas_KAN_SHAP.png new file mode 100644 index 0000000..9bdb9e9 Binary files /dev/null and b/images/Texas_KAN_SHAP.png differ diff --git a/images/Texas_MLP_SHAP.png b/images/Texas_MLP_SHAP.png new file mode 100644 index 0000000..8f8b774 Binary files /dev/null and b/images/Texas_MLP_SHAP.png differ diff --git a/images/Texas_Param.png b/images/Texas_Param.png new file mode 100644 index 0000000..32870e8 Binary files /dev/null and b/images/Texas_Param.png differ diff --git a/images/Wisconsin_GCN_SHAP.png b/images/Wisconsin_GCN_SHAP.png new file mode 100644 index 0000000..21706ac Binary files /dev/null and b/images/Wisconsin_GCN_SHAP.png differ diff --git a/images/Wisconsin_KANGNN_SHAP.png b/images/Wisconsin_KANGNN_SHAP.png new file mode 100644 index 0000000..20bb160 Binary files /dev/null and b/images/Wisconsin_KANGNN_SHAP.png differ diff --git a/images/Wisconsin_KAN_SHAP.png b/images/Wisconsin_KAN_SHAP.png new file mode 100644 index 0000000..b3d1c38 Binary files /dev/null and b/images/Wisconsin_KAN_SHAP.png differ diff --git a/images/Wisconsin_MLP_SHAP.png b/images/Wisconsin_MLP_SHAP.png new file mode 100644 index 0000000..fadb2f9 Binary files /dev/null and b/images/Wisconsin_MLP_SHAP.png differ diff --git a/images/Wisconsin_Param.png b/images/Wisconsin_Param.png new file mode 100644 index 0000000..a83209d Binary files /dev/null and b/images/Wisconsin_Param.png differ diff --git a/main_tuning.py b/main_tuning.py new file mode 100644 index 0000000..523b188 --- /dev/null +++ b/main_tuning.py @@ -0,0 +1,556 @@ +import random +import torch +import torch.nn as nn +import numpy as np + +from torch_geometric.datasets import Planetoid, WebKB +import torch_geometric.transforms as T +from torch_geometric.nn import GCN, GAT, GraphSAGE, GIN, MLP +from utils import random_disassortative_splits +from models import KANGNN, KANonly + +# Log training time +import time + +seed = 0 + +random.seed(seed) +np.random.seed(seed) +torch.manual_seed(seed) +if torch.cuda.is_available(): + torch.cuda.manual_seed(seed) + torch.cuda.manual_seed_all(seed) + +device = torch.device("cuda" if torch.cuda.is_available() else "cpu") + + +def train_KANGNN(feat, adj, label, mask, model, optimizer, criterion): + model.train() + optimizer.zero_grad() + out = model(feat, adj) + pred, true = out[mask], label[mask] + loss = criterion(pred, true) + acc = int((pred.argmax(dim=-1) == true).sum()) / int(mask.sum()) + loss.backward() + optimizer.step() + return acc, loss.item() + + +@torch.no_grad() +def eval_KANGNN(feat, adj, model): + model.eval() + with torch.no_grad(): + pred = model(feat, adj) + pred = pred.argmax(dim=-1) + return pred + + +def train_KAN(feat, label, mask, model, optimizer, criterion): + model.train() + optimizer.zero_grad() + out = model(feat) + pred, true = out[mask], label[mask] + loss = criterion(pred, true) + acc = int((pred.argmax(dim=-1) == true).sum()) / int(mask.sum()) + loss.backward() + optimizer.step() + return acc, loss.item() + + +@torch.no_grad() +def eval_KAN(feat, model): + model.eval() + with torch.no_grad(): + pred = model(feat) + pred = pred.argmax(dim=-1) + return pred + + +def train(feat, edge_index, label, mask, model, optimizer, criterion): + model.train() + optimizer.zero_grad() + out = model(feat, edge_index) + pred, true = out[mask], label[mask] + loss = criterion(pred, true) + acc = int((pred.argmax(dim=-1) == true).sum()) / int(mask.sum()) + loss.backward() + optimizer.step() + return acc, loss.item() + + +@torch.no_grad() +def eval(feat, edge_index, model): + model.eval() + pred = model(feat, edge_index) + pred = pred.argmax(dim=-1) + return pred + + +def train_MLP(mlp, mlp_optimizer, feat, label, mask, criterion): + mlp.train() + mlp_optimizer.zero_grad() + out = mlp(feat) + pred, true = out[mask], label[mask] + loss = criterion(pred, true) + acc = int((pred.argmax(dim=-1) == true).sum()) / int(mask.sum()) + loss.backward() + mlp_optimizer.step() + return acc, loss.item() + + +@torch.no_grad() +def eval_MLP(feat, mlp): + mlp.eval() + pred = mlp(feat).argmax(dim=-1) + return pred + + +# For GNN experiments +def run_GNN_experiment( + dataset_name: str, + model_type: str, + hidden_size: int, + n_layers: int, + lr: float, + epochs: int, + patience: int = 100, + device="cuda", +): + path = "./data/" + transform = T.Compose([T.NormalizeFeatures(), T.GCNNorm(), T.ToSparseTensor()]) + + if dataset_name in {"Cora", "Citeseer", "Pubmed"}: + dataset = Planetoid(path, dataset_name, transform=transform)[0] + elif dataset_name in {"Cornell", "Texas", "Wisconsin", "Washington"}: + dataset = WebKB(path, dataset_name, transform=transform)[0] + + in_feat = dataset.num_features + out_feat = max(dataset.y) + 1 + + if model_type == "GCN": + model = GCN(in_feat, hidden_size, n_layers).to(device) + elif model_type == "GAT": + model = GAT(in_feat, hidden_size, n_layers).to(device) + elif model_type == "GraphSAGE": + model = GraphSAGE(in_feat, hidden_size, n_layers).to(device) + elif model_type == "GIN": + model = GIN(in_feat, hidden_size, n_layers).to(device) + else: + raise ValueError(f"Unknown model type: {model_type}") + + criterion = nn.CrossEntropyLoss() + + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + adj = dataset.adj_t.to(device) + feat = dataset.x.float().to(device) + label = dataset.y.to(device) + + trn_mask, val_mask, tst_mask = random_disassortative_splits(label, out_feat) + trn_mask, val_mask, tst_mask = ( + trn_mask.to(device), + val_mask.to(device), + tst_mask.to(device), + ) + + num_params = sum(p.numel() for p in model.parameters()) + # Early stopping + best_val_acc = 0.0 + best_tst_acc = 0.0 + patience_cnt = 0 + # Log training time + start_time = time.time() + # Log best epoch + best_epoch = 0 + for i in range(epochs): + train(feat, adj, label, trn_mask, model, optimizer, criterion) + pred = eval(feat, adj, model) + val_acc = int((pred[val_mask] == label[val_mask]).sum()) / int(val_mask.sum()) + tst_acc = int((pred[tst_mask] == label[tst_mask]).sum()) / int(tst_mask.sum()) + + # Early stopping + if val_acc > best_val_acc: + best_val_acc = val_acc + best_tst_acc = tst_acc + best_epoch = i + patience_cnt = 0 + else: + patience_cnt += 1 + if patience_cnt == patience: + break + + return best_val_acc, best_tst_acc, num_params, time.time() - start_time, best_epoch + + +# For KAN + GNN experiments +def run_KANGNN_experiment( + dataset_name: str, + hidden_size: int, + kan_layers: int, + mp_layers: int, + input_embed: bool, + lr: float, + epochs: int, + patience: int = 100, + device="cuda", +): + assert kan_layers in {1, 2} + assert mp_layers in {1, 2, 3} + + path = "./data/" + transform = T.Compose([T.NormalizeFeatures(), T.GCNNorm(), T.ToSparseTensor()]) + + if dataset_name in {"Cora", "Citeseer", "Pubmed"}: + dataset = Planetoid(path, dataset_name, transform=transform)[0] + elif dataset_name in {"Cornell", "Texas", "Wisconsin", "Washington"}: + dataset = WebKB(path, dataset_name, transform=transform)[0] + + in_feat = dataset.num_features + out_feat = max(dataset.y) + 1 + + model = KANGNN( + in_feat=in_feat, + hidden_feat=hidden_size, + out_feat=out_feat, + use_bias=False, + kan_layers=kan_layers, + mp_layers=mp_layers, + input_embed=input_embed, + ).to(device) + + criterion = nn.CrossEntropyLoss() + + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + adj = dataset.adj_t.to(device) + feat = dataset.x.float().to(device) + label = dataset.y.to(device) + + trn_mask, val_mask, tst_mask = random_disassortative_splits(label, out_feat) + trn_mask, val_mask, tst_mask = ( + trn_mask.to(device), + val_mask.to(device), + tst_mask.to(device), + ) + + num_params = sum(p.numel() for p in model.parameters()) + + # Early stopping + best_val_acc = 0.0 + best_tst_acc = 0.0 + # Log training time + start_time = time.time() + # Log best epoch + best_epoch = 0 + patience_cnt = 0 + for i in range(epochs): + train_KANGNN(feat, adj, label, trn_mask, model, optimizer, criterion) + pred = eval_KANGNN(feat, adj, model) + val_acc = int((pred[val_mask] == label[val_mask]).sum()) / int(val_mask.sum()) + tst_acc = int((pred[tst_mask] == label[tst_mask]).sum()) / int(tst_mask.sum()) + + # Early stopping + if val_acc > best_val_acc: + best_val_acc = val_acc + best_tst_acc = tst_acc + best_epoch = i + patience_cnt = 0 + else: + patience_cnt += 1 + if patience_cnt == patience: + break + + return best_val_acc, best_tst_acc, num_params, time.time() - start_time, best_epoch + + +# For KAN + GNN experiments +def run_KAN_experiment( + dataset_name: str, + hidden_size: int, + kan_layers: int, + input_embed: bool, + lr: float, + epochs: int, + patience: int = 100, + device="cuda", +): + assert kan_layers in {1, 2} + + path = "./data/" + transform = T.Compose([T.NormalizeFeatures(), T.GCNNorm(), T.ToSparseTensor()]) + + if dataset_name in {"Cora", "Citeseer", "Pubmed"}: + dataset = Planetoid(path, dataset_name, transform=transform)[0] + elif dataset_name in {"Cornell", "Texas", "Wisconsin", "Washington"}: + dataset = WebKB(path, dataset_name, transform=transform)[0] + + in_feat = dataset.num_features + out_feat = max(dataset.y) + 1 + + model = KANonly( + in_feat=in_feat, + hidden_feat=hidden_size, + out_feat=out_feat, + use_bias=False, + kan_layers=kan_layers, + input_embed=input_embed, + ).to(device) + + criterion = nn.CrossEntropyLoss() + + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + feat = dataset.x.float().to(device) + label = dataset.y.to(device) + + trn_mask, val_mask, tst_mask = random_disassortative_splits(label, out_feat) + trn_mask, val_mask, tst_mask = ( + trn_mask.to(device), + val_mask.to(device), + tst_mask.to(device), + ) + + num_params = sum(p.numel() for p in model.parameters()) + + # Early stopping + best_val_acc = 0.0 + best_tst_acc = 0.0 + # Log training time + start_time = time.time() + # Log best epoch + best_epoch = 0 + patience_cnt = 0 + for i in range(epochs): + train_KAN(feat, label, trn_mask, model, optimizer, criterion) + pred = eval_KAN(feat, model) + val_acc = int((pred[val_mask] == label[val_mask]).sum()) / int(val_mask.sum()) + tst_acc = int((pred[tst_mask] == label[tst_mask]).sum()) / int(tst_mask.sum()) + + # Early stopping + if val_acc > best_val_acc: + best_val_acc = val_acc + best_tst_acc = tst_acc + best_epoch = i + patience_cnt = 0 + else: + patience_cnt += 1 + if patience_cnt == patience: + break + + return best_val_acc, best_tst_acc, num_params, time.time() - start_time, best_epoch + + +# For MLP experiments +def run_MLP_experiment( + dataset_name: str, + hidden_size: int, + n_layers: int, + lr: float, + epochs: int, + patience: int = 100, + device="cuda", +): + path = "./data/" + transform = T.Compose([T.NormalizeFeatures(), T.GCNNorm(), T.ToSparseTensor()]) + + if dataset_name in {"Cora", "Citeseer", "Pubmed"}: + dataset = Planetoid(path, dataset_name, transform=transform)[0] + elif dataset_name in {"Cornell", "Texas", "Wisconsin", "Washington"}: + dataset = WebKB(path, dataset_name, transform=transform)[0] + + in_feat = dataset.num_features + out_feat = max(dataset.y) + 1 + + model = MLP( + in_channels=in_feat, + hidden_channels=hidden_size, + out_channels=out_feat, + num_layers=n_layers, + ).to(device) + + criterion = nn.CrossEntropyLoss() + + optimizer = torch.optim.Adam(model.parameters(), lr=lr) + + feat = dataset.x.float().to(device) + label = dataset.y.to(device) + + trn_mask, val_mask, tst_mask = random_disassortative_splits(label, out_feat) + trn_mask, val_mask, tst_mask = ( + trn_mask.to(device), + val_mask.to(device), + tst_mask.to(device), + ) + + num_params = sum(p.numel() for p in model.parameters()) + # Early stopping + best_val_acc = 0.0 + best_tst_acc = 0.0 + patience_cnt = 0 + # Log training time + start_time = time.time() + # Log best epoch + best_epoch = 0 + for i in range(epochs): + train_MLP( + mlp=model, + mlp_optimizer=optimizer, + feat=feat, + label=label, + mask=trn_mask, + criterion=criterion, + ) + pred = eval_MLP(feat=feat, mlp=model) + val_acc = int((pred[val_mask] == label[val_mask]).sum()) / int(val_mask.sum()) + tst_acc = int((pred[tst_mask] == label[tst_mask]).sum()) / int(tst_mask.sum()) + + # Early stopping + if val_acc > best_val_acc: + best_val_acc = val_acc + best_tst_acc = tst_acc + best_epoch = i + patience_cnt = 0 + else: + patience_cnt += 1 + if patience_cnt == patience: + break + + return best_val_acc, best_tst_acc, num_params, time.time() - start_time, best_epoch + + +# import wandb +from itertools import product + +if __name__ == "__main__": + dataset_list = [ + "Cora", + "Citeseer", + "Pubmed", + "Cornell", + "Texas", + "Wisconsin", + ] + + for dataset_name in dataset_list: + # GNN experiments first + model_name_list = ["GCN", "GAT", "GraphSAGE", "GIN"] + hidden_size_list = [16, 32, 64] + n_layers_list = [1, 2, 3] + lr_list = [0.1, 0.01, 0.001, 0.0001] + epochs = 300 + + for model_name, hidden_size, n_layers, lr in product( + model_name_list, hidden_size_list, n_layers_list, lr_list + ): + val_acc, tst_acc, num_params, train_time, best_epoch = run_GNN_experiment( + dataset_name, + model_name, + hidden_size, + n_layers, + lr, + epochs, + device=device, + ) + # Log locally to a .txt file + with open("results_GNN.txt", "a") as f: + # Config + f.write( + f"Dataset name: {dataset_name}, Model name: {model_name}, Hidden size: {hidden_size}, Num. layers: {n_layers}, lr: {lr}\n" + ) + # Results + f.write( + f"Validation accuracy: {val_acc:.6}, Test accuracy: {tst_acc:.6}, Num. parameters: {num_params}, Train time: {train_time:.2f}, Best epoch: {best_epoch}\n" + ) + + # KAN + GNN experiments next + hidden_size_list = [16, 32, 64] + kan_layers_list = [1, 2] + mp_layers_list = [1, 2, 3] + input_embed_list = [True, False] + lr_list = [0.1, 0.01, 0.001, 0.0001] + epochs = 1000 + + for hidden_size, kan_layers, mp_layers, input_embed, lr in product( + hidden_size_list, kan_layers_list, mp_layers_list, input_embed_list, lr_list + ): + val_acc, tst_acc, num_params, train_time, best_epoch = ( + run_KANGNN_experiment( + dataset_name, + hidden_size, + kan_layers, + mp_layers, + input_embed, + lr, + epochs, + device=device, + ) + ) + # Log locally to a .txt file + with open("results_KANGNN.txt", "a") as f: + # Config + f.write( + f"Dataset name: {dataset_name}, Model name: KANGNN, Hidden size: {hidden_size}, Num. KAN layers: {kan_layers}, MP layers: {mp_layers}, Input embed: {input_embed}, lr: {lr}\n" + ) + # Results + f.write( + f"Validation accuracy: {val_acc:.6}, Test accuracy: {tst_acc:.6}, Num. parameters: {num_params}, Train time: {train_time:.2f}, Best epoch: {best_epoch}\n" + ) + + # KAN experiments last + hidden_size_list = [16, 32, 64] + kan_layers_list = [1, 2] + input_embed_list = [True, False] + lr_list = [0.1, 0.01, 0.001, 0.0001] + epochs = 1000 + + for hidden_size, kan_layers, input_embed, lr in product( + hidden_size_list, kan_layers_list, input_embed_list, lr_list + ): + val_acc, tst_acc, num_params, train_time, best_epoch = run_KAN_experiment( + dataset_name, + hidden_size, + kan_layers, + input_embed, + lr, + epochs, + device=device, + ) + # Log locally to a .txt file + with open("results.txt", "a") as f: + # Config + f.write( + f"Dataset name: {dataset_name}, Model name: KAN, Hidden size: {hidden_size}, Num. KAN layers: {kan_layers}, Input embed: {input_embed}, lr: {lr}\n" + ) + # Results + f.write( + f"Validation accuracy: {val_acc:.6}, Test accuracy: {tst_acc:.6}, Num. parameters: {num_params}, Train time: {train_time:.2f}, Best epoch: {best_epoch}\n" + ) + + # MLP experiments + hidden_size_list = [16, 32, 64] + n_layers_list = [1, 2, 3] + lr_list = [0.1, 0.01, 0.001, 0.0001] + epochs = 1000 + + for hidden_size, n_layers, lr in product( + hidden_size_list, n_layers_list, lr_list + ): + val_acc, tst_acc, num_params, train_time, best_epoch = run_MLP_experiment( + dataset_name, + hidden_size, + n_layers, + lr, + epochs, + device=device, + ) + + # Log locally to a .txt file + with open("results_MLP.txt", "a") as f: + # Config + f.write( + f"Dataset name: {dataset_name}, Model name: MLP, Hidden size: {hidden_size}, Num. layers: {n_layers}, lr: {lr}\n" + ) + # Results + f.write( + f"Validation accuracy: {val_acc:.6}, Test accuracy: {tst_acc:.6}, Num. parameters: {num_params}, Train time: {train_time:.2f}, Best epoch: {best_epoch}\n" + ) diff --git a/models.py b/models.py new file mode 100644 index 0000000..906095b --- /dev/null +++ b/models.py @@ -0,0 +1,97 @@ +from torch_geometric.nn import GCN, GAT, GraphSAGE, GIN +from src.efficient_kan import KAN +import torch +import torch.nn as nn +import torch.nn.functional as F +from torch_geometric.utils import spmm + + +class KANGNN(torch.nn.Module): + def __init__( + self, + in_feat, + hidden_feat, + out_feat, + use_bias=False, + input_embed=False, + kan_layers=2, # Number of KAN layers + mp_layers=3, # Number of message passing layers + ): + super().__init__() + + self.input_embed = input_embed + self.module_list = nn.ModuleList() + # First layers + if self.input_embed: + self.lin_in = nn.Linear(in_feat, hidden_feat, bias=use_bias) + if kan_layers == 2: + self.module_list.append(KAN([hidden_feat, hidden_feat, hidden_feat])) + elif kan_layers == 1: + self.module_list.append(KAN([hidden_feat, hidden_feat])) + else: + raise ValueError("Invalid number of KAN layers") + else: + if kan_layers == 2: + self.module_list.append(KAN([in_feat, hidden_feat, hidden_feat])) + elif kan_layers == 1: + self.module_list.append(KAN([in_feat, hidden_feat])) + else: + raise ValueError("Invalid number of KAN layers") + # Intermediate MP layers + if mp_layers > 2: + for _ in range(mp_layers - 2): + if kan_layers == 2: + self.module_list.append( + KAN([hidden_feat, hidden_feat, hidden_feat]) + ) + elif kan_layers == 1: + self.module_list.append(KAN([hidden_feat, hidden_feat])) + else: + raise ValueError("Invalid number of KAN layers") + # Last layer + if mp_layers > 1: + if kan_layers == 2: + self.module_list.append(KAN([hidden_feat, hidden_feat, out_feat])) + elif kan_layers == 1: + self.module_list.append(KAN([hidden_feat, out_feat])) + else: + raise ValueError("Invalid number of KAN layers") + + def forward(self, x, adj): + if self.input_embed: + x = self.lin_in(x) + for kan in self.module_list: + x = kan(spmm(adj, x)) + return x + + +class KANonly(torch.nn.Module): + def __init__( + self, + in_feat, + hidden_feat, + out_feat, + use_bias=False, + kan_layers=2, + input_embed=False, + ): + super().__init__() + self.input_embed = input_embed + + if self.input_embed: + self.lin_in = nn.Linear(in_feat, hidden_feat, bias=use_bias) + if kan_layers == 2: + self.kan = KAN([hidden_feat, hidden_feat, out_feat]) + elif kan_layers == 1: + self.kan = KAN([hidden_feat, out_feat]) + else: + if kan_layers == 2: + self.kan = KAN([in_feat, hidden_feat, out_feat]) + elif kan_layers == 1: + self.kan = KAN([in_feat, out_feat]) + + def forward(self, x): + if self.input_embed: + x = self.lin_in(x) + x = self.kan(x) + return x diff --git a/result.ipynb b/result.ipynb new file mode 100644 index 0000000..9253738 --- /dev/null +++ b/result.ipynb @@ -0,0 +1,1651 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "Load result log from local\n", + "\n", + "There are three files, one for each of the three models.\n", + "1. results_GNN.txt: Results for GNN models (GCN, GAT, GraphSAGE, GIN)\n", + "2. restuls_KANGNN.txt: Results for KAN + GNN models\n", + "3. results_KAN.txt: Results for KAN models\n", + "\n", + "Datasets are in the following order:\n", + "1. Cora\n", + "2. Citeseer\n", + "3. Pubmed\n", + "4. Cornell\n", + "5. Texas\n", + "6. Wisconsin\n", + "\"\"\"\n", + "\n", + "\n", + "def parse_config(config_string):\n", + " config_dict = {}\n", + " parts = config_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \")\n", + " if value.isdigit():\n", + " config_dict[key] = int(value)\n", + " elif value.lower() in [\"true\", \"false\"]:\n", + " config_dict[key] = value.lower() == \"true\"\n", + " elif \".\" in value:\n", + " config_dict[key] = float(value)\n", + " else:\n", + " config_dict[key] = value\n", + " return config_dict\n", + "\n", + "\n", + "# config_string = \"Dataset name: Cora, Model name: KAN, Hidden size: 16, Num. KAN layers: 1, Input embed: True, lr: 0.1\"\n", + "# config = parse_config(config_string)\n", + "# print(config)\n", + "\n", + "\n", + "def parse_results(result_string):\n", + " result_dict = {}\n", + " parts = result_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \")\n", + " result_dict[key] = float(value) if \".\" in value else int(value)\n", + " return result_dict\n", + "\n", + "\n", + "# result_string = \"Validation accuracy: 0.688192, Test accuracy: 0.714286, Num. parameters: 24048, Train time: 0.77, Best epoch: 13\"\n", + "# results = parse_results(result_string)\n", + "# print(results)\n", + "\n", + "result_GNN = {}\n", + "\n", + "with open(\"results_GNN.txt\", \"r\") as f:\n", + " for line in f:\n", + " if line.startswith(\"Dataset name:\"):\n", + " result_config = parse_config(line)\n", + " elif line.startswith(\"Validation accuracy:\"):\n", + " result_dict = parse_results(line)\n", + "\n", + " dataset = result_config[\"Dataset name\"]\n", + " model = result_config[\"Model name\"]\n", + " hidden_size = result_config[\"Hidden size\"]\n", + " num_layers = result_config[\"Num. layers\"]\n", + " lr = result_config[\"lr\"]\n", + "\n", + " if dataset not in result_GNN:\n", + " result_GNN[dataset] = {}\n", + " if model not in result_GNN[dataset]:\n", + " result_GNN[dataset][model] = {}\n", + " if hidden_size not in result_GNN[dataset][model]:\n", + " result_GNN[dataset][model][hidden_size] = {}\n", + " if num_layers not in result_GNN[dataset][model][hidden_size]:\n", + " result_GNN[dataset][model][hidden_size][num_layers] = {}\n", + " if lr not in result_GNN[dataset][model][hidden_size][num_layers]:\n", + " result_GNN[dataset][model][hidden_size][num_layers][lr] = result_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_config(config_string):\n", + " config_dict = {}\n", + " parts = config_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \", 1) # Only split at the first ': '\n", + " if value.isdigit():\n", + " config_dict[key] = int(value)\n", + " elif value.lower() in [\"true\", \"false\"]:\n", + " config_dict[key] = value.lower() == \"true\"\n", + " elif \".\" in value:\n", + " config_dict[key] = float(value)\n", + " else:\n", + " config_dict[key] = value\n", + " return config_dict\n", + "\n", + "\n", + "def parse_results(result_string):\n", + " result_dict = {}\n", + " parts = result_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \") # Only split at the first ': '\n", + " result_dict[key] = float(value) if \".\" in value else int(value)\n", + " return result_dict\n", + "\n", + "\n", + "def parse_log(log):\n", + " config_string, result_string = log.split(\"\\n\") # Split the log by '\\n'\n", + " config = parse_config(config_string)\n", + " results = parse_results(result_string)\n", + " return config, results\n", + "\n", + "\n", + "result_KANGNN = {}\n", + "\n", + "with open(\"results_KANGNN.txt\", \"r\") as f:\n", + " for line in f:\n", + " if line.startswith(\"Dataset name:\"):\n", + " result_config = parse_config(line)\n", + " elif line.startswith(\"Validation accuracy:\"):\n", + " result_dict = parse_results(line)\n", + "\n", + " dataset = result_config[\"Dataset name\"]\n", + " model = result_config[\"Model name\"]\n", + " hidden_size = result_config[\"Hidden size\"]\n", + " num_layers = result_config[\"Num. KAN layers\"]\n", + " num_MP_layers = result_config[\"MP layers\"]\n", + " input_embed = result_config[\"Input embed\"]\n", + " lr = result_config[\"lr\"]\n", + "\n", + " if dataset not in result_KANGNN:\n", + " result_KANGNN[dataset] = {}\n", + " if model not in result_KANGNN[dataset]:\n", + " result_KANGNN[dataset][model] = {}\n", + " if hidden_size not in result_KANGNN[dataset][model]:\n", + " result_KANGNN[dataset][model][hidden_size] = {}\n", + " if num_layers not in result_KANGNN[dataset][model][hidden_size]:\n", + " result_KANGNN[dataset][model][hidden_size][num_layers] = {}\n", + " if (\n", + " num_MP_layers\n", + " not in result_KANGNN[dataset][model][hidden_size][num_layers]\n", + " ):\n", + " result_KANGNN[dataset][model][hidden_size][num_layers][\n", + " num_MP_layers\n", + " ] = {}\n", + " if (\n", + " input_embed\n", + " not in result_KANGNN[dataset][model][hidden_size][num_layers][\n", + " num_MP_layers\n", + " ]\n", + " ):\n", + " result_KANGNN[dataset][model][hidden_size][num_layers][num_MP_layers][\n", + " input_embed\n", + " ] = {}\n", + " if (\n", + " lr\n", + " not in result_KANGNN[dataset][model][hidden_size][num_layers][\n", + " num_MP_layers\n", + " ][input_embed]\n", + " ):\n", + " result_KANGNN[dataset][model][hidden_size][num_layers][num_MP_layers][\n", + " input_embed\n", + " ][lr] = result_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "def parse_config(config_string):\n", + " config_dict = {}\n", + " parts = config_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \", 1) # Only split at the first ': '\n", + " if value.isdigit():\n", + " config_dict[key] = int(value)\n", + " elif value.lower() in [\"true\", \"false\"]:\n", + " config_dict[key] = value.lower() == \"true\"\n", + " elif \".\" in value:\n", + " config_dict[key] = float(value)\n", + " else:\n", + " config_dict[key] = value\n", + " return config_dict\n", + "\n", + "\n", + "def parse_results(result_string):\n", + " result_dict = {}\n", + " parts = result_string.split(\", \")\n", + " for part in parts:\n", + " key, value = part.split(\": \") # Only split at the first ': '\n", + " result_dict[key] = float(value) if \".\" in value else int(value)\n", + " return result_dict\n", + "\n", + "\n", + "def parse_log(log):\n", + " config_string, result_string = log.split(\"\\n\") # Split the log by '\\n'\n", + " config = parse_config(config_string)\n", + " results = parse_results(result_string)\n", + " return config, results\n", + "\n", + "\n", + "result_KAN = {}\n", + "\n", + "with open(\"results_KAN.txt\", \"r\") as f:\n", + " for line in f:\n", + " if line.startswith(\"Dataset name:\"):\n", + " result_config = parse_config(line)\n", + " elif line.startswith(\"Validation accuracy:\"):\n", + " result_dict = parse_results(line)\n", + "\n", + " dataset = result_config[\"Dataset name\"]\n", + " model = result_config[\"Model name\"]\n", + " hidden_size = result_config[\"Hidden size\"]\n", + " num_layers = result_config[\"Num. KAN layers\"]\n", + " input_embed = result_config[\"Input embed\"]\n", + " lr = result_config[\"lr\"]\n", + "\n", + " if dataset not in result_KAN:\n", + " result_KAN[dataset] = {}\n", + " if model not in result_KAN[dataset]:\n", + " result_KAN[dataset][model] = {}\n", + " if hidden_size not in result_KAN[dataset][model]:\n", + " result_KAN[dataset][model][hidden_size] = {}\n", + " if num_layers not in result_KAN[dataset][model][hidden_size]:\n", + " result_KAN[dataset][model][hidden_size][num_layers] = {}\n", + " if input_embed not in result_KAN[dataset][model][hidden_size][num_layers]:\n", + " result_KAN[dataset][model][hidden_size][num_layers][input_embed] = {}\n", + " if (\n", + " lr\n", + " not in result_KAN[dataset][model][hidden_size][num_layers][input_embed]\n", + " ):\n", + " result_KAN[dataset][model][hidden_size][num_layers][input_embed][\n", + " lr\n", + " ] = result_dict" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"\n", + "For MLP models:\n", + "Dataset name -> Model name -> Hidden size -> Num. layers -> lr -> results\n", + "\"\"\"\n", + "\n", + "result_MLP = {}\n", + "\n", + "with open(\"results_MLP.txt\", \"r\") as f:\n", + " for line in f:\n", + " if line.startswith(\"Dataset name:\"):\n", + " result_config = parse_config(line)\n", + " elif line.startswith(\"Validation accuracy:\"):\n", + " result_dict = parse_results(line)\n", + "\n", + " dataset = result_config[\"Dataset name\"]\n", + " model = result_config[\"Model name\"]\n", + " hidden_size = result_config[\"Hidden size\"]\n", + " num_layers = result_config[\"Num. layers\"]\n", + " lr = result_config[\"lr\"]\n", + "\n", + " if dataset not in result_MLP:\n", + " result_MLP[dataset] = {}\n", + " if model not in result_MLP[dataset]:\n", + " result_MLP[dataset][model] = {}\n", + " if hidden_size not in result_MLP[dataset][model]:\n", + " result_MLP[dataset][model][hidden_size] = {}\n", + " if num_layers not in result_MLP[dataset][model][hidden_size]:\n", + " result_MLP[dataset][model][hidden_size][num_layers] = {}\n", + " if lr not in result_MLP[dataset][model][hidden_size][num_layers]:\n", + " result_MLP[dataset][model][hidden_size][num_layers][lr] = result_dict" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Analysis" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "def print_best_results(dataset, result_GNN, result_KANGNN, result_KAN):\n", + " \"\"\"\n", + " result_GNN\n", + " Dataset -> Model -> Hidden size -> Num. layers -> lr -> Results\n", + " \"\"\"\n", + " best_val_acc = 0\n", + " best_settings = None\n", + " best_test_acc = 0\n", + " num_parameters = 0\n", + " train_time = 0\n", + " best_epoch = 0\n", + " for hidden_size, hidden_size_results in result_GNN[dataset][\"GCN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " if results[\"Validation accuracy\"] > best_val_acc:\n", + " best_val_acc = results[\"Validation accuracy\"]\n", + " best_settings = (hidden_size, num_layers, lr)\n", + " best_test_acc = results[\"Test accuracy\"]\n", + " num_parameters = results[\"Num. parameters\"]\n", + " train_time = results[\"Train time\"]\n", + " best_epoch = results[\"Best epoch\"]\n", + "\n", + " print(\n", + " f\"Best settings for Cora with GCN: Hidden dim = {best_settings[0]}, Num. layers = {best_settings[1]}, lr = {best_settings[2]}\"\n", + " )\n", + " print(\"Best validation accuracy for Cora with GCN:\", best_val_acc)\n", + " print(\"Test accuracy for Cora with GCN:\", best_test_acc)\n", + " print(\"Number of parameters for Cora with GCN:\", num_parameters)\n", + " print(\"Train time for Cora with GCN:\", train_time)\n", + " print(\"Best epoch for Cora with GCN:\", best_epoch)\n", + " print(\"\\n\")\n", + "\n", + " \"\"\"\n", + " result_KANGNN\n", + " Dataset -> Model -> Hidden size -> Num. KAN layers -> MP layers -> Input embed -> lr -> Results\n", + " \"\"\"\n", + " # Get results for the best validation accuracy for Cora with KAN + GNN\n", + " best_val_acc = 0\n", + " best_settings = None\n", + " best_test_acc = 0\n", + " num_parameters = 0\n", + " train_time = 0\n", + " best_epoch = 0\n", + " for hidden_size, hidden_size_results in result_KANGNN[dataset][\"KANGNN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for mp_layers, mp_layers_results in num_layers_results.items():\n", + " for input_embed, input_embed_results in mp_layers_results.items():\n", + " for lr, results in input_embed_results.items():\n", + " if results[\"Validation accuracy\"] > best_val_acc:\n", + " best_val_acc = results[\"Validation accuracy\"]\n", + " best_settings = (\n", + " hidden_size,\n", + " num_layers,\n", + " mp_layers,\n", + " input_embed,\n", + " lr,\n", + " )\n", + " best_test_acc = results[\"Test accuracy\"]\n", + " num_parameters = results[\"Num. parameters\"]\n", + " train_time = results[\"Train time\"]\n", + " best_epoch = results[\"Best epoch\"]\n", + "\n", + " print(\n", + " f\"Best settings for Cora with KAN + GNN: Hidden dim = {best_settings[0]}, Num. KAN layers = {best_settings[1]}, MP layers = {best_settings[2]}, Input embed = {best_settings[3]}, lr = {best_settings[4]}\"\n", + " )\n", + " print(\"Best validation accuracy for Cora with KAN + GNN:\", best_val_acc)\n", + " print(\"Test accuracy for Cora with KAN + GNN:\", best_test_acc)\n", + " print(\"Number of parameters for Cora with KAN + GNN:\", num_parameters)\n", + " print(\"Train time for Cora with KAN + GNN:\", train_time)\n", + " print(\"Best epoch for Cora with KAN + GNN:\", best_epoch)\n", + " print(\"\\n\")\n", + "\n", + " \"\"\"\n", + " result_KAN\n", + " Dataset -> Model -> Hidden size -> Num. KAN layers -> Input embed -> lr -> Results\n", + " \"\"\"\n", + " # Get results for the best validation accuracy for Cora with KAN\n", + " best_val_acc = 0\n", + " best_settings = None\n", + " best_test_acc = 0\n", + " num_parameters = 0\n", + " train_time = 0\n", + " best_epoch = 0\n", + " for hidden_size, hidden_size_results in result_KAN[dataset][\"KAN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for input_embed, input_embed_results in num_layers_results.items():\n", + " for lr, results in input_embed_results.items():\n", + " if results[\"Validation accuracy\"] > best_val_acc:\n", + " best_val_acc = results[\"Validation accuracy\"]\n", + " best_settings = (hidden_size, num_layers, input_embed, lr)\n", + " best_test_acc = results[\"Test accuracy\"]\n", + " num_parameters = results[\"Num. parameters\"]\n", + " train_time = results[\"Train time\"]\n", + " best_epoch = results[\"Best epoch\"]\n", + "\n", + " print(\n", + " f\"Best settings for Cora with KAN: Hidden dim = {best_settings[0]}, Num. KAN layers = {best_settings[1]}, Input embed = {best_settings[2]}, lr = {best_settings[3]}\"\n", + " )\n", + " print(\"Best validation accuracy for Cora with KAN:\", best_val_acc)\n", + " print(\"Test accuracy for Cora with KAN:\", best_test_acc)\n", + " print(\"Number of parameters for Cora with KAN:\", num_parameters)\n", + " print(\"Train time for Cora with KAN:\", train_time)\n", + " print(\"Best epoch for Cora with KAN:\", best_epoch)\n", + " print(\"\\n\")\n", + "\n", + " \"\"\"\n", + " result_MLP\n", + " Dataset -> Model -> Hidden size -> Num. layers -> lr -> Results\n", + " \"\"\"\n", + " # Get results for the best validation accuracy for Cora with MLP\n", + " best_val_acc = 0\n", + " best_settings = None\n", + " best_test_acc = 0\n", + " num_parameters = 0\n", + " train_time = 0\n", + " best_epoch = 0\n", + " for hidden_size, hidden_size_results in result_MLP[dataset][\"MLP\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " if results[\"Validation accuracy\"] > best_val_acc:\n", + " best_val_acc = results[\"Validation accuracy\"]\n", + " best_settings = (hidden_size, num_layers, lr)\n", + " best_test_acc = results[\"Test accuracy\"]\n", + " num_parameters = results[\"Num. parameters\"]\n", + " train_time = results[\"Train time\"]\n", + " best_epoch = results[\"Best epoch\"]\n", + "\n", + " print(\n", + " f\"Best settings for Cora with MLP: Hidden dim = {best_settings[0]}, Num. layers = {best_settings[1]}, lr = {best_settings[2]}\"\n", + " )\n", + " print(\"Best validation accuracy for Cora with MLP:\", best_val_acc)\n", + " print(\"Test accuracy for Cora with MLP:\", best_test_acc)\n", + " print(\"Number of parameters for Cora with MLP:\", num_parameters)\n", + " print(\"Train time for Cora with MLP:\", train_time)\n", + " print(\"Best epoch for Cora with MLP:\", best_epoch)" + ] + }, + { + "cell_type": "code", + "execution_count": 43, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 64, Num. layers = 2, lr = 0.1\n", + "Best validation accuracy for Cora with GCN: 0.889299\n", + "Test accuracy for Cora with GCN: 0.866995\n", + "Number of parameters for Cora with GCN: 95936\n", + "Train time for Cora with GCN: 0.66\n", + "Best epoch for Cora with GCN: 18\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 32, Num. KAN layers = 1, MP layers = 1, Input embed = False, lr = 0.1\n", + "Best validation accuracy for Cora with KAN + GNN: 0.907749\n", + "Test accuracy for Cora with KAN + GNN: 0.875205\n", + "Number of parameters for Cora with KAN + GNN: 458560\n", + "Train time for Cora with KAN + GNN: 4.88\n", + "Best epoch for Cora with KAN + GNN: 105\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 64, Num. KAN layers = 2, Input embed = False, lr = 0.001\n", + "Best validation accuracy for Cora with KAN: 0.804428\n", + "Test accuracy for Cora with KAN: 0.760263\n", + "Number of parameters for Cora with KAN: 921600\n", + "Train time for Cora with KAN: 4.75\n", + "Best epoch for Cora with KAN: 84\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 16, Num. layers = 1, lr = 0.1\n", + "Best validation accuracy for Cora with MLP: 0.712177\n", + "Test accuracy for Cora with MLP: 0.737274\n", + "Number of parameters for Cora with MLP: 10038\n", + "Train time for Cora with MLP: 0.53\n", + "Best epoch for Cora with MLP: 2\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Cora\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 32, Num. layers = 2, lr = 0.01\n", + "Best validation accuracy for Cora with GCN: 0.831579\n", + "Test accuracy for Cora with GCN: 0.815825\n", + "Number of parameters for Cora with GCN: 119584\n", + "Train time for Cora with GCN: 0.82\n", + "Best epoch for Cora with GCN: 38\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 64, Num. KAN layers = 1, MP layers = 1, Input embed = False, lr = 0.1\n", + "Best validation accuracy for Cora with KAN + GNN: 0.831579\n", + "Test accuracy for Cora with KAN + GNN: 0.809004\n", + "Number of parameters for Cora with KAN + GNN: 2369920\n", + "Train time for Cora with KAN + GNN: 15.03\n", + "Best epoch for Cora with KAN + GNN: 104\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 16, Num. KAN layers = 2, Input embed = False, lr = 0.01\n", + "Best validation accuracy for Cora with KAN: 0.801504\n", + "Test accuracy for Cora with KAN: 0.757162\n", + "Number of parameters for Cora with KAN: 593440\n", + "Train time for Cora with KAN: 11.82\n", + "Best epoch for Cora with KAN: 65\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 16, Num. layers = 1, lr = 0.1\n", + "Best validation accuracy for Cora with MLP: 0.760902\n", + "Test accuracy for Cora with MLP: 0.723056\n", + "Number of parameters for Cora with MLP: 22224\n", + "Train time for Cora with MLP: 0.14\n", + "Best epoch for Cora with MLP: 3\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Citeseer\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 16, Num. layers = 3, lr = 0.1\n", + "Best validation accuracy for Cora with GCN: 0.887649\n", + "Test accuracy for Cora with GCN: 0.864639\n", + "Number of parameters for Cora with GCN: 8560\n", + "Train time for Cora with GCN: 2.41\n", + "Best epoch for Cora with GCN: 191\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 16, Num. KAN layers = 1, MP layers = 2, Input embed = False, lr = 0.01\n", + "Best validation accuracy for Cora with KAN + GNN: 0.906416\n", + "Test accuracy for Cora with KAN + GNN: 0.905703\n", + "Number of parameters for Cora with KAN + GNN: 80480\n", + "Train time for Cora with KAN + GNN: 27.13\n", + "Best epoch for Cora with KAN + GNN: 330\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 16, Num. KAN layers = 2, Input embed = False, lr = 0.01\n", + "Best validation accuracy for Cora with KAN: 0.884098\n", + "Test accuracy for Cora with KAN: 0.881115\n", + "Number of parameters for Cora with KAN: 80480\n", + "Train time for Cora with KAN: 25.33\n", + "Best epoch for Cora with KAN: 319\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 64, Num. layers = 3, lr = 0.001\n", + "Best validation accuracy for Cora with MLP: 0.890439\n", + "Test accuracy for Cora with MLP: 0.885932\n", + "Number of parameters for Cora with MLP: 36675\n", + "Train time for Cora with MLP: 0.44\n", + "Best epoch for Cora with MLP: 80\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Pubmed\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 16, Num. layers = 2, lr = 0.1\n", + "Best validation accuracy for Cora with GCN: 0.810811\n", + "Test accuracy for Cora with GCN: 0.723404\n", + "Number of parameters for Cora with GCN: 27536\n", + "Train time for Cora with GCN: 0.57\n", + "Best epoch for Cora with GCN: 5\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 16, Num. KAN layers = 1, MP layers = 3, Input embed = False, lr = 0.001\n", + "Best validation accuracy for Cora with KAN + GNN: 0.891892\n", + "Test accuracy for Cora with KAN + GNN: 0.617021\n", + "Number of parameters for Cora with KAN + GNN: 275840\n", + "Train time for Cora with KAN + GNN: 1.18\n", + "Best epoch for Cora with KAN + GNN: 78\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 64, Num. KAN layers = 2, Input embed = False, lr = 0.001\n", + "Best validation accuracy for Cora with KAN: 0.972973\n", + "Test accuracy for Cora with KAN: 0.829787\n", + "Number of parameters for Cora with KAN: 1093120\n", + "Train time for Cora with KAN: 0.66\n", + "Best epoch for Cora with KAN: 46\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 16, Num. layers = 2, lr = 0.001\n", + "Best validation accuracy for Cora with MLP: 0.918919\n", + "Test accuracy for Cora with MLP: 0.914894\n", + "Number of parameters for Cora with MLP: 27381\n", + "Train time for Cora with MLP: 0.22\n", + "Best epoch for Cora with MLP: 37\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Cornell\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 32, Num. layers = 2, lr = 0.0001\n", + "Best validation accuracy for Cora with GCN: 0.918919\n", + "Test accuracy for Cora with GCN: 0.754098\n", + "Number of parameters for Cora with GCN: 55584\n", + "Train time for Cora with GCN: 0.68\n", + "Best epoch for Cora with GCN: 25\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 32, Num. KAN layers = 2, MP layers = 1, Input embed = True, lr = 0.1\n", + "Best validation accuracy for Cora with KAN + GNN: 0.918919\n", + "Test accuracy for Cora with KAN + GNN: 0.737705\n", + "Number of parameters for Cora with KAN + GNN: 74976\n", + "Train time for Cora with KAN + GNN: 0.53\n", + "Best epoch for Cora with KAN + GNN: 1\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 64, Num. KAN layers = 2, Input embed = False, lr = 0.01\n", + "Best validation accuracy for Cora with KAN: 1.0\n", + "Test accuracy for Cora with KAN: 0.704918\n", + "Number of parameters for Cora with KAN: 1093120\n", + "Train time for Cora with KAN: 0.56\n", + "Best epoch for Cora with KAN: 23\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 32, Num. layers = 2, lr = 0.01\n", + "Best validation accuracy for Cora with MLP: 0.972973\n", + "Test accuracy for Cora with MLP: 0.852459\n", + "Number of parameters for Cora with MLP: 54757\n", + "Train time for Cora with MLP: 0.24\n", + "Best epoch for Cora with MLP: 48\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Texas\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best settings for Cora with GCN: Hidden dim = 32, Num. layers = 2, lr = 0.1\n", + "Best validation accuracy for Cora with GCN: 0.84\n", + "Test accuracy for Cora with GCN: 0.6125\n", + "Number of parameters for Cora with GCN: 55584\n", + "Train time for Cora with GCN: 0.54\n", + "Best epoch for Cora with GCN: 3\n", + "\n", + "\n", + "Best settings for Cora with KAN + GNN: Hidden dim = 16, Num. KAN layers = 2, MP layers = 1, Input embed = True, lr = 0.001\n", + "Best validation accuracy for Cora with KAN + GNN: 0.82\n", + "Test accuracy for Cora with KAN + GNN: 0.65\n", + "Number of parameters for Cora with KAN + GNN: 32368\n", + "Train time for Cora with KAN + GNN: 1.38\n", + "Best epoch for Cora with KAN + GNN: 148\n", + "\n", + "\n", + "Best settings for Cora with KAN: Hidden dim = 32, Num. KAN layers = 2, Input embed = False, lr = 0.01\n", + "Best validation accuracy for Cora with KAN: 0.98\n", + "Test accuracy for Cora with KAN: 0.9125\n", + "Number of parameters for Cora with KAN: 546560\n", + "Train time for Cora with KAN: 0.72\n", + "Best epoch for Cora with KAN: 39\n", + "\n", + "\n", + "Best settings for Cora with MLP: Hidden dim = 64, Num. layers = 2, lr = 0.1\n", + "Best validation accuracy for Cora with MLP: 0.98\n", + "Test accuracy for Cora with MLP: 0.9125\n", + "Number of parameters for Cora with MLP: 109509\n", + "Train time for Cora with MLP: 0.17\n", + "Best epoch for Cora with MLP: 4\n" + ] + } + ], + "source": [ + "print_best_results(\n", + " dataset=\"Wisconsin\",\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import xgboost as xgb\n", + "import shap\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def get_GCN_shap_summary_plot(result_GNN, dataset):\n", + " # Prepare the data\n", + " X = []\n", + " y = []\n", + "\n", + " # for dataset, dataset_results in result_GNN.items():\n", + " # for model, model_results in dataset_results.items():\n", + " # for hidden_size, hidden_size_results in model_results.items():\n", + " # for num_layers, num_layers_results in hidden_size_results.items():\n", + " # for lr, results in num_layers_results.items():\n", + " # X.append([hidden_size, num_layers, lr])\n", + " # y.append(results[\"Test accuracy\"])\n", + " model_results = result_GNN[dataset][\"GCN\"]\n", + " for hidden_size, hidden_size_results in model_results.items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " X.append([hidden_size, num_layers, lr])\n", + " y.append(results[\"Test accuracy\"])\n", + "\n", + " X = np.array(X)\n", + " y = np.array(y)\n", + "\n", + " # Fit the XGBoost model\n", + " model = xgb.XGBRegressor()\n", + " model.fit(X, y)\n", + "\n", + " # Calculate the Shapley values\n", + " explainer = shap.Explainer(model)\n", + " shap_values = explainer(X)\n", + "\n", + " shap.summary_plot(\n", + " shap_values,\n", + " X,\n", + " feature_names=[\"Hidden size\", \"Num. layers\", \"lr\"],\n", + " title=\"Shapley values for GNN models\",\n", + " plot_type=\"violin\",\n", + " )\n", + "\n", + "\n", + "def get_KANGNN_shap_summary_plot(result_KANGNN, dataset):\n", + " # result_KANGNN\n", + " X = []\n", + " y = []\n", + "\n", + " # for dataset, dataset_results in result_KANGNN.items():\n", + " # for model, model_results in dataset_results.items():\n", + " # for hidden_size, hidden_size_results in model_results.items():\n", + " # for num_layers, num_layers_results in hidden_size_results.items():\n", + " # for mp_layers, mp_layers_results in num_layers_results.items():\n", + " # for input_embed, input_embed_results in mp_layers_results.items():\n", + " # for lr, results in input_embed_results.items():\n", + " # X.append(\n", + " # [hidden_size, num_layers, mp_layers, input_embed, lr]\n", + " # )\n", + " # y.append(results[\"Test accuracy\"])\n", + " model_results = result_KANGNN[dataset][\"KANGNN\"]\n", + " for hidden_size, hidden_size_results in model_results.items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for mp_layers, mp_layers_results in num_layers_results.items():\n", + " for input_embed, input_embed_results in mp_layers_results.items():\n", + " for lr, results in input_embed_results.items():\n", + " X.append([hidden_size, num_layers, mp_layers, input_embed, lr])\n", + " y.append(results[\"Test accuracy\"])\n", + "\n", + " X = np.array(X)\n", + " y = np.array(y)\n", + "\n", + " # Fit the XGBoost model\n", + " model = xgb.XGBRegressor()\n", + " model.fit(X, y)\n", + "\n", + " # Calculate the Shapley values\n", + " explainer = shap.Explainer(model)\n", + " shap_values = explainer(X)\n", + "\n", + " shap.summary_plot(\n", + " shap_values,\n", + " X,\n", + " feature_names=[\n", + " \"Hidden size\",\n", + " \"Num. KAN layers\",\n", + " \"MP layers\",\n", + " \"Input embed\",\n", + " \"lr\",\n", + " ],\n", + " title=\"Shapley values for KAN + GNN models\",\n", + " plot_type=\"violin\",\n", + " )\n", + "\n", + "\n", + "def get_KAN_shap_summary_plot(result_KAN, dataset):\n", + " # result_KAN\n", + " X = []\n", + " y = []\n", + "\n", + " # for dataset, dataset_results in result_KAN.items():\n", + " # for model, model_results in dataset_results.items():\n", + " # for hidden_size, hidden_size_results in model_results.items():\n", + " # for num_layers, num_layers_results in hidden_size_results.items():\n", + " # for input_embed, input_embed_results in num_layers_results.items():\n", + " # for lr, results in input_embed_results.items():\n", + " # X.append([hidden_size, num_layers, input_embed, lr])\n", + " # y.append(results[\"Test accuracy\"])\n", + " model_results = result_KAN[dataset][\"KAN\"]\n", + " for hidden_size, hidden_size_results in model_results.items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for input_embed, input_embed_results in num_layers_results.items():\n", + " for lr, results in input_embed_results.items():\n", + " X.append([hidden_size, num_layers, input_embed, lr])\n", + " y.append(results[\"Test accuracy\"])\n", + "\n", + " X = np.array(X)\n", + " y = np.array(y)\n", + "\n", + " # Fit the XGBoost model\n", + " model = xgb.XGBRegressor()\n", + " model.fit(X, y)\n", + "\n", + " # Calculate the Shapley values\n", + " explainer = shap.Explainer(model)\n", + " shap_values = explainer(X)\n", + "\n", + " shap.summary_plot(\n", + " shap_values,\n", + " X,\n", + " feature_names=[\"Hidden size\", \"Num. KAN layers\", \"Input embed\", \"lr\"],\n", + " plot_type=\"violin\",\n", + " )\n", + "\n", + "\n", + "def get_MLP_shap_summary_plot(result_MLP, dataset):\n", + " # result_MLP\n", + " X = []\n", + " y = []\n", + "\n", + " model_results = result_MLP[dataset][\"MLP\"]\n", + " for hidden_size, hidden_size_results in model_results.items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " X.append([hidden_size, num_layers, lr])\n", + " y.append(results[\"Test accuracy\"])\n", + "\n", + " X = np.array(X)\n", + " y = np.array(y)\n", + "\n", + " # Fit the XGBoost model\n", + " model = xgb.XGBRegressor()\n", + " model.fit(X, y)\n", + "\n", + " # Calculate the Shapley values\n", + " explainer = shap.Explainer(model)\n", + " shap_values = explainer(X)\n", + "\n", + " shap.summary_plot(\n", + " shap_values,\n", + " X,\n", + " feature_names=[\"Hidden size\", \"Num. layers\", \"lr\"],\n", + " title=\"Shapley values for MLP models\",\n", + " plot_type=\"violin\",\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvQAAAEDCAYAAABao5AqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABpzUlEQVR4nO3dd3hUxfrA8e/Zze4m2d30kARC7yCdKyIIWCjKBUFUbIBcFbEh9q7oz4IFxS5cRQTLVRAFRRRQBEGKIioKSg09pG6STdk6vz+WrCzZUNI3vJ/nyQM7Z86Zma3vmTMzR1NKKYQQQgghhBAhSVfbFRBCCCGEEEJUnAT0QgghhBBChDAJ6IUQQgghhAhhEtALIYQQQggRwiSgF0IIIYQQIoRJQC+EEEIIIUQIk4BeCCGEEEKIECYBvRBCCCGEECFMAnohhBBCCCFCmAT0QgghhBCiXpgyZQoWi+WE29LS0tA0jfnz55/S8Su6X3ULq+0KCCGEEEIIUZNSUlJYu3Ytbdq0qe2qVAkJ6IUQQgghxGnFZDJx1lln1XY1qowMuRFCCCGEEKeVYENnnE4nkyZNIi4ujpiYGG688UY+/PBDNE0jLS0tYP+SkhJuvfVWYmNjSUlJ4e6778btdtdwK/4hAb0QQgghhKhX3G53mT+v13vcfe6//35mzJjBfffdx8cff4zX6+X+++8Pmvehhx5Cp9PxySefMHHiRKZNm8bbb79dHU05KTLkRgghRJ3lcrl49913ARg/fjwGg6GWaySEqFXaJb5/1YJysxQWFpb7XWE2m4Om5+Tk8Oabb/Lwww9z3333ATB48GAuuOAC9u3bVyZ/r169eOWVVwAYOHAgK1asYP78+UycOPFUWlNlJKAXQgghhBAh4sSDSyIiIli1alWZ9JkzZ/Lhhx8G3Wfz5s2UlJQwfPjwgPSLL76Yb7/9tkz+QYMGBTzu0KED33333QnrVl0koBdCCCGEECFCO2EOnU5Hz549y6R/+eWX5e5z6NAhABITEwPSGzRoEDR/TExMwGOj0UhJSckJ61ZdZAy9EEIIIYQIERonE9SfqpSUFAAyMzMD0jMyMqq8rOogAb0QQgghhAgR1RPQn3HGGYSHh7Nw4cKA9M8//7zKy6oOMuRGCCGEEEKEiKoP5gHi4+O56aabeOqppwgPD6dr167MmzePbdu2Ab5hPHVZ3a6dEEIIIYQQftXTQw8wdepUJkyYwDPPPMNll12Gy+XyL1sZHR1dLWVWFU0ppWq7EkIIIUQwsmylECKAdrXvX/VBjRQ3ZswYVq9eze7du2ukvIqSITdCCCGEECJEVE/vPMDKlStZs2YNPXr0wOv18uWXX/LBBx/w4osvVluZVUUCeiGEEEIIERLUkYC+OsJ6i8XCl19+ybPPPktxcTHNmzfnxRdfZPLkydVQWtWSgF4IIYQQQoSI6uuh79GjBz/++GO1Hb86SUAvhBBCCCFCQnX20IcyCeiFEEIIIUSIkAUag5GAXgghhBBChAQlffNBSUAvhBBCCCFChAT0wUhAL4QQQgghQoL00AcnAb0QQgghhAgJEtAHJwG9EEIIIYQICUomxQYlAb0QQgghhAgR0kMfjAT0QgghhBAiJMiQm+AkoBdCCCGEECFBAvrgJKAXQgghhBAhQgL6YCSgF0IIIYQQIUEmxQYnAb0QQgghhAgJMuQmODnNEUIIIYQQIoRJD70QQgghhAgJMuQmOAnohRBCCCFESJAhN8FJQC+EEEIIIUKCBPTBSUAvhBBCCCFCggT0wUlAL4QQQgghQoQE9MFIQC+EEELUcR6XB3eJB+VSeJzeI38eirNKMFgMKI9CKVAe5U8LC9ejaYBOQ3m8uEu8RCaGozNo6I169AYdmh4MFgN6ow5Nk0BJ1H1emRQblAT0QgghRDVSSlGU68Rpd+MocFOc58KR7yI/vYTMbQVYGphw2N2+v3w3mdsLMITr8XoU7hIPbocXfUEJxhJn9VVSgzCTHn24Hq/bS1i4nqimZkzRRoxWA3qTjuIsB416J2KKMRIeayI8xkiYOQxLSgSGSAknRE2RE89g5BMohBBCnCKlFMV5bnIzHDjsHuw5TgpzXRRkOzmwJgOLRUexzUVxrpOSAjfKo8o9li5M8/eul3IUuAPyhHm91dYWABS+k4cSDwAuu5viLAcAml5DeRUo2LsiHYI0RW/SER5rIjLRhC5cjz5MR0qvBMxJEZiTwolMiiAywYQpxihXAkSllP9JOr1JQC+EEEIcxeXwYM9xkZ/lpCDLSX6Wk52/5KFp4LB7yM92Umhz43V5A/oKNR3ovIrI/ELyTqE8r7tuhygBJyPlVNXj8FKYXkxherE/7dCGrDInMnqTDnNyBNbGZqwNI1EoYlpYSewUi7Wx2TckSC8BvyifrEMfnAT0QgghThsel5f8bBf5mQ4O/G0nP9OJ16PIz3SSm+4g77ADZ3Fgb7imA3USHeTKC15v3Q7Oa1KwqxIeh5f8PYXk7ylEC9NQx5zMaHoNU4wRvUGjcb9krE3MRDU2Y20ciTU1kvAYU01VX9RRsspNcBLQCyGEqBfcHkVmroddB92UOBUZOR4ycj1k5LhRqw8S5XDisHv+2UH5QgOdXsN7nCExJxPMi1N3bDAPvpOAkmzfUJ+/F+wBL77hPkeEReiJbmYhuoWF6KYWwmONmFMiSeoWR0SCSYbznAYkoA9OAnohhBB1ntuj40CmB1uhIiPXQ6bNyy/bHDicisISX1peoUJ5/7kgr9NApwOvR3FedjGOco59vGBe1J5gAb+72EP21jxy/s7zrd5zVB59uB5r40iiGpvxurw0H9LIF/w3tRCRKMF+fSEBfXAS0AshhKgVSinsTki3K9ILff9uTvey7ZCLcL1iv02x1+bhUNYIzij08sHvNv++Oh2UN09U4VsHw6vA6wFN4vV6R3nxvcBH8ZR4sG0vwLa9AID9P2T4t+nD9ejDdcS3iyapSxxRzSxENTET3cwiPfshRgL64CSgF0KcMqUULq/C4dFwesDhAYcbch2+tbBBw+UFpweK3F4OFGgkm8GjwO31/bstR9HQAga9b4UPr4LMIkWxG1Kt/3xhe7yKv3OhYwLoNc3X66rBgQJFQoRGdDiE6UCvgUcp8h0aja0aBj0YdL4/h1sRH6lh1IFR7/szaApTGBj0MsGqqrg8ioxCRa4D8hyQVQzZxXCgwMvqvV4aRmocLlQctENGoeKwHcrE5CUucLgJ0/neKwAR3jB0BC7ZWN2Lvoj6xVPiwVPi4dC6LA7/nB0wEVnTaUS3sBDTwkp0UzNRTS3oTTqSesRjSYmUSbp1jAT0wUlAL0Q95fYqCpyQXazId4LLq2F3KuwuyC1R/JwOzaM1Cl1gdykKXbDxsCLKqGHQqSPpkF4I+Q6INECJGxxeX/B+ap2ex8sdbFt5+Y9NP5V9g9Ph9Qf/Og1KPNDQDOFhEHHk70ABNI+GBmaNcL1vW75T4fRAx3iN8DCN8DAw6hS786B7Er40PZjCoNAJseEQbdIw6sF05KRCpykiwzQMR040wnTUSE+hx6tweaHErXB6NIrdvnaXuH0nSmjg8fpe/0IXHLIrtuVCQ4vvvZDvBNuR95DF6MuT5/Ttf+SMLoDmUSi3Qq8pTji65ch2twTsopocu6qQ8ipsOwqw7Szwzac4OtgP07AkRxDd3ILOqCOmmYWkHvFYU81YUyMxWgw1Xf3TXigH9AcOHGDVqlVkZGQwatQoUlNT8Xg85OXlER0djV6vr/CxJaAPMT///DMTJ07kscceY9iwYbVdHVENHG5fAJ53pJdzp82Ly6vhUb5gKs8J+/O9/JkNjaM08hyKPAfklsBOmy8wLHGD8yQCIp2mOLrzyeWF8gLiAldVtK7u8XLkCsNRcyXT8svm21Pge76O3HjzyHMFX+xUKHxXJgKD1YqP8zDo/rnqEKbzvZ56DSwG0DTQAe4j74eECF9JpaXllPhOQsI0X328CordvgBdp/kC5YrGyoYjFzO8R7U1o7j8/KVK6yZD1UWdpoIE+25Fwf4iCvYXAbAX4J0d/u1hkb477jbsnYg11YylYSTWRpGExxqJaWWVgL8ahGJAr5Tirrvu4rXXXsPtdqNpGp06dSI1NRW73U6zZs144oknmDx5coXLkIBeiCqilKLYrch3av5gPM+h+C1DEWEAp+dI8O2E7bmKgwUQHe4LxG0O31++o7ww0JeqAXqdLzhTgP5g2R7PEk+ZncvlVWWGoYrjKH2ujn7OXdXQk+zyHnPcI+UVBjmp2m8vm1biLpt29HEqUy8hxD/cRR7ceNj9zcF/Vks66nNmiAzDnByOtbEZfbie8GgjyT3jMSdH+P6SwgmLkFDsVITiOvTPP/88L7/8Mvfddx/nn38+AwcO9G+Ljo7mkksu4dNPP5WAXojK8AXikO9QZBSD26uR7/D1kuc74ccDiqRIX6BcmvZnlm8yn1Hv6zEvcIDdCceLpfWaQnekY6GigZEicCiC9HgKIUQdEKR3H8BV5Ma2y45t1z9n3n99khaQR9NxpHc/gsikCMwNwnE7vMS1ifJN2o03EZFowmg1yORdQvNOsf/9738ZO3YsTz/9NNnZ2WW2d+7cmSVLllSqDAno6yGlFMXFxURGRtZ2VaqNw63IKv5njK/dCQftXjKKNSwGKHByZKy4lx8PQIsYjSKXr3c8zwG7bL5hBx4vFLlP3Eutw9czDoHDDU6Fp4L7CSGEqL+UF/L3FpK/txBNr6FpwU8ONB3oDDqimliITDQRkRCOKdZAcaaD5H/FE5kQjinGSHiMEVOMkcgG4fXyBCAUh9zs27ePs88+u9ztZrOZ/PwgYz1PgQT0Ie7oMfXFxcXMmzeP/fv3c+2113LjjTfWdvWqTYd3PewKem9135dg6UooyuvrNV+f7hvjXNF42ousqiFEfVS6xGV9KadqyqrJ2oqjKY8qf0kAr+9Ou7nb88ndfuQOxhrggV1fHSiTv+tNbfnXHR2qtb61IRSH3DRo0IB9+/aVu33jxo00adKkUmVIQF9PfPTRR+Tl5TFixAji4+NJSkqq7SpVq/TC428/dmy4jBM/jSjlmzlal9TFOglRnvoaz9ezz+Hx7mCs6aAos6TmKlODQvHn/JJLLuGtt97i2muvJTo6GvhnRbOlS5cye/Zs7r333kqVEXqnOSKo9PR05s6dyw033MAll1xCnz59artK5OTk4HD8c29Gu91OQUGB/7HT6SwzluzQoUPHfZyeno4KsizeP0Lxo15RdbGtdbFOVaG62lUXn6+qqFPNtKsuPntC1AlHnbhUxW/tsb/ntcmLDm+Iha+PP/44KSkpdO3albFjx6JpGs8++yx9+/blwgsvpHPnzjz44IOVKiO0nhFRrqFDhxIXF1fb1QgQFxeHyWTyP7ZYLFitVv9jo9FIfHx8wD4pKSnHfZycnHyCMYH1p/flxOpiW+tinapCdbWrLj5fVVGnmmlXXXz2hKhrquK39tjf89qlEWqf/ujoaNatW8e9997LgQMHCA8PZ+XKldhsNh577DF++OGHSs97lCE39URlx14JUW/UxUvqdbFOAqi5sCCk3gEhVdlTcDp9Do97JTu0hWrLIiIiePjhh3n44Yer5fjSQ19PhIeH13YValT3JDCewrtXr/luimM4crMeIYSoryr/FSdfknWaBrowDS2s/NdJC9MR1yaqBitVc0JxyE1NkB56EZJ+uNL31vV4lW/ZShfklviWstTQsLt868TnORU/HoDm0b7lLQucvjue/nrYtya8TudbxtJ+ZDnLE91dVaf5TghK15HXCN3eAiGEEHWHLkzz3fU5yJKVRmsYYRF6NL2OBl3jiIgzERFvIjzOiCPfSYPOcYTHmjDF+patDAvX13wDakgoLlv5n//854R5NE3jnXfeqXAZEtCLkKbXaUSZIMoEDS1Hf8j/+f8NnU/+eF7lOxHId/ru2lrggs2ZCqvRd0JQmr4504vdDVaDRm6JItcBGUW+1Xf02vHv1nr0SYBB51ubXlbhEUKIekrDdxfZYwN1DUxWA16lSO4ZjyU5ksgG4UfWj4foFlasjSKJiDOhM0iPdKlQ/Ln87rvvysz/83g8HDp0CI/HQ2JiImazuVJlSEAvxFF02j8nCByZv9srJVhvwPG/XN1eRb7D1+uflqdA811FyDuStiNXsa9AkRCpke8Am0ORUQR/ZUOkwXezqyLXib+4Sr/jlYIgnTpCCCFqgC6sbMBuMIdhbWwmqnEklkaR6MP1RMQaadA1DnNyBJEJ4RKoV0AorkOflpYWNN3lcjFjxgymT5/OsmXLKlWGBPRCVIMwnUZcBMRFQPOYil0eLL1acLhQUeyGQrdGvkOR54BDhYo/s6Ch5chVAyfklSjWpUOcCRxe3/CiwiPbTibW12m+KwUaEKbz7aNO47vbavjm0OnwnSyVPi9Q8bsFH31sveZ7jq1G33FL53fklECSGSLDfOlhOsguhjANUiy++uh04PTAnjxod2TxitI5cNtzISHCd2Lo9vrqmVXsG1YWF+Hbr/QvpwRMet//T/aEUF960zY5iRSnkWABuynGQERCOJpOo+m5yVgaRWJNjcTS0PdXn4e91KZQHHJTHoPBwK233sqWLVu49dZbWbx4cYWPJQF9iOnZsyc///xzuY9F/fHP1YLgQ4lOhcOtsLt8QZ3dBflOxd85EBeOfw5CoQs2piuiTWDQ+64QFLlhX77ioB2Szb7HxW5f3kN2X9DoUeDy+OYf1PWhQ6UTow1HAmKDHuIjfEFteBigfEOnujaAiDCN8DBf+o5cRZtYjQZmCNf70oucCocX2sX9k8+kU2SXaLSM0fzHNOlBpynMYRAepmEK8wXFde2W7B6vosTte2+4PFDk1vzvi6wiLzvzNGJNpcPOFHkOxQ/7fScfdhfkFENuCWQW/TPHxO9IU0tPBmSYmahzNND0WsD4dS1Mw5ISSUwLC1FNLYSZdMS0tJLQKRZro0gMkRJC1QZvPQroS3Xp0oW5c+dW6hjybhTiNGA6EkjGR5SmaPRuWPXluD1eXF4Nl9cX1Dk9vn/zHAqTXsOjfL3Gbq/vykO0CXQ6Da/y9fgWOBUON8RG/POFrZTiUCE0tmq+icxH/vIdiiiTL8AO04FeB3oUbgVWo+YL3PW+4D1MpzDotFoMouv+D5Bep2E2gtkYrK6n1tPo8ihySnxXFrKKFel2xbr9ioQIyCiEjELFIbtiU7rCq3wnmv4w6kjxYTrff8ucHAhRhbQwDaM5jJReiUQ3NRPV1EJUUzPm5AiiGpvRdHX/s3u6qU899KWWLVsm69ALIeqOML2OMD1ElNkS7Au4MmlVkVdUF4NeI8ns670vfe4vb19+frdXkVkI6XbF31k6th0OQwcczPOyz+bh9x25uBzhGJUWdHnt0uFiQvjvOXTUiaDepMPaxIxOr9GgSxwNusQS1dRCdFMLEYmmOne1TBxfKH7Un3jiiaDpNpuNVatW8csvv3D//fdXqgxNqXp89wEhhBAhzeVy8e677wIwdty1FBTrybJ5ybB5+HW7gxInlDgV6dke0nM8ZNs8qKOCOU0DvaYYsGt/2YOrSvb1Bdlf83qx2Isqc9SgjPZiDE53lR83FGk6QBc4PKY0aI9tYcWaGolS0PT8FAna66HN2isAdFKTarkmJ0+nCz6RNzY2lpYtW3L99ddzww03VOp9Kj30QgghQoJep5EYoycxRk97DPTvWvaGekopcvK9ZOV5ycjxkJHr4XCOm2xDDAkeJ0U5LgptrjJBv6bXUB5Vn2+wGXI0nYY66tKLptOIamYmoUMMUU3MRDUxY06JwJoaiTXVLEH7aSIUP6Jeb/WPHZSAXgghRL2haRrx0Xrio/W0bWL4Z8OoaP9/vR5Foc3F4d1F5Gc6cRZ7yM9ykp/pJGtfMdn7SvB6VUDQ7zu4L/gvky5OmS5MQ3kJCNh1Bh3m5IgjPeq+Hvaoxmasjc1YUyMxRRlrscairpC7xAYnAb0QQojTik6vYY03Yo0vP0AsDfoLsp3kZznZvSkP0HAWe8jL9AX/+RkleJzB+ws13ZGlREOxO7ESSq90BN12pIc9urkFa8NIzCkR6A06YlpZiWsTTUSCDI0RJxYKH6m9e/dWaL8mTZpUuEwJ6IUQQohjHB30N2wD7c6OC5rP5fBSmOvEnuvCnuPCnuNk75pMomLCKMlzUZTjoDDLScHhkrJ3Ci2l+YLd0li23Hw1TNP76qQgYLz6sQyWMMzJEZiTwolMDEcz6NCH6Ug5M8GXluTbpjfKuuyi8kJhlZtmzZpV6OTU4znObeZPQAJ6IYQQooIMJh0xyeHEJP8znr/nsOSgeZVX4ShwU5LvojjPRWGWg6wddiJiDDgK3Tjtbhx2Nwd/txERY0R5Fc5CD65iN65DXnR5XnR6Da9L4XV7K9VVqek131UEj8JoNWCwGDBEhmEw63Ha3RjMYcS1jsIYZcBoNaAP1+PMc5LULZ7wOCOmGCPhMUaMVoMs7ShqVCjcKXbWrFk1frVJAnohhBCiBmg6jfBoA+HRBmIa+9JaDWhQoWMppVBuhavEg4bvZKF0Uq+72I3OqEOn1/nH/Ws6X1e7PkKP3qCTIFyErLpx/er4rr322hovUwJ6IYQQIsRomoZm0DAZgvVWmmq8PkLUlFAYclMbJKAXQgghhBAhwRPCAf2aNWv45ZdfyMvLK7OUpaZpPPLIIxU+tgT0QgghhBAiJIRiD31OTg5Dhw5lw4YNKKXQNI3S+7qW/r+yAX3dn1kghBBCCCEE4EXDG2JB/T333MPvv//Ohx9+yK5du1BK8c0337Bt2zYmTpxI165dOXjwYKXKkIBeCCGEEEKEBIUWcr30X331FTfeeCOjR4/GarUCoNPpaNWqFa+//jrNmjVj8uTJlSpDAnohhBBCCBESQvF+bTabjY4dOwJgsVgAsNvt/u2DBg3im2++qVQZEtALIYQQQoiQ4EWHN8TC14YNG5Keng6AyWSiQYMG/Pbbb/7tBw4cqPS69TIpVgghhBBChIRQ650H6NevH8uWLeOhhx4CYPTo0Tz33HPo9Xq8Xi/Tp09n8ODBlSpDAnohhBBCCBESQm38PMCdd97JsmXLcDgcmEwmpkyZwp9//ulf1aZfv368+uqrlSpDAnohhBBCCBESQm2FG4BOnTrRqVMn/+PY2FiWL1+OzWZDr9f7J8pWRmgNQhJCCCGEEKetUFzlZsuWLUHTY2JiqiSYBwnohRBCCCFEiPDoNDy60ArozzjjDDp37szTTz/Njh07qqUMCeiFEEIIIURIUJrvL5S8+eabJCYm8uijj9K2bVt69OjB888/z549e6qsDE2V3ntWCCGEqGXFNif5B4rJ3VvIrpWZhMeF8edPf6MywmnQLA63w0PBoRKiG0Wg6TWKshw07BqLKcpAca6T5v0SiW4UiaWBiaiGEZVeCk4IUbcsMc4F4ELnmFquyak7fPgw8+bN45NPPmHNmjUAnHnmmVxxxRVcdtllNGzYsMLHloBeCCFErXAUuEjflMOf8/agPIqMLXkU2BUcFYRrOlBeBccbM6sd+fMGJoeF64hOjURv0NFhWEMadIgmvqUZQ7isByFEqFpsfh+AoYXX1HJNKufAgQP+4H7Dhg1omobL5arw8eRbTQghRI1wFbk5uDGbvasz+HvhflxFnoDtStPAaAhM88Jxg3ko99aR7hIv2Tt8d2PM2JqP5vUS5nKT0C6KpM6xWOKNtL2kCeakiIo3SghRo7whNn6+PCkpKXTs2JH27dvzxx9/UFhYWKnjSUAvhBCi2mT9lceBn7LZ9V066RtzfIkatXN3mCMXpLP+yidni42wEjebpv1JRKKJyMRwOoxpSfK/ErA2NctQHSHqKBXCsz+VUnz//fd8/PHHfPbZZ2RlZREbG8sVV1zB6NGjK3VsCeiFEEJUGaUUe1dncOiXHHYuPUT+vqKyAXxdGOjpUZQO5CnOdFCc6eCHB37BHabHHRNBi3OTSO4cQ1ybKJp0i0GrJ72CQoQ6rz70Pos//PADn3zyCfPnzycjI4OoqChGjBjB6NGjueCCCwgLq3w4LgG9EEKISvF6FDuXHCD9dxs7lx2kONt5ZOz7kQx1IYA/SUqvw+NW7PjuMH/+kIMjPBxDuI6kVpFYE0x0u7ABKW0thFvk51OI2qBC8OS6f//+WCwWhg0bxujRoxkyZAhGo7FKy5BvJCGEEKfM4/Dw97w0MjfnsmfZIQpdoOk1fxCvvMffv65T3iO3mFcKV4mX/X/YATtbv88GwBipp03vWBKaRhKTYqLlv2IkyBeiBnhCsId+3rx5DB06lPDw8GorQ759hBBCnBSHzckfs3eQ81ceB1Zn4CnxQGlPfKQx5IP4U+Es8vDniqyANodb9ZhjDLQ5O47oZCNRCSZSz4giwio/tUJUlVBbgx5g1KhR1V6GfMsIIYQISilF3hYbf7y9new0O9l/2nwB7NFj4k+jIP5Yx57AlBR4KCnwsH7+Ibyef8YZhRk1wq1hNO0ShTFSjznWQJMzoohKMmKNN2GM0NdwzYUIXUomrAclAb0QQgi/oj12slcdZvusbRTsL8KV7yLPYghYGz6UxsTXhqODeQC3U2HPdrHl++yjTgIO+LeHW/UYTDrMsUZSO1jR9BCVYCSlrQVznIHoRBOGcAn6hYDQHHJTEySgB7744gsef/xx3nrrLXr27Fnb1RFCiBrhdXrIWnUY+1955G3MJn3RPrwlvrXhi836wCBeVFp5Q5JKe/YLslxk7C7C6y57xmQy69EbNKISTTRsZwEFcY3DSWljwZpgJCrRiD4shNfzE+IkheKQm5pwSgH9zz//zMSJEwF46KGHGDlyZJk8PXv2pG/fvkyfPr1KKiiEEKJylFKUpNkp3plP0dY8Dny+l8IsJ0V77eD0+m60qtdQHul6r23BgnkAR6HvRKvI5iZjV1GZqwBoYIk1oOkhoUkkDdtZ0Ok0klqZadA8kqgGEvCL+kGG3ARX4R76mTNncuGFF1brjF0hhBAn5il24cwowZVeTMHGLFw5Ttx5LrK+O4Qz14UjswS93YEOQAf2cANK5wvuSn8aJZgPHWWCeQAF9hzfbeMLMvPY82t+mXwms57EphEoBSltLSS3MmOM0NOgZSQxSSb0Bgn4Rd3nCcFlK2tChQL6Dh06sGXLFj766CPGjx9f1XUSx+F2u/F4PJhMptquihBVwl3iIW9XAZZGkZiiA9flVV5F7vZ8TNFGzMkRtVTDysvbXYCmaUQV2yDcAM2TKnScjMX72T97B65cB/Zt+XiLPXhdXgz5JRiOjOdwowM0NIMOp/uf3iz/CGwvaGgyDL6eCxb0Owo97N9iB+DAVnuZ7XqDRkxKOA1aRBKbbKLXZQ2JjDZUe12FOBWhOuQmPz+fN954gxUrVpCRkcGMGTM488wzycnJYfbs2QwfPpxWrVpV+PgVOh2/4IILaN++Pe+99x42m+2E+Xv27MmUKVPKpH/xxRf07NmTn3/+2Z82Y8YMevbsya5du5g2bRqDBw+mT58+3HTTTaSlpQHw3XffcfXVV9OnTx+GDRvGggULKtKM4yosLOSNN95g3LhxnH/++fTu3ZsRI0bw6quvUlJS4s/3119/0bNnT15//fWgx7n99tvp378/xcXF/rSsrCyeeeYZhg4dyllnncWQIUN46qmnyMnJCdi39LnYuXMnL774IhdddBFnn302mzdvBmD16tVMmDCB888/nz59+jB06FDuuece9uzZU+XPhxDVoSTXwecXf8fnw79j3vlLyfrT5t+mvIrlE9fy2dBv+XjA1+z8Yl/tVbQS1j+zmfkDl3Ggy5PQYRK0vBmmLazQsQ7M3cnhhfvIWZWBM70Ed54Lb5EnaHiuXN5/ut8h8P+i0k7qhEhV8LTp6P1U8Fvslnfj3cqcqHlciuy9xfy1Mpsf/3eQXT/bKnE0IaqHR6eFXC/9/v376datG48++ij79+/n999/x273nVTHxcUxY8YMXn311UqVUaGAXtM0br31Vux2O7NmzapUBcozZcoUtm3bxvjx4xkzZgybN2/mtttuY/HixTz77LMMGDCASZMmYbVaefrpp/n111+rtPzMzEwWLlxIhw4duP7667njjjto164dc+bM4e677/bna9euHe3bt2fx4sV4PJ6AY2RkZLBu3ToGDRpERISvdzE9PZ0xY8bw7bffMmTIEO677z4uuugili5dynXXXed/gY/2yCOPsHnzZq6++momT55MQkICGzdu5M4776SgoIDx48dzzz33MHLkSPLy8ti3LzQDH3H62fnFfvJ2FgC+Nc7/fHeHf1vm77ns/S4dAOVWbHrtr1qpY2U4C1z88c52ItxFtM/f5ktUCh79X8UPGlq/Y+KIKrkiUkOXVUrPISp6PiJEdVKaFnLj6O+55x4KCgr49ddfWblyJeqYD9eIESNYvnx5pcqo8IC5Xr160atXL+bPn8+hQ4cqVYlg4uPjeeutt7jiiiuYOHEit956K4cOHeK5557jvffe44YbbmD06NG8/vrrGI1GPvnkkyotv1GjRixevJj77ruPK6+8kssvv5ypU6fyn//8h3Xr1vHHH3/4844cOZKMjAzWrl0bcIwvvvgCj8fDxRdf7E977rnncLvdfPDBB9x2222MHDmSSZMm8eabb3Lw4EE++OCDMnWxWCz897//5eqrr+aqq66iWbNmrFy5Eq/Xy+uvv84111zDiBEjuP7665k5cyZ9+/at0ueionJycnA4HP7HdrudgoIC/2On00l2dnbAPse+l459nJ6eHvBBkDJCuwyjNfByvjHa4C/DaDUEBK+mKEOdbUd5ZeiMOvThetxaGJ6jv25jzBUqo/ioq4MitIRW+BEoFL5LpIyaLaM2hWJAv3TpUiZNmkSHDh3QgtS9RYsWle6MrdQMmNtuuw2Xy8Wbb75ZqUoEM3r06IBGd+3aFYB+/fqRnJzsT4+NjaVp06ZV3ittMBgIC/NNMXC73eTn52Oz2TjzzDMBAgL6IUOGEBkZycKF/1xGV0qxaNEiWrVqxRlnnAH4PmSrV6+mX79+mEwmbDab/69hw4akpqayfv36MnW56qqr/HUpZbFYAN/wI7fbXaVtrypxcXEBY/0tFgtWq9X/2Gg0Eh8fH7BPSkrKcR8nJycHvC+kjNAuo9XFjWl7RTMiEkw0OqcB3Se195cR09LKWQ93JjIpnLj20fR9qnudbUd5ZYSZ9Jw7/V+YmsawvuN5uJPioG0j+N+dFSojQhYhOD2UF6sc9R6tydFUofBdImXUbBm1yavX8IbYWvTFxcUkJiaWu/3oE7CKqtQ69O3atWPw4MF8/fXXjBkzhtatW1e6QqVSU1MDHkdFRQHQsGHDMnmtVivp6elVVnapefPm8emnn7Jr1y683sAFhI9+8iMjIxk8eDBffPEFubm5xMbGsnHjRg4cOMBdd93lz5eWlobX62XhwoUBwf/RGjVqVCatSZMmZdIuv/xyVq5cydSpU3n11Vfp0qULZ599NoMHDyY2NraiTRaiRmk6jb5Pdocng2/vOK4VHcdVfJJQXdD0goY0vaDs91ZFaAYdqGOWmAyt37V646Se9gr3Ih613ykeoyrfDgaTrHoj6p5Q650H32Iyq1at4sYbbwy6/fPPP6dbt26VKqPSN5a66aab+Pbbb3n11Vd55ZVXTmnfY8ecH02nC/5FUl76seORKuv9999n+vTpnHXWWVxxxRUkJCRgMBjIzMxkypQpZQL8kSNH8tlnn7F48WKuueYaFi5ciNFo5KKLLipz7AsvvJB///vfQcsNdgYcbGnQmJgY5syZw6ZNm1i/fj2bNm3ixRdfZMaMGbz88st07ty5gi0XQtRVbR7vSlz/JNx5Lgp+z8Ftd6Mz6ijamIEuz4kqcuOxu1GlYZ2CI4veQMCFPIWcCZyeNF3ZG1yZYw0kNovA5fCS2tFKYrNIYpJNND4jqnYqKcRxKH3onWhOnjyZcePG0blzZy677DIAvF4vO3bs4PHHH2ft2rV8+umnlSqj0gF9o0aNuPTSS/noo48CVqs5WnR0NHl5eWXSDxw4ECR33fDVV1/RsGFDXnnllYCTiB9//DFo/g4dOtC2bVsWLlzIxRdfzHfffUf//v2Jjo7250lNTUXTNNxuN7169ap0HfV6PT179vTf3Xb79u1cc801vPPOO7z88suVPr4Qom6JbGGlSQvrcfN47E5KDhXj2FtI7vfpOHKcOLMc5H13AGVzgFtJPF9P6fTgPaafTNNBVKIJTQcNWkbSsI0VTQ8N21hIaBqBOcaAFmIrhojTmwrB9+s111zDnj17ePjhh3nooYcA33BtpRQ6nY6nn36aESNGVKqMSgf0ANdddx2LFi0qt4e+SZMmbN68mZKSEn9vc35+PosWLaqK4oNKT0+npKSE1NTUMuPPT4Zer0fTtICef7fbzezZs8vdZ+TIkUydOpXnnnsOh8NR5sWJiYmhT58+fPfdd2zevJlOnToFbFdKYbPZTmrIjM1mIyYmJiCtWbNmhIeHk5+ff8L9hRD1k95ixNzaiLl1NHHnBw71UR4vxbsKyFi8n8JDxRT8nU/2ynRwess5mqgrgvWsg2/t+DCjRnRyOI3aWfB6FUktzCS3NmNtYCQ6wSQBu6hXQnHIDcBDDz3EmDFj+PTTT9mxYwder5eWLVtyySWX0KJFi0ofv0oC+piYGMaMGcNbb70VdPvll1/OI488wsSJE7nooosoKCjg888/JyUlpczM66ry6KOP8ssvv7Bo0aKg4+5P5Pzzz+e1115j0qRJnHvuuRQWFvLNN98c9+RgyJAhvPzyyyxZsoRGjRr5J9Ae7f777+f666/nhhtuYOjQobRt2xav18uBAwdYtWoVF110UbljrI725JNPkpGRQa9evUhJScHhcLBs2TIKCwsZOnToKbdXCFH/aXodka2jaTb5nyuHSimK0+zkrMtk7zvbKd5bSMmBon+G68jShdWu3GA9TENv0rDEGGnY3oLXo4htGE7DthYiow3ENDT5ethDNMARoiK8ev2JM9UhRUVFnHPOOdxwww1MnDiRO+64o1rKqZKAHnyXE+bPn09WVlaZbRdeeCGZmZl88sknvPTSSzRq1Ijrr78enU4XsFpMXTJmzBiUUixcuJBp06YRHx/PwIEDGT58uH/807EsFgsDBw5k0aJFDBs2LOiXbHJyMu+//z7vvfceK1euZMmSJRiNRpKSkjjnnHMYOHDgSdXvoosu4osvvmDx4sXk5uZiNptp0aIFzz77LOeff36l2i6EOH1omkZkcyuRza2kXunrJSo5VETaezvI213A4R8y0Eq8KAnuq5ROD8ZIPeGWMBqfEYVOD+Y4I6kdrJhjw4hKNGKONUqwLsQxQq2HPjIykt27d1f7Z1lTVT2b9DQ3depUPvvsMxYtWkRSUsVu7y6EEHWFUor0HzM4vCmHvSvSyfwtFwjsVVaAK9JY+bI0DbfRcOKMFaR5PIS5fYPMdS4PepenzFQCl8mAM8IImobDZMRpMlZ4tRqdXiOxeSTmmDAiow206BmDNdGANcFEXMNwGQojRAW82vMbAG77eXAt1+TkXXXVVZSUlLBgwYJqK6PKeuiFb535JUuWcPbZZ0swL4SoFzRNI6VPEil9kuh6a3vs6UUcXJ1B2jcH2bfCt1ywFmJrQlc1TQfJrc3EpIRjiTXQpk/cPxNOQ6w3UYi6zhuCq9w88sgjXHbZZYwZM4Ybb7yR5s2bExERUSZfXFxchcuQgL4K7Nixg7///pvFixdTVFTE+PHja7tKQghRLSzJkbS5tBltLm2Gs9DFgR8y2L1kP9tWZPpG5OiAejbH9uirEfowjbjUcCzxRjoPSiSljYW4RtLbLkRNCbUhNwAdO3YEYMuWLXz44Yfl5jvecu4nIgF9Ffj222/573//S4MGDbjvvvtkDXghxGnBaDbQfEgjmg9pRH+nh/3rs9m5/CDbFh3w3fgqVIP7IwGDzuMlLEyj1dlxNGxvIaFxBC16xqA3hF4PoRD1hbec+xHVZY8++qiMoRdCCBFavB7F4d9y2bX8EH9+sgfPSS6LWdNj6MNcR3rDNPwTfk3JERibRHHGlc1o1C2WqEYRMmxGiDpkWp8VANy15txarkndIj30QgghqpROr5HSPY6U7nGcfU8HbGmF7F6Rzu9zd1Fic/l672uRptdQbl+QHtPSSoMe8ZiTw2l7eXPMyWXHtQoh6o5QHHJTEySgF0IIUW00TSO2uYXY5q3o/p9WuIo9HNqYza/v7cRZ4Cbr7zyUB18veVVfSdeO/B25QBBmDiMi3ECHEY1J7hJLYodoIuJMVVyoEKI6heKk2CeeeOKEeTRN45FHHqlwGTLkRgghRK1xOzzsXZ1BYWYJGX/ksWN1Nl4FrqKyk8M03ZGRMV7QdEfu5B3kF0xn0NCF6WjaO5645hbCTDraDEomqqEMnxEi1D074AcA7vv+nFquycnTHWfcv6b5vss0TZNJsUIIIUJTmElPi/NT/I9Lb4vnKHBxeEs+LqeLbz7/Fu/BCHqe1wmPU5H5VwFJHaPR6cG2v5jG/4ojIsYAaCR1jCZClosUot4KxSE3Xm/ZeURer5c9e/bw+uuvs2rVKpYsWVKpMqSHXgghRJ3lcrl49913ARg/fjwGQ/VNmhVC1H1Pn/8jAA9+e3Yt16TqXH311Siljruk5YmE3kAkIYQQQghxWlKaFpK99MfTr18/vvrqq0odQ4bcCCGEEEKIkOCthzdx+/nnn487zv5kSEAvhBBCCCFCQij2zs+ZMydous1mY9WqVSxYsIDrr7++UmVIQC+EEEIIIUJCKAb01157bbnbEhISuP/++3n00UcrVYYE9EIIIYQQIiR4tNCb/rl79+4yaZqmERsbi9VqrZIyJKAXQgghhBAhIRR76DVNIzExkYiI4HeiLi4uJjMzkyZNmlS4jNA7zRFCCCGEEKelUFzlpnnz5nz22Wflbl+0aBHNmzevVBnSQy+EEEIIIUJCKK5yc6JbPrlcLlnlRgghhBBCnB68IdI7n5+fj81m8z/Ozs5m7969ZfLZbDb+97//kZKSUmbbqZCAXgghhBBChARvJXuya8pLL73EE088AfjG0E+ePJnJkycHzauU4sknn6xUeRLQCyGEEEKIkBAqPfSDBg3CYrGglOLee+/lyiuvpHv37gF5NE3DbDbTo0cPevbsWanyJKAXQgghhBAhQYVGPE/v3r3p3bs3AIWFhYwaNYozzjij2sqTgF4IIUSd4yx0c/i3HJxFTry/RUCJjh1JByjOcdOwZzyWpAjMiSa0EOmtE0JUjVBch/6xxx6r9jIkoBdCCFGrlFexZ9VhDm7IIvvvfA79nI3XffSqENEAfL/ud7wGA7AdAL1JR3wbK9akcLqOaU6DM2LQ6SXAF6I+C7UlK4+2Zs0afvnlF/Ly8vB6vQHbNE3jkUceqfCxNXWitXSEEEKIKuZxeTmwLpMNr2wlb08RrkL3CfZQKE2HN6z8fihNB60vakiHEamkdI+t9DJwQoi6Z9JlWwF4ZV77Wq7JycvJyWHo0KFs2LABpRSapvmXsiz9v6ZpeDyeCpchPfRCCCFqhFKKrC15/D53Jzu+OojyVG1/kvLCtsUH2fblQUxRBrpf14K2QxtiTgiv0nKEELXHE4Lr0N9zzz38/vvvfPjhh/Tq1YsWLVrwzTff0Lx5c1566SXWrl3LkiVLKlWG9NALIYSoVo4CJzu+OsjPr/9Fcbazgkc5cQ99UBqccXkTul7TjOjG5gqWLYSoK24a/TcAb37ctpZrcvJSUlK48sorefHFF8nOziYxMZFly5Zx/vnnA3DJJZdgMpn46KOPKlyG9NALIYSoFhl/5/PHgv38/eFONG8t9R0p+GPeXv74eC9Nz0nkrNvakNAmqnbqIoSotFDsobfZbHTs2BEAi8UCgN1u928fNGgQDz74YKXKkIBeCCFElXEWudn5bTq/ztlNZloxml4jrLaC+VJH5p7tWZ3Jnh8yiW9j5dxHziCpU0ytVksIcepCZR36ozVs2JD09HQATCYTDRo04LfffuPiiy8G4MCBA5VesUsCeiGEEJV24M88tqzM4c//pWHIL0HpAL2+ysfJV8qRqmRvK2D+mLVEpUZw3mOdaNgzTpa/FCJEhOIqN/369WPZsmU89NBDAIwePZrnnnsOvV6P1+tl+vTpDB48uFJlyBh6IYQQFWLPcfLLJ/vZ+1MOe9KcaDqN8IIiTCVOlAbeMD0AhqISKv8TXMEx9CchIs5In7va0XpIQ1n2Uog67tprdgIw+/2WtVyTk7d582aWLVvGLbfcgslkIjc3l8suu4zvvvsO8AX8H330ESkpKRUuQwJ6IYQQJ60o38VPiw6zc20Oh/8qwFjiBA1KTCbQNCLsRZgcThShE9CXCo8x0G54I/51Y2uMZrmALURdNHbMLgDmzG1RyzWpPJvNhl6vx2q1VvpYtbJI74QJExg2bNhJ5f3555/p2bMnX3zxxUnlHzZsGBMmTKhM9WrEqbZLCCFqg9ej2PNbHms+3M+0Kzby/OhNrHpvP4f+LoTSsfH1pFuoxObi1zlpzBqwnAXj13H4DxvS5yVE3eLWabhDcGJsMDExMVUSzEMlA/rSoHTu3Lnl5unZsyeTJ0+uTDFCCCFqSEGWg50/2fjixV28ecufPDVyI+/ftYWVs/dhz3XXm+D9eDwuxaFNucy/Zi3/7bOMtS//Tc4u+4l3FEJUOy8a3iq45lfT9u7dy8SJE2nbti1xcXGsWrUKgKysLCZNmsSmTZsqdfxauab4+uuvn/a9Ht27d2fNmjWEVePlYyGECMbt8pKX5eLA33Zse4vIz3Cwe2MeLqeX4jzfHVtdej1enQ7N68WI76ZN6Gu12rXCVeThl3d38cu7uzBFGWh5XhIJLSJpPSyV8FhTbVdPiNNOKE6K3bJlC+eccw5er5devXqxY8cO3G7fd21CQgKrV6+msLCQd955p8Jl1Eo0aTAYaqPYOkWn02EyyY+BEKJqFWSUYM9wcHhrPpoGh/eUkFOgcLhh345iNJ1GYYHv9uImhxODxwMaqBDs8appjnwX2+btZpfDzYYnfkMfrqfROQ0wJ0eQ0DGGBl3jsDaxoDfWymhWIU4LoTjc5t577yUmJoZ169ahaRoNGjQI2D506FA+/vjjSpVRKwH9hAkTOHToUJnx499//z0zZ84kLS2N2NhY/v3vf9OtW7egx0hPT2f69OmsXbsW8PV433XXXeWWuX79eubMmcOff/6J0+mkSZMmXHrppVx66aUB+YYNG0ZKSgoPPvggL730Eps2bULTNHr16sW9995LQkLCCdu3c+dOZs6cye+//47NZiMqKopmzZoxZswY+vbtC/iGK02cOJHHHnvMP59g2LBhHDp0KOgxu3fvzsyZM/2Pt2zZwqxZs9i0aRNFRUWkpKQwdOhQxo0bJ73+QtRRf/1q59vPsoi06Bn5n2Ri4qu2c+PAr7nMm7jxqBSFPTISp9GI0jS8+qO62I/6TVQq8PHJON411uMd79hNgY9PYceAhJM+ygm3npD3nyN4SjzsXX4o4MmI7xDNiEXnV/z4x8ovgjvehR2HYOwA2LIPftoJ/+4B946s9OF32RR3fu/F7oTHztZxTmroBUvi9BKKw21WrVrFo48+SmJiItnZ2WW2N2nShAMHDlSqjCqJ/EpKSrDZbJU6xooVK7j33ntp2LAh119/PXq9ni+++ILVq1eXyVtQUMCECRM4fPgwl1xyCS1atOCXX37hxhtvxOFwlMm/YMECnnnmGTp16sR//vMfIiIiWL9+PVOnTuXAgQPcfvvtAfkzMzO58cYbGTBgAJMmTWL79u0sWLCAwsJCXn/99eO2w2azcdNNNwEwatQokpOTsdlsbN26lT/++MMf0Adz1113UVRUFJD2xx9/8MknnxAfH+9PW716Nffccw+NGzfmmmuuISoqis2bNzNjxgy2bdvGs88+e9w6CiFqXoHNzTvP7sXl9EV/BXluJj3ZvErLKMl3/fNAKdA0ggavJ/t7WANDI7WjA+xjYu3jht7lx/No/rZz1PNwMgetgGOeosLDJVV4cHzB/Kxvff9fteWf9B+2QMtkGNW7Uoe/ZKGH3zJ9//8p3cPeG/VEm0IvYBKnD08Ivj29Xi+RkZHlbs/MzKz0qI0qCehnzJjBjBkzKry/x+PhhRdeICoqivfee4+YmBjAFxBfccUVZfLPmTOHgwcP8uijjzJ8+HAALrvsMqZNm8ZHH30UkDcrK4sXXniBQYMG8dRTT/nTL7vsMl544QU++OADRo0aRWpqqn/bvn37eOaZZxg4cKA/TafTMW/ePNLS0mjWrFm5bfntt9/Iyckps//JGDBgQMDjgwcPMn36dFJTU7nvvvsAcDgc/N///R9nnHEGb775pr83ftSoUbRu3ZqXXnrJP1m5tuXk5GA2m/1vUrvdjlLKP6Pb6XRSUFAQcLJy6NChgHVYj32cnp5OUlKS/yYwUoaUESpl7Nye7g/mATIPleBwOKq0jNxcG5VV1fHu6awq3leOrXsp92d+Z3qly9hp++dw+U7IKoainPr5GZQyqq6M2hSKQ266d+/O4sWLufnmm8tsc7vd/O9//+Oss86qVBlVMtBv5MiRvP7660H/TsbWrVs5fPgww4cP9wfzABaLhVGjRpXJ//333xMfH8/QoUMD0seNG1cm7/Lly3E6nVx88cXYbLaAv9IJChs2bAjYJzExsUwwXhog79u377htsVgsAPz444/Y7RVfFcFutzN58mRcLhfTp0/3Py/r168nOzubYcOGYbfbA9rTp08ff566IC4uLuDDb7FYApZnMhqNAV8wQJmbKhz7ODk5OeCOjlKGlBEqZZzRtSFN20T4H/e+IL7Ky4iNjaGytHIfVI/6PHa/Kt5XpolD/rnCkBQDxiP9cLEWGNmr0mVc1+mffc9rotE8uv5+BqWMqiujNoXiKjcPPPAAX3/9NTfddBN//PEHAIcPH2b58uUMGjSIrVu3cv/991eqjCrpoW/SpAm9evWq8P6l44aaNm1aZlvz5mUvSR84cIAOHTqgP3o8KL6Zwseu55mWlgYQ9KyoVE5OTsDjRo0alckTHR0NQF5eXrnHAejRowdDhw7liy++YMmSJXTo0IFevXoxcOBAWrQ4uZsguN1u7rvvPvbu3curr74acEVg9+7dADzxxBPl7h9sfJYQonaFGXTcMqUZW3+xE2nR07qTuXoLPHqYSYV/+zTKGy1/vEOWv1fZ/QJPILRyt6kyO2rB/49vFQytnG1lHlexKj/82HOhYxPYdRjO6wQZefB7GvRpB6knntN1ItPP0zO0hRe7C4a20NCF4Aoi4vTiCsEe+gsvvJDZs2dz++23++dDXnPNNSiliIqKYs6cOfTr169SZdT72ZOly2M+/vjj5U5oPTaA1+nKv3BxMsttPv7444wZM4Yff/yRTZs28f777zNr1izuvPNORo8efcL9n332WdavX8/DDz/Mv/71r6Dl33777bRp0ybo/omJiScsQwhR84wmHV16R1Xb8Ru0i6L5OQkUpJeQu6cQrwc05eXo0FjTHVmCsjp/E6vh2Mc7SaiB4sse/5gKGSxhxLePoenAit+6vVw9Wvr+AOKt0D71+PlP0cBmsiqPCB2eEOudLzVmzBguueQSli5dyo4dO/B6vbRs2ZLBgwdXyc2l6kRAXxpQ79mzp8y20h7pY/Pv27cPj8cT0EuflZVFQUFBQN7GjRsDvrtxVeYqwqlq1aoVrVq1YuzYsRQUFDBu3Dhee+01Lr/88oDLWMeaM2cOn332GWPHjmXEiBFltjdp0gSAiIiIGm2PEKLuszYI5+Lnu/ofK6UoznNRkOsmP8fFnq2FhBl1/PWTb0nL3F0Kr83jD0z9wb4ol1enoQvX0/T8ZEzRRlr8O5X49jEYrbIcsxA1IVQmxT744INcccUVdO7c2Z9mNpsZObLyq1MFUycC+vbt25OUlMSiRYsYN26cf7y43W7n008/LZO/f//+zJ49m8WLF/snxQK89957ZfIOHDiQN954gxkzZtCjRw/Cw8MDttvtdoxGI0ajsUrakpeXh9VqDejlt1qt/pMQh8NRpg6lVqxYwauvvsq5557LbbfdFjRP7969iYuLY/bs2QwcONA/FKhUSUkJHo8Hs7maL+cLIeo8TdOIjDESGWMkqTm07uH7vhhwebI/j9ejyD1QTNqmPEoKPfzxXRYl+W5sNs+RY9RK1esWDWKbmWnSJ5GOlzYmpqn5uB0zQojq4zrOKIq6ZOrUqZxxxhn+gD47O5sGDRqwbNkyzjvvvCovr04E9Hq9njvuuIMHHniAcePGMWLECPR6PYsWLSI6Opr09PSA/GPHjuXrr7/mqaeeYuvWrbRs2ZKNGzfy+++/B0yqBUhKSuL+++/nySef5LLLLuOiiy4iJSWF3NxcduzYwffff8+8efNo2LBhlbRl8eLFfPjhh5x77rmkpqYSFhbGL7/8wtq1axk4cGC5wbzNZuORRx4hPDyc3r17s2TJkoDtcXFxnHXWWURERPD4449z9913M2rUKIYPH07jxo0pKCggLS2NFStW8Pzzz9eJVW6EEHWfTq8R3ySS+Ca+JdX6XOUbzpGf5WDf1kJ2/5bP3yuy/lkS83SIY48Mp0loZ6Vhjzi6j2+JOaFuTAgU4nTnru0KVMLJDNuuqDoR0ANccMEF6HQ63n77bWbOnElcXJz/xlK33nprQN6oqCjefvttXnzxRb766ivAtyTQjBkz/GvAH2348OE0adKE999/nwULFlBQUEBMTAxNmzblpptuKjP7uzJ69OjB33//zQ8//EBWVhZ6vZ6GDRsyefJkLr/88nL3KyoqoqTEt37x008/XWZ79+7d/Usa9e7dm/fee4/33nuPJUuWkJubS1RUFKmpqVx99dW0bt26ytojhDg9RSWY6HiOiY7nxPHvW5tRnO/i5y8Pc2hXMdvX5IBL1cvgXtNrtL+4Ea0vbEjqv6rut0EIUTU8cnUsKE1V5+mCEEKIesfl8JC2KY/fvkxnz8rD4IWScBNoGhH2IkwOJwrwhvnmOBmKSqog9lcoTYe3mu6EHRFrpPNVTWk/srH0xgtRh7W/1XcntK2v1e0FQHQ6He+//z5XXXUV4Btyk5iYyPLly+vvkBshhBChw2DS0/qsOFqfFYeruC3bV2Xy3Tt7ycvxjbsPpbtTxTQz035EI7pc3Qy9QX/iHYQQtcoVIt8t4Fs6/ZdffgH+WfZ8+/btZYaHl+revXuFy5IeeiGEEFUi92AJP7y+g0PfHcRV4qnTPfRxrSx0GNWYzqObooXgutZCnK4aTsoC4OArlb8PQ3XS6XRlJs8rpYJOqC9N93g8FS5PeuiFEEJUidiG4Qx/6gw8rg5sXbSf9W/vojDLWdvVChDbwkyXq5vR4ZLGslKNECGoKEQ+t++++26Nlic99EIIIapN9o4CVv7f72RvzsXjqMwi95XroY9qFMGARzrS+Ky6Pe5WCHF8psnZADimy6T1o0lAL4QQotq5Ct1snLmNXUsPkb+3sAJHOPWAXtNDYvtozn+8E3EtK38nRiFE7dPuyAFAvRRXyzWpWySgF0IIUaMy/rSx8c2/ydqaR2F6iX/d9+M7+YA+Mt5Iq8Ep/Gtia8Kj5A6uQtQn2p25AKgXY2u5JnWLBPRCCCFqhVKKtBWHydicy7aF+yg8XOLfpulABYzQOX5AH9fKgrVhBGfe1JoG7aOD5hFChD4J6IOTgF4IIUSd4ChwceiXbLYt2k+YScfeHzJAQUl+CXg1wiIMuLwaMc0s6PQaDc6IpkmfRBLaWolONdd29YUQNUC72waAeiGmVutR18gqN0IIIeoEk9VAs/7JNOuf7E9zuVz+1SLGjR+PwSBDaIQ4vYXGKjc1TQJ6IYQQQggRGnS1XYG6SQJ6IYQQQggRIqSHPhgJ6IUQQgghRGiQeD4oCeiFEEIIIURoCJE7xdY0CeiFEEIIIURokHg+KAnohRBCCCFEiJCIPhgJ6IUQQgghRGjQSUAfjCz+I4QQQgghRAiTHnohhBBCCBEaZFJsUBLQCyGEEEKI0CDxfFAS0AshhBBCiNAgAX1QEtALIYQQQojQIENugpJJsUIIIYQQQoQw6aEXQgghhBChQZatDEp66IUQQgghhAhh0kMvhBBCCCFCg3TQByUBvRBCCCGECA0yKTYoGXIjhBBCCCFECJMeeiGEEEIIERqkgz4oCeiFEEIIIURokCE3QUlAL4QQQgghQoPE80FJQC+EEEIIIUKDBPRBSUAvhBBCCCFChET0wUhAL4QQQgghQoPE80HJspVCCCGEECI0aBw3qJ8yZQoWi6XGqlNXSEAvhBBCCCFECJMhN0IIIYQQIjTIkJugpIdeCCGEEEKEBk2r1Fr0mzdvZvDgwZjNZqKjo7n00kvZu3evf/t1113HOeec43+clZWFTqfjX//6lz/NbrdjMBiYN29ehetR1aSHXlQLpRQFBQW1XQ0hRIhzuVwUFxcDkJ+fj8FgqOUaCSGsVitabd3gqRLF7tu3j379+tGyZUvef/99SkpKeOihh+jfvz+///47VquVfv368cEHH1BSUkJ4eDirVq3CZDKxadMmCgoKsFqt/Pjjj7jdbvr161d17aokCehFtSgoKCA6Orq2qyGEqEcmT55c21UQQgB5eXlERUXVStnq7oqHri+99BIul4ulS5cSFxcHQLdu3ejQoQOzZ8/mtttuo1+/fjgcDtavX0///v1ZtWoVI0eOZOnSpaxZs4YhQ4awatUq2rRpQ1JSUlU1q9IkoBfVwmq1kpeXV9vVCGC32xk6dCiLFy8+LWbAS3vrt9OpvadTW0HaW9/Vh/ZardbarkKF/PDDD5x33nn+YB6gXbt2dOnShdWrV3PbbbfRvHlzUlNTWbVqlT+gnzhxIsXFxaxcudIf0Nel3nmQgF5UE03Tau3svTw6nQ69Xk9UVFTIfomeCmlv/XY6tfd0aitIe+u70629dUlubi5du3Ytk56UlEROTo7/cWkgn5+fz2+//Ua/fv0oLCxk/vz5OBwONmzYwA033FCDNT8xmRQrhBBCCCHqvbi4ODIyMsqkHz58OKDXvl+/fqxdu5bvv/+ehIQE2rVrR79+/fjpp59YsWIFDocjYOJsXSABvRBCCCGEqPf69u3Lt99+S25urj/t77//5vfff6dv377+tNIe+RdffNE/tKZr165EREQwdepUGjduTLNmzWq6+sclQ27EacNoNHLDDTdgNBpruyo1Qtpbv51O7T2d2grS3vrudGtvbfB4PMyfP79M+u233867777LoEGDeOihhygpKeHhhx+mSZMmXHvttf587dq1o0GDBqxcuZJXXnkFAL1eT58+fViyZAlXX311TTXlpGlKKVXblRBCCCGEEKKypkyZwuOPPx5029y5c+ncuTN33303a9asQa/XM3DgQF588UWaNm0akPeyyy5j/vz5/Prrr3Tp0gWAZ599lvvvv58ZM2YwYcKEam/LqZCAXgghhBBCiBAmY+iFEEIIIYQIYRLQCyGEEEIIEcJkUqyo91atWsWbb77Jnj17SE5O5tprr2X48OGndIy77rqLlStXcvvttzNmzJhqqmnlVaSt+/fv54UXXmDbtm3YbDaioqLo0qULN998c5kxhXVNRdr7559/Mn/+fDZt2kRmZiYNGjTg/PPP57rrriMiIqKGal4xFWmvy+XijTfe4I8//mDr1q2UlJSwfPlyYmJiaqbSJ5CWlsZzzz3H77//jtls5qKLLuLmm2/GYDAcdz+lFO+99x7z5s3DZrPRpk0b7rzzTjp16lRDNa+YirZ33rx5rFmzhj/++AObzcbUqVO54IILaqjWFVeR9mZlZfHBBx+wfv169u/fj8VioVu3btx6662kpKTUYO1PXUVf30ceeYQ//viDzMxMDAYDrVq14rrrruOss86qoZqLUCc99KJe+/XXX7nnnnvo1KkTr7zyCgMHDuT//u//WL58+Ukfo/RHtK6raFuLi4uJj4/nlltu4ZVXXmHy5Mns2bOHiRMnYrPZaqbyFVDR9i5btox9+/YxduxYXn75Za688ko+++wz7rjjjhqqecVUtL0lJSV8/vnnGI1GunXrVkO1PTn5+flMnDgRt9vN888/z80338xnn33Giy++eMJ933vvPWbMmMFVV13FSy+9REJCArfeeiv79++vgZpXTGXau3jxYmw2G3369KmBmlaNirZ369atrFixggsuuIBp06Zxxx13sGPHDsaNGxew3GBdU5nX1+VycfXVVzNt2jSeeOIJoqOjuf3229m0aVMN1FzUC0qIeuyWW25R48ePD0h78MEH1aWXXnpS+zscDjVixAi1cOFC1aNHDzVnzpzqqGaVqGxbj7Znzx7Vo0cPtWTJkqqqXpWraHtzcnLKpC1ZskT16NFDbdmypUrrWJUq8/p6vV6llFKLFi1SPXr0ULm5udVRxVM2a9Ys1bdvX2Wz2fxpn376qTrzzDNVRkZGufuVlJSofv36qddee82f5nQ61b///W/1zDPPVGudK6Oi7VVKKY/Ho5RS6sCBA6pHjx5q2bJl1VrXqlDR9ubn5yuXyxWQlp6ernr27Knmzp1bbfWtrMq8vsdyu93qoosuUk8++WRVV1PUU9JDL+otp9PJzz//XOay9KBBg9i9ezcHDx484THmzp2L1Wpl2LBh1VXNKlEVbT1adHQ04Os1qosq097Y2NgyaW3btgUgMzOzaitaRSr7+mqaVp3Vq7Aff/yRM8880/9+Axg4cCBer5d169aVu9/vv/9OYWFhwPNhMBg499xzWbNmTbXWuTIq2l4AnS70fq4r2l6r1UpYWOCI4KSkJGJjY+vsZxQq9/oeS6/XY7Va6+x3sKh7Qu8bQoiTtH//ftxud5m7uTVv3hzwjXU8nvT0dGbPns0999xTZwOiUpVtK4DX68XtdnPw4EGee+45kpKSOPfcc6uhtpVXFe092q+//gpQ5+78V6qq21tXpKWllWmT1WolISHhuG0q3Rbs+UhPT6ekpKRqK1pFKtreUFWV7d2zZw85OTn+93xdVNn2KqVwu93YbDbmzp3Lvn37uOSSS6qnsqLekUmxot7Kz88HfF+oR4uKigrYXp5p06Zx7rnn1vlJdlD5tgI89thjLFmyBIDU1FTeeOMNLBZLFde0alRFe0vZbDZmzpxJ//79adKkSdVVsgpVZXvrkvz8/DJtAl87j9em/Px8jEYjJpOpzH5KKQoKCggPD6/y+lZWRdsbqqqqvUopXnjhBRITExk8eHBVVrFKVba9Cxcu5MknnwQgMjKSp59+ms6dO1d5PUX9JAG9CCl2u52srKwT5mvUqFGlylm3bh3r16/n008/rdRxKqOm2lpq4sSJXHHFFaSnp/PRRx9x8803884775CcnFwlxz+Rmm4vgNvt5sEHHwTggQceqLLjnozaaK8QoWjmzJls2LCBV199tc6vRFUZAwYMoE2bNthsNpYvX84DDzzA888/H1IToUXtkYBehJTly5f7ezCOZ/78+f7eS7vdHrCttKekdHswzz//PKNHjyY8PJyCggJ/usPhoKCgIGgvTFWrqbaWatSoEY0aNaJjx4706dOHkSNH8t5773HfffdVoPanrqbbq5Ti8ccf588//+S///0vCQkJFah1xdV0e+uiqKioMm0CKCgoOG6boqKicDqdOByOgF76goICNE2rkc9nRVS0vaGqKtr72Wef8d///pdHHnmEM888s6qrWKUq296YmBj/crJnn302+fn5vPzyyxLQi5MiAb0IKSNGjGDEiBEnldfpdBIWFkZaWhq9e/f2p5c3/vZoe/bs4d133+Xdd98NSH/rrbd46623WLNmTZnL/VWtptoaTHh4OM2bN6/RJQBrur3Tp09n+fLlvPzyy7Rp06YCNa6c2nx964pmzZqVGVtceuXieG0q3bZnz56A1y4tLY3k5OQ6OdwGKt7eUFXZ9q5YsYKpU6cyceJELr744uqpZBWq6te3Xbt2/Pjjj1VTOVHvyaRYUW8ZjUZ69uzJt99+G5C+bNkymjdvTsOGDcvdtzRwP/oPYNSoUbz11lsnvElITatMW4Ox2+1s3769zg73qGx7Z8+ezYcffshjjz1W53v9oOpf37ri7LPPZsOGDQFXwZYvX45OpzvuDXU6d+6M2WwOWIPf7XazYsWKOt2bWdH2hqrKtPfnn3/moYceYsSIEVx//fXVXdUqUdWv72+//VZnv4NF3SM99KJeu/7667nxxhv9d1XcuHEjX3/9Nc8880xAvl69ejF06FAeffRRAHr27Bn0eKmpqeVuq20VbeuMGTOw2+106dKF2NhYDh06xP/+9z+cTidXXnllbTTlpFS0vV9//TWvvfYaF154IY0aNWLz5s3+vKmpqUGXtawLKtpe8N0crbi4mC1btgC+O85GRkbSokULWrRoUaPtONqoUaP4+OOPueuuu/jPf/5DRkYGL7/8MpdccgmJiYn+fDfddBOHDh3i888/B8BkMjF+/HhmzpxJbGwsrVq1Yt68eeTl5XHNNdfUUmtOrKLtBdiyZQsHDx703+yt9GZ3sbGx9OjRoyabcdIq2t7du3dz991307hxYy666KKAz2hsbCypqak13ZSTUtH2rl69msWLF9O3b1+SkpLIz8/n66+/Zu3atTz11FO11BoRaiSgF/Va165dee6553jzzTdZuHAhycnJPPzww2XW8/Z4PHi93lqqZdWoaFvbtWvHBx98wFdffUVxcTGJiYl0796dqVOn1tkfTqh4e0vXg16yZIl/VZ9Sjz32WJ2950Bl3stTp07l0KFD/sdPPPEEADfccAM33nhj9Ve+HFFRUbz55ps8//zz3HXXXZjNZkaMGMHNN98ckM/j8eDxeALSxo0bh1KK999/n9zcXNq0acOrr75ap9+zlWnvJ598wpdfful//P777wPQvXt3Zs6cWf2Vr4CKtvePP/7Abrdjt9u57rrrAvL++9//ZsqUKTVR/VNW0fampqbidDp57bXXsNlsxMTE0Lp1a2bMmFFnT9ZE3aMppVRtV0IIIYQQQghRMTKGXgghhBBCiBAmAb0QQgghhBAhTAJ6IYQQQgghQpgE9EIIIYQQQoQwCeiFEEIIIYQIYRLQCyGEEEIIEcIkoBdCCCGEECKESUAvhBBCCCFECJOAXghR71x77bVomlbb1QB8d70MCwtj2bJl/rTvv/8eTdOYPXt27VVM1AmzZ89G0zS+//77Cu0v76Xgfv31V3Q6HStXrqztqghRIySgFyJE7Nq1iwkTJtCuXTsiIyOJjY2lffv2jBs3jhUrVgTkbdasGWeccUa5xyoNeLOysoJu37p1K5qmoWkaP/zwQ7nHKc1T+hceHk7r1q258847ycnJqVhD65k777yTPn36MHDgwNquSo1IS0tjypQp/Prrr7VdFVFDbDYbU6ZMqfBJSUUd773WtWtXRowYwV133YVSqkbrJURtCKvtCgghTuznn3+mf//+GAwGxo4dS8eOHSkuLmb79u0sXboUq9XKueeeW2XlvfPOO1itViIiIpg1axbnnHNOuXm7du3KXXfdBUBOTg5fffUVL730EsuWLWPjxo0YjcYqq1eoWbt2LcuWLePzzz8PSO/Xrx/FxcUYDIbaqVg1SktL4/HHH6dZs2Z07dq1tqsjaoDNZuPxxx8HYMCAATVW7onea5MnT6Z///589dVXDB06tMbqJURtkIBeiBDw+OOPU1RUxK+//kqXLl3KbE9PT6+yslwuF3PnzuWyyy4jOjqamTNn8sorr2C1WoPmb9SoEddcc43/8aRJkxg2bBhffvklCxcu5LLLLquyuoWaN954g4SEBC666KKAdJ1OR3h4eC3VSojTwznnnEOzZs146623JKAX9Z4MuREiBGzfvp34+PigwTxAcnJylZX1xRdfkJGRwbhx47j22mspLCzk448/PqVjDB48GIAdO3aUm+fNN99E0zQWLVpUZpvX6yU1NTWg123p0qWMHj2aFi1aEBERQUxMDIMGDTrpMbIDBgygWbNmZdLT0tLQNI0pU6YEpCulePPNN+nRoweRkZFYLBbOPffcMsObyuN2u/n888+54IILyvTEBxv3fHTaG2+8Qdu2bQkPD6dTp058+eWXAGzevJkhQ4YQFRVFfHw8kyZNwuVyBW3nrl27uPjii4mOjiYqKoqRI0eya9eugLxer5ennnqKfv36kZycjNFopEmTJtx0001kZ2cHbdenn37KgAEDiImJITIykrZt2zJp0iScTiezZ8/2XykaP368fyjWyfTapqWlMWbMGJKSkjCZTLRs2ZIHH3yQoqKigHxTpkxB0zT+/vtvHnzwQVJTUzGZTHTp0oWvvvrqhOXAP+PWv/32W5544gmaNm1KREQEvXr1Yt26dQCsXLmSvn37YjabSUlJ4f/+7/+CHuvzzz+nT58+mM1mLBYLffr0YeHChUHz/ve//6Vdu3aYTCZatWrF9OnTyx0OkpeXx3333UerVq0wmUwkJiZy5ZVXlnkNT9XJPs/Hm4eiaRrXXnst4HvfNm/eHPB1PJS+5qWftaM/Xx999BGdO3cmPDycJk2aMGXKFNxud8CxT/ZzejLvNU3TGDx4MF9//TV2u/0UnykhQov00AsRAlq2bMnff//NggULuOSSS05qH4/HU+4YeYfDUe5+77zzDs2bN+ecc85B0zS6devGrFmzuP7660+6vtu3bwcgISGh3DxXXHEFd9xxB3PmzGH48OEB27799lsOHDjgH8oDvh/wnJwcxo4dS2pqKgcOHODtt9/m/PPPZ8WKFccdFlQRY8aM4aOPPuLSSy9l/PjxOBwOPvjgAwYOHMiCBQvK1PlYGzduxG63c+aZZ55Sua+//jq5ublcf/31hIeH88orrzBy5EjmzZvHDTfcwJVXXsmIESNYunQpr776Kg0aNODhhx8OOEZhYSEDBgygV69ePPPMM2zfvp033niDdevWsWnTJv8JoNPp5Pnnn2fUqFFcfPHFmM1mfvrpJ9555x1Wr15dZsjUQw89xNNPP02HDh244447SElJYefOnXz66ac88cQT9OvXjwcffJCnn36aCRMm+F+TpKSk47Z5z549nHnmmeTl5XHzzTfTunVrvv/+e5555hnWrFnDt99+S1hY4M/VuHHjMBgM3H333TidTqZPn86IESPYtm1b0IAwmPvvvx+Px8Ptt9+O0+lk2rRpDBo0iDlz5nDdddcxYcIErr76aj755BMeffRRmjdvHnA16o033uCWW26hXbt2PProo4DvfTpixAhmzJjBhAkT/HmnT5/OHXfcQZcuXXj66acpKirihRdeoEGDBmXqlZeXx9lnn83evXv5z3/+Q8eOHTl06BBvvPEGvXr14ueff6Zp06Yn1cbKPs8n0r59e1566SXuuOMORo4c6f9+slgsAfkWLVrErl27uOWWW0hOTmbRokU8/vjj7Nmzh3ffffeU23Ky77XevXszY8YMVq9ezZAhQ065HCFChhJC1Hk//vijMhgMClCtW7dW48ePV2+88YbasmVL0PxNmzZVwAn/MjMzA/Y7cOCA0uv16rHHHvOnTZ8+XQFBywLUoEGDVGZmpsrMzFTbtm1TL774ojIYDCo6OlodPnz4uO269NJLlclkUjk5OQHp11xzjQoLCwvY3263l9k/PT1dxcfHqwsvvDAgfdy4cerYr7f+/furpk2bljnG7t27FRDQ5gULFihAzZgxIyCvy+VSPXr0UM2aNVNer/e4bZs1a5YC1MKFC8tsW7FihQLUu+++WyatYcOGymaz+dN/++03BShN09Snn34acJzu3bur5OTkMu0E1O233x6QXtqmG2+80Z/m9XpVUVFRmfq9/fbbClAff/yxP239+vUKUOeee64qLi4OyO/1ev3PR7C2nchVV12lALV48eKA9LvvvlsB6u233/anPfbYYwpQQ4cODXgNNmzYoAB1//33n7C8d999VwGqW7duyuFw+NMXLlyoABUWFqZ++uknf7rD4VDJycnqrLPO8qfl5OQos9msWrZsqfLy8vzpeXl5qkWLFspisajc3FyllFK5ubkqMjJStW/fXhUWFvrz7tu3T5nNZgWoFStW+NMnTZqkwsPD1a+//hpQ77S0NGW1WtW4ceP8aafyfJ/K8xzsM1QKCKhDsM/Qsdt0Op3auHGjP93r9aoRI0YoQK1du9affiqf05Np+w8//KAA9cILL5SbR4j6QIbcCBECevfuzcaNGxk3bhx5eXm8++673HzzzXTo0IF+/foFvQzfrFkzli1bFvRv0KBBQcuZPXs2Xq+XsWPH+tOuvvpqDAYDs2bNCrrP0qVLSUxMJDExkTZt2nDnnXfSoUMHli5dGrT38Wjjxo3D4XAEDOmx2+189tlnDBkyJGB/s9kckCc7Oxu9Xk+vXr1Yv379ccs5Ve+//z5Wq5URI0aQlZXl/7PZbAwbNoy0tDT/VYjyZGZmAhAXF3dKZV977bVER0f7H3fu3JmoqCgaNmxY5upM3759SU9PDzqc4P777w94PHLkSNq2bRswQVfTNCIiIgDfFR2bzUZWVhbnnXceQMDz+sEHHwDwzDPPlBn/XzrcoSK8Xi+LFi2iW7duZeYaPPDAA+h0Oj777LMy+91+++0BZf7rX//CYrGc8HU52k033RRwBaK0l7dXr1707NnTn240GjnzzDMDjr1s2TIKCwuZNGkSUVFR/vSoqCgmTZqE3W5n+fLlgO8zUlRUxC233EJkZKQ/b2pqKldffXVAnZRSfPDBB/Tr149GjRoFvP/MZjNnnXUWS5cuPek2lqro81xVBg4cSPfu3f2PNU3j3nvvBajWcuPj4wHIyMiotjKEqAtkyI0QIaJTp07+Mdd79uxh5cqVvP322/zwww9cfPHFZYZHmM1mLrjggqDHev/998ukKaWYNWsWnTt3xuv1Box/79OnD3PnzuWZZ54pc0m+V69ePPnkkwCYTCaaNm1KkyZNTqpNpUH7nDlzmDhxIuAbo11YWBhwUgGwc+dOHnroIb755htsNlvAtqpec37r1q0UFBQcd6jI4cOHadOmTbnbS+ukTnHJvBYtWpRJi42NpXHjxkHTAbKzswOGOMTExASdV9G+fXs+//xzCgsL/SdIn3zyCdOmTWPTpk1lxuPn5ub6/799+3Y0TSt3HkdFZWZmYrfb6dixY5ltcXFxpKSkBD1hDfY8xcfHlzv2P5hjj1H6fJaOCT9229HH3r17N0DQepemlda79N927dqVyduhQ4eAx5mZmWRnZ/tPlIPR6U69L66iz3NVad++fZm00rZXZ7mln7+6cl8KIaqLBPRChKCmTZsyduxYxowZwznnnMOaNWvYsGEDffv2rfAxV65cyc6dOwFo3bp10DxffvklI0aMCEhLSEgo98ThRMLCwrjqqquYPn06O3bsoFWrVsyZM4fY2NiAMep2u51+/fpRWFjI5MmT6dSpE1arFZ1OxzPPPMN33313wrLK+0E/dlIe+IKAxMREPvzww3KPd7x1/gF/MHaq6/Hr9fpTSodTP2kotWDBAkaPHs2ZZ57Jyy+/TOPGjQkPD8fj8TBkyBC8Xm9A/sr0xFe18p6PU3kuKvJcV7fS+l9wwQXcd999tVaPU/m81OVySz9/5Z0cCVFfSEAvRAjTNI1evXqxZs0aDhw4UKljzZo1C5PJxJw5c4L2AN5444288847ZQL6yho3bhzTp09nzpw53HDDDXz//fdMmDABk8nkz/Ptt99y8OBBZs2axfjx4wP2P3ZCaHni4uLYuHFjmfRgvYOtW7dm27ZtnHXWWWUm952s0oD/VIaAVBWbzUZ6enqZXvqtW7fSoEEDf+/83LlzCQ8PZ8WKFQFDQf76668yx2zTpg1Llizht99+O+5E31MN+BMTE7Farfz5559ltuXm5nLo0KE6uZ59ae/+n3/+yfnnnx+wbcuWLQF5Sv/966+/ys1bKjExkZiYGPLz8yt8ohzMqT7PpUPFcnJyAoaNBfu8nMxrvnXr1jJpxz5PpeWe7Of0ZMotvdJ4ohNwIUKdjKEXIgQsW7YsaA9VcXGxfzztsZfuT0VeXh7z589n0KBBXH755Vx66aVl/oYPH86SJUs4dOhQhcsJpmvXrnTu3Jn333+fuXPn4vV6GTduXECe0h7TY3tfly5detLj59u0aUNBQQEbNmzwp3m9Xl566aUyeceOHYvX6+WBBx4IeqzDhw+fsLxu3boRFRXlXwaxpk2dOjXg8Weffcbff/8dcEKm1+vRNC2gJ14p5R9CdbSrrroKgAcffBCn01lme+lrU3oCdLJXJnQ6HcOGDWPTpk18/fXXZdrg9XoZOXLkSR2rJg0cOBCz2cyrr75KQUGBP72goIBXX30Vi8XivzvwwIEDiYiI4PXXXw9YHnL//v1lrgLpdDquvvpqNmzYwPz584OWXZHx4Kf6PJcOJyudB1Bq2rRpZY59Mq/5smXL+OWXX/yPlVI899xzAAHvyVP5nJ5MuevWrSMsLIw+ffqUm0eI+kB66IUIAXfccQfZ2dkMHz6cTp06ERkZyb59+/jwww/Ztm0bY8eOpVOnThU+/kcffURxcTGjRo0qN8+oUaOYPXs27733XpkJl5U1btw47rrrLp599lnatGnDWWedFbC9b9++JCcnc9ddd5GWlkZqaiq//vorc+fOpVOnTmzevPmEZUyYMIFp06YxcuRIbr/9doxGI/Pnzw96olS6VOVrr73GL7/8wr///W8SEhLYv38/a9euZceOHScc96vX67nkkkv4/PPPcTgcAVccqltCQgILFizg4MGDDBgwwL9sZVJSUsB6+5deeimffvop5513HmPHjsXlcvH555+XWZMc4Mwzz+S+++7j2WefpXv37owePZrk5GR2797N/Pnz2bBhAzExMXTo0AGr1cobb7xBZGQkMTExNGjQwD/RNpinn36aZcuWMWLECG6++WZatWrFqlWr+Pjjj+nXr1+ZE7y6ICYmhueee45bbrmFXr16+ddlnz17Njt27GDGjBn+yc2xsbH83//9H3fffTdnn302Y8eOpaioiLfeeovWrVuzadOmgGM/9dRTrFmzhssvv5zLL7+cs846C6PRyJ49e/jqq6/o0aNHwD0MTtapPM9XXnklDz74IBMmTOCvv/4iLi6Or7/+OuhSuPHx8bRq1Yr//e9/tGzZkqSkJMxmM8OGDfPn6dKlC+eddx633HILKSkpLFy4kOXLlzNmzBh69+7tz3cqn9MTvdeUUnz99dcMGTKkwlfahAgZtbK2jhDilHzzzTfq5ptvVp07d1bx8fFKr9eruLg4NWDAAPXOO+8oj8cTkL9p06aqY8eO5R6vdEm60mUre/bsqcLCwsosH3m0kpISZbVaVZs2bfxpHFk+sLLS09NVWFiYAtSTTz4ZNM9vv/2mBg8erGJiYpTFYlH9+/dXq1atCrq8XnlL7i1evFh16dJFGY1GlZKSou699171119/lbvk3pw5c1Tfvn2V1WpVJpNJNW3aVI0cOVL973//O6l2lS71OH/+/ID04y1bGWwJvqZNm6r+/fuXSS9dwnH37t3+tNJl/3bu3KmGDx+urFarslgsavjw4Wr79u1ljjFz5kzVvn17ZTKZVHJysrrhhhtUdnZ2maUJS3344Yfq7LPPVhaLRUVGRqq2bduq22+/PWD5x8WLF6tu3bopk8mkgKB1P9auXbvUNddcoxITE5XBYFDNmzdXDzzwQMAyj+W1+UTP07FKl608eqnIUuW1u7z31IIFC1Tv3r1VZGSkioyMVL1791afffZZ0HLfeust1aZNG2U0GlXLli3VSy+95F/e9Ni6FBYWqieeeEKdccYZKjw8XFksFtWuXTt1/fXXq3Xr1vnzneoyoSf7PCul1Lp169TZZ5+tTCaTio+PVzfccIPKzc0N+hytX79enX322SoyMlIB/qUnj15u8sMPP1SdOnVSRqNRpaamqkceeUQ5nc4y5Z7K5/R477Xvv/9eAerLL788qedGiFCmKVXB2VRCCCFOaMiQIRQWFvLDDz/USHkDBgwgLS2NtLS0GilPiONJS0ujefPmPPbYY2XuxlzdRo4cyb59+/jpp5/qzGRuIaqLjKEXQohqNG3aNNauXVuhtcOFEBWzadMmFi5cyLRp0ySYF6cFGUMvhBDVqGPHjtW+1J8QIlC3bt3KLLsqRH0mPfRCCCGEEEKEMBlDL4QQQgghRAiTHnohhBBCCCFCmAT0QgghhBBChDAJ6IUQQgghhAhhEtALIYQQQggRwiSgF0IIIYQQIoRJQC+EEEIIIUQIk4BeCCGEEEKIECYBvRBCCCGEECHs/wE09nOB7KUx/AAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvQAAAEDCAYAAABao5AqAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAABqqklEQVR4nO3dd3gU1frA8e/sbnY3ZdNDEgihI0Wa8KMIgl4FVBRBVGyAXBuWi9i7oteCBUGxgQ2xCxZQRAFFUES4CAoKCiihJpC2STZl25zfH0sWlmwo6Rvez/PkSfbMmTlnTmZ33zlz5oymlFIIIYQQQgghQpKhvisghBBCCCGEqDoJ6IUQQgghhAhhEtALIYQQQggRwiSgF0IIIYQQIoRJQC+EEEIIIUQIk4BeCCGEEEKIECYBvRBCCCGEECFMAnohhBBCCCFCmAT0QgghhBBChDAJ6IUQQgghRKMwefJkoqKijrosIyMDTdOYN2/ecW2/quvVNlN9V0AIIYQQQoi6lJqayqpVq2jfvn19V6VGSEAvhBBCCCFOKBaLhb59+9Z3NWqMDLkRQgghhBAnlGBDZ1wuFxMnTiQ+Pp7Y2Fiuv/563n//fTRNIyMjI2D9srIybr75ZuLi4khNTeWOO+7A4/HU8V4cJAG9EEIIIYRoVDweT4UfXdePuM4999zDzJkzufvuu/noo4/QdZ177rknaN77778fg8HAxx9/zIQJE5g6dSqvv/56bezKMZEhN0IIIRoFt9vNW2+9BcD48eMJCwur5xoJIWqcdqHvt/q00izFxcWVvv8jIyODpufl5fHKK6/wwAMPcPfddwMwdOhQzjrrLHbt2lUhf58+fXjhhRcAGDx4MMuWLWPevHlMmDDhePamxkhAL4QQQgghQsTRB5eEh4ezYsWKCumzZs3i/fffD7rOxo0bKSsrY/jw4QHpF1xwAd9++22F/EOGDAl43alTJ7777ruj1q22SEAvhBBCCCFChHbUHAaDgV69elVI//LLLytdJzMzE4CkpKSA9CZNmgTNHxsbG/DabDZTVlZ21LrVFhlDL4QQQgghQoTGsQT1xys1NRWA7OzsgPT9+/fXeFm1QQJ6IYQQQggRImonoD/55JOxWq3Mnz8/IP3zzz+v8bJqgwy5EUIIIYQQIaLmg3mAhIQEbrjhBh5//HGsVivdu3dn7ty5bNmyBfAN42nIGnbthBBCCCGE8KudHnqAKVOmcN111/Hkk09y8cUX43a7/dNWxsTE1EqZNUVTSqn6roQQQghRXTJtpRAnAO0K32/1Xp0UN2bMGH788Ue2b99eJ+VVlQy5EUIIIYQQIaJ2eucBli9fzsqVK+nZsye6rvPll1/y3nvv8dxzz9VamTVFAnohhBBCCBES1IGAvjbC+qioKL788kueeuopSktLadWqFc899xyTJk2qhdJqlgT0QgghhBAiRNReD33Pnj356aefam37tUkCeiGEEEIIERJqs4c+lElAL4QQQgghQoRM0BiMBPRCCCGEECIkKOmbD0oCeiGEEEIIESIkoA9GAnohhBBCCBESpIc+OAnohRBCCCFESJCAPjgJ6IUQQgghREhQclNsUBLQCyGEEEKIECE99MFIQC+EEEIIIUKCDLkJTgJ6IYQQQggREiSgD04CeiGEEEIIESIkoA9GAnohhBBCCBES5KbY4CSgF0IIIYQQIUGG3AQnpzlCCCGEEEKEMOmhF0IIIYQQIUGG3AQnAb0QQgghhAgJMuQmOAnohRBCCCFESJCAPjgJ6IUQQgghREiQgD44CeiFEEIIIUSIkIA+GAnohRBCiBChdIWnzIunzEtZnhNN09C9Ct2jo7t1nIVudJeOOTrMv47XreMqdBOZEo7BpGEwGTCYNJQO1lgzpggjJqsRg0luNhQNny43xQYlAb0QQghRh5SucBa4cWSVULCjGE3TKLO7KMt3Urzfyb5fcohqGo6r0I2z0I2z0EVpjgtNA92jDm5Ir+HBBwZf36c5xow1zowlOgxLjJkyuwtbWgRxbaKxxPqWmawGLLFmYlrZsMaa0QzSayrqihxrwUhAL4QQQtQApRTOIg85Wwpx252U5bsp3l9K8b4ysjfkU5rnRPcqnHY3SlcV1teMGigFXkXeX4UVt394/preAd1XhjPfhTPfFbAo+7d8DKa96F5VoSKaASyxZsIiTWiaRtN+SUSmhBOZbCUi2YrZZia+fTRhERJyiOqr+M4RIAG9EEIIcUx0r8KR58K+z0XBfif2LCfbl+/DYlQUZ7tw5DjxOHWshcUYvToAmklD47Ce9UoorwLVcG/5q2wflA5leS7K8nwnAUV7S3zph+U320xEpkZgS4/A7fDQ/LRkYtvaiG4eia1ZBKZwCUnE0ck89MHJu0cIIYQ4oLTIQ/bOEvZsLkb3KvKznOTvLSNnVylFue6AvJpBEVlQUmEbmjoYyCqPOuF6FA8P5Mu5ijy4igrJ3+K7+pD5c07AcoNZw9Yskibd4ohuEUV0i0iiUsOJTo8kIim81ustQkPDPeWtXxLQCyGEOGF4vYrCbBd5mU7yM51kbCjEnlWGu0zHvs+Jq1T395JrBnzj1r3Bt6UqSUfTkIEBx093KQq2OyjcWQwcuGJxQFiUiZiWUcS2sRGZbCUs0kTzgSlEt4jEHBVW2SZFIyQBfXAS0AshhGhU3B4TmzcUo5Xo2LNc5Gc5yd3rZPdfDjxlOod0oKOpyufMULqE5fXh0EC+nNvhIed3O7mbC3z3HyhYO20zANY4M7b0CJQXWp/bjNjWNmJaRmFLi8RoluEZjY0E9MFJQC+EECKklDl1snO87M/1kLXPzdr1pYSHa2Ttc7M380y8uom9X/6NgcBe9kOHwojQFCzYL8t3UXbgJt6cP+wHz8I0MJoNNOkWT0KnGGJaRvkC/RZR2FLDZWaeECUBfXAS0AshhGgwdF2x36HYts9DfqYb3amTnethf66XHbtc5Od68B461EUdfouc72utPE162U8wKvBvr1Mnc00O+9blBszQoxk1oltEEtfG5pt6My4MW1okTbrHE9HEiqZJ0NhQSUAfnAT0Qgghap1SCocbtuQoisp0Motgb5Fib6HOir/dFJcpCssU+xwKjw6dSspoU+abe91gAF0HdCVfWqJKDp+hR3kVBf84KNjuwGDMClhuNBuwNY8gookVo9VEizNSfDPxpPtu0pUHcNWvUA7o9+zZw4oVK9i/fz+jRo0iLS0Nr9dLQUEBMTExGI3GKm9bPhtDzNq1a5kwYQIPP/ww559/fn1XRzRAXl3h9EKZR+FVGm4d3F5w65BXprAaQUfDo4NHh/0lCqsJzAbwKtAV2MsUZV6NhHDftNgKcHoV+4o10qMPzn+tUOws0mgdAwbt4E+WA5pGgdmoYTSAUYNit8JmhnCThskAJg00FEaDLy3MCGEG34/JgPSQNXDlAXpuqe8Y2pzr+79ll0J2iSKzWLF8J8RaYH+JL93pBQqc/l5Sg+Y7NtxOb4VudIM6MDuMwt8jL0eEqHGqYrDvdenY/3Zg/9sBwK5lWQcXlg/j6R5PdHoktrRIbM0jCIs0kdgplogkqwzlqWWhGNArpbj99tt58cUX8Xg8aJpGly5dSEtLw+Fw0LJlSx599FEmTZpU5TIkoBeilimlKPOAww0OF+x1KExGjWK3otgNxW5Yl6VIigRd1yj1KEo8sCFbEWbQiDJD6YG8O4ugyAXRFnB6fAFSkQtKPb7AyKODXnM1r0Za9ZUH9mEG3/CJEg8kR4LFCFYThGmwxwFtYiEuHKxGDYsRdhQqmkZpNI3y5bUYIa/Ut602cZo/zasrilwa7eLAYgKLUcNsUJS4ISXKl898IK9JU1hNGmYjGEP4y9qr+47FIpfCpWsUu6HkwDH4V75OhEnzH1OFLvhtv45X+doir0yRVwY7C33LvDoEm52wPEj36r6TwwoCH3QaPI8QDVX5MJ7VOWT9kgsqcFy/ZtKISLIS3TwS3aOT2DmW+JNiiEwNJyo1nMiUcJmVp5pCcR76Z555hueff567776bM888k8GDB/uXxcTEcOGFF/LJJ59IQC9ETdKVwuHyBTV7HL4Paofb97rIBb9n+3oOLUYoOpC+LV+RUwoxloPBkL3Mt1ypYw95TZqivGParQMoDFrFoCezuOK6Qe4VC2lu3fdTekjarqKK+fYfyKDhaztd+f4+9Kq4+8BZjkFTh7Xl8TeaAd/JgVf5Av5w08ErC8Vu37ImEb7fJgOUun3HQeuYg2lOL+wohC6JYNC0A7McKv7IhQ7xvgC63J95iuRIsJk1XwCsKzIKfMNQEqwH2ymn1Nf5nRDu277bC8UeKHL66un0Hssxog60k+/Hc4RjsDL+IL2RHY9CHC7YfPvKoyjOLKU40/fBtG9dXoU8BpNGZGqEL8BPDcdkNWIIM5DSK4GIJCvhiRYikqz+J++KQKH40fLaa68xduxYnnjiCXJzcyss79q1K4sWLapWGRLQN0JKKUpLS4mIiKjvqtQJt9fXe51T6htqUuLWcLgVRS7YVaTIdECsVcPh8qVlFit+z4H0aF8AVOCEfKdvmIjxQLB1LMIOBIxKBe+prApPkEBIejCPjQL/dISKg0H8oWqiLXXAdWDbpR7fz+GySyumBTsZ2V4Ah//Dt+QHXlBWwMacivkqE6xsT5A6HsnhPedyDApRc3SPomhXMUW7itGMmr+Hf9O7/wRm1PAF+AkWIppYsSaYKckqI7VvEhFJVqxxZqyxZozhRiKbWLHEmE+I8f2hOORm165dnHrqqZUuj4yMpLCwsFplSEAf4g4dU19aWsrcuXPZvXs3V111Fddff319V6/WnD3Pw6q9vmAqWOB2OKPm62UEX6/jwSApkOcYg3k4tnKFqAqJn08cipq/NyDYNqtTTm3UUfgEm4bz4EIo2V9Gyf4ycjcX+P4JCvasyq70Q8IUbsRsC8MSY6bHjSfRZlhardS7PoXikJsmTZqwa9euSpf/8ssvpKenV6sMCegbiQ8++ICCggJGjBhBQkICycnJ9V2lWvXDbt+Y6mPlVY1vSIoQomGqu+nu6zfUrukTh+qWXRfr1it12O8gPKVePKVeSrLL2L1yfyMN6EPPhRdeyKuvvspVV11FTEwMcHDih8WLFzN79mzuuuuuapUReqc5IqisrCzeeecdrr32Wi688EL69+9f31UiLy8Pp9Ppf+1wOCgqOjjuwOVyVRhLlpmZecTXWVlZqOP+tgzFt39DFQptWVd1bIht0RDrJISoa4fOtFMT37WHf5/XJx0DlT/fuWF65JFHSE1NpXv37owdOxZN03jqqacYMGAA55xzDl27duW+++6rVhmh1SKiUsOGDSM+Pr6+qxEgPj4ei8Xifx0VFYXNZvO/NpvNJCQkBKyTmpp6xNcpKSlVuEkoJPtiGqhQaMu6qmNDbIuGWCchRH2qie/aw7/P65dGqH3WxcTE8PPPP3PXXXexZ88erFYry5cvx2638/DDD/PDDz9U+75HGXLTSFR37JUQQoiaUXcTk9RvUBOs9FA4nQ6tULBqVCO+kz1U9yw8PJwHHniABx54oFa2LwF9I2G1Wuu7CnVq/Mkaq/Yq/9zuxR4odB79jX7wgUi+WWqU8s1a0og/+4QQDVhtBJc1HWifCAFwQ6YZfENodF1V+qARo8WAJdaMJcZMeLwZS5yFdsOb121F60ioDbepKxLQi5D04lnBH49cPoVlkcs3d3x2iSKrxDdnfPnc8lnFig3Z0CLm4NzyeaWK9ft9c3iXeKDY5ZtT3HWUmWw0DjzQ6cAJgUmTEwRx4IKw5vtdfjO2yXAwMPIeeADYoWnl058aD8wBX86t+/IEm1c/zHDwJNajHyxbDj8hGj7N5HujV5jPXoOwSBPokNgllogmvqkrrXFmyvJcJPdKICLBgiXWjDXOgiUm7ISYrrJcKE5b+e9///uoeTRN44033qhyGRLQi0YlzKgRa4TYAxcsOiZU743v9uo43Jo/8C9ywd9239Mz4cCJgwu22nX2l0CTCA2HCwpdir0O38ODYi2+k4MSj++pnMcbbIUFCeRO9KCtfASlzsEnk5bzP0SK6j01V+Pg02qdXt9Dw8JNvoc0mQ2+BznFW30ngf60Mt8TbFvGaP6HSBW6FHml0ClRw4DvWQdur2JLPvRoomE0lO+P4tdsjZMTfdsrtylXkRqpYTMfnB9+e4HCoGk0ifCdMHh034lqdgmkR2u4vIoyr+/hZtsLIDXKN8Vr2YF58+1OX/sc6/MTyo9BXWaLEuKYaCYt6IOnjBYDlhgzCZ1iiEwJJ7JJOGE2EyaLkaSucUQkWrHGnxjzyVdVKH4EfffddxXu//N6vWRmZuL1eklKSiIyMrJaZUhAL8QRhBkNxBkh7pARTX2bBrs6cGwfvkopyjyKEo9GsftAoO/2PUzIZgaX92DgvzFHYTFChOngA4z+sSvsTkiN0g5sB7JLfE+OTYrwre/y+vIWOMFq9AVgbr3hBWLlvdAaB5+2ajL4gsYyLzSN8gXJZqMvzx4HdE2EiDAwGzXMRsWfedAlUSPW6strMcLOImgWBSmRvieuWozgcCtMmkbzaLCawGLUMGkKlw7JEQfymXx5wwwKq0nDZAi9XqDj5dEVJQeOw33FvicgF7k0ilyKIjf8nqPw6L7/i70MClywJU+RWez7v+SV+Ya6BTu2NM131aG6J1ZCNESaUQMVOFbdYDYQlRqOrXkktrQIdLdOUpc44tpG+4L3FCtGc/Cry+LYheI89BkZGUHT3W43M2fOZPr06SxZsqRaZUhAL0Qd0jSN8DCN8DBfz265nim1HzwqpXB7FV6l+Xt1PTqUeBS+7ybN3wPs9CrcXrCYNJQqfwqrwuECm0XzX/DUNHC4FNEWX++zQfOlub2KiDANo+brkTZqvh5os/Fgz3X9P9K8svLru151x2TQiLZAtMV3knjQsbeBUr57WfYUKQpdGtkliuxS3xWDxdsVqVEa+4oVexywrwTyD4vwT/SrTaKBCnJgakaN8AQzaBrpZ6QQ3TwSW1oktmYRRDYNJzzB0gA+1xq/UBxyU5mwsDBuvvlmNm3axM0338zChQurvC1NHf+k3kIIIUSVuD062SWwt1Cxt0ixt1Dx/d8eSpw6xS5FRp7O3kJFi8Iy2pe5AN9JosEAukdV7IVSwfvrOuyr+ChoLcjXnaaC3GKnjjFkUIooR0mF5PDCYgzeKl6XONayAU1u1qkezRekHzo0xmg2YGseQWybaCISLRjDjTQ/LZno9EgiU8JlKEwDsFmbBkBHdWs916TmzJw5kzvuuCPgWT3HS3rohRBC1Jkwk4Gm0dA0+mDahD5hAXmUUthLbGRneygo8JKd6yE7z0vGLhcZGS6UgiJHYMBsODBrlXRRiQoMHLjMeOC1BhFJVpp0iyOmZRTRLaOIahpOdHoUtrQI6WVv4BpTD325JUuWyDz0QgghGhdN04iL1IiLNFeax+VW5OR6yNrvZv2GMixmjaz9Lv7YvJ8yZzgeTcN0ILrXDL5eft1zIg2oOsEcfrOGBhHJVjRNI+20JiR2jCWmZRQxraKITAkPeJKqCC2heM7+6KOPBk232+2sWLGCdevWcc8991SrDBlyI4QQolFwu9289dZbAFxy0VhK7Tr5WU7ys1zkZTrZtq4AV7GXUocH3etbp3zITflNvIAMuWmgtAPTWalD7sK2xJqJbR1FdItIdLei9bnNfL3u6ZFyA2ojtVF7AYAuamI91+TYGQzBh2rFxcXRpk0brrnmGq699tpqXR2SHnohhBCNTqTNSGy8ldTWFS9j615FYY4vyN/xRxH5e8rwenRydzuxZzlxFnv8ebUDN3DrDW2aqEZMM2oBQbshTCO+fQyxbaKIaWkjslk44fEWUnomYI4KO8KWRGMUiu9EXa/9ub4koBdCCHFCMRg1YpMtxCZbaN09usLy0iI3+zNKKSnwkJ/pxL6vjOwdpez5y4HygjfIg4ACogy58F0pzQBooLyB6dYEC4YwjYT2MTQ5JZ6YdF+ve3R6JJaYyodeiROPPCk2OAnohRBCiEOE28Jo0SV4z69SimK7h4J9Tuz7nPzzQzYWI5TkuyjYU0rR/jJUkQH/mB5AM2gB85U3dsH21xIT5pviMd03zaO7xEPagCbEtrIRlRaBySLDY8SxCYV30s6dO6u0Xnp6epXLlIBeCCGEOEaaphEVF0ZUXBjNOkTReVBChTxlDjdl2WWUZDsp3ldK8f4y9v2aT0lOGZqmUZJdRlmeE3eJN0gJB8opHy+uq/qJYDRfYO67mbjyCpjCjVgTLEQ2sWKKNKG8iuanJROZHE5EspXIlHAimlgwWSTcEDUjFGa5admyZZXGw3u9lX8mHI28w4QQQogaZI0KwxoVRmwr2xHzeZxeiveV4i72UmZ3UZbvojSnjMz/5WBLi8Dt8OAqclNW4CJ3UwHmqDB0r46nTMfr9OIt8VQ72DdaDBgtRkxWI0arAWe+m5hWUUQkW7HYwjDbwijNcxLTwjdDjDXOjCXW92ONNcsYdlHnQuFJsW+++WadT38qAb0QQghRD0wWIzHpURXSu4xtc8zb0L0K3aOju3V0j8Lj9KK8OgZjYNCju3XCIk0YwgwYTAYMJg3NqMmc6yLkhMKQm6uuuqrOy5SAXgghhAhRBqOGwWgEGYMuThChMOSmPkhAL4QQQgghQoI3hAP6lStXsm7dOgoKCipMZalpGg8++GCVty0BvRBCCCGECAmh2EOfl5fHsGHDWLNmDUopNE2j/Lmu5X9XN6Bv+HcWCCGEEEIIAeho6CEW1N95551s2LCB999/n3/++QelFN988w1btmxhwoQJdO/enb1791arDAnohRBCCCFESFBoIddL/9VXX3H99dczevRobDbf7FcGg4G2bdvy0ksv0bJlSyZNmlStMiSgF0IIIYQQIUERGjPdHMput9O5c2cAoqJ8M1s5HA7/8iFDhvDNN99UqwwJ6IUQQgghREjQMaCHWPjatGlTsrKyALBYLDRp0oTffvvNv3zPnj3VnkJWbooVQgghhBAhIdR65wEGDhzIkiVLuP/++wEYPXo0Tz/9NEajEV3XmT59OkOHDq1WGRLQCyGEEEKIkBBq4+cBbrvtNpYsWYLT6cRisTB58mT++OMP/6w2AwcOZMaMGdUqQwJ6IYQQQggREkJthhuALl260KVLF//ruLg4li5dit1ux2g0+m+UrY7QGoQkhBBCCCFOWKE4y82mTZuCpsfGxtZIMA8S0AshhBBCiBDhNWh4DaEV0J988sl07dqVJ554gm3bttVKGRLQCyGEEEKIkKA0308oeeWVV0hKSuKhhx7ipJNOomfPnjzzzDPs2LGjxsrQVPmzZ4UQQoh6pHt07LtLKLO7KdhTyp51+UQmminYU0ru3w6ikq3k73dT6NIIj7dQUuBGKbAlmCks8mK2hVHoysRbFkannuk0SY/AWeIhvZONhGZWbAkmwszG+t5NIUQ1LDK/A8A5rjH1XJPjt2/fPubOncvHH3/MypUrAejduzeXXnopF198MU2bNq3ytiWgF0IIUae89jJyl+6hMM9NUUYxf6yx4zQZKc5zVZiTTjNqKF35051WMy6LGQ4bQ+symVCaxsENaL4sh20vKs5EQjMLSoduZyaQ0iqCxOZWwqNkjgghQsHCyHcBGFZ8ZT3XpHr27NnjD+7XrFmDpmm43e4qb08+wYQQQtQa185CnGsycW3KpeDjLbj2lKDbXWyNT8RtMoFJI69pHOANur7yHm+f0yFRfJBVHfkeHPkeAHZuKvanxze1kJhmJTbZTI+zEklpHY7RJKNShWho9BAbP1+Z1NRUOnfuTMeOHfn9998pLi4++kpHIAG9EEKIGqE8Os4N2Tg+20rJ0gy8exx4dhX5Fho1PF4D6sCtW+rAl7LyNIyLxHl7neTtdQKw5otsnNYwolIj6DkoluZtrbTtGEF4hAzXEaK+qRA+z1ZK8f333/PRRx/x2WefkZOTQ1xcHJdeeimjR4+u1rYloBdCCFEl3mIXJQu24dpqp3jBNpzr94NeSYB+3D3t9cutGcnO9rD40xx0HTQNWrYLJyEljJ79ozmpSxSmsMbRUyhEKNGNofe+++GHH/j444+ZN28e+/fvJzo6mhEjRjB69GjOOussTKbqh+MS0AshhDgmemEZ7h8zKHrhF9w5Tsp+3YfHawKjFnIB+7HSdd9vpWD7llK2byll7YpCTCaIjjfR71+xdO0dTUqaGU0LvUBDiFCjQnDIzaBBg4iKiuL8889n9OjRnH322ZjN5hotQwJ6IYQQQek78/Gs3Y33xwxKZ69H2ctQCoqJOpDjwBdrIw3mj8Tjgbz9HhZ+mMPCD3MwGKF7XxudT7HRukM4CU1q9staCOHjDcEe+rlz5zJs2DCsVmutlSEBvRBCCJRSkJGL573/4fltH97f9uLZmg9oYDKgPBqHzywjDtK9sP6nItat9N0z0KSpmXadI0htbuH/BsXI+HshakiozUEPMGrUqFovQwJ6IYQ4AemlLtQP22DjHryfrIPfdkOJGzdmdP9Xw4Eg1KMf/FtU6tBJoPfvdbF/rwuAT97aR2JKGKnNLZx6VhytTgqXAF+IKlIytC0oCeiFEKKRU24valMm+g/b0D9aC4WlsHGvLwI1aJXfyCpqhFKQnekmO9PNhjUOisxhhCeY6dUrkpRkE11PDqdZ0zAZgy/EMQjFITd1QQJ64IsvvuCRRx7h1VdfpVevXvVdHSGEqDJlL0Ft3IP3g7WoEjdq3U7U73vQFICqOGhGgvk65zYYKC3Q+fb7IrxegHzCrRAVZaRH9wg6dbDSNDWMtKZhGELwBkAhalMoDrmpC8cV0K9du5YJEyYAcP/99zNy5MgKeXr16sWAAQOYPn16jVRQCCFEIN3rhb0FqK3Z6Is2obIKUHvtsPJvNKcbBb753g0G0HUZ+d5AeQ95llZpGZSWeVm8tIjFS33j8E0mSEk2YTRo9O0TSWqyiehoI61bWrBaQ3gybiGqQYbcBFflHvpZs2Zxzjnn1Oodu0IIcSJSuo6+vxjv9jzcP+9BUwrv2l1oG3aiudzwdzYGvTwa9PoDdg39kK3IUJpQ5/HA7j0Hnmq72x4wRt9i1rBYNU5qa8FghJhoE21aWzAaICnRREKCicgIDavVIEN5RKPilatWQVUpoO/UqRObNm3igw8+YPz48TVdJ3EEHo8Hr9eLxWKp76oIIY7V5t0QboaWTQKSnQv/wr1mN95MB+7v/kaLMOPNKoLsksD1DRom5SRM+W6y1NBRyJwzJxJ12LmZ06VwuhT/W1d6MPHbogrraRpYwg38YbYQl2AiKlwju1BxcrqJCItG2xQTNwyJOKQcxR85EGOB5tF1d4TtdSiyin1DwprbNBIj5OgWwYXqkJvCwkJefvllli1bxv79+5k5cya9e/cmLy+P2bNnM3z4cNq2bVvl7Vfpmt1ZZ51Fx44defvtt7Hb7UfN36tXLyZPnlwh/YsvvqBXr16sXbvWnzZz5kx69erFP//8w9SpUxk6dCj9+/fnhhtuICMjA4DvvvuOK664gv79+3P++efz6aefVmU3jqi4uJiXX36ZcePGceaZZ9KvXz9GjBjBjBkzKCsr8+f7888/6dWrFy+99FLQ7dxyyy0MGjSI0tKDH7o5OTk8+eSTDBs2jL59+3L22Wfz+OOPk5eXF7BueVv8/fffPPfcc5x77rmceuqpbNy4EYAff/yR6667jjPPPJP+/fszbNgw7rzzTnbs2FHj7SGEqKLrX4FOE6H1DTD9i4BFhZd+TMnjy3G++Qv63/l4N+6rGMyDr6e90s72mvl2U5X8XWtbrE4hAZuu2W2Xr3roZo93c5XlV0dZfryOZTtKQUGpIl838E+2zoadXjLtOks2uFiw1snUL4p9U5biC+ZHf6HT5W0vrV7z8tZG/Shbrxkf/anTcpaXnu/onPKO7+8fdsvVJRGc16CFXC/97t276dGjBw899BC7d+9mw4YNOBwOAOLj45k5cyYzZsyoVhlVCug1TePmm2/G4XDw5ptvVqsClZk8eTJbtmxh/PjxjBkzho0bN/Kf//yHhQsX8tRTT3H66aczceJEbDYbTzzxBL/++muNlp+dnc38+fPp1KkT11xzDbfeeisdOnRgzpw53HHHHf58HTp0oGPHjixcuBDvoQMigf379/Pzzz8zZMgQwsPDAcjKymLMmDF8++23nH322dx9992ce+65LF68mKuvvtr/Dz7Ugw8+yMaNG7niiiuYNGkSiYmJ/PLLL9x2220UFRUxfvx47rzzTkaOHElBQQG7du2q0bYQQlTR7hyYtcT3t1Lw0IcBi5VX9z2U6QR8MFPNa5ht2DBr5XP4udDGHJi7xZfoVTD5p7oJ6P+7Ssd9SFHFHnh6Td2ULUKP0rSQG0d/5513UlRUxK+//sry5cv9J9HlRowYwdKlS6tVRpXvqunTpw99+vRh3rx5ZGZmVqsSwSQkJPDqq69y6aWXMmHCBG6++WYyMzN5+umnefvtt7n22msZPXo0L730EmazmY8//rhGy2/WrBkLFy7k7rvv5rLLLuOSSy5hypQp/Pvf/+bnn3/m999/9+cdOXIk+/fvZ9WqVQHb+OKLL/B6vVxwwQX+tKeffhqPx8N7773Hf/7zH0aOHMnEiRN55ZVX2Lt3L++9916FukRFRfHaa69xxRVXcPnll9OyZUuWL1+Oruu89NJLXHnllYwYMYJrrrmGWbNmMWDAgBpti6rKy8vD6XT6XzscDoqKDl4Sdrlc5ObmBqxz+LF0+OusrKyAN4KUIWU06DIiLBB2cGSjiosMKEOIhiAzMwuAaLNvFtNycQdukavt92BskFvxIjRn6LzPT8Ay6lMoBvSLFy9m4sSJdOrUKeg9La1bt652Z2y1bpP/z3/+g9vt5pVXXqlWJYIZPXp0wE53794dgIEDB5KSkuJPj4uLo0WLFjXeKx0WFobJ5Psi9ng8FBYWYrfb6d27N0BAQH/22WcTERHB/Pnz/WlKKRYsWEDbtm05+eSTAd+b7Mcff2TgwIFYLBbsdrv/p2nTpqSlpbF69eoKdbn88sv9dSkXFeV79Pp3332Hx+Op0X2vKfHx8QFj/aOiorDZbP7XZrOZhISEgHVSU1OP+DolJSXguJAypIwGXUa8DeZMhOaJcFIztPdvDShD1KTa+4I/3i1rlfzdUKWm+r5TW8ZovHKWgaZR0CURZp/je/hVbb8HXxtipEcTiAwDmxkGpcH0weGh8z4/AcuoT7pRQw+xuehLS0tJSkqqdPmhJ2BVVa156Dt06MDQoUP5+uuvGTNmDO3atat2hcqlpaUFvI6OjgagadOmFfLabDaysrJqrOxyc+fO5ZNPPuGff/5B1wMv/x3a+BEREQwdOpQvvviC/Px84uLi+OWXX9izZw+33367P19GRga6rjN//vyA4P9QzZo1q5CWnp5eIe2SSy5h+fLlTJkyhRkzZtCtWzdOPfVUhg4dSlxcXFV3WQhR0y4d4PsJwhBjRS89ZJidQQMU1MNog5oPQo+yxeoUErDpmt22f8agWogXtMN+19T2jprvQMby3vdDJz8yHdatd103A9d1q9spMTsmaKwbK4/FEccm1HrnwTeZzIoVK7j++uuDLv/888/p0aNHtcqo9jvohhtu4Ntvv2XGjBm88MILx7Xu4WPOD2UwBP9AqSz98PFI1fXuu+8yffp0+vbty6WXXkpiYiJhYWFkZ2czefLkCgH+yJEj+eyzz1i4cCFXXnkl8+fPx2w2c+6551bY9jnnnMN5550XtNxgZ8DBpgaNjY1lzpw5rF+/ntWrV7N+/Xqee+45Zs6cyfPPP0/Xrl2ruOdCiLoS//t/8G7JQd/nwPXtP2gxFry7CnF/vx0tIgzvzgIocfvzawBhRnAf+tnZkEdpi/pgNmvExRopK9NpmhpGQryJhCKN1m2s2CI09uTqdG9pwmrWSE80yrSWIqQoY+g9g2HSpEmMGzeOrl27cvHFFwOg6zrbtm3jkUceYdWqVXzyySfVKqPaAX2zZs246KKL+OCDDwJmqzlUTEwMBQUFFdL37NlT3eJrzVdffUXTpk154YUXAk4ifvrpp6D5O3XqxEknncT8+fO54IIL+O677xg0aBAxMTH+PGlpaWiahsfjoU+fPtWuo9FopFevXv6n227dupUrr7ySN954g+eff77a2xdC1C5DQgSGfr4rcJYRnYLm0R1O9J0FeDZmwbqdaB4v+vKtsDMX7CUHg3uDVi89+6J2aVrgzasmE7RsYcYWZcBiMXByp3AiwjXi44ykpJiJthnk6bKiUVMheHxfeeWV7NixgwceeID7778f8A3XVkphMBh44oknGDFiRLXKqJFrXFdffTULFiyotIc+PT2djRs3UlZW5u9tLiwsZMGCBTVRfFBZWVmUlZWRlpZWYfz5sTAafb0Wh/b8ezweZs+eXek6I0eOZMqUKTz99NM4nc4K/5zY2Fj69+/Pd999x8aNG+nSpUvAcqUUdrv9mIbM2O12YmNjA9JatmyJ1WqlsLDwqOsLIUKDIcqCoVMTTJ2awOjAK2/Kq6P/sRe1PRe2ZaPPW+cL8rfngFMHtANPi638aqhoGA4P3MPCoHNHK+nNzZjDNHqdEkFKcpg8IVac8EJxyA3A/fffz5gxY/jkk0/Ytm0buq7Tpk0bLrzwQlq3bl3t7ddIQB8bG8uYMWN49dVXgy6/5JJLePDBB5kwYQLnnnsuRUVFfP7556Smpla487qmPPTQQ6xbt44FCxYEHXd/NGeeeSYvvvgiEydO5IwzzqC4uJhvvvnmiCcHZ599Ns8//zyLFi2iWbNm/htoD3XPPfdwzTXXcO211zJs2DBOOukkdF1nz549rFixgnPPPbfSMVaHeuyxx9i/fz99+vQhNTUVp9PJkiVLKC4uZtiwYce9v0KI0KMZDRi7pkHXA/cc3X4W4HvSrNq4F31bNvovO1HvrQFHGeQV+/KZDOCR7vyGItpmoMvJ4URGGPi/U8Jp28ZKeLgE7kIEoxuN9V2F41JSUsJpp53Gtddey4QJE7j11luPvlIV1NhdKFdeeSXz5s0jJyenwrJzzjmH7OxsPv74Y6ZNm0azZs245pprMBgMAbPFNCRjxoxBKcX8+fOZOnUqCQkJDB48mOHDh/vHPx0uKiqKwYMHs2DBAs4///yg4xJTUlJ49913efvtt1m+fDmLFi3CbDaTnJzMaaedxuDBg4+pfueeey5ffPEFCxcuJD8/n8jISFq3bs1TTz3FmWeeWa19F0KENs1gQOuWhqFbGozqAU/4ps7Vd+ehL9gAewvQv/odNuwBrwT2dclghPREA83ahtO3v432bS3YokIrQBGiPoVaD31ERATbt2+v9XtVNFXTd5Oe4KZMmcJnn33GggULSE5Oru/qCCFEpZSuozZnoX+yDvXjNtS2bNzbi9AxgcmA16NRPpeKFyOgoYBifNPm6mh4jqNfyIMRdWC25C2JSXgMRhSQmX7sU3g6rWZcFjOHz/HiMpkO+aJXFZYfL0e4FU81egINxoMjnVq1D6dFeyvNW1np1icas0V634Woqhm9vgHgP2uH1nNNjt3ll19OWVkZn376aa2VIfNE1SCHw8GiRYs49dRTJZgXQjR4msGA1rkphs4HhyWaMnLxrt6Jd81O9HfWo3JKZCKd42SNMND/rFjad4mkZftwwiOkB16ImqKH4Cw3Dz74IBdffDFjxozh+uuvp1WrVoSHh1fIV53nk0hAXwO2bdvGX3/9xcKFCykpKWH8+PH1XSUhhKgSQ8sEDC0TCBvdA+vUC1BFZXhW7aRsxk949zjwbMgCrzpws21917ZhiIoxEBMXxr/OT6BDt0hsMfLVKkRtCbUhNwCdO3cGYNOmTbz//vuV5jvSdO5HI586NeDbb7/ltddeo0mTJtx9990yB7wQotHQbFbChrQnbEh7AFSpm4hPN+PaVkDJN9vx/LzvhOnB1wygdDCaNDp0iyQ+0cSpZ8XRtIVF5nIXoo7olTyPqCF76KGHZAy9EEKIhku5vTjX78fxxTYcc//Cu78EPd/pWxhmAPfBbvxQHUOvaZDczEyv02JIbxtO207hmA5/xKoQok5M7b8MgNtXnlHPNWlYpIdeCCFElWlhRqy9U7H2TiXxv6ehlMK5IZuSbzLw7CjA8fk2vJmOir34Dawr6dCbWC2RRpqkh5HUNoreZ8bRvHU4pjDpgReiIQjFITd1QQJ6IYQQNUbTNKzdmmDt1gSAJi8NRi/z4NqQTeHHf+Ha4cCVUYh5uxcPB24WVQrNoFEX14vLh82UM5k1rJFGupyeQJMWVpJbhNPspEgZQiNEAxWKN8U++uijR82jaRoPPvhglcuQITdCCCHqnNIVJbuLKdxayNZv9+OJCMOeWUrmb3ZQ4HUFueNWA6fFN+TGYDKge3xfXwajRplmQGnBv+gNRrDFheH1Ktr9XyxJ6RZMYQY69I0lJskswbsQIeSp038A4O7vT6vnmhw7wxHG/WuahlIKTdPkplghhBChRTNoRKZHEZkeReqZgU/zVkrhKvaQv7ME3aVTtK+M3L8dRCZasO9zUlCgE90snML9TnRdEd80HHuuG0u0kU3/rMXrNnLuyAEkNI0kItpIZGwYBoME7UI0BqE45EbXK3ZQ6LrOjh07eOmll1ixYgWLFi2qVhnSQy+EEKJRcLvdvPXWWwCMHz+esLCweq6REKKmPXHmTwDc9+2p9VyTmnPFFVeglDrilJZHE3oDkYQQQgghxAlJaVpI9tIfycCBA/nqq6+qtQ0ZciOEEEIIIUKC3giHz61du/aI4+yPhQT0QgghhBAiJIRi7/ycOXOCptvtdlasWMGnn37KNddcU60yJKAXQgghhBAhIRQD+quuuqrSZYmJidxzzz089NBD1SpDAnohhBBCCBESvJVMT9uQbd++vUKapmnExcVhs9lqpAwJ6IUQQgghREgIxR56TdNISkoiPDw86PLS0lKys7NJT0+vchmhd5ojhBBCCCFOSKE4y02rVq347LPPKl2+YMECWrVqVa0ypIdeCCGEEEKEhFCc5eZoj3xyu90yy40QQgghhDgx6CHSO19YWIjdbve/zs3NZefOnRXy2e12PvzwQ1JTU6tVngT0QgghhBAiJOjV7MmuK9OmTePRRx8FfGPoJ02axKRJk4LmVUrx2GOPVas8CeiFEEIIIURICJUe+iFDhhAVFYVSirvuuovLLruMU045JSCPpmlERkbSs2dPevXqVa3yJKAXQgghhBAhQYVGPE+/fv3o168fAMXFxYwaNYqTTz651sqTgF4IIUTI85S4Kc4oJGyHhilPY1fhn0Q0i8Rd6Ma5sxhbt3g0iwGvw030/yViSY3AZAur72oLIY5TKM5D//DDD9d6GRLQCyGECAnKq5O/JoeSbUWU7igmZ8leynYV4y324M53AZCCFYNX8Y++7ojb0tCJMrgI7xhLRPcEcOskjD0JW/8UTLGWutgdIUQVhNqUlYdauXIl69ato6CgAF3XA5ZpmsaDDz5Y5W1r6mhz6QghhBB1TClFyT8O7Kuz2TPnb8r2llC63YHu9H0JaiYN5Qn+9WXwKgy64khf+0a8ROI6sAJwyHerFmEi9rx04ke2JvqMpoQlR9TMTgkhqm3ixZsBeGFux3quybHLy8tj2LBhrFmzBqUUmqb5p7Is/1vTNLxeb5XLkB56IYQQ9U7pipylmTg22cn/aT/7F+5GuSvvb6osmK+SwI4yVImH/Ln/kP/xPwCYW9pIvLIdMUObE9kvGYMx9C75C9FYeENwHvo777yTDRs28P7779OnTx9at27NN998Q6tWrZg2bRqrVq1i0aJF1SpDeuiFEELUOaUUxX8Vsv35zTgzS8j7YT/eIjdogEEDb9W/mo67h/5YGH11MkSaSLi8HTHD0ok5Kw1jpIzDF6Iu3TD6LwBe+eikeq7JsUtNTeWyyy7jueeeIzc3l6SkJJYsWcKZZ54JwIUXXojFYuGDDz6ochnSQy+EEKJOuHKdZH+zh+3TNuHMLMW1v8y3QAPK43dFtYL5WnOgTnqxh+y3/iT7tc1oYQbiLmpN3PCWxAxNwxRnredKCtH4hWIPvd1up3PnzgBERUUB4HA4/MuHDBnCfffdV60yJKAXQghRK3SvYu9fDrYt24/jmd8wZhYfDNwP1QDj9yM6MNxHuXXy5v5N3gfbwKgROyzdH9yb02z1XEkhGqdQmYf+UE2bNiUrKwsAi8VCkyZN+O2337jgggsA2LNnD1o190sCeiGEEDWmqMDDn+sd/LY8j30/7QevIsJRRoe9xfVdtdpRPpbfq7Av3Iljwd/sRRHRPxXbOS2IGtSMyP6p1f6yFkL4hOIsNwMHDmTJkiXcf//9AIwePZqnn34ao9GIrutMnz6doUOHVqsMCeiFEEJUmcers31LKdt+K+aXH+zkZLkBMHvcxJQPnQm1HviqOmSoUMlPmZSszGQfYEqNIOqMNKyd44m/urPMmiNENXhDMKC/7bbbWLJkCU6nE4vFwuTJk/njjz/801QOHDiQGTNmVKsMuSlWCCHEcfkn18vCTW5+yvCy9Wc7A7LsGAxw6LTKZrebmJJSACKKyuiwfned1a9Wboo9RiY8GIOdwRxyn0BYWiSmZlEkXNOZiN7JWDvFo5lk5hwhjsXYMb7Zp+a807qea1J9drsdo9GIzVb9IXr10kN/3XXXkZmZyRdffHHUvGvXrmXChAk8/PDDnH/++UfNf/7555OamsqsWbNqoqq15nj3Swgh6kuJS/HJRjff/e1lzS4vmzK9oBQmA3Rx6r5ZH/WjbeUEd0iM795djHt3MbtX7/MlaGDtmoi1awKaUSPm4nZY28dibhktgb4Qh/GE4E2xlYmNja2xbVUroC8PSm+55RbGjBkTNE+vXr0YMGAA06dPr05RQggh6kipW7F6j+KNX9z8usvDn/t1PAHzvvv+9kgQXzMUlP2WQ9nGHNAhf/af/kWm1AjMbWNQDg9RZ6ZhbhOD8uhEnJJEWLMoTMkRGKwyelacOPQjXntruHbu3MkTTzzBsmXLyM7O5vPPP2fgwIHk5OTw6KOPMn78eHr06FHl7dfLp8BLL73EiT7S55RTTmHlypWYTPJBLISoP0op/sxRbMxWrNmr+PB3L1nFB4aDl7ob5hSSjVWQEyRPZgmezBIASn/LDppHsxgxNQlH9+hYWkZj7RiPt9iFOc2G9eQENLMBY1I41naxGJPCZe58EdJC8abYTZs2cdppp6HrOn369GHbtm14PB4AEhMT+fHHHykuLuaNN96ochn1Ek2GhcmHicFgwGKx1Hc1hBAnELdX8Vce/J6t+OB3L/mlij+yFXkHpoMPM4Bbet0brkr+N8rpxb3LN6d1SWYJJf/bd3D2nWCMGqaUCAzhJrQwg28WnggTeBVRg5phSo7AclKc3LwrGqRQHHJz1113ERsby88//4ymaTRp0iRg+bBhw/joo4+qVUaDGkP//fffM2vWLDIyMoiLi+O8886r9PJDVlYW06dPZ9WqVYCvx/v222+vtMzVq1czZ84c/vjjD1wuF+np6Vx00UVcdNFFAfnKx+Dfd999TJs2jfXr16NpGn369OGuu+4iMTHxqPv3999/M2vWLDZs2IDdbic6OpqWLVsyZswYBgwYAAQfQ3/++eeTmZkZdJunnHJKwH0BmzZt4s0332T9+vWUlJSQmprKsGHDGDdunPT6i0bBqyse+FFn5V7F4BYGHuir1cnUf59v1Xl+nSI1EqafYaBJZOh9eQSjlKLFyx4yy59l4q0YHTbUYF6B/yL7oX8fOWft1qMh8tfvSME8gFfh2XNwGlHnn/mgfGvnvrQRAEOMmS7262urqkJUWSgOuVmxYgUPPfQQSUlJ5ObmVlienp7Onj17qlVGjUR+ZWVl2O32am1j2bJl3HXXXTRt2pRrrrkGo9HIF198wY8//lghb1FREddddx379u3jwgsvpHXr1qxbt47rr78ep9NZIf+nn37Kk08+SZcuXfj3v/9NeHg4q1evZsqUKezZs4dbbrklIH92djbXX389p59+OhMnTmTr1q18+umnFBcX89JLLx1xP+x2OzfccAMAo0aNIiUlBbvdzubNm/n999/9AX0wt99+OyUlJQFpv//+Ox9//DEJCQn+tB9//JE777yT5s2bc+WVVxIdHc3GjRuZOXMmW7Zs4amnnjpiHYUIBTPWK6as8QUmP+zWSbcZGHdy7X6Q/21XXPKF7g9sHW6dBSONtVpmXcp0HD1PSKsk4m7ogXhN0Y7j1OcgBUrj4DQ8vnX0IndtVFGIavOG4JtZ13UiIiq/4pWdnV3tURs1EtDPnDmTmTNnVnl9r9fLs88+S3R0NG+//bb/rt9Ro0Zx6aWXVsg/Z84c9u7dy0MPPcTw4cMBuPjii5k6dSoffPBBQN6cnByeffZZhgwZwuOPP+5Pv/jii3n22Wd57733GDVqFGlpaf5lu3bt4sknn2Tw4MH+NIPBwNy5c8nIyKBly5aV7stvv/1GXl5ehfWPxemnnx7weu/evUyfPp20tDTuvvtuAJxOJ//97385+eSTeeWVV/y98aNGjaJdu3ZMmzaNtWvX0qtXr+Mquzbk5eURGRnpP0gdDgdKKf/0TC6Xi6KiooCTlczMTFJTUyt9nZWVRXJysr+nVspovGX8bQ/sZSx/XZv7sbNQBfRSl5fZ0NvqWMs4NidK+CuOVUM4dqWMhlVGfQrFITennHIKCxcu5MYbb6ywzOPx8OGHH9K3b99qlVEjAf3IkSM566yzgi676aabjrr+5s2b2bdvH2PGjAmYwicqKopRo0ZV6BX//vvvSUhIYNiwYQHp48aNqxDQL126FJfLxQUXXFDhKsJpp53Ghx9+yJo1awIC+qSkpArBeK9evZg7dy67du06YkAfFRUFwE8//US/fv38r4+Xw+Fg0qRJuN1upk+f7m+X1atXk5uby0033YTDEdjd1r9/f6ZNm8bq1asbREAfHx8f8PrwtjCbzQEfMEDAB0qw1ykpKVLGCVLGFR0NvLHRS6kHbGa4+CRDre9Hn1Tokggbc3zp/z7ZUONllKuP/8exCb0vSxHMsf4fj56vIRy7UkbDKqM+heKQm3vvvZfzzjuPG264wd9RvW/fPpYuXcoTTzzB5s2befHFF6tVRo0E9Onp6fTp06fK65ePG2rRokWFZa1atQqav1OnThiNgZfCExMTK0zOn5GRARD0rKhcXl5ewOtmzZpVyBMTEwNAQUFBpdsB6NmzJ8OGDeOLL75g0aJFdOrUiT59+jB48GBatz62hyB4PB7uvvtudu7cyYwZMwJOILZv3w7Ao48+Wun6wcZnCRFq+jbV+G2ckfX7FL1TNVrG1P6HeESYxsrLjXyzXZEapdG/Weh9cTRGWiV/V8wYfGlN/Rcb/tFQ3Ro2/D0Uwh2CPfTnnHMOs2fP5pZbbvHfD3nllVeilCI6Opo5c+YwcODAapXR6O+eLJ8e85FHHqn0htbDA3iDofIHeRzLdJuPPPIIY8aM4aeffmL9+vW8++67vPnmm9x2222MHj36qOs/9dRTrF69mgceeID/+7//C1r+LbfcQvv27YOun5SUdNQyhAgF7eI02sXV7Ye3zaxx0Umh94VxNJqm8chpBhb/o7MhG4p8D3HFpB39HkrRCBm1oFOSGuMsmJqEE3FqapCVhKh/3hA98RwzZgwXXnghixcvZtu2bei6Tps2bRg6dGjoPin2cOUB9Y4dOyosK++RPjz/rl278Hq9Ab30OTk5FBUVBeRt3rw54HsaV3WuIhyvtm3b0rZtW8aOHUtRURHjxo3jxRdf5JJLLjniTB1z5szhs88+Y+zYsYwYMaLC8vT0dADCw8PrdH+EEKHvoQFGHhpgRCnF33mKP3MV6/cp3vvdS2YRFLp8+cpvjxQhQsN3dUKv+F/TrEYwGzBFm7F2TQQFhggTEf1SMEaFoVmMhPdIwpQcgTHBiiGs8dwELhqnULkp9r777uPSSy+la9eu/rTIyEhGjhxZK+U1iIC+Y8eOJCcns2DBAsaNG+cfL+5wOPjkk08q5B80aBCzZ89m4cKF/ptiAd5+++0KeQcPHszLL7/MzJkz6dmzJ1arNWC5w+HAbDZjNptrZF8KCgqw2WwBvfw2m81/EuJ0OivUodyyZcuYMWMGZ5xxBv/5z3+C5unXrx/x8fHMnj2bwYMH+4cClSsrK8Pr9RIZGVkj+yOEaHw0TaNtgkbbBDivPTx4mgmlFDsK4N3fvWzOVqzNVGzZ6wvtTQZ5Kmy9OfzsSgMtzIC5VTTmtrF488uwdk3E2j4W3enF0i4Wc6toX097cgTGCHnui2hc3EcYRdGQTJkyhZNPPtkf0Ofm5tKkSROWLFnCv/71rxovr0EE9EajkVtvvZV7772XcePGMWLECIxGIwsWLCAmJoasrKyA/GPHjuXrr7/m8ccfZ/PmzbRp04ZffvmFDRs2BNxUC5CcnMw999zDY489xsUXX8y5555Lamoq+fn5bNu2je+//565c+fStGnTGtmXhQsX8v7773PGGWeQlpaGyWRi3bp1rFq1isGDB1cazNvtdh588EGsViv9+vVj0aJFAcvj4+Pp27cv4eHhPPLII9xxxx2MGjWK4cOH07x5c4qKisjIyGDZsmU888wzDeKmWCFE6NA0jZax8MCAg18LGfkmfsrw8kOGl49+c5NfIv32dcHUNBJLxzhUqZfoC1phaRuDwRZGeJdETEnhaMbQCGiEqA2e+q5ANRzLsO2qahABPcBZZ52FwWDg9ddfZ9asWcTHx/sfLHXzzTcH5I2Ojub111/nueee46uvvgJ8UwLNnDnTPwf8oYYPH056ejrvvvsun376KUVFRcTGxtKiRQtuuOGGCnd/V0fPnj3566+/+OGHH8jJycFoNNK0aVMmTZrEJZdcUul6JSUllJX5Htf4xBNPVFh+yimn+Kc06tevH2+//TZvv/02ixYtIj8/n+joaNLS0rjiiito165dje2PEOLE1TLOQMs4A5f3COOVkVZ25Oss2eLhjTUuftnlwe315QuRK+ANwyFj1zWrEWvneAzRZuLHdcTaJQFLxziM4dKrLkRlvHXwgMFQpKnaPF0QQgjRKHm8itU7vSz80YFzRTbePFfAcrPbTUyJ787biKIyOqzfXWd1M3gVBl0d8UTDiJdIXEfIUTUmPBgPvwPB4BvfrpkNRJ/fiogBqVg7J2A7Iw3NJL3tQhyPjjdnA7D5xYY9AYjBYODdd9/l8ssvB3xDbpKSkli6dGnjHXIjhBAitJiMGv1bmejfKhbGxFJk9/DLDwX8b3k+OZludLf0omGAsOY2Em/sgm1oOtauiUecFEEIcXSh9NGSkZHBunXrgIPTnm/durXC8PByp5xySpXLkh56IYQQNcrrVfz9u4N187Mo2lVC0cZ8Oq7bVelUiTWtPnvojVaNqK5xJN/RA9vQFhija2bCBSGET9OJvif/7X0h+FTkDYXBYKhwAq+UCnpSX57u9XqrXJ700AshhKhRRqNG+2422nfzza1clONk++tJeH/PJXvRHrxFHjAAjWTmHC3KhO3UFFLv6o5tYKpM/ShELSoJkatcb731Vp2WJz30Qggh6ozSFTnfZlK4Ppfsb/aS/8N+ADSThqqhJ1zVRQ+9ISaMmLPSSLm9G1F9ktFC8OmVQoQiy6RcAJzTa25Ck8ZAAnohhBD1xlvqIX9VNnnfZ7Hz9a24813VHpZTWwG9KSWcuOEtSb7pZMK7xMt4eCHqgXZrHgBqWnw916RhkYBeCCFEg+Et8WD/Xw47Xv0LV2YphRvy8Tp8M09rYRrKffSvrGoF9IcMBTLGmjG3sJFweVsSx7THnCoP7BOivmm35QOgnour55o0LDKGXgghRINhjDCRMCiFhEEpgG+ITv7qbEq2FOLYVEDW5ztw7SvDW3Lw5rEqDdfRNA6fXTKsWSS201MxxVpIHNeeyJ5NZCiNECIkSA+9EEKIkOPKdZK3cj+l24vwOjy+oD/Dgb3YjikXrKUGDBYjusuLcuuYYsxoJg1viZfo3glYUsLRcopJvrQV4Z3jsZwUQ1hs8Cd5CyEaDu0OOwDq2dh6rUdDIz30QgghQo45wULK8OYBaW632z+zxPjx4wkLkyeuCtH4yFWzYCSgF0IIIYQQoUEerhyUBPRCCCGEECJESA99MBLQCyGEEEKI0CDxfFAS0AshhBBCiNAgz38ISgJ6IYQQQggRGiSeD0oCeiGEEEIIESIkog9GAnohhBBCCBEa5GFvQcnkP0IIIYQQQoQw6aEXQgghhBChQW6KDUoCeiGEEEIIERokng9KAnohhBBCCBEaJKAPSgJ6IYQQQggRGmTITVByU6wQQgghhBAhTHrohRBCCCFEaJBpK4OSHnohhBBCCCFCmPTQCyGEEEKI0CAd9EFJQC+EEEIIIUKD3BQblAy5EUIIIYQQIoRJD70QQgghhAgN0kEflAT0QgghhBAiNMiQm6AkoBdCCCGEEKFB4vmgJKAXQgghhBChQQL6oCSgF0IIIYQQIUIi+mAkoBdCCCGEEKFB4vmgZNpKIYQQQggRGjSOGNRPnjyZqKioOqtOQyEBvRBCCCGEECFMhtwIIYQQQojQIENugpIeeiGEEEIIERo0rVpz0W/cuJGhQ4cSGRlJTEwMF110ETt37vQvv/rqqznttNP8r3NycjAYDPzf//2fP83hcBAWFsbcuXOrXI+aJj30olYopSgqKqrvagghTiBut5vS0lIACgsLCQsLq+caCdE42Ww2tPp6wFM1it21axcDBw6kTZs2vPvuu5SVlXH//fczaNAgNmzYgM1mY+DAgbz33nuUlZVhtVpZsWIFFouF9evXU1RUhM1m46effsLj8TBw4MCa269qkoBe1Irc3FySkpLquxpCiBPUpEmT6rsKQjRaBQUFREdH10vZ6o6qh67Tpk3D7XazePFi4uPjAejRowedOnVi9uzZ/Oc//2HgwIE4nU5Wr17NoEGDWLFiBSNHjmTx4sWsXLmSs88+mxUrVtC+fXuSk5NrareqTQJ6USssFgvdu3dn4cKFJ+Td5kfjcDgYNmyYtE8lpH0qJ21zZNI+lZO2OTJpnyM7tH1sNlt9V6dKfvjhB/71r3/5g3mADh060K1bN3788Uf+85//0KpVK9LS0lixYoU/oJ8wYQKlpaUsX77cH9A3pN55kIBe1BJN0zAajURHR8sHYxAGg0Ha5wikfSonbXNk0j6Vk7Y5MmmfIzu0feptuE015efn07179wrpycnJ5OXl+V+XB/KFhYX89ttvDBw4kOLiYubNm4fT6WTNmjVce+21dVjzo5ObYoUQQgghRKMXHx/P/v37K6Tv27cvoNd+4MCBrFq1iu+//57ExEQ6dOjAwIED+d///seyZctwOp0BN842BBLQCyGEEEKIRm/AgAF8++235Ofn+9P++usvNmzYwIABA/xp5T3yzz33nH9oTffu3QkPD2fKlCk0b96cli1b1nX1j0iG3IhaYTabufbaazGbzfVdlQZJ2ufIpH0qJ21zZNI+lZO2OTJpnyMLpfbxer3MmzevQvott9zCW2+9xZAhQ7j//vspKyvjgQceID09nauuusqfr0OHDjRp0oTly5fzwgsvAGA0Gunfvz+LFi3iiiuuqKtdOWaaUkrVdyWEEEIIIYSorsmTJ/PII48EXfbOO+/QtWtX7rjjDlauXInRaGTw4ME899xztGjRIiDvxRdfzLx58/j111/p1q0bAE899RT33HMPM2fO5Lrrrqv1fTkeEtALIYQQQggRwmQMvRBCCCGEECFMAnohhBBCCCFCmNwUK2rUihUreOWVV9ixYwcpKSlcddVVDB8+/Li2cfvtt7N8+XJuueUWxowZU0s1rXtVaZvdu3fz7LPPsmXLFux2O9HR0XTr1o0bb7yxwni/UFeV9vnjjz+YN28e69evJzs7myZNmnDmmWdy9dVXEx4eXkc1r31VaRu3283LL7/M77//zubNmykrK2Pp0qXExsbWTaVrQUZGBk8//TQbNmwgMjKSc889lxtvvJGwsLAjrqeU4u2332bu3LnY7Xbat2/PbbfdRpcuXeqo5rWvqm0zd+5cVq5cye+//47dbmfKlCmcddZZdVTrulOV9snJyeG9995j9erV7N69m6ioKHr06MHNN99MampqHda+dlX12HnwwQf5/fffyc7OJiwsjLZt23L11VfTt2/fOqq5OJT00Isa8+uvv3LnnXfSpUsXXnjhBQYPHsx///tfli5deszbKP9iaWyq2jalpaUkJCRw00038cILLzBp0iR27NjBhAkTsNvtdVP5OlDV9lmyZAm7du1i7NixPP/881x22WV89tln3HrrrXVU89pX1bYpKyvj888/x2w206NHjzqqbe0pLCxkwoQJeDwennnmGW688UY+++wznnvuuaOu+/bbbzNz5kwuv/xypk2bRmJiIjfffDO7d++ug5rXvuq0zcKFC7Hb7fTv378Oalo/qto+mzdvZtmyZZx11llMnTqVW2+9lW3btjFu3LiAaQ9DWXWOHbfbzRVXXMHUqVN59NFHiYmJ4ZZbbmH9+vV1UHNRgRKihtx0001q/PjxAWn33Xefuuiii45pfafTqUaMGKHmz5+vevbsqebMmVMb1awX1W2bQ+3YsUP17NlTLVq0qKaqV++q2j55eXkV0hYtWqR69uypNm3aVKN1rC/VOXZ0XVdKKbVgwQLVs2dPlZ+fXxtVrBNvvvmmGjBggLLb7f60Tz75RPXu3Vvt37+/0vXKysrUwIED1YsvvuhPc7lc6rzzzlNPPvlkrda5rlS1bZRSyuv1KqWU2rNnj+rZs6dasmRJrda1PlS1fQoLC5Xb7Q5Iy8rKUr169VLvvPNOrdW3LlXn2Dmcx+NR5557rnrsscdqupriGEgPvagRLpeLtWvXVrhUO2TIELZv387evXuPuo133nkHm83G+eefX1vVrBc10TaHiomJAXy9I41BddonLi6uQtpJJ50EQHZ2ds1WtB5U99gJ1cezB/PTTz/Ru3dv//EPMHjwYHRd5+eff650vQ0bNlBcXBzQhmFhYZxxxhmsXLmyVutcV6raNgAGQ+MPA6raPjabDZMpcGRycnIycXFxjeLzBap37BzOaDRis9kazXdTqGn872RRJ3bv3o3H46nw5LRWrVoBvjF6R5KVlcXs2bO58847G1UQAtVvGwBd1/F4POzdu5enn36a5ORkzjjjjFqobd2rifY51K+//grQ4J7iVxU13TahLCMjo0I72Gw2EhMTj9gO5cuCtWFWVhZlZWU1W9F6UNW2OVHUZPvs2LGDvLw8/3sw1FW3bZRSeDwe7HY777zzDrt27eLCCy+sncqKI5KbYkWNKCwsBHwfBIeKjo4OWF6ZqVOncsYZZzSqm9TKVbdtAB5++GEWLVoEQFpaGi+//DJRUVE1XNP6URPtU85utzNr1iwGDRpEenp6zVWyntRk24S6wsLCCu0AvrY5UjsUFhZiNpuxWCwV1lNKUVRUhNVqrfH61qWqts2JoqbaRynFs88+S1JSEkOHDq3JKtab6rbN/PnzeeyxxwCIiIjgiSeeoGvXrjVeT3F0EtCLSjkcDnJyco6ar1mzZtUq5+eff2b16tV88skn1dpOXaqrtik3YcIELr30UrKysvjggw+48cYbeeONN0hJSamR7de0um4fAI/Hw3333QfAvffeW2PbrWn10TZCiOqbNWsWa9asYcaMGY1qFq3qOP3002nfvj12u52lS5dy77338swzzzTqm6wbKgnoRaWWLl3qP/M+knnz5vl7DB0OR8Cy8jP88uXBPPPMM4wePRqr1UpRUZE/3el0UlRUFLT3oL7VVduUa9asGc2aNaNz587079+fkSNH8vbbb3P33XdXofa1r67bRynFI488wh9//MFrr71GYmJiFWpdN+q6bRqL6OjoCu0AUFRUdMR2iI6OxuVy4XQ6A3rpi4qK0DStQX6+HK+qts2Joiba57PPPuO1117jwQcfpHfv3jVdxXpT3baJjY31T4V76qmnUlhYyPPPPy8BfT2QgF5UasSIEYwYMeKY8rpcLkwmExkZGfTr18+fXtn41UPt2LGDt956i7feeisg/dVXX+XVV19l5cqVFS6X17e6aptgrFYrrVq1atBT7tV1+0yfPp2lS5fy/PPP0759+yrUuO7U57ETylq2bFlhTG/51Y4jtUP5sh07dgQcGxkZGaSkpIT8cBuoetucKKrbPsuWLWPKlClMmDCBCy64oHYqWU9q+tjp0KEDP/30U81UThwXuSlW1Aiz2UyvXr349ttvA9KXLFlCq1ataNq0aaXrlgfuh/4AjBo1ildfffWoD7do6KrTNsE4HA62bt3aaIZkVLd9Zs+ezfvvv8/DDz/cqHrOoOaPnVB26qmnsmbNmoCreEuXLsVgMBzxQTZdu3YlMjIyYN5+j8fDsmXLGk0vYlXb5kRRnfZZu3Yt999/PyNGjOCaa66p7arWuZo+dn777bdG890UaqSHXtSYa665huuvv97/pMFffvmFr7/+mieffDIgX58+fRg2bBgPPfQQAL169Qq6vbS0tEqXhZqqts3MmTNxOBx069aNuLg4MjMz+fDDD3G5XFx22WX1sSu1oqrt8/XXX/Piiy9yzjnn0KxZMzZu3OjPm5aWFnRay1BT1bYB34PaSktL2bRpE+B74mxERAStW7emdevWdbof1TVq1Cg++ugjbr/9dv7973+zf/9+nn/+eS688EKSkpL8+W644QYyMzP5/PPPAbBYLIwfP55Zs2YRFxdH27ZtmTt3LgUFBVx55ZX1tDc1q6ptA7Bp0yb27t3rf1Bd+YP94uLi6NmzZ13uRq2pavts376dO+64g+bNm3PuuecGfL7ExcWRlpZW17tS46raNj/++CMLFy5kwIABJCcnU1hYyNdff82qVat4/PHH62lvTmwS0Isa0717d55++mleeeUV5s+fT0pKCg888ECFObS9Xi+6rtdTLetHVdumQ4cOvPfee3z11VeUlpaSlJTEKaecwpQpUxrFl0m5qrZP+TzJixYt8s8CVO7hhx9uFM80qM77asqUKWRmZvpfP/roowBce+21XH/99bVf+RoUHR3NK6+8wjPPPMPtt99OZGQkI0aM4MYbbwzI5/V68Xq9AWnjxo1DKcW7775Lfn4+7du3Z8aMGY3mPVSdtvn444/58ssv/a/fffddAE455RRmzZpV+5WvA1Vtn99//x2Hw4HD4eDqq68OyHveeecxefLkuqh+rapq26SlpeFyuXjxxRex2+3ExsbSrl07Zs6c2WhOBEONppRS9V0JIYQQQgghRNXIGHohhBBCCCFCmAT0QgghhBBChDAJ6IUQQgghhAhhEtALIYQQQggRwiSgF0IIIYQQIoRJQC+EEEIIIUQIk4BeCCGEEEKIECYBvRBCCCGEECFMAnohRKNz1VVXoWlafVcD8D1t0mQysWTJEn/a999/j6ZpzJ49u/4qJhqE2bNno2ka33//fZXWl2MpuF9//RWDwcDy5cvruypC1AkJ6IUIEf/88w/XXXcdHTp0ICIigri4ODp27Mi4ceNYtmxZQN6WLVty8sknV7qt8oA3Jycn6PLNmzejaRqapvHDDz9Uup3yPOU/VquVdu3acdttt5GXl1e1HW1kbrvtNvr378/gwYPruyp1IiMjg8mTJ/Prr7/Wd1VEHbHb7UyePLnKJyVVdaRjrXv37owYMYLbb78dpVSd1kuI+mCq7woIIY5u7dq1DBo0iLCwMMaOHUvnzp0pLS1l69atLF68GJvNxhlnnFFj5b3xxhvYbDbCw8N58803Oe200yrN2717d26//XYA8vLy+Oqrr5g2bRpLlizhl19+wWw211i9Qs2qVatYsmQJn3/+eUD6wIEDKS0tJSwsrH4qVosyMjJ45JFHaNmyJd27d6/v6og6YLfbeeSRRwA4/fTT66zcox1rkyZNYtCgQXz11VcMGzaszuolRH2QgF6IEPDII49QUlLCr7/+Srdu3Sosz8rKqrGy3G4377zzDhdffDExMTHMmjWLF154AZvNFjR/s2bNuPLKK/2vJ06cyPnnn8+XX37J/Pnzufjii2usbqHm5ZdfJjExkXPPPTcg3WAwYLVa66lWQpwYTjvtNFq2bMmrr74qAb1o9GTIjRAhYOvWrSQkJAQN5gFSUlJqrKwvvviC/fv3M27cOK666iqKi4v56KOPjmsbQ4cOBWDbtm2V5nnllVfQNI0FCxZUWKbrOmlpaQG9bosXL2b06NG0bt2a8PBwYmNjGTJkyDGPkT399NNp2bJlhfSMjAw0TWPy5MkB6UopXnnlFXr27ElERARRUVGcccYZFYY3Vcbj8fD5559z1llnVeiJDzbu+dC0l19+mZNOOgmr1UqXLl348ssvAdi4cSNnn3020dHRJCQkMHHiRNxud9D9/Oeff7jggguIiYkhOjqakSNH8s8//wTk1XWdxx9/nIEDB5KSkoLZbCY9PZ0bbriB3NzcoPv1ySefcPrppxMbG0tERAQnnXQSEydOxOVyMXv2bP+VovHjx/uHYh1Lr21GRgZjxowhOTkZi8VCmzZtuO+++ygpKQnIN3nyZDRN46+//uK+++4jLS0Ni8VCt27d+Oqrr45aDhwct/7tt9/y6KOP0qJFC8LDw+nTpw8///wzAMuXL2fAgAFERkaSmprKf//736Db+vzzz+nfvz+RkZFERUXRv39/5s+fHzTva6+9RocOHbBYLLRt25bp06dXOhykoKCAu+++m7Zt22KxWEhKSuKyyy6r8D88Xsfazke6D0XTNK666irAd9y2atUK8HU8lP/Py99rh76/PvjgA7p27YrVaiU9PZ3Jkyfj8XgCtn2s79NjOdY0TWPo0KF8/fXXOByO42wpIUKL9NALEQLatGnDX3/9xaeffsqFF154TOt4vd5Kx8g7nc5K13vjjTdo1aoVp512Gpqm0aNHD958802uueaaY67v1q1bAUhMTKw0z6WXXsqtt97KnDlzGD58eMCyb7/9lj179viH8oDvCzwvL4+xY8eSlpbGnj17eP311znzzDNZtmzZEYcFVcWYMWP44IMPuOiiixg/fjxOp5P33nuPwYMH8+mnn1ao8+F++eUXHA4HvXv3Pq5yX3rpJfLz87nmmmuwWq288MILjBw5krlz53Lttddy2WWXMWLECBYvXsyMGTNo0qQJDzzwQMA2iouLOf300+nTpw9PPvkkW7du5eWXX+bnn39m/fr1/hNAl8vFM888w6hRo7jggguIjIzkf//7H2+88QY//vhjhSFT999/P0888QSdOnXi1ltvJTU1lb///ptPPvmERx99lIEDB3LffffxxBNPcN111/n/J8nJyUfc5x07dtC7d28KCgq48cYbadeuHd9//z1PPvkkK1eu5Ntvv8VkCvy6GjduHGFhYdxxxx24XC6mT5/OiBEj2LJlS9CAMJh77rkHr9fLLbfcgsvlYurUqQwZMoQ5c+Zw9dVXc91113HFFVfw8ccf89BDD9GqVauAq1Evv/wyN910Ex06dOChhx4CfMfpiBEjmDlzJtddd50/7/Tp07n11lvp1q0bTzzxBCUlJTz77LM0adKkQr0KCgo49dRT2blzJ//+97/p3LkzmZmZvPzyy/Tp04e1a9fSokWLY9rH6rbz0XTs2JFp06Zx6623MnLkSP/nU1RUVEC+BQsW8M8//3DTTTeRkpLCggULeOSRR9ixYwdvvfXWce/LsR5r/fr1Y+bMmfz444+cffbZx12OECFDCSEavJ9++kmFhYUpQLVr106NHz9evfzyy2rTpk1B87do0UIBR/3Jzs4OWG/Pnj3KaDSqhx9+2J82ffp0BQQtC1BDhgxR2dnZKjs7W23ZskU999xzKiwsTMXExKh9+/Ydcb8uuugiZbFYVF5eXkD6lVdeqUwmU8D6DoejwvpZWVkqISFBnXPOOQHp48aNU4d/vA0aNEi1aNGiwja2b9+ugIB9/vTTTxWgZs6cGZDX7Xarnj17qpYtWypd14+4b2+++aYC1Pz58yssW7ZsmQLUW2+9VSGtadOmym63+9N/++03BShN09Qnn3wSsJ1TTjlFpaSkVNhPQN1yyy0B6eX7dP311/vTdF1XJSUlFer3+uuvK0B99NFH/rTVq1crQJ1xxhmqtLQ0IL+u6/72CLZvR3P55ZcrQC1cuDAg/Y477lCAev311/1pDz/8sALUsGHDAv4Ha9asUYC65557jlreW2+9pQDVo0cP5XQ6/enz589XgDKZTOp///ufP93pdKqUlBTVt29ff1peXp6KjIxUbdq0UQUFBf70goIC1bp1axUVFaXy8/OVUkrl5+eriIgI1bFjR1VcXOzPu2vXLhUZGakAtWzZMn/6xIkTldVqVb/++mtAvTMyMpTNZlPjxo3zpx1Pex9POwd7D5UDAuoQ7D10+DKDwaB++eUXf7qu62rEiBEKUKtWrfKnH8/79Fj2/YcfflCAevbZZyvNI0RjIENuhAgB/fr145dffmHcuHEUFBTw1ltvceONN9KpUycGDhwY9DJ8y5YtWbJkSdCfIUOGBC1n9uzZ6LrO2LFj/WlXXHEFYWFhvPnmm0HXWbx4MUlJSSQlJdG+fXtuu+02OnXqxOLFi4P2Ph5q3LhxOJ3OgCE9DoeDzz77jLPPPjtg/cjIyIA8ubm5GI1G+vTpw+rVq49YzvF69913sdlsjBgxgpycHP+P3W7n/PPPJyMjw38VojLZ2dkAxMfHH1fZV111FTExMf7XXbt2JTo6mqZNm1a4OjNgwACysrKCDie45557Al6PHDmSk046KeAGXU3TCA8PB3xXdOx2Ozk5OfzrX/8CCGjX9957D4Ann3yywvj/8uEOVaHrOgsWLKBHjx4V7jW49957MRgMfPbZZxXWu+WWWwLK/L//+z+ioqKO+n851A033BBwBaK8l7dPnz706tXLn242m+ndu3fAtpcsWUJxcTETJ04kOjranx4dHc3EiRNxOBwsXboU8L1HSkpKuOmmm4iIiPDnTUtL44orrgiok1KK9957j4EDB9KsWbOA4y8yMpK+ffuyePHiY97HclVt55oyePBgTjnlFP9rTdO46667AGq13ISEBAD2799fa2UI0RDIkBshQkSXLl38Y6537NjB8uXLef311/nhhx+44IILKgyPiIyM5Kyzzgq6rXfffbdCmlKKN998k65du6LresD49/79+/POO+/w5JNPVrgk36dPHx577DEALBYLLVq0ID09/Zj2qTxonzNnDhMmTAB8Y7SLi4sDTioA/v77b+6//36++eYb7HZ7wLKannN+8+bNFBUVHXGoyL59+2jfvn2ly8vrpI5zyrzWrVtXSIuLi6N58+ZB0wFyc3MDhjjExsYGva+iY8eOfP755xQXF/tPkD7++GOmTp3K+vXrK4zHz8/P9/+9detWNE2r9D6OqsrOzsbhcNC5c+cKy+Lj40lNTQ16whqsnRISEiod+x/M4dsob8/yMeGHLzt029u3bwcIWu/ytPJ6l//u0KFDhbydOnUKeJ2dnU1ubq7/RDkYg+H4++Kq2s41pWPHjhXSyve9Nsstf/81lOdSCFFbJKAXIgS1aNGCsWPHMmbMGE477TRWrlzJmjVrGDBgQJW3uXz5cv7++28A2rVrFzTPl19+yYgRIwLSEhMTKz1xOBqTycTll1/O9OnT2bZtG23btmXOnDnExcUFjFF3OBwMHDiQ4uJiJk2aRJcuXbDZbBgMBp588km+++67o5ZV2Rf64TflgS8ISEpK4v333690e0ea5x/wB2PHOx+/0Wg8rnQ4/pOGcp9++imjR4+md+/ePP/88zRv3hyr1YrX6+Xss89G1/WA/NXpia9plbXH8bRFVdq6tpXX/6yzzuLuu++ut3ocz/ulIZdb/v6r7ORIiMZCAnohQpimafTp04eVK1eyZ8+eam3rzTffxGKxMGfOnKA9gNdffz1vvPFGhYC+usaNG8f06dOZM2cO1157Ld9//z3XXXcdFovFn+fbb79l7969vPnmm4wfPz5g/cNvCK1MfHw8v/zyS4X0YL2D7dq1Y8uWLfTt27fCzX3HqjzgP54hIDXFbreTlZVVoZd+8+bNNGnSxN87/84772C1Wlm2bFnAUJA///yzwjbbt2/PokWL+O233454o+/xBvxJSUnYbDb++OOPCsvy8/PJzMxskPPZl/fu//HHH5x55pkByzZt2hSQp/z3n3/+WWnecklJScTGxlJYWFjlE+Vgjredy4eK5eXlBQwbC/Z+OZb/+ebNmyukHd5O5eUe6/v0WMotv9J4tBNwIUKdjKEXIgQsWbIkaA9VaWmpfzzt4Zfuj0dBQQHz5s1jyJAhXHLJJVx00UUVfoYPH86iRYvIzMyscjnBdO/ena5du/Luu+/yzjvvoOs648aNC8hT3mN6eO/r4sWLj3n8fPv27SkqKmLNmjX+NF3XmTZtWoW8Y8eORdd17r333qDb2rdv31HL69GjB9HR0f5pEOvalClTAl5/9tln/PXXXwEnZEajEU3TAnrilVL+IVSHuvzyywG47777cLlcFZaX/2/KT4CO9cqEwWDg/PPPZ/369Xz99dcV9kHXdUaOHHlM26pLgwcPJjIykhkzZlBUVORPLyoqYsaMGURFRfmfDjx48GDCw8N56aWXAqaH3L17d4WrQAaDgSuuuII1a9Ywb968oGVXZTz48bZz+XCy8vsAyk2dOrXCto/lf75kyRLWrVvnf62U4umnnwYIOCaP5316LOX+/PPPmEwm+vfvX2keIRoD6aEXIgTceuut5ObmMnz4cLp06UJERAS7du3i/fffZ8uWLYwdO5YuXbpUefsffPABpaWljBo1qtI8o0aNYvbs2bz99tsVbrisrnHjxnH77bfz1FNP0b59e/r27RuwfMCAAaSkpHD77beTkZFBWloav/76K++88w5dunRh48aNRy3juuuuY+rUqYwcOZJbbrkFs9nMvHnzgp4olU9V+eKLL7Ju3TrOO+88EhMT2b17N6tWrWLbtm1HHfdrNBq58MIL+fzzz3E6nQFXHGpbYmIin376KXv37uX000/3T1uZnJwcMN/+RRddxCeffMK//vUvxo4di9vt5vPPP68wJzlA7969ufvuu3nqqac45ZRTGD16NCkpKWzfvp158+axZs0aYmNj6dSpEzabjZdffpmIiAhiY2Np0qSJ/0bbYJ544gmWLFnCiBEjuPHGG2nbti0rVqzgo48+YuDAgRVO8BqC2NhYnn76aW666Sb69Onjn5d99uzZbNu2jZkzZ/pvbo6Li+O///0vd9xxB6eeeipjx46lpKSEV199lXbt2rF+/fqAbT/++OOsXLmSSy65hEsuuYS+fftiNpvZsWMHX331FT179gx4hsGxOp52vuyyy7jvvvu47rrr+PPPP4mPj+frr78OOhVuQkICbdu25cMPP6RNmzYkJycTGRnJ+eef78/TrVs3/vWvf3HTTTeRmprK/PnzWbp0KWPGjKFfv37+fMfzPj3asaaU4uuvv+bss8+u8pU2IUJGvcytI4Q4Lt9884268cYbVdeuXVVCQoIyGo0qPj5enX766eqNN95QXq83IH+LFi1U586dK91e+ZR05dNW9urVS5lMpgrTRx6qrKxM2Ww21b59e38aB6YPrK6srCxlMpkUoB577LGgeX777Tc1dOhQFRsbq6KiotSgQYPUihUrgk6vV9mUewsXLlTdunVTZrNZpaamqrvuukv9+eeflU65N2fOHDVgwABls9mUxWJRLVq0UCNHjlQffvjhMe1X+VSP8+bNC0g/0rSVwabga9GihRo0aFCF9PIpHLdv3+5PK5/27++//1bDhw9XNptNRUVFqeHDh6utW7dW2MasWbNUx44dlcViUSkpKeraa69Vubm5FaYmLPf++++rU089VUVFRamIiAh10kknqVtuuSVg+seFCxeqHj16KIvFooCgdT/cP//8o6688kqVlJSkwsLCVKtWrdS9994bMM1jZft8tHY6XPm0lYdOFVmusv2u7Jj69NNPVb9+/VRERISKiIhQ/fr1U5999lnQcl999VXVvn17ZTabVZs2bdS0adP805seXpfi4mL16KOPqpNPPllZrVYVFRWlOnTooK655hr1888/+/Md7zShx9rOSin1888/q1NPPVVZLBaVkJCgrr32WpWfnx+0jVavXq1OPfVUFRERoQD/1JOHTjf5/vvvqy5duiiz2azS0tLUgw8+qFwuV4Vyj+d9eqRj7fvvv1eA+vLLL4+pbYQIZZpSVbybSgghxFGdffbZFBcX88MPP9RJeaeffjoZGRlkZGTUSXlCHElGRgatWrXi4YcfrvA05to2cuRIdu3axf/+978GczO3ELVFxtALIUQtmjp1KqtWrarS3OFCiKpZv3498+fPZ+rUqRLMixOCjKEXQoha1Llz51qf6k8IEahHjx4Vpl0VojGTHnohhBBCCCFCmIyhF0IIIYQQIoRJD70QQgghhBAhTAJ6IYQQQgghQpgE9EIIIYQQQoQwCeiFEEIIIYQIYRLQCyGEEEIIEcIkoBdCCCGEECKESUAvhBBCCCFECJOAXgghhBBCiBD2/8L82XZ4NmWJAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Cora\")\n", + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Citeseer\")\n", + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Pubmed\")\n", + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Cornell\")\n", + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Texas\")\n", + "get_GCN_shap_summary_plot(result_GNN=result_GNN, dataset=\"Wisconsin\")" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvsAAAFUCAYAAAC6I/PoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACM7UlEQVR4nOzdd3gUVdvA4d9sSe8hIYEQQhGQojQBC6B+NEEp0iwgVpoN7K8N8LW9FkRUEFQUBRRpAiIKKEVRQZqAID2UQCBtk2yy2WyZ748lC8tmQ3qyyXNf10J25sycM5PszjNnTlFUVVURQgghhBBC1Diaqi6AEEIIIYQQomJIsC+EEEIIIUQNJcG+EEIIIYQQNZQE+0IIIYQQQtRQEuwLIYQQQghRQ0mwL4QQQgghRA0lwb4QQgghhBA1lAT7QgghhBBC1FAS7AshhBBCCFFDSbAvhBBCCCFqhcmTJxMUFHTZdYmJiSiKwuLFi0u0/9JuV5F0VV0AIYQQQgghqpPY2Fj++OMPmjVrVtVFKTMJ9oUQQgghhLiIr68vXbp0qepilAtpxiOEEEIIIcRFCmuOk5+fz2OPPUZERARhYWGMGTOGBQsWoCgKiYmJLtvn5eXxyCOPEB4eTmxsLE899RRWq7WSj8JBgn0hhBBCCFGrWK1Wt5fdbi9ym+eee45Zs2bx7LPPsnDhQux2O88991yhaV944QU0Gg3ffvstY8eO5d133+XTTz+tiEO5LGnGI4QQQgghao2cnBz0en2h6wIDAwtdnp6ezsyZM3nxxRd59tlnAejduzc9evTg5MmTbuk7d+7M9OnTAejZsyfr169n8eLFjB07tpyOovgk2BdCCCE8sFgsfP755wDcd999HgMEIUQVU26/8LO6tMik/v7+bNq0yW357NmzWbBgQaHb7Nmzh7y8PPr37++yfMCAAfz8889u6Xv16uXyvmXLlvzyyy9FlquiSLAvhBBCCCG8nFLslBqNho4dO7ot//777z1uc+bMGQCioqJclkdHRxeaPiwszOW9j48PeXl5xS5jeZI2+0IIIYQQwsspF73KX2xsLAApKSkuy8+dO1ch+ZUnCfaFEEIIIYSXq9hgv3Xr1vj5+bF8+XKX5d99912F5FeepBmPEEIIIYTwchUT5BeIjIxk3LhxvPbaa/j5+dG2bVsWLVrEwYMHAUfToOqq+pZMCCGEEEKIauLNN99k9OjRvPHGGwwdOhSLxeIcejM0NLSKS+eZoqqqWtWFEEIIIaojGY1HCC+hDL/ws7qw0rIdOXIkv/32G8eOHau0PEtKmvEIIYQQQggvV7HNeAA2btzI5s2b6dChA3a7ne+//5758+czderUCs+7LCTYF0IIIYQQXq7ig/2goCC+//57/ve//2EymWjUqBFTp05lwoQJFZ53WUiwL4QQQgghvFzFB/sdOnTg999/r/B8ypsE+0IIIYQQwstVfLDvrSTYF0IIIYQQXk6CfU8k2BdCCCGEEF5NvSjYl7DflYyzL4QQQgghRA0lwb4QQgghhBA1lDTjEUIIIYQQXk4a73giwb4QQgghhPBq0mbfMwn2hRBCCCGEl5MQ3xMJ9oUQQgghhJeTYN8TCfaFEEIIIYRXUyXY90iCfSGEEEII4eUk2PdEgn0hhBBCCOHV1KouQDUmwb4QQgghhPByUrPviQT7QgghhBDCq0mbfc8k2BdCCCGEEF5Ogn1PJNgXQgghhBBeTWr2PZNgXwghhBBCeDkJ9j2RYF8IIYQQQng1qdn3TFPVBRBCCCGEEEJUDKnZF0IIIWqB3Hw76bkqxnzIMkOmSSXLrLLlhI16IQoWO5gsYLKonDDYOZOt0jhCg80OVjtY7Sp7km00CNUQ4qegUUBRwGiGM9l22tXT4qsDX62Crw5OGOwkhGuIC9UQ7KsQ5AsBerDYoHmUlnB/hVA/0GikRlaUndTseybBvhBCCOGFLDaVY+l2krNVDHkqZ7NVzuWonM608/MRK1EBGtJNKmm5KgaTitlW9P60ChTE3Ra74/9fj9kckxWpjkmL7Cr8c9aGolxoIW0/P5vRrtN2xzLFkb5gH0VRgCBfx891AhRaxWioG6QhOkihToDjpuSmJjrqhSjUD9EQ4CMBnfBE/jY8kWBfCCGEqGZy8lVOZdo5aVA5abBzJM3OmkNWIgMUTmWqJGXZMZjcZw3VaUBVwabCAS4T3V/Cdn67i1k9BOyq6p63p7RFUYFss+PnbLPKsQwbOo3jZsJqc6yfsi7fmT7IB/x0EB2kcF1DHfFhGuLDFeLDNEQFKDSP1qDXStBXG0nNvmcS7AshhBCVSFVVMrPsnDlnYcMJlVy9luMZdo4b7BxJUzmYYnOrFdcAxYmlSxNwVzdFHYMx3/FKzVU5mGpxS68AscEKTSI1NK2jIdRXITpI4eamWppGaogIUFAUCQprJvm9eiLBvhBCCFGO7DaVzAwLGSkWMs7lk5FiYfs/ZrLRkmlUSc+wYrXCGR89v4YHo1WsaBRH0Hppbblzn5V6BN6hsJsCFTidrXI628YfJ2wX0vzk+C/IBxpFKNjs0Ke5jrb1tDSro+GKOloiAiRY9GZSs++ZBPtCCCFECViNFkxJuZz7KxWLTcWUkkdOUi7ZJ3JISrHxb2Q06kW1xxoNJAUEYdO4Rqf280kKaz4jyq6wmwFjPuxJdpzs/SkWVNXiXBegh1A/6NVMT/MojeNVx/GEwFcngaTwXhLsCyGEEOeZjRbyzuWRc8ZETrKJ7NNGfFYGEnBCZeOnP2I+Y8JqtAKQFaxH1SgoOsXRgdWmkh0ZilrHNTC0S7V8taRecoOVa3G85u+0OPs9FIgKVGhfX0PLaO35GwGFhDAtDSOkWVB1ITX7nkmwL4QQosaz5tnISTWTk2omN9VMysFsspJy0eg0GM/mkZ1sIifFjM/ZLJSLgjxFq+Br1OFjspFzNttln+r52EK1XhI1qqpjTErhlQp7IpCSo/LTQRu/HLa5NLcK8oEr6mhoXVdDi2gtIX7QpYGWVjFa/PXyN1C55Hx7IsG+qDDbtm1j7NixTJo0idtuu62qiyPKiV1VSTOpGPMVDGYwmFUMZjhjVNl1DuJDFIwWx1jeRgv8naKi10CADkxWxyvbDMm5EO53YeQQmwo5+aCcT6u5aGi/TDNEB4K/Dvy04Kt17FsBroxUCNRDoB4CdCqHDQqdYyEqQCHUB0LPj+3to4GGoQrhvsgj+RpAVVXyc23kZlrJybCQa7CQcigb89lctArkppsxnsvDeM6M8Wyex8bwihZUm3On+F4at9ukvlBccGnHaWM+7DxtZ3eyHbBiO79eAWJDFFpGa2gUoUGrwKDWeq6ooyE+TEErcwuUO/mkeibBvhC1nNmqkmKCf1JVLHZIz4OUXEgxqRxIV9mf5giYU0yQkecY97qoVgk6RXVWatov0xb5TE4hC+2QZ3VffCrbfRnAv+kqmvPjg6sqWFWVlUdA9djV0XHDEOIDeTZoEgaNQx1jfEf6gb8W8vPtdKmnoU6A4/F9nQCFIB/kcX0FsuTbMWZYsBit5GZZMWVZMGVZOXbMTKZdh12nISvTSlamjZz0fEKPp6Gxu/6O/XJN6C1WNDoFu62QsSELoZZsdEohCmW75EtRBU5nqZzOsqEoNlQVPt7i6B+g00DDcIVAvULrGA03JOhoEqmhSaSGhmEKOhk6tFQk2PdMgn0haqA8q8rZHNiTomIDzuXC2Rw4m6uyN0XlaCZoNY6g3mhx375gcp2iRgfxxKpS8o3KQMW9g+Plss+zQZ7J8fPOc7DrHGg1jkuFNc+GmuceASr5VoJ9VOqHaKgbpFA3WEOAHgwmlRub6IgMUIgMVIgMUAj1VYgNgMAATa2aHdSeb8OSZSE/04IlKx9zSh6m3en4BPtgzTBjzcjHkm5mW5YPp+qFk6fVkWO0kZtrR5NrITbD4Ha5Tg4NIc9Xj6JRUM8HVD4WK+F2z79l+6XNaoSoQpf2DbDa4Uia44tyd7Kdr3dZnd9ZGsBHB13iHaMENYpwvGJDFJpEKNQL0UilgygxCfZFlVJVFZPJREBAQFUXpVqzqyqGPEft+u4UR032udyCl8qusyqncxxBbqoJcgoJ4HUax6Pl4sxqWdtGB1G5qJ2uh+NW7SpZeZCVZ2f/OdCcr61TgeX7rFwce16XmUP4+ao+f1+FgAANwTo7oSlGmjf2wS9Qi1+AFt8ADaSbiNBaCYv1ReevQ++vReuvxZZvJ7CuP1ofjePlq0XRK2j1GjQ6DYq2+B0DVVVFtYNqtWO32MFix262YTfbUc02rEYrlnQzGr0GW64Vu8mGLddKxt4MtHX9sdtVrEYL1hwruadzyTlmxLeOH5bMfCzZFqzZFvIz890e+ejNNgKzHY9pFJ3iaMeuqvzd82qyku3AhcmS/FR74fVy56dkVaWTq6ihLv7KseN4srnhqI3fEh2zF1/81MBHC/VCFBpHOJoDZZhUbr1ST3yYhvohCnGhGkL8audTSKnZ90yCfVFpLm7DbzKZWLRoEadOneLee+9lzJgxVV28SpNnVcnIczSJyTBDisnOn6chyt/RhCYtzzFhzN8pkJXvCEINZri0IlPBEcBD8QL4mjDZTnVy8e/j0t+N70VVeSazislsI9+cT2BWHv+k5KHRAIqCgkq9Q0n4m/JKVwgF52xLmoJg+jzVpqLaHU2qnIGyqtIgMRttMf8WDJE+oFFQtOc7UKgXOqNmH8y6/A4uftpS2Y98hPByhX1n59sgMUMlMcOGRnF89yzf5/okUqdxdBxuVVdLXKhCTLCGmGDINMH1jbTEBGuIDlSIClKkE3EtIcG+qHRff/01mZmZDBw4kMjISOrWrVvVRSp3n+62M32HnVQTtK8LH/6floRQhXtX25j7T+EBj0ZxNJ8pqMm5XFikUrwgX1Q/jqEYHb9hpSwBsAqcv87bLYUH0xc3IVDsFDvQvzgPt9FmRMWqyNF8SrLvsqaVUYkqlKeWbFY7GPJg83Gb87pis59/8LbRNa2fDh7qpGf6AP+KLm4lkL81TyTYF5UuOTmZxYsXExERUdVFqRC/J6k8tOZCRLXqKJzLtbF1hI4D6UW0M1Y9f3kLUVvJR0KUnUptDQQvd13Js8Lvx2tGL3VpxuOZpqoLIGqffv36VbtAPz09HbPZ7HxvNBrJzr4w/Et+fj5paWku25w5c6bQ90cz3b9Zj2Y68rCXOJqXUKf8VM9zWT1LJUQ5kNirHFX8N0V5XgergorifAlXUrMvKl18fHxVF8HNpTcfQUFBLu99fHyIjIx0WRYbG1vo+14NFRoEw8mLhop8oLVCREQEGk0hY0oWSb60yk/1PJfVs1RClINqU6FeLQpRRhV/DOV5HawaNeH3XDEk2BeVzs/Pr6qLUKGiAxV2jNSyJlElOUelbV2Fm+MdD9EULnwdSY2uEJdXKy/f1aWde0mKUVjaanIYonA6jaOJj7aGtPGQa6pnEuwLUQHqBCjc1dL9Svd8Fw0rj6ik56mkmiDN5Bg+M8XkuV1lwZCZl5ugSnin4v5KFc2FUXWU8zMAO/4uVLCBolFQLrpoF4w1r7l4tmDlkv/l76n2KdGNhET73karcZ/gq4BGgdhghXohCrEhF0bk6dOsZoSC0nzHs5rxGxbCS9zaRMOtTQpfZ7GpjqE3TY6x8vel2UnPA1BIMamk5MLpbJVtZ8FX5xht4dJBUgqG43QZN15UGa3W8b/dDnYP16F8Hz3+eWZ0/lp0flp0/jo0vgrmtHzCrghBH6hD66tF66shL8OMoigENwh0jLWvUVC0kP5vJhHNQ9HoLkT7ptQ88nOsBNULQLWrqFYVm9WGfdM5wmP9UFAcY+2bbJjP5GJJzUMX5os914otz7Fco3out5MCilZxjNhT8OhK/vaEqBB6jftkh346iA1RiA/T0DBMg1ajUidAQ+d4LbHBBUNvKgT41PRguKYfX+lJsC9ENaHXKtQNhLqBjvfdGmiLTK+qKgaz48nAwXSVk9mO2v+zuSpnc+GMUWVzEui1jhuD/EsCsIvH6S/NTLm1iU4DRfW2UIBgXwgPUIgKVPAP9aNVoErjaB1BgQpBARoC/BTICqNJQx98AzT4+WvxDdDi698avU/Rv+uqZLfaseZYnS9LppncEzlo/XXOCbUsWRbStqeiD9SjqioWQz7mdDOWJBMczUY5f7NRQGe9MPqHRuOobK4uLVeEqEoFY+dfLNzfMW5+fJiG6xJ0NAxzTKjVMFxDvWDHzN21cRKtS0nNvmcS7AvhpRRFIdwPwv2geUTRX3KqqpKdD2dz4ZhB5UCGY+zlghuDszmOGwOtBoz5YCxkBl4Fx/rizsJbHWkUx0vhonGnC0mk1UC9YIXoAIgJdgTwqVnQOlqhaaSWqECFOudfIX6O9VpNzbzQaHQafEJ98An1cS6L7BhVon2oqordZMOSYcaank+jk3mkB/mRZ9OQY7SRY7SRlWbBsMNGeJAGU6YFU5YVc44Vrb2Q39L5U31x0yYhvEFBJcvFFSw6DcSHKTSP0pAQriHfpjKgpZ7GERoSIjQE1vga+fIhwb5niqqqUqEnhHBhtjr6FJw2Om4M9BpH86K0PEgzqWxOUvHTOS5Y6XmQaXbMBpxfwuGaCwJvBcc/BU2PnK1Rzo8Rbcc5gWux+ZyfRTLE53ytsQodYxQi/CHcFyL8HM2j2kUr1A9SqOMPkf4Q4ed4yiKqnqqqmLKtGHNVjEYbxiwbxmwbmRlWTm9JJSpUQ26mBWNaPrkZFizJRnxM+YXv7PxMw5fJkEBDjttif5MVf5PNLZTIDNG7PZJIiwzlVHxdt+VngoKwaVx7Qib56tkcFlxYQS5TUFHd6TWOPlYX19I3ilC4MlpD8zpamkVpiApUaBOjoUmkpsZWFlSmVOUF58911NeqsCTVj9TsCyHc+OoU6gdD/WCFa0owkprNrpJjcTwZKHhCcNSgOmZx1DgmcMmzQrZFZdc5aBkJdlXBZndcGI9lqug1EBesoCgFE4Go7E2FjjHgr1Pw1Tr6LJgsKgoKjcIUAvU4X75alXA/BR8J2L2eoigEhOgJCIHoS1cOjHRLb7fbseTYMGXkk5ueT26qmZw0M8d/T8U/3AdTRj7Gs3nkpJrJM7g/vnLpzCxEMeg1rk86fbXQPErDdQlamtXR0DxKQ/MoLfGhoNfVkGFvqimp2fdMgn0hRLnRahRCfCHE98Ky9nUr+wtYvvBrK41Gg2+wBt9gPWHxgc7lVw9v6JbWZrVjSs8nN81MTooZ4zkzOSl5nP45CR8t5KXkkXsuD6vJhqpcNJDR+RsC9dLe8aLW8NE6mvkF+sLtrfU0j9LSIkpDsygNwb7y/VNVJNj3TIJ9IYQQtY5WpyEo2o+gaD+48qIV465wSZeTkcv8D74mP1mhW6cbyE/Ow3Qql9wTOeT9m0n+JZ2PgfM9jpHWOF5Eq7gPbRwd5Gh2o6oqPa/Q0TFOR4soR+dYjTS7qYbkd+KJBPtCCCGEBz5BeoixkR8DDe5uhF6vd1mvqirm9HyMSTnknDaRctjIP0kqthA/0pLzyUi1YDbZUc53j1MUxwhEhfU7FhVLe37Up4uHJQ7ygSvqaGgZrSEmWEO4P9zSQk+zOhqCpJbeq8i9tWcS7AshhBClpCgKfpG++EX6UucqaAh0vCRNnsnGycQ8DLmQbrCTkmolJdVKYLKdXfl2cpC23OVFqziCvos7xvpooVVdDVdGOzrDNo3UEOqncG28hqggjQxbWUNIMx7PJNgXQgghKpCfv5YrrgwsdN1nOEa/OpWpcjzDzgmDyrpDFoz5kJOvcizDzuksFdMl/Yl1Xj4Mbml4OuYAPdQPUTBZ4ZbmOppHaWgcoaFRhIZG4RpC/SUIrA0k2PdMgn0hhBCiCvnqFJpEKjSJdNTw39vRvalQVh7sO2cj2wyns+wkZamczrLz+3EbGbkqFhuk5qqFDn+rPT+/RHW7MSgoF3gum1aBpnU0NAxTaBCmoV6Igl4D9UM1XBOnJT5MgnlRQP4OPJFgXwghhKjGFEUh1B+ubVj0JVtVVbLNcM6osuu0FZ0G0k2QlquSlquy54yNlByVEF+FjDwVg0klK08l3QSqWnFtnvUaCPCBQL2CXgvGfJVODbREBmiICFAI94dss0pCuIYro7VEBylEBynUCVDQyRC6opikZt8zCfaFEEKIGkBRFEL8IMRPoWkdn8tvcBFVdTwVMFkcc1hkmx03A356xzwYVjtY7SqnMu1EBSrotYpzUjw7kGNWiQ3R4KsDX62Crw50CgT7KfjI/AWiEkgHXc8k2BdCCCFqOUVxBOi+OgjzVyjBXHpCVAtSs++ZBPtCCCGEEMLLSbDviQT7QgghhBDCq0nNvmcS7AshhBBCCK8mbfY9k2BfCCGEEEJ4NanZ90yCfSGEEEII4dUk2PdMgn0hhBBCCOHlJNj3RFPVBRBCCCGEEEJUDKnZF0IIIYQQXk066Homwb4QQgghhPBq0mbfMwn2hRBCCCGEV5Ng3zMJ9oUQQgghhFeTYN8zCfaFEEKIElJVFes5E1nrTqIJ0JG3Jw19vUD0DYLQR/nj3y4KRZHgQ4jKIm32PZNgXwghhLgcVcX46xnMW1PIXHYE065U1Hy7x+RKsB5duC8xL11D2OAm6ML9KrGwQtRGcnPtiaKqqtwMCSGEEJdQ7Srpm0+zY/T3+J1TCUi3lnq86qAb61PvzWsJ7BxTrmUUQjgcVN51/txMfbIKS1L9SM2+EEIIcZ4tz0rWb2c5+/kBUpceR82zEloODQSMG5I42GUx+rhA4uf8H8E9GkgzHyHKkbTZ90yCfSGEELWWalfJ+cfAqY8PkHskm6yfT6G12iosP8upHI70WoEuxp+Eeb0I/r8GFZaXELWJNFPxTIJ9IYQQtYI1x0LuwSwy1ieT+WcKecdzyNqWCgVN7xXQqZ7b4ZdrWZJNHO6xHJ9GwTT4+CZCesVXSr5C1FTeXrOflJTEpk2bOHfuHIMHDyYuLg6bzUZmZiahoaFotdpS71uCfSGEEDWKarWT+3cqWetOYUnPJ2nhCaxWBXNS7mU2rJzyXSz/WDZHeq/Av0MUdZ/tQNiQJtK8R4hS8NZgX1VVnnzyST788EOsViuKotCmTRvi4uIwGo0kJCTwyiuvMGHChFLnIcG+EEIIr2ZPy8X42S6sSUbSlh7DmGzFbgUbWuxahRxb9R8Jx7Q9hcRhP+Lftg7hdzUjemJbFF1puwMLUft4azOet99+m/fff59nn32W//u//6Nnz57OdaGhodx+++0sWbJEgn0hhBC1h91kwbz5FLmL92P+Zi9k5WFRtaDRYLb7AfrztXwq2Lyrts/0dyqmXamcfWcHwd3qE/taF/yahVd1sYSo9ry1Zv+TTz7hnnvu4fXXXyctLc1t/VVXXcXq1avLlIcE+17m9OnT9O/fn4ceeogxY8ZUdXGEEKJS5Gfmc/rDPShbkrD8eBC9JR8FO7qLG9zbvbVu7yLnD8F2Lg/D4iMYFh9BXz+Q0EGNqfNQK/zaREozHyEK4a3B/smTJ7nuuus8rg8MDCQrK6tMeUiwX0Lbtm1j7NixAAwdOpRnn33WLU16ejp9+/bFarXSvn17Zs+e7Vw3evRoduzY4Xyv1WqJiIigXbt2PPDAAzRp0qTiD0IIIbxARqqFv3/L4NxbO9EeM9D03Fn0qh0f1Y5K7ZlCx5KUQ+qHe0j9cA+Kn5aQvg3xjfYj4sFW+LWpg+JT+o57QtQU3nqrHx0dzcmTJz2u3759O/HxZevAL8F+Kfn6+vLTTz8xceJEfHx8XNb98MMPqKrqsee0j48PL774IgBms5m9e/fy/fffs3nzZubOnUtCQkJFF18IIaodi03l57/zOHPAxJ7fs7AmmwjIMdHxSMaFC7m3XtHLiZpnI3vZEfJUG5kf7wYF9E3D8L0yAt+WEQTf2hjflhFoZcZeUct4a83+7bffzscff8y9995LaGgogPPp3Zo1a/jiiy945plnypSHBPuldOONN/LTTz+xceNGl84UACtWrOD666/nr7/+KnRbrVZL3759ne8HDRpEo0aNmDZtGgsXLiz0aYE3UlUVk8lEQEBAVRdFCFEN5Zjt/HrUyt+nbXz8u5mzRpUuqUairTYCLBYCq7qA1dXFE9+rYDlkwHLIgHHFUdLe3AaANjYAja+O4IFN0McH43dNXfw71EXjL5d9UTN5a7A/ZcoU1q9fT9u2benatSuKovC///2Pl156iT/++IN27drx/PPPlykP+dSXUosWLTh69CgrV650Cfb37t3L0aNHGT9+vMdgvzBdunQBKPJRTlEWLVrEhg0bOHr0KBkZGYSGhtKpUyfGjRtHvXr1ALBYLNxyyy3Ex8czZ84ct318+eWXTJ8+ndmzZ9O+fXsA8vPzmTdvHj/++COnTp3Cx8eHdu3aMWbMGFq0aOHctqB506RJkzCZTCxatIhTp05x7733MmbMGI4cOcLs2bPZvXs3BoOBkJAQEhISGDlyJDfccEOpjlmI2ujfNJXvDqs0C4fbm2mw2VXm/qOSZoKRrRRiAh0XvOx8lTl7VLQKPNBGwV9f+IXwtFFl/j6VOv4wqrWCxkN78JNZKl//qxIbCCNaKuxLg5VHVFpGgl4Du1LglkYKbaNdty+sfN/szOfl1SYOp15ojlMQvpZ1/JmiKv4vbvpzaTOgotZdfm+goqKcf3/xz572V5HNkFTAdiYXG5D2/k6Ui+8NfLRo29Qhom8CUZO7oGguU4r9p2D5VmheDwZ1ubA8Mwfm/AI+Onjg/8DPx/M+hKgE3vrQLzQ0lD///JN3332XxYsX4+fnx8aNG2nSpAmTJk3i6aefxt/fv0x5SLBfBv379+e9997j3LlzREdHA45a/YiIiBIHsAVBflhYWKnKMm/ePFq3bs3w4cMJDQ3lyJEjfPfdd/z111988803hIWFodfrufXWW5k3bx6JiYluzYVWrFhBfHy8M9C3Wq08+uij7N69m759+zJs2DCMRiPLli3jgQce4JNPPqFly5Yu+/j666/JzMxk4MCBREZGUrduXQwGA+PGjQNg8ODBxMTEYDAY2L9/P3v37pVgX4hiSsxU6bLARqbZ8X7qjfBvusrs3Y7L3My/YfcoLYF66LXIxp9nHOmWH1FYO9S9WWGWWeW6BTaOn+/7te2swkc93NNl5Klcu8BGktHxfv1J+PYA5Fhc073yB2y9W0ubqAsB5Ph1drfyrdib7wz0wfUirajFu2R7SlVVdXuKh58dihPaX0hT1I2IpyO/+AZDuWgLR6B/0R7ybdi2nyV1+1nCH2yFPj7Ec5GOJkPnZyHb5Hg/7X54/Faw26HHZNh2xLH8h+2w6sXLHJ8QFctba/YB/P39efHFF51NvMubBPtlcMsttzB9+nS+//577r//fvLy8lizZg0DBw5Epyv61BoMBgDy8vLYu3cv7733HgD9+vUrVVm++eYbtzu/bt26MX78eJYvX86oUaMAR5OhefPmsXz5ch5//HFn2l27dpGYmMijjz7qXLZw4UK2b9/OBx98wLXXXutcPmTIEIYPH860adNcOh8DJCcns3jxYiIiIpzLNm7cSHp6Om+88YZbkychRPH9lqQ6A32AVUdV/k2/EPwdy4T9adA4DGegD7DuuEq+TcVH63ox/CcNZ6BfsL+PCsl31znVGegDrD7qHugD5Fnh5xOqS7C/6qh7+QAUxbU1Sk1WniGI6vIcpHR5FDvtr/svBPoAq7Y7gv2zhguBPsCPuxw3ABqZF0BUJe8N9iuafDLLICwsjG7duvH9998DsH79eoxGI/379y9yO5PJRI8ePejRowe33norzz33HFarlcmTJ7sE1SVREOjb7XaMRiMGg4FmzZoRFBTE3r17nekaNmxI+/bt+eGHH7Barc7ly5cvR6vVcuuttzqXrV69moSEBK688koMBoPzZbVa6dy5M3///Td5eXku5ejXr59LoA8QFBQEwO+//47RaKQ6Sk9Px2y+EEUZjUays7Od7/Pz893Gvz1z5kyR75OTk1EvimYkD8mjrHm0jVLQay7s/5oYuDriQtQd4Qd19TnoLEaahF3YR6twm0ugX7DPpmEQ5nsh3TUxSqHHEa3JJFh/4f1VdWxolcIDzo51FZc8CvZZUL4L5aolkT7lfaQVc94K+9vNb1kfdBee9JivPj8iSJ0Q1IZRFzZu3wg0mir/fEge1S+PyqSiOF/e5P7777/s64EHHihTHlKzX0a33XYbEyZMYNeuXaxYsYJWrVrRuHHjIrfx9fVl6tSpgKOzbmRkJA0bNkRThlqRv/76i08++YR//vnH5cMKuHxYwdHz+8UXX+S3337jxhtvJCcnh3Xr1tG1a1ciIyOd6Y4dO4bZbKZHjx4e8zUYDMTExDjfFzY8VIcOHejXrx8rV65k9erVtGzZks6dO9OzZ8/LnqvK4ukGpYCPj4/LuQGIjY0t8v3F50XykDzKI4/WUQo/DNayYL9Ks3CFp65RMFn9eP1PO6kmeLS9hvg6jjx+Gabyv612tAr8p7NPofuMClBYP1zLRzvtRAXA8501hR5Hq7hwfh6mMmu3ndhAx/42nlRZdFDlygjQaWBPKgxoqnBDnOKSx5d9NS7li/A/31RF9XBBLuYY8p5SVdUtRNFt/ssv+FA81Oy7NvRRLmkGpFy2BIX+7UZEwKoX4JvfoHk9fJ8c4Fip16Fs+C+8tczRZv/5wUDVfz4kj+qXR2Xy1uqDX375xW3uDJvNxpkzZ7DZbERFRREYWLbhCiTYL6Nrr72W6OhoZs+ezbZt23juuecuu41Go6Fz587lVoZ//vmHRx55hLi4OB555BHq1auHr68viqLw/PPPY7fbXdLffPPNhIaGsnz5cm688UbWrl2LyWRi4MCBbvtu2rQpEydO9Jh3eLjrzI5+foUP9zZlyhRGjhzJ77//zs6dO5k3bx5z5szhiSeeYPjw4SU/aCFqqR4NNfRoeOF9sA+80c29nX18SOHt7y/VNlrhk96XT3dNrMI1sRfS3dJY4ZZi3KsH+yhu5bsmXseS3RbybY73WgVs5XSlLiqoLapdfdFt7i+f08Xh9KWhdWH7c1+meFxX0lsF5ZI3Fz+EUQB9w2D8O8egiylGANGrreN1qYRomCETO4rqw9tq9AskJiYWutxisTBr1iymTZvG2rVry5SHBPtlpNVq6devH59//jm+vr707t270svw448/YrPZmD59OvXr13cuN5lMbrX64Lg779evHwsXLiQlJYXly5cTHR3t1oSoQYMGZGRkcM0115TpqUOBpk2b0rRpU+655x6ys7MZNWoUH374IcOGDZMZIYWoRSZ29+PRG3zZc8bGyn8sHDfY+GaHhVwL2C+/uSgOBRR/HQHd49BF++PfOZaAbvXxaRKCxk9f1aUTotx5a82+J3q9nkceeYR9+/bxyCOPsGrVqlLvS4L9cjB48GB0Oh3169d3e+xVGQom71Iv6e02Z84ct1r9AoMGDWLBggVMnz6dPXv2cP/997tNAtavXz/ef/995s+fz8iRI932kZaW5vZIrzCZmZkEBwe73DAEBwdTv359Tp48idls9vhEQAhRM+m0Cu3idLSLc1yGPhsOSQY7SzZpyTxk4sRuK4pFutwVh+KvQ58Qgk/zcIL7JaCLCyawe5yMqS9qFXsN/ba4+uqr+eqrr8q0D/kmKAcxMTGMGVN1jzNvvPFGFixYwOOPP86gQYPQ6/Vs2bKFw4cPexzKs1GjRrRt25bVq1ejKEqhnYrvvPNOtmzZwvvvv89ff/3FNddcQ2BgIMnJyfz111/4+Pgwa9asy5Zv1apVLFiwgJtuuom4uDh0Oh07duzgjz/+oGfPnhLoCyEAqB+m4bH+IUAI+flRHPonl/2bM7AeOI7O6OiLVNNq70pDf2UkflG+RIxtjX/7aHyahcvTUVHreWsznstZu3ZtmScnlWC/Bmjbti1vvfUWn376KR9//DG+vr506tSJ2bNn89BDD3ncbtCgQezatYuOHTsSFxfntl6n0zFt2jQWL17MDz/84Azso6KiaNWqlcvIPUXp0KEDBw4c4NdffyU1NRWtVku9evWYMGECw4YNK91BCyFqNB8fDa3aBdGqXRDqw3Fk7jNw5rVt6LafhoNnq7p4lctHQ/DNcUTedyWB3erhU5y29kLUMt5aEfDKK68UutxgMLBp0yZ27NhRrP6gRVHUS9t+iFpj7dq1/Oc//+HVV1+lT58+VV0cIYQoFvM/qeT9cJi81UewbTwKdhULWlAUslV/LOixoWBHgx0NRor/9FCHFa1L2KDii6MnsRZr5Y1XrVXwaxVB7H87E3pLQxT95TtRC1Gb/a5cmPfnOnV0FZakZDz1iQwPD6dJkyY8+OCDPPTQQ2V6eic1+7XYokWLCAsL4+abb67qogghRLH5tqqDb6s6hD7dBdVqx7LjDNnvb8WamkfOxnNgds4fW8UlLTlthC8h/RKIm3oDujr+l99ACAF4bzMeT30ry5ME+7VMeno6W7duZdeuXezYsYNHHnkEHx+fy28ohBDVkKLT4NOpPpHzBwEQrapYThrJ3pCE4aeTWHPt5P10DqvZXq2H+tFF+VFnfBvq/qcjGl+pxReipLw12K8MEuzXMkePHuXFF18kODiYwYMHM2LEiKoukhBClBtFUfCJDybynhZE3tMCgOaAPd9G5pZU8o4bydiYTNZfaZhP5WBJy6/a8gbqqPdaF6LGt5GmOkKUgbe0ST9x4kSptits0tLikjb7Qgghaq280zlk/ZnKyY/+xXQ0G2tiZqW02Vd8NcRN60bE/Vei8ZEgX4iy2qR85vy5m/pAFZakaBqNplTt7202W6nzlJp9IYQQtZZfvUD8bg8k+nbHtMTGvRkYfjpFysKjGP9KKff8FH8t9d+5gcj7r0TjJ5dgIcqLtzTjmTNnTqUPlSs1+0IIIUQhrAYzZ5cc5fBzG/HNAL3NikahZO0FNArYVXwSgon9bxdChzZB6ytBvhDlbYMyx/nzjer9VViS6ke+cYQQQohC6MJ8ib6nKatsv6Lkq/QzX0f+32lkrTmB7azpQsLzAf2lFH8tUQ9fRdhdVxDQNkomvhKiAnlLzX5VkGBfCCGEuAzVRyFqTBv0ej0A1ow8THvTMCw6gk/9QHK3nUPfIBh9vQC0IT6EDW6CLlKGzhSisnh7M5XNmzezY8cOMjMz3YbjVBSFl156qdT7lmBfCCGEKCFduB/BXesT3LV+VRdFCIH31uynp6fTr18/tm7diqqqKIpCQQv7gp/LGuxX2mSAQgghhBBCVAQVxfnyJk8//TS7d+9mwYIFHD16FFVV+emnnzh48CBjx46lbdu2nD59ukx5SLAvhBBCCCG8mv2ilzf54YcfGDNmDMOHDyc4OBhwDM/ZtGlTPvroIxISEpgwYUKZ8pBgXwghhBBCeDVVozhf3sRgMNCqVSsAgoKCADAajc71vXr14qeffipTHhLsCyGEEEIIr6YqF17epF69eiQnJwPg6+tLdHQ0f//9t3N9UlJSmUfykg66QgghhBDCq3lbjX6Bbt26sXbtWl544QUAhg8fzltvvYVWq8VutzNt2jR69+5dpjwk2BdCCCGEEF5N9dK2Kk888QRr167FbDbj6+vL5MmT+eeff5yj73Tr1o0PPvigTHlIsC+EEEIIIbyaqvXOmv02bdrQpk0b5/vw8HDWrVuHwWBAq9U6O+2WhZfeBwkhhBBCCOFg1yjOlzfZt29focvDwsLKJdAHCfaFEEIIIYSXUzUXXt6kdevWXHXVVbz++uscPny4QvLwslMihBBCCCGEK28denPmzJlERUXx8ssv07x5czp06MDbb7/N8ePHyy0PCfaFEEIIIYRX89ahN8eMGcPPP/9MUlIS77//PoGBgTz33HM0btyYa6+9lvfff19m0BVCCCEqiqqqhJ7MI/xEHrZ/zqJavW1+TiFqB2+t2S9Qt25dHnnkETZt2sSJEyd49913URSFJ598koYNG5Zp3zIajxBCCHGe3WLFtng31q0nsH6+FfKs9DVbATj32ueoGh0E6vHtEEPA0Cvx79sEfUJY1RZaCIHdO2P8QsXGxtKqVSuuvPJK9u7dS05OTpn2J8G+EEKIWs96OBXzi6uxr/0X0k2gAKprGhUN2FXIzse84QTmDSfIUEB/cyMC72xNyP2tyzzTpRCidLy1Rr+Aqqps2LCBhQsXsmzZMlJTUwkPD+eOO+5g+PDhZdq3BPtCCCFqLcvO0xifX4ttzUF87aYLK1TP27hQIfvn0xh+PkvKezsJu78VkRPbS9AvRCXztrb6BX799Ve+/fZbFi9ezLlz5wgJCWHgwIEMHz6cHj16oNOVPVRXVFUt7leaEEIIUSPYjmVgfGkd5q/3gF1FgxVfzEVuk04kjip/VyZ8saN1vvdtF0WdZzoSekfz8i62EMKDb2MXOn8edqZsNeGVSaPREBQUxG233cbw4cPp06cPPj4+5ZqH1OwLIYSoNexZeZim/U7OqxvBUjGdbc07U0i6czWGBf8SPaUL/u3qVkg+QogLvLXN/qJFi+jXrx9+fn4VlofU7AshhKjxVLsd+9d/kTPuO/Ky3eu5yrNm3+l8u//wR9sS9XJndHX8S1l6IcTlfFPvQs3+Hae9p2a/MsjQm0IIIWo0+9p9WBr8B9uIz1Gz8yl+g/wyOp9Nxke7OFh3Nimvb8Wea6mcvIWoZbx96M2KJMG+EEKIGkdVVewbDpDf+AWsvabD6cyqK4wdsKucfeEPdoZ9xpl3dmGToF+IcuWtk2pVBgn2BbNmzaJjx45lnqGtJFauXEnHjh3Ztm1bpeUphKj5VKsNdfFWrA2exnrTe3AsraqL5GRHwWaBk0//yfawOZz8z59YzuZWdbGEqBFURXG+hCuvD/a3bdtGx44d+eqrr6q6KIVasGABK1eurOpiCCFEjaZuPYL6/LcQ/BAM/QA1qQpr8ovDonLmzV3sjPmSf/t8T9o3h7HlW6u6VEJ4Lbty4SVcyWg8Fezrr78mNjaW2267raqLIoQQNYbdYid9ZxrqW6uI3LMP5eAZ0CiOSa+AwjrSVldZP50i66dTaAJ0BF4TRcTwpkQMbYxeOvQKUWxSo++ZBPtCCCGqtXybyp6zKv+m2fnhTxNKmoneH20iyGxmYMrPF7rb2r17cDl7rpXsjWfI3niG4+N/RR/jj3+7OgS2jyK0Z338m4ehjwms6mIKUS15c1v9rKwsZsyYwfr16zl37hyzZs2iU6dOpKen88UXX9C/f3+aNm1a6v3XyGD/9OnT9O/fn4ceeoiWLVvyySefcPjwYYKDg+nbty8PP/ywy4xko0eP5syZM8ycOZOpU6eyfft2AK655homTJhAXFycM+3KlSuZMmUKH3/8MR07dnTJt2A/Bc12CtafOXPGJe2KFSuoV69ekcewZs0aFi5cyKFDh7DZbDRt2pSRI0fSo0cPl3QdO3bk1ltvpV+/fsyYMYODBw8SGhrKsGHDuPfee8nKymLatGn8+uuv5Obmcs011/DCCy8QFRXllqfJZOLtt99m3bp1GI1GmjZtysMPP0ynTp3c0m7ZsoUvv/ySf/75h/z8fOLj4xkyZAhDhgxxS7ts2TLmzZvH6dOnqVu3LsOGDSMoKKjI4xdCVDxjvsrOcyoKEB8MGWYFjaISoHdcNa12aB7h+FlVVZYctGMww11XagjQK5itKv+mg9mmEu6ncEX4havtuRyVMznQMhL0GuCfExAaCA3qFFoWe04eW5ce4K/8MJJCIvkzTUMWGv41KOTZFFTA12IlLi2PcGMeA/OtFAx3c36ES5f/C1z6nmKuK56y76EolmQT+atPkrX6JOmv/YkeO4qfFk2YL/6tw7HbrSTHhxFzSyMShrUodB85+SqHDNA4FEJ8FTh+DnLM0LLBhUQZRjiSDHY7NIyGumGO5b/shr0n4c4bICrUsSwtG06lQkw4nMkAvRa0GlBVSDwHrRt6/B0LUZHsXlqzf+rUKbp3787Jkye54oor+PfffzEajQBEREQwa9Ysjh8/zvvvv1/qPGpksF9g8+bNLF68mMGDB9O/f382btzIV199RXBwMPfff79LWpPJxJgxY2jdujWPPPIIJ06cYPHixezZs4f58+dTp07Jv7xeeeUVpk6dSlhYmEt+4eHhRW43Y8YM5syZw3XXXcfYsWPRaDSsX7+e5557jmeeeYZhw4a5pD9w4AC//vorgwYNol+/fqxdu5YPP/wQX19fvv/+e+rVq8fo0aM5efIkCxcuZNKkScyYMcMt30mTJqHRaLjnnnvIzc1l6dKlPProo0yfPp3OnTs70y1dupQ33niDNm3acP/99+Pv78+WLVt48803SUpK4vHHH3emXbBgAVOnTqVZs2Y8/PDD5OXlMW/evMueAyFExTqVrdLpKxtnzvcPLQiUL/VEB4V3b9LS7DMbhw2OZY/9YmPPKA1DVtrZde5C2he7KPz3Bi1rEu0M/M6OyQrX11PZ+N37aBf97ggKZ4+D+//PJQ9bUjrnrn6OTc26Mrt9bwx+FtL8fUCrnr9TOK8EFfeFheFqEetKprBbikvXebr9KO6+Hf8XvCvYg5pnw5aciznZgB4r0YpC5sL9fBEUzr19XSfvOpWtcsPXNo5nQUwgbLL8xhUTPnAE5vfeBJ8/CtuPQM/JkJHj2MhPD989Bx+uhu/PD6AwcQ5sfwdM+dDnv5CV6/hd2gqZlExR4NPxbr9jISqat9bsP/3002RnZ7Nr1y6io6OJjo52WT9w4EC+//77MuVRo4P9o0eP8u233zpr0QcPHszw4cNZuHChW7BvMBi48847efLJJ53L2rdvz9NPP83s2bN5/vnnS5x/3759mTlzJhEREfTt27dY2/z777/MmTOH++67j4cffti5/I477uDJJ5/ko48+ol+/fgQGXniUe/jwYT7//HNat24NwIABA7j11luZOnUqw4YN4+mnn3bJY8GCBSQmJpKQkOCyXKvV8umnn6LX6wHo378/Q4YM4e2332bx4sUApKam8s4779CrVy9ee+0157ZDhw7lnXfeYf78+QwePJi4uDiys7OZMWMGjRo1Ys6cOc7Z4W677bZCnwAIISrPp7vtzkAfPMfRU7erDGx6IdAHMFnhmU2ugT7Aa3+qvNBF5fU/HYE+QOb2k45AHxzB4eSFboHgyQ/Wk5CWik2jQWe3oVK+U8XXBJ5+P1pVRWu3M2WHlnsvucx8tkfleJbj5+QcmLE1l/cK5tH8Yj28NBTeW3kh0AfIs8CUb+GPAxeW2VV4ai6E+DsCfSg80AfHjcSkbyTYF5XOW9vsr1mzhokTJ9KyZUvS0txHD2vcuDEnT54sUx5ePxpPUW688UaX5jKKotCxY0fS0tLIzXUf7mzUqFEu72+66SYaNmzIxo0bK7ysBVavXo2iKPTr1w+DweDy6tatGzk5OezZs8dlmzZt2jgDfQC9Xk+rVq1QVZU77rjDJW27du0ACv3Dueuuu5yBPkDdunXp06cPiYmJHDt2DIB169aRn5/PgAED3MrXtWtX7HY7W7duBeDPP/8kLy+PoUOHukwDXbDf6iQ9PR2z+cLsmUajkezsbOf7/Px8tw/hmTNninyfnJzMxRNUSx6SR3XKI8yveBdGfx345GdxabgZpnMfJz7Ix1ERf/G+s/z8UTUXXWrCA92OwycioFhlEZ6Fqhd+HwW/8zBf1zThXEij6jQQ5AdhhfQBiAhyC5wsYf5YAot5ExbhaKbpzZ8PyaN88qhM3jr0pslkKrRpdYGLfwelVaNr9uvXr++2LDTU0e4wMzOTgIALF5jg4OBCm+o0atSIDRs2YDKZ8Pev+JERjh07hqqqRdZ8X/phK+w4Q0JCANz6BgQHBwOO479Uo0aN3JY1btwYgKSkJBo1akRiYiIA48eP91i+9PR05zaA2xOEi/dbXURERLi8v7RPgY+PD5GRkS7LYmNji3wfExMjeUge1TaP8dEqvyfB8iOOZWE+YLY5QvpgH0cFrV4L79+soXOTcMa3tTJzl2N9pxiYdYsfIQF2vtirkmeFuoHwcU8NWo3C+zdpSMm1cTQTRnWJRmk42lFbHBkMXzzqdhz1Jvbkn9V7yMW33NrdVuTlvmQNc8pWEuWS/wujVVW+ujvU+b7gdz4uTGVrssLPx1Wuq6/w5LVXwt44yDahvH43RIfBlDvg0BnY/K+jzf7VCfDRQyhr/oaxHztq9WPD0X/5OGTnQVIG7D0BgX6QmeOo4ddrwWx1NPNpUMf5O/bmz4fkUT55VCZvbcbTsmVLNm3axJgxYwpd/9133zkrakurRgf7Go3nBxcX382WhFLEhchms5Vqn4XlMX36dI/lb9Kkict7rVbrcV+e1pX2+Au2mzJlisd+DIXdfAghqhcfrcK3/Yt/Cfioh46PXMcH4L2btLx3k3vahqEKm++6aN839ILRvTzvXK+j1fpnqLcmF/vKHEdL9RIG/Z6CYqWINKWNDZQi91T2vV/8f1F7KVgXXC+AuMbuT0d8tArz+118DWgG+6a7JooMhp9edt/5Qz0dr4sF+MEvrxRVeCGqjKrxzmh/woQJjBo1iquuuoqhQ4cCYLfbOXz4MFOmTOGPP/5gyZIlZcqjRgf7JZGdnU1qaqpbAHvs2DEiIiKctfoFNeZZWVlu+zh9+rTLKD9Q9M1BYRo0aMDvv/9OTExMoTXtFenYsWM0a9bMZdnRo0eBCwF8gwaOERzCwsJcOu0WpmCbxMREtxF9CvYrhBAFxvTwp09bH06m2diRCmn5Cr8mQZ4Ndp690CbXOy/pZWPXadHWDcCvTQTacD8Cro1FF6DBr2MMusZhVV08IaqctzXfKTBixAiOHz/Oiy++yAsvvABAnz59UFUVjUbD66+/zsCBA8uUhwT7F5k7d65LB93169dz/PhxBg0a5FwWHx8PwNatW7n55pudy3/88UdSUlLcHmH5+/sXemPgSd++fVm4cCEfffQR//vf/9xq5tPS0tweo5WXBQsWcPPNNzvb7Z89e5affvqJhg0bOm88evbsyYwZM5g1axYdOnRwaYsPjjZ+Pj4++Pj40LlzZ3x9fVm0aBH9+/d3pi3YrxBCXEyjUWgUraNRtI5uhazPMKlsOqDlbLI/6adjqfvvGeyAotGg2D10GPUmFw3eo68XQHC3eoT2iiOwQxT+rSJQvLTmUojK4K01+wAvvPACI0eOZMmSJRw+fBi73U6TJk24/fbby6XZswT754WFhfHLL7+QkpJChw4dnENvRkZGurSjSkhIoFOnTixduhRVVWnWrBkHDx5kw4YNNGjQAKvVdbrzNm3asHz5cmbOnEmjRo1QFIVu3bp5bP/fqlUrRo8ezezZs7nrrrvo0aMHUVFRpKamsn//fjZv3syff/5ZIefAZrPx4IMP0rt3b3Jzc1myZAlms9llNJ+6devy3HPP8eqrrzJ06FD69u1LbGwsGRkZHD58mA0bNrBo0SLq1atHSEgI48aNY9q0adx///307duXvLw8li5dSoMGDThw4EARpRFCCFfh/goD2voAPtCnO3arHdOqNgT8uhtmrAWTe6dhr6FA8M31iRjUiPChjfGJlk7LQpSIF9bs5+bm0rVrVx566CHGjh3LxIkTKyQfCfbP8/f3d06q9eGHH6KqKtdeey0TJ050a9rzyiuv8Pbbb/Pjjz/yww8/0K5dOz7++GPeeOMNt57o48ePJzMzk0WLFpGdnY2qqqxYsaLIzr6jR4+mZcuWfPPNN3z99deYTCYiIiJo0qQJTz31VIUcPzja4S9ZsoS5c+eSnZ1N06ZNmTRpEl26dHFJ179/f+Lj45k3bx5Lly4lOzubsLAwGjZsyLhx41yePIwYMQJ/f3/mz5/PRx99RN26dRkxYgRBQUG88oq0/RRClJ5GpyFwQCsY0Ar17Ttg80GYOB92HQerd8ymq4v2p97z7Yi6vwXaYBlyVIjS8saa/YCAAI4dO1biJt8lpail7alZg1w6860QQgjvpaZkYX9iIbZleyAn32WdiUDM+HNpy38NVnwxU5R0It22c+zTFzueB0ooYEVD3vk5BPxbR5DwcVeCr6+60UuEqElmXL3K+fP4v/tVYUlK5q677nK2eqgoUrMvhBCiRlGiQtB+9RCa7DxsTyzCvuAvyM2//IYVTIud4DahNFzQi4DWFdP3SojaSlW8c+qol156iaFDhzJy5EjGjBlDo0aNCm39cenQqCUhwb4QQogaSQn2Q/fJSNS3B2MdMx91yU4onxGSS0zXMJi4xf0I6Bhz+cRCiBLzxmY84OirCbBv3z4WLFjgMV1ZhneXYF8IIUSNpoQFoF/4EOrJdCx3L8D869lKy1sT6kP9r28hqE9ChbfLFaI289ahN19++WVpsy+EEEKUJ8v2JLJGLMb2b6pzWbm22VcAnYbYD24k7IHWKDrvbF4ghDf5oOOFIb0f3da7CktS/UjNvhBCiFpF36E+EfseI3/1IbLHLMd+qvhzoVyWRiFqUmciJraX0XWEqETeWrNfGSTYF0IIUesoioJv32boE5/AvGAPpilr4ciZCxNblWRfqCg6hYhnOhI+tg0+DUIqpMxCCM+8tc1+cYYhVxSFl156qdR5SDMeIYQQtZ6qqljXHMDyyR/Ylu4pNOAvrBmPNj6EkOevI2BIC3SRMhGWEFVlWpd1zp8n/NmjCktSMhqN52Z+iqKgqiqKokgHXSGEEKIsFEVB37sF+t4tUM1WrL8exTJ1A3arDXXtIQB8MKPc0ARNqB++3RsSNLI12pigKi65EAK8txmP3W4vdNnx48f56KOP2LRpE6tXry5THlKzL4QQQnhgsVhY9OYs9GY7/e8aim9LmQRLiOpo6nW/OH9+4vebq7Ak5evuu+9GVdUih+W8HBkiQAghhCiCsa4PGfF+aK6oU9VFEULUMt26deOHH34o0z6kGY8QQgghhPBq3tqM53K2bdtWZLv+4pBgXwghhBBCeDVvDfa//PLLQpcbDAY2bdrE0qVLefDBB8uUhwT7QgghhBDCq3lrsH/vvfd6XFenTh2ee+45Xn755TLlIcG+EEIIIYTwat46zv6xY8fclimKQnh4OMHBweWShwT7QgghhBDCq3lrzb6iKERFReHv71/oepPJREpKCvHx8aXOQ0bjEUIIIYQQXk1VFOfLmzRq1Ihly5Z5XL9ixQoaNWpUpjykZl8IIYQQQng1bwvyC1xuuiuLxSKj8QghhBBCiNrNm4L9rKwsDAaD831aWhonTpxwS2cwGPjmm2+IjS3bZH4S7AshhBBCCK/mTcH+e++9xyuvvAI42uxPmDCBCRMmFJpWVVVeffXVMuUnwb4QQgghhPBq3hTs9+rVi6CgIFRV5ZlnnuHOO++kffv2LmkURSEwMJAOHTrQsWPHMuUnwb4QQgghhPBqqvfE+lx77bVce+21AOTk5DB48GBat25dYflJsC+EEKLWsNpV5u9TOZBu57vDoAIpuaBRIEgPNhXa1IE8G3SoCxoVjphb0kCbztx/IF+18U8aZOerZOTBoQzQaeFEFoT5Qp4V4gJUGoVAl3oKd7fWUC9YBr4ToqJ5U83+xSZNmlTheSjq5boBCyGEEF7uYLrK2LU2tpyBXGsFZ5Zvd9xFnBcbCB/20TKgmQatl078I0R1N6XPVufPk37sVIUlKZ3NmzezY8cOMjMzsdvtLusUReGll14q9b4l2BdCCFFjJadYee7bHObmBkCpav5UoITbXRLsFwjxhS9v09G/mYLipbWQQlRXk275y/nzlNXXVGFJSiY9PZ1+/fqxdetWVFVFURTncJwFPyuKgs1mK3Ue8mxRCCFEjWM12/jlo8OMefY0fyWW/iJZnrLMMHCxlRYfWziYJvVsQpQnFcX58iZPP/00u3fvZsGCBRw9ehRVVfnpp584ePAgY8eOpW3btpw+fbpMeUiwL4QQokbJ33ycpTd8z5avT2Er42Q0FeFgOjT/2MJT66xY7RL0C1EevHUG3R9++IExY8YwfPhwgoODAdBoNDRt2pSPPvqIhIQEj8NyFlf1+xYUQgghSkE1Wci47SsMN3yKwaKt6uJc1rtb7MROs/BPiv3yiYUQRfLWYN9gMNCqVSsAgoKCADAajc71vXr14qeffipTHhLsCyGE8HrWlXtIi3sLy/cHq7ooJZJqgqs+sXLfSovU8gtRBt4a7NerV4/k5GQAfH19iY6O5u+//3auT0pKKnMfHxl6UwghhPfKysU67GPyfjqOnZCqLk2p2FX4YrfKhuMWPr5FR+8mUg8nREl50zj7F+vWrRtr167lhRdeAGD48OG89dZbaLVa7HY706ZNo3fv3mXKQ75RvMzKlSvp2LEj27Ztq+qiCCFE1bHbYfI3qPFjsf/kXbX5niRmQp9vrPRaYOGcUZr2CFESdkVxvrzJE088Qf/+/TGbzQBMnjyZLl268NJLLzFp0iQ6dOjABx98UKY8ShTsb9u2jY4dO9KxY0eWLVtWaJqOHTuWuSNBZSsIoNetW+e2bu3atXTp0oXBgwc7H7NcbNSoUXTs2JFXXnnF4/4nT55Mx44d6d69OwaDoUT5CyGEuIjdDjN+hEZjYcq3kJlT1SUqd2uPqcR/aOXOZRbScqVpjxDF4a3NeNq0acMTTzyBr68vAOHh4axbt4709HQyMzPZsGEDsbGxZcqj1DX7s2fPJi8vr0yZV3dLly7lhRdeoGnTpnz66afExMS4rD98+DD//PMPcXFxrFu3DpPJVOT+cnJy+OyzzyqyyEIIUTMdT4GXFkDoCHh4NpxIreoSVSizDb7ZpxIzzcJNX+Wz8bjNbaIdIcQF3hrsexIWFuYcnaesShXst2zZkpSUFL7++utyKUR1NHfuXF5//XXatm3Lxx9/THh4uFua5cuXExgYyH//+19yc3NZu3Ztkfts2bIlS5Ys4cyZMxVV7GrFarU6H0sJIUSJnE6Dhb/BnVOh+SOQMAZeXQzGml3JdCmrChtOwI3zbIS/a+Waz/L5dKeVLafs0qFXiIt4azMegBMnTjB27FiaN29OREQEmzZtAiA1NZXHHnuMnTt3lmn/peqg26NHD1RVZe7cuQwaNIiwsLAi03fs2JFbb72VyZMnuyxfuXIlU6ZM4eOPP6Zjx44AzJo1i08++YRvv/2WZcuWsWbNGoxGI1dddRXPPvssCQkJ/PLLL3z22WckJiYSERHBfffdx+23316aQynUhx9+yBdffEHXrl1544038PPzc0tjsVhYvXo1N998M23atKF58+YsX76c/v37e9zvww8/zCOPPMKMGTP473//W27lzcnJYe7cuWzZsoVTp06Rm5tL3bp1+b//+z8eeughZ/n//fdfRowYwX333cfDDz/stp/HH3+cXbt28eOPP+Lv7w84/tA++eQTfvvtN9LS0ggLC6Nr166MGzeOiIgI57YFv7eFCxeyfPly1q1bR2pqKjNmzKBjx4789ttvfPnllxw5coS8vDzCwsJo2bIljzzyCA0bNiy3cyGEqF5UVYXtiain0iE1G8WYB746OHQW6gTB/tOAHdIMKMeSwWxx1NrbpBb7Uln5sC0Ztv1gB+woQKQ/+Ong6rqQZ1VoEamg1YCfFuKCIcMMzSIhx6zQJEKhbV2FMD/vC4aEuBxv7aC7b98+unbtit1up3Pnzhw+fBir1QpAnTp1+O2338rcMqRUwb6iKDzyyCM8/PDDzJkzhyeeeKLUBfBk8uTJ+Pv7c99992EwGJg3bx6PPvooY8eOZfr06QwZMoSQkBCWL1/O66+/TuPGjWnbtm2Z8lRVlTfeeIMlS5bQp08fJk+ejE5X+CnauHEjBoOBW2+9FYDbbruNd955h8TERBISEgrdpnnz5vTp04cff/yRkSNH0qxZszKVt0BKSgrLly/n5ptvpk+fPmi1Wnbs2MGXX37JgQMH+PDDDwFo0aIFV155JatWrWLs2LFotRfGoT537hx//vkn/fv3dwb6ycnJ3HfffVgsFgYMGEBcXBwnT55kyZIlbNu2ja+++so5JmyBl156CV9fX+6++24URaFOnTps376dJ554giZNmnDfffcRFBREamoqW7du5eTJkxLsC+EtNv0DYz6GzFzQakABgv3BkAv33wz/vQvW74GxsyAnz5EmJQfVdOF7VD0fpLrKA9xnuVWhlHNhXqbGW1Xh4tq/81PTU1iNYOkLUbFUFRVINTkKdyobQOXnxKKP3VcP9cM15NngjuYK796k5Y/TKg/+ZCPLDCG+kJ4Hvlqw2GHElQr/61795ywQwttmzi3wzDPPEBYWxp9//omiKERHR7us79evHwsXLixTHqUeerNz58507tyZxYsXc+edd5a588ClIiMjmTp1qnNs0bCwMN555x3eeustFi5c6Gw/36tXL/r168e3335b5mD/ww8/JCkpiaFDh/LMM88UOa7pihUrqFevHu3btwegT58+TJs2jRUrVvDYY4953G7cuHGsW7eODz74oMy9qwvUr1+fVatWudyYDBs2jJkzZ/LZZ5+xd+9eWrduDcCgQYN4/fXX+eOPP7jhhhuc6VeuXInNZmPAgAHOZW+99RZWq5X58+dTt25d5/IePXpw3333MX/+fMaMGeNSlqCgIGbMmOFSlqVLl2K32/noo49cngY8+OCD5XL8QohKMuxdOGsofN2ri+HG1jD8XUjLvmiFlguXmqID0Uvjau+8dFcShcve0xTGbIOjmY6fp25X6dbAzmM/2zlR8CszuqZ/6y+VGxvYuaWxDN4nqjdvbL4DsGnTJl5++WWioqJIS0tzWx8fH09SUlKZ8ijTp/fRRx/FYrEwc+bMMhWiMMOHD3cJtgsC+W7durl0lA0PD6dhw4acPHmyzHmmpjo6fDVs2LDIQD85OZk///yTfv36udyM3HDDDaxatcr5+KUw9erVY8iQIfzxxx/89ddfZS4zgF6vdwbXVquVrKwsDAYDnTp1AmDv3r3OtH369CEgIIDly5c7l6mqyooVK2jatKnzpsBoNPLbb7/RrVs3fH19MRgMzle9evWIi4tjy5YtbmW566673J6GFNT+//LLL0Wem6qUnp7u0r/AaDSSnX0hYMnPz3f7EF7a9+LS98nJyY4mDJKH5FET8sjLA8NlRr45l3n5NKKcXC6wKd6dQJrJUZNfZJo8L//blTyqLI/K5K0ddO12OwEBAR7Xp6SkOEfqKa0yTarVokULevfu7WyWcsUVV5SpMBeLi4tzeR8S4pgspV69em5pg4ODCx0Ws6QmTpzI4sWLeeeddwC44447Ck33/fffY7fbufrqq11uMjp27MiGDRvYvHkz3bt395jPAw88wIoVK/jggw+YO3dumcsNsGjRIpYsWcLRo0fdRmy4+MMaEBBA7969WblyJRkZGYSHh7N9+3aSkpJ48sknnekSExOx2+0sX77c5cbgYvXr13dbFh8f77Zs2LBhbNy4kTfffJMPPviAq6++muuuu47evXsX2vG5Klz8xAFwa57k4+NDZGSky7JLn2Zd+v7S0ZskD8nD6/OYNAyen++yDp0GrHbodAUM6AQvD4NJ3yAqmHq5YN5zwKNVwKbCVVEwpJmCwazhqQ12VECnODoFaxTHZF/t68LApgpBPl7+tyt5VEke4vLat2/PqlWrGD9+vNs6q9XKN998Q5cuXcqUR5ln0B03bhw///wzH3zwAdOnTy/RtjabexvNAhpN4Q8dPC1XL/vFd3lhYWF8/PHHjBs3jnfeeQe73c5dd93lls/KlSsBeOSRRwrdz4oVK4oM9sPCwrjnnnuYOXPmZUfwKY558+Yxbdo0unTpwh133EGdOnXQ6/WkpKQwefJkt+B/0KBBLFu2jFWrVjFixAiWL1+Oj48Pffv2ddv3Lbfc4uyXcKnC7jQL68wcFhbGl19+yc6dO9myZQs7d+5k6tSpzJo1i/fff5+rrrqqlEcuhKhU/xkMw653dKL104MpH6JC4HQGtIwDH70j2L/zBscNgJ8eVu6ExwtGbnO0PfHUDL786uPKsWavulYSlqJcCtCjocLc/hqScxSujAQ/ncITHRUGNlUwWSHKH5KMEB2gkmJSuDICfHXV9SQIcYG31egX+M9//sOtt97KuHHjnJXMZ8+eZd26dbz++uvs37/f2feytMoc7NevX58hQ4bw9ddfe5zVNTQ0lMzMTLflZW2DVBHCwsKYOXMm48aNY+rUqaiqyt133+1cv23bNpKSkrjzzju5+uqr3bb/6aef2LRpE2lpaW53wBe7++67WbRoETNnzuSee+4pU5l/+OEH6tWrx/Tp011uhn7//fdC07ds2dI5etCAAQP45Zdf6N69O6Ghoc40cXFxKIqC1Wqlc+fOZSofgFardU7IBnDo0CFGjBjBZ599xvvvv1/m/QshKkmTGPdl0WGu76+46Ansfd1RMkyoB5PhbBbk5aP46+FYCoQHwvFUUALAmAUmc6naoZfYpUGBVwYJrmX20zna5UYHOh62aDVQPwhScuGKCDDkKXSIVbi9hYbYIA2xrpW2NA67sL/oQMf+65fPEN9CVAq7N36McVSqfvHFFzz++OPMnj0bgBEjRqCqKiEhIXz55Zd069atTHmUOdiHC81SPNXsx8fHs2fPHvLy8pw1v1lZWaxYsaI8si9UcnIyeXl5xMXFeRxRx5OCgH/8+PG89957qKrKiBEjAMfY+lqtlvvvv7/QJijh4eGsX7+eVatWFRnE+/n5MXr0aF5//XWPsxEXl1arRVEUl6cbVquVL774wuM2gwYN4s033+Stt97CbDYzcOBAl/VhYWFcf/31/PLLL+zZs4c2bdq4rFdVFYPBUKxmOAaDwW141oSEBPz8/MjKyrrs9kII76UE+8OkQcWriFZVSMmEvw7Dv0nwyx7YdhjOyfdEAb0GbkqAhiEaejZSaB2t0CRcwUfrpZGOEOXEW2v2AUaOHMntt9/OmjVrOHz4MHa7nSZNmtC7d+9ymVirXIL9sLAwRo4cyccff1zo+mHDhvHSSy8xduxY+vbtS3Z2Nt999x2xsbGF9jwuDy+//DI7duxwjppTUmFhYcyYMYPx48czbdo07HY7gwYNYv369bRt29ZjkNuuXTsiIiJYsWLFZWvsBwwYwPz589m3b1+Jy3ex//u//+PDDz/kscce46abbiInJ4effvqpyJucPn368P7777N69Wrq16/v7Mx7seeee44HH3yQhx56iH79+tG8eXPsdjtJSUls2rSJvn37uo3GU5hXX32Vc+fO0blzZ2JjYzGbzaxdu5acnBz69etXpmMXQtQgiuJ4StCvo+P15PnRwc4Z4O3lsGYX7D5ehQWsGoF6GNBMYVwHLdfHKUUOICFEbVXYoL7V1fPPP88dd9zh0ow5MDCQQYMGVUh+5TaW1ogRI6hTp06h62655RYee+wxUlNTee+991i9ejUPPvgggwcPLq/sK0RBDX/z5s2ZPn06X3/9NWazmZtuusnjNhqNhu7du5OYmMjff/9d5P61Wq3Hdv8lMXLkSB5++GGSkpJ49913WbRoEZ07d2bKlCketwkKCqJnz56AY46Awi4eMTExzJs3jzvvvJOdO3cybdo0Pv74Y7Zu3UrXrl2d219O3759iYyMZNWqVbz99tt89tln6HQ6/ve//zFkyJDSHbQQovaIDoO3R8Hf78G+96Hn1V7a9KZkogNg8WAdhid1zB+o54YGGgn0hfDAm0bjefPNN11GSkxLS0Or1fLLL79USH6KWh49W4VXevPNN1m2bBkrVqxwGUdfCCGqvSPJMPRt1J2JWIgiH19yCXGu/u7qzqQFBbG5RVOOhQewLzq4lDcIpZhVK99epr4HQXqY1VfLna0kuBeiuEbfedD58+yvy2fS0oqi0WiYN2+ecxCYtLQ0oqKiWLduHTfffHP551fuexRewWg0snr1aq677joJ9IUQ3qdJDOx4F9ZNgmB9VZemXGiA0e00pD6h567WWgn0hSgBu6I4X8JVubTZF97j8OHDHDhwgFWrVpGbm8t9991X1UUSQohSU/7vKvQpU7GPXwRz9ld1cUotPgTW3qWnWaQEKkKUhjc036kqEuzXMj///DOffPIJ0dHRPPvsszLGvRDC6ym+evw+uwvtw6cx9JqLmpZb1UUqkWk9tTx6jQaNBCtClJq3Db2ZmJjIjh07AJzD0x86dMht9MIC7du3L3Ve0mZfCCFEjaGarRj/u55Fy3M5Gxpardvst6oDS4foaBYpLWqFKKt7Rxxx/vzFvCZVWJLL02jc++Ooqlpo072C5UVNRHs5UrMvhBCixlB8dQS/2pN+/ZJZ8VH1HKbTRwMvd9Xw3HUatB5mhRdClIw3tdX//PPPKzU/CfaFEELUOHWvjeGBTnWJXJrGm7uoNkN1Dr8S/ttdxxVSmy9EufKmYH/UqFGVmp8E+0IIIWokjVbh9qF1uLmvjRk7VN7YAUZL1ZTl7lYwpr2OrvES5AtREbytzX5lkmBfCCFEjRYWqOX5rvDcDSp/nIZJm22cyYH9aYU3rffXOVrpxweDTgPazOO00yZibdyNc7kKB9IhzwY5FsfLbR8aCNdD4zC49yotI9toCPWTSESIiuRNM+hWNgn2hRBC1AoaReH6+rBu2IVLX7bZTqrJEdwH+0KYr4JWcyFosFgsfP75zwDc16sber3rZVNVVXItkGJS0SmgUSAmSCsj6whRyWToTc8k2BdCCFFrBftqCPYt/faKohDoA4E+EmgIUZWkGY9nEuwLIYQQQgiv5k0ddCubBPtCCCGEEMKrSZt9zyTYF0IIIYQQXs0msb5HEuwLIYQQQgivJs14PJNgXwghhBBCeDXpoOuZBPtCCCGEEMKrSZt9zyTYF0IIIYQQXs0mzXg8kmBfCCGEEEJ4NWnG45kE+0IIIYQQwqvZpBmPRxLsCyGEEEIIryZDb3qmqeoCCCGEEEIIISqG1OwLIYQQJWQ1Wcj6/ji2k9kYNybh17YOltR86oxuiX/rCBSt1KUJUZlknH3PJNgXQgghikG12Un59hCJr/5N/pFMgiy5znUZK49jVbUkz9gHOoW6T1xF9IMt8b8itApLLETtIaPxeCZVD0IIIUQRNHkqdVfY+Tv8Sw6P+IWcf7NQLTbXRKp64WerStI7e9jSbAmHn9iCxWCu3AILUQtZL3oJVxLsCyGEEIWwnMkh6bHNtJlgJ3YVqHm2y290nmp3/H9q2j/8HrWAs98cRb34hkAIUa5siuJ8CVfSjEcIIYQ4T1VVMlcmkjZnP5nLE1EBpdT1YiqoCqpV5Z87N3Dotd1cs7Y3vjH+5VlkIQRglRjfIwn2hRBC1GqqzU7uH2dIfW0rpl0p5CZbKe8hu20aDdkHstnY6juaPt+Gxk+2Lt8MhKjlrDLOvkcS7AshhKhVrDkWjDvSSJ61H9vZXNRfjqCxO9rdOP71gQpqcWPLtnLgPzvJ+COFVh90xi82oGIyEqKWsUis75EE+0IIIWo0y7FMTFvPcPLDfzGmWDEdyAJU9NhRUAk7H+JXpnMrT3Hu+ySufKcD8WObo9FJFzohysIibfU9km+Xyxg9ejS33XZbsdJu27aNjh07snLlymKlv+222xg9enRZilcpSnpcQghRlVSbHeOvpznVZzGnrpjJscafkHzHKlJ+Szsf6FcDKmBX2f/ENn6ut4gz3yai2ir/pkOImsJy0Uu4qjXBfkHA+tVXX3lM07FjRyZMmFB5hRJCCFEubBY7BxccZeujf7Il+DMOdvsOy08HsR3OqOqiXZbVkM+uEb+yru63HHlrDzlHs6u6SEJ4nVxFcb6EK2nGcxkfffRRrR8urX379mzevBmdTv5chBDVh8VsI/HvbLZ9fICc3akEJxnRqioN87xzpG1rloWDL+7i4Iu7CLwylLAOkdQf1YSQtuHoQ32runhCVGsmifE9kujtMvR6fVUXocppNBp8feVCI4SoeicNdhZvzMFwOBfTr2cIzMsn8nQqOtv5MfBrSN1Mzv5McvZnkjTvKAC6CB8CGgYR3DoM/8bBhHWMJKBZCAEJQShSkykE+TIaj0cS7F/G6NGjOXPmjFt79Q0bNjB79mwSExMJDw/n1ltvpV27doXuIzk5mWnTpvHHH38AjpryJ5980mOeW7Zs4csvv+Sff/4hPz+f+Ph4hgwZwpAhQ1zS3XbbbcTGxvL888/z3nvvsXPnThRFoXPnzjzzzDPUqVPnssd35MgRZs+eze7duzEYDISEhJCQkMDIkSO54YYbAEcTqLFjxzJp0iRn/4XbbruNM2fOFLrP9u3bM3v2bOf7ffv2MWfOHHbu3Elubi6xsbH069ePUaNGydMCIYRHmXl29qWqLN1v599zNjYespCda+fmjGwirDaaWh0BfkGsW5Mv9db0fLLS08name66QgM+0X74Nwgk+KpwgluFE9YpkpC2EWh8tFVTWCGqQk3+AiijWhdp5eXlYTAYyrSP9evX88wzz1CvXj0efPBBtFotK1eu5LfffnNLm52dzejRozl79iy33347jRs3ZseOHYwZMwaz2X0K9aVLl/LGG2/Qpk0b7r//fvz9/dmyZQtvvvkmSUlJPP744y7pU1JSGDNmDDfeeCOPPfYYhw4dYunSpeTk5PDRRx8VeRwGg4Fx48YBMHjwYGJiYjAYDOzfv5+9e/c6g/3CPPnkk+Tm5ros27t3L99++y2RkZHOZb/99htPP/00DRo0YMSIEYSEhLBnzx5mzZrFwYMH+d///ldkGYUQ5efT3XY2nbRz0gjJOdC1PrSMVNiTCrc2URh0xUXduL7fBsu2wNUJ8Ghflh1W+f6ISoe6CjfHw/s7VIJ94PnOGsL83K+yiZkqb/9lx1cL/+msISqg8Cuxqqq8+5edr/arxAbCm101vLPNzrcHwGK2O8bCzLc6auzNjg6sl+5JveT/6ufiEipF/O+ayn0fF9I609ghPzmP/GQThr/SLmynUcgZ2YrG9zam/fWhJS/y5v3wxXpoGAXPDAQfecotqjl5wuVRrQv2Z82axaxZs0q9vc1m45133iEkJIS5c+cSFhYGOILlO+64wy39l19+yenTp3n55Zfp378/AEOHDuXdd9/l66+/dkmbmprKO++8Q69evXjttdecy4cOHco777zD/PnzGTx4MHFxcc51J0+e5I033qBnz57OZRqNhkWLFpGYmEhCQoLHY/n7779JT0932744brzxRpf3p0+fZtq0acTFxfHss88CYDab+e9//0vr1q2ZOXOmsxZ/8ODBXHHFFbz33nvOjtNCiIo1Z4+dh9a4jvbybzoUBKKf71VZNwxujtfA7//CgDfh/Njzh8/mMzj8NlRgzl6VEB/Iynfs4+8UOz8Nca1BtthUblpoI/H8wDe/n7bx592FX27e267y9CZHGXanwIaTdsy2Eh5c9Y3yXV0m1ldRUTxVTxZ+XwCq6ghyLvznSGZXOf1nGr+l++Dnp6Flh+Dil/NoMvScAqbzv+SzBvjgoZIcqRCiGqk1o/EUGDRoEB999FGhr+LYv38/Z8+epX///s5AHyAoKIjBgwe7pd+wYQORkZH069fPZfmoUaPc0q5bt478/HwGDBiAwWBweXXt2hW73c7WrVtdtomKinIL1AuC55MnTxZ5LEFBQQD8/vvvGI3GItMWxWg0MmHCBCwWC9OmTXOely1btpCWlsZtt92G0Wh0OZ7rr7/emaY6SE9Pd3nSYjQayc6+MCJGfn4+aWlpLttc2ozp0vfJyckunbslD8mjKvPYmlx0RKwCf53PKuuXnc5AH8C8+V+XeLog0AfYekZ1O44UE85AH2BbMpw+XfhxbD3jWq4SB/o1SHnUSyrnf1PqRTs7fthUsr+rPScuBPoAWw7V+M+H5FExeVQqRbnwEi5qXc1+fHw8nTt3LvX2SUlJADRs2NBtXaNGjQpN37JlS7Ra15qvOnXqEBzsWtOSmJgIwPjx4z3mn57u2l6zfv36bmlCQx2PbDMzMz3uB6BDhw7069ePlStXsnr1alq2bEnnzp3p2bMnjRs3LnLbAlarlWeffZYTJ07wwQcfuDxJOHbsGACvvPKKx+0v/eKoKhERES7vC26ECvj4+Lg0TwKIjY0t8n1MTIzkIXlUmzz6JNiZ9bfngF+vgR4NHRfJkAHXwWvLIc8R8AUO7ISPCvnnA/HYQDiT4/j5lkaK23HUDYB20bDznON97wSFevUKP45bGiksPHChXGG+YHBv4VgrFFGvX+p9aLTQ/OogYi+ZqbfIv6tOTSEyGNLOB3p929f4z4fkUTF5VCqJ8T2qdcF+dVZwhz1lyhSPnWsvDe41Gs8PZ4ozZOiUKVMYOXIkv//+Ozt37mTevHnMmTOHJ554guHDh192+//9739s2bKFF198kWuuuabQ/B9//HGaNWtW6PZRUVGXzUMIUXYDr9Cwdij8nqRyNheOGKB3AjSLUNh51hGQd4g5f7Vs0xB+fx1+2AFXJ5Bwa0d+O6Oy5rhKh7rQoa7C5+eb8zzQxv0Kq9Uo/DJMy6d7VHy18NBVnq/Co1prCPdT+XwvxAU72vff+b2NTadKcHDecpFXLv3ftWdxkYdx6TZc8v6SfWgUaNYmkNsmNaJRc9dA/7JiI+DPN+HbzZAQDXd1K9n2QlQJb/kiqHwS7JdQQbB9/Phxt3UFNdmXpj958iQ2m82ldj81NdXl8RhAgwYNAAgLCyvT04eSatq0KU2bNuWee+4hOzubUaNG8eGHHzJs2LAih3T78ssvWbZsGffccw8DBw50Wx8fHw+Av79/pR6PEKJwPRpq6OH+UJJ+hT3Ia9fY8TrvmliFa2IvfB8806noC2uYn8JT1xTv4tu/qZb+TS+8f/oaDVrFzp8nwVSMWv5LY+jqxy3K97C+8LXFS+O6xDc2gKvub0idkgb6BZrGwvNDLp9OiOqi+n4BVLla12a/rK688krq1q3LihUrXEb1MRqNLFmyxC199+7dSUtLY9WqVS7L586d65a2Z8+e+Pj4MGvWLPLy8tzWG41G8vPz3ZaXVmZmJna7a4e94OBg6tevT15eXqGjBRVYv349H3zwATfddBOPPvpooWmuvfZaIiIi+OKLLwptUpSXl0dOTk7ZDkIIUePc2kTDL8N15D7lw7kJej4b6MPE63Q0rqNFr4Fa3KzflVZBF+FD6DWRxA5LoPkb7en0c096pAzj5mODqdOjXlWXUIjKo1z0Ei6kZr+EtFotEydO5D//+Q+jRo1i4MCBaLVaVqxYQWhoKMnJyS7p77nnHn788Udee+019u/fT5MmTdi+fTu7d+926eALULduXZ577jleffVVhg4dSt++fYmNjSUjI4PDhw+zYcMGFi1aRL165fMFvmrVKhYsWMBNN91EXFwcOp2OHTt28Mcff9CzZ0/8/PwK3c5gMPDSSy/h5+fHtddey+rVq13WR0RE0KVLF/z9/ZkyZQpPPfUUgwcPpn///jRo0IDs7GwSExNZv349b7/9tozGI4TwKCpQ4f52jkvV1D4+mK0qP+304cwBEydWZUGGiYIWi94yKE9Jafy1BLUIwb9hEKEd6xDQJJjQTpH41QtAo5U6OyEcJMr3RIL9UujRowcajYZPP/2U2bNnExER4ZxU65FHHnFJGxISwqeffsrUqVP54YcfAMekU7NmzXKOcX+x/v37Ex8fz7x581i6dCnZ2dmEhYXRsGFDxo0b59Y5piw6dOjAgQMH+PXXX0lNTUWr1VKvXj0mTJjAsGHDPG6Xm5vrfPLw+uuvu61v3749Xbp0ARy1+3PnzmXu3LmsXr2ajIwMQkJCiIuL4+677+aKK64ot+MRQtR8vjqF/tf4wzX+MCKClBMmtn5ymMxt51AzTDXieq/oFaJ61yP0mijqj2iMf4PAqi6SENVfDfjsVxRFLU4vTiGEEKKaS9mZRsqGZLL/tw392RzCMaBRwKz6AAqnCeNCRKCix46CShgXJgi0A/n4ON+rgO2iFq82FMzo0WElGLPLcutF9WcWNFjQOvOzaDRYLxmV7VL+jYNo8UYHovrVRyuz3wpRIsqzF/pBqv8rwbwStYDU7AshhKgRotpFEtUuEia2Iv+UkYz/bUE9lEL+2iRU++W3ryoBTYO5eu4NhF1T+ChsQohikJp9jyTYF0IIUeP4xAVR94P/A6Cu1Y551zl0H+3DmGohY80Z1IJJAwpmpa1sCmgDdbT9qivR/eIun14IUTQJ9j2SYF8IIUSNpug0+HWMofHnFyYRyjuVw7mvDpF/MhvzvL0o2ZU0k9f5m4tGE1tyxaSr0frLZViI8iHRvifSZl8IIUStl5+UTfq7O8j9/QyGLWkUBA7l3WbfPyGQltM6Ed1XavOFKE/Kf4zOn9U3gopIWftIlYIQQohaz6d+MDFTuwNgPp5Fyvt7OPfBbrCWT32YVrUT0bM+bRfdhDZALr1ClDup2PdIBugVQgghLuLbMIS4qdfTNvshYt/ugs23tAG/I/rQhurpsPlWOqzqKYG+EBVFUS68hAv51hFCCCEKofHTEfV4G74P+ovwrSpNfvTHdsZ9dvNCt0VF0ULT97sQO7oFGr3UrQkhqoYE+0IIIURRNAoZXRTazLqLvJ0ZJE7eQe7OVEguvFOvNsyHhLe6EHn3FWgD9JVcWCFqKanQ90iCfSGEEKKYgjtF0+aHPqiqSv6xLPL2p5Oz6TR+bSKxGq1E3HEFujDfqi6mELWQRPueSLAvhBBClJCiKPg2DsW3cSih/RpVdXGEEBLreyTBvhBCCCGE8G4S7Hskwb4QQgghhPByEu17IsG+EEIIIYTwbhLreyRjgQkhhBBCCFFDSc2+EEIIIYTwblKz75EE+0IIIYQQwrvJzLkeSTMeIYQQQgghaiip2RdCCCGEEN5NKvY9kmBfCCGEEEJ4OYn2PZFgXwghhBBCeDeJ9T2SNvtCCCGEEELUUFKzL4QQQgghvJvU7HskNftCCCGEEELUUFKzL4QQQgghvJuMs++RBPtCCCGEEMK7SazvkTTjEUIIIYQQooaSmn0hhBBCCOHdpGbfIwn2hRBCCCGEl5No3xMJ9oUQQgghhHeTWN8jabMvhBBCCCFEDSU1+0IIIYQQwrtJzb5HUrMvhBBCCCFqhcmTJxMUFFTVxahUEuwLIYQQQghRQ0kzHiGEEEII4d2kGY9HUrMvhBBCCCEEsGfPHnr37k1gYCChoaEMGTKEEydOONc/8MADdO3a1fk+NTUVjUbDNddc41xmNBrR6/UsWrSoUsvuiQT7QgghhBDCuynKhVcpnTx5km7dupGWlsa8efP4+OOP2bFjB927dyc7OxuAbt268ddff5GXlwfApk2b8PX1ZefOnc40v//+O1arlW7dupX9uMqBNOMRtZ6qqs4PqBBCXMxisWAymQDIyspCr9dXcYmE8A7BwcEoZQi8S6wcsnrvvfewWCysWbOGiIgIANq1a0fLli354osvePTRR+nWrRtms5ktW7bQvXt3Nm3axKBBg1izZg2bN2+mT58+bNq0iWbNmlG3bt2yF6ocSLAvar3s7GxCQ0OruhhCiGpuwoQJVV0EIbxGZmYmISEhlZaf+lTZQ9pff/2Vm2++2RnoA7Ro0YKrr76a3377jUcffZRGjRoRFxfHpk2bnMH+2LFjMZlMbNy40RnsV5dafZBgXwiCg4PJzMys6mJcltFopF+/fqxatarWDRtWEnKeik/OVfHIeSo+OVfFUxvOU3BwcFUXocQyMjJo27at2/K6deuSnp7ufF8Q5GdlZfH333/TrVs3cnJyWLx4MWazma1bt/LQQw9VYsmLJsG+qPUURanU2ofS0mg0aLVaQkJCauzFoTzIeSo+OVfFI+ep+ORcFY+cp+opIiKCc+fOuS0/e/YszZo1c77v1q0bTzzxBBs2bKBOnTq0aNGCnJwcnn32WdavX4/ZbHbpxFvVpIOuEEIIIYSo9W644QZ+/vlnMjIynMsOHDjA7t27ueGGG5zLCmryp06d6myu07ZtW/z9/XnzzTdp0KABCQkJlV18j6RmXwghhBBC1Bo2m43Fixe7LX/88cf5/PPP6dWrFy+88AJ5eXm8+OKLxMfHc++99zrTtWjRgujoaDZu3Mj06dMB0Gq1XH/99axevZq77767sg6lWCTYF8JL+Pj48NBDD+Hj41PVRanW5DwVn5yr4pHzVHxyropHzlPVysvLY+jQoW7Lv/rqKzZu3MhTTz3F3XffjVarpWfPnkydOtWtD0K3bt1YvHixS0fc7t27s3r16mrVORdAUVVVrepCCCGEEEIIIcqftNkXQgghhBCihpJgXwghhBBCiBpK2uwLUY1t2rSJmTNncvz4cWJiYrj33nvp379/kducOnWKd955h4MHD2IwGAgJCeHqq69m/PjxNGzYsJJKXrlKc57++ecfFi9ezM6dO0lJSSE6Opr/+7//44EHHsDf37+SSl75SnOuLBYLM2bMYO/evezfv5+8vDzWrVtHWFhY5RS6AiUmJvLWW2+xe/duAgMD6du3L+PHj7/sTLmqqjJ37lwWLVqEwWCgWbNmPPHEE7Rp06aSSl75SnuuFi1axObNm9m7dy8Gg4E333yTHj16VFKpK19pzlNqairz589ny5YtnDp1iqCgINq1a8cjjzxCbGxsJZZe1ERSsy9ENbVr1y6efvpp2rRpw/Tp0+nZsyf//e9/WbduXZHbmUwmIiMjefjhh5k+fToTJkzg+PHjjB07FoPBUDmFr0SlPU9r167l5MmT3HPPPbz//vvceeedLFu2jIkTJ1ZSyStfac9VXl4e3333HT4+PrRr166SSlvxsrKyGDt2LFarlbfffpvx48ezbNkypk6detlt586dy6xZs7jrrrt47733qFOnDo888ginTp2qhJJXvrKcq1WrVmEwGLj++usroaRVq7Tnaf/+/axfv54ePXrw7rvvMnHiRA4fPsyoUaNchoEUolRUIUS19PDDD6v33Xefy7Lnn39eHTJkSIn3dfz4cbVDhw7q6tWry6t41UZpz1N6errbstWrV6sdOnRQ9+3bV65lrC7K8jdlt9tVVVXVFStWqB06dFAzMjIqooiVas6cOeoNN9ygGgwG57IlS5aonTp1Us+dO+dxu7y8PLVbt27qhx9+6FyWn5+v3nrrreobb7xRoWWuKqU9V6qqqjabTVVVVU1KSlI7dOigrl27tkLLWpVKe56ysrJUi8Xisiw5OVnt2LGj+tVXX1VYeUXtIDX7QlRD+fn5bNu2ze1Rd69evTh27BinT58u0f5CQ0MBR3OMmqQs5yk8PNxtWfPmzQFISUkp34JWA2X9m1IUpSKLVyV+//13OnXq5Px8APTs2RO73c6ff/7pcbvdu3eTk5Pjci71ej033XQTmzdvrtAyV5XSnitwzBZbW5T2PAUHB6PTubasrlu3LuHh4TXy+0hUrtrzCRTCi5w6dQqr1eo2A1+jRo0AR5vQy7Hb7VitVk6fPs1bb71F3bp1uemmmyqgtFWnPM7TxXbt2gVQrWY+LC/lfa5qgsTERLfzERwcTJ06dYo8HwXrCjuXycnJ5OXllW9Bq4HSnqvapjzP0/Hjx0lPT3d+RoUoLemgK0Q1lJWVBeA2iUdISIjL+qJMmjSJ1atXAxAXF8eMGTMICgoq55JWrfI4TwUMBgOzZ8+me/fuxMfHl18hq4nyPFc1RVZWltv5AMc5Kup8ZGVl4ePjg6+vr9t2qqqSnZ2Nn59fuZe3KpX2XNU25XWeVFXlnXfeISoqit69e5dnEUUtJMG+EJXEaDSSmpp62XT169cvl/zGjh3LHXfcQXJyMl9//TXjx4/ns88+IyYmplz2X1Eq+zwBWK1Wnn/+eQD+85//lNt+K1pVnCshRMWbPXs2W7du5YMPPqjRo4OJyiHBvhCVZN26dbz66quXTbd48WJnbavRaHRZV1AzVLC+KPXr16d+/fq0atWK66+/nkGDBjF37lyeffbZUpS+8lT2eVJVlSlTpvDPP//wySefUKdOnVKUumpU9rmqaUJCQtzOB0B2dnaR5yMkJIT8/HzMZrNL7X52djaKohRas+vtSnuuapvyOE/Lli3jk08+4aWXXqJTp07lXURRC0mwL0QlGThwIAMHDixW2vz8fHQ6HYmJiVx77bXO5Z7aCl+On58fjRo18ophASv7PE2bNo1169bx/vvv06xZs1KUuOpU5d9UTZCQkODWjrrgaUlR56Ng3fHjx13+ZhITE4mJialxTXig9OeqtinreVq/fj1vvvkmY8eOZcCAARVTSFHrSAddIaohHx8fOnbsyM8//+yyfO3atTRq1Ih69eqVaH9Go5FDhw7VuOYcZT1PX3zxBQsWLGDSpEk1vgatvP+maoLrrruOrVu3kp2d7Vy2bt06NBoNXbp08bjdVVddRWBgoMv8BFarlfXr19fYseRLe65qm7Kcp23btvHCCy8wcOBAHnzwwYouqqhFpGZfiGrqwQcfZMyYMc7ZJrdv386PP/7IG2+84ZKuc+fO9OvXj5dffhmAWbNmYTQaufrqqwkPD+fMmTN888035Ofnc+edd1bFoVSo0p6nH3/8kQ8//JBbbrmF+vXrs2fPHmfauLi4Qofm9HalPVcAmzdvxmQysW/fPsAxE29AQACNGzemcePGlXoc5WXw4MEsXLiQJ598kvvvv59z587x/vvvc/vttxMVFeVMN27cOM6cOcN3330HgK+vL/fddx+zZ88mPDycpk2bsmjRIjIzMxkxYkQVHU3FKu25Ati3bx+nT592Tuq3d+9ewDH8bYcOHSrzMCpcac/TsWPHeOqpp2jQoAF9+/Z1+T4KDw8nLi6usg9F1CAS7AtRTbVt25a33nqLmTNnsnz5cmJiYnjxxRfdxkm32WzY7Xbn+xYtWjB//nx++OEHTCYTUVFRtG/fnjfffLNGXjBKe54KxrxevXq1c9SiApMmTeK2226r+MJXstKeK4A333yTM2fOON+/8sorADz00EOMGTOm4gtfAUJCQpg5cyZvv/02Tz75JIGBgQwcOJDx48e7pLPZbNhsNpdlo0aNQlVV5s2bR0ZGBs2aNeODDz6okZ8xKNu5+vbbb/n++++d7+fNmwdA+/btmT17dsUXvhKV9jzt3bsXo9GI0WjkgQcecEl76623Mnny5MoovqihFFVV1aouhBBCCCGEEKL8SZt9IYQQQgghaigJ9oUQQgghhKihJNgXQgghhBCihpJgXwghhBBCiBpKgn0hhBBCCCFqKAn2hRBCCCGEqKEk2BdCCCGEEKKGkmBfCCGEEEKIGkqCfSGEKKV7770XRVGquhiAYwZOnU7H2rVrncs2bNiAoih88cUXVVcwUS188cUXKIrChg0bSrW9/C0VbteuXWg0GjZu3FjVRRHCIwn2hRAujh49yujRo2nRogUBAQGEh4dz5ZVXMmrUKNavX++SNiEhgdatW3vcV0EwnJqaWuj6/fv3oygKiqLw66+/etxPQZqCl5+fH1dccQVPPPEE6enppTvQGuaJJ57g+uuvp2fPnlVdlEqRmJjI5MmT2bVrV1UXRVQSg8HA5MmTS33DUlpF/a21bduWgQMH8uSTT6KqaqWWS4ji0lV1AYQQ1ce2bdvo3r07er2ee+65h1atWmEymTh06BBr1qwhODiYm266qdzy++yzzwgODsbf3585c+bQtWtXj2nbtm3Lk08+CUB6ejo//PAD7733HmvXrmX79u34+PiUW7m8zR9//MHatWv57rvvXJZ369YNk8mEXq+vmoJVoMTERKZMmUJCQgJt27at6uKISmAwGJgyZQoAN954Y6Xle7m/tQkTJtC9e3d++OEH+vXrV2nlEqK4JNgXQjhNmTKF3Nxcdu3axdVXX+22Pjk5udzyslgsfPXVVwwdOpTQ0FBmz57N9OnTCQ4OLjR9/fr1GTFihPP9Y489xm233cb333/P8uXLGTp0aLmVzdvMmDGDOnXq0LdvX5flGo0GPz+/KiqVELVD165dSUhI4OOPP5ZgX1RL0oxHCOF06NAhIiMjCw30AWJiYsotr5UrV3Lu3DlGjRrFvffeS05ODgsXLizRPnr37g3A4cOHPaaZOXMmiqKwYsUKt3V2u524uDiX2ro1a9YwfPhwGjdujL+/P2FhYfTq1avYbXJvvPFGEhIS3JYnJiaiKAqTJ092Wa6qKjNnzqRDhw4EBAQQFBTETTfd5NZkyhOr1cp3331Hjx493GrwC2tnffGyGTNm0Lx5c/z8/GjTpg3ff/89AHv27KFPnz6EhIQQGRnJY489hsViKfQ4jx49yoABAwgNDSUkJIRBgwZx9OhRl7R2u53XXnuNbt26ERMTg4+PD/Hx8YwbN460tLRCj2vJkiXceOONhIWFERAQQPPmzXnsscfIz8/niy++cD5huu+++5zNu4pT25uYmMjIkSOpW7cuvr6+NGnShOeff57c3FyXdJMnT0ZRFA4cOMDzzz9PXFwcvr6+XH311fzwww+XzQcutJP/+eefeeWVV2jYsCH+/v507tyZP//8E4CNGzdyww03EBgYSGxsLP/9738L3dd3333H9ddfT2BgIEFBQVx//fUsX7680LSffPIJLVq0wNfXl6ZNmzJt2jSPTUwyMzN59tlnadq0Kb6+vkRFRXHnnXe6/Q5Lqrjnuah+L4qicO+99wKOv9tGjRoBjkqJgt95wWft4s/X119/zVVXXYWfnx/x8fFMnjwZq9Xqsu/ifk6L87emKAq9e/fmxx9/xGg0lvBMCVHxpGZfCOHUpEkTDhw4wNKlS7n99tuLtY3NZvPYJt9sNnvc7rPPPqNRo0Z07doVRVFo164dc+bM4cEHHyx2eQ8dOgRAnTp1PKa54447mDhxIl9++SX9+/d3Wffzzz+TlJTkbB4Ejot7eno699xzD3FxcSQlJfHpp5/yf//3f6xfv77IpkalMXLkSL7++muGDBnCfffdh9lsZv78+fTs2ZOlS5e6lflS27dvx2g00qlTpxLl+9FHH5GRkcGDDz6In58f06dPZ9CgQSxatIiHHnqIO++8k4EDB7JmzRo++OADoqOjefHFF132kZOTw4033kjnzp154403OHToEDNmzODPP/9k586dzpvD/Px83n77bQYPHsyAAQMIDAzkr7/+4rPPPuO3335za4b1wgsv8Prrr9OyZUsmTpxIbGwsR44cYcmSJbzyyit069aN559/ntdff53Ro0c7fyd169Yt8piPHz9Op06dyMzMZPz48VxxxRVs2LCBN954g82bN/Pzzz+j07leFkeNGoVer+epp54iPz+fadOmMXDgQA4ePFhosFiY5557DpvNxuOPP05+fj7vvvsuvXr14ssvv+SBBx5g9OjR3H333Xz77be8/PLLNGrUyOUp1owZM3j44Ydp0aIFL7/8MuD4Ox04cCCzZs1i9OjRzrTTpk1j4sSJXH311bz++uvk5ubyzjvvEB0d7VauzMxMrrvuOk6cOMH9999Pq1atOHPmDDNmzKBz585s27aNhg0bFusYy3qeL+fKK6/kvffeY+LEiQwaNMj5/RQUFOSSbsWKFRw9epSHH36YmJgYVqxYwZQpUzh+/Diff/55iY+luH9r1157LbNmzeK3336jT58+Jc5HiAqlCiHEeb///ruq1+tVQL3iiivU++67T50xY4a6b9++QtM3bNhQBS77SklJcdkuKSlJ1Wq16qRJk5zLpk2bpgKF5gWovXr1UlNSUtSUlBT14MGD6tSpU1W9Xq+GhoaqZ8+eLfK4hgwZovr6+qrp6ekuy0eMGKHqdDqX7Y1Go9v2ycnJamRkpHrLLbe4LB81apR66ddo9+7d1YYNG7rt49ixYyrgcsxLly5VAXXWrFkuaS0Wi9qhQwc1ISFBtdvtRR7bnDlzVEBdvny527r169ergPr555+7LatXr55qMBicy//++28VUBVFUZcsWeKyn/bt26sxMTFuxwmojz/+uMvygmMaM2aMc5ndbldzc3Pdyvfpp5+qgLpw4ULnsi1btqiAetNNN6kmk8klvd1ud56Pwo7tcu666y4VUFetWuWy/KmnnlIB9dNPP3UumzRpkgqo/fr1c/kdbN26VQXU55577rL5ff755yqgtmvXTjWbzc7ly5cvVwFVp9Opf/31l3O52WxWY2Ji1C5dujiXpaenq4GBgWqTJk3UzMxM5/LMzEy1cePGalBQkJqRkaGqqqpmZGSoAQEB6pVXXqnm5OQ40548eVINDAxUAXX9+vXO5Y899pjq5+en7tq1y6XciYmJanBwsDpq1CjnspKc75Kc58I+QwUAlzIU9hm6dJ1Go1G3b9/uXG6329WBAweqgPrHH384l5fkc1qcY//1119VQH3nnXc8phGiqkgzHiGE07XXXsv27dsZNWoUmZmZfP7554wfP56WLVvSrVu3Qh/tJyQksHbt2kJfvXr1KjSfL774Arvdzj333ONcdvfdd6PX65kzZ06h26xZs4aoqCiioqJo1qwZTzzxBC1btmTNmjWF1lpebNSoUZjNZpdmQkajkWXLltGnTx+X7QMDA13SpKWlodVq6dy5M1u2bCkyn5KaN28ewcHBDBw4kNTUVOfLYDBw2223kZiY6Hx64UlKSgoAERERJcr73nvvJTQ01Pn+qquuIiQkhHr16rk91bnhhhtITk4utInCc8895/J+0KBBNG/e3KWzsKIo+Pv7A44nQQaDgdTUVG6++WYAl/M6f/58AN544w23/gYFTShKw263s2LFCtq1a+fWt+E///kPGo2GZcuWuW33+OOPu+R5zTXXEBQUdNnfy8XGjRvn8uSioHa4c+fOdOzY0bncx8eHTp06uex77dq15OTk8NhjjxESEuJcHhISwmOPPYbRaGTdunWA4zOSm5vLww8/TEBAgDNtXFwcd999t0uZVFVl/vz5dOvWjfr167v8/QUGBtKlSxfWrFlT7GMsUNrzXF569uxJ+/btne8VReGZZ54BqNB8IyMjATh37lyF5SFEaUkzHiGEizZt2jjbeB8/fpyNGzfy6aef8uuvvzJgwAC3JheBgYH06NGj0H3NmzfPbZmqqsyZM4errroKu93u0t7++uuv56uvvuKNN95we8zfuXNnXn31VQB8fX1p2LAh8fHxxTqmgoD+yy+/ZOzYsYCjTXhOTo7LDQfAkSNHeOGFF/jpp58wGAwu68p7TP39+/eTnZ1dZPOTs2fP0qxZM4/rC8qklnDYv8aNG7stCw8Pp0GDBoUuB0hLS3NpNhEWFlZoP44rr7yS7777jpycHOfN07fffsu7777Lzp073dr/Z2RkOH8+dOgQiqJ47DdSWikpKRiNRlq1auW2LiIigtjY2EJvZgs7T5GRkR77GhTm0n0UnM+CNuiXrrt438eOHQMotNwFywrKXfB/ixYt3NK2bNnS5X1KSgppaWnOm+jCaDT/3969hzT5/XEAf+vWZnOLeVcwRNKV1TQrSpeVdPWPGi5FyWoSpIH+YWEkBRF0V5CKLlRglIYVLCvItOxihmSLMgnTTMuwtP4oKzPLcJ/vH7/fM5zbcrObjM8LRHZ2POd5zvbgOec55/M4Px840nb+XSIiIqzShHP/k/UK199oee4GY4NxZ58xZldISAj0ej3WrFmDuXPnora2FkajEXFxcSMu886dO2hrawMAhIeH28xz5coVJCYmWqT5+vraHVQMRywWIy0tDQcOHEBrayvCwsJQXFwMLy8vizXxX758wbx589Db24sNGzZArVZDoVDA3d0de/fuxa1bt4aty94/+6EbBIH/dRD8/PxQWlpqt7yfPccAgLmj5uzzBkQikVPpgPMDCkFZWRlSU1Mxa9YsHDx4EOPHj4eHhwcGBgaQkJAAk8lkkf9XZvB/N3vt4UxbjKSt/zTh+BctWoS8vLx/dhzOXC+juV7h+rM3cGLsX+LOPmNsWG5ubpg9ezZqa2vx5s2bXyrr5MmTkEqlKC4utjlzuH79ehQVFVl19n9Veno6Dhw4gOLiYmRkZKC6uhqZmZmQSqXmPDdv3kRnZydOnjyJtWvXWvz90M2p9nh7e+Phw4dW6bZmFcPDw9HS0oKYmBirjYaOEgYDziwr+V0+fvyIt2/fWs3uNzU1wd/f3zyrX1JSAg8PD9y+fdtieUlzc7NVmSqVChUVFWhoaPjppmNnBwN+fn5QKBRobGy0eq+7uxtdXV2jMl6/cFegsbERCxcutHjv6dOnFnmE383NzXbzCvz8/KBUKvH58+cRD6JtcbadheVnHz58sFiKZut6ceQzb2pqskob2k5CvY5ep47UK9yhHG5wzti/wGv2GWNmVVVVNme2+vr6zOt3hy4HcManT59gMBiwZMkSpKSkIDk52epHq9WioqICXV1dI67HlmnTpiEyMhJnzpxBSUkJTCYT0tPTLfIIM61DZ22vX7/u8Hp9lUqFnp4eGI1Gc5rJZML+/fut8ur1ephMJmzZssVmWe/evRu2vujoaIwbN84cyvFv27dvn8Xrixcv4tmzZxaDNZFIBDc3N4sZfCIyL8saLC0tDQCwdetW9Pf3W70vfDbC4MjROxru7u5Yvnw56uvrUVlZaXUOJpMJOp3OobL+psWLF8PT0xOHDh1CT0+POb2npweHDh2CXC43PzV58eLFGDt2LI4cOWIR4vL169dWd4/c3d2xatUqGI1GGAwGm3WPZP25s+0sLFET9h0ICgsLrcp25DOvqqrCo0ePzK+JCAUFBQBg8Z105jp1pN66ujqIxWLMmTPHbh7G/hWe2WeMmW3cuBHv37+HVquFWq2GTCZDR0cHSktL0dLSAr1eD7VaPeLyz549i76+PiQlJdnNk5SUhFOnTuH06dNWmz9/VXp6OnJzc5Gfnw+VSoWYmBiL9+Pi4hAYGIjc3Fy0t7cjODgYjx8/RklJCdRqNZ48eTJsHZmZmSgsLIROp0NOTg4kEgkMBoPNQZQQbvPw4cN49OgRli1bBl9fX7x+/Rr37t1Da2vrsOuMRSIRVqxYgUuXLuH79+8Wdyr+NF9fX5SVlaGzsxPx8fHm0JsBAQEWzxNITk7GhQsXsGDBAuj1evz48QOXLl2yirkOALNmzUJeXh7y8/Mxffp0pKamIjAwEC9fvoTBYIDRaIRSqcTkyZOhUChw9OhRyGQyKJVK+Pv7mzf92rJnzx5UVVUhMTERWVlZCAsLQ01NDc6fP4958+ZZDf5GA6VSiYKCAmRnZ2P27NnmuPOnTp1Ca2srjh8/bt5o7eXlhZ07d2LTpk3QaDTQ6/X4+vUrjh07hvDwcNTX11uUvXv3btTW1iIlJQUpKSmIiYmBRCLBq1evcPXqVcyYMcPiGQ2OcqadV65cia1btyIzMxPNzc3w9vZGZWWlzXC+Pj4+CAsLw7lz5zBhwgQEBATA09MTy5cvN+eJiorCggULkJ2djaCgIFy+fBk3btzAmjVrEBsba87nzHU63HeNiFBZWYmEhIQR36Fj7I/6JzGAGGOj0rVr1ygrK4siIyPJx8eHRCIReXt7U3x8PBUVFdHAwIBF/pCQEJoyZYrd8oSwekLozZkzZ5JYLLYKgTnYt2/fSKFQkEqlMqfh/yEQf9Xbt29JLBYTANq1a5fNPA0NDbR06VJSKpUkl8tp/vz5VFNTYzNEoL2wgeXl5RQVFUUSiYSCgoJo8+bN1NzcbDdsYHFxMcXFxZFCoSCpVEohISGk0+no3LlzDp2XEK7SYDBYpP8s9KatMIIhISE0f/58q3QhDOXLly/NaULowra2NtJqtaRQKEgul5NWq6Xnz59blXHixAmKiIggqVRKgYGBlJGRQe/fv7cKrygoLS0ljUZDcrmcZDIZTZw4kXJycixCWJaXl1N0dDRJpVICYPPYh3rx4gWtXr2a/Pz8aMyYMRQaGkpbtmyxCFVp75yHa6ehhNCbg8NdCuydt73vVFlZGcXGxpJMJiOZTEaxsbF08eJFm/UeO3aMVCoVSSQSmjBhAu3fv98conXosfT29tKOHTto6tSp5OHhQXK5nCZNmkTr1q2juro6cz5nQ5062s5ERHV1daTRaEgqlZKPjw9lZGRQd3e3zTa6f/8+aTQakslkBMAcPnNwyMzS0lJSq9UkkUgoODiYtm3bRv39/Vb1OnOd/uy7Vl1dTQDoypUrDrUNY3+bG9EId1wxxhgbNRISEtDb24u7d+/+lfri4+PR3t6O9vb2v1IfYz/T3t6O0NBQbN++3eop1X+aTqdDR0cHHjx4MGo2ljM2GK/ZZ4wxF1BYWIh79+6NKDY6Y2xk6uvrcfnyZRQWFnJHn41avGafMcZcwJQpU/54uELGmKXo6Gir0LGMjTY8s88YY4wxxpiL4jX7jDHGGGOMuSie2WeMMcYYY8xFcWefMcYYY4wxF8WdfcYYY4wxxlwUd/YZY4wxxhhzUdzZZ4wxxhhjzEVxZ58xxhhjjDEXxZ19xhhjjDHGXBR39hljjDHGGHNR3NlnjDHGGGPMRf0Hqzj8O4GgRvEAAAAASUVORK5CYII=", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Cora\")\n", + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Citeseer\")\n", + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Pubmed\")\n", + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Cornell\")\n", + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Texas\")\n", + "get_KANGNN_shap_summary_plot(result_KANGNN=result_KANGNN, dataset=\"Wisconsin\")" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvoAAAErCAYAAACvlSfCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB+W0lEQVR4nO3dd3wURf/A8c/ulfROCKH3JkWKhiZFAXlAEBTEQhF/ShHFrtjRR8UK2EDwEQEVC4gCIggqRZEiiAiIFCH0kt6Ta/P745KD4y4QQtqF7/v1OribnZ2dnVz57uzsrKaUUgghhBBCCCEqFb28KyCEEEIIIYQoeRLoCyGEEEIIUQlJoC+EEEIIIUQlJIG+EEIIIYQQlZAE+kIIIYQQQlRCEugLIYQQQghRCUmgL4QQQgghRCUkgb4QQgghhBCVkAT6QgghhBBCVEIS6AshhBBCiEpv0qRJBAcHX3BZfHw8mqaxcOHCiyq/uOuVJmN5V0AIIYQQQoiKIjY2lg0bNtC4cePyrsolk0BfCCGEEEKIfH5+fnTo0KG8q1EiZOiOEEIIIYQQ+bwNwbFYLEyYMIHIyEjCw8MZM2YM8+fPR9M04uPj3dbPzc3lvvvuIyIigtjYWB599FFsNlsZ74WTBPpCCCGEEOKyYbPZPB4Oh+O860ycOJGZM2fyxBNP8OWXX+JwOJg4caLXvE8//TS6rvPVV18xduxY3nrrLf73v/+Vxq5ckAzdEUIIIc5htVr5+OOPARg1ahQmk6mcaySEOC/tpjPP1aJCs2VlZRX6eQ4KCvKanpyczIwZM3jmmWd44oknALj++uvp2bMnR44c8cgfFxfHO++8A0CvXr1YvXo1CxcuZOzYsUXdmxIjgb4QQgghhPBxWpFyBQQEsG7dOo/0WbNmMX/+fK/r7Nixg9zcXAYMGOCWfuONN/LTTz955O/du7fb6+bNm/Pzzz8XqX4lTQJ9IYQQQgjh44oW6Ou6Tvv27T3Sv/vuu0LXOXHiBADR0dFu6VWrVvWaPzw83O212WwmNze3SPUraTJGXwghhBBC+DjtrEfJio2NBSAhIcEt/fTp0yW+rZImgb4QQgghhPBxpRfot2jRAn9/fxYvXuyW/u2335b4tkqaDN0RQgghhBA+ruQD/AJRUVGMGzeOl19+GX9/f6688koWLFjA3r17AedwoIqq4tZMCCGEEEKIIim9Hn2AV199ldGjRzN58mSGDBmC1Wp1Ta8ZFhZWKtssCZpSSpV3JYQQQoiKRKbXFMLHaLedea4+L5NNDh8+nF9//ZWDBw+WyfaKQ4buCCGEEEIIH1d6Q3cA1q5dy/r162nXrh0Oh4PvvvuOzz77jClTppTqdi+VBPpCCCGEEMLHlW6gHxwczHfffcdrr71GTk4O9erVY8qUKTz44IOlut1LJYG+EEIIIYTwcaUb6Ldr147ffvutVLdRGiTQF0IIIYQQPk2dFeiXbsjvWyTQF0IIIYQQPk7Ce28k0BdCCCGEED5NevS9k0BfCCGEEEL4OAnvvZFAXwghhBBC+DgJ9L2RQF8IIYQQQvg0JYG+VxLoCyGEEEIIHyeBvjcS6AshhBBCCJ+myrsCFZQE+kIIIYQQwqcp9PKuQoUkgb4QQgghhPBxMnTHGwn0hRBCCCGET5OLcb2TQF8IIYQQQvg4CfS9kUBfCCGEEEL4NOnR906uXBBCCCGEEKISkh59IYQQQgjh06RH3zsJ9IUQQgghhE+T6TW9k0BfCCGEEEL4OOnR90YCfSGEEEII4dNk6I53EugLIYQQlwGlFDabAgfYHQplB4dDYbc7sFvBZNbRdNB1Dc0AmgYGo4bRKEMihPBVEugLIYQQPsBuU2Sl28hKt5GZZiMr3c6Rfdk4HApd18jNspOTbScr3caJ+Fz8/A0oh8JqVdgsDqwWdVHb0xwONEDTwWjSMJp0jGaNvBwHIeFGwqPNBAYb8A824Begk3zKSoOWwYRGmggKMxIUaiQozEhAkI5BDhZEKZMefe8k0BdCCCHKkVKK7DQb6QkWUo7lcGh7On7BRjKTrWQk5pGeYCEh2U4mpkLLMBhAAQ77mbTcLEfJ1M8B1jyFNe9M4Uk5FpJOWEADXQelnPn+3pjmtq5V18ny9yM4xEhYuIGIKiYiIo3oBggMNNCoWQCRVUxERBnx85eDAXEpJND3RgJ9IYQQohQ57A4yU2ykncwj9VQeqSdzST2Ry/7NqegGnexUK3abe2+7btBAKRz5sbrFZAKzorBgxm73mlz6lPvBxbkcug4KMjPsZGbYOXbEgsFwpr7Lvz2TNyBQRzdATKyZeg39qVLVRFS0Kf9/I37+hlLdFeHbpEffOwn0hRBCiEtky7WTuC+d5CM55GbYST2WQ+rRbFKOZHM6WWHXzwSpusHZ+63OM5LGYb+4YTa+pLCDkpxs51HNgYxcDv2bi+OcNgoM0ompbqZadTPR1UxEVzUREKjToEkAAYFyEHC5k0DfOwn0hRBCiCLIS7eSfiSLxD1pHN+chG7USIvPJPVQFrnJFiz+Zmx+ZjQNNIOGI7+X3hHg71bO+XrAhZO3g4HsLAcH9zkPAgDX2Q5wHgRUjTUTW8NMaJiB4FADzVoGUbWaCbOfDAm6HEig750E+kIIIQT5Y+UT80g7mk1KfAb2jaGw349vflhP5rEcLJm2goyAM5hXZ/W8K01zLVZnD8WR+KNEObxcepCd5SB+fy6HD+SetTwRgNAwAzHVzfj5a8TW8KNx8wCqVjNTpaoJg1H+OJWH/C29kUBfCCHEZSM3zULWsWyyjmWTeTSLzMNZZBzO5NCuDPJsZ3rhnUIw2BwkJ2d4LUtV4uE1vsrbQUB6mp30tBwAdm7LZtV3KYBz+tCIKAO6rtO4eQC16/tTtZqJqtXMRFYxousSOPoS6dH3TgJ9IYQQlYJyKLKTLWSczCE5PouE3enoukb6ced4+cyTOeinsjDnWZ0r6KDpGsqmyAkJhHNHeCgJHCozpSA50Q7YSUqw8tuadNcyXQejUaNx8wBiqpuJrmamaoyJ6BgT4VFGTCYZDlTRSKDvnQT6Qgifo5TC7gC7AocCuwOsdoVeMHTirLx2h8Koa+g66Jrz5K6ugY7CaNCk184HOByKrEwHCcdyIMtGVoqFzCQrmUkW0k/kkLD5NCZNkZNiQZ3To6sbNeeFrflvioCzr+50OA8OADnrf5k798JohwMsFsXOP7PZvSPb48Lg8Eijq/e/SoyJwCCdKlVN1KrrR3CIAU2TN1TZkzb3RgJ9UWq2bNnC2LFjef755+nfv395V0eUArvDQaYFsmya838rZFphd5KDAKOGQznTsm2QYVGsj3fQOBysdsixKXJscDpLcSBZUSNUI88OeTbIsytSMuxYcu34GcDmcH+UpILA36A7DxiMOgSawaRrGA1g0hVJ2RATrBEeoBFg0vA3glFX/JusaFfDQJDZmeZv1LDYFcnZijY1DPgbNQJMzvQcq8LfCDXCdAJMEGByLjNoEOrvLDfASKU+8FBKkW2BzBwHGTmKpHQHqYlWzDqkZznIzHKQnung2L856Nk2lM1Berqd7CwHSkGd04kYCsbH5/fGk2cjKDMPayHbdNhkeI24NN4uDE5NtpGabGP/nhznFKNnfS8ZTRoRkUaiq5mwWRX1GvlTvZYfkVFGIqKc9xGQawNKnnzSvZNAX4jLkNWuSMxRZNs00vMgLU+RboGUXMX6Y1A3DDIskJ7/OJSuOJgKEf7O187gHnJt59tKfkCGM5DGobBn21mjOcfGqvze+IIv5+OZ53xN5ymwQ05hEVwJUTjPDBT8mNvtkJdzpv4FMpOVRxrAv0k215kCNLDZnbm+2G5z27/zOqv3z6iDWQeL0ogKhEDTmYMFpRTJOYpW1Qz4GcHPqOFnhJRshUNB42gdkw5mg4bJAIfTHMQE61QJ0jBozrINOuxLctA4SsdkAE3T0ACrQ3EoVdEwUnfeeEk5y0zKVqTnKmJDdax2sDrA5lDsOWXH3wBBZuf7IM8GOVYHvx9xUC1Ew2aH9DxFZp4iJ9tBaJoVQ/7fvEC4zUaUze5qAj1/NERoVh5+XgZb62d1qar83nhdft1FOfI2g5LNqkg4ZSXhlPPLa+/fOR55dANUi3WeDYiIMhIeYSQ41IDBoFGngT9h4UaCgnU5M3ARZOiOdxLoC+FDHEqRaYGkHEWOTSPdciZIP5zhDMajAshPdy7bkQAWhzMQLQjSLRfoFTdo+cE5+UNj8oOpo5kXX+eCQLog4rV7j5d9luOc4LVAka/TPOe3yXXWQoNTmXCmsc4UeCjV7jqA0rQzZzlMe85EHQqwKUDT0PMPrFwlFOP3UHMW5frflmdDU2DMn75c5fdqOhT8c9p93UC7IswB577ttPw6afnrFxxsyc+1qOwcdjh+1MLxo84biBV8fs6m6xAcYsBo0ggI1KnbwJ+QUCMhYQZCQg1oGlSJMREeYSQoxIDZfHlfN6A8LrIRIIG+KGdKKXJycggMDCzvqpSJHKvij9POYSwZ+UF3hhW2n1boGpgNzp70DIsiJRf+SoBgM+TZnXmzz9uD7lRwjVhBAFqcmNquLiJQFeXi3AMocPa2uznrvVAS21PnHHMonMOw3DIJIS5KYTcQczicMwYVOHHUgqbhcb1AAecBgYbVoqhey895ABBsIDBYx2TWyMlyUK9RAAGBOoGBOgGBBgKCdEJCDZViyKD06Hsngb4oM2eP2c/JyWHBggUcPXqUO++8kzFjxpR39UrUk+vszN2laBwB828wUD3Y+QX0340OJm8651b32plAzKS796ADpORd3LY9gj1RsRV0aYsyI03uhVJuQ8jOm5XSaz9fLbssnNvjf+7+2KyKjDTnj8eBvbnOM3C6M8+Zg4lUj3Jbtw9i3KM1Sr7CokKQQF+Uuc8//5y0tDQGDhxIVFQUMTEx5V2lEvXDQQevbnZ+2Z7IgsfWOvisn3N8Q5bVOU767AtKHefrkRXiUvh6ZCPceI3FLyJAF2WvPD+CSoEqwl2YU5KLcKrYB0iPvncS6Isyd/LkSRYuXEhkZGR5V8UlOTmZoKAg/Pz8AMjMzEQpRUhICAAWi4WMjAyioqJc65w4cYLY2FiP18m57mWn5J7Zht0ejFaq4wi9/ayUx0+NRJilR/6eFZu0lfBNJfk7WB4k0PdOAn1R5vr161ehgnzAoz7BwcFur81ms9uXG+DxZVbwekADjfYxsOUUBJng8as01zYMBjulO5DZ2xddeXz5yRdu6bmIti2xP4P8PYuu9NrKa8nypxElpCR/B8uHfBi8kUBflLnatWuXdxVKVZBZY/3tBv5OghrBEB145stHwzlsx6TnzzJSzItlRSUiv01lzmebvDQj/YsY/lOa7eerZZfHNotTtq6f+VM7lHOaWlMlmdNffku9k0BflDl/f//yrkKpMxs0rqzqmT62tU6QyUGmFdesO+kWxa7E/AwaZOXfeOpipsBUlPyNpIQQQlRMmo7HXaDPZTJrBAToBAYbMPtp5GY7aNDEOetOQP6sO4FBOvUbBZRNpUuZQ6bX9EoCfSHKUNMojZevMRQpr9WuSM3Nv6lV/o2rMizOGyb9fhJqhmikWxRpec5lB1MVh9IhzB9Sc/MPJKzOqTnPx5g/K4PCeWdY6RWpRM4zXPzsefHhzFSshrMOHgvSCy1bCFHidN1zhh2A4FDn/Plh4QbCwo1kZTmIrWGmaqyJ4BADwSEGgkIMBATohIQZMVaSnvqiu9z2t2gk0BeigjIZNKKDzv3icr6+vXnRy8mzOfLvcqu5bqKVboEtJxWhZrA4NFdaYrZi00mIDXIeJKTl5c/1b/G82dG59PwzDM67rJ4JJEtiDndfVnBjq4IpUwvuc+C8+2x++1zk75NBA5PBed8Fs+FMe1cN1vLTnP8fz1BEBzvfR0YdjLqGril2JSiaR+v4m878nXKsiv3JipZVdVfdFHAq03nAWTtMx2JXWOzOufMPJuoYUfgZNXKszvRcqyI995ybc+H9mKDgZl8Fzy/394mo3DQ9/3vgnI4XgwFCw4xERDnvhGuzQbNWgYSFGwnND+hDw40EBmnouvRYn49cjOudBPpCVHJ+Rh0/I1Rx3ZPM+WU4oGHRy1BKkWtTZFg0MqwFN/WCA6nOYUj+Ro3M/CFHmVbFphOKcD8Nk+58nWlxnmXYfxLCzc7ANNcGebbznHGo4N/ZOs4ANsTPuf9+RvA3aTgcikyLollVA4EmCDRr+Bs1krId+Bk0GkfrBJggwKQRYIJjaYp6kTpVgjQCTBr+RueybIuiRpiOvxHnI3+ZWVcYDBX7B9/5foHMPEWWBTLyHJxMshNo0MjIUWTkOsjMUZw8bSP9lIXIII30DAdpGQ7SMx3YEzSwFFK4duZOukJUZJoGRiNEVzNTs44fEVFGIqNMREQZ8fPXqVHbj6BgHU2mRy0R8pXgnQT6QogL0jTNFZiefenBNTWLNgzpDJNHilKKPLvCYtfIs4HFDnl2RUaeicw8hZ9Bw2pXWO3O6xCOpDoIMjsDa3t+j7jdAf8k2KkXoWPUNdcXvs2u2J/koFlVw5kzDvm91xl5itrhzvwG3TmEKSNPEWTWCA9wHqSY8nvHHUoR4qfhlx/Qmw1gKLc7SVb8oMD5fnEesEQDoNMy9uJ+bmw2RWaGnfQ0O+lpNjLS7Rz5w0yIZicvw0ZGQh7pCRayE/NQWe6tohs0HHJrZ1HCDAbPHvnQMAPRMSbMfjoRVYw0bhZIVLSRyComwiONGAwV//NaWUiPvneaUtIvIoQQwnflZljJTswj81QumadyyTiVS+K+DBL3ZgCQeToXh9X5UxeQkYPJYkMzaijbmZ+/zJDAM1e3F1AKw7mRXX66N3kBftjNngezOYH+KO3SzsLkmkxYzEbK8kBPczgueWt5RiM5JpPP3NTr3GBeN0BklIlqNcxUrWYiLMJAQICBJlcEEhltxGSq2GfXLidHtZdcz2uqZ8qxJhWL9OgLIYTwaf4hJvxDTETWC/a6XClFTrKF9BM5nP4zmdwjWdizrGQcyiT9YCbZp3LQlHL1COpGDeVQRbqrqPA9BoPzYtezj9fCIgzUqutPTKyJqtWcF7iGRxqJiTWjl9vZO3ExpEffOwn0hRBCVGqaphEY5UdglB/VWoR7LFcORVp8JplJFtKPZZN+JIeUwxkc2HoUlaCjnRUQagYNJTfA8Annzl5j9oMq0WYaNQ8gJtZM1WpmYmJNREabZIhNJSAfSe8k0BdCCHFZ03SN8PohhNcHrnLe+dNqtfLxx1sBuP2mO8g+YSX9SBZpR7I4vSuV03+m4LA7yEu1XngDxZhZSRRPULBOSLiRwECd1u2CqRprIibWTHSMCZNZhtlUZjKPvncS6AshhBDn4RdmJrhKEFVbhnsss2bZSD+aRfqRbI7+kULSKQs2qyLlSDaZCXnOmxrldzXqBg2l1AVvdCTO8HYBbFCwTnQ1M1WqmrDZFO06BLuC+YDAi50gQFQecjTtjQT6QgghRDGZgoxENQkjqkkY9XrGui1z2BxkJORxZHsa2dmKrDQbaSdzST6WS8qJXHLS3SNYPX/s+OU0BsHbeHldh8gqJqrGmoiOMREV7bzAuWmLQKrGmvH3l55b4eky+thcFAn0hRBCiFKgG3XCYgMIiw3wutyaaycj2Ur6aedUoemnLSQczubozgxMAQaykq3kZNrOimDyLxbWcd3O2tsdVMtbQf2UwvnPWTPu6DoEhxgwmTUCAnUaNw8ksoqJyCr5U1JGGAgNN8oFsOKi+frFuMeOHWPdunWcPn2am2++mZo1a2K320lLSyMsLAyDoXhnqyTQF0IIIcqByd9AZHUDkdX9C81jtznISrWRfDyXhJNW0DUy021kpdnISrdzeG8WjvwTA7nZdvJyHNisZde3aTRr+AUY8PPXyMmyU7NREGFRJoLCjASFGvELMmBRGvWaBhEabiA4xCBBvCgVvhroK6V45JFHeO+997DZbGiaRsuWLalZsyaZmZnUrVuXF198kQcffLBY5UugL4QQQlRQBqNOaBUzoVXM1G1VtHXsNkVmmg2HXWHJc2C1OLDmKSy5dk4dySOiqhmHXeFwKBx2yM2ykZ5iI7qGH7quoemg6xo5mXYMBgiPNmMya5j8dOcFrRoEhRrwD5IbQomKw1cD/TfeeIO3336bJ554guuuu45evXq5loWFhXHTTTfx9ddfS6AvhBBCCDAYNcKiPG/cBdCkbRlXRogy4qtj9D/88ENGjBjBK6+8QlJSksfyVq1asXz58mKXL4G+EEIIIYTwacpHp9c8cuQInTp1KnR5UFAQ6enpxS5fAn0hhBBCCOHTfHXoTtWqVTly5Eihy7du3Urt2rWLXb5vHv4IIYQQQgiRT5318CU33XQTH3zwAQcOHHClafkzVa1cuZI5c+YwZMiQYpcvgb4QQgghhPBpCs318CUvvPACsbGxXHnllYwYMQJN03jttdfo0qUL//nPf2jVqhVPPfVUscuXQF8IIYQQQvg0Xw30w8LC2LhxI48//jjHjh3D39+ftWvXkpqayvPPP88vv/xCYGBgscuXMfpCCCGEEMKn+dqQnbMFBATwzDPP8Mwzz5R42RLoCyGEEEIIn+ZrPfllRQJ9IYQQQgjh03w10L/rrrsumEfTND766KNilS+BvhBCCCGE8GkOHw30f/75Z9csOwXsdjsnTpzAbrcTHR1NUFBQscuXQF8IIYQQQvg0X+3Rj4+P95putVqZOXMm06ZNY9WqVcUuX2bdEUIIIYQQPs1X59EvjMlk4r777qN3797cd999xS5HAn0hhBDiHPsSHRzOjeBwbgT7Eh3lXR0hxAX46vSaF9K6dWvWrVtX7PVl6I4QQohKTylFUrbilwN2cqyKk5mKtQdsZOYpDDrsT3SQmK0INGlkWRSZFoDeALw8NZdgcy6BJo1cmyLMX6NxtI7BoKMZNK5raKR6CJgMGl3rGIgJxmPMrRCitFXOz9yqVatkHn0hhBCiQHq2nc37bRxPcbDtkJX5+xxkKy0/eHfSNXB4Ocefkef9xH+mBTItzmXpeYojaXYwKjDq/HjQiv2s1QKM4GeA6xrodKploH6ERqfaOlWD5SS6EKXFV3vyX3zxRa/pqamprFu3jj/++IOJEycWu3xNKVVZhjMJIYS4zCilSD5lYdWvmaxP0PgnEQ6etgOgaZCnaRzxM5XOxo2681FIgKHl16HggKJ+hMYV0RpNonX+r62RJlU06fkXooRs0Wa4nrdX48qxJhdH1713AERERNCgQQPuvvtu7rnnnmJ/V0igL4QQwqdkJFmI/yONtUsTSExWZGfa2RwZzrEgf49evTxN46h/+QT6FxLuB7GhGo90MtGrgU7tcOnxF6K4NmsfuJ5frcaWY00qFhm6I4QQokJzWB0kbUnk6A/HWftbFlkOZ0CcHhiI0vODbB/sGE/Ng9QExd2LnWOKAk0wrJWBwVcY6VpXx8/ogzslRDnx1Xn0S5sE+kIIISoca3IeicuPceSzfzmyLQnlAKufgazGNc9kqmS/69lW+HCrnVlb7egaxNXUuLudiX6NDcQEV7KdFaKE+coY/cOHDxdrvdq1axdrPQn0hRBCVAhZe9JIXHqEIzP2kHswExRY/HVUaP7Qm8tglsuCsbQOBRuOKDYccfb2Vw+Be6820b+JgZYxMrZfiHP5yjj0unXrFuvza7fbi7U9CfSFEEKUC2Wxk/3rcTKWHeTAhwfJzsB5d5ezA3pf+fUuZccz4PmfrTzzk5UAI9zV1sgNTQx0r6vjb5KgXwhf6dGfPXt2mR6oS6AvhBCizFjjU8hdGU/2d/tJXnYM5QCMGhZbCGC4LHrti6tgCs8cG8zcYuP9zTY04Nr6OgObGejdQKdRlC69/eKy5CuB/p133lmm25NA38csXbqUF154gQ8++ID27duXd3WEEOK8HMdSsf+wB/uWI+R++w9pJzRAQ2kaSgU4M9mk2/5i2fIPiBTw8wEHPx1wJkQFwICmBjrW0ulR10DDKjKTj7g8yLeIdxcV6G/ZsoWxY51TFj399NMMGjTII0/79u3p0qUL06ZNK5EKloWC4PnVV1+lZ8+ebstWrVrFs88+S40aNXj//fepVq2a2/KRI0eya9cuBgwYwHPPPee1/EmTJvHdd98RFBTE4sWLCQ8PL/L2hRDCVyiHA/aexPH5Zhy7T6P+OILt3xTsmMGoY7cZgLD8zPKzXFLObsmkHPhku52Pt9kBK7XDNK6uoVE/UmdYayPNozUMum/0fApxMXylR78w69ev548//iAtLQ2Hw/3UpqZpPPvss8Uqt9g9+rNmzeI///kP/v7+xS2iwlu0aBGvvvoqjRs35t133yUiIsJt+f79+9m1axc1a9bkxx9/5LHHHiMgIKDQ8rKysvjoo4945JFHSrvqQghRqlSeFbbGw4HT8Och+GIjJGdBjgUH/igM+TnzL6S1OcCVJkqT7awY4XCa4nCaAhy8/qsNswHC/WFoCwNtYp137b26pk6AjPMXPs5Xp9dMTk6mX79+bN68GaUUmqZRcIurgudlHug3b96cv//+m88//5xRo0YVa8MV3dy5c3n33Xdp27YtU6ZMITg42CPP4sWLCQoK4r///S+jRo1i1apVDBgwoNAymzdvztdff83tt99ObGxsaVa/QrDZbNjtdvz8/Mq7KkKIYlA5FtTuE3A4Ee1EKmrzAdh0ALLz4HASmsqPKE0GsBZvRghRtix2OJ0FM363Y3Oc+ZvVDNUI84OWMTqd6+jUDNGIDdG4oqpOsJ9vBlDi8uKrPfqPPfYYf/31F/PnzycuLo769evzww8/UK9ePaZOncqGDRtYvnx5scsv1uC9nj170qxZM+bOnUtqauoF87dv355JkyZ5pC9dupT27duzZcsWV9rMmTNp3749Bw4c4K233uL666+nc+fOjBs3jvj4eAB+/vln7rjjDjp37kz//v1ZtGhRcXajUO+99x7vvvsu11xzDe+8847XIN9qtbJ8+XKuvfZaWrZsSZMmTVi8ePF5yx0/fjxWq5Xp06eXaH2zsrKYPn06I0eO5LrrrqNjx44MHDiQd999l9zcXFe+f/75h/bt2/P+++97LeeBBx6gW7du5OTkuNISExOZPHky/fr1o0OHDvTp04eXX36Z5ORkt3UL/m7//vsvU6ZMoW/fvnTq1IkdO3YA8OuvvzJ69Giuu+46OnfuTL9+/Xjsscc4dOhQibaFEOXqeBI0vQ/Ch8Gd75Z3bYrNMXwWjojxqMAx0O45GPQO6t55MOdX2H0cDiW5D70plSC/CEN7zh3+o86zzFu6x/pFGU50nm0WWfkPW7Kdc9Hz0XTFrgTFFzvtTFhmZdAXFjp8mEfIyzmEvpRNn3m53guq4B5fayfiXRt1Z9n4O1Gu9K7M1FkPX/L9998zZswYhg4dSkhICAC6rtOwYUPef/996taty4MPPljs8osV6Guaxn333UdmZiazZ88u9sbPZ9KkSezdu5dRo0YxfPhwduzYwf3338+yZct47bXX6N69OxMmTCAkJIRXXnmFP//885K3qZRi8uTJzJkzhz59+vDGG28UOjRp7dq1pKamcsMNNwDQv39/tm/f7joY8aZJkyb06dOHFStWsHfv3kuub4GEhAQWL15M8+bNufvuu3nooYdo2rQp8+bN49FHH3Xla9q0Kc2aNWPZsmUe87GePn2ajRs30rt3b9fwo5MnTzJ8+HB++ukn+vTpwxNPPEHfvn1ZuXIl//d//0dmZqZHXZ599ll27NjBHXfcwYMPPkiVKlXYunUrDz/8MBkZGYwaNYrHHnuMQYMGkZaWxpEjR0qsHYQod9dNgj3HIS0b5q6GD1eWd42KZ9lfkJpdyEJf+xktYSWx+xW8Cc+tXoYFftjve0HyqngHb/yuSM2DQ+lw3QLf2wdRdArN9fAlqampXHHFFQCujuWz46vevXvzww8/FLv8Yl+OHxcXR1xcHAsXLuTEiRPFrkBhoqKi+OCDD7j11lsZO3Ys9913HydOnOD1119n7ty53HPPPQwdOpT3338fs9nMV199dcnbfO+99/j6668ZMmQI//3vfzEaCx/ZtGTJEqpXr07btm0B6NOnD0ajkSVLlpx3G+PGjcNoNPLuuyXX21ejRg2WLVvGE088wW233cYtt9zCq6++yl133cXGjRvZuXOnK++gQYM4ffo0GzZscCtj6dKl2O12brzxRlfa66+/js1m47PPPuP+++9n0KBBTJgwgRkzZnD8+HE+++wzj7oEBwfz4Ycfcscdd3D77bdTt25d1q5di8Ph4P3332fYsGEMHDiQu+++m1mzZtGlS5cSa4dLkZycTF5enut1ZmYmGRkZrtcWi4WkpCS3dc5935/7+uTJk65xdrKNy2MbjhMpbq9zN/7jm/uhzg2ILhyZVvDYtZIpxpmHEvgL+cJ79+xt/HnafZ9Tcn3nM1hZtlGWfDXQr169OidPngTAz8+PqlWrsn37dtfyY8eOXdKUuZc079b999+P1WplxowZl1KMV0OHDnXbsSuvvBKArl27us18ExERQZ06dUqkZzgxMRGAOnXqnLdRT548ycaNG+nXr58rX3h4OF26dGHZsmXYbLZC161evTqDBw9mw4YN/P7775dcZwCTyeQ6KLHZbKSnp5OamsrVV18N4Bbo9+nTh8DAQLdhRkoplixZQsOGDWnRogXg/ID/+uuvdO3aFT8/P1JTU12P6tWrU7NmTTZt2uRRl9tvv93jAKngCPXnn38+b9uUp8jISLdrCYKDg12n0ADMZjNRUVFu65x7ncW5r6tVq+b2PpJtVP5t6MO6nXlh0PF/ZJBv7od27k+DVsjzC6X6GJ/ZiaJU9Nw8l75zvvDePXsbI67Q8Dvr+u//1NN85jNYWbZRlhxnPXxJ165dWbVqlev10KFDef3113n55Zf573//y7Rp0+jRo0exy7+kefSbNm3K9ddfz4oVKxg+fDiNGjW6lOLc1KxZ0+11aGgo4AyUzxUSEuI6GroUDz30EAsXLuTNN98E4NZbb/Wa77vvvsPhcNC6dWu3A4z27duzZs0a1q9fT7du3byuC/B///d/LFmyhHfffZe5c+decr0BFixYwNdff82BAwc8pmU6+4g8MDCQ66+/nqVLl5KSkkJERARbt27l2LFjbrMBxcfH43A4WLx4caHXHtSoUcMjrXbt2h5pt9xyC2vXruXVV1/l3XffpXXr1nTq1Inrr7/eYyYjIXzae/dA56awZT+MuR4ae35f+QSTAQwaaJrnYO4yU4TA9HxZClt24WOWC2zznJWKVUYx1iknRt13Z0KNCdL5926YtlXRKEJjdGu5p0Blpnx02tiHH36YVatWkZeXh5+fH5MmTWLXrl2uWXa6du16SaNALvmGWePGjeOnn37i3Xff5Z133rmodc8dJ342Xff+gSwsXZXAN1F4eDgffPAB48aN480338ThcHD77bd7bGfp0qUA3HfffV7LWbJkyXkD/fDwcEaMGMGMGTPcjuKK69NPP2XatGl06NCBW2+9lSpVqmAymUhISGDSpEkegf+gQYP45ptvWLZsGcOGDWPx4sWYzWb69u3rUfZ//vMf13UI5/I2m463axrCw8OZN28e27ZtY9OmTWzbto0pU6Ywc+ZM3n77bVq1alXMPReiArrtGufDh2mfj4Ff96EOJ8Fv++B0uvO6g4KgX8s/CHAU/h1eNs4XdBcn0i+rQKFiBSQF8ZFDnXkd4Q9h/tCtroFaYRpX1fDNqVFrhOi80b28ayHKgsNQsT5XRdWyZUtatmzpeh0REcGPP/5IamoqBoPB7axKcVxyoF+jRg0GDx7M559/7jZ7ztnCwsJIS0vzSD927Nilbr7EhYeHM2PGDMaNG8eUKVNQSnHHHXe4lm/ZsoVjx45x22230bp1a4/1f/jhB9atW0dSUpLHKa6z3XHHHSxYsIAZM2YwYsSIS6rz999/T/Xq1XnnnXfcDoR+++03r/mbN2/umiXoxhtv5Oeff6Zbt26EhYW58tSsWRNN07DZbMTFxV1S/QAMBgPt27d33c133759DBs2jI8++oi33377kssXQpQc7drmcG1zt3BU2R2o+ATYchDtdAZq2yHUsm1o2XmQmT+uV9fORIuiQjr7T+RvgBA/6NnAwFU1dGKDNVpX02gUpWP00aBJXL6Uj56w+fvvv2nevLlH+rk3Vy2uSw704cxQlMJ69GvXrs2OHTvIzc119fimp6df8MLVS3Hy5Elyc3OpWbPmeS+q9aYg2L/33nuZOnUqSimGDRsGOOfONxgM3HXXXV6HnURERLB69WqWLVt23gDe39+f0aNH88orr/DNN99c3M6dw2AwuN1gAZxj9efMmVPoOoMGDeLVV1/l9ddfJy8vj4EDB7otDw8Pp3Pnzvz888/s2LHD7WgTnGc2UlNTizT0JjU11eMNW7duXfz9/UlPT7/g+kKI8qcZdLQGMdAgxvk6P10pBYeT4OvNcCodfj8A6+LBnp9J4v5yVRDY6xp0qqUTV1MjKkDnlpYG6oVr6D463EGIcykfPTht0aIFLVq04NZbb+WWW26hYcOGJVp+iQT64eHhDB8+nA8++MDr8ltuuYVnn32WsWPH0rdvXzIyMvj222+JjY31uIK7pDz33HP88ccfrtlxLlZ4eDjTp0/n3nvvZdq0aTgcDgYNGsTq1au58sorCw1w27RpQ2RkJEuWLLlgT/2NN97IZ599xt9//33R9Tvbddddx3vvvceECRPo0aMHWVlZ/PDDD+c9wOnTpw9vv/02y5cvp0aNGq4Ld882ceJE7r77bu655x769etHkyZNcDgcHDt2jHXr1tG3b1/GjBlzwfq99NJLnD59mri4OGJjY8nLy2PVqlVkZWXRr1+/S9p3IUT50jQN6lSBh88M/TPY7bD7JOqX/Ti++AP77ycgp2JeiF9Z+RugRYzGsNZGrqljoGVVMBl9tMtTiCJw+OhB64wZM/jqq6947rnnePbZZ7nyyitdQX+dOnUuufwSCfQBhg0bxsKFC10z15ztP//5DwkJCXz11VdMnTqVGjVqcPfdd6PrutuMMBXN2T3777zzDrm5ueTl5Z336mdd1+nWrRvffPMN27dv9zq8p4DBYOC+++7jscceu6R6Dh8+HKUUixcv5q233iIqKopevXoxYMAAhgwZ4nWd4OBgevXqxZIlS+jfv7/XWYaqVavGp59+yty5c1m7di3Lly/HbDYTExPDNddcQ69evYpUv759+7J06VKWLVtGSkoKQUFB1K9fn9dee43rrrvukvZdCFHx6AYDtKgBLWpgGNcNP6Vw/HMa47c7sX68G8uRbFSuBP4lyWyA2mEat7QwcEsLIy2rSm+9uLz46tCdMWPGMGbMGE6dOsWCBQv46quvmDhxIhMnTuTqq6/m1ltvZciQIcXqtAbQVElcxSp80quvvso333zDkiVLiImJKe/qCCEuE8piJ/fXwyRO3kLuwUys/6ZxmlBseF7wafHTyQ4zAWA1GTjQ9MyMbOlBgaj8TorNUeEcC/T3mEM7T9M46m8qnR0x6s5HOV1cWysU6kXoPNHFSI/6BgJMEtiLy9fiiPmu5zem3H6enBXfsWPHXEH/5s2b0TQNq9VarLJKrEdf+JbMzEyWL19Op06dJMgXQpQpzWwg4Np61Lq2HgCWg2kEvPkXiX+kk74lCWWT/idvNA3aVdO4Ikbnya4mGkdpl3QjHSEqE1WJPgqxsbFcccUVNGvWjJ07d5KVlVXssiTQv8zs37+fPXv2sGzZMrKzsxk1alR5V0kIcZkz1wuj3vvXUA+wpVs49tE+kn44TvrGBCy55T2FZ/kKNkPHmjpd6uiMjzMRFViJohkhSpCvzqNfQCnFmjVr+PLLL/nmm29ITEwkIiKCW2+9laFDhxa7XAn0LzM//fQTH374IVWrVuWJJ56QOeyFEBWKMdRMnYeuoM5DV6DsDhJ/OsGB+QdI/TeD5APOXi1N892bOBXm7AmK6kdoXFlN47aWRm5sZsDko7OJCFGW7D76Ofnll1/46quvWLhwIadPnyY0NJSBAwcydOhQevbsedEzR55LxugLIYTwCVnHstj6+VFOZygObksnETNK19E02BQZztFAf84dL19Rx+i7picFAk3Qo65GnQidCXFGmkT75s2phChPC6p94Xo+5OSt5ViTi6PrOsHBwfTv35+hQ4fSp08fzGZziZUvPfpCCCF8QlCNILo+2gQAh12x9/dUjh+xcHB3NjsOKUCr0FP3F9RN16B7XZ2udXWaResMkl57IS6Z8tHrVRYsWEC/fv1c95kqadKjL4QQwudZbQ72nbTz1yEbP+/MY8u/NrLyFNnK2aNv0JxBdoneuNdLj76Oc2iRPX87ugZhftC2ujOgj6up06Kqhr/JR+cCFKKC+qL6l67ntx4v/pj2ykZ69IUQQvg8k1GneU2d5jVN3No5AACLTbH/pI2vd9iw6rA/ycGKPTZsDsjI816OUQeHAxznpOua82E7d0F+kB9sAk2H3g10mlbRUcCNTQ20itHxl2kvhSh1vn4xbmmRQF8IIUSlZDZqNK9ponlNzzH6eTbF3gQHydkOMi1wINnBv0kOqofq5FgVmbl2zAe/RwP0xn3Rdec89QlZDmJDdBpH64T5Q7CfTrOqusxhL0Q5q0zTa5YkCfSFEEJcdvyMGi1jDeDlJl0AVquVjz9OAWDUdWZMplK6oFcIUSJ8dYx+aZNAXwghhBBC+DS7DN3xSgJ9IYQQQgjh02Tojndy2b8QQgghhPBpDk1zPXxNeno6r776Ktdffz1t2rRh8+bNACQnJzNlyhT2799f7LKlR18IIYQQQvg0X+3RP3r0KN26dePIkSM0atSIf/75h8zMTAAiIyOZOXMmhw4d4u233y5W+RLoCyGEEEIIn+arF+M+9thjZGRk8Oeff1K1alWqVq3qtnzgwIF89913xS5fhu4IIYQQQgifpjTN9fAlK1euZMKECTRv3hzNS93r16/PkSNHil2+9OgLIYQQQgif5qtDd3JycoiOji50eUZGxiWVLz36QgghhBDCpyldcz18SfPmzVm3bl2hy7/99lvatGlT7PIl0BdCCCGEED7NYdBdD1/y4IMP8sUXX/Daa6+RlpYGgMPhYP/+/QwfPpwNGzbw0EMPFbt8GbojhBBCCCF8m4+NzS8wbNgwDh06xDPPPMPTTz8NQJ8+fVBKoes6r7zyCgMHDix2+RLoCyGEEEIIn+ZrQ3bO9vTTTzN8+HC+/vpr9u/fj8PhoEGDBtx0003Ur1//ksqWQF8IIYQQQvg0X5ttByA7O5trrrmGe+65h7Fjx17SEJ3CSKAvhBCi0rLn2cmJzyRrbzopy49ijjKTdzSbtF9O4l87GHuGBcOeU/hVDwBdw3Y0E3OdELQwE53/TiGnlkb61h9QJzIxXV0DU71wlFKYrojGWDccLdzf65R4QoiypTTfGpsPEBgYyMGDB0v1O0RTSqlSK10IIYQoI9YsGyc3JXBo2VHseXaSNyTgtzMVTYHucOBnt4NBA6XA4VxHx0EYOR5laTiIJB0FaEYNbIX8VOqgRwdhahGNZrNhbh2D+eoa6DFBGJpFo1cPlQMBIcrAe21XuJ7f90efcqzJxbn99tvJzc1l0aJFpVK+BPpCCCF8Ul6OnfhdmexZdYr0RftxJGW7Anh0MGfbCUu2OF8WBPrnuFCgfzFMWPAI6QNNGEONGBtGYLquAXq1EPTmMRjjaqP5yUl1IUrKu+1+cD2/f+v15ViTi7N7926GDBlCmzZtGDNmDPXq1SMgIMAjX2RkZLHKl0BfCCGET1BKcfyYhZ3bs9nycwrZe5xT0YWmpBN7LMEjvzm3AgT6gBELOgqMOtgKTiVoEBmAXjcS88Ar0JtGY2gVi6FR4TfOEUIU7p2rVrqeT/i9dznW5OLo+pkhR+c7+2f38v1VFNKdIIQQosKy2hz8vc/C73/lsn5dOnqqBU2DgFwLIeA1sK6wCoJ8AIeCxGwcidnkbjsOducyrUoQepNo9LoRmO9sj/Gqmmhhnr17Qgh3vjrrznPPPVeqw/sk0BdCCFGhZGY72LYrl607c1m3ORuLFQw6+OU5CAaobOeh7WcOAFRiFvbELOzr47F+ts2ZGBGAeWhrDB1qY2hXE2OLauVUUSEqLl+cdQdg0qRJpVq+BPpCCCHK3ZHTNrbuyOWvv3PZ8lcuDuUM7gti4LNi4ctPSg6WjzbDBxsB0KqHYuhcB0P9KMxjOmCoV7yxu0JUJr4a6Jc2CfSFEEKUOatdsXynha17LWz910rywTwi7XZ03TmqBS7z4P5c1rN6/Y+nY1u4A5uCvNfWQHQQeu1w/Cd0wdijAXqt8HKrphDlxVcD/RdffPGCeTRN49lnny1W+XIxrhBCiFKXZ1NsPWpn3hYL247Z2XHCTnCOjdD8qL6axUr4BSL7QKuNYJsNDQjMsxCSm4eGD12MW1YCTJjuaIOpRwMMHetIj7+4LLzVebXr+SPre5RjTS7O2RfjnkvTNJRSaJpW7Itxfe/uAmVs9OjR9O/fv0h5t2zZQvv27Vm6dGmR8vfv35/Ro0dfSvXKxMXulxDi8pZlUazYZ+f9jVbuW5JHjZczCHo6nc7Ts5i5wcLmw3ZyrD52Ia0vybFinbOF7Ds+J6P+q6TVnUzmqC/JeWYFjkMpSP+eqIyUprkevsThcHg8bDYb//77Lw899BDt27fn9OnTxS7/shm6s2XLFsaOHcsDDzzA8OHDveZp3749Xbp0Ydq0aWVbOSGE8CG5VgensjSOZijWH3GQbYFTWYqV+2yk5iiScwC7M5g06WC1OCrfBbQV3Vkz/KhDKdjm/YHNoch7+WfnUJ+oQMyj4zB2rovhyupo5ssmHBCVlMNQefqudV2nXr16vPnmm9xxxx3cf//9zJ8/v1hlySf7At5///3Lvvejbdu2rF+/HqNR3i5CVDZ2h+JUliLdopGUo9hy3EGgCdLzYHW8IjwAsi2w4bjCoDvTM3LP+k50OHvmjTpYLZ7flVYZZ18xOM762yRk4UjIIvfh75yvNdBbVsPQpR56iB+moa0wXFFNgn/hU3ytJ7+ounbtyhNPPFHs9eVTfAEmk6m8q1DudF3Hz8+vvKshhCiiXJviRAYcz3Sw/ogixE/jaLqDHw8qYoM1jmcqdiY6Z7XJtBaspYFSroDQoDk75Qvmd1b5WbxRSEDv0xQ4/jqJY9cpsCvnBb4GDYLMGK9riPGqWmhh/hh6NMDQsAqayVDeNRbCQ2UN9Lds2XLecfwXIoH+BYwePZoTJ054jE9fs2YNs2bNIj4+noiICG644QbatGnjtYyTJ08ybdo0NmzYADh7yB955JFCt7lp0ybmzZvHrl27sFgs1K5dm8GDBzN48GC3fP379yc2NpannnqKqVOnsm3bNjRNIy4ujscff5wqVapccP/+/fdfZs2axV9//UVqaiqhoaHUrVuX4cOH06VLF+DMsKfnn3/edb1C//79OXHihNcy27Zty6xZs1yv//77b2bPns22bdvIzs4mNjaWfv36MXLkSDlLIEQJ25XgoM2HVu+Bt6bhGkOjA65ruzx/IO3KmV8VnqXEqbLZzCU7u54XW+dLWfdS1ioSu3J/np6H7dtd2BbvgoL3k66h148kaPGdGJrHlE49fM0vf8Pc1VA/Bh4bCCb5XSsPvhroz5s3z2t6amoq69atY9GiRdx9993FLv+yezfm5uaSmpp6SWWsXr2axx9/nOrVq3P33XdjMBhYunQpv/76q0fejIwMRo8ezalTp7jpppuoX78+f/zxB2PGjCEvL88j/6JFi5g8eTItW7bkrrvuIiAggE2bNvHqq69y7NgxHnjgAbf8CQkJjBkzhu7duzNhwgT27dvHokWLyMrK4v333z/vfqSmpjJu3DgAbr75ZqpVq0Zqaiq7d+9m586drkDfm0ceeYTs7Gy3tJ07d/LVV18RFRXlSvv111957LHHqFWrFsOGDSM0NJQdO3Ywc+ZM9u7dy2uvvXbeOgohLs7JzFLqXVcq/0ChhIvFe9h66QFx6dGKFd57rutZTvkeQhRa7NkjshwKx/4k7DtPSqAPsO849HoB8vJPjSWkw9S7yrdOlylfDfTvvPPOQpdVqVKFiRMn8txzzxW7/Msu0J85cyYzZ84s9vp2u50333yT0NBQ5s6dS3h4OOAMlG+99VaP/PPmzeP48eM899xzDBgwAIAhQ4bw1ltv8fnnn7vlTUxM5M0336R37968/PLLrvQhQ4bw5ptv8tlnn3HzzTdTs2ZN17IjR44wefJkevXq5UrTdZ0FCxYQHx9P3bp1C92X7du3k5yc7LF+UXTv3t3t9fHjx5k2bRo1a9Z0jSXLy8vjv//9Ly1atGDGjBmu3vubb76ZRo0aMXXqVNeMPuUtOTmZoKAg1xClzMxMlFKEhIQAYLFYyMjIcDuIOXHiBLGxsYW+PnnyJDExMa6hD7IN2UZZbCMnJ4fL8Ku9HJX+YUhFO9ABsNlsZCQl+dzno8S38dehM0E+wOZ9vrkfpbSNsuSrgf7Bgwc90jRNIyIiwtX2l+Ky+zUYNGgQPXv29Lps/PjxF1x/9+7dnDp1iuHDh7uCfIDg4GBuvvlmj170NWvWEBUVRb9+/dzSR44c6RHo//jjj1gsFm688UaPsw7XXHMNX3zxBZs3b3YL9KOjoz2C9Pbt27NgwQKOHDly3kA/ODgYgN9++42OHTu6Xl+szMxMHnzwQaxWK9OmTXO1y6ZNm0hKSmL8+PFkZma6rdO5c2emTp3Kpk2bKkSgHxnpPs/0uW1hNpvdvtwAjy+zc19Xq+Z+m3rZhmyjLLYREBAAWBFlpfSDi4oYvhiNRp/8fJT4Njo0hohgSMn/jevbzjf3o5S2UZZ8NdDXNI3o6Oj8725POTk5JCQkULt27WKVf9kF+rVr1yYuLq7Y6x87dgyAOnXqeCyrV6+e1/zNmzfHYHC/eKlKlSoeR2rx8fEA3HvvvYVuPzk52e11jRo1PPKEhYUBkJaWVmg5AO3ataNfv34sXbqU5cuX07x5c+Li4ujVqxf169c/77oFbDYbTzzxBIcPH+bdd991O7AoOEo9313fkpKSirQdIUQ5K6UfUe0in1cECu0i63Tm2oiz1/Uspyh7XZT0itZilViNKNj0Kizc4ByjP7TwIa+idCkffdvXq1ePTz75hNtvv93r8iVLlnD77bcX+4ZZl12gX5EVTOP5wgsvFHoh7bmB/fmuxC7KtKAvvPACw4cP57fffmPbtm18+umnzJ49m4cffpihQ4decP3XXnuNTZs28cwzz3DVVVd53f4DDzxA48aNva4fHR19wW0IIYquXrhGrVA4luE+o2IBg+YMOWWSnOK7lJDa58JxLX82JgANtJphGFpUwxhXvN7FSqlRdXjy5vKuxWXPcQkz05SnC8VqVqtVZt0pSwWB9qFDhzyWeRtnVaNGDY4cOYLdbnfr1U9MTCQjI8Mtb61atQAIDw+/pLMOF6thw4Y0bNiQESNGkJGRwciRI3nvvfe45ZZbXGP3vJk3bx7ffPMNI0aMYODAgR7LC04zBQQElOn+CHE5qx+hcXiCH3aHIikHdicq8mzOqTZXHVDEhmicylKsOaII94eUHDiRqXB4Czvzb71u1PMv8PWJyFQUi54f0BfEHLXC0P1NGAdegbF9TfS6ERhaV0fzk7BBVEwOHxq6k56e7jZEOykpicOHD3vkS01N5YsvvrikIVHyib1IzZo1IyYmhiVLljBy5EjXePTMzEy+/vprj/zdunVjzpw5LFu2zHUxLsDcuXM98vbq1Yvp06czc+ZM2rVrh7+/v9vyzMxMzGYzZrO5RPYlLS2NkJAQtyPFkJAQ18FJXl6eRx0KrF69mnfffZcePXpw//33e83TsWNHIiMjmTNnDr169XINKSqQm5uL3W4nKCioRPZHCHGGQdeoGgRVgwp+/HTubF14/jybIiUX9qco7A7n818PK0L8nHPtrzmkCDJBah78k6iw2t3PGBi0s2brFL7F34ixX1OMneui1wzHdH1jtFDv3/1CVFTKh3oipk6d6hrWrGkaDz74IA8++KDXvEopXnrppWJvSwL9i2QwGHjooYd48sknGTlyJAMHDsRgMLBkyRLCwsI4efKkW/4RI0awYsUKXn75ZXbv3k2DBg3YunUrf/31l9vFvAAxMTFMnDiRl156iSFDhtC3b19iY2NJSUlh//79rFmzhgULFlC9evUS2Zdly5Yxf/58evToQc2aNTEajfzxxx9s2LCBXr16FRrkp6am8uyzz+Lv70/Hjh1Zvny52/LIyEg6dOhAQEAAL7zwAo8++ig333wzAwYMoFatWmRkZBAfH8/q1at54403KsTFuEJc7vyMGtWCoVrwmR/LgU0Kz+9QitNZsP2kg5RcOJqu+H4vpOY4OJymSMo/YalrMkyo3BXcP0EBZgN6uxro4QGY7+2IsUMd9CrS2SJ8ny9djNu7d2+Cg4NRSvH4449z22230bZtW7c8mqYRFBREu3btLilOkkC/GHr27Imu6/zvf/9j1qxZREZGum6Ydd9997nlDQ0N5X//+x9Tpkzh+++/B5w3lJo5c6ZrDvuzDRgwgNq1a/Ppp5+yaNEiMjIyCA8Pp06dOowbN87jivdL0a5dO/bs2cMvv/xCYmIiBoOB6tWr8+CDD3LLLbcUul52dja5ubkAvPLKKx7L27ZtS4cOHQBnr/7cuXOZO3cuy5cvJyUlhdDQUGrWrMkdd9xBo0aNSmx/hBBlR9fyDwwanhmS+GinMz8pJzIc/HPawZ8nFV/8qTiQ6CAx68LXDYkSomvOUy66huG6hhi7N8DQrCqmfk3RzPLTLyofXwr0O3bsSMeOHQHIysri5ptvpkWLFqWyLU0V5YpNIYQQ4hKdzHDwxTYrW4/a2HTITupJC6EOhUGH6Fwr4fbz9/0HWm0E22xoQGCehZDcPDQgNCWd2GMJHvnNuXbCki0A6A4Hfl5mrdBxEEaOR7qGg0jSL2r/TFi8Dh4wYkGnjH5qzQa0mGD8xnfC2KMBhrY10IyGC68nhI97+oZtrucvf9emHGtSschhvRBCiDJRLUTnwa5+gPOGPPtP29i4x8qmvRa2/2EDOxh0uEC8L86+Aa7ZgN6mBnrtMPwfvAbDVbXQTBLYi8uPr06vWWD9+vX88ccfpKWl4XC4fwlqmsazzz5brHIl0BdCCFEuGlY10rCqkWHXBJA3IoQ9+y1s/iuXVb9mkZWjXKNPBGeG4mgahq71MHaug6FZDKYhrWQmHCEAu49Or5mcnEy/fv3YvHkzKn+ms4LBNgXPJdAXQgjh0/xMOq2a+dOqmT//d0sYh4/b2LgthxVrs0hIsfvQfBolLMiMVisMv/+7GuM19dCvjEX3M5V3rYSocHxpjP7ZHnvsMf766y/mz59PXFwc9evX54cffqBevXpMnTqVDRs2eEx6cjEk0BdCCFGhaJpGnRom6tQwMfSGUBKTbWzansvPP6eTesCWn6l861gqDBqGq2thaBKN1qAK5jvaoNeNOO/9TIQQTr40j/7Zvv/+e8aMGcPQoUNJSkoCnDdDbdiwIe+//z433XQTDz74IJ9//nmxypdAXwghRIVWJdJIvx7B9OsRTE6Og927stn0UwonNlux5/nmgH6teihabAiG+pGYbmqJoXUsWsModJP8LAtRHL46Rj81NZUrrrgCgODgYMB536QCvXv35qmnnip2+fKNIoQQwmcEBOi0bR9M2/bBKFWTpON57P45gdMLFfajGeQm5QGgGcv4V9+kg9UzzdC4CnqwAVOTKEw9G6I1iMLQtCp6ZGDZ1k+ISs6Xbph1turVq7vuweTn50fVqlXZvn07N954IwDHjh27pLN6EugLIYTwSZqmUaWGP9cMrwXDa6GUIuNQJod/OI413UrihgRsP52AXLv75Jb594/CoDm7Ac89KaDhvPjV7lysaXi965cW6gcaGJtGYW4TCzYbfm1iMLWtjl43HD0mWIbdCFFGfHXoTteuXVm1ahVPP/00AEOHDuX111/HYDDgcDiYNm0a119/fbHLl3n0hRBCVGr2PDvZBzJI++UURj+dvGNZpPx4nIDGYdgzrdg3HyO4WRgYNHJ3JBHQqgpaqJGEX3eQXRda9YyD5FzM7WIx1A5DD/PDWDccLUAuihWionhg8N+u528vbF6ONbk4O3bsYNWqVYwfPx4/Pz9SUlIYMmQIP//8M+A8EPj888+JjY0tVvkS6AshhBDnsFqtfPzxxwCMGjUKk0mCeiEqsglDdruev7OgWTnWpGSkpqZiMBgICQm5pHJk6I4QQgghhPBpdt03h+4UJjw8vETK8c27CwghhBBCCJHPgeZ6+JrDhw8zduxYmjRpQmRkJOvWrQMgMTGRCRMmsG3btmKXLT36QgghhBDCp/nqDbP+/vtvrrnmGhwOB3Fxcezfvx+bzXm/kCpVqvDrr7+SlZXFRx99VKzyJdAXQgghhBA+zeGbcT6PP/444eHhbNy4EU3TqFq1qtvyfv368eWXXxa7fBm6I4QQQgghfJpD01wPX7Ju3TrGjRtHdHS01+l4a9euzbFjx4pdvvToCyGEEEIIn+arQ3ccDgeBgYXfQC8hIQE/P79ily89+kIIIYQQwqc5tDMPX9K2bVuWLVvmdZnNZuOLL76gQ4cOxS5fAn0hhBBCCOHT7JrueviSJ598khUrVjBu3Dh27twJwKlTp/jxxx/p3bs3u3fvZuLEicUuX4buCCGEEEIIn+ZrY/ML/Oc//2HOnDk88MADzJo1C4Bhw4ahlCI0NJR58+bRtWvXYpcvgb4QQgghhPBpvjZk52zDhw/npptuYuXKlezfvx+Hw0GDBg24/vrr5c64QgghhBDi8uZLN8p66qmnuPXWW2nVqpUrLSgoiEGDBpX4tnxrIJMQQgghhBDnUJrmelR0r776qms8PkBSUhIGg4Gff/65xLclPfpCCCEua9ZUC1m7Ukle8C/mcCO2xFzyTmQRVNeBMsHBYasxR/ljrBoAidmE31QP/9bRGKMCyrvqQoh8vjx0B0ApVSrlSqAvhBDispL2RyIZvyeR/PMJEr49grI40FCEkAu6BpoCOzTKz5/KATBoaDgIsueR/v425wKjTnCfOgRfXwf/dlUJ6BDr9YY3QojS56sX45Y2CfSFEEJUasqhOP3NYdJ+O82prw+RdyjLuUAHHK5czv8chfSq2RUa5yyzOcj8/iCZ3x0EwBATSOiQRgR0iCXs1sZoBhkdK0RZ8aUx+mVJAn0hhBCVUsovp0j87gjHP/kX64n83vqzA3lH4esW2Vll2E9lkzJjOynvbefkhNWEDWtKcL/6BPeqLT39QpQyq+5bn7H4+Hj++OMPANLS0gDYt28f4eHhXvO3bdu2WNvRVGkNChJCCCHKmDXVwqkvDnLkg3/I2p56Tq994TQchJB33jw6DgKxFL0yBsAOpoZhRN7bmrBhTTFGF36reyFE8fW956jr+fcf1izHmlyYruseB/9KKa8dAgXpdru9WNuSHn0hhBA+TSlF2m8JHJ25h5OfHHBfWBK99sWV/7ts3Z/GqYfXcerhdYTcWJ+I+64k6NpaaD7WAylEReZLQ3c+/vjjMtuW9OgLIYTwSZakXE7M+5cDz/2JPdOGZtRQtuL9pJVKj77XQpzDhzR/A1Weuorwu1tiig26tDKFEPQafdz1fNWs6uVYk4pFevSFEEL4DGV3kPzzSfY+/DvZ/6Sh7Mp1HW1xg/wylX+NgMq1k/D8RhKe34ipfhgxb3UlpG9dNJOhnCsohG/y9ek1S4sE+kIIISq89L1p7H3qD7J+OY31dG55V6dk5B+XWP9N4+jApejhfgS0q0rV16/Bv020XMArxEWw+9DQnbIkgb4QQogKKf1QJrum/k3a7wlk7s8gLCEPzQc67YvLkZpH1k9HONhuPsZ6IQS0jaHqix0xN4uUoF+IC7DLR8QrmeRXMHPmTNq3b8/x48cvnLmELF26lPbt27Nly5Yy26YQomJz2BWntyXz4/iNLLjuBxZct5Ijnx8gc39GeVetzNkOZpDx9X7+veIT9tWbzeG+35K17ijKWryZN4So7Ky67nqIM3y+R3/Lli2MHTuWBx54gOHDh5d3dTzMnz+fkJAQ+vfvX95VEUKICkU5FImHczi0PZ29n+7DsicZe/Y5gawG596n6nJjO5RB5qEMMpfHg78BU60QIu9tRWC3mvi3qiI35hICsJV3BSoonw/0K7rPP/+c2NhYCfSFEJc1h0NxOMnBX7+nYzycTsqBTA5vT8dhBzSIPpyEwV6ec2H6iFw71n2pnHpknXPqUINGYOfq+LWJxlQtiJCBDTA3DEczSvAvLi92Gd7mlQT6QghRxhbucfBvKtzcWKNhhIbdoZi7S5GcCyOaa1QN8v0frLQ8xcc7Ff4GOL0/iy/W52KxwYADh4myWNx76S+xx17B5XcZXsExkV2Rve4Y2b8cAwWnn1wPJp3QdqHUvDkchneHmPDyq2dJSc+G2T+B2Qj/1xP8THAsCeb/AtXCYVg3kEDvsmaTP79XlTLQP378OAMGDOCee+6hefPmfPjhh+zfv5+QkBD69u3L+PHjMRrP7Pro0aM5ceIEM2bMYMqUKWzduhWAq666igcffJCaNc/cYW3p0qW88MILfPDBB7Rv395tuwXlLF26FMC1/MSJE255lyxZQvXq55/jdeXKlXz55Zfs27cPu91Ow4YNGT58OD179nTL1759e2644Qb69evH9OnT2bt3L2FhYdxyyy3ceeedpKenM23aNH755Reys7O56qqrePrpp4mOjvbYZk5ODm+88QY//vgjmZmZNGzYkPHjx3P11Vd75N20aRPz5s1j165dWCwWateuzeDBgxk8eLBH3m+++YZPP/2U48ePExMTwy233EJwcPB591+Iyur1zQ6eWOeM0l77Hf4aaeCF3xz8b4cz2p25HbaPNBBo8t1fLbtDce1Xdv445Xx9RZIVS/55dYNSXgP7i431L8vg3sXL3p/dgFYHWRtPw8YlMOMH+GsqBPmXZQVLlsMB1z0PW/51vl6+DT55ADo+CUcSnWnbDsKUUeVXR1HubJfxN8L5VMpAv8D69etZuHAhN998MwMGDGDt2rV88sknhISEcNddd7nlzcnJYcyYMbRo0YL77ruPw4cPs3DhQnbs2MFnn31GlSpVLnr7L774IlOmTCE8PNxtexEREeddb/r06cyePZtOnToxduxYdF1n9erVTJw4kccff5xbbrnFLf+ePXv45ZdfGDRoEP369WPVqlW89957+Pn58d1331G9enVGjx7NkSNH+PLLL3n++eeZPn26x3aff/55dF1nxIgRZGdns2jRIu6//37eeecd4uLiXPkWLVrE5MmTadmyJXfddRcBAQFs2rSJV199lWPHjvHAAw+48s6fP58pU6bQuHFjxo8fT25uLp9++ukF20CIyuq7A2eGp6Tkwm/HFN8dOBOl7U+FPcnQJqYcKldCTmThCvIB0vPAXPDiEn6LL+/gvpgOnILdR6F9w/KuSfGdTD0T5AN8/wdsP3gmyAf4bosE+pc5q3w5eFWpB/EdOHCAuXPnMnbsWAYPHsw777xD/fr1+fLLLz3ypqamcu211/Laa68xZMgQHnnkEV555RWSkpKYNWtWsbbft29fAgICiIyMpG/fvq5HQEBAoev8888/zJ49m1GjRvHOO+9w++23c+uttzJz5ky6devG+++/T1ZWlts6+/fv5+233+a+++5j8ODBvPfee0RFRTFlyhSuvPJK3njjDYYMGcLDDz/M0KFD2bx5M/Hx8R7bNhgMfPTRR9xxxx3cc889zJkzB7PZzBtvvOHKk5iYyJtvvknv3r2ZPXs2I0aMYMiQIbz55pvceuutfPbZZxw9ehSAjIwMpk+fTr169Zg9ezbDhg3j7rvv5uOPP+bw4cPFatPSkpycTF7embtiZmZmkpFxZqYPi8VCUlKS2zonTpw47+uTJ09y9o2nZRuyjczMTFpFnLlkzKwrapvSaB9z5hcq0s9BvbCKvx/n20bVQKgReOai2gATorxEBkP9GJ/5fHjdRnQo1DnrLHS7+tCkBoQGnkm7qmHF34/LcBtlyapproc4o1IH+t27d3cbIqNpGu3btycpKYns7GyP/CNHjnR73aNHD+rUqcPatWtLva4Fli9fjqZp9OvXj9TUVLdH165dycrKYseOHW7rtGzZkhYtWrhem0wmrrjiCpRS3HrrrW5527RpA8CRI0c8tn377bdjMp35RY6JiaFPnz7Ex8dz8OBBAH788UcsFgs33nijR/2uueYaHA4HmzdvBmDjxo3k5uYyZMgQ/P39PcqtSCIjI/Hz83O9Dg4OJiQkxPXabDYTFRXltk5sbOx5X1erVs1t7mvZhmwjODiYqT39eKmLzqgWGisGG+jQIIJP++k8dpXG/7XUWHOriXB/7ZK2Ud5tZTZorL3dzJjWGg+01dwOXApTlJ9mrZDnl58i7H2QH/zfdbD6RYgM8ZnPh9dtmIzO/RjTGyb0g6VPQbUI+GkS3HUdPHUzzBpX8ffjMtxGWbKe9RBnVOqhOzVq1PBICwtz/uKkpaURGHimNyAkJMTr8Jx69eqxZs0acnJyztsTX1IOHjyIUsrrWPcC5x5Re9vP0NBQAI9rAQo+tGlpaR7r1KtXzyOtfv36ABw7dox69eq5zgTce++9hdYvOTnZtQ5A3bp1Cy1XiMuNyaDxdAf3QC3MT+P1boZyqlHpaBCu8UEv5z6NP2Bg/wlnD79SmvchOJcQuV/eQb935lbV4H9Dy7saJadeDHww1j2tfUP4yIeHJIkSlaTLN4E3lTrQ189z04SzT1ddjPPdndBuL5kbmWiaxjvvvFNo/Rs0aOD22mAoPEAobFlx979gvRdeeKHQ6xa8HXgIIS5f7/1fKCdSHOw9YWPnuuoEH04j7UAmmUnOvjfdoF32c+VfNKMONuf1HoboAPyurIIhMoDw25rg17IKprqh5VxBIcqWRQ75varUgf7FyMjIIDEx0SN4PXjwIJGRka7e/IKe8vT0dI8yjh8/7jabD5z/wMCbWrVq8dtvv1GtWjWvPeyl6eDBgzRu3Ngt7cCBA8CZ4L1WrVoAhIeHu12g603BOvHx8R4z9xSUK4So/DRNo3qkgeqRBrpfEQs4T++nnMjh5L5sjuxI58j8dDiVWb4Vrejybx6mBZsIH96MgGuqE9C2Kn5NIsu7ZkKUP4nzvarUY/Qv1ty5c91er169mkOHDtGtWzdXWu3atQFc49ALrFixgoSEBI8yAwICvB4UFKZv374AvP/++17PEJw7bKckzZ8/H6v1zOi2U6dO8cMPP1CnTh3XQUevXr0wm83MnDmT3NxcjzIyMzOxWCwAxMXF4efnx4IFC9zyFpQrhLi8RcQG0KxrFL3H1+P/1vfmtg196fpGOyIah2Dwy/95kp5+MOmYGoYRO/M6Gh26i2YZ44mdfi3htzWVIF+IApp25iFcpEc/X3h4OD///DMJCQm0a9fONb1mVFQUY8aMceWrW7cuV199NYsWLUIpRePGjdm7dy9r1qyhVq1a2GzuN2Fu2bIlixcvZsaMGdSrVw9N0+jatWuh4/2vuOIKRo8ezaxZs7j99tvp2bMn0dHRJCYmsnv3btavX8/GjRtLpQ3sdjt33303119/PdnZ2Xz99dfk5eXx2GOPufLExMQwceJEXnrpJYYMGULfvn2JjY0lJSWF/fv3s2bNGhYsWED16tUJDQ1l3LhxTJs2jbvuuou+ffuSm5vLokWLqFWrFnv27CmV/RBC+KbAaH8aDapDo0F1sOfZOb4xgV2v7yBnVyr2nJIZGukzzDp+TSKIfqEjwdfXQQ+UqYuEEBdPAv18AQEBrhtmvffeeyil6NixIw899JDHcJ4XX3yRN954gxUrVvD999/Tpk0bPvjgAyZPnuwxtdS9995LWloaCxYsICMjA6UUS5YsOe+FvaNHj6Z58+Z88cUXfP755+Tk5BAZGUmDBg149NFHS2X/wTnu/uuvv2bu3LlkZGTQsGFDnn/+eTp06OCWb8CAAdSuXZtPP/2URYsWkZGRQXh4OHXq1GHcuHFuV+UPGzaMgIAAPvvsM95//31iYmIYNmwYwcHBvPjii6W2L0II32bwM1CrWzVqdauGPc/OqZ9PsP/JrVh2poHD+023fFp+J6SxdghVJ3cm9MYGEtwLcTGkJ98rTRX3qsxK5Nw72gohhKiYLEm5nPr8IP8++ye2VAuaUUPZLv1nTMNBCHnnzaPjIBDLJW/LxaCBXaEFGol+Lo6wEc0xxQaVXPlCXEa0R1Ndz9Wb4eVWj4pGevSFEEL4DHOUP7Xua0at+5qRvjWJY7P2cuzDvWdum1vRu67OqmPo0MZEjmtFQOfqFz1xgxDiHPIZ8koCfSGEED4ptF0UoTM70uit9pz6Kp6j0/eQsTXJOc2Eo7xrdw4DYAdz4wgi77+SsDuaYAj3v+BqQogikjjfKwn0hRBC+DRjsIkadzWixl2NSFl3ktNfH+L4nP3Y023lG/QXTIcZaCT0jiaEDmpIcJ+60nsvRKmQz5U3MkZfCCFEpePIs3P47b9J/eU0icuPgp3zDu0psTH6BdvQIfC62gR2iCXqiXYYgszF2AshRFFpT5yZyly9JjeMKyCBvhBCiErNmpLHwZf/ImtXKkk/nQCrcl0IW+CSAv2Csgwagd1q4NcskirPxmGKkQtrhSgr2hMZrufqtZByrEnFIkN3hBBCVGqmCD8av3kVAPZsG8c+3EtOfCbJP54ga2eqe+bzXdCraR7LTA3DCLq+DuZaIYSPaYlRxt0LUT5k5I5XEugLIYS4bBgCjdR+oLnrtTXDQvbuNDL+SiF1/l78ov2wHMkka8Mpt/WC4qpirhuCdiKdyFsa4N+mKubmkRLYC1FRSKDvlQzdEUIIIc6R8Xci387/GoCBt99MSPMqF1hDCFGetCczXc/V5OByrEnFIj36QgghxDn8G4WRU1tzPRdCVHC6dOl7o5d3BYQQQgghhBAlT3r0hRBCCCGEb5MOfa8k0BdCCCGEED5OIn1vJNAXQgghhBC+TeJ8ryTQF0IIIYQQvk0Cfa8k0BdCCCGEED5OIn1vJNAXQgghhBC+TeJ8ryTQF0IIIYQQvk0Cfa8k0BdCCCGEEL5Nk0jfG7lhlhBCCCGEEJWQ9OgLIYQQQgjfJh36XkmgL4QQQgghfJxE+t5IoC+EEEIIIXybxPleSaAvhBBCCCF8mwT6XsnFuEIIIYQQQlRC0qMvhBBCCCF8m0yv6ZUE+kIIIYQQwrdJnO+VDN0RQgghhBCiEpIefSGEEEII4dukR98rCfSFEEIIIYSPk0jfGwn0hRBCCCGEb5M43ysJ9IUQQgghhG+TQN8ruRhXCCGEEEJUepMmTSI4OLi8q1GmpEdfCCGEEEL4NunR90p69IUQQgghhKiEJNAXQgghhBC+TdPOPIppx44dXH/99QQFBREWFsbgwYM5fPiwa/n//d//cc0117heJyYmous6V111lSstMzMTk8nEggULil2PkiRDd8RlTylFRkZGeVdDCFGBWK1WcnJyAEhPT8dkMpVzjYTwLSEhIWiXEHRftEvc1JEjR+jatSsNGjTg008/JTc3l6effppu3brx119/ERISQteuXfnss8/Izc3F39+fdevW4efnx7Zt28jIyCAkJITffvsNm81G165dS2a/LpEE+uKyl5GRQVhYWHlXQwhRQT344IPlXQUhfE5aWhqhoaFltj316KWFtFOnTsVqtbJy5UoiIyMBaNOmDc2bN2fOnDncf//9dO3alby8PDZt2kS3bt1Yt24dgwYNYuXKlaxfv54+ffqwbt06GjduTExMTEns1iWTQF9c9kJCQkhLSyvvapSbzMxM+vXrx7Jlyy672QjOJu3gJO1whrSFk7SDk7SDU1HbISQkpAxrdel++eUXrr32WleQD9C0aVNat27Nr7/+yv3330+9evWoWbMm69atcwX6Y8eOJScnh7Vr17oC/YrSmw8S6AuBpmll2utQ0ei6jsFgIDQ09LL+8ZJ2cJJ2OEPawknawUnawamytkNKSgpXXnmlR3pMTAzJycmu1wUBfnp6Otu3b6dr165kZWWxcOFC8vLy2Lx5M/fcc08Z1vz85GJcIYQQQghxWYuMjOT06dMe6adOnXLr5e/atSsbNmxgzZo1VKlShaZNm9K1a1d+//13Vq9eTV5entsFu+VNAn0hhBBCCHFZ69KlCz/99BMpKSmutD179vDXX3/RpUsXV1pBD/6UKVNcQ3SuvPJKAgICePXVV6lVqxZ169Yt6+oXSobuCHGZM5vN3HPPPZjN5vKuSrmSdnCSdjhD2sJJ2sFJ2sHJ19vBbrezcOFCj/QHHniAjz/+mN69e/P000+Tm5vLM888Q+3atbnzzjtd+Zo2bUrVqlVZu3Yt77zzDgAGg4HOnTuzfPly7rjjjrLalSLRlFKqvCshhBBCCCFEaZo0aRIvvPCC12WffPIJrVq14tFHH2X9+vUYDAZ69erFlClTqFOnjlveIUOGsHDhQv78809at24NwGuvvcbEiROZOXMmo0ePLvV9KSoJ9IUQQgghhKiEZIy+EEIIIYQQlZAE+kIIIYQQQlRCcjGuEJXcunXrmDFjBocOHaJatWrceeedDBgw4LzrWK1Wpk+fzs6dO9m9eze5ubn8+OOPhIeHu+WbOXMmH374ocf6EydOZPDgwSW5G5esNNsBYPv27UybNo29e/cSERHB4MGDGTlyZNneAr6IitMW4LxRzpQpU1izZg02m40OHTrw+OOPU6VKFVeeivieiI+P5/XXX+evv/4iKCiIvn37cu+992Iymc67nlKKuXPnsmDBAlJTU2ncuDEPP/wwLVu2dMuXkJDA66+/zqZNmzAajfTo0YOHHnqows0xXprtsGXLFsaOHeuxbq9evZg8eXKJ78ulKG47LFiwgPXr17Nz505SU1N59dVX6dmzp0e+yv5+KEo7+NL7obKTQF+ISuzPP//kscce48Ybb+SRRx7h999/57///S+BgYFef6AK5Obm8u2339K8eXPatGnDhg0bCs3r5+fHBx984JZWo0aNEtuHklDa7XDkyBHuv/9+4uLiGDduHPv27eO9997DYDAwfPjw0tqtYiluWwA8+eSTHDhwgCeffBKz2cz06dOZMGEC8+bNw2g883NSkd4T6enpjB07ltq1a/PGG29w+vRppk6dSm5uLk888cR51507dy4zZ87kvvvuo1GjRixYsID77ruPzz77jJo1awJgs9m47777AHjppZfIzc3l7bff5plnnmHatGmlvXtFVtrtUOD55593m1rQ20FxebqUdli2bBkAnTt3dj0/1+XwfihKOxSo6O+Hy4ISQlRa48ePV6NGjXJLe+qpp9TgwYMvuK7D4VBKKbVkyRLVrl07lZKS4pHngw8+UF26dCmRupam0m6Hl156Sd1www3KYrG40t577z3VvXt3lZeXd2mVL2HFbYvt27erdu3aqQ0bNrjSDh48qNq3b69WrlzpSqto74nZs2erLl26qNTUVFfa119/ra6++mp1+vTpQtfLzc1VXbt2Ve+9954rzWKxqBtuuEFNnjzZlbZ8+XLVvn17dfDgQVfahg0bVLt27dSOHTtKdmcuQWm3w++//67atWundu3aVTo7UEKK2w5KKWW325VSSh07dky1a9dOrVq1yiNPZX8/KFW0dvCV98PlQMboC1FJWSwWtmzZ4tFL27t3bw4ePMjx48fPu35FHHJSHGXRDr/99hvdu3d3O+Xdu3dvMjIy+Ouvv4pX8VJwKW3x22+/ERISQlxcnCutbt26NG7cmPXr15danS/Vb7/9xtVXX01YWJgrrVevXjgcDjZu3Fjoen/99RdZWVlubWUymejRo4fb/v722280atTIrdcyLi6OsLCwCtUupd0OvqK47QCg6xcOmSr7+wGK1g6i4pC/lhCV1NGjR7HZbB536KtXrx7gHJ9ZEvLy8ujZsydxcXEMGTKEb775pkTKLSml3Q45OTmcOnXKY57lunXromlaibVzSbiUtoiPj6dOnToeBz716tXzWK8ivSfi4+M99jckJIQqVapccH8Br2118uRJcnNzXfnO/dtrmkadOnUq1N++tNuhwAMPPMDVV19N3759efvttz2Wl7fitsPFlF+Z3w8Xq6K/Hy4HMkZfiEoqPT0dcH55ny00NNRt+aWoVasW999/P02aNMFisbBixQpefvllMjMzK8zY9NJuh4yMDK/lm0wm/P39S6SdS8qltEV6errHegVlnb1eRXtPFLXe3tYzm834+fl5rKeUIiMjA39/fzIyMryWHxoaWuH+9qXZDsHBwYwYMYK2bdvi5+fH77//zqeffsrBgwcr3Nj04rRDUVX290NR+cr74XIggb4QPiQzM5PExMQL5iurCx/79u3r9rpLly5YrVY++ugjbrvtNrcLNEtSRWuH8lTR2qK83hOifDVt2pSmTZu6Xl911VVUqVKF119/nZ07d9KiRYtyrJ0oa/J+qDjkG1cIH/Ljjz/y0ksvXTDfwoULXb20mZmZbssKemsKlpe0Xr168dNPP3HkyBHXkJCSVpHaoaBX7NzyrVYrubm5pdbOBcqqLUJDQzl16pRHekZGxgX3sSzeE4UJDQ312F+4cL1DQ0OxWCzk5eW59WZnZGSgaZrr7x4SEuK1/PT0dGJiYkpgD0pGabeDN7169eL111/nn3/+qTCBXXHboagq+/vhUlTE98PlQAJ9IXzIwIEDGThwYJHyWiwWjEYj8fHxdOzY0ZVe2JhbX1KR2iEgIICYmBiPca2HDh1CKVXq7VxWbVG3bl02b96MUsptnH58fDwNGzYsTtXLRN26dT3+NgVnQS60v+D8OzZu3NiVHh8fT7Vq1fD393fl279/v9u6SikOHTrkduFyeSvtdvAVxW2Hiym/Mr8fhO+Ri3GFqKTMZjPt27fnp59+cktftWoV9erVo3r16qWy3R9++IGQkBBq1apVKuVfrLJoh06dOrFu3TpsNpsrbeXKlYSEhNC6detLLr+kXEpbdOrUifT0dDZv3uxKO3ToEHv27KFz587n3W55vic6derE5s2bXddSgPMsiK7rdOjQodD1WrVqRVBQED/++KMrzWazsXr1arf97dSpE/v27ePw4cOutM2bN5OWlnbBdilLpd0O3vzwww8ANG/e/BJrX3KK2w4XU35lfj9cior4frgcSI++EJXY3XffzZgxY1x3Lty6dSsrVqzwuDNhXFwc/fr147nnnnOlrV+/npycHP7++2/AeTfVwMBA6tevT/369QEYNmwYN9xwA3Xr1iU3N5cVK1awevVqHnnkkQo1Fru022HEiBGsWLGCp556iiFDhrB//34++eSTIt1lsqwVty1atWpFx44defHFF3nooYdcN8xq1KgRPXr0cK1X0d4TN998M19++SWPPPIId911F6dPn+btt9/mpptuIjo62pVv3LhxnDhxgm+//RZw3vRr1KhRzJo1i4iICBo2bMiCBQtIS0tj2LBhrvV69uzJxx9/zOOPP8748ePJzc1l2rRpdOnSpUINTyjtdnj22WepWbMmTZs2dV18OX/+fLp3716hArvitgPA33//zfHjx0lNTQVg586dAERERNCuXTug8r8foGjt4Cvvh8uBppRS5V0JIUTpWbt2LTNmzODQoUNUq1aNO++8kxtvvNEtT/v27bnhhhuYNGmSK61///6cOHHCo7x77rmHMWPGAM47pe7atYukpCQAGjZsyK233sp//vOf0tuhYirNdgDYvn07U6dOZe/evURERDBkyBBGjhxZIe9HUNy2yMzMZMqUKaxevRq73U5cXByPP/64W2BQEd8TBw8e5I033mD79u0EBQXRr18/j4Ow0aNHc+LECZYuXepKU0oxZ84cFi5cSEpKCo0bN+bhhx+mVatWbuWfPn2aN954g02bNmEwGOjRowcPP/wwwcHBZbaPRVGa7fDxxx+zfPlyTp48icVioXr16vTp04dRo0ZVuIPd4rbDpEmT+O677zzKa9u2LbNmzXK9ruzvh6K0gy+9Hyo7CfSFEEIIIYSohGSMvhBCCCGEEJWQBPpCCCGEEEJUQhLoCyGEEEIIUQlJoC+EEEIIIUQlJIG+EEIIIYQQlZAE+kIIIYQQQlRCEugLIYQQQghRCUmgL4QQQgghRCUkgb4QQhTTnXfeWWHufLtz506MRiOrVq1ypa1ZswZN05gzZ075VUxUCHPmzEHTNNasWVOs9eW95N2ff/6JruusXbu2vKsihFcS6Ash3Bw4cIDRo0fTtGlTAgMDiYiIoFmzZowcOZLVq1e75a1bty4tWrQotKyCQDgxMdHr8t27d6NpGpqm8csvvxRaTkGegoe/vz+NGjXi4YcfJjk5uXg7Wsk8/PDDdO7cmV69epV3VcpEfHw8kyZN4s8//yzvqogykpqayqRJk4p9sFJc53uvXXnllQwcOJBHHnkEpVSZ1kuIojCWdwWEEBXHli1b6NatGyaTiREjRnDFFVeQk5PDvn37WLlyJSEhIfTo0aPEtvfRRx8REhJCQEAAs2fP5pprrik075VXXskjjzwCQHJyMt9//z1Tp05l1apVbN26FbPZXGL18jUbNmxg1apVfPvtt27pXbt2JScnB5PJVD4VK0Xx8fG88MIL1K1blyuvvLK8qyPKQGpqKi+88AIA3bt3L7PtXui99uCDD9KtWze+//57+vXrV2b1EqIoJNAXQri88MILZGdn8+eff9K6dWuP5SdPniyxbVmtVj755BOGDBlCWFgYs2bN4p133iEkJMRr/ho1ajBs2DDX6wkTJtC/f3++++47Fi9ezJAhQ0qsbr5m+vTpVKlShb59+7ql67qOv79/OdVKiMvDNddcQ926dfnggw8k0BcVjgzdEUK47Nu3j6ioKK9BPkC1atVKbFtLly7l9OnTjBw5kjvvvJOsrCy+/PLLiyrj+uuvB2D//v2F5pkxYwaaprFkyRKPZQ6Hg5o1a7r10q1cuZKhQ4dSv359AgICCA8Pp3fv3kUeg9u9e3fq1q3rkR4fH4+maUyaNMktXSnFjBkzaNeuHYGBgQQHB9OjRw+PYVKFsdlsfPvtt/Ts2dOj597buOqz06ZPn06TJk3w9/enZcuWfPfddwDs2LGDPn36EBoaSlRUFBMmTMBqtXrdzwMHDnDjjTcSFhZGaGgogwYN4sCBA255HQ4HL7/8Ml27dqVatWqYzWZq167NuHHjSEpK8rpfX3/9Nd27dyc8PJzAwECaNGnChAkTsFgszJkzx3VmadSoUa4hXUXp5Y2Pj2f48OHExMTg5+dHgwYNeOqpp8jOznbLN2nSJDRNY8+ePTz11FPUrFkTPz8/Wrduzffff3/B7cCZcfE//fQTL774InXq1CEgIIC4uDg2btwIwNq1a+nSpQtBQUHExsby3//+12tZ3377LZ07dyYoKIjg4GA6d+7M4sWLveb98MMPadq0KX5+fjRs2JBp06YVOqwkLS2NJ554goYNG+Ln50d0dDS33Xabx9/wYhW1nc93nYumadx5552A831br149wNkhUfA3L/isnf35+vzzz2nVqhX+/v7Url2bSZMmYbPZ3Mou6ue0KO81TdO4/vrrWbFiBZmZmRfZUkKULunRF0K4NGjQgD179rBo0SJuuummIq1jt9sLHYOfl5dX6HofffQR9erV45prrkHTNNq0acPs2bO5++67i1zfffv2AVClSpVC89x666089NBDzJs3jwEDBrgt++mnnzh27JhrSBA4f9iTk5MZMWIENWvW5NixY/zvf//juuuuY/Xq1ecdXlQcw4cP5/PPP2fw4MGMGjWKvLw8PvvsM3r16sWiRYs86nyurVu3kpmZydVXX31R233//fdJSUnh7rvvxt/fn3feeYdBgwaxYMEC7rnnHm677TYGDhzIypUreffdd6latSrPPPOMWxlZWVl0796duLg4Jk+ezL59+5g+fTobN25k27ZtrgNDi8XCG2+8wc0338yNN95IUFAQv//+Ox999BG//vqrx9Crp59+mldeeYXmzZvz0EMPERsby7///svXX3/Niy++SNeuXXnqqad45ZVXGD16tOtvEhMTc959PnToEFdffTVpaWnce++9NGrUiDVr1jB58mTWr1/PTz/9hNHo/rM4cuRITCYTjz76KBaLhWnTpjFw4ED27t3rNVD0ZuLEidjtdh544AEsFgtvvfUWvXv3Zt68efzf//0fo0eP5o477uCrr77iueeeo169em5nr6ZPn8748eNp2rQpzz33HOB8nw4cOJCZM2cyevRoV95p06bx0EMP0bp1a1555RWys7N58803qVq1qke90tLS6NSpE4cPH+auu+7iiiuu4MSJE0yfPp24uDi2bNlCnTp1irSPl9rOF9KsWTOmTp3KQw89xKBBg1zfT8HBwW75lixZwoEDBxg/fjzVqlVjyZIlvPDCCxw6dIiPP/74ovelqO+1jh07MnPmTH799Vf69Olz0dsRotQoIYTI99tvvymTyaQA1ahRIzVq1Cg1ffp09ffff3vNX6dOHQVc8JGQkOC23rFjx5TBYFDPP/+8K23atGkK8LotQPXu3VslJCSohIQEtXfvXjVlyhRlMplUWFiYOnXq1Hn3a/DgwcrPz08lJye7pQ8bNkwZjUa39TMzMz3WP3nypIqKilL/+c9/3NJHjhypzv0a7datm6pTp45HGQcPHlSA2z4vWrRIAWrmzJluea1Wq2rXrp2qW7eucjgc59232bNnK0AtXrzYY9nq1asVoD7++GOPtOrVq6vU1FRX+vbt2xWgNE1TX3/9tVs5bdu2VdWqVfPYT0A98MADbukF+zRmzBhXmsPhUNnZ2R71+9///qcA9eWXX7rSNm3apADVo0cPlZOT45bf4XC42sPbvl3I7bffrgC1bNkyt/RHH31UAep///ufK+35559XgOrXr5/b32Dz5s0KUBMnTrzg9j7++GMFqDZt2qi8vDxX+uLFixWgjEaj+v33313peXl5qlq1aqpDhw6utOTkZBUUFKQaNGig0tLSXOlpaWmqfv36Kjg4WKWkpCillEpJSVGBgYGqWbNmKisry5X3yJEjKigoSAFq9erVrvQJEyYof39/9eeff7rVOz4+XoWEhKiRI0e60i6mvS+mnb19hgoAbnXw9hk6d5mu62rr1q2udIfDoQYOHKgAtWHDBlf6xXxOi7Lvv/zyiwLUm2++WWgeIcqDDN0RQrh07NiRrVu3MnLkSNLS0vj444+59957ad68OV27dvV6Or9u3bqsWrXK66N3795etzNnzhwcDgcjRoxwpd1xxx2YTCZmz57tdZ2VK1cSHR1NdHQ0jRs35uGHH6Z58+asXLnSa2/l2UaOHEleXp7b0KDMzEy++eYb+vTp47Z+UFCQW56kpCQMBgNxcXFs2rTpvNu5WJ9++ikhISEMHDiQxMRE1yM1NZX+/fsTHx/vOmtRmISEBAAiIyMvatt33nknYWFhrtetWrUiNDSU6tWre5zN6dKlCydPnvQ6LGHixIlurwcNGkSTJk3cLgzWNI2AgADAeQYoNTWVxMRErr32WgC3dv3ss88AmDx5ssf1BQXDJorD4XCwZMkS2rRp43Etw5NPPomu63zzzTce6z3wwANu27zqqqsIDg6+4N/lbOPGjXM7Y1HQKxwXF0f79u1d6Wazmauvvtqt7FWrVpGVlcWECRMIDQ11pYeGhjJhwgQyMzP58ccfAednJDs7m/HjxxMYGOjKW7NmTe644w63Oiml+Oyzz+jatSs1atRwe/8FBQXRoUMHVq5cWeR9LFDcdi4pvXr1om3btq7Xmqbx+OOPA5TqdqOiogA4ffp0qW1DiOKQoTtCCDctW7Z0jek+dOgQa9eu5X//+x+//PILN954o8cwi6CgIHr27Om1rE8//dQjTSnF7NmzadWqFQ6Hw218fefOnfnkk0+YPHmyx6n9uLg4XnrpJQD8/PyoU6cOtWvXLtI+FQTz8+bNY+zYsYBzDHhWVpbbwQbAv//+y9NPP80PP/xAamqq27KSnjN/9+7dZGRknHfIyalTp2jcuHGhywvqpC5yar/69et7pEVERFCrVi2v6QBJSUluQyXCw8O9XrfRrFkzvv32W7KyslwHTl999RVvvfUW27Zt8xjvn5KS4nq+b98+NE0r9DqR4kpISCAzM5MrrrjCY1lkZCSxsbFeD2S9tVNUVFSh1xZ4c24ZBe1ZMOb83GVnl33w4EEAr/UuSCuod8H/TZs29cjbvHlzt9cJCQkkJSW5DqC90fWL7wssbjuXlGbNmnmkFex7aW634PNXUe6rIUQBCfSFEIWqU6cOI0aMYPjw4VxzzTWsX7+ezZs306VLl2KXuXbtWv79918AGjVq5DXPd999x8CBA93SqlSpUugBxYUYjUZuv/12pk2bxv79+2nYsCHz5s0jIiLCbQx8ZmYmXbt2JSsriwcffJCWLVsSEhKCrutMnjyZn3/++YLbKuyH/tyLAcEZHERHRzN//vxCyzvffQoAV5B2sfcTMBgMF5UOF38wUWDRokUMHTqUq6++mrfffptatWrh7++P3W6nT58+OBwOt/yX0nNf0gprj4tpi+K0dWkrqH/Pnj154oknyq0eF/N5qcjbLfj8FXbQJER5kUBfCHFBmqYRFxfH+vXrOXbs2CWVNXv2bPz8/Jg3b57XHsMxY8bw0UcfeQT6l2rkyJFMmzaNefPmcc8997BmzRpGjx6Nn5+fK89PP/3E8ePHmT17NqNGjXJb/9wLUQsTGRnJ1q1bPdK99SY2atSIvXv30qFDB4+LCouq4EDgYoaSlJTU1FROnjzp0au/e/duqlat6urN/+STT/D392f16tVuQ0r++ecfjzIbN27M8uXL2b59+3kvML7YA4Ho6GhCQkLYtWuXx7KUlBROnDhRIefjLzgbsGvXLq677jq3ZX///bdbnoL///nnn0LzFoiOjiY8PJz09PRiH0B7c7HtXDDkLDk52W34mbfPS1H+5rt37/ZIO7edCrZb1M9pUbZbcGbyQgfmQpQ1GaMvhHBZtWqV1x6tnJwc13jdc4cAXIy0tDQWLlxI7969ueWWWxg8eLDHY8CAASxfvpwTJ04UezveXHnllbRq1YpPP/2UTz75BIfDwciRI93yFPSwnttbu3LlyiKPz2/cuDEZGRls3rzZleZwOJg6dapH3hEjRuBwOHjyySe9lnXq1KkLbq9NmzaEhoa6pmssa6+++qrb62+++YY9e/a4HagZDAY0TXPruVdKuYZine32228H4KmnnsJisXgsL/jbFBwYFfVMhq7r9O/fn23btrFixQqPfXA4HAwaNKhIZZWlXr16ERQUxLvvvktGRoYrPSMjg3fffZfg4GDX3ZB79epFQEAA77//vts0lkePHvU4a6TrOnfccQebN29m4cKFXrddnPHmF9vOBcPSCq4zKPDWW295lF2Uv/mqVav4448/XK+VUrz++usAbu/Ji/mcFmW7GzduxGg00rlz50LzCFEepEdfCOHy0EMPkZSUxIABA2jZsiWBgYEcOXKE+fPns3fvXkaMGEHLli2LXf7nn39OTk4ON998c6F5br75ZubMmcPcuXM9LvS8VCNHjuSRRx7htddeo3HjxnTo0MFteZcuXahWrRqPPPII8fHx1KxZkz///JNPPvmEli1bsmPHjgtuY/To0bz11lsMGjSIBx54ALPZzMKFC70eQBVMqfnee+/xxx9/cMMNN1ClShWOHj3Khg0b2L9//wXHFRsMBm666Sa+/fZb8vLy3M5QlLYqVaqwaNEijh8/Tvfu3V3Ta8bExLjdL2Dw4MF8/fXXXHvttYwYMQKr1cq3337rMac6wNVXX80TTzzBa6+9Rtu2bRk6dCjVqlXj4MGDLFy4kM2bNxMeHk7z5s0JCQlh+vTpBAYGEh4eTtWqVV0X+HrzyiuvsGrVKgYOHMi9995Lw4YNWbduHV9++SVdu3b1OPCrCMLDw3n99dcZP348cXFxrnnl58yZw/79+5k5c6brouqIiAj++9//8uijj9KpUydGjBhBdnY2H3zwAY0aNWLbtm1uZb/88susX7+eW265hVtuuYUOHTpgNps5dOgQ33//Pe3atXO7B0NRXUw733bbbTz11FOMHj2af/75h8jISFasWOF1yt6oqCgaNmzIF198QYMGDYiJiSEoKIj+/fu78rRu3Zprr72W8ePHExsby+LFi/nxxx8ZPnw4HTt2dOW7mM/phd5rSilWrFhBnz59in1mTohSUy5z/QghKqQffvhB3XvvvapVq1YqKipKGQwGFRkZqbp3764++ugjZbfb3fLXqVNHXXHFFYWWVzB1XsH0mu3bt1dGo9Fjmsuz5ebmqpCQENW4cWNXGvnTHF6qkydPKqPRqAD10ksvec2zfft2df3116vw8HAVHBysunXrptatW+d1GsDCpgZctmyZat26tTKbzSo2NlY9/vjj6p9//il0asB58+apLl26qJCQEOXn56fq1KmjBg0apL744osi7VfBlJQLFy50Sz/f9JrepgqsU6eO6tatm0d6wVSTBw8edKUVTE/477//qgEDBqiQkBAVHBysBgwYoPbt2+dRxqxZs1SzZs2Un5+fqlatmrrnnntUUlKSxxSKBebPn686deqkgoODVWBgoGrSpIl64IEH3KapXLZsmWrTpo3y8/NTgNe6n+vAgQNq2LBhKjo6WplMJlWvXj315JNPuk1HWdg+X6idzlUwvebZU1oWKGy/C3tPLVq0SHXs2FEFBgaqwMBA1bFjR/XNN9943e4HH3ygGjdurMxms2rQoIGaOnWqaxrWc+uSlZWlXnzxRdWiRQvl7++vgoODVdOmTdXdd9+tNm7c6Mp3sdOZFrWdlVJq48aNqlOnTsrPz09FRUWpe+65R6WkpHhto02bNqlOnTqpwMBABbimyDx7Wsz58+erli1bKrPZrGrWrKmeffZZZbFYPLZ7MZ/T873X1qxZowD13XffFalthChLmlLFvLpKCCFEhdGnTx+ysrL45ZdfymR73bt3Jz4+nvj4+DLZnhDnEx8fT7169Xj++ec97j5d2gYNGsSRI0f4/fffK8xF5EIUkDH6QghRCbz11lts2LChWHOfCyGKZ9u2bSxevJi33npLgnxRIckYfSGEqASuuOKKUp+SUAjhrk2bNh7TwwpRkUiPvhBCCCGEEJWQjNEXQgghhBCiEpIefSGEEEIIISohCfSFEEIIIYSohCTQF0IIIYQQohKSQF8IIYQQQohKSAJ9IYQQQgghKiEJ9IUQQgghhKiEJNAXQgghhBCiEpJAXwghhBBCiEro/wEursnrFCHxwwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAvoAAAErCAYAAACvlSfCAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/w0lEQVR4nO3dd3wUxfvA8c9eTSeFkARCQpciTZAuWAARBEFBUSniTyn2Lnb0ay+IDQUVBRULiIIgCCpFkSKI9A4BDC29l7vb+f1x5MiRC4T0C8/79Tq43Zudnbm9yz07OzOrKaUUQgghhBBCiBrFUNUFEEIIIYQQQpQ/CfSFEEIIIYSogSTQF0IIIYQQogaSQF8IIYQQQogaSAJ9IYQQQgghaiAJ9IUQQgghhKiBJNAXQgghhBCiBpJAXwghhBBCiBpIAn0hhBBCCCFqIAn0hRBCCCFEjTdp0iQCAgLO+VpcXByapjF37tzzyr+021UkU1UXQAghhBBCiOoiKiqKNWvW0KxZs6ouSplJoC+EEEIIIcQpVquVLl26VHUxyoV03RFCCCGEEOIUT11w8vPzue+++wgNDSU4OJhx48Yxe/ZsNE0jLi7Obfvc3FzuueceQkJCiIqK4pFHHsFut1dyLZwk0BdCCCGEEBcMu91e5KHr+lm3mThxItOmTePxxx/n22+/Rdd1Jk6c6DHtU089hcFg4LvvvmP8+PG89dZbfPLJJxVRlXOSrjtCCCFEObPZbHz22WcAjBkzBrPZXMUlEqKG064//VzNKzZZVlZWsd9Hf39/j+uTk5P58MMPefrpp3n88ccBuPrqq+nduzdHjhwpkr5z5868++67APTp04fly5czd+5cxo8fX9LalBsJ9IUQQgghhJfTSpTK19eXVatWFVk/ffp0Zs+e7XGbrVu3kpuby6BBg9zWX3fddfz2229F0vft29dtuWXLlvz+++8lKl95k0BfCCGEEEJ4uZIF+gaDgY4dOxZZv3DhwmK3OXbsGADh4eFu6+vUqeMxfXBwsNuyxWIhNze3ROUrb9JHXwghhBBCeDmt0KN8RUVFAZCQkOC2/uTJk+W+r/Imgb4QQgghhPByFRfoX3zxxfj4+DB//ny39T/++GO576u8SdcdIYQQQgjh5co/wC8QFhbGhAkTeOmll/Dx8aFdu3bMmTOHPXv2AM7uQNVV9S2ZEEIIIYQQJVJxLfoAr776KmPHjuWVV15h2LBh2Gw21/SatWrVqpB9lgdNKaWquhBCCCFETSLTawpRybSbTz9XX1fKLkeOHMmff/7JwYMHK2V/pSFdd4QQQgghhJeruK47ACtXrmT16tV06NABXddZuHAhX331FZMnT67Q/ZaVBPpCCCGEEMLLVWygHxAQwMKFC3nttdfIycmhYcOGTJ48mQceeKBC91tWEugLIYQQQggvV7GBfocOHfjrr78qdB8VQQJ9IYQQQgjh1VShQL9iQ37vIoG+EEIIIYTwchLeeyKBvhBCCCGE8GrSou+ZBPpCCCGEEMLLSXjviQT6QgghhBDCy0mg74kE+kIIIYQQwqspCfQ9kkBfCCGEEEJ4OQn0PZFAXwghhBBCeDVV1QWopiTQF0IIIYQQXk1hqOoiVEsS6AshhBBCCC8nXXc8kUBfCCGEEEJ4NRmM65kE+kIIIYQQwstJoO+JBPpCCCGEEMKrSYu+ZzJyQQghhBBCiBpIWvSFEEIIIYRXkxZ9zyTQF0IIIYQQXk2m1/RMAn0hhBBCCOHlpEXfEwn0hRBCCCGEV5OuO55JoC+EEELUULqusNsVSnc+10/9n5+vYzQa0LRT7aAaKKXQNA2L1YDZpGEwgqZJ8CSEN5NAXwghhKhASikcdmfA7bDp2O2KnFwdpTRsNmfQbbMpEk/kY7YYQEF+vsKWr5OaYic50U5ImIn8PGfa/Dydg/tyCQkz4XDgWp+eakdXYDBoOBzOfer6+RS06FR8BiMoHfwDDPj6GfHxNeDnbyAn20FgkInoWCv+gUYCg4z4BRgwGDRiGvgQWMuIwSAnCaLySIu+Z5pSSlV1IYQQQojzpZQiL0cnJ8tBTrqd9MOZ+Fo1bNkObLkObDkOTmxPwz/MimbUcOTrOPJ1Uk/mk5UPAZG+6A6F7lDYch0kHswitJ4vClC6QjkUGcdysJg1zH5G5zodsvI1TmDFN8RyupXcoZOV4cBiNaAA3a6w2Rwoh4Z2RgBi1zQyfaxF6qMp91BF06DgF9poLKgz5xe8nwdNnX8vZ6PRc5kMBggIMhIaZiY/X6dxM19iGloJj7BQO8JMaG2TnAiIcpWlPeB67q+mVFk5qhtp0RdCCFFt5OU5W7HTUhykJNvYtiWboFpGsjJ10tPspKU6yDyUiSnPjsOmXIGwb04uYcmp7plpgO7832A8HVRmmy3YLWa0HZmgTgXTp4LsjJP5blkYbfYiwW+Wrw9ZARayjudzphx74YjX8ywgqpjuMGeuLdwM53B43KTKFVcuXYf0VAfpqc4ER4+4v1eaBlYfAxe18iWqnpXIehai6lmoU9eMr6+xoostaiBp0fdMAn0hhBCVQilFerqD/XtyyM3VSUtxkJxkJ/GkjcOH8sjIcKB7CBwNp+LlglbjoBwH6O4XozVPzdzq9P+6vVD6U798qiQt41qhfES5UQpyc3S2bMxi26YstxOGWiFGGjTxITrGSnSslahoC+ERZoxGmT5RFE8Cfc8k0BdCCFFuHA7FySQHR0/aOXQknz3/ZuJvhuPH8klKtGO3nY6aDQZny+65WqvPjOHl57zmUKro8U9LcbBlQxZbN2a5jr3RCLGNfYht5ENMQysxDX2IrGfBaJRPg3CSQN8zCfSFEEKcF4euOJyq2JvgYE+izt5Enb1bs/FPzCMvW3cFZ1a7g5D8ot1bClRUX3Ph/ZQq2nXpwJ5cDu3PdZ0YaBrENLTSsKmz/39sYx8i60rwf+GS4+6JBPpCCCGK0HXFoRSdf485SMiEPQkO9iTobDthJy75dG8WDTAZoG1aPga7RO6iYhVu/VcKDh3I479DeW7r60ZbuOhiP2Ib+RDb2EpElEUG/l4ApEXfMwn0hRDiAmV3KI6kKfYn6izebSMrX3E8Q7HrpE5csk5eoeDJbAC7XrS7ugJsEt+LKnRm15+j/+Vz4li+a73BCMEhJtpdGkBsIx/qN7QSWVeC/5pGAn3PJNAXQogaStd1krIhLkXnYLLOwWTFjhMOfttrx6DB0XSFo1DkXvAz6WnsqQTzwpsUDv51ByQn2lm5NNW13mgCHx8Dl3QOJKahlegGVurVt2KxyoBf7yWBvicS6IsKs2HDBsaPH89zzz3HwIEDq7o4QtQ4NociPk3nSKrit302jKeC94PJOvsTdQ6m6DjU6R8/46l52YuL2WVyGVGTFQ7+HXbIytRZvTyNP35zrtM08PHViG7gQ/NWftStb6FufSvhEWZp/fcC8vfLMwn0hRCimlFKkZEPuxMcpGTpnMhQxKc5g/ptxxxsO+EATSMpS7n9uBk0ZzDv1vpeKD5xyC+hEG4KDwhXCnKyFXt35LB/V47rNYMBfHwNtGjjR2RdC5F1LUTUtRAeKXP+VyfSdcczCfSFEKKS5NkVR9N1/kuH9Hw4kak4nqk4kqbze5wixFfjWKbiZBbk2oHMXFd0bjI4Y3abTnH3YUJXRaaXF0KUQuETAF2H7Cydf9Zmohlwu9eDr5+BiLoWIqLMhEdY8PUzULuOmfoNrNQKMckMQJVIFfeH8QIngb6oUkopcnJy8PPzq+qiCFFqNodi+X4HxzMViVmKhCxFYrZi1SEdq0kjLQ+SshVZNpzReqE7o5oMzkvODk93Ziq0KBPaCFG1lAJ1xsDfnGyduH25HD6QC5r7SYCmQUCQkVq1TNgdihat/QgOMVErxERQsJGQMBORdS1oxdwpWZwfadH3TAJ9UWkK99nPyclhzpw5/Pfff9x2222MGzeuqotXrp5Y5WDmdkWzEJh9rZG6AfIHqCabv8PBsNm5gLPrjEFzxuh2TTvn+DBXAC+NURc8heePS3Hry7Yz5XbCWaH7KisvKGvBFYDCZVIKMtIcZKQ5o/+Tx/Odd2kudNJ+212RdOkZVKllFRcWCfRFpfv6669JS0tj8ODBhIWFERERUdVFKle/HNR5db2zKfZYFjy6UuerAdKPsybLtZ9ueneoQn3h5bB7VNYA7fx6J5Vtb9UpmKxO5H05f/oZVwM0DbKzznFbaFFi0qLvmbQhiUp3/PhxvvjiC+68806uv/56unfvXtVFIjk5mby8PNdyZmYmGRkZruX8/HySkpLctjl27JjH5eRc97xTcst/HwWOHz+OKnT7SNlH1e5D1EAy5kFUAvmbWHYKzfUQp0mLvqh0AwYMIDQ0tKqL4ebM8gQEBLgtWywWwsLC3NZFRUV5XB7UWKNjBGw4Af5meOxSrdz3USAyMrLC6iH7OP99iJKp3J/hsu1N8zB0QojyJn8Ty4ME+J5IoC8qXUxMTFUXoUL5WzRW32JkRxLUC4BwP/njc6EwaDLrTWWoqd+o4upVIfUtZgBoSfdVqcegjGWtTCUpk6Y5p+x0OJD5+cuR/On1TAJ9Uel8fHyquggVzmLUaFenqkshKkufJkYe6G7meIbiRKbOiYLZd/KK//ExG8CunAP2hBA1m6ZBaG0TwaEmQsLM1Ao2EhxqomO3wKouWo2hS290jyTQF0KIMooINPD2tdYi65VSZOTBySzlfGQqticoDqUqrCbnPPr/pSsOp8OxTIXuoT2wYDZOuVIgRPVgMJyaarPQd9LXz0B4hBmrj0ZIqJkmLXwJDTMTUttEaJgJXz8ZmV/x5OqIJxLoCyFEBdE0jSAfCPLRaHKqa+vgs6TPylccy1Qcy4CjGYo/DkBeroOsPMXhFJ3DqTrH0hX2Qj9oGs4pPe1yIiBEuTIYQemnA3qLVSMiykLd+s474xqNGs0v9qNOpFkC+WpABuF6JoG+EEJUE/4WjSahGk1OjYm76eKiwYNSisQsnaPpcCRV50iqzuEUBz/vsmM2ahxL1zmeodyuAJhOXdGWm24JUZSmnbpqdur7YTRBdKyV+rE+1K1vIaqehbA6ZsIjzHJzq2pM2jo8k0BfCCG8iKZphAcYCQ+AtnVPnwi8MuB0GrtDcTRdsSneQVyKTlqu4mCyzr5End0nHSRkF8oP54mATU4CxAXgzG43tYKNNGjiQ/0GPkQ3sFI32iIBvZeSFn3PJNAXFaZjx45s2LCh2GUhRMUwGTViQjRiQjwPTsu3Kw6l6OxP0jmQ7Pz/5502MvPhZKYi/8wb+yCtZcL7nBnU165jomFTX2IaWolp6EO9GAsBgRIG1RwS6Hsin3AhhLjAWEwaTcONNA0/fUXgrYG+AOi6Ij5dsS9RZ90RO+sPO9AV7DihE5eiYzt1EiBXAkR1ohmc/ekLhIWbaNjUhwaNfanfwEK9+lYCgiTkqcmkRd8z+dQLIYRwMRg06gdr1A82cEUT958Ih674L03x614bOTbYn6Sz66TOrpMO8rMKDRA+NU849kouvLggnBnUh4QVBPU+hIaZaNHGD/8ACW8uNHLV0TP5JgghhCgRo0EjNkTj/zoVnUo0zxZAYrKD4wkOjp60c+yknbi4XJJ221F2Hd3hIUMhzsFgxO2zExZuomETH+rGWKkVbKTdpYH4B8iMN0Lm0S+OBPpCCCHKzGo2UC/CQL0IMx3OeE3XFakpdhJP2kk4aePfjZloGqSnO0hKsJGW6nDNeAKF7hyq47GZTlruah7NABTqT28yaURFW4hpZCUw0EjDpj40a+kn01iKs5CuO55IoC+EEKJCGQwaoWFmQsPMNGvhS/deQW6v67oiOcnOiWP55ObqpKY4SE2xk5RoY9eOHHx9DWRlOsjO0tF1z4F+wSwpBpPmDBZ1JXcdroaMRnAUaqE3mTTCI83Ui7EQeWpu+vadA6gTacFgkMBNlJx83T2TQF8IIUSVMhg0aoebqR1uPms6pRQ52TqJJ/Nx5DjIz9XJzXKQk6WTmZBL+lY/atcxY8t2YMtxYMuxk7AzHWuQGc2g4cjXceTrkAu5Jg2D2YDSFbpDObuHOIqGCoqi7YQGXXdediijgvnbC7LS7afuhHxGH3RvUFAHTydXmgYhoSbqN7QSHuGcvjIkzERIbRP16lsloBflwtsH48bHx7Nq1SpOnjzJDTfcQHR0NA6Hg7S0NGrVqoXRWLqrWRLoCyGE8AqapuHnbySmoW8xKeqVeR9KKefdUHWFriscNoWmgXI4rxAoXaF0RZ4NNKPmvMKgK3QdsjPsmK0augPy8uws/GkR9nwTl/e8Al9/C3abwmFX5OU6OPyfjdAoKzabwpavsNkURw7m4utnwGzWsOUr8vJ0UpLtZKQ58A8wkJfnTJuf7yA/r8xVLRsNLBaN0NpmgmoZCaplwuKjkZOtc3E7f0JCTQSHmQgJNUl3G1EpvDXQV0rx8MMP8/7772O329E0jdatWxMdHU1mZiYNGjTghRde4IEHHihV/hLoCyGEEKdomoZmBIwaRsBcdNwxAP4e155ObLPZ8AvNAKBt91qYze5XK7qWQ1l1vSDwV9hsOlmZDhw2BZqGzaawnzqpSDhhI7S2GV3HefVCh2PxeQSHmLD6GFyt8TnZDvJzFXWiLJhMGiazhsmkkZOlUzvShK+vER9fAz4+Bowm7wyqRM3lrYH+G2+8wTvvvMPjjz/OVVddRZ8+fVyv1apVi+uvv57vv/9eAn0hhBDiQmIwaFh9NKw+AEZCw87e9UmImsxb++h//PHHjBo1ipdffpmkpKQir7dp04bFixeXOn8J9IUQQgghhFdTXjq95pEjR+jWrVuxr/v7+5Oenl7q/CXQF0IIIYQQXs1bu+7UqVOHI0eOFPv6xo0biYmJKXX+3nn6I4QQQgghxCmq0MObXH/99Xz00UccOHDAta5guuClS5fy+eefM2zYsFLnL4G+EEIIIYTwagrN9fAmzz//PFFRUbRr145Ro0ahaRqvvfYaPXr04JprrqFNmzY8+eSTpc5fAn0hhBBCCOHVvDXQr1WrFmvXruWxxx4jPj4eHx8fVq5cSWpqKs899xx//PEHfn5+pc5f+ugLIYQQQgiv5m1ddgrz9fXl6aef5umnny73vCXQF0IIIYQQXs3bWvIriwT6QgghhBDCq3lroH/77befM42maXz66aelyl8CfSGEEEII4dV0Lw30f//9d9csOwUcDgfHjh3D4XAQHh6Ov7/ne3GXhAT6QgghhBDCq3lri35cXJzH9TabjWnTpjFlyhSWLVtW6vxl1h0hhBBCCOHVvHUe/eKYzWbuuece+vbtyz333FPqfCTQF0IIIcrZ3mTFYVsoh22hbDqu2JtcU8IPIaonb51e81zatm3LqlWrSr29dN0RQgjhNZRS6Mk55O9Kxp6Yh55rx5GYi+1gGjmbErDEBuLIsOFIyeHY5lxUsB9KgZ7nIAHICDSjWQwoXZFlsXK4XiQGixG0U3nbwWjSMBg1NA0yDEbyzGYsPgYMBo0Eo5ElfoEE1DJiNICGxkllIjzQiK8ZDBrkO2B3MsAgAF6aBWCjWShYjODQIT5XI9hXw3xqOTUPdAX+ZnAoyLNDlu30sgJybGAygOFUE51dBxRYTc79oiDXAbV9wccEViMkZENsENQPhECrRrZNYTHCpZEGwnwg1EeBptEuXCPSH8zGmhUkiQtJzfzsLlu2TObRF0IIUTMopdCPpWNf9x96ej6Ogyk49ieR+csRdIMRPTkHbDq5WHAU/IQV/L4ryDZp4FAoBVmEQGKGK++cSF/s+Trk6wDkWozomgHd5t7abrcpOLUu12rCBuTbnNv852siyddAUmrBNgpqGclIO3fd9iQXWrBqpGcUTZOe776cdsZyvg7o7uvsNvflY1nuy0m58M9JMGoKx6liz9mtu54XdHbQgBAf52KbOtAhQqNhLY0of0X9QI12dTQ5ERDVlre25L/wwgse16emprJq1Sr++ecfJk6cWOr8JdAXQghR6ZRSqCOp6FuPYftxKyo+DXUiA31PAvZMBzZ8nAlNztZ3u+7jvn3hH/XCcbpdusgUx6E8Py+ggORc5/MVR2B1vMKuq1Nvr8KoQYMgaBYCDjRGtoTWtQ00DwWryTuDLFFzeOs3f9KkSR7Xh4SE0LhxYz766CPuvPPOUucvgb4QQogKpfJsqO3HUJuOoP9zmPzvtqJnOZx9UTwq9NNk14tJIyqa7Yy33qFgf5rzAYqlcQAOjJqzi1HXKOjdwED7OtCujkaYrwT/ovJ46/Saul6xf+Mk0BdCCFF+snNhx3+wcT9sPIC+bAf2QzZXc5syGtAdPmfPQ3gVh3J2OfrlECw7rKOfOtb+JujbADpGGugYCe3CoY6/zAEiKoa3BvoVTQJ9IYQQpeNwwNo9sOco/L0P1uyBzQedQb0GGI0ouxkIKrSNtNDXZHqh/hNZdpi/HxbsPz0eoF6ATre6Gp2iNC4KgV71Icgqwb8oO2/po3/48OFSbRcTE1Oq7STQF0IIcW5Kwa7/4Jd/IT4Z1ux2ttrnnup+YzaCzVEoPWB3AOYqKKyoLvQzOk7HZ8K8vYrv9yp05TwfbBriDP5bhkHLMI3esZr0+RfnzVv66Ddo0KDInXBLwuFwnDuRBxLoCyGEcKcUxJ2EH9bBvmPOFvv1+yAjx/n6mUE9FF0WohiFBwIrYE8KHEhVp8ZRK0watAyDSyPB36IxqqWBi2vLgF9xdt7Soj9jxoxSBfqlJYG+EEJcyGx22BUPmw7AzOXOCdy3xEFG7lm2kaBelK/CkyXZFWxJhG2JoKN49x/ngN/moc7pP6+K0bgyxkCbcAj28Y7gTlQ8bwn0b7vttkrdnwT6Xuann37i+eef56OPPqJjx45VXRwhhLfQdfgvCbYddj5W7XB2v0nPOdXFRojqpfBoDoeC7UnO53/GK55f4/zMhlghKgCua6JxcW3no1mwwscs/f4vNN7SdaeynVegv2HDBsaPHw/AU089xZAhQ4qk6dixIz169GDKlCnlUsDKUBA8v/rqq/Tu3dvttWXLlvHMM89Qr149PvjgAyIjI91eHz16NNu3b2fQoEE8++yzHvOfNGkSCxcuxN/fn/nz5xMcHFzi/QshxHnJynV2t1m8CfLtsPcobDkE2w+f7jNhNMigWFEjpOQ5H3tTFLZCAwJiAnXahDv7/PuZoWtdjbbhGnX8qNRuE6LyeEuLfnFWr17NP//8Q1paWpEpNzVN45lnnilVvqVu0Z8+fTrXXHMNPj41d5q0efPm8eqrr9KsWTPee+89QkJC3F7ft28f27dvJzo6ml9//ZVHH30UX1/fYvPLysri008/5eGHH67oogshaqp8G+w7DseS4b9kZ1/6TQdgw35nt5vE9NNpDRpoWtGgXoJ8UcOcOef/4Qw4kgG/xKlTrzlPAvxMEO7nvBLQO9Z559/YIEWoj8bF4RqBFu8OFi9k3jq9ZnJyMgMGDGD9+vUopdA0DaVO3a361PNKD/RbtmzJjh07+PrrrxkzZkypdlzdzZw5k/fee49LLrmEyZMnExAQUCTN/Pnz8ff353//+x9jxoxh2bJlDBo0qNg8W7Zsyffff88tt9xCVFRURRa/WrDb7TgcDqxWa1UXRYjqTdchLdsZpMcnw44jzlb346lwLAWWbQYfC5xIheQM92vUJqNzmktP1611hVzQFhcqRdETgGw7HEqHQ8D2JPc7/4Lzxl91/Z0Xvy6u7ZwJKNJfI8CsCLBotArTqO0HYT5gNnpnYFlTeWuL/qOPPsqWLVuYPXs2nTt3plGjRvzyyy80bNiQt99+mzVr1rB48eJS51+qTmy9e/emRYsWzJw5k9TU1HOm79ixo8db/P7000907NiRDRs2uNZNmzaNjh07cuDAAd566y2uvvpqunfvzoQJE4iLiwPg999/59Zbb6V79+4MHDiQefPmlaYaxXr//fd57733uOyyy3j33Xc9Bvk2m43Fixdz5ZVX0rp1ay666CLmz59/1nzvvvtubDYbU6dOLdfyZmVlMXXqVEaPHs1VV11F165dGTx4MO+99x65uacH1O3atYuOHTvywQcfeMzn/vvvp1evXuTk5LjWJSYm8sorrzBgwAC6dOlCv379eOmll0hOTnbbtuC47d+/n8mTJ9O/f3+6devG1q1bAfjzzz8ZO3YsV111Fd27d2fAgAE8+uijHDp0qFzfCyHOKScP7p4OPZ+G93+u6tLAXdPAPAxCR0Gze+CKZ+Huj2H8NHhxLnzyKxw44Qz+kzKKxu32YoJ8r+L1FRBeyKYX/eRl2WBvKhxIg5/2K97aoHhohc4dSxXDF+q0nukg6kMHlrcdRH9kJyO/6j67m08qrpnr4Jq5DjaflO+QKvTwJj///DPjxo3jpptuIjAwEACDwUCTJk344IMPaNCgAQ888ECp8y9VoK9pGvfccw+ZmZnMmDGj1Ds/m0mTJrFnzx7GjBnDyJEj2bp1K/feey+LFi3itdde4/LLL+e+++4jMDCQl19+mX///bfM+1RK8corr/D555/Tr18/3njjjWK7Jq1cuZLU1FSuvfZaAAYOHMjmzZtdJyOeXHTRRfTr148lS5awZ8+eMpe3QEJCAvPnz6dly5bccccdPPjggzRv3pxZs2bxyCOPuNI1b96cFi1asGjRoiLzsZ48eZK1a9fSt29fV/ej48ePM3LkSH777Tf69evH448/Tv/+/Vm6dCn/93//R2ZmZpGyPPPMM2zdupVbb72VBx54gNq1a7Nx40YeeughMjIyGDNmDI8++ihDhgwhLS2NI0eOlNv7IESJPPsNTF0Cf+yAez+BZf9WbXn+jSs62XgBu0O62RTL237OhbcpuCJQ3NczPhOScjy/VtF0pbjmewdL4hRL4pzPC7p7XKgUmuvhTVJTU2nVqhWAq2G5cHzVt29ffvnll1LnX+ph6Z07d6Zz587MnTuXY8eOlboAxQkLC+Ojjz5i+PDhjB8/nnvuuYdjx47x+uuvM3PmTO68805uuukmPvjgAywWC999912Z9/n+++/z/fffM2zYMP73v/9hMhXfs2nBggXUrVuXSy65BIB+/fphMplYsGDBWfcxYcIETCYT7733XpnLW6BevXosWrSIxx9/nJtvvpkbb7yRV199ldtvv521a9eybds2V9ohQ4Zw8uRJ1qxZ45bHTz/9hMPh4LrrrnOte/3117Hb7Xz11Vfce++9DBkyhPvuu48PP/yQo0eP8tVXXxUpS0BAAB9//DG33nort9xyCw0aNGDlypXous4HH3zAiBEjGDx4MHfccQfTp0+nR48e5fY+lEVycjJ5eXmu5czMTDIyMlzL+fn5JCUluW1z5uf+zOXjx4+7/eGVfVSTfew/7rae/SeqtB42u43zdWH/nAvvca5PqqfXS7NNWctRNlXxNzEhNYtjWYW2z4L/Trpfaa8Of3crk7cG+nXr1uX4cefvktVqpU6dOmzevNn1enx8fJkGkJdp/ql7770Xm83Ghx9+WJZsPLrpppvcKtauXTsAevbs6TbzTUhICLGxseXSMpyYmAhAbGzsWd/U48ePs3btWgYMGOBKFxwcTI8ePVi0aBF2u73YbevWrcvQoUNZs2YNf//9d5nLDGA2m10nJXa7nfT0dFJTU+nUqROAW6Dfr18//Pz83LoZKaVYsGABTZo04eKLLwacX/A///yTnj17YrVaSU1NdT3q1q1LdHQ069atK1KWW265pcgJUsEZ6u+//37W96YqhYaGuo0lCAgIcF1CA7BYLISFhbltc+Y4izOXIyMj3T5Hso9qso/brnD2aweICIZrO1RpPcym879zrHf9jIkL17k+qZ5eL802ZS1H2VTF38SIkACGNz/9+vDmGvUjqt/f3cqkF3p4k549e7Js2TLX8k033cTrr7/OSy+9xP/+9z+mTJnCFVdcUer8yzSPfvPmzbn66qtZsmQJI0eOpGnTpmXJzk10dLTbclBQEOAMlM8UGBjoOhsqiwcffJC5c+fy5ptvAjB8+HCP6RYuXIiu67Rt29btBKNjx46sWLGC1atX06tXr2L383//938sWLCA9957j5kzZ5a53ABz5szh+++/58CBA0WmZSp8Ru7n58fVV1/NTz/9REpKCiEhIWzcuJH4+Hi32YDi4uLQdZ358+cXO/agXr16RdbFxMQUWXfjjTeycuVKXn31Vd577z3atm1Lt27duPrqq4vMZCREhRvUCf5503mTqMtaQGQVfwYNWvGz41wwql/wJkRxNJxfWYeq2k/hVwMMjGjhbJG/ppF8H5TBO9+Dhx56iGXLlpGXl4fVamXSpEls377dNctOz549y9QLpMw3zJowYQK//fYb7733Hu++++55bXtmP/HCDAbPFxuKW18efdOCg4P56KOPmDBhAm+++Sa6rnPLLbcU2c9PP/0EwD333OMxnwULFpw10A8ODmbUqFF8+OGHbmdxpfXll18yZcoUunTpwvDhw6lduzZms5mEhAQmTZpUJPAfMmQIP/zwA4sWLWLEiBHMnz8fi8VC//79i+R9zTXXuMYhnMnTbDqexjQEBwcza9YsNm3axLp169i0aROTJ09m2rRpvPPOO7Rp06aUNReilFrHOh/VwaSbYOEGSMyAk2lw4Lhz5h27A+xnBP4mg/OEQO5MK0S5M2hg1JxfuzMjCj8TWI1wcW2I8IfavhqNamnEBFVJUQEwaBoDGntncFsRdC+dBal169a0bt3atRwSEsKvv/5KamoqRqPR7apKaZQ50K9Xrx5Dhw7l66+/dps9p7BatWqRlpZWZH18fHxZd1/ugoOD+fDDD5kwYQKTJ09GKcWtt97qen3Dhg3Ex8dz880307Zt2yLb//LLL6xatYqkpKQil7gKu/XWW5kzZw4ffvgho0aNKlOZf/75Z+rWrcu7777rdiL0119/eUzfsmVL1yxB1113Hb///ju9evWiVq1arjTR0dFomobdbqdz585lKh+A0WikY8eOrrv57t27lxEjRvDpp5/yzjvvlDl/IbxW77bOx5mUgpRM5xSb6/c61x1Ndt7dduV253ScKVmQfbpPLUaDs4nxzBMEIYQrkC885aZRgwg/Z+t83wbOwD06QMOoKS4O14gN0gj3lak0vYHy0psh79ixg5YtWxZZf+bNVUurzIE+nO6KUlyLfkxMDFu3biU3N9fV4puenn7Ogatlcfz4cXJzc4mOjj7roFpPCoL9u+66i7fffhulFCNGjACcc+cbjUZuv/12j91OQkJCWL58OYsWLTprAO/j48PYsWN5+eWX+eGHH86vcmcwGo1uN1gAZ1/9zz//vNhthgwZwquvvsrrr79OXl4egwcPdns9ODiY7t278/vvv7N161a3s01wXtlITU0tUdeb1NTUIh/YBg0a4OPjQ3p6uueNhLjQaRqEBjofLet7TlNwMrA7HtbthZx85820th+GjQecVwWEuABpnG6VNwD1g+DSSI2mIRDlB3X8NbrW1agXAEYv7fIh3CkvPRm7+OKLufjiixk+fDg33ngjTZo0Kdf8yyXQDw4OZuTIkXz00UceX7/xxht55plnGD9+PP379ycjI4Mff/yRqKioIiO4y8uzzz7LP//845od53wFBwczdepU7rrrLqZMmYKu6wwZMoTly5fTrl27YgPc9u3bExoayoIFC87ZUn/dddfx1VdfsWPHjvMuX2FXXXUV77//Pvfddx9XXHEFWVlZ/PLLL2c9wenXrx/vvPMOixcvpl69eq6Bu4VNnDiRO+64gzvvvJMBAwZw0UUXoes68fHxrFq1iv79+zNu3Lhzlu/FF1/k5MmTdO7cmaioKPLy8li2bBlZWVkMGDCgTHUX4oJWcDLQtbnzcaa0LNh9FHb9Bwv+hmOpcCTBeVWgIAoyG6UrkPBKxlP95AsEWaBFqPP5LS00WoQ5H/UCKNOsJcI76F56wvbhhx/y3Xff8eyzz/LMM8/Qrl07V9AfG1v2LqblEugDjBgxgrlz57pmrinsmmuuISEhge+++463336bevXqcccdd2AwGNxmhKluCrfsv/vuu+Tm5pKXl3fW0c8Gg4FevXrxww8/sHnzZo/dewoYjUbuueceHn300TKVc+TIkSilmD9/Pm+99RZhYWH06dOHQYMGMWzYMI/bBAQE0KdPHxYsWMDAgQM9/hGMjIzkyy+/ZObMmaxcuZLFixdjsViIiIjgsssuo0+fPiUqX//+/fnpp59YtGgRKSkp+Pv706hRI1577TWuuuqqMtVdCHEWtfyhU1PnY1Shv1tZubDpACzbAqlZ8M9+2HQQsk51AzIZnQODL/B5uUX1YTac7nJjAC4KhY6RGo1qQYNaGv0aakT4SUB/IfPWrjvjxo1j3LhxnDhxgjlz5vDdd98xceJEJk6cSKdOnRg+fDjDhg0rVaM1gKYu9DssXMBeffVVfvjhBxYsWEBERERVF0cIUZWUcs5EtDse/jkAG/bD8q2Qe2qef5OhVH3/Hfjg4PSIRQXk43fWbeyYsHF6sL8CcvF1S5ODFR1j8dUBjuF+5fVEpC+5/qfbt9KCAzkeffa/felWC7ZCV0f3+1pZGXrGCMxavpw3q5dGJZWgcFCvAZdEQJcojUsiNFqEQvs64GOW90+4mx8y2/X8upRbzpKy+ouPj3cF/evXr0fTNGy287/nCpRji77wLpmZmSxevJhu3bpJkC+EcHYDahHtfAwuNAD/aDJs3O8M/H/ZBP8cBNup+2EYDRfwlKCiPBS0vyucXXHC/eCGphodIzU6Rmi0CJM+9KJkVA36mERFRdGqVStatGjBtm3byMrKOvdGxZBA/wKzb98+du/ezaJFi8jOzmbMmDFVXSQhRHVWN9T5GHgpPD/c2fJ/JBH+3uccADxrBaRnOwcCC3EOBYNkDRrUskDPaI1rGmlcGqnRurbMbiNKz1vn0S+glGLFihV8++23/PDDDyQmJhISEsLw4cO56aabSp2vBPoXmN9++42PP/6YOnXq8Pjjj8sc9kKI86NpEBPufNzQFV4fBboOe446g//Zq+DACYhLgPzqeSdsUfliAiHAAne01ugUZaB9HfAze3dgJqoXh5eeJP7xxx989913zJ07l5MnTxIUFMTgwYO56aab6N2793nPHHkm6aMvhBCi/NkdsOMI6vftOBbuRGXYUVviUbk2Zx99g+a8OuDhF0j66HuXMwfKNgqGJsFQP1DjlhYa7SM0alm9MwgT3mNO5Deu58OOD6/Ckpwfg8FAQEAAAwcO5KabbqJfv35YLJZyy19a9IUQQpQ/kxHaNEBr0wDTA85pdJVDh/0JaN/8g55lR99xAv3feNR/hW6oaDZA6caciQpmNrjfNTbQDG3CoW0djUAL9InV6BKl4W+RoF5UPuWlMy7NmTOHAQMGuO4zVd4k0BdCCFEpNKMBmkVgefYat/V6Uhb6vkTU3gT03Qmw5jCODSfRbQqyC6J+5ew2ZDI4J0+XMcDlSsP51ioF9kJXWYwa1LJCmA/0a6jRPFTjolBoEASNgjWZzlJUG7qXfhRvuOGGCs1fAn0hhBBVyhDmjyHMHzo7bw5jBQJxDk5TyTk4DiSTs/QAymxGT8jGfjQTfc1x8jMUyqHQ0/KKCfwVoDmjWE1DO9UWrZm0glXO/RtPDRJVzuEGmgbaqZ41BbGD4dRyQYcbt55HSp3OrKRObaOd2kdB8Y2nius4lbfJcLoMNt25f6Ph9DI4W9rBOQGSfmbZzsLfDAFmyHNAz2iIDtSoF6CRa1d0idJoVVujXiCYvHyQo7gwePtg3Ioigb4QQohqSdM0tDA/DGF+mC+NdnstvNBzpSv01Dxs/2U4A/+MfPQMG7U2JkFEIOgKPU+nzpEssq1GLBE+KF2Rk6tzKN1EaMtgV15HD+YSXs+K1deApkFKuo7NaCQk3IzBoJGrQ6csjXqxVoyaM6jem6rRKNyIr8m5rGlQx8fB6mULAOjbfxAbTxoJ8XEG37qCncmK+rU0LEYNhw7xmQqbDpH+zuUsm2JnElwcruHQFTrw7wlFo2ANf7OzrPGZCocODYM1jJrzBsf706BTpIaPCaxG+C9D0TxUI9wPAi0afiaFvwXqBTj3LURNUZOm1yxPEugLIYTwappBwxjqgzHUvY9r4ICGbssxHrbtUYr9DSlBGptN54g5GYCu0Ro9GxY/cLhySTQkaiZv7aNf0STQF0IIIYQQXs0hXXc8kkBfCCGEEEJ4Nem641nNmchXCCGEEEJckHRNcz28TXp6Oq+++ipXX3017du3Z/369QAkJyczefJk9u3bV+q8pUVfCCGEEEJ4NW9t0f/vv//o1asXR44coWnTpuzatYvMzEwAQkNDmTZtGocOHeKdd94pVf4S6AshhBBCCK/mrYNxH330UTIyMvj333+pU6cOderUcXt98ODBLFy4sNT5S9cdIYQQQgjh1ZSmuR7eZOnSpdx33320bNnS4w3oGjVqxJEjR0qdv7ToCyGEEEIIr+atXXdycnIIDw8v9vWMjIwy5S8t+kIIIYQQwqspg+Z6eJOWLVuyatWqYl//8ccfad++fanzl0BfCCGEEEJ4Nd1ocD28yQMPPMA333zDa6+9RlpaGgC6rrNv3z5GjhzJmjVrePDBB0udv3TdEUIIIYQQ3s3L+uYXGDFiBIcOHeLpp5/mqaeeAqBfv34opTAYDLz88ssMHjy41PlLoC+EEEIIIbyat3XZKeypp55i5MiRfP/99+zbtw9d12ncuDHXX389jRo1KlPeEugLIYQQ5WhvgoOULJ3DuSEAbIrXCfF30DTcWMUlE6Lm8rbZdgCys7O57LLLuPPOOxk/fnyZuugURwJ9IYQQogQcuiIuWSchS3E0XXEsQ2fNIQdpOYogH430PMXxdJ0N8fqpLfoC8NLUXADaRhmIDNQI8jFgMihOZCj6XWSmbpBG3SADkYEQFWQg2Ne7+hgLUR0ozfu+N35+fhw8eNDjtJrlRQJ9IYQQopCMXMWmo3bmbrFjMsKeBJ2dJx3EpSh0dTqdBhQsGjTcXvNk8zGdzcdA0xygnNuuOOAosl24v8ZF4Qaa1zEQaNFoHWWkT1MT9WppFRoQCOHNvLXrTr9+/fjll18YN25cheSvKaXO8adJCCGEqJnSs3U2H7Lzyfo8kh0aW47rHE49/bNoMoBDPx3QVyaTAez66eUgK7Sra8TfAoNamunTzESjUIME/0IA73X4xfX83o1XV2FJzs/OnTsZNmwY7du3Z9y4cTRs2BBfX98i6UJDQ0uVvwT6QgghLgi6rth3wsHcNTkcTnSw+6iDI0k6Cjjga3FrofcWwT7QKcZIgEXjrq4Wusaa8LNI4C8uPO9eutT1/L6/+1ZhSc6PwXC6y9HZTtodDkep8peuO0IIIWokm0Oxelc+a/fY2H/Cwd/7bWTmFh/Ke1uQD5CaC0v3OAOAedvsGDVoV9dAt1gjjcKMjO5gIcRPAn9R83lr151nn322Qq/KSYu+EEKIGsFm0/l7j43N8Q7W7M5n40EbeTbna2frQ1/Qol+TaBoo5RxH0CrCwFVNTXSLNdI11kT9YO8btCjEuUzp8qvr+QNre1dhSaoXadEXQgjhlWw2RdyBXHbvzGHn9hzWHrCz2c8Pg+YM3gs3Y51roGxNU1B3BWw7obM7IZ93/nSua17HQJ+mJno1MtGzoZHwAAn8hffzxuk1K4ME+kIIIbxCbq7O/r257N2dw/at2RzYlweAwQC6DvkWM3DhBfUlYSs0qHfXSZ19ifm8tzofgMhAjetamrmsoZHLGpqICZHAX3gfbw30X3jhhXOm0TSNZ555plT5S9cdIYQQ1Y5SiozjuRzfmsqxLWks3ezghLKi1OnA/kwnLWZ2Bvid/76oeV13zlfhGX6sRuh7kYk+TU10jTHStq4Rs9E7gyhx4Xir+3LX84dXX1GFJTk/hQfjnknTNJRSaJomg3FF6U2bNo2PP/6YBQsWULdu3UrZ508//cTzzz/PRx99RMeOHStln0KI6is3OY/Ebakkbkthz+8nSDppw5bjjDwNRo2E2BjUqV8sT0G+KJvC03jmOWDhDjsLd9pRCswGCPaFW9tbuLS+kY7RRpqEGTB46eBHUTN5a4u+7uEPmq7rHDp0iA8++IBVq1axePHiUufv9YH+hg0bGD9+PPfffz8jR46s6uIUMXv2bAIDAxk4cGBVF0UIIaqccujkH0gjb0siuVsSOfbXSbbG6+TlOy8ua0aNHB8rDsvpnyfdofDS33CvpVz/OLv9JGTB+3/ln271N0Edf43BF5tpE2mkTZSBVpFG/GVqT1FFdGPN6XJmMBho2LAhb775Jrfeeiv33nsvs2fPLlVeXh/oV3dff/01UVFREugLIS4oenou+evjsSfkYt+TjG1XIrkbT5CxL/f0PJYmAwn+/uSFBVMQySuH9Catrtxa/e1wJE3x0Zp8t/7/wT7QOcZEywgDzcONhAfApdFG6gbJFQBRsby1Rf9cevbsyeOPP17q7SXQF0IIcV6UUqjkbNSRVNSRVPQjqeT/fhB7ug09MQfHgWRUWh45+ACaswO4rnDoGuBzOiO79MHxdrYzDmFqLvyyx87v+9xfsxihfrBG4zADWXkwsKWJ2BADMcEG6gcbiAoEUw1qkRWVr6YG+hs2bDhrP/5zqZGB/tGjRxk0aBB33nknLVu25OOPP2bfvn0EBgbSv39/7r77bkym01UfO3Ysx44d48MPP2Ty5Mls3LgRgEsvvZQHHniA6OhoV9qz9S0vyOenn34CcL1+7Ngxt7Ql6Qu/dOlSvv32W/bu3YvD4aBJkyaMHDmS3r3d54bt2LEj1157LQMGDGDq1Kns2bOHWrVqceONN3LbbbeRnp7OlClT+OOPP8jOzubSSy/lqaeeIjw8vMg+c3JyeOONN/j111/JzMykSZMm3H333XTq1KlI2nXr1jFr1iy2b99Ofn4+MTExDB06lKFDhxZJ+8MPP/Dll19y9OhRIiIiuPHGGwkICDhr/YU4q7/3wvRlUC8UHh8CvtaqLlHNtPM/9Fd/JH9bOnpUbdTxTNSxdNTxDPepbTTIVT4ojGdkcOqH1xXQl+GHuDwb+pWi9H2BFEXqUab8aqYzTwDyHbA/SbE/yTmg8K9DjiKHNMQXIgMNGIwaeUrjhjZmXu19YQ+Srkjz9ugsOqDoGKkxoZ33n2R5a6A/a9Ysj+tTU1NZtWoV8+bN44477ih1/jUy0C+wevVq5s6dyw033MCgQYNYuXIlX3zxBYGBgdx+++1uaXNychg3bhwXX3wx99xzD4cPH2bu3Lls3bqVr776itq1a5/3/l944QUmT55McHCw2/5CQkLOut3UqVOZMWMG3bp1Y/z48RgMBpYvX87EiRN57LHHuPHGG93S7969mz/++IMhQ4YwYMAAli1bxvvvv4/VamXhwoXUrVuXsWPHcuTIEb799luee+45pk6dWmS/zz33HAaDgVGjRpGdnc28efO49957effdd+ncubMr3bx583jllVdo3bo1t99+O76+vqxbt45XX32V+Ph47r//flfa2bNnM3nyZJo1a8bdd99Nbm4uX3755TnfAyGKFZ8EVz4HmbnO5cOJMOOeqi1TTZSRA1c8i+NEPjbqAInFp1VQpiC+RKpJlx4Pcb5XKXJSUjUV8nQ0U3IgJef0GcJryYpLY0zc0Mz7g9Dq5vfDOkMX6ChgxjaFruDu9t79PntroH/bbbcV+1rt2rWZOHEizz77bKnz9+6jeg4HDhxg5syZjB8/nqFDh/Luu+/SqFEjvv322yJpU1NTufLKK3nttdcYNmwYDz/8MC+//DJJSUlMnz69VPvv378/vr6+hIaG0r9/f9fD19e32G127drFjBkzGDNmDO+++y633HILw4cPZ9q0afTq1YsPPviArKwst2327dvHO++8wz333MPQoUN5//33CQsLY/LkybRr14433niDYcOG8dBDD3HTTTexfv164uLiiuzbaDTy6aefcuutt3LnnXfy+eefY7FYeOONN1xpEhMTefPNN+nbty8zZsxg1KhRDBs2jDfffJPhw4fz1Vdf8d9//wGQkZHB1KlTadiwITNmzGDEiBHccccdfPbZZxw+fLhU72lFSU5OJi8vz7WcmZlJRkaGazk/P5+kpCS3bY4dO3bW5ePHj1N49lrZRzntY+d/p4N8gPV7vbMe1X0fcSfhRCpCFK/iT75WHshxW6423w8v38ffx9yP3vpjqkLqUZmUprke3uTgwYNFHnFxcaSlpXHy5ElefvllfHx8zp1RMWp0oH/55Ze7dZHRNI2OHTuSlJREdnZ2kfSjR492W77iiiuIjY1l5cqVFV7WAosXL0bTNAYMGEBqaqrbo2fPnmRlZbF161a3bVq3bs3FF1/sWjabzbRq1QqlFMOHD3dL2759ewCOHDlSZN+33HILZrPZtRwREUG/fv2Ii4vj4MGDAPz666/k5+dz3XXXFSnfZZddhq7rrF+/HoC1a9eSm5vLsGHD3D6kBflWJ6GhoVitp7t/BAQEEBgY6Fq2WCyEhYW5bRMVFXXW5cjISLRCf3BkH+W0j/aNIDL49Mb9O3hnPar7PppGQbPKmW5XeKuKD6iGtHRvGKs23w8v30fvWA1LoZ52/RtpFVKPyuStgb6madSpU4fY2FjXIyYmxvXe5+TklKlxtEZ33alXr16RdbVq1QIgLS0NP7/TN1YJDAz02D2nYcOGrFixgpycnLO2xJeXgwcPopTy2Ne9wJln1J7qGRQUBFBkLEDBByctLa3INg0bNiyyrlGjRgDEx8fTsGFD15WAu+66q9jyJScnu7YBaNCgQbH5CnHewgJh7avw9Z9QNwRGXl7VJaqZfCzw50vw8HfwxU7nZOq6giqbFaccf7zLkpWnbb0prigSBFWvwms4b4jm0KFHtMYVMTW6PbLKdIjU+HO4kaWHFB0j4OqG3v8+q+r1US6xhg0b8sUXX3DLLbd4fH3BggXccsstcsMsT842Srm0NwTWznKmWNqD4Gkf7777brHlb9y4sduy0XjmALhzv1ba+hds9/zzzxc7bsHTiYcQ5Sq2Dky8vqpLUfOF18I0dRTWS9ai/5fmHIgbn4Zj5wlIzj5j1hzljNI0zX2gbnkp1x/xCznSr1pGrei5okFzzst/cYSBerUM1A0yEBmoMail2XMmolxcGqVxaVTN+ezqZZiZpiqdKx6z2Wwy6055yMjIIDExsUjwevDgQUJDQ12t+QUt5enp6UXyOHr0qNtsPnD2EwNP6tevz19//UVkZKTHFvaKdPDgQZo1a+a27sCBA8Dp4L1+/foABAcHuw3Q9aRgm7i4uCIz9xTkK4So3rQAK5YHenl8TWXkop+aYtO48iCONBt6Si6O3Yk4DqRAaqGBnmYD2Cqv3KLqmA3Oc8BCt0ugYaiBZrUNNAzVyMyDa1uaiD01tWa4vyZz7Isy072oy056ejqpqamu5aSkJI/dc1JTU/nmm2/K1CVKAv1CZs6cycMPP+xaXr58OYcOHWLIkCGudTExMQCsX7+eK6+80rV+yZIlJCQkFDkYvr6+Hk8KitO/f3++/fZbPvjgA1577bUiLfJJSUlF+siVl9mzZ3PllVe6+umfOHGCX375hdjYWNdJR58+fZg6dSrTpk2jQ4cORQaIZGZmYrFYsFgsdO7cGavVypw5cxg0aJArbUG+QgjvpgX6YGwZCS0jMV3dvMjrjuRs7AfSsO1KwrYrkbxNJ7GtPIEjRz/d6u89v83CA0OhCzi+JmdAf2UTE83rOG+Y1SRMo36w3CxLVDzlRX9M3n77bV544QXA2SD8wAMP8MADD3hMq5TixRdfLPW+JNA/JTg4mN9//52EhAQ6dOjgml4zLCyMcePGudI1aNCATp06MW/ePJRSNGvWjD179rBixQrq16+P3W53y7d169bMnz+fDz/8kIYNG6JpGj179iy2v3+rVq0YO3Ys06dP55ZbbqF3796Eh4eTmJjIzp07Wb16NWvXrq2Q98DhcHDHHXdw9dVXk52dzffff09eXh6PPvqoK01ERAQTJ07kxRdfZNiwYfTv35+oqChSUlLYt28fK1asYM6cOdStW5egoCAmTJjAlClTuP322+nfvz+5ubnMmzeP+vXrs3v37gqphxCiejCG+mEM9cPa8XQDSCSg59rJ35VM7pZETH8cJ3NnNmnpDuzZ5dP9UVQMDWcrvVFz3vyqbpCBG9uaaRNppHWUgdr+3tl1QtQM3jQIt2/fvgQEBKCU4rHHHuPmm2/mkksucUujaRr+/v506NChyH2bzocE+qf4+vq6bpj1/vvvo5Sia9euPPjgg0W687zwwgu88cYbLFmyhJ9//pn27dvz0Ucf8corrxSZWuquu+4iLS2NOXPmkJGRgVKKBQsWnHVg79ixY2nZsiXffPMNX3/9NTk5OYSGhtK4cWMeeeSRCqk/OPvdf//998ycOZOMjAyaNGnCc889R5cuXdzSDRo0iJiYGL788kvmzZtHRkYGwcHBxMbGMmHCBLcrDiNGjMDX15evvvqKDz74gIiICEaMGEFAQIDrbFYIcWEx+JjwaVcHn3Z1CB7VkmY4W60yDmWRsC2Fvb8cJyE+l7Tjueg2Z9//Ug4rEqVUENQDxARrhPpq3NHZwqXRRtpEGfExe09QJS4M3hTod+3ala5duwKQlZXFDTfc4DZ7YnnSVGlHZdYgZ97RVgghRNVz2HQS92RwbGsqv/6ZzeE8C1nZzp8szUPwf9JiZmeAn4eczk4BB3wv7DuwFnTBsRoh1A+Gt7PQu4mJLrFGQv2kpV5Uf09du8n1/KWF7auwJNWLtOgLIYSoloxmAxGtahHRqhbthjtb/RMT7OzdncOObdlsWJeFzeaM9g3FTz4mzlDQXV5XzoGy7esaGNbGQs9GRi6pZ8Rs9J6WUSEKeOv0mgVWr17NP//8Q1paGrquu72maRrPPPNMqfKVQF8IIYRX0DSN8DpmwuuY6XZZEHdMgJQUO3t25bB7Rw4rt+ay065A0zAZzpj98wJm1JxXLXQFZiNcc5GJK5uY6NXIROtIA0YZKCtqAIeXTq+ZnJzMgAEDWL9+PUopNE1zTblZ8FwCfSGEEBekkBATnbsG0rlrIKOAk2kO/t5vY/0+G6t32YhLcA7wvZACf+OpG04BBPvAlU1MXN7YGdi3qqNhNHpnQCTE2XhTH/3CHn30UbZs2cLs2bPp3LkzjRo14pdffqFhw4a8/fbbrFmzhsWLF5c6f+mjL4QQosaKT3Kwdl8+O/9zsG5vPruPOtBP3durYJCvt/fRL3wTqshAjSsaG+kea6R1lIkeDYwytaW4IDwyZKvr+Zs/tK7CkpyfqKgobr75ZiZPnkxSUhLh4eEsW7aMq666CoDrr78eq9XK119/Xar8pUVfCCFEjVUvzMgNYb5w6v5+mbk6izflcfCEg93H7Gw6aCctR4FSGAxahdzUtzwVDupNBmgbZaBbrJEQXwO3X2omNlQGK4gLk7f20U9NTaVVq1YABAQEAM57EhXo27cvTz75ZKnzl0BfCCHEBSPAx8CwrqenN1ZKcThRZ/bGPBLyNbYed7DpqE5Swew+OANqWyV3+zEZnFcbCoJ6ixFaRRjoEG0kwKIx+GIzXWKMWE1eGt0IUc686YZZhdWtW5fjx48DYLVaqVOnDps3b+a6664DID4+Hq0M3ZIk0BdCCHHB0jSN2HAjT/Rzn5bzWLqDJbsd5NgUexN1diXo/POfnYSs0/PLF2Y+1e1dLxScn8mgOVvk0cDu8JyP1QiXRBtpUcdA09rOm1C1iXQG+DJoVoji6V7aR79nz54sW7aMp556CoCbbrqJ119/HaPRiK7rTJkyhauvvrrU+UugL4QQQpwhKsjImEuLdoPRdUVStuJouuJYhs76ww5ScxUBFo2MPEVGnuJ4huLG1gb2rFkIQP9rB/LuXw6sZo1Aq/NhMSpOZkKfpibqBjnvMhsZqGGRFnohSsVbB+M+9NBDLFu2jLy8PKxWK5MmTWL79u2uWXZ69uzJe++9V+r8ZTCuEEIIUc5sNhufffYZAGPGjMFsNldxiYSo2e4bttP1/N05LaqwJOUjNTUVo9FIYGBgmfKRFn0hhBBCCOHVHDWsa1twcHC55COT6QohhBBCCK+mo7ke3ubw4cOMHz+eiy66iNDQUFatWgVAYmIi9913H5s2bSp13tKiL4QQQgghvJq39tHfsWMHl112Gbqu07lzZ/bt24fdbgegdu3a/Pnnn2RlZfHpp5+WKn8J9IUQQgghhFfTvTPO57HHHiM4OJi1a9eiaRp16tRxe33AgAF8++23pc5fuu4IIYQQQgivpmua6+FNVq1axYQJEwgPD/c4X35MTAzx8fGlzl9a9IUQQgghhFfz1q47uq7j5+dX7OsJCQlYrdZS5y8t+kIIIYQQwqvp2umHN7nkkktYtGiRx9fsdjvffPMNXbp0KXX+EugLIYQQQgiv5tAMroc3eeKJJ1iyZAkTJkxg27ZtAJw4cYJff/2Vvn37snPnTiZOnFjq/KXrjhBCCCGE8Gre1je/wDXXXMPnn3/O/fffz/Tp0wEYMWIESimCgoKYNWsWPXv2LHX+EugLIYQQQgiv5m1ddgobOXIk119/PUuXLmXfvn3ouk7jxo25+uqr5c64QgghhBDiwuZNN8p68sknGT58OG3atHGt8/f3Z8iQIeW+L+/qyCSEEEIIIcQZlKa5HtXdq6++6uqPD5CUlITRaOT3338v931Ji74QQgjhgVKK9AydA4fySc2D3HzF0UQ7h47aiQg1kZ2v89MRRWSkCaNBY3+iAz+LRt1aBjJyHWw7cCX1fVL594ccdp7MoUO0iSAfjRMZDkL8DMSEONvaUnMULSON+Jo10nJ0GoQa8LcYMBsVQVaNWn4GzMbqH7wIUZW8uesOOP/eVAQJ9IUQQlzQdF0RH5fL3i2Z5GTrxB/K5e+9DvKVhsMBJy1m8o1Gt21MxjxyFPxltaKdsKFpoJ/6nTa4nodwODeYv9bYcShYtd+OUQObfv5lNBlA0yAmxECoHyRmKi5rbKZxmBGDpmgabqRzrIn6IQaMBi+PeIQoBW8djFvRJNAXQghxQcnLcXB4RxZ/LU3mZIKdk8fzseU5o3SDEWxKI8fX9/QGHgIIuwMK4nUFFG6M0ws/x+BMcGq9XspGO/upne1P1Nl/at2hlHwM2unXAAwG8LMaGNDSTLu6RuoEaAy+2Eyov/TUFTWbN/XRr0wS6AshhKjRdIfi6O5M9q5LYc2SZLKzFUpBjtmEbjCckRa8JV7wdOKgK8jMV8zdbGPOvzZ04P++y6FZuIGLwg1c1sjEbZdaCA+QwF/ULDYvu5IVFxfHP//8A0BaWhoAe/fuJTg42GP6Sy65pFT70VRFdQoSQgghqkhumo24vxLZsvAY+/fmoeugDJBj8XGl8RToAzg0jRS/0y36J60W8j2kywPW+p7t1vSKSj9r0HD2HTrLfjXgonCNJuFGnurtQ6f6RgxeFiQJcab+d/7nev7zx9FVWJJzMxgMaGdcKVRKFVlXeL3D4SjVvqRFXwghRI2QcSSLQ78e45+vD5Ga6gAF+VYzutXq7H5zZt/4CzS2VcCuBMWuBDsLd2QS5gfNwo08doWVAS3NMvBXeCVv6rrz2WefVdq+JNAXQgjhlZRSpGxL5cjPR9jy1UHysx2gQU6AL5hODZ6Va9bnlJQNaw45GPJ5NoFWuKyhkUGtLIzpZMFi8p7gSVzYHF40GHf06NGVti8J9IUQQngNPc9ByorjxH2+jwN/J2LPdaAMkG859XMmgX2ZZOTBz7sc/Lwrh0d+ymFASxPdG5gY29WKVYJ+UY15+/SaFUUCfSGEENVa3uFMUn75j8Pv7iBjTxYqXycnwIg9yOy5S44oF5n58N2/dr79187ERbkMamWma6yRMZ0sBPrIYF5RvTi8qOtOZZJAXwghRLViS8kjZeUJkpfFkzxzNyrLBkAuJlTBDd2l5b5SFLzN2Tb4brONb/618dBPuVzZxESvRiYGtjLRpq6EEqLqOSTO90hOyc9h7NixDBw4sERpN2zYQMeOHfnpp59KlH7gwIGMHTu2LMWrFOdbLyGEKCmlFHn/niDjs80k3b2E3TGfsDL0a7YMWU78tD2uIF9UvYKpPB06/LbXztNLcmn7Viax/0tj9NdZvPxrDkfT5PKKqBo2g8H1EKddMKfhGzZsYPz48dx///2MHDnSY5qOHTvSo0cPpkyZUrmFE0KIC4DKt+PYnYRty3Eyv9iGI1cnf9NJVHqeM4HJQK7dF6jlTO+QZvvqqvD8/YdTFV9ssKGApxbnERUIoX4Ghre30CXWSLu6RmrLvP2igtmrugDV1AUT6JfWBx98wIV+q4FLLrmE1atXYzLJx0UIcXZ6dh7qSBrqYDK25ftxJGSjErKwbTiK/UQuKGd3kFx8im5sl9Zgb1X4V/JYBhzL0HlmSa5rnZ8Z2tY1EhNswGqCfs3NxIQYiArUiA42yOw+osy8adadyiSR2zmYzeaqLkKVMxgMWK1nuymMENXctkOwaCO0ioFrO1Z1abzXzxthyyEY0AFaxwKg7zpB/iPz0Q8mof+Xip5uo2CCejtGwAAa6MoAGKlWk9cXuZ9VSW9wVd43wqqsG2tVwQ28Tsm2OafwXHvIgQJmbXTvklXLByICDbxyjZUj27JISnYw/LpatIyxVEl5hfexV6M/LdWJBPrnMHbsWI4dO1akf/qKFSuYPn06cXFxhISEcO2119K+fXuPeRw/fpwpU6awZs0awNlC/vDDDxe7z3Xr1jFr1iy2b99Ofn4+MTExDB06lKFDh7qlGzhwIFFRUTz55JO8/fbbbNq0CU3T6Ny5M4899hi1a9c+Z/3279/P9OnT2bJlC6mpqQQFBdGgQQNGjhxJjx49gNPdnp577jnXeIWBAwdy7Ngxj3lecsklTJ8+3bW8Y8cOZsyYwaZNm8jOziYqKooBAwYwevRouUogKt7ueOjyBGSdal2cPgHu7FO1ZfJGn/0Gt3/gfP6/OfD369CyPo4V+3As2lEoobHotpV9UbSkV2HPTFdMHFzkqm5x8bJSzlmAzleJzy+Kyf/M9cWWr4T7qUDFHZm0XMjI03nxm3R67jkJwOS1KbzwXiPqhsrvhDg3e1V/uKupC+7bk5ubS2pqapnyWL58OY899hh169bljjvuwGg08tNPP/Hnn38WSZuRkcHYsWM5ceIE119/PY0aNeKff/5h3Lhx5OXlFUk/b948XnnlFVq3bs3tt9+Or68v69at49VXXyU+Pp7777/fLX1CQgLjxo3j8ssv57777mPv3r3MmzePrKwsPvjgg7PWIzU1lQkTJgBwww03EBkZSWpqKjt37mTbtm2uQN+Thx9+mOzsbLd127Zt47vvviMsLMy17s8//+TRRx+lfv36jBgxgqCgILZu3cq0adPYs2cPr7322lnLKESZrdh2OsgHWLhBAv3SWLjx9PPsPPh9K7Ss71zWkFlwzks1iLirIaMBbKmnW/oDcm38sSWXmy4PqMJSCW9hk6+URxdcoD9t2jSmTZtW6u0dDgdvvvkmQUFBzJw5k+DgYMAZKA8fPrxI+lmzZnH06FGeffZZBg0aBMCwYcN46623+Prrr93SJiYm8uabb9K3b19eeukl1/phw4bx5ptv8tVXX3HDDTcQHR3teu3IkSO88sor9OlzOnAxGAzMmTOHuLg4GjRoUGxdNm/eTHJycpHtS+Lyyy93Wz569ChTpkwhOjqaxx9/HIC8vDz+97//cfHFF/Phhx+6Wu9vuOEGmjZtyttvv+2a0aeqJScn4+/v7+qilJmZiVKKwMBAAPLz88nIyHA7iTl27BhRUVHFLh8/fpyIiAi0Uy1tso8q2scljcBgAP1U/+9Lm3hnPap4H0HtYjHNWwuAMmhkN4/CH3FhO/OEpYwnMArwPX1FKM9koEF4DnA60K+u3w/Zh+flymSTPvoeXXCB/pAhQ+jdu7fH1+6+++5zbr9z505OnDjByJEjXUE+QEBAADfccEORVvQVK1YQFhbGgAED3NaPHj26SKD/66+/kp+fz3XXXVfkqsNll13GN998w/r1690C/fDw8CJBeseOHZkzZw5Hjhw5a6AfEOD84/nXX3/RtWtX1/L5yszM5IEHHsBmszFlyhTX+7Ju3TqSkpK4++67yczMdNume/fuvP3226xbt65aBPqhoaFuy2e+FxaLxe2PG1Dkj9mZy5GRkbKP6rCPS5vCgokwdw1cHAMPXOud9ajqfTw1DPx9YeshtCGd8e9dqKtidWvNL+nv/ZmBQTHbaSVMV/IYt4T5lTT/kpav3J25o7LtWFfQvUsAljqKzHQ7g64LpXMrP7c01fb7IfvwuFyZZCJezy64QD8mJobOnTuXevv4+HgAYmNji7zWsGFDj+lbtmyJ0ejeb7V27dqus+QCcXFxANx1113F7j85OdltuV69ekXS1KrlnJouLS2t2HwAOnTowIABA/jpp59YvHgxLVu2pHPnzvTp04dGjRqdddsCdrudxx9/nMOHD/Pee++5nVgcPHgQgBdeeKHY7ZOSkkq0HyHKZEBH50OUnsEADw0qurpdPbSGoaij6ZBnx9Wqa6jKO9aWMOAskqzMEXcJty/v/ZZ08+rT4mk2gO3Mz4cG7eubGHdjpMdthDibJEP1+XxXJxdcoF+dFQz4ev7554sdSHtmYG84y40hSjIt6PPPP8/IkSP566+/2LRpE19++SUzZszgoYce4qabbjrn9q+99hrr1q3j6aef5tJLL/W4//vvv59mzZp53D48PPyc+xBCVF/GLg3wO/Cs8/ueko1j81FUeh56XDKGZftwJOWgTmSix6WBOvVDXKUnAaKyGDTnOOGCX6JQX416wRq+Jo1rWpiICTZg0KBjfSNRQQZCfDUMEqyJUsqXcS8eSaB/ngoC7UOHDhV5raAF+8z0R44cweFwuLXqJyYmkpGR4Za2fn3nwLbg4OAyXXU4X02aNKFJkyaMGjWKjIwMRo8ezfvvv8+NN95Y9JJ1IbNmzeKHH35g1KhRDB48uMjrMTExAPj6+lZqfYQQlU/TNAj1x3RFU9c66/09Xc+VzYF9ZwKOPc4bZjm+2okj045+8tSgfhnQW2NoQJAPDGhhplsDE83rGGhT10i43DRLVCSJ8z2Sb915atGiBRERESxYsMCtH31mZibff/99kfS9evUiKSmJRYsWua2fOXNmkbR9+vTBYrEwbdo0cnNzi7yemZlJfn5+2StxSlpaGrru3qwWGBhIvXr1yM3N9TgrUIHly5fz3nvvccUVV3Dvvfd6TNO1a1dCQ0P5/PPPPXYjys3NJSsrq2yVEEJ4Bc1sxNwmEp+hrQh84Srq7r+H+iceIPrk/YROv4bA+y/FenkMRrOGq+uP8AomA1wabeDGtiZ+n+BP+su1SH0pmK9G+HN3DytXNTNLkC8qnqadfggXadE/T0ajkQcffJAnnniC0aNHM3jwYIxGIwsWLKBWrVocP37cLf2oUaNYsmQJL730Ejt37qRx48Zs3LiRLVu2uA3mBYiIiGDixIm8+OKLDBs2jP79+xMVFUVKSgr79u1jxYoVzJkzh7p165ZLXRYtWsTs2bO54ooriI6OxmQy8c8//7BmzRr69OmDj4+HO1finJbzmWeewcfHh65du7J48WK310NDQ+nSpQu+vr48//zzPPLII9xwww0MGjSI+vXrk5GRQVxcHMuXL+eNN96oFoNxhRBVwxjuT+Cdpwf21rE5iF6bQOpfCSQuiSd35RE0BZpJk3vcVyPRtTR6NDTS9yIzN7a14G+V4EqI6kgC/VLo3bs3BoOBTz75hOnTpxMaGuq6YdY999zjljYoKIhPPvmEyZMn8/PPPwPOG0pNmzbNNYd9YYMGDSImJoYvv/ySefPmkZGRQXBwMLGxsUyYMKHIiPey6NChA7t37+aPP/4gMTERo9FI3bp1eeCBB7jxxhuL3S47O9t1xeHll18u8voll1xCly5dAGer/syZM5k5cyaLFy8mJSWFoKAgoqOjufXWW2natGmR7YUQFy6D2UjwZZEEXxZJg8dbo+faSf/zBClLjvDfp/vIS3XIJfoq0iZSo01dEw/3stK2nvGsXTuFqHTyefRIUyUZsSmEEEJUAzkHM0j46T/ivtpPfLyzf78yaORYTo+Bygn0RTc5l/MtZvJ8rKBpKCCn0JXKHIsJXSvapcShaaT4+bqWT1ot5HuY+CAPWOtrPUtpq+DGWBqnuj2Vz37bRBnoEG3k2b4+NAj1cNdjIaoJ7ZFU13P1ZnCVlaO6kRZ9IYQQXsO3YSAx97Ug5r4W5Kfnc2z5cQ4tPMK+FSdQCjSjtOqVVeMwA/2am3jsCh9iQqRvvfAS0qLvkQT6QgghvJIlyELsdTHEXhdD9zwHx9YlcmjZUbYuOUE+EvSfj8gAuPcyK6M6WokOluBeeCH5unskgb4QQgivZ7Qaie4ZQXTPCLo9rzi5M52DfySw5ZeTJGQUzN9ftWWsTnxNEBOi8cRVvgxoYaK2zIojvJ5E+p5IoC+EEKJG0QwaEa1qEdGqFl3GNyE9MY+DG9LYuzaFzRuz0JXmvMpfBV3oK5NBA/3UKDyrEWJDNbrEmhjXxUqnGCMmueIhahL5OHskgb4QQogaLai2lbb96tC2Xx2u1xUn4nI4uC2Tv35NITFZJzfn9P1EvK2br1EDxxlTamhotIo00LG+EYtRY1RHM5fWN2ExeVnlhDgv8vn2RAJ9IYQQFwyDQSOqkR9RjfzoNqgOAKlJNnZvzmT35kwcdsXhg3mkZihUQdR/KpA2GcHuKNv+Cwfm5lP5KTwH7B7Lr0GgFfIdcHGUkabhRmwORdNwIz0bmWgSbiQmWMNskq444gIjcb5HEugLIYS4oAWHmel8ZQidrwxxrXM4FCkpDhKT7GzZk0emHexoxJ+0c+SEg9rBRrJydeKTFIG1jBgMGsczHFiMGmH+BnJsOidScqljySS6bh0OJitaR5kI9tU4mqYT7KvRMMwZpCdlKS6pb8TXrHEg0UG7aBNBPho5+YowfwNRQRqBPhp+Zo1QPw2D3DVYiKLka+GRzKMvhBBClDObzcZnn30GwJgxYzCbzVVcIiFqNu2JTNdz9UpAFZakepEWfSGEEEII4d3kSpdH0olPCCGEEEKIGkha9IUQQgghhHeTBn2PJNAXQgghhBBeTiJ9TyTQF0IIIYQQ3k3ifI8k0BdCCCGEEN5NAn2PJNAXQgghhBBeTiJ9TyTQF0IIIYQQ3k3ifI8k0BdCCCGEEN5NAn2PJNAXQgghhBDeTZNI3xO5YZYQQgghhBA1kLToCyGEEEII7yYN+h5JoC+EEEIIIbycRPqeSKAvhBBCCCG8m8T5HkmgL4QQQgghvJsE+h7JYFwhhBBCCCFqIGnRF0IIIYQQ3k2m1/RIAn0hhBBCCOHdJM73SLruCCGEEEIIUQNJi74QQgghhPBu0qLvkQT6QgghhBDCy0mk74kE+kIIIYQQwrtJnO+RBPpCCCGEEMK7SaDvkQzGFUIIIYQQNd6kSZMICAio6mJUKmnRF0IIIYQQ3k1a9D2SFn0hhBBCCCFqIAn0hRBCCCGEd9O0049S2rp1K1dffTX+/v7UqlWLoUOHcvjwYdfr//d//8dll13mWk5MTMRgMHDppZe61mVmZmI2m5kzZ06py1GepOuOuOAppcjIyKjqYgghahCbzUZOTg4A6enpmM3mKi6REJUrMDAQrQxB93kr466OHDlCz549ady4MV9++SW5ubk89dRT9OrViy1bthAYGEjPnj356quvyM3NxcfHh1WrVmG1Wtm0aRMZGRkEBgby119/Ybfb6dmzZ/nUq4wk0BcXvIyMDGrVqlXVxRBC1FAPPPBAVRdBiEqXlpZGUFBQpe1PPVK2kPbtt9/GZrOxdOlSQkNDAWjfvj0tW7bk888/595776Vnz57k5eWxbt06evXqxapVqxgyZAhLly5l9erV9OvXj1WrVtGsWTMiIiLKo1plJoG+uOAFBgaSlpZW1cUoVmZmJgMGDGDRokU1fraAC6muIPWt6S6k+l5IdQWpb0kEBgZWcKnK1x9//MGVV17pCvIBmjdvTtu2bfnzzz+59957adiwIdHR0axatcoV6I8fP56cnBxWrlzpCvSrS2s+SKAvBJqmVWqrw/kyGAwYjUaCgoJq/A/KhVRXkPrWdBdSfS+kuoLUtyZKSUmhXbt2RdZHRESQnJzsWi4I8NPT09m8eTM9e/YkKyuLuXPnkpeXx/r167nzzjsrseRnJ4NxhRBCCCHEBS00NJSTJ08WWX/ixAm3Vv6ePXuyZs0aVqxYQe3atWnevDk9e/bk77//Zvny5eTl5bkN2K1qEugLIYQQQogLWo8ePfjtt99ISUlxrdu9ezdbtmyhR48ernUFLfiTJ092ddFp164dvr6+vPrqq9SvX58GDRpUdvGLJV13hKjmLBYLd955JxaLpaqLUuEupLqC1Lemu5DqeyHVFaS+3szhcDB37twi6++//34+++wz+vbty1NPPUVubi5PP/00MTEx3Hbbba50zZs3p06dOqxcuZJ3330XAKPRSPfu3Vm8eDG33nprZVWlRDSllKrqQgghhBBCCFGRJk2axPPPP+/xtS+++II2bdrwyCOPsHr1aoxGI3369GHy5MnExsa6pR02bBhz587l33//pW3btgC89tprTJw4kWnTpjF27NgKr0tJSaAvhBBCCCFEDSR99IUQQgghhKiBJNAXQgghhBCiBpLBuEJUsVWrVvHhhx9y6NAhIiMjue222xg0aNBZt9m+fTtz585l06ZNJCQkUKdOHa666ir+7//+D19fX7e0mzdvZsqUKezZs4eQkBCGDh3K6NGjK/fW5IWUpr42m42pU6eybds2du7cSW5uLr/++ivBwcFu6aZNm8bHH39cZPuJEycydOjQ8qxGiVVkfaF6Hd/S1BWcN+OZPHkyK1aswG6306VLFx577DFq167tSlOVxzYuLo7XX3+dLVu24O/vT//+/bnrrrswm81n3U4pxcyZM5kzZw6pqak0a9aMhx56iNatW7ulS0hI4PXXX2fdunWYTCauuOIKHnzwwSqbr7wi67thwwbGjx9fZNs+ffrwyiuvlHtdzqW0dZ0zZw6rV69m27ZtpKam8uqrr9K7d+8i6WrKsS1JfavbsRVOEugLUYX+/fdfHn30Ua677joefvhh/v77b/73v//h5+fn8UejwLJlyzhy5AijRo0iJiaGAwcOMG3aNLZt28ZHH33kSnfkyBHuvfdeOnfuzIQJE9i7dy/vv/8+RqORkSNHVkYV3ZS2vrm5ufz444+0bNmS9u3bs2bNmmLTWq1Wt/cAoF69euVWh/NR0fWtTse3tHUFeOKJJzhw4ABPPPEEFouFqVOnct999zFr1ixMptM/U1VxbNPT0xk/fjwxMTG88cYbnDx5krfffpvc3Fwef/zxs247c+ZMpk2bxj333EPTpk2ZM2cO99xzD1999RXR0dEA2O127rnnHgBefPFFcnNzeeedd3j66aeZMmVKhdbNk4qub4HnnnvObQpCTyexFa0sdV20aBEA3bt3dz0/U006tiWpb4HqcGxFIUoIUWXuvvtuNWbMGLd1Tz75pBo6dOhZt0tOTi6ybvHixapDhw5qx44drnUvvviiuvbaa1V+fr5r3fvvv68uv/xylZeXV8bSn7/S1lcppXRdV0optWDBAtWhQweVkpJSJM1HH32kevToUS5lLQ8VXd/qdHxLW9fNmzerDh06qDVr1rjWHTx4UHXs2FEtXbrUta6qju2MGTNUjx49VGpqqmvd999/rzp16qROnjxZ7Ha5ubmqZ8+e6v3333ety8/PV9dee6165ZVXXOsWL16sOnbsqA4ePOhat2bNGtWhQwe1devW8q1MCVR0ff/++2/VoUMHtX379oqpwHkobV2VUsrhcCillIqPj1cdOnRQy5YtK5KmphxbpUpW3+p0bMVp0kdfiCqSn5/Phg0birR29u3bl4MHD3L06NFitw0JCSmy7qKLLgKcl4oL/PXXX1x++eVul2X79u1LRkYGW7ZsKWsVzktZ6gtUWVej0qqM+laX41uWuv71118EBgbSuXNn17oGDRrQrFkzVq9eXWFlLqm//vqLTp06UatWLde6Pn36oOs6a9euLXa7LVu2kJWV5faemM1mrrjiCrd6/fXXXzRt2tStBbRz587UqlWrSupf0fWtTkpbVwCD4dzhU005tlCy+orqSY6cEFXkv//+w263F7mDXsOGDQFnX8rz8e+//wK48svJyeHEiRNF5v9t0KABmqadd/5lVd71LU5eXh69e/emc+fODBs2jB9++KFc8j1fFV3f6nR8y1LXuLg4YmNji5zYNGzYsMh2VXFs4+LiitQrMDCQ2rVrn7NegMf35Pjx4+Tm5rrSnXkMNU0jNja20r+jBeWpyPoWuP/+++nUqRP9+/fnnXfeKfJ6ZShtXc8n/5pwbM9XdTi24jTpoy9EFUlPTwecf2gLCwoKcnu9JFJTU5k+fTq9evUiJiYGgIyMDI/5m81mfHx8ziv/8lCe9S1O/fr1uffee7nooovIz89nyZIlvPTSS2RmZlZ6n/WKrm91Or5lqWt6enqR7QryKrxdVR3bkpbP03YWiwWr1VpkO6UUGRkZ+Pj4kJGR4TH/oKCgSv+OQsXXNyAggFGjRnHJJZdgtVr5+++/+fLLLzl48GCl91svbV1LqqYc25KqTsdWnCaBvhDlKDMzk8TExHOmK88BhHa7nSeffBJwDmqsTFVR37Pp37+/23KPHj2w2Wx8+umn3HzzzW4DO0ujutW3IlW3ulb0sRWVo3nz5jRv3ty1fOmll1K7dm1ef/11tm3bxsUXX1yFpRNlIce2epK/jEKUo19//ZUXX3zxnOnmzp3rau3MzMx0e62gZaXg9bNRSvH888+zfft2Pv74Y7fpCAtabs7M32azkZubW6L8z6Wy61saffr04bfffuPIkSOuriSlVZ3qW9HHt7LqGhQUxIkTJ4qsz8jIOGcdyvPYnq18Z9arJOULCgoiPz+fvLw8t1bujIwMNE1zHb/AwECP+aenpxMREVEONTg/FV1fT/r06cPrr7/Orl27KjUYLG1dS6qmHNuyqKpjK06TQF+IcjR48GAGDx5corT5+fmYTCbi4uLo2rWra31xfV09mTJlCr/++ivvvPMOzZo1c3vN19eXiIiIIn0vDx06hFKqRPmfS2XXt6pVp/pW9PGtrLo2aNCA9evXo5Ry66cfFxdHkyZNSlP0ctWgQYMi73HB1Y5z1Qucx6PwdzMuLo7IyEh8fHxc6fbt2+e2rVKKQ4cOuQ1QriwVXd/qpLR1PZ/8a8KxFd5NBuMKUUUsFgsdO3bkt99+c1u/bNkyGjZsSN26dc+6/eeff87s2bN57rnn6NSpk8c03bp1Y9WqVdjtdte6pUuXEhgYSNu2bcteifNQ1vqW1i+//EJgYCD169evkPyLUxn1rS7Htyx17datG+np6axfv9617tChQ+zevZvu3bufdb+VcWy7devG+vXrXWMiwHm1w2Aw0KVLl2K3a9OmDf7+/vz666+udXa7neXLl7vVq1u3buzdu5fDhw+71q1fv560tLRz1r8iVHR9Pfnll18AaNmyZRlLf35KW9fzyb8mHNuyqKpjK06TFn0hqtAdd9zBuHHjXHcZ3LhxI0uWLClyF8HOnTszYMAAnn32WQCWLFnC+++/zzXXXEO9evXYunWrK210dLRr+s1Ro0axZMkSnnzySYYNG8a+ffv44osvSnQnxIpQ2voCrF69mpycHHbs2AE478Lq5+dHo0aNaNSoEQAjRozg2muvpUGDBuTm5rJkyRKWL1/Oww8/XCV9uCu6vtXp+Ja2rm3atKFr16688MILPPjgg64bZjVt2pQrrrjCtV1VHdsbbriBb7/9locffpjbb7+dkydP8s4773D99dcTHh7uSjdhwgSOHTvGjz/+CDhv7jVmzBimT59OSEgITZo0Yc6cOaSlpTFixAjXdr179+azzz7jscce4+677yY3N5cpU6bQo0ePKunqUNH1feaZZ4iOjqZ58+auAZuzZ8/m8ssvr/RgsLR1BdixYwdHjx4lNTUVgG3btgHOqY87dOgA1JxjCyWrb3U6tuI0TSmlqroQQlzIVq5cyYcffsihQ4eIjIzktttu47rrrnNL07FjR6699lomTZoEwKRJk1i4cKHH/J577jkGDhzoWt68eTNvv/02e/bsISQkhGHDhjF69Ogqm5e+NPUFGDhwIMeOHSuS35133sm4ceMA52Dk7du3k5SUBECTJk0YPnw411xzTcVV6Bwqsr5QvY5vaeuamZnJ5MmTWb58OQ6Hg86dO/PYY4+5BR9VeWwPHjzIG2+8webNm/H392fAgAFFTqbGjh3LsWPH+Omnn1zrlFJ8/vnnzJ07l5SUFJo1a8ZDDz1EmzZt3PI/efIkb7zxBuvWrcNoNHLFFVfw0EMPERAQUOF186Qi6/vZZ5+xePFijh8/Tn5+PnXr1qVfv36MGTOmShofSlvX4v4GX3LJJUyfPt21XFOObUnqW92OrXCSQF8IIYQQQogaSProCyGEEEIIUQNJoC+EEEIIIUQNJIG+EEIIIYQQNZAE+kIIIYQQQtRAEugLIYQQQghRA0mgL4QQQgghRA0kgb4QQgghhBA1kAT6QgghhBBC1EAS6AshRCnddtttVXaH4TNt27YNk8nEsmXLXOtWrFiBpml8/vnnVVcwUS18/vnnaJrGihUrSrW9fJY8+/fffzEYDKxcubKqiyKERxLoCyHcHDhwgLFjx9K8eXP8/PwICQmhRYsWjB49muXLl7ulbdCgARdffHGxeRUEwomJiR5f37lzJ5qmoWkaf/zxR7H5FKQpePj4+NC0aVMeeughkpOTS1fRGuahhx6ie/fu9OnTp6qLUini4uKYNGkS//77b1UXRVSS1NRUJk2aVOqTldI622etXbt2DB48mIcffhilVKWWS4iSMFV1AYQQ1ceGDRvo1asXZrOZUaNG0apVK3Jycti7dy9Lly4lMDCQK664otz29+mnnxIYGIivry8zZszgsssuKzZtu3btePjhhwFITk7m559/5u2332bZsmVs3LgRi8VSbuXyNmvWrGHZsmX8+OOPbut79uxJTk4OZrO5agpWgeLi4nj++edp0KAB7dq1q+riiEqQmprK888/D8Dll19eafs912ftgQceoFevXvz8888MGDCg0solRElIoC+EcHn++efJzs7m33//pW3btkVeP378eLnty2az8cUXXzBs2DBq1arF9OnTeffddwkMDPSYvl69eowYMcK1fN999zFw4EAWLlzI/PnzGTZsWLmVzdtMnTqV2rVr079/f7f1BoMBHx+fKiqVEBeGyy67jAYNGvDRRx9JoC+qHem6I4Rw2bt3L2FhYR6DfIDIyMhy29dPP/3EyZMnGT16NLfddhtZWVl8++2355XH1VdfDcC+ffuKTfPhhx+iaRoLFiwo8pqu60RHR7u10i1dupSbbrqJRo0a4evrS3BwMH379i1xH9zLL7+cBg0aFFkfFxeHpmlMmjTJbb1Sig8//JAOHTrg5+dHQEAAV1xxRZFuUsWx2+38+OOP9O7du0jLvad+1YXXTZ06lYsuuggfHx9at27NwoULAdi6dSv9+vUjKCiIsLAw7rvvPmw2m8d6HjhwgOuuu45atWoRFBTEkCFDOHDggFtaXdd56aWX6NmzJ5GRkVgsFmJiYpgwYQJJSUke6/X9999z+eWXExwcjJ+fHxdddBH33Xcf+fn5fP75564rS2PGjHF16SpJK29cXBwjR44kIiICq9VK48aNefLJJ8nOznZLN2nSJDRNY/fu3Tz55JNER0djtVpp27YtP//88zn3A6f7xf/222+88MILxMbG4uvrS+fOnVm7di0AK1eupEePHvj7+xMVFcX//vc/j3n9+OOPdO/eHX9/fwICAujevTvz58/3mPbjjz+mefPmWK1WmjRpwpQpU4rtVpKWlsbjjz9OkyZNsFqthIeHc/PNNxc5huerpO/z2ca5aJrGbbfdBjg/tw0bNgScDRIFx7zgu1b4+/X111/Tpk0bfHx8iImJYdKkSdjtdre8S/o9LclnTdM0rr76apYsWUJmZuZ5vlNCVCxp0RdCuDRu3Jjdu3czb948rr/++hJt43A4iu2Dn5eXV+x2n376KQ0bNuSyyy5D0zTat2/PjBkzuOOOO0pc3r179wJQu3btYtMMHz6cBx98kFmzZjFo0CC313777Tfi4+NdXYLA+cOenJzMqFGjiI6OJj4+nk8++YSrrrqK5cuXn7V7UWmMHDmSr7/+mqFDhzJmzBjy8vL46quv6NOnD/PmzStS5jNt3LiRzMxMOnXqdF77/eCDD0hJSeGOO+7Ax8eHd999lyFDhjBnzhzuvPNObr75ZgYPHszSpUt57733qFOnDk8//bRbHllZWVx++eV07tyZV155hb179zJ16lTWrl3Lpk2bXCeG+fn5vPHGG9xwww1cd911+Pv78/fff/Ppp5/y559/Ful69dRTT/Hyyy/TsmVLHnzwQaKioti/fz/ff/89L7zwAj179uTJJ5/k5ZdfZuzYsa5jEhERcdY6Hzp0iE6dOpGWlsZdd91F06ZNWbFiBa+88gqrV6/mt99+w2Ry/1kcPXo0ZrOZRx55hPz8fKZMmcLgwYPZs2ePx0DRk4kTJ+JwOLj//vvJz8/nrbfeom/fvsyaNYv/+7//Y+zYsdx666189913PPvsszRs2NDt6tXUqVO5++67ad68Oc8++yzg/JwOHjyYadOmMXbsWFfaKVOm8OCDD9K2bVtefvllsrOzefPNN6lTp06RcqWlpdGtWzcOHz7M7bffTqtWrTh27BhTp06lc+fObNiwgdjY2BLVsazv87m0aNGCt99+mwcffJAhQ4a4/j4FBAS4pVuwYAEHDhzg7rvvJjIykgULFvD8889z6NAhPvvss/OuS0k/a127dmXatGn8+eef9OvX77z3I0SFUUIIccpff/2lzGazAlTTpk3VmDFj1NSpU9WOHTs8po+NjVXAOR8JCQlu28XHxyuj0aiee+4517opU6YowOO+ANW3b1+VkJCgEhIS1J49e9TkyZOV2WxWtWrVUidOnDhrvYYOHaqsVqtKTk52Wz9ixAhlMpncts/MzCyy/fHjx1VYWJi65ppr3NaPHj1anflntFevXio2NrZIHgcPHlSAW53nzZunADVt2jS3tDabTXXo0EE1aNBA6bp+1rrNmDFDAWr+/PlFXlu+fLkC1GeffVZkXd26dVVqaqpr/ebNmxWgNE1T33//vVs+l1xyiYqMjCxST0Ddf//9busL6jRu3DjXOl3XVXZ2dpHyffLJJwpQ3377rWvdunXrFKCuuOIKlZOT45Ze13XX++Gpbudyyy23KEAtWrTIbf0jjzyiAPXJJ5+41j333HMKUAMGDHA7BuvXr1eAmjhx4jn399lnnylAtW/fXuXl5bnWz58/XwHKZDKpv//+27U+Ly9PRUZGqi5durjWJScnK39/f9W4cWOVlpbmWp+WlqYaNWqkAgICVEpKilJKqZSUFOXn56datGihsrKyXGmPHDmi/P39FaCWL1/uWn/fffcpHx8f9e+//7qVOy4uTgUGBqrRo0e71p3P+30+77On71ABwK0Mnr5DZ75mMBjUxo0bXet1XVeDBw9WgFqzZo1r/fl8T0tS9z/++EMB6s033yw2jRBVQbruCCFcunbtysaNGxk9ejRpaWl89tln3HXXXbRs2ZKePXt6vJzfoEEDli1b5vHRt29fj/v5/PPP0XWdUaNGudbdeuutmM1mZsyY4XGbpUuXEh4eTnh4OM2aNeOhhx6iZcuWLF261GNrZWGjR48mLy/PrWtQZmYmP/zwA/369XPb3t/f3y1NUlISRqORzp07s27durPu53x9+eWXBAYGMnjwYBITE12P1NRUBg4cSFxcnOuqRXESEhIACA0NPa9933bbbdSqVcu13KZNG4KCgqhbt26Rqzk9evTg+PHjHrslTJw40W15yJAhXHTRRW4DgzVNw9fXF3BeAUpNTSUxMZErr7wSwO19/eqrrwB45ZVXiowvKOg2URq6rrNgwQLat29fZCzDE088gcFg4Icffiiy3f333++2z0svvZSAgIBzHpfCJkyY4HbFoqBVuHPnznTs2NG13mKx0KlTJ7e8ly1bRlZWFvfddx9BQUGu9UFBQdx3331kZmby66+/As7vSHZ2NnfffTd+fn6utNHR0dx6661uZVJK8dVXX9GzZ0/q1avn9vnz9/enS5cuLF26tMR1LFDa97m89OnTh0suucS1rGkajz32GECF7jcsLAyAkydPVtg+hCgN6bojhHDTunVrV5/uQ4cOsXLlSj755BP++OMPrrvuuiLdLPz9/endu7fHvL788ssi65RSzJgxgzZt2qDrulv/+u7du/PFF1/wyiuvFLm037lzZ1588UUArFYrsbGxxMTElKhOBcH8rFmzGD9+PODsA56VleV2sgGwf/9+nnrqKX755RdSU1PdXivvOfN37txJRkbGWbucnDhxgmbNmhX7ekGZ1HlO7deoUaMi60JCQqhfv77H9QBJSUluXSWCg4M9jtto0aIFP/74I1lZWa4Tp++++4633nqLTZs2Fenvn5KS4nq+d+9eNE0rdpxIaSUkJJCZmUmrVq2KvBYaGkpUVJTHE1lP71NYWFixYws8OTOPgvezoM/5ma8VzvvgwYMAHstdsK6g3AX/N2/evEjali1bui0nJCSQlJTkOoH2xGA4/7bA0r7P5aVFixZF1hXUvSL3W/D9qy731RCigAT6QohixcbGMmrUKEaOHMlll13G6tWrWb9+PT169Ch1nitXrmT//v0ANG3a1GOahQsXMnjwYLd1tWvXLvaE4lxMJhO33HILU6ZMYd++fTRp0oRZs2YREhLi1gc+MzOTnj17kpWVxQMPPEDr1q0JDAzEYDDwyiuv8Pvvv59zX8X90J85GBCcwUF4eDizZ88uNr+z3acAcAVp53s/AaPReF7r4fxPJgrMmzePm266iU6dOvHOO+9Qv359fHx8cDgc9OvXD13X3dKXpeW+vBX3fpzPe1Ga97qiFZS/d+/ePP7441VWjvP5vlTn/RZ8/4o7aRKiqkigL4Q4J03T6Ny5M6tXryY+Pr5Mec2YMQOr1cqsWbM8thiOGzeOTz/9tEigX1ajR49mypQpzJo1izvvvJMVK1YwduxYrFarK81vv/3G0aNHmTFjBmPGjHHb/syBqMUJDQ1l48aNRdZ7ak1s2rQpe/bsoUuXLkUGFZZUwYnA+XQlKS+pqakcP368SKv+zp07qVOnjqs1/4svvsDHx4fly5e7dSnZtWtXkTybNWvG4sWL2bx581kHGJ/viUB4eDiBgYFs3769yGspKSkcO3asWs7HX3A1YPv27Vx11VVur+3YscMtTcH/u3btKjZtgfDwcIKDg0lPTy/1CbQn5/s+F3Q5S05Odut+5un7UpJjvnPnziLrznyfCvZb0u9pSfZbcGXyXCfmQlQ26aMvhHBZtmyZxxatnJwcV3/dM7sAnI+0tDTmzp1L3759ufHGGxk6dGiRx6BBg1i8eDHHjh0r9X48adeuHW3atOHLL7/kiy++QNd1Ro8e7ZamoIX1zNbapUuXlrh/frNmzcjIyGD9+vWudbqu8/bbbxdJO2rUKHRd54knnvCY14kTJ865v/bt2xMUFOSarrGyvfrqq27LP/zwA7t373Y7UTMajWia5tZyr5RydcUq7JZbbgHgySefJD8/v8jrBcem4MSopFcyDAYDAwcOZNOmTSxZsqRIHXRdZ8iQISXKqzL16dMHf39/3nvvPTIyMlzrMzIyeO+99wgICHDdDblPnz74+vrywQcfuE1j+d9//xW5amQwGLj11ltZv349c+fO9bjv0vQ3P9/3uaBbWsE4gwJvvfVWkbxLcsyXLVvGP//841pWSvH6668DuH0mz+d7WpL9rl27FpPJRPfu3YtNI0RVkBZ9IYTLgw8+SFJSEoMGDaJ169b4+flx5MgRZs+ezZ49exg1ahStW7cudf5ff/01OTk53HDDDcWmueGGG/j888+ZOXNmkYGeZTV69GgefvhhXnvtNZo1a0aXLl3cXu/RoweRkZE8/PDDxMXFER0dzb///ssXX3xB69at2bp16zn3MXbsWN566y2GDBnC/fffj8ViYe7cuR5PoAqm1Hz//ff5559/uPbaa6lduzb//fcfa9asYd++fefsV2w0Grn++uv58ccfycvLc7tCUdFq167NvHnzOHr0KJdffrlres2IiAi3+wUMHTqU77//niuvvJJRo0Zhs9n48ccfi8ypDtCpUycef/xxXnvtNS655BJuuukmIiMjOXjwIHPnzmX9+vUEBwfTsmVLAgMDmTp1Kn5+fgQHB1OnTh3XAF9PXn75ZZYtW8bgwYO56667aNKkCatWreLbb7+lZ8+eRU78qoPg4GBef/117r77bjp37uyaV/7zzz9n3759TJs2zTWoOiQkhP/973888sgjdOvWjVGjRpGdnc1HH31E06ZN2bRpk1veL730EqtXr+bGG2/kxhtvpEuXLlgsFg4dOsTPP/9Mhw4d3O7BUFLn8z7ffPPNPPnkk4wdO5Zdu3YRGhrKkiVLPE7ZGxYWRpMmTfjmm29o3LgxERER+Pv7M3DgQFeatm3bcuWVV3L33XcTFRXF/Pnz+fXXXxk5ciRdu3Z1pTuf7+m5PmtKKZYsWUK/fv1KfWVOiApTJXP9CCGqpV9++UXdddddqk2bNiosLEwZjUYVGhqqLr/8cvXpp58qh8Phlj42Nla1atWq2PwKps4rmF6zY8eOymQyFZnmsrDc3FwVGBiomjVr5lrHqWkOy+r48ePKZDIpQL344ose02zevFldffXVKjg4WAUEBKhevXqpVatWeZwGsLipARctWqTatm2rLBaLioqKUo899pjatWtXsVMDzpo1S/Xo0UMFBgYqq9WqYmNj1ZAhQ9Q333xTonoVTEk5d+5ct/Vnm17T01SBsbGxqlevXkXWF0w1efDgQde6gukJ9+/frwYNGqQCAwNVQECAGjRokNq7d2+RPKZPn65atGihrFarioyMVHfeeadKSkoqMoVigdmzZ6tu3bqpgIAA5efnpy666CJ1//33u01TuWjRItW+fXtltVoV4LHsZzpw4IAaMWKECg8PV2azWTVs2FA98cQTbtNRFlfnc71PZyqYXrPwlJYFiqt3cZ+pefPmqa5duyo/Pz/l5+enunbtqn744QeP+/3oo49Us2bNlMViUY0bN1Zvv/22axrWM8uSlZWlXnjhBXXxxRcrHx8fFRAQoJo3b67uuOMOtXbtWle6853OtKTvs1JKrV27VnXr1k1ZrVYVFham7rzzTpWSkuLxPVq3bp3q1q2b8vPzU4BriszC02LOnj1btW7dWlksFhUdHa2eeeYZlZ+fX2S/5/M9PdtnbcWKFQpQCxcuLNF7I0Rl0pQq5egqIYQQ1Ua/fv3Iysrijz/+qJT9XX755cTFxREXF1cp+xPibOLi4mjYsCHPPfdckbtPV7QhQ4Zw5MgR/v7772oziFyIAtJHXwghaoC33nqLNWvWlGrucyFE6WzatIn58+fz1ltvSZAvqiXpoy+EEDVAq1atKnxKQiGEu/bt2xeZHlaI6kRa9IUQQgghhKiBpI++EEIIIYQQNZC06AshhBBCCFEDSaAvhBBCCCFEDSSBvhBCCCGEEDWQBPpCCCGEEELUQBLoCyGEEEIIUQNJoC+EEEIIIUQNJIG+EEIIIYQQNZAE+kIIIYQQQtRA/w9ilyjQJ6bopwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Cora\")\n", + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Citeseer\")\n", + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Pubmed\")\n", + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Cornell\")\n", + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Texas\")\n", + "get_KAN_shap_summary_plot(result_KAN=result_KAN, dataset=\"Wisconsin\")" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Cora\")\n", + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Citeseer\")\n", + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Pubmed\")\n", + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Cornell\")\n", + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Texas\")\n", + "get_MLP_shap_summary_plot(result_MLP=result_MLP, dataset=\"Wisconsin\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [], + "source": [ + "def plot_parameter_efficiency(\n", + " result_GNN,\n", + " result_KANGNN,\n", + " result_KAN,\n", + " result_MLP,\n", + " dataset,\n", + " input_embed_only: bool = False,\n", + "):\n", + " num_parameters_GNN = []\n", + " test_accuracy_GNN = []\n", + "\n", + " for hidden_size, hidden_size_results in result_GNN[dataset][\"GCN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " num_parameters_GNN.append(results[\"Num. parameters\"])\n", + " test_accuracy_GNN.append(results[\"Test accuracy\"])\n", + "\n", + " num_parameters_KANGNN = []\n", + " test_accuracy_KANGNN = []\n", + "\n", + " for hidden_size, hidden_size_results in result_KANGNN[dataset][\"KANGNN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for mp_layers, mp_layers_results in num_layers_results.items():\n", + " for input_embed, input_embed_results in mp_layers_results.items():\n", + " if input_embed_only:\n", + " if input_embed:\n", + " for lr, results in input_embed_results.items():\n", + " num_parameters_KANGNN.append(results[\"Num. parameters\"])\n", + " test_accuracy_KANGNN.append(results[\"Test accuracy\"])\n", + " else:\n", + " for lr, results in input_embed_results.items():\n", + " num_parameters_KANGNN.append(results[\"Num. parameters\"])\n", + " test_accuracy_KANGNN.append(results[\"Test accuracy\"])\n", + " # for lr, results in input_embed_results.items():\n", + " # num_parameters_KANGNN.append(results[\"Num. parameters\"])\n", + " # test_accuracy_KANGNN.append(results[\"Test accuracy\"])\n", + "\n", + " num_parameters_KAN = []\n", + " test_accuracy_KAN = []\n", + "\n", + " for hidden_size, hidden_size_results in result_KAN[dataset][\"KAN\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for input_embed, input_embed_results in num_layers_results.items():\n", + " if input_embed_only:\n", + " if input_embed:\n", + " for lr, results in input_embed_results.items():\n", + " num_parameters_KAN.append(results[\"Num. parameters\"])\n", + " test_accuracy_KAN.append(results[\"Test accuracy\"])\n", + " else:\n", + " for lr, results in input_embed_results.items():\n", + " num_parameters_KAN.append(results[\"Num. parameters\"])\n", + " test_accuracy_KAN.append(results[\"Test accuracy\"])\n", + " \n", + " num_parameters_MLP = []\n", + " test_accuracy_MLP = []\n", + " \n", + " for hidden_size, hidden_size_results in result_MLP[dataset][\"MLP\"].items():\n", + " for num_layers, num_layers_results in hidden_size_results.items():\n", + " for lr, results in num_layers_results.items():\n", + " num_parameters_MLP.append(results[\"Num. parameters\"])\n", + " test_accuracy_MLP.append(results[\"Test accuracy\"])\n", + "\n", + " # Get the unique values of the number of parameters\n", + " unique_num_parameters_GNN = list(set(num_parameters_GNN))\n", + " unique_num_parameters_KANGNN = list(set(num_parameters_KANGNN))\n", + " unique_num_parameters_KAN = list(set(num_parameters_KAN))\n", + " unique_num_parameters_MLP = list(set(num_parameters_MLP))\n", + "\n", + " plt.figure(figsize=(6, 6), dpi=100)\n", + " \"\"\"\n", + " Plot the test accuracy for each unique number of parameters,\n", + " set the alpha value to be 1 for the highest test accuracy point,\n", + " and decrease the alpha value for the other points\n", + " \"\"\"\n", + " for num_parameters in unique_num_parameters_GNN:\n", + " indices = [i for i, x in enumerate(num_parameters_GNN) if x == num_parameters]\n", + " test_accuracies = [test_accuracy_GNN[i] for i in indices]\n", + " max_test_accuracy = max(test_accuracies)\n", + " for test_accuracy in test_accuracies:\n", + " if test_accuracy == max_test_accuracy:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"orangered\",\n", + " alpha=1,\n", + " )\n", + " else:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"orangered\",\n", + " alpha=0.1 * (test_accuracy / max_test_accuracy),\n", + " )\n", + " for num_parameters in unique_num_parameters_KANGNN:\n", + " indices = [\n", + " i for i, x in enumerate(num_parameters_KANGNN) if x == num_parameters\n", + " ]\n", + " test_accuracies = [test_accuracy_KANGNN[i] for i in indices]\n", + " max_test_accuracy = max(test_accuracies)\n", + " for test_accuracy in test_accuracies:\n", + " if test_accuracy == max_test_accuracy:\n", + " plt.scatter(num_parameters, test_accuracy, color=\"darkviolet\", alpha=1)\n", + " else:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"darkviolet\",\n", + " alpha=0.1 * (test_accuracy / max_test_accuracy),\n", + " )\n", + " for num_parameters in unique_num_parameters_KAN:\n", + " indices = [i for i, x in enumerate(num_parameters_KAN) if x == num_parameters]\n", + " test_accuracies = [test_accuracy_KAN[i] for i in indices]\n", + " max_test_accuracy = max(test_accuracies)\n", + " for test_accuracy in test_accuracies:\n", + " if test_accuracy == max_test_accuracy:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"dodgerblue\",\n", + " alpha=1,\n", + " )\n", + " else:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"dodgerblue\",\n", + " alpha=0.1 * (test_accuracy / max_test_accuracy),\n", + " )\n", + " for num_parameters in unique_num_parameters_MLP:\n", + " indices = [i for i, x in enumerate(num_parameters_MLP) if x == num_parameters]\n", + " test_accuracies = [test_accuracy_MLP[i] for i in indices]\n", + " max_test_accuracy = max(test_accuracies)\n", + " for test_accuracy in test_accuracies:\n", + " if test_accuracy == max_test_accuracy:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"limegreen\",\n", + " alpha=1,\n", + " )\n", + " else:\n", + " plt.scatter(\n", + " num_parameters,\n", + " test_accuracy,\n", + " color=\"limegreen\",\n", + " alpha=0.1 * (test_accuracy / max_test_accuracy),\n", + " )\n", + "\n", + " plt.xticks(rotation=45)\n", + " plt.xscale(\"log\")\n", + " plt.xlabel(\"Number of parameters\")\n", + " plt.ylabel(\"Test accuracy\")\n", + " plt.ylim(0, 1)\n", + " plt.title(f\"Parameter efficiency, {dataset} dataset\")\n", + " plt.scatter([], [], color=\"orangered\", label=\"GNN\")\n", + " plt.scatter([], [], color=\"darkviolet\", label=\"KAN + GNN\")\n", + " plt.scatter([], [], color=\"dodgerblue\", label=\"KAN\")\n", + " plt.scatter([], [], color=\"limegreen\", label=\"MLP\")\n", + " plt.legend(loc=\"lower right\")\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 41, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Cora\",\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Citeseer\",\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Pubmed\",\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Cornell\",\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Texas\",\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Wisconsin\",\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": 42, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAhgAAAI0CAYAAABf6lBdAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjkuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy80BEi2AAAACXBIWXMAAA9hAAAPYQGoP6dpAACq00lEQVR4nOzdd5xU1dkH8N85t0zbCssuS4lUOyJBJaCIsWtEDbEnwRpjLMGgqMQoYiOKscSuseSNXSwxicGGJmCNCgZjR5QiLCywbWZnbjnn/ePsDDs7M7szu9N29/n64bPuvXdmzty5O/PMOc9zDpNSShBCCCGEZBEvdAMIIYQQ0vdQgEEIIYSQrKMAgxBCCCFZRwEGIYQQQrKOAgxCCCGEZB0FGIQQQgjJOgowCCGEEJJ1FGAQQgghJOsowCCEEEJI1lGAQUiR+vLLL3HooYeivLwcjDE8//zzAID//Oc/mDJlCgKBABhjWLFiBa666iowxjJ+jAMOOAAHHHBAdhveR5x22mkYMWJEoZuRNfl6rbt7LZK+hwKMfu7hhx8GYyz2z+v1Yscdd8T555+Purq6Qjcvp9566y1cddVVaGhoKHRTkjr11FOxcuVKXHfddfjLX/6CvfbaC7Zt4/jjj8fWrVtxyy234C9/+Qt22GGHQje16Bx55JGorKxEx5UQli9fDsZY0nO2ZMkSMMZw33335auZpIO77roLDz/8cKGbAQD47rvvcNVVV2HFihWFbkrvJUm/9tBDD0kA8uqrr5Z/+ctf5P333y9PPfVUyTmXI0eOlMFgsNBNzJmFCxdKAHL16tWFbkqCUCgkAcjLL788bvunn34qAcj7778/brtt27K1tTXjx4lEIjISifSorcXouuuukwDkf//737jtt99+u9R1XQKQa9eujdt39dVXSwDyf//7n5RSSsuyZDgczlubcy1fr/W8efNkdz9adtttNzlt2rTsNqib/vOf/0gA8qGHHip0U3ot6sEgAIAjjjgCP/vZz3DWWWfh4YcfxoUXXojVq1fjr3/9a4/uVwiBcDicpVb2DqFQqMf3sXnzZgBARUVF3PZNmzYl3a7rOrxeb8aPY5omTNPsVhuL2X777QcAWLZsWdz2N998E0ceeSRKSkoS9i1btgwDBw7ELrvsAgAwDAMejyc/Dc6Dvvpak+JFAQZJ6sADDwQArF69GgBw0003YcqUKRg4cCB8Ph8mTpyIRYsWJdyOMYbzzz8fjz76KHbbbTd4PB4sXry4W/fx9NNPY9ddd4XP58PkyZOxcuVKAMC9996LMWPGwOv14oADDsA333yTcB/vvvsuDj/8cJSXl8Pv92PatGl48803Y/uvuuoqzJkzBwAwcuTI2BBR+/t65JFHMHHiRPh8PgwYMAAnnXQS1q5dG/c4BxxwAHbffXd88MEH2H///eH3+/Hb3/6203P72Wef4bjjjsOAAQPg9Xqx11574YUXXohrW7QLf86cOWCMYcSIETjttNMwbdo0AMDxxx8PxlhsTD3VuPcjjzyCffbZB36/H5WVldh///3x8ssvx7W/47h8JBLBvHnzMGbMGHg8HgwfPhyXXHIJIpFI3HHR1+n555/H7rvvDo/Hg9122y32ere3fv16nHnmmRgyZAg8Hg9GjhyJX/3qV7AsC19//TUYY7jlllsSbvfWW2+BMYbHH3+803Pa0T777APTNONec0AFGPvvvz/22WefuH1CCLzzzjuYMmVK7Dwmy8F44oknMHHiRJSWlqKsrAzjxo3DbbfdFndMQ0MDfvOb32DEiBHweDwYNmwYZs6cifr6+tgxmzZtwplnnomamhp4vV6MHz8ef/7zn+Pu55tvvgFjDDfddBPuu+8+jB49Gh6PB3vvvTf+85//xB27ceNGnH766Rg2bBg8Hg9qa2txzDHHxF3PHV/rN954A4wxPPXUU7juuuswbNgweL1eHHTQQfjqq6/SOs/Lli3D3nvvDa/Xi9GjR+Pee+9NetxDDz2EAw88ENXV1fB4PNh1111x9913xx0zYsQI/O9//8O//vWv2N9jtL1bt27FxRdfjHHjxqGkpARlZWU44ogj8NFHHyU81u23347ddtstds3vtddeeOyxx+KOWb9+Pc444wzU1NTErtsHH3ww7tzsvffeAIDTTz891p5iGb7pLfRCN4AUp1WrVgEABg4cCAC47bbbcPTRR+OnP/0pLMvCE088geOPPx5///vf8aMf/SjutkuWLMFTTz2F888/H1VVVbE36UzuY+nSpXjhhRdw3nnnAQAWLFiAo446CpdccgnuuusunHvuudi2bRtuvPFGnHHGGViyZEnc4x9xxBGYOHEi5s2bB8557A1u6dKl2GeffTBjxgx88cUXePzxx3HLLbegqqoKADBo0CAAwHXXXYcrrrgCJ5xwAs466yxs3rwZt99+O/bff38sX748rgdhy5YtOOKII3DSSSfhZz/7GWpqalKe1//973/Yd999MXToUFx22WUIBAJ46qmncOyxx+KZZ57Bj3/8Y8yYMQMVFRX4zW9+g5NPPjn2jbumpgZDhw7F9ddfj1//+tfYe++9O32s+fPn46qrrsKUKVNw9dVXwzRNvPvuu1iyZAkOPfTQpLcRQuDoo4/GsmXLcPbZZ2OXXXbBypUrccstt+CLL76IJZpGLVu2DM8++yzOPfdclJaW4o9//CN+8pOfYM2aNbFr57vvvsM+++yDhoYGnH322dh5552xfv16LFq0CKFQCKNGjcK+++6LRx99FL/5zW/i7v/RRx9FaWkpjjnmmJTPMxmv14uJEyfG9VKsXbsWa9euxZQpU9DQ0IB//OMfsX0rV65EU1NTrOcjmVdeeQUnn3wyDjroINxwww0AgE8//RRvvvkmZs2aBQBoaWnB1KlT8emnn+KMM87A97//fdTX1+OFF17AunXrUFVVhdbWVhxwwAH46quvcP7552PkyJF4+umncdppp6GhoSF2X1GPPfYYmpub8ctf/hKMMdx4442YMWMGvv76axiGAQD4yU9+gv/973+44IILMGLECGzatAmvvPIK1qxZ02Wi6u9//3twznHxxRejsbERN954I37605/i3Xff7fR2K1euxKGHHopBgwbhqquuguM4mDdvXtJr8u6778Zuu+2Go48+Grqu429/+xvOPfdcCCFif+O33norLrjgApSUlODyyy8HgNh9ff3113j++edx/PHHY+TIkairq8O9996LadOm4ZNPPsGQIUMAAPfffz9+/etf47jjjsOsWbMQDofx3//+F++++y5OOeUUAEBdXR1+8IMfxALkQYMG4Z///CfOPPNMNDU14cILL8Quu+yCq6++GldeeSXOPvtsTJ06FQAwZcqUTs8J6aDQYzSksKI5GK+++qrcvHmzXLt2rXziiSfkwIEDpc/nk+vWrZNSqpyA9izLkrvvvrs88MAD47YDkJzz2Dh2e5nch8fjicuNuPfeeyUAOXjwYNnU1BTbPnfu3Lg8CiGEHDt2rDzssMOkECLusUeOHCkPOeSQ2LZUORjffPON1DRNXnfddXHbV65cKXVdj9s+bdo0CUDec889Cc83mYMOOkiOGzcubmxfCCGnTJkix44dG9u2evVqCUAuXLgw7vavv/66BCCffvrpuO0dx72//PJLyTmXP/7xj6XrunHHtj8v06ZNixvz/stf/iI553Lp0qVxt7nnnnskAPnmm2/GtgGQpmnKr776Krbto48+kgDk7bffHts2c+ZMyTmX//nPfxLOR7Qt0df3008/je2zLEtWVVXJU089NeF26ZgzZ44EELuGH3/8cen1emUkEpEvvvii1DQtdi3dcccdCc/v1FNPlTvssEPs91mzZsmysjLpOE7Kx7zyyislAPnss8+mfK633nqrBCAfeeSRuOc6efJkWVJSEmtT9BoYOHCg3Lp1a+zYv/71rxKA/Nvf/iallHLbtm1Jr5WOOr7W0Wtpl112icvNuO222yQAuXLlyk7v79hjj5Ver1d+++23sW2ffPKJ1DQtIQej49++lFIedthhctSoUXHbUuVghMPhhOt49erV0uPxyKuvvjq27ZhjjpG77bZbp+0+88wzZW1trayvr4/bftJJJ8ny8vJYWykHo+doiIQAAA4++GAMGjQIw4cPx0knnYSSkhI899xzGDp0KADA5/PFjt22bRsaGxsxdepUfPjhhwn3NW3aNOy6664J2zO5j4MOOijum9ekSZMAqG9qpaWlCdu//vprAMCKFSvw5Zdf4pRTTsGWLVtQX1+P+vp6BINBHHTQQfj3v/8NIUSn5+LZZ5+FEAInnHBC7Pb19fUYPHgwxo4di9dffz3ueI/Hg9NPP73T+wRUN++SJUtwwgknoLm5OXa/W7ZswWGHHYYvv/wS69ev7/J+0vH8889DCIErr7wSnMf/mXdWQvj0009jl112wc477xz33KNDZh2f+8EHH4zRo0fHft9jjz1QVlYWez2EEHj++ecxffp07LXXXgmPF23LCSecAK/Xi0cffTS276WXXkJ9fT1+9rOfZfjslWhvxNKlSwGo4ZGJEyfCNE1Mnjw5NiwS3RcdrkqloqICwWAQr7zySspjnnnmGYwfPx4//vGPE/ZFn+uLL76IwYMH4+STT47tMwwDv/71r9HS0oJ//etfcbc78cQTUVlZGfs9+m06eo59Ph9M08Qbb7yBbdu2pT4hKZx++ulxuRkd7z8Z13Xx0ksv4dhjj8X3vve92PZddtkFhx12WMLx7f/2GxsbUV9fj2nTpuHrr79GY2Njl230eDyx69h1XWzZsgUlJSXYaaed4t4/KioqsG7duoQhpCgpJZ555hlMnz4dUsq4a/ywww5DY2Nj0vcj0j00REIAAHfeeSd23HFH6LqOmpoa7LTTTnEfTH//+99x7bXXYsWKFXFj8ck+rEaOHJn0MTK5j/ZvWgBQXl4OABg+fHjS7dE31i+//BKAKvFMpbGxMe4Nu6Mvv/wSUkqMHTs26f5ot3TU0KFD00qe++qrryClxBVXXIErrrgi6TGbNm2KBXU9sWrVKnDOkwZ6nfnyyy/x6aefxoaKkrWvvY6vEwBUVlbGXo/NmzejqakJu+++e6ePW1FRgenTp+Oxxx7DNddcA0ANjwwdOjQW3GRq3333BWMMb775Jk466SS8+eabOOSQQ2KPt+uuu8a2vfnmm9h77707fR3PPfdcPPXUUzjiiCMwdOhQHHrooTjhhBNw+OGHx45ZtWoVfvKTn3Tarm+//RZjx45NCPyiyaXffvtt3PaO5zh67UbPscfjwQ033ICLLroINTU1+MEPfoCjjjoKM2fOxODBgzttSzr3n8zmzZvR2tqa9G9kp512wosvvhi37c0338S8efPw9ttvJyRBNzY2xv6OUxFC4LbbbsNdd92F1atXw3Xd2L7oUBwAXHrppXj11Vexzz77YMyYMTj00ENxyimnYN999421u6GhAffdd1/KcuSO1zjpPgowCACVFJfq29vSpUtx9NFHY//998ddd92F2tpaGIaBhx56KCF5Coj/ttLd+9A0LWlbUm2XbfMdRHsnFi5ciD333DPpsSUlJUm3RwkhwBjDP//5z6SP1/H2yZ5vqvsFgIsvvjjptzwAGDNmTFr3lStCCIwbNw4333xz0v0dA7yuXo9MzJw5E08//TTeeustjBs3Di+88ALOPffchA/idA0cOBA777wzli1bhpaWFvz3v//FvHnzYvunTJmCZcuWYd26dVizZg1++tOfdnp/1dXVWLFiBV566SX885//xD//+U889NBDmDlzZkKCZjalc44vvPBCTJ8+Hc8//zxeeuklXHHFFViwYAGWLFmCCRMm9Pj+e2LVqlU46KCDsPPOO+Pmm2/G8OHDYZomXnzxRdxyyy1d9igCwPXXX48rrrgCZ5xxBq655hoMGDAAnHNceOGFcbffZZdd8Pnnn+Pvf/87Fi9ejGeeeQZ33XUXrrzySsyfPz927M9+9rOUX0L22GOPrDxvQgEGScMzzzwDr9eLl156Ka5s76GHHsrrfaQj2l1fVlaGgw8+uNNjUw0VjB49GlJKjBw5EjvuuGPW2jZq1CgAqgekq7b11OjRoyGEwCeffJIy0Ep1u48++ggHHXRQVmZjHDRoEMrKyvDxxx93eezhhx+OQYMG4dFHH8WkSZMQCoXw85//vEePv99+++HBBx/Eyy+/DNd145L0pkyZgscffxxvvPFG7NiumKaJ6dOnY/r06RBC4Nxzz8W9996LK664AmPGjMHo0aO7fK477LAD/vvf/0IIERc8ffbZZ7H93TF69GhcdNFFuOiii/Dll19izz33xB/+8Ac88sgj3bq/zgwaNAg+ny/WY9je559/Hvf73/72N0QiEbzwwgtxvSUdh9uA1H+TixYtwg9/+EM88MADcdsbGhpiCdpRgUAAJ554Ik488URYloUZM2bguuuuw9y5czFo0CCUlpbCdd1uvz+Q9FEOBumSpmlgjMV1S37zzTcJFQW5vo90TJw4EaNHj8ZNN92ElpaWhP3R+SUA9UYEIGEmzxkzZkDTNMyfPz/hW5yUElu2bOlW26qrq3HAAQfg3nvvxYYNGzptW08de+yx4Jzj6quvTviG2Nk30xNOOAHr16/H/fffn7CvtbUVwWAwo3ZwznHsscfib3/7G95///2E/e3bous6Tj75ZDz11FN4+OGHMW7cuB5/m9xvv/3gui5uuukmjB07Nm7oZ8qUKWhpacFdd90FznmXFQIdX3fOeax90SG/n/zkJ/joo4/w3HPPJdw++lyPPPJIbNy4EU8++WRsn+M4uP3221FSUhIrRU5XKBRKmGtm9OjRKC0tTSgtzhZN03DYYYfh+eefx5o1a2LbP/30U7z00ksJxwLxr3VjY2PSLxeBQCDpzLqapiVct08//XRCzlLH18g0Tey6666QUsK2bWiahp/85Cd45plnkgaC6bw/kPRRDwbp0o9+9CPcfPPNOPzww3HKKadg06ZNuPPOOzFmzBj897//zdt9pINzjj/96U844ogjsNtuu+H000/H0KFDsX79erz++usoKyvD3/72NwAqGAGAyy+/HCeddBIMw8D06dMxevRoXHvttZg7dy6++eYbHHvssSgtLcXq1avx3HPP4eyzz8bFF1/crfbdeeed2G+//TBu3Dj84he/wKhRo1BXV4e3334b69atS1rX3x1jxozB5ZdfjmuuuQZTp07FjBkz4PF48J///AdDhgzBggULkt7u5z//OZ566imcc845eP3117HvvvvCdV189tlneOqpp/DSSy91mgiZzPXXX4+XX34Z06ZNi5W+btiwAU8//TSWLVsWV/I7c+ZM/PGPf8Trr78eKwXtiDGGadOmxXoeOhPtlXj77bdx2mmnxe3bcccdUVVVhbfffhvjxo1LmLyso7POOgtbt27FgQceiGHDhuHbb7/F7bffjj333DOWPzFnzhwsWrQIxx9/PM444wxMnDgRW7duxQsvvIB77rkH48ePx9lnn417770Xp512Gj744AOMGDECixYtwptvvolbb701Lok5HV988QUOOuggnHDCCdh1112h6zqee+451NXV4aSTTsrovjIxf/58LF68GFOnTsW5554bC5J22223uL/pQw89NNbz88tf/hItLS24//77UV1dnRBoT5w4EXfffTeuvfZajBkzBtXV1TjwwANx1FFH4eqrr8bpp5+OKVOmYOXKlXj00UdjvYLtH2vw4MHYd999UVNTg08//RR33HEHfvSjH8XO6+9//3u8/vrrmDRpEn7xi19g1113xdatW/Hhhx/i1VdfxdatWwGoIK2iogL33HMPSktLEQgEMGnSpJQ5ZiSJvNetkKISLVNNVkLY3gMPPCDHjh0rPR6P3HnnneVDDz2UdEpgAPK8887L+n1kWra5fPlyOWPGDDlw4EDp8XjkDjvsIE844QT52muvxR13zTXXyKFDh0rOeULJ6jPPPCP3228/GQgEZCAQkDvvvLM877zz5Oeffx47Ztq0aV2WxXW0atUqOXPmTDl48GBpGIYcOnSoPOqoo+SiRYu6/XxTTc/84IMPygkTJkiPxyMrKyvltGnT5CuvvBLX/o5lgZZlyRtuuEHutttusdtNnDhRzp8/XzY2NsaOS/Va77DDDgmlpd9++62cOXOmHDRokPR4PHLUqFHyvPPOSzp19W677SY557Hy0vaam5slAHnSSScl7EtlyJAhEoC87777EvYdffTREoD81a9+lbCvY5nqokWL5KGHHiqrq6ulaZrye9/7nvzlL38pN2zYEHe7LVu2yPPPP18OHTpUmqYphw0bJk899dS4ssi6ujp5+umny6qqKmmaphw3blxCOWSqa0BKde7nzZsnpZSyvr5ennfeeXLnnXeWgUBAlpeXy0mTJsmnnnoq7japylQ7XkvRx02nPPNf//qXnDhxojRNU44aNUrec889Sa/FF154Qe6xxx7S6/XKESNGyBtuuEE++OCDCX9zGzdulD/60Y9kaWmpBBBrbzgclhdddJGsra2VPp9P7rvvvvLtt99OeE733nuv3H///WN/96NHj5Zz5syJu26lVOf/vPPOk8OHD5eGYcjBgwfLgw46KOEa+etf/yp33XXX2PTyVLKaGSZlljJ5CCEkCyZMmIABAwbgtddeS9j34osv4qijjsJHH32EcePGFaB1hJB0UQ4GIaRovP/++1ixYgVmzpyZdP/rr7+Ok046iYILQnoB6sEghBTcxx9/jA8++AB/+MMfUF9fj6+//rpbi7cRQooH9WAQQgpu0aJFOP3002HbNh5//HEKLgjpAwoaYPz73//G9OnTMWTIEDDG0ipZfOONN/D9738fHo8HY8aModXtCOkDrrrqKggh8Omnn2ZcpkkIKU4FDTCCwSDGjx+PO++8M63jV69ejR/96Ef44Q9/iBUrVuDCCy/EWWedlVB3TQghhJDCKpocDMYYnnvuORx77LEpj7n00kvxj3/8I26ClJNOOgkNDQ1YvHhxHlpJCCGEkHT0qom23n777YTpXQ877DBceOGFKW8TiUTiZrMTQmDr1q0YOHAgTQVLCCGEZEBKiebmZgwZMqTLdYJ6VYCxceNG1NTUxG2rqalBU1MTWltbky46tWDBAsyfPz9fTSSEEEL6vLVr12LYsGGdHtOrAozumDt3LmbPnh37vbGxEd/73vewdu1alJWVFbBlhBBCSO/S1NSE4cOHpzWlfa8KMAYPHoy6urq4bXV1dSgrK0u5ZLbH44lbvTOqrKyMAgxCCCGkG9JJMehV82BMnjw5YfrgV155BZMnTy5QiwghhBCSTEEDjJaWFqxYsQIrVqwAoMpQV6xYEVv+d+7cuXFTBp9zzjn4+uuvcckll+Czzz7DXXfdhaeeegq/+c1vCtF8QgghhKRQ0ADj/fffx4QJEzBhwgQAwOzZszFhwgRceeWVAIANGzbEgg0AGDlyJP7xj3/glVdewfjx4/GHP/wBf/rTn3DYYYcVpP2EEEIISa5o5sHIl6amJpSXl6OxsZFyMAghhJAMZPIZ2qtyMAghhBDSO1CAQQghhJCsowCDEEIIIVlHAQYhhBBCso4CDEIIIYRkHQUYhBBCCMk6CjAIIYQQknUUYBBCCCEk6yjAIIQQQkjWUYBBCCGEkKyjAIMQQgghWUcBBiGEEEKyjgIMQgghhGQdBRiEEEIIyToKMAghhBCSdRRgEEIIISTrKMAghBBCSNbphW4AIYSQ3HOli+Uty1Fv16PKqMKEkgnQmFboZpE+jAIMQgjp45ZsW4KF6xZik70ptq3aqMacYXNwYOWBBWwZ6ctoiIQQQvqwJduWYM7qOXHBBQBssjdhzuo5WLJtSYFaRvo6CjAIIaSPcqWLhesWdnrMTetugivdPLWI9CcUYBBCSB+1vGV5Qs9FR3V2HZa3LM9Ti0h/QjkYhBQhVwDvfQdsCgLVAWCfIYBGXwcA0LnJRL1dn9XjcsVygP9bCaxpAL5XAcwcB5j06dTr0UtISJH551fA/H8BG1q2b6stAeZNA44YU7h2FQM6N5mpMqqyelwuXL8UuH85IOT2bdctBX4xAfjt1II1i2QBxf2EFJF/fgX86h/xH6AAsLFFbf/nV4VpVzGgc5O5CSUTUG1Ud3pMjVGDCSUT8tSieNcvBe79MD64ANTv936o9pPeiwIMQoqEK9S3c5lkX3Tb/H+p4/obOjfdozENc4bNSbmfgeHiYRcXZD4My1E9F525f7k6jvROFGAQUiTe+y7x23l7Emr/e9/lrUlFg85N9x1YeSAWjlyY0JNRY9TgxpE3FmwejP9bmdhz0ZGQ6jjSO1EOBiFFYlMwu8f1JXRueubAygMxrWJaUc3kuaYhu8eR4kMBBiF51Fm2fHUgvftI97i+JFfnpj9VpGhMw/jAeLhwoUEr+DTh36vI7nGk+FCAQUiedJUtv88QVRGxsSV5rgEDMLhEHdff5OLc9KeKlIiIoMlpQkiEIKUEYwx+7keZXgYP9xSkTTPHqeu/s2ESztRxpHfqo7E6IcUlnWx5jasPN0B9YLYX/X3etL77Dbsz2T43/akiJSIi2GxvRrNohslN+DU/TG6iWTRjs70ZEREpSLtMXQXXnfnFBJoPozfrh29VhORXJtnyR4wB7v6R+jbe3uAStb2vfbPORLbOTX+rSGlymmBJC6VaKXSmgzEGneko1UphSQtNTlPB2vbbqcAvv696KtrjTG2neTB6N4oNCcmxTLLlz5qgPigPHdV/cgMykY1zk0lFyuRhPW5yQdnCRkiE4OO+pPu9zIuQCMEWNgxu5Ll1ym+nAhdPppk8+yJ6CQnJse5ky2u893+45UpPz01/qkhx4UJKCQ3JEzp1psMSFly4MFCYAANQwcRZhZnri+QQfSciJMcoWz77LBcIO+pnpvpTtY4GDYwxuEh+ohzpgDGWMgAhpCcowCAkx2aOSxxj7oiy5dMTdoC6FmB9E7CuSf2sa1Hb0xWtSEn1kjCo/X2hWsfgBvzcj1bRmnR/WIbh5/6CDY+Qvo0CDEJyjLLlsyPsqGGLJkudqxJT/Wyy1PZ0g4z+Vq1TppfBZCaa3WbYwoaUEraw0ew2w2QmyvSyQjeR9FF95E+IkOJG2fI91xgGIi5Q5gF0DjCmfpZ51PbGcPr31Z+qdTzcg0HGIJTyUtjSRsgNwZY2SnkpBhmDCjYPBun7mJSyi/z2vqWpqQnl5eVobGxEWRlF7iS/OpvJk6RmuWo4xNRVUNGR7ap/Q8sAM4N0gv40kyegqkqiM3nSsAjpjkw+Q+mtjZA8omz57hEScCWgpUic0LkaIumqHLij/latY3CjoNUipH+hAIMQUvQ4U8GFKwE9SZDhCLW/q2TaZCxXBSacZdb7QbKLXoe+hwIMQkjRMzXAb6iEzrIkKQOtDlBmZvbBFHZU3kbI3t474jeAci/gpXfGvAk7QFMECNrbA4yAoV5neh16N3r5CCG9QrlXJXM2RQBfWy6GI1Rw4dHU/nRFK1Iirgoqor0jTZbaVh2gD7d8CDvA5mSvQwSIOMAgeh16tT6czkQI6Uu8uvrgLzNVQmeLpX6WmZkHBNmsSCHd1xTp/HVoKsw6bCRLKDYkhPQaXh3wlvRsvN5y1bCIP0Wuo09X+y2XcgFyyXLVsEiq18FvqP30OvReFGD0kCUsPL35aayLrMMwzzAcP+h4mNwsdLNIEaNktp7ryXnLVUVKb+IK4J31Lt5vXg5u1mPSoCpMLJsAjeXvghRS/Uv1Omhs+zGkd6IAowduW3cbHtn0CAS2r+t86/pb8bPqn2HWsFkFbBkpRpTMVhxyWZHSG/zzK2DeiiWwhi6E5tkEhIGHm4AyVo0rRszBgZUH5qUdvO0cp3odXLn9GNI7UQ5GN9227jb836b/iwsuAEBA4P82/R9uW3dbgVpGilE0ma0pohISSwz1symitmeylgbpmWhFSshOvr/VUfv7Yu/SP78CZr2zBM7IOeDmprh9jWIT5qyegyXbluSlLaamAuxUr0PIVvv74uvQX1CA0Q2WsPDIpkc6PeaRTY/AElaeWkSKHSWzFZdy7/YAz3YBKdXPaACYSUVKb+EK4Kp/ufCPXghAXYPtMQZAAjetuwmu7MYytd1Q5tn+OjhCvQ6O2P46JCtJJr0HBRjd8PTmpxN6LjoSEHh689N5ahEpZpkks5H8yGZFSm/x3nfAFm05NM+mhOAihgF1dh2WtyzPS5u8uipFjQbaLfb2QJxKVHs/evm6YV1kXVaPI30bJbMVp2xUpPQmm4IAM+vTOrbeTu+4bPDq6l9/eR36EwowumGYJ73FC9I9jvRtHZPZ7HZvpIZGyWzdkc0Po/7yYVYdAKRVldaxVUZ6x2VTf3kd+hMaIumG4wcdD97FqePgOH7Q8XlqESlm0WS2ba1AfQjYEAQ2BtXP+pDaTsls6YnOwLm+efu/TZQkm5Z9hgAD3QlwI9VIuYa2BGqMGkwooRX5SM9RgNENJjfxs+qfdXrMz6p/RvNhkBiPBgQtYGMLoAHwaernxha13UPBRZeoEqdnNA5cvp+G4Ko5AJAQZEgJgDFcPOzivM6HQfouCjC6adawWZhZPTOhJ4ODY2b1TJoHg8SJuECJBxgcUEMirY76OTigtkcowbNLVInTc5OGAnN3PxB89UIIqzpuXymrweW1N+ZtHgzS9zEpU3aW9UlNTU0oLy9HY2MjysrKenx/NJMn6Yrlqq58j6Y+EDvmYDhCfUAOLaVhklQ6nsOO6Bx2zXKB9U2AqQMMwIcbXPw3pGbynDCwCjt7J0AIDUPL6ByS1DL5DKUkzx4yuYmf1vy00M0gRaxjFYnR4c2bqki6RpU4Pdd+inTGgL2Hatgbe8X2Swm0uHQOSfZQgJEFIScEGzYMGPDr/kI3hxQZCRefhJejpbUeg4wq7OaLX/MhVRUJle1tR9NK9xxngICNVlfA0DggjISetL48RTrJPwoweqDJacJ3ke+wzdkGIQU446jUKzHEMwRles+HX0jvt2TbEixctxCb7O3TMlfp1Tineg72LVVj3SFb5RFEg4hI25olIXv7N05/25olnn76FxutxGmKJJ/dseM5JPEsYaFZNCOEVmxpccGhQbo+mKwUXm7C1zYJXJWfziHJHkry7KYmpwlfhL7AJnsT/JofA/QB8Gt+bLI34YvQF2hymgrdRFJgS7YtwZzVc+KCCwCodzbh2u/m4N9NSxKmRI44wOYQ0BxRb/QlbeWrzRG1PdKPKyVoWunusYSFerseLW4LAoYBxw5gS8hAq2yBzethw8KGFnWN0cyZJJsowOim7yLfISRCqDar4eEeMM7g4R5Um9UIiRC+i3xX6CaSAnKli4XrFnZ6zH2bbkLAdOOmRG6KAJYDlHaolCj1qO39uVKCppXunma3Gba0UaKVwHV1lHoZakt0eFkJmm0bIbcZg0uAUi+V+pLsoj/Jbgg5IWxztqFcL0+6v0wrwzZnG0JOiHIy+qnlLcsTei462uLWYb1cjlpdJdpZrurq96VYs8TXtvKk5fbfbmyaVjoztrDR6rbCy72wXVUeHS3zdVwgIrwQaEWF1waE0e+vL5Jd1IPRDTZsCClgInk5qod5IKSAjRTrEJM+L921HNof1z7LPxmtLcmRsvzVB6BXpw/CrggIuHChQUu4vnQN8OsaNO5CSgGd0/VFsosCjG4wYIAzDgtqOXZHOrCEBUeq/sWIjIAzDgMpvoqSPi/dtRzaH8fZ9iAimeiHA2X5k3RxcGjQ4MJNen2p7RoY41RFQrKOAoxu8Ot+VOqVqLfq0WA3oN6qR71dH/t9i70FlXolDY/0YxNKJqDaqO70mI5rPpiaqhZpTdHx1dq25Dt9ayfpMrgBn+ZDWIRhaIBPV8MkURERhof7YDADrQ5dXyS7KMDopiqjCrawsTayFkIKeOGFkAJrI2thC7sgqxGS4qExDXOGzUm5nyH5mg9lHjXTYnOHSonmiNpOlRIkU6VaKQxmoMVtgd90YDKJhoiDRqsFBkx4URqrxCn3Frq1pC+hAKMHhnmHYbhnOGxpo9FthC1tDPcMxzAvLdNOgAMrD8TCkQsTejJqjBrcODL5mg8eHRjkb6saaauUsFz1+yB//50Hg3SfyU1UGVUo0UrAuQ2/LwivbsNACQw5EBAmyky1nDtV4pBsorVIusEWNjZYG2ByEzrT0eq0woEDHTp8ui+Wk1Fr1sLglIfR37nSxfKW5ai361FlVGFCyYS0VqukSgmSbbawISDAwSGlQdcXyRitRZJjAgJCCmjY/lfJsD0zSmVsCwiIQjSPFBmNadirdK+uDyQkx9p/4bFoBV+SYxRgdAMHB2ccjU4jtlpbsU1sgxACnHNU8koMMAfA5GbCUu6EpIOmCie5FG67voL29h6yQNv1RUMkJJvocuoGgxtwpYvPg58DXE2sZXADNmxsdjdjc3Azdi3ZlYZHSMaiU4VbjppYK1pW2BxRs1ZSHgbpibADbA6qa8nf7vpqiqhrj2ZEJdlEX7G7KegEYcOGn/uhMQ2MMWhMg5/7YcNG0AkWuomkF6KpwkkuNUW2T6/e/vqKTr9O1xfJJopVuyHkhBAUQQz3DocrXYRFGBYscHAEtADK9DIERZCmCicZoanCSS5ZrhoW8ae4vvyG2k/XF8kWCjC6wYEDRzooZ+XgGocjHEhIMDDoXIcQAlvkFjiglYNI+miqcJJLou3a6ez6EnR9kSyiIZJu0KFDZ3rKqcItWNCZDp3iN5IBmio8fZar8gmoEiJ9vO3a6ez64nR9kSyiT8BuiE4V/k34GzDG0OQ0xRYUKtPLIKXECO8IGh4hGYlOFd4cUTkXHbXaant/7r6OOOr8tDrbAy6frs4LJb92ztRUtUhTJPmMsCG7bSbZfnx9keyiHoxuKtFKsMXeglWtq8DBUYYycHCsal2FLfYWlGglhW4i6YVoqvDUIg5QHwKabbUSaMBQP5tttT1CI5JdKvOoKcGbOlxf0anC+/P1RbKPYv5uanFbMNAYiCq9Co2iEU2yCZxxjPaMhmQSLW5LoZtIeqHoVOEd58Eo9dA8GM0RwBJAqbl9m8EAwwSaLbW/P5+fdHh1VYracR6MMg/Ng0Gyjy6nbgg5IWxztmGwZzC83IuwG44NkXg1L8IijG3ONqoiId3i0YFBOk0V3p7lqmGRVB+A3rZVQqkComteXf2j64vkGgUY3RCtIjGhvkp5tfglCE2YaJbNVEVCeoTe9LeLVth4UyQg6gyIUAVERuj6IrlGAUY3tK8i8SJxfWOqIiEkuyRcfBJejqZQPQYZVdjdH79gnNODChv6Jk9IbhQ8yfPOO+/EiBEj4PV6MWnSJLz33nudHn/rrbdip512gs/nw/Dhw/Gb3/wG4XA4T61VolUkjW5j0v2NbiMq9UoaHiEkC5ZsW4IZnx6FK777JRZuvByXrP0lZq46Csual8SOCTuqmiSTACHiAPVBoK4F2NiiftYHKVmUkGwpaIDx5JNPYvbs2Zg3bx4+/PBDjB8/Hocddhg2bdqU9PjHHnsMl112GebNm4dPP/0UDzzwAJ588kn89re/zXPLgcGewfBzP+rsOoRFGEIIhEUYdXYd/NyPwZ7BeW8TIX3Nkm1LMGf1HGyy498T6p1NuGb9HPyrcQmaLcDkyUt7U6GKFEJyj0kpCzZqOWnSJOy999644447AABCCAwfPhwXXHABLrvssoTjzz//fHz66ad47bXXYtsuuugivPvuu1i2bFlaj5nJWvZd3pfThI2RjdjmbIMjHehMR6VeicGewSjTe3bfhPR3rnRx1MdHJQQX7VVpNfi/0X9DhVfLqIKkPqiCifYVKVHNFlBqAFWBbjSakD4uk8/QgvVgWJaFDz74AAcffPD2xnCOgw8+GG+//XbS20yZMgUffPBBbBjl66+/xosvvogjjzwy5eNEIhE0NTXF/cuWMr0MOwZ2xLjAOIwrGYdxgXHYMbAjBReEZMHyluWdBhcAUO/WYa1cnlFwkUlFCiGk+wqWhVhfXw/XdVFTUxO3vaamBp999lnS25xyyimor6/HfvvtByklHMfBOeec0+kQyYIFCzB//vystr0jyrUgJPvq7fqsHhdFFSmE5EfBkzwz8cYbb+D666/HXXfdhQ8//BDPPvss/vGPf+Caa65JeZu5c+eisbEx9m/t2rV5bDEh6ROuxPo3WvDF4w1Y/0YLRKpFI/qJKqMqq8dFRdd8cVKc3p5UpBBCtitYD0ZVVRU0TUNdXV3c9rq6OgwenDxB8oorrsDPf/5znHXWWQCAcePGIRgM4uyzz8bll18OzhPjJY/HA4+H5r8lxW3Vs41YOmsDguu2ZxcGhumYelstRs8oL2DLCmdCyQRUG9WdDpPUGDWYUDIho/s1NVVx0myrWUA7CjsqB4NKVgnpmYL1YJimiYkTJ8YlbAoh8Nprr2Hy5MlJbxMKhRKCCE1T7wIFzFUlpEdWPduIxcetjQsuACC43sHi49Zi1bPJy6H7Oo1pmDNsTsr9DAwXD7s4bj6MdJV6VOVJswXYbWty2ALdqkghhCRX0CGS2bNn4/7778ef//xnfPrpp/jVr36FYDCI008/HQAwc+ZMzJ07N3b89OnTcffdd+OJJ57A6tWr8corr+CKK67A9OnTY4EGIb2JcCWWztoAJIuP27Ytu3Bjvx0uObDyQCwcuRDVRnXc9hqjBjeOvBEHVh7Yrfv16ECVX/VUOK5al8Nx26pH/LSmCSHZUNA/oxNPPBGbN2/GlVdeiY0bN2LPPffE4sWLY4mfa9asieux+N3vfgfGGH73u99h/fr1GDRoEKZPn47rrruuUE+BkB7ZsDSY0HMRRwIta21sWBrE0AP65wq9B1YeiGkV07C8ZTnq7XpUGVWYUDKhWz0X7Xl09Y9m8iQkNwo6D0YhZHMeDEJ66ovHG/DKKeu6PO6Qx4Zhx5Mrct8gQgjpRCafodQRmAW2sCEgwMFhcKPQzSG9SKA2vT/BdI8jhJBiQe9aPWAJC81uM1rd1thy7T7Nh1KtFCZPkp5OSAe1UwMIDNMRXO8kz8NgQMkwA7VTaVpJQkjv0qvmwSgmlrBQb9ejxW2BwQ0EeAAGN9DitqDeroclrEI3kfQCXGOYelut+qXjvAttv+9362BwjSZlIIT0LhRgdFOz2wxb2ijRSqAzHYwx6ExHiVYCW9podpsL3UTSS4yeUY7DFw1HYGh8h2LJMAOHLxreb+fBIIT0bjRE0g22sNHqtsLLvUn3e7kXrW4rbM2mnAySltEzyjHymDJVVbLBQaBWR+3UAPVcEEJ6LQowukFAwIULL5IHGBo0hBGGgMhzy0jRcl3g46XA1g3AgFpg96lAh7lbuMb6bSlqOiiZmpDehQKMbuDg0KDBhQs9ySmMJnxyGoEiALDsWeCuWUB9u3LUqmHAubcB+80oXLt6iYiIoNlpRkiEIKQAZxx+7kepXgoPpyk3CSlW9AnYDQY34NN8CItw0v1hEYZP89G3LKKCi6uPiw8uAKB+vdq+7NnCtKuXiIgI6u16NItmmNxEQAvA5CaaRTPq7XpERKTQTSSEpEABRjeVaqUwmKoacaSjlo+XDlrcFpjMRKlWWugmkkJzXdVz0dk84HdfqI4jSTU7zbCkhVKtNC6ZulQrhSUtNDuUTE1IsaIAo5tMbqLKqFJVI8JGUARhC1VVMtAYSPNgEJVz0bHnIo4ENq9Vx5EEtrAREiH4uC/pfh/3ISRCsIWd55YRQtJBORg9YHITA/lA2Boln5Ektm7I7nH9jICAkAIaki8QokGDkIKSqQkpUhRgZAEFFSSpAbWx/3UZsHxkCepLDVQ125iwugWaTDyObMfBwRmPT6Z2XeCzd4GGTXDLB4LvOIGSqQkpUhRgEJIru08FqoZhSU0LFk4fhk0V24fNqhsszPnbOhy4qVQdRxIY3ICf+9EsmlVO07svAg9fAWz9DgDQ6tVQ6q+GcdqtVI1DSBGi0J+QXNE0LLngV5jzs5HYVB7fy7Wp3MCcn43EkvPPSZgPg2xXqpfCZCaa330Wzq1nQW79Dg4Hmr0aTEeg9DuqxiGkWFGAQUiOuNLFwpKlABjAOszIyRgAhptKlsGVVEWSiod7UMUrUfrwtbB0hqBXg6VzlIZdVLU48Dht+RdUjUNI0aEAg5AcWd6yHJvsTYmLmEUxoM6uw/KW5XltV2/j+eQ9VK1Zi9pGG7UNFmob7bbgIprEQtU4hBQjysEgJEfq7fqsHtdvtVXZGG6y+UQSjyOEFAcKMAjJkSqjKqvH9VtUjdNnCVfSAn99GAUYhOTIhJIJqDaq1TBJCjVGDSaUTMhjq3ohqsbpk1Y924ilszYguM6JbQsM0zH1tlqMnlFewJaRbKEcDEJyRGMa5gybk3I/A8PFwy6GxqiKpFNUjdPnrHq2EYuPWxsXXABAcL2DxcetxapnGwvUMpJNFGAQkkMHVh6IhSMXotqojtteY9TgxpE34sDKAwvUst6DqnH6FuFKLJ21odMlepZduBGiq5wbUvRoiISQHDuw8kBMq5iG5S3LUW/Xo8qowoSSCdRzkaZMqnH2Kt0rr20jmduwNJjQcxFHAi1rbWxYGsTQA0ry1zCSdRRgEJIHGtPow6+bqBqnbwlu6CS46MZxpHhRgEFIEXEtASkAxgHNpBFMgKpx8sZ11VwiWzeoipzdp+YkryVQm97HTrrHkeJFryAhRcCNCIQbXNhBAekCTAOMAIe3QoPm6d+BBlXj5MGyZ4G7ZgH167ZvqxoGnHtb1td5qZ0aQGCYjuB6J3keBtT131pPOTW9Xf9+5yKkCLgRgeAGB1ajgG5ymKUcuslhNartbqR/L0dO1Tg5tuxZtZ5L++ACAOpzs84L1xim3tb5nCXSBV46gapJejsKMAgpsHCDC9eS8JRr4AYDYwzcYPCUa3AtiXADfZOjapwccV3Vc9FZSUcO1nkZPaMchz05DF3FhFRN0rvREAkhBeRaAnZQwPAnj/UNP4cdFHAt0e9zMqgaJwc+XprYcxGn3Tov4w/I6kP7BunotLKYqkl6PQowCMmXJEl0UjCVc5HiL5HpgGwFZP8eJYnRmIbxgfFw4UKDRsFFT6W7fksO1nmhapK+jwIMQvIhRRId+8VtYDv8CNIBmJF4M+mohDfWvzsvAAAREUGT04SQCEFKCcYY/NyPMr0MHu4pdPN6p3TXb8nBOi9UTdL30dsWIbnWSRKdtuA4GCv/CTuUvIvCDgkYAd7vh0ciIoLN9mY0i2aY3IRf88PkJppFMzbbmxERkUI3sXdqW+el01nMBg3PyTov0WqSzh66ZLiB2qmBrD82yY/+/a5FSK6lkUTnfXw2NF0g0uhC2BJSSghbItLoQvMweCtoGKDJaYIlLZRqpdCZDsYYdKajVCuFJS00OU2FbmLvpGmqFBVA4id92++/ujUn82HEVZOkeOj9bh1Mq6v2YhRgEJJLaSTRaVtXI7DlXZjlHI4lYDULOJaAWc4RGKz3+3kwbGEjJELwcV/S/V7mRUiEYAs7zy3rI/abAVy5CKgaGr990DC1PcvzYLQ3ekY5Dl80HIGh8cMgJcMMHL5oOK2q2svR4BYhuZRmcpzWsgGBGoNm8kzChQspJTQk/xatMx2WsODChYEkiSyka/vNACYfk5eZPDsaPaMcI48pU2uUbHAQqNVROzVAPRd9AAUYhORSu+Q4W2MQDOASMDrW9rcdFw0qhCux/o2WhDdc4cp+90asQQNjDC5c6EneshzpgDGWMgAh29nSjiXIGsyI/10zsl6Kmi6usbyWojqWwMd3bUHjKhvlow3sfu5A6H0soC+G9woKMAjJpd2nIlIzDM3BOoRMBsEZuJDwWwKlYRceB6orul0S3apnG7F01oa4FScDw3SMPbkcXz7emLB96m21fbor2eAG/NyPZtGMUq00YX9YhlHKS2Fw6r1IxRY2gm4QYRmGlBKOdOBKFxrTwBkHZxxe5kWJVtLnz+Obl2zARzdviZuD462L6zB+9kDse2P2q2UKIdV7SL7fK/pWyEZIkYkwB/VnXY5mL4fpSATCLkxHoNmrob7EQERnwC9ujHVFr3q2EYuPW5uwnHVwnYMVC7ckbl/vYPFxfX9K5TK9DCYz0ew2wxbqW7ctbDS7zTCZiTK9rNBNLFq2sNHgNCAkQjCYAQ0agm4QW+wtCLkhGDBgMANBEcQ2Z1ufzmV585INWLFwS8IEX9IFVizcgjcvyf58H/mW8j2kAO8VFGAQkkPNTjOsnSai9MT50MurwQDoAigNu7AG1aD5l9cB46YBUF2aS2dtSLkAVFJtx/b1KZU93INBxiCU8lLY0kbIDcGWNkp5KQYZg2gejE4E3SBsacOv+aExDSEZgoRElVkFAYFW0QqNaQhoAVjSQovbUugm54RjCXx085ZOj/no5i1wrN47q12n7yEFeK+gIRJCcsQWNkJWI3xhF9j7cGDSkcBXHwINm4GKQfCN3gMhNwI71ACjbCA2vGklfOtISz+ZUtnDPRhkDoIt7NhMnn29O7+nbGkjLMOxAMyRDiIiEvvdwz0IyzD80g+d6fByL8IyDFvaMJLN/NaLfXxXYs9FR9JVx+154aD8NCrLNiwNdv4ekuf3CgowCMkRAQEhbGhSApoOMAbsuHdsvyYlBGwIywaE2+MpkfvLlMoGN6haJE1SqnlVeNtUsEIKCCliv3Pw2DFg6nchRez3vqRxVXpDP+keV4yKbfp1CjAIyREODs4NuIwBThhC18GhJogCVPkldwU4NwCu9XhKZJpSOXM9ybQvhiz9rjDGAMGw/p1mRDZKmIMB/fsMggtoLiA+fw+suQ6sbCSw674QrgUuHDDmAKaZlzbmqzS7fHR6QWm6xxWjYpt+nd6RCMkRgxvQdR82GiEYrSG4vhJoYPBwD/zch4i0UGpJGOUVgGGidqqBwDAdwfVOZnkYTE1MRFMqZ6YnmfbFkqXflTXPhfDy5WvR2BCE0eoFALCxrRj389XY8bP5iAQ3wR8R0MMuUFGD8HEXILD7wTAMG/CWAKUVgOnNSducsECkwYXdItSCfxpglHB4KjTo3uwHGv4hXQcOTAN2P3dg1h87X6LTr6d8D8nzewUleRKSI5aw4MCB4/OiVZMwQ63grkCz04T14bVgwWaUeiuB0koAXUydnErbcZNvrCm6b8/FrCeZ9sWUpd+ZaDvtrwxwW4PtC0NwF/ZqDW/dXo3/1u0A7kr4bAGXAcHQZpgPXYGSTz8ADA8QbFCTblnhrLfNCQuENjiINKjp8I0yBs3DEGlwEdrgwAlnN9Fy1bONeOWkzmbUVcbP7t3zYRTb9Ou990wSUuRa3BYwMAwrGYWKAaNh+32wnBD0iAWPy+ANDISnakTcN8RUUyf7h+jY+YwK+Dt0bfprdex362AMmUa9F+nqSaZ9sWXpp9K+nZqjw9tYCiPkgTAcQBcwQh589dEv4bPVBHC2zhCICFSGXBj/d7UaryipAKwI0NyQ9fZFGlw4EQFPhQZuMDDGwA0GT4UGJ6J6NrIl3eqs8RcN6BPzYBTT9Os0REJIDtjSRliE4eVe6EyHx18L21cFYUfAhQTTNPXGbmgJ6Yodp072VmkoGa7D8GvYZ3416t5tRWudA1+NjppJPkgXcFpcuJZG04unoSeZ9sWWpZ9Kx3Zqjg6tqRQi5EAyCSYZuFMLOXB3DBrwIZiUMKKdBlu+Az57F9htCuANAOEWwLYAIzs5Ga4lYLeoVYKTMQIcdouAa4msXM9dvmZtRh7Vd+ZSKZbp1ynAICQHpJQQEHHTVxvMAEwjtj8iQymz9dtPney0CjR/a4HpKmmvdoo//rG4hNuKLkvwiNKTTPtiy9LP9PG5E/+WHwlVwyxP8tW+oU791HQgEgJk9oYspFDXKkvx6cN0QGbxIXvLa5Zt+Z5+PRkKMAjJAcYYOHjK9TNcuODgKss/BddSyW/ClWAaIB0g2dQEwlbJaSzJUhw9rXQopkoJW9gQEODgPZr/oieZ9sWWpd/Txw94NiffUVGjfroOwDU1ZJIljKPT61k6bddzlh6yt7xmfRGdUUJywGAGvNyLoBtEiZb4LSIswghogaSTGTlhgfA2F06LG8uujwQFeFDAX5Pk+JCAWZE4PNLTSodiqZSwhIVmtxkRNxKbYMujeVCqlcLkmXfb9yTTvsvbtln996aCfnuMtTPl0IBAiacOtZUfJu4aOATYeZL6/3AQCFRkbXgEUKWoRglHpMGFpyIxKraDKjcjW8N96bze/lodg/b2ZeXxyHY0YEtIjkQXjmpxW+BIJ7bIVIvbAoMbSQMPJywQ/M6G1eBC83AYZRyah4MBiDS6CNXZcC01MZJryVgWvrcy/o26p5UOxVIpYQkrtmaGznX4uR861xFyQ9hib4ElrIzvsyeZ9lxjmLJwcJeP8dEfthZ0XYvO26k+ZSePvRmcJRmHmDlfjU+0NACmR5WqZpmnQoPuUUGGsNX1LGx1PesenjTw6K50Xu/vX1qF1rrsV6/0dxRgEJIjJjcxQB+AgBZQ62dItX5GQAtggD4g6bfv8DYXbkQmZNcHagyY5RoEAGEJ2E0CwlI9F4EhRty8AT2tdCimSolmtxmOdBDQAtCZDsbURGUBLQBHOmh2m7t1vz3JtB8yLYDJN9V0+RiFXtdiyLQA9r1tMHy18R/W/iEG9p21GUNGr4+/wYBa4Lw71Mq+dkT1XAyozck8GLqXw1+rw1OhwY1I2E0ydt37a/Wsz4MRfb39gxOrsH54/xCMOb4cbkQivI0SmbKJhkgIySGTmxjAB8CWagVQxljKNR5cS8BpcVNm13srdQhLwF9rgGsMTEs+82FPKx2KpVLCFjYibiTlQmYe7kHEjcDW7G7lZHQn0z76GlkNXScEFnJdi2g7Rx9bhtEzyrDp3RBCdS78NRqqJ/kh3VFwWt+B2/IetOYNKpDYfSogXMSm1czisEgyupdDH8zzNpPniKNKUbmriS0fRRDe4saqsKKvt+7nVI2VZRRgEJIHBjO6nDxLup1n13MDcFtVl6/uS/0G2NOs+WLJuhcQcOHCg+QBhgYNEUQg0P1egkwz7aOvUfPa9J57oda1aH8tMcYweEp8PomqPOKQu+0PtL+WtOwNTaQrXx/m0gUYGGqn+pMmV0f/vqgaK3sowCAkT7qqgohWgqRbLZKqwqOnWfPFknXPwaFB67QSR4MG3sOR3mi1Tqoeofai5790eHrPvVDrWqR9LQkbiAhVKZLjHotU8tWDET0nkQYBQIIbHGZJu6HFTqqxSPdQgEFIjkWrIFrd1tiHok/zJVRBaCaHXqLBSpFd375apLMKj5HHlPVoPYJiWc/A4AY8mkcleGqJb1UREYFf83e7ZDVZtY5eosFbmXotjOhrNOq4cnxw3RZ01nlSyHUturyWGlthas3QtrWqYRGuAb4SNW19jtYe6ciNCIQbXNjBdmuRBDi8FRo0T/YDDTsk0PCNheAaG9xk0AwGz0ANpcMNeMr1lNVYpPvoTBKSQ5awUG/XxypHAjwQqyypt+sTqiC8lVpsTYZU1SJdVXis/mvT9gqCFFnzna1dUkzrGZRqpdCZjqAbjKvECbpB6ExHqVbarftNVa1jNbgIfmd3Wk3grdTgKdGw82mdl+oWel2LlNfS5hC00GZ49Sa15oi/TP1saVCzeOZg7ZGO3IhAcIMDq1FANznMUg7d5LAa1XY3kt3k2HCDg/qPWmE3C5jlHLof4B6G0AYb9R+F0bwmkrQai/QMBRiE5FCz2wxb2ijRSuKqIEq0EtjSTqiC0L0cgSEGzAotabUIN1haFR61+/mx362Dk2bNp7N2SbGsZ2ByEwONgfBrfjjCQUiE4AgHfs2PgcbAbs2DAaSu1olWNXRWTRB9jSZdOxg7n1WREIQxDdhzzsCCr2uR8lrSmhGotKBXVQK6ATCmfsbWHtmW87aF24IeT3mH81+uwbUkwllciwQAGr+xYLcIVIzyoGS4CbPMAOeAp1SD1egi3CQSqrFIzzEpZWFX5cmzpqYmlJeXo7GxEWVlfWfueVJ8bGGjzqpTy7Ynydx0pANb2Kgxa5J28yfLDVj/Rgue/+E3XT72QX8ZiqH7BwCOpGuXCEugdAezy+7gvjiTp2upqdc1Dwc3Ep+La8m0z49rCditAp/cvxXN3zooH21g93OLb0XO2LUkbGjb1qgeCz3JOXQste5IzQ45y8lwLYHmdTZ0M/n5F7aEYwmUDjOyMlxhtbjY+FYQRqkWlxzt2uqcuGEBYUkMnhKAWUI9GF3J5DOUcjAIyZFoFYQX7ca0bRtq4J5D03WEEU5ZBZHszTXdyo3QRidWQVC9lw/SlWAaA9dYRmuXFMN6BnBd4OOlMLa2K6fsgXSrddI5P5rJoZkc37+4ukdtyrXYtRQRKuciSU6LOtAAIm15GTmS1lokrdlbi0RYEsKR6FjtrBkcMABuAq0bHQir733XzlcCbSoUYBCSI3FVELYAgo1q4ai2pDrXNKH5/OBp/uE7YQEtzS+V/sE6nBYBKyTgBiWEK8E1Bi3AYPh478mWX/YscNcsoH7d9m1Vw4BzbwP2m9Gtu8y0WqdP4Zr65zrJezBce/sxOZLvtUi4ycB1BhEBeJLZwN0wwHUGbhamZy4XnLBa8t5uaZdAW6JmSM3nMFBx9eMR0ocY3IBP8yEcaQK21QGtTYBuqmx93UQ4VA9fUyMMp+uvak5YILTBQcXOHnhrOvmzZaqaZPAPfGrcuUmAmwxGKQc3GewmgaZvLTCdFX+2/LJngauPiw8uAKB+vdq+7Nlu3W20wsIOJj/vTkhAL+mj1QRG2/UXDibfHw6p/TksWdVMrpZkDyU//3ZILeWerfNvlmjwVOsIb03e+xfZ5sBTrfeZ4ZHoe0U0MdwoY7Fk39CG/E6H3gf/gggpHqVaKYxQK1rsBjg+P6SmwYGLFh6B6R+IUmGq7P0uRBpcOBEB70AdEy5JMTNk2xewva+qBmuXJyE7/OwVXFf1XHSWzXr3heq4bkinWqfPKq1Ua4y0NKicCynVz9jaI5U5b4K3QoNmMkQaO6xF0th2/rO4FgkAlI8wYZRwtKy3YIcEhBCwQwIt6y0YJRzlIwozB0guRN8rkiUwOxHVs5EvFGAQkkOmC1S5HpR4BsKWDoKyFbZ0UML8GKhXwvSWA5GgSqxLwbUE7Bb1rU5YErU/8GHyDdXwVce/CfsGa5h2dy0G/8AHJyRQNsKEUaZBWgJOs4C0BIwyDaU7mJCOhFvAdTK69PHSxJ6LOBLYvFYd1w1dVev06WoC06tWTC2pUNddqEn9LKlQ2/MwD4bm4QjU6jDLORxLwGoWcCxVQhoYrGd9HgxvhY6q8T74hxpwWly0bnTgtLjwDzVQNd4Hb0XfyBZo/16RjBHgsFtE3v72+8ZZJaRYSQFTcgz0DoINB0JK8PbrkWgSsDrPaGufFCfC6v+HH1qCYQeXYPOHYbRusqGXaBhxZAl0P0frJgcAg6eSwyxlcC0eV40ipYTdJIp7SuStaa5Emu5xSehejpJaDtfS0p7Js88wvcDAWhVYRCfayvNMnpqHI1CTv7VIvBU6vHvqsFpcCEuCm6zPDItEpZVAG8peAm1XKMAgJJcYB7gG2wlD6jo44zDa//W7jnpz7ySjLS4pTgOEkHCCAtzkqBrvgWuZKkve4BA2YqV/cUl07fLXekUS44A055BI97hO9ORDracfjo4l8PFdW9C4ys5piWvKdnYMKmwrb4udReU7qOtrQUV7+U6g7QoFGITkkK0xBDUX4dY6SF8JGBi8zIOA5lO9GJEQ4C/v9M1cMzmMEtUzIRlgtQiEN7tgGgMTAsJl8FXxtsmhJPw16p0lVGeDMQan3VTMekD1YPhrsjPHQM7sPlVVi9SvR8r5ygcN63HJandlI0v/zUs24KObt8T1JL11cR3Gz87eJF1pt9OKqCqncBAQAuAc8AaAQLnKyyC9QvS9IpJiing7qHIz8vW3X8TvMIT0braw0eA0IOQzYOg+eFsjMFyJkAihIbIVdssWNeFRSUWX96X7VEJccJ0N3cvgOi5Cmy2E6lXCGvdyBNdbsBpd6D4G3acqRlrWWQADtBIADGhZpypLdF+Rl+RpmipFBZByvvJf3VqQ1T+zkaX/5iUbsGLhloRhKukCKxZuwZuXdH/oJ+N2WhGgoU7lYrSrckKoSW23Ij1uC8kfT4UG3aOCjLgE2gYXuocnDTxyhQIMQnIk6AZhSxt+XwW0yiFg/nJoQsBvubCdEIIeA6gcnNY3RCesprUuGWbAaZXQdQ5/lQ5flQamcYiwRGCoAU+5BqdVwg1LlTA3zAAk4LRIQAKBYQbMcg433AtqSvabAVy5CKgaGr990DC1vZvzYPRUT7P0HUvgo5u3dHrMRzdvgdPDRLy02xlsVEMj/rL4qcP9ZWp7sLFH7SD5pXs5/LV6bNp7u0nGpsX31+p5TWCmIRJCcsCWNsIyDE90+kDTBMxBaiZPKeCBRFgHbIOjq0mvXUvADgp4K3VIKeHZxuEb4AH3cEC2ja87gLdS/TlHtjoAA7wDdHCDqTLMtpk8NZNB2DKWSV7UwySACiImH6OqRdrP5FmAngsgsyz9VOf247sSey46kq46bs8LU5QkZ6udwQi0cBAwk8xABajt4bYqpwIt504yp3s59MH5S6BN2Y68PyIh/YCUqmuSd8ymMlQ4waWEFGFIKRNHADreV4cqEsYZ9AAHY+qG3FAfFlJIaB4G6UhIsFgmuWYytH+QfGeS95imAeMPKHQrAGQnS79xlZ3WY6V7XDJpt9N1Vc5FyqnDdbW6aq+5WEh7hf4CQQEGITnAmOqSFhDQ0PZt23FiCXRCY7Fj2nNtCQgJcAZICSkA4ci4KpKOWeJqOwPjTFWI6AyMZS+TvNDfgpJqW5+kO70aHSs3djlrADSdpfX8Ombpu5aEFBKMq96hdM5t+ej0FmpL97h02glXAJ+9AzRsAiqqIUdPUteMpqmEzpRThztqf77KDkifQgEGITlgMANe5kVIhOB3daC1uW0dEhVgRAwGf2AQDFO9qbuWgNUk4IQEnFYXVosEBKD7GTSfmlbZCQn4BxnQA2qJaU+5+kB1WtUEWpqpEvg8A3Qwhh5nkhfLegYJerA+SbLKjTdn12HnM8sxcW41jABXs0ymmOgpmqUf2qSGoZyQiA0/6X41ZOWv1js9t7ufOxBvXVzX6TAJ09Rx3RVXTfD5S8DDVwBbv4vtt0vGwnP2ZdDGHANYgbYEzyQBhtWqcjFoeIR0A4WlhORIQAvAsAVCDWvghhoguQ7X40WIOTDCrQi0BAErAtcSaN3swGp2IaWE1SLghgVcW43lMwBcqoAhtNmG4edqBcgtDlq3OOAmoHtZ3DTXPc0kL6b1DOL0YH2SVJUbkMBnf2rE8hs3w2oUCG5w4EZSPz/dx2A1umhZZ4EB0AMMDKpCJ1rF0xnd5Bg/u/PgYfzsns+H4anQoK98GZEbLoSor4OUgBAaInYJ9Ma18PzxRHW+Am1l0qEmwLHbpg631e+GqfYT0g0UYBCSIwY3UGFz+F0NtteLsObChgO/UYqKkqEwHAmEmmA1CbiWhFmqFuCStkrY9FboEDbghiV81Qa85ZqaEYIDRkCD5uPQvQy6VwNjiJvmuqeZ5MW0nkFMD9YnSady45P7G6D5VFJsuJPn54QlPOUaSoeZ6rO4RX0mlw4zVRVPGhU6+95Yiz3nDEyY7IxpwJ5zsjMPhm5I+BddCI/RDFeYsJ0SuMKEx2iB37MZumap86XpQEWN6qlwLKC1Rf30l6ntNA8G6SYaIiEkVxwbRsRCha8GtsYgIcDQbiZPE3CbW+A4Aeg+A64l4QQldN/2D3/dx+G0Cri2hKdSh2MJ+Kt18LacAQApp7nubiZ5NiolciKT9Uk6JIWmU7kBAXz28FbsevpA2MHkzy9W0ROr0Ik/t8KWKW/b0b431mLStTW5m8nz46XQt62G7gFcQ4eUHIwJaLzdqqLtz5dZXZCZPEnfRQEGIbkiRCxD32BJus01HXBaIW0BVqKSOaWUYHq7ig8OSKESP5nJIFsBrrOMciAyDQKKbT2DmB6sT5JuRUbzN456fimWh+l4bjqe285um4xu8m6Xonap3XmICyo6OY6CCpJNFGAQkiucd52hr3MwtC1GxtVQRFyFiFDbwdOrUMiGYlvPIKYH65OkW5FROkLv9PkV7blJJo/ruWRDvqqVirIqKkcK/Vz79tklpJB0Q63nYLUm32+1QistgV5qwmkV0EwGPcDgtG7/+uu0Cug+Ds1gsENq2CLXbxTRCgQ7mPxruB0UMEpy344EO+6jlhNPOXEIAwYNT7o+ye7nJuY7JODAzqcN6PQ8ayZXQ0ShFOcmT69RWqLruXTjfOWTGxEIbbIRXO8guF79DG2yO0207e7jBOtsNK+z0bxW/QzWZf9xikG+zmlXiuCvgJA+LFrilypD318Gs4xDMxmsZhdGgIMZQHibg3CDA24AmletQ6J5GLx5WkegmNYzAKDWw2jZAhx/CVIufgYAv7gx6XwY6VRu7PqLCritssvz7K1oKwlu7HBu8vwadamI13OJciMCoToHVpMANxn0Eg5uMlhNanu2PhDdiKoOshoFdJPDLOXQTZ5W1VBvk69zmg4KMAjJJdMDlFcnz9AvrwZMDzSTwzdIh1mqgTEGs4RD83JohvomLAG1rshgPeX8DNlWTOsZAFABmW0BEw4CTrsOqKyJ319Zoz4sx01LeRepKjfAgJ3PKseESwaldZ41D0egVodZzuFYAlazgGOJvL9GaSnS9VyiIo2uqqAqi69WMss0uJYK2rIh3KAex1PeoSqqXOuyaqi3ydc5TQeTUvaCVY+yp6mpCeXl5WhsbERZWVmhm0P6E8fevhR2spwMJJ/Js9BjxYUex4Vjty3bDmBbner5YRz48kOgcTNQUgmM3B2oGKTOXc0OnSYr9mQmz44Kfm7S1YOZT3PWJEsguN4BN9UHYEfClhCWRGBo5xOXpfM4zets6CZP+TiOJVA6zCju1zAN+TinmXyGUpInIUVEM9qvG1IcS6oX/E1XCLUeBufqp8evVvzcaW+1X0q1IBfTABEBROff0LJZuZGNc5OXIKWI1nOJkkJVSEkJiIgKqtt/KDIdkGHZ42qltKqiMqj86YxwJTYsDSK4wUGgVkft1AC4lr+/4+g5bV+J1l62zmm6KMAgJNdsCwg2Adb2qcJh+oEATcHcJSsMbNsMbNuozl3TFjXEVFoJGF51THS9DOkCXFP/eoGinYo9T4QtEd7mQLS9fOAMup/BU6qBe7iqyOGsxxU5+ar8WfVsI5bO2oDguu0lwYFhOqbeVovRM/IzGyrj6px1+lyzcE7TVfCr+M4778SIESPg9XoxadIkvPfee50e39DQgPPOOw+1tbXweDzYcccd8eKLL+aptYRkyLaAhs1qLRLdVFUluql+b9is9pPkrLDq0o8EgUAF4PEBJRXqvDXWA3ZYHWe39WrYNuAr6RVBW9FOxZ4nbttssNIFpCuhB1Sis9MiEKp3ICJCVVAFWI97dfJR+bPq2UYsPm5tXHABAMH1DhYftxarnm3s9n1nQjN5QiVae9k6p+kqaIDx5JNPYvbs2Zg3bx4+/PBDjB8/Hocddhg2bdqU9HjLsnDIIYfgm2++waJFi/D555/j/vvvx9ChQ5MeT0jBBZvakjpL1cRajKmf/lK1PdhU6BYWr+YGVT1SUqF6LHRT5a74S1VPxrY6lfwJqGER06OO6wWKcir2PIo0uRCWRMlQA7pfzQwLCegBDrdVoPk7C5rJYgv69VQuK3+EK7F01oZOZ7BfduFGCDc/6Y6ecvVcrab452o1uVk9p+ko6BDJzTffjF/84hc4/fTTAQD33HMP/vGPf+DBBx/EZZddlnD8gw8+iK1bt+Ktt96CYaj+nxEjRnT6GJFIBJFIJPZ7UxO9oZM8cWw1LOLxJd/v8an9jp0y6bPfsi0g3KJ6fADA8ADlVSqI4LoKKJq3AZ4SoHwgUDZQBRemt7DtTkPRTsWeJ669fUp8bjD4B+mItK0kjIhsW0aewTMg9aq2mYpW/oQbXLXeT6saFjHLO189Nx0blgYTei7iSKBlrY0NS4MYekBJtx8nXZqHw1+jI9LowglKyLAE4wxmGVfBRx6rnAoWYFiWhQ8++ABz586NbeOc4+CDD8bbb7+d9DYvvPACJk+ejPPOOw9//etfMWjQIJxyyim49NJLoaXIiF6wYAHmz5+fk+dASKeiU4Wnygng2vZjSDwpVBChtXuLMjzqn79clVk2bwMGj1BBSC8YFokq2qnY80XIuEREzcPhH8ThWmo7GCAs2ZbwnD2ahyNQk/naPF0JbugkuOjGcdmgeTj81dl/rpkqWHhcX18P13VRUxNfz15TU4ONGzcmvc3XX3+NRYsWwXVdvPjii7jiiivwhz/8Addee23Kx5k7dy4aGxtj/9auXZvV50FISpyrLtKVS4FlzwD/exOIhFW3v2OrD9DodOIkHuMqAHMT35RtjcFiArbP1+3gwrUEnLDqJci39kmHyeRsunHbUnkt7fN+km3LNc5iiYjtMab+wd0+PX4uaKZabThbH7iB2vS+p6d7XDZl+7lmKuNnPGLECJxxxhk47bTT8L3vfS8XbUpJCIHq6mrcd9990DQNEydOxPr167Fw4ULMmzcv6W08Hg88HlpumBTAO38Dbj8f2NZuManyQcDxFwMTDlY9FwNqaXgkGcMEvCVAsEHlYACwpY0WN4SwjEAEG8D9FfAiiBLBYPD0zmExVG5Ep2KPNLhJZ0S1gyo3I2sfClZY5bOEW9qCWg3QDPVpLtztlU3eABAoz/ny7JqhpsS3mwRMQ4MbaZusLCQghYQTkvBWa4DQUSyl2p2pnRpAYJiO4Hon5SSzJcMM1E4N5L1thZbxFXzhhRfi2WefxahRo3DIIYfgiSeeiMtxSFdVVRU0TUNdXV3c9rq6OgwePDjpbWpra7HjjjvGDYfssssu2LhxIyyLsvFJEVn2LHD1cfHBBaAmhvrTpcD7iwE7AjhtPRokUWmF+rBraYBth7DNaUTQboYRCsFnlsEoHYigCGKbsw226Hq11GKq3MjbVOzRSpxgQ9vwUtvESBu+BjauUuMwvhKVQBtqAhrq8nI9eso0cJOhdbON4AYbVpMDxtQcDrqfgUkgtKl3TOHNNYapt7UtGJdiRvb9bh2c1/kwikW3AowVK1bgvffewy677IILLrgAtbW1OP/88/Hhhx+mfT+maWLixIl47bXXYtuEEHjttdcwefLkpLfZd9998dVXX0G0G7P+4osvUFtbC9PsPWOwpI9zXeCuWUj+dabNc39UC01JbK+EIPFMr+rhCVSgJdIAK7QVAcGhBSrBBgyG5vEjoAVgSQstbkuXd1dMlRt5m4q9fSWO3tZrYYUBjxfQTCDcqrbphgo+bAsI5r6kUuUI6JAMcEIqCVFKwCzTEKg14BtkQFgSkabeUU0zekY5Dl80HIGh8YMCJcMMHL5oeN7mwSg2PZ4q3LZt3HXXXbj00kth2zbGjRuHX//61zj99NPBWOcR25NPPolTTz0V9957L/bZZx/ceuuteOqpp/DZZ5+hpqYGM2fOxNChQ7FgwQIAwNq1a7Hbbrvh1FNPxQUXXIAvv/wSZ5xxBn7961/j8ssvT6u9NFU4ybmP3gDm/LDr4+Y9B+y0jypXrRpKQyUp2NJGfWgjDHBo3ACM+PPkShe2tFFlVMFINrsQ2qaLXmND86SeQtmNSJR+L//TRecsEc+2gE1rVM9F9NpyLGDrRvW7RLtrr+0LmmNv35bjxFnXlgiutwHWlgfNWVxip7AlXEsiMNTIesJnrhR6Js98yMtU4bZt47nnnsNDDz2EV155BT/4wQ9w5plnYt26dfjtb3+LV199FY899lin93HiiSdi8+bNuPLKK7Fx40bsueeeWLx4cSzxc82aNeDtEuCGDx+Ol156Cb/5zW+wxx57YOjQoZg1axYuvfTS7j4NQrJv64aujwFUd7Smq2+UVEmSkpQSQufg3NeWBRiPg0NIASllyiH7Yq7cyFlAk6wSJ1bZ1LbN6jBHdvR6zMeJaKsmMUp40i+j0WmtISR6Qy4GoIZL8lGK2ltkHGB8+OGHeOihh/D444+Dc46ZM2filltuwc477xw75sc//jH23nvvtO7v/PPPx/nnn5903xtvvJGwbfLkyXjnnXcybTYh+TOgNr3jKmq2T3NNlSQpMcbAGYeAgIbE3AQBAc6Sf0jF7iPH00UXuhwwqfaVONEejOi1JtoSEnmHJx29HvMxl3S7apLOprXOVTUJyb2MA4y9994bhxxyCO6++24ce+yxsQmv2hs5ciROOumkrDSQkF5n96lA1bC2FUBTjEAOHALs/AM1Dba/jIZHOmEwA17mRVAEEdASM/HDIowAD6QcHgFyV7nhRsT2CY2EyiXQAyzvExollaQSB7qpplVvbVY9Gf7y7cMjgOrR8OdnjZyO1SQdOa0CRhnvNcMjJFHGAcbXX3+NHXbYodNjAoEAHnrooW43ipBeTdOAc29TVSRgSBpk/PwqFVwY5vbMfpJSiVYCW9oIukF4uVcNi0AgLMIwmYkSretuaU+FBrdVVWoYAa664B0VXHSncsONCITqHLiWmpWS6erbuNUk4IYl/DV64YOM0grAbgVaGlQZqqar5NmGzSrF3+tTq9G6jgouDFOVquaJp0yDG1bTWKtzqF4Tp1WAmwyest6xcB1JLuOrf9OmTXj33XcTtr/77rt4//33s9IoQnq9/WYAVy5SyXLtDRgMXHAn8P1DVGBRXp3zeQf6AoMbqNQrEeAB2NJGq2iFLW0EeACVemVa82Bku3Ij0ujCtSTMsviqFLNMg2updS4Krl0lDuzI9oql2lHA4NFqKKS1pW29nDI1bJfH6zFaTWKUqZk81RTpEkaZ2l7wAI30SMY9GOeddx4uueQSTJo0KW77+vXrccMNNyQNPgjpl/abAUw+Bvh4qUr8HFCrhkUYU+PcNCySEYMbqOSVsKUNKSUYY50OiySjezn0wT2fQtm1RGw9jaSP4+NwgrI41hMxvcDAwaqqJPqko0MgybblWWyq8Iq2hM4O1SSk98o4wPjkk0/w/e9/P2H7hAkT8Mknn2SlUYT0GZoGjD+g0K3oUwxm9LiooKcf+lIgbj2NjqIVEEW1nkiyAKKI1nBRQQUFFn1Jxn9lHo8nYfZNANiwYQN0vaCLsxJSnAqx3gPJKcaRdD2NqGgFRD6KMXrEsbevjUNIlmV8+R966KGxBcSiGhoa8Nvf/haHHHJIVhtHSK9mhYEtG9VkR3Xfqp9bNqrtpFfTTA49wOC0Ju+icFoF9AAr/PBIKlZEJXrWr9/+r2EzTVtPsirjLoebbroJ+++/P3bYYQdMmDABALBixQrU1NTgL3/5S9YbSEivFF0Dwopsz953HVUyaLeqfAzTW+hWkh7wlKeugNBMVapalKwI0LhJ9aiZvu3XZqgJsMOUeEyypltThQeDQTz66KP46KOP4PP5sMcee+Dkk09OOidGsaGpwklebNkYP/9Aey0NKqt/YPJF/UjvUdTzYKTSsFkFE8nKo6PbKwblv12kV8j5VOGBQABnn312txpHSJ9nW2ppbG+K5Zm9AbXftooqyY5kTpVZ9rwqJW8cGwgHVc9FMqZP7XcqqMqJ9Fi3szI/+eQTrFmzJmGZ9KOPPrrHjSKkV0u2BkR7mg5ECrTwBcmJog4q2ouuRdLZtUlr45As6dZMnj/+8Y+xcuVKMMYQHWGJrgPgukUwuQwhhZRsDYj2XCdxDQjSuSKYr6FPiK5F0nZtOtKFhAADh840WhuHZFXGV9GsWbMwcuRIbNq0CX6/H//73//w73//G3vttVfSxckI6Xeia0CEg8n3h4NqP31Qds2KANs2qSqHzW3VDts2UbVDd+kG4A3AjjSjyW1Bg9OIbU4jGpxGNLktsCPNagiPhkdIFmTcg/H2229jyZIlqKqqAuccnHPst99+WLBgAX79619j+fLluWgnIb1LsjUgXKdt/Nuj9pPOWRG1pH2qaoc8T2vdV9g+P5rDG+GEmmCYJTC5CVdYCIfr4RhelPr8oPCCZEPGPRiu66K0tBQAUFVVhe+++w4AsMMOO+Dzzz/PbusI6a2SrQFhR9TvVKKanmCjCi6iq80ypn76y9T2YGPX90EStGounNJK+PxV0F0BFglBdwV8/io4pZVo1WiYm2RHxj0Yu+++Oz766COMHDkSkyZNwo033gjTNHHfffdh1KhRuWgjIb1TZ2tAkM7ZVnrVDlSJkxFHOrCEBcMMAB4dcG2V0Mk5oBkw2vY70oHOaGZm0jMZX0G/+93vEAyqseWrr74aRx11FKZOnYqBAwfiySefzHoDCen1evkHoGsXYBEqmUa1Q6hJVeMABT/HBTlHGYi2z4GAYAIm2s6XZgDt5gPToMGGWkyOlgUhPZVxgHHYYYfF/n/MmDH47LPPsHXrVlRWVsYqSQghvZ9rCVhNAk5IbJ9Eys9hlvHcl2Wy+GqHOHYEaNoKhBrVh6DhVXkugfK852QU9Bx1o30uc2F5BbRSB6aZmGnhwgUHp/dykhUZ/QXYtg1d1/Hxxx/HbR8wYABdkIT0Ia4l0LrZgdXsgpsMeoCDmwxWs4vWzQ5cK8fzJBimChqs1vjtdtsaGk31KhejZACgm6o3o6Eur9UlBT9H3Wif6TGAFh1N9SG4dmL7bGnD5CYNj5CsyCjAMAwD3/ve92iuC0L6OKtJwLUkzFINXGdgjIHrDGapBteSsJry8OEZKFeBRqhJzUAppeq5aNkGlFYCZQMLmvhZFOeoG+0rLysBszQ0NQbhSAdSSjjSQatohQ4dPi1F3gshGcq4D+/yyy/Hb3/7W2zdujUX7SGEFJhrSzghAd2X/O1B93E4IaHG9XPJ9KhSVH8Z4FhAc9uwSNlAoHwQYHQYDmmf+JljRXOOUuisfTrTURmogN7qgWU7CMswXOnCy70oNUphMCpSJdmRcT/YHXfcga+++gpDhgzBDjvsgEAgfr2FDz/8MGuNI4QUgGhbuEtLPuzJNECKtqTGXGcCmh7ArFZBQySkHq5kgOq56Cg6zXU+pmAvpnOUTBftM3QdJawEHs5ivRs0LEKyLeMr6thjj81BMwghRYMzMM4gXSDZZ450AcYZwPP4wRmtEjG8XUzBzvMzBXsxnqP20myfrhnQCtXGPqrXLHyXBxkHGPPmzctFOwghRUIzVCWE1ezCLNUS9jutAmaplv9yzGjiZ6gpeYBhtarhlDyUrBbtOWpT7O3ri9yIQKTRhROU2yuKAgyecg2ap38GGtQnRghJYJZxuBEBq9mF7uOqy99VH0yayWCWFegNM1CupgkPNcVPH261qsAiUJ63phTtOeol7etL3IhAqM6Ba0l1rnUG6bQl2oYl/DV6vwwyMg4wOO+8RpoqTAjp/TSTwzdIT5jjwSzVCjvHQzTxM9ioEjqtsBoW8ZflfR6Moj1HvaR9fUmk0VUVO2Xbe4uYAZiGBqvJRaTRhb+6/53vjAOM5557Lu5327axfPly/PnPf8b8+fOz1jBCSGFpJoevihffLJXtEz8LPAV70Z6jNsXevr7AtQScoOy8oigo4Vqi3wV1GQcYxxxzTMK24447DrvtthuefPJJnHnmmVlpGCGkOKgPpCL8UCqiKdiL9hy1Kfb29WZSqIohpqeoKNIBGZZ5KW4qNlkLp37wgx/gtddey9bdEUIIIUWPcVWRI53k+6Wj9uejuKnYZOUpt7a24o9//COGDh2ajbsjhBBCegXN5NADDE5r8i4Kp1VAD7B+NzwCdGOIpOOiZlJKNDc3w+/345FHHslq4wghhJBi5ynX4IYlrKa2ih1d9VxEK3Y85Ymlwv1BxgHGLbfcEhdgcM4xaNAgTJo0CZWVlVltHCGEEFLsNA+Hv0bfPg9GuK1ip4zTPBiZOO2003LQDEIIIaT30jwc/mpOM3m2k/Gzf+ihh/D0008nbH/66afx5z//OSuNIoQQQnojzeTQvTTPCNCNAGPBggWoqqpK2F5dXY3rr78+K40ihBBSAI6t5hdx7EK3JOdcW81NUagVb/uDjIdI1qxZg5EjRyZs32GHHbBmzZqsNIoQQkge2RbQ2qKmXBcuwDU1FbuvpKjmG8kG1xKwWwScVgnhSnCNQfcxGCXU65BtGZ/N6upq/Pe//03Y/tFHH2HgwIFZaRQhhJA8sS2gaQvQ2gxoBuAJqJ+tzWq7bRW6hVnjWgLhLS6sZhfcAIwAAzcAq9lFeIsL1+qHs2HlUMYBxsknn4xf//rXeP311+G6LlzXxZIlSzBr1iycdNJJuWgjIYSQXGltARwL8JWqxeMYUz99pWp7a0uhW5g1douAa6mVZLnOwBgD19X6LNGeDZI9GQ+RXHPNNfjmm29w0EEHQdfVzYUQmDlzJuVgEEJIb+LYaljE9CXfb/rUfscGdCO/bcsy15ZwWrtYM6RVwrUlrdeSJRkHGKZp4sknn8S1116LFStWwOfzYdy4cdhhhx1y0T5CCCG5IqXKuTC8yfdzDbDD6rjeTqqcC82bYs0QDRBh2fZcKcDIhowDjKixY8di7Nix2WwLIYSQfGJMBRHCVcMiHUUTPlkf+MBlDFxjkK5agKwj6QJcY33juRaJjHMwfvKTn+CGG25I2H7jjTfi+OOPz0qjCCGE5IFubB8GSSY6fNLLh0cAtaKs7utizRAfLWefTRkHGP/+979x5JFHJmw/4ogj8O9//zsrjSKEEJInvhJAN1XViOuoIQLXUb/rptrfR0RLUa1mF8KRkFJCOBJWswvN5DBKqEw1mzIeImlpaYFpJtZFG4aBpqamrDSKEEJInhgmUDZw+zwYdlgNi/hK+9w8GJrJ4R0I2C1MzYMRVvNgmKUazYORAxmfzXHjxuHJJ59M2P7EE09g1113zUqjCCGE5JFhAmUDgIpqoHKw+lk2oE8FF1GayeEdoMNXrSMwWP30DtApuMiBjHswrrjiCsyYMQOrVq3CgQceCAB47bXX8Pjjjyddo4QQkj7VbduWe6d3PRbs2m1Z74zGjjPh2hIQEuB03uL0gVyLdKnXnV77XMo4wJg+fTqef/55XH/99Vi0aBF8Ph/22GMPvPrqq5g2bVou2khIn+faEk7IhROWgADAAd3LoPu1pB+ANN1x97iWgNUs4IQEpFBLaut+DrOUzhsh2cak7AsFzulrampCeXk5GhsbUVZWVujmEALXlog0OJAOwD0MjANSACIiwXTAU6HHBRnR6Y5dS0D3cTBNldg5raJtjFmjD8skXEsgXO/AtWSS88bgraJuckK6kslnKP01EVJgTsiFdADdz8G1tumLNfXNWjpqf3s03XH3WM0CriVTnDcJq5nOGyHZlHGA4boubrrpJuyzzz4YPHgwBgwYEPePEJI+4Ug4YQnuST4WzD0MTliV0gGZTXdMtlNDUKLz8xaipbsJyaaMA4z58+fj5ptvxoknnojGxkbMnj0bM2bMAOccV111VQ6aSEjfJSUAAbAUf4mMq/2xgcy26Y6ZluJ4DRCu7BtTO2eTkCrnopPzJkVb4ichJCsyDjAeffRR3H///bjoooug6zpOPvlk/OlPf8KVV16Jd955JxdtJKTPYgxAW85FMrIt4TM2e3G76Y6THk/THSfHGRjv/LwxzgBO542QbMk4wNi4cSPGjRsHACgpKUFjYyMA4KijjsI//vGP7LaOkD6O6wy6l0FEkn9zFhEJ3ctiJas03XH3aIbKaen0vPk5nTdCsijjAGPYsGHYsGEDAGD06NF4+eWXAQD/+c9/4PF4sts6QvoB3a+B6YATEhBu2/TFrsoZYLra3x5Nd9w9qhSVpThvDGYpnTdCsinjv6gf//jHeO211wAAF1xwAa644gqMHTsWM2fOxBlnnJH1BhLS12kGg6dCh+5nELaE2yohbAndzxJKVAHESlHNUg3CBuyghLABs1SjEtVOaCaHt0qH0VY1YgdVVYlRqlGJKiE50ON5MN555x289dZbGDt2LKZPn56tduUMzYNBihnN5JkfNJMnId2TyWcoTbRFCCGEkLRk8hma8VThhBBCCEmOese2owCDEEII6SFa5yYRBRiEEEJIDySuc6PmXLGbXYiI6LdJxP3vGRNCCCFZROvcJJdxgDFq1Chs2bIlYXtDQwNGjRqVlUYRQgghvQGtc5NaxgHGN998A9dNnG83Eolg/fr1WWkUIYQQ0ivQOjcppZ2D8cILL8T+/6WXXkJ5eXnsd9d18dprr2HEiBFZbRwhhJD+IdM5YIpGu3VuWJJP1P68zk3aAcaxxx4LAGCM4dRTT43bZxgGRowYgT/84Q9ZbRwhhJC+TQ0xuHDCEmhb3E/3Muh+rVeUeUbXubGbXZilid0YTquAUdo7nku2pR1gCKGSVEaOHIn//Oc/qKqqylmjCCGE9H2uLRFpcCAdgHsYWNvKwk5IwrWcpFPlFyOzlENEBKxmt62KRPVcOK2iX69zk3GZ6urVqxO2NTQ0oKKiIhvtIYQQ0k84IRfSAXT/9g9gpgHcz+CEBJyQC628+GdTiK5z03EeDKNU69fzYGT8rG+44QY8+eSTsd+PP/54DBgwAEOHDsVHH32U1cYRQgjpm4Qj4YQluCd5DwX3MDhhteJtb6CZHL6BOvyDDQQGG/APNuAb2D/nv4jK+Jnfc889GD58OADglVdewauvvorFixfjiCOOwJw5c7LeQEIIIX2PlAAEwNo+hVwBOEL9BNq2i7bjehHNYNA8vFcM7eRaxn1PGzdujAUYf//733HCCSfg0EMPxYgRIzBp0qSsN5AQQkjfwxgADtgOYAOw3djCwDA0wADAedtxpFfKuAejsrISa9euBQAsXrwYBx98MABASpl0fgxCCCGkI64zwGRoCUpEXFXFaWjqZ8QFWoISMFnvKlklcTLuwZgxYwZOOeUUjB07Flu2bMERRxwBAFi+fDnGjBmT9QYSQgjpm1xTg8sdmBEB5mEAA5gEtIiExdV+0ntlHGDccsstGDFiBNauXYsbb7wRJSUlAIANGzbg3HPPzXoDCSGE9D2uAFzOEKjUIcMd5sHwMxheDS5ncAWg9d88yV6NSdnbUmh6pqmpCeXl5WhsbERZWVmhm0MIIf2SI4DGMODRVJ6FcCQkAAY1fCKlGiop9wI6BRhFI5PP0G69bH/5y1+w3377YciQIfj2228BALfeeiv++te/dufuCCGE9DMMKt8iukQH1xk0fXvOhZBqP2Vg9F4ZBxh33303Zs+ejSOOOAINDQ2xxM6Kigrceuut2W4fIYSQPkjjgKmpnoxkHKH20/BI75XxS3f77bfj/vvvx+WXXw5N256As9dee2HlypVZbRwhhJC+y6OrACLiqJwMKdXPiKO2e4p/Ek/SiW5NFT5hwoSE7R6PB8FgMCuNIoQQ0vfpHAiYKqCwXMAWaljEo6t/lHvRu2X88o0cORIrVqxI2L548WLssssu2WgTIYSQfiIaZJR5VEJnmUf9TsFF75d2D8bVV1+Niy++GLNnz8Z5552HcDgMKSXee+89PP7441iwYAH+9Kc/5bKthBBC+ijKteh70i5T1TQNGzZsQHV1NR599FFcddVVWLVqFQBgyJAhmD9/Ps4888ycNjYbqEyVEEII6Z6clKm2j0N++tOf4ssvv0RLSws2btyIdevW9Si4uPPOOzFixAh4vV5MmjQJ7733Xlq3e+KJJ8AYw7HHHtvtxyaEEEJI9mXUKcU6rDrj9/tRXV3dowY8+eSTmD17NubNm4cPP/wQ48ePx2GHHYZNmzZ1ertvvvkGF198MaZOndqjxyeEEEJI9qU9RMI5R3l5eUKQ0dHWrVszasCkSZOw995744477gAACCEwfPhwXHDBBbjsssuS3sZ1Xey///4444wzsHTpUjQ0NOD5559P6/FoiIQQQgjpnkw+QzMqU50/fz7Ky8t71Lj2LMvCBx98gLlz58a2cc5x8MEH4+233055u6uvvhrV1dU488wzsXTp0k4fIxKJIBKJxH5vamrqecMJIYQQ0qmMAoyTTjqpx0Mi7dXX18N1XdTU1MRtr6mpwWeffZb0NsuWLcMDDzyQtFQ2mQULFmD+/Pk9bSohhBBCMpB2DkZXQyP50NzcjJ///Oe4//77UVVVldZt5s6di8bGxti/tWvX5riVhJDexBVqWmo3xZTVhJDuSbsHIxeLrlZVVUHTNNTV1cVtr6urw+DBgxOOX7VqFb755htMnz49tk0I9a6g6zo+//xzjB49Ou42Ho8HHo8n620nhPRujgAsB7DapqhmDDA5YNIMkoRkRdp/RkKIrA6PAIBpmpg4cSJee+21uMd57bXXMHny5ITjd955Z6xcuRIrVqyI/Tv66KPxwx/+ECtWrMDw4cOz2j5CSN/kCCBkq+XA9bZFt3Sufg/ZqRfgIoSkr+BLycyePRunnnoq9tprL+yzzz649dZbEQwGcfrppwMAZs6ciaFDh2LBggXwer3Yfffd425fUVEBAAnbCSEkFattca32i2kxqN8jjtqvmwVrHiF9QsEDjBNPPBGbN2/GlVdeiY0bN2LPPffE4sWLY4mfa9asAefUX0kIyQ5XqGERQ0u+39DUfo+g6asJ6Ym058HoK3IxD4YrXUhIMDBoLMW7FiGkKDgCaI6oYZFkuetSqpU9Sz2Ui0FIRzmbB4PEc6QDW9iwhR0LMAxuwOAGdEanlpBixKACC9n2/x3Jtv2Fr5sjpHej+LybHOmg1W1FRESgMQ0GM6AxDRERQavbCkc6hW4iISQJjatqEdtNvt921X4aHiGkZ+hPqJtsYcOVLjzcA844GGPgjMPDPXClC1vYhW4iISQFU1cBRMQBhFTDIkKq37W2UlVCSM9QgNEN0QDCYEbS/QYzYgEIIaT46BzwG4BHa5sPw1U/PZraTrkXhPQcxendINv+YylGaRlY7BhCSHHSuSpF9Yjt+Rg0LEJI9lCA0Q2s7b9okNGxiiT6/6kCEEJI8aCggpDcoACjGzSmweAGgm4QHBy2bFdFwgwICAS0AJWsEkII6bcodu8mxhgsaaHZbQYDgw4dDAzNbjMsaRXF4nCEEEJIoVAPRjdJKeFhHng1L2xpw4EDBoZSrVRlX/Sv+csIIYSQOBRgdEO0isTLveCMw5RmXA6GkAK2sGFyk4ZJCCGE9EsUYHRDxyqSjkEEVZEQQgjp7ygHoxvaV5EkQ1UkhBBC+jsKMLohWkViy+SzddrShsENGh4hhBDSb9EQSTcZ3IAjHUREBAYzYj0atrRjAQghhBDSX1GA0U060+HTfAmrqXq4h1ZTJYQQ0u/Rp2AP6EyHrukweXwVCSGEENLfUYCRBRRUEEIIIfEowCCEkP7AddS69IwBGr31k9yjq4wQQvoyxwYirYAdAaQAGAcMD+DxATolo5PcoQCDEEL6KscGQk3qp+4BOAeEACIhwLUBfxkFGSRnaB4MQgjpqyKtKrjw+AFNaxse0dTv0Z4NQnKEAgxCCOmLXEcNi+ie5Pt1j9rvOvltF+k3aIiEENKvCVcCEgADuNaHpveXUuVc8BTfIzkHXKGOIyQHKMAghPRLwpFwwgLCkrHcR24y6F4OrveBQIMx9aSEUMMiHYm2J836wHMlRYmGSAgh/Y5wJOwWF05YABrAPQA0wAkL2C0uhNMHvtVruqoWcSLJ9zsRtZ9KVkmOUIBBCOl3nLCA60jVW6ExMMbANdV74bb1bPQJ0VLUSAhwXTUc4rrqd91Q+wnJEQpdCSH9inAlhCXBjeRDA9xgEJaEcGXvz8nQDVWKGp0Hw20bFvH4aR4MknMUYBBC+pdo7mOKz1bGAWGr4/oE3VD/aCZPkmd0lRFSpBxne/Kh3heSDnvIlW7s/3u0/k9b7qMUQLK7iZ5z9LVTTkEFyTO64ggpMrYl0RoSiES2BxgeD4PPz2GYfe1Tr2uudGEJCw4cSCnBGIMOtYpxdwINrjFwk8EJi6RDIMLenptBCOk+CjAIKSK2JdHcKODYEqaXxWZ2DockHFugtLx/BRmudNEqWuFKFzrTwTmHkAKWtOAKFz7u61aQoXs5ZFsyJzdYrEdD2BKarpI9CSE9Q39FhBSR1pAKLnwBDq2tukHTGHwBDsdWPRv9iSUsuNKFyU1wpt6uOOMwuRnr2egOrjMYJZoKJFxARAC4KvAwSrS+MQ8GIQVGPRiEFAnHkYhEVM9FMqaXIRKRcBzZL3IyXOnCgQOdJX+b0pkOBw5c6XZvqERnMEu0vjuTJyEFRgEGIUVCiq5ndo4e019IKcFTnBAGBpmFaa4pqCAkN2iIhJAiwfj2mZ2Tic3s3I/+ahljEB0jKlcAroB0XTCa5pqQotWP3qoIKW66zuDxMFjh5N/KrbCEx8P6xfAIoEpRdehwZNtqn64Awq1AawsQbILT2gg9bEPrRz06hPQmFGAQUkR8fg7dYGgNCriuhJQSrivRGhTQDVWq2p9ES1EtOwzR2gxphSEYg6UzaFyH6QogHFTTXxNCigrlYBBSRAyTobScJ8yD4fX3z3kwNKbBx32wHAuOsCF1A4wBJkyYmqGSO+2I+qf5C91cQkg7FGAQUmQMk8EwNZrJs40mAJ/U4BplsQzYuKoRzQAcW/ViJFuWnBBSEBRgEFKk+nNQkUAIaKYn+T7GUmfGEkIKpn8N6BJCeifeSXmNlKlrewkhBUN/lYSQ4qZpbauB2sn3u7baT8MjhBQVCjAIIcXP8AC8LaFTCNVrIYT6nWtqPyGkqFAOBiGk+Gka4A2ogMKxVXDBuQosDA/1XhBShCjAIIT0DpqmSlHbz3lBgQUhRYsCDEJI70JBBSG9AgUYhJBexZXbezC6s4oqISQ/KMAghPQKrnRhCQsOHEgpwRiDDj02nTghpLhQFQkhpOi50kWraIUlLXBwGNwAB4clLbSK1rheDUJIcaAAgxBS9CxhwZUuTG6Ct61XzxmHyc1YzwYhpLhQgEEIKWqudOHAgc6Sj+jqTIcDh3oxCCkyFGAQQoqelDLWc9ERA4OUMs8tIoR0hQIMQkjRY4xByORrkUiohE9CSHGhAIMQUtQ0pkGHDkc6Sfc70oEOnSpJCCkyVKZKCCl6JjfhCpXMqTNdDYtAwpEONKbB5Gahm0gI6YACDEJI0dOYBh/3JcyDYTKT5sEgpEhRgEEI6RU0psGn+WgmT0J6CQowCMkDIYVKRgRLWQ1B0tPXggrhbq+A4Vp+k1XbJ87SdUmyjQIMQnLIlS4c4ahu/bYAQ4cOnVNSYn8nXAk3IuDaAIQEOINmAJqH5zzQEFKkvC4p0CDZQgEGITniShcREYGQAhrTwBmHkAK2tOEKFx7uoSCjnxKuhB0UkK4ENxiYwSGFhBuREI6AEchdkCGkQEREICHBwWPXpQMndl1SkEGyga4iQnLEEQ6EFGrdjHbTWxvciH2DJP2TG1HBhebhYFwFEowzaB4O2dazkSuOUL0WOtPjrkud6aoyh65LkiUUYBCSA9FvhKl6KDSmwYGTcvIo0ncJV8K1AW4k76HgBoNrx+dmZO2x265LnuKtn4PTdUmyhgIMQnJAtv2XqquZMx47hvRDQsZ6LhIwtT9X0rkuCckGCjAIyQHW9l+qb4JCitgxJA1CAK6rfvYFnEGmCiKk2p8r6VyXhGQDJXkSkgOccejQYUs76bdFV7owmEHJdF1xXcCxAMcGpAQYA3QD0E1A650JslxT1SJuRELzJH6YC1ttz0WSZ/S6TDVMIiCggypJSHbQVURIjkRL/mxhx74xCilgCxV06Jzi+065LhBpBWwL4BpgmOqnbantbu9dnl3zcDCNqWRPISGlbKsiEWCaSvbMFZ2rqdYd6cRdl450VLkqXZckS+hKIiRHNKbBwz2x+QZc6YKBwWAGzYORDscChKsCiyjOAW6qIMOxAM1XuPb1ANcYjABPnAfDw3I+DwZnPOl1SfNgkGyjAIOQHNKYBk3TYEiDZvLMhBBqWERL8Ral6Wq/4VFBRy/ENQbu16AVYCZPzjhMzYQu9bhthGQTBRiE5AG9eWdISvUvVfDAOeA66pheLt/Tg8c9Nl2XJIcowCAk19rnCvTSxMS8Y0z9EyJ5kCHE9mMIIUWJAgxCcsV1ATuiuvKjH5S6obr1KdDoXPRc2ZbKuejIddqSPukbOCHFiv46CckF1wXCQRVgcA0wPW0VEBG1vRdXQOSN3q5qJDr/hRDbq0r0JIEHIaRoUIBBSC7YkbYKiHZJiJyr30VbzwbpnKYBHp/qqRBuW6DRVlXi8VEvECFFjoZICMk2122rgDCS79cMtd916UOyK5qmSlENz/aJtmhYhJBegQIMQnJBCJVDkEw0eZGkj4KKnhOCgjSSVxRgEJILnKeugOis/JKQbOuD062T3oHe5QjJNk1Tb+CunXy/a6v99OZOcq0PT7dOih8FGITkgtGuaiTaNS3E9qoSw1PoFpL+oP1063HJxm2Js45V2PaRPo0CDEJyQdMAb6Bd1Yi1varEG6DeC5J76U63TvlAJEcoB4OQXNE0QPPTTJ6kMPrRdOukOFGAQUiuUVBBCoGmWycFVhRDJHfeeSdGjBgBr9eLSZMm4b333kt57P3334+pU6eisrISlZWVOPjggzs9nhBC+qXodOuuk3y/66j9VNFEcqTgPRhPPvkkZs+ejXvuuQeTJk3CrbfeisMOOwyff/45qqurE45/4403cPLJJ2PKlCnwer244YYbcOihh+J///sfhg4dWoBnQAghRUo329bEsVTORbR82nW6nG7ddV3YdopKKNKnmaYJnoXAk0lZ2AG4SZMmYe+998Ydd9wBABBCYPjw4bjgggtw2WWXdXl713VRWVmJO+64AzNnzuzy+KamJpSXl6OxsRFlZWU9bj8hhBS1DOfBkFJi48aNaGhoyH9bSVHgnGPkyJEwzcQANJPP0IL2YFiWhQ8++ABz586NbeOc4+CDD8bbb7+d1n2EQiHYto0BAwYk3R+JRBCJbF/3oampqWeNJoSQ3iTD6dajwUV1dTX8fj8Y5Wj0K0IIfPfdd9iwYQO+973v9ej1L2iAUV9fD9d1UVNTE7e9pqYGn332WVr3cemll2LIkCE4+OCDk+5fsGAB5s+f3+O2EkJIr5ZGl7frurHgYuDAgXloFClGgwYNwnfffQfHcWAYKZY8SEOvzu75/e9/jyeeeALPPfccvF5v0mPmzp2LxsbG2L+1a9fmuZWk3xNCdVPTfAOkyEVzLvx+f4FbQgopOjTi9nCm14L2YFRVVUHTNNTV1cVtr6urw+DBgzu97U033YTf//73ePXVV7HHHnukPM7j8cDjoVkTSQFEV1UVTruuaZ2mCSdFj4ZF+rdsvf4F7cEwTRMTJ07Ea6+9FtsmhMBrr72GyZMnp7zdjTfeiGuuuQaLFy/GXnvtlY+mEpIZ1wWssEquY23lgoyr360wrQFBCOnzCl6mOnv2bJx66qnYa6+9sM8+++DWW29FMBjE6aefDgCYOXMmhg4digULFgAAbrjhBlx55ZV47LHHMGLECGzcuBEAUFJSgpKSkoI9D0LiOPb2NSCiOAe4qUoGHZt6MQghfVrBczBOPPFE3HTTTbjyyiux5557YsWKFVi8eHEs8XPNmjXYsGFD7Pi7774blmXhuOOOQ21tbezfTTfdVKinQEg8IdSwSGdrQAiHcjIIybKNGzdi1qxZGDNmDLxeL2pqarDvvvvi7rvvRigUAgCMGDECjDG88847cbe98MILccABB8R+v+qqq8AYwznnnBN33IoVK8AYwzfffJPrp9PrFbwHAwDOP/98nH/++Un3vfHGG3G/04tKil50DQitkzUgHJfWgCB9l+sCHy8Ftm4ABtQCu0/NeY/d119/jX333RcVFRW4/vrrMW7cOHg8HqxcuRL33Xcfhg4diqOPPhoA4PV6cemll+Jf//pXp/fp9XrxwAMP4KKLLsLYsWNz2v6+qCgCDEL6lBRrQAjZ1mMhBDitAUH6qmXPAnfNAurXbd9WNQw49zZgvxk5e9hzzz0Xuq7j/fffRyAQiG0fNWoUjjnmGLSfU/Lss8/GPffcgxdffBFHHnlkyvvcaaedUF1djcsvvxxPPfVUztreVxV8iISQPodzVS3StgaEkAK2sGEJCxERgeWEYENCUHxB+pplzwJXHxcfXABA/Xq1fdmzOXnYLVu24OWXX8Z5550XF1y0174yYuTIkTjnnHMwd+5ciC6GKn//+9/jmWeewfvvv5/VNvcHFGAQkgu6AXANwgrDdiNwpAMuAd0V4NyAozHYwt7eq0FIb+e6qucCyYb+2rbdfWFOKqi++uorSCmx0047xW2vqqqKFQBceumlcft+97vfYfXq1Xj00Uc7ve/vf//7OOGEExJuT7pGAQYhuaBpgOmFq2kQ0oUuJBgkoJlgpg+67oGAgCupXJX0ER8vTey5iCOBzWvVcXny3nvvYcWKFdhtt93ilowA1GyVF198Ma688kpYltXp/Vx77bVYunQpXn755Vw2t8+hAIOQHBGcwTUNaGYJYPrVP483luymQYMrXerFIH3D1g1dH5PJcRkYM2YMGGP4/PPP47aPGjUKY8aMgc/nS3q72bNno7W1FXfddVen9z969Gj84he/wGWXXYYCrw/aq1CAQUgOSUgwTVNBRYe1IBhjkEm7kwnphQbUZve4DAwcOBCHHHII7rjjDgSDwbRvV1JSgiuuuALXXXcdmpubOz32yiuvxBdffIEnnniip83tNyjAICSHGFjKbzxSSjBQpifpI3afqqpFUl7TDBg0XB2XA3fddRccx8Fee+2FJ598Ep9++ik+//xzPPLII/jss8+gpSiTPfvss1FeXo7HHnus0/uvqanB7Nmz8cc//jEXze+TKMAgJEc449CYBhfJ8yxcuNCYBs7oz5D0AZqmSlEBJAYZbb//6taczYcxevRoLF++HAcffDDmzp2L8ePHY6+99sLtt9+Oiy++GNdcc03S2xmGgWuuuQbhcLjLx7j44otpxugMMNnPBpSamppQXl6OxsZGlJWVFbo5pI+LlqgKCGjQ1LCIlHDhgoPD4AYFGKRohMNhrF69GiNHjky5QnWXks2DMWi4Ci5yOA8GyZ7OroNMPkNpoi1CcogzFUS40oUr3diwiM506r0gfdN+M4DJx+R9Jk9SfCjAICTHOONquERqcdsI6bM0DRh/QKFbQQqMAgxC8oSCCkJIf0LveIQQQgjJOgowCCGEEJJ1FGAQQgghJOsowCCEEEJI1lGAQQghhJCsowCDEEIIIVlHAQYhhBBCso4CDEIIIb3aaaedhmOPPTZu26JFi+D1evGHP/whbvuCBQugaRoWLlyYcD8PP/wwGGM4/PDD47Y3NDSAMYY33ngj202Ps3HjRsyaNQtjxoyB1+tFTU0N9t13X9x9990IhUKx40aMGAHGGN55552421944YU44IADYr9fddVVYIzhnHPOiTtuxYoVYIzhm2++yeXToQCDEEJIdglXYv0bLfji8Qasf6MFws3vkld/+tOf8NOf/hR33303Lrroorh9Dz74IC655BI8+OCDSW+r6zpeffVVvP766z1qwwEHHICHH3447eO//vprTJgwAS+//DKuv/56LF++HG+//TYuueQS/P3vf8err74ad7zX68Wll17a5f16vV488MAD+PLLLzN9Cj1GM3kSQgjJmlXPNmLprA0IrnNi2wLDdEy9rRajZ5Tn/PFvvPFGzJs3D0888QR+/OMfx+3717/+hdbWVlx99dX4v//7P7z11luYMmVK3DGBQAAnnHACLrvsMrz77rs5b2/UueeeC13X8f777yMQCMS2jxo1Cscccww6rkt69tln45577sGLL76II488MuX97rTTTqiursbll1+Op556KmftT4Z6MAghhGTFqmcbsfi4tXHBBQAE1ztYfNxarHq2MaePf+mll+Kaa67B3//+94TgAgAeeOABnHzyyTAMAyeffDIeeOCBpPdz1VVXYeXKlVi0aFFO2xu1ZcsWvPzyyzjvvPPigov2GGNxv48cORLnnHMO5s6dCyFEp/f/+9//Hs888wzef//9rLU5HRRgEJIvUm7/R0gfI1yJpbM2AMku77Zty/6/vTsPi6re4wf+PjODjjICKsYiCApmpiwimEsuF63Bayb+7NGfiYj6pP4UtRRSrgsBpWjmGt66V8rsuqBm6u2mt1Iht5sLYJpCargGgksgKMEw5/fHxOQwA7LMBrxfzzOPzFm+5zMI33nzPd9z5s08k50uOXDgAFauXIl9+/Zh6NCheuuLioqwe/duhIWFAQDCwsKwc+dOFBcX623r6uqKuXPnYtGiRVCpVHrrje3KlSsQRRHdunXTWe7o6AiFQgGFQmHwdMjixYuRk5ODrVu31th+QEAAxo4dW6tTKsbEgEFkaqIIqFSAqhwoL9P8q1IxaFCTknu0RG/kQocIFN8sR+7REpMc39fXF56enoiNjTUYGrZv3w4vLy/4+fkBAPz9/eHh4YGUlBSD7S1YsAAFBQXVztWoatmyZdowoFAocPToUcyYMUNn2Y0bN+r0mk6dOoXMzEz06NEDv//+u976Dh06ICoqCkuXLkVZWVmNbb377rs4evQovvnmmzrV0BAMGESmJIpAhQpQVwCCoPkYa0HQPK9gyKCmoyS3dn/p13a7uurYsSNSU1Nx+/ZthISE4OHDhzrrk5OT8dNPP0Emk2kfFy9erDZAODg4ICYmBnFxcTpXcFRnxowZyMzM1D4CAwMRHx+vs8zV1dXgvt7e3hAEAdnZ2TrLu3TpAm9vb7Rq1ara486bNw+PHz/Gxo0ba6zPy8sLb7zxBhYuXKg3n8NUGDCITKmiAlCr/wwWwJ9BQ63WrCdqAmxdanfNQG23qw8PDw+kpaUhLy9PJ2ScP38eZ86cQWpqqs4bfmpqKk6ePImsrCyD7c2ePRsSiQTr1q176rHbtWsHb29v7aNVq1Z45plndJbJZIZfe/v27fHSSy/hww8/RElJ3UZ4FAoFlixZgvfee08vVFW1dOlS/Pzzz9ixY0edjlFfDBhEpiKKgKgGJNX8mkkkmvUcxaAmwGWgLWzdZIBQzQYCoHC3gctAw5MYjcXd3R2pqanIz8+HUqlEUVERkpOT0adPHwwaNAg9e/bUPgYNGoSgoKBqJ3vK5XLExcVh/fr1Jq0ZADZu3AiVSoXAwECkpKTg0qVLyM7Oxr/+9S9kZWVBKpVWu++0adNgb2+Pbdu21XgMJycnzJs3zyyvB2DAIDItUfxz5KIqQWC4oCZDIhUwcJ2L5knVH/k/nr+41hkSaXUJxHjc3NyQmpqKu3fvQqlUYsuWLRgzZozBbceMGYMtW7agvLzc4PpJkyahS5cupiwXgOYURkZGBoYNG4aYmBj4+fkhMDAQGzZsQFRUFBISEqrd18bGBgkJCSgtLX3qcaKioqBQKIxZerUE0VwnY6xEUVER7O3tUVhYCDs7O0uXQ02ZKGomdAqC4ZBReUWJzKb6EEJkRqWlpcjJyUHnzp0hl8vr1Yah+2Ao3G3w4lpns9wHgxqupp+DuryH8kZbRKYiCIAg0UzoNDS8qVYDEinDBTUpXv/HHp1H2WmuKslVwdZFBpeBtmYZuSDrwoBBZEpSKQBRM5lTIvnztIj6j7kZNZxXJWqsJFIBHYeYZxierBcDBpEpCQIglQGo0EzoVKs1yyRS3StLiIiaGAYMIlMTBEAm053QyWBBRE0cAwaRuTBUGAeDGlGjwIBBRI1D5dyVJz/YSSL5c24LEVkVBgwisn7iHxNlK+8r8uRkWVHkfBYiK8QbbRGR9asMEk+OVgjCH3dDFXVHNYjIKjBgEJF1qwwQNd0RVc1brhNZGwYMImocagoYRGR1GDCIqHGoboSCIxcEICIiAqGhoTrLdu/eDblcjg8++EC7bPny5ZBKpXj//ff12ti8eTMEQUBISIjO8t9++w2CICA1NdUUpTdZDBhEZN2enGthSNW5GWRxFWrg5C1gX7bm3woLTJHZtGkTJkyYgL///e+YP3++dvknn3yCt99+G5988onB/WQyGb777jscOXLEXKU2WQwYRGT9KgPEk3MtnpybIWFXZi0OXAEGfAr83y+AOQc1/w74VLPcXFauXInZs2djx44dmDx5snZ5WloaHj9+jPj4eBQVFeHEiRN6+9ra2mLKlClYuHCh+QpuovhbSUTWTxA0l6I+edVI5cgFL1G1GgeuAP/vP0Buse7yvGLNcnOEjAULFiAhIQFfffUVRo8erbMuOTkZ48ePh42NDcaPH4/k5GSDbbzzzjs4f/48du/ebfqCmzAGDCJqHCpDhkz254PhwmpUqIG4NMDQiazKZXFppj1dcuDAAaxcuRL79u3D0KFDddYVFRVh9+7dCAsLAwCEhYVh586dKC4u1mvH1dUVc+fOxaJFi6BSqfTWU+0wYBBR41J5oy0GC6ty6lf9kYsnidCsP/Wr6Wrw9fWFp6cnYmNj9YLD9u3b4eXlBT8/PwCAv78/PDw8kJKSYrCtBQsWoKCgoNq5GvR0DBhERNRg+SXG3a4+OnbsiNTUVNy+fRshISF4+PChdl1ycjJ++uknyGQy7ePixYvVBggHBwfExMQgLi4Ojx49Ml3RTRgDBhERNdgztsbdrr48PDyQlpaGvLw8bcg4f/48zpw5g9TUVGRmZmofqampOHnyJLKysgy2NXv2bEgkEqxbt860RTdR/CwSIiJqsD6ugItCM6HT0DwMAYCzQrOdqbm7uyM1NRV/+ctfoFQq8dxzz6FPnz4YNGiQ3rZBQUFITk42eF8MuVyOuLg4zJo1y/RFN0EcwSAiogaTSoDYwZqvq86OqXweO1iznTm4ubkhNTUVeXl5+PLLLzF8+HCD240ZMwZbtmxBeXm5wfWTJk1Cly5dTFlqkyWIYvO6DV5RURHs7e1RWFgIOzs7S5dDRGQ1SktLkZOTg86dO0Mul9erjQNXNFeLPDnh00WhCRfDvY1UKJlUTT8HdXkP5SkSIiIymuHewMtdNFeL5Jdo5lz0cTXfyAVZDwYMIqrRk4OcAi8NpVqQSoB+bpaugiyNAYOIDBJFERB1AwYEzYNBg4iehgGDiPSIoghRrQkWT4aJytABCUMGEdWMZ8WISN8fgxZVQ4T2ebOaGk5E9cGAQUQ6RFGEKIrVjlAIgqDdhoioOgwYREREZHQMGERERGR0DBhEpEMQBO1pEEMqT59wkicR1YQBg4j0Vc7lrBIytM+ZLYjoKRgwiEiPIAgQJILOhE7tyIWEoxdUswqxAmcensHB+wdx5uEZVIgVJj9mREQEBEHAjBkz9NbNmjULgiAgIiJCu21oaGi1bXl6empH6WxtbREQEIBdu3aZqPKmiwGDiAzShomqD4YLqsHhB4fxyoVXMP3ydCy6tgjTL0/HKxdeweEHh01+bHd3d+zYsQOPHz/WListLcW2bdvQqVOnOrUVHx+P3NxcZGRkICgoCOPGjcOJEyeMXXKTxoBBRDWq/EuOwYKe5vCDw4jOiUZ+eb7O8vzyfETnRJs8ZAQEBMDd3R179uzRLtuzZw86deqEXr161amtNm3awNnZGc8++yySkpLQqlUr/Pvf/zZ2yU0aAwYRETVYhViB92+9X+M2q26tMvnpkilTpuDTTz/VPv/kk08wefLkBrUpk8lgY2ODsrKyhpbXrDBgEBFRg2UUZ+iNXFR1p/wOMoozTFpHWFgYjh07huvXr+P69es4fvw4wsLC6t1eWVkZli9fjsLCQgQHBxux0qaPn0VCREQNdrf8rlG3q68OHTpgxIgR2Lx5M0RRxIgRI+Do6FjndhYsWIDFixejtLQUCoUCiYmJGDFihAkqbroYMIiIqMEcbWr3Jl7b7RpiypQpiIyMBAAkJSXVq43o6GhERERAoVDAycmJc5DqgQGDiIgarJeiF56xeabG0yRONk7opajbZMv6CAkJQVlZGQRBgFKprFcbjo6O8Pb2NnJlzQsDBhERNZhUkCLaLRrROdEG1wsQEOUWBakgNX0tUikuXbqk/dqQwsJCZGZm6ixr37493N3dTV1es8GAQURERhHcNhjv4328f+t9nZEMJxsnRLlFIbit+SZJ2tnZ1bg+NTVV79LVqVOnYtOmTaYsq1kRxGb2mctFRUWwt7dHYWHhU38AiYiak9LSUuTk5KBz586Qy+X1bqdCrEBGcQbult+Fo40jeil6mWXkgoyjpp+DuryHcgSDiIiMSipIEdgm0NJlkIXxPhhERERkdAwYREREZHQMGERERGR0DBhERKSjmc39pyqM9f/PgEFERAAAGxsbAMCjR48sXAlZUuWHulV3D5Ha4lUkREQEQPOG4uDggPx8zT0sWrduzVtkNzNqtRoFBQVo3bo1ZLKGRQQGDCIi0nJ2dgYAbcig5kcikaBTp04NDpcMGEREpCUIAlxcXPDMM8+gvLzc0uWQBbRo0QISScNnUDBgEBGRHqlU2uBz8NS8WcUkz6SkJHh6ekIul+OFF17AqVOnatx+165deO655yCXy+Hj44Ovv/7aTJUSERFRbVg8YKSkpGDevHmIjY1Feno6/Pz8oFQqqz3/d+LECYwfPx5Tp05FRkYGQkNDERoaigsXLpi5ciIiIqqOxT/s7IUXXkBQUBA+/PBDAJoZrO7u7pg9ezYWLlyot/24ceNQUlKCr776Srusb9++8Pf3x0cfffTU4/HDzoiIiOqn0XzYWVlZGc6ePYuYmBjtMolEgmHDhuHkyZMG9zl58iTmzZuns0ypVGLv3r0Gt//999/x+++/a58XFhYC0HyTiIiIqPYq3ztrMzZh0YBx9+5dVFRUwMnJSWe5k5MTsrKyDO6Tl5dncPu8vDyD2y9fvhxxcXF6y93d3etZNRERUfP28OFD2Nvb17hNk7+KJCYmRmfEQ61W4/79+2jfvn2dr/ENCgrC6dOn61xDXfYrKiqCu7s7bt68yVM4DVDf/ytrYQ31m6sGUx3HWO02pB32GY2HNfzONYS56hdFEQ8fPoSrq+tTt7VowHB0dIRUKsWdO3d0lt+5c0d7s5eqnJ2d67R9y5Yt0bJlS51lDg4O9apXKpXW6xe4PvvZ2dmxs2iA+v5fWQtrqN9cNZjqOMZqtyHtsM9oPKzhd64hzFn/00YuKln0KpIWLVqgd+/eOHTokHaZWq3GoUOH0K9fP4P79OvXT2d7APj222+r3d6YZs2aZdb9qP4a+/fcGuo3Vw2mOo6x2m1IO+wzGo/G/j23xvotfhVJSkoKJk2ahI8//hh9+vTB2rVrsXPnTmRlZcHJyQnh4eHo2LEjli9fDkBzmergwYORmJiIESNGYMeOHVi2bBnS09PRs2dPS74Uo+BVLkRUF+wzyFpZfA7GuHHjUFBQgKVLlyIvLw/+/v44ePCgdiLnjRs3dG5Z2r9/f2zbtg2LFy/G3/72N3Tt2hV79+5tEuEC0JzSiY2N1TutQ0RkCPsMslYWH8EgIiKipsfid/IkIiKipocBg4iIiIyOAYOIiIiMjgGDiIiIjI4Bg4iIiIyOAcPK8SIfIqqNyr6CfQZZCwYMK3Tv3j0kJyejsLAQgiCwwyCiGt25cwdTpkxBcXGxpUsh0rL4jbZI36JFi/Dtt9/izp07mDFjBtq1awe1Wq1zwzEiIgDIz8/H+PHjERwcDIVCYelyiLT4jmWFRo8ejaFDh6Jly5ZYt24dysvLGS6ISM+jR48QHByM4OBgLF68GABw5coV3L59G2q12sLVUXPHdy0r5ObmhoKCAnh5eQEA4uLisHDhQuTn56OiosLC1RGRtWjdujUCAgKQnp4OAJg4cSJiYmIwYsQIJCUlITc318IVUnPGgGFlRFHE888/j86dOyM0NBRDhgzBxx9/jNOnT6Nt27aQSqWWLpGIrEDlCMWWLVvQtm1btG7dGq1atcKuXbuwfv16pKWl4aeffrJwldSc8bNIrNSSJUvg4uKCLVu2wMvLC97e3lCr1Vi0aBHkcrmlyyMiK1BRUaH9o2Pz5s147bXXtPMw4uLi4OjoaJUf403NA0cwrMCT50orT4H0798fH3/8MV566SVs3boVQ4cOxahRoxguiEjbZ0ilUqhUKgBARESENlxkZ2fjiy++0J5mJbIEjmBYmEqlgkymuZinpKQEpaWlaN++PR49eoT09HS8+OKLAMCrSIgIQPV9RqULFy5g9OjRWLJkCcLDwy1VJhEDhiU9GRrGjx+PW7du4cKFC5gwYYL2ShIAKCsrQ4sWLSxZKhFZger6jPDwcAwfPhwhISEoLCzE2bNnERwcDEAzr0sQBEuWTc0UA4YVePXVV3H79m28/fbbyM/Px7Zt2yCKIsLCwhAZGQmAIxhE9CdDfYZarcbEiRN1+gxBEBguyGJ4oy0Lu3z5Mm7evIlNmzahd+/eAIAhQ4bgn//8JzZu3AiJRIKZM2cyXBARAPYZ1HjwJ9DCZDIZfvnlF1y5ckW7zMfHB3PnzkVwcDC2bduGtLQ0C1ZIRNaEfQY1FgwYZlT1bJQoimjTpg0CAgJw+vRpnc8R8PLywhtvvIEHDx6wsyBqpthnUGPGgGEmKpVKey700aNHAABBEODo6IiwsDCsWbMGKSkpOh2Kn58fhg8fjl27dqG0tNQidRORZbDPoMaOczDMQK1Way8rmzx5Mnx8fPDGG2+gTZs2AICpU6fi+vXrmDlzJioqKjBu3DjY29sDABQKBbp16wYbGxuL1U9E5sU+g5oCBgwzqJxsNWnSJHz++eeQy+Vo2bIlJk2apL0xTnx8PKRSKWbOnIn09HR07doVTk5OWL16Nd577z3eIpyoGWGfQU0BA4aZHDlyBNeuXUNaWhoOHz6MOXPmQBRFnbvvxcbGwtvbG3v37sV//vMfdOnSBYsXL8bs2bMB8Hp2ouaEfQY1dgwYZuLm5oaIiAj07NkTAwcOBADMnTsXgOavlMqhzwkTJmDs2LEoKSmBSqWCo6MjAN4Hg6i5YZ9BjR0Dhpl07doVHh4e2jtyxsbGAvizw5g8eTJsbW2Rnp4OhUKBZ599VruvKIrsKIiaGfYZ1NgxYJhRZUdR+ZfFkx2GVCqFnZ0d3nrrLfzjH//Q6Sw4xEnUPLHPoMaMAcMCJBKJTochk8m0H6m8ePFihIaGWrZAIrIq7DOoMWLAsJAnO4zKT0xdt26ddnIWz58S0ZPYZ1Bjww87s7CLFy/C19cXb7/9NpYtWwaAHQURVY99BjUWDBgWdu/ePZw/fx5DhgwBwI6CiGrGPoMaCwYMK8KOgojqgn0GWTMGDCIiIjI6Rl8iIiIyOgYMIiIiMjoGDCIiIjI6BgwiIiIyOgYMIiIiMjoGDCIiIjI6BgwiIiIyOgYMIiIiMjoGDKIm6tq1axAEAZmZmZYuRSsrKwt9+/aFXC6Hv7+/pcshIhNiwCAykYiICAiCgMTERJ3le/fuhSAIFqrKsmJjY2Fra4vs7GwcOnTI0uWYlaenJ9auXWvpMojMhgGDyITkcjlWrFiBBw8eWLoUoykrK6v3vlevXsWLL74IDw8PtG/f3ohV1UwURahUKrMdz5Qa8v0nMicGDCITGjZsGJydnbF8+fJqt3nnnXf0ThesXbsWnp6e2ucREREIDQ3FsmXL4OTkBAcHB8THx0OlUiE6Ohrt2rWDm5sbPv30U732s7Ky0L9/f8jlcvTs2RNpaWk66y9cuIDhw4dDoVDAyckJEydOxN27d7XrhwwZgsjISLz55ptwdHSEUqk0+DrUajXi4+Ph5uaGli1bwt/fHwcPHtSuFwQBZ8+eRXx8PARBwDvvvGOwncrjRUZGwt7eHo6OjliyZAme/Nikzz//HIGBgWjTpg2cnZ3x+uuvIz8/X7s+NTUVgiDgwIED6N27N1q2bIljx47h6tWrGDVqFJycnKBQKBAUFITvvvtO5/ienp549913ER4eDoVCAQ8PD+zfvx8FBQUYNWoUFAoFfH19cebMGZ39jh07hoEDB6JVq1Zwd3fHnDlzUFJSon1N169fx1tvvQVBEHRGsGrar7KehIQEhIeHw87ODtOmTUNZWRkiIyPh4uICuVwODw+PGn/GiCyBAYPIhKRSKZYtW4YNGzbg1q1bDWrr8OHD+PXXX/H9999j9erViI2NxSuvvIK2bdvihx9+wIwZMzB9+nS940RHR2P+/PnIyMhAv379MHLkSNy7dw8A8NtvvyE4OBi9evXCmTNncPDgQdy5cwdjx47VaeOzzz5DixYtcPz4cXz00UcG61u3bh0++OADrFq1Cj/++COUSiVeffVVXL58GQCQm5uLHj16YP78+cjNzUVUVFS1r/Wzzz6DTCbDqVOnsG7dOqxevRqbNm3Sri8vL0dCQgLOnTuHvXv34tq1a4iIiNBrZ+HChUhMTMSlS5fg6+uL4uJi/PWvf8WhQ4eQkZGBkJAQjBw5Ejdu3NDZb82aNRgwYAAyMjIwYsQITJw4EeHh4QgLC0N6ejq8vLwQHh6uDT1Xr15FSEgIxowZgx9//BEpKSk4duwYIiMjAQB79uyBm5sb4uPjkZubi9zc3FrtV2nVqlXw8/NDRkYGlixZgvXr12P//v3YuXMnsrOzsXXrVp1ASmQVRCIyiUmTJomjRo0SRVEU+/btK06ZMkUURVH88ssvxSd/9WJjY0U/Pz+dfdesWSN6eHjotOXh4SFWVFRol3Xr1k0cOHCg9rlKpRJtbW3F7du3i6Ioijk5OSIAMTExUbtNeXm56ObmJq5YsUIURVFMSEgQX375ZZ1j37x5UwQgZmdni6IoioMHDxZ79er11Nfr6uoqvvfeezrLgoKCxJkzZ2qf+/n5ibGxsTW2M3jwYLF79+6iWq3WLluwYIHYvXv3avc5ffq0CEB8+PChKIqieOTIERGAuHfv3qfW3aNHD3HDhg3a5x4eHmJYWJj2eW5urghAXLJkiXbZyZMnRQBibm6uKIqiOHXqVHHatGk67R49elSUSCTi48ePte2uWbNGZ5va7hcaGqqzzezZs8Xg4GCd7xGRteEIBpEZrFixAp999hkuXbpU7zZ69OgBieTPX1knJyf4+Phon0ulUrRv317nVAEA9OvXT/u1TCZDYGCgto5z587hyJEjUCgU2sdzzz0HQPPXdaXevXvXWFtRURF+/fVXDBgwQGf5gAED6vWa+/btq3MaoV+/frh8+TIqKioAAGfPnsXIkSPRqVMntGnTBoMHDwYAvZGIwMBAnefFxcWIiopC9+7d4eDgAIVCgUuXLunt5+vrq/3ayckJAHS+15XLKr/X586dw+bNm3W+j0qlEmq1Gjk5OdW+ztruV/V1REREIDMzE926dcOcOXPwzTffVHsMIkuRWboAouZg0KBBUCqViImJ0RvKl0gkOvMLAM0pgKpsbGx0nguCYHCZWq2udV3FxcUYOXIkVqxYobfOxcVF+7WtrW2t2zS1kpISKJVKKJVKbN26FR06dMCNGzegVCr1JkBWrTsqKgrffvstVq1aBW9vb7Rq1Qqvvfaa3n5Pfl8rg46hZZXf6+LiYkyfPh1z5szRq7dTp07Vvpba7lf1dQQEBCAnJwcHDhzAd999h7Fjx2LYsGHYvXt3tcciMjcGDCIzSUxMhL+/P7p166azvEOHDsjLy4Moito3LmPeu+J///sfBg0aBABQqVQ4e/as9hx/QEAAvvjiC3h6ekImq393YGdnB1dXVxw/flw7mgAAx48fR58+ferc3g8//KD3Grp27QqpVIqsrCzcu3cPiYmJcHd3BwC9CZfVOX78OCIiIjB69GgAmjf4a9eu1bm+qgICAnDx4kV4e3tXu02LFi20IzB12a86dnZ2GDduHMaNG4fXXnsNISEhuH//Ptq1a1fntohMgadIiMzEx8cHEyZMwPr163WWDxkyBAUFBVi5ciWuXr2KpKQkHDhwwGjHTUpKwpdffomsrCzMmjULDx48wJQpUwAAs2bNwv379zF+/HicPn0aV69exX//+19MnjxZ783waaKjo7FixQqkpKQgOzsbCxcuRGZmJubOnVvnmm/cuIF58+YhOzsb27dvx4YNG7TtdOrUCS1atMCGDRvwyy+/YP/+/UhISKhVu127dsWePXuQmZmJc+fO4fXXX6/TiE91FixYgBMnTiAyMhKZmZm4fPky9u3bpzNZ09PTE99//z1u376tvUqnNvsZsnr1amzfvh1ZWVn4+eefsWvXLjg7O8PBwaHBr4XIWBgwiMwoPj5e7w2te/fu2LhxI5KSkuDn54dTp07VeIVFXSUmJiIxMRF+fn44duwY9u/fD0dHRwDQjjpUVFTg5Zdfho+PD9588004ODjozPeojTlz5mDevHmYP38+fHx8cPDgQezfvx9du3atc83h4eF4/Pgx+vTpg1mzZmHu3LmYNm0aAM2Iz+bNm7Fr1y48//zzSExMxKpVq2rV7urVq9G2bVv0798fI0eOhFKpREBAQJ3rq8rX1xdpaWn4+eefMXDgQPTq1QtLly6Fq6urdpv4+Hhcu3YNXl5e6NChQ633M6RNmzZYuXIlAgMDERQUhGvXruHrr7+u8/8ZkSkJYtWTv0REFjRkyBD4+/vzrpdEjRzjLhERERkdAwYREREZHU+REBERkdFxBIOIiIiMjgGDiIiIjI4Bg4iIiIyOAYOIiIiMjgGDiIiIjI4Bg4iIiIyOAYOIiIiMjgGDiIiIjO7/A//SDM+ivBzwAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Cora\",\n", + " input_embed_only=True,\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Citeseer\",\n", + " input_embed_only=True,\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Pubmed\",\n", + " input_embed_only=True,\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Cornell\",\n", + " input_embed_only=True,\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Texas\",\n", + " input_embed_only=True,\n", + ")\n", + "plot_parameter_efficiency(\n", + " result_GNN=result_GNN,\n", + " result_KANGNN=result_KANGNN,\n", + " result_KAN=result_KAN,\n", + " result_MLP=result_MLP,\n", + " dataset=\"Wisconsin\",\n", + " input_embed_only=True,\n", + ")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.2" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/src/efficient_kan/__init__.py b/src/efficient_kan/__init__.py new file mode 100644 index 0000000..b2089bf --- /dev/null +++ b/src/efficient_kan/__init__.py @@ -0,0 +1,3 @@ +from .kan import KANLinear, KAN + +__all__ = ["KANLinear", "KAN"] diff --git a/src/efficient_kan/__pycache__/__init__.cpython-312.pyc b/src/efficient_kan/__pycache__/__init__.cpython-312.pyc new file mode 100644 index 0000000..379cd75 Binary files /dev/null and b/src/efficient_kan/__pycache__/__init__.cpython-312.pyc differ diff --git a/src/efficient_kan/__pycache__/kan.cpython-312.pyc b/src/efficient_kan/__pycache__/kan.cpython-312.pyc new file mode 100644 index 0000000..a351a2e Binary files /dev/null and b/src/efficient_kan/__pycache__/kan.cpython-312.pyc differ diff --git a/src/efficient_kan/kan.py b/src/efficient_kan/kan.py new file mode 100644 index 0000000..7d36495 --- /dev/null +++ b/src/efficient_kan/kan.py @@ -0,0 +1,280 @@ +import torch +import torch.nn.functional as F +import math + + +class KANLinear(torch.nn.Module): + def __init__( + self, + in_features, + out_features, + grid_size=5, + spline_order=3, + scale_noise=0.1, + scale_base=1.0, + scale_spline=1.0, + enable_standalone_scale_spline=True, + base_activation=torch.nn.SiLU, + grid_eps=0.02, + grid_range=[-1, 1], + ): + super(KANLinear, self).__init__() + self.in_features = in_features + self.out_features = out_features + self.grid_size = grid_size + self.spline_order = spline_order + + h = (grid_range[1] - grid_range[0]) / grid_size + grid = ( + ( + torch.arange(-spline_order, grid_size + spline_order + 1) * h + + grid_range[0] + ) + .expand(in_features, -1) + .contiguous() + ) + self.register_buffer("grid", grid) + + self.base_weight = torch.nn.Parameter(torch.Tensor(out_features, in_features)) + self.spline_weight = torch.nn.Parameter( + torch.Tensor(out_features, in_features, grid_size + spline_order) + ) + if enable_standalone_scale_spline: + self.spline_scaler = torch.nn.Parameter( + torch.Tensor(out_features, in_features) + ) + + self.scale_noise = scale_noise + self.scale_base = scale_base + self.scale_spline = scale_spline + self.enable_standalone_scale_spline = enable_standalone_scale_spline + self.base_activation = base_activation() + self.grid_eps = grid_eps + + self.reset_parameters() + + def reset_parameters(self): + torch.nn.init.kaiming_uniform_(self.base_weight, a=math.sqrt(5) * self.scale_base) + with torch.no_grad(): + noise = ( + ( + torch.rand(self.grid_size + 1, self.in_features, self.out_features) + - 1 / 2 + ) + * self.scale_noise + / self.grid_size + ) + self.spline_weight.data.copy_( + (self.scale_spline if not self.enable_standalone_scale_spline else 1.0) + * self.curve2coeff( + self.grid.T[self.spline_order : -self.spline_order], + noise, + ) + ) + if self.enable_standalone_scale_spline: + # torch.nn.init.constant_(self.spline_scaler, self.scale_spline) + torch.nn.init.kaiming_uniform_(self.spline_scaler, a=math.sqrt(5) * self.scale_spline) + + def b_splines(self, x: torch.Tensor): + """ + Compute the B-spline bases for the given input tensor. + + Args: + x (torch.Tensor): Input tensor of shape (batch_size, in_features). + + Returns: + torch.Tensor: B-spline bases tensor of shape (batch_size, in_features, grid_size + spline_order). + """ + assert x.dim() == 2 and x.size(1) == self.in_features + + grid: torch.Tensor = ( + self.grid + ) # (in_features, grid_size + 2 * spline_order + 1) + x = x.unsqueeze(-1) + bases = ((x >= grid[:, :-1]) & (x < grid[:, 1:])).to(x.dtype) + for k in range(1, self.spline_order + 1): + bases = ( + (x - grid[:, : -(k + 1)]) + / (grid[:, k:-1] - grid[:, : -(k + 1)]) + * bases[:, :, :-1] + ) + ( + (grid[:, k + 1 :] - x) + / (grid[:, k + 1 :] - grid[:, 1:(-k)]) + * bases[:, :, 1:] + ) + + assert bases.size() == ( + x.size(0), + self.in_features, + self.grid_size + self.spline_order, + ) + return bases.contiguous() + + def curve2coeff(self, x: torch.Tensor, y: torch.Tensor): + """ + Compute the coefficients of the curve that interpolates the given points. + + Args: + x (torch.Tensor): Input tensor of shape (batch_size, in_features). + y (torch.Tensor): Output tensor of shape (batch_size, in_features, out_features). + + Returns: + torch.Tensor: Coefficients tensor of shape (out_features, in_features, grid_size + spline_order). + """ + assert x.dim() == 2 and x.size(1) == self.in_features + assert y.size() == (x.size(0), self.in_features, self.out_features) + + A = self.b_splines(x).transpose( + 0, 1 + ) # (in_features, batch_size, grid_size + spline_order) + B = y.transpose(0, 1) # (in_features, batch_size, out_features) + solution = torch.linalg.lstsq( + A, B + ).solution # (in_features, grid_size + spline_order, out_features) + result = solution.permute( + 2, 0, 1 + ) # (out_features, in_features, grid_size + spline_order) + + assert result.size() == ( + self.out_features, + self.in_features, + self.grid_size + self.spline_order, + ) + return result.contiguous() + + @property + def scaled_spline_weight(self): + return self.spline_weight * ( + self.spline_scaler.unsqueeze(-1) + if self.enable_standalone_scale_spline + else 1.0 + ) + + def forward(self, x: torch.Tensor): + assert x.dim() == 2 and x.size(1) == self.in_features + + base_output = F.linear(self.base_activation(x), self.base_weight) + spline_output = F.linear( + self.b_splines(x).view(x.size(0), -1), + self.scaled_spline_weight.view(self.out_features, -1), + ) + return base_output + spline_output + + @torch.no_grad() + def update_grid(self, x: torch.Tensor, margin=0.01): + assert x.dim() == 2 and x.size(1) == self.in_features + batch = x.size(0) + + splines = self.b_splines(x) # (batch, in, coeff) + splines = splines.permute(1, 0, 2) # (in, batch, coeff) + orig_coeff = self.scaled_spline_weight # (out, in, coeff) + orig_coeff = orig_coeff.permute(1, 2, 0) # (in, coeff, out) + unreduced_spline_output = torch.bmm(splines, orig_coeff) # (in, batch, out) + unreduced_spline_output = unreduced_spline_output.permute( + 1, 0, 2 + ) # (batch, in, out) + + # sort each channel individually to collect data distribution + x_sorted = torch.sort(x, dim=0)[0] + grid_adaptive = x_sorted[ + torch.linspace( + 0, batch - 1, self.grid_size + 1, dtype=torch.int64, device=x.device + ) + ] + + uniform_step = (x_sorted[-1] - x_sorted[0] + 2 * margin) / self.grid_size + grid_uniform = ( + torch.arange( + self.grid_size + 1, dtype=torch.float32, device=x.device + ).unsqueeze(1) + * uniform_step + + x_sorted[0] + - margin + ) + + grid = self.grid_eps * grid_uniform + (1 - self.grid_eps) * grid_adaptive + grid = torch.concatenate( + [ + grid[:1] + - uniform_step + * torch.arange(self.spline_order, 0, -1, device=x.device).unsqueeze(1), + grid, + grid[-1:] + + uniform_step + * torch.arange(1, self.spline_order + 1, device=x.device).unsqueeze(1), + ], + dim=0, + ) + + self.grid.copy_(grid.T) + self.spline_weight.data.copy_(self.curve2coeff(x, unreduced_spline_output)) + + def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0): + """ + Compute the regularization loss. + + This is a dumb simulation of the original L1 regularization as stated in the + paper, since the original one requires computing absolutes and entropy from the + expanded (batch, in_features, out_features) intermediate tensor, which is hidden + behind the F.linear function if we want an memory efficient implementation. + + The L1 regularization is now computed as mean absolute value of the spline + weights. The authors implementation also includes this term in addition to the + sample-based regularization. + """ + l1_fake = self.spline_weight.abs().mean(-1) + regularization_loss_activation = l1_fake.sum() + p = l1_fake / regularization_loss_activation + regularization_loss_entropy = -torch.sum(p * p.log()) + return ( + regularize_activation * regularization_loss_activation + + regularize_entropy * regularization_loss_entropy + ) + + +class KAN(torch.nn.Module): + def __init__( + self, + layers_hidden, + grid_size=5, + spline_order=3, + scale_noise=0.1, + scale_base=1.0, + scale_spline=1.0, + base_activation=torch.nn.SiLU, + grid_eps=0.02, + grid_range=[-1, 1], + ): + super(KAN, self).__init__() + self.grid_size = grid_size + self.spline_order = spline_order + + self.layers = torch.nn.ModuleList() + for in_features, out_features in zip(layers_hidden, layers_hidden[1:]): + self.layers.append( + KANLinear( + in_features, + out_features, + grid_size=grid_size, + spline_order=spline_order, + scale_noise=scale_noise, + scale_base=scale_base, + scale_spline=scale_spline, + base_activation=base_activation, + grid_eps=grid_eps, + grid_range=grid_range, + ) + ) + + def forward(self, x: torch.Tensor, update_grid=False): + for layer in self.layers: + if update_grid: + layer.update_grid(x) + x = layer(x) + return x + + def regularization_loss(self, regularize_activation=1.0, regularize_entropy=1.0): + return sum( + layer.regularization_loss(regularize_activation, regularize_entropy) + for layer in self.layers + ) diff --git a/utils.py b/utils.py new file mode 100644 index 0000000..3e0e9f4 --- /dev/null +++ b/utils.py @@ -0,0 +1,33 @@ +import torch +import numpy as np + + +def index_to_mask(index, size): + mask = torch.zeros(size, dtype=torch.bool, device=index.device) + mask[index] = 1 + return mask + + +def random_disassortative_splits(labels, num_classes, trn_percent=0.6, val_percent=0.2): + # * 0.6 labels for training + # * 0.2 labels for validation + # * 0.2 labels for testing + labels, num_classes = labels.cpu(), num_classes.cpu().numpy() + indices = [] + for i in range(num_classes): + index = torch.nonzero((labels == i)).view(-1) + index = index[torch.randperm(index.size(0))] + indices.append(index) + + percls_trn = int(round(trn_percent * (labels.size()[0] / num_classes))) + val_lb = int(round(val_percent * labels.size()[0])) + train_index = torch.cat([i[:percls_trn] for i in indices], dim=0) + + rest_index = torch.cat([i[percls_trn:] for i in indices], dim=0) + rest_index = rest_index[torch.randperm(rest_index.size(0))] + + train_mask = index_to_mask(train_index, size=labels.size()[0]) + val_mask = index_to_mask(rest_index[:val_lb], size=labels.size()[0]) + test_mask = index_to_mask(rest_index[val_lb:], size=labels.size()[0]) + + return train_mask, val_mask, test_mask