diff --git a/.travis.yml b/.travis.yml
index 5435f54..c1ac6ca 100644
--- a/.travis.yml
+++ b/.travis.yml
@@ -3,7 +3,7 @@ dist: focal
 language: python
 
 python:
-- '3.8'
+- '3.8.2'
 - '3.9'
 
 install:
diff --git a/docs/source/reference/auditors.md b/docs/source/reference/auditors.md
index d7d327f..7a368c0 100644
--- a/docs/source/reference/auditors.md
+++ b/docs/source/reference/auditors.md
@@ -15,4 +15,10 @@ SenSeI Auditor
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 .. autoclass:: SenSeIAuditor
     :members:
+
+SenSTIR Auditor
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autoclass:: SenSTIRAuditor
+    :members:
+
 ```
diff --git a/docs/source/reference/distances.md b/docs/source/reference/distances.md
index 71087ea..1a3479c 100644
--- a/docs/source/reference/distances.md
+++ b/docs/source/reference/distances.md
@@ -41,4 +41,11 @@ Euclidean Distance
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 .. autoclass:: EuclideanDistance
     :members:
+
+Wasserstein Distance
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+.. autoclass:: BatchedWassersteinDistance
+    :members:
 ```
+
+
diff --git a/examples/synthetic-data/synth_senstir_demo.ipynb b/examples/synthetic-data/synth_senstir_demo.ipynb
new file mode 100644
index 0000000..4bf9418
--- /dev/null
+++ b/examples/synthetic-data/synth_senstir_demo.ipynb
@@ -0,0 +1,643 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "24994978-778d-4faf-a8a3-1cb28d2855f0",
+   "metadata": {},
+   "source": [
+    "# Sensitive Set Transport Invariant Ranking (SenSTIR) demo\n",
+    "\n",
+    "The idea of this notebook is to replicate the synthetic experiment shown in figure 1 of [Individually Fair Rankings](https://openreview.net/pdf?id=71zCSP_HuBN)."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fe062f06-3d2c-455e-84ec-ef0a8f575945",
+   "metadata": {},
+   "source": [
+    "## Synthetic data generation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "4a3f1a1b-c6d6-4e4d-ba2b-bb695afd6314",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import numpy as np\n",
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data.sampler import RandomSampler, BatchSampler\n",
+    "from torch.utils.data import IterableDataset"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "ab911b86-1206-4e03-8cf2-f9296d783c55",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def generate_synthetic_LTR_data(majority_proportion = .8, num_queries = 100, num_docs_per_query = 10, seed=0):\n",
+    "    num_items = num_queries*num_docs_per_query\n",
+    "    X = np.random.uniform(0,3, size = (num_items,2)).astype(np.float32)\n",
+    "    relevance = X[:,0] + X[:,1]\n",
+    "    \n",
+    "    relevance = np.clip(relevance, 0.0,5.0)\n",
+    "    majority_status = np.random.choice([True, False], size=num_items, p=[majority_proportion, 1-majority_proportion])\n",
+    "    X[~majority_status, 1] = 0\n",
+    "    return [{\"Q\":X[i], \"relevances\":relevance[i], \"majority_status\":majority_status[i]} for i in range(num_items)]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e0a23705-341e-450d-b900-58a2e25895db",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class QueryIterableDataset(IterableDataset):\n",
+    "    '''\n",
+    "    iterable dataset that takes a set of items and indifintely samples sets of such items (queries) per iteration\n",
+    "    '''\n",
+    "    def __init__(self, items_dataset, shuffle, query_size):\n",
+    "        self.dataset = items_dataset\n",
+    "        self.query_size = query_size\n",
+    "        self.shuffle = shuffle\n",
+    "\n",
+    "    def __iter__(self):\n",
+    "        while True:\n",
+    "            idx = self._infinite_indices()\n",
+    "            query = [self.dataset[i] for i in next(idx)]\n",
+    "            query = torch.utils.data.default_collate(query)\n",
+    "            yield query\n",
+    "    \n",
+    "    def _infinite_indices(self):\n",
+    "        worker_info = torch.utils.data.get_worker_info()\n",
+    "        seed = 0 if worker_info is None else worker_info.id\n",
+    "        g = torch.Generator()\n",
+    "        g.manual_seed(seed)\n",
+    "        while True:\n",
+    "            if self.shuffle:\n",
+    "                idx = (torch.randperm(len(self.dataset))[:self.query_size]).tolist()\n",
+    "                yield idx"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "99828ea6-d543-4dca-ac3d-1e4eed068b67",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'Q': tensor([[[1.8246, 0.0000],\n",
+       "          [0.6184, 2.7684],\n",
+       "          [0.7639, 0.0000],\n",
+       "          [1.3092, 0.0000],\n",
+       "          [2.0094, 2.2866],\n",
+       "          [2.5500, 2.3130],\n",
+       "          [1.1940, 2.8637],\n",
+       "          [1.1564, 0.4380],\n",
+       "          [1.8691, 0.0213],\n",
+       "          [0.3541, 2.5002]],\n",
+       " \n",
+       "         [[1.6751, 1.9320],\n",
+       "          [1.3357, 1.0165],\n",
+       "          [1.6118, 2.5823],\n",
+       "          [2.6423, 1.0858],\n",
+       "          [1.9938, 2.6551],\n",
+       "          [2.8647, 2.2234],\n",
+       "          [1.4214, 1.5937],\n",
+       "          [0.8223, 1.5743],\n",
+       "          [2.6399, 0.7949],\n",
+       "          [0.4082, 2.7509]]]),\n",
+       " 'relevances': tensor([[3.4841, 3.3868, 1.6027, 3.2032, 4.2960, 4.8630, 4.0577, 1.5943, 1.8904,\n",
+       "          2.8543],\n",
+       "         [3.6071, 2.3522, 4.1941, 3.7282, 4.6489, 5.0000, 3.0151, 2.3966, 3.4348,\n",
+       "          3.1591]]),\n",
+       " 'majority_status': tensor([[False,  True, False, False,  True,  True,  True,  True,  True,  True],\n",
+       "         [ True,  True,  True,  True,  True,  True,  True,  True,  True,  True]])}"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "num_docs_per_query = 10\n",
+    "num_queries = 100\n",
+    "dataset_train = generate_synthetic_LTR_data(num_queries = num_queries, num_docs_per_query = num_docs_per_query)\n",
+    "dataloader = torch.utils.data.DataLoader(QueryIterableDataset(dataset_train, True, num_docs_per_query), num_workers=2, batch_size=2)\n",
+    "#the data loader gets a batch of queries with relevance (batch x num_items_per_query) and features (batch x num_items_per_query x num_features)\n",
+    "next(iter(dataloader))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "395380a0-b1a1-4265-a82e-f07df4fe21dd",
+   "metadata": {},
+   "source": [
+    "## fair distance learning\n",
+    "\n",
+    "This is necessary to compute the wasserstein distance on the worst example generation (q' in the paper)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "976c708c-c0ed-4b46-a33e-ff624ed18675",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "sensitive directions tensor([[2.2047e-02],\n",
+      "        [5.2825e+01]])\n"
+     ]
+    }
+   ],
+   "source": [
+    "# we perform a logistic regression on the dataset to build a sensitive direction\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "\n",
+    "all_data = torch.utils.data.default_collate(dataset_train)\n",
+    "x = all_data['Q']\n",
+    "majority_status = all_data['majority_status']\n",
+    "\n",
+    "LR = LogisticRegression(C = 100).fit(x, majority_status)\n",
+    "\n",
+    "sens_directions = torch.tensor(LR.coef_,dtype=torch.float32).T\n",
+    "print('sensitive directions', sens_directions)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "1d2fca1e-f502-4f8e-8740-6b64d63bbe61",
+   "metadata": {},
+   "source": [
+    "As we can see, the logistic regression finds a high sensitivity on the second dimension, the data generation process artificially produces this high correlation."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "786e828c-9f5f-486a-874e-c333c7cc47a9",
+   "metadata": {},
+   "source": [
+    "### Batched Wasserstein Distance\n",
+    "\n",
+    "To audit the model we need to compute a Wasserstein distance between sets of items. This distance can be build by using a Mahalonobis distance as the pairwise cost between items in each set. The sensitive direction we just learned can be used to build this Mahalanobis distance."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "20a02d4b-8c91-4696-8995-fc2136a871dc",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from inFairness.distances import SensitiveSubspaceDistance, BatchedWassersteinDistance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "99a60e17-a06c-4e10-b6db-ffcd30a3f7d8",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "distance_q = BatchedWassersteinDistance(SensitiveSubspaceDistance())\n",
+    "distance_q.fit(sens_directions)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "e7ab1b7a-972e-4503-aafb-f8a3f8ea538a",
+   "metadata": {},
+   "source": [
+    "## Model and Output distance\n",
+    "\n",
+    "We also need a model we would like to train and to define a distance in the output space."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 16,
+   "id": "3478a7bb-2fe5-4f49-a756-463f6d5d814d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch.nn.functional as F\n",
+    "class MultilayerPerceptron(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.fc1 = nn.Linear(2, 10)\n",
+    "        self.fc2 = nn.Linear(10, 10)\n",
+    "        self.fc3 = nn.Linear(10, 1)\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = F.relu(self.fc1(x))\n",
+    "        x = F.relu(self.fc2(x))\n",
+    "        x = self.fc3(x)\n",
+    "        return x\n",
+    "\n",
+    "# model1 = MultilayerPerceptron()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "d6fe9ab5-96bc-43c9-a511-68d76a2447c6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from inFairness.distances import SquaredEuclideanDistance\n",
+    "distance_y = SquaredEuclideanDistance()\n",
+    "distance_y.fit(num_dims=num_docs_per_query)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "fb2a45d8-7aa4-4a86-b46d-36132beafb63",
+   "metadata": {},
+   "source": [
+    "It's worth nothing that in the output space we are measuring distances between sets of scores (each score corresponding to each document in a query). Therefore the dimensionality of the SquaredEuclideanDistance above."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "db410d36-4a04-4ce5-a64e-bf366b295e97",
+   "metadata": {},
+   "source": [
+    "## SenSTIR\n",
+    "\n",
+    "High rho to enforce fairness."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 39,
+   "id": "36169c53-ed09-4828-baba-6ef8dd2009f6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SenSTIR(\n",
+       "  (network): MultilayerPerceptron(\n",
+       "    (fc1): Linear(in_features=2, out_features=10, bias=True)\n",
+       "    (fc2): Linear(in_features=10, out_features=10, bias=True)\n",
+       "    (fc3): Linear(in_features=10, out_features=1, bias=True)\n",
+       "  )\n",
+       "  (distance_q): BatchedWassersteinDistance(\n",
+       "    (distance): SensitiveSubspaceDistance()\n",
+       "  )\n",
+       "  (distance_y): SquaredEuclideanDistance()\n",
+       ")"
+      ]
+     },
+     "execution_count": 39,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from inFairness.fairalgo import SenSTIR\n",
+    "fairalgo1 = SenSTIR(\n",
+    "    network=MultilayerPerceptron(),\n",
+    "    distance_q=distance_q,\n",
+    "    distance_y=distance_y,\n",
+    "    rho=0.01,\n",
+    "    eps=0.025,\n",
+    "    auditor_nsteps=20,\n",
+    "    auditor_lr=0.1,\n",
+    "    monte_carlo_samples_ndcg=20,\n",
+    ")\n",
+    "fairalgo1.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c845f522-bb4f-4d2f-80b6-a1da9c953676",
+   "metadata": {},
+   "source": [
+    "## Baseline\n",
+    "\n",
+    "Set rho to 0 to train the network normally."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "6c265bbf-83ed-42ca-809b-ba5c70005f25",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "SenSTIR(\n",
+       "  (network): MultilayerPerceptron(\n",
+       "    (fc1): Linear(in_features=2, out_features=10, bias=True)\n",
+       "    (fc2): Linear(in_features=10, out_features=10, bias=True)\n",
+       "    (fc3): Linear(in_features=10, out_features=1, bias=True)\n",
+       "  )\n",
+       "  (distance_q): BatchedWassersteinDistance(\n",
+       "    (distance): SensitiveSubspaceDistance()\n",
+       "  )\n",
+       "  (distance_y): SquaredEuclideanDistance()\n",
+       ")"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "from inFairness.fairalgo import SenSTIR\n",
+    "baseline = SenSTIR(\n",
+    "    network=MultilayerPerceptron(),\n",
+    "    distance_q=distance_q,\n",
+    "    distance_y=distance_y,\n",
+    "    rho=0.0,\n",
+    "    eps=1.0,\n",
+    "    auditor_nsteps=50,\n",
+    "    auditor_lr=0.05,\n",
+    "    monte_carlo_samples_ndcg=20,\n",
+    ")\n",
+    "baseline.train()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "da851e9e-266b-470b-b229-806a32d41fe7",
+   "metadata": {},
+   "source": [
+    "# Training Loop"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "7136d397-a29c-4f61-92d0-70611f20b127",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loss tensor(11.2935, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(10.7321, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.1320, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.6465, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.5944, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.4085, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.5727, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.6411, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(10.2405, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(10.5633, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.1581, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.7829, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.1914, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.1587, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.2823, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.6258, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.3198, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.5528, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.6492, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.9255, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.0945, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.9413, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.9854, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.2259, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.5703, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.2719, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.8199, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.2028, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.7028, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.2733, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(10.5939, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.2807, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(9.3140, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.1168, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.7209, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.9868, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(10.1933, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.6560, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.8995, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(8.0981, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.4372, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(7.3379, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(6.5346, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(6.8720, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(6.2605, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(5.5615, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(6.0874, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(5.4418, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(6.3867, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(5.7821, grad_fn=<MeanBackward0>)\n",
+      "CPU times: user 3.23 s, sys: 220 ms, total: 3.45 s\n",
+      "Wall time: 3.92 s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "from trainer import Trainer\n",
+    "trainer = Trainer(\n",
+    "    dataloader=dataloader,\n",
+    "    model=baseline,\n",
+    "    optimizer=torch.optim.Adam(baseline.parameters(),lr=0.005),\n",
+    "    max_iterations = 1000,\n",
+    "    print_loss_period= 20\n",
+    ")\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 40,
+   "id": "6c227599-ac6b-4d57-95dd-9e8dd03929d8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "loss tensor(11.2257, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.2347, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.9171, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.3560, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.3011, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.5033, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.2771, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.1039, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.5014, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.2602, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.7446, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.2764, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.9515, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.0390, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.8717, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.8761, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.8281, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.4061, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.6437, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.3209, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.5436, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.7618, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.8581, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.4659, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.3047, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.0338, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.5776, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.4932, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.9934, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.8790, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(11.9319, grad_fn=<MeanBackward0>)\n",
+      "loss tensor(12.7642, grad_fn=<MeanBackward0>)\n",
+      "CPU times: user 1h 27min 39s, sys: 2min 12s, total: 1h 29min 51s\n",
+      "Wall time: 1min 52s\n"
+     ]
+    }
+   ],
+   "source": [
+    "%%time\n",
+    "trainer = Trainer(\n",
+    "    dataloader=dataloader,\n",
+    "    model=fairalgo1,\n",
+    "    optimizer=torch.optim.Adam(fairalgo1.parameters(),lr=0.005),\n",
+    "    max_iterations = 625,\n",
+    "    print_loss_period= 20\n",
+    ")\n",
+    "\n",
+    "trainer.train()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c1fb5025-19e4-4e40-aa65-9f252e7f6975",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  },
+  {
+   "cell_type": "markdown",
+   "id": "9bd43369-8c34-4a1a-ae02-49c899f92381",
+   "metadata": {},
+   "source": [
+    "# Visualize Results"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 41,
+   "id": "56e1fca0-2771-4b90-96a2-513341dd1e4a",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "<Figure size 432x720 with 0 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXUAAAD8CAYAAACINTRsAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/YYfK9AAAACXBIWXMAAAsTAAALEwEAmpwYAAEAAElEQVR4nOz9Z5BmSXrfi/3y+Nf7t7yvam9mpsfsrMHu7KwBdoFdwpMEDcgbgqigdKm4VNwI3vtBIcWVviik60jCXFEkQMISWLg1WG9mx7ueae/K+9f741Mf3uqurq7q6e6dGcwS6H9ER1edypMnT54nn3zysUJKyUM8xEM8xEP8zYDyQQ/gIR7iIR7iId47PGTqD/EQD/EQf4PwkKk/xEM8xEP8DcJDpv4QD/EQD/E3CA+Z+kM8xEM8xN8gPGTqD/EQD/EQf4NwT6YuhLCEEK8IId4SQlwQQvzfDmgjhBD/ixDiuhDibSHEY+/PcB/iId47PKTth/gvBUKIRSHEOSHEWSHEa+/UVruP/hzgk1LKthBCB34ohPialPKl29r8FDC38+8p4Nd3/n+Ih/hxxkPafoj/kvCMlLJ8r0b3lNRlH+2dX/Wdf3dGLH0R+J2dti8BaSHE0IOO+CEe4q8TD2n7If4m4n4kdYQQKvA6MAv8Gynly3c0GQFWbvt9defaxh39/BrwawCGbp4p5IfwgI7j32qjCEHS1FDDAITAFwpCgNLrwW3RryJiUXUCpIRAv9/XfXCEBqhCkNdV8ByklKiqhqnr+J6DIQApkULgC5XtUMEJAgSQMnRMJAJJIBRUoSB9GyklAhCaSUW6+O8yqjdvmCiyP4eKEJiKiqaoCEWl7dmEUmJoCu3AxQ69dz0n94ukZiNQiGpJdEVHEQKBgpSCEBcQhFLihS69oPWun5dS7Fs/nz/nlaWUhXvd877QtmqcKSSL9Gwf3wvQNIV4zECRIQiBYWo4jfbe3SMRp9Z+b79NPGNghi5hEBCxTFTpEwJih958KegKg0bPJxXR0EWIEAJD13DsHmEokVqfTsu2T/AAdBo3dKJm0F8vQsFUVQxVA0KangcoeFKh4th37cMw/Lv+7V7IGxDXEqg7YqtAIZABkgApFZzQoeu373p/Ru3e8xkX3oHGPvvZJ2Wl0rivsb7++tULwO0T8VtSyt+6o5kEviGEkMBvHvD3W7gvpi6lDIBHhBBp4E+FECeklOdvayIOuu2Afn4L+C2A0fSQ/OdP/gqGZeCenOPPL64D8HePDyLPXkCG/dt10+DkU3O89cK5PX1Z8Sgv58a4uFqjPfL+2Xu7oyF/d2SAwurFW69kGCafmhjDKy/T6u0SRiQ7zP+bQZ7f2OSLY0PMthbxfBeAicIwI6rHS5Ua4W2LY3tynD/eXn5XY/yl0RmKYZmYZnA6mSAIbEZSw3S8Foqeo+E5QIBqWfzW6vOsO/c8wb0n+GT+MseSnyCuS0Yih4hpFoqQCGnRDXr4skUvUFnpLnKh8d13/bzPxS/e+vnQ2MbS/dzzftD2WLQo/+XYF0memOT7l2t84tEBemf7Y4sV0hwdMag2HZaXa7fujzwyx59vG9Rq92Ym94ORoSTPPmrTq/W/9fEjU0yHm3hOj1K7T5OqprE68jQ3qjbx2lXCMGRqYpS8t46tpzi31sJNgxCCpdg0f3F9876fP51N8cXHVDTpcjoVIxlJEQnrGJEiHhrbdgcfky9vdfmP1y4f2MfkaOlHendD0fi/Hp+gaKXIGAkUwp2/pGl4y3hhlCvta7xd/+Fd+/iF5Bv3fM6R8bvTWKXc4OWXf/2+xqvpz9pSysfv0ewjUsp1IUQR+KYQ4rKU8gcHNXwgbiilrAPfA37yjj+tAmO3/T4KrN9Pn67tEl/dZDiXoJiOEd3cvMXQAYIgIOK66Lp6x8jFLcE9vhbyfiFpGBwxFSLq7vNd10GNJjECd09bx4wzpAoUIZhVvVsMHSCua4hulbxlIoBCJMLhVILjQRJdvLtN6QflTazIABPROL7fwdBiqAJUNUlSNknTwncrmO4Gn8sdxlKMd/W8mxiysnwsf4LHM4eIqOaBbWJaDJC4oYMbOghUpLAxlDiqSND1O6z1rrwn43k3eD9ou3l+kU99YhYWdwV9KSWhH5K443QphUIYvnd5mE4dShP125hGX27zVQsF0MVta0UziegqeVkjDPvXI7og9D2i2CQiBpOpGDPpOOOx+5L/bmG+2qAUJpiKJ/H8LoYq0M00ughRvS1idAicdZ7Nm0zFkw/8fqpQOJ4c5dmBYxxPjqLetoaGrAyKcOkGXbzQp38YA4GPKhK4YchS++oDP/PBICEM7+/f/fQm5frO/9vAnwJP3q3t/Xi/FHakGIQQEeBTwJ1b618A/2jHU+BDQENKucF9wqm1KMZMDF0Fb+8RNPQDuoaFru0lKjE+yrXNBqm4yaePFPn50RwfGcmjq3cw/3eBz80U+WcxwazX5YweciwRuyW2lTtd/OGj6LEMWiSBMjTH1WYLVYaoQqDKvR+rGwQIRUFXVE5lUhzWHLJujRNmwP8yfZKfH5ggqR/MGO+FTbvDf1pbwzEH8YwiTTWFLywKloklHLKGRlIzkCi4bonjifF3OTPw0dwJPjMwx3Ak5FDC5BdGnqBoZve182UAQMVZxQlCvFAiiCCI0/QCbrQvUHfvi0feE19tH3ug9n8dtB0REt/d3dy75QZ+Lo+QEiHEzYHQSecZyEb4qTMDfPaxQcaGHpzR7XTFZz40xKMDIXOWy+mUZLYQp91s0IsVIDuKFomh54Zppsao1eoo4a6aww5AKCqWrnJqyGQwbDIh2nxmMMq/+tBhCrHIfY/lP87PU1XyeEYRqeeIWim0oE5MVcibOrqi0nEaPFXIP9A7GorGL42d4el8hpGIz4fzGX5p7Az6DvPu+A4Sjbpboul1cUOBEAaKiNMLLF6vv0zD336gZ/5IeI+YuhAiJoRI3PwZ+Axw/m7t72f7HQJ+e0f3qAB/JKX8shDinwFIKX8D+CrwOeA60AX+yX30ewuRQobVRpda28afGYDSXl3UpS50Dh0m06iieC69bJ5vbNnkEiZfGNDoXb2AE5PkTIPZo0f53cUS/n3ugHfDqcEMc80l2q0Gi36BWT1CulNjNJpipWtTjqR5a/5tTMtC1aLU1tcxIjEu9ly8MKSkWCQQ3Dypr5S3GZk7jrq1RNxr4gc+I8NzlKqLxMImn8xOM5kp8LuNKpvOgx/BN+0O3yltMqU0mE0P4wcKUlURMiQIPdK6xrr0cEMXU7He1dxk9AQz8Th22AQgkAEBVT6Um+Uv1l+51e475SMMWvNMx2fxZZsN+yqWksBUhni1+vs0vHUk798p6z7w/tK2EKyWe2THh/EuL9y6fPWtFWY/fYZocKXP0ONZWih8SG7Tu1oH4JMjRd5K5jl75cFUZaeOFBjrLbD6lk3y6Snk8iWyhsO6UOkEGS5XHbphls5WB7tXp1k8RsrMAhUAVta2yM1NEtNttjY3yGctzMwQGytvczKW49fm4vzRss61avOeY3HDgBdLZSa1OkkzSkY1EbJvKwuDkGI0zatrW2jKg21gj2eniKgd3J3NyAkdImrAE9lpXqhco+w26fgpTEVh016i6m4TVdOUnUVern7tr4fmJHtsgO8SA/RVg9Dn2b8npfyruzW+J1OXUr4NPHrA9d+47WcJ/PMHGuaOlBJJJ9gu5ihf7gs/zzd8fuLEHMHSGkJVYGKUb6w22Kh1SURNdD1K7VIZKeFnjxfpXripaxd4jkv02jVOjkzy5mb1gYZzJ47EVZy1JjqCLcoMzB5hYniaTCRKw1X5H26s8pPFWYbbW/idJma6yFUjw7nVvt7xzzcq/IORQ0Sb6wSBh0gM8L+utvjM8Byd3hZR06RcX8fptRBGSFQGONVlnslO8/s/oo79O9tr/NOJGTKaznZrlWjuKIaaxPZdekFAqadg6mmu1Bbu3dk7YDI2iBt29l1PajoKgvA2lfOmfRWBwnB0Bk2o1L0e860/pR1U3tUY3gu8b7QNqLpG7MQUX39libHRFKeOTuOtbqJYBuHoCP/6P7yBsnOq9L1lvvCT0K3Ub93fXdvm+JEM51SFILh/JjSVVXA2+99m5VqVY099mEjoYsUKfGvNJSkUZGsLRTcIR6b42rkK2ZjJT83OoLU2kAgut2OEgwWUQgwSsFFaxXdtVFkmqhb4+GDivpg6wLc21vlvTxwndEqU1Tx5PQPSpxP4NFwHXTW4Vn8wIaZoRvFlb881X/oUreit39+ofZ9jySdIGWncENZ7y1xpvf7XKERI8H90Q++enqScB07fb/sHU5S9hwgiFu7pI1yzfS5d2T3NNnse9VyM0eNzOJrOC6UOc/kExwsJrta6LJd2vSRigbvPYmV3ugzpKldNgyeLKeIKXO16XC3XH2jjDG6zjx0eGSO+dpWuDAgTWZJajH80McYfr27hE2Eolmah1aXc2zUkVW2Hfz2/wVwqTUxXubzeJAglHylmEE6TmDRwXAcA6ap4OzrBlPzRia7ju/xvi9cYO/YoMWnyyvYCuWgWI/RAeqh6jov2NhX3/qzyd0PNa6MrSZxw78Jyw3APQ7+JDfsyG/bBxrD3EjljnBXtWU6Y28D/9L4/766wTKoT43zvhWW6LZtyRKM1OsLQY8foobBZs3n01DBblR7XLm8yOpmD+n4hxOg0OX1skKwe0Hbh7PUqtv3OHjLBzv+RRIyZgQj2+VdRLIMg1+ZwdJDfXzZRGaXdCVi4skUoJc2uy/+31mVuqIiUks2lEv/q2WEG/RayZfela0AYUXo9h6R+/ye9pufy+4ur/J+m0lQaZVrxAqFvEwRdDCPLiq/yaunB9NtOGBx43b7tui9d3m48/0D93gtCxIhbH0dVEoTSBn7j7o0l960vf6/xgTH1luPxtetbe67FIwafL1g0X7vAGjBTTPIvZwepVas0qi2OJpJcODzAd6707+sqOjc1fEZL4iYERsQiMDT+ScHCvX6RwPeZSKc5PjXJl+Z3n6cIQcTQ6brugcz+jarNz+YG8Fo1hqRPTlNQ7C7EExRbFdrrDUzFYiU1xO+tbd1S96hCcDyToWDoXGi1KNs2T6UyPBtLcTKTotWpEDETiNYqg6bFtiLwzCQ3en1G21HendHUDny+sb3FSdPGC1wW2lXSZpJ0bID/8fpVkslr76p/gOXOJr3MFKqwkTtMXBcRLrb2qwq+Uz7CJ/PvP0Mfto4yGZ/Bl00U5b2RkH5UNFsOL71wA4BULsYnjmZpvXmBZsri9OECjw3EqZQdGoZkbvwIz726hEgNQ21XYBHA5NwQnLtBt1qnaOgcfmyOPz/fot60URSBZen0envp99Kay8eLOUaGEqScTXRLEh0Zwqtvk6kv8k+HJ3m+m+JP3+4z9EIqypHBONWOT9rSOJETPP5UkogBSjPEcuoMWgm2hUonWqS+vYCXyT3QfFyql7nczSCdGtRrxI0YaSvGUsvnd649uJH8leoyPz9yBDus37pmKWlerb5/dCZEhEz87wMNwEfhXn7U8m8fUz8IZ0YytC/0P3IhYTGlBDS/9yrW6cPUN0sM+j6uqnI2EaHa6vHKdo/Pz0wRrq3h+QGBJvAPzVEIA3pXdomlV68zrK0wkc6yVG/zoeEsj+g+Rq+DHU3zSg/ObtX3jGWh2uKHkSwfnx6moG0T9lp4hVG0tet4dod4Io2BT759hafzMzy3XSJu6PzqcJ54dZkhKfivBvKkBkZ4+8qbCCEwm9cwNItaZoxuYpxERCNhJXhpbY2qrGGlRvjL1t5xHARNKDyTH2HS0PrHZbvH85WNWzLyd7ZWiI1MM2MqaPjUMPjT5QXWug3WugMcHdx6x/7vhRDJlzde58O5o+RMCz+UXGxtc6757tQ6PzoEI7E+Q/9xwyPHh2hfuo6iKpw8XCSYX6Y9D/HjszjLi4znQkZHMqwaaUbSdXAdHNujODWI3WzRrdYBCFyP4OJFPnz4JNudgKOpAN3tYJt53tgIuLzQd4+8vlgjHStwajRDZHERpTCMvzaP0+0iBBTMBgPVEo9OTJCNaRzVqhTEKlNHxojRY6vRQS5t0Q4C0ofO4Fp5NK+DkS/y4uVLRBJ5nqs4d33fx4ZynMpHMIRkJebzV5sb2IHPHyyt8bPjw6SFQyAULrQFf7j0owkYFafJVzau86HcBDFNpeMHfKtynYrz/n3/qPkhoMXuWegex/6/jZL6QYgISbijPyyYKnT7x3sRhkSLWTIDGTJxE20ix++/tUbG0tFTFmPZGIqqsFxI8b9eWOIf5i1u+huoiqAYtTDcHo+NpYjqKk+0N7HLZW4qDz4+NEw5FWO1sVdP/MpalQtljUceTdH1AoqKSmj32wRCJakolHtdplXJc8DnijnUtUvMpWJEOxWiPZXk4iZHVYkTieM3ahB4JEKPV9ZWuaAoTE2dYEFJ4aRiPN+qstq7e0DETfzi8BSDvQ28nWCVJ/UIieI4X9vRxYdI/nztBpaqEdUM6k6PkH7A03Q8w8lEhMVeiZa/Xy9+OwSC0UiRrBFjqVOi4bdvSea9wOHb22fvOdYHw65h+UGgCh1NqAQSDCVGXUy8x+P60WGqIENJrhhH6XRuBZpFBzJoqkSJRAjn0ly0AwonDpEObYJIlGY8yfyXvwX0aTifjqBrAjFkUrx6A+d6lZvnkQ+PjVFpxSiV+9/ztQslPvZInqDuki4IlO6OzlpREIDb7XL6UJR4e50xrUfKrRHzkyjb15gamKDuqdS6Ac2F8yznRtGdJpHBHKXYOK9sd7lWrXEQPjRW4CPpHk6vf2KbMiT/ZHKc37gxz2avw69fuUbatAjCkJbnEtF0Hi8M4AYhl+oVvLswwaKZZiySZsNpst7rq6nWelX+ZPXd2c0ehN5UJQV4CGGia2OI+5DUxbtQpb4b/Fgx9U0n5GjcwmnbiFD2vTdUBTWdIGf3cN6+jMhnCFjj//LEcaKhS7dUpeT4rM6vI4sRnpibxVYCFCBm6ByLqFCvIqwIZ6TN0eEUpVcv7Xlud2OdZx99km4uSiT0qAud7603aDouHcdnRcQppotIBIoANRKnqah0g/6ufVMfPoBHXNdIuB28MEAzDMLqBlY0gyJDbNXAC1y0HULywpBXGza/vdjXxWvD9zYYZc0oY2GXbrCrW3W9HkfiGb6tqLi36RWdwGc4kuCjuQFCKZiMx7C8KmnN4dHMLNd9hxdqBx9ZDUXnpwfPkFR9RqIDJPTHqLkur9eX+UH5Au4DRKa+kwpGFTpziadJ61mEEDS9BleaL+DLu0ca3olAunhhQELPkjUKO/rOHw9U2h6jkb677k2elTg+jdjYxL28iJaMMzU+wrEj42wsbFB2QlavXmLq5CSZ4QJ2tc6hvAGNGkHPZ6h4mis3HFZve4babfKPnz3J4lKVRqDzwsUK5xZajI4dIVT9nZgFDT+epdbtf7diMkJ7s046J/F9vx+gI0F6DlFdUBeC0HMxVJUb9Q7bSo8/uvbOwUdn8iZOa9dVMJQhKafMoWSGK83+RqAg+HBxkJlEgkFTodFZRwiFTw/M8kfLG6x0dlVQCoLPDZ1kMmoxGskQ13TaoeCbmzf4XukywY/ANBVUjqaeJGdkEQiafpsLjZdx77AP3Qk/qKJrc1jGLH0nqPvYDB5K6nBurcr0kVki1xfoCnBNi+SHHyWwuzjzK6iGTjuZZMj1ib/yOupQnuDKArlUAm12lOZmmbmEyQ1VJzk8yHi3ib+9hVAUlMkplt6+yJnHT9DUVBx/l/klUklmZZuz1/tRf0OKwj+YOca/X27S83y+vtHhI4kM6UyOWMTCWZ0nYkVxmj0iuSFebPUJwhEKcU0l9PrMudMok8oOE/Q62HYXJ5JG79boCBUhBFZunD8t3/vIOB5J8tFklogI0c04hlPiTvZvhC4xzcB1ewjgU8UxfrowwJDq0/J9JD5RTXI5UNlsGuTjFeaMNPNmlk1nv8Tz4dxRTBqMRacxlBZu0CClmUxFNcziab66+ToSiUAwYOZQFcGmXXnghXY0+THiGoRUQUJcUziZfoY3a1+7r/sHrUMUrXEsNcmgOYcdzj/Q899vvP3WGiOfmqO9voEtBYnxQaKTg1S+8QIIiE0O0l1Zw6lX0FWNZKvL8TMz9Na3OfqJM7TfeINgvc/C9eFh6pUmBeFSMjUcxyeRSzE3ZNK6fhZjvU1RUfi5x4/z5XNVZhMxTgykycycxK+sIcMQV2hEBkd5e6vLqaiJ8Pu2HE+q6Ahs10e1kujdOmEsQ6nVxCxO852l+oHvl42YPDOeI6tJHi0kuO5Hafd2qdP1egxaebZsi1+bneFDSY3At8lYOvVenY1Eluv1TfA3+JmRQf7t1V2mfio9xpARMBXLAlWcEEyh8nQuhRBH+NbWReJahIKZpOw0afnvzJgBTqQ+RNrQCGV/k4mpgscyH+elyl09BDH1E+jaCDHrU0hZI5Rd7hniIyX4Bxt032/8WDH1IAj5s0sbHB4eYiJhEg4kMLZKzGUzGGNDdCIRrpU7TPpdZOijKX0PFb/RYmZugpq08be28BbXSZw5QTIxQXc1i5LJ4LfbnJoYxlR1Rop55td39cqzE8NsLOzqg2UYwuIVnho5yveWy3xvqczjn5qmUlnFjcaxZh+hUatyaG6a/7ncZaHSZ4pv2yEDRhRFeAR2G6/XoTN5ip5cw3Mdznc8BsbPcLnjUUrP8oOtOpXeO0uVE9EUvxiPYjcXATCEyvHxk7zstPFvCxrpqBYNt9/XM4UxnjRcit4GdreHDozkZlhvrjAVK1Ld0T3abp256OCBTL2gW2iKIKJK/B1G7UuHiWiRE6kMj6Sn2bZrJPUEZW8VZIgbHuK58hVWewf7VqtCRxXGLXdIXYmQ1BP4cvc4LwmJqjpRNUM3OPiYfxNTsccZjBQIZAc/3ETKAQxlkk7w7mwG7yU81+fLX7/C3JFBzMkxhpI6RqeDVswhUknKaxVMz0dpddBHBtFbLdJBl/VGldL1VSZOHqY1PAjRKEGvh6Eo6GND5KmxttViZCwLmzeoejGgT7ti6Qpzw4eY71iMNbuISJzoyHF6nQ5xNcobSyqvXdtk5vFRQs8Dx6W6vsrgzEm6tTKtdkgjOUvdLPB2t8EPFmo0bXffu8VNnX98KItX7a8dEUlyMpvkXEXStvsM1rLSXCu1+UeTY5zSqjjNNhFVIyoMQjOL9DxWNBPHd0gqDknDpLnjFTYRTWFpBpro4e8IxrrQOJnKcygxxWcHjuFJm+XuGpJxFjpdvrl58ZaK8CZMJYYvHQQKGTNNEN5OV5KoCim9SMPbH5AUNT9CxDyElE388AaqyKIqs7j+PYSHhzr1XYRScmmtyiXg61c2mCqm+Ew+jtP0aW+VKSYjhK6HHYvcijLVNRWz2wZFUJcCGYYsvvo2xY8+xnrPYbw+j9jqL3R3dZnCJ5/Fz+QJOy0aoaAZTbDVucPv1fPIKH3iUIWCM7/FS43dVA+KomBUqtip0VvXXipVUAs5BsYmGbTrNH2fHyzcQE8VWUlmOBs0ePv84l11hwfho8kMdmPx1u+uDNgsLzGTm+ZK6SoCgRUv8o1m+5Y74dGoRQyX8LY0BrK3TcLK0JUemtKfN0WoOOHBniK+lKhCRdzm15s1ssR0HS/skdB6jGUHaLp1FCXLcncZ6PKx/GH+cKVKeNt9AoEjf56P530UJG4YstB+m27QRBx4jA3QFWvXJnUAVKEzGBkh2NkQQnwc2ULBpeJ8UAbbgxEGIVcurHPlwjrJbJRf+Tsn6G7a+Os9xk0PFEiODdCq1kkT4NebRCbHuLpUQl9fJf/YEZpvvIXXaGILwcChMaY/+jjy/DyxbIJaJUW1vCvh+k5fl54UNmfP7boLKopCKCXJoZM4rs8fXmyTeuoUU4Uaru1wds1GRIdZUBL85avrlBpXaE0clPqmj4+O5AnquzEV8w2b44pkMlfg/NoqUSvJ5SBCXPNJBXVMFHz6a1yGPhEhqXstslacjbZDiLpnbXgSDKEhd6wHMS3KUCRFSBdVURiL+bQ9hZA8V1tLjEdNTqXHeGtnTAVjjLnkCUwBIQo1t4Ui5T6ykgSYykGRsiqWcYR+BgmQ0iVkHSFTeP7ivT/8Q516H4auEoSSIAiREua3GvzHRpefPzyDfvk6jZ7L5FABJ5/jysoGg4UcicBFDBToGTEWlvsfVAKtjs14NoV3tr/IY7EouXwW5eLbJCcmKAU+Tamy6Kv9YKjbfMMMy2J9R208l09wLB/Fj47SRjBf2iDwfQglqtgl+qiu44Twm2t1hIDDkSh+PMoL5RZb3Rv3fHd/PbpPrx47IFjiRqdGzyxQtobxgZfLZcrOrtFTF5Ku56MYOsGOjr3tuehGmsAPb13TzTznyxcOHMv1TpnTyTS+7BuETMUkqhn4YY+QJAE1FNEgrsdx6fazLxJiKC6DkRzrvd1kTGcyc0zGdEJZIgQUAYeTZ3it+k3cUCLu4BuB1Gh5u/erQmckcpSolqThltm0r2IqMRTCPQu05dfJGIPoIsqPE1RNQVEVPMenWe3yl9+6zscOD+DcWIF0FE9X6Saz6F0HFQ9tZpLNlTrN7TrN4RTjnQaNXg/V0CgMZEjg460vMTqax7EiNO29G7MRjVHqSE7PZkgEo4RCYbvVo7TVn9Ob0y0lfO1qHV3XKVo6gYQ3rnbYqN7fSSepQ+jt0mfDdnm9FJAfjbGqjnK2UedKc5nHcgW8wCPYcUB2wgAfA02GKGqUrm2jKiorjqDn79pq3qytMBU5hCCGoEF65xRsBwG6ohOENWJaklSgowkNN3SYjmd4q77MC6VH+O+Oj+GHFbydZZ0xTOLaEDWvvuc9pDSouv1YmZwxwlBknJiZxnGvIIRyiy14/gqmPofEQRH3ioJ96NJIKmryzHiWWKsLmkLJNPnufAnPD+jYHn94vcrpyRlSmuDNbILo0iKteo+qofHIT5wBr4vY2mIkNFjZyWK5ECocLRQxhoYwkQyKEK20hXQd1GSC9nYZQ7OQqoY/dwxv/ko/U93UBJHCAJVKj+zcMIebq3g3VjDsLTKKyiOzx3ljZYGwOMrFSl+V8UgmzaeNAFlZRCgqXnGcP6y02NjRL1qaxslshololK1ulzdqdTre3Y2NqhDMxjLErSRhU+xJz2toFi93mrxaP9hwteVJAs+hSwxTeIRS0lNjrNsePS2JYeVZdYssOhfoBgerf841F9CVWWKaw1RsCEMNafsOETVFw6sjdw65qgBFSBQhCGQ/o19wR3DIZDS7z90wkHVGoke41n6Do4knQHSQMkSIJDfa5wh3pDNDifJI5tMookMoXTL6BIORKc7VvkMg9+o1m942yCgt/68vvfA7QdUUPvzhGQpaX79qmxYvvrHC6nKVv2x0OXF8nNh0nmi3xeY3zlI4OsojZ05Rq7XRm3UMXWW7E+BH4qjDwxQjEKmVCDa6aN0uVrJH20gxeeoIzRfPo0ctJmYGCVN5cpiYqxcx3A3CwGMyncMYGaLqhJzb6vIzJwaZCrZxG+voWpJtdZg/eXubMJQcHs1wbChFudnlB7JB29mvetFVFdOMMqQl2Wq1bmUedYOQFzfb/MW1dZzx/n2XG3U+nR1m2+0xqGkEoc+W7ZCNxnEsnW6nwkpg8efLe5Mebth1vl1aIaImmUkMoYgQNwgIZAo3aPW12sLBUA00oeFLn5s50R5JjxHc5scOEEiHblBHEVkUuoQyQFUSXGtdxZcux1MfpmjG8cI2pl7AMg6hiCiB7Ksnw7CJ7V7B1I/jHxBRvQcSeA8TtD0IPjCmrji3Hc8F/OR4ls5rV2jcdPkydJ45OcM3rvZ3UMfzeWXhpvS2zVAmzrHjxzk5nOL86+eZG8uh1eoMqSpKIUlsahyXAO3GMpgxUoU09qsvEZMBIpvDW1oiIxQGB7PcWFnmG5kxRsaO8exgkvDaRS7dWCQhJc8emmBVhSvVHkcGi0TtDlZ5g4Fjj/Mfy3XcIMBUNT5lSuy12/RsS5f4wsRxfnO1y5lchl9KG8x0tpBtBzc9xKVomj+tu1yo74/uLJgRfjlTJNrcwqgscGL4OPPVRdZ7bQzNopkY4c2Nu6sY/nJrlX84Osm1XoNxK04qkmEhNPjLzVVeqlxEU1S8MODo4DuH6r9Rv86b9RtEVJOP5k9wOpUnY9TxZZ+g/bDPzJ1AEOxEHXZ9jW1nV2epCRVT1W/pRG9CEqKiU3fXeKVaYsCaRUFly34e7zbvlen4GaBOKCUKGjE9SQKT0dgJ1nuLjEXH8HY2DE3EWexc5Xr7JX4c8PTT08QXVmj2dpniJ544zJ9/8wrths1LLyzw0gsLZIsJPvyhR0geSrPa6iIu38CyXU4fm0Em4ri1FqZQsNIJgvUVQttGG46ib2+SHolw8VId7cyHmQrKVG8s0raXOZQO8IenaPV8kn4H0eswPHGYby1JUtGAic4i3VZ/3ny3TKbT5LMnjnM0q3JUriM6ywRjg3wsmuOPNmze3N79pnPZJD89ZGG05pkYG2UqrnK+2qHrhcj0BN+5tFfS7/oe3631eCYbQQYqRcvCN3P89lqDP1laxAnvnqv9cmuDy60NckaSfz77UUaiGh1/A1PVyBomoNMLQuzQxlSiXGj0BR1L1VGFeiuh3E04YZcXK99iyJpGU3TWe6/ghj0SWo6imcILGyhCRdMGEGiEYQIhMsjb7D6t3vdodb96j6//3qUJeFD8WEjqY/kkYmFjj/rDdz0KvR6GruJ6+5WrG7U2jh8w0azQqTQ41+wwNTNHXAmZOjnFwvkrLK1vkzR1jhqCqNPDLxYRjo0sFvEuXUIxTeLTc4hml3rXptGFk61NuqXbDIelTYbzRTZCybm1LnpWR+sFvNFxuNzoL4rZZAKlurZvjOlek0I0yqeskNHaEk57h4m2KkwNHeVTSZ3LDbGHoP31KF94tADb1+jSd556ebnD9MhJKkaLBcfmtY2FW8bLg9D2HX5z8SqHklkyPcHFpcs0vF1G6d0lzPogSCTdwOZbW6+T1J7GDVUGrCghDp1AgDTY7G1hKSmavuQ7W2/d8op5OneUqViaqVgBU4mx1kuQ1vubka6k2Oj1w7gD6bLeu3jg8yNqDOgSUVPkzSGk7BvRTqZ/glcqf8nF5lkOJz5EyijS8up44Qbix6CeuqIqFA32MHQAf2GdiekCC9d2GV91u4XftbnyzdcRisL4kUlSMY10Mc76tTWWal1OF1TcNxeJHJ3Br5TxEAT1OpEJSYDA7/S48FZflTaQixJ0W4ilazSGx5ivdrH0GMFGi9dWfH7qUAZ7c+/JyXddnh3VsLav4N6MDG41GJ06xDOZKOcrKl4QoArBTw5F8Mo38IBXrl1lpFBkePQoX1qo8eKFTXrefmb2Snmbiw2D4+ksPb/FxfrSO9Lwnai4Tb5fusFTuSwjUQs3dOn6CoaSYa23iCbSvFUvc6O9xScKRziSzDERG8YNm1TdEh2/gUCl7jUIpMfqHemei9YYftjGUuMMWMPoahWQKNog1dbrRIw5NLWAH1Tw/LsmSNyF7MfXfBD4sWDqpq4SHkAIeD6qonA3i1kubhLU+owy8HyuX+7r0x8ZyrC53b/edDzeDjWKKZ344Rm6C/P4O9GmQtexNY3mwDCbN0o8MZzF275NchYCmUxjqQqqqhL4Pl3PI5LJcaWzq/vu+gGKZgB7j2SBpnE4EcVqrWKE3VsBUUhJLHCId1sUY3E22rtGLkvTyPjdPWVQPN9laeMS540055r3l7UvRHK5+c6S+KXN+48uDZH85cZrPJk9zHAkJK0nuN5e5/ulr6ErKgoKnWDX2PxIeobpmIkn69xot5hLTDEVG6bn1/CkYKWzROc+knr50kMHssYQ4O4kZFJwwzpTseOsdhdQRI+a219oQ5EcSeOTwDfv673eLyiKgAMScQWOh5lI7LtuEeDR915ZurhCcXIAZWGRrhmlVOuxnkozPTiEjKfolSv4N/qbY5jO0mp6KK1dJt3seExMDhC0W8QsnQ3Px/V8QjWK41bxpNhnQ9I1lagI0QKb25VXan2DYnyUsWSc+VqDoWScaK9yi9LDMGBla4Oo7XN2mwMZ+k20PZeXS/dfaONOfL90hZY/yZFkgUErxZbd4s/Wvo+KQiewCWTIk9kZZhM6LX+LqhshpacYMMfYlDp1z+ZS83sH9t3yaqjRPAVzEIELhEBIKDskox/D8a/g+n3+ErNOoKlZ4HfeYbTyvczS+ED4sWDqy6UWT40X6Z5bQADD6RgpAZHpQc5stXhxsXRgprqNehc1n4PmHfotYeLe5iPa83yW2jYDAfhmlMFHHu2XoRse4RVX4T+f6+vylls2H0ln8bY2SKaSHCpkSLfrFDIJEkdmuLq5xbLusVYcY2F9lzgXW01aYyMorTo3gxI0TWdRi9G2PQKhECp7p1oKhVA36d5RwiyUklDs/yyKqtN9AAn7vUZEtYioJs+XL+zxbAHwg/0LeTKWw5P9zSok4ErrOjE1QVYXnGt8A+8ewR4ACa1I1+0ym3malK4h6SdwcwKdTfssqjCZip/ECXeLUIS4JLXUu3vZ9wC+F9DVTRACRREMD6eIaAqJoxOUru931WyHCuYdjFYxdDo7hsjNmk3SD8lN6Bjj48RGhhDZHEvRAb7yF2/zzIkMMSCSijE3M0iGJtFkivxwDqfdoaLG+FalTz+vrrb55bFRepu782akcmz2QkbupFNFI1B0Ol7/hOQEAaj76TMUGl6wX/f+XiKpRVnolHmjtnjXNjOJNG7Yp7uau0LD2ySqZCk5bd6sf+eu97mhTc44QtbQkdhoIoKUCra3jKEWUUWEQPYFPinbmPrkvQf8t1FSTyz0aE1FcDyf1xzJZz90lNFKHcP10GZGOHtllcJGjc+emuGrl/cXUmj3XG5EikwVMnRLNRCCxMQwL3UgkUlh13al7jUzRlWPcjiVpnTtCp5pMb+4TcOMMJsqcna7zlary/LAIKPdNocLGaz5y8QTUTZuNNFUhbnjj7IZsfiD63s9WSTwn7Zq/J3x44yFDuOxCF09wmazx1bPppMfotVeI7pjDFQ0g7qis2ZGiWoNPpkfQBFwttXjRqPJktAZU3X8W1Gjgk6iyMLmuyt796NAFQrP5E4ybBikNYOUkWfTbXOtu83Ltav0goPzgBykAOkELa61DXTemaGrwuBU+lmiqkraGMVQdFSRxZMNQgmhbCNlgCJ0DjrFhffo/68LL76+zM986hHmVBdZaWJMFFmvuxS3Szz59DSvvLhrg3nlzXU++9NHsC9dI/QCmtU24iMnKX3rdQCqDZtSMkU6lab+wmWEqlGfrzHfuMbRiTFeut7ip+dmOZSRxFcuI5WAXq5A7/zbHD7xGH+8qXDpWp9+thtdvhlN8vTYMeYSklgkwoqrUfIVksIipqqEO9HSfnaETZI8WeihFxKca/So6AkiooLc2YAURWFTSdBy3ptiJ3ciqpp8fvAoA5rCSCSJqsS40K7wg8oNFjp7S97dSXeh9GgHW3fN7KgJgzOZT5DUIyRUFV0U8GUbaCFlB0UoIBTkHVHKB7vi3oaHfup9q3ltq8WAqdFsd2h97XUGj41R1xQipTqpuEWjvd9T4/vXtlkZyHHk5DABgu9ttdl+fYknnxrjcC6HWq8TZNLcSKU5iUCurhKaEdYDWG93oNXlZHGQszv9/emNLT5/+DhHGoukB4fYLG3j2H3GZSwuongakwNJ5pt7dZIN1+VL21X+WTHJhSvnCcOAPIJ/MDrLV1oBdmqCM7kRkqpK3YxzyRF0HJdfTUo6pSuAZDaR4/WhIl86V+ZnT04wIX1UGVDWLP6iukWI5JFknicjUSIypCZUvtEos2nf3RKf0E2moknKrs16b39x53upYD6UOcKAYhMVMKib+MEaU2YW24PiwKP8ycYrB0aRbtptJmIagfTJGXnSehxFGLxWfZWJexTPmUs8haHYeDLAUDRcuY4nIzhBA0+2QUJSL7Jt19EVb59LpMKPj0uj7Ni0fZvQh+b3L2IW0kSTUUYsBU1X8XfsRc1alz+9UOfR6cPEVFiwQ158rcrTJ45ilEsIQ0d//Bj1S+dRNYO21Fjc7mD3PGaHQl4udfhOLMdUwsHM52m3OrSXt/EMMC5fZiI5StTU6Tp9QeHyRpNjxUHWFq7j9Lp9lWCmwPr0UYayo6QUDz+apRSLUyytQuUaUkpmEhmuOXHi6TkGhI0UsBaYfG2+whfnhhkzAyRwvSP4SriyzwCqKwqziTQhcL1Zu69i1j81cJRE2GAqMoAIa8iwyulEEUuM8G0Urnd26XfD7jIR7eepzxoTGIpBIHUuNL5yYN9Hk49jKD1iahFXbtEJVEwlJAg3kbKDqkSRUiXc8VW/9V0PLF27t8XfOu8XccdKPJaM0D6/QF1InJ3EWq2LK4yenmJzq04ymzmQqUPfl33+Dr70ndUSL+oayViGXsvlV8wusXqJxkpfmsiYBuPJNMutLuZtFnIp4WKpzqxjY8guvr1XEnVbDcbHCxwUT/YTuQzu8sVb9R5B4qxd5+j4cX59cYOYrjMej/GTcZ9obYNfTkXxrAgXrChtu0OvVeHRfIwXVZUvlZbRhYIilFsBQicSOT6tePSq8wRAEvj7uSl+s+zR8fcffT9TGOO0IQntBmokwlZ2gN/bWNhnKJ2IDHAqOogBNGXAi40btHf04yNGDD+oMGAU8MP+/Ad+nYKZZdspcyg2xqX2/vq7L1cvkzYe4/H0HFGthy8Dyk6Vj+Qn6HqjVN3VfffcREJLIbm5aQqiWg5Bm6g6gBQF3MCj7K5yrvEd8uY4M/Fj+LKOQCVvHoF7Jlt6n7FD2seODtG7sU4zcPF2IjK7y9sUTs+wUWpjRQ3ajd1TRbfr8vz5vTrn5fUm2WyME9MZ8vMLdOeXCN0+Y54tFriwEaCFPooiaLUdNmsOlt3A69zc6BVAoLYaZBLxW0y9kIoyam/R7e4KBJ1aCXU7y7+52ObjhwvMqqscz9oooUtxfIILK8v0WjXmzBi/uehje30G7gUB//DYKNnWDYJOvxLBUc0kZo7z+84ubUzHk/xsMYO+E8Hs5Cb4463KrXwvMc3gp0aGKRoCOxSsaSrLdo2cJkircVTpENxUb4YddBHyaHpoD1N/bvsqhdEzfLQwTErvZy5tek2Opx7j5cq38OTe9ZzUU0gaCCEwlCia8FFEEl05RBh2cYMyrc6XMY0hpGyiazNo6ih+UH9nGpB8YN4vH5ibQMrS+KknJiim+lKVFobYro+M7NbplGGICiiDWbbr9/ALvQPxtZCe57PVaHMkkyC4Pk+p3kbP93NBB45LTvTrRJbVvYWYl2otnIFRXOW2eqdC0IkmUCIxluyDN5e0CG9j6DvvICWJHaZs+z6fjWsEa1cI3R40S7B6iSO53RqNaqfKSKwf8u3JcE/E5+ORGL3OXuNiUFvh6VRh31gmo2keUR167S0c36bbq5HurvGpwsiedkcSWT4RzRN1ttGcbbJuhS/kjmMo+s3X7o/rtk1YIkEIvNAhZ8YPnAsQvFa9waa9xXynwsXmOut2GSesE/DsXe65rf+b8yFiaAIkDna4ScO9gRf2uNZ8lUC6bNnXOVd/ibYnSOnHsIMSJefsO/b/fiOVsHj6o4ewDJV2o4ca33s0UaTEj0fpNO+deCwMJeVym0Fps3ljHX1w6NbfZK1GPh2hqVq32tWjecLbi1gIgZPO0dZMqq3d5xXjJkF3f94hw+0wNZDiULBBWN1AdBt4tS2iW9eYHOg/W7YrTCZjuEGAFwTkYhGGwhpBcFuRCt9hynCIaH06UoTgC8UsfmuFntuh53YIW8v8nYE+7WtC4Z9OTzBKGd3ZJuFt8fFonKOxQQSSqKLfcpsFbnlYRZS9wmGIpOy0udxYYNspsdJdoOquImgyHT+5f353Tpktv0pMKwI9vHAbP1zAD+cJghpt+69o9V5EUWZQlQSudw7Pf+seX27HUHo//95jfGBM3e+5tF69xmfVKIauUlP6UXdbfoiVS/QTXmUS+Mk4V1Qdx33wXW8qk+CjI3kmU3E8x6VartIaGEEfKAL9qFH15Em+vbnXVzwIJX9RslmdPE5seg5jeJTgyCnmt2tsFcZYaO1XYwCUpEC9o0C2oihUdwyfo4kEkUZfqvDCgEDtE7zVrWOZOwvfSlB2Dl7s1gF6vCD0iR9QWON0IkW3V9vXdkzbW5j7Q5kcq5W9Ur6wtzkeHwNg3e2iCg33NhWLpqUp2WUMNcZKd683ztHEOL84+jR/b/xJfnnso6hKQN1r7fEXjukavMPxtWyvo2LtjNlBYRBNDODJECFSVN11MmbxVvuWv8185006wQqtv46CwvdA0HUw5jfIFFNoMZO6LzFT/Y1aNXXUgSwXlhu3dNLvhHjc5MzRAQbTFl7HpqxGMUdHQBEITSN+6hg/vLrLnL96tk5p+lEik9Pog8Nw+CRLtR6XZZyes2uUX613URL7C4X3jDjTaZVerYLvBwQ7RtHQc0lp/W8mIgm2ursSb8LQEf5+mlUCm+gOUx+Mxol7+2MyEkGLvBXldDZPxKvsmRPHa3A4kqQaQMO30ZTdE1ggYjS9Jk2/T5eGovG5oZP86tTjfHZojuFokl7QJpB9viEJiGv7BZBtZwtVWJhKFDeUaGIYVaSRoSAMDYKwBCi43mXCsITtniUI7yPl702d+ntQePpB8YHr1FuXVzn6+BgvLZX5mccP0bm6yvVewOTpGZzZYf7g/DKb1QeT0lVV4YtHB7Bqa9jzTfJjQ0wen+XNC9e5eHWBdDbN4IlT2HOzVJc3eaqY4sWtOh3XI2rqjCVjNGyP/+e5dY4PFTldMPF7PZZSMV6b3yYaKnRH93+MH5RrHB47jLZyFd/3UFUNxg7xnZ3ADS8MQe8z1SAMKUmVomYgFZVQhuiaxaKZpdpbh97+lAHbCEaEgryNwUasJFftfjtNKHwqP8KkpjAXT6NYgvn6+i3JNx/NMJjK8S8UaIYK36uXiYj9jMUPPVJ6fwG8WL1MrHCKpAfTkTwegjWnDkKhHGgs93aZ6Hi0yBPZIZywgRuCHcJMrIAdOHRui1y1g4B3Sl26bl8lbY4yEjlG0sgSUMINQiDFZvcsPj2QezcFXYl8YPmrD4LXdXG36ngzo7TWSzQ7LsNzY6hzo/zuX7xFeePeJQVPHypwSrfpLl8nMTBFZijGjYVNypbJ0JFT5CeGeWu5zUghTrVhk0xaZFMW//arq8xODTJXMKjaPpddi0tLezffRsfhGkVmky3sZgOEIFIY5ntlGEkJhBBIKdnyFIZ1E99zkICuG6ybBbbauyUo15sd3JEsdPcKOz0tSb21wmcGhjkdtzgd19iy49yo9e+dzQ1TjCT4r0wby0rRauwva2cJ+OOtK/zM4FFGRJqI5uGgM98toWt5frjZd0/+3NBJ0noPL3SwgwRxzSepT7DWu+nUILAPiJ6eb58jq3+GmdhxTKWDL6t4oU6EAMd7DUGWm7QqhP5ggvXfNp36TXi2R0RXiVk6Cz2P6OExpOvzcr3L6g8u3buDA/D4eI7oxau09b4Eur24SvboFDNHZ1m8vogHJEaGuPS954l3uqQ0lUOHDzGvW8x2alBaRonHKU8P8cfLZS5s3J8roe37/G+bNT46eIi8IqlKwQ+363R30gGst9s0JgbRGv3AhuutDk4sSbwwS0NrMO9D13b5F5MDxEVIKR7wrU6DZbu/WL5e3eBXCzNYjTUcr0skmmHZynFpaxGAnx+YYLizhhd4bLbXeTyRQc+Mcrm2QtJKciyWYKE+T9DrEAN+ITtATRiod7yHqcVYdeoA+DLgr7bfJKHFyOhJxiJZLEVhxa5zvb26R1VyLDmGE+4u7IZXpxsUGLSy3Oj0bRmGEue16jqXWgfnWJ+JP0nRGsJUdGKaQsffRtIhlB4gyJgT1N0N1rqv7p37oEXKmERXbH6UQhvvB0QQsrzeZGCwQBiEXFipsvS95wjvY7FHowYnTZfW1b7HypW3lzl+fJiZRIelSo9c3GT9xbdgs8GJeITP/+LjbFy4TtAoIw7luR6G/PF3+/rsxox54DP+6uI2R4cHOTI0hi8Fr6132KjV2GxGODQ9Qm9rlcVWBzcWY7gwzGpkgPJgkURo86+O5akFCi9WXd4q1flhJeQT2RGc+gZCEeipYb682eOLs6NMO5u4ZRvbz1AIuli5EaQiSNklOkEXu14nFsvyWH6EV0t7bS2NMKTl9/i91Tf4hpHkcGKIhKbSCTxer12hGzjENYsBS6O34/a82t3meGoUQ6mgKxZeaKMqWW50vrun76wxzPHkYxSsIoFcISRFy68QyoCY5qMqE9jedXbpKYpljCCEskOP74S/xblfUjMDEDN5VlVpX1zBSsWQs4O82niwCuO3Y0iXuD0Howdusi/RXb60AE+e5trsYUaTMfwX38Cxbxr+AtTr83z+9GHOnt8Jv293iJcrfHLuGH+1XLrbo/bB9n2+tXX39r+3WePnRo9RcJuEKLxlxPmTiwv0fJ8nCjn+9zGHRLuMCH1cT2cyO8z/y3do+S4d3+M3N5c4ncxzJDOBjUbXaVG0YthBwMRO8QwB9AKfy902s9E8icQwk6kCq/VFVnq7px67vQ2pBOnkJJq8gi89TC1GRYszX9/rttnyO7T8Dsu9De4G7U43FOBqa560PoEdxPDCkEvNZRa6BwegZI1xBqwCvqxhqTN4YQmBiiKSKMIFAkwlyVL3BRr+3j5OpD6OHVSw1Dzhj0FZOzNqMHNyDOfrZ/Ev1olPF6lY+n0xdICpoSTu6q4fudtxOPvaEmMfPoE1HOWt51/GcfqqhUJUJfray8TiWbabHWh2mC3mWB7JsLz2zieCS+t1Lt3hiVhq9vh2Oc2Hhg8TibTYNqJ8x9Y5v7HFfz8bI1NfRg08fM1gtlCgHSR4daPCtbrJx0ZnmU3HWG13MdUec6qL7dsI4FyrybFEgqKqElpRql6LizteZJVOlbniJMPxHuvtCqqiokeGeK6ymw6j7DYpV/Z/W13R9mQTtUOHi801nsjmCGWSpu9yvfUD7GC3qphA4XjyMSRVdDGAJ9t0/ICEPkjbrwJtFCVDu9vPs27oRxBCIkQCaKGIezDsv40ujYoiyB4doZtPk3hlifJOGTdvu45abfHUo1P84PqPFn0WiDtlzz4ars/L62UGFG4x9JsYsDRk9Q4jpO8zcpcdObp6sArmXqg7Dv+/5U2iuk4oJba/S2h/bzBNfOFF/B3vFGHDrBD8RHqQr1T6EowvQyKKwki7RLdVYhI4mhrkbSPJkNIjG0uhE2KjsOjanKtv8vs9ybNSJdptoSAomBEsVaeYKJIwTLbtNq71GBWxxZu9TXLC5adzJ3Ck5M32GtvuO+c1v4n1XoMjiQgBu/YPVWh8v3Sei63Fe94/aE3h3wxYkj6mkiaupxGoeKFDN+ix2LnGandvmHZCK5I10liqjhfYOwvvg4OiqZz6mTNc/PpbdHdUh9XzK8wdH2MpbtG9ixfX7eg4PqplQHe3rQxDSrUuYbNH6OzOcUKTeNU68YEhbirDetsVDk8P3ZOp3w0XVutcXAM5Z9HzmvhhyH/9yBT50hv4bu/WFx7xXT4zfJxfr7ZIGBqHDBtv9Rr5MOALuSEOxZM4IoVJiI9g1XHZCmsonmS13iCu60wl0oymi6TCJno8TzY+yKv1LiKs8kx6jFoQ8MP64l1jIupuh26wd833Apv13hI/LP/VThTyXmT0QXTFxQ37RtekXsRSIygoCC1P6FfpOq8jd+LAo8bjqIoglE0UkSUMD7ar7UJC8MEEC35ghlLP0Pn2SgOn1aO1Ud/zt8APyAY/+hH6bLlDbGJoz7X45Civ7USe1iVo+l63t1BCoO93hQvu6Y96d+RMi58dLPIPBnJ8aqCAeVskXtfzsO9weSri7ctwKDs1Dkd2mZSpaDypCLqtbdjJldhtbPBRM8KIlUTYdXy7iWbXOWroDKfH+HA8yUAkRS6S4vFkmhk14NHsMCeULqneOrHuBoX2PJOKwSPRIoNunYhdIu2U+anEOEPmfoPaQXircYOGb2IqcVShYSpxth3B5dZ+l8eDcHukajeokzSmEPSQ9AhpEVVNMsb4vvsm4o+RNTIYikRVbFTlRz/lvRdwhWDh8hrd6t56s52lEuNT+bvcBcblXdXD8nqDcGIMcZt3hxG1WPUN7DtkMQmoUYuefZsAIsQD0e5YLs7fOV7gF47nODOZQxECKaHlOPg7EueUpeC7ewO7PLvNTLQ/nk8NJXHKi4Q7NGx36oxFLGJuk6DXQPTqHDNVpvMjZKNpniiM8GhM50xhmGl/m7RfRtavMOBu8TN5k7i9TsTZZiSo8UvFIxjKwTKoRPLd7RvoSgZTMTEUA0PJcKV14UCGDuwkbe6zP5UoETUBdJHYSFqYxlHCWzp4haj1GJqaRhE+UEJV7jG3N7M03s+/9xgfGFPv2R6dtosXShR1/zCCe03aO2Cl0uZFEUU5dYT4kRnEqaN8zzTZ2GHqr27XUY8cQtzmNVIbHKJk7nU9M2JRrocHS/33wlAkyj9J6Iwunie9eJETq1f4p4M59AM8VW6ioxgIZe/z1GiK9dt2/GIkhmHvl5zHRMBat4UeHwD6hq5iepRc0CXXXqa3dY4P56eIKv1I1ZQZxffaqKGLKgSe12UUjcHA2bMQbHuLR+Mj+553EAIZ8pWNV/nG1nUuNNp8beMa39h641bxjjvxnfKRPb+vd6+iK2kACuYUbrANZAllFEEKNwywtL0br4JKSosT3paGV95T3/n+wrY95AHfWbN0bPv+xhaGkq+er+AcP0rs+CyRE4dYH53i+fObvL7SITq9u7nVPIFx4gTby7v+2tHxUd5evD811KnRNF/MdsitniO1eoGnnEW+cKK4r13FA9XcG9ilaDoN2We2GXXvu43m8pTLayTSowihkI4mycVTaE4Tp3KDOQ1S8UGi0kaGNq7vktJV4oZJ1tskpvZtAVKGaHaJRxJ3p8OVboX/uPg6z5drvFxp8DuLr7Pt3F2YqHvbOGH/G8X0CH7ogUwTEgeZoOzWiUU+BICpH6FfWuPmOpTIfQUlD8DfVu+XCwtlPnV0lN7qrmIvXkhx/T6JXxHiVi7nmxjOxolbBs+VbdarLVrDexdYz/P53a0mHz9+nLTv09M0vl5rk5MaP/vkGSKNOpuoXFYsnl+5f3367XgmHceeP3frd9/3iCxf5amhWX64fXCfzzd6fHroCEZ1lcBpo8VzNIem+cr2bqhT03UI4zHo3bFgFZXlxgbreoSRxAipSIJKe5vmzoYQhAGV7auQHqehRHCCAMe1EUIQV1XqfogMVUyxnxlFHnDv37SrbNr3dvsajRR4NDOJrui4octC+y0WWtcYjc6hiwQSl7a/gR006Ys+EoWBPX0YSgxwaQUNElpyR5/+AWdplFB2A6yogdfdcRcVAmN6kOVv3d34r9wmyCiKIJ+Jst4KeH6zQ6Oxq4ZZ3WzxjSDGo4dPYMqA86HKlZrBqTMnEJ02m4HBS5sB5eq9v4EQ8EROobe4aytxuh3GnRLFdJTWbSkXnttuMVGYJdZYI+jUUCJJ/MIMf77UV1t2pbaHoWiKwO7WuOKFROKj5NIZ1rZv0FU0VARL1RWKQyfwcel6AVKGmKoBSBQZYqr6La8pP3TJ6O+sVnNDn4vNuwe16cLkaOoJEloCKUNqTo2kkUQVFoGs4couHb9OuOMGGeNmZbVxXPcslnkGaAMuEHvnif3bmE/9Jloth1erNqdmJsEKCUyd+SDk/D2Mk8eGs5yI6RiOh23qvNHosVhq8fmjQ6TXNrGvbnA0l6R5dJg/bG3fOkLehO0FtENIItBCybFcmkNuj+23LqPpGurgAOuO944uTO+kV08GezelfDrLZCLBUQtOD2Z5zYOXK3sX3Z+sbREdLTKTGCWWhpKw+PJ8i5a5q0tseDYL+gCjmoW34xts6FGuCp1QKPTcDtcrHQ7lxzHtJhXRD6yS9FVJodPkWm2dw8kcCSOCgsQLQfgenhalZu/XW7bke68bLJppPlmcQ1eu999BgeOpD3G29n02qldY7y7xdOEZAtpYahIQuGGXurtXR+yGHXwJdXeJjh8nqQ3uSzj2QeDll+Z58kPTFEwVEYT0NI0fvLpIeEBiuqPHh5kdSqAHAd2hLJdrDqcKEVhYwavYHB0psjCa5qULuzamrhPgSYEOTBTjRHotNs/OY8YsRGGQeutg/fOdMHSNiNu5xbrjyQQzwzki0iM1kOLrQYxvr/XdIZ9bLVE0BzhtDpGMDdDG5PlSyNvbfTp+vebxE7EMTqd/kqz1bOL5AVbLG8T8gIGgie91aelJpJCEYUi9too1fBhL20ABXKHRQaCoFi17111WVyw23Qdzbd4LwePZZ9BEeyeCFApWhI1eiavNa4zGLAQSS00QyoAgFHTtHwLg+auY+gA952U0dRxFiRIG94qH+DH2fhFCjNHPMTlIPx/lb0kp/+c72nwC+HPgpqn6S1LK//v9DmJ1vcHqeoPebAz/AKK/E5OFJE95DvGFEgpQ8wKeHsoxfmyE2OXrtJt9Em1vVLGaHZ58fIoXNvZuEj8/XiRx4TKu46IDPzc9QtXUWQkCOp0u1Jt87Mhhrqj9PNIPipaqk9n5ORqJcsRQCFeusB3LonS7/EQmTyed5fxtRTI6ns9vLKwzGo8T1zUWW9vYvo82vLfvL5WW+UR2iGlFRQJvBwFvrVzmv584TaG9ie12CPQonWierduqI5WDgLRiENUjhGGIEhlADWws32YwNswP2g6hYRJRDPzQRREKWmSIV+t7c09bislP5E4waGQouXVW7TKX2qv48v4DxE6np3DCOgvdPFPRPtPwZZXx2AkuN59j1X6LkvM4k/FpkDUUESGiTnK+/hd7+gkJ2OgtMxodwQtbSCRxLXPQI/fh/aTtMAh56fnrCCFQVEHgH0zXU3MDnEyqxCoVFCGg2+XvPDLBwvlFujtR1M35NSYnBrmei1GudIjFDH7mcILexYsowHTDwpoY5mo8QnOzCls1Pnr8BP+5dG8m6Ho+XT2BoG9nOjqcJlg8j4zGafVKnMqYuMMTPLdeIZSS/3x9k+9ELYpRi7X23oLUr25UcAcyPJrJYYiQ1xyVupHg8aKO73SIJzKUhMJ8o4mmqAwk42DE8H2JFR1C9VsEUkE3kiz7goBFAHTFoGPmOL/VP/lais6zhWPMxoosdcu83VpjoVPaV3D6duSMYSwlxLstliGQNgORQX5Y/jP+fuy/IaF6IHqoIksnsGg6LwLgeBeJmI/1k3shUZUEmrI/insPJB+YofR+JHUf+JdSyjdE363gdSHEN6WUd1Y1eE5K+dPvZjB+EDKQiTGbTdL1Ay6uV3EOyM/8ibEcg69dwqm2kFIyFDXpVRsMzgwx39xryHE7DkN33D+cjJFdW6ezU6arUMgyZOoMei75dIJucphLCysom5uMZAZZrN7bg2AqkeBUJIItJS82Gnyv0eLvj83QW5lnPJfHX7lCmM6z3u7r4uxamTNTg5yv7+9rtd03sCUMg0w8QV1x9uRrCaTk25V1vr3zu6lo/O8GJlhbfJ12JEnCjNHzQtpaGkUp3TK+ritR3nQFHy3MUq3M04sP4AmTUDFp2y5fL9d4s7bFL8xaFI0cXenzZvXinjzph2Jj/OrAo6QFGLILZopVK8qV2ABfKZ9HEQrHE2OA5HxzhYa/11jIrTEfbKvQd04WAoUQm4a7RUYfwZdtWt7bnEw/jpQeV9vPYygxAumx3D1LL2hwPPUMhlCpu/edzfJ9p20pJYl0nNnZIt5OAWr7tmjMJ06PUJxfwqk2kVJSzCWIrW0zNJrnxm2pMdorWxw6cohypcOZ2Rz2pUvIUFIcyTIwkUSWtzgzWWBrKMO1yyvo7TrxuEX7AE8bIWB2IM1cSqflSy50BE/mB8hGNeT6PKqu09LjtGttnK7HsULIc7fdX+naVLo2mWiEYiJGud29pQJ9a6vGWzuq/c/PDBJuXeWKkGSjSQyitOniywZ+4HPN0zieGmezfIlUfIBQydAKfGr1Br9d6jA3mCImVLa8Hm9unSeQIbOxAf7r8ScoqhLhlvlwJsrHE0d4rj3ExfY2I1aKuu9wrrGy551japKQ/fmRVAQZY5CqO49hTRBRcnSCCnawzED6X7FV+x+AkEb7D0jGfomIUSSUNTx/f1GcO778j6/6RUq5AWzs/NwSQlwCRoCDS9W8C3x0ZojidoP6a9eJWwZzJ8b59nadSmsvox7TFdq3+au6XYeooaPoBzMKrdnXVaqKwNQ1BqMW3mZfh6+oKkeH8qiVClKGuCvrqMChY4dZbnffMen/TXyuWOT49jqdpasoqsrJ0Sn+TCr8+7bPJ6ZPMJ2IUmlUWGz3CG770Npd1BqKEPzc6CAzXhPVbuLGc7yA5JXmnWlGBT+ZG+EZK8KY06CTG+NaY5ulTv843CoeZtsaYkAV2Aieb9RY6W0QH5lEbdWRzfqtvtKRNM9kxyg7Nmdb+4OCbuKXio+guttoeoQg6Lt1jehpFnqb/PzgU4RhE8frH79nikd5pbnJ5fbKvn7KToekrt8K4+6/t0HT6+tnx6OPMWSNYighPusIBDEtiR20mEs+wdHUR1CFSyAly53rvFX/KzrBNt3g/n3U/zpo+9RjE4xpgtrVNSKGxqefmuS16yU2VvrfaDQbofnKrtDg9Vw038cy9tKyZujYXohpaiQN0VfjCMH4dAGtuk2oCJz1TeRmldnjx1hoSVz3YGPeF44OMFJepDdfZ1jX0CZneLFX4NODaXpOnYYrWd/e3VCMOyJ1Y4bGL03myfcqKIFHZ6jAV7Z6LDT6G7ilafzi3CCfzwZ4MkpLNbhUWWexssrExGm6yQi+lLzUc9hcX0Zt1wkrdQBM3WIokeGJdIYvV8/j3bFGfnXkEeJBi9CrAyGEMKyl+In0AEcjJiu9TSYNg5PxRygHCzg7tUS33RVmxBSB3MvYe6HHydTT5I1MPzNoWMVQVCQWpjrEaOFfEwTb+GEbz9+i5758fx8ePjCm/kAWJSHEJPAocNCbPS2EeEsI8TUhxPEHHUguG2PsRo3aUgkpwe25lF69zlODe4/Spq7hBgGatTcJl6IqrAWQnN6rq4iPD3Cu1uEnhgv8ai7FP9RUnjINBucmAXjs0SOkt7eRS6vo7Q7DR2ZRVIW459IeHmar9c5H2NFqlOONCp1qn+GGQUB36TrPRkzKdo8/3tjmt8sNVlH36PU1TWdVHrwJfXKgyET5Or3SCu1WDffaMp9wbQbMvcaZz2SHOdxYI1Jdwi0voG9d5USyiLojBVuBy9dKK/yHzWX+YHOJlR3jakfuZoNWhMLpwjQnLY1MZ4mfj6l8PnMK5QDSSGlxktLB0pPIYNdPV4Q9Rqw8M5EEtlfdcbSUOF6FRxJDqDvGVwVBWk8QUU1er13DDuLowmShm0cTUdzAZKV7jqwxzpnsJ4loJpaaQhfFnSLXAk0kKVoFYpqDpIIiqkwnJjiaegYhf3QD6ftB29G4xVhEp3p1AxlKfNuj/OYipw8PAv3C1H4oUcy9Hj2uYSKsvdeSp2aZSBv8/EyMI3GFo4/PMXF6mkzoIsoV1FKZ+HCRSDFLxO5Qi2VwD8iXNJFPMFpboVerA/2KYc61K0xFBP/ulXUWSLFW795SZQihsKnsXWtfHM8TW79Et7pJu1FBrl3mC0XjlmfXL8wUmegswPZVgsoS0dINTuZHAaiUV/mzUoV/v7LCy+Vt2lK5ZQEZTw3wRCbNqF9lwtviH+WOUDSSt54bUy0yeBiKArfZTVRFJ6c4RJT+BuCFLtIvcTj2CAARNYGCwlp385Z3lYKGLnJsd7eYjM2Q1NMYSgRTGUBKSGojCOEgRAtEBU31iUeeRnBbsrR3wn8JuV+EEHHgT4D/s5T7QvbeACaklG0hxOeAPwPmDujj14BfA7CMvdVpDk3m6F5Y4s45izl7DY6u77PUsJk+PYO+tIVTaWIV06hHJ/j2pTWimsmjjx7GdBxcw+D1jkde15hZWKVb32FE86tMnTnK+NEZkptbeIur+KpCr92D5gLFE8fYjFj8ydq9vQdm0lHcyn6Le6LbwVBV3CDg7WqNueEpps1NvEYVI56glB/juxsHG4MPGRLuMLT2ahs8MXKYLzu7m8whBVLAoGaSi2ZwpaTZ2qYYz7PR3KIpVNJGBAHUbvMv/mGzxs8livQ624wlB4j1NrE1i41ei0BK9G2TU5lxzrYX98697FdxCkJnJw+GhxAaCI1AhIgDqhlZeKT0BBk9xhOZCSzFJ5Aqm47DX66/wnR8iKKZQglvsO3cQBUGR1JPgKjjhVE0NYIiAnRy+LJKVB0klGs7fsZ9hLLFZPQIC51zJHTlrr7Jd8N7TttKP2/O8FgWv9xEUZU9BlKl3cOKmthdh+XVOuOnZpDLWzi1FuZYge5wkXO+QvzULLof0NZNsHSCH56lLSU35hWOjSY58uFjON/8LtKxiabidC7dIHPyCKuuxnOvH2zIm8tG6C7sLyOYDh22G13OFQucHFLwKluoZoTe9BRfXdl1oTVUleGwQ6AIvGA3gF6rrnMoO8hyq8dg2CStqxTiSUKp4wmFRq9J1IzhWwkMu4ehqLhhwA+rDX4uWyBwGoxbKkF7k9BMsVyvkRAdPpkc4w/K/YOTJ318oRAS7IgcAiFUdC1C0y3j3+bVIJGktBRPZT9DTFGRSGwpudC4RM4s4oVdVrqv87HC5/DCFSRFJDYIMNQ8mjCRssLuGwZIauj6CVzvtQPndh9+XNUvAEIInT7R/66U8kt3/v32hSCl/KoQ4t8KIfJSyvId7X4L+C2AYn5SPvPROcIwZCBhEXU9jKEUHSVkqdVF11RiuoYSs+54FlyxfcJKHdMwSB4ep9Sxqbshq+X+MK5u9pN63SyB94uHCthreyPA3jp7hWOf/xgbL7zK2PAgtc0SbqfPlIyew/NahJa9Xwd3J0o9DyMaw3P3ehs4pom3058E/nh9k6FolJmhPGu2w8Lq/mhZTVH4mcECH47p6KYCkSTdIKQXBGxqexmmAHKaziEhsRsbBLqF7tvkYznWjSipwgy6HuPX4h2Qknp2kD+ublB1bW606/xhKPlIepQjsQzlVpeFVuNWwQLPdxhSE7cKh9xEL3AoSYPDqk5MH0YVIaHfIlAsNNmi4u93Qw2EigA+kp3ECav0dnhx0dB5MnuI5ysXudJa4ZP5awAMWrOEskEoM3T9CqoYwVRMFBEjCF2csIqpGrh31DdVFZWrrVf5WOFXSBl3Swe8H+8HbY/kJ+Qv/erHSEdNxJUVuoaKLaDddtA0BTUZxdvJiX51rUmgephCITY+TCkUdDohf/XqItB3bcxlY3w6Zt9K0xr4IQtlm8LKFsrYKPbyGuWaQxhKrPkNlieP0WgczNTLPZ+ZaAS3u5ee7J3Anu9dK/FmzORw8TA12+fsfGmPy/BHR7I8mpLQBSuWphtKtm2PUqhCAKamMhHVyDZbdNsQU12EDBgoZDgUL9DRLX7VbeOkC7zuSr5b2uIPZJK/PzaL42/TVOPMN5q3aDEZ+v1CKaGPG/qs+JIBM0oydgQRuoShjVTihKrPemtvaouByDib9lu4O8xVBWbjR3ih8jUA8uYYUrYIiFJzt8iawwh8FAwCFIR0CMNdFZYMmwjSWMbH6Jtj/vWBc7xDED++TF30q1n8O+CSlPL/c5c2g8CWlFIKIZ6kr9Z5x6rCCU1h5NoGSUsj0FTCfAJ9MIP79g0enx2kvFZF1VSQ8OyhYb5zbf2We+GbK2V6wxnmoiatMKQUj/Hy1b05SW6vaaqEEqMlcRO7fsBhEFLqOjQ6Ntu6ymQug9Fqg6oSjAzx1asHl+a6md7k5lgWay2qM+NEW41b+aStRIrXFW2fLX6j22Wje/eghc8NFJjaukopKHLYMIh3ykgpWfN8BkcOcUEz+ensCAkZsgWko2m89b7kvuk5pDSDSDRNOz5I22kTbJ7H2xmF0drml/Oz/PrmIgDL3QbL3QaBhGJ3vyHYp68umYuOMGIkaIceq26dWmeVphEnrmgIt4KiWqzZdTpel7aRQxM6/k7wj6oYrLsuU7FBvLC+t3/pMWqlURAYis53y0d5Jn8JIRSQkoZXJmsUaHlreGoKQ4nQ9DrYvkfaiOyRxgUqDa/JXOIJ7GAJ37m/A+j7RdtmEJI4u4yai1M4Ncn8V15nMB/HQdLzJbGRNEeOj3LhrWUunlvFPjTAzEiKtpRsZzO8fnbXCBeGEl1XkXeoUjwvoNNxWdp2GIqnUGmjCoEYGebbF/YP72Y8x/n1OmeOzyGunEfuHP0jhQLP1Xfns9FxeGWhL6SEE7tr5pFihkfba7SjWSYtHa2xRkZR0EOVicNPs1kNsB2bkcFB2rXr1HyJHVOJqzpWNIMfqlxbfrvfWafKU9EMG8k0l5t1/vPaGr+YDOk4e4WvQFGYtHJMWSkCIbDtJh1FEg/aaEEPoehsOE1CLY6iGBD2aS9pFOiF/cR5t8MSARl9mIa/jUJf6m97bRJ6lKqzTlRLoosICBNdOoRy95SiiCHs4G2krKAo9yE4/Bh7v3wE+IfAOSHE2Z1r/x0wDiCl/A3gF4D/gxDCB3rA35X3SBbtd13aG3U0Q8VIRmisVrCOjzL+U49ibjVJpmNstW0WX7hCPBPn8GiOy2u7xHp5vcbt5rxCKkoyarJebe/JGw2wJVQGDA33tiN7dmyQb1XqfGxuisqla9SEIG7F0JJxXqi06bh7+9BUhZ8cyTPm2wgp2TIifHWjRs/1+NLZKh87dYIh3yNQBK+H8HJ5b6rTe0EAM7h4nstKeZvjR45BZRnVtYkXB5j3JL8MvLJ+DV8GDKg6yUQBdegYmdYWqu9ix/O87rpcb1cp+g06dxB0qldjwIqzZe96pLxUr/DLmQK922o9RmJF/nC5xS9PnSJj1/F6JYaExqcLT7DauMiWZhGzt9FliAw8NEVj2y7hh7DiC0Z20gosOi1erZ3nicyhA995MJLhF8eexlAkTgAaIZv2NcaiM3T8Cn7oktTzeGGHmnuBF8p/gCp0Plb8FXJGDkkHIU1caXG2+rs8nnuWqKbf0uHfB94X2pZeQHerQa/cwm71OPb3P0rltRtEJ4u01uuc/dPXmTw2wlIqQrvRY/7qFvNX+y4jyiNTjA6maHUdypWdDXuriXx0AEr1W88IwhBnfIzqpVUqQUAsaiFUhWrXYm1td1M4c7TAxISK4Xs0jAjf3+zwB1frfHLqJDlcHKHycj3g4h2pOg7CqZiKvVanlogxlRlAqCoEHrmhORrNEk+2KlysdyFaY+jQU/ibl0ENaScGKLcbtO+Ytl63xmPpaS4361xv1mgWptGc9i19vq6YxCNFnvG72PY2Y8kxBrDpyTh1r40mQ2Tgg6LzRvkyydRhOrKCHYa8Xa8wfEeskqFYDEYmeELL4AZtqm6DUFpU3A2cME1cS9ELqlSdbW50LvDFwacQJBH4IFL4oYOuRhDKLNwrzfOPc/CRlPKHvFNFg36bf807nkUOuCcI+51KcBtddEtH8ULq18p0lzfZjOg0d1y/2rU2o7MDHOSTYegqPzUzSGS9jL9Z5snhPFc1jdeXdpnU8wtlfubUEZLNbdSezdzkML1IhKfLNdyBHOZTjzKtKiiawjmp8PqlxX3P+cJYntyli9g7aXTTisIvnjzF7yxs4fgBf7H9YMUZzmTSPGGoREKfumbw7VYXVYb4QCQSpb50icDtYVgxFioVEukcYvkihqLiBwF+4OFvXqeQLtCToBhR3MYWhWiab4UhxQP5jtz3JZd7Tb6q63wkMUZchLSkwneaDVK6SdZp4AYdBIKcHqMYemRjI+jRYdT2tVvh/6ZqMB0pcC2AF2v7v9KF1jJHEqexg12pJ6uniGsGOHXcviMHM7HDdOt1rrXeYiZ+EikD6m6dju9yvvFdJAG+DPjB9u8wEj1F0Ryn4Za40X6JsegjZM0M/h0ngnfC+0Xb/ftA+gF4Pq2lMguvzBMdSrOw2N/sGze2mJoZ4Nwbi7fuOfXIGJNTKdz1Mloiiv34ON98aw3PC3hxo8eHTx1C3dxiPB8jOlpkZb3G1Gc+jPA9dBlSkjrf/e5u9PEjh/Mc7azRvNjBp1/k7wvHDvM7yx5/efne9JqJW/zMZJJC4OAqCkPpOFtrENdVNq5fQLNiCFUl6dh0Vi5jxXNIJK7tYmzdoGum8WQbr7pGYnCW7fJ+29PNyZfA7yyv8YWhUYY0iYfgkq9zqrOG7TbRFY0hK0XcLZONZGk31m+d1aLSZNBM8Epzla+WdunvC6MTt9JKCwRDkXEkgq7f98ZKGzq9IMBUMrgyoOrW6QaSN2s/wAm7bFW/TjzyaRQRpW0/RzH9f0QIFXDvQTU7b/TjytTfTwRBCFEDBUngB+iKAAFqKkq7cVuaTAHBXSbxIxNFgjeuoRgao5aGslFmYnqIykCKxa2+WsHzA750YYPksQT/6NgUb73wNnavv2HEljc5+tFHOPfCG7iOSyQZ5xcPT/NHS5u3dIkRQ2eo3byVFx0gDENSW+t8bmaMotcjSISsGwZfr5Zx73HsOplJ88luhd5aCY9+wPEvTxyiZiWICoHjOMh0kqBdxzcibNo98qmAUNNxb68w4zsIM4ZT6uC7HbRICiWeZbPdoh5Lo7f2GmJbkSzbjcV947nQrHChuffI/oXBCVx/ExDMWkUigY302qT0CIrXBDOD51RBCNzQJ4ZG/S7BR22/yyu1NR5NjRBVAoajA+SMIk1/lRErx5rdf/bVjsZo9AgXm9+n4iwR0/P4oUPvjnqQgfRY7rzOcuf1W9ey5sC+UoIfFMJQokV0/J6LlAKp9qt62be7s1o69m02m0w+wbQlsOfXGUpHUJ0ecnOTzz45wZefn2dpvcl6qcM//vQR1i/PU/3WOQSSzEgSfXyA8y9dQbMMPn98lj9/axvb9plNCtz1BmR2l3miWedfnJlks1Snrph8f7VJrbPfl11TFX5xLkZv/hzeTpnlRG+A6MgEPT8gpRn4dgfdiuHuVOryhIIApAwIHBcUk3ZrGz2Rp6nF0HQTbnOzjFhJzt2WhbLpOfyn5d18Lc8MDHPIqGMoGscjWZRelVgsj+q1iKkROkGvXyNVhuSMBDfqe3O9vFV/iUfSHyauagxZE8S0NE1/k7ReoO6VCKVHRBU8V/o6cT1DKH3a/q7gEYTbNDq/C4Cpn6CvlHwARv0e0qPo7yavAWv3ipn4wJi6tuOy1bI9Bg8NoukqFccjNl6gJQLC+i5Tz80N8f3SwQFA+SDAMDWGfR9nvUEIBKU6v/Yrz3J2YQvNcekYBq+WWmglQbl89RZDBxgzdZQri7cYeK/ZJnF1nuMjw5wr9T+wqakozv6w68PjQ5wKeth2E9dTSfRWyc/M8O+33jll8BlTo7e2l+G6qzcoTZ1ieOI4keoa7ViWROgx3/Nwgx6hGaXUMfFvSyRkCYXL9S3saIZEaoia06a0fJHJgTn+pLrJL+XnGAxtPN+laiT4Ur103yRZ8Ty0iEFU0YmGHoH06XS3sIofQrOXEVoM1Szghz3swCMwi7y2/vxd+7vUWuZ6e52/N/ZxFlvLyLiPrnTJ6ipC5Fnt9SVYsaM6CQloeVt37e9OKCKgHXSIa1FC+cFmaZQSnFCSGslAwsKNmERnBrh+aVctEj80zML3dqXKQ4cGcFbXmRzPYm9U8AHN0HjmqUNknhyl5QZUdYPuxUVaq/25GsrHkFslhKFgxiPYrS7Kucs8cegwz729gb7HRwgKIwUeHUnjtUvkhMd2s0pxLM/vzPvYd+jsT4xkUNfmwdylmOub2xx77HFWSluMjB5BKS1REibJUGBEk6x0PXRVJXR6bJkRqkoSJzfNVqeOs/g27ZETZCMprMChJVXeDnTe3jrYdgWwadvoepRR1UB6LWzAT43hO3VCPYOlRrFDm3ao0lQSXO/uPX10gwYvV7/JM/mfpe7W8WUViUdK67sG173Sjo1M0vTeOS2JphZwvOuY+hRQ557M/b1Xv/wL4BL9evPviA+MqYeGxvgXz+D7AUtNm23XZ32rxca3LzH+kRFmzkyjdF38mMlb3R6l8v6Fenw0x1wuTqwco1NucJPtxpJRIstbpK6tsLETlffJk9OcFQLZ2itFW0EAvo9yW1a9bqPN2LTOzXRc9a5NdzwHa7sEmEglmRQ+S6++gpBgCsHJ00e4vL3NSCzOWufgSEoAM9wvyQdBgBoG/MbyNhOJLMkmDFpjTFg+YQb+1DU5Gi1Atw5IFKHgDs2xsvwWfuBx00xs6Cbl0GPIiKL5Lng9VC1CKQgpOftdDu+G12rbPBaf5lG9QhD0514Yac5W3mIuOYbhd7jmNghRsUObhh9Qcevv2Ofx5DTDhknDjdJ0exQiGqH0yeox/DBLRItSs++fkd+Ort+lJhZwgjwxLfcj9fFewUhHyX/8KA3PZ6Pe4dwfv8rMVIHcyXGEH+KaOs+/uYzv9elAUQSjE1mmEkCjjYhb2B2HfD5O7/oakc0GW1tNxmaGKCRNbpoSo2o/LkL6AYq2sxn6Aakdf+2qNEjfpGshePzoOOpLz1N3Q1Q/YKyQx7R1zozkeH5hL1NLWype04HbiiZJJNcqTX6/oTMlTWZSJ4j6XbKRFDFXUmuu9VMdmHFa8TyXFq7hp/pjiacHCX0X4Tio+ARalIXe3dcIwOVGldbMIJZ0biVILDfWSCYH8XtbOFqCBcel7jQpq12CA/TcE9ETxIVOKD0UMgRUgICCOYymGFTd4I6t72A43lUsYwbbPYeuTSH21Qs7AO8RUxdCjAKfB/4fwH9zr/YfGFOvtmz+zdfOHZgwa+EHK5ybjqBrKu7WwRP+0ekB8otbVF2PaL2D1XXRc0lqlSYDp6ZYffUy+aEsUaVfE6W0sEbhyBRifAjOXbvVT6hrhPk07vauYVM3Dep3HJ2+1XT4/NEjhIuLhGHIkUeOUnvrzd3xS4l37SrDJ06Q1XUOCiJWhCBjWVQ0i2FF2aMuiCZSXLFdJLDY6nvRvX3bvXkrglHMMzf7BJVekxLwXKPEpxI5/PpmP3eHouEWprjWKPNPYnF6pRu3iiaMqAafyY7z1QN86g+CE/r89voyhSMjpEUeR3psulWaTo1rzZDh5AQ1b72ft1tP8/3G/F37Egg+VTjF8WiKhKyR0DV8JYbjC+IGZI04umJQdT2KVhpV+QkuN39ASh9kOv4IETWCF3qsdW+wbh+c5fBG+3UezXwaJ2zQdX60zJrvFUqVFr/+O8/tuVbeqKMoAlVT8e6Qij/+iSP03logcmKI5pUVYrkEidEsdHuEAopJE0GCRqVB8uhhuNjXCXsILENHDObpvtpPjIYQuDvBZz+4UOaLj50k0lohGrUwNtdoSYHj99eUXyqTzxdJ3rEGhYDVts+jA0M43dspWVBSTbbaTbbaXV7auZqyOnxucpCpuSE22h1eiiUxt/trTBUCTdPJD07RW3idRuDTP3Nv8IXcFEtdne4BrrDQF3a/VL7M0OjTDOtxAgSrbgu1scaoFafhtqi7HRwjy7dKV/bdP2zN8GjsNJZsgBQYoY5Ux7D0fue2msUU65xMfYSGV2UsOoEmdOzA5krr7T19+cEarr+NoeVxvbe5J+uUEnmXfD8HIC+EuN35/bd2XGRv4n8C/lvgvqq/fKA69XfyIZASXO9ghh4xdUZ6DtVqm/lam9EnZrFKDYyYQTA9RFtVyWUT9CpN7HoHRQimMnH0hMU3nB7PnJxDXdtiJpUgOzZI0Ghy+tAUV1c3sXs2+tEZ3tiu73nmUr3Nv2urHB+bQRcCt9bh8Tvyl0jfx4rHWazvD1o6nUrxcU1gNmooPZ2R00+zcvVtep020UyepdwoF9cPLhX37ECBJ7wGveWz+BsmydkRvtyrU3J7dKJpfmX6DBNhiIvgnNPjc7lRnI0Le/rwApepA4pMAxiKSkK3aLq9PQmPmp7DH5Zewsk/QqSzeSukvyfg9yoXCIUkkJKlxiL+O2RynIoOMaSFtNwq09Yobmgjgyo9kaTnR6jicrG5ih32AIO5WIK8McOh5Cl8WcGXXYSAyfgUAT49v0nSGKDpbtH0+5K9G3Z4rfoVRiJHiWj3PKG+v7gLXYehJLyDoecHU0RrTZobdTZHMww+fgi/1SVzfJxerYl7fRWv46J0XYoRk1DTiT5ymES1Qj5tMvChQ5S3m0yfmGTh4hKxQ5P8cKHPNns9jz96cYPC08M8PZFjafkioreXgVoKLLd2xzSRT/DJAZ1Yq8rgwDCjSoRzC/OohkUwMs3XNvbGZj0xkOUTRg9n6Q26qkq6OMmXFjaYSA3yS0dniVs96uhYgcvqHYKSX1/lsdQYP6zsns5ShoUQUN/R0zuhx3/YeINfyEzg7NS5FQgaqskb3TYVv8NieXFfzn5dqMxGJmg6i2Qi04R4ON4aMfUQXa+CKwUr3fOAZDI6gScHafsbBBJ0BR5JP4UlSwih4XhXCMMare5fYGizmMYRwvA+qoHdf5XqspTy8YP+IIT4aWBbSvn6TnK5e+IDT717N6Ti1v+fvP8MtizNzjOxZ/uzj/fnXG8z86Z3VZ1VXe0Nmt1wDYAACNAMQAUpxZAhTcRICo1CivkjRUgxCoXmBwYzHJEcgqAIEIYEG+hGe1PV5Su9v97fc4932xv9ODfz3pumMgtoUxH9RmRU5cl99t5n7+9b3/retda7KCdjVLsGjUe0X1KJCEF9sAkNQ3j76gpHU1EiQch9w2Lu+BgJATrtverLMCQUBJKSROVmi/9lXOZ/dW6OlZtLvPeDK2Q0hWFN5sSFU3zfMPlKtYn1BM0X2/O5vDMw2LmJAmsezGQyeO0WYRgSS+R5Ixaju3uYU89FInzBteivrAwY8eoOK9ubNE+cYcvoc69n0Kw1+PlykVgYsOKFvNto4IchGS3Ci16Hfm3gMdm2ibh2hy9NnuTfOJukZIXu5n3ePZBrfmnmBVZECfM58mQ/lxvhtAyKY+CkM7zreLzW3L//WztFJOEGLySnKYgqDnDT2GHDfv6UzclojpwcoaCo+F6fnBpHVtNYQpxAVFg0Hxj0Abyww/HUKzjBYWEuL+xzIfN36LjL+KGBGB2j69ncbH2HkGBP3Ov6o5f/0KA4kiGeiLC93sDsD8jCfCGBtZeqeP/KKsFUDgGwttvkExKG6dLbM8SuaeP3bV7dNPml4yPMz29wa/4Ww0kNPaow/PmP8idvrFJr7lOVQRByf6dFy3RIx3WmCgVoNgg8DzkSoVUc4c69QYBRU2S+VBSw529hAPd2tolMZoif+xjf3K7j9AI+U0zgk+TthkHDtvl4xMXYHnzf933YuM8Xxk4QyCL3br2LmxzMo1dGpzgZjXOtf3hReCAhn1RUfnOoTN7rQRjQVIr8SWWwz2y4Pf60ucpLyRFigkAnDHi9eo+u93Q6sailiAsyGbWEEDjEpQSSkkZEQhSL7Jg3eLD6RiUJO5Tp7U15SdAY1kdIi1/CceeJamcw7fsY9vdwvAUcb+HZL/tHx6m/AvzSXjVzBEgKgvCHYRj+g6d94UNp1F85P46GjbFc52gujnl0lO/Mbz4MZra6JkI+Cbt7HonjcbvR49jRY7T9gGuaxsXJIdSuhdPqoQ/l8EeLNNcraKqML0kEqzu0KoOsi6bl0LQc4reXeS+XpP0claQ/2GkxPjnDzcUFStkiakRjYWKG/2lt5bFjLyWTGPdvHPrMNnsonRZfrzUZiUb5J0kVZ/kmIvCZbJb/9bEjXGm2UNM5nPuPlyXnbRsRgdOyivVI8dDqxh2mhma4vb1PVciSwnx4OIXoYqrEL+kakcDB1+Ns2z0+Latsx9Is9lsPj3NDjzfa95/5TABkQeZkfIyMrFNz+9zpryMiU1R0XL+PJaoDj9+3CGWdirFJWhTpKBmae0JgkqDhBe5j5f5JZZSI6FDfK/IMwi4xSWMkeoqND7Ex13SFj3/sGMFWE6dnceTsOFumw40rq+xWOsyOpnCWdwm8gIWlOpmZEmo5Rz8iYhUaBEYFORpBnxtn8eYal45Psf3GVbw9r39hrxFHJN5gt/ZkraLdtsHCUBnXMEnHc+iKiDU0yh/dqT+cVyeHUoQbhw1Wu9lE2a1QVCMcb65hV1rMJqL8WqlEKz+NtH2P24JIcGCHVxY8fLtD+4Cn2gwgF3oP5QEAlPQI79UG7/x3Rsc4Tp+IpGAjIfdr/Fa5xF/6A6qp4fb4av1xiuUgcmqCc4khEGDN6pJVygTeDr6Uwg8MCAVEKU7XWiYvFzD9Nn7oIAkq7gEto4I2CTQBF3AIwzrRyFFs9xZ+UOO5M2B+BEY9DMP/Bvhv4KEM9P/+/Qw6fAiN+pHpAsryLp16DyctY3RNIvUe544Wubw6WLkt22M9ojJUTNPdo0kihRSvGzZvLe9SzsSJBi7RQob45BDr9S6N68vEz83guj1kUQHvCV6s5+2JBT0bPdvl32y2eXH8CBkxZMeHy/e2cYYeP6/EQIL1UYh7H30uFcdaGBils8k4WmUNsdciH8+i2F2K2QzXqocj+44kERAiPyFtyrD73JMiSPkZRj2DdCRBLZrhT7f3eW8B+J3SCJmtK4RhQCE7zol4mpbvUkwN8X/fmGfH+mBNCTRR5cv5Myh2HddrMSpHOFo4z67ngKiD3yeuRPF8E1+K0XM7VO0O5UiUvJJ8aNSXjAkIfsBM4gheuB9M06UE1iMNfwNsckqZeDJFWskCAl2vDQ+FiX/6uHhxmvblFfw9OtFoGpSPlNksJGnsduidHEbP9DGbfQI/wE7F+eu7VU4kZcKOQ/HkDF3bZf76BrFyBtNykZ/A14rP0Lz5q7s7zJVLzOQVHATeWenQOpDOqEgcMs4AWhtUUeS43cRsNzmZjhFv13DbFbKiCK7ByVSUGwey1QRVJzAP0xP3KutcnD5N0exRwMOL5fhK36HvVZlMpPhUJMSurJLNjhITfM5kM1REhRrTvNl5erzmAc4kRng5lsK264SEnEgUUaUMlreLKmoEoUkQSviBiyJqOF6LlFym4a5hBxpdd/8amqgiCB7+QSmK0CeX+mf4/hZh6GE594A/ffoNfZhlAn7SKCci9OYPc8tW16TwCH/9xlKFI+U00+MDsfprPYvF5YHh22n26B8fwbq+yM5eB6VYOcO8FxJRJc7k0kwnYnQbHTYM82HgKBwrs1Z7Dq5sD6br8YPNZ9MQ7/X6HC8P09/ZDzrJioqVSPI7ksRnZAFzdJKtdoOY1cUXRDIivDA8wk6nRW5oAqVef6iprrhpbuztWzdEkSOSjO/v00V6IsefN7c5HU2SEUR2qmvYzn1+OzvM1+QcN3p1jsQzJDpbBL5DMTeN0lrDC3yiehql3+Y3MkV+b2eFUT3JVDBOMlHljrmJE7hoooooCI91d38xOY1oVR7Kpbq+hW7XyETKrJpNiloWUcrstakzMPwuu3aLEEjqOQQhTdOxeb1+hRfT82S1EbJqCi/sIgk6fqDRdB731or6DF33HgGDdxeXf8rt7B5BXBKoPRIfaixWmD4+QqPa4fvfu8fcqRFKowM1yretkO3dGpGjJSZlhaUbAxpK1VWs0SK2F3L+0izdpW0qbQvDchFliTqPN05/FHd3Wtx9Ssbtja0OL0yO4S3va6gk0knGhorolVWcySmSVhu7J5JLJtACG2/yBNrWEppsYXseihLhuhkyFstD50DOt++xGIgEIXR6HbqVDU7occTSMMlIhLCxQipVJmbUCF0DXxBI6XlejsnUo2VG1ChW4HOtv4MXeGiSQm+vZkMSRC7Gslj2Pjfft2t4dgZHSiLIeQhNvMDFtNfphTYRSUMSE/R9jW/s/AmnMx9BFV38wEIQVAy/RTR8YNRVIuoZHH9pT+QLdHXmmc/6AwRKnwthGH4P+N6zjvtQGfV0Okq+kGA3pmH3DxuM8AmNqOd3WszTeuK5/ur+Nh85NkGRkEAUuW7YrFba/Opknt7357lbinBqtEixb3LPNHFHCnzXcR5re/dB8aQWd1tGnzdyOV6c0FEau4SxBO7wOLntVfqVLZxYlEirypljZwh2+xQTCQTboFvbJu85qO0oiROX6DVrOKLAFU/iB+0Bj/mt1g7loaPk2hV8q4+cyHEzEqfRrXPEhlpzf4E0Gpt8vDzLzR7MRBN4bpfhaIEo4f6CIUhUPItIr8I/GT9Bor+D2d9gSHY5lzxFX5SIen0IoSXJfKe7QG+viUZGUgge4fG9wMX3DFpilGZngVqkyIiqAB4tL0AVVaKizprR4a8rN2i5vT09mCh3Oz8gLufJa2N0vRW84DonUheQhYAwDHDDPqqYxwu6DGpxB/igKo0/TqgRhXQ5g1tu0d7Zp8kkWcJ54EyEIXdubPCALHPmBjK1V+9X6E9mmTmXRwxDaj4MhyHijftUx3IUs0nSUZUdSaOayvDDa08OtD8vDNvle50oH5s5hlLfQUulmBrOcPvtNzgl2mi2SWF8nKBYwttcRhoZp7++RKY0TCk7xXqny11P5psrFY5kEnxxaBbZX0cQRJzMCJbn0q/se8SG0WFO1TF0FTWSIK8n8IydQYJhGBJKCnGzze9mJ7hXu4UsSvxi8TzVwMF0WhiSxmv9Km3fJhLah1pB+2GA7TZoe71B79OwD4SEYhQvcPFI8l7zDdbMWyhihLfr3yanjpBQUrSda2Q0maKWJsRBlkYIsfH8/dUw5Bm72A+zTMBPApIk8rHz48iVDv3rG5w6NUazb3F3T8kwNZzhfv/5c6xhUK36xtJg5Y7pKkEQcnE0S//qAoHn0+savHV3lVwxg33mCH94f/m5Wun9TfFqvc47ssxwdpiWY/NL/R6xvcKLdc/nQiqDvrZAau4UzsI1pJMvImwuEdS3EWyDiZkk/7taj+5eVeuDFndO4POvamuM60mKmSSLZpem0eZ8skDQfbwUPOqYDOsJXorESXYaCL5NPJrEVXSMwKcjqlSdJqVohnxos7a3jfZ8h2mzC9EM9/uD9xJF4AvJo/xZ8xoAJiHRR64nINALfF6r3uRjmaPIQUhCyBGGfdyww6nkJD0/xDcX+eXicRq+REwCVXyR4UiDDXOR5b3K0YRSQpNyZJQUkiBhBwI3268zrJdIKWVUMYIferQ/QNHSjxNHTowwmUtgr9YoZeKMHR3i/rtLOIZD7sQI3z8gEfA0zK80mAd0XeXoVI7wzjKu5bIxv0MlopIupXDGyvzFd58jePccuLXd5t6uyHC2zKV4gtY7l7ETAb1sgmF89HoFcXQc//QLeJ0G0Z0NwsBBGj3N7y01H7LNdxsdltoSMyfKeGHAaqPBP0s/OjpANru8MnECb20eRY+iiyKurNEPYcPxKCohTbcHhAwrceKNBdTUCDeNQSvLz8dH+JPOBp6gPnbuqt+gJrnYnshoZJow6CELkBF12n6XOX2SC+mP0nI2CBFoeR1udN6koI0wFf8cmjaGEEoIQhrLeR1VnkRAxg97eN7Ti6Ye4mfZqJ+dG8K8to69F/DxDZuxqTxzx6eo6SErYcDC+gfPPU7HI/zcRIFIs4vrh4yVUyzcEfEPeEi1SgNhKPtjNegPYHkeS52BtxaJ7Vd15GUZzzEJZJkgmUWfPYNbWSeorCGqEWrdNsrCVX6+eJQ/2h4YLG8rijy875usmR3WDqx7O7aJpCfAPVwCbssRPh1JUF2/xnB5Bre9gRKCFni0lDjX+oP7S2fGWKjeQ9iTpeyYKXTVJwgCsnqBoppCDMFXorypF6nZLW50t/hCahz7YMNgvczVxl06Xp+vVq/s/2YlxW+NfpR7vS36ey3vNCHklUyBpX6VfCRDQVVJKyXMoEvL2eJE8mX63hKGJ5KQR1AlnfHoSdJqBpHdPQ9dJio/e2v840YsqTOZirFzZQ0BGB7NEjVcTn/hDKsbDa4t7GA8odXco4jHVD59cohYz6CUlhH1Mot3N3AMB9dyqK5WiSZ/tCmcnh+wVu3wQk4hDAIkUUQLA3xJxY/paIVhWLxOv1FFkBXquxXyocy5Yokru/vpvI7vc7U9oCsEwJIe7x17LFvk/sYdjiRH2XVckqGI6PvUlBR1x6UQi1MxWwiCSFqUCTyDNBKnMkcRQw8bgQuJETb8gGFRwwsGO3xZUKkLBtc7rz+81seyv0xSCDG8Ol7oMBE/gyQ4aJERgtAlo6SRiZBQI9SdO5TFLoo0hSQKxCKfwPVvASEiWWTxGQVuP+ucekoSaRj7GSe1pkG9tUb65Vm+urF7qAXc80JVJP7LMxM4r94k9HyCmIbd63Ps+Dg3r+5zhoIg0HtKG7y/KZ5EwTyKhhyhKAhookTOsej1OljxJPcrFebkgHhzF0dPIIUBmSBAj+jMio8HYcf1JElJYdHsYB5orLFt99gsTFA02rje4NlqsRRvBwEXQg+fkBuVJUbSQ1i+QLl0hqbZxnSryJkyP7RcPpufIrrHW1qSihhWkNUEo4ZB0B0UMelajn+Wv8T97jIe0AlkPLWAJggYYcA7zQVEQXyo1fEAPiFdu4J5oIdpIZJFF0WOxLOYfgsZA0WMcDHz87zb+EtkwcULJYb0U4j0CbHJ6EO4oUoQZgjCDhAiHCyD/Clh5miZ2v3BjiYENjcaiKKAXU7xjW/fev8vH8A/+uQRhHfuEFoOqpEgbHY4cnyMW+/tj2FL/vFM4y1boBDRGI5JCI0qzcAnAEquS1DfJZJIYjguSSEkCAOORSQeLNvjqQRJVea23MD0BgLQ7zoBr8QyWP3B7k+RVfxkkerSe7TNNtPZMlPFM8hWk5btYMeiBJkER4wqopYkG0ljmSpxWaPXmkcQREaS4/yj9DhvdjaIxSapu32swGHZtchbV1BFHedBumxo0vEGi0xMLiITEpPTqEELw++iihJn0y+ybLxNXC4S0SYhbCNJAoKgI4rjBME6hDKDlrbPwPPnqf9I8aEw6k9UPBMELNv7Gxl0gF8+M4X/1j3MvcYZtPrERnNENY1IPIKDjSiJJE9N8829/ogw0HkZTsXpWA71D0j5fBB8vdnkd2ZPkt1ZI2xXkeNJ+iNT3F9eYOjcRWKqjm508B0bIZmlW9vhRHGcjKbRtG1isszvZEZJ1rYJHAuyJX4gS7xzQMTrj2vr/ErxCC9pGqEg8m2zz6vVFU4URlEYZDqsNzdZB1Qlwp30BPd8hbXKBv9oaArdaOGbg0mgCiLJiTP0xYDggRyAIJKKl6nVbpAQRapum7iosq3n+Gb7PnklwWfSM0R9i1CQqQsi32jcwglcMmqMqegYQpDDJWTbqiEAuqzTswfeXtONklEMYqJORBp4oyl1DJEe4R6HLgghXrCJ4Ym4gYkoSHS9J1ed/iThOj6qIuHZ+1x/EIQ4z9Hz9gFePj+OPr9Ga2dgBO22wdhsCbvTR09FMTsmqWNjvLo5GOPJZIRUIkKtYWCaz07LfRbeXWtw5NRxkmwQtHykSJTO0ASaqJDRo4hGD/wAMZXDq+9y+sxJvrLT5LfHc6RbmwS2xWfLeV4VkrzRqvNao4qfK/Hl0jRRAm55Au92O4iA4zrcraxxt7JGKpbmVmwEy3WZ62xCbwc/DPH7dYqFY9T8AT+eSY4RsevUjB0SCFSqW8jJaa73G7wQzzMnzxFKCg3B5mbvXTLKEAmlBEAo6uhKgjBo4O8F9kN8hKBNQhkiLscgHKRTCogE4QYE4PkhQbCDH1x5ylNj71zPVuf9ceFDYdQrhkNpOE1nt4O3FzEuHClxeaMx6Nf2FORTUaIRhZ1G71D1qSgI5DwP/xFNdKfapjpeoHN6FsW0qeck/rrWpGsPJsALpRxnHI9wo4aUiNIeH+IvtnYfBrT+NijqOj8XSzAUeIwnU/QsizXXpXrsHHmzTWV3i921JcIw5LUb1/jVSy9h3ngTT4vR7vcRIjrbjTofz6T5zztVfqmcQ1m5hvFg5Gwv8aniBPdkDUUUuRTLMKMnyfabLK8NCi1OJwtY6SGuuy4f1ZPYZgdd1RlPFtESBd5r1VgzOiQUjbzb5arRYlZPExUGJnTDbpCI5ZFFDQhR4sN0+5sEgYcuRZEEiSk1zSm9zJggMhkfY6F962GWTEIQ+WT6GFd663w8MYxlbRMTfdTQZzqSoxtI+GHwcJIBiCj0vDqEAW4oo4o64YGQmBt4EAZ7MgPP6vD+k8PS/DaffvkY9RsbOLZLEIRoMY2m/eSS+GwpRTSmUdlsPOx5PxJXcXcOUDRhyMbiLqWPn0AsFXE6Ft9aa9Fsm3z2/Aj5Xoeg2USczLAqZXnz5vsLyz0JMV3h8xMZZmMCQzGVnuMRDJ0izJfYaDTZXl6l1DP51MgMXr1C33HptLtIxRGceoVfmyyirVx/OC69rWU+WRqnk8zxQiLOyxGN1dVbbNl9klqM6MQpjEgS2+pQThUoaDrES/z/Njb4YibOre4mk1qKmCDQQCBu90ERUOQIEVGmG3g4gUNey1BSIsTFkEtDZ9gwKjheE7yQlKDyudyvElo7iFKEILSRBJWIPoYdtrEPNCvv+y10MY8kHNaaCkOXkD5BUMcPKiA8o1dpCPyIs1+eFz91oz5cSjKa1JmZG0ayHDotg10/YKHRp97ok2hAd0o/9B1Nlfm56TLCagO/1eOFsRx3Q5/be000BAE6rT7Z8eK+pw6EQYibT/P1twa6FD1rP/UtG41wvmPSWtrTRml1kXbqfPrcEb6+8bcLvEVkmd+KRHDu3ODExCThlXdIqhp+PE59U2X55Bmc/sLDXHYlkeRdJyCTH0F3LMLsEJUQlrc2iE8OPNZh38bpSESyCqlokp5lYNc3+btHL5JrbmNv3ufFSJyYFqVbmmK1uU21U+OCFuP3jTYksnwiM8Z5IaTd3GS+scFFQWK6OMVfdwZd4o3A5+aBIqS4L6IpImlcQEB3u5Q8G1mO0AxMZrQ8qtcncLrEXAOtvcBsbJw7ncHzDsKAkqhwPjGB5dRYdgRGIzkSsk7oGTSRESyHuBghxCMi6kiijxT06PkN7rR/SF79LSQ52JszARvGbUqRiUP51bLw0xX0Ajh6fJREIcHsr1zEqPcwg5CVWoe33zhcxKXpCh9/5RhitY3Xtzl9aYZ7MZ27yzX6HQOpnIWN/bTZMAjoJxP82VdvP/zswlyJxOIK3d7ezrLRZWwoy85ohpWN50/RFQWB35hOE91cZjqj4lxZJquoVLeyJKcmaPd6BL5P1zBoD2dppwVC28LLj7HU6WGZu4wPR2iGAVokQjIWpyl2GBEE/rnio1UXSfRbTA1NsxakudfYwdq4y3pxmleGdUrtdbpGk/naJr8ey5KLxun2fOatfZ7eRsCP52giIngmjm+jyVGiooBhd9EkGau/Tc7rISYmaNgrCGFAgTgr7l2CMEtSToEgYnsWRhAgCjKqoCOKOjWnxlr/LifScwjog3HmtxkoSCkEYR+QIHx2A+qfSU9dVWU+fnIUqdJl4/v3UWIqmSNFHMdjYeXp+d8fnyjSfWsR/8FK2Ohx/MQIa7pKz3TwgxAjqeO7PpOfP0/j9hqu55N68Sj/w8KT077OZpK0Lx+ecL7rUX5CR/bnwUFe/cV0mmD+HqVcDnF1GS8I8CyTcjzBZqeN06xzuTzFrAjpaIyGINH1AvStDYIgIAhCIERRNTb3uCpfEDkyNEZJ6EKrAdEkRnmMpu+xVt9AlxRKYYBS3yAtjqP7PnOJHPetPmUtxhutCkdVjdd25w/ctUeuvUleSdLX4vBIAUlPS/Fq+w5fik0R9rcxzCoj6VnaVh3L6aFLAT4hpiAy0PQLiDg9dCWB6e4XDWmCCOHgiHVr/z13RYNXW20+mhlmQk8OUs/8LoqgczLxMlfb3+U7u/+Gj2R/Hi+s4YWDHUDVbtFxOwiCjhs4rPZ+8Dd6Zz8qqBGFUxNFnI02i5c3SE3kUAoxtrYb+2N2Dy++OE3vyvLDwqTubocjnzjORkyj6oZMxGSmfv4Fuve3MNom8VPjfHX58HsZiog4vcNUYX+7wczp4gcy6jOlFNrGKmPlDM78TQB81yETeLx96x6ZSy/T6PeREgmWRJ+ltQV833soTKeMHcHyAo6Oj5O3u4TdGmKpSDaq815tk1FVJiNBuHmH46NzDMVi3PY8VjyfjdoG8+0DO4vOLjP5EfqIBAdSVHeUCJ4kYrg9irECuqiCmsDcG0ehlsE2B7vHhJCiAYiCvGeUoeM16HiDRSLuW0iRNBk5ShAG2G6VmJQjKhlcb12lFIkzrSwRhjaimEeWJvADB9/v0rO+8v4P82c1pfHoTAG13mN9r8kuQHO5zpG/e5HvCk+PMyRtn1oQMnV0iIQsEQoiHdthrpzh3eUK08U0sZaJWWmy2bMYvzSLNFnkG0u7VFtP1tr2w4EE6qNJMMGzW5w8E0lBxHUcopqGbxqIQEyW0WSJnKZhuB5vdbuMD5WJrC0SNuvE4knmTl3i7vx1+v0ukWiMzsgR3tgZcOb9aIqh7XWcvfRCzB5pPYGz1x80LauoYYjvu0T7bcpKhKC5TXryLFqywHprmxc1nZaeZMHqPZQttawuY/Eif91p84vpCYReBQQIYiW+0mmjJDr8aecOp2KjxEWVLb/LiKQQUaLISgwvmmelt0oQOIzoRcLARxQe9H4XqYU+Dc9iVlbww30qQhM1dhGY720Sl3SGI3msIGTD0oiJA4mFI/GL3Ox8jyvNbzIVP4cixnEDlzud738g7fUfN6JRjdatLXq7g4WsV+2iZ6K88NEjrC4cTjNNSCJNYObiFKoigSDQ3G5yYqpEUVcIGi027m9ROjZM6TNneWujzc37hzVxnjZEP6hJSWkybsNACge7QVkUiasygiwhCj6GbZPqteneu0E8rvPSxBS36lWarSZ6cZjXPJWz0RSF7UWczsBw6nYUrdZFFiQSokTgWEQlCdXuI5otPp0b5cTQMNZGlU4swbxlYuwV0q21dpHLR4l0NvF8Gzma4y1crlZvcS4+TMN3mIqPkvf6JOUIgZbhrllnVNQIAu/hYwnw6T8iZicJEoEgs9Jf5nRiDpsQJxBpWtcRwgA/FFjorTOZEkGIYTlL9Mx/CXwAJ+9n0VMfKiVpvLVy6LMwCAnaBrIs4rpPfiqhIHDy1DjmrU1ae2Jf8aE0M0dKvLdS4VxCZ+fdBXZFgVOlNGs/uIO62kBt9/jy7BB/uVLBsj3imwG9kYHBuVJvcWx2jNbd/ftRoxHWladXJwoCjKYSiKLIdrv31I5Ht0yTuVyB3VaL0WKZbG0XwbJwTZOjtkUrX+C0LDO6tojRG9BFvW6ba++9iXDuEuv9LptuwNXt3YfFUR2jz64PWS2PKDvYisaNXp3p5BQAaUGiF7gklQiqFsXs10GS0RMFRu7/EEWL4eCTMZqcjGW5vqcfE1FjbDo28/0mv2d2OZEcUBm3K5vYgQf9EsfLFd7tHi6rHo/kCZQY/fZ+kHLV6TKWOY7QX0XXcjRFhe/Vb+GHAaPF88T8Lk5gMhUdIRYponSXGS6cRVHT3D1wnqnoXgcqcZDn3PVqXG9966nv5acNSRQeGvQHMJsGpSdkqYQCnHjlKK0rKxjWYJHLTBfJzZVZ/It3uO94zI2k2Lm2yvq7S6TOTfOlC2P89dUN3D3vfrnjcTyXxKzvU42JiTKXt7uPXS+hq+QTOs2+fUgiAGC+1uUj5TJ9H8ZiOgnPIrB6BG6MizENO6rx3rXBe99odWn0Fxg5d4ErSYd3Gz0q/QZTukQ1kMnGM4iBj61FqQU2JUHAsPrkokkUs0MgyUgIaPEs4fK7JFUNt1/nXDzH2/0+XhjQFTW+Ur/JpJ4loaVYMCsPRbze2OvgJSJwLjXBF+IFKu1l/NAn0OKMqkl2vSyKWqQt+sx3X2NOm8J16+TVMgm1TMfvc1o/hu11aLiHF8q4lORW502a0uUP8uoPvNiQ8GfRU1/faXM6n6Rf3/eeBRF8WTrUCSqxbKKfz3Mml0J1A8bHC2j3t+kcUG8MQwgqHdIJHWFPwbGcjGKu1/Bdn2Czjp6LU393gRfPTfPq4mEapms7fD+q89K5Y6j1FmE0wlYyyg82n9zLsRjX+cVMgtlmi6TnIU6VuSor/MnqDg3zcDXsSq/LwvAIH2nUKcUHLet832Ot34PxSaorS3x6fAJr6bCCnet5OK0mf1F/fAvthHC3ayCJoCR8HGvwm5OxFIqiE4gCPcsilshjFyfx2zpWEKD3W3iOSUqNstxrMpcqkzA76JKCE4Z0s6PcrAyqVe3A40rr2R6wHTjMG1u0vD6fS0yj2i0gpKul+Z9238XEww1c2u5++uJ/qrzHbGyYc8lJzFBgt3WHvJogJEQWPDpqgZpzuDbBfx953wcQkRnSj/HT1H7xgwBVV3EOZKCoukrX2B8X08eGGC+nmDw6TLRr0hL23W3XdMiYNo7pMFJIYK7XCPa2kJrtYN5b5eyRMd69MxjDtxerJE+WGS/lEfp9gmSC272AnQM9AgQBPj9T5iOhRbrVQiknqRdH+cOFXZaqg3HX7ttcL+X5jGZRPncGFu4TKsqA8puYQl9fRBCEh7Efw/XYWlvndT9K0xjMRQ+43+4PtOMFEbO2w4XxI8hGCxtw5QhKLoWbLiNEk3Q7NYx2DXX8JJJSB6PFcCTJrqDyuhPgRXwWjKfXqASEXG6voBByVs8jOx06yLweKvxw9x4XMlcx98S6Gu42F1OfRhQTVO11dEEhIojoQgRTymL6+9z906WkRTTlOIo8Bvzr9x8IP4ue+uLiLhc+cZxE18Rpm0iKhJKJsdy3Bv1L95BJRzkf0dl5c887vF/hxeOjZKYKWC0Doiqbtovc7CMKIsJeYY8uCA+5SjmpY/QtfM8nLwl8crZMIgjo5BTebreo9U3uN9vMC5DSI1imidV53NN5gC9mEowurpBRZDQ9gru4xol8ml/NpfjXW1X8IDzEq98xTM5pOm3bpasnEQKP6NRRvrdwF8swKM/MUH+kcQbwsOHBo3i70+dYYQitU6ekgh1CTVX5406Vz09fIG8blH0fVJ2d3UV6zW0i2WGCPeMfCtDoNbkZJDmSn8QVZO46Jt/b3cD/G+bXVp02f1y/xkgkjySIbDRuPDY5RARmYsOUlQQVt0vP64EcckRP4+3lsSvYJPWJh0Z92cgzG3dZNd+/alIVY5zLfA6Rn247O6Nvkz09Qm+5htu3UWIqylCK69cHi+XREyOUQ2i+t8ryTocsMPWJ42xeXiRUBtlcSS9AFAUiAofmQiAIiLLIC1M5chLYksiV5Tpv3trhPUUiGlXprlb34jD7ODuS43R1m6xlEE0nCLs9Utu7/L3ZaX7fcB72Kd3p2gRRmWatgzQ0iWcYSOUCV1bWuJBU0RUZ40BWma9FsNr7f3+vZfFruRIxs0VGkehFZFb7fUamzzFqNNE9G1dR2di4S1FRsRNpAs9ha3edhp4jpyr4iTJf3alwo7bL5OjzPfO32qvckDTG9Awtq0HFXgbgeLKLgMiwNkVKyqChEHht8oKOH1jgtkmoZRx1lA1zYNQVKc3d7pPSYmXS8b+HJMqE4dNtAzCIGfk/Y556RJP5+PFR2g2D0Vdm6VW7NA2HpirxxtXDDWRPTOao3Nzv2OOEIZ7vk58bpdbqsbbdoN20yWditNYr7BYSxOMRfAEkAURZhqEMvWvLyKrM8Wycq9+6iuv5yCmBnz8+wdfjAjs9gzActK97P2RjOrFqg7nJUfwb9/Caa+hRnWw5z1avy2w2xb1a69B3XlJVdm7epByNIu8pLoqrqwxNT7LmOFzpmxwZm8Zc3Tdceq7E95wnp8Bt9vs4R2c4l4ghGhWCSAy5MMyEb2Pcf5fXXJOUrHFM05nKjWIkC8wbbcbCAElW2d4z3B2jwzXb4vfa1Yf6L8/CnZ0BBfMkBASsW0/e3ciCxC/kzpJ029hui0k5ynhsjJhfx/P3vXjX6+N5Fp0gQUKWccKQJfNNKvb7G/XZ+ItA67GGCT9paKoCSY3hj85gtAzqHYONTp+lewPPeqyYovbuwOgYpsv0+XFc0yX/kSMsXV2l2zbZ6NpkT4ziV9sMSPOQ1NwoW9Uup+aGaL57D2e7jSgKfO7MFN9abdHuWLTbT66tmFJFJjJxknUH+848giCQm55AIuBiKcW3lgZj/mJGY/fOXUoRD/eBU7OxSnpiEmNoCP/ArlFWFNb0FGZt/30vt7rI52c50t+GTp1MKoM2MsMbt17ntmNxLp5iBo/C8FHaSoTe4lvISoSK57Nd26KayPHv2xus9p9hNJ8Aw7e51zucxikJCh+JfxzNauF5PYZkiaQ2TdsajCU/9Og6O0S1UyBmcEKf+d59as7jHcKi2iUkIXy2QX+AnzVPXQ5g4+0VAOaB8dOjrAQuCzcf32rJfvgwaCopEnOzZRrXN8gUU9Duc2QsQ308zzvOIPPltcUKLx4dJqnKHD0zSX23xe3bA87s5CsnWHzzzkOpAKUd0ri9youXjvKV3mEP71wxy6wkIwYhmyK8WanhByFeEFAs5Qhv3sVrDrho3zCxrt+jfPEUMefxtxnxBgGWTT9gNhbH7fcIHIeIKKFNzfDteo2risJnj50m5TgYisx33IBbrdYTn99YPI6yMc/rzRqqGsGPNAh2V/nsyZe56Q4mdtuzeduzWfNc4jNnaZkdwliKTPQUW5t3EAWR4dET7Mgan0bkjV6drvt4g+2/DSRBJK0ksXybudgwMbuGHQxoCccz8PobpFJjNIx9oy7JMWp2ndeb87T3smY+k59/4vkPIibHgA9uDH7UcPo2V/7qBpIikRvL0tVFbry3/PDfpT0vWhAEps6M0V+uIjo+kXKKoWyc/NwQX1+u4XoBLx0d5cipMXqNHpvbTTKFJM5WnUpz8I7DIKRxbZnz52f53rVBnv6xyRwzaQ0xDNj1BL7jthAViaQVYC+v791FiD2/TGpiGPVA2EgLXCzHo5+KoUl9Qj/At21iEZ2vGyHe5AlGAosQWBY1vv6ISunJfBpn/jqv93uomoZjt7lUrzBTHOLmzirvdppsR3Sm6jtsZYYYmn2Ryu4qu702R0aP09WTDNWqbJl93L+FuJ4iSKTVOHPR8yjmLt5e1y7PsxD8XSJaAWsvuB5IOtvmIq83v0MQPj0QqshDhDxb2uEBfuZSGg9W2gGs3digeGmSJ/liBhDtBRhxkbHxPM69HWTTpds1cboWrDbI/NxJbv1wkIYVhCFvLVd4CyilolwopNFPjuMoMqtBQPcJGTAR57CX+spQgZnlXfqNNj4woWvkz0zzF+vbdEwbORXHNqxDiQdBNIIsS9yrHG5aAdDSNDKCQNW2ECMRRvQokajOwsg4/76yTc9x6DkO/6p/WP1tPB7jxVgMMQy5bjnc29OOORmPYqwsAeGgG5I6GEFRe3/QSZJCPpElp0bZQeDPJJn1yjIRWeHFwjSvJPL0du7jdescFyXOFCb4Y8tg3eoSk1VeSRVICwLbvsebH8CTf4Cj+jAvRPJEnD5+RCWfGGOrffPQMdtWnaHULJKSQwxtfFGj7jk03D7WXtFSWcuyY3+BqehbmH7riddKyiWy6jiy6NF9Rmf4nxR812d3qcrQixOHPnekwajJjWUJKm38tokW0zDqXYIQojMl1q8ODPR/qnYp5+OcHkmjlbNEx7KsLu1gWgd2cGGItkfRnDtaZLrdxFhtDkr6dZVf+MQxaoKI1+kd4sTleAyr2qKi7WuydCSNpCBwr24wlSmSEDyUfJJ38iX+7N7KIWouIst8rJQlL4bUQ4E3dlvMRJWHtSG2ZSJEQggDdM9HEAQSsRTJeIq+GuE1Qeary2u8mC3y66VZmuu3qZk9Pq5GuFCe5l/ubHMiWmZKimILcNnYpXFAVuJpOJcY5aKWIOL2OSMXcLwddr0tQkKa3i4pdQJVSuMFBoGk0fF7dP0+AiJDkWlCQqr2+sP2jQNIyNIQqlwiDG1cf/mp1x+8E372PPWDEEQBNaIgPIXLvTFf4VMvTlNZ3SIaUVFsHzkbY6faJvBDMB3G632iuopxIDglCgLVjsnX2vtG/OJEgRFdwz4QzBQEMLX9RyGLIkccn25j3zjbpk1uq0E+plPrm7zWNvi5UoFyKgGWja+ptIAVTaNv79/DA179m50W//D4cYL5eSqWRSeRoDE+zh+uLj3sPPMoLmWzfLLXpL8+WOp+KZPnWmGYb1SrVFyPU1Ed2zi8QFUVlZHsCMOSQlmOoAoCjiSzu3abX40m+Us9yV2jxbzZ5aLRxOwOCrb8wMevLPG54WP8ue/wu5kiYW0FP/AYkVVOFqf4l7vrDw37+1EwADFJ52Uti93beMhwRyMZXohNYAYmIdAOXDasBitOj0Z/G0mS8AMfRdRY93z80OcXihfJiR5eYDEdu0Qt6HKv9/qha43oJ5mMz+CE28SkHBGx/NT7+klCUiQkWXxsct+6u8WFC5PEBIFwt40gifiaTG19wOnGWgbplE5rj0qptQy+WRsYsxcDgfQjue6CJGKKIqIoMKuL9Ob3KRLXdEhuVrmTTrCeyTI26SN1OoSyjKWqNNJpbs7ve9vfX2/z6yfm8OYXWKj30VNxtooj/NG9lUPjVFdkfncohbh4B891KSsKJ2bmuB+KyIqCt6cm6oUBfUWjkCnwuWiMrO8QKFG6gcexnSWsTBkIWVp4D39vbDmOhV6Z5/80+wKR/mUsq4KAwExmlG/IGsvWgeYVj6CgJnlJ0TB7m/QA39bJ+xoZ7SSm38PAoRuYeG6VhrcLnoAgyPQJ+VjqMwhBF0I4qh/lRu/agydMOvYbCIKDKIqAgCRdeN93/zMpEyDuNTKYnBsiqavg+gi5BDNTeRaXD2/pLMvl21fXGPvoCMFYgYjtsXFz41AwyHU98kmdNdMZ8PUTJZLGQEioo8u8urKL7Xpc32wwfXaK4Moiru0iSiKZM1P8ZXN/IkQ1BbH7uDfvtrrkporU+iav7tSZLBW4dW+JjK4jBAFmIcfXdh5vOg3QtG3+Z9/npbk5UsCK73F9d+epBl0WRV7Cp1/Zl/g0mjVOxxP8UFG40WzxytAM4tItwjAg6CroIwleC11+UY0Rq22SSZcQjQ6OY3E6lmBXkPmEqnHXaHFMT2BVHt8XZXyPz6SL+LuLhHvctOs56LVlXkoN8Wrz+UrPT8aGcY3DRj/iOSRjBYw9SeCMIKGmjvEvK29wJDrMK4kpEjj0XAMTk18qXiISVLH2qCvXa5CTkuTVSWrOCgAiEmPRGdyghRsMpH4T8uNqgD9JCILA3KVpZEQC1yc+WyC/sEltT0+9ut3i1Z7Fxz53krFyis33lumv748b1wvIpaOUszGmExEk28WLKNyt97m+WOVL52boXV3EczwkRSJ1dpqv36+iqjKC+Tg9YDe7qOkE12SdpaZFWouiCND3JJatEPtAgV3TsPmDJZ+L43Mk5ZC1vs/bm7uPjdOPFzMIC7fw9t6N57pI87fRj55FGJ2F5bs8yJR3R6bxW7uUCdBDCCqrKMkcpxMZtMBhW4s8NOgPEBMEZp0OCw8C+4RYzXVeKs68r1E/EythHhh3sh8gy0lEz8L0u8SQ8CIZtmkxps8hegb90CSnFtgxr+KFew6Za3AidgaCr6Epx5EklSCoYbseqjyKIDwjGB/CcyRr/Vjw0zPqEZmzn51Db9r0dzugytQurzOc0ukWEuxWD3Ojw0MpMrLCRrXLxNkx1NUaVttElEUKZ8bZtR1a3cGA/uxECeOdRap7Ho2kSHzmhRm+dn8D1/P5i8UdLpyYIC2AIQq8ttigntkf2D3LwSs8XmquFjNs7Rn7vu3wpz2JT52ew7dtbEXhPdNhsfE49fIApudxudvhI8kkZVlhIxKhZj45sJXSNNRO67FSB6lZZyg/xEK7w/+y2+SLkycpBi62KPJWwmTWd7i8dY/zxSnsxjZOuwphSDTwiDe3OXn0RWRBpOI5nI/EMM3D21lDlMiGwUOD/gCu5zAk/c2HS0KKItotmloSN1JGAWyg4XvUnA6z0TIb7Vt4wT6tcD57ivv9JiEBaSVJ20sxqjpcSH2ebWuBirNOz6shCeHD4r2eVx9oxfwUEc9EUe0Q3zCRdIW1Hy5w5vg4rzbu4DoegiAwPJ6nX+ujf3IMZX4HWgaCKJA9PkLbdNAjCqPtPo17+3o2J+eG6cY0vnZrhzPHJkhIYIQCr9/dxTBdBAH8mP7Y/URKGTbaBncrLT559Ahh6BIgsI7ED5cep6osx+N+vc/pQpysJhKTFbrOYYGwXOjje4dHp+/7JFybf9s0+PzkKbKBgy3KVASRpcYuXy6P0l28jh8GCP0OiVia2eEZWloUfy8Y/ABZVaPvPj434r6PiPBcwXBdUpGdDn3JRkvOgCvhCiFtr4EsB6x33gBAE6MkApeSNkPNWUOXUihSDF1OEuMf7lFWg3kSBC2sB4J2z8DPnKfeMxwyxRTzP7iM4/p4boCkiKjA9GTmkFF/4fQo2mab9tfuY6cV1s5PUvrMCZrrdbwQFhsdcjPTfFSV0FWZEVHkxgEv3nd9IrUuiahG17BxXJ83lx+hDjL70aIgDLkS+Lw4OURndYcwDIkXMqxk43Q3979X65v86XMoOT6gYE4lUnzOdDCv3SEMAo6PjfB6Jstbzce9+67j4MXj8MicCxNJqnvUUc91+ZPt/cwDWTA4lhxQD7Ik4/WaD8tyBSAhqWSVCL+ZKnPVtejlxlE27z7UTYnEs3zfc5jRdHQgpkaZShaJhD6epPAd6dl6Fw9wq7/F8cQMdn+w01BEGQGBhm8ihCGaMHjXWVknIqqMyDqec3iB8ewG0/FxSmocJbDR5BiKJLDrrKCHBrPaJDtSFj/8cLWvA4HdxSq+H+A6HkpEIYyaTB4tM39zg1c+eRx7sUpzpcGbO21OvXKU2JEynVqHdteicKzMK6qMKYYYuwrOHn9ev7fN3IUpXruxydu3H5e7CEO4Ubc4PztCZ3FrsJjnU6xlU7SWBjusby89u+7gpfEcZ+0Wxp0VRElk9twEX9MjzLf36yh6okRaFAkPBDMFUaQnyjRMmz9e2R+4/2UqTjqawG9UHlYuC0AmGidJyFVJJVWeprFzQE44O0rT6qBIGhPJEaJBiCcKbOkpAuPpfPb1foUjsQKmWUURJIQwIPB97MBFCEIkAdJamaaz9NBhCsMAAYGiMkxByaMKKoIgYIUuvmsgq0cJRQsvWH3qdR/Dh5lTFwRhDPgDoMzgNv9FGIb//SPHCMB/D3yJQVzzd8IwfN9SLEWR6G23MYwDOa9ugOINXt4DRKMqKcujstN6+Nn1Kyuc/vQclaRKGISkp6fYfXuBbq2Hr6s4isLxkxPs7jYZyqcQ/QClkGDEMKi3DE7lkyhByK7vc2OjfigP+AFu1JpUEzHOv3AUCbhuWcxvfrBS9GRE42wuiRkEvCO3+DgS/aWVh//eW9vgkjbLVUnG9g97PY7vc0uNciqexN6rMlUiUZZTedqVp9/HIgFDWpyu7+IqEWTfB0kiokXR2jV2WxXSO/N8MZnnbUUjO3SEUuDjCCI/cC2ud6qsR2L84+Isp3wbb3ceAQE5lmFSzzKixdm0B8b3/Xj1vm/yhtPghfgoEaePreiYsWEinoFibBLuTW5dy/BSYnoQ2HgEDc/kfPQ0jnGHAAERC8F3SSvDbNt38IIuRbVAw6mRU+P4DBbYwXLxbPy4xrbvelgHYjuu5ZIIQFVkCsNp2O3SbwwC4rtbba585w7HPnsCOxEhnU9w9Y/fZHxuGG+3zblPn8DomeB4oMh0hzJcCiFKSC8IubFUwzoQNJ1fa9LMRjl5+ggSMN+0uLz0bMosl9A5nk/gIHAu6NJbGyzGvudjLCzxyZMnOJh/9Gq1w+9MH8VavDdYTQSByNQRflDrPHbubUklEYT0JZmoJBMGAYlkln6riqfH8e++gzB+FHv0FKJr0RFk/kOtyS8XivwdXSPcHlA5UTVKPPCZ00vcNZ887qpOhze1JBfjI4SuQRjPEVGS9JvXeCD6ERF14mKC/p7H5IQWmlpCDRwcvwGiTBh6qHIWV57EdW6hxz6LF6zzwFILwrMpvg+zp+4B/3UYhpeFgTL8e4IgfDMMw9sHjvkicGTvzyXg9/f++1SIgoBhOKgJDae7H7TUMzpbByZELhvD3Hmc0thZrvGm5GFYDl9yfLp7gSTDcvA0lYIkkk0l6NzcQIpqRHs2v3VyFD8aZe32BmvNDkNRjbGzk/zlvcdzUgF2un2+1n1GL8Kn4IVSlhctE+PWPSRZ5tLLR4k2qhxsghWRZcY6PT4+Ncp3tjce4y2/Ua3SLI1xYkhABBYQ+OHuk3PAYdAN6V2qTI1MkzR6tLIlEv02YixNaHYgnSfwPY5GEqx0G5xO5vgfWhuPbWR3rD4r6TITvSpKNIMpCCxbfax+h48Vj/DH9rMzEADuG1ssmjtklCSmZXOegF9W09hhiChIIEdZsuoMqyk2fJchQT6UcSDIGSy3hSRqyIIMArihg+h3iMoFDK+KFAasG7cwvFHy2giCAA376c/o0UfGj2FshwyC/wfLxHOzRX747StMzZboLB/emTXrPVbv7xBqImvvDC5tBiGJhE6sbxNu1BFEAUkUmRnNkDMNNnfahIbDF85P8fXbO4cMe61h8P3GAc535v2bhnx8qshcp0H/zh2GJocZDw1uqDKW4yGJAuVohJhrU4xH2d1L+23ZNn/QgE8dOUPSd+lKCt+rd2laj6fEfqVZ578ojNLGx+21KcZTOIEHWgRHjzOitFhfuUVtdI4/re6/u5umxUdpEImlCASBNd+m0VrhbHGWuzzdsbna3eBWb5DSGBMdTpvdvSw1CUGJstO/Rz5zFpx9qQtBVPBDG1GMAi6BIOG6O0Qik7jeXSzrNi4WspgiCB1M+7vv+0zhp9Yj49lGPQzDbWB77/+7giDcAUaAgwP/l4E/CAe5Um8KgpAWBGFo77tPhOv6tDyP/OkRnEqHXrVHYihF9uIY//kv9h2hVtvkSD5Bp37YkMjpKEa1RjSi4h8ouAhCqPo+p9JxKrfvofgh6ahKb7uF7/gEEQGl2mE4H2ez2SN+f5uZUoaFzeZDHZjnxXA8xgupOKofUJME3qjUsT0fXZF5wXXoLg5y433Px7lxh2PHZthisIBM6VHKlo1kObywvM7sUIl/12087EH6AO80GrzznPejShKXEkUM3+P7sTgL6RxjTpGi43AunqLTb+Os3yEjCGSTOW67zkCq1H88N9d3LW70Wo99rn/A6I8fBtT2OMgVq8p84JGQNLwwoGZV8UOfSBjlSmcbLTVFSQAxdLFFnRt2h7GIhuU0kEWVvBbHDyAqBjxQsfIFEdvvsWHeZMO8yWD5ez78uMa27weMf3Sa1lINx3DITOaxoxL9jkmj1mUin6C9dVj6IVBEpANZLTv1Pme/cJLW924RHc7g1DpEcgnWvnKZ2OkxsoSYskjr8hJnT07w1q1n98xUZYlLo3nyBDiSyOV6D8cPmOs06K4Nfk6n0cbXPKYSGpuGyKwu4rdaKPkcvxWN8c1Mitt7tRkNy+bPN94/fVQSBI7G42x7Pl+NJTly/GWOOwalbg1TEGms3GQ4CMmmcrQfCZZmJJHF/uPGO/Ic+etu6FO12zS9LutOg4QcJySk420OhOScXQRtCNW3CBHw5Th14yaioJKQEwThg4DzwDIH9OgaD5QZFeDJRYEPEQLB314M8G+CD8SpC4IwCZwH3nrkn0aA9QN/39j77NDAFwThnwL/FCAZzxEpJehW+3Q9l9RMjrAQ56uvHy4y6XYtrNkSelLH7JhoLRftSJaKCq7n0zMspNESHODwIrI0KKCQJWJDaWor1QFNE9OQUwk8x+VBM6percPQdPGJ+fHvh8l0nM+5Ie13B+XEQ4rMb1w4xr/fqDCZTuBvbD740WRyKTRVxY3HicVi4DiUDQvXtjCmJqgvLyFUd/nSudP8ce1vpjaYUBR+N59GXbmF49pEYklqo9P8vzqb/P3SEcpbyzi1wSsKwxDadYrjx7EqT87W2fJ9RmQNx9v3vERRovaI0XxWauNBVOwmhj6EbdUYV9MU1Ry+ALVIgXb7Pn9du0ZcjqJLGk2ngxf6fDLzK+RVBxUBVYggSjK+FMW0ashSig17nQAPSVA4Gn+JlJLZM/ff/EDP70c5trOJPJYUYkgQn8hgJ2S++9WBo7K1VufY505htvo4ey0cs5N51ittRsr7HWFURcJqGniiBIpMv2sjqAoyIUIQYjV65IcyrFU6xJ/DdkiiwK9Ol/Cv3sNzPFTg52ZH6IwX6b89uDdZVdCjEeTpMvrCIlNRGW93F3IxaqJA7+49PnXiGPOi+FyFQbIo8g8nCyR37mOaXTQtws7YUeLZHO7KDTx7fzcRNbrow0mo78/j+6bBy4k0ttk6dN629PwL946zzpR6FscxSYspktIwHiE7+LzW+TZxOUuAR6snc0EbQwkDFCGGICj4goTtryBIBXrOW0SUM+jqeURBIQhd4P/x1OuGCAT+h9yoC4IQB/4M+K/CMHyUOHvS3T+2+QjD8F8A/wIgHx0J5795n+mXJgkns6x2LJbeW8J1HvcE37i6ysljZXKaAoLAQjzg7urAkPhByLzvMjNdpL68SxhCrpTC0hWatQ4iSUI/IAwhkkvQ7BiH7i6ajrFkPr5l1BWZlwo50l6ILYvcNHocjcVIugGWIlJUZNpv3Hh4vOd6KLdXODk9TMNxECMamutyenIU1rcIGm0io1nci+eYMG2CnV26gsD82uqDZ0PxCffxPFAliX86McbI4g22LRF0sPod8msLnB4dwTPa1KNx0noC3xwEoKX8CDvvk0HwZnuXueIUifoqjmOiyhpOfpLv1AaLlSJKBGHwgXRi3NDjmtPm76fn8NtLgIASLeLbLU7FxrnRX6XnGfS8/cl+u1fl08kiotfG9WxCJY+FRU9Q2Tbu0HAH9nYu8TESYkAQfPDMlx/12C5o5bCy1GDk3Cg3Li+z+ub2IR31V79/h1PnJ8mpCqEAqxt11perNOpdLl2conp9jZTr4Ycg5xP0mn181ycUQJJFAmFQYS0CoiRiHrhFWRY5d6REVhEIRAFXldFth9SxLOqdJTYPpC92FjYZGSvRjUTIpGOMRhS8jW3sfo/ypz9Cr1HHKOTYVQKWVwc7TGW7wlC+yFr7ce78UXxmrMTp5godcRCzsW0LcekWeuJl/PIU4sZ9At9FEGWC4gTbj2TY3Ou02BkrMhQEWHYHSZQR85O8au0gCxIh4cPA69NgBl1aisgZYQq3vwaiihwtEvENdDFO1xukTy8atzirn0QLbDy/j6Bk8aQ4fnCZjv0NQCIZ+TxBUB+EEJ7148MPN6eOIAgKg0H/78Iw/PMnHLIBjB34+yjwzP2ga3vc/8EC5ZcnuLfwdG8vDOHm3f1gz6OdkG5v1mlk4sxdmkYIoZ6JsfLmAnMXp+nd3yaViREGIcrREupmg4Th0JUEZEVCPTHK/fube78T5nIZZiI6F2JR5n94k77poMsi/9sLc9xaWKPV6BIRBM5+ZI6rqnJI3Mjs9imqMtd265gTw5zs9bAv34IwRJIltlbWkRyDrxeTzFUrOPZhI+6KHzyLYzQa558Wsxy3u1jNXYZjMTa1OKt2D8vsMYlCSxS4V1mlmC6Qyw0TCgKb3Sa37afHC9ww4F/vrnE+WWQkpVD1Pd6pbRCXFH4jN0zes/FEkRVBZkGoPnNyAUSlCDN6marVgUgOP3CpdVfxAodj8RFuPHI7qqigBQbf332XjJZDQKDpLKFJUVrKPTruYEwoQoSkHMcPnrzreD/8uMb2zkIVJJF6tf1YYwzP9bn69uJj32nsdnjVXmbu+AhKIUkrIqMNZWCjjqjI2KbLzJdfYOmdRWKFBBXbI3t+km8uDHLUT8/k+dhsgea799nebjFejJPLxtjo2sSjHvpOA1JRNg8U47UbHfQTs4w2qph3BvvV0PG49f3LFE7PcOXeOs7BlpKahuk9vZT+AT43WuQf5TXEap+M22Yimea659D3XXAd3t1ZZ6I0RVQQsICK0edO+Lh43Vfa88zGC0yn83RDn7t2hU/qQ+Rdh1AQ2JZlvtlbGXD0T4AoyKTENO3QRIiVcIIunf5NwtBnOn6Em9Z7AExGpplvfQ9ViqPLaQxzAdfvcSzZxvM3SUa//IEdhg+tUd+L/v9L4E4Yhv/vpxz2n4F/LgjCHzEIIrXfj3M8iDAE2f3bRxR2mj12mgPePZvQ+dRYnuuLO4zPltDKaTLZOK1Ki9ALyB4bJVpIsGOYfPXe5sPm1r8SG0Je2aaYcnEW7jIbjbASUUkpCrXvXmX0wgytRpcwDOm2+oxpGvcOGPVoKs7tvWrSP92uc2asiFTIEgAtUWTB6iOuWQT5BNG5YwxXG3ihz061ihyJcOOAdrsoCE8tTHqAyXic/zafQrvzHplEEmF0mlqjwojtsCPKeAJ0hJA3u3Vmx46yu36PnTBAFESk0aN8t/v07lIwqAZ8p115yOmLCPx2vgSV+1h7zuqkpED2Avfkd9/3XCdjY7wgxikbTVKBSxgtsmjX8PZ0YNQn+D6yICEyyJlv2AdauhGgHOgRKQkqAiFJuUBUSiA8Z2OTH/fYbm22KA5naNefL7AM0GubvPvmwLh+6u+/gnlzg6GJHDMvTJFK6jTWa8RzKdInxvBkhT9/9T6+H/LF08Po9TbuazfQmj3mRnIIpkXr9hqlC7Ns9UyiqkwuDNkWhYeFez1JYsmGcctBLeTwBYF6KLBe75F2A8oTw0gpiXqrTa/bo1UuUd3afSSr/DBeGSrwj1WLxPwSEd/FG5liZ3uVo4kUV3yXe4CaLbNYGeyyFEWjPXaMu5XHe8yGhMybu8wzCKD+duoY6vZ9nL2rF0WJLxan+YvO49pAeTXBx9VXKHcNJKuNEC3giCHhXjBeEfYXEXFvzDh+D+eAuJyA9PC/ghBBlccQUB42Pn8aQiAMP7z0yyvAPwRuCIJwde+z/zMwDhCG4f8IfJVBytcCg7Sv3/0gNxHsGTNJEolGVfp9+zHp0INILJuPeesH0eiavCYKnDs9RtX12TIthroCzeur2J5Pfy9TIH9pFmfP6xjKxkls1Kh2uswVc+geCC2Tc2M5ar6HHwTIBzyu5d0mJ4+MI1y5QxiGqBEVZ26CO+sD79FwPO72TcwDbcYkQCrJDOsR1EqTVKtH1A+ZOH6Kr8cUvr+5xrCu83PROGnDwlVkbsgSP2g8bnxFQeCXoxrK3Ws4nRZ126IgQn50gu31RQrlFNXhMd4wGgSE/JHd5cWJOdJBQEsU+V6vRs9/vOO8AHwuPcwxQpQwpCLL/FW7StuzmYml0dvbmAems+e7TAUuC4L4VG9dE1UuSgns7iY1SSct6QTtVcbTE9ztdAGB5hOSeg3foouI8sjnvhij5e4bACvoEFdGiNMnDB//Te+DH+vYjmWj7LT6xJI6ruM9zDd/Xnz3+gYX5oZpEbLuhay9t0Jts0nfdHBdn0QpSTEbp5jU6F5eIH9yFHXHJqrJKD0DNaVj1kDyAirbdYZPTyKvbaPKErbnkzw6zreafeIRlYWeg9nar0aVVQU9FiELyJU6Q/ksO+fP8Xtrm/z2cJGcZeCLEguyyrcqtYcOiK7I/Go0wLrxHo4oMhyPEt67SeHoSWrtGtHyOH/WaaBIOucmT6IGAWvAa9XtQ4tEWtH4pWyOo2oUVxRZkDzm3Tapbh3jwJFB4FOyTXRJe9jg/AE+mxglaF/GUsrEwoCgt0U2PkxP1ECQqAf7weqqVyUlZfH8/V2MJGo44WCx8IIOce0jENYZdEp9BkIIP6yB0jAMX+MZFNJeZsA/+5vcwPCJMks7TU4dGyIryThtC3WiyI5hcX/puVPTHsNu2+Abe9vMTFLn45UOjd7hEupgo04+HaPa7DOWitG7vkwspZByQzw/wOtbqI0euUycliLjHfCk260e70RVui/MofkB64S8u1k55F2vygojegT3QOl2ZG6ayG6TnfsL7LAnqnr1OrGzJ4jIMr8ua5jXbjzUSzmfTOJPjvHDxuGtXzkWQ9/dRlMj5BIpBMBPptGTWeIXRqjEfP6sX+HLsQLlbhfB9mlqAv/JbFN/QqXeA/xcZpgTtXVcx8AFcoLAPxg5zu/XN4hJMoH9uGGSwgBJkJ5q1McjedjTqu77Jh0lQTmSww8lInISW8/ww879J373B81FPp89iuK1B1Wucoo3ulssGDN8Jn93cH1BwXE7oGYQ6RE+Z9XHj3NsqxGF8qkhkm0Dp2khqRKeJnL5zft47vNlELmuz1s3B4vXZwSR/p3DrE+30mFsNI8S+jiuT1KASEzD2mkSmjaJbIy4rhIoEmEQcvXWGsc+dZZ+s4spCHxvt02jZyFJJi9PjcHVfQ3xo0dHaFy/w3y1g5MWYG2LaM/gH89Ns/POu5h743xW1xFmjvD1vTaLc5kk5tY6E8kUkTAgUHWi4xOE6SybQ+PUwoAvd+pIRgdDTPEdz+VW73DKsiQI/Be5LGzcwU0OOLnjWoz86BFoPJ5+LPoeqihhHnisqiiT2qNkGl6VqDaB7ov4jkkyPs2W2Gbd2NcQ2rAWyMVfJidm8b0ekhSjJYYYziBuLqIS4CCKCQhMEJ/uVD7Ahzal8ccFNaYy8tFJlnaaxHQVebvH2oF89NJMkVIpSaXy5IBMRJM5OZQjKog0PY87W08uIoLBwxXFJ8xdQXj44GuGzXA6Tk6DzRtLTJ+apHd1kUAUqW7WmP3iR3j95mDVFiWR5Kkp/uNWhdYjwU1FkjhTyJCVJdZtG3luhunApxjR6EV1Xo2YnFrar0x78N5jjQ6fGC7iXb9x6Hxmp8MJP+SHj9y6G4Tko1GitTZKq0Hy1MVByY1tUQ8FeprA30sMI9+7QscZGHGtssZvzp7m913ziVtnAZgLA1xn31sJwxC9vsHReIZ7/RafTZWgvnLoew05wrWt7FOzYIzAQRCjCFhMRAoUkXHtHrpeIBmf5N+1rtDxnszv19w2/2H3PSb0MoogsWyu4ASHFxZF0HGDNpv9NaJKaZAD/1OEGlXJnCridG1WX9+vflQiCuc+Msu7P7x36HhNV5k7NUpEUWh1DRbubD7Gwz/NPoQMGqkkkzq9+U0Sx0fxeia+YeOIIsXz01xb22u0XMryrUqLy5v7DsJoLsHRVJQNWaH0kdOUAh89FkGNqty8O7j3B3MkJssU1lbZOWCtHNNk1rP5xt69uEFAUlVJmC5yLEZiZByh2yTQLJKZLGfnr7LWbmAEHlQ3+YXhaTYUjfYByeeTyQxafR37wK927T4508SO58E8vAj09ATt7uECKz8M8PcanBfkYXRfBM9G0zKEaoLr3e88sviHXOu9TlzOklUKtOxVOl6N6eRgpRCFCLb9NqKYRZJy+M6zU0gD/6dT6fxTq6/umQ5vXFulUulQTkZpHTDokiySjKl85swkHz0zzsRY9tB3E0mNX5udIH2vTu/NVZL36nxhZhT5KalOra5JUE49VrQojuaotQbGZHm3hXBkGN0ddEtaurVK5KXj+Gcn8U9P8N3AYXG6hH/hCO2Ls/xpt/OYQY9rCn+/nOf4vTXS79zhpc06M6kkgeWyfn2e2ls3+IgVkMjt/x5BFEEQCCIKWhjgPiEIpTxhsaoafbLlEaqdNpEXPkaksUt49U2Ce7eIbq3z5arNZ+pNThk2Z7Uk0l7z59juJmN66rHzAciCiPzEnHWbtKRg+i7fdX0iuUk0JYIeSSCUjvGV9vvnKm9ZdYJ4iVORIY6EMnG7S0rUaPgWu9UrfDT6eHubgppmNjrEkdgon8uc4FgkiyKIuE8IiEXEODFllIicpe9u03XWHzvmJ4lez6LV7LF9Y3/ix9JRjpyf4OhEmZc+PkcyGwMgno7yhZ87Q7xu0b25RbRu8olPnRyoOx7AZtciXkgc+iw1nGa12efaSp3hC9N4psvqu0uEoyVyX/oItUyarWyWVrmId/EYr0Yjhwz652eG+IzRJ3X5LoXr85zWNZx6h5XXbyKu7zJ7dE8yWBAQBAFdVXGe0LRF8jykvSD/SscgUx6mGoikJ2cRrr9NeO8m4uJdJms1zpomLyBwJBIHwNpZ4eVE+tD50rKM5zwuTCb6Lq8GHZTCNJoSRdPiSMUjfPsJxWZ+GLAeBoxHjjPk6mhmn4gPXiRBq/IGx7XTD4/VxSTD6gwnYpc4ph4jI2R4dBkNUVGlk4CC684/M2gahs//50eND4X07qNuyLmPzhLU+9Aw6N6uUMxE0aaL3F/apVxK8vOXZlj/q5skVIFcNsF636R5eZ3jxwvcWH8yZfO9jSqfeukIwk57UKE0lOb72weCbyF8dXGH3/nIEQqVLDFFodM3qKy3qXgum1mNN/Z0ViRRYDabIpZOstTt0TFtgjDkk4Ucxnt3H+phqEHIy60ePVGiUy5QsS02v32Ti1/6CL1GkyPZHJppI2oqi8NDXKlu8xvlEslWhyQCjgAbrsNORINHYm2SILDc7/PKS58m7loEW+sQTWB4PtHdTRxFBiWJa/aJ2CYz2Tz37S5hEKAIT1783DCgoUSIPfK5nC5xqz/gHy93q9yVFOZiRYzAY7669sy0xpAQy/eQ40MEjkGoJbEDH6lfQxQEMkGILEh4oY8syHwxc5Ksb5IXVUqRLDtuny1jg7wcpZQ5wbebtwD4bu04/3yqSDqU8c01SuowdmSIHev2+97PTwKyLBLsNSKPJnWOX5zCbVt4bYv2nSrnT0xwa3mbX/j5C2x8/Taq4zM+nKVj2LRubTF7fIQbBxII7q/USB4folRO4zX7yNk4WyGs3Bt4qN9cb/Plz51F6xhIqsz6/R3Wt1pwXOSvr25gHotytJjm9EiepXqHRERlaGeX7vbAOJ2cKJJZ3yFfSLGpytSbPcpCwMVLJ/H7bQhDhMlR1lsNiqZFVhLxgA3LpqnH8PZ6FEQ1hY2+wcc//lnCH3wV/AAhkcLrNAnv3yBSLBG2a5Q8h0ZEp+7YKI94W9e7bV7JlDFqh6mWlqoy319nVWwymy7ghwGL/aWn9hP1wgBZL+HTQ9DiuIKA29kkIuoQDKQkTkVfpOhrlEmj+BJ9WaBi3OWidpKb4iJwjVTkV1B8GSkUkcURAmUcy731jBEgfKgDpT92tF0XPaFjdk2mTg6RFETWlptUF2uMjWexRIjGNBZEgVPDWdr3dzE7Fr4uYvZtRsYyLDQ7ZOSnb7s7hs1/vr9BKq4jitCcf5ybs12Pby/s8FtTeTa+ex3XsImlolz4O+f56tIgBS2ja/xiOoNeaTOekNC0BLv5Am+4NinHfViUoUY0zhUy9L/zDkEhjdVoUyrnCIaLLFZ2OH7iOLx7HVcQaMkS7XqNY8cnKZSHGbl5B2t9AzkRp/zCRf6v7ccDpX4YUoolaFx7h3QmBa4LtkMsmaRtW9CoEcwdg4WrBEFAyg84E80wMX6Sk67JZr7Av+7tsGgdpre+1mvwm8PHkGtreJ6DmhniTVml298PKhm+y+XO44vnwUIkXdT4aGySbCAQijIjochKd5XA8/Hdwe5IEhVSUoyOIDwUFXs5NUPS3MUJPTJ6Cae3RkHN0FaS9N0Oo5JOWonTcnscjY+S8m3csIUL2HaflFxCU6beb7j9RLC6uMvFs9OsX17j7GfmcHf61O9X0eIa0ydGqVVbfO7zZ+ku1jBaA3rMNhySpSTdrkk6EYXGYUrq3TvbqKpMIhGhs1jFPcDNr6w3cM+PYt1YpbtRR5BETn50ju+ZIeNDKc4OJRkOA+JegDySxx3LsfDXA5XC0nCebLuNOb+OUsriNjrkTs0g5RPo21XqZgdbllirNjj76ZcQez3M5SUkLUL5wjn+P/394HTLsCiPFOku3UdwXULbRgk85EiEvuuiSDJhECLYFp/KlxHiadZjCcYiOv/f7TWcwKfl2LyVSHEpN4LoLSEpGn5hnO/YgwXMCTxu95+cgKSKMp9ITFAKBc5ECrh2jU5vkzDweOA9JvUkfSFkRJ2hYHsoYYAcynihhS7ppLUxWvYa09EZdOUFZC8gCKtYfhNZGkIM0oRS+pljIPiwBkp/Erhzf4dLZ8dJVQ2OHBti/q9u4YXQ79v0b20zcmYEC4HyUIreap3UcPrQ94OeTTwWeRi8eT+0e08PEgIcTUR59a1bjB8to8sybcdj6Y07HD1a4Opujc9msxhXl5gbLtJ6YxBYiuZTTMVUShdnWNk7z/hwgf6dZTKyhLN3X9ZOndJQnk42w41rNzHcvS3m3pz4OCqb71xmm5DS7Ax926H69jtcOnuKtf5hV10UBFrdDllRwhIl9HgSeh0810WUZIJCmRvVDXKzp1Cq2xTTJeRYnN17V6BdY1yW+T/MneP/pgVsHNByqXs2/6pX52hmiIQkc7XXpGU8XU74SRAR+cXYEaTaEmEYIAoS5dxxtlwLPz4Me5QXggCixDruQynVkqjhhx6yICOFAT7gO03yepG+2yH0+hTUFC23x3gkjRfu63c4gUHVWcaV0x/ofn8csAybrXqLqUtTxPUId27OI2kKzVqXeqXNxEsTyI7/WB5Fv94nX07RcJ+cKeM4HvUnpEjOjOe4/61bRGMKufMz+EHI1evr5I6NMVqOkTAswsVNGnvy1OUXjnAsn+LqVp1SUse+tzMI2u95zdbKFrnUFIttg3uhDTakVJXw8k1uSSHxiWkc36Py3g1OnzjO1b37SEY0WrUaBQmCaByMPoIg4rsujiTijUyjGk0mXBchnmKnXYd7l/lkIkNi7gL/z83B+3y1WeOeFuXj45P0Q5c75spTPfKD+OXULIm95i4iMrK3jZaewWgNguqCIIAUoUKVopTHsxuklDL+XuV04JtExTItIBJKqOIQ4V4xXIiH66+Dv04YPrqffQQ/JmrlefChMOpBEPLGlVUKxQRDLQM/ItOr7XspjZU6I1+Yw9muI8oym2sNRk4Ns3tzC18XESSR4tlR/nrzudKH3xea62E1PJbcw4GXvDSELIrEuxbp4Tzdu2sP/81p9YgqSSw3ID5apLexiyKJGKZNfrxMd+eAPC5gC1Es63HOMBMEbOy1s1vu7wcrU86T0/RqjkvH85H1JPlMAUmPge8jl8psZIss3LnGUsJjpDhGYvIYzVf/M+EeZ+57HrG1RT515Bh/aPdQRInfzI7xCVEl5lh0VJ0/crq03Mfv8yBiksIXM2UKoY+NSCMiEggCWmsbd8/7DkKfTuBQEKMs9NaZSI0TCTwCPcsde5vXDmS+PJgHfugNAl0AiA+zigQ5RrU3ePZ24LNiFJiMVlEEHUEQcAIT/6elefoIlu9v4/g+KU3DBXqt/THd3+2Tm8ywtVJl6PgQu3cGY1eQRApnR3n9L96FieJzXyuf0DAWehgtqG3u76pG4yr20iapsQTd7v67bC9skT0/TaFjIIUBRhCSTsXp78V0BEFAliW2ehYP+LisquC0WoSZBKsb+/GClLMfWwrCkA3ToeOYvDgyjS6rhKGLIkl4R0/w9ZtvMhNLMFKeYGP9PnZ7QP+43San6hVGowl+Lp3jk7KAblu4gsJ/ZPeJBl1E4KX4GJOhjAD0tSi5XhVzL+5Sc01KooBjtwnS48i+h6BluCcus2jd5lx0oMtmBgZJIYG/p/fyYAzagk8o+DxIkBLFOIQBQdjf+/zpCIEg+OmELD8URv0B6vUejYJJ8fgQQ56P3XfZmq+QGc+wUu9Qq/U4+8I0mz9cQBBg+NIkoSYQmyvz767dx/iAecBPgqUefiSjowVK6SSVRJxR0yAQJRRJwj9Qbi1KEm4Y0Gv1eDcd51wpQ0/XKZ6e5Y2dKiOFLBHXQ5BEqpMj/MHSBr88Okxn7QAFJAjsxnQUVcF9JBhlKo+/piAM6SZSjKsaP1xZolgoUoilUItlviFIpI0u8dIoQV7ibjpLeWcZ8ZEgqOi6JPZG8K+mh/lCv0+w/BYeIVHgn4wew4jneaf35CIlWRD53dwwws49wnDwnVkimKUJvObhXqQrzUVmRl7Esyos+116SoTvNd+j4R2mfxbdLqelKK5vsOtbDEk6qEkqZgVFjrKJSMsdeKrXOmscLZ5iWE0hhwGEIaGW4R3z7Sfe708DvZZBvdVl8qUpPMPBsVwqC7vkZ/OsbDXptQy2geEXJiEISE8X+E9feQfb/ED59uy0TI7lk/RrHURJZGSmRFxXiJaS1Ht9xEcDzILA9YVtUi+dGmSK1NvsKDKSZaMpCkI+w1IqjX2A4un6PqMTY7RWVw6dylT2Kwkahok1PYy+cJtXN6uUs2XUSEB8+giXmzsIqQxSaYx6u/bQoD+AZPb49ak5Xm5u4a7exgUimss/mjxNO1Fg3jockP9sYpKJ+jbuXoruXCRDJjPK7f7gvDudTcbKGVKRBNVgCzuiMB/cZscaBNLXnFXOaZMYdg1HzaB4MshxOl4dRStxz1liUnmPrPKrKGEMIQgGGXNqiprzR898J8HPMqd+ECNTBda+cQ+naxHVVY59bIZeUuXdbw+MxNv3NnnhozMEjT5108EcSvL6e3cw7Pev8HpeXK62+dSZSWrbW7x8cQ5xvkJzu8nWrSVeHs2hnCzRuLHE5HiR7p7+jJhL0LJMzIjM3c0ad/fO9QvjQ5Qsi9uVBtFElPDYOP/h3hKG43F1Kss5cQxzawclEsGfneB/bmzz68eOIty8/bA5cGxinG/ZhykjVZL47VyB/OYGI0OjHPM8KqHPVT3G1+pNlns9BCCuanhBB6HR4VxqioIawT+QVeBF47iRKL8gjvE5NY6wcJODUWuxsspnj51/qlE/ncijNdawD+wzt3YtRjMuRLPYxv6kDUKfq1aFr/XnkQQRu3/YaCmCzMnYKFlBRUuNMoWAHNiYcpwVr09NibPmdLnV2Q9Qtb0eHiqhOFDKDgjp2FsMycPP/b5/3DC6FtPnJ7j31Tvg+GhRlblPH2Or3+PVb13nhZePEnEDqvUOcibK61+/QnP32boqj2Jlo8GxixNEPY/zLx/BubuBa1nc/6vLHL0whZpVHsoBi6KAE4sQZpL825tr2J7Pr06PI95fxeyYJMo5ark81+5X+LnTxxDrawRBgDMxwmK5gLC28vC60VKR1/z9xhe/NFIk3mwxNTpBxOrRVlTezGr8yeY9up5LVFY4ZrT5rx9JMRYkBW3iGJ9QFIKtxUMaiOHGfT5z5uIho66JCpOOh3Og5qJud5lwHDRZx/YGnzd689QiPu8IV3EOzCNNiFGQC4hKmfHoaXBbiPEM1aDNjttm2Zmn7dXwIhVCLQKBBpJEiI/rLKFLx4FvPP2FhMKHt/joJ4nZqSJXvnGHhCKh5WL4YcjyvR2EI7mH/FS3a/Pd95aJxjTCMGQ3eP8JEI9quK6P7T7b6L84WWIEgWQ8wkeOvIB5d43K6i5eRGE8GWNlvYZQTLE7UWA4GqM4lKW922RLFtFOjfHV3cOexF+ubTOaijM7UqTquNzd3H0oSfD9Ro1rusaJM7O0fZ+77V38MOQPFI/Pnj9NxnaxFJlv2gYrj/DpfyebI3b7Jm3P493tbVRNIz0yyp/3TXbMB/wfdB0bNjTkYYM/87r8b05dQrl3Bc/oohVGCOfOk1u8QtToMT57DimEHUFEE0RSgogiiMiSzvFYhjsHAqUPUFJU7ANKew/gOn12YnHGAh/bag2EmNKjvGlv4YUe3iNcY0TU+HLqOHJ3iyg2M/42jp5mobeG69t4iVG+0bzz2BY8LkcJvTbb/cOFS+pzBLF+Ujh6aoy3/vwKmXQMKaLgAfNX1/GLGr4X8Nard9F0BUWV6V19crwnElEQxUH/gSdBlkUuHR8mGsALv/YS1lv36Fba2IJIMRXl2uvznPzNFyj+/CXs+U36rs9uOs5dVaLdHAi8/fHCDkfKJYrTGm+1+mzMD+iVf9uxGDs7gSwI3G51CJbW+PTJk5Q8F0eUeMNxuVNvAXChkGV8dYlmt8tbQCSqo8XjXM1lae7loXdcm/c6DpdHZrg0eRxr7T5qJE752FlubixwtDhExPewVB0v9NF9BVUSCIQYEVHF2pOViMoa0iPUoBN6NNw+yeQQ1cYSoiAhpya4Kazi+PvPNi0XuCCegE6FIbEBYQMnnmGt9R2kxDB3nRtYwWDOfc/6En9XWsP0W4euJQml933vA5mA9z3kuSEIQgT4AaAxsNl/Gobhf/u04z9URj2pq+w2DR4tQxkbeTyv2ugPBkli+XGBL4BSOsbFXIag2kOMyxhJjdeWt/GeUqB0YaJIbrlKvdFn7PQ463e2iLsOPdcjsF0SokA6GiFreXzfc/jOVoV0VGNyIkPL9Vje3Dr0EsfTCY7HBgvT5WabhnF4AEY3RFqjNq8/IurVcR3+4zPkd0cc51B/SMe2qS4vcf7kab5mPrkh7uvdCotaj1859xEyCLQFAf3266SjKS6OzpGWdbThI8S2FiAM6Fs9gkQWu9fgNzz4V5EE69bhvrF3jA5nEjmM7uFtdFsW+U73HmNagZn4OEbocsNafqyMW0DgUnyaT0QnyHY2sOQksqjgWg1Ep0MummOrv07UrPPL+RfpuG2avs31/jpO4BKGISECu+4UJxODRhBdr3ao0cZPG1FNZbtjYXQOv/+R/H5uvm262Obj1KGqyrx8fBilaxN6PkI2xrtLu7Q6h43/R0+OEN5YI35siOrb81g315CiGkbHRHU9xsppdhtd/ru1bSZyKWKKxEK9S2+vzmIoHeNEJkFIyPVah1pnfww5ns/V2mGhtK9tPzlt+IgsYHf3x4hlmFiGydEjeQ4SYkEY8t9tLPBCpsgXPvJ5plWVWzffZqQ4QiaaQhs5hmi0sDtVOo6FEEsTtOt8OTbBHxmDAsCOa2DpRegevpdlReYbXpNj+Qns0KcmvYp1oLBtVJnho+pLaI0VIvIUntfD8buoxqC6WXYDPpP4ImvOMivOwsN9qyQNI0slIMD11ngeZuVHSL/YwGfCMOztCdC9JgjC18IwfPNJB3+ojLrj+agRGcc6PCkD5YMFHBRZ4iOpFJuv7yvhKZrMSxfHeG3xyZVgo6JIs9EfdJixPMxWn2QhTqwn03VddMvjVCKJ7wt82obqyBDf2Nyi0X88kPiJoSIzWw3at9YRRZEvz4zwei7C3T2P5m8LX3i8FYQoirjPaMZbsfv8jzsDcui3EmXG41mm+z1yO9fouhZyaZzY+CnshXeIFSfwCmNEtu4z51j8H0++zP9ld4H2AX31VbPDYmGc6SDA7DeRJQUxN8EfbjTJZGHdrrJuP70w6WJ8iiNGl4jQwLOayEAxNkIVkTDwiAoysqgyGxulb7dZtnYpiSozmVP8x+ZN+r6JruaZDAxUa1BOX5TTdPXk3+i5/jjgBQGSLD5eIfocQ/ql48O03lk59N2XPjrDN66vPdRG0jSZpGlTs1xUQnrVLvFcErfVJxFTB65d4OP5Ib80XuabO3Xaxv47fGE0z1yrS+fyfQQBvjRZ5upwlutbH1zxMnhCS0KAJ8mKh8A7zV3eae7yX6WynM+XGd9ZpXv/MmphBFEANZEnl1Uw82W0zVu8kh9mIT/Ou701/DDgrbDHJzKj2K1BP9ZIssw7ksdav8qaORh3n4/uG/S8MsIRO4nqNgmcDpIHqqgSiBE8u8lw6RxBdwWns0vGa1HUT3E7XEfRTiOZHUKnCQhE1Fks6dkibT+qPPU9qYoHF1T2/jx1sn+ojPr95SovXRhj+Y3lh17v8IkyKzuDrb8oCmgRBct03ndrM1NK07p7OHvFtT0KVoAgPHlbJPqDD8MgBEXEbBuER0tELJuw00f1AsR4BDkTZ6ziMdUL8CdG+dbK4Xz3RERjtmXQ2hrw0EEQ0Jpf54ULR7j3lGs/D2RR5HQyTVaWqakKY7qOIkmMZXKIYUg3l+MPGk+ucgu2Y3ziaJyZvbXynhTiiBJDgkzUsvCNgXdV31wkFY3TP/4ymp7ArK6Qjabw41kwevxWqsyy76IJAletLmtmhz+rrnEkluFEMU8n8HmrtYvhuzy7gyNMCzquu4sLD7uK+k6XqBKj7/ZwBRiOjyCZFdoMqBcvcJB7W1yIT/JOdxHL6WCJASk5CoT4oY/1PgvJTxr372xw/sI0K2/vS0OMnxvh7v0tZEVCVmQsw37se5quoHbtxxaD3lKVoVKSze1BmqmiyAR7CQKhKNDZbJK7NEN4Zx0FcAyb0okR6rLIRKvPrx0d419dHahAaorMnO/TWRt4u2EIraVtTp+Z5pYkPlV241HIosjJbAo5Gic/MozZajNayCMR0otofCN4REpDFPlMKs+Y5+OKEtPZAsm77yL12/iuQ6OyTiadQzp2AVcScdvrZBJ5PEHhy0KOYlxhJzC5YVbYljTOlSYQBYEbZo1qv/uUu4RxcQTP3CJIDA20kgiQXINIJI4l68iuhe32cVQVCHHNbY4mj+K7m4joCGIUBJEg6BH675/mG4bgP3/2S14QhIMyp/9iT5//IQRBkID3gFng98IwfLSZy0N8qIy6Zbm8t7TNiZcnkN2QQBFZ2WmyXelw/EiJgqbhdmz0XJSKZXPrzpO9bkWU8L3HU44ScY3RfIqtRvexAdtXpYeBpKbroecSVBeruCcKjGkjxAoJepbN2jeuPOw9+dFPneRuMs5GZ3/VHo1HcRYfp0+UZo+YptKz9nnR6IaIMfrsiZNUVP5BPI04v4RtWcRLRcZe+hilpSXc1RVcVaNlOXxyqMRfVh+/9peLRaYWb+Ps6ae/FEtQO3oCTTk82SRFo17dQAh94kkXcfkmISCJMjlCfj43xPd27uN4NnPJAldSQ3yzvc18v8n8HueeU3U+lSoyFo1zx61TdVtP/V3ynvrGdn+HY/ER/N4mXc8kGikiRdJsG1vMJMaxpAhNa/93+aFHRlSIyzEEv89ds8myqDIRbeAGFqr0ZBmEnwb6HZMbd1Y5dmkM0QckgYXlHaZmh4ggEtge0VKCG9eX2d3Yj1uI4v+fvf+MsSw/0zvB3/HXexf3hrfpbbmsIqvoXbNbao1MS9PSNmYBDXYHuwuswy6wiwXm22A/7AA7IwykkZuRRq2W2rDZzSa7aYrFKpbJqvQmMsP76705/uyHG5WRkRlpiiw2KXAfIFGVkTfOPfee/3nP+3/f530eEe+RNSopEtFkiGRAeRDUu10dZtNAiWJx6OK1/uEac28cw+n2mTg5xsqPb1PenxwdcTzOFFLc2KmSjPih9HivRKy2iYX81FrP9ueNqCp/PxlFWl7FuKsz9vJ58vEYlcVFXFlhEItzPJPiHgdB8HdjOWJLt7EsEx+QPnGB4L5OC4DjOFj6ALHXgp37eHYbHJtocigF0rRb5Ac1Tudn+ANjgzc76wgIzPpTnNdSdHG4OigyeESFVNw/fstqkNDiDIwWihRBQEaKjGB2VkGN0LAPErWIEMQ1Vxi4DUQhiOe5eN4AUXw23fQTEGurnue98LQXeJ7nAOcEQYgBfywIwinP824d9dpfWlCXRIEXz0wgWi4oInv1DpvbdTodg/evbxKLB1BUmVqlw+R4El9VZ6dYIp+OYJU6LEynmf7cCd6+tgaPSPGuVBp8YTbD7o3hxfEFVM4cHyWm+YgFIyiTBd6pN/ho5YDX/tPtCl99eZbB4i6b6xVOvDKP6FfYMtr4cjF21kt41zYOmQk3l4ucP5lju90lFw5yLBJCUhW0ZIR+93Bt2w360VvNp34nk6Ew55UAkudxz7O52Rpugb8WiWNdu/WAEdMplkjGo9zY3qaPgDnow6DPgizzU81H3TgoCYVVjZlOHf0hQwyj1yFdrXI7nmC+GaBAGgGwBBFSOeTMKM7mbRAERMWHGQgjl7eJpsY4Gy8gWjqmohJD4n1Zo71fkjkbTvJVPAblFbySxzfyQW6GIlwZHHD6H0Zd9IgjoFtdlgdlRiJjCEqAd7BpeTqOL4Ioy5jt8lChcR+CINLzHPr2AEsc5viGa2K5+zxj+elGy79oBEI+Xrx0AkGEWqPNyp1tPvjJXZK5KJ4HE5MZ2osVnKBGUNPolUp8+XNnuXV/m+sfDLPoQc9AfmgAKT+VYqwQJxrxM6KbnPvGOf7wx3fo9Uyu7DR56YVp2vd2qQcjTHztLHVRIBYPcv+vbtDaqYNvmDX2dmrMnSxQT4Q5mY6RS0XoNru4DyVBXjhA74iA7ldkLiUSxByXtiTybqPBV5Ix7Ou3sD7egpbLVDY3WPb7qfd13H6RmbBHJhGgrPeZDIRJ723Rtw4C7q2tFT6TSuOIAkq3haz66EsyftWHqyh4losvnMI2+oQcOBbI0BF9NLsDXg0X+EF/nW9GZhmpFTH0IpKkcCI5yR/bhxOchtAjJPpo61u4vhEi0RHagp9uOErVLpH1h6gOVnAf0krvo+PJCpjgegffifdMQ5tfjEyA53lNQRDeBL4G/GoFdb9PZeOdgzJLbjrNxFiCUqXNCyfG6O92sAcWx06NE4r6uPO9u4znYnR3mrgutMtdCi9PcG46x4+vrR86dl+3uB93mDs/Tm+9xslTY0Q8geUfLdLfl+O99Po83XySe7vDDCbgV7nS6eIfTxBSJH5/t0yt2adbEJn2TP5BOEzzIdlZX9jPrm2hmQ6fy2cZ223RvLuM6lOZfeUkS50+zfqQmeOLhljzydiNJz+7X4wmeXmvRWd3+Fk+E4syPl/gz+slUrr5YCoVQFEUvHKVlKyw/NDgh1WrMjEzfSioJzSNcLfGrBvDL5lYksg2DoNel+9HA+jRKJokk6xVCPmCCJKGIynYsoaXLFDttzG6DSb9YRSzj7d5G4ehNvxMfo5z4RRvNXYQEXhd1egXD9xejXaJk+oEVS3DSTmOz3FpSwLvD7bougPe6qzxzcQ8/l4Fw9LZtDvcdZt81F3jfGiSUdHPQO9SiC6w21pkmMoJSMECH7XuYXk2a1afc4ECsuciC31cwaUhPH1q+BcNq2+xul9uiY9EuPCZYwRkhdZOC0EQOD4/yp3dLpor0todZrD3v3+P/Jkc7fkR1u4Pk42Prq1x8SvncEpt5iZTeI0+995dQddtfGGNf/CbZ/nnf3GdvmFxq6MTmcnR9Dy++9NVdN3iv/rm6UMG16Ikoqsyx5MR5J0qrft3cMfSXDg1zc17GxgDEy3kZy/kR68cLi/4FZnfjSWwrt/HtmzCssQ/PDmH6jp099emJMso+gCj2yMWDFLdfxCb9SpTuVnKep8RRcNn6Mz7QmiOjSFKbOk6u5Eknm0wrw+Qui0CEwtg9BECUVyfRG/QJSqqCM0qg2Yfr9cg7gvwQuIiy742+XoZXW8C4DgWbnmZ3525RFgQ8fAoyx3WjEXi8ZeJ9Hr0zSqGYFMPqLQGi6SJgm+WqNWhYe8BHrISZ9VaZ8qvo3mTCMjYdhEkCZ0NngaPT69RKghCGrD2A7of+BLw3zzp9b+0oG72DtfFi6sVpj8zxUgyzMZP1x7UEqs7DT7/N8+hqjIYDof8bj1oLlfJ5aK0OFxKuL9XZ12RmJyOM+eT2bi88SCgA+y8v8aLXz/BVq3FFyZGcNarCG2dYxcmabb6FPwu/VSc7zoVVpst7i+kmJ0dwWv0CIb8dGQBo9thfiLL6Xu7NJsDbEWhMzB5981rHPvyeQa1Jo4A9/H48AmMARiKc10woLN7kFn0my2mymGiAQ3zEfVJ27LwgkEM/XA2JUcilK3D38PAtllIZRhc/wBPc5CBuWCYleksH7aLiNEcU7IfO5Ig2G7RWr2BVtshGQ4jGgaS5kdWFKRwkkaveejYTn2XqdgZ3gKiqp/AoPMYcylquvyWlKJaHNIOMwj87dxJlsQ+hmvx590l0kqEiBZiVd+h6/T5cvQ42U4V2xk+cDuBDNHEKUp6hS4el9tLwyap5KMgB/E7FmFEROU8ulbkbvtbT/yu/zrgPbSwG3ttLnz+GG/9/gH/o56LkS8k2bxxYPRhGTaDlk42G3sQ1Nv1Hn95fYPXX5rBMB3WPzhIgvSOQe/GNn/rCydoL+7idz3Gc1F6fYP8dJqi7fD9xRJfPD+NtV1Fi2o4PpV+SCO2UyfbN/GFAyxuVxntDJj/7FkWKw02PYEP1g/3owBeTSQwr91/wLpybIfezftMfe4FPhYSdhwHW9WQROnQ7IIajlK0h5l503U4HUnRX7qNy7DjtxCOctOxicZzRLQAScukVdkjFYsT7DVRJRdCSYROnX4ojFUefj+u3idqOcwoUfTBYev4meQMkdIGLWkoHzwXKDCT+QYr9n3WfF0igRA1e5NRxpnogmPtUhFKpCLHSYRG2LG32XF2qVklJHcK0fUhOTKyepa+sklPP8r58NF18Kll6iPAv96vq4vAH3ie92dPevEvLah7RzgbibYHlvNYc6i61yI9EsNrHWSgkXSIVruPY7sEAn4ujsXxIQw537tVbMfFtBxW9+p8IZ2gUzqceQiCgDCw+OxEltq7y7iux9mzE+x+6wr+RIj6QMf1XH7r0hy/b+7wR0tr/O8vzBF8f5XSZoVoPsHf+fLLtDs61dUyUq3NVCzIpqbSNEyKxQb/rvF0uzgY1tXlGQWl1eFRHo1TbZBfyHFbgBeiUQat4WfwPI9qPkej34F9CqOiqpQLeXbKh2/IC6Eg290muVQGu7M/ih4M4wTCWINdEq7Hrc07nFVDGI1hg7FfLxOaPEZz0KYnK6wKEtroHPriAYNKFEV6vhC9fa5w3zYx/Yfbo5VukBP5LCvVg11iKjTC5MBgznWpOANOB8f5kVfnRm9YoglLQfKWjfEQ/bHTLyPLCn/eXcJ6iK742cgscn+XjhZHUaPYZpcQfYLyYanmXyb8QR+9Sv9BvwbAlQQ800GWJez9skd2PsvGapHZz83x4qsLOK7L0r1dah7U6l0mZfmxJrug2/jKbXZ2m4zNZln/9lV8YR+GLBJWZKx8nMZIkkRPp7pXYfbCDKfm8+y8eYNgz0A0bXyJIBvNLo1ikz/cPrrBHN7wiKfcQzRaAM91qZsW/liUQXOo5LhnOkzOz7C3L9mhqAq1iQIbzWH/a0FSqYgm0XAMu9McyvpGEyjBCO3Vm/SMAeb+OqyrKnIkRaO7hawlIDhOo197YP4pBaOU7C4NwWBa8T+YLFUVP1FDH64hCRKhOZKmgrzVIKj4aUfTXBHvMPD6ZEwfjjVMHjzPodK6hewUuME1THfAueArCL17uDKIcgrPrSAZDpKYA54sSzJslH5q7JcbwPnnff0vLajLqkQ+G0NwPBDAFjzwSQhHNDg3VirMf3YaudTDMW0iI1HEqI+7VzZYeGMWx/HY+uEGdZ+AP6jxxRfG+MHq9tC9yHGpih6RbJTmQ5oYWjJIw3HwGRZN18MX0BD3Xdv1eo9EKkC53UfYqpMc89M3LMq7VQIRjZHPnSTrCNz/X35CZDqD1NHJxSPs1luM5OM0DRP7CdruR6FvWdiR2GM/l+IRSobOXV1HnCxwyh5Bc1zqPpX/d71EYSTDqcIIkuOyrEj8uPr4biCEx8r2JvVYgsL8STzPY7fbpN5tcCmc5ZQaZSyUQrMfJkR69LotPF+UyOwpGkaHfzGo87o/QFLVEIGmILAjwL39errh2tyXNI5pgQcDSYqs0ldkjP2BEVGUmVcS+KpraFoQweqRdiXceIENo4qHR0wOIFqPc+1lS8cv+bDsg6Z0QpSYCE8Rs/vYgxKa6CPqG6EtXwD+/XN//582FFUmP5oGQNIk1KB6KIlZur7FF3/nZRAEGsUWyckEnf6A4y/P0FyrU7m1jSiLnDs9xl1VZGmzxmc/cww4MNyQZJFgKsROpU1hKk3t9rB/pHd0ovkYm+U2hbkcnWIT3fI4/hsvwN0d9j5Ywim10DwPKeJDNpyhLov09ADUlkQCkvRAThiGidEd3aQ6VuDU6Aiq47KkqvxQFBiPxpEclzVJ5q/aB8Ev4Lrc3lolm8yQyuVxEdhp1ogaBtl4hkytSEcUsV0Xo1bGiCRRR+bpjU2y3djCr7uokQSWKLLr6mzLLrf6Jc6kphH27uHhockBFM9l0zNJyCFG7DBScwdBUogrDmFngJU+yQ3hDpKp82jEEfcZMaY7IIwPzXcBadDH01uIQgglMIcpd4GrT/3O3Of0yv208UsL6oGwD8Fy0Zs6ik9m9uVxlLEIRt9k987eIa56ejbNX7x5l5F8lJe/fhypb+N0DT7z9dMEsmHe/oPLWLoNPoVBz6Dy4RbHT6e5uU/V+vaNNf7LL55A/NF9jK6OGNIwcmHu9/sckxRSuRiFsSQR26UhlRBEgY/vQUe38Ml+4ppGf7lGudUjrqmUViq4PZ3OWpn4mXFaV1aIJILojksgFmRFejZ3MeRTGQ0F2PXp3FZFTqXi9KvDB48WCLCTT1KvDW+IdxrVA/ej/ZhXHgyesaxgxXaZCIZoNOs0mnXEsIUkisxGzhK4fZmOvUggN0W83cBU/XTNAemRKfRGBRyTW/c+xNfvEJ85wWJ2nERlG3PQQQslWI+nufWQvdh36tt04yPMiyKi57GEgOfWiO/bFCf8aYLdGo7nYXo2rmtDr85sKElYDtK2u1TtNo5vEszD1DRDDdDVDwd7TQoQc8yhcqMcQvIc6HY4ljrzzO/+FwlBENCbOrIqMXZihNHTBSLv3qddGT6Q9K7B3cUtfAU/xy7kGdQGpCMZ3K7Bytbw+ru2y9bVLWa/eZbdUpv3S00ufPE4pSsbiIoEER/yTIr2X+0xd3KUvudRWy1j9Q78gsIhjd5ihX7PoLG0h7hWwrFsRk+P07+6gi/iRzcskuMpLh9hfgFD3+CJRIRd12H21Bydm/fxXBdBEAifmOXPW03qusG7T/k+rPGDnfeGAFnNR6lWpsRQbfSFYIxOpUhf8BAsm7ysUnUc0v4AfctgUN1jqbdFMj9PKZ6gXdtElnyY+Wl+ZO5heQ7/sb/JG/lZEo5HTVZY9yQqpRJz/gnkahnXsfB8QRy7BlaP0fgo7wsdbDUA+mEqsK2F6NvDXbFPiiHpFQQHZFLgOtDrEkl+EfgnT10Hv3YqjUbPJJ6PIhVihKN+SotVQh2D1Y0qr/7WOTbuF+k1dcL5CEulOpblsLlRJxbwoRV79Ns63a7B6bOjjERDbJotEmE/AVmmZ9kEpYOPZlg2//27t3jpVJ4kIj3b4V6jzV6pw5deO01vvUH5zfsEZ3JMn5+mVm+zWWkCoI4nKbbLJIN+1IgfWj1Ey8Wwbfw+Fc+D9aVdRk5PEs1GqIU1Nnpt3i89nSv9ej7DXLuPtVpCroWonlZ5dzLFsYkcoudxX4b364/XNj8prjcbnJycI7e9Rr/VRPMFCc+for52F3M/o75a3mImXWBs7gwYHaxul4HeoaSEqFeG4kfZapH/yS8TDkUoxDMsG112H/GL9IAfN/b48UM/a/m7/GZmFre6RtATcWUFJxCl/9CNpEga5j7TY+AY3BNsjvkSGHodEPAFUly2W7iPkMT6goBn94lJPgTXxAUEOYTdf7bV2C8SoiQy/cI4Pr/K1p0iRt9g4eIMnuiys1QikA1x4+oqkWiAbqxFp9ihMJ+lemOXSDyA6pNRZBnTtFDs4WzFlVvbbKeCnH1hHNewqZs2ZmfA3ESGzR/cJaJI5KYyWJ7L4mYNURJpWC7+sJ+ALNLbaxD1q5idAbXtOoGLs/gCGkI6zI8aLW5vPr5ex+IhPh/142wUsSwR5kdxL53F7fXpyvKDgP5J8H67xsLcMRLrqwy6bSZiKeREiuXtZWzbZpAb5cTYDHlNo1kv07R0WtEQ7cYm7aX36R0/x1Zogo5rsaSvPfDF7bkG3+kcyDBfCo1zJpRCcUU8UULUQgww8fZfPzRlMdkUq0z609j7w0qKP8WG1MDe7wFYggeOhUQYPubbywEYPP3e9BB+/QS9PMdl6fIWoagP0XQZdE2O5yP0mn2+/wcfMf+FOTYbbRo31w898aKyzMZ28+AHkkiv0uXYdIbaeo2+6xCJ+RkdSfLuZvGBLIDjuLx773AQmh9Jcu8n90gKkJrJEMjH8PsUxIk4vnf6hGdzXOv38ZcdyoU+5sQo0l4DR5XodfpEcwn0Th+9M2BvqwpTCf6XSpHdzpP5vZos8ZWpAi/tNajs1ij2ddxuH1Wvk35hmnuuxRlH4rThMhrN8mO9xclAmDHLxRUE7okul5tPttKaDIZ4VfMTsGwamsL3203+bbHIQjLHbH6CaqxHRjSYaByUamKhGJLjUTIG/M+yzVc0iVq19mBhA3i9DsnICHd7dVaOeuMn4L2dEGZhlTOZAshx0kIUY+vygzRGkDWa/gDOwOVEcIy84MfA5X3RoRDN4+Jxe1CifATf/XJ7lbngKClRBtfERsByTSJy6hOc4acPo29SWq1R3xxme5F0iOu3lhiZSVMadNn90bCMcuLkODsfDB+agXKbYDKIoDukU2H2lssomszkaAL/Ron+wKJc7fFX1WHgUhSJjAd7Ow2SuQjpyRSS40EigNIeEJzK8KPrm7x6fAS51kEZDaOX2mjRAL2ezvbVNbKfOcEPm10+OiKgRwMa/2gyg371Hk3LodHQ6bzfovDaWfYEiczA5KuhKLWUTMKwkB2Xkiry40od0zlc0Jj2h3lVCuDbX5N/1KszNppnUp5E9ofZuPounueiqRo+QWS7VsOaPsYVY512p0HowbX3wBhw2d5+7HwfxbvdTba1BNPJIOHQKMbOFez9sp6ghWhrIgveWXyuRD2gIvhHcD2HLWebhnEQsNeMRc5pE2DJIKogSOBayEL6mefwa1d+Efc9GP0BjWZ9uPi1gIrreLiOh9U1qB9hBiA4h/c025s1Fs6N0tioY/QtBL9I6liOmz9a5ORcmuubT9ZRyfk1WpVd/IUEMUVh8d0lHNth4uUZRr94irVyi7QsUA0M6GLzZ8U9Xn9pkpqgMvXVc2wsbmPJPmL5GOqL0/yzjXUqTzHh8CsyfzedYrLcxfhoiYQskcrGud3toVsWF/HRWC/RqzboM1Tv+X++8TJ3rlyj3x8gAReiEcJzeX7YePxGnAyG+O2BSe/ekAmQFAT+VydO8M/cFout1lA9sgxn5xwWglH0XovZ7ATpUgmrtYZTq/BK2I9vcu5QQAcgnmbLOPywmg7EyMoaK3qHsnm05owsiKiiytXBFpfddbzQKSYTYwQ9AQ/oKyo1z+b/FrpIeNChL0ts9PaYDsR43+6SkwNc8GWpaQmu9TYPNUo3ByWWg6OE7T6O1SUgqYSVMJb1+EDNXy8EXOtgVxFMBDAHFpu3dwnPPjQY9dBSLq3VuPSNM+y9u4a1PyEayoZZu73D2ZkR3r11mOufToXQd5qoPgVBlbnz5iKe4zF6apTjXzvDRze3iIZ9vHVzmxePjeAdTyJoRZqdAaZpEx1PcTmq8s6dx6l5o/EQv5WJol65j7VXIxfQCBci7Bg6M1s1Os06vU6PsUKWNwSP69UaXctiVJH5u+eO8W/2DoLidCTE11s9elvDVCAtCPyjEyf4p/0GNx2bVz2XVxQVSRA4H0vjrAztIF1dZyEe43L7QK5AFCUaigg2SILIrJYiIMrcN+r0nMM0A1mQ6Homb5tv4vICyWQGzRVxBREllCdt2sQ6CSxVpmoW8RKj1GkyKY4RVkNsmiuAx7axihUaA30PAQnZi4ASxDGf7d3wa1d+QRQZPzWC6HkoIoydGKHXGjCSCGMLwy3sUXA06dCovz/sZ+RUnuR0iky1S9Uyubteotc1yMw//Wlq4iHJIvlYkNIHB02ofrVD2HORtirIfYMvHs/zbtxhpdHi+7vDBRvWVC4eS+F34RoO1+/ew3afPkP2WiZJ76NlzKmh4YZtO0jFOoVsjBW65JDYrh4EpEDQj3pjiaQrfFxGR2+1OdZN8xNRfGCd9zFe1fyYa5vMj43j9zwMUWRrY4NLM1P8sHbwELjba/DyxBSxtWXSAwOrVUcJRVnHpt+oYKXyhEam6BXX8TyPYDzN1VCAbmvIu1dFid+N5klWtjH7HT4TTbEUK/AnzZ1D5/NSOM0lSSLfc7G1FGt+kW8Plvisf4K47WGLEPbFEIp3CTgiptVHBmYyc6z09/jPUwvcqVzD81ySosJE/AQ/7K/zcmCMiOdhCgK39TKZ6DGySg+fEqRtNhh0P5lT06cNLaAQzYZRfDL52QzmwCKTi+NK0HrI/GRgmag+BVO3kFUJBIHTf/MsSALR9Sq7axW275cpvDTx2Hv0+yZK2MdINEDpg4Ps3Wn26byzhFpuczrqp7WQ491bO3x3UGUmE2M6kcQT4Hazw96do2m2L8VCNO5ukt3XXLL6BoFGj9l0BKvbx9nPxPOaQvvGPQr5FPcsC9uyCa3tMJ2Nsdoa9kReCfiwSqssFCbwOR66JLC9vsHL8xP8uF3hw3adC9MLnOp2sO/dAs9DicS42m8x59pMZ8Yo91oosoY9Psd7xjZxOcDfEHMouxs4tsWLyRE+CMa5pg8D7QvBAmcsGW3QoTCYpxru05Y8ArZIUhtHrK1ht3bxcBGBsZEL2K06Ic+g5pSIyWEmkl/BtDsoLpjOLnL8DJLh4Xkujl3He0S18VF4gPM8Aj+/APzSgrogC0TzYVzdYeZ0nmaxzd5KlUatR2Y6QTwbhpuP/97NlSIXPzNN8dYe41NpxJ7J4tsr7N0pEstHEWdj9LoGggDOMzr6t/ZqfPXiFM7egXxvMB4A26V8Z4fYeIKd9oC9m9u8+NI0q0LrQALYMHlz7+lqio8iYrk4jsNmscbp2QLd+1s4jovfg7AYpiUPm2yFbIaoquKPhXFvLaEFlEPHETs9gjGV5iPuSRHX4+JIAfvuIp5to4gil06cYDoa57hp0tI0ftDrUqHPv+nt8dvHT3F6ZZNBOsuSa9Kyh8dr1op8OxdndvYEiidwzeqx3jrIvr4YyRLauEvfsYba6PUic4bONwuTBCwTWxBYc20+Zw7oV3bZAtKhEtNaiE46xV90h6JisiDx9x2PlCDjPsR4kVolZjJziI2NB5zvqD9B1lN5Of0Gm837VPp7aMBFX4IfNO4wrsX4nOwHBJxg4RNdl08boiySmUtj9ywsw2FvuUy91ObS75znL//iQLLj7rUNXnn9BK21OpNzI9SWK9QWS5S36oyeLdDv7k/IHrGOm60BwnwOage7p0hQwzQtmittYtNJtu6XSCkK0YifFi4r5SYrNJ95/gHTotXs4p2ZhO0KeB5mTyc5kqAXDxFpw8xIlrRPoaTIh4zHjVaH3HiWVYZBPQJcSBUw7yziOQ5pWeH4iZMsKDGmg/CuZ/LPuzX+60QeOZHCEkU2LZOOaXDZMgnNzFPLH6cuulw3tjBdm99Qx3BXb2MwXENmeYPfmHqB6WAQVfGRadVpNVboA65XJdmJcz/nscsmr+ugWgbyg/6MgL/Toi/ZqKKEpsTI+KaJGQnKKJS7dxCNLax4FNQ84qCJJ0s46rPt7I5gbf+14JdXU/c8NhZLqKJEc6uFKAqc/tICu9t1mu0BpaUaPr+C/ogkabut89b1DV59ZZqCP8jyT9cQVYmR2TR7yxXGcmEUVSY7l+HqI5Khj6I7MHmn0eTvzY+gN/u4koClSLSLLfyZMI2HSym1LuGMRnvw9MaQIMBoNIwgCOy0Og/00wEMRUITBPrdAeuhAOPn5hA7PcyZPFumScMe8Mr0FMLdDcx2DzccYOzkDJvFwzVEKx6hrT/+2VLxGM7lK3j7fGK/IBC+dx89Hsa+d48g8DsLC/yP1RiDVJM/a2ySD6norcNMEyscYa3X4J57tGVXwXFQPI9TvghBy8QTBPyJPAvNGtfq24DAV/PzVGybh4syltFl0h3hxv7fRUFE8Bz6rokoKTgfc9NdGw2RgTBkzRQiE6SMHv7BDkq/Rd4zCESm2GivYep15qOjfKtxC01UiBhVbPeTuQZ92jAHFlt3ilh9C0kWOfmleXZWy7z759eZms9zrTocxLJMm7d/cJNv/oPXcLa6WJZDIKgRTgTZurLF+MsTCLrJ1hM0WH58fZN/+NoCoUoHEPCFNPaWS4TzMer78rytzSrjCyNsOkeXpMJ+lXQ4QKXTp7PvtmQqQwP3W0t7HL+4gNzuIcU0uqcnEbdLjK130e9vw6kZcj4/G6rygJHlzyRZ7R/cN9lEFPOt9/EcB0UQSdkuXL+BL/Iy2uJtfiM/yh9GNS5bOhljwCGTFknmg0GXZemg9CQLEvHBgJAcoOApKJZNPD+HvbGKpVpEBIWIP8KyP05rMPzMtt4g50yzJ2wjuh624CHvM7IEQURwdFAUJC1G3o0QaFQQ3CIRnw8lfBKsHZzmNdyMB+zi2T3wnu6y9mlOlH5S/HL2B4DZt9gttah2elTKbdaXy6wtFrlzc5uN+yWMnonPpx75u4GAQtgRWHpnjfpOC72pEx+JcuGbp4llosx+YZ67okmt/exx8WKzy0+aLYo+keVGh3K7hxbxo47FMXWLuYUCx06MEc3F0J9htJEK+vn72TyX9ga8stXj7yWzjEZCD/79g1aL6XNzHAsFSXQGlEoNNsez/H8qVX68V2ZDdPC1Brj72uuC61EUPPLJ5PAAgkBkLM8HqvvAs/NhbHa7iLEY4r4uRVTVsENBBvWDG9pYXuZSZFjX7dkm96NhtGAERdEYTRWYGJ3nbsiP+YSADkONmFNqAK1Rxu42ESyDRKNI4oGeh4fV2GNM8cEjzaKHF5zpWrRUjZajY/iCCPuepF44Q1/wqHgmoiiTQMYxOiiiguVZOGaPqO2gSEONF23/5nmrtYTnSyOLR6+bvy5Ylk2r0WVntczm/SL3Lm+wdnuHXnMwND5+CLF0GJ8tsHp5k/pOCySJyQvjnPmN08THE9TCCutbRycnpunw/laNsiSyXG7R6upIikx4NkMsGWb+zBiZ6TTtI1QgBQG+MDXC11Ufp7ebfF318fmpEQDuGjYz86NMqgqDrRply+X6WIL/fmcL1bRx9nWNmq0u4ngOdb8cE4xH2CmkKXYPHkJbrQ5SPIEoikRFGRwXJxZjsK+D1Nvd5pIS5M1+G9/UPJIkkUtkmMyOoy2c4p1u89B5u56LqviZMkFoVpFEBWV3lWC/S0jSEPCwS2uMaocH0ARPwPVsuqpAw20g+ob3gOe5uJE8DiaCpOJ09xAAQVKx7T5yp4SkjYNnY1obOH4/CM+jLSTgPeefTxu/dJXGft8kEg8z6Bq4+1ZbAOFsiNado1kesxNplt/fYHosiazKhIIqSz9eRQ2rxObTlCNBdmrPbwl2ZbPM8UKSsakUguPiH0tRurLOsZEk1ZvbCKJA9OIkF0dSvFt8csnlC5EY3lKRQiKK63lsLe7w2eMF/n2nh+t5jPr9dNsD0rkksu2i+lVW/T4au8Mgnq+KvFcrkctF8Qsim7ZF8/4yo5fO0s6FcAT4y0GXvdbRWdeu63DDc8ilU2hAV1Hp7u2ij+XRJIlpn5+AbTMdCLMtx7ivN/nzzh6/M3+cLzUG2Hvb1Ho6x9Usd7Qg28bRGeKuohCQ1AcTsL5gFBwbyzH3qWIORcskCyiygmWbVLpBRuIu27IFDyXSbw42+Fpmhs12lWwkgz+UZVlxuGUWORmIEtAlJGuAg0BfC+Ls89dFo4dPDmE5Jg1huJVu2l3+Q/0mJ4Oj/LLheC7Svnyt53gIgkAoHqTTfqTZPDPC7lKFQDzA5JlRtq/usHdzj1A6yMTnp9mrPH0d31ouMTuZYmw0jj8VJo2HWWyh39nDtW3yr8yScRx4xKHq5EiS2FqFaCSIlovT7htEl0ucHEuS0hR0yyaRSyC4LnIowHUcCqrGR3dXicVDRESJkm3RrzY5dn6BrjngimVxZ/cw1W/P9bgmWuSzKaKiRqvVoNtrIUoFzqghFMelJwf4S6PFn0rwfzzxIr71ZXp6B1lWuBCMssMBRdXFQw4ncKyhOIEvGMXdW8WLJtFsh6JgMqX4kB6afpXUMBW5DTbcdG9zMXOOcrtDXMshhTJshWTMtk3GG6qGuqKIJ6s4ZhNMAUmI4chhTGEb3byFz3cKRXgOlcZf1fKLIAj/AvgmUPY879QR//454FscjLv9ked5//Uz39g3fGvX9eg7NvFcmGDCj7vhMXNxjK1m+4ndY0kQ6HcMbEUiP5Ni8S+HF1gLqJSLLaTQsL7Y7j0/h7Y1MElpGoIi8r3lbX7j5Citd5bR0hF6eNy4vs6EkedWTKNzBDc3FvBxJhDGHxwwuF8BRSI7kWa3ZzMSDbHb6nDCk9ldWudhFnUkl2A0FWK71aXmuCQ0lZ1H3It2LIM/7jy7fv9Oq8GxhTk27iziOs7Qmf7USXqiwGcKY7TvLSIHgnRXl/mqKCHNxVk1OuRqDT5ce8gSbqnG14+f5p89puQyxJreYTcSIxEIIdsWg1CMRreB060hCsJQk8fW2QzGESWJYLeG5w9TysGVfeeaB9+70+M/dO+Q9ydRxT5b3ctYns25wDiiFGI0kiGjROjL2+xYTRTZR1L24w+NIHo6g9gsv9+5++B4pmtxtbP26CkfiV/U2gaoFZuMjKXolHtEc2E63R7J2TiX37p96HWCAJuLe3zp77/M4p/fRe/oCAL4o34++rObnHxjlsu3t576Xq2uTjrkZ7Xa4cxsltZHG2ipEJYgcO3KBomZDNGodsgc41gowEsLUfrXN3AMi2QswGAig+eTCTY7bC5u8zDfJiuPsxEV0SJBKrUmD3Ov7nT7/PERbCyAn9Sa/O7cLBuL97AUjzHXJfvKJei0qbZauJaNVyrxj8Ih+orKzWsPmfl0Grw2NsV3Ej669kH/aEmvEsuPE3M8HF8UmKTa2EFQo9TtPmF/lHg4RcBusqOOEcg32LCvA6C7Xd5x3yERzaGiUrU/YsKYZtY3QUiaRDFldNHFwiQsZJGkAIoUwAslMZz/FnDQ7euPSXochV9EFv48eJ5M/V8B/x3wPz3lNT/xPO+bn+SNrb7BsdemqKzVkRWJzLE0TdsieT7HrY3KE/0YAXZrHdKjMVbvF4mcHiMyGkUQwQuplNYq+A2TkUuZ5w7qZ0fTZGo6lbvDe/fYVAarb3G/dZhS2dmqMz6W5vYRQT0XDZEq99j64EBYSOsZTH7uGE53gCJJyEfU4/VGh+xojO1WlxuVBsdPTiNeWcTdZ7ZExnL8yHueJTQU7/qXnSavnz5BwrYpxZNka03G7t4lqBvEFk6yFdQoLt7F8zxenJ7H84G4/jg9K9xsEgpqdO3Hz3mj32LDn2S5vI4oSrj1HU7nZ/F7Nua+SbUvnOCPjS4f9Ztk/REalk6+f7SynYvHtnGgkzPjz3G6b2IM7iFqKTpKhJAkETcMZL8fQVJoeBa73V0qjXu8FMqxJ4do2o9TYJ+Bf8UvYG37QhrxkQgWNie/Nkur06Evmyy/+bhSaq3WIZQIsLNaQQjIRIJhBFmibeh02wPCzzCqWJhKkzddKpfXhpLEfQsvHWb19gETqbVVY3wyz82HHY8KaWr/8k2cffqkUGoSFgTGX5mhunYEXa/Roe4PoM8WkFtd7P1MOJhOcF188jl2TYt/4Vp87twJJFHhjBhGuXodZ2+PsekpWpMFrt6/gVAROLOwwJ1Hft8s7TI7neaafZAKLXk9CnqHtV4DURQ5mV5AbUl0RA8cKAYDfEusUotpNO0Gl+xrjxzVo24NP2NBmWa86SLZa+jCAFEOoPTbKP4IeC5GMIzXexOn1yCa+BJN70+fej0O3gHsX1Xjac/z3hIEYfLTfmPLtPlgcZNMJoJt2dx7f+nZv7SP3d0mudNjpMIatufR6epoyQA7m8NyTSgRZPuRAOrXFMaSEQamxXbtYBegyBIFR2R3vYooCKTCAZTWgIgnICsS0USIK2HyJgABAABJREFUZDJMpzPA8Dya5tEPiheiMWofHlaKMxpd4oZHz7QxbQcj+XgtLpCJsblPc7Mchz9eqfPKSwvEdRtTlfiBM2DpE1D0erbNX1TLBBWFf9zTeWttnRejcWRlgFWpIofG+ZgT6jcdepIDqgb9w81SV1Wx3KMzdctz+Z5g87XROcTKLoIkclfV2AgViMVSOILAj22Dm+3h7mK93wSgVcxyPPfsHceCFMUarJNTosiDNp1eHTOQRE4fRxZF2kadW/WDAGl29jgTzfNW5z5jvgwzWoLnufV+UWu71x3Q9QZ4psf3/ujdQ6qNj2L9/h4vvLZAIO6jeH2ApIhoUR97m/vOWbL04LXxeIBUNEC12afR7COKAmM+lb3bG8iyRDIWwOkYBMMq+ZkMwZBGq97DcFxaD5mzqLKEU2kfqg94rodVamE5LkIq8ph5hpCOUu+3+YP+gM9dmCNtOjiiyAeexc3ak4fhADq2ybfbJf7XgSzfuf4Wn/HHiGTSWI6N1WwjCAKWZSFLj4cjRdXoPtKUXNIrTI5MMtUI4LSrrJpNQudeY6tfRhfyXHNbrPd2HjvWUch7KWxjk5hYwOxtY6thgqExtMgoPX2Xtc5VZpXhLkQeSCiBKXxMgSAD//qpx/4lVV8+tZr6JUEQrgO7wP/Z87zbR71IEIR/DPxjAJ8YwnU8intPDliCAGNjSZKRAIZts7JWwTCGGcKVm1vEYn7icynkRpjNleFNoPpkAhMxSg+N2J8opCgYAvV7NZIBlTPHJyg5JrInYEhgrDTRFInJUIh+qY1t2TjZBF/72jmWf3Kf1ocbhFJhZr9ykj/bvXfoHEVBQBJFLMOiF1SQIgEkywHPw1VlWj6RQXO4KK+aBq/M5mmu7KKoCpF0lOJogsr2QWbUMy2+3dg/959DFvxYKIJ1f5WIrBJAIJ3J4lUreKUKwvgki80ma2aQLSp08gXkVv1ghFpR2YwEMTpPvjZ3ew1WRZmFXB7LdVnqFLG9T+D18gSklBhxMYiLgF+QcfcfLEa/Rr8XRpUkMA+fl4eHKgi8ET3GlGWgdz8Z1fQZ+JnWdnn76OZmPB1hbHroRL+1WqJRaXP57UV2ptK8+IU5Ft9cprw+5I+PnSlwZ7eGKApcOj2Ou9ems9bkZCFK7sVZap0e/kqPcMhHxqfSK7cx0zB/fATfRoXNjzYJZyPMf+kE372/+OAcgn6VvuVgaDI+VQbbAVnC1GRKA50dVWa6kKS9UxvKDKSjXAvJmNVhQ/QvS5/8+/XLCpFWF1FWiQdCJEMSXqmMZ3t8fvYkl4ub3A36UX1+TP3jhS+gj02wZt597Hh/1V8nFgwwFstTdgaU6k90d3siJEEmJIaRxSCSMxShcM0Og9YagubHaK3iCxw03SUxTcx6A7e3DM8owHjeL4/98mkE9SvAxL7T9TeAPwHmjnrhvu/ePwWIKpmnPsgEAV4+N0XlToXNmxU0v8ILF8e4uVGkve/M7verNKtdsqdGyJ0YoVJp0/dc3ru+AWPDrDgU0MgPoLlVR/MpDLo6uYHHiCtxZ7VENORjdiZL2XBob9UP6vhRjeqdIqIiExiJoYsC7/3Fdd64MMr3rCKiIPDZXJZs3wXTIe3z45vNUdlrDE3aBPCFVEpRFXtnGOzuNVp0oyF+96sv4i93aPQHDGyP0Ucs8T4NdBwb1ednvq8T1DT0m7eQTBMhESfq1zh54jj/etAlEfRzTbI5c/oC4U4bVxRZC6j8RffZujOGa3Oj82x54edBQPTxNf80kVadrGgR8+Xp4yAIEp7nIPoiNO0eQSGAXzrM29e0EHXP5bQLutH8VM5nH5/q2p45MUpQ8rH90fAhPnY8RyIdYeXONpqm0uz0OfvNk3TqPeqNLsvLu1SjIY7PZmnf3ENRJCKJIOPJCM69MgHBIxb2EcvH2b69gwdo8QDVe0WQRUKFGIYHH/75dc69XqDcHXAmFELqGATjIaSZHLt3t5BEEce2GXtpljfX9mh0BnhTWb50YgKv3KIhCKREGUWSsJwns6KeBtt18FSF44KGIoB54xbYNoLPR9h1mLpwiv+mWeZLp84RbrfBMqn4/Xx70CQSOTpZaNp9mvbRk8zPQl6eYM7IkjAEgnacoBymI3SHdnWqn4EkIsgauvtxo1pAUQoMOn/J8+bgP3+K87Ph5w7qnue1H/r/7wiC8E8EQUh5nvfMu11e2cGeOXpQZGw0QW2xSrM8PLwxsLj3zioLn5ni8o0NZqfThLouG++s00gEWThVYDQTY7PSIp0KY6+16Ez5OZ5PMTIQCfl0nIHN2S+epbNRpbpSZTIeRMmEsVyPTCLMxuZwy+mP+lHDPm7/4A7KWJyth2rrx8JBvhEdYSYQxN5tsXhvC9f1qNzdIfP1iwQ/O4/QGKAEVLoTCf7l4v1Dn+tUKMTi969hP0SP/MKFGX5fHmAeITv8s2K50ya8MIfw9nv4wmFESUIOBhGiUXyKzDtrq/ztc6dRq22c5jpSNM5GPsWfdLdxn+zd+3Pj7hNKMJ/3TaLt3kfHY7NXRU4uEBNVHEkDPJqqSqO1hp06RkmLonkGttlF9sXY1nzg6NjGp/tg/HnW9qOQFYlEJMLyQwbUW7f3mHlxnPOvLdDbaHP/rVW88+NE4yFy+Tid7oDatXVGX5whMq/R2W4xOpokEg+wvV4nGvUTL8Ro1XsEo366rQGhaIDOZo1Ws0cnoNJqD8iOJTiVTCJqBqW9OmurRd6rtHnpxBiFTIRep4+WT/KXgz6NzgBVlpi1Pa785YEGqLyt8OUXp/lO+dnj8UfBcl3a6Tih3QZStQ6qiiIriCM5+pJIsFTmH3g6vbWbuNksH0T8vN0arpPIz/SOT4Yq+lnop7AbK5QFkVzkNJqtEPaP0ZUtuj4Jyy4RyszjND9EkIII4XEsZ5NPUlT5RdjZPQ9+7qAuCEIOKHme5wmC8BJDKvLTi2zPgWQ0yOatw401zwPBHKrWZQJ+Vq+vEwhpTE+kuPf9+4TiAVqezdhUEifj0sFmOhpi54d30Psm/oDK6nfvkJlJoUkSrfU61PtEX5si/EoaXR3ypLu2zdZuHcUnHxrFn5rJ4tts0N7dwfCFsNsDTp8b5/rdDVzX4723bmO/Mo6uapQMg6Xbi4f45IIA6b5N4xG+e//eDgvHc9ws71vrPcOQOqKofDYcJ2q4dFWJd/pNasbh7aDrefyVNeC/OHOaEGCVyuhAf2MTORzi+PQEu9tbbG2WEcMWDPoU2k0uLoxzufdkl6ZfBGRBJmGafKzo7uGxUlskHMiwmR7B9UxGRT+T/gvUu3t4lkg7mGZDkdky61RbLSZ8GWTZ/4Dy+Gng01zbsXSY1t7j59ar9cnPptgpbnP29QW2PtpmR98hmotgGTpnX5olHwtx8y8+RFFkwh7sFNeY/ewsW1c36ZbbnPsbZ4mUW5T3msi5MJXLK/jDfizbYWw2Q7Bnol/ZpLJcRPEpnLkwzrUb6/zgvfsc+/Iprgo2d9e2HrBj5jMxBvcP16RtyybTtRAF4cgZCRiWIl9KJZlwBVxR4JZtcrfRfPDvb/brvLEwQ3CziN3tY8oSvZ1tItksZr1Jz+sx6PdgbZVLY+PcDvhomM9HEvgkKEgTuK39xqvnUmxdp65EiY28RF1sk3GCMKhR6a0ixubo+pYx3D8iwdef+z08wP4VpjT+O+BzQEoQhG3g/8XQhQrP8/4H4G8D/xtBEGyGVeDf8Z7WGXpO6KZFMOzDp8gIgkCrPcCybARFRFVl7M6w8TM+m2HjypDypfd0/Ak/23f2mHp1ks1BHbuuEy/EKC6XCYV8mF2T0p0SwWyQfmtAvzUgWcpQzQRYr7Zo7e8MgmEfL33uGO/+dJhpC6JAIR3lzs0NkIaDQUbPILjTIhoL0mr2MA2Ldl/ngydY1wkIiEeQV13XRRGe76keUhR+V47S/eA+rusynUrwxrEZvuV1eadaOjSy/WG9xt/IjVHdKUK7jec4CIDuumQLBS5f//DQsY1+j1lb5PJzncnPjrgc5Lwygs/xqEsuN8y94RPvEViugYhLyBGYcAT2GndoOcPtdqiroUQTVK1hfX1Tr9CJn8Vn9XG959vx/HWu7X5HpzCVItgK4A9q6H2TbqtHPBuhttEgmg7RLXUeiHlZAwvbtEnFw1TXa6RG43iWi9HR8UyH6lIZBGjvtKiuVNFDMreubRLZrDF9okCvPWBQbJIM+eiU21gRGc/1MPsmxkaDeCpMo9phq9jkvZ3DOydZFHCPIlk/g3j9N3JZYjfXMPo6uXSCi4UMV6Ym+LfuMq7nsd5vU0/laOJht1v7WRp4ro2cTDDYPLhv+jvbvHDmJH/1KQX1hJRlwi0geC6SFEMQDu/qHMdEcF1ylg+zuUTDrWN7JmJnB3U8ge51MOQSmhwG+3kSh1/MYNHz4HnYL3//Gf/+3zGkhf1sJ/CEEky7r/Pal45z+Y9u4DguyVSI2OSQ+meaNnJ42MCQEHD2FfF8IR+t/Zsi7Nf4hpIh2LHZK3YYn8kiySK25YLtYj9smScJrG1WqY1HGJtKIlguhk/iu4Mu4y9PouoOYkil1jdp9nRUwMpLCEC/2iU8HaPV7JGYSvNB48nNRdfzaIRUxEdumtDMCHef8nsP49Vwgt7lJTzP49zMFNr6HsafvsU3F8aYn8rxb7sVBvt0M9NxuIFHqtVi5NwZ5FYbC6jGIkg+7ZCLzcdwxE++EFVRwgOsp0yhfoy5UILf8zL0tpdpO31iosxYYZ6KMnQych86xljuLE7xI7LBEeTGGpOyj10lTMXuYNsG42h87Pzp4fFnrdtcCs+QFp5vA/qLXtsPQ+8ZzL4wgVVfplHs4AuqTJ8YhYCIYij4HT+Dh+waFb+CawwojKeprtXpdk2yhRh2s4/ZHIAoPJCgMC0HKxBg5IVJBKCdCmJ2DArjCTS/wgZg9PqkQz70rs6g2iE8n6bT6tNSHr/e9yotTsyMYNxcf/AzURRoRlTc8tGBPRXwk9mp09UNzs9PIq9soy9v8dm5cfxT4/xrbRvDdbjm6MSMAfmL55FqdWxVxZgco7x5WNBZlCSM5yh1iAioooL+FGmISWWBM9UYZnuXnttBViNk8q+wW/wRAJLoYyx4ArfbRmxuIdo6o4E020IF2zVRjDCoAl3nx7ihl9C8AsIzxLqGMgHPPP1fCH7pE6VPwngixk+/f5eZF8fwLBdBFglkAux9WMLzoNQbMDKXYWBY+MMaju0ghVUGxT6SLJJOBHn7P17lxOsz9PsGa0slsjMpfBGNeDpMeamEFvbhiwfY1XUsTeHWVoVHmcQf990FAX5jfOTBzzf0HrNjCSLRACtGn+zxPCtRiXb5ccrjaCTE+UAY1XRwJZnYZ09iLu3h6ibSWIrLos2gfZi29aQSzMeiYIVcBuXeJnp7P2to9bCvLPL5F+b5fqtKRNNoGwbfr1eZyKS5s7WFoCjYePQ3N1ELOYKZDL1yGbejIIYtAqkMP/oElJuIrPI3/WlSvQ6eILITCfCtbhnDPVpO4fVojt/zhdHufkDG52EFk9x3m6jFNUr5LOSmyQx0RMfGi2SpttaxrMEw3/E8HKtPRok/GHx5NByZrsWPW4v8KmLm5Cjv/elN8lNpEuMxYCjU1Wp2EMXhQyleiNKpdPGHNWzPYebsOEs/WSG+kKHV6NFpD5g/lsMutomMx2l81CaQDdOwLIpbNd6587jO+FdOj9FsDzBkmWg8RFCV8CfD1FWRyMszfG/jgP+tKTKXRtNETRd/Msz8ZwIU724j+hV6p9P8aePJZbmsz4e1uct4IYtwewV9X+rCrjRQOx0+94UJrhgtfmo0yYc17jbKSD6Zgd1jrFVFU6RDx1Mmp7jce7qE8ku+PMf7Impfpx8Mclntcd843O447c/y2VYEb+MjBFEiGcyzZ1XpNNeQC+cQ2mUSwRn02ga6XyXqeYCH22+SCCcoO0UW9RxpdagV03c+4Hlbs7+ymfpfF3w+hbnpLLIHWkjFKvfptnVufrRBZjSG5lPYKzbJZSNsbtVZWaswkosykQpy4eXz9Iod6qUOkdEovpEw67eGi/X2vR1OX5rELHdRZInUy+MoXROx10cLauiyQKvVIzM3wWsiLDfblBqPN9w8D5ZNk5nZDJXlMobtsKV5RM+kWWk2WWm36ZYfzxZGQkE+a8hUbyw/IEEFzk/xXi6A6/rZbjU+EaOgoYiMKTIJTcPcD+iCIKDLAs7A4WUtyKRoIJVb5EdySH4NKlVGJmcRXQuz0cI6cZLf1/v0UyleiCfQul2sEY13/R5L/aN7gALw+XCOY4aL7LqU/CppUcZbvIa+X5HIShJ/a+4k/679OEc4ofh5We8hmAMcx8a2LISmwXg8yYpVI+bJfLe3iF/SkBWZcRvO95oAVHsVkuEsdqeI7DpIggiCxI7w6TWWf1GYPj5KJBZibCrLla073PtwnWQ+SigeoFFsk5lLcOXdRSbnR5iZS3LpeI5GsY0+MMhPp/nofonKPZf5z8zQ3W0jxHy88HuvsHpji+BcGiGkYQ4MUlMpZro6q5vVQ5PYy80eswsjbFcrbDS7pLJREi+O8c76LtsrB5OqggDfmBih8/4ybduhDcTycQanx7m6U2W58nQ3qZ1+HzUdJyKIWP2DHYejKRRyCU42BS62XKYSUfyJJKoXRPOrtNotuoUxrskmgUoM2TDoxKL8iTtg8IiYX16J8qoTJ2xYREIpfLsb7Da30Rk2Oz6Xm6QWDVKzhjRYn6jyGcuH19nDdS1wLWjppGNJit0dVpINauEqpwjgc7YRBxqxyDxeYx3wkF0BQZBoqzbpn4HL8mudqWuazLn5Ue6+s4ZlOmh+mVdfX6CWbDI9l2NnsUx7r8/MhQLNEGzuCxztFVuYlo2kOzRX6yiShKhKpFJB2C8jmIbNR9c2CIZ95KfTvHl3mYl4hJHRMOWtJmMTKWLpMO9/ezhGfGI6QzKf4s7u48Ftca9GMx7i2KVpQh4shU3u3l9+7HUP40IkQvWnh19Tu7HB2MtTvLn7bNrgo/hpu8Y/PDOH2+gjSSKCB0o6zqKhk02nSKztsbqzTUrTiGxWEIN+NpNBIqUaUZ+PUjzI8nuXOR4Jc2N6lH/SaRBUFAyvitt/8ir8cniE4yurmHoPC5gMxTgdS3MjEGag93EcG8dxGGm3CUgKfefwDXk+FMfYuoeZmcAPCKJIUA0TJ0DHJ7K4LwgzcAzAoIiE5I9id8sMrA57vijZ+AR4LrKoUfEHebd777Hz/FXC2UvzlO432b29ieqpKIrKq9+cY+tOieZmh2Qhxvj8CFfeXWRjqUi+kGJxqY4sDT0DYukIkl+m3hzw0QdrRBJBypsm+niUnl/CbVrkfQp1y+b2t28QTYZ49cwE71w/IBisbtVpJ4OMX5pGdD1WLJM/v7L4mATHZDKKe38P5yEGVnO3QSIfp9TsQfTpWWdTN9jMZpnu2zj7w21aJIg5kiS2U6LXqzPquvSvLyOP5FAiQTqrmxinZ7ny03cIT0/xBxGPluTRPaJRH5H9fKPtR9+8hQVk0w7BahsvlqXYK+N5Hnppg3Px4/xgX95iWotj7+3gJobiXbLsR5NDCF6AVihA01tj4LRpq338oozrGFTdGsnEFGK/iRWMYwT83LKvMPMJr7336yi9+zDm/TL33tvAMocLyhjYNOo9zr4wzXt/egvP9RBE2NtooGb8BIMqvd4wCMwWUiy/fVjro9UzOPvFOXbvldCaNkZMpt/VcWMalZUSlWYfnyaTGwkTcWxW3joIuqWVMqMXx7m3L8YkSSIT6SiyKLJRaVFsdCnuZ/LdwtPraqmQnwnVT1FT6RgHWbzjuPh+xtb4wLb5nwdVvlTI8ZXIRWr319gyBpiuy+RIlrX7w8ncrCBj9fvQ7zM9MYKzcY+qYeA7e3x4A7TanLRcfuJ5dEwTdv3I+aM3liICCwMLUz+YMJ1MFyj0BvhNkV44S1EWWK9uI9oWiiLBI0G97zrIssJ6q8r5wgKxVgWlWwHbIzcxy5hocQMBb7+OWrPb7IRGGDH7WGaXUmcbMXMK1xfCMRqYrokqKNjP2RT960Yo4sdoOTT3zaa3Vsq88PoC995ep15uAx7tco97724wMT+C67pU7ldpFg8EvFzHZeLECJUbw7JKu95j4vwY3/vpfVzX4ysvzvDRm/cx9jPadq2LuqWQTYdptAaM52M4rsfmToOV9adn2lOpCOG9Ho5PoacfXDvJsJGes8/ynVKJTn6Ev/XZc3SWt9i0LaYFAcFx6MkygdLws2nlOnI4SKXZwF+uI0oSnbV1Xr54kj96gvfnBSmNsT0srYmiRDacRat1iHdFMrEZNu0WjW4F5aHbqu/ZCLJCkyaFzAnUyi5ut4EYkYkGpoh4Vbo0WLXuk01fRKis0R3sIgZkErmT1N1dBp6B+DOaXTj/qVIaPw0osowxODySfvfmFlO/fZFEIYLnDeuPxWoLsdFh/FyWu/eGfFnBenxb1K332K20Gbs0idPUMcIScibIuw/ZbOmGjWU71DcPGGoCw4aQUe4SDfkQgZfjCVr3Szi2w9xshkXHYKX09FofwJcLeWJbbXxulzEdnEiEpW4H1/PQ/Col8dlB/Ul19YFt8+3SNlf9Qd44OU54YGGrMstBlca+jIHwUJNJE0Ta+8bOh35u2k+lqH0MSRSRbYuPK+XZRI7Q5iq24+HqXezqLiPxNN1ommIsQav7eAC50qnxSnaKzvYindQooWAcKRqlHtC4Xb5JQgsyk8my/JA/5A+69zkezTMupEmpMfRWhUZ52PVII/Bb2Tn+Y3/xVzKwx9IRGqUDlkSj1EbXTQIxP5Jv2BDu9nWq95vMXBoFz2Xn8uHvrbLXZO6VKcbPj2L1LLRUgNV6+4EuUrfceRDQBWFIKazvtDjzxQVo9GgslRFkibkTo7wldym1H5d9EAWBL07lyZQHpBSFkDnAiUdY2RfUM/zKfkP2+QLUT3b32A6HuHRsnKBhQiLGWrGE4NiwP3EsehxYl3lDBUs8D/9T5jT8Lnj79OKp5BTu0i28WgVX0/CqBlMTc1jxEX4qHCQmm3odIz1Dt/k+ViCPkBhBEAQ6PoGd7TeZLsyxp25jeQbvCleYzs2RF/L42wZbe9/H8SyiCLyYPQ+8DzxdQ/1hePwnPHz0acCybVSfjKnbxKIBAqqCazlIikjPsmk2Dy5UMKhiWgcX31MOnqKCKCCKAmpQo9EZcG+phM+v0PMH6K88Prbd7hn4EkGodhiJhQg44Nku+cks6+0qx8Nhtt456Mr3rmywcHGCTVnCesoCPJZM4L9Tolrv0NEULh4vYC4XmYpG2LVMtHPjXC3+/I7324Me//bjh6EJZ+U4r8ai9Jst6ngUVA0x6GND75EJhfAE2H1Iu6YZ9OE2ni1RbLkOzUAA3/7fs6oPq7lKK5HFVGLI3SZ0W+RPnOWfdY82BTZcmz/QO3xt/ASaoFDrNiiGHEQnzonQJABBLce6WcXe9yH18Lgz2OEO8Nscw+4cHNvDQ65tcSwxwq3+s42I/7rRrHYYLYzQqnSJpcL4/Rqu6SGIAt1ej2Z1mMF/rK/eavQIp0J0ql0EQUCURBzbYW+vxvutHpqm0Csfrpd/vPZHUmF8CHi2QzgfIx4J8O5fHUhjdWtdLn5znu8cEdRP5ZOIt3bYbA8InxhDM23s9oBCPIKZj/HTzicf6FrrdFnb/70XNInzqoxud5mIRqBag3Scfr8HgoAe8uM0bRRVZUUVnyiNsSEa5ANhjH6HiO3R7FRJxdN4OIiGg9CsY710npXWlQe/4+LxLWuH/8v0BbzVKn2zgxAv4Lomk74TOFaceHCEurWD5ercc28SF/2UDql8esj1bfyRUwzcq4+f2FPwn+zw0aeB1TubnP7ay2xc20UyPGrlJgsvT7C+WiGoKtghjW53GIwmTo9wefGgwbNRajBxNo9R7CHZw5tm4Qtz/NVHwzKEPrDoD46mO3X6BtZMmoluAmujQUu3CcYDVCttzsbCuK3HObKd9RqF0TDrpSahHffIEsyEotKpD7O0ZDKCZ7vEpkYojEQRgyL/amUF+xnqez8L7nba5OcLzFSjdGtN7JdOI/pVSveXCJ2cRdEUdm7eQlYUtLlp/lA/fJPbu4EnlmC+a7f5u7MnYHMFARElGGVZ8ti2+qSiERzPY9nsYOPyn4XzBG2buiLxo16V3n4pZsfo8s+NLkJiFL/Z45QyQ2rnFp5jIQoy/kGdLxem+Qv9/mPv73Pcxwhutj0g/hy61r8MdFt9tBMyhZk0vZpBZbPFyFQKxScjIRMI+eh3dcZP5dhY2aNV63LpjVME1zREV8SxHMbP5KkM2liWg2U9nkRsdwccOztG4+YurcHQ53TkzCjWXgvVr2A+1Gh0il0iQR/t3uE1nZMU+u0BkiwhSyLBfILAuMTEdJp/v11ka/PnG+a6Wq2TOzZFwWxQautMzE5SFl0CvT6ByTwfba8QCIXpLUzxzlPkpe8aZWZmp8huDnfokqxS9otsiiZaMEJPcOh4Fr8tjwOwJJvc0os07QEfeO8hRQoEnBDR6ib0W7iA1I5zRp3gJ2oJZz+RUI7I1Ryrj+xGH/+Hp+DXPlM3Bha3vneZL/7el9i7UwEJ1pbL9LoGJ86NMV0YY2e7gRLVuLddOcQxL5bazL+aIxbwYw0sHODNP7nGwovjNOo9bNslvDagM+U/8r3fXt3h9y4eZxANANA2Le7e3cEfULnw+hybtw4zOSRVxnjGOL8tCAgCaH6NgqhQ/GCY7aujcVbMAa++NMn3d59v3PpZ06UAo4EgvxvOkWr0GVgyV3MJlNEMdHSU/gDl9HH+v706pmNy5sIpOp7Lh+3GAz7782DP7PE/iAbnZmcYBBKk9BaN9rB0VTL7+CNxdmT4h7oP/d4twCMiivwX08f5H40ag4dq7G/rXf5Wepxwv4XnWICAF45TtBpkWn6CAT8953DK1pZFwo+ck+aPs243D/0sLocZV+PPpdL4i8aN9+7z5b9zicZGFw8obtfwhzRycymCMR+tdodyuU5jf+CtXGkwdSyH0TbxRFi6tU0w4ScRD1BvPP6wXVqvcvqzx0nvly9s4M71LRIIjE6lWb1zsBsMDMA6gi3k7dfLF+ZG6Hy0TtMcrgl5vcTkSJT7fvWBzd0ngQB8c7TAK46IrFvUp0YxRIGb5QY+WWNzJMgdo81IYo4d1+Rmb+/Q4Nxj54nHt41Vxsbi+LQCyqBM1Wx8XNFhfvI8wtoqvX1pgVeCMZIT4/xY36Tvtmgk58iVArj9oUq8KKn0NBdvb4XC9CSb9rCvNlA8Ho0Uii+JIb4HLgiCH01c2C8lPf0e/rVulALofYPNrRr3rm0e+vmtjzY5Hpri9l4Fc+PxICQIYDYG3HnvsKTAzq0i4xNJVteOFu//GK7nsbXXYPsRjq8+MHGDGvFIgKgkg+eh46LMptlb2nzC0Ya40Wnx+bk8UQeaN4YPBV/IR8W1sS2HzODTe4YHFIX/u5Zl8GfvY1kWmiTxn106w1Zjj9vlAxbBV88d45/rNb7T+9n1UQzX5v1umY96Vf7mxBSTjRhiq44VjXMrEiTneOibB01n13WR1+9zaXaeH7YPauWL/SZvJUY55gnI4SSGJLDttHA8F83U8YW1x4L6T40dvpmaxa1v4LgWmhalGE2y1T1Q8HsjPM+kbmC3nu5N+9cFz/Mob9ZZfPfwehEEgZNvTPLhO4fVw2OREB9+7/DP6nstpv7G6SODOkCt0mH76uHjJ/MxorEAY5mhasrA9bCjPgZHSDjfabV5cTqD3x1KRAP4ogFKhklnaZeTFyd5b+OTs7R+Z3KCl6+t090sYglwvr9Ar1bjh24L23Xx+TVy56f58/Yn05LZMhv8U7vL3z42T7RYwR30cDM5upLwIKADGL0ms60U7/mH4m/X3KtMRr+M1krgAR3ZpOFWwIUAB7u9RXeJF1LH8eobuK6FosVoJMIk3FVUYY6IcQbaJZ6nx/CfuvTup4KeZRKK+eg2D7aIwaiPjmFimkdnlYIggPP412caFmFZOuI3HofuEx9Yj32M7HSau/UmZy5OM9hq4LkumVSQXe3Zx6x0+1xPqPxGOoe728YG6qJLdV83XRQF5pJxBrbNduuTb29PheOccVUUy+XEeAH32z/F2m+EOo6DXGmS75s8rBFr31vnzOkxPmw8XbrkaSUYgJeDKV4cgLq5gxuLszEzz4/ae7zhCXzJURHTkxQdg9368Ga1bYvEEc+wdxs7XAhncCsmqdBBGUiPJmmYq4+9vmF3+A/uCqdSBUKCzLrTZqN7MGg0pqWY6nbRjzDk/mVC13X8IZVB9yDbjSQDNKqPB9ijlIs9z3uqkbApP752IxNJQqkQZmPoiZrOhLivHz1uv9PoEsnEOZ5MENio4akSddeh2R0QCmjE4kGiVR8dnm04E9VUPhdNEB5Y/IanUKy18DyPcDaJcX8DWTcYn4yyOuhgDgwmmyaSLDw1Q38Us0qSVwZBfMVdiCVojo3heTYnd3skYzM0RIud+vAhJ3dahCPDvNvFYUMt4xeLgPegNqJG8+x4B7vxrtvkHekqE7lp/GiUqFK2PmTGLxE2z+A1Hl+bR8Hj15z98jGWV8pcuDhBc61JvdgmkYuQmI7z4fX1J/6O63p4fhlBFPAe2u8UFrLc2n0+7aUPt8u88ZlpWotl9I5OYjxBM6GS1F3efu/2kA8uCtgrRVJjCbLx0IMBpSfV1e/Vm2z1evz2fJK96xsPntoj0RBT0Qj9D5eQfTKXZgr8Rb1M13i+zvrpcJwXN7t0izU8QSCnywRElU1JxnSGDz7BcVEeqdmbhklY/Pku94QvzGvFFr3y3pAHUN6jEE3wv5tboHTzfQwlSLBWZjyaQEzl2a7toijakUwfx/P4gWPy9ew04uAuAgJyeox35Dauefjcp7QMZ4QYAduh40l8YJUoW4eD4oySQG8/fQf1y8D9m5tc/MwJKustmqUOyUKU6EiAq+88PvmqWyZaQMV4yPUrno9S7hxtVgJwdXmPV1+bpn2/zKCjk55O40sFefNb15EVCc/zcG67FM6OoqkyxhHJ0d1yg3TAh09w0ffN2qdiYUanMty5uskXgj7KmSTfK+8+MftUJIm/FYzTef8+riQijdukLA85EkRQFdyGgWcYxMQD2WTRtJFVCcd5vjJgSNL4XEOhv3FnONVZ2ePC4DTd5i5O30Bo10kHwkhjk2zW17GiMdrWwU79rrjExbETSKUNbLOPGs2zm1HoOMNEQBMCHBeOETZFHElgV2lStof9O1kcQeh1nj/7/nXnqX8McWmbD12PVCpE8nSaRrPH8tVn+03eXtnj3OszlO9VMPoG2Zk0Dc+i/5CdXWR9wMTrk8Q9CTyPjuxxfaOE63kMDIvvLW8ymosSnghzud6mv9Xki/EkMOSVs1+ObFc6ZPPZI6dOH0XfsHg/YHLhhWnc3Sa+eID5Qpaf/PAqju1CC4RKm89fmuHbu09mwzxcVz/rqnSLNQKyzDE0rM0yqs/HRCJBudmiZRlYiozlUw4xsMKjOW72nt+M+yi8IIXplQ9fj4ikUFhbpei5rNkDzsZSOK0auUyOoqxgTi3w/hO02W/3GqzLKr89OY4H3DVLDB4RcBpTU3y2L2E2l/CAEPC1zDR/KJmHSjQmLqIgPbeY118XXMfl8o9vkc7HSc2GqZebrKwcbet399oaL3zmBO3tNp1qj8RoDCksc3d/2C4RDzBfSCKYLp4qcW+7SqPZ50fX1siPxAjngqw7Fvp+OcZ+qLk6qHaJzfkomUev23e2Snzx/BipWp8YAtlIkOXdKvVSC2jhs7ucO5Xiau3oieNz8TjGzQ18ssRxxYckydDRycXSVBod1LEsXqPFjnNwfTvxAIb+/K5eZ+QM+vaBQ1ooFEPZ3SIkuFQ1kbQWwO53SJgjVGJZboRFTP3ggdF3O7yjfkR+cpyAl2SPvQcBXUDkBe8s4vY9wEMCJrUoYm6BVfseHjo8ouP/NPzaN0ofRbXapVp9/tpvt2vwzrVVzp4ZYzYRoVHtEhVkwmGNTmcY2M+dHKV2u8pGcxgI/EGNV18s8PbKsJbuebBVecRRJ/j4RYykQ9zrPl6eiPg1FEmi3usfHtNutFgT23z9+Dhjpkjv9i5np8dYr9ap1zskNY3jjkIkkmagSdy0Byw9RdxLMR1MYFryYWzXcOfH0ZIJtP4AfypO2bPQp0dYkV0CN3VM3SCYz3IrG6b6FO2Oh/GkEoxwxDY5qPqwO0Pe/sC1uSJ6TCTSBCNxbiWDvNMtYT5F6Ktnm/ybNZ5oc3daTGA2D1sd2pUNzo9O8Hb/gG56fbDDbGQMs/Wrl60DVHYbVHafPt/g2C7vv3mLEy9Mc+rsPJ1GH90wCQU1JEnkRCLO6tvrD15/6oVxrrsu7bbOzm4TGE5nTxZSsNM8dGxfMkird1DqC/k1NFWm3u7hecPE5S9Xd3lxIsdCPEb31g4joRDyuIRe7xI3RC6IUWZjMlfcASvtw2s0LkoYA4MTwRBmsYE5liP52lmcdp98Lkk/H8aSRqnfv4UvGECeG+cPvecP6DAU7/MeksIOKH7cfhUh6GfLbtONBEh5QZRgmLfTCnf6j8tVuJ7Ntv14CSUrj6Hu7WA/lIs7Rou8MceqBI5bxQkriAMJnjNx+Pm1an82/EoG9Z8FuWwUt2zw3ls3gWED9cxnptlotIhEAkQE6UFABxj0DCj2j6R5fYw1Q2dsOk1pdbiFC4R9yFMJiksHlEpNlfmyP4fT7+EaNnIhz4dW+5CT0UuZDPb762y5AolqH9OwmbkwiWC75DoWRqlFeWMXz/O4MJOjFw6y+4QtdyegIAGa4RAczyFtVtldKSJnYygeqKcn+G/FNleqVV4+M0HQE/iw3aDxnAH9abiFztdiCQbNg7p1yzKQU2nYG+4CTNdhyezQF61DzdGfFZr7eL7jeg6+R37ccwb8UKrxYnKK0Cdg9fyqIT+ZRujBe398AxjOXrz8dy4SGwlx968OyyKsXtli/tIEH94+WI+GYdPWJCLZMO394adINkxbk9BNG02ReWM0h1Tq4bRNtHyeq4MO2/UOU6ko2e02O4tV7H07vuxCHjEUoLhdpFOI0Vrd4pX5PN1ggFL/4MG/Yuh8Nh3D19RJzY3RePcOHSAyk8dsmgxO5fl/2GucevUYNcvgWreMZXyyXPaWU+NYbpTe3vDB3eg1mEjnaFltcKBh92kATtDlTv+TNWCDBHCsx3chsuOCNKyNN4XvEcl8Htnw8exGqYD76y7o9ST4fAon5kfAcBFEEQOHO/d2H9N7HsvEWP7JQWlAkiTcYp/XT42zdXOP0fk4I68d5+bdbSQXBo7NoN4jPKo9MagvFev0kxFmX5tCcDwaOLy5cpgl89p4lvr7awz8++ezVePll6YoSv0HXPS8JVDt6BiiQC4ZxtxtULu9zckXpyl+tIKgig/MiWsrRc68MvtYUP+4BLOpePxvP/syvhubaOEAta0qdizI9m4JRVPZvWsy/8osb2SmyHUMTFEkE07xh04R/ecMdov9BhMTBY6Ho4j1GkSj3E0ncESP8+I0drdNd9BDLEzwJ9bPV+pZ0EaYd4NMi3Hk6AxbnQ3cffVHVQuye4RH5LZZY9usIQvP1yD/ZUBRZY5fmEZkeI6OZ3Pno5VhOQ7IF9IsvzsszwiCwNhUFmuxgV9QOTaRI/G5OLfeXcXQLeqtPuIR8w5X7u4wM5EiN5UAoNjRWbm7AzMarxWyNN9bPyjNbNW58MIkZbnPXDBI4+YKXkAjFw0waPWxNmrEFrKEC0mK3WGiUl3a5dyrM3zvoaC+2mrxu6+cZvrOHpppUZNEvGiQpe0iCALSvQ3+r6emsCoNWoEgkYDID57DMvFhNOwel0ciXPDNIZbLEAiyOTmNU94l3vXRN3sImRw/UDvwCViYeWmCESvBeGSSvtOk1l8ZCoAB/X11RgDPG9DiO6BJPIvbMmyUfqKP96nhVy6oP6qvfvbYKHfeWn2wCANhH6fOj3LjoewEwHtELiCXitBeb1LWVDbvFGmuN5g+nWduNM31nyyh+WROfO0YjV6dY4UUxVaXZvfxQLFTa7NTaw9NsNNR5kaSbNbb9AcmsiTi61rUbZeHn9zNeyVmjse4V9uv1+1fXdf1WLcNxkYTiLpFbCxF07a4+8iDIiCJfD6fw297eCENx3KwHBsxr/GVDYP1K5eZnB0nGgoSGUlxv1gCQUBIRagZPb7pS1D6/vsMynVkn8ZrZ2Y5NX+MO6UilixxW7BYH3SHmi9PwJNKMN/r7vF2QCUXy1I1+9iDMr+jZREHJnlHQR8/xn9QTPa6T27uHYWHbe7OaKOcrXQwe9sUBYljSppjqRPcqd5A80eppkdY7D1ZzOtXUTbgY5x5ZYH7724+qPX6giqnX5rn2k/3G6cPRYJkNobTsdnZKhFNB1l/f5PEco25Fwpc/s5tJqaTpKfTVPo6W7uNQ/MbKxtVVoBIxEcuFSaXjdARTAI9m+Yjg0z1xSIzx5MI+4lSs2/gCwdIBOP4XQiPpVirO5S2htfH51OZC0XxeQKxaJBKr8fnc3ms735EMxQiHw0Qjkeo4WJZNonpPFk1SOUH1+mVKqSScf7L187wUsDPOgY3JJ173eZzGZdfM/a4E5IZScToOQYv2nXmLIeUKeMkpnkvJrCmP//DYlyaYXrXxe7doCdmCRkCWu4ku4NFSI1zV7x/RHH8+dbX/79RegQKozEGpT6apjwI6v2OjjBwkGXxwSIWRYH8eBx9tYnngiuCT5YwVZl+R8fzQFIltu+UOPG1eQRRIDkWJxzwsVBSWN+ocLIQw5lK8N7a4w3LoE/hs4UcrXtljF6bV6eTlJIid/eqDx7YasfDDA8Du+d6iA+JIHUCEqIk4jouHdPijmkxOp/nL5wOylbpEB0tnggzIWvcfvs2IyNJ8k4Ho6ezOOjxVW+exlYVs2+wdHMJ8ew8alsnM5ZjzzG5aw84dWyW/ge30StNEpEIqiAQ3a6TkxWWVlc5rvr5QjxGMR1nJQrfMdpU9OfXUIdhHXzFHj4Q/l4wj3LrBrueyy5AY49LEzPc1FR69icbWhEReUWb4Gt2CqHXpifF2RH6NPw+0igE5j/Dj7r3WO8tPhD++k8JkUQQq2PjC/rwXB3LtNF7JkbXxh/UGPQMEvko+fE0ngvJTIS9u2XCUY1Oo48vpFHdqDP1whhjx7OMLWTZ/GgHrdLl1WOj3Ks0KFUO6uYvnBjF19RpLjcYjweYPjOG3H38mniehyhAGYdU2E+/M6DY6VMWBBYms9SKNVZLw4AeCPp4sTDC5uVVzqdjDH5ym5lkmOC1GmIizsadVULn57DqHWL5JJXRFIGRJP3FNQzXJBeLExc17O9f5cyZCbKbW3wpl2Z1dJS3FZ0fd59dJjRdmw29xku+Aplby1TNAVWA7g5jrRQzUylWzGfbyCalLK/0T6A0F7HlEXqqjB5JEpTCDKZOclX/CZb7bCrnk/DLWqE/m/zYXwPGx5Mcnxihvd1CGLjks7Gh+h9gDixU9eB5dPbkKHfeWWdkOk2v3qO90yY9EmXsdI7dlWE93DIcXMFDi/sYe3WSyEyC9/7oGt2dJoOewc79EvZyg8ls7LFzeamQYfOdVZrlzvC1N3fJdh0CmoIRVg8FcEEUmH9phhHNx7FUAlEQeKtaIXlphlg2ij/oY+T4KI3xCFdLVeSLk0QyMURJJJKJMf3qMW7/5DYeMCKr1Bd30HcbFIJBBjd3CEsavkiA0YVJ9IGJ9tJxmM2xLtv4JnIIM1kam3vkYlHUSgu1q+Ou7+FrDbgQjKLuVmneXCLa6OF+eJffViKIz2ml9ygEINc38B7JsMzdLc744p/4eG9o00xt7iDXitCuEe3pvBo5QbK0i7P8AfHNZY6Jiacewy9pvByc/sTv/YuGosm8+PnTmH0Ps+cSiUdI5mIA6B0DX0BjYn6E4nKN7FSKQVNH75rEshHGT49Q2WrQafWRgypaRGNkIcO737pBp9yl2xyw8tM1FjLxB66A+ZEo4k6bvXslBj2D2naDvXdWSY8lkaSD2z4SC3Dx9WNEfCpLlSbimQLJyTT+oEZ2NkfnWIZ2LkIkHUWURM4cm6SyVyMYD9L+aBW93Ucpd3HbAzrX15m7dIqBYRH+/AXksSx7qkggEcFQReI2+Lsm1touQqlJ1pGwS3Ua1++RKrY4fr/MmdDTr+/DGB+IWObhhGTQqjLvBp/5uyExzplaFrVSxuvUCQkRJvsR/BsrWMsfUKjYpMXsY78noBIQXyTifumpx//Y+eh5/jwLgiCMCYLwI0EQ7gqCcFsQhP/D017/KxnUfT6FmKzx/l8uEstF6Ld1Smt1UvHhoHg4FUDVZBRFolCIc2wsw+xUhupui9kXJjjzxXmyp3NUiy3cj7ezAowcz7K1VOHGjU2Mpo5jOrgPxbPqbosRf+Cx81EHziEOPEBpqcxMJsa7W0Uyr86QnkyRySf40lcuULmzR+9HK4zebfGbuVFsx+U/7m5zpeBDeHUSOeZHubbLa/VhVn97IkznpQk+zPu5V6ziuC7hSBB7n43j7PPOXU3GqnaYOTmLfnWN7pUVdn9wjW7Az/0L4/y7sMF3miUiYyMIjS6u4yCrCo5uYrsOSd150IuQ96UOpLUdpkNH+7Xbu49/Fw/DAzxRRBEP17AlUcJ8BqErpvh4IZRm3Dd8b58k4yvJ2FYPUx1aFYYTo8hrtxAdG0kNUOtVSBe3mdaO1nuJySH+tjLFTPnnF0v7tHHs3DTvf+cu/oiGMTCpF9vYpoc/5CM3lcCxHc6+vEBuLI0oS8y9Msnca5PMvDDG6oeb2JaDKIrERmPogsfS+5u4josgiQ/WZne3TSw2DGijyQi17cNsG8ty2Cm3SL82RWYqzfkXZzg1kePOT+7hvbfFF8Nxbjfa/FRzSb1xDC3ip/3+Gna5g3Rhgs6lCXZ8cK/bxueCs2+g3jNNFJ9GMBRAqnRpvneftW+/j246tM5P877ioAkSZr2DJIl4loOsyJj1NqHAcI3Jpku/1uSk/TjjbH07feR36ogikiAiPtKQdJ6Qo8SkNKPSNH4xwrQ3gVVZw1ZlBFlF8xSc0ho+T0VUfLSrd5keZBAeCpGC4CNuf5PAtoiy82SdGgC8Ifvlef48B2zg/+R53nHgFeC/EgThxJNe/CtZfhnHYfNOCb1vYuLw8teP02/qBCI+Xv3NkxQrTVKuymuvTjGo6dz483vUdtpMnMpR2WpS3mwwWmkz8foE2ZkUzb0OqfEYoVSQN791bWgtLArEchF2ewdPekEUDgX5BxAff/Ypqoxuu/QNm+8ubZGIBDh2OsvbP76FPhhu2TrNHsb763zx9WmEgUXA9jhmaVy/s0yrOaw5S7t1pi5N8d19nvqJfBBBAF03kGNR2AVREjAE2PZsLp6epHT5Lp7rIiky4kSad9+7RuKVWdqmyfvNKn/n7BzqeglJlnEch/DxSSrdDqGHaqnm/k7HsxzUIz7fsyAAXwmNMOuFiXo+dElgVbBo2gaMT3Kz/+TJzq9GRjjdamEX15EDIWq5Ub5jNJGN4bXY0atMZ6eRXRdcG1UNUvarDOweDAzGhCwrPH5TvawVsIpPNy35ZUFAYtAxaDU6XPrNU/RaOpIssXBxlLX7O7zxtZfobPe5+eYKqiYz9/IYP/mDq7z8W6d44bfPsLFSIT+eRPBJ3PxonZBPxhfU0B9iB8majLXfF3Jd77FJUxiyk76/ukchFSHq2ly/sfEgsOxd3+I3v3qGgWkS3etTrHdp1jpQ6+AbtGkdi1GShoHclQ/WTN91cJMhxFYXxxw2GP3xMEu1BmoYviPqXJgtIFcauK6HEvLjOz5JdXkdLe6nC5jqMDEQn5MQE5P85JUEM3IOp9um45dZc1tomTw3aB56rSTIXLDPE9yo4AxazEZzBHOjtFimZuxSGD0DW8PmtCT76AddDK+O2u3iS4cYOMOmf4ALCKVNvOcsyXxaPHXP8/bYF5rxPK8jCMJdoADcOer1v5JB3bZsJHU43mvbLlvLFfSOQXIkSr+rk59KMpKL4tQNdm+W8PsUXMdl7fouxz8zxe5ajfRonD/97g0URWZ0LM7d1W2EVZg8lyceEtHyMcxOD2PzgHo4diLHzepBdjOVjZMP+EmmYxiFGKWHuL/Z03m+/5BzUb3dx7el0xocvuCyC2cNhZ+8c49AMMBGcYUTFyeppmM0mh2qlTaRrs2+JhMfNBv8xtkp2ne20KN+tJAPOepnfTBAVGQmxlO4uwnUbIyuJvLTbg3b9fDvG4yYjsO/sKr83usn0Zo9upJILxGh+8Et1GgEURYJzE1ytzn8nOLECMuPaIJo0nBZGE+Z9PtcMMvc4ip3dIPjIxNE+wNOB4K8mwrwJ24L0zi6mTThj3K6XKLfGJbFTFMn1Gny4twxdJ9EtLVDu1/ljjLgfPYcmq2zIrSp2cOHhCxptIWjzytif1q30acPQfD2/yuwvljC6FmMzqZZvbnHxPERbv5oBdGDQEij1xpw56015l8ZY/X6Dm7UoZOMsl6pkAr70TIhxidS3PrhPSq14fqVZBElE6RbrJIfiRL0q5z4xmnuvL9Ko7xPbUyGKe4ziMKKwt5i6VCmOB0NY9/ewzUstlfKZOZz5F87zq2b69TrXSbI8EGvyddPTVAsNpk6PkZjcRstF+Nqp8kr56fQW22UE6OsYbPSbBBvaZQDNh/MxZlwZgm4kMyk2L29jF8SMD2X0Ok5bjTKaAEfdzXvAXPFLys4rvvYnIOAwDesHPUrbxNKj5NUk8QGOrMLL/Mf/VWK5uFG6RzH0O7dx3SGB3aqfWJmgEh0ll5vmx19han0KLQkmmGBkjOkTLqaD9M9SPpkOwzu8+0CPyH7JSUIwocP/f2fep73T496oSAIk8DHAu9H4lcyqO+sljj9jVe4/uYykXCAW9dWkWSREy9NsPzRNp7pMjKVYPt2iUBQAzziuTCtcpduvc/cxTHEkIJh2BiGzeLdA85qsdQeKjbuFTkzlmF6JIzdM5GjPtb0Ho3y8CK+Mp3Hud+gWCxRlkReeHGawvE8pVITIerjw1r9gaZ6NhbkTDzGfCxM1B+mI7rs9YaZeE7z0SoPg6YHFObyqNU+adtGNV2mTkxSVA+ynmORCLKncOriArIm4Z0aY3W7hM92KSnwrd1dImYTy7L5WI5DFAW6mvRAi/pavcq7yTyBlQp6r4+4ITL30gm2YhojzLG8tI5leIROzfFDxcbsDj9HUJb5rUiKVHMYKLxChmWzz2q4zqrePHSN5nQPc5/SdntnFVlW0KweN7KjbA6ePDh2VgnSf0Q/w3VtviQE6NsGM9I8YtBg06iwKnRRo0Fq9eEQiSzIjI9dxLSbFNRZ7godlo2DjF2XRJ5dTf3lQNd1wokgkUSIWz9ZIz0WR1UVSmtNEpkoRs9CkkWyM0k2b+9hGw7+kEZ0JMj7P73JXm14cT8m7V7bLHH+xAiTvRgATlDlw3s7nFnII+/1WPvhEvWIj4WTBSbPFKi2BmxnBW5tlxlLRDibiBNNQ5sOTc9Bd2zcRh8hFcIdGMxenMLYbSHeKTEdCFAYTbMCZH1+ZNHPqD9EKOwn/OIM14slzIDC1ZbOZvFwQP3/sfefMbal15km+Gx7vLcRJ7yPe+P6m3nTM0mKpChRVKmkUklqVHdV96BQQGOAbmB+DBozPf8aA8xggMHUoGsK6OrqGnW5VkkiRVKiE5Pp82Ze78O7E3G8d9vPjxMZ5kZck2RSKUDzJgJ5zzn77LPNt9e3vrXe9S477KXdKvEdvcA3PRL15U2E3AYTw0NMvXGOdq3CxvoGUjREfjjC+61dkqqH35DDhMpNFJ8HKRXjoUvlvp7DcCyG1Qjuh1m6OGwWN9gWJRTVjdAp80g5niANtWVs6yBBLCEj15skIlfQWi40WaLl9eDYEjl7E1lQSKjD6N5hLtgiG3IOuI4t6fQj1s/nPHwG9kvJcZzLz9pIEAQ/8J+A/8ZxnCdyhr8woy4IMH1+FNmlIgoC2ZUctWL/OC3TZnW3xLmvTBGUVGKDwb1uMQ6DYzHuv79OJVvH53VhWza+qIedrQqhTICB2QRLK7u0Ck8OKXwqxXt7q4AoCCiKhFY/0IkJ+90ouQ7FXN8Y25bN1Q+XGX9lnHcaNbTygafodStc8gXZfH+NdtjLeCqIvlYkFfeSb3dIT6dY3OhPKpoCbschfzeLJxOmUWnQLbdI/MElnNIuZxIxkktlNkpNPi0kj40neTfgsLvHW3crMr99YYL2jVUMw0SSJcJnx/lx+6jOzZ9Udrl0dpARU0KXBf5Fr0Iu20EARpJBXGkva63qkQKQ3wvGka7fpw2cHxvFffUuM4rEShyq0yP8x972Pu1Mth0O+8umaWC1TTw8nSOu4SCKIknZTcoRUYCkL4zLdMhXSnjiGdySxnR0hP9RfICgWJzxz+I2HUa8g2Q3PkY02niBlwNJlOgAD7T+9b1llvlycADtMyr/fd5weVROvTiFIArkN0uUdqos3trg1OVJoukgoaSfU1fGaFd7tGpdNh7kqew2cHtd+MMe/HEvgiggeSVK5TrlXB3CR4WHuz2D9+9souzpu5imjdutEOjZbO3JCtQbPa5+sMLky+O8u7xD2VAI+dyctV08+Kt7vHhujPbdOj6Pi1DKh2T16ErgHwzTuLFNr9bBlwhQa3cICDb++RHOPGixufqIT+t2fWE/G6ei3Mjl+HoyTTwaoL3XSyAymuSmbGE7Dmu9Bn8S9nDl5RncpsNPFJv/oXwTryyTmQ1TMLqUmztIgsDvCWF6n9wjkkozXOlhfPSAickQZyaH+VGojEuQcQ4xq2zbQuu18RhGvyn5Y7AlUJCIOTFchkhMSSM2mxi6gTc4gsvWKYd8PIzsEtVmGLIHaTa2qK6/jRuHhXAG1TdJW7iBK/YVnPLSsd94HA7gfI7FR4IgKPQN+v/qOM6fPm3bL8yoe/xuVh6V+hRFQWDuwjCqW6Gw1TdOjY8X+aTS5qWLE5RbHcSuyAW/mxs/XMQBSrkGAy+NsX5zh9BggEDMhygJOG6R0HiE63efr1zcdpxjIkfpkJ/q3eNiYEa9x+NjZj4dY/da35Ns1DpkVZnM2QzDyQCW02U9pNK8149zphMRtm5mCUa8SF4Vn+DH9Kvs5PoP4Zio0igdVW0srxVYeGVy36j3DJPvrJZYeHGUqClQU+AvW2XaxlFBMMtxuFotcfWxc3CAjdbxST7q8RDeLdGwbcYyg8gPV+l1OrgCfizFJnCzzZULY7zX6XtiOY/CqUiSIdWPohsYqkLJ7+ZP9doTrzXAh50KXx89RfLRHUKKi4AgEe52MesVFLcf49a7uNwyPZfI35+b49+oG/yVXWPWPYhr6xq6ccB/15sFToVn+VR8d1Mv8VNXjHPpz9om+POFrptcf6+/GpmYH2Bkxs3m4i73Pl7G9YaLVrNNu9WhU9Oo5JpYhsXUxSHuvrNGeiJKr6MzejqNKVgsPThZJ+ZTHG6eEY/6aO4cL71v5Zr4/W7KWJyORcjuFTfdfJhl7vIoqmETnkzQ7Wlcf/s+52aG0C0Ll9+FEnTj8UjkMcjoIvfWjuYy2rUWo1aSG8CPCjlOT0aYmE7hiAI/7bXYqh7kVgp6l7/4lK2yt8psGDoN48BAT3lDSI82UVSVYQO6K+sABCoKWi/PGxfn+a66yetDw0zUdAJ6P7/TcoksxX10reOees7T4FX3LMpOjoAaw10uI47OoO4W6G7fRvYFCeUDBM9FKXjryKtXMY2D1aZRy+JNzVBz/yVV39v4PZcRjWebzs+Lpy7022P9T8ADx3H+H8/a/gsz6r2uQUfoGzvHcXhwfZMXvjS9b9Q/xeJ6nlMvjfHok00Q+6EGT8hNq95l8VaWs29O4kt60UISkk/hnXtrNOrPx7sWBYFYxIeuW9RbB9+pdnpMRH19KYFDUPwqeuNofM8liTQOTQqlQoOdXpPB0Cjfr+dw12R+88Vxaje2MC0bUZXoRL1sml000cRo9kgIfeEw8YSSeNjr6Xj42hkmb9eOJwpVScIlyTT144kctyzzkj9KxIKaLPBhs3ykSYYiSrD3wIVECfPTakHLRmir9Nxthg5RnO/Q5Tf9Cbh3D9s0kH1+3DMTyCd4SodRNzWqPjdjsxfwFXO4QjGsehlqJXxam4Zl0GtqeD0xnOwq/2j6HKXGFpmeG7d7kA126WgHk5L7saKzba3MtvZ86py/KliHYvurD3a59MY0nzZUWHuwxdwLw7g8CtvFEt6Aqz/RLhY497Upomk//iGVna0CH3xnfb/S+CS4XDKhkJdGo0uvZ9Bo9hiKB/Zb5e1vF3bT3mpATEaBfQaUrhn7RXypsELXJRAeiOBIAi3DREgEyGFS7HXpqQ5pUTyRrSEesl73qtUjks8C4He5cETrSGw8prq5okRwWw4bssXNdgnLcXAJErZpkQhHMA/ruNs2AgKechtxQMQOhwk9XMQul3FECW8sgjwUPvE6dYUeWthPRD6L0jPBpeFYBsLqA2SPB6PdwB0IM7spoIcyiLZKLyBTaD3E2StkEwwB3GA5JerCX4H6xNtycMifH1H9VeAfAXcEQbi5995/5zjOD07a+Asz6uYJ7bn0E5pIVyptuj2D8RcyuBIeoiMhdtcrCKoILomH93eICXFuPKdn/iky0SAz3gD1jRqKx4VnMs5H2zm6mkG+2uL09DCu0kFj30g6RF6wjjVp3qi1mB6OUNo6SLBKkkjHK0K9b4C/W9rlzIUkiuJmajDE7fcf7u/H4/fQ8Mu85EmTCoYJJWrslKr7AyKUCnFHf/okJQoCXwulyFQNnIaGGY/ynthmdU+V0aso/JEao/fJKoZhMKjI/KNzk/wxJTqmiQBEJZmhuWkqgogtivtELjPgo623Ed1gShKfxlzOOW4+WL9LOOzGLXipmDr66gNevniGP+XJMXVZEGk3q9Q0k1Zhm4QkEcxv4kkNYRe3cLk9dPQekuLCK5i48rvs1FcpSh4muwITA6Pc19ukQ8OEHQVDTfCqBB/21rGeoyLxi0CnpaG4ZAzNpFps0G2vsHBlilMvj3L9J4t0Wl0kRWRjMUdHC3Djo/tHJoaTsDAzgFeDVqHFWCKK7pe5+SAL4yk8WTfdZt9hCsb9tF3inkcvs6NppOMB6odWhLIi0VLhg/UdhuNBwkNhgtYIK2s5tG7/OR2dzdDyiJwbH2Jjp0hN6zsOLo9KXj3Zes2EQrwguFFKLcxOlM2YzE/au4y4A/xmVaG2tIxt25z1eZk+P8q/b29TtnWmFhYQ6k3kYhOj3QFBQPcqWI6N7VKQRRFhN89NsUYk5cfCoW5V8GyqRMZ8VI2j1cwBx4/Za1Fdu0sgNYunmEUJJcG2kRwBUxBRBZX69kNMeRxXcQs3AgNTl3CMDrLl4JIUFG5hcFwk7CQ4fH7FR47jvMvzdv7mCzTqsnI89qrIJx93t6Nz/+EOa5slLp0aomuZOLZDu6czMBFhdfPp3Y0AEskAo6kIjuWgYxPSZW4fkvWVVktcfmOMd1b7Jftvr2Y5f2mQhCmAJLCr91jcPl7tli03GJ0cJKXKlDcr+EIePC8N8MPygZdhWBbX8/1jHA4GuHRlHLHSxR1wM5iJo2abaMU2viGd6OkJLnZ0ClqXnGSz7Ibl3eNlz4fleN8IJYlc30JwuRkKBaHQIzMY4/+ldGkbBq/6o3SuLmPtJXZNw6R1c5nXX5ziJ7U8fxAZILC4xWZzm1PBEN6hGMxO0qnWWXL6k5o/k+GvOfCQFXOvpNw4Kq3gekbvVdOxaXjcCFoL29TpGRqqrOASJXD36ZyyL8iuGzw9k95ea8iW1aXpixOqlpgbvoCycR8UFxuNTUYFh8DINH/Ve7J0wBcJj0/F1A+cmF5H45Of3ePi66fwx92oPgnTtLBFk0areaJBF0WBmYkkPlkhGvPR2WqyeLPvZRezNUIJP1NjCa7e3eT0fJq4KIEgUNY07j44METLhQqZUxkS6yrV3RqBsA/ffIqfbPW32So3+A/lBhcyCUbODiN2dOYn0rgNm+K1PJOzI0wGw3RMi12PzUOPzYfF44yQoEvltbZAZ2ub4VQCsWaT6pjoIwMMGQKVRwf3qtvuEHiww+9eGGNwtchu/j7jlkRm/hQF4zZtj8qaVEFR3GRjMrIgI/R6WI5NyTpkwLs9fKKfKkeNepEism8Yx7YwzS6GYCJ7fSCKCIKIHB6k3S0g+kNU9V2iwQBuTSDcVant3kHwhzGt+4Ti56nGdSyebW9w+EzNPz5PPNOoC4Lwr4BvAQXHcRZO+FwA/p/AbwAd4B87jnP98e0eh9uj4Paq9PYaAsycHaK0c5Tb/LgOTLejc/3RNtNzKTAdorLAymaRRuNkQa5PMTwUJWxJLL+zDsBAJkxo7mi1mGXZUOvruXhdCnOpGLIFJUwebpeO8X0P4/2VHWJBDyOXBtnRdDaub9IdPHmC2mo02aKJR1X4TV+Aws8eYW5WiGaiuHItspZFQ9MwU36MiRjXKs8udx7uOERDYVLVHo1HfTnaQDrCP/n6HP98+xFpR2ZscABZENlt1qlW6limRUi3eCEcx3N7hXanvxr4sFIioXUR3zhPtVjC09MQXCo/dnQ2tYMEZNYFC6oL/VCoR3W5eag4zxRTesvpcCGeJri9Sj2/hW9ygWK3jW/6LI3iJjuyxL1qk6+OT7DbOYgprxplUv40A5JK2aOSs5oYexS9VLVGMOCjYT6/5syvamwfrtgcmUrSrrVODKPcfO8BkwsjBFMBBAHKxSqLt072BF84PUL2+g75epdeIojXpTI0EWd7tT8+6sUWk3Nx5PEkHlGiJ8DSVpFG8+iz4Tjw1lqWVNhHJjPIek9jc33zWFjlRrbILUHg2zOjZD9cobNVZfryKHf+p7cJjETRZCgkXeTGPCcar4vBCPajAmfDUWrXVzEUC9Xr5rcyF9k0akSGhpAFiVyrTrlaQ2t1eblocnszSx0oCiJbaytMvnmFh5Uc/nCYnTC8Z21iWw69xAgUjibErYEEef24A9Syq6zFWpwZmaWz+QhleAFdlBEywxh2h3ZQxG6aGKkMvdotdhAYTb2AUdmlGfFRdwrMOl0oLuMLn6Uh//TEe3TkOvO3W/vlXwP/HPg3T/j8m8D03t8V4H/c+/9T0W31mH0pjaQoiILA7lqecq72zIPpdHRu3d165nbQl+MdSoQZToR4+P4aqiqj6ybdtk7+UYnUYIj8Y4mlRMjHnORl7d0NbMvBG3DzxotD/Hx561joBfosnrFkhJTPQ0M32CrW97Z7+mop4FLRV8oETBvDgWgkQPnjVbxxP7pu4Ggm2ZvrnLsywvsneOqHoQgCA4JCbfPgurTyVRLZFmfCMRa6AsbtDSzDZGowQWNkmKXtLA1VYsi20ToH4R3bcci3Wli5It/Vavx6IEa0q3NFUol4knzY7a9WPmgXGD0zR2R5E7cgkokNUEzHuF5/tre80m3w35sG/+1Lb5Io5LnWrtFNpSkEgtSDHhStQ1eSuBaxkCqH749DJ5ZiqblO+7GG00KvTSDs+UxGnV/R2Ha5ZS6+OoEgCZSzVTYenjwx27bD0u2nJ0JDUT/nXpnFqpsEVRW8fediZ6nI3KvjbPdVTxBEgYmhGB/95T026z1ESWDh/BBLrgbFx2LsmWiAkUCAjmmSq7efWNXo97pwtmrQMUiMxane38GxbYxqh5YKlmIxngnwyQnflQWB0WiY6tUDpoje6SHf3eHSqQxb1+9hWxYT6TjJkRE00aGWPTDSlmOz3arT3tgkNxJhjB6pBlwOZbhqbPO+t8mXp2YQcnmSvgRqPMFfBqsYvZPrI246H2HPv8hM/AVK5RzdkIk8P0nZ2sWyegyaZyhuvbe3tYNud9CUFhX7sFfuIBjic8c3/tb2KHUc5+09wvuT8NvAv3H6rsiHgiCEBUEY2KuCesp+4dG1Z3c1+kWRSgWJiy42PtkmuAC1rTrxTIhCtUmj0SXodpGQvPt1iZIk4oQUph2FlbcPjqvT7FG6tcvYRITV3NGVhCgIfHl6mObdHJViHl/Qza+dz/DzrV1az+CyKpKIrWv73dzZS5I6loMsi3QFME0L71Mmh09DMO2wB+fB0ZJwT9jPdjbHryXHuPvRbRaiQZw9LZgpO47/zRf4v9c2eNETxCsIxzxJU5b4QzmGce0B2t6xnRvyIp1K8V43j+HY/HFnm392eo7R5R2211doba7wj2cm+bdypV9Z+hRUjC7/5/x9IoqHSDzATi9Pr33US33BV+e3Js+TKlUxjC71SJgPXU1elOOItRz2oWtshuIUjeeLd36KX9XY7nV07l/95StbvX43U3OjtHa6VPIdOk0Nf8yLKYA36EZv6yiqhKFbzF0YYvXjLdr1vYpSy2H12hZTr40dMeqvjWVguUrpxhout8JXzw/xYbNC5QSFUkUSMTsGjizi8qg0mv3J37FsVLeLjm3hOiEPBnC33eQbniCHdT5FUURqa5R2i6g+D05Px9cxSfVkNl4cZvf67WP7mQtG6V69j+buj+9Rjw/XpRHeNje4ER/km+Yo2tYW2eIWC4MDtDMp7usnl/Dftq5yL6YQTsbp2Vu07Q/7vpcMQ+oYpwbP4CpX6ak22sAw+mYB0RCxHZv72gCnPBVM1/M7DV+Up/55aL9kgMOu8/bee8cgCMI/FQThE0EQPjlcqfWLIJUKMjOdJhY7udxkNB1FL/fwWCJY/SpJrdojEvZh2w5iUCUyHiU1HGFoOsnEl8b5ZCePcMJMXy+1iXvcx96fGYxRu5GlVuw/NO1Gj4331jg/lMSfPT7Y414PX0sP8huRNKe8QcIzKQqmji/qxxIFBElE8rtQIj5y3S6BiI+cZXA5leAbyTSvpVN4Xce1MX5Q3UU5lcHt96C6FLyJIIWADBE/VrFOz7JYlExSQ2nUnklnOUt7Pc9vKBFuaG2CU6NH9hcYHaTkElEWN450mmltd5hvHQyZCU8I+d4i93ObVIweutZDu3OfX1PiT7hrx1E1uqx2avROqF71tWaQqxV6ho7ojjDgH+JyzSHY7HIuukBaDgMC7nCGu14L3X6+Pq+fAX8jYzsSDzJ9dpT0cOzI+xPzQ9S2Wxhdi1DIi+IImC0DGQEhqJKajhNJBBg/nyE+FWd95XjORzhkdNNhP8JqjVK2byC1nsHqh2ucjx793XjAy1fGMlzyB5k5O4buU2jV2gRH+vdVCXsxAiq1noYn5ufX4wN8PT7AoP/gWcy12+QTXjyxIIqq4PZ7kYajaILNrtamGfUS9wag2aWxtA2bJWKzU0iSdOg4Qui2iX5IIlrvthku2rhEhYWKxMrqHbaNGpqp097c4FJVfaqevuUYlM1d2nZt/z0RiZQZw2yUMSWFePA0arlK3D/LKOOEhAiy6oPRSTritafdyiP4HLVfPhM+D6N+kit54qE6jvMvHce57DjOZVX0PNfO5ZWj3pcsi7xwYQypYbF1Yxe/KXHh7CiPCw3Gg16qWzWatS65bI3EWBSjbeDzqHj9LjxDAX7w83tsxQQeqD3eWtmip5k4ruMDwhfy0DhBezymqjRrRx9gy7Jx68dPP+Z18zoBau+sUry6Tv2dVRRHJHpphEbKS9slMvePX0MbDLBi9vDG/Yhnh5iX3cRv7qJ9uIr7402+7Y8RcruO7Lupa3zX3SY3EWEn6WHXKxLxeklOZpD9fcGkhKSS294lp/doeBVytRrG9RWmVB/f89k4l+fxLkwhXJ7jpzEVwzDodY97b6pu7AsozQo+OtXKY1s4RDufTXL3JAy4/LxQraHl1qnWssh6j/C190iWquzkH3KvsoQ3MUFz+izfC3a42Xu+kNxnxK90bAOcfXmWQCjM5oMKtilz+c0FFFd/AR1PR2iVu2zcyxFIB5BdMr2Ghtelokbd3C6WyfvgdqHMnaVd/OHjv+sc0mgZDQUobR/X5FG7h7juAS8vyT6q765SvLrB9R/fZfjUCFoygP/CMCNfPUUtprKJzpU3z2CuldDfXcF8d4XXigLnIwcTxJ/WiuxOJcgnfDRSXkxBYPDKKRrdNv6OSbZaoWDrtL0Ku9u7lEoV2i/N4z0zjevcDNUXpljcXD92vEKnR8odQc0fPxc5VyKqBo69/zRMirP4llbRKpsoiAh338e1eJ9i8Q5ll4E3Mc/ORIqK+3s4PJ/uiwOYzvP9fd74PNgv28DwoddDwK9MJm9mOs29d9f3E6xbyyVatR5jEwnW1g7iX6pbxdpb/+yulYmlg8y8Ps7A6QSf3N/i6q11HAeKjzWQXmu3GJ5Nsf2ov4STFYnBC4O8tXF8aa/jIMniMbaCoxyfKy8Eo2TfPSiPd2yHBx8u4X51jOyom09sk+zqPWYyYaJjIzzqdIjrXeI3d+l1++dqGhb5a2tceWWCH+30IwCfhmDerhWoT0T5tnsEX7ZJod1i9ccfc2ZqjMnJEdyb5f4KRZZgPEl1pR9iihsOP++0WP+Uhrhnj8seD+fTCRrbRyMN9YALe28k1gWLEUXFMI4acU2WnrePwBNxwR1ELG0yFJ9Cs3qEBRVLa+PzeEAATW+xsvEJ7Zk5yr9kl6Wn4Fc6tocmU+ysVCll+3mDwqZOrdBm5uIY9z5exu09mLxvf7DGxKkBMn6V6VdG+e5798mvHIQZVrfKvHZhlJV31/bpwpm5JFvVA+piyzDx+Nx0Hgu12IfG69lomOx7B+HHRlfn7bfvk/rqDD+SKmiKxUQmgilGyZZqZFcP8j2ljQJzsXHuCAKW47DaaGD4/fyXr59ByhWoWwbXbtznnC8B7gYaVURJQpwaoLS5StC2+CjoZ4MG2OCr1vgv0zFYPvqManE/ZW0Xx++Ho1FHHL+XjnW8ucvTEOmoqEoQn2+ckBzH0Pv1AT4rSr65Tr25gRwYB/dn6Bz2K/LCnwefh6f+XeA/F/p4Cag/K+Z4GIIgEEuHiKZCz7W97Ij7Bv1TVEstAp6j3muh3OD06+O4PP1wha6ZmBLcXcnx4NHuPpslsHbU094q1VnzmAy/Mc7oK6PEXhnivezuieyXB7kyI+eHDo5NEhmaTbHabB7bVtbtYzfZMm1k3WapXGW1WkczLe4Uy/x8Z5f1Wp0o0r5B/xSO7eB+gljWhtZme22X6xubiKLEzHCGlZ0cYiKC6+VZfBcmsc9PcHMvoSqKIh355CFQ6nZZGogQTCdAEJAVhcDpaX5SPDieT7plpNmpI9/zxOLcUn/5MMiCJ8xZS0S+u0p6u0DSFUeSFJy/2baPv/DYFiWRRCZCKOZ/4jaReGjfoH8KvWcg7oUPCtky0y8M4wt7cGynz3TxyNxdzZMvHJ3ILMvmwwdbJF8cYuzlUcZeH2Pb1tnere1v8yhfJn0us7+qVSSJxGCYHefgfkn68XGu6yaNaoelao3NRpO3Crvs9No0T/D67VKL4KGVpCSKLN9Y5nZxFwsQQ15WOnXiZ6fxnp/EvjTOjZ3NfqOOsI/aofL/tqlzI+YiODSIIAhIkkxgepKr/jptq0duIICsHPyWrKgUB0O0zM8S/hJIyyOkKjKeh0t46hpBNYUg/nJjzaGvEPM8f583nofS+O+AN+kriW0D/xf64rU4jvMvgB/Qp3wt06d9/ZPn/fFIMsjAbJqtjSKSKHLmS3Os3dqkVXvyTHu4IQXA6GSCSMRHLBzgwpkRVjYKNBo98rUWTqHHwEISVZVptzUqzQ6breMG93HsVprsVp69Xaurc01pcP7NKUZVN5LtUOnpTAsW9Z4O2R6tTN9odl3CMSlUVZVpSk+ezluig0+VMR6TMTDVk2/bkMtPwDSYDSeQKzoul8LIwBC7msX/xynzjYBM9cE6Ab+XiUyGQCTIVdFi0ONjp3s8AfRXlTwbQ1HOT4+w3utwtVGha5rIe/0vNNvk3yk1vnZpgUjHQFMk3lMNbnZ/uYrOjDuAvLmCrXUBB0vr0C1sEwkNsiQ19wugPLEM9+zn4Aw/Ab+qsa24ZKZfGGN7s4Qn7ObM6QyLH6+hPT5BO85+RyzFJTN3cRQEkYHRCIZpsLm8SzIRJzLkZyAdRjdMssU6pn1yOaOmmVy/v33iZwCmZfNOucCrX51hHBeObtGWQbE03KpMTzfRVRFBFI70D3B5VBqPLb2qvR6uqB9qR71oMeylpR8Y+xG3h5jbIiGoqGUDRVWwowlyis2dThlqJrPpQXyOQGckQcrcpX6o/+y7rSLbgyF+c/A8DavHdWuHttn//Ef2Bq9emiDT3GMEBUTeMdefcmeOIyllsFaWsTv9593Qm6itFv7YIDlhBxxQo8Nsits8UcD8CfiiPPXnYb/84TM+d4D/+rP+sCSJvPw7F1lbzTN6apDsWokH97eYOzvM3beP0uIO89VLjTaD41F21iqMTiYwWyZb+QKP7u2g9QzOf2mSO8s7rKwWmJ8dQHAkWk0NT9JLodmm9pQJ4xdBqdFBT1i8/7MHR6pkX3p9kh+1D+K8n5RL/PoL4+xe38DQTVxuheTlUb5ffrLjd6Nc4Y+uTGHdymLYNvlul9jcID9v1va38btVgmWBXKxLwegwFUvj2mnQWi/RbnRxxQKc+tZlyq0cf+GR+errC5xtQOnBBotbO/RMg2/NjfLnXpvCobZ2qiTx90JJ4rs1hHaF4ECMssfP3UO/DVAxevwHY6e/5rPYV4r8ZXDGFaBWustDRWUikkSmRbtbxzpzhUpjCW9XRQ9GuO4zKGnPbn/2JPyqxrYn4EbyK4wtDFLebfDg/hazF0e5995RIait5V2mz2d4dG2LMy9Pcfe9dRS3xNbiLqZpMXY6QbPWIhaP0MlXUcfiSEGZpZXP1rD5MJpdHXSbn719Z9/oSJLIK6+N89cb21zLl/jqi+PsXNvANCxcHpXE5RH+amvnSIq42tNoDycYresIPYOqoWP7VLaDIkbJwqeqyKJAxTaZCIWRSw0a97fRdRPfUJzQeJq1i4P8bjdE85NFdiWHje0N3hhKIo2GedCpAfCNwABThS6hnW2CiSD6QIKP9nLXlmPztrEBn3IYnrBA/HFujq+lH574WdKIUm0vIYSjBHQvvVYJYXIey6OA0UQKDbMSrNOyqid+/2n4ouqbv7CKUrffxQ/+4irZjSKiKHDp5Tnq1RaaZROI+GhWT6YObW9XmBhPcjYTJh0Lcue9NQzB2Q9TPLi6ydiFAR4t7vLg0S6iJOByKfRyxV9q5lRkiVjYS6uj0+ocJEtcqoxU0Y7JHtSWigymgjzai1W3dYMfNPKcvzJE0BZoijbfK+2im08OPp+PRunkmkTTEdyOwPhIlO90yuTyHXyqwtfiSVyFJo7l0PVHuSq28QouajfWMLX+CDcbXXJv3+PNrw/zF7vrFF06793ul2d/iuqjTV5+eYbv7Bl1v6ryjUgS74cPaOx1t6FU5Uszo2yoKl0+34nxcVRtE1V1UdV7XENDESUirhqmtsEP/CW8IQ91YwvzCWGoLxr1Wpsff7/P3j59fhxfxIviU/e98v3tKi28gTqv/fYZmiWNSMqPoetU90IrlgE7G0U2l3K4vSpNR9/XbXlehEIeXC6F0p4sQCrip7lcPvIsWJYNhTZel0Krp/OjYoGzLwwRsgWaWPzV1s6ezPTBKjnoUglq4I0FcOs2gwEvhVEfP9pY5u/FB/EU2mBYRGJhgkjs/OTWfttDrVBHuJ8lctnHJx/epWdp+zmY+laeC4MzPKDG65FBpu/lqZcqiME2VMuMVeIUz8ZZfY4epM8DTTIRRYWKXaGqCoguCav+Hs7gOe56GrStLWz7M8TS9+DgPFW351eJL07Qq6fTavSNiG07XPvgIZdfmutriD9j4K6u9b2zC3PD5EpHY5K9jo5LOTgt23LoPoON8akU75Mwn0mQNEQa2w08ER/CZIIP17JYe91lnBPKui3dQpFE/Fn7IARjmHyQez4vK+RxkSlobC/tsr+gXtxk4pVJ7gBfiydpfbBMY+9aGaUcr782Q9XU6LklVLVfJt7Cxu51CexJ7HpM54hBh34YwKVb+BWFb/sSBAsNznV7dDPD3M/t0Ov1J7H2apaLlyf5+Y6OPPirM+yLvQZ/NHUOaekeLdFhW+8g+8Lcd+t0dY2u9Ys3A/6bwOEQ272ba1x5fQGXRz1xPb67UUSSRTo1m2ruaJy829JxeVQMrUO3rX0mg+52K1yazdDJNjBaBtMzQ9wNaNiCg2Ucd2lt00ZWJdAMuprBR5tPH6evBuLsvLtE9tAhhXNh/vDCKNm/vkd77xr0dmoIl05hht3IpoMjQE2wkHNlJp0oW73j9zKKzD92ZbiwYSL1FHoj42RbjzBNg06pxHRvhlXx8zHq2+I2p4ZfRFpdwhQdqkIVJZRi0ZWlaf5yYcTP0CTjc8UX1qPUth2CIe+R1+CQGozSqj+nwZAFhMe4jPHBMOXH4nwAiirh2qOKBQJuZqZTDA1Fj8XoH0cs5CVcNln5ZItirs7mgxyFj7Y5N9KXGeh0daTE8V6ekak426VfnJUxEQhQ2zo+cGOWyN+bGGW2YZPyevj08ENdhZGNLqnBJG5JpolN0dLpOhZW1Etxj8NdVkBRj3LdZUkiEAnw30XHmbi1TW8jR2tth94nj1hID/7C5/CLIKq4+S8Isr1yDymSZCiY5Nz8Fe6PJ7ijf7bioi8K8mPJZ8dx8PncTzTKxZ0qyeHwsfdDcS/tQ4qjrr2+vF6vyvREkrHHmkgfxrmpQdbeXWNnqUgxW2P5g3Wm8FBp9whPHG/u7EoHaLSfLrdxGP6OdWSOEgSBhN/LQs1hQvUSUPuV4nFZxdytE4lH0ESHkqNjiKAnvDy02/gjR/vjBlQXLysRxq5nsXfKtJa2sD9ZZjI2vr/N52UrJUHhXHuW1u4yYiiF350mk/kSW+Nudu1fjiL7qUzA59F4+rPiC/PUHdvB7VY4/+I02+sFBFFg5tQItUMt4w7jcR0YgOWNPOffnOLRx5t0WhqJTJjMfJJrt9b3t3G5ZBZmM2i1vkcwMZ9m80Gezdt5vAE3V86McWspy5PSopPRMNl3jpZydzs6A8bBZHCjWOaF1yapLRUxDYvoZJxFvYP5DHGrp6FuGAz6PGi9A69qIB0h3bHJP9xGl93EyxqTQwmq3R4xl0p9p8onrkVm5odw79SoKzYVyaE6FeXqXs/QDxsl/ujSFNKNVXo9DZdL5dxL58gubuOp9rC3yizEQ5h+V7+p704Ff9BPq9HCN5Hheqv2C5/T8+DL7ijavTtoONxu9++Kq7LL2tQE+D6bEucXBUEQOP/iNDtbJWzLZnp+kNLak70+ratj2TpjCwNs3s8hSiKT5zOUcmUcxyEQ9jG9MEZLUckMRUB3uPHBKrIq8cLZYR5mC9QOGX9RFJC65jGq7c79HCMX4tzT2px+aYzKUglREonMJPi4+tm8UvMx2u6FmRFYq9DpOig7Tc5FAngiUVrVJsVai9BghFBHwxt0sano1GZC/LC8we8uDOG7adNutsh4/Fw8NU/lvVso+TLuYIBgNEaxUsZV15EkGVckzD1385n6Qs+DUSaQHy3RMXt02nsrk7aILzz1y7u7vyKD/Tz4wox6MOIjnPBSKjWYOz/C6EiaZr7Bww+Ollf7gh4s06bXOb5MazY1bi1uM342hUuVqdTa3H6wxcx0Gpci02z3SIQD3H97FdOwCMd8UNHRNINep/9XK7aYf2OcfOvkhNvzxMUqzS4/bm1zejpJIuDjTrZIrnwwTRwOwTwJg0E/aY+HfK9Ltt5irVbn4vwQrfeb+x7eeCLKxnqOZqtL6OwgnZUi+loJv0+ls1Zm7Pcu8ee3b9OIhhgdDaGmQ2xKXR5JGl+xY3htE80t8Z7VJnIxQ9KR0T0qK4sbGI02mP0uOt1iDdkVxxiMEvR4CEdV7LE0P1csms09zvyO91cSgglrBo/7YprWZcAWHmsn/LcXqkumWqsxOp1kZm4Yvabx8OM+91tR+w2j2/XOEc996fYGkUSQuZeGcByH4k6ZxGCEaCpMajDG239yC2U4iqcHKzezREfC7Bbr3HlrmdNvTnK1/uwJTxAEHGCr0iAnt7h8aRCXKPHeZp5G5+leuigITIfDBCSF1XaDJVFjKh2hmqsSifhxtmrYOBDz4ddtulsVvIaDUagxcGmS27080akovliQRhp0XecPuyl6pkP2yjDenkVCCHJnNUt6LyRTaTRJJ+J4E1FU1U1gYpxHSYtV/fMpNAtoKpb52Hk7Nu4ufB59EZ0vSP3lCzPqtUqTnbUiilumtFsh5PWw+N7qfmOKYMzP1MVx6rU2pmESDHi5X+6iaf2kRSIVJB3vL93KtTaLSzm8XpVzM0M8uLpBt62TGAiRGktzd+/hyYxGWf1gC2/Ijder0unsJZ50+4lx9ZVKjdmZFFsPD2KMXp+Lpnxww0RB4LWpIcy1OvlCnolkkJmpYd5d2T5RBOwwJFHgn8zOEdjuoO92kGNxtsYTfGdjnR+Uc7z+6gT+toUjifQUha1WP4Fcz9dJXhijt1XBnw5ij8bJ3d8lGY+QK1TIl2r44uP80Kjy+1aY4q2l/dXIq5OD/DTe42qnxZtSCu9uCdu2ccZGYas/uSm6yS2nS+zMCN8X2lyUVF5r6bziipH1KfyoVjhxyArAhCdMVFBZ1OvUn6EBcxgiAl2Xcqz/gCwrVL+wQOFnh9bVER2BZr3Fyv1NjIKB3jOYvTyB7FFo1DpkZgdoV1psLeaIpcMMjCVxgHqpjqGZJAfiLF7bxuVR6dUd5l4coy2KbC8VsSwbu2ciSyKmZaPXNRRF2u+CZNsOpkdCVqQjCfzBUyneLZXwuRReS6ep3CzSamlcHo9SyQS5mT3ZsQl4VP7zU9MYuRqmbvGVgWGuqm1WJmB6NMKY3492bYs1vY2yUyV9YQxju4rL6yYxEmF3NU8zprFY3GHYN4ynIFO+c1CINzI7zNuDNgOrdRr5EsOjg/Ru9527Sr1BdtBL8nyEtt5gsqAx7BrnUajLXfNo3N8tqkzKUXRsVo3SM/X1ewr4JfVI/1IAw/XLD7a/7SqNvxLYlk15p7b/Or9eYmFmnNXbWyiqxAvfPM9f/+AGmmYSCLrZzVaZfW2e27ezTIwn0Ks9bvxsEYD0SJT5uQFUWeHm2yv7DINGpc3999cZnUqw9iiPoZmoHgXLtBEPNXsWnhJXrzS6VAd9TL4wQmu3iTvsxo67+WjtoLBwPpOgem2H9l7it7tewldpM38qwb0TNNhFQcDvVunoBn9vagLjxyus7PWVFAQYf3OWi6kkH+/m+eHOwe/8Tnxg/99arcvDR7ukT2XQkj5qH/T10kOvDpGjX/zS8kpccaJUPjgqnFZZ2eFyaootWuwaGhNBH61ak/vlEqcvz2Jv5JETYQJDw3zHqPOmO4hw9SENq28g4orCty9N853HmmF4JYU/kNK4H21jdDpcSae4Oxjhrc7Tk26yIPJNX5rxtk6wbTE2+yJ3126j6T0EQYSJWT7slOk2U8ynTxZr+tsE07TZXT3gz7/62hkGxhPkSg22HmwjSiL+gJtEPMDplyapl3VuvLuK4zgkMxFe/sYCf/mvPgTA4xfJLpcYHI+hpPy4PCqdRg/Lcvrj1gJJlY4Vx91c3OHSy6PohTZG1yAwFOK200EzTK6MZFh7e3V/pbB5d5fMTIqI3031ULWpIku4VZk/mp9i+09v7/PDZUXild88w/9k1LjTrZCx/bzkFejWTIxGjweLOcLJING5Ae799U3AIZQZYhcYHkxw7d2j6sXlxW0W0lPYIQlr22JJbzF1bgprq4g7GkC8MIhRKaHdfbhfpH8qHkM/k2TR6D9fc0qSF/MqxlYWUZJ5cXKMH/kLFK0T8muim9O9eUJ1icHYK3T1CsXGA2zbQBme5q668bnwEb8oPfW/df6Posr8+j95g4cPtrCBdqPLzmYFy3EwsmXmTg0wMRwjEHAxMdNPVuY2K5hNHVUUjlDGNM1ENy083r7vt7FSYvJCBn/UQ/vTFUHUS/sZQlAPd0q8WyqwGRO4oTf4YDV7xAOPiPK+Qf8U7UaXiHh8zpyNRfmNYJqXGy6+oca5IAWobh0UazgO7Fzb5Iz/eIXtA6dHfCwBgCkLKG4VM+Ll41sriKkg4ZEExWYTt1sldnmSd9tFPDYnVsMqe5WDS6061twQkizRaLb5cGOTnek0Pzwd5191C/SwCGyVsKwDj88wDJKlJq7i0WP8upLEuXaPdrWKrmk0NzY5s14n7XpyVSXAt3xpRu49RFt6SHHxHg8f3GJi9jLd6VNsnzrN/2xU6Fqfu1jX3xgUl0xmfoBCoY4ki9QrLbLrJerNHqdfnsUddLPw0gRev4tSrk5uo4Zvj0TQqncJRL3srJWxbIfhU0kEQcDlUzAMC4/XheUWjyVhdd3kgzsbLHZaZBWL9x9ssl3pJ+5dXfvY9rvLBaajkf3XV0YG+GooxkuWh3TLIXhIOM80LCq3sryQ6D9/2VYLfTqGy+vCVPYcJI/Kar2GJ+AmkA5T6bRITmfYEbRjq1fHcRB7FisRCW/IT6Fa5aPiDlujYW5cGeYubUr3j3L826UyM+3+uFJFmReKKq2lZbRel267Sff2fb6kJU+8H+fbC7hvPKK3cpfN7Ps45TLx6TfpnJvjRnqbpv3ZOekn4YsS9PrCPPVPvWNBgEDEx0tvLtDOtph7ZZKHi9tsruVp1rukR2Pkt8qU8g2uvHmKlY06P/9wnXqlTTwV4vSFYe7d2KKQrTEydfwmtjSNi6dS7O7UsC0bNelhdMhPYKeBrEp0BYv7j54t52FZ9jGdmH1IT/D0D73vz9q4Z31MlBw2H63vv18sO2SmUmSXDzxQrdklJh+/NQ/LVTqRAKcGJ+goKmlR4dZ797Adh6xsE78yQrPeIB8zudHMoVsWeZ/FuMdFt3sQBhElkYZHBK2vn/4f2nnefHGSWM/GlEX+kh73d/sxWp+s4HROqBnoaLj98hF5o2Tb2Jfp/RSNXI6zY/PkntDiThElRuodtEP6MU1TY23lAW8Nh1lvHm+kfBJ8kpvz0gBeW2BX0vnuc33rVwdJEgnGfEzODzF6KsPSw212tkq43Arp0RjVfBNBFHl4e5sb7y8jySIXX51h6cYmpVydWCrQj7tbNp12h/GFQQwgV27ytf/qCtntMsGpCKYKtx89mRXUbJ4QKz9hvCqqTG9v4j6XSeLcKbBZ6+BWZdY2O3iDbnxBz77zYnb0IyvcHxSzXLqUJil5mLw8zuLiJrnVLdIDEQZenGJLzXPTqHBaVEmpCrp+MEkrikzFDX/dzvHi2QRTvTSiDTe88E5liW950tj28ZoE2bBBhWE5gr11QnewYhPvkIvOIQqsX4rg2aqg7YVmTHRydha16uLB6BpPU9hUhSncvVEcwabresSnfWdPwqcyAV8EvjCj7vd7OHVuDFfQjcfn4v7NVUamBllZ28U2YWx6gE/efcTOdolEMkSj0iEc9bP+00UiAS/QppSvkxqK4PYohBMB1rZLjM+nWXtwcIPHz2b46XsPiAz4EEWB92+uYhgWkiT248iHZspn8dWfhLVGk5GJOPnVAwpiaiLO+mMaMPP+MDvXjzJpCo02I/EgWQ6MemZhmA/qJ7MRNutNNuv9/UY8Ls6/MIbiOCxZBt99tIjjQEc6GE7XG2UmL43hvbVFp9nB7XHhOTfCjw8lhnumyV9VTw6R7LRbOEMJqD6mUZKOUGkXkA6cO0zxUEhLEFAUFdtx6D4lYaSKEtIJvGlH6+ETjg/PB7njIZiEHOQbnShGdgnHsUi6Pocs1y8Bn8/NqSsTCIJAajDGD7/3EaOTg3j9Ljotjd3tMpOzGRRZplnpT5iWaXPzg2UWLo7idis0SwcTabel4YtJbIlguUT+01u3+klPx/nMxUgAFdnCG3TTOdQxbPjcID8r9kNGCUdiZ6/yWjNM7LhCcTlP6nKG1ft7jaovjPAnuYPJxHIcrpYKXAUibhcXZqKo01Fu2Qb/duUeDqCN6HxkFvj9FyaQbmzS7XRxe9y4zo/wvV7fQF5tFbn66U73/IBFocdsKES7fjAGRVGiGhDABg0TyaXyaU2coqj9Z1tRMJ2jk4GCCtpx6ozQ05AFFf0JJdFzwgL+R0s47XVAIBSdA54uw/t3rvio29RIRSKsbu+ytZbDsmyiyTDra7vMzI1SyFV44fVZ1pdzDIzE+epvjXDvw1Usy0aQBbw+F522RrXQZGAkRigd4PadLQYHw5x7cxJLt5FcIqtbJdotjXbraMLuae3pPiuy5Qa+gRjjqTHMpoYccLFlamzvHjXMosOxwqrVdpOpK+NEqw2MZo/wWIzqXIQbi4vP/N1qV+Nn3afrS5m2zX9sZFk4G2fOHcCQBf6svEPbfHKVnCpJyKJIxzAwbJsP3BavzY7SXt1BEAW8U8P8SOj15UUPsWAWvXDaHyDpDZC2FYRWF3liiDtCGwFIugP9vpLagcFqmzqNcAz5MckSZ2CQFe35vPQXSaJvH/SwN7Tnb2Twq4AkieQ3ylRLDRzLYXMtj+pSOX9livxOlWqpxdy5UTqVLos3N/EF3LSbvb58hFdFEhxkl8PZ18f740VwuPXeA5qjh1sw/uIG43o2zwvn0yQ7YGsmYtjNjWYVbU9jSDj0aDgOrHU6jA9H8ccDhNNhoqcH+DBm0Ng9mVdY7Wn8de9kJ0GzLf6dvs25F+OcckWoixbfrWyeqKfvlmQc4GG7ymvn0sQeqrSKZdx+P87pIT6knyvK6jW08Ql8msmEP41cbSN6XRTTGVxUiagBZEHFdHTqVgl74AwsH60B0VNhOtbKicfsEnykCzZO+1NHyMGuPL1j1d9JSiNAz9BZXz4IfYiSiGXYNOttJEFic3WXRDrEpZcmuffOIrKsIlaaFIFIxEco7ufUpTHqus7de32rsLNTY+dQAnZ/36KAKAqYe9xdt1vhpRcn8csKtuVQbnW4dW/riXz1Z2Fxt8ySACG/m0lZISa5mM3EWdop78cQ85tNMkMRitsHMTtLEviZUaW94CMohXmr3SC7+IuLVMHRptQAsigxhwflQR6h2eN3hqPciwT4pHF0YCuiyK8HUySrGoJu0o3F+ZFZ43ajxqqqcu7yBJbjcKtZpds6/hC+280xcWmOoTt5jFwB1e/HfLjGf51Kok+eZ317nZam0Rga4k/t4j4z5gd2g9+bO424uYFtGsiDw7zlF+l1nq8826d99jLuXyUsyyaf7U/osizh2DY7W0VkSUI3NEam4oxPJvn//tkP0boG4XiAYCSKokokBwL8/M8+PpIb+hSi2C+2syybeMzHK+cnsTsGtiSwvFtmceX5ksiOA1e3csiSwEw6TkSwGAkGaGk67Z5BQ+3TMvW961pt9/BNhdgal2gOJvnzZpHq7vMXKj2OkKxyuuvBurOJ37D5h5NJ3va1WO31Y/5+WeFbcopgqdNnBCW8vMs9Qqc9jDJOiQ5rxtL+KsXB4UeeHP/N5ALOR3dxq26kns3Eu2v8Xy9c5n7+IbGBeXYzXdbFRZbiRWbNWczsFoIgIoyOcC+0+cR5MixGoV5+VofKo9cY+hTPLwBfqFEXBXF/GQmwsbTDmcuT1ApNCpslFJfC6dOjfPQXN+l1dFKjcQZGY2SbOtVqm8HhKOV2l0ePnsyuEEWB+dlBJBMs3cQVcJEt1bh4apS1D7bYelRAFAWSoxGuXB7nnU+WqI8c73L0PAj53FwORln/cAtDtwiEPHzp0vB+f9PtUoPQxUGGQh4a2zW8UR+MBfnr3A6m/auLwH0lkKD3/gqtPZ2Z5r02C5MDrMXclHsHD+c3gil8V9eofRoOWYZvvzDDvxZ6tHSd9yrPFs/SWm0+qGyR8nkZLlcx2m0iuxVczTYjqsCNTg0KBX774mn+Df3l+67e5l8IXeanh3Ajck+r0X6KtMPhEIyIQMybIhG0EICG5LBTW3vid/8mcLjIeWs5x8KFSR7d26RRbNLr6MzPjfDBX9zg/EuTXHt3iVqpieqSufjaNO9//8Yxg666FeYvTqIF/DiOQzQdIOH38fM/vk6vYyArIlOXhzk1k+b+4vOLfb02MkTtZo6dcqvPaDk3xE21wbVsnjdfHsPaqNGtdggORygHJd7a+nyu69dJUPnwUOLzepMvXZxgU25hOja/I6fpffCIyp5dEJdFvvLrY3xfXiTHyau3pOjn0codAn6HgVIdd9dEbumIgsRgWKWzkWWwHqZ+JkneyVIZKJEeGMIWbHLOHSznyYn4Ll3isQu4mxEQwZIbGO0HTz1HB+cLY798oUY9v1Li1LkJ7t3sL3sqhTpzp8cYSyepDbfwuFTcLgUppCLIDqJbZGQ8ykAkDEC18XSDDjA/O8jWzV1ah+KHv/b3L9DaabL1qG+kbNshv17FE3YzMhznzhOSetDXTD83nMKtA5JA2TZ4mO171guJGEuH+ps2612EW7uMT0ZY2a0giQJFo0crqWBGQ5Q6Xcq7T5ZKhb4GzLlQBMUW2LV1HpYrz+S+A5wORFgwPCg9i1NWkId+L+XawTqkvJbj7NA4P9tbJk/5Q7zRVWmi0vKobPc62I6DsbjD1HyUR80nMwKStQSTgxI7dhfJ6JdcJEwRvd3GLcmIHR0HB215neEzEyzvbhAu1AgkXDSNvrduODa3259dz+N1dRx7+R5qvYvZbhBR3XgmZz/zfj5POJZDajhKfrdCMVdFkkX+wT/6MrtLRTKTSbbXC1RaLdwRD1/7+xfJb1dxbJtHH68ck+cFOH15irvvbdAL9hkxEyNxfDNpep090TbDZvXmDue/NctDUTgWZ3e7FU5NpDGDEsgCWbOLadu07peol1t7+7BY/mSD01+a4O3mDkvNBrExP82Uyu1Knc62AaNHXVVZFFkIR4k7CpoENxolWvrJxlGRJL7sHSLTEpgrKZSHR3iws70fBtVXi4ycCyBLEqfXNTr40BSBLauNbtt4NpoEZj00H9NK90gqU2KcMTmKYxaJGSpGp0bIdmNbFtg2+tIq4RdGKBUfMdibpOoqYDgaW6w8VxRrRhvDyW5AZR1sA8kbQph+FXj3qd/7Wyu9+6tEtdAg5ZF57Y1zaKaBKivUN+ssrvcLE17+rfPcurdGt6MhiiKl22vMnR5hbSW/X4QEfc9oeiqNuqe50dEMVvd4wootHDHoAKs3s8ycGjjynuM4NMsdQgMxaD/ZqP/a/DjNxTKVUotqpU0kHuDcqRS3NvNIJ/Q3bZTbDJxK0Az5OB+OsPuwBLZDbCZOW+o/AF6Xgm5ax2QFhoJ+Lusedt7boGM7pEI+hi9k+GH2+EQQ9rh4MRzF3bOJxAPwqMhKsT9ZpiU/E7EAXa9BZ69yUJIk9L0RvRCIcGXXwmmVsLJVArLE/GCEh3oT2XZwiyczXwXgd2KDpNaKaBsFzoQCJM6NUvJsIHUO6umkSIh6p41tmih7a1gHAceBeXeEF00XXt2i4VH4udNgW3/y9T8Mt6gyXNGodEuYHg9JdwLZduAEKunfJLSuwUg6xcRkBsu2cSkK1753l8HxJPfurFPM1xAEgUePtsjtVFB0h8JeSG5gLEE0Hca2wbEsdtcLNCoahn4wtkRg82GBUNxHfS+hqncNrI6Jqsr0DklLiKLAa2fHqa6UaBQMioUm6ZEII5eHuPXxnWPHHkTi65kMlYdFbLPNxHQc3e+lQIee5GDsMWQkQeA3oxkan2zTbHWRZYlvnhvmr921/dWfJAi8HEuR0GAhEmXj6kN2uy1iHRWj1ePMC6Pc3Og7QYIsEVJUvtz0w9omdq6KKgicHoiyKHdBt1Aeu6+zcpJLOy566zu4PA3OJucw1jcOGFmCgOlRsXQdyel/1y34udC+iLvlYLgFtkIF8jzZsQqKMfzZMjk7TzKpIOkBEByc51jM/50MvwDkNyrkN453UIkNhOlisnKIrpVIh1ld2mVsMMHhNOKZhSEWr2/RqPYTdrFUgLm5AR4+3D0xNtnr6bh9RzslCYJAYjhMttw80GfegyQKTKVjvDo5RONGgW5O43QmQfTKDPcWs0i6gCQKOOrx/qYer0rbtjgXibCy185ODwrUPmrx+ptzNNQQZrGN7FWoBSU+KOT2PfGz7iDb1w4q75r1NtFHJYaHAmwd8rp9LpVvuKPsvrdK14GxmSGs9RqBkErT1GkoYC3lGD2X4cFGn70QmR3kJ+2+ITlvuCitLzM+MQqCgGVZpOs6oUAAdTCN40iUPD6yjzXSOB+OEbu7QaPRQgwYGKUK+nvXGXntMr71EkLXxAwHMBMJGjeuo0ZC7GptBEGglgqTEhp8bbdLe3cFnf5l//tT0/wvXuOZlagPcileGe4i7dEtG1aXxh5zwVv/m22PdBLW7hylGQqCwMB8kp//65/uhxtdbhVBgJmJIQrbVUZmB+j1HK6905+MXR6FN35jgY07R8NeumnhUmVU18Hjq7gV1JDriEEPBt18+6tnqd8p0O3CdDzEK1+f4ObSDm5bIBDy0nxMPC8T9POT79/cf23c2uGbb8yxZlTQTJFOXOHtao7ZUITW9Syd1h7F0bTYvLbOC29M8Fe9fp7sm4lB9I+20GSRnlzHU2qRGfSi+0Xsagup0MGzR7cVpxKM6jZrH98nnRmBXBmPIBHKtbmSCqLEM2yZeT7ay3qposzFvIfGYv9a6brGquzm8qkz1NoGjsuNJxYlt7mMGonSNiv4k6PIVZXGw5v70uuTqQzWfJqSc/KK3yf4sbstHBwMYQdjz2yI3acb7H5F6f+/+GgfLq9KejJOMV878n4pX8MT9CAeUqbzB9w0Cq19gw5QzjexuyaKKiF55GNKjsFUgJ5gcuqVcWRFQhAEJs4N4h3ys7tbO9LiThQEXh0fJlUX2PjhKqX7RaxSj8WfrXD7z+6RcnkZCgdRFZn1TovBQ1x5QRQYvjhEod2hs31UsVERRVwrTVoPC+SWC/haFqcK8F+NTHMm0e/a7upaxD0ehvx+/Gq/gKqaqzHsOVrMcyESoXBzY3+5J1oOrWKTAbE/O2302mhJP+HBKLHRJJEXJ3knaNDSdURBQN1bxt/L5Qm9OMNAKoHcswiOpVmsVah/8IBvWn5U6eikNeHIdBp9r9pu9pUf4/4Q8WyTxV4L3yuXkcIBPiys4VmYxzl/ip5Lwb64wHesAi84Ptq7B4lyQRCINNr8t55xvu0dJKEeV788jIbZQg9Hjr1vRONP/d4XgeHpNOVS4wjNTevp2DgIe8M5EA2yuXxgwLWuwe2P1hk9lTqyr3K9w9xLo0h7VdGKKnHpGzMs7hyErwbTIS4MpynfzJN/UKS2XmPjg00++be3mItFkS0YOD94ROVxbH6AXPbAwRIFyLi9rL+9itQ1iXUFJtZN/tnALDMeP3pHZ9DrI+31Ie+t5j5tYh31uPFsNNB6Gi6XgtnS0Hs6gZbDqtNGHI6iKgrp6SECr0zzPbGIu2fhOA6L7RqJy7MkfQFESSIwO8yDjUckPq5wRu6L+mWUCNbmwbWSZYWEGqK6W8D94nnsZIxir457ZAjOTWEMBLBnMjQXD2iIiitAxAhxpXqJEaYQTjCHFaeEGE0ce98JPdtVd57zv88bX7infhixwTDxiQjVehM17mLUE+bWx0v7S0/HgZnTwzz82SKk+w9uIOimsnOcs9KodvD53Cyt5bn4lWnW7uzS6+gMTcYxPfCz9x+xcGqI1//RBQRBYDVb4p0Pj9MIJ9JRstd2GB+MUN9tEPZ5KK5VkV0SjWKbYcOmW+qgyCKbxTpOPMj46+OgW5huifd38kiShKQe5b8nvB56jS6WaHFhbpj81U3KXYPQUJiQz+GN84PMyCFWSlsYmkk66MaKBCkrNtv60XCSxxboHWq20ZMEJEVCaTuoLokhxUvA62U7IvO2KLHePKBB2o6D7utPGJ1Ojw/W1nkjPoiSDnGzWqJY7D/k3UfbnD4/wI36geHQRfAcSnS7XC5GdZHm4jq7ToMf5HYZiCXwv3yZ/0HbpO0UsLwCVb2/3HU9VlByJjOJZ3mNVrVBymrxn42M8v1oiKXeyckxy7G56evxQmqUXmETxwFPPMPN0N+e5hnBmI/MfBJLsfGEFKYXhlm5n93XtE8ORmlV+g7J441WAEq5Opqhc+6NCZZ32jiOw9ipNHd284y8Psr8VyaxRfjo9jrF0kHYajgSQq9ptDbrCBZ0aj1EWcA2LLqlDnJQ4v1SnoXXR3FrDrYskHN0xPpBWDPsddMttgilAgzEw9z++X0cB0LrFea/OsOgJ0RurYQsCkwn/GRVA8slQRciLje9at+RqddauIYGoFYBw2Ik6MfRLJhL8mN/nofNPlOo45WQBIFSrU5Wg7hfRoq42WhXqe8VoY00ktzxQs8xEN0q7C0eJxIjmNcf0Qz5uVpfJhaJE58a4oeZJlvmDpeid5jvnsa9N+Y83hgpM4lxexl2y2TCLRJnL3HN/QmHA+2a3Sabcsj0BqC7C4KEmJ6kFTnane0k/J0rPnJ5FCKJANViE1EUSI3ECY74eOdnNwDYzRdxZJFv/+Hr3PxokU5LY3x6AJcj7ot+AVQrbTKDYVxuhVjCj2M5WLaDO+DiwUoey7K5dneDzFCEsCvMVq5Ge6f//Y+vPTubH1FV1iptXONJ9I6BoSgoLgmHfkzZ43WxlK8Ry/hotDW2Sg22jumoG8iTCaSVvhiT2nCQAhLeoSDs9NC3Gpi9PY6wA/Vym9cND8urWfzpIJX1Mu16l4AgMPzNad5aP8qnrQgWUa9rX8lycT3HpSuT6K0ec00QDRCiHtZ+cJPXz47QUDUqhyaGT6QOr0wMUlnr92TUuhqtUIDiTt+gy7LMeDpJWg2RCsu836nQ0HWudpv87niG+mrfSKcjMezNKjm/DSZ9Kl8xTyDnZ8vTOBZjLLplMqKEbVuEgxH8OzksTaMWdOE4Dq2NdV4LLbB0iPEgCQIXfQlGbZF2a4DN0EN2YzIvpy8waQdp9BoMGV9sEw3Vo6C6lb6E7ovD/OQHHyFKIt6oh6m5EV4fOsuD2xukB6IsLIzx0z/u67woqkQk4Wd4Jo1l2YiCQLvRYf3+NtVCg+SXFxAEgfs7RXTd5METmC6SJGJ2DLyySM9ycAwLSRGxTBtJkfD4XOyUmkiSxAebR6up02ND+0JgoiDgODYTl0a5+f1b/d6lOAi2w9a7q8ydH2F3rYhl2tR365z78iz/m9m/V7lOm0sDYRr1NpZls6X1GFoYIdRx2M7mCU6lWFre4FLYhZ4Jstpr8I5R4nfPTlC5swamTbPUIHhhgrXcJomIl6FwGq8ZZVcxuGNkMaYmESoVHMfB23PQbYe2X8K0TfLlHIVKHl9siqJVx3JMqp4Gw54AZrdJTM1gPLwPgojusjG1Fq4HOyQvZSjY26iihzFrArcu0nRr3JnoMSu+idT1YLKLqj+9z0Cf/fLFmPUvzKi3ex20YI8XX1qgXK6iBhRu3VkhMRKmkm1QzTdIjEQpF6t0az2GxxKEXB4+/uHR5E6va5CZjKO3u3yy19s0nYnw8jcXuLvY90ht22Fr63jc/mlIRHy4ZBlNcPB4VXaKNdKTcdr5FrYI/pAHX8JHpd1FCCpUW08vePlgO8eV18YQqj1EBIYuDKBWerwemaL5IIfhyIiqhOBVQAOn1CVfatALeBl4aRzBctAkh6xxoJ2RCfg55w2iajZzby6wcmuDXLaEIAhsBSTUyRSebYmdap3i8joA+VvrvPTGFD841HDiYatOI+bj4sA0suVQCIXZ/mlfdEmSJS6NDONslljZyBJwHP5gYYw/dTXJ9zr8dSTEyxdn8bQ1hHScQrdHuXm06MqRxBOTRj/TivxnZ0/jfrRK1BfAyW/TTUSoKzYBT5hWs0GgqxP2enBLCuVeiz/0DRJeWkLrtkmIIq8sDPJBtEes1CK/1T/mL7aeFLpaj1NfHyUQ8PHOOzfxJd39RJ0Dj+6tc/rsJMl4mFQ8wo0f39//nt7pMf/iOG997xaOA96Ai1//vcu8+2cfY+gmaxvPZgd5PCqxiA9/1MPatSxnZtJs3dpBkEV8ARfehJeWqUNYpVU+Pvm9n83x0isjKBWdgFthYTSN09WZmxsiu5zDEcAb8VHeKJOtNIi8NIps2DiyREGyqJk6I4EAZ6UA6YCHqYtB7i5vkM1XSH5tjk7DwEjBjWKJXk+HElxMTbJKg6qh8R+9ZV5+fYKq42K0anHt0TJel4t5OUbr2iaVQpm00mP4hWl+7N7gtZdnCFUMFGI062U2OFp1qh+qpNpxNkieu4jnXh5Rs3AUFVJxOkENWfditGtkOI+hWCwUBrFWF7Etg4DiYeH0G9hb38HS+nkoWTy5+fdh/J1LlDq2w9rKNmJAQKuaROMhdrb6zTKGB9OUtmsU1sssnJrilddPo5smtVKT8XPDrN3agkNNM8qFOru5OgNjMQDaHY1P3l0klQqRzz9fVeKn8HoUzswMUViq0FR0AjNepr8+xzt/cYeh+RFSYxG0ag9TgFqjQ8cwsEf81Faf3mSgqxm8tbKNW1X4ytQQ737/NhO+AP6ayUAmQnQoQlfT6bYNXLKEK+Wj+0ij09bYzfUHkqLKsNeJKOnz8oLmYvd6P5GaFzY499IM+myMnKbxXjnPm1j0rm9hBA8Gl+OA6wSWzk63zc5eItSvlfn9l+cI5ptEXW5YzrMtmeh7PUErd9Z47eUZ/lzb4WGrzkP69Dax2OKfjsfh9sG1UFSVrZB0YkPqrmXwr+0dzixkOOcKYzk2UdnF2UIVWhpOehw5OYq0fh+x18Q/PIJcLLO9d5y2baOtPuJbkTfJb//8+W7w3wQE+N4P/pqvf/M1SoUajXqLYNiPT/ZidA2GR5I4SYfiTpXYUIRGpY1pWChelY9/dp/0cD9PYGgGP/rfPmL+zBCL19ef+bMLMwMITYvyVh3d5ePUxRGaxTYLX5uhuFzGE3JT03v0BIecrJ/YxEUzTH6+kWUmHWO0qfPJW49IWBLtnTrjl0fIbhYxeyYuj0rXsbmzfMAcySxkiLrcXChL7D5apQyEVBdnL09x36ezFDZoXj3eAFrpWHyqt9wwdH5o9FcPX40OcGZulEnc9K7fw8kE2XGq2LqDeH2T4dci/EBcQUqIXJYcRjZ17O7BOfmmRrnrHBTyOdjccF0jcXmQUDWB6haRuzbxrI4ancE9NMLunYeMyROIgsPuXrLDtgz8S7tIeDCFPWqv/fQuHX9ni48CUS+3rj/k5SsX2VjaZWZ+hIf31rHohyIkWSIaDXH/7iqFQpVOrYsgCrz4yinuvt0vXpAkEb1r0Gx2aTYPLIdhWswNxz6zUT81Pcidny1j2w5aRKFcbCK+Ms701yZpaQ7hiBcl7UHqGgz6Ytypl7m19nSu+WFkogF2r2XRdANDNMhWmqCKDM+n+eindxFlkXNfmeaRWyeUCFIrHIRyBs5k+NFeh5qzgTC5dw+YMbbjcPOjRTyvjfFRrl+Y05AcfKqMwVGKW9fdF/N6Eua9IexKG6PaJTIepyDmyHcPwjWO4+DrHeUjf1o89V1vg69dnsdbbOK4FLJxNz/qPVkwzXRsbrSL3GwX+b9NLCD/4Gf09sS9BgQZwwGtUcQwdNJtjXgwRE5RMfe2KbZ8THeML0xn4yQIIrSaXe7fX+HSS6f42Q+v0qi1iIwGSWcSbG8VWLm3jdYxsEyLl15Z4M7PlzANm15Hp9c5uqqU5OOsqscxOBCmtdEkv9k3OtVSi8FMhPNfmaTXsxh9fZRasUUsFuFaq8ydzadXn46ILtburjMRCLCaqzCSiZHfrGB4ROqFBi//w0v86J1b+9u7XAqtuMqso7L76GBc1nWN9z96gPzaKFmzxWzIT7N+lLKq+2R4jN7ukRWSlky31kBVVGy/h5x00Fik1+0QN9JAP7dy1dxGfWGE4aKN0NbQ4n7eCdT25YIP4FC0szyMhnjhfoDe8iKCIOFvyZhbJYQFH2SzOJUayTOz5Oq3kWQ3QqeJqLg4Jvb/FDhfUFT9i02UCv0Ba1sO1VKDgeEEZy/OoGsGnmEPZ85OYUoW9x6uomsG4UgAn8fD+tYusXSIPP2SbLffdWzX6aEIlepn0wCRJBGjZRwr3li5s4vvQpylnRJsQMDrwnYc2icUijwLMa+bUjnXHxtuB9O02Ngu45+Mknp5DEESUSYjaLslBl8YJdnS6DZ66D6JDzt1Olp/9MuGfay4wbEdPLaAIkkYlsX1UpnfvjSOsbiKYZhIkkjy/Bjf6T55GZ90ezm93aOynqcCuN0qwWKb6aEo650m2p4YUtct47bkfqL1kCzv5rrN/zK4jS+lotstjBNWBSeh35GnQDIRImCBLQi0bIfuyjLp6SG2illa2MR3dkmPptguHYSPal4ZWXFhfsGx9MehygqtcotLV06xsrhFaiDG+Rfn+fN//xbVUgN/wEs8HmJlNUtyKIIsH62wBvD63ZhPKOg5jFTYz8ObR3NEO9kqofUy1xe38flcCIJANvV8k5+wtyrDcTANi7XNIsGUn5k3pogaBjnJZOFL87SaPWq9LlW/wFuVHL/uPVnu1ofE/U6FU+dGcF9dp9fT+4Jnc0P8TKwd2/4bSoree8t0bJvCsAq7JUZGB+i4LTRdw+V2U3NZyLqE6Vg4OLxjbSDHJFwJhbZVgKeoR3h6MrvGGsHBGF7Hh1Go07EbuI0Iliwg2xZq20YQREy9jR2ewvlMHZecv5ueerPc4de++Qo33+6zTu7fWCEcC/C1r7/K0kcb2LrNnVvL9PZKxiulBnbUQbAhFk+S33uGy9UO8+eGeXh7u19GHQswOJbk1u3P1vbKwUEUjnOcJUk8wjltdjQEAcZSEeaTMUKqSq7SpGGb3N0poJ/AYvgUxXaXSCJArdjEUPp6NLbt0DJNbi9n+fLL89z/yUMK1RZFUWD41CC3vD2yhaPeTVMRjnS2cbsVzk4PYZsyv6VE6SRVfl7K891KnkuzI7iDDm1V4M/aJZpPMRLn3SGqGwctBcutNhdeO0dvZZegJ4yR8VKOuOgoCv+o68ORRMpRDz9oFtAOiTK1zc8+4VmOw6pxcJ4vOl7Ya8EGkDc6DEdi7HMAAe/AMD8S1jk7PUdobR2910JQfzGZh88NNkRiAeKRCNfeeYjb6+L85RlOz09x7doilWJ/9dhstNE0neFMGn/Ey8aDLJffmOHmBysYuonH5+L8lQnuHy6pfwIc+kV4T1qwtNsaXq/KG1NjDHt9tLoaBa3LvVKZxgmtIm133zQYkoAoidiWje0S6egmpZu7bIpdGprO4FSS1UGRR6X+CqHlFpAksS+8JwicnsgQtAS6Dfgd/xAfiBUyr6ZJ9CQMReAHVoWSdjQ2JwoCsapBaW/1V8PixSuX6Tza4bxnGH3CixoNsLS8yZh7mGJS5F3WsRwb07EwrWc7Eo7g0HXadOUWASFMWDD6SWCgKjVIBw815xYEapkgQSOEkKvg2BpiLAO8/9T7YfLFsLC+MKPu9Xl47dXLqA2VM2em2djcwe/zMjSQ5upf3EHvGfgzXgL+o1zlWrXJxUuzFG4XYU8uQHVJpBJ+JufSiJJILt/g9p2+QU+nQ8RjfV53qdImt1t74jHZlgM+CUWV+4p5VQMtojByJs1HhaNMg5cmhnBWm2x8sITW1Zm6OIRWbfDKmQw/X9184sO1XqgysTCCdlUn224zMRommQyT7ba5cGWK/FaZ/J5uu2M7bN7NsvD6ONnHpAuulYv8xpVxKje36bZ6XJwfpbZa5FGzge04SJLIV1+Z4Hu727yby9OR7X1p0qfBFtj3FkVRYDYY4f6PPiE5kqKhd7E1ndGxOd5766N9j1KRJX7rxSn+pPZsXXro67XMeSIMCm7W7A4rvRoA2wGVpCRj7U0OTVUik56k1a6SUX3kjA4PMglWQiqRWICeLPFDq0V1x8VC3CGUmsKHQjF4fOX2Nwm328U/+O3fZOXRFgNDcdLpOKruYvneNqqsHNlW1wwGR+NUFxsIArg8El///RcAB7Nn8tFf3SIUD5AaiWOmI1SbHbZPaM6+XawxMptk4+EBdzuc8NPcC1PFYz5OpRMUfr7L+5tV4gNBEvMJLvljXLVLtHtHJ+HlXovJUwPsLuYZHYkg9CyGXxmltVGlrlg09hytneUC08lxHtE36ldrRX7zpQnK17cYH4hjL5aoBVQWN5roqyZvXB7nTzy5vgPwFE/a2fOtVFUh2RNYvX+XiCeA3u0SbfrYWH9Axe6HqXzLLl55ZYx3WH3i/iRBYdAZw2W5yCnbbKs7nE0PoeW2aNEkEkri7oIjuZEEiXyoi39+ANPQ6XphR1lnWHOhpF5FcKl0YutPPvj+GeAIf8fCL0bXYum9vuGVZJFYKoJW1rm/dHBjBERqhQbzZ8d5eGcdx3HIDCcYTCdYfmsdudIm89WzlHMV7lw94Ji/9KVTqKrMyEiMRq7BtTt9VszQWJyZmTSLe1Qwt1vB7VFpHGoCfPdhlrOvjdKr9DB6Ju5TERabtSNJpUw8SP1BGVfDorWnO/3gg3XmvzTJxp08w2NhNgu1E8/bceCt1W1OnUsyhEQtLrIuGtimG8sDOx8ej3VK3eMzfs8w+W5ph9Pn4oz4A9Q2mvsGHfphKWmnSdDrotF9/rDEzW6N35pIU17eJR4No63mQRRYtXtsmG2igSCp2xtICJh7PrRlWkSLbbxehY5hPLUptSpK/KGcwX1nk06zwVQkwuW5Ef5E2+IHvRx///w8qXwNodvDMzqNadqEVxrEbRdDpxb45646Nxt7OYw9O/S/82ZQ7nxAFgePqCKJz45B/yqhd0ze/nc38PhcJCNxqottct0qcy+PUd6pcvrcBPdvr+E4Dol0lKmJId7+5BrTL4zz1g8P4tTpoSiXvnya9eUCn7yzjBUPMDgc3Rfu8vlcyLJIvd6lVGoRGk1w6pVRGoU2vqgH0yXsM8Am0zEK9woU9nI0pd0GskumExCYm4tybfuo07JRrtMJepl9dZSOZSMFVDaSAvnbleNNqhs6itoP+XVMkz9v7nLmhQQRwizvVih1G/sytKW7Oyy8Huda+2iV7GHYjkMxoqDKMkOJOM07WWRHpx61aSWhd28Rd9C9X/mtaxqpigDH69AAiMk+Lu9eQH+4gWn0OJXOUJ4X2JrpkQnNohRauNKzuBQPraXbpAIjdM4O85fev8R0enjFEC9sZrAqH2GjIApepOzTg+t/NxOlh87XMm2K2eOCUVbLpN3oYjsOL71yGgcYHUnz0Xdu7m/j9ync3TwaI7718TJnXpzF6Zps7mnA+P0u9LZGLOAmGvUxlInSq/ZoN7qMTA9S7fTY2ipj6BbXbm/g9igoiszO1nHjNBDws769xrD3KHnO1kzq5RbJ+QhP6+1uWfZ+oqplHYQSzHiMSNhLs3b0Ny23xEkaY6Zlc6tQIq/1uFgzjpUl25qBEugbuMfleJ+EUq/LtZSHC4FxIoaIS6vS8sls9voHIMsStm70lQgP/ZxjmPtVhU/DG64U4tWHdPb03NvVKsGbOhcvDvBxp8C/72YJxFyc9w9i37lPu1HD5fagqCqdu9cYuzDPzUP7i7t8hPN5vJLKmB1AqbfA/oKlePeuS7etHampKG3W8frdFHIVXnplAQeIRYPc/PFDhmcHuPXJ0fqD4m4N+RUXaw9yiKJAKOLD7BoEVZlXLo6TX69iGiZT80Os5iqsbBQRRQG/3013p7XfiBrA7lnHtPwLm1XGXhmhbZ0sq1BsdCg2DsZiQApwOuyh0T5q1IWAgtE51O7QsrheLjHpkih0j4ZWDNPEzbMn3R/1dvnWy+NEum6ElSpK2EXW3SYieLFMC+kxeymaDgLCiRWar2lpOvfe2X/d3d0mLg5xZ6HI9sAGF9Ivs/b+B5hmD1ckjG1V4OEO8ReS5JxNRsxh9NwaqjyO1JBwuj0E1/NQGj8fT10QhH8FfAsoOI6z8Kztn0smQBCEXxcE4ZEgCMuCIPwfT/j8TUEQ6oIg3Nz7++8/+6FDOBEgORTdlwFYu5NlYnCQ2ZkRFEEmpPrYurlDZiZFZjLR10fXj3ux3Y5OJOKltBdqSSYD2D2T3fUyD69t8KXXZtm6k+PB9S02l0vceGcFvygzM5cmHO5Xfva6Bs1Gl8BaF1WRCPrc+5KqTU3HH/KAcvTyCbJEYjBMvvmLNWlYqlSInx9EVQ/m2sxcmofGCRb9EAqNNu7R6LH3leEwlfZzxFwew+1GhT+2ivxxoMX6TISlXnP/YalU6whzGYzHpIK1VIiGdnxFMKj6+QfSEP9YH+D3pSFmbQ/mYw06et02w/rBOTcNjWjPot2oIQgiiWCEUV+EqdQQg+ZRAzTuCnAWF5cbPlLlHj5BxdCeT+v7b2JcuzwKqeEo/pCHUraKy1Q4NT+BgkzI7UXqCYRSAcJxP53W0eMOhL2UcnUkWSA5EqNRbLK7XkIyHAoPi6w+yLG2WODaW0ucmxokkfBj2w6NRhfDsHC7FXx7GkeCLIIoHJEFDkS8aJZFV3q+2O9Oq4UyH8NzSDcpORpjVT05f9IKyIiPNXVPjCW5Zzy7ZkSzLf5Td5t/4clRuDjAI7VCw+6Rq5UIjA/QO1SgLQgC9Zh0xKDPykm+3Zvg9xrjnO1FkB+TnOjl8iTtQWzHRCw3MY0uqitAyD1AzDOGRwoQ6/Vd/ygxxrtDqFsBxIYbUQxgt56sWtqHs5cqffbfc+BfA7/+PBvCc3jqgiBIwP8b+BqwDXwsCMJ3Hce5/9im7ziO863n/eFPIUoivqCHzJk469vbVDtdxl8YoZc3yK2VWb11QBecvjxKRzG4/2CdQMjH6TcmkUOeY4yBweEY2WyVcNxPudCk19Ro7vVWDER8rNzZOeIrDAyEMCs9Zi8Mk3L5CF3x81c/vYNtOyzMZ9AUgW5DIzgQYVvvsJyv8MalDJtXt4mmg1TzTZIjEQzRJjAT4fbK81Mc/VmbVqY/OVi2ww9LO1x8JUNUB1sRud2ps1t/+iRhOw7XrDaXL41RX8ojCALBmRQf9hr7sf2I1835cJC2Y/KgVT3CWDkJluOw22rxU7/EGxcmMdeKiKqMPZngf5UaXDw7gbaWR5REpKkBvmccHeTmjpfkqM23K15qDx/Ro+9BTE2fYskXoNk+kHYQBAFNFo7EWBuCTVpWOJMeQ360gtlu45Ikzr36Emm3j5zexiMpvNowMEUZq9xEckmEY8MEo5lnXve/iXE9fWmImlZnO5slMRhl9vQoSx9usrNSxBd0M3p+kOt3HtJq9ThzcYpXv3mG9/7yoLiu09KIJgJEkiF2NyuYaj9cqLUMNpYKRBMBHByiPi+lByWuLAwjnVN4+9oKE4MxeqUulmUTHE2jYSIEZOLuCJVsDQeYvDRMPSJwdefJPU4fxw9L21y8kiSliSCLLFot1msn12i8XS/wzVcn6TwsoHd0/PNhVjNQ62ikXD6mlRA1R+dBp/xE7fGdbot34i4uSafwVraQvC7qp1O0chKeDQ3Z7YK5JD+SN/br8ueVFAt3NDrFRbqAbpRwD12kI32IvZevkd0eemIXHDBVgaAvRbwbRn+0DI5DKBxBmJ9iVVzDVzBxO17sZhZpaBZRUJBjM8D3n3idHMD+nGLqjuO8LQjC2PNu/zzhlxeBZcdxVgEEQfj3wG8Djw/+z4ypF4boOl28cYVqo0K93qSYq5DdKvDyaxdw5RS0bp+pEUkGydfKLD/qG8xeV+ftwjW++msv8sqXT3P7kxWajS5Do3FGpzLcvr3NwkKG2fkBsmtFEqkA0XiAcDKA0TaxdAtBBJ/XhVuQWLyZRXUp3Pt4g3Dcz1d/5zRb2xW2buSoiHvWZrHA3KVhqi6Fj3I5zlwZxGeJzIZ9dAWbB8UypWIZj0vBo8qMxcJols1yvrzfKuxZ0E2LD3NP1ogPuF3Mh8KIgsCDehXNtLgYi+MzoO6WqZ1P0dA1Vqv5/TzAlVSSwYJO6XvbhOIKpxcG+ZG7Qqn35Ca7n2K5VWddbDI8H0CzLXaafQNwR5KYOh0j7HFT6vaoto97ay+JMeqP+swNRVGwLIvF1RVmT81w7f7Ng3OaHOV71lHv7ape4StnL6K8fwOj3Z/UZLeH1aUHvHlukn9PmwveKMbdJR65vQwvXMDXbWMvPUBMHBXAegJ+ZePa5VOZeiNNpVcEl4jj2Ny9tch2ZIezZxdYvZll5MwAP//Z9X1n5ON37/Ha1y8wf2GMBzfW8QU8nL08QbvaYnR2AFsQsCWRxGAEt89Ft60RSwfxqW6WbmwTSwWoVTtUii1+/3//Jf7jv3wH0zgwKue/OkUzqhIeCzGmjiL7FNY6dVYqdfxuhfFIAtNxWCpW9mmzJ8FyHD4unxwPHw4EGHP7aVgmea3NaXeYlm7ivpQh12vzVqBAu6Pza74M0Uctytktxnxuzp4d4S+kXZpPYEzd7JR54JF46VWFttOjZFzFPagyMRLDL3vZNPO0D8lezDZ9dIpZBEFAlhWqok18eZfgmWFq1TVAQJobIu/0u6FmgwUmgqfR73108KOyhLG8zNzCaZprN+klLhFKfAnr+jVsUYRk7BmjwMF8Wib4KOKCIHxy6PW/dBznXz7vlx/H8xj1DHCYG7gNXDlhu5cFQbgF7AD/B8dx7p2wzT5cXoVP7t6k2WjjT7vJbud5/Usv4vaoJDIRukKH+V8bo7HZYfVWluRYjHc/vHlkH7bt0Gi3Wc92mTw9isulUC63uX17e+9zG9WvMjwZR9dNOh0dx7ZABLdPxal1SCVDbN3LM7UwwPZe/L1WamF3LVyOSKvRhfABY2Hl9g4TXxrh9kaOj9b2PJxNGEmEuBBL0Ou4SM2EqeUafPLuGrIs8dL5IR706hRqv1zvzMlImPm2ws57WRzH4Y25AQYn4tz88T3Kutmvxj07xLtCb9+ghzwuBos6+aX+RNHr9OhcXeX11yf4M57PQzNtm7Xm0SIuRRC4iBf1Xgmzq/H6aIKrAZM7zSqyKHIxGOWK5ccVyeB2ubFrLfCrVN2w6hMQLs7h6Zm0PQrfV5pUHqO1tU2d+x4Dv8+FW41jSALrkkXJ6BLsGiCA6ojYlkWtWaMUTiNtr+LIIrb+XNf5VzKuATrdDtfv3GF9T+b4N779ZSbmh6g3m0SmfIzoKXqGdqxg6sOf3ebrX3uJkHcOraOz9NEaE2eH8UYDpEci4EDPsQgnfUiSRCTiZ/Ne/76OzKW4+/EGtu1QXK/wODN352ERK6FyY7v/bFweHWTIVJn2D2K2NR5c36Ha6fHC2QHWfBqblc9WtPdriQzi/QrF3XWSoQDfWhjjvY8XabQ1VFVm7KVRPrFNhtwBwvcaFHb7k3ir2aH9/gpvvDnO980nU5A122JDP8idDYsR5rMejI0SGbeMPT3Ljz3rxCQvM5UQ3vg8ouXQa7ZwIh70sEl03Ic2INONwG3fnf3QR9HZpeEdx52OI5oOpksgr1QxqhYBcwzNsclr68SbURzVxjZ7CNrT5Z0dPlPxUclxnMvPu/Gz8DxG/aSjf3ytdB0YdRynJQjCbwB/Dkwf25Eg/FPgnwL4PSEatRaCKOz/xN07D/n133yT//jHf4nL42I7XiAcCjL70jhmz8TtVY8kngAkQcQwLFaWj/b1FEUBWzf58MMlBlIhsuslbNshWWwyMZ/hzJcmUW9kiYa8+Dwq3ZZGvXwQf7bNg1NUawb6nmG3LBv5sUsS8rl5NZjk6n+6hyQLCPku+Y0KqaSPcrvH8iebzL4y+ksZdVEQOOV42Li9vv+evlFF0MT9BJhjO2ze3OLC6+P8uN03klPBINWPjzendtcNREXo0x+Ffu/Lz9JS7xu+JN0PF2l/mny70+LK3AhbXhf/JDGGdyWPU20z3Bbp3FiholhojkUgHKR8Os2/qa2Ai/6S+QnknGWrQ1g20c1uf7u9w+uo/QrEm1qVC5khOlsbFCwdvwkhRPAGnucUPrdxDUfHtiIc8ORdHhe37z8gFopz98Yi9VqTsDfEqaGZY/twe1yUsjXW7+18uk+QRK7+7B7ekJdCtobjddFodPjdf/Yau+tV2uUOM+eH2NmsYJk2oiRgdE1EUeSwTqBpWPuJ7EtjA0QWezx8sMH0RIKNOzkCaT+mz8XKjSxTL4+yJdSfu3PPaDAI98oUc/2JIKzBrT+7wfSr49xc3kLXTUrXtznzG3EijkJpd/3oRXcc/I2+VIAqShi29VTeiEdSObftofJgr9iqCUKpyn/xay8hbdVIqD7M20tYtRaiT6KJRvj0NHfT98iaxzn/DjZ1b4eK++hzovribLi2GI0NYPR0bKuO4ICIG8H/bE/d/oJ46s+TKN0Ghg+9HqLvtezDcZyG4zitvX//AFAEQTgmau04zr90HOey4ziXfT4/0aEgHr8LVeor2nn8Ltb3vN+puRG6VpdHaytISQdv2MWFi0fblEXjwSNaDwCqKjM9k+L0wgBud98QF0st0iMxBoajBCIeooNhfvSTe9QsHTssEYh6Wb1/EPJweRWUgIIlC329lUMYnU2xXqkdee/L82Nc+8sHaD2D1FCE7KM8Wr1H2uUlYookUUmhEvCezJ/2Z59uTEVB4CtjI6TLFtNuP6OBAJIo4HZEqmtlItGj+uqK1t9f1OtmIhRmIhHBtVdqrjT6tsxWJWRR5JvBDP/QTPAP9Ri/Hcjgk589zwtAtHG88pZCnf9TeILBnzzAfWuLUcWL09ZwTIuQIyPLCqbPRbf6uIrlybjZLWHPTe0ZqD58Q8N8KPUn35rR472oB/f4FF1sPKkBtHCQ3FPocofwuY3rvc/3x7bq8qAqCvFkhHAswObaDj6/m9HpASr1OveWlgikvAyMHt3V+YszZJf6x+4Lupl9YYxgMoAki/RaPTJjMdIjUWS3wkapTlbrcOErM9z+aJ1Ctm9QBUEgPRVF6x1d+memE+QK/W1OecIsfrJJOOaluFHF1i2MUpdB0c2A4CLUhkjg6Vr2n0IAvhIdIFq2mJb8jHkDyJaD44CkHYzrbksjYaokPX5mfBHiiufIrOp3u/kH4jD/oBrjD/RBXvOmn/ibk0Kc9upR6u9ocojpmz34+TLidh2fu89Mc+vg8ngotyv42k8+p2ykiit2ELYTZRVjdoAN8z47UyrEIoipUVAUnLgXrfFs6d3PMVH6mfA8nvrHwLQgCONAFvgD4I8ObyAIQhrIO47jCILwIv3J4qkKV4ZhsFPYJRDw4TZVpqfGOPviHDc+fMCpM1PsbBWo7knY5nYKbD0q8PLF87zxpYu0ex1URUXQYPn6JuwJe/kDLkZHQ9y4+ghdM/nSlxdIpYPkc419fu7pkRjXb/QJh/Vah5vXO/z/2vuvIDnyPM8T+7gID61FRmak1khoUSigtOiu7e6ZHsXZ2Zmb2zkub7l3R+7xSOMD+UKj8YnHBy7tzO5hb3m3R3LlzO7M9Iie6a6uLl0FUdBAZiK1zsjQWrjmQ2QBSCSAQvVUF6q78wuDWWaEp/vf3X/+85/8/l56cZwXfv0wize3CUY8jJ/t54NLc6iqwYlXhsmvlCjaOl1DEZp+geLWXtdUMQX03fF6raaG2++m2aqjNTWqu1zZ9WydYz1xVqtVunxeCs0W67nyU1lDLya7aV/aRlW8VDbLiJLIUF+IJgaRiJed1l4+ed0pcjwWYyBvsPnjaZ6fGGAo0yDrsii223h8btJ+m+/Y3bQ/WWFnl4tdFAV+7aVR/qT2xZ24ltjptO3tiuNxKBSaDUbDYfSri7QyHdfaLNdxaCZWKoLgUshKTTJGFacefyoODd22+FdmhtdPTxFrm6gOiZ9SY/UBfvXLjTy3FJl/lBwhnK0SSpcx6k9V/fJzkWvoyPZ6eoPRsUFkp0zfYDc2NrmdEs1axy25dvkO5185zM5aCVXV8brdpGdz6JpBV38UZ8zFZ5/d5dSLU5gy+FxOshsFzFiAQ30R7s7v0GioxENeXv3t49y9so7Lq3Do/AAf3VrhxJujbN/NYegmqbE42406hmF1uk53qRtaTY1IwEUr36JZbhM2bUqZGvH+MC+f6mOzWCHbbLFReHwo5sVoN/p8mVa+gdbSEUWR7pEuqpSx5fsv44DfzaQjzPxHiwz4wth3asS7Q8wZZcKxIHHRyerH98m+okEv5850cbGxv2/DEGxEUcTj9pIMxlEcCpGGQG1mGUNTMZoaer2Jb7iPutqgEDPY1oqMGt6Od/gIbAkr6EdTpGrjiAZU/DpL8lWwYVG4S6k/xZGsH9GMYqzO8GhH7z5s7K8sUSoIwr8DXqMTe98E/q+2bf9Pj9v+C5W6bduGIAj/FPgxIAH/0rbtaUEQ/svd7/858LvAfyUIgkGHj+/37S9gWBJEgV//nddZXFzBH/Djkb1IhsiJk5Nsr+eYyXdqdmVZQhJkysUqDbXN0sXNe23L905il7FxYDDC9voO51+ZZGcrT1tTOfvyGNcvrZHdKTM82YPoctJs7BXSjz+Zxx9wMfJcN9Vqk7999/Y9K/SzGytEo16ksSDT5TLt6v7kR67RYuBwN4vXN8lslHj+pTHmcnXE3fF23qAbVYRRX4DGfImd9DqhqI/XjvXz8eoWyZCXZMyPqNuobpFrxSzN3cSqU5bw5TXWC3WsQ2EUjxOtqWKV27TDMrFz/cy8fePeNe09muJKu8pZ3c3mbhz9xuo2kyNdHIv6mdObrPSY3GgW+H7ZR/2B4RqWZcNiga4hD5nm40shbaAUdvLC4BC122uotRa9iRD9E3E+3UoTUxx0j/Yhl1vIuoiz3sbodZExmyCJ5PxPJhR7EE3L4IfNXQP6MX/TNg1apRJXl2YIBcKMTH3x4Omfl1wDhCIBDp0YxrItUj0JfB4ftWoTU+vIrNOlIFgi7719if5AH5n14h55DvcFabTbvPxrJ6hVW7z6aydYmd2m3dToOdqHw++msUsbcfXWOh6PwtjpLlqqzo8+vYtpWqwK0JUIIIlObqym7w14tu3OSz8Q8VLON5h8qYfScglvyE1L13H7XAxOdLF2LUNmLU0kEWD0SB85vY3P5wALqm6bq6UsAhAqmcwupXnuRC8rF1awLItyqcHIiQHSeicE6HDInHhxggvv3UDTDG77DCZOpvCYIsdGUlRCIjff3puqqFca9NcSXHxELGHJyPLG8ZMoV7JUL23g9AVwhcLIg13E9QBup5tWpY3RLiD3BKiYVbzhMAVf+omDprP2FlnfA3mmB7YNGn5a628jSE4cU8NfJAIAX1n4xbbtP/gy2z9V89Gu6/k3D332zx/4+b8H/vsvc+BKpcqf/Ou/5Df//ndY39ikobe5+PZNYr0hzr12gunpBbx+L0ePjHP7UoeL5POxdI+aOxoIuonHXVSLAlcu3mZgMMmt6wt81jb4o3/ya9y6scXWVonG9qNd/1q1zY3ra4/8rlBoQKFBe8j9yO/v5guc7I8wqQyQXS1Sqbf57v/uZebn0own3LRsk7ams3pxg1yhjGXaFLM1Gh+3ef3bo1Tm8mxdW0Hzd3gzXnt5iLdL2ximhVtxoBc7VQE35zaZOt6DxxRwuRxIw27++cY8x873EdBtDIfIR9UiPtFJfeN+iWGjoXL17jqJgRgXwibF6RbOUSdWe/8LymzruMRHn+eDMEyb/Ha+U+kjiRiKxNadVQh6CUWi2HNpSrky8aPDuGIedvJZpsb7mB/y8VPj6Us+RQQmPGH6cbNNm+lm8ZGdei1FRgHK1RLr1tPlLn4ecg1QLlWIRsIsLq0ikaGaWaVltzh17hDrSxmmDo1y/ZO7xBLhDqfKA/Ic6QrSNRrj1q1Flj7bZnComwsf3mDi8AAnTpzl3Zkdarm9+aNmU+Pmnb3X1LZhJ/NoWb9bKzL8Qj+VtTKZ7TLP/c5R/BE3cysZhnoGuPBXt3EFXFiWTX6ngt+WGOkPcelWJ4btdim89nIfF2pZzLLWUdS5HBMvDSOpJopXIXPIR7FcJ9Lvpe6EpXoVbddQKdebXKp3njX/+CB6GwRjvyxKhv1Yj67WaOBpNXH6PUhuJ5V0ntDpYVwrdXZu3SRxZBSh1qTerDI6McKFUQ1lt9rlcVBEN73GIJItsiVv0LTvX7+qWEX0hLDqObTyrSfuBz4fkvHFRGw/DzxTQi+HQ2Z1dYOZmXl6E70A5DfLzFxb4g/+0+9z8b1bXHl/Bsuy6OlNoBYfTxLVPxjkysUZ1le2qddabKxmeOn1E1y/vMTqcprlpSyG8XdzhxSHxLGeBFKzsx/DI3Fzc4d0sYYsigz2+hkYGcJUBKbzBS5fu095cPJoH+VCFdN8cEalTpetMPNAktc0LTaubjJxOsZ0Pk+l1UZJhmElh2XZ3JnvWBL9x3t5by1LWzf4ZGd/ItQZcENxb9OSw+eiqZUBKLVbCKkUrO9VEM6hKFvNL45J+5sGd5tVZFlEcgioWo1R0SYWi1I2TXyaiiPgpmro3BabKCNB9KEw/+oRiarHQRZE/kDpxTe9RrNaYdjn5/ShIf6tsYX2wCg8RZT4yKzyDwaGaaw9nv/j64LL5eSdtz+k2WzR15vC0fYQSvpIxCNUt9pcfu8Otm0zOT7Mwid7lXHPZIKrl+9y+8YSYLO1nuXFV49z/dIcvhec1GpP11j1OWRZ5PBYD+Kul9Dsc3JzJ4sRD9NzOEzQ7cIUZP78nds0mxongVZdwxFzQ6uTz6GqYdY1lLKNFhJotTWMhSruXgkp7oEFqNbafFbrhDX7p3p4fyNPQ9t9XmvwvfD+SUGSJKLKNnNmlZd7Y+Q37le3SKJIJSg+koc/5ghSXcuwIZdRojI2LcbEIK5CDcNsIXgV8hvbmEeTbMsmZkLgA2uFbz/hOsXoYWy5C3V1FdsyOZ7qY3NcZUPoGJQlOwdjSbhZ+UIu9Q7sX1HqXTrUuw6xU8P8eZtvOVOjvaPTk+xCkRUikSCKobB8fYtgzEco4aeab1DajZMHIl7SGxkMw0LeTQgKwPZ6hjPnx7Ask/7BKMsPVch8WZxOdTPz/hKGYdLbGyER8/Nrx8f565vzbOQrbOTvh3X6osEO18dyCdkl0z2ZYG5uP+HVI0ghadRUuqVOkte2YY4W40dTbM2msSybnpE420Gbdu7RdbDFZhtrIIZju4S+ax25PS4qUYV2+v7ffEyF158bxp1v43M6MWNufiwUMepfLIz6bjetYVn3qnFXjRYDwzESLRN1PUfFIbGkVWhlDMRmFWko8IX7jTncfIsoobpOMhzDvjXL6m64rFmv4bg5xytnRnmnscUJd5SzbQfOeou2z83tqEw0eAxd04HHhhy/Fti2TSDop1VXcSpeMstFzpzxEA4F8R320N2VIDNXpnsohiiL7KwWcDhksrkStmXtMnAaSLLE+kaGY2fHUDyOe6yeT4tjEynmP1nDMi0GRuO4ZYG3xof4q5kFPg94THRF6T2cpLBaIpz0UxkMs1Xr5GlkSeqMWnyoM7RWrBMZDnLHqHP0WC+bM2lM06RnME42KdEo7FV800adI4MJMqv3DYbU0V5+qOep6hrpsW6GvW6CqojiUsgnZf5YfzTZRtNuIwZCUAFtlxJixVUjMTiCZjVoOyxqHpvN8iI24Bt4dIJUFGTG1cP48w561R5q8zO05U7ysr21Qa97FHWwj4FiHEdFh1AJ6fQLWM1tcNg8iaURwP5VY2l0Kgo93d2kEt3cac2jxBRsOlbI4cPj3Hx3AdO08Abc7OyWa02+MMRmdps7K3PEkxGmXh7i7qed2lxZFMlmakTiIWy7Y6F4fC42VnOIkoPMdpXh0S6WF794JNijEAx5qKyVMS2Ls6eGWLu1w60bGfrXqrxyto8Lm1u01fsKc6NQYVuq0dXvQzdMNueXmJjoYuXOfas6NRanLNx30ZSajeYXCMd97Oj3LbKlcpmcS+HQy33ICFyrl8nnnlxH/JNMmhfO9RFrdZqniy74+AGL3rMpkh1ooftiONbrbG5XMAsKhw7HWRAqj+3w+xw3aPJCb5zy5v0XZWiqn/93bhmnKPG743Hyd++Hs3zxCNdc7UdaXp/DJcn8/VaI2q0Z6oC3W8O5VUKLe9mx2kx29RNoG5wsiExGR3HvZCiuL9wjnzzc08MPkgprxtNV1/y8YFk2r7xyno/evUyyN0wt3UaSJZrbOs1VHUkWyRTLxCeDTM8sYmg6E8eGERsOVMmgsl0jHPZhWhambaE4ZdLreYyowbHD3dy4/XRsmB6PQivXxOEQmTjay9yVDaq3dcZyKd58foifznfCKXOZAsuyRNeYj+tUCXe7MCod+dINg8FTg8xv7G2IC/eGmG/WqWkaBZeTw6/04hAErjcrZB7RnLRWq2JPeDjcO4SjZaH6Jd4TOrNuAXbsFqMOL6W1Ii3bRLFDDHcHuGPsz0tX9CaNkRSOHQe63nl+DIfAJ/1logE/xevb9woQ3D4vG2H9kYyQU81jyBfWMSUHekND2qrS1d+N3RXA1RBwbLroVyZYW/kpqlZHc6aRfBGMszpt+cYXXH37K+N++bJ4ZkrdpbgQVQfpxRz/xX/xD7l+cQaf7GN4cJDaRvuehVnbHXTRfyjJrbuz5DOdWHGt2iCXKXL86BTLNzY57FJYtGw0zSYUCVAt1zh6chRZcnD96ipbGzl6+uKIkoBl2siy+KXCMS6njLnVZHgowcJnm9RKu2V1uTq5j1eYOpfi2treMIhpWmw/MIR6M+Zg/JUhaJngEtnQWqytbnP0uX5Wbmxh6CaBoJvIiSTXdvZWoFTbGpee0Gn6MHTT5IP0/rDMg3jeF6fwyTLpz/nV2008jTYnn49xpfxkr2ahXkHuC3G8ZxRFM2h6HPxQK1Nra9SAt/0yLzw3jqehoboc3Ompc6f15H2edEZp3+woGgEwRAGxrZLQfYRT/bjuLNHWNLRqgv5l8CfjFLnPLFbf3uZM9xHWeLZKXbAErBr8wR/8FgvT66TCMn3JFEufpe9VSU2+3M+7P714728ufXKT8y+dJO4JcffWCpFUEM02qdeavPDKMYymztv/4TJdx3Xi8RDFYgPL2j8o5UE4nQ7adY2R8W5uvL/UaXZyiWwv5wm7bfp6g/e8S90w2dz9eTAaYuzlIWib4JLY9gl4Wz6KhU44L9EdpJFyUit0qpxqqspF9Ytlc6FVZoFyh13xgXCzKAicqvpYvvXAkI/ZBkddA8x5xH08QwDvSsuce2WASEkAAXJhk8v2AqGIh3MvjuEpGVhOkfWIzpVHNDU5RQ+eNZ2WoWHbNoLbhW2bRNwparfmUbUGijtBa3mJ7qlx1vXrAJj1Io7iGO1HzwK5hy/ZfPSV4pkpdaNtM9V9BK2l89H/5zbBqI+Y4mf1YuaR7qUSlMnf2ssvUqs0EJydbVeubfLSt06ys50jkfTT3x/lwke3WVxIMz7Zz/ihFNVKg/7+KF6PTLPexuVSUE37qcIy+XydI8PdmCKsle5XhriDLor1+p6a3MdhI19l4xEK57Kmc+h8L7IF22GDn+5sPnXjx6MwEg4xKrmRNAvNI3G5XKDa3l86ElYFKg8NzGg22nRpjn3bPgqztTKzlDu/PHRay40ay9QQBQGrbcMyyE8ewE7AlvFbIr1CAEWzkEotgmNjVBsV3HWNlqbhDAVZps2ApSCspQnHw5Qq9ykG5Eck0b9uKKITbyvC3I8yBCIR1JbO3cX7isXjd5HO7vcYF5fWGOsa4sVXjpEvVegajSE7JC68e4NGXeXky+Ps1DUOTyTYWM2jOGVsSWZuIfNIealUmgyPpLCre8f9ecNuVlfzjI8Os8F+j2+1UGb18/u6i2jAw9irQ2hRWDebrBSebDA8jFPROAlLQDBtKgH4VN1B3c2LRF0ezJX969DWynSd8rHZ2P/MGLbJxyxDaPeD3dteMOv80LGImBA6CfXHREAcoguxYZDQu5ErAu6eCLK7hlQ3QNcRBBHCXoydDKxs4R1KgrbrIRlPLmfs4FcwUWpb9r1GC4BK4clMhOJj6DrFXe7sZq3NnVs7+P0uwtEwf/EfP6GwG6KYvrnMidPjDI2kyG5WuPj+/caB7t4I/QNR1teezBxnmhYltc3EVIrFyxtYhkW4y0/V2p2YovzsHN6Nts6V1d2HZB2s1FORZz4SI+EQI2mTzNoq0InZv3FuiB+ZnaTqg5BqneNEFCddloKk21iKQMPreaqBGk+Dh+mAn4RtSee3vXEqd5c61Yv5IkpvD46XTiGub2P3xFkUdWqGStmhEFBtHA80SzndXqYVe9+8y68bumawvdRR2vnt8r7vTcPEp+wvmHY6FZrVNqszaQ6dHaa4U+HCh/cJvq61Z/n+H3ybH//wGq1dTqRQyMv40QHmFvaHPCzLZqde58RQN7OX1sCGUHeAhmTidMq0raeP+RaqTQrVJjXxaRTaXpyPJnHeyJG2O3F6hyzx3VeG+IG2CkDL0JH8QZQdkUHRh1O1sQUBZzjC++aTn8vH4Yu4zBtGmXj0FRqXL6LbFvl8ifDwJM5oEow0hsti25Em4vJiaxqSuJsPEh1YoadJVtvPLKb+s2uPrxmF9TITU0N7PhsY7qGe2at9dN1kZXEbj8+N5wGK0GKhTDwR5s6N1T3bpzeL+Lxf3AkTifkI+z20Sk3e+v3TxEYi5AyVarPN4HgXG/Unv5S+LHqCPs4mk4xEwo8csfc4jEkesmsdheLxKHR3h6nO5zgc2U/NO92uMTyRorsu0twoUdsp4/N5kLbr9Hp8+7YHCDtdTATCBB+hlP6uSBkOCn4FT08XoiThjUTQkxE+0Yp8Epe4ZdUo7g4S3tIbaCcP4fB46fOEiSZ7KBwZ5fLTdZM+U6gtnWgwjOK87xEJgsD46BC53alGlmCxNLNBNBG8t83wRB9z0xv3FDpAudxAesyL0+GQiAS9WIrAc9+aoHcyTl7QKDXaTDzXz0L+Z1OYAH2BAM/HkgwHg09sw5EEgUTVplpuIggQjwSIhfyYcyVS7g6dQ13XaKRcHHaG0dfK1NJl2rkqTlHipLh38oVDkBhQ4iQdj5mI8ZTwiWEqrRzu8SFExYnD5UWVDWoJibQvS07aoWFVaSUUPJOHkVUbR2AEx+kxmt6LX7h/G7Bt66n+f9V45tUvT4vCdoXhoz2M//0ByrUasinTzmmsTd+P5clLW+jjfbhcbnKZOsFQgEisM8zXH/KTz9XvNWE8iEfVvT+IQNDNqcl+MqsFSiUVUxA4/+YE9bqKLQlUHSZLDyQF/y4QBHitO4U6WyK7vU4w7OWtE728X0zvs7QfBXGXX/7IeC9SSaW+USUW9zEejnEtm93jpm9W6tinR/C0JXwDESynxGqtQuZ2hmOvDrP5wGQOAfhuKEVorYZaKHMmHiTbF+UnTznCDnjiRCQApwnTGyscG5mgb2QErVSl1tAYJML/IK7y28emEJc2ME0dZ38vGyEnQk3AGwojuRRqWM9s2syXxeJnm7z17ZdQJRVN1XCYTtaup++HSWxolJs4PU76+hPYNoR7Yqwt7k8cWo+xuF86M0J1q8bmTIZkf4TTr4wyhYWqwN1WGTX/5YeJSILAm9FeardyFDJ5YlEfEyf6eKeyjf4IOmeXQ8aqafh9Lqb6ElQWCpiGTmIiQtspsLXbDT0j1Tg8HCMR7FSqtFwCl1dWiLl7kH0ihm0xIieY2g7QWi4gOh2cnpzkA+8qdevLlXkCOHBSz29BME78ubPYlRaqWadlabhPHEWbX8bSNdw9o9QUoOTD9uggNbCfKqzyK5gofVo43Q5cHieBmBdPr8IHP72ErhsMjfQREkP7tjdNC6fLgy/gplJuIUkisS4fx08Oo6o6h4/3cfdOh+XQtm0UxYEgPTl0cu65ES79xTSFbEcAo5tBYt8+zMLsNnNrWRwOiedeH+XC+hbmY8rNFIfEcCKCJAms5SvUHzHsF2A4GaH1wQ5ZraP8SoU6tQ9WOPVqH59mvjiOqXkk+nujqItFqrsln3pbp3DB4vhEnBvZvfmDynqD5bX9pWOSvlcgT4fiKNe2ydc666rVmgSKfo4cjXKn+oWd83sw6YoyqXcanBaVNndaHc9iWVb57eERPMs51rY6YQdRFHE6IDLu4n8Udpg4msCJSI/kovvyFYzd6gdRFHmFCYaiw6zbbf7Zl1rR1wdRFPCHvYycSrGR32R+ehWXU+HIkQkk+b4cppdyHDk1xq0r8xiaQSjpR1ZEJqdSWOYmxVJnBKMgCDhc+72mgYEo7WyTz97phBorO3W2Ay78vQE+vrNCLBnk8FSc6fRDRHiCwEAsREBR2K7VyVX3NnIdDsfIfLpJY7devpir0fiwzYlXu/mssL+lv6HpCFE3h2wnqx/dH2hu2zZdqW5kpaOw3cjcWlun0dhbHmW3TZSghGyLTG14yN5Z7XxRA+GTEudeHeIdxzxPgoDAYUcPU2UvtgQZ/zYVO4dr+Bz+GZvi8mWsXTlyNhtsf0elcV4kyRiFq0u0yp3z6tZUlPYk4eF/RCt0BXjC82iDbR+EX/ZAFAXGz/XhH1dwjdskzwe4MXeHJnVcAQd3rs/RlBoEovvDBHOzGY6eOMS5l47ynd84Q/9gkh/99RV++IML+EMKr357knjCw9TRFN/73bMsLj7ZZbfaJoVsDVEUGD2UxOdw8vEPbtPfHebE8X4Mw2T+s02GuvaHOADiIS9no13Ur2UpfLrNlOhnvPvRLG9xxUU5v/dBMgwTV+vpLNArlQKjR/poFDv7cLoVHEkfm9kSCXP/OzwvmngeIhpzuRQKrr1KPaXKNGt7rexaucaw+RQkLg/gZVc3Z283ED5dRPh0kZM3q7zpSuEQJUYtN2OOCDFTYWBsAn8iBj0xZrObTOluDNtiulngWjNHtK7fU+gIAsdTwwSuz9J/bZ7Elb8zJfrPBd0jUfrPxggcEcmwiS63MJ06tmLx4QeX6TlyXyaqhQZ6QeOlV0/w5m8/T6o/wdpqgXypSqovyOhwlLGxBL/598+xsr4/jDLcF+PGx0sIosDEVDeYNvPXtwi4nZw80k8uXcHbEpAeiJG7FJlXU71IszV2PtigJy/wfP/e7HbEkO8p9M+hqjqB9uODMMtODTfiLiMreANumiGJzN0MA+5OrHpFrRLo3//8WDEXTUNnwhWmtrT3ObVtG1fGQBaebJS9Loww9GmZ9sdrqB+skboSYdQ4TkTqQynJhMIjREaO4OyKk5cyBApOMvYGZrNxT6F7fV0ozSGMz+YwP9hA/PiJh+Qrnnz0pfCNtdSHT/Vw4fplJKdIqVniyp3r9PX10m5rtNp5BqZSbJfTnH7xGGY9AaZIs9VETMbZ3qwzN5vBH3BTLJSZn+1UHjgUiTu3F+kfTJLsj7KTLrH9znX6h/ufWAGjaQZ9IzH6hmNk1osEgy7CUQ/FXI315TzDQwmWlrP0Orsf+ffj/hDT73e4bGJxP35bZMDhIznkZrlWZfOBskdTsJEkkYdJKmz56eLq5ZbKtFpDTPlwIlC3DAq1zv6tR7zCb+YKvPl8P847Gcr5GsGID/loF+9V93Kt2495/ZtfwixQJImRZYnKAyyX9VKVge0gv9HTi/PCAkumG89OGdeOhPPUGJcyC5i2hYhAWHFT01UM28IUhXsWSTwcQ1naQG+3sQTfPp7ybwK8AReap8ndmRUMRWN1dQOf38exI1MUixXCgz5sv8753z1MrdCi3dRoFlTKWzUWFjbIbBewE0GaETeVUoM33jrF/FyWt398hakT48ze3Wsl12ttQlEvp18cobBdwXJKHDk3QKPaZmshw0B/lFa5hcvloNHu1Iof70ow/e4SpmkxPBgn4nLjKQh8f3KUD9Y3qDZVLLkTInz4Ej9I3vUwlqplJp0RpKEAIrBjq1T1GlE5gLGr1BqGxkIPjBk9ZJd3cDhkYod6+EApgQo6FoL0iGNIj55L+jnCso/w3TqVRgN27b92vsjY3PMUl64jZeootoJYUjBPRWgXNvDJgzhEF5YE7JbMRuQExuruHAsRrHbtMUfcvR7YWM+o+uUba6lrokqt0kBUOkT6siRz4/odRif7iSaDbOXSGILOyvoGV+ZuUKHMx59c5cMPPiUUNQmG3LhcDpoPDMkNBF1k0iXSW3k21vNsbxbJZysoX1DBpws2qcEINz9ZYuHmFrNX18mnK8guiVK+ht/jJJYMkm/u76zxuBy0ch0LNxh0k/L7uPvBClf/5i5bl7bpqkt0he57G3PZIkPHelCq9wW1qzfMut3Z99MMd55pVDCjbtYadQqtzvmHEgE2rP0hH8Oy+PH0JrcPubBfH2DmsIc/r27sqw2eE9sEE6E9n0VSMWbsp+eID7lcUNj/MAiFBoNlG9swKUgmliJTsTTK82vEwlEmh8eYaMv8/prI/6oV5wV3F9NOHXeos56wy4NWLuMIBtk0v3x89etA91iUW9dnQLZp1tsoToVKpUo47md1Y5NCuYBu6/z7P/8rilqRjz7+jHR9h8Gj3TQbLcxYAL/fRXanRKXSYGkxzfZWkWq5iaXvv6/pQo3jLwxz89Nl7ny2ytL0Njc+XiLc5SOXrhL2efBGPTTV+52fUtO6p9CtTJvZj5a5+vYcG++vcdofQ5ElZltlBg7tNV5SI3EWzNpjZbOlG9SjDrasBit6jeruhCP/ZIz15n2D5mozy496qmhv9FF4OcF/9GbYVDt5nflmCf9Dx5VlmWpSwHxCsjEh+lDze8slQ8EUrVvrNB0tZL8HlRYttYJb8zAYPUVwQ+Tk3XE8RhBvf6c4Q2p3jiG4vJiu8mOP9yAOEqX70FFqikuhqzeC2+dC8SRJDSRYWltDUw26u7tYX9mmXK4jLK4QT4bJ7ZT47NI0r752nvm7BUZHu9jc5TcRBAHLtEj1Jbh9/X7dsPUFwyE0wyC9WcTlc6K2DUJRL7YkoDY6b2KXR6H/ZJILy/uJqnTDwuHrXObBvhhLn3QSqpJDQjMtVqZ3GH9jmEy5I7zVpsq8q8XYK0MYsoXlktgUVWzL4NvhHqjp4JfZkjVmCo+OZW9UaoT7YvQnBtALTRwhNzs+m7lsx32VRIHnEl1E1E7jRkY2+bi+w/IjapY/x1ytRGgizmh3CLvchIiHea/JSu3pO3QrbRU7EoDmfatSBIaTPYRaFvG2B80t00wq+KoqDkR6J8bRVjeYX9mNm27D0XiU98e93JpIcKTWhSa5CI8Osdwq0TKecT3j4yB08j0ORcaFg6FkL416A7fPSaPRIJXqolAsgWQxN79Ed2+MrfUM+bEioxN9XFlOI0kixi6rZjDkY3Ghc+3Nzyl1HzBYq9UmJVcDT8BJo9LC43MSiHi4cXGFaMJHvCfAtF7d8zfCLvVD2O3i7mYnXiyKIqZts3Rlg7Hnu7jYyrMYdzD+6hBSw8R0S1ghmcNlg0OaE9GvsKK0mavsDQm9X83w0muDKFttLN1E6PXynpxD0AXOuZN01UWwIeuw+LSR3lcKa9gWF6LbnHlxBHGrgeB00OiV+VhcfiLzYs6ucyQWpL35ucElELSjuKwWVl5D9nsQXS7MSoOAM85O5ho5eQcbG3F9C+XFkzjCCmI5iliNYvlqmMLTyfzPQ2E/Db6xSt0puPGHvKhGm/ROhnZb5fzLZ/AFPfy9771KPl3k0ke38Ed8qLqKpuv4FQ+CINDbHyfR7aXZsGg0Lc6cm2Tm9gqCIPDmd59jY7Vwr8FJdkjIjifHhdstje1sla6uAN6Ai8x2mXazSd/hJCffGEfrUbh0d+ORDSC6YWKFO8lewbZ3k1vgi3lYK+9aKQ91tqaLNdLFWmcgdRuiXjfHa26WZu533HX1hxkeCLFcKj9yzbfyeaZFAV/ISUOtYzTvH+ONrh4alzbZ2XW7vQE3r77RzfvVxyd+xnwhJn1h/B6JjaSbD4ppyrWn5M/dhWoaLIYdDOXiNNTOi3YqlkJtNKiYoBcqHa6OVIzNgIh3aogtqYKZ3ltZVM8VODIc40+NbT6VBJyizO+PJ3Hc+tkoIL4O5FYqHDkxTqa+w9baDsaGQSwZIRD08Yd/9FtUcnU++ugKhmESCgRxeV2MHxnAHXIS9Xs5GvCwsrTNwHA3ye4oqyudF7ogCLi9Hmx7b4OOKIps7ZSx3RLJkSjVcotcvkb3SIwTL44xJzZYzO1VvDlbJdYTwH6QBjjpJ9NsoRkmXbt8RKv1Kqu73WY9oo+JuxJrD+SlUsNxGr1+Nuv3vbK2YfBDbR1PtwNZEKnqBdDgW+5erE922Nn1qN0eJ2+92MuPWnu7QBVRol+OEvWGMQ6FuCVvMtte/cJQW1GvUx5L4il5gTwRM46Zb0HSi3Z7CY0yvp5utCGZqlIiK99/BizTwEgXuTJyi81oH2+JbYzdLm1Bdj3miB3Yv4rVL7JbYPh8nMqqSiG9v2Ns9foOv/V7b/HOhx/Ql0oxNNKHZdm8/9ML/M5vf4//8D//LQC+3RKo0bFBZi4s89zrR5lZ3eTddy5gmRKnTh9hc03j6KnDu5aSC6+vjdtTIxDyMTk1yNzdJ3eUbmyVGJroYuH2FuGIl2DMS8C0iYxEuJnPszjzaOKhz3FtLc3xcz3EAkGauSYtzWB7t67doUhoj7kLvi2LekrkkDfE2uXVPd9l1ksMDA+y/FDn34MwLZtKc284IuR2omzWKbTvu92NaovUkokzKaOa+8vcfj3Uy/GSTO29RVqlBiOpMPEjMf7WXWar9eVG9H1QzpAfCXMoFERCwDQ8zF2+gcvl5MRzkwQ2yribFpHBIZZUkxHbzwL746bi7q8WNi1L59/o27xycpzztpeALQH/ry+1rq8SDo/I6NluVq9nMfSOZV0p1Hn+xSmsdY1Wu5dQxE/fUA9XL92iO9nDp+/fwB/yks0WOXpiAnSRSxdukSkVCbkCHHr1eXzBMLGol631LK2mRjQeYOroECsb5X1rKJebDB/q5bN354iGvTi9CqIsMv7SILfaFRY293t585kCU+MxukNxChtlkEWKutpR6KkwW40aPDQpcEIOsLm4suezreUc44NDbLI/1NZ8wJPyygqBDY3tB0KkraZKZK2NP6VQ0zsy6pFk/jNlhP6PSqRv3EaSRM5OJUmem+Bd4e6+YzyMd+0lDr/Qw7AkEKkMkFufoS5WiU5NIi5VkeouwqfHqC/fxYET/UHifstCQGCbFdrH8nj7X0GuRLDcJvCTJx73WVnqzyym3mjUefsnP0ZOqnh8+996umawOZdFLZqE5DBzl9ZYvLqBbMuszG/y6uvPE0tEsAybP/yj36CSaTIwluLGjRkkSaRWUdE0HcOsc+xUGLenTd+AB9M0aKkSh45NEInFuXVzm3b7yS57tdJC9Dk48twAiAKuiJuJF4f44dwyi+n9D8dIMsLZniTPxbt4brAHj9PBtbU0fzYzj/NElIZkoRsWgZCbQ68MM7395JeKaO1PTAFgfPmEYMDlol3aXytuVNr4HpFcGPYF6dpo07y5TT1fxTRNyut55Ds5zj6ipPRpMF0r8QNzk7+yt8nuuunttspSJk1DsCn5Hdxtl1icmaW5mmH4gTFjAJ6An0Vl7z3TLBOfLZC9Oc305S9uDvl5ol6v8/6nP2HwdHzP54V0hcUbm4SkMI1tjaXb62yt5IhGQoTCARLxKL/2/deIhiK88/bFDoMpEn2jSQwtTzCg4lB0/JEgEyfGSQ72cudu7rF0vMs7RZ57fQLZ4wC3xORLQ3xaybGQuS+zyZCPc93dnA0lON/TQ7Hd5i82VgieTZIzVeqqRlcqTOBwhO3iI/Ihj+vxeApeJZ+ioBf3y6JWbBJQ7uuEF5Uugks1Nq8sYRommqpTvpMmdkunx/HoirMHYWNzR99iNnSNnL5GrZqlXN6iVSrR9FvUnE028tOYkkSk9cCIQUFA7XLca/eXzCD6wjq1mb+lcfXtLziojW2bT/X/q8YzD798dvkqrz3/bZavpXEoMqZh3guNiKZMq9mmmC/jDbpx+CVEh0AiFWF1Nk0q1s3AcIrKdIveUDfxsTDFSgXB6ebo8RShkIePP7yGx+Mmm6lRKTX43vdforcvwMyd/TW1j4MoCiwtZXE6ZWL9IVotlYufLT1yaMZoMoq5Uuf2xiYuRSbu9fDdF4bZrNVpKBafrGwyMBlm2JWgqmt8tLbx2Np2QYATiQR9Hj/h7gSFWoN0o4Ftd8ia6j9DU2eu3uBEKkTpAa51SRAYHkliWHUMT4QFscF8vQzAkOzFZWpUdva66g7Nwl03vmiq12NhbHugp0k9cv/hjZoy5a0MoSNDlJtVBEFgeX2NI68+T2BTxsyXkWIh1nr9XG/tzV8EZSd92xVq7a+I3+DviHZLJV9J4/a6MHQTXTNollSCoc7M0lDSj20YeIIKLreLUyePojY1xpOjVJp1hof76B/qpn+0m/c//Iz6nRaJRIz5uW1+/bdeRRQ9bD4wCOVRqFZa3KhskUgEEAS4MrNBaeh+qDEW8NDTcHD700XCHjc+ZM4e66Edl1hr1wmeS5KUZNKNOtNrW/v23+Xx0BcOEQjWaaoaGaNF0zDweJyUnRZ8QZN1sd3E1ZuEbPn+Ph0epnpTOFpt0l4vl5s7+Bo2QnOvB6nrBsJ2jT4rxDZP1xlrY6HHBZgTcAs+9FwFQ1MJHRsnX19Gc3hIDQ5Tb2pYDgF7LMod/32aBke2Hy3/5Jr4PUezv3xz11eBZ67UNVUjFPcwfD5OqVbA4/KimD5Wru+wPp3h1ZfP89mNG7SFBqVylXPPn+anP7hAMObl5XPnmXl/jcJunEuSJCSnTCSg8N47F5mcGmRjfRuv14vH40Fxyly+dIeXXzmL26PQaj6e7F4QYGIyiWBZGIaBy+Nmda3A1uaTBSgqKtzaKCGKAnGXm8xSgU/yLaITEbK5KoefS3JrPcPTjHJ4brCHwjs7fCysc3pqgHDTwBNyYMecjE2lWNop8K1wD5uiyt3HJE0fRks32E6IdA3EyKzlEUSB88dH2VnJkyl2unPHUxFc41Fu1QpUbB3NtnAHvLQq90MtliygOyV4mnkBT8BPpDy/+dwExt0tZMvJ0KtnUJttxrNNiA2wZTW4rZZ4u6tNvDdCTm9Sbe1P6EYUN3b5Z297/6ohiiJd/WHUsE21UiMciFNcanPq6AnmI/PMLS9gFgxeevks1y/cobe3m7gS5/1/e51Dr/bj9DjIV4pUb9dYmFvF6XSiqjrxRJBPPrjOd379DZaX93OrCwJMjHUhmrty63WxulmmWt1fmTXsDzF9cQGfy4mjbpItVMlvlJh8ZRinqZMJq2Qqj9bMMbeboxUvH318k7MTA+hLRYYcPpJnupHcDpbrVV6KdnOxlMF4TCGCblksRnWGhhOkV7L0OXz0uvxsZQukb2ZwuZ38vRf7ME0LW9kbVBBFASXopig2H0va9Sgshe5y6LmjCHer+HrCeGNJWrUiCTGF4RXZ9mZZO62j0qBqPjjQRUBoPH1g43OagGeBZ67UJw6PU9XLvP3OT+99FomFOX3seVZu7bDwyTZvff915jfmqVebXPtwBl03KGUr9Me2KaTvP+CWatHbn6DebiJKAuFIgEg0iK5bZHaKpFJJmk0NVVUJBNx7lLqiyARDHmq1Fu2WzsRkkvlbq1TLHctPEATOv36Y6Zmde1QD/pUWtYesdUvtSFjI66KU7rir9UqTfk+SWrXNoPp0pq3LKSMXNRq1FgRErkyvEY14ee7cKDIiF348TVVVsW1IpEJMjESYKz6dUruSzdId9zE+OEjM42FjocD6agYHAnrAJr9VZLRvkFvArXqRyWQ3cdmJemEJy7Rw+dwYKT9zTvXvrNQLeov/r7TB+OkIQU8vgR8tUPmcu3stw9CRUa74oFpVqRp7E7MCcMITZ1hzINsKgW4n9dqzpd39HIdPj3N79g7rM/dDa2+8+SpLl9Oc/u5x/H4PumZy+8Ii7ZbK+t0d3nzlVWzbJhwJ0it38ZO3P+WVN88Qi4VBENBUA0Gw0XQdTVNRFJl2W0eSRCIRL82mRm9PiIUH5Bbg/GtTzDTVfVTT9i6lRNChkN+l0bUsG0yLlbs7HPr2yGOV+pQrzNLHncqTS7OrxKJ+Xj8+RHpuh1u5HE3DwOl08MrLfbxb7Fj5znUFtX+vwFxv5dge8nJsdJBRNcSNm4uU0p1jtlsqwYUaK1MyI10+gqkIla3OOv1dIVqnAiwbe2ebfhFado3riYt0J0fpu9NP+p1PsHbzSLLbhe8/OUrO3Dv2LskAsXoEWfFhkMX8Ep7Bs8AzU+qCIDJ5eJznzz3PH/+7/7jnu2K+hHm0Eyc0DYv8Vonrn848ovSwY6V4A266hiN0jUaY+3iJN37neXAIIFg0Gk0SiRjtpo7TJTE0MoAg2vQN+Egk/SzOZ0mlghhGm+xOjngsjNcfAdPa82DYts3szTVSQ0nW1x5vFYveziWVJZHmbvlZciBCJrfbAKRbdEf9dPt9qKbJ4k4R9WH2REnkUH+CQcuD3NWi3tYQnCL+SAB/XeDGu7N4VIN4IsCG1iC7VWZ4JMwc++FRZE6F47hUG9MpcrteIt9oka7WSVfrnEkmcKznCbudyIJITmqjmxZi00B0CmimyV9JWd4Y6OZw/2mktknWZfGRUWSm9uXoAT6HIkmcDUSJVEWaCZXLepbZVoETdReILbq6wggtHdvlYL1RxKN2PXI/33f30nVjg+Zu0jl45CjO7n5W0k9OXP+8IUkig+O9/PSv9lbtfHblKmcnXiS7XeTGxb0JPtu2EUToGY2j2ipd8Sjf/Y2XsAVotlq4PS7iiTAgMDHRSzDo4rkzPnYyDTBVtjeyBII+uuMerlf2WuXTN1bpm+hl9SG5NZwCiiLBA9a+y6Og2TaiJNAd9HFG6KaotVnNle+VGUqCQJ/Ly+D4EMWNMu2WxuHhfsq3cxQW8sRcEmLMzVqzhrjZxBdWqO/WwztFieecXfgbApYiMCtXWW9XuaQY+DaatOttuhweWrZB1dBoFhq0TR9/GSzyu7/ezWBxAFO0WYnV+VCceySX06Pgl9yMqCeQVJGGr45syyxufEKwJ4Bc1RFEESMoUq3vwAMDusb0IwSu1lEryzQiAi7lBEJ7HkP8ojm79q+epe73+PE1k2SWS2jq/kSl+UAVRm6lwuThEWZu33eHHIoDp+imf6qLuljl05uXGDcHifUHWF/d5uKnNwn4fZw6c5iFuTWOHBvG6XTjcLjw+z3M3plDFGHyyDCFnQo3rnYy+JvrBeKJIKdO7Z9I32y0cSpPvmRZrcV3v3eMuUvrhHojuIMulISbq9fXEAQYHklQ+WSJhYvLuD0KZ870MVMrUap3HsSgz8XJSIzqTIlMs4ZLlnC43WxnigyEg9TydSrlJpZt01pV6RkKs2rWCIoOxqMR1qvVe8RfLofMm/4kKx+tdDhxZJnffW6UcsKmoqtsyzoV0+CtwRQ7N7cwdZPRpIei18b0O7DUzkNc0TT+vLjGn39+kk+YXvRFcEoy/8DdRfPSCpqqEwrb/N6JQf7Ms4No2GwbTXYcoDhlNEvD0mxkkvv2E1M8pFZLVB9gx7x15zY9z5+k3PdohsmvCx6Xj2pao/lQyafaUpGdErYu4At4qT/Aq9I/lCLeF+bm7McYW734Yl6uXr1Drdzg7LmjTN9ewLZNTp4+QrK7i7nZFcqlGqMjA9y8vkah2ISNPB6HTDTqIf8A1US7qeF07pfb+XyR73//BBsXtnDELXxhN5HRCNdnNnjlzBjrl7dZ3sgTifl48XQvn25tEXIpnBNjcL3CyoUNuoYj9I/3kLm6g9A2UA2TWrmF0lLp7vfiVgXGIhFupHcQBIG/J/ax9e4qNc2g2+Hlt3q6aA92s0WLqVSA7Vs1WrUWQZeD7niIRo+HtFamqmv8sbQIn+eebZ467JKQAry8FUO7dB3bMnG6PPSdP0La+oSMu4bkcex2gBr4zZF7f6eIbsIrIs1KJ3dhNLZpOuv4p15EiDqAD5943F85pa62DMq5OoIgMDE5wuzMfYXdP5IiNZoEMrgVL5m7Fbrc3bifc7O8vEYoFGRiZIyt2wU8AyLXL3VcsOlri/zWH32bd9+/QF8yRk3VmJ1Z4sSJKU4/N8X07W1EUeSdH12ikK8gyxLJZIJbN+4SCAapVjreQS5bIRjeP9dwZKKH9E4ZgGR3EJdbIZupkEl0uCdkSSQpuXjnvWmGBxNEfG6sXUEPR7wcf2WYmSvrbO9yt7eaGrc+XOLwm6NcrHdc1COxKHfeXaI36KdQ1ZB0m2gqyPBEktxqkUQoSagrQHGnE3Zy6DZjviD+JnjulvmNk32IQSfb9Tpev4uNnyxi2zbDAwnG/AFK8wVc3R7uTK8RjPo4c26YdrGM5HLQbqoYWzWm3hzjr90teEIZulOSOe6L4BNkVow6K/WnC3uc9Uc6Cn13OIdhGBSvLXP+lSHSfouEozOirL37Ug/1JLj0iKaoXtmLWtjPEFnP5Hk7/uXKLL9qaC0Dt+RDFMV73uXE0WGGD/VhVjVkw8lrL77I/Ooi2Uye/r4Ux08f5o//9V+h6wa6bnD2W51Zq/5ogGtXZzjz3GECQT+HDo3y7//tO2xt5Dh5epwPf3oVQZLx+/zU6iqCBDzk0Q6Nd7OTqdLbGybW5WKzWEXVDQ7Ho/zkR7dIJcMMnu6hkm9g2TZnTg+yOZtjJd9RZsV8HfWTNSaf78LjdLL0/irNloIv5mVrNkss6qdaqDN5sp+Nzzr3yqMoRFoOPLITe1HllfEjlCSd6koOy7R4vn+QQA1qW3VkbOR2GWfEjSfqo15u0KibRPxu3OMJqqX93Ew+ycWEnUS2RRakHEXj8W37J1sJ8jPLBHydt4DWbpK7tUhsYJLsyp171S2iKNGK3jcmfUIIK7dXri21SiNzC3P05pOFwLaxf1UTpaVsjeGTozhOKCwtrjA+NYQ35uZP/tUP7tX4vv7Gy+zcKWLbMJU6QrumcvfDdXrHE0wv3CdvsiyLO1fm6evrIbtZoisRwTDgyuVVYrE4Fz6a5djJQQq7bcOfNy7Uay0ikb38zMVykxfeOMLMjVVaTZXh8W4Urxuj2ObkiT6WZ7dRBZuzZ0bQgw62G00sBOYudfiup2d344gOiVfeOkwmZLPTarC68Iiqm1bn5kuigF3d9Vpsm1Kpgdut4GprHD89wtVMlZX1HPGJKIIsUtgs0RUNYkUcXL29SioZpnUti9bQyEsqPSM9uHpjhNxOKndyLG6mkZ0yh8cPM+1yUC838ec1Pphdp68vRnw8hiXArXIe2b5v7Tp2278/pw6IKC6+a0XJX9ik3dY40RVi8kiKvy3tr5B4GGFDvKfQAayaA/w6vqbNXzjS/Oa5YUIrZYxKA0dPhLtJmc32/qaotNHEGQ6ipveW82kBF23zyfNbvw5sT1d4661vcePmdVLDSXKVHS58cJVypoGiOPj2m9/CXQtxuLeb8k6NtcVt9F0Pq1ysUis1cEgSkUiEUDhONt/i0qV5gqEYWxsPMW2WG4TCIWp1mFvY5q1vneKj9+ZoNlWGxpLEe6PEWgbLd7fp9sc53N2D4ZVp5lrU6ypzizvMsYPP7WTUJ9LVG2U5v7eyplFX6bNl7JKOKIpoLYNyo0446aVcatB9pIt0tc7AsR7WZ3fwyw6CXQHaXhHXosrVjy7TP9aFJGj8xsljrL2zxMpWBZfPyZHxFJZsc+v9GTxH40ReGEBAINuqY+RLIIEsiDgECd02GZBiTK0GyM6l0SyLM/0JdqZC3LL2j60DcNYtHi76rBZ28Jzuxu8cRt8oIHqdMBFixnvtXodqw64gRkegvvdaSFE3uvVkI+ZXcpzdg1i+nqZ3PMXx3zqGM6DwP/8P/3pPrOzTTy/x6pk3WL6e3jMtSW3p+P1eysX7F3hpdo3v/+G3mLuwhhm2CYVcpHpDDA73MTyaJ9UbJdkTZWe7QDweZnOzQP9Q8t44LEGASDRAuayytlIgNdyN0ymTTpepp7McOZzi0nszBIIeelMR/ubfXsTX7ccOKLz27aNkBOgK+hBtGw2bUq1JtlhjuVBkIhXD43fTeLgSYZcMybJthN2fDREkWaLV0qjU2ly9sETP4SQzC9uszayTTAQZnhglMRTnL//mKiAQtERWlvPIskSkz8vWVpHnjw8x/eE8UtPEtCysts7SpTVGx7q4s7iFKInYNqxv5Pk8Eu3uddO2TVyyzBueLrz5jhJuRRXebe3wojPK5gf363eKmTJRAfrHAqw/YvTY5+j3+hkNhFGG+1ndydLcbYwSBIG2W8DQLf5UWyc25CEsBdnSyjQf00OQ0Rpkh/oJlqqo7c719CVibERcvG70PDK/8HWiWWuzfsXk5ZdeJzgg84M/3qac6XgQmqZza+YmfZ4JthY6CrrroZr/SraKqdvUGwaGYeDxSPzu772B1+NhcmqAtZUd1ld3OHR0iEuf3gUEBEFA0wx2Si2Soz24FIl0pkpUNbn43ixnz41y/cIyn9VVegfi9A/EOTLeQ2G7CiIUW202d0pExvbXfouSgCmB5BBoajrJkI96rUWhXMfhceBx+cjtlMi5dM5/dxIxp3K3nKe76Gd7t9tUbWjEegNs/HQZs6kjCKA2VJYvr9L92gAZc4VWtcXdBwZX9xwK8V2lD39OJ7jmw+iS8LUdbDzg2WfXMvR4epkfVGhbexOxfslNT6CLRFLELQjUa53r7XR72HIukhvdIDgWR6NCzZrdQzmgWk2qwyKegh9ttztWjvfhSMWwtZPAk2Yo/ArG1B/E2LkeFjZn+OjfrdI/1cXpVw9z59IizV1uZbWtgbz/AuU3yxx6eZztzcy9l4Db48YswGuvn0fucZHL5TENuHVjlliXyO1b0wTDCifPnGP6xiYrSxlee+M4Ab+P1dVtolE/XT0Jbt3oVLk8nBQ1dQPTsBgcTnBldyxeqdggGXLz2cfzvP7CJH/5by5j2zYOp0yqP4Tkd0ABlnaKnD+T4uZ7i/eaiWLJAGWho7hsG1puAY/fSbbaoK8/RDPXYPhkDxvlGuUBhUi0G3+2heSS2YkINDJZDMMiEvVR31UakiRg2DbFVgvRtBEtcAdc+LweJEVGkyz6uqI4dZtIV5ChWJjVQunemrr6uvmgvsX3PD0UP1yhtHttRVHg7708glLT901aLeyUGZ0aYv0xQ59fDXaRWqyylLnBEcnLVCDEhkclWygRO9TPX3P/Oue1JvmnmKf35+0Nnj+TYqAtEfUEiLi9KHfmKW5/ufmZPw8Eol7CoxLvfPS36JcbRCIRDnePMn29wyleLJQZT95v9tLKJn39PWysd0JKMzeX+J0//A5iyMvS4gqBgB9d07k2e41Gs8KxkwM4ZDfVms5v/u7LlAp1Rscd9A/1cGs6x85O5z54vU6KmQo9fZ3ejka9E1MrZKt0hfx4XE5mVwoIgkC8J8jA4R5uFwoMHepiZfa+Vzl+vJe7pRKp8TBer4uCrhPtCVLN1UkeimP3e4j1O7F2KrTDMumVDFVdJ1y4fx9Vy8IVcFIot0j0RnBLMk6PE4dbwW/IPH/+MNO5NCIdGysSC9AV8HH3x3eoGCb1QBPvioeR8AAP2+T1jTLJ0SCr2n0vpk+Ocmo1wMbiNImciCvowTc6Sba0iPdkihXhIpZtUrAf72HeVW6RenGYeLUHv+cMFATqH/4UrKcp+3o2fOrPXKl3DYa5s3id9dVONrlcrHHj5m1ee/l1rn/SCa1E4iH0+v4GHdu2Wb+a5fVXXqKpN5EEEQUXd95bpm+yi9mNNYqFCuMTfUxPz1EsVBmfGEIUJebnVjl+apJ6zcDnj3DnzjzNRpvFhR1azTu8+Z0z9PYGqFdbKE6FTKZBPldH3OWENvX7N0zRbSwbpLZJU9cYnupmYyGLy+tkaCLJzu7NNUyLpWaVb/3eKayqTsXUSKtN7m7f5yy5sb7DiTPdeNpg6SbJF1NkdZUt2+aj1Y517HbK6KaFsWPxYrKnQ59aV/FEI7AB/oSfpXYdy7KpegWCg2HU5Qp1y0Av1XEIIi4dmvkGf/nDKxw+1Mvzk0k2SxWsiIuP60UGk0GmGm6qqRQ1S2d5e3cg+EoF1+D+UWJut5PcY2KICbeXlzUvqtMgGzGZLtXob9gMnRwmMxnlB2qZkv7lm4YsbOb1KoetGK6ba0R3GsQSIbZjj66W+ToRH3fzo7d/BECo18316zc5eeoEgZCParnO8MgAxe37Sd7NuRyDhwYZGR5A0zXcipvqSptFc5utzSzHTwzyN3/9IaIocPTYKOvrWY4cG6eru5t6vcXaZpFmo83M7CavvXGcSFAGRFq6jdgyiER83JnPwm7vkdetUCjUOXwsjNfnxDQtYt0BgnEvm7Npwn0J3po4gd7UqYgGM+UilUqb7VKG515K4q/YiDoc7hlhRWhyNbeKahi4Qw4+zld4azRJ83IF5y6zpyxLaC6BHaFFMBmkXGkgmhZ6oYG6nKfvZIpZrUakK8x5X5x1r0oxLhIoWBxJ9GDKUNA2UDUNNBuv6KTxAOuoy++iZu8tv3yh2Y+rUsOKxyg4ygQNFY/lxfvWALPKFayn6ua0adPEUYnS/GQbM1/COXwCw/VFnSa/wpa6P+Fi/c798qBarsVAfy+i3FHisUSEc6fPMf/Jo62vVkNl4dP95UUOn0zxxgZW2I/LLVMsdCyXdkulVNSRJIHDh51srNVwOmusLN3ffyweYGs1TanQJJ/vCMrx02MEQ250C4JhL5LjPjF/PBki12jRGwywslEg06ozdLaXlqrx0eUFpt4YBWAwESJUF3j7P1zDxmZoMokd30smZtk219bSCEJnCo1ZvO+K+spQT4m0HiiBvJTd4fxLvbgKBuFwAMu2WSqWsCwbX8DFkkPl0EiMm3fSxMN+/B4nfWMJbIdIz8leqktpPru1yuCZft4VKzSzBYZCQU5knKQvL1CvNHH53Zw5NcjlxRXMtsGmzyTcFaSU6cSuBQEix1O8W9/hYXS5PPynJGi9c5d2o013MkTXcIrby+uUsjl+GmrQ0PWfWRDfsmPUr8zS7QjQLJahWKZncvBn3NtXBAEqD8Rh9ZpNb18PiwsLnJh6jnZdJxUeZHFpr0yvzz6Ybykz9Jsn2fhwBq/XRTbTsUAty6ZQqFGr2SyvZDh3ro8f/U2H59vtcTI2muQ//Ot3SPUlyeebDI0mOXFigpkrqySSQTaLZQQE4l1B5mfT9IwnSBxNIIkCC5tF7G0PR7rjWCsNfrS4iiSJjB1L4XB35N2ybS4VdxDYDcns7M0RNXcHl1wWy5x+aQCf5aK/bVBqt1lv19GaApPnBrn09m0SQR+uFky+PILoVVDbEleXV+k/0ss7/iLfV3upfLBGMVNGEAVGnutm1ZlDDQh4Ve89r0OWZYTJAAX9fuL8vDRM7GqDzK01REkidSiFGq2wXp3Bkhzo9tOR0QmIDKb70GY3MTIWVrtG83YN78n91XH78WyUuvCsBgoMpkbs/8s//n9QKZf40x/9GZZg4lQUgoEgvT3dPPfiGYLuAIM9CSr5OteurNJUW3RH/Zi2QNOyCAe9+CNuZI8braFR3ilRLdaxJJFDR7u5cP06vkSSRDxENZvDoUg0DQunrNBsqwyMDOMTFWRF4NMLM9iCzfhIL5FogB/86Qf0DSYwbIn0ZpFatcXpF46SXS8xNJIgHHBTKjS4emGRgFfG4XUwcmaEP/73l3G7FCZGEwz1BXHLMsHhIC1Vx21I5NfLdEVdINtUGjr9/RGW603+4soyL030cigZZbArBGabH85sUKppTA0EcSsipmqRVwyckoOY14Mo2rTaGqIgEHW62aq32Ky2SOgOLMtkU9JpGnW+kxzC2xDYvr0FgoDZ0Khnq/SdG6RWrpOY7KJpq9wWmiRcToINmYt/e4dJv5eIx0Go24Pmc5N2mji7PMgRJ15TYHqtSCFfwdnlwxtTSAR9JCUXYYeDqmizVa/iyGhkP11myhvEoRkYTQ3/QBjPYASH18WKz2S5UOW6kuH3BqeIuzxcTG8i6mbnpaaZLBkVPqxs81ZymDejvVhtlTvNCigSb7T8aNs5fAE/7nob07BQYn5633zzqm3bZ56FbA/3jdn/+T/4r/jbv/kJkiIRCgQZ7O8l1hPmO2+8gcuWubuQJrdTIuJ1oQoSikchlgxiWAJ6Q6WwVcA5EGNu5ibhaJRINIBdr6OaJqLioNU0MUQ4dWiMu3fXqTfaHJoYJL2dZ2Z2mUgiQi5XJ71V4tU3T+B2KAT9Ht7/6TSSCB5ZQPR6WC5U8XtcHB1L4JZtkmPd1LMNWqUmXQkXpmBi2TIuv8Jfr6Q5PpLgaDiGT7G4WCuy02wxGfVgGxZN08QlKoRcbjTDRLZtBEtkp23QyjWxTIv2AEy2vbiykJvPoigy9XwNy7DpOZvCFVKoyCpSt5eVv5xHqhoELegZDqF7ZUi58CZ9iE6DhZ0C29UCfQNxwhE/STGAS5QpS21qV7O0bxfwCQ4ctoAomcQP92LZGsYhiy17naHIFA7BQaa4hoiAprXZEpfAKXFcOYeoQtlRJ7IiI2o2fkHBNi0ElxPL0Im9+d3HypggiLYgPB2Ph223v1JZfSqlLgjCd4D/DpCA/9G27f/2oe+F3e+/BzSB/6Vt29eetM9UsNf+P57/rzn88hiz1QV++tFFxvsnCDQcBN1eXjx3BDlboL20gXcojm+qm3Qmz8b1u8R6uqlHEsi9PcxNb3HlvRkcDonXvnOSlEsgERXRBZmPZjMERYsR00DbzOOb7GfZFllZ2MRQTZ57/QStrQq5dAPB6SSeCFJdytCoNBh6YZi72TQXL80Q7U0yPpRi1OVCKtYRWhoEAzQRGDzdi7axgadVIpIMsxEf5OK7y3grdbymyej5EerbBWyXxPB4GG9mEaWaRokGEPr6qZdU8hsNlENTrO/oRBQb4/Y8Vr5IbLKbyCsTiOosLsFCDPViLq1hd/egmwZUbWhZbO7A4vU0hqQQPT5EzTQR1TpDw05M3U35bp5SFXRTw+MHo1CBZovoRB+D42G2P9vEG3Th7PJTtWUKWZ3KSoGjr3XjLi3iCdqIkQCek0exJJvmrQ0ad5Yw+gbIjg/hNrcYCLrxibuc3J4gWHVss0k520XmQpby9Ca+mIfoiB9xZ4FgbxhJcWMZNpbbgxSLIY5F0TZz6Le20LbL2B43htNBM+AjcnQIr6uJPXMTweVFHh1BVCTsShrJE8LWq+CUQQlgGSLOsS9W6j8PuQZI+VP2//P/8H/nwzufEAnHcJQkUvEoR+JRpEIFWnWip4bQnHDzk5t0jw7hnJrkz//sOos31+gZiPPWb51hOCxwdb2C0mwSz5XQq20aqQQL20UMXWNwfACH4KK8ViYc9FBcyaH4ZJz9Qa4tLaPZIq8eGcFbbGDlm5geF4mTfai6iqucJR53syF2MffpMlKlQdehXlyKwOCwG19+Abm8jSMawUr0UG1K5I0wgtONcXOG9soWkZEukm8cwikvoTg92LYHUxAwqxbNos3inRLpxQKO7jiJU4MochOf00llW2Xmg2WCKTeKoGMWSgiCxOjrR9CXt5E8XuzeBDM/nmfsfJKYksWj1BF9LlxHjmLoGvWbi9imA9epKRzuKm50BF8AGxXLtCjMKxRuFWhtFvGFRIIpF0ozhzeVABwI4SBmOIS2uIY6t41tCYjJGFJXHN+gH3P5OnJPCjESBrWKqMig18GpYDtDWLaMc/CVL1DqXzB9Zxe2rX29Sl0QBAmYB74NbAKfAX9g2/bMA9t8D/iv6Qj/88B/Z9v280/ab9LZZf/j8f8M0zZ54X/xPFWhRvZuAb2qcfL4KPatZcxqjWDSh1opEz+UAqfFJ7NrNAolzpw5SaZ/kH/xz37SKQU0LURJ5D/5X7/JEUeNj7ZaFHaKnPXLVObTyF4nha44q3dWkfviuCSB/GqeE7/2Itf/5DrPvTnFztV1qjWVwaNJbt9cZvK1cd6+cIU2Er/96gn8BRVKLcy2TrPWZuq7x9h57zr9LwziTi9hOgR2uk+wuV1D3ywiyRLlosrE6W6GDieQb10kFFCRtTqS04HlULDiMVRvLwuzKmJ3D9KNG7Q3cyAIuANOYgMBUt8bRFbXkRoV7ORRrNIWuurHLGnkihI33l/DMgCXC0NxETw5QsKXw+FKsPPxMorXQd0dQi9ncCkydr0GpoW3O8x4VKNJiNJCASHgwRRthJFh7GqNWHuGYK8XyakhKTKerjB6OImua9QuL2O1TdzdvZinI0SEFrKgI4R7QEuDaWAqXay/V6e2lMOoi4jlHRCg+4UhQtU5BNvCFD2IsRT4FAwliJbJoC+nsRo6RtNAGurFUlV8Lx7GmZ/GalZwHD+K5HQglDYRuvqhlQZEkCRspxPbEUYZ+40nPig/L7kG6PF02/9k4h8x+q1xRFWjUmpwKBZEvbmMrRmEh0KYW2nC58bZ1NrILYtczeJv52tsrxfBtomlwvz+/+ZNZt+7zlHBoLSQhqOjXPzkLh63A/dAF9WaTqyni363l7X35gn0h8nXKpTzNQ792lFqlRLmQpZD/d3kF/PE4l5CSR/lTJG+E0nahs36XIW25aClQ3mjxFv/2/NEFi7ibGdw+pwYlRpSLII+MMKmMYw9u0jl1iI2IDlEoik/w394BiX7KdLwEdS0ir7TYnpOZ/P6BogyluRAjIcZ+95xSh9MI4b8ZNMVXIqJnS8gKRKYFoNnh/E2aqTnG3im+qjZDrrteYJxCUlRkdxOFNtEGJtE1S3Uj2eRfAF8r0/icDXBKYFeRlWTLPzpEuggVOoY5RpywEP/2QTOtevYyRGEnhGadzfRC2XMeh0QsSwR97ExZKWJayiEGJIRy+ldGdtGEEVsWwCPH9uVxDH0rScr9acMKtroX6lSfxqGmrPAom3by7Zta8C/B37zoW1+E/j/2R1cBEKCIDx6YOcubOiU01k2hcUC8paOvWMgqgpivYWtadiGiYWAQxJoLG2DbhLrjmKaFqIg0NzoNDLYlg22jWVarK1maQcjLN7dJOF3YtVaYJoo3REWZjc71SsNDVsAweNiaz2PP+JFL7dAN3HIIqqmIQqQm8swNJpiaCiBul5AFgVa5Sa2ZSPLEma+hORSUJsGlqRAvIv8zRUcto1Zb2LYAmZLR7cEFLWGyyNi1auIigOrpWGXKshuD5Kl0jZEvKJJ+/OkqQCmZtIqNjHaCugqmAaiImCbIDQaWE2NSt3uDDUQRWxVw26qNDdyKKEEarGN0VRR8xWSYyEkxYFVrSEIArZhkujzI+pNZKsFgoCt6ajpIh7FomvEi9WoIzklBEHA6XNAo4ZomNhqDWdfNw7bxtpexytGENuVjjQJJmCCAHpLQS+VEQQDh1MA2wLTBFFGxIBKAdHnxcpnwTQwNnPYNb1D22pZiA4JI51DkiXEtoqlGoiBCNACQwNTBREEOi32gqEiCDKi+QX0gD9Huf5cukUEtK0W7fkagz09aCs5zJbe6Vw0bLBs9KZG2OXAsgRyc5sM94U7Za2CgNZWWVnJ0RPy0M7Vkd1O0rkKhmZgagZ6o9Odmt7IYal6h2ZAgkaljUORaacrhB0yHrdCYzcsJdsW9ZUMnlgQ3ZIpFnXMagPZIdJuaAgCGLkCThdgGp0JRYKAVSojShIel01zbg3x8xJcw0JtGKi5NoLHh11NI7o8qG3ILt6XY1QV2irlrEq7WEdSmwR7PJ3PP68htG38Hh1qRVwxH8Z2nsETcWjVEGQL2waHIiMYbQRVQxA15IAXW21jVXVw+kHrvBDbZQvZKTfTxVkAAAQfSURBVCIAgqWBZWFWG1hON2htBMHCqNSxWhpWvdUpO7MtBNNCMAxoG+ByItgg2BaYLQRBBEwEobNWQX8yQ2aH8Pfp/n3VeBpL/XeB79i2/Y93f/+HwPO2bf/TB7b5a+C/tW37493ffwr8n2zbvvLQvv4J8E92fz0C3PmqTuQZIwZ8c8fufDn8spzLhG3b/sd9+VXK9e53v0iy/Ytwj38R1vhYGRME4Ud0zuFpkLdt+ztf1aKexj94FK3gw2+Cp9kG27b/BfAvAARBuPKsEllfNQ7O5ZsHQRD2Kd6HN3nEZz+TXMMvlmx/09cHvzhrfNx3X6WS/rJ4mvDLJtD3wO+9wMOkG0+zzQEO8E3CgVwf4JcST6PUPwPGBEEYEgRBAX4f+MuHtvlL4I+EDs4BFdu2n31b3wEO8HgcyPUBfinxheEX27YNQRD+KfBjOqVf/9K27WlBEP7L3e//OfA3dCoEFumUfv2jpzj2v/iZV/3Nw8G5fPPwxPP4Ocr1Fx77G4Bv+vrgYI0/M55Z89EBDnCAAxzgq8fTD907wAEOcIADfONxoNQPcIADHOCXCM9EqQuC8B1BEOYEQVgUBOH//CzW8FVAEIR/KQhCVhCEb3JN8hdCEIQ+QRDeEwRhVhCEaUEQ/ptnvaafFYIguARBuCwIws3dc/m/fY3H/kbL9S+CvH7TZfFZytfT4muPqT9Ne/YvCgRBeAWo0+k6PPKs1/OzYrdLstu27WuCIPiBq8Bv/YLeEwHw2rZdFzrkGx8D/81uR+jP87jfeLn+RZDXb7osPiv5+jJ4Fpb607Rn/0LAtu0PgeKzXsffFbZtpz8nqrJtuwbMAqlnu6qfDbst/Z/zBDh2/38dlss3Xq5/EeT1my6Lz1C+nhrPQqmnYM/gkk2+QTftVx2CIAwCJ4FLz3gpPzMEQZAEQbgBZIGf2Lb9dZzLgVx/xfimyuIzkq+nxrNQ6k/den2ArxeCIPiAPwX+97ZtP3my7jcYtm2btm2foNMBelYQhK8j1HAg118hvsmy+Izk66nxLJT6Qev1NxC78cE/Bf6Nbdt/9qzX81XAtu0y8D7wdfBwHMj1V4RfFFn8muXrqfEslPrTtGcf4GvEbvLnfwJmbdv+Z896PX8XCIIQFwQhtPuzG/gWcPdrOPSBXH8F+KbL4jOUr6fG167Ubds2gM/bs2eBP7Fte/rrXsdXAUEQ/h1wAZgQBGFTEIT//Fmv6WfEi8A/BN4QBOHG7v/vPetF/YzoBt4TBOEWHUX7E9u2//rnfdBfBLn+BZHXb7osPhP5+jI4oAk4wAEOcIBfIhx0lB7gAAc4wC8RDpT6AQ5wgAP8EuFAqR/gAAc4wC8RDpT6AQ5wgAP8EuFAqR/gAAc4wC8RDpT6AQ5wgAP8EuFAqR/gAAc4wC8R/v/dXJZFfUELUgAAAABJRU5ErkJggg==\n",
+      "text/plain": [
+       "<Figure size 432x288 with 3 Axes>"
+      ]
+     },
+     "metadata": {
+      "needs_background": "light"
+     },
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from matplotlib import pyplot as plt\n",
+    "from matplotlib.cm import ScalarMappable\n",
+    "\n",
+    "import seaborn as sns\n",
+    "import numpy as np\n",
+    "\n",
+    "fairmodel = fairalgo1.network.eval()\n",
+    "baselinemodel = baseline.network.eval()\n",
+    "\n",
+    "range_x = np.linspace(0,3,num=100).astype(np.float32)\n",
+    "range_y = np.linspace(0,3, num= 100).astype(np.float32)\n",
+    "\n",
+    "def get_predicted_scores(model):\n",
+    "    xx, yy = np.meshgrid(range_x, range_y, sparse=False)\n",
+    "    y_pred = []\n",
+    "\n",
+    "    for i in range(100):\n",
+    "        x = xx[i].reshape(-1, 1)\n",
+    "        y = yy[i].reshape(-1, 1)\n",
+    "        x_test = np.hstack([x, y])\n",
+    "        y_pred.append(model(torch.Tensor(x_test)).detach().numpy()[:, 0])\n",
+    "    \n",
+    "    return y_pred\n",
+    "        \n",
+    "def plot_contours_and_relevances(scores_pred, ax):\n",
+    "    scores_pred = np.array(scores_pred)\n",
+    "    ax.contourf(range_x, range_y, scores_pred)\n",
+    "    data_x = np.array(all_data['Q'])\n",
+    "    points = sns.scatterplot(x=data_x[:,0], y=data_x[:,1], c=all_data['relevances'], \n",
+    "                             cmap='magma', ax=ax, alpha=0.5)\n",
+    "\n",
+    "fig = plt.figure(figsize = (6,10))\n",
+    "fig, (ax1,ax2) = plt.subplots(1,2)\n",
+    "scores = get_predicted_scores(baselinemodel)\n",
+    "plot_contours_and_relevances(scores,ax1)\n",
+    "scores = get_predicted_scores(fairmodel)\n",
+    "plot_contours_and_relevances(scores,ax2)\n",
+    "\n",
+    "\n",
+    "# color bar denoting relevance\n",
+    "cmap = plt.get_cmap(\"magma\")\n",
+    "norm = plt.Normalize(all_data['relevances'].min(),all_data['relevances'].max())\n",
+    "sm =  ScalarMappable(norm=norm, cmap=cmap)\n",
+    "sm.set_array([])\n",
+    "cbar = fig.colorbar(sm)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "40eea679-2910-4567-aa63-53e7a98531f1",
+   "metadata": {},
+   "source": [
+    "The fair model is plotted on the right. As we can see from the contours of the fair model, the resulting network is not sensitive to the vertical dimmension, while the baseline is."
+   ]
+  }
+ ],
+ "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.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/examples/synthetic-data/trainer.py b/examples/synthetic-data/trainer.py
index 3f0fe93..96f5afc 100644
--- a/examples/synthetic-data/trainer.py
+++ b/examples/synthetic-data/trainer.py
@@ -10,7 +10,7 @@ class Trainer(object):
         max_iterations (int): Number of training steps
     """
 
-    def __init__(self, dataloader, model, optimizer, max_iterations):
+    def __init__(self, dataloader, model, optimizer, max_iterations, print_loss_period=0):
 
         self.dataloader = dataloader
         self.model = model
@@ -18,6 +18,7 @@ def __init__(self, dataloader, model, optimizer, max_iterations):
         self.max_iterations = max_iterations
 
         self._dataloader_iter = iter(self.dataloader)
+        self.print_loss_period = print_loss_period
 
     def run_step(self):
 
@@ -36,6 +37,10 @@ def run_step(self):
                 "Data format not recognized. Only `list`, `tuple`, and `dict` are recognized."
             )
 
+        if self.print_loss_period:
+            if self.step_count % self.print_loss_period == 0:
+                print(f'loss {self.step_count}', model_output.loss)
+
         self.optimizer.zero_grad()
         model_output.loss.backward()
 
@@ -45,5 +50,5 @@ def train(self):
 
         self.model.train(True)
 
-        for step_count in range(self.max_iterations):
+        for self.step_count in range(self.max_iterations):
             self.run_step()
diff --git a/inFairness/auditor/__init__.py b/inFairness/auditor/__init__.py
index ea2d369..0f077f6 100644
--- a/inFairness/auditor/__init__.py
+++ b/inFairness/auditor/__init__.py
@@ -1,5 +1,6 @@
 from inFairness.auditor.auditor import Auditor
 from inFairness.auditor.sensei_auditor import SenSeIAuditor
 from inFairness.auditor.sensr_auditor import SenSRAuditor
+from inFairness.auditor.senstir_auditor import SenSTIRAuditor
 
 __all__ = [symb for symb in globals() if not symb.startswith("_")]
diff --git a/inFairness/auditor/senstir_auditor.py b/inFairness/auditor/senstir_auditor.py
new file mode 100644
index 0000000..0419a9d
--- /dev/null
+++ b/inFairness/auditor/senstir_auditor.py
@@ -0,0 +1,158 @@
+import torch
+from torch.nn.parameter import Parameter
+
+from inFairness.distances import (
+    BatchedWassersteinDistance,
+    MahalanobisDistances,
+)
+from inFairness.auditor import Auditor
+
+from inFairness.utils.params import freeze_network, unfreeze_network
+from inFairness.utils.normalized_discounted_cumulative_gain import log_expected_ndcg
+
+
+class SenSTIRAuditor(Auditor):
+    """SenSTIR Auditor generates worst-case examples by solving the
+    following optimization problem:
+
+    .. math:: q^{'} \gets arg\max_{q^{'}}\{||h_{\\theta_t}(q),h_{\\theta_t}(q^{'})||_{2}^{2} - \lambda_t d_{Q}(q,q^{'})\}
+
+    At a high level, it will find :math:`q^{'}` such that it maximizes the score difference, while keeping
+    a fair set distance `distance_q` with the original query `q` small.
+
+    for more information see equation 3.4 of the reference bellow
+
+      References
+      ----------
+          `Amanda Bower, Hamid Eftekhari, Mikhail Yurochkin, Yuekai Sun:
+          Individually Fair Rankings. ICLR 2021`
+
+    Parameters
+      -----------
+      distance_q: batched wasserstein distance to compare each pair of queries per batch (q and q').
+        it should take tensors x, y each with dimensions B,N,D (batch size, num_items and feature size)
+        and return a tensor of size B corresponding to the wasserstein distance between the two queries in each batch.
+        You can use a mahalanobis distance to build this by using :class:`~inFairness.distances.BatchedWassersteinDistance`
+
+      distance_y: takes tensors x,y with dimensions B,N,D and returns a tensor with dimensions B,N,1 conitaining the pairwise distace between items.
+        Mahalanobis distance objects can perform this operation by setting parameter `batches_of_sets_of_items` to true when calling
+        it's forward method. This would return batched version compatible with this class.
+
+      num_steps: number of optimization steps taken to produce the worst examples.
+
+      lr: learning rate of the optimization
+
+      max/min_noise: range of a uniform distribution determining the initial noise added to q to form q'
+    """
+
+    def __init__(
+        self,
+        distance_q: BatchedWassersteinDistance,
+        distance_y: MahalanobisDistances,
+        num_steps: int,
+        lr: float,
+        max_noise: float = 0.1,
+        min_noise: float = -0.1,
+    ):
+        self.distance_q = distance_q
+        self.distance_y = distance_y
+        self.num_steps = num_steps
+        self.lr = lr
+        self.max_noise = max_noise
+        self.min_noise = min_noise
+
+    def generate_worst_case_examples(self, network, Q, lambda_param, optimizer=None):
+        """Generate worst case examples given the input sample batch of queries Q (dimensions batch_size,num_items,num_features)
+
+        Parameters
+        -----------
+          network: torch.nn.Module
+            PyTorch network model that outputs scores per item
+          Q: torch.Tensor
+            tensor with dimensions batch_size, num_items, num_features containing the batch of queries for ranking
+          lambda_param: torch.float
+            Lambda weighting parameter as defined above
+          optimizer: torch.optim.Optimizer, optional
+            Pytorch Optimizer object
+
+        Returns
+        ---------
+          q_worst: torch.Tensor
+            worst case queries for the provided input queries `Q`
+        """
+        assert optimizer is None or issubclass(optimizer, torch.optim.Optimizer)
+
+        batch_size, num_items, _ = Q.shape
+        freeze_network(network)
+        lambda_param = lambda_param.detach()
+
+        delta = Parameter(
+            torch.rand_like(Q) * (self.max_noise - self.min_noise) + self.min_noise
+        )
+
+        if optimizer is None:
+            optimizer = torch.optim.Adam([delta], lr=self.lr)
+        else:
+            optimizer = optimizer([delta], lr=self.lr)
+
+        for _ in range(self.num_steps):
+            optimizer.zero_grad()
+            Q_worst = Q + delta
+            input_dist = self.distance_q(Q, Q_worst)  # this is of size B
+
+            out_Q = network(Q).reshape(
+                batch_size, num_items
+            )  # shape B,N,1 scores --> B,N
+            out_Q_worst = network(Q_worst).reshape(batch_size, num_items)
+
+            out_dist = self.distance_y(out_Q, out_Q_worst)
+            out_dist = out_dist.reshape(
+                batch_size,
+            )  # distance_y outputs B,1 whereas input_dist is B.
+
+            loss = (-(out_dist - lambda_param * input_dist)).sum()
+            loss.backward()
+            optimizer.step()
+
+        unfreeze_network(network)
+
+        return (Q + delta).detach()
+
+    def compute_loss_ratio(
+        self,
+        X_audit,
+        X_worst,
+        Y_audit,
+        network,
+        loss_fn=lambda x, y: -log_expected_ndcg(50, x, y),
+    ):
+        """Compute a ratio the utility ratio between X_audit and X_worst in a ranking setting. If X_worst was computed using a gradient flow with
+        a sensitive distance, the ratio should be close to 1.
+
+        Parameters
+        --------------
+            X_audit: torch.Tensor
+              Auditing samples. Shape (n_queries, n_items, n_features)
+            X_worst: same shape as X_audit but should be computed using some adversarial attack.
+            Y_audit: torch.Tensor
+              True relevances of items in each query, Shape: (n_queries, n_items)
+            network: model to be audited
+            loss_fn: a ranking function taking scores (n_queries, n_items) and relevances and then computing a negative utility function, usually normalized discounted cummulative gain gets used
+
+        Returns
+        ---------
+            loss_ratios: numpy.ndarray
+                Ratio of loss for samples computed using gradient
+                flow attack to original audit samples
+        """
+
+        with torch.no_grad():
+            scores = network(X_audit).squeeze()
+            scores_worst = network(X_worst).squeeze()
+
+            loss = loss_fn(scores, Y_audit)
+            loss_worst = loss_fn(scores_worst, Y_audit)
+
+        loss_ratio = loss_worst / loss
+
+        return loss_ratio.cpu().numpy()
diff --git a/inFairness/distances/__init__.py b/inFairness/distances/__init__.py
index c6d65f7..ceec6d2 100644
--- a/inFairness/distances/__init__.py
+++ b/inFairness/distances/__init__.py
@@ -16,4 +16,9 @@
     SquaredEuclideanDistance,
 )
 
+from inFairness.distances.wasserstein_distance import (
+    BatchedWassersteinDistance,
+)
+
+
 __all__ = [symb for symb in globals() if not symb.startswith("_")]
diff --git a/inFairness/distances/mahalanobis_distance.py b/inFairness/distances/mahalanobis_distance.py
index faf55e5..9ef5235 100644
--- a/inFairness/distances/mahalanobis_distance.py
+++ b/inFairness/distances/mahalanobis_distance.py
@@ -18,6 +18,13 @@ def __init__(self):
 
         self.sigma = None
         self.device = torch.device("cpu")
+        self.vdist = vmap(
+            vmap(
+                vmap(self.__compute_dist__, in_dims=(None, 0, None)),
+                in_dims=(0, None, None),
+            ),
+            in_dims=(0, 0, None),
+        )
 
     def to(self, device):
         """Moves distance metric to a particular device
@@ -71,6 +78,11 @@ def __compute_dist__(X1, X2, sigma):
         dist = torch.sum((X_diff @ sigma) * X_diff, dim=-1, keepdim=True)
         return dist
 
+    @staticmethod
+    def vdist(X1, X2, sigma):
+        """here for reference, this method gets populated in the init method. takes care of the "pairwise fashion" in the forward method"""
+        raise NotImplementedError
+
     def forward(self, X1, X2, itemwise_dist=True):
         """Computes the distance between data samples X1 and X2
 
@@ -118,15 +130,7 @@ def forward(self, X1, X2, itemwise_dist=True):
             nsamples_x2 = X2.shape[1]
             dist_shape = (-1, nsamples_x1, nsamples_x2)
 
-            vdist = vmap(
-                vmap(
-                    vmap(self.__compute_dist__, in_dims=(None, 0, None)),
-                    in_dims=(0, None, None),
-                ),
-                in_dims=(0, 0, None),
-            )
-
-            dist = vdist(X1, X2, self.sigma).view(dist_shape)
+            dist = self.vdist(X1, X2, self.sigma).view(dist_shape)
 
         return dist
 
diff --git a/inFairness/distances/wasserstein_distance.py b/inFairness/distances/wasserstein_distance.py
new file mode 100644
index 0000000..3508f6c
--- /dev/null
+++ b/inFairness/distances/wasserstein_distance.py
@@ -0,0 +1,57 @@
+import torch
+from functorch import vmap
+from ot import emd2
+
+from inFairness.distances import MahalanobisDistances, Distance
+
+
+class BatchedWassersteinDistance(MahalanobisDistances):
+    """computes a batched Wasserstein Distance for pairs of sets of items on each batch in the tensors
+    with dimensions B, N, D and B, M, D where B and D are the batch and feature sizes and N and M are the number of items on each batch.
+
+    Currently only supporting distances inheriting from :class: `MahalanobisDistances`.
+
+    transforms an Mahalanobis Distance object so that the forward method becomes a differentiable batched
+    Wasserstein distance between sets of items. This Wasserstein distance will use the underlying Mahalanobis
+    distance as pairwise cost function to solve the optimal transport problem.
+
+    for more information see equation 2.5 of the reference bellow
+
+    References
+    ----------
+        `Amanda Bower, Hamid Eftekhari, Mikhail Yurochkin, Yuekai Sun:
+        Individually Fair Rankings. ICLR 2021`
+    """
+
+    def __init__(self, distance: MahalanobisDistances):
+        super().__init__()
+        assert isinstance(
+            distance, MahalanobisDistances
+        ), "only MahalanobisDistances are supported"
+        self.distance = distance
+
+    def forward(self, x, y):
+        """computes a batch wasserstein distance implied by the cost function represented by an
+        underlying mahalanobis distance.
+
+        Parameters
+        ---------
+        x,y: torch.Tensor
+            should be of dimensions B,N,D and B,M,D
+
+        Returns
+        --------
+        batched_wassenstein_distance: torch.Tensor
+            dimension B
+        """
+        costs = self.distance(x, y, itemwise_dist=False)
+        uniformx = torch.ones(x.shape[1]) / x.shape[1]
+        uniformy = torch.ones(y.shape[1]) / y.shape[1]
+        num_batches = x.shape[0]
+        batched_wasserstein_distance_loss = torch.stack(
+            [emd2(uniformx, uniformy, costs[j]) for j in range(num_batches)]
+        )
+        return batched_wasserstein_distance_loss
+
+    def fit(self, *args, **kwargs):
+        self.distance.fit(*args, **kwargs)
diff --git a/inFairness/fairalgo/__init__.py b/inFairness/fairalgo/__init__.py
index 8fade0b..4fccb2d 100644
--- a/inFairness/fairalgo/__init__.py
+++ b/inFairness/fairalgo/__init__.py
@@ -1,5 +1,6 @@
 from inFairness.fairalgo.sensei import SenSeI
 from inFairness.fairalgo.sensr import SenSR
+from inFairness.fairalgo.senstir import SenSTIR
 from inFairness.fairalgo.datainterfaces import FairModelResponse
 
 __all__ = [symb for symb in globals() if not symb.startswith("_")]
diff --git a/inFairness/fairalgo/senstir.py b/inFairness/fairalgo/senstir.py
new file mode 100644
index 0000000..2b6bd8e
--- /dev/null
+++ b/inFairness/fairalgo/senstir.py
@@ -0,0 +1,113 @@
+import torch
+from torch import nn
+
+from inFairness.auditor import SenSTIRAuditor
+from inFairness.distances.mahalanobis_distance import MahalanobisDistances
+from inFairness.distances.wasserstein_distance import BatchedWassersteinDistance
+from inFairness.utils import datautils
+from inFairness.utils.normalized_discounted_cumulative_gain import log_expected_ndcg
+
+from inFairness.fairalgo.datainterfaces import FairModelResponse
+
+
+class SenSTIR(nn.Module):
+    def __init__(
+        self,
+        network: torch.nn.Module,
+        distance_q: BatchedWassersteinDistance,
+        distance_y: MahalanobisDistances,
+        rho,
+        eps,
+        auditor_nsteps,
+        auditor_lr,
+        monte_carlo_samples_ndcg: int,
+    ):
+        super().__init__()
+
+        self.network = network
+        self.distance_q = distance_q
+        self.distance_y = distance_y
+        self.rho = rho
+        self.eps = eps
+        self.auditor_nsteps = auditor_nsteps
+        self.auditor_lr = auditor_lr
+        self.monte_carlo_samples_ndcg = monte_carlo_samples_ndcg
+        self.lamb = None
+        self.auditor = self.__init_auditor__()
+
+    def __init_auditor__(self):
+        auditor = SenSTIRAuditor(
+            self.distance_q,
+            self.distance_y,
+            self.auditor_nsteps,
+            self.auditor_lr,
+        )
+        return auditor
+
+    def forward_train(self, Q, relevances):
+        batch_size, num_items, num_features = Q.shape
+        device = datautils.get_device(Q)
+
+        min_lambda = torch.tensor(1e-5, device=device)
+
+        if self.lamb is None:
+            self.lamb = torch.tensor(1.0, device=device)
+        if type(self.eps) is float:
+            self.eps = torch.tensor(self.eps, device=device)
+
+        if self.rho > 0.0:
+            Q_worst = self.auditor.generate_worst_case_examples(
+                self.network, Q, self.lamb
+            )
+
+            mean_dist_q = self.distance_q(Q, Q_worst).mean()
+            # lr_factor = torch.maximum(mean_dist_q, self.eps) / torch.minimum(
+            #     mean_dist_q, self.eps
+            # )
+            lr_factor = 0.5 * self.rho
+            self.lamb = torch.maximum(
+                min_lambda, self.lamb + lr_factor * (mean_dist_q - self.eps)
+            )
+
+            scores = self.network(Q).reshape(batch_size, num_items)  # (B,N,1) --> B,N
+            scores_worst = self.network(Q_worst).reshape(batch_size, num_items)
+
+        else:
+            scores = self.network(Q).reshape(batch_size, num_items)  # (B,N,1) --> B,N
+            scores_worst = torch.ones_like(scores)
+
+        fair_loss = torch.mean(
+            -log_expected_ndcg(self.monte_carlo_samples_ndcg, scores, relevances)
+            + self.rho * self.distance_y(scores, scores_worst)
+        )
+
+        response = FairModelResponse(loss=fair_loss, y_pred=scores)
+        return response
+
+    def forward_test(self, Q):
+        """Forward method during the test phase"""
+
+        scores = self.network(Q).reshape(Q.shape[:2])  # B,N,1 -> B,N
+        response = FairModelResponse(y_pred=scores)
+        return response
+
+    def forward(self, Q, relevances, **kwargs):
+        """Defines the computation performed at every call.
+
+        Parameters
+        ------------
+            X: torch.Tensor
+                Input data
+            Y: torch.Tensor
+                Expected output data
+
+        Returns
+        ----------
+            output: torch.Tensor
+                Model output
+        """
+
+        if self.training:
+            return self.forward_train(Q, relevances)
+        else:
+            return self.forward_test(Q)
diff --git a/inFairness/utils/misc.py b/inFairness/utils/misc.py
index afd899f..b34a0e4 100644
--- a/inFairness/utils/misc.py
+++ b/inFairness/utils/misc.py
@@ -1,6 +1,9 @@
 from functools import wraps
 import inspect
 
+import torch
+from functorch import vmap
+
 
 def initializer(func):
     """
@@ -36,3 +39,11 @@ def wrapper(self, *args, **kwargs):
         func(self, *args, **kwargs)
 
     return wrapper
+
+"""
+vectorizes torch that gather so that the index tensor can have a batch dimension.
+
+it's the same thing as torch.gather but it would perform the same operation on the source
+tensor B times.
+"""
+vect_gather = vmap(torch.gather, (None,None, 0))
\ No newline at end of file
diff --git a/inFairness/utils/normalized_discounted_cumulative_gain.py b/inFairness/utils/normalized_discounted_cumulative_gain.py
new file mode 100644
index 0000000..1061ce2
--- /dev/null
+++ b/inFairness/utils/normalized_discounted_cumulative_gain.py
@@ -0,0 +1,85 @@
+import torch
+from functorch import vmap
+
+from inFairness.utils.plackett_luce import PlackettLuce
+from inFairness.utils.misc import vect_gather
+
+
+def discounted_cumulative_gain(relevances):
+    numerator = torch.pow(torch.tensor([2.0]), relevances)
+    denominator = torch.log2(torch.arange(len(relevances), dtype=torch.float) + 2)
+    return (numerator / denominator).sum()
+
+
+def normalized_discounted_cumulative_gain(relevances):
+    """takes a vector of relevances and computes the normalized discounted cumulative gain
+    taken from (wikipedia)[https://en.wikipedia.org/wiki/Discounted_cumulative_gain]
+
+    Parameters
+    ---------
+    relevances: torch.Tensor
+      vector of dimension N where each element is the relevance of some objects in a particular order
+
+    Returns
+    -------
+    normalized_discounted_cumulative_gain: torch.Tensor
+      scalar value corresponding to the normalized discounted cumulative gain
+    """
+    dcg = discounted_cumulative_gain(relevances)
+    sorted_rels, _ = torch.sort(relevances, descending=True)
+    idcg = discounted_cumulative_gain(sorted_rels)
+    return dcg / idcg
+
+
+"""
+vectorizes :func: `normalized_discounted_cumulative_gain` to work on a batch of vectors of relevances
+given in a tensor of dimensions B,N. The output would be the NDCG on the last dimmension. And it's batched
+version would return B samples.
+"""
+vect_normalized_discounted_cumulative_gain = vmap(
+    normalized_discounted_cumulative_gain, in_dims=(0)
+)
+
+"""
+Adds a further outer dimension to the vectorized normalized discounted cumulative gain so it works 
+on monte carlo samples of rankings (e.g. samples of a plackett-luce distribution).
+
+This function would take a tensor of size S,B,N and return a tensor of size S,B with the
+ndcg of each vector.
+"""
+monte_carlo_vect_ndcg = vmap(vect_normalized_discounted_cumulative_gain, in_dims=(0,))
+
+
+def log_expected_ndcg(montecarlo_samples, scores, relevances):
+    """
+    uses monte carlo samples to estimate the expected normalized discounted cumulative reward
+    by using REINFORCE. See section 2 of the reference bellow.
+
+    Parameters
+    -------------
+    scores: torch.Tensor of dimension B,N
+      predicted scores for the objects in a batch of queries
+
+    relevances: torch.Tensor of dimension B,N
+      corresponding true relevances of such objects
+
+    Returns
+    ------------
+    expected_ndcg: torch.Tensor of dimension B
+      monte carlo approximation of the expected ndcg by sampling from a Plackett-Luce
+      distribution parameterized by :param:`scores`
+
+    References
+    ----------
+        `Amanda Bower, Hamid Eftekhari, Mikhail Yurochkin, Yuekai Sun:
+        Individually Fair Rankings. ICLR 2021`
+    """
+    prob_dist = PlackettLuce(scores)
+    mc_rankings = prob_dist.sample((montecarlo_samples,))
+    mc_log_prob = prob_dist.log_prob(mc_rankings)
+
+    mc_relevances = vect_gather(relevances, 1, mc_rankings)
+    mc_ndcg = monte_carlo_vect_ndcg(mc_relevances)
+
+    expected_utility = (mc_ndcg * mc_log_prob).mean(dim=0)
+    return expected_utility
diff --git a/inFairness/utils/plackett_luce.py b/inFairness/utils/plackett_luce.py
new file mode 100644
index 0000000..5a2e01f
--- /dev/null
+++ b/inFairness/utils/plackett_luce.py
@@ -0,0 +1,110 @@
+"""
+taken from https://github.com/pytorch/pytorch/pull/50362/
+"""
+
+
+from typing import Optional
+
+import torch
+from torch.distributions import Distribution, constraints
+
+
+class PlackettLuce(Distribution):
+    """
+    Creates a Plackett-Luce distribution over permutations, parameterized by :attr: `logits`.
+
+    The Plackett-Luce distribution defines a probability distribution over permutations by assigning a score `a_i` to
+    each element, and repeatedly choosing the next element by sampling from the remaining elements with a probability
+    proportional to their score.
+
+    If :attr:`logits` is 1-dimensional with length-`K`, each element is the log-score of the object at that index.
+
+    If :attr:`logits` is N-dimensional, the first N-1 dimensions are treated as a batch of log-score vectors.
+
+    This distribution supports batched operations with permutations of different sizes, by using the :attr:
+    `permutation_sizes` attribute to specify the permutation size of each score vector in the batch.  If the
+    permutation_size is `N` for a given index of the batch, the first `N` entries of the resulting sample will be a
+    permutation of the number `1` through `N`, while the remainder have unspecified values.
+
+    Example::
+
+        >>> m = PlackettLuce(torch.tensor([[0, 1, -1], [0, 1, 2]]), torch.tensor([3, 2], dtype=torch.int64))
+        >>> m.sample()
+        tensor([[ 1,  0,  2],
+                [ 0,  1,  2]])
+
+    Args:
+        logits (Tensor): The log of the Plackett-Luce distribution scores `a_i`.
+        permutation_sizes (Tensor): Optional sizes of the permutations sampled by the distribution.  Should match the
+                                    shape of the logits, with the last dimension stripped.
+    """
+    arg_constraints = {'logits': constraints.real}
+    support = constraints.integer_interval(-1, torch.iinfo(torch.int64).max)
+
+    def __init__(self, logits: torch.Tensor, permutation_sizes: Optional[torch.Tensor] = None, validate_args=None):
+        batch_shape = logits.shape[:-1]
+        max_size = logits.shape[-1]
+
+        if permutation_sizes is None:
+            permutation_sizes = torch.full(batch_shape, max_size, dtype=torch.int64, device=logits.device)
+        else:
+            permutation_sizes = permutation_sizes.expand(batch_shape)
+
+        if validate_args:
+            if (logits < -1e30).any():
+                raise ValueError("Plackett-Luce implementation cannot handle logits less than -1e30")
+        self.logits = logits
+        self.permutation_sizes = permutation_sizes
+
+        # Mask is true for invalid indices
+        self.mask: torch.Tensor = torch.zeros(
+            *batch_shape, max_size + 1, device=logits.device
+        ).scatter(-1, permutation_sizes.unsqueeze(-1), 1)[..., :-1].cumsum(dim=-1).bool()
+
+        event_shape = torch.Size((max_size,))
+        super(PlackettLuce, self).__init__(batch_shape, event_shape, validate_args=validate_args)
+
+    def sample(self, sample_shape=torch.Size()):
+        with torch.no_grad():
+            expanded = self.logits.expand(*sample_shape, *[-1] * len(self.logits.shape))
+            gumbel_noise = - torch.log(-torch.log(torch.rand_like(expanded)))
+            scores = torch.where(self.mask, -1e35, expanded + gumbel_noise)
+            sorted_scores, indices = torch.sort(scores, dim=-1, descending=True)
+            return indices.masked_fill(self.mask, -1).detach()
+
+    def log_prob(self, value: torch.Tensor):
+        if self._validate_args:
+            self._validate_sample(value)
+        return _plackett_luce_log_prob(self.logits, self.permutation_sizes, self.mask, value)
+
+    def expand(self, batch_shape, _instance=None):
+        new = self._get_checked_instance(PlackettLuce, _instance)
+        batch_shape = torch.Size(batch_shape)
+        logits_shape = batch_shape + (self.logits.shape[-1],)
+        new.logits = self.logits.expand(logits_shape)
+        new.mask = self.mask.expand(logits_shape)
+        new.permutation_sizes = self.permutation_sizes.expand(batch_shape)
+        super(PlackettLuce, new).__init__(batch_shape, self.event_shape, validate_args=False)
+        new._validate_args = self._validate_args
+        return new
+
+    def _validate_sample(self, value: torch.Tensor):
+        super()._validate_sample(value)
+        max_int64 = torch.iinfo(torch.int64).max
+        if (value.masked_fill(self.mask, max_int64).sort(-1).values
+                != torch.arange(0, value.shape[-1], dtype=torch.int64).masked_fill(self.mask, max_int64)).any():
+            raise ValueError("Not a valid permutation or batch of permutations.")
+
+
+@torch.jit.script_if_tracing
+def _plackett_luce_log_prob(logits, permutation_sizes, mask, value):
+    value = value.masked_fill(mask, 0)
+    logits = logits.masked_fill(mask, -1e35).expand(value.shape)
+    log_probs = torch.zeros(value.shape[:-1], device=value.device)
+    for i in range(int(permutation_sizes.max())):
+        log_probs += torch.where(mask[..., i],
+                                 0.0,
+                                 logits.log_softmax(dim=-1).gather(-1, value[..., i:i + 1]).squeeze(-1),
+                                 )
+        logits = logits.scatter(-1, value[..., i:i + 1], -1e35)
+    return log_probs
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
index 8cc68e4..f6e64ec 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -1,6 +1,7 @@
-torch>=1.11.0
 numpy>=1.21.6
 scikit-learn>=0.24.2
 pandas>=1.3.5
 scipy>=1.5.4
-functorch~=0.1.1
\ No newline at end of file
+torch>=1.12.1
+POT~=0.8.2
+functorch>=0.2.1
diff --git a/tests/auditor/test_senstir_auditor.py b/tests/auditor/test_senstir_auditor.py
new file mode 100644
index 0000000..1b34324
--- /dev/null
+++ b/tests/auditor/test_senstir_auditor.py
@@ -0,0 +1,66 @@
+import pytest
+
+import torch
+from mock import patch
+
+from inFairness.auditor import SenSTIRAuditor
+from inFairness.distances import (
+    SensitiveSubspaceDistance,
+    BatchedWassersteinDistance,
+    SquaredEuclideanDistance,
+)
+
+
+def mock_torch_rand_like(*size):
+    return torch.ones_like(*size)
+
+
+@patch("torch.rand_like", mock_torch_rand_like)
+def test_sestirauditor_generate_worst_case_examples():
+    batch_size = 2
+    query_size = 10
+    feature_size = 2
+
+    num_steps = 1000
+    lr = 0.005
+    max_noise = 0.5
+    min_noise = -0.5
+    lambda_param = torch.tensor(3000.0)
+
+    # let's create a Wasserstein Distance sensitive on the first dimension
+    distance_q = BatchedWassersteinDistance(SensitiveSubspaceDistance())
+    distance_q.fit(
+        basis_vectors=torch.tensor([[0], [1.0]])
+    )  # we use the second dimension in the basis vector because the projection complement will give us the first
+
+    # distance between sets of items
+    distance_y = SquaredEuclideanDistance()
+    distance_y.fit(num_dims=query_size)
+
+    auditor = SenSTIRAuditor(
+        distance_q, distance_y, num_steps, lr, max_noise, min_noise
+    )
+
+    # let's create a dummy network equally sensitive in both dimensions
+    network = torch.nn.Linear(feature_size, 1, bias=None)
+    network.weight.data = torch.ones((1, feature_size))
+
+    # now some dummy batch of queries
+    Q = torch.randn(batch_size, query_size, feature_size)
+
+    Q_worst = auditor.generate_worst_case_examples(
+        network, Q, lambda_param, torch.optim.Adam
+    )
+
+    # since the first dimension is sensitive, the examples should differ quite a bit in the second dimension while being similar in the first
+    first_dim_Q = Q[:, :, 0]
+    second_dim_Q = Q[:, :, 1]
+
+    first_dim_Q_worst = Q_worst[:, :, 0]
+    second_dim_Q_worst = Q_worst[:, :, 1]
+
+    # if two sets differ, their values should add to a high value
+    assert (torch.abs(second_dim_Q.sum(1) - second_dim_Q_worst.sum(1)) > 10.0).all()
+
+    # if two sets are close, their sum should add to a similar value
+    assert (torch.abs(first_dim_Q.sum(1) - first_dim_Q_worst.sum(1)) < 1.0).all()
diff --git a/tests/distances/test_common_distances.py b/tests/distances/test_common_distances.py
index 2d87537..e588687 100644
--- a/tests/distances/test_common_distances.py
+++ b/tests/distances/test_common_distances.py
@@ -219,10 +219,36 @@ def test_logistic_reg_distance_raises_error():
     dist = distances.LogisticRegSensitiveSubspace()
 
     with pytest.raises(AssertionError):
-        dist.fit(X_train, data_SensitiveAttrs=protected_attr, protected_idxs=[1,2])
+        dist.fit(X_train, data_SensitiveAttrs=protected_attr, protected_idxs=[1, 2])
 
     protected_attr = torch.randint(low=0, high=6, size=(100, 2)).long()
     dist = distances.LogisticRegSensitiveSubspace()
 
     with pytest.raises(AssertionError):
         dist.fit(X_train, protected_attr)
+
+
+def test_wasserstein_distance():
+    """
+    uses a SquaredEuclidean special case of a Mahalanobis distance to reduce the set difference between
+    2 batches of elements.
+    """
+    squared_euclidean = distances.SquaredEuclideanDistance()
+    wasserstein_dist = distances.BatchedWassersteinDistance(squared_euclidean)
+    wasserstein_dist.fit(num_dims=2)
+
+    x1 = torch.randn(3, 10, 2)
+    x2 = torch.nn.Parameter(torch.ones_like(x1))
+    optimizer = torch.optim.Adam([x2], lr=0.01)
+
+    for i in range(1000):
+        optimizer.zero_grad()
+        loss = wasserstein_dist(x1, x2).sum()
+        loss.backward()
+        optimizer.step()
+
+    """
+    if two sets are close in the euclidean space, the sum of the elements in the two sets must add to a similar 
+    value
+    """
+    assert (torch.abs(x1.sum(dim=1).sum(dim=1) - x2.sum(dim=1).sum(dim=1)) < 3.0).all()
diff --git a/tests/fairalgo/test_senstir.py b/tests/fairalgo/test_senstir.py
new file mode 100644
index 0000000..280947b
--- /dev/null
+++ b/tests/fairalgo/test_senstir.py
@@ -0,0 +1,99 @@
+import torch
+
+from inFairness.distances import (
+    BatchedWassersteinDistance,
+    SensitiveSubspaceDistance,
+    SquaredEuclideanDistance,
+)
+from inFairness.fairalgo import SenSTIR
+
+
+def generate_test_data(num_batches, queries_per_batch, items_per_query):
+    num_features = 2
+    item_data = torch.rand(
+        num_batches, queries_per_batch, items_per_query, num_features
+    )
+    relevances = torch.sum(item_data, dim=3)
+
+    # mask the second dimension for some items
+    mask = torch.ones(num_batches, queries_per_batch, items_per_query, 1)
+    mask = torch.cat([mask, mask.clone().bernoulli_(0.8)], dim=3)
+    item_data *= mask
+
+    return item_data, relevances
+
+
+def compute_loss_ratios(senstir_model: SenSTIR, Q, relevances):
+    Q_worst = senstir_model.auditor.generate_worst_case_examples(
+        senstir_model.network, Q, torch.tensor(1.0)
+    )
+    loss_ratios = senstir_model.auditor.compute_loss_ratio(
+        Q, Q_worst, relevances, senstir_model.network
+    )
+    return loss_ratios.mean()
+
+
+def test_senstir():
+    num_steps = 200
+    queries_per_batch = 10
+    items_per_query = 5
+    feature_size = 2
+
+    # dummy synthetic data
+    item_data, relevances = generate_test_data(
+        num_steps, queries_per_batch, items_per_query
+    )
+
+    # dummy data for evaluation
+    eval_item_data, eval_relevances = generate_test_data(1, 20, items_per_query)
+
+    # dummy wasserstein distance sensitive on the first dimension
+    distance_q = BatchedWassersteinDistance(SensitiveSubspaceDistance())
+    distance_q.fit(
+        basis_vectors=torch.tensor([[0], [1.0]])
+    )  # we use the second dimension in the basis vector because the projection complement will give us the first
+
+    distance_y = SquaredEuclideanDistance()
+    distance_y.fit(num_dims=items_per_query)
+
+    # dummy network equally sensitive in both dimensions
+    network = torch.nn.Linear(feature_size, 1, bias=None)
+    network.weight.data = (
+        torch.ones((1, feature_size)) + torch.rand((1, feature_size)) * 0.01
+    )
+
+    fair_algo = SenSTIR(
+        network,
+        distance_q,
+        distance_y,
+        rho=0.1,
+        eps=0.001,
+        auditor_nsteps=10,
+        auditor_lr=0.05,
+        monte_carlo_samples_ndcg=60,
+    )
+    fair_algo.train()
+
+    loss_ratio_random = compute_loss_ratios(
+        fair_algo, Q=eval_item_data[0], relevances=eval_relevances[0]
+    )
+
+    optimizer = torch.optim.Adam(fair_algo.parameters(), lr=0.01)
+
+    for i in range(num_steps):
+        optimizer.zero_grad()
+        loss = fair_algo(item_data[i], relevances[i]).loss
+        loss.backward()
+        optimizer.step()
+
+    weights = network.weight.data.squeeze()
+    # the ratio of the first component of this vector should be greater than 3
+    # so that the response of the network should be majorly on the first dimension
+    assert weights[0] / weights[1] > 3.0
+
+    loss_ratio_trained = compute_loss_ratios(
+        fair_algo, Q=eval_item_data[0], relevances=eval_relevances[0]
+    )
+    # the trained loss ratio should be closer to 1 since the network should predict same scores for both adversarial examples and
+    # normal examples.
+    assert abs(loss_ratio_trained - 1.0) < abs(loss_ratio_random - 1.0)
diff --git a/tests/utils/test_normalized_discounted_cumulative_gain.py b/tests/utils/test_normalized_discounted_cumulative_gain.py
new file mode 100644
index 0000000..f3d2842
--- /dev/null
+++ b/tests/utils/test_normalized_discounted_cumulative_gain.py
@@ -0,0 +1,16 @@
+import torch
+import inFairness.utils.normalized_discounted_cumulative_gain as ndcg
+
+def test_normalized_discounted_cumulative_gain():
+  x = torch.tensor([10,8.,1.])
+  assert ndcg.normalized_discounted_cumulative_gain(x) == 1.0
+
+  x = torch.tensor([1.,2,3])
+
+  assert ndcg.normalized_discounted_cumulative_gain(x) - 0.7397 < 0.01
+
+  batch_x = torch.arange(8,dtype=torch.float).reshape(2,4)
+  assert (ndcg.vect_normalized_discounted_cumulative_gain(batch_x) - 0.6447 < 1e-2).all()
+
+  batch_x,_ = torch.sort(batch_x, descending=True, dim=1)
+  assert (ndcg.vect_normalized_discounted_cumulative_gain(batch_x) - 1. < 1e-2).all()
diff --git a/tests/utils/test_plackett_luce.py b/tests/utils/test_plackett_luce.py
new file mode 100644
index 0000000..2d94a29
--- /dev/null
+++ b/tests/utils/test_plackett_luce.py
@@ -0,0 +1,48 @@
+
+import torch
+from torch.nn.parameter import Parameter
+from functorch import vmap
+
+from inFairness.utils import plackett_luce
+from inFairness.utils.plackett_luce import PlackettLuce
+from inFairness.utils.normalized_discounted_cumulative_gain import vect_normalized_discounted_cumulative_gain as v_ndcg
+
+vect_gather = vmap(torch.gather, in_dims=(None,None, 0))
+batched_v_ndcg = vmap(v_ndcg, in_dims=(0))
+
+def test_batch_plackett_luce():
+  """
+  the idea of this test is to use normalized discounted cumulative gain to evaluate how
+  good the underlying plackett_luce distribution approximates some ideal relevance
+
+  after optimization, the parameterized dummy_logits should assign the highest value to
+  the most relevant item in the query.
+  """
+
+  relevances1 = torch.arange(3,dtype=torch.float)
+  relevances2 = torch.arange(2,-1,-1, dtype=torch.float)
+  relevances = torch.stack([relevances1, relevances2])
+
+  montecarlo_samples = 100
+  dummy_logits = Parameter(torch.randn(2,3))
+  plackett_luce = PlackettLuce(dummy_logits)
+
+  optimizer = torch.optim.Adam([dummy_logits],lr=0.01)
+
+  for _ in range(1000):
+    optimizer.zero_grad()
+    sampled_indices = plackett_luce.sample((montecarlo_samples,))
+    log_probs = plackett_luce.log_prob(sampled_indices)
+
+    pred_relevances = vect_gather(relevances,1,sampled_indices)
+
+    utility = -batched_v_ndcg(pred_relevances)*log_probs
+
+    utility.mean().backward()
+    optimizer.step()
+  
+  #the dummy logits should be increasing for the increasing relevances and decreasing for the others
+  dummy_increasing, dummy_decreasing = dummy_logits[0], dummy_logits[1]
+
+  assert all([(dummy_increasing[i] < dummy_increasing[i+1]).item() for i in range(2)])
+  assert all([(dummy_decreasing[i] > dummy_decreasing[i+1]).item() for i in range(2)])