{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Lorentz-Equivariant GNN\n",
"\n",
"Now we will look at graph neural networks using the PyTorch Geometric library: . See {cite:p}`PyTorchGeometric` for more details."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# For Colab\n",
"!pip install torch_geometric\n",
"!pip install torch_sparse\n",
"!pip install torch_scatter"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"import torch\n",
"import torch_geometric\n",
"\n",
"device = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
"from tqdm.notebook import tqdm\n",
"import numpy as np\n",
"\n",
"local = False"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# For Colab\n",
"\n",
"!pip install wget\n",
"import wget\n",
"\n",
"!pip install -U PyYAML\n",
"!pip install uproot\n",
"!pip install awkward\n",
"!pip install mplhep"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [],
"source": [
"import yaml\n",
"import os.path\n",
"\n",
"# WGET for colab\n",
"if not os.path.exists(\"definitions_lorentz.yml\"):\n",
" url = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/definitions_lorentz.yml\"\n",
" definitionsFile = wget.download(url)\n",
"\n",
"with open(\"definitions_lorentz.yml\") as file:\n",
" # The FullLoader parameter handles the conversion from YAML\n",
" # scalar values to Python the dictionary format\n",
" definitions = yaml.load(file, Loader=yaml.FullLoader)\n",
"\n",
"features = definitions[\"features\"]\n",
"spectators = definitions[\"spectators\"]\n",
"labels = definitions[\"labels\"]\n",
"\n",
"nfeatures = definitions[\"nfeatures\"]\n",
"nspectators = definitions[\"nspectators\"]\n",
"nlabels = definitions[\"nlabels\"]\n",
"ntracks = definitions[\"ntracks\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Graph datasets\n",
"Here we have to define the graph dataset. We do this in a separate class following this example: https://pytorch-geometric.readthedocs.io/en/latest/notes/create_dataset.html#creating-larger-datasets\n",
"\n",
"Formally, a graph is represented by a triplet $\\mathcal G = (\\mathbf{u}, V, E)$, consisting of a graph-level, or *global*, feature vector $\\mathbf{u}$, a set of $N^v$ nodes $V$, and a set of $N^e$ edges $E$.\n",
"The nodes are given by $V = \\{\\mathbf{v}_i\\}_{i=1:N^v}$, where $\\mathbf{v}_i$ represents the $i$th node's attributes.\n",
"The edges connect pairs of nodes and are given by $E = \\{\\left(\\mathbf{e}_k, r_k, s_k\\right)\\}_{k=1:N^e}$, where $\\mathbf{e}_k$ represents the $k$th edge's attributes, and $r_k$ and $s_k$ are the indices of the \"receiver\" and \n",
"\"sender\" nodes, respectively, connected by the $k$th edge (from the sender node to the receiver node).\n",
"The receiver and sender index vectors are an alternative way of encoding the directed adjacency matrix.\n",
"\n",
"
"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"Processing...\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "51eb09799508446ab490fb88420cc6d3",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/8000 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/Users/wmccorma/IAIFI_Summer_School_2022/iaifi-summer-school-PATRICK/book/LorentzGraphDataset.py:153: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at /Users/distiller/project/conda/conda-bld/pytorch_1646756029501/work/torch/csrc/utils/tensor_new.cpp:210.)\n",
" x = torch.tensor(fourvec, dtype=torch.float).T\n",
"Done!\n",
"Processing...\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "85319282abd04bd881fe887ee3782bb1",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/2000 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"['track_pt', 'track_mass', 'track_ptrel', 'track_erel', 'track_etarel', 'track_phirel']\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"Done!\n"
]
}
],
"source": [
"# If in colab\n",
"if not os.path.exists(\"LorentzGraphDataset.py\"):\n",
" urlDSD = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/LorentzGraphDataset.py\"\n",
" DSD = wget.download(urlDSD)\n",
"if not os.path.exists(\"utils.py\"):\n",
" urlUtils = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/utils.py\"\n",
" utils = wget.download(urlUtils)\n",
"\n",
"\n",
"from LorentzGraphDataset import LorentzGraphDataset\n",
"\n",
"# For Colab\n",
"if not os.path.exists(\"ntuple_merged_90.root\"):\n",
" urlFILE = \"http://opendata.cern.ch/eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/train/ntuple_merged_90.root\"\n",
" dataFILE = wget.download(urlFILE)\n",
"file_names = [\"ntuple_merged_90.root\"]\n",
"\n",
"##If you pulled github locally\n",
"# if local:\n",
"# file_names = [\n",
"# \"/teams/DSC180A_FA20_A00/b06particlephysics/train/ntuple_merged_10.root\"\n",
"# ]\n",
"# file_names_test = [\n",
"# \"/teams/DSC180A_FA20_A00/b06particlephysics/test/ntuple_merged_0.root\"\n",
"# ]\n",
"# else:\n",
"# file_names = [\n",
"# \"root://eospublic.cern.ch//eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/train/ntuple_merged_10.root\"\n",
"# ]\n",
"# file_names_test = [\n",
"# \"root://eospublic.cern.ch//eos/opendata/cms/datascience/HiggsToBBNtupleProducerTool/HiggsToBBNTuple_HiggsToBB_QCD_RunII_13TeV_MC/test/ntuple_merged_0.root\"\n",
"# ]\n",
"\n",
"graph_dataset = LorentzGraphDataset(\n",
" \"ldata_train\",\n",
" features,\n",
" labels,\n",
" spectators,\n",
" start_event=0,\n",
" stop_event=8000,\n",
" n_events_merge=1,\n",
" file_names=file_names,\n",
")\n",
"\n",
"test_dataset = LorentzGraphDataset(\n",
" \"ldata_test\",\n",
" features,\n",
" labels,\n",
" spectators,\n",
" start_event=8001,\n",
" stop_event=10001,\n",
" n_events_merge=1,\n",
" file_names=file_names,\n",
")\n",
"print(test_dataset.features)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Graph neural network\n",
"\n",
"Here, we recapitulate the \"graph network\" (GN) formalism {cite:p}`battaglia2018relational`, which generalizes various GNNs and other similar methods.\n",
"GNs are graph-to-graph mappings, whose output graphs have the same node and edge structure as the input. \n",
"Formally, a GN block contains three \"update\" functions, $\\phi$, and three \"aggregation\" functions, $\\rho$.\n",
"The stages of processing in a single GN block are:\n",
"\n",
"$\n",
"\\begin{align}\n",
" \\mathbf{e}'_k &= \\phi^e\\left(\\mathbf{e}_k, \\mathbf{v}_{r_k}, \\mathbf{v}_{s_k}, \\mathbf{u} \\right) & \\mathbf{\\bar{e}}'_i &= \\rho^{e \\rightarrow v}\\left(E'_i\\right) & \\text{(Edge block),}\\\\\n",
" \\mathbf{v}'_i &= \\phi^v\\left(\\mathbf{\\bar{e}}'_i, \\mathbf{v}_i, \\mathbf{u}\\right) & \n",
" \\mathbf{\\bar{e}}' &= \\rho^{e \\rightarrow u}\\left(E'\\right) & \\text{(Node block),}\\\\\n",
" \\mathbf{u}' &= \\phi^u\\left(\\mathbf{\\bar{e}}', \\mathbf{\\bar{v}}', \\mathbf{u}\\right) & \n",
" \\mathbf{\\bar{v}}' &= \\rho^{v \\rightarrow u}\\left(V'\\right) &\\text{(Global block).}\n",
" \\label{eq:gn-functions}\n",
"\\end{align}\n",
"$\n",
"\n",
"where $E'_i = \\left\\{\\left(\\mathbf{e}'_k, r_k, s_k \\right)\\right\\}_{r_k=i,\\; k=1:N^e}$ contains the updated edge features for edges whose receiver node is the $i$th node, $E' = \\bigcup_i E_i' = \\left\\{\\left(\\mathbf{e}'_k, r_k, s_k \\right)\\right\\}_{k=1:N^e}$ is the set of updated edges, and $V'=\\left\\{\\mathbf{v}'_i\\right\\}_{i=1:N^v}$ is the set of updated nodes.\n",
"\n",
"
\n",
"\n",
"We will define an interaction network model similar to Ref. {cite:p}`Moreno:2019neq`, but just modeling the particle-particle interactions. It will take as input all of the tracks (with 48 features) without truncating or zero-padding. Another modification is the use of batch normalization {cite:p}`bn` layers to improve the stability of the training."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [],
"source": [
"import torch.nn as nn\n",
"import torch.nn.functional as F\n",
"import torch_geometric.transforms as T\n",
"from torch_geometric.nn import EdgeConv, global_mean_pool\n",
"from torch.nn import Sequential as Seq, Linear as Lin, ReLU, BatchNorm1d\n",
"from torch_scatter import scatter_mean\n",
"from torch_geometric.nn import MetaLayer\n",
"\n",
"hidden = 16\n",
"outputs = 2\n",
"\n",
"\n",
"class LorentzEdgeBlock(torch.nn.Module):\n",
" def __init__(self):\n",
" super(LorentzEdgeBlock, self).__init__()\n",
" self.edge_mlp = Seq(Lin(4, hidden), ReLU(), Lin(hidden, hidden))\n",
" self.minkowski = torch.from_numpy(\n",
" np.array(\n",
" [\n",
" [-1.0, 0.0, 0.0, 0.0],\n",
" [0.0, 1.0, 0.0, 0.0],\n",
" [0.0, 0.0, 1.0, 0.0],\n",
" [0.0, 0.0, 0.0, 1.0],\n",
" ],\n",
" dtype=np.float32,\n",
" )\n",
" )\n",
"\n",
" def psi(self, x):\n",
" return torch.sign(x) * torch.log(torch.abs(x) + 1)\n",
"\n",
" def innerprod(self, x1, x2):\n",
" return torch.sum(\n",
" torch.mul(torch.matmul(x1, self.minkowski), x2), 1, keepdim=True\n",
" )\n",
"\n",
" def forward(self, src, dest, edge_attr, u, batch):\n",
" out = torch.cat(\n",
" [\n",
" self.innerprod(src, src),\n",
" self.innerprod(src, dest),\n",
" self.psi(self.innerprod(dest, dest)),\n",
" self.psi(self.innerprod(src - dest, src - dest)),\n",
" ],\n",
" dim=1,\n",
" )\n",
" return self.edge_mlp(out)\n",
"\n",
"\n",
"class LorentzNodeBlock(torch.nn.Module):\n",
" def __init__(self):\n",
" super(LorentzNodeBlock, self).__init__()\n",
" self.node_mlp_1 = Seq(Lin(1 + hidden, hidden), ReLU(), Lin(hidden, hidden))\n",
" self.node_mlp_2 = Seq(Lin(1 + hidden, hidden), ReLU(), Lin(hidden, hidden))\n",
" self.minkowski = torch.from_numpy(\n",
" np.array(\n",
" [\n",
" [-1.0, 0.0, 0.0, 0.0],\n",
" [0.0, 1.0, 0.0, 0.0],\n",
" [0.0, 0.0, 1.0, 0.0],\n",
" [0.0, 0.0, 0.0, 1.0],\n",
" ],\n",
" dtype=np.float32,\n",
" )\n",
" )\n",
"\n",
" def innerprod(self, x1, x2):\n",
" return torch.sum(\n",
" torch.mul(torch.matmul(x1, self.minkowski), x2), 1, keepdim=True\n",
" )\n",
"\n",
" def forward(self, x, edge_index, edge_attr, u, batch):\n",
" row, col = edge_index\n",
" out = torch.cat([self.innerprod(x[row], x[row]), edge_attr], dim=1)\n",
" out = self.node_mlp_1(out)\n",
" out = scatter_mean(out, col, dim=0, dim_size=x.size(0))\n",
" out = torch.cat([self.innerprod(x, x), out], dim=1)\n",
" return self.node_mlp_2(out)\n",
"\n",
"\n",
"class GlobalBlock(torch.nn.Module):\n",
" def __init__(self):\n",
" super(GlobalBlock, self).__init__()\n",
" self.global_mlp = Seq(Lin(hidden, hidden), ReLU(), Lin(hidden, outputs))\n",
"\n",
" def forward(self, x, edge_index, edge_attr, u, batch):\n",
" out = scatter_mean(x, batch, dim=0)\n",
" return self.global_mlp(out)\n",
"\n",
"\n",
"class LorentzInteractionNetwork(torch.nn.Module):\n",
" def __init__(self):\n",
" super(LorentzInteractionNetwork, self).__init__()\n",
" self.lorentzinteractionnetwork = MetaLayer(\n",
" LorentzEdgeBlock(), LorentzNodeBlock(), GlobalBlock()\n",
" )\n",
"\n",
" def forward(self, x, edge_index, batch):\n",
"\n",
" x, edge_attr, u = self.lorentzinteractionnetwork(\n",
" x, edge_index, None, None, batch\n",
" )\n",
" return u\n",
"\n",
"\n",
"model = LorentzInteractionNetwork().to(device)\n",
"optimizer = torch.optim.Adam(model.parameters(), lr=1e-6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Define training loop"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [],
"source": [
"@torch.no_grad()\n",
"def test(model, loader, total, batch_size, leave=False):\n",
" model.eval()\n",
"\n",
" xentropy = nn.CrossEntropyLoss(reduction=\"mean\")\n",
"\n",
" sum_loss = 0.0\n",
" t = tqdm(enumerate(loader), total=total / batch_size, leave=leave)\n",
" for i, data in t:\n",
" data = data.to(device)\n",
" y = torch.argmax(data.y, dim=1)\n",
" batch_output = model(data.x, data.edge_index, data.batch)\n",
" batch_loss_item = xentropy(batch_output, y).item()\n",
" sum_loss += batch_loss_item\n",
" t.set_description(\"loss = %.5f\" % (batch_loss_item))\n",
" t.refresh() # to show immediately the update\n",
"\n",
" return sum_loss / (i + 1)\n",
"\n",
"\n",
"def train(model, optimizer, loader, total, batch_size, leave=False):\n",
" model.train()\n",
"\n",
" xentropy = nn.CrossEntropyLoss(reduction=\"mean\")\n",
"\n",
" sum_loss = 0.0\n",
" t = tqdm(enumerate(loader), total=total / batch_size, leave=leave)\n",
" for i, data in t:\n",
" data = data.to(device)\n",
" y = torch.argmax(data.y, dim=1)\n",
" optimizer.zero_grad()\n",
" batch_output = model(data.x, data.edge_index, data.batch)\n",
" batch_loss = xentropy(batch_output, y)\n",
" batch_loss.backward()\n",
" batch_loss_item = batch_loss.item()\n",
" t.set_description(\"loss = %.5f\" % batch_loss_item)\n",
" t.refresh() # to show immediately the update\n",
" sum_loss += batch_loss_item\n",
" optimizer.step()\n",
"\n",
" return sum_loss / (i + 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Define training, validation, testing data generators"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7484\n",
"5988\n",
"1496\n",
"1887\n"
]
},
{
"name": "stderr",
"output_type": "stream",
"text": [
"/Users/wmccorma/miniconda3/envs/ml-iaifi/lib/python3.9/site-packages/torch_geometric/deprecation.py:12: UserWarning: 'data.DataListLoader' is deprecated, use 'loader.DataListLoader' instead\n",
" warnings.warn(out)\n"
]
}
],
"source": [
"from torch_geometric.data import Data, DataListLoader, Batch\n",
"from torch.utils.data import random_split\n",
"\n",
"\n",
"def collate(items):\n",
" l = sum(items, [])\n",
" return Batch.from_data_list(l)\n",
"\n",
"\n",
"torch.manual_seed(0)\n",
"valid_frac = 0.20\n",
"full_length = len(graph_dataset)\n",
"valid_num = int(valid_frac * full_length)\n",
"batch_size = 32\n",
"\n",
"train_dataset, valid_dataset = random_split(\n",
" graph_dataset, [full_length - valid_num, valid_num]\n",
")\n",
"\n",
"train_loader = DataListLoader(\n",
" train_dataset, batch_size=batch_size, pin_memory=True, shuffle=True\n",
")\n",
"train_loader.collate_fn = collate\n",
"valid_loader = DataListLoader(\n",
" valid_dataset, batch_size=batch_size, pin_memory=True, shuffle=False\n",
")\n",
"valid_loader.collate_fn = collate\n",
"test_loader = DataListLoader(\n",
" test_dataset, batch_size=batch_size, pin_memory=True, shuffle=False\n",
")\n",
"test_loader.collate_fn = collate\n",
"\n",
"\n",
"train_samples = len(train_dataset)\n",
"valid_samples = len(valid_dataset)\n",
"test_samples = len(test_dataset)\n",
"print(full_length)\n",
"print(train_samples)\n",
"print(valid_samples)\n",
"print(test_samples)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Train"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "4218389d3f8f473689e0b7f5acdf982e",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/2 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/187.125 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/46.75 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 00, Training Loss: 0.7810\n",
" Validation Loss: 0.7829\n",
"New best model saved to: lorentznetwork_best.pth\n"
]
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "1114825255ea478bbf1252cd406b9927",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/187.125 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "ff4de51a4b5947e88522ef67466ae6e3",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/46.75 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Epoch: 01, Training Loss: 0.7805\n",
" Validation Loss: 0.7821\n",
"New best model saved to: lorentznetwork_best.pth\n"
]
}
],
"source": [
"import os.path as osp\n",
"\n",
"n_epochs = 2\n",
"stale_epochs = 0\n",
"best_valid_loss = 99999\n",
"patience = 5\n",
"t = tqdm(range(0, n_epochs))\n",
"\n",
"for epoch in t:\n",
" loss = train(\n",
" model,\n",
" optimizer,\n",
" train_loader,\n",
" train_samples,\n",
" batch_size,\n",
" leave=bool(epoch == n_epochs - 1),\n",
" )\n",
" valid_loss = test(\n",
" model,\n",
" valid_loader,\n",
" valid_samples,\n",
" batch_size,\n",
" leave=bool(epoch == n_epochs - 1),\n",
" )\n",
" print(\"Epoch: {:02d}, Training Loss: {:.4f}\".format(epoch, loss))\n",
" print(\" Validation Loss: {:.4f}\".format(valid_loss))\n",
"\n",
" if valid_loss < best_valid_loss:\n",
" best_valid_loss = valid_loss\n",
" modpath = osp.join(\"lorentznetwork_best.pth\")\n",
" print(\"New best model saved to:\", modpath)\n",
" torch.save(model.state_dict(), modpath)\n",
" stale_epochs = 0\n",
" else:\n",
" print(\"Stale epoch\")\n",
" stale_epochs += 1\n",
" if stale_epochs >= patience:\n",
" print(\"Early stopping after %i stale epochs\" % patience)\n",
" break"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluate on testing data"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"application/vnd.jupyter.widget-view+json": {
"model_id": "6d13d8453de64f0e866ef3be894b6b90",
"version_major": 2,
"version_minor": 0
},
"text/plain": [
" 0%| | 0/58.96875 [00:00, ?it/s]"
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"# In case you need to load the model from a pth file\n",
"# Trained on 4 vectors (as above in notebook)\n",
"# urlPTH = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/lorentznetwork_best.pth\"\n",
"# pthFile = wget.download(urlPTH)\n",
"# model.load_state_dict(torch.load(\"lorentznetwork_best.pth\"))\n",
"\n",
"model.eval()\n",
"t = tqdm(enumerate(test_loader), total=test_samples / batch_size)\n",
"y_test = []\n",
"y_predict = []\n",
"track_pt = []\n",
"for i, data in t:\n",
" data = data.to(device)\n",
" batchmask = torch.cat([-1.0 * torch.ones(1), data.batch[:-1]], dim=0)\n",
" track_pt.append(data.x[batchmask != data.batch, 0])\n",
" batch_output = model(data.x, data.edge_index, data.batch)\n",
" y_predict.append(batch_output.detach().cpu().numpy())\n",
" y_test.append(data.y.cpu().numpy())\n",
"track_pt = np.concatenate(track_pt)\n",
"y_test = np.concatenate(y_test)\n",
"y_predict = np.concatenate(y_predict)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"from sklearn.metrics import roc_curve, auc\n",
"import matplotlib.pyplot as plt\n",
"import mplhep as hep\n",
"\n",
"plt.style.use(hep.style.ROOT)\n",
"# create ROC curves\n",
"fpr_lorentz, tpr_lorentz, threshold_lorentz = roc_curve(y_test[:, 1], -y_predict[:, 1])\n",
"with open(\"lorentz_roc.npy\", \"wb\") as f:\n",
" np.save(f, fpr_lorentz)\n",
" np.save(f, tpr_lorentz)\n",
" np.save(f, threshold_lorentz)\n",
"\n",
"\n",
"For colab:\n",
"if not os.path.exists(\"deepset_roc.py\"):\n",
" urlROC = \"https://raw.githubusercontent.com/jmduarte/iaifi-summer-school/main/book/deepset_roc.npy\"\n",
" rocFile = wget.download(urlROC) \n",
" \n",
"with open(\"deepset_roc.npy\", \"rb\") as f:\n",
" fpr_deepset = np.load(f)\n",
" tpr_deepset = np.load(f)\n",
" threshold_deepset = np.load(f)\n",
"\n",
"# plot ROC curves\n",
"plt.figure()\n",
"plt.plot(\n",
" tpr_deepset,\n",
" fpr_deepset,\n",
" lw=2.5,\n",
" label=\"DeepSet, AUC = {:.1f}%\".format(auc(fpr_deepset, tpr_deepset) * 100),\n",
")\n",
"plt.plot(\n",
" tpr_lorentz,\n",
" fpr_lorentz,\n",
" lw=2.5,\n",
" label=\"Lorentz GNN, AUC = {:.1f}%\".format(auc(fpr_lorentz, tpr_lorentz) * 100),\n",
")\n",
"plt.xlabel(r\"True positive rate\")\n",
"plt.ylabel(r\"False positive rate\")\n",
"plt.ylim(0.001, 1)\n",
"plt.xlim(0, 1)\n",
"plt.grid(True)\n",
"plt.legend(loc=\"upper left\")\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"image/png": "iVBORw0KGgoAAAANSUhEUgAAAokAAAJuCAYAAADclpgbAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAC4dUlEQVR4nOzdd3gUZdcG8PtJJ71QAgRIKIFA6CBdBBVRCCJ29BVRwS62FwsWRGyI+qlgoQgWRAEbsaCvShepSg2EECCEkIQQQgjpyfn+2EJ2djfbM/tMzu+6ci3MzM6czZ3dnEx5RhARGGOMMcYYq8tH7QIYY4wxxpj34SaRMcYYY4yZ4SaRMcYYY4yZ4SaRMcYYY4yZ4SaRMcYYY4yZ4SaRMcYYY4yZkaJJFDonhRAvO/Hcq4UQW4QQJUKIM0KI1UKI3p6okzHGGGNMK6RoEgFcA6CVo08SQtwEYDWAgQCOASgDkAJgixBisDsLZIwxxhjTEq9uEoUQYUKI2wF84sRzowF8BqAKwGAiSiaiOACPAAgEsFgI4dWvnzHGGGNMLV7bJAkhVgI4B+BzAM2dWMWt0DWDs4loi2EiEb0P4FcAXQCMcEOpjDHGGGOa46d2AfX4C0CB/t+d4XhDd6v+8TsL874FcJX+6w+nqmOMMcYY0zCvbRKJ6B3Dv4UQk+B4k5gA4BwRpVmYZ9izmORkeYwxxhhjmua1h5tdIYQQ0B2iPmNlEcMeyrYNUxFjjDHGmFy8dk+ii2Kge21nrcwv1D+GWJophCBPFMUYY4wx5ilEJNy5Pk3uSbSDr/6xVtUqGGOMMca8lNuaRCFEgLvW5QZnAFQDiLYy3zD9VH0rIaIG+5oyZYpmt9fQr61bt26a/V42hu1xfnJvryHz0/r3UsvZNYbvZ0Nt7+XU/e7sn0w41STq74AyRQiRKoTIFUJUACjVz+skhJghhGjh1kodQEQEIB+6w86WGKbX2yQyOQUFBaldAnMB5yc3zk9enB1TcrhJFEK0AvAvgI8AjIHuAhF/AIbj4GEAXgawTwjRzz1lOiUTQLgQItnCPMPdVo42YD2sgZSXl6tdAnMB5yc3zk9enB1TcqhJFEI0AfAbgO7Q3clkPi6OR2hwEsAu6PbW/SqEiHS9TKcs1z9eZ2HeeMUyTEP4r2G5cX5y4/zkxdkxJUf3JN4FoCuAIgD9iOhhIvq67gJElAdgAIB1ACIBTHO5SucsB1AO4FkhxEDDRCHEwwBGAdhGRHtUqo15EP81LDfOT26cn7w4O6bkaJN4OwAC8BQR7bO2EBHVAHgBukPQVztfnm1CiOZCiF/0X8bb9xHRWQB3QDcUzhYhxB4hRDaA96A7F3GyJ+tyVEpKima319CvraH/GtZydmpsj/OTe3sNmZ/Wv5dazg7Q/vezobfnCUJ3jYedCwtRACAKQDsiyq4zvRa660V860wLAXAewBkiauZSkbo7riyF7j7MzyvmtQNwTP/feCI6rpg/GsBM6A6RVwDYCOBxIjpSz/YIuhfkStlMJd27d8fevXvVLoM5ifOTG+cnL85OTrN/PIDnU7oBcP84iY4Opl2pf7Rnn7RhSByXxyIkok8BfGpl3nFcvGjG0vw1ANa4WgOTR0CAN43GxBzF+cmN85MXZ8eUHD3cvEv/OMyOZXvpH3c7uA3GXFJVVaV2CcwFnJ/cOD95cXZMydEmcTN0e+3mCiGirC2kv3fyLOjOX9zqfHmMOc7X19f2QsxrcX5y4/zkxdkxJUebxLcA7AGQAOCAEGKqEKKDYaYQopkQ4kromskh0J0r+IabamXMLnwuqdw4P7lxfvLi7JiSQ+ckElGlEOJWAKsBdADwoWGW/jFX/yigu+PJbURU4o5CGbPXHXfcoXYJzAWcn9w4P3lxdkzJoaubjU8Swh/AwwDuBxAPoO4+6pMAvgDwKhGdd0ONDY6vbpZbUVERIiMj1S6DOYnzkxvnJy/OTk6evLrZqXs3E1EVEb1NRJ0ABEM3wHZvAKFE1IaInpG1QWTyKy0tVbsE5gLOT26cn7w4O6bk0OFmIUQbACCiE4ZpRFQF4GA9y1cRUa6l+Yx5Av8lLDfOT26cn7w4O6bk6J7E4wCOOrD8fgB/ObgNxlySn5+vdgnMBZyf3Dg/eXF2TMmZw812He8WQrSA7lB0rBPbYMxpcXFxapfAXMD5yY3zkxdnx5TqbRKFEI8IIY4YvupMP2LjKxNAFnQNZZ6HXwNjJjIzM9UugbmA85Mb5ycvzo4p2TonMRK6MRHrEhamWUMAXnOwJsZckpiYqHYJzAWcn9w4P3lxdkzJVpO4FMA6/b8FgLXQNX4j7Fz/0boXuTDWENLS0pCUlKR2GcxJnJ/cOD95cXZMyaFxEoUQtQCIiDR97x4eJ5ExxhhjMvCmcRLjYf+hZqZh69evhxACI0bYu1O54aSlpaldgl0qKyuxcOFCjB49Gq1bt0ZQUBASEhIwcuRIzJ07FyUllm9W9NJLL0EIgRYtWqCwsNDq+mtqaiCEQEKC6Vs2ISEBQgjcc8899da3ePFiCCHw0ksvOfS68vLyEBUVhW3btgEAjh8/DiEEJk+ebNfzvTW/yZMnQwhh99eIESNQW1uL5ORkLFy40GN19e3b17jNjIwMq8vZ+5415KX8ualrzZo1uPXWWxEfH48mTZqgbdu2GDlyJD788EPs3bvX6dfiDrt378YNN9yAFi1aICIiAkOGDMHq1astLltVVYV33nkHl1xyCSIiItCmTRuMGTMGmzdvdnr7xcXFCAoKwuLFi60us2XLFkybNg233347Pv74Y1RXV1tcbs+ePfD19cWGDRucrscR3vreYyoiIo98AWgC4AyAHzy1DQ/WTrpvDbNm3bp1BIAuu+wytUvxCE+/tj179lCnTp3I8LMWFRVFQ4cOpS5dupC/v79x2u+//2723JkzZxqfd+edd1rdRnV1NQGg+Ph4k+nx8fHG569du9bq8xctWkQAaObMmQ69tokTJ1JKSorx/8eOHbNZqwzeeustGj16tMlX9+7dCQC1bt3abN706dOJiGjlypUUFRVF+fn5bq/p4MGDxiwB0Msvv2x1WXvfs4a8lD83RESlpaU0YcIE4/aio6Np6NChlJiYSL6+vgSAkpKS6PTp0y6/Nmf89ttvFBgYSACobdu21L9/f2Nd7733nsmy1dXVNHz4cAJAYWFhNHjwYEpOTib9kSRavHixUzXMmzePANCiRYsszv/www/Jx8fHJLehQ4dSZWWl2bJXX301jRkzxqk6WOPxcup+qtO3uLcfcupJQACAvgCGWfm6FLoLVmoBnHd30Z7+4ibRNm9uEg8fPuzyOjz52jIzMykyMtK4jbS0NJP5eXl59MQTTxAACg0NpR07dpjMr9skArDYSBLZ1yR26tSJysrKLD7fmSbxr7/+IgC0bds24zRHm0R35NdQli5davO11dbWUlJSEt17771u3/4LL7xAAGjkyJEEgLp27Wp1WXc0iePGjTP+3Gzfvp1qa2uN8w4fPkxXXHEFAaArrriCampqnH9hTigvL6dmzZqRv78/rV692jh9586dFBYWRkFBQZSTk2OcbmjmRo4cSWfPnjVO37hxIzVp0oSCg4NNptty5swZmjdvHgUHB1ttEo8fP05BQUE0aNAgOnDgAJ05c4ZefPFFAkBz5swxWXbdunXk4+NDu3fvtv+b4CKZ3nvsIk82iQ6PkyiEeBhAMYBt0F3UYulrLYDp+qc0zH5yxvTatm2rdgn1mj59OoqKinDvvffijz/+QJcuXUzmN2/eHHPnzsWsWbNQUlKCl19+2eJ6xo4dCwC49957UVZW5nAdY8eOxeHDhzF79mzHX4QV7777LpKSktC/f3+n1+Ht+TlKCIE77rgDn3/+Oc6ePevWdS9fvhwAMG/ePLRt2xYHDhzw2OHetWvXYvXq1ejatSu2bt2Kfv36QYiLpz917NgR3377LeLj4/H7779j48aNHqnDmu+++w6nT5/GzJkzkZKSYpzep08fPP744ygvL8dPP/1knL5+/XoAwMsvv2xyp5GhQ4fi5ptvRmlpKbZv327Xti+55BLExMTgoYceqvfWdmvXrkV5eTmWLFmCpKQkREdHY+bMmRgwYADWrFljsuxTTz2F22+/HT169LCrBnfQ2nuPuc6hJlEIMRLAu9DtSSwHkAvdVc8CwEnoxkaswsUBt+cCuMldxTK5ERE++OADXH755YiJiUG7du0wbtw4/Pbbb2bLGs67y8vLw/Lly9GhQwdER0ebLJOZmYk777wT3bp1Q2hoKJKTk/Hqq6/iyJEjJssZzsX69NNPceLECdxyyy1o1qwZIiMjMWzYMJPtG7YLAOvWrTM5h2vEiBE2z0GzZePGjVi1ahViY2Mxd+5c+PhYfws+8cQTuOGGG+Dv74+Kigqz+ePHj8eECRNw5MgRzJo1y+a2lebNm4fw8HDMmTPHLY3FqVOn8O233+K2226z+zlfffUVrr76asTGxqJly5YYPXo0Pv74Y5Nl7r77bggh8Nlnn5lM/+STTyCEgK+vL4qKikzmpaSkQAiBH374od7tCyFw//334/Tp05gyZQpiY2MRFRWFK664AkuWLLH7ddgyceJElJWVuXWd27dvx+HDh3HJJZcgKSkJN92k+6g1NI7uNmPGDADAzJkzERUVZXGZsLAw3HDDDQCAVatWeaQOaxYtWmRsyJWeeuopHDt2DNdff71x2oULFwDApNE1MLwvrZ0XrDRq1Cjcd999uO+++9CvXz+ryxUXFwMAYmJiTKY3bdrU5Gf4m2++wT///OPU+9oVubl8B12m4MhuRwCroDuEvBpAoH7a8wBqAIzW/z9YP60WwEvu3vXZEF/Q77adMmWK2VfdwxiNmaOHm6urq2nMmDEEgPz9/alPnz6UmJhIQggSQtCsWbNMljccUn3zzTeN5z5dfvnlxvm//PILhYeHEwBKSEiggQMHGg/z9OnThwoLC81qfeONN6h169YUEhJCgwYNojZt2hAA8vX1pU2bNhER0RdffEGjR482brPuuWXTp083O+9s9OjR1L59ewJAV111lc3vwx133EEA6O2337br+2aJ4XuzaNEiOnnyJEVERJCfnx/9+++/Zt9z1HO4ubq6mubPn08AaMCAAWaHBx093Pz+++8TALPDY9YON993330EgHx8fCg5OZm6d+9uPFfrnnvuMS739ddfEwCaPHmyyfPvuusu4yGWH3/80Ti9traWoqKiyM/Pj86dO1dvzQDo+uuvp/j4eBJCUHJyMnXu3Nl4XlrdOiyx53CzQc+ePal///42l7PXo48+SgDo/fffJyKi7du3G98PlrhyuPn48ePG8/xsHUYuKCig7Oxsj5yDWZ+QkBDq0qWL3csvWLDA4uHmTZs2UXBwMIWHh5t8jtir7vtTadu2bQSAHnzwQeP3cfPmzRQQEED3338/ERFVVVVR586d6bHHHnN42646f/58g2+TOW716tUmfcmlj/yfd5yTCOCQviHsXWdaO31D+Ipi2S8AVALo7+6iPf1V55vNrHC0STQ0HD169KDjx48bp2/YsIFiYmLI19eXDhw4YJxu+KANCAigefPmmZz7dOHCBWrVqhU1adKEvvvuO+P0wsJCYyN63333mdUaGhpK48aNM34Q1tTU0EMPPUQA6O677zap197XduLECWrevDkFBwebNWmWdOzYkQDQxo0bbS5rjfKX0IcffkgAqH///ia/wO1pEmtqamjQoEEWT+x3tEmcMGEChYSEUHV1tcl0S03i77//TgCoTZs2Jk3lvn37jM37r7/+SkS6c718fHyoffv2JutNTEw0/mHw1FNPGafv3r2bANCll15qs2bDe71ly5a0a9cu4/QtW7ZQixYt6j3nk8ixJnHq1Knk6+tLRUVFNpe1paamhlq2bEn+/v4mF4l06NCBANCWLVvMnuNKk/jHH38QALr66qtt1nbq1CkHXol7FBcXG1/biRMnaNKkSZSYmEhRUVE0fPhw+uyzzyw+76mnniIhBIWHh9OQIUOoe/fuJISg2NhY2rBhg1O11NckEuku7DJ8fwcMGEC+vr4UHR1tPF/y448/pvDwcFUu/lEjO+Y6T56TaGswbaXW+seDhglEdFwIUQagi2LZ+QAmAngSwM0ObkdzXkrdjwM5xWqXAQDo2iocL+rHVGoor7zyCgBgyZIlJue9DBs2DC+88AKmTZuGOXPmmB2OGz9+PB588EGTaR999BFycnLwyiuvYPz48cbpUVFRWLZsGTp16oTFixfj7bffRpMmTYzz/f398emnnyI0NBSA7pDS888/j3nz5pkdorZHZWUlbrjhBuTn52PZsmXo2bOnzecYDucoz0MEdEN39OrVy+Lzli5dikmTJlmcd++99+KLL77A5s2b8f7772PatGl2vwYfHx8sXLgQvXv3xowZM3Ddddc5ff/W9evXo0+fPvD1tT2MquHn4d133zU556pbt2547bXXcPvtt+O1117DqFGjEB0djb59+2L79u04ceIE2rRpg9OnTyM9PR333XcfPvnkE5Pz3wz/vuqqq+yu/Z133kHv3r2N/x84cCDeeust3H777Xj99ddx+eWX270ua/r3748FCxZg06ZNGDNmjEvrWrt2LU6dOoVrr70WTZs2NU6/6aab8Nprr+Grr77CwIEDXS3Z6PDhwwBQ77A4BgEBAXav9/fff8dbb71lc7knnngCV1xxhdX5p06dAgCcPXsWAwYMwJkzZ5CcnIwmTZrgr7/+wvr167F27Vp88sknJs9r164dgoKCUFxcbDLsTevWrdGiRQu7X4cjPv30UyQmJmLZsmU4fPgwxo4di3feeQctW7ZEWVkZXnrpJUyfPt0k14biSHascXC0SSyHbmgbfwB1z5Q/BkB5P5/9+sdhTlWmMQdyirH1qPUx7bSspKQER48eRbdu3dCnTx+z+bfffjumTZuGPXv2mM275pprzKbt2LEDAHDjjTeazYuIiMDQoUPx3XffYdeuXRgyZIhx3qhRo0xOUAd0F4k46+GHH8bWrVvx2GOPYeLEiXY9p6qqCgAsNlJhYWEYPXq0ybSTJ0/aPF9QCIEFCxagd+/eeO6553Ddddc5dAJ6t27d8NRTT2H27Nl44IEHrI4pV5/CwkKcOXPG7u3u2bMHoaGhJk2+wejRoxEREWHy83DVVVdh+/btWL9+PW6//XbjL/RRo0Zhz5492LFjB8rKytCkSRPjmHL2Nol1z6Or65ZbbsG9996Lf//916712GL43tQ3lqG9vvzySwAwO//u5ptvxmuvvYavv/4ab7/9dr3nvDrCcP5eUFCQW9ZncPLkSbMLNiy55ZZb6p1/5swZALo/tC699FJs374drVq1AgAcOnQIY8eOxZIlSzBhwgTjBV+zZ8/G888/j379+mHu3Lno06cPCgsL8cUXX2DWrFnG9bRp08bFV2nKz88PL774Il588UWzef/3f/+H2tpaPProo8Zp69atw8aNGxETE4MxY8agXbt2bq2Hsfo42iRmA4iCbvibtXWmHwZwjRAiiIjK9dNq9Y+RLlWoEV1bhatdglFD12K4aby1vRDR0dEIDw+3uDcvNjbWbJphr4at+4wWFBSY/L99+/Z21WuPxYsXY8GCBRg+fDjmzJlj9/OaNm2KkydPGi84UNb3yy+/mEx79913TX5hWNO1a1c888wzeOmll3D//febXMVpj+eeew4rVqxAamoqVq5cabEBr09eXh4A8xPyLSkuLjbu6bF00UBVVRXatWuHPXv2oKioCJGRkRg1ahRmz55t1iQOHjwYw4cPx19//YWtW7fisssuw4YNG9C0aVOLf5BYkpCQYLFp9/X1RUJCAvbt24fi4mKEh7v2vjF8b1y9OKCiogLffPMNAF1T8eGHHxrnERF8fHyQm5uLdevWYeTIkS5ty6Bjx44ALr6X61NZWWn3eidNmmR1D7kjDBfS+Pv7Y/ny5cYGEQA6d+6MuXPnYvz48Vi+fDnGjh2LvLw8zJ49Gy1atMBvv/1mfH5YWBhmzJgBPz8/PP3003j99dcxf/58l+uzR2FhId544w28/vrrCAkJARFh8uTJ+PTTT43LTJ8+HZ999hkmTJjgkRocyY41Do42iRsA9ADwf0KIm4jokH76TgApAG6B7n7PgG6sREB3xXOj19CHd70J6c7ztNgQGPj6+hr3stVlac+F4e4EV155pcVf7jU1NfD19TX7pR4YGOhQ3dZs374dDz74IOLi4rBixQr4+dn/Nurbty9OnjyJ3bt3mzWJljhy1fEzzzyDr7/+Gj///DO+/vpri3vHrAkMDMSCBQswYsQIPPLII7jyyivtfi4A49AuYWFhNpe19fMQGhpqzNWQ9cCBAxEWFoZ169YBADZt2oROnTqhRYsWuPTSS/Haa69h48aNiIuLQ25uLiZOnFjvz1td9eVnqMPS1eWOioiIAIB675Jjj59//hnnzp0DgHqHmVm+fLnFJtHw/bfG0nzDH2QHDx40m6d04cIFREVFISgoCFlZWfD397f5HFcZ/pjs0qWLSYNoMHToUAAX30/btm1DRUUFRo8ebfFK7YkTJ+Lpp5926c4rjnr11VfRrFkz452QFixYgE8//RQvvvgipk2bhlOnTuHuu+/GXXfdhSFDhnjkcLjhVBzGDBw9FvEWdIeckwEcEEJcp5/+PXTD3rwvhJgphHgGwBLoTqRc76ZamaQ6dOgAwPpeiKKiIpw9e9a4t8IWw3IfffQRfvnlF7OvRYsW4ZdffvHILQNPnz5tHEbjm2++cfhwtWEP3Zw5c2z+1V5WVobff//d7nUbGj0hBKZNm+ZwMzJ8+HDcfffdyM3NxfTp020/oQ7D8ETnz5+3uWxERARiYmJw7Ngxiw1JYWEhjh49ioiICON5Wf7+/hg5ciQyMjJw5MgRk1MJhgwZAl9fX2zcuNHhQ80AcPToUYvTiQiZmZmIiIhAs2bN7F6fNYbGTjmUk6MMh5oXLlxo8UTznTt3AtD9fNb9w8twmDIrq/6/248fPw7AdM97hw4dEBcXh4MHD1ocsqqu1atXo6ioCN26dbPZIP7++++4+uqrbX7Zeh9ERkYiJCQE5eXlFucb/tgw/BFjOAwfEhJicXnDdHv/0HDViRMnMH/+fLz66qvGP1pWrlyJQYMGGYcc6tq1Kz755BOcO3cOf/zxh0fqcPUPGKY9DjWJRHQcunMMD0HXFPrpp+8FsAhACHTD38wG0AxAof7frBELDQ1FQkIC9u/fj3/++cdsvmH8u+7du9u1PsOFDtZ+Wb388su46aab3H7opKamBjfffDNOnDiBefPm2bUnUOm2227DwIEDkZGRYfOeyM8//7zxF7a9hg0bhilTpiAvLw9PPvmkw/XNmTMHLVq0wKJFi4yDDdvDsFfDcG6YLT169MD58+ctjmO4fft2FBUVmQ0iPGrUKADAm2++icrKSuPeobCwMPTu3RtbtmzBn3/+CQAO7Qk9e/Ysfv75Z7PpK1aswPnz5902mLHhe+PKHqDi4mL8+OOP8PPzw3XXXWdxmT59+iA+Ph5nz57Fr7/+apweHx+PqKgoHD16FLt377a6jZUrVwLQ7fU28Pf3Nw66/tRTT1kdP7CyshKLFi0CALPzay0xnJNo6+vkyZM21zV+/HgcOXLE4v2HDZ8Vhs8Yw0VmGzZsQG1trdnya9fqzqaqezGTJ73wwgtITk422ft/5swZsz8oDH+Unj592iN1WDq9hzVyzl4WDSACQESd//sAeBzAFgC7oGsa27j7cuyG+AIPgWOTo0PgLFy4kABQz549KSsry2Q90dHR5OvrS/v27TNONwwjsW7dOrN1nTlzhiIjIyk6Otrk3sNlZWX00ksvEQCaMGGCWa3WhnKx9DoAUK9evUymPfnkkwSApk6datdrtmbXrl0UEBBAAGjMmDF05MgRk/mnTp2iW2+9lQAYhzRZunSpcb6tITaKioqoZcuWxiER6hsCxxLDuISGL3uHwImJiaGhQ4eaTbc0BM7//vc/47h7e/fuNU7fs2cPtW7dmgDQmjVrTNZz+PBhAmC8N2/d2xkabmMYGBhIPXv2tKteootD4LRv395kfVu3bjV+D3/++Werz3dkCBzDeyA1NdXu+qxtb9SoUfUuZ/h+TJw40WT666+/bhxLUXnf7pKSEuPPVlRUFB07dsxkfk1NDfXv358AUOfOnWnbtm0mQ1Pl5OTQddddRwCoe/fuVF5e7vTrdMbGjRsJAPXu3ZuOHj1qnG4YzsjPz89kuKWrrrqKANDDDz9sUuu2bduodevW5OPjQ+vXr3e4DlvvT6V9+/aRj4+P2VBL9957LwUEBBiHy6qpqaFHHnnE6hBH7sC35ZOT1927Wetf3CTaZmi8QkJCKDk52erX66+/TkTmg2n37dvXZDDt2bNnm6y/viaRiGjZsmXGZqFTp040YMAAY+OVkJBAubm5ZrU60iRGRUWRj48PXXPNNfT888/TyZMnjW/CESNGWBxUe/To0ZSXl2fX92/Xrl2UlJRkXGdUVBQNGTLE2MAJIejxxx+nXbt2OdwkEhGtXLnS6SaRiIxZOdIkTpgwgYKDg+0aJ5FI90sQ0A1m3r17d5PBtKdMmWJxG4aBy2NiYkwalB9++MFYr2Hwc3sYGp7OnTuTr68v9erVi5KSkoyDaSsH8FZyxziJDzzwAI0ePZq++OILm+sYNWqUXQ2I4R7aISEhdOHCBeP02tpauv32243fqzZt2tCwYcOoZ8+eFBISQoBuEPlffvnF4npLSkqMA8IDoIiICBoyZAh16dKF/P39CQB17NjR5A++hvTf//6XoB9ftU+fPtStWzfy8fEhHx8fs3sjZ2dnU7t27Uzef126dDH+DL744osmy+/Zs8f4Pq+Po01iSkqKxab/5MmTFBUVRb6+vnTJJZcYf/Zvvvlmu9bLGg+vaRIBLNbvIfR3dyHe9MVNom2GxsvW16OPPmp8Tm1tLb3//vt02WWXUXR0NLVp04ZSUlIsDlZsq0kk0n1o33TTTdSpUydjs/rss8+a/ZXtTJP42WefUevWrSkoKIhuuukmY6Nj60u596U+paWl9Morr1D//v0pMjKSAgMDqV27dnTnnXfStm3biIiosrKSAgMDHW4SiYjGjRvndJN4/PhxCg0NdahJNNxxRTmouLUmkYjoyy+/pFGjRlGLFi2oRYsWdNVVV9Fbb71ldRuGu7SMGzfOZHphYaHxl/sff/xhV71EF7M/e/YsTZ06lbp06UKRkZE0YsQIu37JO9Ik9urVy+IdV3r16mXX9zkvL498fX3Jz8+PCgoK6l22trbWuEf2q6++Mpu/adMmuummm6hHjx4UEhJCLVu2pEsvvZRmzJhhcvcRa1atWkVjx46lVq1aUUBAALVr146uuOIKmjt3rl2DynvS0qVL6ZprrqFmzZpRXFwcjR071urg9SUlJTRjxgzq378/hYWFUXx8PKWkpFgcSLvuZ159HGkSN23aREII2rlzp8X5mZmZNH78eIqOjqaOHTvSCy+8QJWVlTbX66y6NzRg8vBkkyhI1xTZRQhxHrrb7iURUbrdT5SMfi8CHPneMNbYnTp1Cu3atcOLL75ovM+vtxNC4LLLLjOeg+YpJ06cQLt27TB37lw8/vjjZvOfe+45BAUF4bnnnvNoHYwx7Zn94wE8rx9BhYjcerWVo1c3r9M/On7GPmMNxNKJ68zzWrZsiQkTJmDZsmUurUeL+S1fvhxNmjTB5MmTzeaVlJRg8+bNNsf9lIUW82ssODum5GiT+BiAMwDeEEI0/D2DGLNDUlKS2iU0WtOmTUNaWhq2bdvm9Dq0lh8R4bPPPsN//vMfi2PyXXPNNYiLi/PYAMkNTWv5NSacHVNydDDtMwCuBfAlgCNCiEUA/gVwCoDV0WaJyPqIr4y5WXp6umb2yshm0KBBmDhxIl5++WWkpqY6tQ6t5fftt98iJycHs2bNsjjfMLajVmgtv8aEs2NKjjaJde9zJgA8asdzyIntMOY0d95+jznu7bffRpcuXbBt2zanxpLUUn61tbV48cUX8frrr7t0n3CZaCm/xoazY0qONm9Z0DV9jHmt7OxsxMfHq11Go9WiRQvjbfqc0ZD5efriNB8fH+zbt8+j2/A2/P6TF2fHlBxqEokowVOFMOYujWWPjVZxfnLj/OTF2TElRy9cYczrFRUVqV0CcwHnJzfOT16cHVPiJpFpTnBwsNolMBdwfnLj/OTF2TElbhKZ5lRXV6tdAnMB5yc3zk9enB1T4iaRaU5tba3aJTAXcH5y4/zkxdkxJW4SmeYEBQWpXQJzAecnN85PXpwdU+ImkWlOcXGx2iUwF3B+cuP85MXZMSVuEpnmNG3Kd4yUGecnN85PXpwdU+ImkWlOTk6O2iUwF3B+cuP85MXZMSVuEpnmJCTwmO8y4/zkxvnJi7NjSk43iUKIK4UQ7wsh/hZCHBJCnNRPbyuEuE0IEeC+Mpm3Wb9+PYQQGDFihNqlmDl06JDaJdilsrISCxcuxOjRo9G6dWsEBQUhISEBI0eOxNy5c1FSUmLxeS+99BKEEGjRogUKCwutrr+mpgZCCLMP/oSEBAghcM8999Rb3+LFiyGEwEsvveTQ68rLy0NUVBS2bdsGADh+/DiEEJg8ebJdz3/jjTcs1u0Iw8+no7W7wvA6Hflav349vv76a3To0AFlZWUeqSs1NdW4vf/85z/1LjtixAhjXfWZPHkyhBD49NNPzeYdOnQIBQUFePnll9G/f380bdoUYWFh6NWrFyZNmoSDBw+69HrU9uWXX0IIgcWLFzv0vH379uHGG29E+/btERoait69e+OFF17AhQsXzJYtKyvD22+/jVtuuQXTp0+v99aO119/vds+h2X57GQNx9F7N0MIEQbgKwCjDZP0j4aboDYF8DmAl4QQVxDRMVeLVMvUqVPNpqWkpCAlJUWFapi9unTp4vI6hBC47LLLsHbtWjdUZG7v3r24/vrrcfjwYQBAVFQU+vfvj4KCAmzatAlr167Fq6++ipUrV+Lyyy+3uI78/Hw88cQTWLJkiVM1LF68GLfffjsuu+wyZ1+GRY8//jiGDRuGSy65xKnn9+vXD6NHj0aLFi3cWpenNWnSBKNHjzabvn79epSVlWH48OFo0qSJybzo6GhceumlmD17Nl599VW8/PLLbq/ryy+/NP77+++/R1lZmVkd7nT06FEMHToUZ86cgY+PD7p164YmTZogIyMDu3fvxpdffom5c+di2rRpHqvBksmTJ2Pp0qU2l7vzzjutvqdOnDiBBx980OFtr1mzBmPHjkVNTQ0SExPRu3dvHDhwAC+//DJWrVqF7du3IyQkBIDuridDhgzBgQMHjM9/77338NVXX2H8+PEm6926dSu+++47/P333w7XZIk7PjuZ56WmpiI1NdX4/0NNunluY0Rk9xd0TeU6ADUAagGkAnhK/+8a/TJtAJzQTzsOIMiRbXjDF3QNLzHr1q1bRwDosssuU7sUMwcOHHB5HZ58bZmZmRQZGWncRlpamsn8vLw8euKJJwgAhYaG0o4dO0zmz5w5kww/owDo999/t7id6upqAkDx8fEm0+Pj443P7dSpE5WVlVl8/qJFiwgAzZw50+7X9tdffxEA2rZtm3HasWPHCADdeeeddq3DHfkZfj4dqd1TDN/vY8eOWV3mq6++ooCAADp+/Lhbt11SUkLBwcEUFBREgwYNIgC0YsUKq8tfdtllBIDWrVtX73rvvPNOAkBLly41mf7333+Tv78/AaDnn3+eiouLjfOqq6tp8eLFFBAQQL6+vvTnn3+69uIc9NZbb9Ho0aOtfnXp0oUA0LPPPmvx+TU1NcbvDwBatGiRXdutqamhFi1akK+vL3377bfG6aWlpXTzzTcTAHrmmWeM0x944AHy8fGhjz76iM6dO0dbt26lxMREat68OZWUlJise/jw4XTDDTc48d2wzB3vPdbwXk7dT3X6Fvf2Qw4tDNyub/5KAYyqM93YJOr/HwrgH30z+ai7i/b0FzeJtnlzk+gOnnxtN9xwAwGge++9l2pqaqwuN2vWLAJA1157rcl0Q5M4duxYAkAdOnSg0tJSs+fbahINz58xY4bF7TvTJN58882UlJRkMs3RJtEdZGsSy8vLKSIiwqRZcIcvvviCANAtt9xCixcvJgA0YcIEq8u72iReeumlBIA+/vhjq8+dN2+e1312XLhwgRITE6lr16504cIFi8vMmTOHAFDHjh0dahL379f9Ar/yyivN5hneG4MHDzZOi4+Pp1tuucVkuV9++YUA0IYNG4zTfv75Z/Lz86NDhw7ZVQfTLk82iY6ek3iPvpCZRPSbtYWIqATA09Adir7ewW0wjSIifPDBB7j88ssRExODdu3aYdy4cfjtN/MfJcN5d3l5eVi+fDk6dOiA6Ohok2UyMzNx5513olu3bggNDUVycjJeffVV7Ny502Q5w/lpn376KU6cOIFbbrkFzZo1Q2RkJIYNG2ayfcN2AWDdunUm510aztey9mXPeUEbN27EqlWrEBsbi7lz58LHx/pb8IknnsANN9wAf39/VFRUmM0fP348JkyYgCNHjmDWrFk2t600b948hIeHY86cOdi7d6/Dz1c6deoUvv32W9x2221WlykoKMDkyZPRvHlzhIaGok+fPvjss89Mlvnjjz+snsM4b948DB8+HGFhYejQoQNef/111NbWIiwszOr3/+jRo7j++usRFRWFiIgIDB48GD///LNdr6nuz+GKFSvQv39/hISEoGvXrrjrrrvcdjVoYGAgbrjhBixcuNBi1s4yHGq+4447cN111yEgIAA//fSTR8bD+/XXX7FhwwZ07NgRU6ZMsbrcXXfdhbCwMGzYsAF5eXlur8MZ//3vf5GVlYWvvvrK4v2Ld+/ejeeeew5jx46t9+fbEsM5h4bPlboM7/+65x8XFxcjJibGZDnD0DRFRUUAdHdGeeaZZ3D33XcjMTHRoXrqI/v5osz9HG0SO+sfv7Fj2S36xw4OboNpUE1NDVJSUvDggw9i48aNiI+PR1BQEH788UeMHj3a6rlYn3/+OSZOnIiioiL06dPHOH3NmjXo3bs3Pv30U5SVlaF79+44evQoZsyYgfvuuw9nz541W1deXh4GDRqEH3/8EZ06dUJ4eDg2bdqEa665Bps3bwYAdOzY0XheWXR0NEaPHm08t+6SSy7B6NGjzb7at28PQPeL3pZFixYBAKZPn47Q0NB6lw0ODsbKlSuxcuVKq+t+//33ERERgblz52L37t02t19XXFwcXnvtNVRVVWHKlCku35Lrm2++QVVVldVzds+cOYPBgwfjq6++QkJCAlq2bIl//vkHkyZNwhdffGFcrkMH848MIsLEiRPx8MMPY+vWrUhKSkJVVZXxFyURmT0HAI4cOYIBAwbgt99+Q9euXREeHo4tW7YgJSXF5sUZdc2dOxc333wzMjIy0LNnT5w8eRJLlixBnz59sGvXLrvXU5+xY8eioKAAf/zxh1vWV1BQgN9++w0tWrTAlVdeiaioKFx55ZWoqKjAd99955Zt1PX1118DAJ566imLDZFBkyZNcOTIEWRlZSEyMtLtdTjq119/xQcffIDXXnsN3bt3N5tfXl6O2267DREREVi0aFG9r82SXr16IT4+Hn/88YfJ972srAxPPfUUAODaa681Th84cCC+/PJLY8NWWVmJ1157Db6+vujbty8AXfN/+PBhvPjiiw6/3vp07tzZ9kKscXFktyOA09AdQo5UTDc53KyfFqaffsbduz89/QU+3GyTo4ebDYcue/ToYXLe1YYNGygmJoZ8fX1NzocxHFINCAigefPmUW1trXHehQsXqFWrVtSkSRP67rvvjNMLCwtpzJgxBIDuu+8+s1pDQ0Np3LhxdP78eSLSnSv00EMPEQC6++67Teq197WdOHGCmjdvTsHBwfTvv//aXN5wqGrjxo02l7XG8L0xHO768MMPCQD179/f5PC1rcPN1dXVVFNTYzxX7b333jNZztHDzRMmTKCQkBCqrq42mW44pAaAhgwZQvn5+cZ5r7/+OgGgkSNHGqdt2LDB7PD0ihUrCAD17duXTp06ZZy+YMEC8vHxMcvLkDkAuu6664znclVXV9ODDz5IAOiuu+6y+Zrqnv/5wAMPGF9bZWUlTZkyhQDQ0KFD612HPYebiYhycnIIAD355JM267LHBx98QADoscceM0777LPPCABdddVVFp/jyuHmYcOGEQCT8+68XVVVFXXu3Jk6depEVVVVFpeZNm0aAaDvv/+eiMzff/bYt28fdejQgQBQ586dadiwYRQTE0MAaNKkSSbb3rNnDwUGBlJgYCANGjSIWrVqZXLeYkVFBcXHx1s9d9IVR44ccfs6med58nCzo1c3/wPgcgD9AfzPxrKGy21cP46lBb88DeR6ybcitjtw9esNuslXXnkFALBkyRK0bdvWOH3YsGF44YUXMG3aNMyZM8fsqsLx48ebXU340UcfIScnB6+88orJ1X5RUVFYtmwZEhMTsXjxYrz99tsmV3H6+/vj008/Ne7B8/HxwfPPP4958+bhyJEjDr+myspK3HDDDcjPz8eyZcvQs2dPm8/Jzc0FYPkqwt27d6NXr14Wn7d06VJMmjTJ4rx7770XX3zxBTZv3oz333/foatGfXx8sHDhQvTu3RszZszAddddh7i4OLufX9f69evRp08f+Pr6Wpzv7++Pzz//HM2aNTNOe/LJJzFr1ixkZmYapzVv3tzsubNnzwag+/mJjY01Tp8yZQp++eUXq3vGoqOjsXTpUuOVo76+vnjuuecwf/58k23akpSUhHnz5hn3Ivn7++Ojjz7Chg0bsGnTJmzevBlDhgyxe32WtGzZEq1bt8a6detcWo9B3UPNBtdeey2CgoLwxx9/4PTp0yZZuMpwpX6/fv3ctk5Ad7WxrcPSLVq0sOvKZaVFixbh0KFDWLVqFfz8zH8d/u9//8N7772He+65x2Rvn6NCQ0MRFxeHI0eO4NChQ8ahZvz8/NC1a1eT90z37t3x999/47///S+2b9+OuLg4PP3003jooYcAAB9++CHOnz+P6dOnO12PNa1atXL7OpncHG0StwO4AsAcIcQAIqqsZ9lnoOts3XMsRna5e4Hjm9SuQhUlJSU4evQounXrZnLI2OD222/HtGnTsGfPHrN511xzjdm0HTt2AABuvPFGs3kREREYMGAAUlNTsWvXLpNf3KNGjTI7vGWpIbGX4dDnY489hokTJ9r1nKqqKgCw2EiFhYWZDaFy8uRJm+cLCiGwYMEC9O7dG8899xyuu+46k0bclm7duuGpp57C7Nmz8cADD2D16tV2P9egsLAQZ86cqXe7/fr1Mxv70NfX1ywD5akC5eXl2Lt3L7p3727xcODEiROtNolXXXUVwsPDTabVbTLtdeedd5odZvTx8cHkyZPx9NNP499//3W5SQSAtm3bIi0tzeX1ZGVlYfPmzUhOTjb5wyM8PByjR4/G999/j1WrVuH+++93eVsGhnPvLI3754r169fj2LFj9S4THx/v8HovXLiAmTNnYsCAAbj+evNT5wsLC3HnnXciISEB77zzjsPrNzh16hSGDRuGvLw8vPzyy7j99tsRExODXbt2Yfr06XjqqadQVFSEV1991ficXr164X//M98Pc/78ecyePRvPPvssIiIiAACnT5/G6tWrceLECfTr1w9jxoxx+JC4QUFBgdN/JDJtcrRJfAPARAA9AOwQQjwJYEPdBYQQnQDMBpAC3eHpht1l5a1izX+5qaaBazHssbE2OHJ0dDTCw8Mt7s2z9AvdsMfC1gnbBQUFJv83nDvoDosXL8aCBQswfPhwzJkzx+7nNW3aFCdPnsThw4fNxhFs3749fvnlF5Np7777Lh599FGb6+3atSueeeYZvPTSS7j//vvx008/2V0TADz33HNYsWIFUlNTsXLlSosNeH0Me3qUJ9zXZe8vcuW5mpmZmSAiq8+vb73ONA+WdOrUyeL0jh07AoBTe6ItiYmJQVFREcrLyxEUFOT0epYvXw4iwtmzZ3HllVeazDM0XMuXL3drk9ixY0f8888/OHPmjNvWCeguPPKExYsXIy8vz2oDeO+99yIvLw8bNmywef5wfd544w2cOHECr7zyCp599lnj9OHDh+PXX39F165dMXfuXDz00EM29+S9+eabCA4ONh5d2bJlC8aPH4/8/HzjMpdffjlSU1OdGgtT+QcVYw41iURULIS4DcCPAJIB/AKgGvqBtIUQJQCaQHdVczmAu4ko38rqGpcGPrzrTUh/UUF9f936+voa97LVZekXZXV1NQDgyiuvtLhHrrKyEgEBAWYfePZcWGKP7du348EHH0RcXBxWrFhh8TCVNX379sXJkyexe/duuwabduSq42eeeQZff/01fv75Z3z99de44YYb7H5uYGAgFixYgBEjRuCRRx4xayxsMez9CwsLq3cb9lBe3Wvral9rh7cd2aYt1jI2bNtdVyQb9g6dPXsWLVu2dHo9hkPNJ0+exMmTJy0us2nTJpw4cQJt2rQxm2d4z1pjaX5iYiL++ecf7N+/3+Ze1cceewxLly7Fs88+i//+97/1LuspH330ESIjI3HddddZnL9q1SpERkaaXVSXkZEBAHjnnXewatUqDBo0CC+88ILV7WzcuBEALB5tiIyMxNVXX41PPvkE27ZtMxssu668vDy8/fbbmD9/PgIDA40X1ERFReHHH39EYmIili9fjgcffBCzZs3Ca6+9ZutbYKa8vJwbRWbC4TuuENFfQoiOAGYCmAKg7qdwMHQXq6wA8BQRZbmjSCY3w9Wq1s4BKyoqwtmzZ62ej6fUsWNH/Pvvv/joo48s7h0sKCgwDhnhbqdPnzYemvrmm28cPlx94403YvXq1ZgzZw4mTZqEgADrd68sKyvD77//bve6DY3e8OHDMW3aNIwcOdKh2oYPH467774bixYtwvTp0zFgwAC7n2sYnuj8+fMObdMS5bBAhr141g45Hj9+3OVt2mLtZ9fQMFjb0+ioc+fOAdCdX+us/fv3Y8+ePYiLi0NWVpbFP87GjRuH1NRUrFixAk888YRxert27QDoDlfXx/A9r/v+u+yyy/D1119j0aJFFu9WVdcPP/yAoqIiDBo0yObr8cQ5ievXr0daWhoefPDBevfYFhUVYc2aNRbn7d+/H/v377e5x9fw82w4L1bJMN3WIeJZs2YhISHBeGvFHTt24OjRo/j111/Rv39/AMB9992HtWvX4ptvvnGqSaxvSC7WODn1E0FEhUT0CIAQAB0BXAPgOuguVgkmolu5QWQGoaGhSEhIwP79+/HPP/+YzTeMk2fpfDNLevToAQAWx1cEdGOe3XTTTaisrO+UWcfV1NTg5ptvxokTJzBv3jynbjt32223YeDAgcjIyLB5X+Hnn3/e4QZo2LBhmDJlCvLy8vDkk086XN+cOXPQokULLFq0yKEhYgy30HPHoUblnsHQ0FB06NAB+/bts3gP2xUrVri8TVuWLVtmNq22ttZ4oZXhZ9JVZ86cQUREhEuHmg17EW+88UarjYfhD53ly5ebTO/duzcA3e37rDl+/Di2b98OHx8f4/IAcPfdd6NTp07Yvn27yZBGluo7evQooqKi7PpDZP369VizZk29X478rAIw3ne5vnOJrV3tOXPmTAC6i16IyOZwQoYL2izd4rO2thYbNujO2Kr7vVTKyMjAwoUL8dprrxkbOcN7TTl+bPPmzXH69Ol6a7LGkaMirHFwqEkUQphcCkdEtUSUSURriOgHIkqzcTELa6QM5+JMnjwZJ06cME5fv349XnrpJfj6+hrHDLPlwQcfRGRkJGbMmGFyJWh5eTlmzZqFpUuXoqampt69dPYwDFxr8PTTT2Pt2rWYOnUq7rnnHqfWKYTABx98gICAALz66qsYO3as2V6q3NxcTJw4EW+99ZbFMQNtmTNnDlq2bGk2SLU9oqKi8N5774GI8Pnnnzv0vJiYGLfs1SsvLzeb9swzz4CIMHnyZOMV4gDwxRdfYOXKlS5v05bt27djxowZxsOsVVVVePDBB3HgwAEMGDDA4b221mRlZRnPc3SWofGr77zScePGwd/fHzt37jSe4wvoLiJr3bo1vvvuOzz++ONm74GtW7di3LhxuHDhAh599FGTc/X8/f2NA8TfcccdeO6550wGiQZ0YykartKdP38+/P39bb6eo0eP2hymw5HzFmtra/HLL7+gSZMmxj1wnnTXXXfBx8cHjz32GLZv326cXl5ejsceewy7d+/GFVdcUe9FX8899xwGDBiAsWPHGqf169cPvr6+ePXVV42nO6Snp+PLL7906ChAXaWlpU49j2mYI+PlAKgA8D10ew393D0ej7d8gcdJtMkwDl1ISAglJydb/Xr99deJSDc+nWEMQ39/f+rbty8lJiaSEIKEEDR79myT9RvGIrM2XtuyZcsoMDCQoL//8IABAyggIMA4LmBubq5ZrdbG+4OFMRGjoqLIx8eHrrnmGnr++efp5MmTxnGoRowYYfX+r3l5eXZ9/3bt2kVJSUnGdUZFRdGQIUOMY+oJIejxxx+nXbt2mY1HZ884bStXrjSuu75xEq0xZFXf901pwoQJFBwcbHWcRGu35YuPjzepMS0tzWz56upquvrqqwkABQYGUv/+/SkhIYEA0AsvvEAhISEmtz1zJnNLDN/rlJQUEkJQs2bNaPDgwRQREUEAqFmzZrR9+/Z61+HqOIl//fWX8efLFsO9s9u0aWMytqglo0aNIgD00ksvmUzftGkTNW/enABQkyZNqGfPnnTppZdS27ZtjT8T48aNo8rKSovrXb16NbVo0YIAkI+PD3Xp0oUGDx5MzZo1IwDk6+tL06dPt/laPOXvv/82vo+dUd/7b/r06TR69Gj64osvTKbPmjWLhBDk4+NDSUlJNHjwYOP929u2bUtZWVlWt7djxw4SQtDmzZvN5j311FMEgFq2bEmDBw+moKAgCggIsGvMVkus3ZKQeTdvui2fP3RXLa8CcEoI8a4QwnxME9ZoXLhwwXgY0NKXYa+Pr68vUlNT8f7772PIkCE4evQoysrKMHbsWPzvf//DjBkzHNruxIkTsX37dtx0000AgH379iExMRHPPvssvv/+e+PhT2e9++67aNmyJf78808cOnTI5KKatWvXWj3sVVZWZtf6e/fujZ07d+KVV15B//79QUTYsWMHiAh33nkntm7dirfeegvJyclOXXxxww03YNy4cQ4/z+CDDz5w+IrOESNGoLS01OIhYUcor0oHdD8/P/74I1555RV0794d+/btQ0hICJYtW4ZnnnkGFy5csHrOlzs88cQTWLVqFXr06IEDBw4gNjYWkyZNwj///OO2cQG3bdsGAGa3F8zPzzf+fNliONR8ww032DzHzXBhk/KQ85AhQ4y3ehwwYADOnDmDHTt2IDw8HNdffz1+//13/PDDD1b3Anbv3h27d+/Gk08+ia5duyInJwf79u1DmzZtcNttt2HXrl144403bL4WTzF8H4cNG+b2dW/btg1r1qwxnqtq8Pzzz2PDhg0YM2YMysrKsHfvXnTq1AnPPvssDhw4YPHiIYOnn34a48aNw+DBg83mvfbaa3j//fcRExODffv2YciQIfj777/tGrPVkrpXSTMGAIJsXMVmsrAQEwHcDOAqAAHQX9UM4ACAJQCWEZF33IzTBUII3e5EB743zHtUV1fzuTUqOHXqFNq1a4cXX3zR4aa/LkfzO3LkCDp27IgHH3wQ8+bNc3q7lrz00kuYOXMm1q1bh+HDh7t13UpTpkzB999/j+zsbLM/DKqrqxEUFGS8st+b8ftPXpydnGb/eADPp+juX0JEzg2SaYVDexKJ6EsiuhZAcwB3AvgVuiFwugF4E8AJIcRqIcT1QgjbJ5sw5gGO3EmDuU/Lli0xYcIEixd5OMJSfhMnTkRSUhIKCwvN5hkG/3bXxSNqqKiowKpVqzBlyhSzBpGI8Ntvv9kcF9Rb8PtPXpwdU3L26uZiIvqMiK4B0ALAPQAMY3WMhW4InFwhxPtCCM+fGcxYHbL8MtWiadOmIS0tzXjo1BmW8ouPj8fBgwfx5ptvmkw/cOAA3nzzTQQEBCAlJcXpbapt9erVKC0txX333Wc2LzU1FY8++ijmz5+vQmWO4/efvDg7puTyoEhEVEREnxDRVQBaArgPwFoA4QAeALDF1W0w5gh33NaMOWfQoEGYOHGi2QDEjrCU31NPPYWOHTvi9ddfR//+/XHvvfciJSUFl1xyCXJzc/HKK6+4NPi0mogIs2fPxvTp0y1e4Tpu3Dikp6ebnavorfj9Jy/Ojim5e+TMagClAM4DqILuzituPT7OmC1JSUlql9Covf3229i0aZPTexMt5RcREYG///4bjz/+OC5cuIDPP//ceKL+r7/+6tSYkN5i5cqVKCkpMbllm8z4/Scvzo4pOXThisUVCNEcwHgAEwCMgO4uLobG8CCAr4holksbaWB84Yrc0tLS+MNOYpyf3Dg/eXF2cvLkhStOXcYkhGgH3ViJEwAMhukew0wAX0PXHNp/41nG3IQ/5OTG+cmN85MXZ8eUHL3jyrNCiB3QNYJvARiqX0e2/v+XEFFHIprBDSJTi3KMMiYXzk9unJ+8ODum5OiexNl1/p0LYCWAr4noL/eVxJhr6ru9FfN+nJ/cOD95cXZMydELV84AWABgJIDWRDSNG0Tmbere25fJh/OTG+cnL86OKTm6JzGWiGo8UgljbhIdHa12CcwFnJ/cOD95cXZMqd49iUKINvqvWADgBpHJoKSkRO0SmAs4P7lxfvLi7JiSrT2Jx6G7P3MagGQhxB9ObIOI6Aonnqe6qVOnmk1LSUmR+s4OjUFAQIDaJTAXcH5y4/zkxdnJITU1Fampqcb/H2rSzWPbqnecRCFErf6faUTUrc7/HUFE5OtUdSrhcRLlVlhYyIdNJMb5yY3zkxdnJyc1x0lcqn88pX+8050bZ8wTKisr1S6BuYDzkxvnJy/OjinV2yQS0V2K/3/m2XIYc11oaKjaJTAXcH5y4/zkxdkxJUcH0x4mhBjm4PJ9HC+LMecVFhaqXQJzAecnN85PXpwdU3J0CJz1AGodeF4qgHMA2jm4HcacFhsbq3YJzAWcn9w4P3lxdkzJ0cG0gYv3aK5/ISF6AwgH0MyJbTDmtKysLLVLYC7g/OTG+cmLs2NKtsZJfEEIUWP4gm44HNSdZu0LwA798sc9/zIYu6hjx45ql8BcwPnJjfOTF2fHlOw5bOzK5dRlAJ5x4fmMOSwtLQ1JSUlql8GcxPnJjfOTF2cngeydwIY5QMXFgc//c+YCnvfQ5myNkxgOINLwXwBHods7mGDn+k8RUZUrBaqBx0lkjDHGmNf58mYgfY3ZZPFSMQD3j5NY7+FmIiomoiz91/E607Ps/JKuQWTyS0tLU7sE5gLOT26cn7w4OwkY9iAGRgDthgLthuJ4aG+Pbc6hq5uJyJkLXRhrUHy4RG6cn9w4P3lxdhKJ7Q5M/gkA8PmPBwB45tZ8ti5caaP/4uvimTTS09PVLoG5gPOTG+cnL86OKdnak3gcunMQ0wAkCyH+cGIbRERXOPE8xpzSvn17tUtgLuD85Mb5yYuzY0r2Xt1sOBFyhBPb4Ks/WIPKzs5GfHy82mUwJ3F+cuP85MXZMSVbTeJS/eMp/eOdHquEMTdp3ry52iUwF3B+cuP85MXZMaV6m0Qiukvx/888Ww5jrisqKkJwcLDaZTAncX5y4/zkxdkxJb5amWkOf8jJjfOTG+cnL86OKTk0BE5dQgh/ANVUZ8RpIcRdAEYDKALwGxGtcrlCxhxUXV2tdgnMBZyf3Dg/eXF2TMnhPYlCiB5CiC0AzgOIrTP9TQALAVwP4B4AXwsh3nW1QCHE1UKILUKIEiHEGSHEaiGE3SNHCp1JQojNQohCIUSuEOIPIcRYV2tj3qm2tlbtEpgLOD+5cX7y4uyYkkNNohAiHsDfAAYACKgzvR2AR/X/XQVguf7fDwkhBjtbnBDiJgCrAQwEcAy6e0GnANjiwHo/h+4CnD4A0gGcBHApgFQhxCxna2PeKygoSO0SmAs4P7lxfvLi7JiSo3sSnwUQBGAfgFEA8vTTJwDwBbCaiG4motsAvAbd0DkPOlOYECIawGcAqgAMJqJkIooD8AiAQACLhRC2BgMfA+A2APsBdCCigUTUF0B3APkAZggheIh5jSkuLla7BOYCzk9unJ+8ODum5GiTOAi6cQ/vJ6Lficiwb3q0fvrXdZZdon/s4WRtt0LXDM4moi2GiUT0PoBfAXSB7XEbh+sfXyWinDrrOAjgA+he/1An62NeqmnTpmqXwFzA+cmN85MXZ8eUHG0S4/WPuwwT9HvzBur/u77Osln6x7ZOVaZrEgHgOwvzvtU/XmVjHSH6R0sDehsa3FAH62JeLicnx/ZCzGtxfnLj/OTF2TElR5tEw77oJnWm9QEQBiCTiE7VmW44ucHZy6USAJwjojQL8wx7Fm0dKv5e/zhDCNHKMFEI0QXAA9Adyv7FyfqYl0pISFC7BOYCzk9unJ+8ODum5GiTmKl/rHsv5pv1jz8rljVcWJLtaFFCCAGgOYAzVhYp0D/Wu5eSiP4H3TmMiQAy9FdJ7wCwF0AwgFv1h56Zhhw6dEjtEpgLOD+5cX7y4uyYkqPjJK4EMATAPCFEKHR7FB+C7nDut4CxwRsK4EP99B1O1BWjr+2slfmF+scQK/PryoFuD2gMLh4WB4DTcKKBZd6vS5cuapfAXMD5yY3zkxdnx5Qc3ZP4MYBDAJpCNybie9BdXPIHERnOR3wMwDrozl8kAG+6o1AFX/1jvYM6CSFuh25InkLohs6JAtAaukPNTQH8Ud+Yi71790avXr3Qq1cv9O7dGz169EDfvn3RvXt39OvXD8nJycbHBQsW4ODBgyAiZGZmory8HNnZ2SguLkZ+fj4KCgpQVFSEnJwclJaW4tixY6iurkZ6ejoAIC0tzeQxIyMDlZWVyMrKQklJCXJzc1FYWIjCwkLk5uaipKQEWVlZqKysREZGhsV1pKeno7q6GseOHUNpaSlycnJQVFSEgoIC5Ofno7i4GNnZ2SgvL0dmZiaICAcPHjRZh4yvaevWrZp7TVrMydpr2rhxo+ZekxZzsvaatm7dqrnXpMWcLL2mbdu2ae41yZzT/Pnz0aNHD5NeZMdO3X63HTt3GHuSTz/9FJ4i6twwxb4nCBEB4B0Al0N3yPZ3AA8R0Rn9/McBzIVuiJnJROTwOX/6vZGVAE4QUXsL8+MAnACwgYiGK+frlwnQLxMGoDsRHVHMvxnAVwB+JqIxinkEAI5+bxhjjDHGPGbJGOD4JqDdUGDyTwCA2T8ewPMp3QAARCTcuTmH77hCROeI6C4iakdEzYjoVkODqLcKuuFpWjvTIOq3QdA1mTFWFjFMP2VlPgB0hu68xm3KBlHvGwAV4CFwNMfwlxmTE+cnN85PXpwdU3K4SbSFiLKIKJ2IalxcVSaAcCFEsoV5hotijtbzfMOh6AuWZhJRNXRNoqt1Mi/TuXNntUtgLuD85Mb5yYuzY0ouNYlCiPZCiCuFEPcJIR4WQowWQpgdHnaS4dZ+11mYN16xjCWHoGsC+wshzC5wEUL0BRAO4F/nS2Te6OjR+v52YN6O85Mb5ycvzo4pOdUkCiEGCSE2ATgMYA2A+QD+D8BPAA7rh5oZWM8q7LEcQDmAZ+uuSwjxMHS3BNxGRHusPVm/p3ApgGYAlujPpTSsIxEX7wiz2MU6mZdp1aqV7YWY1+L85Mb5yYuzY0oON4lCiAcAbILuFn0CQBmAg9Ddz7lUP20AgM1CiHudLYyIzgK4A7qhcLYIIfYIIbKhu6L6FIDJdWpqLoT4Rf/VvM5qnoRuT+GNALL1zese6O7l3B3AUiJa5myNzDsVFBTYXoh5Lc5PbpyfvDg7puRQk6i/U8mb0DWCfwIYSkShRNSNiHoSURh04yiu0y/zlhCik7PFEdFK6Iau2QqgA3RXU68GMIyIDtRZtAl0948ejTp3gyGiEgD9AfwXwG7oLqiJ0dd+HRFNBtOc8PBwtUtgLuD85Mb5yYuzY0qODqb9OHRN2FoAVxGR2TiFRLRFCHEl9E2k/jn3O1sgEa2B7pB2fcsch64ptTSvGroheeY6WwOTS3l5OX/YSYzzkxvnJy/Ojik5eri5O3QDZL9oqUE00F/Z/Dx0jVsvp6tjzAk+Pm6/aJ81IM5PbpyfvDg7puTonsSu+sfddiz7j+I5jDUIPz9Hf6yZN+H85Mb5yYuzkweBUF2j21dX48Ebfzj6E5ELoCOAOABpNpZtXec5jDWY0tJSREZGql0GcxLnJzfOT16cnTz+PVGE62Y4db8Shzi6b9kw5MyNdix7k+I5jDUI/pCTG+cnN85PXpydPCqqrZ7x51aONomroTvP8HkhxCRrCwkh/gPdOYkE4Afny2PMcfn5+WqXwFzA+cmN85MXZ+e9amsJ+efLUVlj2hzeMzQBT45K9Nh2BTl4LFsI8R2Aa6FrAA8B+B0Xb48XD+ByAEnQNZM/EJGlO6Z4NSEEAYCj3xvmHaqrq/ncGolxfnLj/OTF2XmPvzIKkLrnFIgIlTW1+HbXSQDAVwEvY6BPGv6uTcItlc9j4/QRaBMdDCF0A7wQkcWRXpzlzE/DZABz9I9dAChv9iigu2/yEujGJ2SsQWVmZiIx0XN/WTHP4vzkxvnJi7PzDrW1hAe+3IWi0qp6lwsL9ENMaIBHa3F4T6LxiUJ0BTARugtZOkLXHGbov5YT0T53FdnQeE8iY4wxxtRQXVOLjvqLUkICfBEapNufl1dcgS2xb6Fl0U7kRfVDycQf0KFZKAB41Z5EQyEHADznxloYc4u0tDQkJSWpXQZzEucnN85PXpyd97lveAc8fHmdG9ct+QAoAlqEB6GFvkH0JJdOPhBCBAJIgO6WeUEA0gFkEFGZG2pjzCn8ISc3zk9unJ+8ODum5NTw6kKIDkKILwCUANgP3VXPKwD8C6BECLFKCMEnNjBVpKXZGsKTeTPOT26cn7w4O6bkcJMohLgZuoG0bwXgC925iBcAnNP/WwC4DsA+IcQt7iuVMfvwX8Ny4/zkxvnJi7NjSg41iUKIzgAWQneY+jiAKQBaEFE4EUUDaApgEoBM/TILeI8ia2gZGRlql8BcwPnJjfOTF2enng3pp3Hrgr8x4YPNuPHjLWqXY+ToOYmPAwgFcBjAACIqqjuTiAoBfC6EWA1gK4BOAJ4AcK/rpTJmn7Zt26pdAnMB5yc3zk9enJ165v52CHuyz5lNN1zZrBZHDzf3hW4Q7ceVDWJdRHQOwJPQHXru73R1jDkhN5dvFy4zzk9unJ+8ODv1lFbWAACahgZgWKemGNapKW7p3wbje7VWtS5HW9Qu+kd79oX+pX/s4OA2GHNJdHS02iUwF3B+cuP85MXZqW9AQgzm39ZH7TKMHN2TaLixY1M7lo3UP+53cBuMuaSkpETtEpgLOD+5cX7y4uyYkqNNYqr+8VY7lr1e/7jVwW0w5pKAAM/epoh5FucnN85PXpwdU3L0cPPLAG4E8LwQIg/AAiKqVS4khLgRwGwAhQDedLlKlUydOtVsWkpKClJSUlSohjHGGGMMOJR+CG9Z6FHczdEmsQ2ARwF8BGA+gCeFED8BOAagErq7r4wA0Eu//DIAlxvuKahERJ87WnBDWrBggdolMCdUVlaqXQJzAecnN85PXpydPDondsaCyRd7lIULF3pkO442iTuhu7oZ0F253B7AQ4pl6naEynlKXt0kMjmFhnr+fpbMczg/uXF+8uLsmJKjTeJ6XGwSGfNKhYWF/GEnMc5PbpyfvDg7puRQk0hEIzxVCGPuEhsbq3YJzAWcn9w4P3lxdkzJ4Xs3M+btsrKy1C6BuYDzkxvnJy/Ojilxk8g0p2PHjmqXwFzA+cmN85MXZ8eUuElkmpOWlqZ2CcwFnJ/cOD95cXZMSd07RzPmAUlJSWqXwFzA+cmN85MXZ9dwTp0rw+KNR1FUVgUAyDtXrnJFlvGeRKY5/New3Dg/uXF+8uLsGs4Ha49g0aajWLUzG6t2ZuN8RTUAIMDPu9oy3pPINIf/GpYb5yc3zk9enF3DKSzVDVzu6yMQGx4EAIho4o/bB7ZVsywz3CQyzUlPT0diYqLaZTAncX5y4/zkxdk1vPiYYPzxxGVql2GVd+3XZMwN2rdvr3YJzAWcn9w4P3lxdkzJ6SZRCOEjhOgrhLhPCPGMEOJV/fRgIUSw+0pkzDHZ2dlql8BcwPnJjfOTF2fHlJw63CyEuBHAmwDaKGY9C6ALgD+FEPOI6DkX62PMYc2bN1e7BOYCzk9unJ+8ODvPysgvQU5RGQDg9PkKlauxj8NNohDiMQBzAQgAtQAOA+iMi/d0rgUQDuAZIURbIrrDTbUyZpeioiIEB/PObFlxfnLj/OTF2XnOukP5uHPJdrXLcJhDTaIQojd0DSIALAfwKBGdFkLUGpYhon+FENcD+ALAbUKIJUS01m0VM2YDf8jJjfOTG+cnL87OfapqavH0N3tx4FQxACBN/6h0SUK05RVk7wQ2zAEqSkyn5+51Z5k2Obon8XHo9iD+RES3WVuIiL4TQjwH4C0ADwPgJpE1mOrqarVLYC7g/OTG+cmLs3PNnDUH8duBPAC6Q8vWrLh3EHx9gEA/X3RrFW55oQ1zgPQ11jcWGOpKqXZztEkcAN1h5dl2LLsCuiaxm6NFMeaK2tpa2wsxr8X5yY3zkxdn57z88+X4YN0Ri/O6xIahTXQwfARwXe/W1vce1mXYgxgYAcR2N50XGAoMn+5ixfZxtElspX/cZ8eyp/WPrR3cBmMuCQoKUrsE5gLOT26cn7w4O+dVVF1ssHvERaBNlO7Q/cAOMfjPwHbOrzi2OzD5J1fLc5qjTeIhAL0AtAdg68C4Ydhwy601Yx5SXFyM8HAru/CZ1+P85Mb5yYuzc4//DGyHG/spB3+Rk6PjJP6jf7zPjmVv1D/ucXAbjLmkadOmapfAXMD5yY3zkxdnx5QcbRIXAqgBcJ8Q4lkhhMXnCyGugW7MRALwqWslMuaYnJwctUtgLuD85Mb5yYuzY0oONYlEtBXAS9Bd4fwygGNCiM8N84UQHwghNgNIBRACYD4R/e7GehmzKSEhQe0SmAs4P7lxfvLi7JiSw7flI6JXANwDIBdAHADDUDgCusPQgwCcB/A0gCfcUyZj9jt06JDaJTAXcH5y4/zkxdkxJaduy0dEnwghvgJwHXR3W0kEEAggXf+1mohO17MKxjymS5cuapfAXMD5yY3zkxdnx5ScahIBgIhKASxzYy2MuUVaWhqSkpLULoM5ifOTG+cnL86OKTndJFojhAgBUEFE0g/dPnXqVLNpKSkpSElJUaEaZi/+kJMb5yc3zk9enJ25CxXVuFCha2eyCkvxw785IJDZciXlDdfypKamIjU1tUG2JYjMX6zNJwnRBbq7r6wiogv6afEAPgMwGEAFgD8B3CXjYWchBAGAM98bpr6DBw/yYROJcX5y4/zkxdmZWnswH/d9sRMV1Y7diebdW3rh2l4u3kdkyRjg+Cag3VC7BtMWQgAAiEi4tmFTDu9JFEK8CmA6dBeq/Abggn7WlwAG6v/dBMA1ADYLIboTUYUbamXMLp07d1a7BOYCzk9unJ+8ODtTfxzMs9ogxoQEWJzeoXkoLkts7smyGpRDTaIQYix0Vy0DQDaASv30S6FrEM8BmAjdWIoLAXQAcIf+34w1iKNHj6J9+/Zql8GcxPnJjfOTF2dnynAwMSTAF8+O0R2KDw30w5VdWyA4wO1n63klR1/lw9ANkP0RET1YZ/p4/ePHRPQLAAghngCwAsCt4CaRNaBWrVrZXoh5Lc5PbpyfvDg74ExJBU6dKwcAFF6oBAA0CfDFbQNcuP+yxBxtEhP1j28opo+Arnn8pc60tfrHeMfLYsx5BQUFiIuLU7sM5iTOT26cn7wae3YHcopx7fxNqKrh6xEMHB1M23Cg/ZRhghAiHEB3AFUAttZZ9pz+Mdbp6hhzAt+gXm6cn9w4P3k19ux2Hi+02CAmtWy83xdH9ySeANAJQBsAmfppI6FrNrcSUXmdZVvoH8+4VCFjDiovL2/0H3Yy4/zkxvnJi7O76K0beyK8iT/8fQUGto9RuxzVONokHoCuSXwIwONCd831Q9Adal6tWPYO/eMJlypkzEE+Pg7fbZJ5Ec5PbpyfvDi7i4Z3boamoYGe31D2TmDDHKCixHR67l7Pb9sOjjaJ/wfdRSrThBD9AQQA6A+gHLqLVCCESAbwGIBJ0DWP37ipVsbs4ufXOK460yrOT26cn7w4OxVsmAOkr7E+PzC04WqxwKGfCCLaIIR4A8BTAIbUmfUSERn2GI4CMFn/78MAPnS5SsYcUFpaisjISLXLYE7i/OTG+cmLs1OBYQ9iYAQQ2910XmAoMHx6w9dUh8N/NhDRM0KInwFcASAYwO9E9GudRS4A+BvAFgAv6u/xzFiD4Q85uXF+cuP85MXZqSi2u113VmloTp2AQEQbiehFIvqvokEEEX1MRIOJ6AkiKrG2DsY8JT8/X+0SmAs4P7lxfvLi7JgSn6XKNKcxj/OlBZyf3Dg/eXF2TMnq4WYhxDB3bYSINrprXYzZkpmZicTERNsLMq/E+cmN85MXZ8eU6jsncT10Vye7imxshzG34g85uXF+cuP85MXZMaX6mrfjcE+TyFiDSktLQ1JSktplMCdxfnLj/OTV2LKrqqnFHYu3YWfWWQBATa2HWx5LYyJ6yXiI1lhtEokooSELYcxdGtOHnBZxfnLj/OTV2LLbe/IctmSa3xQuJMAXoYEeOABa35iIKo+HaA0fBmaa09j+GtYazk9unJ+8Glt2dfccju3REnFRwRACGNmlOYL8fd2/QWtjInrBeIjWeKxJFEIEQDdW4hYieshT22FMqTF9yGkR5yc3zk9ejTm7W/q3xdBOTRtmY146JqIlTg+BI4SIEUK0sfLVFsAUAL1x8R7OjDWIjIwMtUtgLuD85Mb5yYuzY0oO70kUQoyH7h7Obex8yh5Ht8GYK9q2bat2CcwFnJ/cOD95cXZMyaE9iUKIfgBWAWgLQNj4AoCvANzkrmIZs0dubq7aJTAXcH5y4/zkxdkxJUcPNz+sf84WAPEAAgF8AN1QOZcRkQ+ATgA+0S//FxHluKdUxuwTHR2tdgnMBZyf3Dg/eXF2TMnRJrEfdA3hdCLKIqIqAO9Bt+dwJAAQ0REiugfArwBeF0Lw6JysQZWU8C3DZcb5yY3zkxdnx5QcPSextf5xd51phwFUAuiiWPYtAKMBPANgslPVMeaEgIAAtUtgLuD85Mb5yasxZPf9Pyfx454cEAFnSyvVLsfrOTsEjnFwISIiIcRx6A4z1/WP/nGkk9tgjDHGGHOL8qoaTP9mDyqra83mNQlwerAXTXO0STwBoCuAbgC21Zl+BMAIIYQfEVXrp5XpH5u5ViJjjqms5L8OZcb5yY3zk5cWsiMi7DtZjPPlVWbzLlTWGBvE2PAgNA3T7TntEReJ3m2iGrROWTjaJG6HrkF8QwhxLREV66f/A+AqAGMBfK+f1k//KO2FK1OnTjWblpKSgpSUFBWqYfYKDfXO2xsx+3B+cuP85KWF7N7/MwNv/y/d5nL3DEvAPcPaN0BF7peamorU1NQG2ZajTeJbACYBuBTAKSHEdUT0G4AfoTv38EMhRCSACgAzoTssvc3yqrzfggUL1C6BOaGwsFATH3aNFecnN85PXlrIbveJIpvLCAH0ahPp8Vo8xdLOqoULF3pkWw41iUS0XwhxLYDPAUTov0BEW4QQPwEYA2CxfnEBoBzAy+4rlzHbYmNj1S6BuYDzkxvnJy8tZZfQNASvT+hucV5cdDBaRzZp4Irk5PCFK0T0oxCiOXTnJp6uM+smAG8AuBG68RN3QTdUTpo7CmXMXllZWejYsaPaZTAncX5y4/zkpaXsQgJ9MaB9jNplSM+pq5v14yPuVkwrA/CI/osx1WjlQ66x4vzkxvnJi7NjSlabRCFEGAAQ0fmGK4cx16WlpSEpKUntMpiTOD+5cX7y4uwclL0T2DAHqLBzEPLcvZ6txwPq25N4DkCtjWUY8zr8ISc3zk9unJ+8ZMwuI78Ejyz/B3nF5QCAYgtD33jMhjlA+hrHnxcoz8VBthpAYXWGEDuhG0u7n7VlGFMD/zUsN85PbpyfvGTMbvXuHBw4VWw2vWlooOc3btiDGBgBxFq+SMZMYCgwfLrnanIzQUSWZwhRC10T6OvMfJkJIQjQDcrJGGOMMe9wrqwK/1m8Fel5ujPhqmoINbUEIYDbBrQFADTx98XEAe2Q0DTEs8UsGQMc3wS0GwpM/smz27JBCN0+PSKyunPPGXwomWlOeno6EhMT1S6DOYnzkxvnJy8ZstucUYA92efMpreObILZ4+3cm8fsxk0i05z27eUcRZ/pcH5y4/zkJUN21bUXj/Dd1C8OUcEB8PURGNOjpYpVaRc3iUxzsrOzER8fr3YZzEmcn9w4P3nJlt3USzugY3N5LgKRETeJTHOaN2+udgnMBZyf3Dg/eXlrdkSEwguVAICS8mqVq2lcuElkmlNUVITg4GC1y2BO4vzkxvnJyxuzq66pxfgPNmPfSfMrmJnn+ahdAGPu5m0fcswxnJ/cOD95eWN2RwsuWGwQm/j7onl4Awxz08jxnkSmOdXVfDhCZpyf3Dg/eXljdnUHorupXxySW0cAAAYkxCA8yF+dohoRm02iEOIPV+ZDN5biFQ5VxZgLamtr1S6BuYDzkxvnJy9vz254YnO+irmB2XPHlREuzAdM/xBgzOOCgoLULoG5gPOTG+cnL86OKdXXJC5tqCIYc6fi4mKEh4erXQZzEucnN85PXpwdU7LaJBLRXQ1ZiDVCiKsBvACgO4AKAJsBvEhE/ziwjngALwK4CkA4gIMA5gNYSnzvPc1p2rSp2iUwF3B+cuP85MXZMSWvvrpZCHETgNUABgI4BqAMQAqALUKIwXauozuAfwDcCd3r3QugG4BPAMx1e9FMdTk5OWqXwFzA+cmN85MXZ8eUvLZJFEJEA/gMQBWAwUSUTERxAB4BEAhgsRDCnvo/BxAJ4D4ALYloEICuALIBPCaE6OOJ+pl6EhIS1C6BuYDzkxvnJy/Ojil5bZMI4FbomsHZRLTFMJGI3gfwK4AusHHRjBBiIICeABYS0ceGQ8tEdBTA89BdeDPBM+UztRw6dEjtEpgLOD+5cX7y4uyYkjePk3ir/vE7C/O+he78wqsA1DcEzz36xyUW5i0DsBZAqbMFMu/UpUsXtUtgLuD85Mb5yctbsvtsyzF8uTULNbWEimrvHpZH67x5T2ICgHNElGZhnmHPYpKNdQwEUFZ3T6QBEVUR0XEiOu1inczLpKVZ+pFhsuD85Mb5yctbsnv9l4M4mHseh/NLkFV4cT9OZDAPnt3QvHJPohBCAGgOIMvKIgX6x7Y2VtUSQJ4QIhLAKwCGAWgHYD+AFQDeIyL+M0VjkpJs/e3AvBnnJzfOT17ekl15VQ0AoEOzEHSODQMAJLYIw8D2MWqW1Sh5ZZMIIAa62s5amV+ofwyxtgIhRCCAaADF0A2bkwggDcAhAL0BDAIwVggxihtFbTl48KDXHDZhjuP85Mb5yUut7M6VVuHXA7nG5rBWPzDdNd1b4olRnRu8HnaRNx9uro+v/rG+5i5a/xgP3V1fkomoBxFdAqADgG0ALgfwgLUV9O7dG7169UKvXr3Qu3dv9OjRA3379kX37t3Rr18/JCcnGx8XLFiAgwcPgoiQmZmJ8vJyZGdno7i4GPn5+SgoKEBRURFycnJQWlqKY8eOobq6Gunp6QAu7uY3PGZkZKCyshJZWVkoKSlBbm4uCgsLUVhYiNzcXJSUlCArKwuVlZXIyMiwuI709HRUV1fj2LFjKC0tRU5ODoqKilBQUID8/HwUFxcjOzsb5eXlyMzMBBHh4MGDJuuQ8TWFhoZq7jVpMSdrr8kwdKmWXpMWc7L2mkJDQzX3mrSYk6XXFBYWpspr+u/KfzB91R688MN+vPDDfhicP3/eq3O6UHrB5NHdOc2fPx89evQw60V69uyJPn36GHuS5ORkeIrwxrGk9YebKwGcIKL2FubHATgBYAMRDbeyjiDoxlUEgP5EtEMxvyeAfwH8RURDFPMMV0G7+EqYGjIzM9G+vdmPDZME5yc3zk9eDZXd35ln8MSK3ThbWgkAKK2sMVsmLNAPn919CXq3jfJ4PU5bMgY4vgloNxSY/JOqpejaJoCIhDvX65WHm4mIhBD50B12tsQw/VQ96ygXQpyDrhHeYWH+biHEeeju5MI0pFWrVmqXwFzA+cmN85NXQ2X3zc5snCwqM5t+dXIsZo/X7RULCfRDkL+v2TKsYXllk6iXCWCoECKZiPYp5hnutnLUxjpOAmgvhPAlIpM/VfQDcfsAOOeWapnXKCgoQFxcnNplMCdxfnLj/OTVUNnV6E86DAv0wy2XtAEAhAf545ZL2iImNNDj22f28+YmcTmAoQCuA6BsEsfXWaY+3wGYAd25h78p5g2B7sKXTS5VybwO36Bebpyf3Dg/eTV0dpEh/pgxpmuDbpM5xpsvXFkOoBzAs/o7pwAAhBAPAxgFYBsR7bGxjoXQXdzysf4cRMM6OuvnAcB7bq2aqa68vFztEpgLOD+5cX7y4uyYktc2iUR0FsAd0O3t3CKE2COEyIauqTsFYLJhWSFEcyHEL/qv5nXWcRzANOjGU9ypX8cuAHsBdAYwj4h+brhXxRqCj4/X/lgzO3B+cuP85MXZMSVvPtwMIlqpv7hkJnQXmFQAWA3gcSI6UmfRJgBG1/l33XXME0IcB3AXgP4A/KG7Hd8HRPSDZ18BU4Ofn1f/WDMbOD+5cX7y4uyYktf/RBDRGgBrbCxzHIDVy76JKBVAqptLY16qtLQUkZGRapfBnMT5yY3zkxdnx5R43zLTHP6QkxvnJzfOT16cHVPy+j2JjDkqPz8f8fHxapfBnMT5yY3zkxdnZ0X2TmDDHKCixHR67l516mlA3CQyzeEx2uTG+cmN85MXZ2fFhjlAej1nvQWGNlwtDYwPNzPNyczMVLsE5gLOT26cn7w4OysMexADI3S34Kv7lTgaGD5d3fo8iPckMs1JTExUuwTmAs5PbpyfvDg7G2K7q36P5obGexKZ5qSlpaldAnMB5yc3zk9enswuI/881h7Mx9qD+Th1jgftlgXvSWSak5SUpHYJzAWcn9w4P3l5KrvNGQW4bdFWj6zbadYuRrGkEVygYg03iUxz0tLS+BeVxDg/uXF+8vJUdvtzzlmcPiAhxu3bsputi1Es0fAFKtZwk8g0h39ByY3zkxvnJ6+GyG75lIFoEuCLAF8fJLUM8/j2rKp7MUpsd9vLB4Zq+gIVa7hJZJqTkZGBjh07ql0GcxLnJzfOT14NkV2PuAiEBHpR69EIL0ZxhBclxZh7tG3bVu0SmAs4P7lxfvLSZHaNeCBsd+AmkWlObm6uNj/sGgnOT26cn7w0mV0jHgjbHbhJZJoTHR2tdgnMBZyf3Dg/ebkru/KqGkxesh37TuouWKmoqXXLep1S37mHjfQ8Q0dwk8g0p6SkBKGh/NehrDg/uXF+8nJXdjuPn8WWzDNm0yOa+CPAT6XhmfncQ6dwk8g0JyAgQO0SmAs4P7lxfvJyV3bVtWT895geLdEiLAg+ArgqORb+vnwPD5lwk8gYY4wxl2w/Voi1B/NBALIKS43T7xqSgL7totQrjLmEm0SmOZWVlWqXwFzA+cmN85OXs9mVVdZg0ifbUFpZYzbPz0e4WhZTETeJTHP4fCi5cX5y4/zk5Wx258urjA2ir4+Ar9A1hv0TotCtVbjb6mMNj5vEekydOtVsWkpKClJSUlSohtmrsLCQf1FJjPOTG+cnL3dkN+vabrhtQDs3VcQsSU1NRWpqaoNsi5vEeixYsEDtEpgTYmNj1S6BuYDzkxvnJy/OTg6WdlYtXLjQI9viy4yY5mRlZaldAnMB5yc3zk9enB1T4iaRaQ7fN1ZunJ/cOD95cXZMiZtEpjlpaWlql8BcwPnJjfOTF2fHlLhJZJqTlJSkdgnMBZyf3Dg/eXF2TImbRKY5/New3Dg/uXF+8uLsmBI3iUxz+K9huXF+cuP85MXZMSVuEpnmpKenq10CcwHnJzfOT16cHVPiJpFpTvv27dUugbmA85Mb5ycvzo4p8WDaTHOys7MRHx+vdhnMSZyf3Dg/eUmdXfZOYMMcoKLEdHruXnXq0QhuEpnmNG/eXO0SmAs4P7lxfvKSOrsNc4D0NdbnB/KtIp3BTSLTnKKiIgQHB6tdBnMS5yc3zk9eUmdn2IMYGAHEdjedFxgKDJ/e8DVpADeJTHOk/ZBjADg/2XF+8pImO0uHlg2HlWO7A5N/UqcuDeImkWlOdXW12iUwF3B+cuP85CVNdvUdWubDym7FTSLTnNraWrVLYC7g/OTG+cnLkexOFJZizb5cVNXWoqS8gZtLa4eW+bCy23GTyDQnKChI7RKYCzg/uXF+8nIkuweW7cLek+fMpvsI4c6S6seHlj2Om0SmOcXFxQgPD1e7DOYkzk9unJ+86ssu/3w5Vu3MxoUK3V7Dw/nnzZZpHdkElyY282iNrGFxk8g0p2nTpmqXwFzA+cmN85NX3exKKqqxfGsWTpdUAAAWbMi0+Jz/DGyHGWN0t/ML8PWBj08D7klkHsdNItOcnJwcvnOAxDg/uXF+8qqb3Rd/H8frvxy0uJyfvhFsGhqI8b1bI8jft8FqZA2Lm0SmOQkJCWqXwFzA+cmN85NX3ezyisuN/26ibwJDAv0wc1xXjO3RqsFrY+rgJpFpzqFDh9ClSxe1y2BO4vzkxvnJy1J2YUF+2DvzKnUK4lvtqY6bRKY5/AtKbpyf3Dg/eamWnbVm8Pim+p/HYyJ6HDeJTHPS0tKQlJSkdhnMSZyf3Dg/eamWna37LgNAu6Gm/+cxERsEN4lMc/gXlNw4P7lxfvJSLTt77rvcum/D18W4SWTac/DgQT7kJTHOT26cn7xUz44Hx/Y6PmoXwJi7de7cWe0SmAs4P7lxfvLi7JgS70msx9SpU82mpaSkICUlRYVqmL2OHj3K47RJjPOTG+cnL85ODqmpqUhNTW2QbQkiapANyUQIQQDA3xs5lZeX8/1jJcb5yY3zk9fBk4XIOV8FAPhy6wn8npbXMEPgLBmju5K53VA+3Owkob9nNhG59ZY3vCeRaU5BQQHi4uLULoM5ifOTG+cnp73Z55Ayb4vaZTAvw00i0xxrN6hncuD85Mb5yenAqXMWpw9sH+O+jfDg2NLhJpFpTnl5Of+ikhjnJzfOT36LJ/VD09BA+PkKJMW6MUtb4yHy4Nheh5tEpjk+PnzRvsw4P7lxfvJLahmOVpFN3L9ie8ZDZF6Fm0SmOX5+/GMtM85Pbpwfs4nHQ5QGv5uZ5pSWliIyMlLtMpiTOD+5cX5yqK0l3L9sJ7YeLQQAVFTVqlwR80bcJDLN4V9QcuP85Mb5ySEttxi/7s8zmx7g54OwIG4NmA7/JDDNyc/PR3x8vNplMCdxfnLj/ORQXXNxHODLuzRHXFQTnD9/HuP6d0BYkL+KlTFvwk0i0xweo01unJ/cOD/1FJVWYtXObBSXVdlcNre43Pjv2wa2xcguLVBdXc3nlDIT/NPANCczMxOJiYlql8GcxPnJjfNrWNU1taio1p1P+NrPB/H1jhMOr8NHf7cOzo4pcZPINIc/5OTG+cmN82s4+06ewx2fbEPhhUqzecLOm7Mlt4rAJQnRADg7Zo6bRKY5aWlpSEpKUrsM5iTOT26cX8P582C+xQbx8i7NsfjO/g6vj7NjStwkMs3hDzm5cX5y4/waTi1dvPjkmau7QAggyN8XVye3dGp9nB1T4iaRaQ7/NSw3zk9unJ86pl7aHsLeY8xWuDU7S/dp5ns0S4ebRKY5/AtKbpyf3Dg/ebk1u/ru08z3aJYG32STaU5GRobaJTAXcH5y4/zk5dbs6t6nud3Qi1+Jo/kezRLhPYlMc9q2bat2CcwFnJ/cOD/X/JGWh6+3n0BNLdlcNrPgglu37ZHs+D7NUuMmkWlObm4u/6KSGOcnN87PNU9/uxenz1c49Jwgf/ccFOTsmBI3iUxzoqOj1S6BuYDzkxvn55rz5bq7pTQNDUBsRJDN5X2FwE3927h80QrA2TFz3CQyzSkpKUFoKJ8YLSvOT26cn3tc3ycOz1zTsBcBOZWdpauYAb6SWSO4SWSaExAQoHYJzAWcn9w4P3k5lV19VzEDfCWz5LhJZIwxxphz6l7FHNvddF5gKF/JLDluEpnmVFaa36aKyYPzkxvnJy+XsuOrmDWJx0lkmsPnQ8mN85Mb5ycvzo4p8Z5EpjmFhYX8YScxzk9unJ9j1uzLxRtrDqK0shoAUF5Vq1otnB1T4iaxHlOnTjWblpKSgpSUFBWqYfaKjY1VuwTmAs5PbpyfYz7ZdBRHLQyKHRPa8BcAcXZySE1NRWpqaoNsSxDZHtW9sRFCEADw90ZOGRkZ6Nixo9plMCdxfnLj/Bwzfv5m/HuiCLHhQbisczMAQPPwINw9NAERTfwbtBanslsyBji+SXfLPT4nUTWGcTKJyPUBM+vgPYlMc/gXlNw4P7lxfs5JjA3D69f3ULUGzo4p8YUrTHPS0tLULoG5gPOTG+cnL86OKXGTyDQnKalh71LA3IvzkxvnJy/Ojinx4WamOWlpafxhJzHOT26cn7zqzY5vv9cocZPINId/QcmN85Mb5yeverPj2+81Sny4mWlOenq62iUwF3B+cuP85FVvdnVvv9duqOlX4mi+/Z5G8Z5Epjnt27dXuwTmAs5PbpyfvNq3b2/7sDLffq9R4SaRaU52djbi4+PVLoM5ifOTG+dnW0FJBYpKqwAA5VU1KldzUXZ2NuL/4sPK7CJuEpnmNG/eXO0SmAs4P7lxfvX7ac8pPLx8F2q98F4NzZs3Nz2sHNvddIHAUD6s3Mhwk8g0p6ioCMHBwWqXwZzE+cmN8zN1oaIab/8vHcfPlAIAfk/Ls7hcYnP199AVFRXBmBwfVmbgJpFpEP+CkhvnJzfODzhXVoWM/PMAgG93ncSyrVkWl3vv1t4AgLAgPwzt2LTB6rOGs2NK3CQyzamurla7BOYCzk9ujT2/sxcqMWzOWpRUmH8fWkUEITI4AP5+Ppg6rD3G9GipQoXWNfbsmDluEpnm1NbWql0CcwHnJ7fGmN9nW44hdXcOiIAdx89aXKZdTDD+fOIy+PqIBq7Ofo0xO1Y/bhKZ5gQFBaldAnMB5ye3xpZfaWU1ZqUeQLWFK1Gmj+6M5FYREALo3TbKqxtEoPFlx2zjJpFpTnFxMcLDw9UugzmJ85NbY8uvsrrW2CAmNA1Bq0hdo9WrTSTuH94BQnh3Y1hXcXExGk9yzB7cJDLNadpU/RPAmfM4P7k1hvxKKqqxMf00KmtqUVp5cZzDOwa1w+QhCSpW5iDFwNmtamuB/P0qF8W8CTeJTHNycnL4rg8S4/zk1hjyu/+Lndh4uEDtMlynuB+zyX16edBsBm4SmQYlJEj0lzwzw/nJrTHkdzivxGxaE39fDGwfo0I1LlAMnE0gCAgeNJsZeX2TKIS4GsALALoDqACwGcCLRPSPk+sTANYAGAXAj4i8555IzC0OHTqELl26qF0GcxLnJzct5FdVU4s/0vKRf74cALAh/TTWHjqNqOAAAMCZCxUAgKuTY/HkVZ0BAM3CAhEe5K9Owa7SD5x96OBB6bNj7uXVTaIQ4iYAy6Crcz+ASAApAEYJIUYS0V9OrPYh6BpEplH8ISc3zk9uWshv1c5sPPPtXrPpBSUVJv9PaBqCDs20c1hWC9kx9/KxvYg6hBDRAD4DUAVgMBElE1EcgEcABAJYLIRwqH4hRFcAc9xeLPMqaWlpapfAXMD5yU0L+R07c8HqvIkD2mLigLZ4ZGRH3DNMW+deaiE75l7evCfxVuiawRlEtMUwkYjeF0KMAXAVgBEA/rBnZUKIAOj2Sl4AUAYgyu0VM6+QlJSkdgnMBZyf3GTNj6jOOIf6fwb4+WDL0yON/w6T9XCynWTNjnmO1+5JhK5JBIDvLMz7Vv94lQPrexlALwD3ATjnfFnM2x08eFDtEpgLOD+5yZjfmZIKXPH2eiQ88zMSnvkZH2/IBAAIADGhgYgJDdR8gwjImR3zLG9uEhMAnCMiS/u/DXsW7fqzRwgxHMCTAD4jolVuqo95qc6dO6tdAnMB5yc3GfPblFGAI6fNDzG3jmyiQjXqkTE75lleebhZfwVycwBZVhYxDFDV1o51RUB3buMJAA+7pUDm1Y4ePar5cdq0jPOTm7fkd7TgAlbsOIHyKtsDWGTkXxzS5s7B8YgM9oefj8Do5JaeLNHreEt2zHt4ZZMIIAa62izfKR0o1D+G2LGu+QDiAIwgomI31Ma8XKtWrdQugbmA85Obt+T3/Pf7sCnD8QGv7xmWgLioYA9UpCLFnVWMck2v4PaW7Jj38ObDzfXx1T/W1reQEOJmALcBmEtEGxzdSO/evdGrVy/06tULvXv3Ro8ePdC3b190794d/fr1Q3JysvFxwYIFOHjwIIgImZmZKC8vR3Z2NoqLi5Gfn4+CggIUFRUhJycHpaWlOHbsGKqrq5Geng7g4lVlhseMjAxUVlYiKysLJSUlyM3NRWFhIQoLC5Gbm4uSkhJkZWWhsrISGRkZFteRnp6O6upqHDt2DKWlpcjJyUFRUREKCgqQn5+P4uJiZGdno7y8HJmZmSAi4zkphnXI+JrS09M195q0mJO117Rnzx7NvSYt5mTtNaWnp3vFazpZeB4A4OsDhAb6Gr/CAn0RGuCDsEA/hAT4ICzIDyH+useR7UPROrKJ9nIy3Fnl+CbTrwrd6fmVIgBFRUU4fPiwPK+pEbyf5s+fjx49epj1Ij179kSfPn2MPUlycjI8RZhc0eUl9IebKwGcICKzfd9CiDjoDh9vIKLhVtYRB2APdIesLyGiyjrzjgKIh5XBtIUQBCiudmPSKC4uRng436ZeVpyf3Lwlv6ve2YBDeecxulssPvpPX7XLUdeSMbqmUH9nFROGu6u07us12THH6domgIiEO9frlYebiYiEEPnQHXa2xDD9VD2ruRy6YW5yAPxg+AbqtdA//iyEqAUwq+4wO0xu5eXl/EEnMc5PbpyfF9PfWcUazo4peWWTqJcJYKgQIpmI9inmDdY/HrVjPd30X5YY7rzykRP1MS/l4yPrWRQM4Pxkp1Z+JwpLMe/PDJwt1R00OllUpkodMuP3HlPy5iZxOYChAK4DoGwSx9dZxiIi+hTAp5bm2TrczOTm5+fNP9bMFs5Pbmrlt2BDJr7eccJsepMAXwtLM0v4vceUvPnPhuUAygE8K4QYaJgohHgYuj2A24hoj1rFMe9VWlqqdgnMBZyf3NTKr7i8CgDg7yvQJTYMXWLDMCAhGncNSVClHhnxe48pee2fDUR0VghxB4AvAWwRQuwFEA2gNXTnIk42LCuEaI6Lew0nEVF+Q9fLvEdkZKTaJTAXcH5yUzu/1pFNsObRS1WtQVZqZ8e8jzfvSQQRrQSQAmArgA4AggGsBjCMiA7UWbQJgNH6r8Y1RD4zk5/PfyPIjPOTG+cnL86OKXntnkQDIloDYI2NZY5Dd5tNe9fJxx80LC4uTu0SmAs4P7lxfvLi7JiS1zeJjDkqMzMTiYmJapfBnMT5yY3zU5Gdd1axhrNjStwkMs3hDzm5cX5y82R+B3OLcSDH8t1Vswr5ogvjnVWsCQyt9+n83mNK3CQyzUlLS0NSUpLaZTAncX5y81R+x89cwOj/2+j29WqKYQ9ifXdWqQe/95gSN4lMc/hDTm6cn9w8lV/m6Qt2LXdl1xa2F9I6G3dWsYbfe0yJm0SmOfzXsNw4P7k1RH4f3d4HSS3Nbx8X6OeL2Iggj25by/i9x5S4SWSawx9ycuP85NYQ+cVGNEG7mBCPb8druXiBijX83mNK3CQyzcnIyEDHjh3VLoM5ifOTmzvz25V1Fmv25SL7bCkO5p53yzo1wcULVKzh9x5T4iaRaU7btm3VLoG5gPOTm7vyu1BRjYkL/0Z5Va3ZvGZhgW7ZhlextnfQEsMeQycvULGG33tMiZtEpjm5ubn8YScxzk9ujuZXUV2DmloyX09xubFBbB4WiM6xYYiLCsaIzs3QOlKDN9aytXfQknaDgIlfu60Efu8xJW4SmeZER0erXQJzAecnN0fyW74tCy+u3o/KavO9hXU9MSoRN/fXePNS3/A1lriwx9Aafu8xJW4SmeaUlJQgNNS5c3KY+jg/uTmS3w//nrTZIAJAm6hgV8uSh5PD17gDv/eYEjeJTHMCAgLULoG5gPOTmyP5GY4yt40Oxm0DLO8pbN8sFIM6xLijNGYDv/eYEjeJjDHGVNUqMgj3Du+gdhmMMQVuEpnmVFZWql0CcwHnJzdb+Z0+X4GiUt0yZZU1DVESsxO/95gSN4lMc/icGrlxfnKrL79f9+figWW7LF7NzNTH7z2m5KN2AYy5W2FhodolMBdwfnKrL7/NGQUWG8TOLcI8WRKzE7/3mBLvSWSaExsbq3YJzAWcn9yCI2Kw/ZjlZiOvuBwAEBLgizdu6KH7d6AfhnZs2mD1qc5Dt9RzB37vMSVuEpnmZGVl8a2lJMb5yau4vArD39qAC5X1D2sT4OeDsT1aNVBVXsZDt9RzB37vMSVuEusxdepUs2kpKSlISUlRoRpmL/6QkxvnJ6/DeSU2G0QA6Nkm0vPFNCQvuKWeO/B7Tw6pqalITU1tkG0JIj6BWEkIQQDA3xs5paWlISkpSe0ymJM4P+/22/5cLNiQicoa82bwQkU1jpy+AAD471Wd0TMu0mwZP1+Bvu2i4O+roVPiv7zZ8VvqJY526y313IHfe/ISQgAAiEi4c728J5FpDn/IyY3z825v/ZaOQ3nnbS43qEMM+rSNaoCKvIAX3FLPHfi9x5S4SWSaw38Ny43z825lVbqxDVuEB6Jry3Cz+SUlJRjUJQ69tXZI2R4q3lLPHfi9x5S4SWSawx9ycuP85DC4Q1O8c3MvtctgbsTvPabETSLTnPT0dCQmJqpdBnMS56eumlrC+vR8nDpXbnH++fKqep/P+cmLs2NK3CQyzWnfvr3aJTAXcH7q+uHfk3h8xW6by1k7O57zkxdnx5S4SWSak52djfj4eLXLYE7i/Dxv38lz2HLkjMV569NP23x+gK8PruzawuI8zk9enB1T4iaRaU7z5s3VLoG5gPPzrHNlVbj+w79QUV3/eIY+Avj7mcstzgsO9ENooOVfH5yfvDg7psRNItOcoqIiBAcHq10GcxLn51kFJRU2G0QAuKlfGzQPD3J4/ZyfvDg7psRNItMc/pCTG+fXcOZc3wPX9GhpNt1HAMEBzv164PzkxdkxJW4SmeZUV1erXQJzAefXcAL9faweNnYW5ycvzo4paei+SIzp1NbaPpTGvBfnJzfOT16cHVPiPYlMc4KCHD+PinkPzs8+5VU1KCqtf8xCSwrOV3igmos4P3lxdkyJm0SmOcXFxQgPN79dGJMD52fbodzzuOGjv3C+3PsOD3J+8uLsmBIfbmaa07RpU7VLYC7g/GzblFHglgaxQ7NQN1RjivOTF2fHlHhPItOcnJwcvnOAxDg/neqaWhw5fQEEMpuXV3zxlnkvjO2KJgG+Dq8/sUUokltHuFSjJZyfvDg7psRNItOchIQEtUtgLuD8gNpaQsq8zUg7VWxz2Rv6xSE8yL8BqrIP5ycvzo4pcZPINOfQoUPo0qWL2mUwJzXW/GpqCftzzqGqphbnyqrsahBbRzZBiJPjGXqKpvPL3glsmANUlJhOz92rTj1upunsmFMEkfmhjMZOCEEAwN8bxpinEBH25xQbzy18YNlOnLVwtfIt/dtgeGIzs+lCCAxIiEZUSIDHa2V6X94MpK+xPj9xNDDx64arhzE9IQQAgIiEO9frXX+CMuYGaWlpSEpKUrsM5qTGkt87/0vHe39m2Fzupv5t0KdtVANU5B6azs+wBzEwAojtbjovMBQYPr3ha3IjTWfHnMJ7Ei3gPYmMMXfLPluKl1IPIF8/TuHuE0UWlxvXsxVu6BsHAGgXE4x2MSENVSIzqO+wcsU5oN1QYPJP6tTGmAW8J5ExOx08eJDPq5GYzPmdOldmbP5KK2sw99dDiAzWHQ4+YOUcw0A/HyydfAkAoGloADq1CGuQWj1F5vyMNsyp/7ByoPuHDvIGmsiOuRXvSbSA9yTKjYiMf1Ux+cia37myKgx89Q+UVdXYXNZwjmFIoC/uG94BPeIiPVxdw5E1PxNLxgDHN9V/WLl1X3Vq8yBNZNdI8Z5Exux09OhRHutLYt6c3097TuG9Pw6jotq8ETx2ptTq80Z2aQ4fIeDnI3DLJW1wWefmnixTVV6bn7VDyJYYrlaO7d6oDit7bXZMNdwkMs1p1aqV2iUwF3hzfh+sy8ChvPM2l3t5fDL6tdNdbNKhWSgC/BrPza28Nj9bh5At0ehhZWu8NjumGm4SmeYUFBQgLi5O7TKYk7w5v4rqWgBAq4gg9E+ItrhM15bhuH1A20Z72M5r86vvymRLNHC1sqO8NjumGm4S6zF16lSzaSkpKUhJSVGhGmYvvkG93GTIr3fbKLx7S2+1y/BKXp9fIzuE7Aivz44BAFJTU5Gamtog2+ImsR4LFixQuwTmhPLycv6wkxjnJzfV89P4XVE8SfXsmF0s7axauHChR7bFTSLTHB+fxnP+lxZ5U37r00/jiRW7ca6sEgBQVcMjHtiien6NdPgad1A9O+Z1uElkmuPnxz/WMlMzv4rqGny76yRyisoAAO9buSNKbERQQ5YlFdXffxq/K4onqZ4d8zr8E8E0p7S0FJGRkWqXwZykZn6pu0/hmW8tH5Z84LIOAIDIYH/c1K9NQ5YlFbfn58jQNUCjHb7GHfizkylxk8g0hz/k5KZmfrnnyoz/FgIQAIL8ffHU6C6YNDhetbpk4vb8nBm6BuDDyk7gz06mxE0i05z8/HzEx8erXQZzkrfklz77avj78jlajnJ7fo4OXQPwYWUnect7j3kPbhKZ5vA4X3Lj/OTmsfz48LHH8XuPKfGfyUxzMjMz1S6BuYDzkxvnJy/Ojilxk8g0JzExUe0SmAs4P7lxfvLi7JgSN4lMc9LS0tQugbmA85Mb5ycvzo4pcZPINCcpKUntEpgLOD+5cX7y4uyYEjeJTHP4r2G5cX5y4/zkxdkxJb66mWkO/zUst4bMr7qmFrN/SsOBU8UAgJNny2w8g9nC7z95cXZMiZtEpjkZGRno2LGj2mUwJ3k6v6LSSvyTVQQA+OtIAZb+dcxsmSb+vvARwmM1aBm//+TF2TElbhKZ5rRt21btEpgLPJlfRXUNrnh7AwpKKszmhQX6oVvrcPgIgev7xMHXh5tEZ/D7T16cHVPiJpFpTm5uLn/YSczd+a3YfgJL/zqGmlpC9tlSXKisMVumaWgANk4fiSYBvm7bbmPF7z95cXZMiZtEpjnR0dFql8Bc4O785vx6EAUllWbTHxzRAVd2jQUAJLYI5QbRTfj9Jy/Ojilxk8g0p6SkBKGhoWqXwZzkan6lldX482A+Sit0ewyLy6sBAO1igpEUGw4A6Ng8FI9c3gkBfjzAg7vx+09enB1T4iaRaU5AQIDaJTAXuJrfiz/sx8qd2WbTr0hqgefHdnVp3cw2fv/Ji7NjStwkMsaktie7CI+v2I0z+otRzpZWmS0T6OeDEZ2bN3RpjDEmNW4SmeZUVpqff8bk4Wh+3+46iYz8ErPplyRE452bewEAwoP8EBbk747ymA38/pMXZ8eUuElkmsPn1MjN0fyqamoB6PYW3ty/jW4dgX64bWA7tI5s4vb6WP34/Scvzo4pcZPINKewsJA/7CTmbH5hQX6YdW2yBypijjDJL3snsGEOUGG+p9duuXvdUxiziT87mRI3iUxzYmNj1S6BucCe/GpqCZXVuj2I1TXk6ZKYA0zy2zAHSF/jnhUHcvPiafzZyZS4SWSak5WVxbeWkpghv+LyKpC+//tl7ykczi+BAHDibCl+3Z+nao3MOpP3n2EPYmAEENvd+ZUGhgLDp7teHKsXf3YyJUHEf4UrCSEIAPh7w5g6pny2A/874Fgj2KtNJL5/cIiHKmL1snZYOXcvUHEOaDcUmPyTOrUx1ggI/b3micit9xPlPYn1mDp1qtm0lJQUpKSkqFANs1daWhqSkpLULoM5acfu/fU2iCEBvqgloKyqBk9f3QUA4O/rg6uT+VCZamwdVuZDxVLgz045pKamIjU1tUG2xXsSLeA9iYypp7i8Cj1m/gYAuLJrCwxsHwMA6BEXgf7xfNswr7RkDHB8k+XDyoZDxa37qlMbY40A70lkzE7817Dc0g+lG/89ICEadw9NULEa5pDY7kgbOJfff5Liz06mxE0i0xz+kPN+madL8NH6Izivv69yXVV8tbLU+P0nL86OKXGTyDQnPT0diYmJapfB6jHvzwx8+89Jm8sF+fs2QDXMnfj9Jy/Ojilxk8g0p3379mqXwGw4V6a7v3KAnw/iY4JN5hEBQgBto4P5YhQJ8ftPXpwdU+ImkWlOdnY24uPj1S6D2SGxRSh+fHiYybRjx45xfhLj95+8ODum5KN2AYy5W/PmzdUugbmA85Mb5ycvzo4p8Z5EpjlFRUUIDg62vSBrMDlFZXhx9X7kFZcDAI6evmB1Wc7Py1kaOLvO/ZU5P3lxdkyJm0SmOfwh532+2ZltcYDssEB/s2mcn5erb+DswFDOT2KcHVPiJpFpTnW1+bAqTF1lVTXGf4/o3AwA0CTAF1OGmZ8oz/k1MGu31LPGsNdQOXC2ftBszk9enB1T4iaRaU5tba3aJTAr/H0Flky+pN5lOL8GZuuWeta0GwRM/Npscm1+vhuKYmrg9x5T4iaRaU5QUJDaJTAXcH4NzLAH0dIt9awx3GrPAs5PXpwdU+ImkWlOcXExwsPD1S6DOYnzU0lsd2DyTy6vhvOTF2fHlLhJZJrTtGlTtUtolPZkF2Hb0UKL8/49UWT3ejg/N3DkPMM6Vya7A+cnL86OKXGTyDQnJyeH7xzQAI6cLsH/DuShppZwrqwKCzZk2nyOEMLmMpyfGzhznmFgqFs2zfnJi7NjStwkMs1JSEhQuwRNyj1Xjh/+PWm8Uvn/fj/s8Dpu6BtncxnOzwHW9hhauwLZmnrOMXQU5ycvzo4pcZPINOfQoUPo0qWL2mVoznPf78XvafVfudosLBDf3j8YkcHm4x/6CIGQQNsfOZyfBdaaweOb6n+elSuQPYnzkxdnx5QEEaldg9cRQhAA8PeGsYuueXcjDpwqNpnWNDQAiyb1R1LLMABAgK+PXYeUmRXONoMA0G6o6f8Newdb93VffYwxr2T43CUit34A855EpjlpaWlISkpSuwzNuiKpORbe0c/4f3c3hY06P3vOJfTyZrBR5yc5zo4peX2TKIS4GsALALoDqACwGcCLRPSPA+uYCGAKgC4A/AHsAfAZES11e8FMdfwh57zyqhqcK6uyOK/aONCu8OjewkaTX333QLZ0LqGXNYPWNJr8NIizY0pe3SQKIW4CsAy6OvcDiASQAmCUEGIkEf1lxzoWArgHQBWAAwBqAQwFMEIIMQ7A9cTHlTXl4MGDfF6NEw7kFOPmj7fgfIW6t+ZqNPnVt9dQhXMJ3aXR5KdBnB1T8tomUQgRDeAz6Jq7S4loi376wwDeA7BYCNGNiKzeR0gIMRC6BjELwGgiStNP7wjgWwDXAZgK4GNPvhbWsDp37qx2CVLanFFgV4PYvlmIR+toNPlZu9OJG680VkOjyU+DODum5LVNIoBbAQQCmGFoEAGAiN4XQowBcBWAEQD+qGcdd+ofXzI0iPp1ZAghJgHYBeAOcJOoKUePHuWxvpxAuLhD/cWUrgj08zVbJryJH65IauHROjSXn61hatx0pxNvobn8GhHOjil5e5MIAN9ZmPctdE3iVai/STT8tK9TziCif4QQZwH0cKFG5oVatWqldgnSu6lfG7uGq/EEzeVn62IUNw1i7S00l18jwtkxJW9uEhMAnKu7B7AOw55FW2fZ/g3gOICTyhlCiCAAoQAs30eMSaugoABxcbYHbWbeSXP5WTusDEh/aNkSzeXXiHB2TMkrm0Shu3SyOXTnElpSoH9sW996iOiFemZPg+5K5w0OF8i8Gt+g3j61tYQ5vx7C3pNFAICTZ8vULUhPs/lp7LCyNZrNrxHg7JiSVzaJAGKgq+2slfmGvX8On0Gvb0AfBfAKdEPqvOJEfcyLlZeX84edFefLq7D7xDkQCDuPn8VH64+YLRPg6wM/X/UGxOb85Mb5yYuzY0o+ahfgJMMZ9VavbLZECNEXwF8A3tY/dxIR7ba2fO/evdGrVy/06tULvXv3Ro8ePdC3b190794d/fr1Q3JysvFxwYIFOHjwIIgImZmZKC8vR3Z2NoqLi5Gfn4+CggIUFRUhJycHpaWlOHbsGKqrq5Geng5AN4hp3ceMjAxUVlYiKysLJSUlyM3NRWFhIQoLC5Gbm4uSkhJkZWWhsrISGRkZFteRnp6O6upqHDt2DKWlpcjJyUFRUREKCgqQn5+P4uJiZGdno7y8HJmZmSAiHDx40GQdMr6mM2fOaO41OZvTiZxc/LgjA6t3ZOKrjQfQfeZvuH3xVvxn8TaTey/7CKBr80BcEh+NBwY2g6itUe01nThxQsqcSg6tR9nicahdfDXKPhwJWnINSuePuHiBioSvyZmfvTNnzmjuNWkxJ0uv6ezZs5p7TTLnNH/+fPTo0cOsF+nZsyf69Olj7EmSk5PhKV55Wz793r5KACeIyOxSKyFEHIATADYQ0XA71hcI4GUAT0DXGO+FrkG0OCA335ZPbkVFRYiMjFS7DK/wn8VbsfFwQb3LhAX54a+nRyIsyPx+y2rwqvysXZlsia1b5yWOlnbsQ0d4VX7MIZydvBrVbfmIiIQQ+dAddrbEMP2UrXUJIVoDWAMgGbpzGV8AsICIatxRK/M+paWl/EGntz+n2OL02eOT0SVWd7/lxNgwr2kQAZXyc+WeyZZYu3VeI8DvP3lxdkzJK5tEvUwAQ4UQyUS0TzFvsP7xaH0rEEKEAfgJugbxJwB3EVG+2ytlXqUxf8htOlyA135JwwX9oNhFpZUAgKuTY3Hf8A4AgNZRTdA0NFC1Gm1RJT9n7plsiSS3zvOkxvz+kx1nx5S8uUlcDt3t864DoGwSx9dZpj6PAOgJYCWAW+q7OwvTjvz8fMTHx6tdRoNIzzuP/67ag4LzFQCAk0WWr1Du1DwUPdtENmBlzlMlP3uGqWnEjZ8jGtP7T2s4O6bkleckAoAQIgpAjv6/I4job/10w235thHRABvrOAYgDkBLIjrtwLb5nESJVVdXw8/Pm//+cZ/XfknDx+szLc67tpduYNymoYG4/7IOXr33sC5V8lsyRndoud3QRjFMjSc1pvef1nB28mpU5yQCABGdFULcAeBLAFuEEHsBRANoDd25iJMNywohmgP4VP/fSUSUL4SIAdAOQDmAzwzfQAvOEtFED70MpoLMzEwkJiaqXYZHEBHWpZ9G5ukLAIB/sooAAP6+Atf2ag0ACA30w6TB8Uho6tl7LHuKR/OzdYs85jItv/+0jrNjSl67J9FACDEawEwA3aEb13AjgMeJ6EidZdoBOKb/bzwRHdcPd7PDjk3kElFLxTZ5TyLzCjW1hCmf7cDWzDMAgAuVlq+3Cg/yw56ZVzVkaXL68ub6zz1sJFcgM8a0pdHtSTQgojXQXZ1c3zLHAQjFtJ3KaaxxSEtLQ1KSrTs2yiHtVDH+PGj7WqsJfbRzKy2P5tfIbpGnBi29/xobzo4peX2TyJijtPQhV1N7cW/2qK4t0DY6GASgX7soDO7YFADg6yMQGqidt3KD5NdIbpGnBi29/xobzo4paec3C2N6Wv1r+JZL2mBklxZql+FxbsmPzz1UjVbff40BZ8eUuElkmiP7h9yOY4VYsy8XtQScLqlQu5wGZzU/d979JDDU8cKYXWR//zVmnB1T4iaRaU5GRgY6duyodhlOqakl3PPZDhSVVpnN8/OR9VbrjrGanz0DXlvSiO9+ogaZ33+NHWfHlLhJZJrTtm1btUtwWlVNrbFBDPD1QaCfrjHs1joclyREq1lag7GaX30XnVjCg2CrQub3X2PH2TElbhKZ5uTm5mriw+7RKzvhgcsa31/1NvPji068mlbef40RZ8eUuElkmhMd7d173E4UluLjDUdwrqzabF5tLY/N6e35sfpxfvLi7JgSN4lMc0pKShAa6r0XJnywLgPLt52wuVygn28DVON9vD0/Vj/OT16cHVPiJpFpTkBAgNol1MtwzqG/r0CbqGCLy7SOaoKxPVpanCclB65MjqmuAvz8zWfw8DVS8Pb3H7OOs2NK3CQy5mGFFyrxxi8HkXOuDABwIKcYAJDQNAS/PTZczdLcz1ozaGtImjostIemePgaxhhrENwkMs2prKxUuwQT3+7Kxtc7zA8vBwdo8O1nzzA1yiFpFCorK63v0eDha7yet73/mP04O6akwd9SrLHzhnNqThaVIT3vPABg38lzxum920ZCAAjy99Xmlcv23BvZxpA0lSUlCPCCDJlzvOH9x5zD2TElbhKZ5hQWFqr6YZd1phSXzV0LSxcqf3v/YAghGr6ohubCMDVq58dcw/nJi7NjSo3jFg6sUYmNjVV1+wdOFVtsEPvHRzWOBtFFaufHXMP5yYuzY0q8J5FpTlZWltfcWuqdm3siPiYEvj4CXVuGq12OFLwpP+Y4zk9enB1T4iaRaY4aH3IzV+/H72l5AICyyhrj9M4twtG1FTeHjuBfUnLj/OTF2TElPtzMNCctLa1Bt5dTVIalfx1D9tkyZJ8tw5kLF68QjAy2OaALU2jo/Jh7cX7y4uyYEu9JZJqTlJTk8W3kFJXhj7Q8VNcSCus0hf3aRaFtjG6A7MEdmqJVZBOP16IKa+MhumHA64bIj3kO5ycvzo4pcZNYj6lTp5pNS0lJQUpKigrVMHulpaW5/cOu8EIlftp7CmWVuvstv/rzQYvL3T6wHcb3bu3WbXslW+MhujDgtSfyYw2H85MXZyeH1NRUpKamNsi2BJGFyzAbOSEEAQB/b5jBw8v/QerunHqXaREeiNUPDUWL8KAGqkpFS8bo7qLiwniIjDHG3MMwcgYRuXUIDd6TyDQnPT0diYmJLq3j78wzeOjLf1B4oQIALA5pE+Drg4//0xe920YCAEID/eDn+//t3XmcHGWdx/HPb+5ck4OQQBKSSYAcCCQcIiAYkVMgeKByiMoql6yIiuuu+vJEdz1WXXVdVNSAKIrIGeSQVSAQQJZLSEiCkAOSCeQ+JsnMZGae/aOeJp3q6p7pnuqjer7v16tela6rn6pfuvs3T9XzPAPsMd9+9IeYTRzxk/JR/JJLsZMwJYlSdaZMmdLvY9z591bWt3VkLJ8zcxzfem9Qc9ZQV0P9QEsKSyCO+En5KH7JpdhJmJJEqTqrVq2ipaWlX8fo8VWHQxpq+ehxkwEY1lTH2YdPYEjjAPrYFLGBSta3jCF+Uj6KX3IpdhI2gH7tZKAYM2ZMbMca2lTHVadMi+14iVPEBirZxBk/KT3FL7kUOwlTkihVZ/PmzQwePLjcxUieqFrDVI1hrgYqMVP8kk3xSy7FTsKUJErV0ZdcgXLVGk46Bs6/qSTFUPySTfFLLsVOwpQkStXp6uoqdxGSKVWDGK41LFKNYTaKX7Ipfsml2EmYkkSpOj09PeUuQrIVoVubfCh+yab4JZdiJ2Hqv0OqTlPTAOjMuoopfsmm+CWXYidhqkmUqrN161aam5vLXYzKVYZubfKh+CWb4pdcip2EKUmUqjN69OiC9nt14w5e3bQDgNe3tsdZpMpShm5t8lFo/KQyKH7JpdhJmJJEqTqtra15jxzw9CubOPuaRxkQw3Vna6ACJW+kEqWQ+EnlUPySS7GTMCWJUnUmT57cp+3WbNnJotVbAfjLktcjE8TDJ46Ms2iVpcwNVLLpa/ykMil+yaXYSZiSRKk6S5cuZfr06RnLf/rQy9z5bCsOWN/WwbptmWMzA1z74SMZ1lRHfW0NMycML3Jpi6jCnz3MJlv8JBkUv+RS7CTM3IC4v5YfM3MAujbJ1tbRxcMvrqOzu4cdnd18/tbek6Pp+wzjniuPx8xKUMIiu/Gc3M8eTj2tZB1ki4hI8aR+s5xzsf54qSZRqs7ixYuZMWMGH//NUzz8j/WR25x80FgABtXXctHxkzEMM5i2z7DqSBCh4p89zCYVP0kmxS+5FDsJU01iBNUkJtPOzm7uX/w6be3BqAH/cc9itrXvOYLAoPpabr38WGbsOwC6eZh7Bqx8BCYdV5HPHoqISDxUkyjSi2/fu4TrHl2Rsfz0Q/bhqlOmAbD3sEaam+pLXLIYZXvOMEqFP3uYzZIlS/RcVIIpfsml2EmYkkSpGsvXb89Y1lBXw3sOm8D+e5e377/Y9NbHYZQy93uYr2nTppW7CNIPil9yKXYSpiRRqs4BezXy20uPA2BIYx1DGyv4v3k+NYOwu3Yw6jnDKBX87GE2y5cvV19tCab4JZdiJ2EV/OspUpjBTY2MbS7BGKT5JnhRVj5S2H6Tjqnalsnjxo0rdxGkHxS/5FLsJExJolSdXV1dvW8Uh0Ju/eYy6bi+bZfA2sF8rF+/ngkTJpS7GFIgxS+5FDsJU5IoibW9o4vf/9+rrPXjLL+8LqjRq62tjfeNeuuUuq+3frNJJX3jjyj8GFWkuXkAtDyvYopfcil2EqYkUSqac45NO3ZFrpu7YDk//utLGctrKLDromzJYG+3hKv41m85tLe368cqwRS/5FLsJExJolSsru4e3vWTBSxq3drrtk31NQAMbqjjfbPGFvaGfbl9HL4lXOW3fsuhpqam3EWQflD8kkuxkzAliTlccsklGcvmzJnDnDlzylCagcE5x5ot7XT3OJat396nBHHa2GHc9+m3vfF68+bNhb15X0Yo0S3hoqur09dSkil+yaXYJcO8efOYN29eSd5LI65E0IgrpfNC61ZueHwF7bt6ALjtmdWR251z5H4cNC7zNkhtjXHijDHsO3zQG8taW1sLa6WnEUoqQsHxk4qg+CWXYpdcGnFFqtLX5i3ib8s39rrdRcdP5sCxw/p0zBEjRvSzVFJOil+yKX7JpdhJmJJEKavNvlHKoPpa9h7WCMDabe1cNnt/xo8Iagen79Pc5wQRYO3atbS0tMReVikNxS/ZFL/kUuwkTEmiVITZU/fmpx+K53k/9fOVbIpfsil+yaXYSZiSRKk6y5YtY+rUqbk3iuruJtXvoZRVn+InFUvxSy7FTsKUJEpJOedY1LqVTTs6AWjriH90lD2+5Arp+7BxaOxlkr7Tj1SyKX7JpdhJmJJEKalfLVjB1Xe9UNT3WLx4MTNmzAhe5Nv3ofo9LLs94ieJo/gll2InYUoSpd82tHXwfys2Ra5b39bBNQ++zIjB9QBZ+z08smVkbOXZ40tOfR8mjn6kkk3xSy7FTsKUJEq/dHb1cOp/zWd9W2fO7VZv3pmx7I+XHQPA8EH1ebVe7k3kX8P7HKK+DxNCtRnJpvgll2InYUoSpV/Wt3X0miCmnDh9DGbQWFfLhW9t4ciWUUUpk77kkk3xSzbFL7kUOwlTkih529DWwYNL19HV0/NGP4cAV554IKe+aZ+M7Wtq4MAxw6itibUj+D2lNVDZuXMngwb5EVjUYjlxXnrpJQ444IByF0MKpPgll2InYUoSJW8fu/5Jnn11c8by8SMGRQ6dVxJpDVQGRa1Xi+XEmDhxYrmLIP2g+CWXYidhShIlb8vWtWUsGz6onqOn7FWG0nhpDVTaRx5IU2PT7nVqsZwor732mn6sEkzxSy7FTsKUJEqvNm3v5K7nWtne2Q1AR1cPAO8/YgKfPjnoV2vUkAaa6muLX5hs/R6mbivvcwhd778JhqrmMKlGjSrOs6pSGopfcil2EqYkUXp19Z9e4NanV2csH9ZUz7gRkTd385Mt8YuSqxNsgMahtLW1MVRJYmIpfsmm+CWXYidhShIlUk+Po9s5AF7duCNj/fBB9Zx2cGYjlYL0pcPrKOmdYMMbt5UbGhriKZeUheKXbIpfcil2EqYkUTI8sXwjl97wJJvSWi4DHNUyius/ehQA9bVGXW1NPG+Yq8PrKL11gr1xYzzlEhERGcCUJEqGu59fk5EgAuw3ajCDGtKeO8znNnEuac8TxtHhdWdn3/ptlMqk+CWb4pdcip2EKUmUDD3+NnNTfQ2fOCHoM2tIYx3vmjV+zw0LvU2cTUzd1OiZmmRT/JJN8UsuxU7ClCQOUF3dPby+rSNyXVtHFwCD6mv5xDsOzH6QfG8T5xJjNzUbN27Ul12CKX7Jpvgll2InYeZ8rZHsZmYOoFqvTfuubk7+wUO8ujFzPOWZ9hJX1N3GUGunrsY4clKOLhFeex46tgQNSCpoXOTOzk49gJ1gil+yKX7Jpdgll1kwoplzLtahzVSTOAAtat0amSACXFF3GyfVPrN7wco+HLDCRjN55ZVXNLRUgil+yab4JZdiJ2FKEge4jx03mWljh73x+tDHamEjdNYNw/Y9hPqaXlowV+BoJvqSSzbFL9kUv+RS7CRMSeIAlbqtfOQr9YxYl3Z7Yfs/AGgYP7OibiHnY/HixcyYMaPcxZACKX7Jpvgll2InYXomMUK1P5P41MpNbPrFe/a8rRw29TQ4/6bSFUpEREQKomcSpTARfRlO7diFq1kKQFf9MOrGzdxznwq8hZwP/TWcbIpfsil+yaXYSZhqEiOkahIvvvjijHVz5sxhzpw5JS9TwW48J2dfhhvGncBel9xeuvKIiIhIwebNm8e8efP2WHbttdcC8dckKkmMUFW3m+eeASsf2aMvw20du1jUupU218So07/E4cecWOZCxuvFF19k6tSp5S6GFEjxSzbFL7kUu+TS7Wbpn7Qh715cuYlzr3kUgOv3OrScpSqKKVOmlLsI0g+KX7Ipfsml2ElYL/2bSFK1dXRx9/NrWN8WjKqyvq2D259Zze3PrGb+i+vKXLriWrVqVbmLIP2g+CWb4pdcip2EqSaxSnR0dfP0o39h0sL/pq5rO8vWb2cU0GArweCldW186qZny13MkhgzZky5iyD9oPglm+KXXIqdhClJTKjuHsdDL65lzZZ2AL59zxK+3/0fjPPd2owJ1RG3uaaMY+w1pIFZE0YUu6glt3nzZgYPHlzuYkiBFL9kU/ySS7GTMCWJCXXHs6v5zB/+vseyoQ1BwrjVDeYFNwmA/UYOYuTIUcx482d4YOysPbbfd3gTTfW1JSlvKelLLtkUv2RT/JJLsZMwJYkVyjnHlb9/lgeWro1cv629K+u+jRNmMuF9tzKssZ7hg+sBGEgf/a6u7NdGKp/il2yKX3IpdhKmJLGCfPe+JVy3YAXdztG+q6dP+5jB3z4fdGEz6ub/hlehsa6WCSMHUlq4p56evl07qUyKX7Ipfsml2EmYksQy6+lxpHpj/OUjyyOTwzeNa+aoyaMylteacebMcYxp9s8b1qixOkBTU+bzl5Icil+yKX7JpdhJmJLEMvrN4yu5+q4X6OjaMzGctd8I3uKTwgPHDuPsw8e/0VGm9G7r1q00NzeXuxhSIMUv2RS/5FLsJExJYhnd/OSrGQkiwPuOmMAFR0/y4y5/FZ5ry9gm0mvPx1q+pBo9enS5iyD9oPglm+KXXIqdhClJLKMef5/5nSNX87lBd1LfvZ2G2hpGv9AIiy0YTq8QjUPjK2QCtba2auSABFP8kk3xSy7FTsI0dnOEYo3dvKGtg+seXcGG7Z0A3LvwNTZu7+T2kT9i1s7Hc+886bi+vUnjUJj9ORh/RD9Lm1zOOd2eTzDFL9kUv+RS7JJLYzdXgWsfXs5j8+/jirrbGGrtnAXQAFM7Xgk2aBwejLGcTklf3pYuXcr06dPLXQwpkOKXbIpfcil2EqYksYQ2tHVwRd1tnORHRXlD6rHEScfA+TeVvFzVZv78+fqiSzDFL9kUv+RS7CRMt5sj5HW7edVTMP870BHduGRXTw+dvnHKqk072XfnP2i2HZm1hqoxjM3BBx/MwoULy10MKZDil2yKX3Ipdsml282Vav534MV7s66u9xPANIBU+FRrWDTq6yvZFL9kU/ySS7GTMCWJeerucSxq3cKu7qB2cMSq19gf2G5DWFY7he2dvQ9r1DRkOLNmf67IJR242tvby10E6QfFL9kUv+RS7CRMSWJf+dvKL7+yhh07Ot9YvLetBIPnuydy7s7PZ939fz54ODUGDXU1zNp/NNTXlqLUA5L+Gk42xS/ZFL/kUuwkTEliX/nbylMBIka/a3NNzNxvBDhHZ7fjqpOnYgY1ZhzRMpLmpvrMnaQoOjo6yl0E6QfFL9kUv+RS7CRMg/3mMvcM3NzT2XrNKexavgCArQzm8Z4ZLGk8lM1jjmLzmKPY0XISJ132Pe7457dyxyeO454rj+ekg8Zy4oyxnDB9TJ8SxHnz5hX7bMr2fqU+t4aGhpK+XzXHrhzvp/gl+/1KGb9qv5bVHDuo/utZ6vcrBiWJuax8BFu5gObX/0b9rm0APNE9jXM7v8Svp/8PIy6/nxGX38/gC2/pd6vkav7PW+pz27VrV0nfr5pjV473U/yS/X6ljF+1X8tqjh1U//WshiRRt5tzaGMIC3sm7n7tmvhR13sBeMvkUeUqlvSitlbPeyaZ4pdsil9yKXYSpiQxh4U9Ezm380sAjB7ayK8uPJJvAKOGNDBh5ODyFk6yUt+fyab4JZvil1yKnYQpScxh1JAGzpi2L4MbavnY8ZOZvk9zuYskIiIiUhIacSVCasQVERERkaSIe8QVNVwRERERkQyqSRQRERGRDKpJFBEREZEMShJFREREJIOSRBERERHJoCRRRERERDIMqCTRzN5pZo+ZWZuZbTCzO83ssFIfQ/IXU+zON7MHzGyNma03s7+a2YVFKrKkiftzY4H7zMyZmYaJKKKYPnstZjbXzFr9cZ40s38ys1i765BM/Y2f/6x9xMwWmNlGM3vNzP5iZmcWs9yym4/BajO7uoB9+/f5dc4NiAn4ALALcMBCYJX/dztwbKmOoalssbvW79MJPAs87f/tgFvxLf01VWb8Io55hT+GA2rLfY7VOsX02TsE2OT3ew14DNjpX3+v3OdYzVNM8fuN32cn8DjwVNoxv17ucxwIE3CGv95Xlzz+5T75El3gUf6i7ACOSVue+qFZDNQU+xiayha7o/22K4EZacsPAJ7z6y4t97lW41SMzw1wUFqSoSSxwmNH8EeZAy5ld7drk4FXgR7g8HKfazVOMX13ppKThcC4tOXTgdeB7vTvVE2xx3AYcIG/1nklibF9fst9EUp0of/ZX5QvRKy71687sdjH0FS22P3Ub/fRiHWH+XULyn2u1TjF/bkBGoBngPXARiWJlR07dv+B9vOIdRf6dd8o97lW4xRT/L7jtzs/Yt1X/LqLy32u1TgBN/s/olzalE+SGMt370B5JvE8P78tYt2tfn5qCY4h+Yvjuk/x8wfDK5xzzxDcCju0kMJJr+L+3FwNzAIuA7YUXizpgzhid5Gfz41Y91ugBfhh3iWTvogjfkP83EWs6/HzoXmWS/rmUeBnBJUcDxSwfyzfvQMlSZwMbHHOLY5Y95ifzyjBMSR/cVz3x4FfAKvDK8ysieBLbnt/CilZxfa5MbPZwGeBXzvn/hhT+SS7OGJ3NLDTOfdYeIVzbpdzbqVzbl0/yynR4ojf7X7+RTMbl1poZtOBywmed7unn+WUCM65HzjnPu6c+zhwfQGHiOW7t+qTRN96bgywIcsm6/18YjGPIfmL67o7577snLvYOdcRsfpKoB6YX3BBJVKcnxszGw78muA5titiKaBkFWPs9gVeN7MRZvYTM3vOzLaY2aNm9ikzq/rfoHKI8bvzfuCTwFTgJd9K9kngeWAwcJ5zbkk8pZa4xPndWxdXoSrYXgTnuSnL+o1+PiTL+riOIfkr2nX3H6JPAd8EOvxc4hVn/H4CTABOcM5tjaFsklu/Y2dmjQQPz28FFhAkGouBpQTPAh8DnGlmpzjnerIdRwoS52evlSCGexHUDKesI2gtK5UntvjrrzhI9bHWny+pOI4h+SvoupvZEQTPe3zf7/sR59zfYy6b9K5P8TOzc4APAv/pnFONb2XoS+xG+XkLwTNtBzvnDnXOHQXsDzwBnEhw21JKq6+fvQuAPxIkFXOAkcB4gpiNBv6ifoITqc+/nQMhSdwAdLH7CysstXxNkY8h+Yv1uptZo5l9h+DH6WiCWyZvcc7d1N+CSqR+x8/MJgDXAH8HvhRr6SSXOD576bUYFzrnlqZeOOdagUv8y/OQuMXx2WsAvkfQ3dQ7nXN3Oec2O+danXPXEHRpNAT4RnzFlpjE9ttZ9bebnXPOzNYSVL9GSS3PerHiOIbkL87rbmbjCZr9H0zwPMaXCbrl6I6jrJIppvidSFB70QrcERqgY6yf321mPQQd+2Y0kJD8xfS92W5mWwj6RnwyYv3fzWwbQWfbEqOYPnvTCJ5re8g593LE+lsIHtU5ruCCSlHE+ds5EGoSAZYBzWZ2cMS6Y/18eQmOIfnr93U3s2HAnwgSxD8Bb3LOXaMEsSTi+ty8CTgtNA3y607xr8f0r6gSEkfsVgMNUUMn+kYrNcC2fpVSsulv/FK3IiN7fnDOdREkifoerUyxfPcOlCTxd37+noh17w5tU8xjSP7iuO6fBGYSdE56lnNubTxFkz7oV/ycc9c75yxqAlb4zer8sjtiK7VAPJ+924AmghrhsLcS3K58vpDCSa/6G7+lBEngm80so4GDf7a7mWBEHak88eQs5e5VvBQTwe2qnX46Om15aniav5XiGJrKFrsVBM9n7F3u8xloUzE/NwR/BWvElQqOHTCJoKZpOTAzbfk0YIk/zunlPtdqnGKKX2q0qj8Aw9OWT2X3kKYfLPe5VvsEfIT8R1yJ5bu37Cdfwov8fnYPdP0cuwe6bgUOSttuDEHnoPcAYwo5hqbKiR3BsxfOf1DuyTHdWO7zrNYpjs9eluMqSUxA7IBP+ESxyx/jaaDTH+fH5T7Hap76Gz+CgQae8ftsI+iE+bm0Y84t9zkOhClXkljsnKXsJ1/iC30awegb2wma9N8B7B/aZhK7x0mcVMgxNFVO7IAj0pblmtaU+xyreYrjsxdxTCWJCYkdQfcpt/kfqdeB+4B3lfvcBsLU3/gRNHD9LPAIQYv11T5+7y73uQ2UqZcksag5i/mDiIiIiIi8YaA0XBERERGRPChJFBEREZEMShJFREREJIOSRBERERHJoCRRRERERDIoSRQRERGRDEoSRURERCSDkkQRERERyaAkUUREKp6ZfcXMXIHTR8pdfpEkUpIoIiIi/WJmD6SS8tDyST7Bv7Kv+wwUZjbTX5uK/SNGSaKIiFQ859zXnHMWnoC3p23WErWNc+76MhVboAX4KvCpspaiMs0iuDYXlrUUOdSVuwAiIiKSeK8AS0qwj5SQkkQRERHpF+dc3rdMC9lHSku3m0VEZEAws9n+Gbh5/vV5ZrbIzLrMbLZfNtdv85Ucx1nut5mdZf07zewGM1toZtvN7AUzu8bMDiygzKn32svMppjZL81slZm1mdljZvYjMxuXY/8aM7vCzO40sxVmttHM5vv9xufYb7iZfdnMHjeztWa2xcyeNbPvm9mYiO1TDYvm+teT/LOGD/pNWtIaEk3Kss9oM9vll12Qo2xf9NtsMLOG0LpxZvYDM3vIl3mVmd1rZmeZmeW41Nney5nZNv/vI83sQTPbGf7/YWYHm9mvfMy3+OkFM/u1mb05tO1sf22u84venu3ZTB+Hb5rZ/Wa23sxe8+f2ITOrz/d88qWaRBERGXDM7NPA92M+ZiPwXeCK0KoZfvqomX3YOXdTAYc/Bvgt0Jy27Gg/nWNm5znn/hoqzwTgRuD40LGO99MFZnaxc+6W0H6TgL8BY0P7zfTTh81slnNuVQHnkZVzbr2Z/RU4BXgv8Jssm57j5zc65zrTyj0HmAvslbZtMzAeOBW42cwuSN+nr8zsrcCfgcER684E7gTCSWgzQdw/aGbvd87dmud7HksQ85bQqrHA24CLzOws59yWfI6bD9UkiojIQDOLIJn7M/AOYAIwP4bjfpEgQewCvgkcBIwATiRIuhqAG83smAKOfQPQRNAAZDIwDjgfWAuMAW41s5GhfX5FkAy2+/0OJEigTgWeA0b68kwO7TeXIBFZDswBRhEkPKcDq/0xvpersM65laGGRSvSGhKtzLHr7/38NDOLSsimA4f4l9elLZ8G3OLLNh+YDQwHDgb+E+gB3g/8MFe5s2gAbiY49/cRXMdv+vdtIIiNAQ8DxxJcq+EEidzjBLnWf6UO5px7yF+bC/2iB9MaYqXOZy/gLoIE8Xngnf7cpgKfBzr88VPXqzicc5o0adKkSVMiJ4JkwPlpUh7b3pRlm7l+/VdyHGe532Z22rIJwA6//EMR+9QRJC8OeCyP81ueVuYzItZPBLb49f+etvy0tP3eEbHfYGCRX39j2vImggTEASdH7HexX7cytPwrfvncLNd8ecSxMvYhSKpT7//eHPssDC2/0y+/H6iJ2O9Sv74bOCiP65+6hiuAQRHrZ/n17cDIiPWT0o6xd2jdR/zyByL2+5Fftwhoilh/atpxT43zM5U+qSZRREQGon+P+XgXAoOAJ5xzN4RXOue6gM/4l0dHPdfXi4edc3+KOO4rwI/9y39KW/UhP7/fhW5D+/12sPsanJP2bF89Qc0ZBAlj2K8JEuJj8yt+3zjnNgP3+ZfvjdjkA35+XWqBv60+x7/8pHOuJ2K/nwMLCWr1ziigaD9wzu2MWL4OOBd4t3NuU8T6NWn/zqgZjWJmtcAl/uVnnXPt4W2cc/cBqf8PZ/XluIVQkigiIgNNN0HCEKdpfv6/ObZ5mqC2EeDIPI9/R451d/r5PmY2xP/7AD//c479UutqCG5h45zbRnBrHOAG33jlkFSjD+dch3NutXNudZ7lz0fqmc0z0xummNnBBLfwuwme1UtJXfs1zrnFUQd0QfXbAv/yzVHb9OLZLMdd7Zy7yTl3b/py32BoGoU999oCNBI8tvBQju0e8fNCzqdP1HBFREQGmrXOue6YjznVz79gZl/ow/bh5wd7syLHumVp/55C8AxbKklcnm0n59w6M9tBUMO1P7DUr7qAIFE7HPianzaa2QLgbuB259xreZY/H3cS3L4dTvDMaCoBSzVYudc5l15Dl7r2+0a1EI6Q77WHPWsEM/hGJmcChxFcy0nsrpHNV+p86oDtfWiUXcj59IlqEkVEZKDp6Of+UV2PNOZ5jGF5bp+rRe6utH+nbhH3tbuXVLL8xjk5514iqJ06i6DxSytB45U5wDXAMjP7DEXiazNTt1LTbzmnbjWHR9Ap9rWHLP9nzGywBV0qLSBoUPIOYDtBze83gBMKeK9SnE+fqCZRRESkj/ztz30jVr1I0D3M551z3yrCW4dbIKc7IO3f//DzVKLXkm0nMxvN7gTjH+nr/HN98/yEmU0hSHg+RNAY5Xtm9rxz7v6+n0JebgLOBt5tZpcBhxLUsG1i9+31lBf9fKlzbnqRypPNtwhqENcClwPzXKiLnQK6Z0ydz05gaJZnLEtCNYkiIiKZohptABxB9G9n6od9ZrYDmlmdmR3hp3w7Qn5HjnWn+/k63/ADgiQR4OQc+6XW9QAv+zIeamZXmdml6Rs655Y5535JkCg+4Ref2seyF+IuoA3YGziO3beaf+ecC9fqpa79AWnPZGYwswP9tY9K8guVqt38gnPulogE8YCIfXrzMkFMBhF0txPJzCb685lUwHv0iZJEERGR3dr8/C1Z1n81y/LfEdy6PdvMDsuyzRXAkwS1ZF15lussMzs6vNCCUVNSt37TG3OkOqI+1czeHrHfEODL/uWtaYnXvgT9Cv7UzFrC+/kGIKlb1JvzKH9e1Wm+JfE8//Jsst9qTt0efxyoJUt8zGw/4BmC619I4pZN6tZwRgtk79/Si5Flmz2W+1jc7F9+I3IHs2EEt7ifJOgvsSiUJIqIiOz2lJ+fYGZXpzp0NrPJZnYLQe1bRqMN59wi4FqCZ/v+bGaXm1mLmTVaMJze1wk68Ab4rk+28mHA/WZ2sZlNMLN9zOxcX94RwFbSEgrn3N1Aquubuy0Ymm+KmY00s1MJWjBPJ3jW8V/T3udZdic8t5jZ8WY21MyazOxNZvYzgtFfHLlbcoeNN7N98jznVEfRFxE0yFnsnHsiy7af9mW6yoKhFQ8zsyFmNsrMziboo3II8Lhz7uE8y5HL037+VTN7m39GcS8zO9HM7gY+lrbtHD8qT9j0iBrQfyWIw/ssGFLxGDNr9sP0nerPZwJBg6abKZZidcCoSZMmTZo0FXuisM60l+fYpp4ggUods5vdnVX3AJ/zP8p7dKbt9x0O/CFt36jpW3meX6oz7W8TJA1Rx1wLnBSx70SCblKylWUD0R1WX9bLOTjgX0L7ZOtMe6K/bqlruS0Vp2z7pO3bSFBbmXrPz/VyrS4iqAnOVubngdF5Xv+c/7cIHj/IFpcdwCcJkt3UsmfS9j0ubXknsCN07LMI+mHMdj6rgP2L+flSTaKIiIjnnNtFMIze1wiSinaCW8N/Bk5zzn0nx75bnHMfAM4D/kjwrNwOYAlBovBm59y/Zdu/F3cTdK/yc4LavjaCZwN/AsxyzmXU6rmgo+3ZBEPy3QWsJEh4HyHogPsQFzGesHPupwRjQt/sy95GkKw9RzAizSzn3HfD+0XxZbgceIWgFfZG9myNnWvfDuA2/7Kb7GM5p7b/BcE1+hlBot9GMJTeQwQJ5OHOufV9ee++cs49RZAo3kSQ0HcQJG83+Pf7EXAV8BhBq+fH0/Z9BPg6Qc10N6EaaufcnQRDEP6QYMi/zcDrwKPAZ4GpzrmX4zyfMPPZqoiIiFQYM1tO0EL57c65XB0ri8RONYkiIiIikkFJooiIiIhkUJIoIiIiIhmUJIqIiIhIBiWJIiIiIpJBrZtFREREJINqEkVEREQkg5JEEREREcmgJFFEREREMihJFBEREZEMShJFREREJIOSRBERERHJ8P9rY10qgsundgAAAABJRU5ErkJggg==\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"from sklearn.metrics import roc_curve, auc\n",
"import matplotlib.pyplot as plt\n",
"import mplhep as hep\n",
"\n",
"plt.style.use(hep.style.ROOT)\n",
"# create ROC curves\n",
"pt_split = 5.0\n",
"fpr_lorentz_lowb, tpr_lorentz_lowb, threshold_lorentz_lowb = roc_curve(\n",
" y_test[track_pt <= pt_split, 1], -y_predict[track_pt <= pt_split, 1]\n",
")\n",
"fpr_lorentz_highb, tpr_lorentz_highb, threshold_lorentz_highb = roc_curve(\n",
" y_test[track_pt > pt_split, 1], -y_predict[track_pt > pt_split, 1]\n",
")\n",
"\n",
"# plot ROC curves\n",
"plt.figure()\n",
"plt.plot(\n",
" tpr_lorentz_lowb,\n",
" fpr_lorentz_lowb,\n",
" lw=2.5,\n",
" label=\"Lorentz GNN (low pT), AUC = {:.1f}%\".format(\n",
" auc(fpr_lorentz_lowb, tpr_lorentz_lowb) * 100\n",
" ),\n",
")\n",
"plt.plot(\n",
" tpr_lorentz_highb,\n",
" fpr_lorentz_highb,\n",
" lw=2.5,\n",
" label=\"Lorentz GNN (high pT), AUC = {:.1f}%\".format(\n",
" auc(fpr_lorentz_highb, tpr_lorentz_highb) * 100\n",
" ),\n",
")\n",
"plt.xlabel(r\"True positive rate\")\n",
"plt.ylabel(r\"False positive rate\")\n",
"plt.ylim(0.001, 1)\n",
"plt.xlim(0, 1)\n",
"plt.grid(True)\n",
"plt.legend(loc=\"upper left\")\n",
"plt.show()"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.9.13"
}
},
"nbformat": 4,
"nbformat_minor": 2
}