From 2e6570c84b2dded950480b8bf63862e33de4b4d5 Mon Sep 17 00:00:00 2001
From: MicnedSQ <MicnedSQ@gmail.com>
Date: Tue, 29 Oct 2024 13:50:59 +0100
Subject: [PATCH 1/5] initial project commit

---
 Ex1.ipynb | 292 ++++++++++++++++++++++++++++++++++++++++++++++++++++++
 Ex2.ipynb | 244 +++++++++++++++++++++++++++++++++++++++++++++
 2 files changed, 536 insertions(+)
 create mode 100644 Ex1.ipynb
 create mode 100644 Ex2.ipynb

diff --git a/Ex1.ipynb b/Ex1.ipynb
new file mode 100644
index 0000000..696d156
--- /dev/null
+++ b/Ex1.ipynb
@@ -0,0 +1,292 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torch import nn\n",
+    "from torch.utils.data import DataLoader\n",
+    "from torchvision import datasets\n",
+    "from torchvision.transforms import ToTensor"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "training_data = datasets.FashionMNIST(\n",
+    "    root=\"data\",\n",
+    "    train=True,\n",
+    "    download=True,\n",
+    "    transform=ToTensor(),\n",
+    ")\n",
+    "\n",
+    "test_data = datasets.FashionMNIST(\n",
+    "    root=\"data\",\n",
+    "    train=False,\n",
+    "    download=True,\n",
+    "    transform=ToTensor(),\n",
+    ")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Shape of X [N, C, H, W]: torch.Size([64, 1, 28, 28])\n",
+      "Shape of y: torch.Size([64]) torch.int64\n"
+     ]
+    }
+   ],
+   "source": [
+    "batch_size = 64\n",
+    "\n",
+    "train_dataloader = DataLoader(training_data, batch_size=batch_size)\n",
+    "test_dataloader = DataLoader(test_data, batch_size=batch_size)\n",
+    "\n",
+    "for X, y in test_dataloader:\n",
+    "    print(f\"Shape of X [N, C, H, W]: {X.shape}\")\n",
+    "    print(f\"Shape of y: {y.shape} {y.dtype}\")\n",
+    "    break"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Using cuda device\n",
+      "NeuralNetwork(\n",
+      "  (flatten): Flatten(start_dim=1, end_dim=-1)\n",
+      "  (linear_relu_stack): Sequential(\n",
+      "    (0): Linear(in_features=784, out_features=512, bias=True)\n",
+      "    (1): ReLU()\n",
+      "    (2): Linear(in_features=512, out_features=512, bias=True)\n",
+      "    (3): ReLU()\n",
+      "    (4): Linear(in_features=512, out_features=10, bias=True)\n",
+      "  )\n",
+      ")\n"
+     ]
+    }
+   ],
+   "source": [
+    "device = (\n",
+    "    \"cuda\"\n",
+    "    if torch.cuda.is_available()\n",
+    "    else \"mps\"\n",
+    "    if torch.backends.mps.is_available()\n",
+    "    else \"cpu\"\n",
+    ")\n",
+    "print(f\"Using {device} device\")\n",
+    "\n",
+    "class NeuralNetwork(nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "        self.flatten = nn.Flatten()\n",
+    "        self.linear_relu_stack = nn.Sequential(\n",
+    "            nn.Linear(28*28, 512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(512, 512),\n",
+    "            nn.ReLU(),\n",
+    "            nn.Linear(512, 10)\n",
+    "        )\n",
+    "\n",
+    "    def forward(self, x):\n",
+    "        x = self.flatten(x)\n",
+    "        logits = self.linear_relu_stack(x)\n",
+    "        return logits\n",
+    "\n",
+    "model = NeuralNetwork().to(device)\n",
+    "print(model)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "loss_fn = nn.CrossEntropyLoss()\n",
+    "optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def train(dataloader, model, loss_fn, optimizer):\n",
+    "    size = len(dataloader.dataset)\n",
+    "    model.train()\n",
+    "    for batch, (X, y) in enumerate(dataloader):\n",
+    "        X, y = X.to(device), y.to(device)\n",
+    "\n",
+    "        pred = model(X)\n",
+    "        loss = loss_fn(pred, y)\n",
+    "\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "        optimizer.zero_grad()\n",
+    "\n",
+    "        if batch % 100 == 0:\n",
+    "            loss, current = loss.item(), (batch + 1) * len(X)\n",
+    "            print(f\"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def test(dataloader, model, loss_fn):\n",
+    "    size = len(dataloader.dataset)\n",
+    "    num_batches = len(dataloader)\n",
+    "    model.eval()\n",
+    "    test_loss, correct = 0, 0\n",
+    "    with torch.no_grad():\n",
+    "        for X, y in dataloader:\n",
+    "            X, y = X.to(device), y.to(device)\n",
+    "            pred = model(X)\n",
+    "            test_loss += loss_fn(pred, y).item()\n",
+    "            correct += (pred.argmax(1) == y).type(torch.float).sum().item()\n",
+    "    test_loss /= num_batches\n",
+    "    correct /= size\n",
+    "    print(f\"Test Error: \\n Accuracy: {(100*correct):>0.1f}%, Avg loss: {test_loss:>8f} \\n\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Epoch 1\n",
+      "-------------------------------\n",
+      "loss: 2.301345  [   64/60000]\n",
+      "loss: 2.289013  [ 6464/60000]\n",
+      "loss: 2.267571  [12864/60000]\n",
+      "loss: 2.253652  [19264/60000]\n",
+      "loss: 2.245495  [25664/60000]\n",
+      "loss: 2.214388  [32064/60000]\n",
+      "loss: 2.218577  [38464/60000]\n",
+      "loss: 2.192012  [44864/60000]\n",
+      "loss: 2.185515  [51264/60000]\n",
+      "loss: 2.154312  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 46.3%, Avg loss: 2.144304 \n",
+      "\n",
+      "Epoch 2\n",
+      "-------------------------------\n",
+      "loss: 2.153029  [   64/60000]\n",
+      "loss: 2.143812  [ 6464/60000]\n",
+      "loss: 2.087860  [12864/60000]\n",
+      "loss: 2.103519  [19264/60000]\n",
+      "loss: 2.048817  [25664/60000]\n",
+      "loss: 1.996760  [32064/60000]\n",
+      "loss: 2.015409  [38464/60000]\n",
+      "loss: 1.948691  [44864/60000]\n",
+      "loss: 1.953080  [51264/60000]\n",
+      "loss: 1.880756  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 60.8%, Avg loss: 1.873655 \n",
+      "\n",
+      "Epoch 3\n",
+      "-------------------------------\n",
+      "loss: 1.901290  [   64/60000]\n",
+      "loss: 1.874183  [ 6464/60000]\n",
+      "loss: 1.759593  [12864/60000]\n",
+      "loss: 1.804479  [19264/60000]\n",
+      "loss: 1.688624  [25664/60000]\n",
+      "loss: 1.641422  [32064/60000]\n",
+      "loss: 1.656471  [38464/60000]\n",
+      "loss: 1.567693  [44864/60000]\n",
+      "loss: 1.594154  [51264/60000]\n",
+      "loss: 1.483651  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 63.9%, Avg loss: 1.499217 \n",
+      "\n",
+      "Epoch 4\n",
+      "-------------------------------\n",
+      "loss: 1.559186  [   64/60000]\n",
+      "loss: 1.532048  [ 6464/60000]\n",
+      "loss: 1.379261  [12864/60000]\n",
+      "loss: 1.455680  [19264/60000]\n",
+      "loss: 1.335025  [25664/60000]\n",
+      "loss: 1.325481  [32064/60000]\n",
+      "loss: 1.334234  [38464/60000]\n",
+      "loss: 1.269634  [44864/60000]\n",
+      "loss: 1.307040  [51264/60000]\n",
+      "loss: 1.203263  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 64.5%, Avg loss: 1.229295 \n",
+      "\n",
+      "Epoch 5\n",
+      "-------------------------------\n",
+      "loss: 1.298207  [   64/60000]\n",
+      "loss: 1.292620  [ 6464/60000]\n",
+      "loss: 1.121837  [12864/60000]\n",
+      "loss: 1.233628  [19264/60000]\n",
+      "loss: 1.112199  [25664/60000]\n",
+      "loss: 1.126678  [32064/60000]\n",
+      "loss: 1.144357  [38464/60000]\n",
+      "loss: 1.091252  [44864/60000]\n",
+      "loss: 1.132425  [51264/60000]\n",
+      "loss: 1.049065  [57664/60000]\n",
+      "Test Error: \n",
+      " Accuracy: 65.3%, Avg loss: 1.068460 \n",
+      "\n",
+      "Done!\n"
+     ]
+    }
+   ],
+   "source": [
+    "epochs = 5\n",
+    "for t in range(epochs):\n",
+    "    print(f\"Epoch {t+1}\\n-------------------------------\")\n",
+    "    train(train_dataloader, model, loss_fn, optimizer)\n",
+    "    test(test_dataloader, model, loss_fn)\n",
+    "print(\"Done!\")"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}
diff --git a/Ex2.ipynb b/Ex2.ipynb
new file mode 100644
index 0000000..aff4a70
--- /dev/null
+++ b/Ex2.ipynb
@@ -0,0 +1,244 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import torch\n",
+    "from torchvision import datasets\n",
+    "from torchvision import transforms\n",
+    "import matplotlib.pyplot as plt"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Transforms images to a PyTorch Tensor\n",
+    "tensor_transform = transforms.ToTensor()\n",
+    " \n",
+    "# Download the MNIST Dataset\n",
+    "dataset = datasets.FashionMNIST(root = \"./data\",\n",
+    "                         download = True,\n",
+    "                         transform = tensor_transform)\n",
+    " \n",
+    "# DataLoader is used to load the dataset \n",
+    "# for training\n",
+    "loader = torch.utils.data.DataLoader(dataset = dataset,\n",
+    "                                     batch_size = 32,\n",
+    "                                     shuffle = True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# Creating a PyTorch class\n",
+    "# 28*28 ==> 9 ==> 28*28\n",
+    "class AE(torch.nn.Module):\n",
+    "    def __init__(self):\n",
+    "        super().__init__()\n",
+    "         \n",
+    "        # Building an linear encoder with Linear\n",
+    "        # layer followed by Relu activation function\n",
+    "        # 784 ==> 9\n",
+    "        self.encoder = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(28 * 28, 128),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(128, 64),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(64, 36),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(36, 18),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(18, 9)\n",
+    "        )\n",
+    "         \n",
+    "        # Building an linear decoder with Linear\n",
+    "        # layer followed by Relu activation function\n",
+    "        # The Sigmoid activation function\n",
+    "        # outputs the value between 0 and 1\n",
+    "        # 9 ==> 784\n",
+    "        self.decoder = torch.nn.Sequential(\n",
+    "            torch.nn.Linear(9, 18),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(18, 36),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(36, 64),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(64, 128),\n",
+    "            torch.nn.ReLU(),\n",
+    "            torch.nn.Linear(128, 28 * 28),\n",
+    "            torch.nn.Sigmoid()\n",
+    "        )\n",
+    " \n",
+    "    def forward(self, x):\n",
+    "        encoded = self.encoder(x)\n",
+    "        decoded = self.decoder(encoded)\n",
+    "        return decoded"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "# Model Initialization\n",
+    "model = AE()\n",
+    " \n",
+    "# Validation using MSE Loss function\n",
+    "loss_function = torch.nn.MSELoss()\n",
+    " \n",
+    "# Using an Adam Optimizer with lr = 0.1\n",
+    "optimizer = torch.optim.Adam(model.parameters(),\n",
+    "                             lr = 1e-1,\n",
+    "                             weight_decay = 1e-8)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "epochs = 20\n",
+    "outputs = []\n",
+    "losses = []\n",
+    "for epoch in range(epochs):\n",
+    "    for (image, _) in loader:\n",
+    "       \n",
+    "      # Reshaping the image to (-1, 784)\n",
+    "      image = image.reshape(-1, 28*28)\n",
+    "       \n",
+    "      # Output of Autoencoder\n",
+    "      reconstructed = model(image)\n",
+    "       \n",
+    "      # Calculating the loss function\n",
+    "      loss = loss_function(reconstructed, image)\n",
+    "       \n",
+    "      # The gradients are set to zero,\n",
+    "      # the gradient is computed and stored.\n",
+    "      # .step() performs parameter update\n",
+    "      optimizer.zero_grad()\n",
+    "      loss.backward()\n",
+    "      optimizer.step()\n",
+    "       \n",
+    "      # Storing the losses in a list for plotting\n",
+    "      losses.append(loss)\n",
+    "    outputs.append((epochs, image, reconstructed))"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "plt.style.use('fivethirtyeight')\n",
+    "plt.xlabel('Iterations')\n",
+    "plt.ylabel('Loss')\n",
+    "\n",
+    "losses_tensor = torch.tensor(losses)\n",
+    "\n",
+    "plt.plot(losses_tensor[-100:].detach().numpy())\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 30,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Images:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reconstructed:\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZgAAAGYCAYAAAB/O/RVAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAPTklEQVR4nO3cTW8b5wEE4JVpkRT1YTqOESDJIf//N+UWIB+GbdGSTUkUSfXSS9EWJSeZre08z7njd8ldarKHzslqtXoaAOAv9uz/fQEAfJ0UDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQ8P/R/uFwui5fx93JychLlnj3L/ntgOp1GucViEeVev34d5V69ehXl5vN5lEu/zzFtt9sot16vo9z19XWU++2336Lc/f19lNvtdlHu6Sn7/5Wnua/ZarX6n/+bz/8XBsAXScEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoOXlPm36WryGdnZ1Hu5cuXUS5dN/7xxx+j3E8//RTlvv/++yj34sWLKHd6enp0Zr/fR2dNJpMol674/vLLL1Hu7du3Ue7nn3+OcukK85s3b6Lczc1NlEtWrcdebk6fzSZvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIU15X9KlpEvLi6is7777rsol64GpyvMl5eXUe7Vq1dRLlk3HoZ8qThZn91sNtFZqbGXt9OF8Nvb2yj3/Hn2Jyj97f3+++9R7v3790dn0mfl8fExyqX3Ll1vPoQ3GAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoOKrW1NOF0Vns9nRmW+++SY6a7lcRrl0ITe9ztevX0e55Lv8M9brdZSbz+dHZ9Ln69mz7L/l7u/vo1y6TJ0+Yz/88EOUS+7BMAzDdDqNcunydrI4vFqtRjtrGPIV5iZvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIU15X86Ozs7OnN5eRmdla4bn5+fR7nks/2Z89Ll4NRms4lyybPy/Pm4P5mrq6sol/4OttttlEtXn9NnJV3sTs9LlorT73K/30e53W4X5dLrPIQ3GAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNARX25Lx3dS3PT6TTKXVxcHJ2Zz+fRWelIZjrUd3p6OmouHetLpfc8GQFNn8vFYhHlkudyGPJRznT4cOxc+mym9y8Z81yv19FZ6WhlMsg5DMYuAfgCKRgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQMVXt6acrqzOZrOjM+lCbrr+m+aSzzYM+T1I12DTdep0OTi5f5PJJDorWW7+M7lUutidXme6Fr3ZbKJcuji8XC6Pznz48CE6K/1snz59inIPDw9R7hDeYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIrPdk05Xa1N15STRd50pTj9bOlqcPqd7Pf7KJde59PT06jnJd9Leo3pPUgXtNOF3LFXn9MF7XT1Of0+k9Xnq6ur6Kx0jfz6+jrKrdfrKHcIbzAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0DFwTO06SpymksXctO11ES6BJt+J+ki73a7jXLpdY69ipzmkkXedMU3XdZ98eJFlLu/v49y6e8nfcbSZyVdAE4Xwm9ubo7OXF5eRmc9Pj5GucViEeXSFeZDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqshnaEaRLvqlkRXbMFd9hyJdu08XaL+U6x1xhTs/69ttvo1x6D9J141T6vaQL4el5Z2dnUS5ZtX737l101vn5eZSbzWZRbjKZRLlDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAq6mvK6SpyuqybSq4zXSFNl2DHXhtO7126ADyfz6NcsnSb5tJ7nn62dG04XQ3e7XZRLn02N5tNlBv7t7der4/OvHr1Kjrr7u4uyi0WiyiX/l4P+rdr/zIAf2sKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQ8dmuKacLn9vtNso9PDyMkhmGfEE2XdadTqdRLl1nvbq6inIXFxdRbrlcRrlk7Ta95+mKb7rCnF7n5eVllHt8fIxyt7e3Ue7+/j7KpavPSS5dfE5/P+nvIP0bfQhvMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQMXBE69jryJ/CdJV5HR5Nl2CTdeU03XWly9fRrl0cTj9fMmzmS7kpteYnje29HeeLminq+n7/T7KnZ+fH51Jn+f0no993iG+3r/+APxfKRgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQEU2v/kZS5dBZ7PZ0Zmx138Xi0WUu7q6inIvXryIcuma8nw+j3LJ0m0qXRVP13/T7yR9xsZefd7tdqOely6ZJ9K/D+kzlj4r6XUewhsMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaDi4JWzdIDt9PQ0yqXDbWdnZ1Hu8vLy6MxyuYzOSnNjj0GmufTzpc9KOtD49PR0dGa1WkVnpaOO+/0+yjUHDP+TdHxys9lEuTFHK4chG8NN73maS//2pffuEN5gAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaAioMnV9PFzcViEeXS5eD0vGSJ9OrqKjorXSlOP1t6nek668XFRZQbe005ka74pp8tfVbW63WUS1eY09Xn7XYb5VLpfUgWjp89y/77PV2uT3PpdR70b9f+ZQD+1hQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaDi4OnUdHEzXWdNl0HT85Ll4HTpNl03HnuRN11FTteN0+8lXZm+u7s7OvPx48forHSNfDabRbl09TldMU9zqfTzpevNyd+j9G9Y+qw8PT2NmjuENxgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaCivqY89gpzuuqarCmn15hKl2BT6edLV5/TZyVZRR6GbBl5t9tFZ202myh3fX0d5fb7fZRLn7Hb29so98cff0S5dE05zSXPSvpcPjw8jJpLV58P4Q0GgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoOHguN11ZTVddp9NplBt7ATgx9jL1bDaLcmOvRd/c3ES5q6urKJcuIyfS38/T01OUm0wmUS79vabfZfq7S9epU8lvL70HqbHv3SG8wQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUHz+WmS77pIm+6ppzmksXhk5OT6Kx0ITc9L111Hfs6Hx8fo9z9/X2US9Zn07PS38HDw0OUS3+v6XmfPn2Kcre3t6Oely4OJ9eZfrb1eh3l0vOay9TeYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIps4vUI6ZLvdruNcunabbJgutvtorPSxdp0CTa9zru7uyi3Wq2iXLJoPQzDcHNzE+WSe/7hw4forHTdOF20Tu9d+vnSe5Dm0gXg9DeU/F0Zex08XZhOr/MQ3mAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoCKg9eU01XXdKlz7NyYa6npsu50Oo1y6Tpruvqcnpfm0mczWVNOv5N0pThdFU/XlNPPl64ip99LKl1TTj7f7e3taGcNwzB8/PgxyqXfySG8wQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABWf7Zry2CaTyWhnpd9Jeg/Sddb5fB7l0rXoNJdKloPTteHNZhPlksXnYciXqd++fRvl0utcrVZR7vT0NMqlv6FknXrsFfOx/64cwhsMABUKBoAKBQNAhYIBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQcfCa8m63iw44OTmJcul5Y0rXUqfTaZRL11Jvb2+j3Gw2i3LpPU+lK8zJQm66/vv8+cE/tX+RLt1+/PgxyqXPyna7jXLpMz3234dk4Thd0B57sduaMgBfHAUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUHHwAt/Yo3vpeZPJJMp9+vTp6MxyuYzOSkfp5vN5lNvv91GuOYL3V56Xfr5kMDG9d+v1Osqlw6Hpdzn2aGWaS6XDqMkAZTqGmw6Ops9Y+vs5hDcYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgor6mnK7Ppp4/P/gj/Yvr6+ujM+m6cboge3p6GuXSe5cu+d7d3UW52WwW5VLJau2vv/5auJL/brFYRLl0FTldP0+XfN+9exflptNplEsWtIch+/vw/v370c4ahny9ubma7g0GgAoFA0CFggGgQsEAUKFgAKhQMABUKBgAKhQMABUKBoAKBQNAhYIBoELBAFChYACoqK8pp8vBqXTV9ebm5ujM+fl5dNZ+v49yz56N+98Dk8kkyqWfL10ATs9L7nn6fKXrv6l0VTyVLvkmi9bDkD+bqdVqdXTmw4cP0VnpGvnYy/WH8AYDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgAoFA0CFggGgQsEAUKFgAKhQMABU1CdX06XbdBk0PS9Zi04XZNNV5HRteD6fR7nlchnlXr58GeUuLi6i3MnJSZRLlnzTpdvZbBblFotFlNvtdlHu7du3Ue7NmzdRLv0Npc90usKcXOf19fVoZw1Dfs/TpfxDeIMBoELBAFChYACoUDAAVCgYACoUDAAVCgaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqDl5TXq1WxcsA4GvjDQaACgUDQIWCAaBCwQBQoWAAqFAwAFQoGAAqFAwAFQoGgIp/AKyQ5ECtMprTAAAAAElFTkSuQmCC",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Images:\")\n",
+    "for i, item in enumerate(image):\n",
+    "  item = item.reshape(-1, 28, 28)\n",
+    "  plt.imshow(item[0].detach().numpy(), 'gray')\n",
+    "plt.axis('off')\n",
+    "plt.show()\n",
+    " \n",
+    "print(\"Reconstructed:\")\n",
+    "for i, item in enumerate(reconstructed):\n",
+    "  item = item.reshape(-1, 28, 28)\n",
+    "  plt.imshow(item[0].detach().numpy(), 'gray')\n",
+    "plt.axis('off')\n",
+    "plt.show()"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.9.19"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

From 1dd7e77c45321189ce1ba75a898e91c9d5b4ebb3 Mon Sep 17 00:00:00 2001
From: MicnedSQ <MicnedSQ@gmail.com>
Date: Sun, 3 Nov 2024 20:44:39 +0100
Subject: [PATCH 2/5] Task1 done

---
 Ex1.ipynb | 16 +++-------
 Ex2.ipynb | 93 +++++++++++++++++++++++++------------------------------
 2 files changed, 47 insertions(+), 62 deletions(-)

diff --git a/Ex1.ipynb b/Ex1.ipynb
index 696d156..008799c 100644
--- a/Ex1.ipynb
+++ b/Ex1.ipynb
@@ -84,25 +84,16 @@
     }
    ],
    "source": [
-    "device = (\n",
-    "    \"cuda\"\n",
-    "    if torch.cuda.is_available()\n",
-    "    else \"mps\"\n",
-    "    if torch.backends.mps.is_available()\n",
-    "    else \"cpu\"\n",
-    ")\n",
+    "device = \"cuda\" if torch.cuda.is_available() else \"mps\" if torch.backends.mps.is_available() else \"cpu\"\n",
     "print(f\"Using {device} device\")\n",
     "\n",
+    "\n",
     "class NeuralNetwork(nn.Module):\n",
     "    def __init__(self):\n",
     "        super().__init__()\n",
     "        self.flatten = nn.Flatten()\n",
     "        self.linear_relu_stack = nn.Sequential(\n",
-    "            nn.Linear(28*28, 512),\n",
-    "            nn.ReLU(),\n",
-    "            nn.Linear(512, 512),\n",
-    "            nn.ReLU(),\n",
-    "            nn.Linear(512, 10)\n",
+    "            nn.Linear(28 * 28, 512), nn.ReLU(), nn.Linear(512, 512), nn.ReLU(), nn.Linear(512, 10)\n",
     "        )\n",
     "\n",
     "    def forward(self, x):\n",
@@ -110,6 +101,7 @@
     "        logits = self.linear_relu_stack(x)\n",
     "        return logits\n",
     "\n",
+    "\n",
     "model = NeuralNetwork().to(device)\n",
     "print(model)"
    ]
diff --git a/Ex2.ipynb b/Ex2.ipynb
index aff4a70..62d753a 100644
--- a/Ex2.ipynb
+++ b/Ex2.ipynb
@@ -20,17 +20,13 @@
    "source": [
     "# Transforms images to a PyTorch Tensor\n",
     "tensor_transform = transforms.ToTensor()\n",
-    " \n",
+    "\n",
     "# Download the MNIST Dataset\n",
-    "dataset = datasets.FashionMNIST(root = \"./data\",\n",
-    "                         download = True,\n",
-    "                         transform = tensor_transform)\n",
-    " \n",
-    "# DataLoader is used to load the dataset \n",
+    "dataset = datasets.FashionMNIST(root=\"./data\", download=True, transform=tensor_transform)\n",
+    "\n",
+    "# DataLoader is used to load the dataset\n",
     "# for training\n",
-    "loader = torch.utils.data.DataLoader(dataset = dataset,\n",
-    "                                     batch_size = 32,\n",
-    "                                     shuffle = True)"
+    "loader = torch.utils.data.DataLoader(dataset=dataset, batch_size=32, shuffle=True)"
    ]
   },
   {
@@ -44,7 +40,7 @@
     "class AE(torch.nn.Module):\n",
     "    def __init__(self):\n",
     "        super().__init__()\n",
-    "         \n",
+    "\n",
     "        # Building an linear encoder with Linear\n",
     "        # layer followed by Relu activation function\n",
     "        # 784 ==> 9\n",
@@ -57,9 +53,9 @@
     "            torch.nn.ReLU(),\n",
     "            torch.nn.Linear(36, 18),\n",
     "            torch.nn.ReLU(),\n",
-    "            torch.nn.Linear(18, 9)\n",
+    "            torch.nn.Linear(18, 9),\n",
     "        )\n",
-    "         \n",
+    "\n",
     "        # Building an linear decoder with Linear\n",
     "        # layer followed by Relu activation function\n",
     "        # The Sigmoid activation function\n",
@@ -75,9 +71,9 @@
     "            torch.nn.Linear(64, 128),\n",
     "            torch.nn.ReLU(),\n",
     "            torch.nn.Linear(128, 28 * 28),\n",
-    "            torch.nn.Sigmoid()\n",
+    "            torch.nn.Sigmoid(),\n",
     "        )\n",
-    " \n",
+    "\n",
     "    def forward(self, x):\n",
     "        encoded = self.encoder(x)\n",
     "        decoded = self.decoder(encoded)\n",
@@ -90,17 +86,14 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "\n",
     "# Model Initialization\n",
     "model = AE()\n",
-    " \n",
+    "\n",
     "# Validation using MSE Loss function\n",
     "loss_function = torch.nn.MSELoss()\n",
-    " \n",
+    "\n",
     "# Using an Adam Optimizer with lr = 0.1\n",
-    "optimizer = torch.optim.Adam(model.parameters(),\n",
-    "                             lr = 1e-1,\n",
-    "                             weight_decay = 1e-8)"
+    "optimizer = torch.optim.Adam(model.parameters(), lr=1e-1, weight_decay=1e-8)"
    ]
   },
   {
@@ -113,26 +106,26 @@
     "outputs = []\n",
     "losses = []\n",
     "for epoch in range(epochs):\n",
-    "    for (image, _) in loader:\n",
-    "       \n",
-    "      # Reshaping the image to (-1, 784)\n",
-    "      image = image.reshape(-1, 28*28)\n",
-    "       \n",
-    "      # Output of Autoencoder\n",
-    "      reconstructed = model(image)\n",
-    "       \n",
-    "      # Calculating the loss function\n",
-    "      loss = loss_function(reconstructed, image)\n",
-    "       \n",
-    "      # The gradients are set to zero,\n",
-    "      # the gradient is computed and stored.\n",
-    "      # .step() performs parameter update\n",
-    "      optimizer.zero_grad()\n",
-    "      loss.backward()\n",
-    "      optimizer.step()\n",
-    "       \n",
-    "      # Storing the losses in a list for plotting\n",
-    "      losses.append(loss)\n",
+    "    for image, _ in loader:\n",
+    "\n",
+    "        # Reshaping the image to (-1, 784)\n",
+    "        image = image.reshape(-1, 28 * 28)\n",
+    "\n",
+    "        # Output of Autoencoder\n",
+    "        reconstructed = model(image)\n",
+    "\n",
+    "        # Calculating the loss function\n",
+    "        loss = loss_function(reconstructed, image)\n",
+    "\n",
+    "        # The gradients are set to zero,\n",
+    "        # the gradient is computed and stored.\n",
+    "        # .step() performs parameter update\n",
+    "        optimizer.zero_grad()\n",
+    "        loss.backward()\n",
+    "        optimizer.step()\n",
+    "\n",
+    "        # Storing the losses in a list for plotting\n",
+    "        losses.append(loss)\n",
     "    outputs.append((epochs, image, reconstructed))"
    ]
   },
@@ -153,9 +146,9 @@
     }
    ],
    "source": [
-    "plt.style.use('fivethirtyeight')\n",
-    "plt.xlabel('Iterations')\n",
-    "plt.ylabel('Loss')\n",
+    "plt.style.use(\"fivethirtyeight\")\n",
+    "plt.xlabel(\"Iterations\")\n",
+    "plt.ylabel(\"Loss\")\n",
     "\n",
     "losses_tensor = torch.tensor(losses)\n",
     "\n",
@@ -206,16 +199,16 @@
    "source": [
     "print(\"Images:\")\n",
     "for i, item in enumerate(image):\n",
-    "  item = item.reshape(-1, 28, 28)\n",
-    "  plt.imshow(item[0].detach().numpy(), 'gray')\n",
-    "plt.axis('off')\n",
+    "    item = item.reshape(-1, 28, 28)\n",
+    "    plt.imshow(item[0].detach().numpy(), \"gray\")\n",
+    "plt.axis(\"off\")\n",
     "plt.show()\n",
-    " \n",
+    "\n",
     "print(\"Reconstructed:\")\n",
     "for i, item in enumerate(reconstructed):\n",
-    "  item = item.reshape(-1, 28, 28)\n",
-    "  plt.imshow(item[0].detach().numpy(), 'gray')\n",
-    "plt.axis('off')\n",
+    "    item = item.reshape(-1, 28, 28)\n",
+    "    plt.imshow(item[0].detach().numpy(), \"gray\")\n",
+    "plt.axis(\"off\")\n",
     "plt.show()"
    ]
   }

From e7524c7d2e7493f928c22ff264b24e25945b6f2b Mon Sep 17 00:00:00 2001
From: MicnedSQ <MicnedSQ@gmail.com>
Date: Mon, 4 Nov 2024 09:01:47 +0100
Subject: [PATCH 3/5] Task2 done

---
 .pre-commit-config.yaml | 20 ++++++++++++++++++++
 Ex2.ipynb               |  2 +-
 README.md               |  2 +-
 3 files changed, 22 insertions(+), 2 deletions(-)

diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index c1fba16..735a146 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,3 +17,23 @@ repos:
       - id: end-of-file-fixer
       - id: mixed-line-ending
       - id: trailing-whitespace
+  # Black formatter
+  - repo: https://github.com/psf/black
+    rev: 24.4.0
+    hooks:
+      - id: black
+        args: ["--line-length=120"]
+
+  # Codespell - Fix common misspellings in text files.
+  - repo: https://github.com/codespell-project/codespell
+    rev: v2.2.6
+    hooks:
+      - id: codespell
+        args: [--write-changes]
+
+  # Pyupgrade - automatically upgrade syntax for newer versions of the language.
+  - repo: https://github.com/asottile/pyupgrade
+    rev: v3.15.2
+    hooks:
+      - id: pyupgrade
+        args: [--py310-plus]
diff --git a/Ex2.ipynb b/Ex2.ipynb
index 62d753a..087eed3 100644
--- a/Ex2.ipynb
+++ b/Ex2.ipynb
@@ -136,7 +136,7 @@
    "outputs": [
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApkAAAHNCAYAAABVWGAuAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/H5lhTAAAACXBIWXMAAA9hAAAPYQGoP6dpAADjkElEQVR4nOz9eZxcVZ3/j79u7b130kk6C50OCQGCrCIgREA2kUV2HCCioj90ZhD5fMAFkdEvgoOIMAoKjnwAYRCGIWNGUGQLSNgEIQgMEsmeztZJOr13135/f1RudVXd9/ucc2/dqr7VfZ6PBw86Vbdu3brLOe/zem9GX1+fCY1Go9FoNBqNxkMC430AGo1Go9FoNJqJhzYyNRqNRqPRaDSeo41MjUaj0Wg0Go3naCNTo9FoNBqNRuM52sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjcxIRj8exbt06xOPx8T4UTQn62vgTfV38ib4u/kRfF/8yXtdGG5mTjEwmM96HoGHQ18af6OviT/R18Sf6uviX8bg22sjUaDQajUaj0XiONjI1Go1Go9FoNJ6jjUyNRqPRaDQajedoI1Oj0Wg0Go1G4znayNRoNBqNRqPReI42MjUajUaj0Wg0nqONTI1Go9FoNBqN52gjU6PRaDQajUbjOdrI1Gg0Go1Go9F4Ts0YmStXrsSFF16IuXPnYvbs2Tj55JOxbNky5c+vX78eN998My666CIsWrQIra2tOOigg6SfW758OU4//XTstdde6OjowJlnnokXX3yR3X7NmjX44he/iPnz52PmzJlYvHgx7r33XpimqXysGo1Go9FoNLVOaLwPQIUVK1bg/PPPRywWw3nnnYfGxkY8/vjjuOyyy7B582ZceeWV0n28+uqruOWWWxAMBrHffvuhu7tb+plHH30UX/3qVzFt2jRcfPHFAIBly5bhnHPOwa9//WucffbZRduvWrUKn/rUpxCPx3HOOedg1qxZeOaZZ3DNNddg1apVuPXWW92dAI2mQmwaSmPTUAaHT4ugLmSM9+FoNBqNZgJh9PX1+VpiS6fTOOKII7B161Y8++yzOPjggwEA/f39OOmkk7Bp0ya8+eabmDt3rnA/GzZswM6dO3HggQeirq4O7e3tmDFjBt577z1y+76+PhxyyCEIhUJYsWIF5syZAwDYsmULjjvuOADAX//6VzQ1NeU/c/rpp+PVV1/FY489hlNOOQUAkEwmcfbZZ+O1117DM888gyOPPLLsc+KWeDyOrq4udHR0IBaLjdtxaOxU+9qYponv/qUfd70/DABojRhYduo0HDYtUvHvriX0M+NP9HXxJ/q6+Jfxuja+d5evWLEC69evxwUXXJA3MAGgpaUFV199NZLJJB555BHpfubNm4cjjjgCdXV1St/7P//zP+jv78dXvvKVvIEJAHPmzMHll1+Onp4e/P73v8+/vmbNGrz66qs49thj8wYmAEQiEXz3u98FADzwwANK363RVJrXdyTzBiYA9CVNfP2VvvE7II1Go9FMOHxvZL788ssAgBNPPNH23kknnQQAeOWVV8b9e0XbH3300WhoaKjIcWo0bnhpW8L22nu7UxhIZsfhaDQajUYzEfF9TObatWsBAAsWLLC9197ejsbGRqxbt66q32u9Zm1T+Pf8+fNt2weDQXR2dmLVqlVIp9MIhcSnPR6Puz5uEclksuj/Gv9Q7WuzezRFvt43HEck6/u1Z9XQz4w/0dfFn+jr4l+8vDZO3O2+NzIHBgYAAM3NzeT7TU1N+W2q9b1WHGbh91p/t7S0kPtrampCNpvF0NAQWltbhd+9detWZDIZN4ethErSk2Z8qNa12dEXBhC2vb5+81YkYr4O0x4X9DPjT/R18Sf6uviXcq9NMBgkxTQO3xuZk5HZs2dXZL/JZBLd3d1ob29HJKITPPxEta+NsXkQgH1FO7V9FjqagxX//lpBPzP+RF8Xf6Kvi38Zr2vjeyPTUhI5tXJwcFCqDJb7vVOnTrV9Z+E2hX/39/ezx2kYBhobG6XfXenMr0gkojP/fEq1rk08O0y+bgbDiMX05FCKfmb8ib4u/kRfF/9S7Wvj++ArKv7Roru7G0NDQ46kWy++l4rXtP6m4kMzmQw2btyIzs5OaTymRlMNhtO0SzxRuSgNjUaj0UwyfG9kLl68GADw/PPP295bvnx50Tbj+b2i7V977TUMDw9X5Dg1GjcMp2gjM57R8ZgajUaj8QbfG5nHH3885s2bh6VLl+Ldd9/Nv97f34/bb78dkUgEF110Uf717du348MPP2Td1qqce+65aG5uxq9+9Sts2bIl//qWLVtwzz33oK2tDWeeeWb+9YULF+KYY47BSy+9hGeffTb/ejKZxA9/+EMAwOc///myjkmj8YqhNF2qKKGNTI1Go9F4hO99t6FQCHfccQfOP/98nHHGGUVtJbu6unDjjTeis7Mzv/0NN9yARx55BL/4xS+wZMmS/Os9PT24/vrr8/9OpVLYvXs3/umf/in/2k033YS2tjYAQGtrK2699VZ89atfxfHHH49zzz0XQK6t5O7du3H//fcXdfsBgNtuuw2nnnoqlixZgnPPPRczZ87EM888gw8++ACXX345jjrqqIqcI43GKSOsu1wbmRqNRqPxBt8bmQBw3HHH4amnnsLNN9+MZcuWIZVK4YADDsANN9yA8847T2kfQ0NDts5Aw8PDRa9de+21eSMTAP7hH/4BbW1tuO222/Dwww/DMAwccsgh+OY3v4lPfvKTtu9YtGgRli9fjptuugnPPPMMRkZGsGDBAvzkJz/Bl7/8ZXc/XqOpAJy7XBuZGo1Go/EK3/cu13iH7ivrX6p9bWb/x1ZSzbzrE624ZGFDxb+/VtDPjD/R18Wf6OviX3Tvco1GUxWypilwl1f5YDQajUYzYdFGpkYzyeAMTEBnl2s0Go3GO7SRqdFMMrh4TEDHZGo0Go3GO7SRqdFMMrhC7IBWMjUajUbjHdrI1GgmGSIjUyuZGo1Go/GKmihhpNFoaF7dnsCja0cQCRr43MJ6HNIm7zs+nKILsQNAIquNTI1Go9F4gzYyNZoa5fktcXz22R5YwuTDq0fwh9Om4dBpYkNTrGR6eYQajUajmcxod7lGU6P8v1XDKLQXh9MmHlo9Iv2cKPFHx2RqNBqNxiu0kanR1Chr+tO21/7el5J+TsdkajQajaYaaCNTo6lRUkT8pIoSKYrJjAsMUI1Go9FonKCNTI2mRqFsxVGFmEqtZGo0Go2mGmgjU6OpUdKUkqmgROo6mRqNZrwYSmXxzdf6cPSybnzxhd1YN2AP+9FMHHR2uUZTo1C2opq7nN8myXvSNRqNpmy+9KfdeGZzAgDwQV8ab+xI4C/ntaMhrDWviYi+qhpNjULFZI6qKJmimEytZGo0mgrRE8/g2T0GpsXWkSxe3p4cpyPSVBptZGo0NUqasBVVjMQRHZOp0WjGgW0jWVAjzNZhXaB3oqKNTI2mRiGVzIwJ0xQbikM6JlOj0YwD1JgFAGnJmKWpXbSRqdHUKJTXO2vSrxciisnUSqZGo6kUSWZ8obwymomBNjI1mhoka5qk2wnIqZkihgUjulYyNRpNpeDWt1SlDM3EQBuZGk0NIlIrZWWMRoRKptsj0mg0GjEpTsnUNmYRGwbTeKcnOSE8S7qEkUZTg3CxTYBcyRTFZE6EQU2j0fgTrkSaVjJzmKaJr73Sh9+sHgEAzGsK4r9PmYYFLbVrqmklU6OpQUQxTDKXtygmM2PqAV+j0VQGbnEsGJImFb9ZM5I3MAFgw2AG3/1L/zgeUfloI1OjqUFESqbUXS55X8dlajSaSsCNWxm9sM2pmC/32V5/aVvCvnENoY1MjaYGEdmJInd5JmtK3enaZa7RaCoBF0uus8uBlbtS5OvDaXlZOj+jjUyNpgZxq2SK+pbnP6+TfzQaTQVIsu7y2jWivOLXfx9m36vldb82MjWaGkS08hcplSpGplYyNRpNJUgxC9jJrmQOJLP47/Wj7Puy2sd+RhuZGk0N4lbJFJUvyn9eG5kajaYCsDGZk3zIWbpuVBgrzynAtYA2MjWaGkS0shUpmUMKkoFWMjUaTSVg3eU1bESVi2mauF/gKgdqu+JH7RZf0mgmMaJBR6REisoXWWgjU6PRVAJujVuuu/x3G0bxqw+GEE+bWLKwAV/av6G8HVaRv/ak8N5uOunHopbd5drI1GhqEFFopcjtIitfBGgjU6PRVAZOyUyXkfjzwpY4vvjC7nyb3bd29SEUAD6/b20YmqKEHwvtLtdoNFVFZ5drNJpag+/4436fj64dQemo9ujaEXJbvzGYymLpOj7hx6KWE6O0kanR1CDC3uWimEwFv4tO/NFoNJWAC/MpJ+awa9i+Kt5CvOZH/nvdqNLCv5ZjVrWRqdHUIKJBWZT4o93lGo1mvODd5e73OUTEmcu6nvkFFVc5wCvAtYA2MjWaGkTYuzzNv6eS+KOVTI1GUwn4jj/uxxzKOyPrauYH/rorib/2iBN+LGo5u1wbmRpNDSJyn4hLGGklU6PRjA8pZmwpJ+aQWjjXwkJZJRbTQrvLNRpNVRHZisLEH4WYTG1kajSaSsC5fcsxoih3eSIDZH3eqnJVn5qKCWh3uUajqTJulUy1mExXh6TRaDRC2MQfl/Zg1jTZxBm/q5n9DixH7S7XaDRVxW12uVoJo9od0DQajX/h7KqMS6VuJG3ayhdZ+D35ZyCpfny1XIxdG5kaTQ0i7PgjGFwp11Ip2l2u0WgqAdtW0qVrWzSejfrcIzNAWI5To7RJlqzhMVkbmRpNDSIKlC/XXa6VTI1GUwn4Opnu9ieqluF3JbOfUDKnxWiTzOc/RYg2MjWaGsR1xx+d+KPRaMYJ3l3ubswZFIxnfi5jlMqa5IK/jTEydXa5RqOpKiKvt2hw1TGZGo1mvOCMJYUoHhJRSTY/j2ODjLXdpt3lGo3GDwhjMoVtJeWDVdLnsUwajaY2STFji9vsaZG7fNTHPmbKVQ5od7lGo/EJ4o4/OiZTo6kVhlJZrO1Pw/R5XUcv8LqtJNXtx8LP4xhXvmgiustD430AGo3GOW7rZA4rRNjrmEyNpvKYponb3x3Cv749gIwJ7NsSwmOntKGzaeJOy9y45VrJLHNBPV4MMApsWyxIvl7L3iWtZGo0NYjIVkxl6UD6dNZUKrTuZwVAo5ko/GVnEjeuzBmYAPBhfxpXvNw7vgdVYfje5e72NyjKLvfxOMYpmay7vIaVTG1kajQ1iMx9QqmZKkk/gFYyNZpq8HRX3Pbaa93JCf38sUqm6zqZAne5n5VMh+5y3VZSo9FUFVnxYmoVLwqSl31Wo9F4y9YRu+WQMf2dsFIuXiuZwsQfH49jXLcfLru8lmMytZGp0dQgsnKX1ESlEo8J6N7lGk016B6hH7SJvMhjE39cGpmiahl+VjKdu8sreTSVRRuZGk0NIuv1q5VMjcbfbGf6Hk7k56+a7nJfK5nMcU9l3eX+/S0ytJGp0dQg0phMUslUG6hqeUDTaGqFHaO0oVHLhbdlcHUyU1m4KuEkLMbuYyWTcpc3hAzUBQ1ye+0u12g0VUU26GglU6PxL6msiV1x2sicyM+fKJbcjR0lcpf7Wskk3OXNEQOGYSBE2JnaXa7RaKqKbJE+mra/ph6T6d/BWaOZCOxkVExg4sZEm6YprPfoRngcrtli7PZjaw7nzLFwwG5l1rJ3SRuZGk0N4krJVC5h5M51pdFo1Ohm4jEBfxtH5ZAxAdEvc+MSrtXEHyomsyWyx8gk6rHLEj39jDYyNZoaRCZKluMuByaumqLR+AGRkTlRPQkyQ8mNS3iiucsBIGzYlUxdjF2jKSBrmloJqzCyQaecxB9g4qopGo0f6CZqZFpM1GdP5vLNuEr8qc1i7KS73FIyCatMF2PXaJAzfL75Wh/2fngbFj26HXe+NzjehzRhkakCtJKpPlJNVDVFo/EDXPkiYOI+ezJ3uFOXsGmaE0rJbLGUTCLDXGeXazQAfvLOIO5ZNYz+pInto1n8y5sD+N2G0fE+rAlJJUsYAUCihgc1jcbvcOWLgImrZMrd5c5+dzwDiE6VX89jPG2SymQ+8YfMLvfnb1FBG5kaz/j9Jnsv3ic3aSOzEsjsxfJjMmt3UNNo/M52ptsPMHHjoWX1P516t2XVMvzanpPr9mO5yyOEkqnd5RoNgB2EC2g3UwtOUx6yle1I2TGZjg9Jo9EoQo2VFn5V4MpFltjjVK0TucoB+jy+uj2B057ciY88uh1ff6UXI+NQgJLr9mMl/oSIEkbaXV4FVq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8nt+/r6cP311+Owww7DjBkzsGDBAnz+85/HBx98QG5/xhlnoLW1lfzvoIMOcvybaw1KKUtoG7MiuIrJdOIun6ATnUbjB7YL62ROzGdPlvjjVHiUGpkltYK7htI4/5kevNadxJaRDB78cARXvtzn7Es9gOr2AxSUMCKsslouxh4a7wNQYcWKFTj//PMRi8Vw3nnnobGxEY8//jguu+wybN68GVdeeaV0H9lsFpdccgmWL1+OI444AmeddRbWrl2LBx98EC+++CKee+45TJs2Lb/97t27ccopp2Dt2rU48sgjcfrpp6O7uxuPP/44nnvuOTz++OP42Mc+Rn7Xt7/9bdtrLS0t7k9ADZA1TdKImcgt0sYTaZ1MSsl0EFk/UdUUjWa8MU0T3QJ3+UR99mRGptPEH1HfcsCe+PN0V9z22u83jSKeNhGj2uxUCN5dnjuGyAQrxu57IzOdTuOqq65CIBDAH/7wBxx88MEAgG9961s46aSTcOONN+Lss8/G3Llzhft5+OGHsXz5clxwwQW45557YOypRXXffffh6quvxk033YSf/vSn+e1vvvlmrF27FldccQV++MMf5l9/4403cNppp+FrX/saXn31VQQC9mXHd77zHQ9+eW1BuWeB2n44/IxsZUtlVmolU6MZf/qTdOKHxUR99mRjVqbC7vKthGGfyAC7E1nMDhEV0CsEp2RaiT8hQsnUxdgryIoVK7B+/XpccMEFeQMTyCmDV199NZLJJB555BHpfh588EEAwPe+9728gQkAl112GebNm4fHHnsMo6NjSSpPPvkkAoGAzWA88sgj8elPfxqrVq3Cyy+/XO7PmzBwSSUTdcAcb7zqXU65ZgB/15jTaGoZUfkiYOKOmV67y2WL5tF0cb1mbo6SKaJew8VkjrnLdTH2qmIZcieeeKLtvZNOOgkA8Morrwj3EY/H8eabb2LhwoU2xdMwDJxwwgkYHh7G22+/nX+9u7sbbW1taGxstO2vs7MTQM4Apnjsscdw22234a677sJLL72EbLaGlyGKcKvKWl6B+Rl573L7BpTa3BalhwCtQGs0lUFUiB2YuNnlsrnAaXLLoGSHJoqzsjmjdNBB1Q0v6GcSFcbc5fb3ank89r27fO3atQCABQsW2N5rb29HY2Mj1q1bJ9zH+vXrkc1mMX/+fPJ96/W1a9fimGOOAQC0tbVh586dGBoashmaGzduLDq2Ui6//PKif++zzz645557cNhhhwmP0yIet5cC8oJkMln0fy/ZPZwmX4+nsxX7PRMJp9cmJVE7RpIZ23mnVuxTIga2E1WmBuMpfd1Q2WdG455avi6bBxLC94eT6Zp99kTXZTguvlYj8STicXVjqm9Efu37hkfzCuFggp6jdg8nEG+qnhqyezRFvh7NJhGPpxEw7ceSzJhl3xNePjOxWEx5W98bmQMDAwCA5uZm8v2mpqb8NrJ9cMk31r4L93PyySfjN7/5DW655RbceOON+dfffPNNPP300wCA/v7+ov2cfvrp+PrXv46DDz4Yra2t2LRpE+6//37cc889OOecc/Dyyy+jo6NDeKwAsHXrVmQylVvOdnd3e77P9f0BAPYbbzSVRldXl+ffN1FRvTaJdB0APli9bySOrq7i+3MoZf9MPZIA7PFI23b1oCs0QSUVF1TimdGUTy1elw+3hQBE2Pd7B4fR1dVbvQOqANR12doTBBBlP7Ntxw50OSgIubVHfB4BYF3XFkzbs0nPYBTUWLd+207MS1VvrNu6OwwgXPSaARO927eg3wBS8QhKTbOEh/Nouc9MMBhkBTsK3xuZ48V1112H5cuX484778Rf/vIXfOxjH0N3dzd+97vfYb/99sP7779vS/q54ooriv6933774Uc/+hGamppw66234s4778SPf/xj6XfPnj3b099ikUwm0d3djfb2dkQi4ofTKR8GkwDsbSQzRlDJsJ7sOL022Td2I+cQojFDEXR0zBjbf8ZE2txt225mcx3Qb1/ZNjRPQUdHndrBT2Aq+cxo3FPL1yWxaxgAr0oFY3Xo6Giv3gF5iOi6tCIBYIj97JS26eiYrX4tgz3i8wgAU9tno6MxZ1hmP+wHYFczY61t6OjgjV+vyW4eAlCsZjeFA+icm5snW7oGgZ7iMdmLeXS8nhnfG5mUyljI4OAgWltblfZRqjxaUGrpnDlz8Pzzz+Pmm2/Gc889h7feegtz5szBddddh7lz5+JLX/pSUckjEZdddhluvfVWvP7660rbO5Gi3RCJRDz/jpTBx2RW+vdMJFSvjSxTM5k1ivYTZ+KAZtSHANiNzEwgpK9bAZV4ZjTlU4vXpSc5Inw/ZQZq7jeVQl6XoHjQCoTCjn53XGJgAkA2GEEsllMNR7O0DRE3g1U930OZYdtrzZGxax4Nj6J0TE6b3s2j1X5mfG9kWrGYa9euxaGHHlr0Xnd3N4aGhvDRj35UuI958+YhEAiwsZvW66Vxn7Nnz8add95p2/7mm28GAOUYy6lTp8IwDIyMiAeXWmaIsXomaqbkeJM2JZmVJeedy6CcyiT+TNRafRrNeNMtKMQOTNxnT9q73ONi7EDxuRzhssurXEmDyi5viYyFMU20Yuy+zy5fvHgxAOD555+3vbd8+fKibTjq6upw+OGHY/Xq1di0aVPRe6Zp4oUXXkBDQ4OS0ZjJZPDb3/4WoVAIZ511ltJveOutt2CaprSWZy3DPfDJLIrKSGi8wWnHH66O6dQYXR9OLw40msogKsQOTNxnT1rCyHGdTLnlVVhlg8sur3oJI6JOZnNBSvlEK8bueyPz+OOPx7x587B06VK8++67+df7+/tx++23IxKJ4KKLLsq/vn37dnz44Yc21/gXvvAFAMAPfvCDIqPn/vvvx4YNG3DhhReirm4sBi2VShXVzQRyXYOuv/56rF69Gl/5ylcwa9as/HsbNmxAb689WHvr1q34xje+AQC44IIL3JyCmoCrQQboMkZeY5omZPNQaQkjboDVSqZGU126JXUy48TbfYksvvtGP8784058/y/90vI9fkRWosipWieacywKx7Fh5gsGmeLolYLq+FNoZHLF2GtVrPG9uzwUCuGOO+7A+eefjzPOOKOorWRXVxduvPHGfN1KALjhhhvwyCOP4Be/+AWWLFmSf/2SSy7BsmXLsHTpUmzcuBGLFy/GunXr8MQTT6CzsxPXX3990ffu2LEDRx99NE444QR0dnYimUzi+eefx4cffohTTz0V3//+94u2f+WVV3DNNdfg6KOPRmdnJ1pbW7Fx40Y888wzGB4exmc/+9kiY3iiwT3AQG4VFglWr23XREdlfik1EjmluSlsIBKArQNJUieWazSeE0+b6JMYNaVKpmmaOP+ZXXhrV670zcvbk3hzVxJ/OG16xY6zEoyHu7xwsc15c6ptsA8QRmaxu5yeKzMmUMXul57heyMTAI477jg89dRTuPnmm7Fs2TKkUikccMABuOGGG3Deeecp7SMQCODhhx/Gv/3bv+HRRx/FXXfdhSlTpuDSSy/F9ddfb0viaW5uxmmnnYbXX38dTz/9NMLhMBYtWoQ77rgDn/vc52yZ5YcccgjOPvtsvPPOO1i5ciWGh4fR0tKCo446Cp/73OeUj7NWET3wyYxZWrFBUwYqRYvjmdzkZHW34hYBDSEDsaBhc8doJVOj8R6ZignYn73/7U3nDUyLV7YnsaY/hX1aamdgldX2dVqMXcXNbZ3LdNZki9xXsxi7aZoYIL6vJVzoLqc/m8yaCDEGqJ+pCSMTAA4//HAsXbpUut3dd9+Nu+++m3wvGo3i2muvxbXXXivdT1NTE/793/9d+fgOPPBAR9tPNEQtvpjEZo1LVFf88QxQt+cJ54LeG8JGTmUueX+ixoVpNOPJDknSD2B/9tYP0EXENw5lasvIlAwpGYfzhErCjpUAKZqfVBRRrxhKm6Bs6eYCJZMzJGswQgJADcRkamoDUXxMUhssnqIaIF+oiHADckMogBgRyqCVTI3Ge2R9ywH7s8c9i7W2EJTNA7KKGaUoZZfvGfdE81M1E3+opB9grG85wLvLa7V/uTYyNZ4gelBrOTPOj6iOiUWZlQIlM0okmNfaBOaUif77NP5kh4KRWXpvlibxWdRa3LTMHe7U1hPlAVhYSuaIYNtqusupeEygNLuc/qyDZki+QhuZGiW2jWSwbP0I/rorSWa5Cd3lNTYY+h3V2KWiGnGskmkgSiqZ7o7N72weSuO0J3di1n9sxaFLt2P5ltrsEa2pTbaPqLjLizOJS2ve5rerscW7zIjMOPg9KUGMZSGWkilSPaupZFKZ5QDQHFZxl9fW9baomZhMzfjx7OY4Ln2+J294fG5hPe5Y3IqAMfYwiB7iWn04/IpqqY/iGnFM4k/YIN3lE1Xp+8ILu/NJFBsGM7j4uR68e+FMzKyn64VqNF6iomSayBlkkT23JK9k1tYzKq2T6eDnqMZRxvNKJr99dZVM+ruai9zl9GdrtSC7VjI1QkzTxLf+3FekbD20egRv7ChuezUsWA1OVINlvFCNXSqKySQGUgNAXZBWMifiNds+krFl6Saz0GqmpmpsV0j8AYqfXU7JrLUwJJlg6ESMUFUfRxWMzKGUiWyValBS3X6A4phMqhg7UHvX20IbmRoh20ezWD9oX32/2l1iZAoe4lqNJfEryjGZRYWI7denIWTAMCaPksmVj+mJ6xtUUx1k3X4sCp8/TsmstTAkaTH2SiiZexLzRfOTKXnfS3gls9BdTn+2VrPLtbtcI2Q3MwH3ldQlktbJ1HiGckxmYSFi4vo07IkDomMynV+zdNbEj98ZxLOb49irIYhrDm7CodMijvdTKbgBvtq9izWTFxV3OVD8/MUnirtccrxOYjJVjcx8CSOJhTaUMtFUhWpQbEymQna5rM6oX9FGpkZIL/NQFGbJZU1TkvhTmw+HX1GOyZS0VGsIWUam/bNurtl1b/TjVx8MAwDe3pXCi9sSeO2cdsxp8Ee8I5fZqdKeTqMpl6xpKtXJBIqfv5EJkvgjW8s5UepUMsuBghJGki/Pud8rP05xY1Bhxx/OXV6ruQ3aXa4R0stUUi/sWiCKdwFqV+b3K26UTGrl37AnwtyL7PJU1sQja0aKXhtImvjDxlFnO6ogVKcNQFzeRKPxit2JrKNGCvm/J4mS6aROpmqyjkpMJlC9/uXUGBQycrHx+X9z7vLautx5tJGpEcIamQUrMpkSVGsrbr+jOlGNSkoYWUqmFzGZ20Yy5MC/acg/gWNaydSMJyrliywSCuXHai0mUxab70jJdJhdLnOvVyvDnHKXN0cC+fa/gEDJrLFFhYU2MjVCSmMvLQofFpkrotZW3H5HueNPUQmjysZkbhumZ7xq1qCTwRmZOiZTUw1U4zGBkpjMCZJdLhu3nLSVVB1XrDFQqmRWaZyixqBCVznAlzDy0VDqCG1kaoTwSmahK1Z899faYOh3VAebwsmJCnwXKZkZ01kbs22MSuMnA453l/vnGDUTl+2KmeWAWnZ5rS3eZUqmE3d5JRJ/qgGVfNhc0uJnohVj10amRggfkzn2uuwBrTW3jt9RHWwK3eWUsVcf4pVMwJnLfAszgVZr8FaBd5fXqESgqSm6FZN+ALVuXczQ7Fu8bCupunj1m5JJusvDxeMv11ayVocpbWRqhPDZ5WJXbCG1ugLzK057l5umSZYwatzjl6GUTMCZkVkb7nL69+iYTE014Oq0UiRU3OU1pmTK5gFnJYycFWOXZ5ePn5LZUmJVsiWManQe1UamRkhvgpmY02b+ppcm/tTYYOh3VAdjy8hMZulkoXwJI2YUcJJhvm2clcyuoTS+8uJuLP6fbnzjtT5SmeC6bVSrELNmctPtIPGn8NnjE39q675NSsaTSraVVCthVHmoMcjuLqc/W6tGpq6TqRHCucsBYDCZxdRYEEOSEjCywUXjDFW7LS6JRxIl/gDOJrGt42hkJjMmTv/jLnTtyWR/vzeNNQNp/M+p04q2Y93l2sjUVAFKyQwZtHGlpGTWmNEhi/F2YkQpZ5db7nLJ9ly8tpdksiaZxd5ckvgTYcZjHzmFHKGVTI0QkZFpPZiyB77WBkO/4zQmkzOirJjMWIge1JxkmPNKZuVHxpe3J/IGpsWftiaweShd9BrnLteJP5pqQBmZezXSBcAnYltJaeJPBbLLrTFQJoRUYzHMlUmyucsN7S7XTCK4EkaF78mUoFpz6/gd1cFY1u2iUVCMHRi7bgPJLL7xWh/O/ONOXPNan23hYZoma2RWQyXcOEh/98YSw5Nzl4+kTUfxYBqNGyh3+dxG2ploPXumaRYl8BVSa4t3aUymk+xyxXEllc0piPJi7JVfDKu0lAR073LNJCKZMYUPs6VkylaVtfpw+BXljj8ZsdIsKmFU+PkLn+3B6zuSAICXtyfx111JPHfm9HwB4d2JLKuqDKVMmKZZVGzYa7jM0NIFEqdkArnWfU1MwL1GUy5DqSw5lnYySqb17CWzAPe4T7TEH0fZ5Q6Ux9GMKfW2VaPUGmtklmaXs+7y2rreFlrJ1LD0SVZ3VoybtIRRjT4cfkW5d3naWgSI3eVU73Ig5477oDeVNzAt3tqVwlu7Uvl/bxUkNJiovJrJxVMVVkZIZ03hcchitjSacuB6ls+VuMs5VzlQeyWM5O5y77PLgZzB7gclkxunSpXMiVaMXSuZGhZRPCYwZmTWWsefzUNpPLclganRAD61V4yNSfQryh1/8n176evYGBYrmYmMiQ/70+R7/7s7hY9NjwDgyxdZDKVMNIaVDtkVXEJPoZIpaxunk3/Gn7X9aTyxcRRNEQNnddZheh2z+qlBuPJFc5voKdjKLudc5YD/xlUZMiXOySPo5HkdScuNzGrEZHLjVGtJ4k9ogsVkaiNTwyIzMvuTtZf481p3Auc/05MfdA6fFsbvPj0tH59YC6iOh9a8xg3IDXt+M9crN54x0ROn74H1A2PGJxePaVHpOpScAdlX4B7nXFUWfqrnORl5vTuB857pyd+rP3tvCH88fTrmNEwMQ5MrXzSrPohwwK5SWUpmXKRk1pyRKX7fmZKpvm1vIgvZ1tUxMtWUzAhzy9eqkVk7M6um6kiVzD2jhqxjip+yIG98a6BoVfvWrhQeWzs6jkfkHOWYzLR4ESCLyUxkTOxiimWuHxwzMrnyRRaV7qahomRy21joDPPx5d/eGypaDG0ayuDXfx8exyPyFk7JnFkXIJ+/MS+EQMmsMaNDpryqPoJcIk9pD3ALbqFcSDU6/vAxmarF2D0/pKqgjUwNi9xdbpWHqB13+dsFsYQWL29PjMORuMdp73JZCSMuuzyeMbGLUzILMrq3ytzlFTbgeCWzwMjU7nJf87+77c/lWzuTxJa5HuA3/nUYt64N4689dDiH3+CMzBl1QfL5yyuZgrHTT4t3GaZpSo1I1Vhz7lmdHqMlQDUjM5egWEm4hW5LtNRdTn++VpVM7S7XsPQKsnEB9cQfv6y4uXIghapcLeC04w+nNKvEZLJG5kA6nzUuc5dX2hXNqRC9DpRM3VpyfKFcv9sJw2zLcAaL/6d7TyhEGEu39+OhE4M4fW5dFY7SPdsJd3ksmFPf3CqZtWR0qAwBqu5ybr6ZFgtgzYD9dW4MK8RKUGwMVy4+n038KVEyDcMgQyi0kqmZcMhjMtXc5X7p+MMdZq0ZmV4pmQ0hq04m/3lugB5Kj70nc5dX2oBTc5drJVOVjYNp/Lk7UVUPBFWBgopjfODD4aJY26yZi9/0O9uJZ2RGXRCGYSBCzMJqSmbt3LMqBrHqIzjMSJ7TYrQ506OYhl/puEzKXR4L0iWLKJd5LS0qCtFKpoZFVIgdKOj4I3OX++Th4I6jN2GiL5FFK9fE22c46fhjmnSNuKAxZlxy2fXJLNiYTCBnnE+vCyoomePjLnemZNaoTOAhWdPE/321Dw98OAIgFy/4u09Pw36tFSwNsIcUcQv1JLJIZsyiSfhtwoW+clcSmayJoI/rnFJG5uz63ANIK5m5/4tjMlHxGrReUS0lk6JHMIYVMpjKYiYql2hGLXRLu/1YUAXZa3WIqo1ZVTMuKJcwkrnLfbLiFh1HLamZqiv+rJkbmHoJA6sxbOQnJ1FMpiieaf1gBqNpE70JSQ268Ur8cZBdrhN/gGc3J/IGJgBsH811eqoGXC3dHSUuc0o1T2XlFQ7GG+q4Z+0xMqPEIk9FyQTktSf9gorQoDpMcIvKaUzJK5WYTKDyi2FqnCrNLLegKn7UqpKpjUwNi0riT9YUF7kG/FOMXfRz1g3UjpHpZLAZzZikitJeMCCzHX/SYiNz3UBaaXKv5OCdzJjghIq+ZBbZPcH8ssSfanT88DuvEAlwr3Un8+ewUmSyJtvVZntJEXMqthEANgz518gcTZtFCx6LmfW56VcUkykqxg7UjstcxYBUbSvJeR2ml+kul9XSLRdqoVva7ceCqqinlUzNhINSwArpT2YxkjalNcj8stoWDcjrmf7XfkQ1CxPIGYrdRLeRmfVjRmbIAKihrns0I1RN1w+mpfGYQGXjHUVJRVlzbOLQiT9yqOuUNiufxSxahBYukBIZkzUYNvrYE0Et8oAxd7kou1xmZPolFEmGUkym4rjm3F2uaGRWeKKiFrq8u1wrmZpJgEqdTJXJuRbc5bWkZDopWswpmTPrxh59w6AzXLdIShNtGMhIu/0Alc0ulymU1j0sS/zhuiJNJjjXbKXVMlFiYGHpH5FqvsHHi0TuuGeqGJkyd7l/f3YRKgaSqhHFG5llussr3f7Wkbvc/po2MjUTDpmRmciouSL8stoWHWotxWQ6sdl2x7OkG6i9vnhApjLMN0sMyPWD4+8ulymUVvLagOSkaSWTX4TJ4gLL/l6hkpkt+Ju/1zYO+ff55Y57VoOV+GN/b6IpmSrGsOptNuQwu3y3qru8wkom6S5nCsjT2eWeH1JV0NnlGpJM1sy3jRShYmT4ZbUtTPypISXTyYqWm3zb64oH5JySWbxfWZH1nfEs29u8kErGOsmUTKsgu9RdrmMyWWOy4kamYP+qSuZGHyuZXEjJrDpeycz3LvdpTOZgKotl60exaTCDk/eK4uPtUeH21VAyp9fRRqay8ToOseOcu1yXMNJMeGTZuBYyQwTwT3C6UDEZzWI4lc338/YzTsZCzo04y6Zk2gc1lVvgVYVuSZUsDyRTH/oSVkymrpMpg3tOK69k8u91jxQamfyGG3zsieCSlUSJP6rZ5eMxtg6nsjjnqV14a0/3tJ+8O4iff6IVn1vYwH5GrYSR6vfTv3lKNAD7UlmdinpcmBOgE380kxZZWRoLFSUzbaLiGaoqyGJD/RzXVYhqxx+An3xL3eVchrmMdQrnrJKxTjKVtFfZXV6jI7iHcAk+8Qob4LLFn4VorOkezXoeV9s9ksH/rB/FX3eVl2FPHXdzxMgvaGklM/d9stJa45FU+dyWRN7AtPjxXweFbRlV3PppE0qtHakY71gwp/7VcT0ZFZCNEeXALXK5mEytZGomPLLMcgsVJRPIucxj43y3ybJk1w+m8ZGplS88XS5OxkIua35miWuJq5XpBeMak5l3l2slUwanilVaLRPtv1DJFMVkAsCmoQz2b/VGN1m+JY4ly3vyLs4lC+tx5+JWBFwUPqeMzFmSEmIZM5fg50cl890ee0H8TUMZ9CdNxJjPqCYrZky+d7cFtWi1upfFgobrmreVHKc4zyBvZNpfq9V1sFYyNSSypB8LlRI2gD9qZcqOoVbiMp2saFWVTK61pBdUMrtcRclMZ+W1XHXiD/98KDZMcY3o9tgRz+aVe9lY41Vcpmma+OZrfUW/+zerR/DnbrtxpQJlHFtJP4C4GYJUyRwHI5O7H0QGsariqiJGU8ag1XO8rozFciWbRnCL4RZHiT+1OUZpI1NDom5kqm3nhwdENiDXSq1MaiBmFsRkhnhjyEBTuHpKZiUNOBUlUyXxSCuZQII5B5UvYcTvP2sCu/aUoJEpmV7FZfYksmQYyBs7nBuZpmmSsaSFngQuVCWRkSuZ4+Eud1OFQNUYTrt0lzfsMTLL8ZZVVsl06i63v+aHOdQN2sjUkKgamSp1EoHKF3RWOwaZkVkjSiYxEJcajRbUuNReb9/WbUymCkNpUynWyg0qSqZKEptuK8kbCbJajeUii9fbNpJhjbVCvDIyOWPDzUKkP2mS5292kZJJfzae8Wd2OXufCI5V9dS5VTKt8a+ccaySSibrLmcTfyZOCSNtZGpIVI1M1ZZdfliFyWyNWinITg3ETYzbhaKd6PFbSSUza1bOiJMF6/clslK1E8gdnx+S08YT7jSNZzF2IJfU05+Uu443etRa0sui9GwhdoW2romM6cs6mW6qEHipZFLGft5dXkbiT2Wzy+l9T4YSRtrI1JCoGpmq+KGMkWyg6xrO+KY7kQgqiJ5TMilm1tuNzEoqmUDlBnBZQk9v0pTW0rSY7GrmeNXJlMVKd49msH1UbkB6pWRyhp2b88C5+AufQVFMpkxFrhUlU9UYVlMyCXf5HuOynHFsPBIUeSPT/ppWMjUTCtXsclX8YGTKJrOsCXR5pIZUEmqwaWLcLhQzCXd5JZVMoHIDuMzFpapkAjr5h1tgVfrZTUn2v31ErX3ppsGMJ2EZnLHk5jxwyUqzFRJ/lJTMcRiu3FQhUK0upaLWUc9p4x6rrJzEn0qWMOLc5dy4TSmZtdLdqRRtZGpI+jxWMv2wClMZkGshLpMaiB0ZmYS7vOJKZoV6g8uUzJyRqTY4T/bkn/FTMsXvd49m1dqXpk3l8B0RXp4HthC7QuJPXMHIHI+qHVx2uUh1VTWQZKfYNE26hFE+8ac8JbNSsePUGNQUNhAkjEmAVjIrNIRWHG1kakgmortcZUCuhbhMMrs8aJADE0Vp+aLc58s8KAnjpWQ6MTwms5GZNU02JrPcYuwj6Sxe3Jpg3dky9Wr7SEaa9GPhRRmjSrvLDRQ/g1zij1J2+TiMq2xMpuA+URUZZPU0c7HT9tebPChhVNHYcapvuWDA1jGZmgmPascfVfwg9asMyLWgZFLB8eGAoTzAlhZiB7xTMrm9jFdMJgB0Mf3bS5nMXX9EKn85lSFe2Z7Agf/VjbOf3oVDl3bjprcGbGqRbAHaPZqRli+y8CIuk1cyne+LcpdPrwsUGREiJdOPHX/cVCFQNZBkjyC3ELTc5apKJjdWVmqcotzlzYJkTS4ms1JKayXRRqaGxGslczxih0pRUVNV2iSON9RAHAqoD7BU4o9qTGaD5DvmNtKyTCUKspumqVR2RFXdmsxKpkgxc+suT2VNXPFyL3YXjCU/eXcQf+stNgRlhtL2kaxy0wcvWsNyhp0bbwxZiN3WCIF+pgaSprQP93h4iCqbXS5+nzMCrXFJdaFNlXEDKlfGiCq1xtXIBGglE1AvBeUntJGpsZE1Te8Tf/ygZCr8pA014S6nlUxVNZIqYaT62Y9OE7fd3K+VroZcCQMukVFzw21SVjLH/x4dL0TGiltD5tXtCdLoe3FboujfMgOkezSjbGRuVLzWIipdwqh0kcc9eypx8ePT8ce50qv6aGUk8wRnBDotYUSNgUDllEzqnNULjpXzpNeiy1wbmRobgyk67qUcZBmk1UBlktgwlPZ9vURqnA0baqv4WJBuZaaqZB4xIyJ8f58W2shU6brjFNVs0E2KFQMms5IpWgS6VTJ/vzFOvl4aliALpUllgb/3qRmPXiiZXGyh0/OQyZroHrXfo7NKwlW4Z09loT8ei3fOKyWMyVQ8d1J3OTOONDosxt5OhAwBlRmnAHoxIBAyWSXTDx5Bp2gjU2ODc5XHykgO8dj77gqVuNBEBtiq2MVovKBWs6GAoeQub68LwjDs26kMzk1hA/u1ipXMfVvo9yvhLh9UzBpXnThGajV90wNECzA3RmbWNPGHTaP0d5Wc5pTC46aakLHRg5hMLrbQaQLUrniWzJYu7FsOlKtkOjokT3AXk6m2b1kxdk5pdKxkEiFDQOXc5dR6ISIYc3l3ee0thLWRqbHBDW5zG903hvXSrWOaJl7cGsfP3hvEi1sT8g/kj0FtOz/HZZqmScblhAJqSmZpPJgFl+FaSFssgL2bxBsuZJTMSrihvK5rN7nd5fx7bozMt3elsJXJCC81aL1U4zYPZ6QZyjK8KmHElV1SjclUiYsfDyXTTXa5V8XYh5kNGh0WY6fKuAGVc5dTvz/CGJKAyF3u1RFVD21kamxwg1snk9ShgpfZ5d95ox9nP92D7785gLOf3oUb3uxX+pxqTJVXnUMqAfcTwqpKJhPwrjI4T4sFML9ZvNDobAySbqBKGHCq9S9VoervTRa8jsn8/UZaxaT253YBulfMPk5lzJyhWQ5eJf6oGpmch6hP4f72V0xm+dnlsgUC55VosIqxKyuZ1U38oe4dN0pmLXSkK0UbmRobnJE5r8m9kulVFuTmoTR++bfhotfu+N8hpRInqobueh8n/3BjYDigZihyAe+iAc9iWiyItmiALfxu1f9rJJbhFXGXe7zPkUmsZIqzy53tyzRNPMHEYwL2idLtAvTQZvr6l+sy52Myne2Hq+1ZmvjDKZlK7vIqK5npLO1JAWRGpuL+XWaXW+7ycpIfRfsfez+LFdsSyiW1LKjfL47JpF+vxYgebWRqbHAB53MlrlIRXiWrv92Tsr2WMYE3dyaln1U1dNf5WMnkFIGQYp1MqnwRoK5kGobBLjZm7Kn/10gYoRVJ/PG4AgLnipsMiBQSpwvEv/ensUawUCs1RtxexkOb6Ym+3OQfNibTIyVzdomKxsZkqiT+uPyppmnirveHcMz/dOOYZd34r7UjSp9zG7ur7i4Xb8fVsm1ybGQySqZAPX5xaxz7/ud2nPXULuz/6Hbc9s6g0ncB3imZKR2TqZkIcIXYO30QkznIDLwbFTKIVWMy1w/4NyaTG4RDhlqdTKoQO6CWXT4tlvssF5dpuQEbieOojJLp7YA7mWMyRQaCrLVhKVxWuUXpI+x2bDiEUzLLLGMkcgc7KYZNGZnhADA1WvwMhgIGqMdPJSbT7bm7/+8juO6NfvytN42/9aXxlRW9eGmbPL5dZGSK7hP13uXi9/k6mc7c5TMYJZPzjpimiX96qbcolOLGlQNY028XPUrJZE0yzMlNTKZ2l2smBGxMZllKpkdGJjPIqLjIVIPk1w+mfdtZgRvHVTv+8Eqm/Lvb9hiZXFzm7D1Zs5S7vBLlgbxXMv15zauB6FQ6VTJF8ZjU/tyMDdEA0FlnooG4FctVMjl3edZ0VgybcqnOrFev7qCkZLocV/9zjV25/Pn/ypU5UciAF8XYM7LscuIChIyxxEVVJbMxbJBhP1xc9sahDJnI9vJ2uQeNM5zdlDCqRWeLNjI1NigjszFkYFoZNYy8KrVRjpGpWqttMKXe77racANWruOP/PNcLJKakpn77N6Mu3y2pWRSg3cFVELPlUyfG5mZrIn3dqcqkpzgVcefrqE0/kqEtBRiyy53MTa01wVgGMDcBvv9XG5MpqhckpNzQSmZs9nqDvZnRuW8uFW2NhBq7593JKU1gt0qmV61laQ8Ig1hI2+4qyqZ9SEmrIcx7Dkvh8qzyC0EXLnLdTF2zUSAMjJbowFhr1UZXpXa4NyuKu5yJ8ewzqfJP9wgo65klpddDvAJYLOERqZO/HFLOmviV38bwr7/uR3H/m4HOn+zDXe/P+Tpd3iVXf6HTWJXObU/NxPnrD33cWej/X4uW8n06FxQiT/886e825Ljcf4Z0zSxO24/tv6kiVWSovdui/YrJ/5I7gVqsdpU4DlRGcfqQwYChlH0OdH+Af4eVQkl4T7ryl3uT+1DiDYyNTYoN82UaACNIQOC50KIZzGZrJKZkbq4qQG5lTGc1/u0ViY3CKtkl1PxYBZOYjIPmBIiY8gWTckZnw0OBu9y8L6Ekf9G8Dd2JHDCEzvxrdf78+p61syV8VqtEA+milfF2J+QuMoB+0TppvKEFVs8lyir1pPIlrUAGRU8+qrxqYmMWdSz3YKrU6tS3YHCTajBYIrPEH+9W+z+FdXC9CTxR7IZ5W0oXNSqLLStdo50gqJabVcLlWeDWwhEBAsL3l3uz4WwCG1kamxQSuaUaC6zuJkpXyPDqxUY584YzZjYQbRwKz4G+wO6aArdoca/Sib9esiQ18nkuv0AakamFZM5vS6I8+fXFb3X0RjEp/aKAWCUzLSzpAkVyjEkqMnIT4k/u+IZfO3lXnzqD7vw3m7amHTSiECGF+7yXfEMXpMYKQClZCrtvogxI5OewjaWsUgUGVKqBrFqjUwL1VjCUtws3inj1+LPO8T3lHAxInSXy48LkMccku7ygnFPJfmxIW9kqi+GuflLpROVGyWTM0B1MfYKsnLlSlx44YWYO3cuZs+ejZNPPhnLli1ztI9EIoFbbrkFH/3oR9He3o79998fV111FXbu3Elu39fXh+uvvx6HHXYYZsyYgQULFuDzn/88PvjgA/Y71qxZgy9+8YuYP38+Zs6cicWLF+Pee+/1bSIJBVWfbUo090A0i6KV90A9Ol4pmQMCQ0CWVUoNkHMbg2S3m/U+LWPEjWkqHX84Vx3gzF0OAHcunoLvHtaEk+dE8fl96/H8mdMR2jNoUgH1WVPcds4N5SiZs4hzodq6sNK8sj2BI37bjYdWi8vKeBmTKoqZjmegNH79cVMcKkKLPSazDCWTiMkEymuo4EXNUK6OIt9xq3qLd1HW+p9lSqbLxB+virH3EG7+QmORCTkvwjIyqXGKe6bKcZdz97fomoe4Yuw1qGS6r0lTRVasWIHzzz8fsVgM5513HhobG/H444/jsssuw+bNm3HllVdK95HNZnHJJZdg+fLlOOKII3DWWWdh7dq1ePDBB/Hiiy/iueeew7Rp0/Lb7969G6eccgrWrl2LI488Eqeffjq6u7vx+OOP47nnnsPjjz+Oj33sY0XfsWrVKnzqU59CPB7HOeecg1mzZuGZZ57BNddcg1WrVuHWW2/1/Nx4jWmaZJ3MKXuMy5yRKR5pp0QDttWyd9nl/AC5cTCDI2fwn6Um0rqggb0aglhbUraIilnyA7y73IApeZq5pB9A3layIWSgPjQ2mEeDBr55aDO5LaUQADmVoN7DEaectpIz64O29qF+SPzZMJjGRc/1KBmQXhrtMrUymZXfI79XiMcEvMkut4xMKiYTUIvR5hAtNlQN4u2Khdgt3CqZbgx0kZK5cSiD7SMZ9jiFiT9Cd7nasYkewUTGxCbiunYUhEwoKZlh5+5y7h5VeQa5387FXQIA5zD0YUSPFN8bmel0GldddRUCgQD+8Ic/4OCDDwYAfOtb38JJJ52EG2+8EWeffTbmzp0r3M/DDz+M5cuX44ILLsA999yTdxved999uPrqq3HTTTfhpz/9aX77m2++GWvXrsUVV1yBH/7wh/nX33jjDZx22mn42te+hldffRWBwNidcvXVV2NgYACPPfYYTjnlFADAd7/7XZx99tm45557cOGFF+LII4/06tRUhNGMScaQTNkTyydzlxsAWiIGdpd4Xbyrk8nvR6ZeUEHr4aBBDvBedSjyGj7xBwgyrnALTkUBgKgk2LYtpu70aGAG+qGUiRl15FuuoAwxA4DKlZtNKGAjaRNZ00RAch4rRTpr4vIXdysrlCL3pFNk93s8YwqVl+FUFn/aqmZklk66rtzl9QEgAXRUXclUO+dbWSXTfUw0hZuEStkC+vUdSZw9j35QhedGcMpVYwlF260fTJP1Jhe2jJkxaok/1lxGu8tN07SFFXFKv1Lijwslk4vR1dnlFWDFihVYv349LrjggryBCQAtLS24+uqrkUwm8cgjj0j38+CDDwIAvve97xXdQJdddhnmzZuHxx57DKOjY0HrTz75JAKBAL7zne8U7efII4/Epz/9aaxatQovv/xy/vU1a9bg1VdfxbHHHps3MAEgEongu9/9LgDggQcecPjrqw9XiN0yMlsk7vLGsEGX4/BoBSbKUhapF5msSbryogH6eP2axceXMDKk5Tu4LhcAEAwYwpX1NAdGJqUQAN5ng1N1MrkSMaVwBvd4usxvfWcQf9mpnszjpZIpMzJl7/+9L62c6VxqqLhZ0M3acy/Xhwzyvt7k0sg0TVNoOKgamZy7vJw6tRRex2QCwJ+7+bhMWYIYF1ahepyix291P31NC43MgGHIvTICJTPDhPWU5S4XeJ84JpK73PdGpmXInXjiibb3TjrpJADAK6+8ItxHPB7Hm2++iYULF9oUT8MwcMIJJ2B4eBhvv/12/vXu7m60tbWhsbHRtr/Ozk4AOQNY5TiPPvpoNDQ0SI/TD3DxOq2WkikpY9QQMsiA5kpnlwPi+njcgx4NcjXq/Pkwizr+yGIy2yUGmEgFcGZk0tt6mVhjmiZ5L6i0Po0IsuzHK/nn9e4EbmXa1J04O0oaIdVUMmWTaT+zKmsjznPpWOBGnSk0LKlOZG7LGCWzYiVc9ZxTiT9NYbpsDlCGkqkYL1uIzMh8fQcflykysk3wi3Nld7ngXlijYGQCcjUzH5PJCCZU8k85iT+cCjpZepf73l2+du1aAMCCBQts77W3t6OxsRHr1q0T7mP9+vXIZrOYP38++b71+tq1a3HMMccAANra2rBz504MDQ3ZDM2NGzcWHVvh39R3BINBdHZ2YtWqVUin0wiFxKc9HldzOzklmUwW/Z+ie5BWUhqNNOLxOBoC4oeqPgSEDfs28XTWk98lUsPWD6bZ7+C6wwTMDELEtOLV8aqicm0AYCRBv2+mU1I379RQRvibRINea1j9voya9D20eySBeNwbw2g4RSvTcxTc8U1hAxHQE1bvcBwtgTGLTvW6lMNAMov/34v95O+Z3xTAPcc04IgnkrYJfjjJ3+9OGUmJjbKB0QTiYX4Rt3uEVr+mRg30lLyVyJhFx51waCy3RgwEs7l7LJlMoqMeeKNkm41DaYyOjrLVFDg4Y9liMJ5EPC7f55Yh+zMwsy7AXq8w3FkPJoDh0TirfFHsGBbfy+/0pNAzNEqGvQwlxEr7wCj9vKSyar9vVHBPf1Aag4Xc4npmOI14QUZSLAj0C74jauTG9igzBuwaiqPZKF7VcePuSEo8pgLAUJz+rJFJsfeSyTyPI8mU62fey7EsFospb+t7I3NgYAAA0NxMJxk0NTXlt5Hto6WlhXzf2nfhfk4++WT85je/wS233IIbb7wx//qbb76Jp59+GgDQ3z92K8u+o6mpCdlsFkNDQ2htbRUe79atW5HJVK5OY3d3N/veml1BAFHb68n+XehCFoiHAdBlfwAgnE0jmzIBFD+kQ/Ekurq6XB5xjlQWiGfq2fe3DmewfmMXQoSxtCsJAPbPjg72I5sM2o53JJEq+3jdILo2ALBtdwCA/QHv7dmJdMgEILCy+negS6BEBM0YOOdGJDmErq5e4bFZDA3Qx7hx+y50eXRf70wYoH5rc2YYovsTAOqNDOIDvaDu87WbtyHYaD9HsutSDt/7ewRdw/ahOGiY+N78EezePoQw7Nemd2gEXV19nhxD72AEoulg45ZtiPULvAjd9LjRiCRKn61EFti0qQuW/ZfI1IGuSUEzNZTJX4/u7m40ZOxjUjwDrNm42bEbmruvLLbt7EFXQH4Pbx6wX68Wgx8D03Hx+RexbtNmpaxqiy294u/KmMAzH2zFx1rthmF3TwhAhP3s5u4dmBaxPy/xlNo17u0fQFdXD/neB7uiKL2X5sSy2L5lc9FrIcE4BgDZ0dxYlhyg79m1m7chXDIGcL97IC6fJ7b10N/Tt2snuhhpcmecvg939PSiK1Ze5ZNyx7JgMMgKdhS+NzLHi+uuuw7Lly/HnXfeib/85S/42Mc+hu7ubvzud7/Dfvvth/fff78o6cdLZs+eXZH9JpNJdHd3o729HZEIPVCEknEAw7bX99urHR2tIew1NAp08aVVptRHcq6fgZIVbzCMjo7p5Rz+HjcPb+hkYSDQNrso2zDPcAZAn+3lGVNa0ZxOAb3Fx5sNhtDR0VHW8TpB5doAQCsSAOzdXma3z8DUqAH8lV/DHzJvNqYL4jIb/trL+oXmTWtBR4da1s5QXxp4134csZap6OhQXwGLiA/Q13Pf9lYENw+TCQIWU+rD6JjRDKy2n8emae3omD5msKheF7f8dkMCf9xJd+/59kEN+PQBuYoXje/0orvEzWlE6tDR0e7JcQTXDwDgVaop09vRMY033iOjowDs48Ls5jq8PWBXTtrn7JV3EadepY0KjrnNUbS3t+Svy6z+NLDZXgR+6qw5pLteRGaQvq8sGlrl97Bpmtj159221+dNqUNHB13+Ymr3ECCIhRQxfdacfMy8Cok14msNABuMKTi3w74orx+gr7NF45TpwPBO2/OSfX03VFLy6hub0NHRYHvdNE10vdFr28f+U6O2eaXxvT5hraX2Kc3o6KhHJxLkGFA/tR0d7cX3euMw/bvThnyeaDLpMXuvWTPYZyo8kgXetM91jS2tyuNwKZUeyzh8b2RSKmMhg4ODUmXQ2keh8lgIpZbOmTMHzz//PG6++WY899xzeOuttzBnzhxcd911mDt3Lr70pS8VlTySfcfg4CAMwyBjPEtxIkW7IRKJsN8xlKUHn/amOsRiQbTVZyAaZJqjVsHv4v2kzPJ/VzIlX8FtTwaxH/E9BuPmaYiFURc2YTvebOWvA4Xo2gCAEaKNwIZYBC11QXCOoqABzGmtE7rU60IBgHHbzWwSH1chUxvS5HEkEPLsnCYGaZdPW30EU6Kj2CXIoG2NhtBaFwU18KcDYfIYZdfFDX2JLL7zlt0YAYBj2iO45rBWBPe4QevCQZRem6RpeHZMaeJcFJIJRhCL2dUYiwQTIjGjIQTAfq2McBSxSACmaTpOspvTFM5PkpFIBE0xA4DdyMwds7MpLjsqNr7ShvweHkhmMUIMVXsJnqGGSAKAOyPTCEcRcyDZ9qXEnj8AeGt3ljzWdEDsas0Gc+e79HlRjbs1A0Hye3eOZtBHVBbZb0rUtn19WFxmryWWe8anNgDUGJAkrnE2QN8XcZV5Ikjf4I2xKGIx2thr4o4/UP4YWomxTITvjUwrFnPt2rU49NBDi97r7u7G0NAQPvrRjwr3MW/ePAQCATZ203q9NO5z9uzZuPPOO23b33zzzQCAww47zHac1HdkMhls3LgRnZ2d0njM8YZL/JminPgTQJoIRPcisVilNeGGwQyOJ17nMl/DAYOMRfRr4o+o448o8WdGXUAasxkVZKc7SfyhihwD3vYv5zo/NUcCaI0EhEZmc9jIZ5iWUon2lxy/XT+KfmLibIkY+PfjpuQNTIAuMu2k3aMM2b5kzwN3bdsY48fKkuVuiXCAf29WyclooOJjoN4CshBZYo/KuOC02w/gPrsccD5WyRJ/AOCNnUlksmbRPQjI42fjGSooqfw6mSqZ5RayxJ/6fDF2J4k/9IGpJIJx10fUSlRnl1eRxYsXAwCef/5523vLly8v2oajrq4Ohx9+OFavXo1NmzYVvWeaJl544QU0NDQUGY0cmUwGv/3tbxEKhXDWWWcpHedrr72G4eFh6XH6AcrIjAWRL48jK2HUwJUw8mBCVCmBw3X94VbS0WBtlTBis8sD4kLEXOmUQkSD83QHsyDVuxzw1oDjOj81hY18dyqO5kiAreVZzYLsS9fRHoGfHtOKjkZ5xqwbI4pDpU6mCCrTP2jkDGZyf3uOnZs05zD1LwFgVkPx/VXPLBjclKOSlYVSMeydli8C3GeXA84Nj16FRhMDSRMf9NnHUtnvp97nysdRZJhDW8O0+aWMTFmVDVEJI4C+lyvTVpL/DJ9dro1Mzzn++OMxb948LF26FO+++27+9f7+ftx+++2IRCK46KKL8q9v374dH374oc1t/YUvfAEA8IMf/KCo5MP999+PDRs24MILL0Rd3VisQyqVKqqbCeS6Bl1//fVYvXo1vvKVr2DWrFn59xYuXIhjjjkGL730Ep599tn868lkMl/M/fOf/3w5p6IqcH3LLWRtJRtCBln/y03R4FJEhdgtuJ7FbGuvgEGuKP2qZHJjWjggVjJF3X4sRBOdk2Ls0SBdc9NTI1OiZIpojvBK5kiVaoRsGab7fB8+LYxz97ZrQZSR6aWSKatxKXseqAVgY9hgi/xbl48rbTaXKEtkMbPkXubuezcLBpnhrjIubGW6/XCF2AH3HX9yx6S+bTJjYkjxvLxO9DGXLkaIfTtxYHAG2YeEwQswSqakXrClfPNKpv2AuYLqaVMeCsCVMBLVyeT6mtdi7/KK+277+vqwdetWLFiwANEoH9PDEQqFcMcdd+D888/HGWecUdRWsqurCzfeeGO+biUA3HDDDXjkkUfwi1/8AkuWLMm/fskll2DZsmVYunQpNm7ciMWLF2PdunV44okn0NnZieuvv77oe3fs2IGjjz4aJ5xwAjo7O5FMJvH888/jww8/xKmnnorvf//7tmO97bbbcOqpp2LJkiU499xzMXPmTDzzzDP44IMPcPnll+Ooo45y/PurDWlkFkzaso4/jWGDHIgkFVKUUFEyuU4fnIcoEqS73WRMkO6i8UbU8SccAAIGSNVgpiDhx0JkZDpxlwO5+6C0sP+QhwYcVy81p2TKjMwA62KtVp3M/9kwSqZBnD+frp5ATZyiDitOKVfJpBYQTeEAO+Fb38cpRHOp5L095Lo1jX2QWzC4UXorqWQKO26VYWQ6qTOq4iq3eL07iS/vX/yaXMm0v5ZyUMeTdZcTSubUaIAMx5ApmZa7nFMyKS+JSC0eSZusYi/6rOiac29NSnf5O++8gx/+8Ic2N/Ho6Ci+/OUvY/78+fjEJz6B/fffH7/73e9cfcdxxx2Hp556CkcddRSWLVuG++67DzNmzMB9992n1LccAAKBAB5++GFce+212LVrF+666y68/vrruPTSS/Hss88WJfEAuUSe0047De+88w5+9atf4Te/+Q1aW1txxx134JFHHiEN5kWLFmH58uU47bTT8Mwzz+CXv/wlDMPAT37yE/z4xz929durTS+hFrY6UTLDAVoZ9ELJVDAAuK4/nGISDRqIMGO/H13moo4/hiAuU1aIHeDjwmJBvlUkB1WQvVpKZovMyBTFZFbJXf7fhKvcAHDu3nTmKHVdnSqZpmmy7jbZ8ymLPaOezcYw3ZgBKDQy6f2SFSL2UGqs1TP3pht3uex3qsTgcTGZIm9CeUpmZYzMPxNF2WWqKdktx8HxZZj7YU2/PfGGUjEBBSVT4i4nlUzBaZPdE9zcI5pKDYP2Bk3KYuwPPfQQ7r33Xjz22GNFr//rv/4rfvvb3+b/3dfXh8svvxwLFy7EAQcc4Ph7Dj/8cCxdulS63d133427776bfC8ajeLaa6/FtddeK91PU1MT/v3f/93xcS5cuLAm2kdy9Enc5dK2kkzHn6yZiydxUjS4FC7Zo5Bd8SyGUlmbkcMGXwfEE6GsVWO14VQL6zBjQYN0E4pUFAvOtTktFnRc1LqRKuTsoZFZvpLJGCZVUDLXD6Sxcpd90lw8M8JeJ1LJVJy8M1kTN64cwP1/z5Umu2y/Bnz/8Oaia1q+kml/NpvCfIu/vJHJ7LctGkB9yLAZikEDmB4LIFVg/7Duche+RS+UTMrInB6jF98WovdkOHGXc0ZmWzSAnpL3Ng1lsHU4s0c5zqGUIFby+DlZrFOXLJkxyQ5O+zBGpjQmc8+zFDAMNIYM28LSSeIPIL9neC+a+DgjAcM23k/K3uWvvvoqYrEYTjjhhPxryWQSDzzwAMLhMP7rv/4LGzZswFe/+lWkUin88pe/LPcrNRVEFpMZC/JByYCV+EO/V67UP6ioTFBxmbzLgndb+NE1wQXGW/E9nFEs6ltuwZ0HJ/GYFpRK4GV2OaVk1ocMhAKGNCazJRJAKEDfp8NVkAp+u95ebgcALmBc5QCT+CPoFV3I/X8fxk/fG0J/0kR/0sRP3xvC/1tVXAtXbjyIv4OamBvDAfaesoYZzgCJBOme5O11AVsIC+sudxGzKs8ul++Dqmwgb+kq3y+Hk3FqN5P0cypT+7M0LlO+GLG/5sQwoiqTrB9Mk3Vv9+WUTMXEH4Aep6iwLFFbZJlizim5nLhhQUX0+NG7JqNsI3PHjh2YNWtWUWHyN954A4ODgzjttNNwyimnoKWlBd///vdrpn/3ZCWRMUkVrNDINAwDzQIrszEcYAOauQBoVVSUTIDOMOcmhwiT+JP7jP+MTFFMJsAPsOVklzuNxwRod7mX8Y6UkmnFC0uVzD3bUXGZ1cgup1zlIQP4TCdfu45SZ7KmWiLAY+vsRu0fNxW3ppM9m26UzEam0gQgVzIjAYNM/qFe45QrN6q0F0om1ZqyVVL6rZyYTCfjFFei7rS59L3355LkNDfZ5U7WltQajytftE+zO3d5fcFzT/UvpxZM5bjLuVAUkViTe9/+OyZldnlfXx+mTJlS9Nobb7wBwzBw0kkn5V+rq6vDvHnzsHXr1nK/UlMhKFc5YJ+0RbUyG0L8xFK2kqk4aThRMiNBA5xNUq5RXAm4U2CFIXADbDnZ5d4pmZWNybQmDNmEbsUVU7F8lU78+VtvCn8jMmVPmB1la0oCfA1TmVFkmiZW9dld8ztLFK1y62TSMZkB1zGZ0SBw4QJ7fOpF+9jVXq5k1oiLRaIsWUjFyKTOBZfJbFFOTKZIZSul1CVucfi0CKYTz/nbJWEdsjGcNjIdKJnEtk5qZALq7nKAUTKJvARh4o/k/FMGaiQAaQgS5ZDxo3dNRtlGZl1dHXbt2lX02muvvQYAtmzqSCRSsVaMmvLpZZTCKSV3uygusyFcOWVQJbscoDPM2cQfkZLpwweaW8nm3eWEnWIgV4xdRqWVzEFPs8vpGEBAQcmM8IH/lVYyOVc5l1VuwU2cMhVlZzxLFnwvLNWUzprCNpyA2Jg1TZPJLjfYe8p6HkVNEv5hQT2+dWgT6oIGYkHgmoMbcQlhZLKJPy4WDG6UulKoBZCsiUVZSqaDx4pzl0+NBnDQVHuLw56SCyTo1si+78TFS93OlJEZMoC9XSqZhe5yyvinVHmRIS9bmFCflbnKAbog+6QsYbTvvvti5cqV+OCDD7Bo0SL09PTgpZdeQltbG/bbb7+ibbdt22bL4tb4B07JLC3PIMowbwjRHXQAL9zlikomkWEuKmHEPfBOFIJqwWeX5/5PTerT6wJKCVdcLK2TQuwWXOKPaZqOk4goSHe5pWRK3eW8kikzTP7cncB/rB7B7ngWs+qDmNOQ+2+vxiD2aQ4JwxJM0yRd5bEgcDrjrhzbxp2SyalAhROjyuJPtM1w2iTLMTWF+coN1vMoapIQDhi47rBmXHdYM7mNRYQp3eWqGHuZdTJN02RCOSqnZJZbwqg+ZCAWMshFV+n5cJMg5iS7nPota4h7eF5TiA3LEimZuVJvYiWTLmHE7lJ6n1FihUqiF51d7r85SUbZRuY555yDt956CxdeeCHOPvtsvPDCC0gmkzjvvPOKtuvq6sL27dvxyU9+styv1FQISvEA7JO2qFZmkyDYv3x3udoybpMTJTNYuUSlSsB2/Nlzyuc2hYDtxXFUXOxSKdxE55W7PGvmlI46D6rzku5yS8mUFmPPvU9lmItqeT62dgRffalX2L3k1I4Y7j1+Cqnk/rUnhfVEKMen9opJS4NxCV2ySZ+aoIFixVbFyBQpeFwYhDDxJ69kcjGZ0kPKYxgGGkKGzbhz4y4vV8kcTtPdbSqqZJZZwmjqnvGdusdKlX13MZnqx1f6cdM08SFRvojLLAfESVSlz7xqgqJoLpCdE6pGtMr9TYkfkzLx5ytf+QqOOeYYbNmyBXfddRc++OAD7LPPPvj2t79dtN2yZcsAAMcee2y5X6mpEFTAOmB3jwuVTIXaeG5RjenbOJSxZd26K2Hk7PiqAWUDhYyx+J6LFtTbCvl+cb8GpX1zq2uv3OWAdxnmbpXMcGBsEqJi+biYzLd2pfC1V8QGJgA83RXHjW8NkO/9N5GAA8hd5YBAyZSoKEpKpsIlET273OKvSdDxR1aM3WlJH8pAcpX4U6aSOcAs1GWLiGr1LhdVD6ES4UpVOjfZ5Y7c5SUPWE8iiz7inHKZ5QC/IAPsv5FSmC2PSyGiZiLSe8alkkm7y/0nfMgoW1OIRCJ44okn8Mc//hGrV69GR0cHzjjjDMRixe6fYDCIf/zHf8TZZ59d7ldqysA0cwNH70gG02LFmeC8kWkI/12IyF1ern2hmvgznDaxK57F9IIARVHXhVoqYUQNMoXX8NhZUTx8Uhv+3wdDSJnAxfvU47ML5EYM4HVMJr2voZSJ6XS9cWUyWdolaSmZ0aBB1lgEcpOKZZBTSib1me1xA196c1B50fH05jhuKXkta5pYRsRjNoYMfGovsasc4CdOmYqymlCBgNzEb9WtVVMy+ffcKJmWZ0GUXe4EMvTBRQywNLtc0mWJN7jFz1B5vcvVt3WqZKayuTHHGmMqrWSWnj42s1yoZArmp5JxiRqn0oTHRdbxRwQVLqByf+ti7AUEAgGcccYZwm2uuOIKL75K44LHN4zixpUD6I1n0J+sQ8rcDQB4/dwZ2K91LNhbdRXOrcoN5AaqSiXSDBADeNCwu1iAnJpZaGTyJYz4VaUvSxgRh1Q6GJ3aEWPr3omgsjVDBrCwxZ4QIIOrXaga8iCC68pTOJG3Rhgjs2CBRB1jqXtwOG3img+i2BlXvxe2DGeQNU0ECmJPX9+RxBaiSPfpnTGlgv9cSIfcyOStopG0ieaIopEpmEi5xV+joGZuPK9kMkamQ6OLNjJduMvLzC7nx1Dx76laxx8i8ccyMkWdkyxhwVVMZhmJP04zywGxkln6G0X9y+tCcpECUFEy7a9xscpF25Ducv/NSTJ0qvckIJU1sbo/jV0JEylz7MYtTfThlMxSlwJnZDaEDAQM3v1cTiKNaZpk4g832GwsicukvjtoAMFAjZUwIgaZoEdP8ZEzIvjotGKD8pKF9dJsbQpu8PYie5url1o4kXMF2QvvXU7JzO5xlWVNE1e+NoQPh539/lTWrhi9QbToA4Dz91ZTmblkBtEEl8yYbJvVws+qZEyLjAsuBKJJVGkin/hD79NJTCbgnZEp7d4iLeU0Dkqm4riaNU2ygogVc811wbLuE9M0pWo+7S5Xj7stbSvJGZkid3m5SiZgXziJDGXZPUON2WrZ5dS+pB/zHWVPT7t27cKLL76INWvW2N67//77sXjxYsyfPx8XXnghVq9eXe7XaVzAxaiVxrpQRmYsaC8JwSX+NOTdlfRxlLMK4zJYDyTKbgCwtSGjvtsa2LmJ0I+rRqrjD5dl6ZRQwMBvPzUN3z2sCefvXYdbP96Cnx7T6mpfInd5uVDZn0DxYoi751uKjEymvuKeSfWHKwfw5GbaODx1ryi2XzobN36MznzeNlJ8oTYP07Pz8bOi5OulcBOnyEDkOqVYWL+z3MQfvsVnQKGEER/G4oR64lrKFCaKchN/xkXJVBynBpJ0UtIUgbscKLxP5N9BnR8uWZFzzxfyIWFkTokawpqyQiNTIfEHsC+cyilhRN3jKvc3ZYjWYnZ52UbmL3/5S5x77rn4y1/+UvT6r3/9a1xzzTX429/+ht7eXjz33HP4zGc+g927d5f7lRqHcKpOqVFJZZdTNTG5OpnWA8u7n4WHKYSbyPZvDdsSXQB71x/qQbd+RqUSlSoBGZPpQUkgi9ZoAN88tBn3fnIqLl/UWOTydQJVwgjwJvFHSclkjMzCBRLn0h9OmXh2cxy3vTtEvr+oNYR7jp+KWMjAwlZaUdlWYlSW/hvI1S6V1fSz4LYTxUpSE3QhTowHN0pmY9jIJaUJ9sct5JwunMjC+i6MTJn6mTbFEz0V0gPIlcxwgD5PKoiSUgrh+paruMsBNWPWSeIP9X2lbSXXEDHFC5vF4Ttid3nxdeDj8Yv/LYorldbJJIUB4UfYbfxYVk9G2UbmSy+9hGAwiM985jNFr99+++0AgCuvvBIPPfQQjj76aOzYsQN33XVXuV+pcQiXqKPiLqeNTEbJ3PMAV8JdzhkWU6IG9mqwr2pLu/5QH7cGmFoqYUTNYYwgN65wXVhUk7dEcEpm4UTOufgL3eWiSfX2dwfJ99qiATxyclt+PzOZTkrbR4vvv61EPOYshVafFm6KsXPliyy8UjJFiT+GQcdljrWVpPc5Xu5yWUwmID4XVGktQK5kGgZfuL4QSsBTVTJZIzMmMzJzn3Mbu8uN+9Q9XZjYksyYNo8UAHZhZ+HEXa4qMIjrZIoXzm4Tf8jscv9NSVLKnp66urrQ3t6OxsbG/Gvvvfceurq6cNRRR+EHP/gBzjjjDNx///0IBoN4+umny/1KjUN4d3nxw0ENkJRBycZkSpTMcow2biJrCgfQ2WQfdEq7/pBKpsRd7s8SRoSS6ZG73Esq6S7nFhxNBd/Jx2TKlczdiSwZQxkOAP9x4lTMK7jfOENxa6mSSRiZsx0YmZySKYoHEyX9AB66yxkXcVOEf74se6eSiT+VcJcD4vOlEsrBwS12C9+nDChVj4uo2w8gVzJVzg3tLqe3pRTHwvGNC/dYKKn76yTxRxbOwf27EFkXJLcljLS7fA+7d+/GzJkzi17785//DAA4/fTT86+1t7dj/vz52LBhQ7lfqXEI594udY+X7S7f8wBXIpGGC6hvDBvobLSPzpuHM0UPJDVIWDX8uFp+fnRNUHOYH5XMJtYV7YG7nJvII86UzEbmxL3TkyInt6sOasIxM4tjKKfXBchwje0FRmU6a6J71P67ZxMKPIebmEy5kulAoXJRJ9OKf6OO3esSRlwh8dJ6hzJkSRyA2KhQWQBxyOL0Yky5NdVxtWx3uctzwy0kaHf52N9uMssBsZJZGsbDGfalhqE4u1ymZNpfU1HqaXe5/HN+o+zpKRAIYGioOHbpjTfegGEY+PjHP170enNzM5JJOpBeUznCAYPMHCxVMil3OaVacq4fy0VaCSVT5CKdRyiZGTNXSsaCLCOx56exXUl8uGqkVrIqLSOrDV+M3QN3uZKSSZ+TwphMblJ9cyc9Rh05PWJ7LWAYpMu8ULnsHs2SCReOlEyH2eVcpxTqs2rqHf8eVVKqcU+lCYA2GMdKGNH7dOoup8Y3E3KVyXZckjqYgHMlszFkIKjU1lW8TT1THk51nOqRGpniRDiVc0mdGy6esY74vsLxjVskyYxMJ0qmqhfL67aSKok/tLvcf3OSjLKNzLlz52LdunXo7e0FAKRSKTz//POoq6vDYYcdVrRtT08P2trayv1KjQso92FhTKZpmkxMJuEuZwyIvLu8ijGZTWEDnU30ZF0Yz0N9tzXAcJ4s1YD6akItmlWCyKtNJDDW6rIQrsalE9gFh0Mlk3OXv8UYmftPoSe3WQ327yrMLi91nec/V69+4ZwWY+c6pRRiJcaoFPOOZ3hVkEr8KQyXoNQikZJplRZzArdgkKlMhZimqahkikIHiHanknhMC1lMZixId1BSHVd7GXf5FA+VTOr8cc4L2l0+9jeVuBY0QIoKhYQDBuldAOyx4iperEyWzsq3kC3SKHFFJcSJWmjVYjH2sqenE088EalUCl/+8pfxxz/+EVdeeSV2796Nk046CaHQ2M3Q39+PDRs2YM6cOeV+pcYFlLFYaFTGM/RkQ7nGI0EDM+rsr1vKDFdoVqV9HYfIRdrZSA86hckWohJGtaRkVjq73CsMwyDjMr0oxq6iZHJGZoukTiYA/J2Y3BpCQAfj3pYpmVTSDwDMceAu5yZOLlFFFo8JOFMys6a9ULYFFZNZaPBTz5coJtNNzUjOCHeSYa6qeoqSg6gFkEo8JiD/3blGF/bXVTv+UO7yoDE2N3gTk5nrKld8fIy7nEr8KfgwpWTu3RRSimfkEuVKn3mVxiGy8ytTMslQLYVHnzJE/RjCJaNsI/P//J//g/b2drzwwgtYsmQJHn30UcRiMVvv8qeeegqmaeLoo48u9ys1LmghJt1CpUO1b7nFeXsX9wYMGcBnOnNdZlglswyjja/FZ2BKVJwVCYhLGIUCBqhDrlYJo95EFi9sS2J7Qj541kp2OUC7zLne4E7gWkoWlls6pI0ubXVYQbF5Tsmk2K8llG9HWcoswljcGc/mFwSckukkJhOgJ05u4lcxMp0oVADvmqdCIIqVTD5ZhfpuN8o8V/PUSfKPihEl245aAMkyyy1k/cvrgnSjC1XDgzIyp0TH2qzyarD6fWLCHjfuVslcN2i/h0XtJAvhEuVKn3m2skjBIyubt9yVMFJxl9tfS5twHGc83pTdVnLGjBl4/vnncccdd2DNmjXo6OjAP/7jP2K//fYr2u61117DgQceiFNPPbXcr9S4QOYu59Qhzsi88YgWGACe2BhHe10A3zy0CQe35WLWZP2K3cB3FQmwK82RlHg1Wnic0YBhc/VUY9X4dFccn3+hZ08MUB2+kxjBtw/nW0LWSkwmQCc7eJJdTtwLpWpRWyyIKw9sxE/fG4sX//L+DZhboHpzhgnF/i28BcBlmG8fyaCjMURmlos+xxELGbZwg7KMTElB9FK47Uh3eaj42eL2RT3WbpRMmQqngqpBKjpf9ALIOyWTOl/llDCaWiA+yNRglfJOueMp/jdVwof7PsuIMgyDfM5VQ0y40ANbTCYzdhY+V7Le66IQizTjaldJbOO2SZuAg/XxuONJ7/LZs2fjRz/6kXCbn/70p158lcYllLu80LCkMsu5zwG5ldjNR7Xi5qOo9+hjKEcZpAbvkJFbiXJuz0JXmaiEUe5voKS0YVnufRWypokrXu4tCjK/+d1RfHZhGnszZTqocd6PMZkArRR6UYyd6qpCxb19//BmfHJ2FG/tTOHgtjBOnlOcGc4ZJhT7uTIys+hopN3lzRGDTY7ioCZOzjBy4i5XfS45g3aQOAaZu1zU8cdpZjnglbu8UkpmeYaRRV3QgEH0PSs8h7vjGXztlT68vC2BqbEA/vXIFpw+N+d1ooxMq6Uk4E2dTIAwMhnljXNpZ0wgALqFpWpnJO5+KJ0rVAQRWUa3sLUrY6C6dZdbx+bHsnUcnhiZGv9D1cocSJnIZE0EAwbft9xpmidyGbfhgF2lKMe+4ALqDcNAPXMXF6oYohJGgDXYVFfJXN2fxi4iGP/V7gRrZFKrar8qmZQRVSklk1JNDcPAJ2fH8MnZtDLsxF0uVjLpZ8RSMLcQ7nInmeUW1ATLGTyy8kWAs44/ue0YI5N4NmWJP5b6Rvd1VjueQmR9t1VQVT1F54sL5VBBRcmkjrDQCLrylT48uSkOABhIZXDZn3Zj5fkzMachSCb+FMYuhwIGIgG71ye/GFEcvxPZ4t9BJVCGDD52P50FsuQvFWeOF8IZo7bEH6WYTPdKJmegunWXA7XXv9xTI3PHjh144YUXsHr1agwODqKpqQn77rsvTjjhBEyfPt3Lr9I4hHN7D6RMTInyRianZMqIBAzbBFKOkkkF1FtuqHAgF8BeuvvCCYZyKYULBjky1qnCiT9cfKIobpEaYPzqOqFaS7pp9VcKpWS6WQyFA7luNCpG1n6CWDBOybSMzHILsVtQcWbUBJfMmFhPxLOV4jQmk0qMMU2TXDgUuoipZ8s659Sw47QQO1BdJZMzKlJZkzRUvVIyYyGD9GRYY9twKotnNseL38sAD60exrcPbZa6y4Gcmpkseb6GHd4npV/DZVcHmRjnlGmyWdSqoRScSmp3l9OfTzpwlycyyIs1tv2wSqaCu5zZprT1pt/xxMhMJBL4l3/5FzzwwANIpey12cLhMC677DLccMMNiEajxB40lYbrgNKXyGJKNCBwl7vzxUaCwHDJPFde4g+vXhlGrg5oqSE6XKRk2vdZqGRSP7PSSiY3qYkG81rp+APQXX+8yC6n7wV392l9yJBOns0hE+11/DmeKYjJNE2TNDKpZCEZVAdLKk5uA9MppRTLDVqOmziRoUM4imIyHSb+uHGXc0pmNWMyyynEDijUyQwapCpojVM9iSy5CH2nJ4XRNF2eqdTIbAgF0FcyWDqpQgAQ7nJqYRzklbpMlr8WnPFYCpv4o+guL1x4qixCRzMmGh0kZSn1Lmd+aq0VZC/byMxms7j44ovxpz/9CaZpYvr06Vi4cCFmzpyJ7du3Y/Xq1di5cyd+9atfYc2aNXjsscfYLE1N5ZC1lnSaXS4jZ8CVup9d7QoAXSaltA91qZFZ5C6XlEoRlVmpFNxkJRrMaz27fChl5gP73UK5JFUzeEtpCAXQK5lF5tdnhcfbHDZQHzJsBs3WkQx2J7LkJOWVu5wyHFTiMYFCN6h7I3OIkZzkJYwE7nLnp0aaGa1CuTGZbEtJD5VMUrnecw659p7v9qSk3X4sKEXYqeKdyJS4y5mya9ziOG2a7DlWjslk7qHSEBmrskjpIRY+EzIlE8jdE41h++tcUqrbYuyqx+MnyjYyH3roIbzwwgtobm7GTTfdhIsvvrioPmYmk8EjjzyCf/mXf8Hzzz+P3/zmN/jc5z5X7tdqHMK5vS3j0ml2uYxwGZ0pKKiEkUKFgBocrULMWdMkjbPCyYzspDFuSib/GcpV4t+YTPtxZcyc27XO5cjDuSTdKplcj/VCFtSLVxuGYWBWfQBrB4ov3PaRLBmPCbgzMql7nLpH1wyoGZmO3aDEdpxhI43JzCuZ9vfcKPO8u1x9pViuksmNoaoLIFkySG4hQ6lluf9zXoLNwxmsZe6JqTG7u7wUJ3UyASBRshm1wI8E6WYNQG4hzV0LTqFU3Y6qKBEL2heIxYk/8t/NKeac904pu1wQs1pLlK2BPProozAMAw8++CAuvfTSIgMTAILBID73uc/h17/+NUzTxCOPPFLuV2pcwLvLcw8B5S6PBOS12ziosiVcKQsVKPWqUCmjBsd8RxPGaCtK/BmHwrfcoC0azGul4w/At5Z0MvGXwiUOqbokS1HJMJ9fL78PKJf5tpFMUeefQpzWyASYxB/CdqA6pVCMOkz8oVzznGFTaGRyMZmmaZKqjJsSRl4k/qh0+xHtk6/l65GSydTJtIxe7vsB4MWtcfL10qYFIiPTvZJp3yYc4FttprO8kqnsLie2M0DPZ9TUWPhbVYrdc/cEd85U4o7Z7PIaUzLLnp7ef/99dHZ24vjjjxdud/zxx2PevHl4//33y/1KjQvcuMubIwHXbk1qFVZexx+xkkmtUEck7sDCBz3s8fGqwHUYEQ3mpOuphpRMoLwMcy+rIAC8cVKITMkEaGVy+0jGs0LsgLq7XCWzHHBjPBDucgXDijOeUllxkwQnyPpuq6BcB9KhkqmaPOm240/azHlruJhQAPjT1gT5OpX4U4pjJVOhTmY4wMcc5rwd5SmZMwh/+Yw6ej4jS2wV/AYV9zRnZHIh6Cr3OK/0TjIjc3R0FFOmTFHadsqUKYjH6RWVprJwbu9+gZHpNrMcoNULtw9HMmOSBlnhREa7yy0lk/7e0mLspZSjvKrgWUymP21M1sgUKS4yRJ2f3FCvoDLNb5AbmZSSOZAysXrAnggJALMd9C23oCZY6l5Rjcl0ajxQBq3K9eBUm3jGpLPLXSyaosGcUlWKk+xyVSXTaUymV0pmHdO7HMgpw6Ln6u0e+j5UMTKdKt72Opn2bSIBQxhzWG5M5mkd9rJlZ3bWEVvKQ6VUlEPu3uETf8rILp9s7vL29nasXr0ao6Ojwu1GRkawevVqzJgxo9yv1LiglTEYra4/tJHp/vYQZZQ6he32U/CbRO5y7nsLx35yoKnwitFpdnkma5LV43wbk8moS+UUZOfUGrdKJlVmqZBpUQNTiID+UrgyRit32if3aNA+uavAFWMvbDPXE8+wSR6ljEgWYaVQRgZ3LWVtJYHc5E3H6zm/n60KE6U4Svwps04mf296qWRyRqaJAcFzxQ1lKkbmsMMqBKV1Mqn7Kxww2ITFtCgmU/HeOGZmFHcubkVHYxBNYQMXLajDD49oIbeVhUqpJKxyx1tOCSPtLt/Dsccei+HhYVx33XXC7a677joMDw/juOOOK/crNS6oDxmk4tWXT/yx37jlGJnU4t2tkamiEFCFtfOTKJfhV1SM3f5+pWMynSqZ3Bzi35hMJhmjDCWTm0ibXSqZsoLs+7equbW5guzvEArSrPqgqzAUKh7NRPH9zamY1D3itDQNmV3OXMvCeFzOnk5k6GfM7bAjyoxWoVJKZmnLUw6pkRk0hAa7Gw+BSkymzCNUir2EEe0uF7mD2ZhMB26bS/dtwLsXtGPDJbPwy+Omsq52KgTBSVtJQJD4wxio5bnL5Z/1E2VPT1dddRXC4TAeeOABfOITn8BDDz2ElStXYvPmzVi5ciUeeughLF68GA8++CAikQi+/vWve3HcGocYhkG6v62En2oomW4fDpVkD2oCzg+OCqtJur+yo8N0jFMlkyvC61slswIxmVw2c5PLe1WW+CMqwl4Ip2RShoubzHKAj0crvI84I3NRq12OHdmjgqokNgBMdjnnZVBRMjl3uQslExB7M1RQVT3Z9ppcnUyPssvrQoaweLgoJpOiOWxXRikjLr6n2LiXdTIjQd5dnjHLVzItDINPMLKQxWSqnFZ2LFfIB+Dg3eW1pWSWXcJo3333xS9/+Uv88z//M95//33SiDRNE7FYDHfffTf23Xffcr9S45LWiIGekvoSY+5ySsn0NibTrZLJTWSldTJLsSZRlQw/6oGutFuCVzLp7blYHP8qmfSBlVOQnU38calkci59C1E7yUK4guwUbpJ+AD6zNp420RLJ/c0l/RzSFsa7u4tVVRO5e60cJVMlo5ozMuMZU9ru1QnlussroWSGjPIyogupC4mUTOexzqUqJkAnUAK5c6Pe8afEXU61wjV4pS6d5c+x6rl0Ai0weKNkcnH9KnHH3LjucC0x7ngyPZ177rlYsWIFlixZghkzZsA0zfx/M2bMwKWXXooVK1bgnHPO8eLrNC6h4tb6k1kkMnQ3CLdxbgDtgnBrtKnU4qPcniZygyNfwmjs7/FoK+m07AU32E2W7PLRtIlffTBMvudWyZS5y/dTNDI5JZPCrZLJGRiFz+5qoh5iS8RARyOjtKaz6m0lifuVd5fLE38SGZPsFkRVelCBdperz8jlZpdTSmJTxFAOjVBxl3PGSSJjOl68ldbIBHh39EiaTr4kj6XkMKhLIFIyhYk/FchyJAWGgu9XeT7YsZzLLle4x7lxvdayyz3rXb5w4UL8/Oc/BwAMDAxgaGgIjY2NaG5uzm9z/PHHo7+/H3/961+9+lqNA1qJCbUvmfW8EDvABVO725eKS44rYTKaNpVcFmTJpT21/CrVoYpzxzuNyay17HK3/ct/uHKArAG5V0MQM+sq5S4PYkChIEY0aGBqNKCUdOPEIC2EMwAK7xdKyVzYEmJ/53BaXaGiYzLtvzcWLA7h4GrtcjGMbpVMUfkdFcrt+NNPdaJy4GZQ6fgjMti5xTgHlXzG3ScjDu4T1d7lbOKPyRv8bus2i6BihgvnjHLqZHIGYTlK5qQ1Mgtpbm4uMi4tNm/ejN7e3kp8pUYByv3dlzAFLSXdWy9Uxx/XSqaCS47v+EG75AB5TCaQM+zctLlTwWlMJje4+DYm08Ps8te6E/jF+0Pke1/av8H1QkCkZM6uD6AlEsCA4r5m1qsZmW7d5ZwRUjgh7yTkps7GEO8GdWI8KCb+lJbs4SZULoaQGjtUoMpRVbN3ObVYd6KwS3uXhww2iSqX+ONQyaTc5czzkFMy3bnLqX7rucQfJibTgxJGTqBLGI39rVLKjgu1YEO1lIxMfk6qJXwazaWpBFQpjf5klozHBCqgZLp2l8uVTK6otmgFXvjzWIWggqtGp9nl3Fjn15jMKNM6zqm7fDiVxT+/1EuWbzq0LYwrD2x0d4AQF2NfpFK7qABVN/gctzGZXFebPTeGaZrkuW2JBIRuUOWOP4qJP6UKNmc8DTFGnWslk/ieSmSXO+n44yRWWKnjD6tkehOTycU8lqNkpoiExUjAECh1/LVwkl2uCnXek0VKpnt3OaeCTiZ3uU+nJ00loFpLpk1g6wg9y5RjZIrcz05hSxhJEn+A3MPPP+hqGbCVwisl068xmYZhkC7zPoeR6//fmwNYP2i/R6NB4O5jp5T1+zmFDwD2JzKyRagm/7h1l8uUzESGVjkawwb7fPQns6TxTkEZo7J2rwD/bHGLR7fDTj1xrzlK/CmzTialZDqJa1fpXS4sYVRhd7nb7HJqDA0FwLeVNE2yXWokAAQqELokL8Yu3wfrLq9A4o9WMjW+hVtVbxykM1K9zi4H3D0gbMHnggFR5C7njLbi3uX0d1eyjJHT7HI2JtPHT3E70d6Na7VI8eLWOO5ZRSf7fPewZsdqYykid/miKc6iiVSMx4ABtLuMH2WNzD330RCT5NIkMDJ7Ew6MMGV3eamSSe+PU95cu8uJzw2XFKsXUW5MJqXqeqlk5koY8YthL9zlvJGpniBW6i4nE38ESmaaUTIrkfQD0GN/0qG7fMRhCaNyirFrJVPjW7iuP5uG6Em/vOxyfsXtFGoyaggV1z9j3eUpuqtI6TFyE1slM8wd18nkYjIrlJjkBVT8IaeclzKUyuKKl/vI946aEcEVH3HvJrcQussdKpkqRmZ7XcB1DG0dY/PmjUxBYXTeyFQ3TOiYTCIOscSwYmMyGaPIy8SfrFm8UNw4mMbFz/XgwP/aji++sBvdBfdiOdnlpmmSDS2cKZlydzlnsLtxl1PZ5SKPkLKSWfJ4c12duHErnaWFgUqUL7KOpZSEQ3c5d+9Q8aiAWojTRFEyK5L4o/EnnDLJGZnlxWTSryczJuBQfKImo9KJTOTmYUsYFQzY3MQ2Hu7yidLxB6CNzG0jGaWs/aXrRrGZUD3rggbu+sQUaZFlFURK5n6tISCTVN4X1/WnELfliwBBCaM9ExxXJaIpwiuZqi0oAfU6mcruclbJVD6kIih3OZBTxWIhA+msiTOf2oWuPePd5uFRrO5P4eWzZ8AwDOWYTMoAGkmbZMx06TglQqRkxoI5VzFnsO9OqIc9WFBKpjiBUm2/hbcUV+w/ZPAemLRJu59V1D83UPvNmjljNxQwlIw6LvZXK5layZxUsEZmJdzlbCKN831RsUalWZt8YgPv5ikcsLlAbDfHqwrnFs+YtGpZax1/ANqoSmTUjJuXtiXI1/+/jzVjgWInHhlcTObcxiBbTJ5DRcl0G48JCIqx77mP+M5Y1VUyS+NwOeOJi8n0MvEHyCWOAcDrO5J5A9Pi/d40/tabG/9UYzIpY5QzmL1SMq1zyI2ru1SLWBZAZpcLqhCoKpnJAnc59xFRncw0k11eKSWTu9+sY1BK/GF+KCVSGABUfsqkVTJvueUW1182Ojrq+rOa8uGUSUrJDBpiV6IMUeyQU1SUTFF2uVJbyXFI/BHFOMUzJhpLzmEtKplcJvWW4QzaJEXvqBaJ+zSHcPmiBk+ODeAVcDexnioGpNvyRQAfk2ZNcJyh0xg22EVYr4MkrNKJP1c0276drYSRQyXTdVtJgZIJ8B6bjUNpfGRqWFnJTGVzZXYKlXRORaYqenCIlEzrPuXc5bvizi0PKrucO4cDSVqppShct3Bjr6h3edqkVfNKxWRyAoPldVOZAzh3OfX7o0EolVybKEqmYyPzRz/6keuadJUsbK2R08J1YCEekJZIoKxrxT64HsVklk5kXDF25RJGgk4alUKkDCQyJhpL7BwuJtOv2eUA7x7eOpLBwW3857KmiTVE95qDpoY9zTBtChtoChu2e+xAh0k/ADAtFkDQ4NUboDx3uaitJMAnyIkTf9x3xFHp9gM4T/xxG6XDnZ/hPd/D/daePQaaqlIH5Nyg9QXPnUotXxmi7PK8ksk86z0ujMw2quMPcw4dhVUUGplsTKKgGHuWVpUrpmRKvG4q6zDOXU59ViWzHJjERuYxxxyjDcUaxYn7uxxXOSBSMp3vSyWDVRSTyXWWUyphNA51MgHalV5rHX8AXrnbOiweubcMZ8iBe2Grt2HkwYCBs+bV4TerR/KvhQzg8/s6V0uDAQPtdQFsHeF/WyWUTLXEH3pGd+YuL/43l7ijWieT+7xbJbOBMeis+0hkZGZN9XqhQO5c1Bfcil4omYaRS+yhjqMur2Ry7nJnRmYkQHt/uBhlR/dJgbucC/HJZZc7S/ypmJIpERhUlExOBacy01VFgUnrLv/DH/5QiePQVAEn5TTKySwHvDXaBhTivkRGJveNhcfI/Vy3rTBVkCmZpdRaxx+Ad5fLyhhRrnIAWNjsfa7ij49qgQHg+S1xNIUDuOGIZnQ2ufueWfXBihmZfEzmnsQfgZIZC+ZiwUrvoD7GeGgOG7b6tKX3K2fUlo4dXMwbV9dRVekphc2M3nPc3G/tSWTZZzFkgOyvXro9W8vXYSxLNGjQmdVSI5N+njijdWqU9lSFAwb5m50omQklJZOPS0yZTAmjKiuZlnGpohzyvctpd7kKQYN+Zie8kqmpXYIBAw1BE8MZ+cNaTmY54J372TTpIsOliT+5khj2wXEkbZKDmYFiBdBPHX8A2gCttY4/QK5sVl3Qnrm7RVLGiOpRDuT6cHtNQziAn39iiif7yhVkT7Hvl+MuDwUM0h0/5i7nDR3DyLnMS/vGcwpVcySAgZL6K6X3q0r9WoC/P7nPu3aXc5nRlrucURt3xbOskTAlGsBOQiUsDR3glUyHRmaAMivGFhjc7jh3+cemR/DKdnuFBCrpx6I+bNjKMXEGOnU/JrJjTTdEDSS4xXEma5IxjpUyMmVJn+UUY6eMbFUl0zBytURLv7/WlEwfT0+aStAcUjOaynaXszGZzvYzzCiRlCpLKRlc4k9p8HW1E39k7jknSqafYzINwyBL+7hVMvepgJHpJTIjspzscoBWM8cSf8Tua8oI4wwv6vkvXfjwiUbF19swckpqKdzn3ZaqESX/AbxBvTueERqZFKpKphPvEcD/dpmS2cP8tsUzo+TrU4h4TAsqS59TMikxwsRY2R9+zOIXH2lWyWQOuEw449Ua+8vKLifnHvV7ghrbuXPal8jivd0pjHDxYeOEv0dsjec0hQCmMkwRlVIynRptTgLq60N2F19ugrEfS6lyyf3cSiX+yOK/KCWzFjv+ADkX8bqStpCyguwf9tnVwL0anJcVqjai1pJTonyWtyqxkGFL1BPFZNYVlIqhFmHcfUgpcGlzrHYg932APZQFyD1vpfd0qapq4XbRJCokDvBG5q447y6nWvEC9nGBK8fkVMnkDB7rvuFdqPT+FrdHAQzaXhcqmdRihDUyDewm5pN4xkQzRL27+WLsKa6E0TjFZHIF1QsZ2dNZqjQEgZrvnAxh1LbctX5+SxxferEXQG6sXNgSwj4tIXz9wEZ0NI6fqefvEVvjOU3KSmaZRqZHMZnc4N1EKC20kpmlV5MlAwsfQ6pylM6RGa+OYjJ9nohHdv0Zzgjb/VFKZiVc5V4jKshejqvcgjJCRgXu8kKDjzPCKLjnv3Dy55TT0lAWwFntS9WYtVL4QuK542QTfxJZjDKGRGtUHAdrIYqHdQL3263rbiUHqXLEjDC5/Uyi3atFPWHZcOeulVV6c/8XeV+CXGJLhl78VD0mM6uuZAJ0siY1f1RKySysxrF5OIMXtiZwzwfDyqWnKoU2MicZ6kZmeQ803/HH2X5EcWalUJMMV8KodPXKlrGo0BMqK5dCDbKcF8Tn4h7mEMbVcNpEP5P40Z/MYvuo/cfWhpHJT95eGJnUPW7dS9SCrMm1kSl/Hvhn0/7ZcidWFTh3uUzJ7Iln2TqHnJJpCx0g7uX6EB93yMEZUoXXTjX7PhbMlXb77Px623tnzatjP0e5y7k69dz5sdzHotq+YWZxPMwMdJVSMkWtOgEnRqZ9O7KlpoN7glYyGSOTWJhHg0BHGcmGXuDz6UnjNU2K91u52eVeJdKolkkB6G4VubaSxINech64ia1SJYxkRib1fi3WyQQEZYwYlzk1WALAvrVgZAoG9HIyyy0oIyTvLicsgcLwAieTNK9kjv3NeRmoZ9OJ+ua2hBHf9ctEJssvagZTJvqZ38IrdXIl02k8JsAb44XXXVUVthbi3/1oMz61Vy42M2gA3z+8GZ+YGWE/xxVkp5AZ4eLEH3qf3OKlYok/Mne5ojeLKrlGiRTO3OWUkklvu5qoKzy/KeRJ+91y8P+orfGUqrnLPYrJdFIahBocR9Im2RqydDDnJsFKlTBy5S5nPuL7mExGwds2ksEBRGcdtnxRi/MuPNVG5IYsN+kHoJMfLBWOynAuDCtx0sGLe/5VlMxG4oZ05C4voxg7Fa84nDYxkOJLmQG5uqwUXOJPqaehNBsboMMGZKgomaqqsKUoz6wP4r9OmYbd8QwawgHp550UPefCCfIqIDN+RgQljLg4/Gq7y53UyQSA0XQWQPEDShmEZbvLieMxTZNcnPshUdLn05PGa6qVXc4abV7FZBIGJTU4skpmycPLrma1klk2otaSFKv76RJAteAub4nw3XUqpWRarkk6JtOdkskVES/MwqaU03CAfvadqJNhl8aEVaaplNG0KS0m3sXci8ru8ioqmaq2a6mROzUWVDJwuILsFLLYXZGSaRgG2UiCK21VuRJG4rFfdc6ilEw68adMdzlxON2jWdI498OYqY3MSYZqjelylUzuQXLSVQPgV7WUO58aHEUljIr/7Y3yqgoXA2ZBJ/7Q2/peyXRYkJ2qkdkYoksh+Q3DMDCzjj5Ozth2AhmTKUj8KY7JVD9/KkomZVg1hg2yyLcTA8GJ6lkKF5ctMzK5BQ/nLi99Pikl003IkSy7HHCuZDrFiZJZjpEJ0GMXq2RWKiZTkj+g6s1SjcmsROIPW/KtAs0rnOL/UVvjKdVyl3MPktNuBXwJI9Xscroe5XiXMGIadBS8P3Gyy6fFAuSKnIvJJDPLW0M1086WK2PkjbtckPhDGH3uE38UsssJw4orMeVIySxj6KF+47CCkbl5iJ6kWxUUXUB+7lXhPECFRqaqEua025CFk/uEV3pz/+eqc1iHRo1dXBx+pXqXs0qmg44/AF2QnTJQnUytpJJJ7JOLY9fuck3VqVZ2uVdGG+c6IbPLGXc59Z2laolhGOQxj18JI/trmRrNLg8YBml4UUpmOmtiLRHA7ge3jyqccutJCSPKHZzJ3ePUvVpo9KkaD5EAP6EXx2SqG1aqcZaRAMpaTFBxpyru8s2OYzKrrGQWJv4o3kZUmTcVnLjLuZhMK4SDC/GxDDtKyWQTfyqWXS5O+izLXU5ll5erZBKl31YPcCFG4x/H7vPpSeM1qu7ySmWXOzXaKCWTi/viBkcqc5SK+6LiMivmLncRk1mLHX8sqDJGlJG5cTBDhgXs64PBUhUqC35mXaDshRtAG3/xtGgxNra9akxmLGiwE2/hfUnFZHLqmerE6rZvuQXtLs+6dperdPxJZ02ysLw7JVPuLlc9l80uV5+OEn/YsIrc/6VKJnG9OSOzUkomtwDKJ/4ozlnVK2Fkf20toWS2RQPs/VtNxv8INFVFJfHHgPt4HguvYhypxB8u7ouLOesj9kE9e9TgXU7iz4bBNJ7pipMTnLvscsZdXgNPMaXuUf3LP6zhpB+LJQsbbJPDZfs3eOLup56reMZUavGoml0eCdJtIK3vsqDd5fLEFdl3lwMXMsO1RbTgDAmVjj+cUVSxmExFI4VL3pJBFWPnkJV4ksZkOkj8cdtuVAY/V+X6qKtOAaVKpsm0Di67hBExN/i5eUUNTE85Vq5ciQsvvBBz587F7NmzcfLJJ2PZsmWO9pFIJHDLLbfgox/9KNrb27H//vvjqquuws6dO8ntR0dH8fOf/xzHHXccOjs7MXfuXCxevBg/+clP0N/fb9v+jDPOQGtrK/nfQQcd5Op3e42Ku7w5YiBQ5oTIzWdO3eVUCSNOLeGUGupBpwYWSh11W8Lo5rcHcOjSbnz2uR7s95/b8FTXaNH77pRM+3YBA2Vfq2pAuYr7k6ZtQuEC2GuhRqbFnIYgXvjMDJy6VxTHtEfwo6Na8M1DmjzZN6XmmAB2xxWUTOUi3iIlc+xvyhjgjEx1JVNpMxbOyJQpmRyyjjYA7SkB3BmZUWYMK7x2qufSdUymF4k/abGRGREomZzBX7li7Hx2uRPPW2lMJpfb6Sjxh9i29JwmMyY2DtknKj/EYwI1UidzxYoVOP/88xGLxXDeeeehsbERjz/+OC677DJs3rwZV155pXQf2WwWl1xyCZYvX44jjjgCZ511FtauXYsHH3wQL774Ip577jlMmzYtv30qlcJnPvMZvPnmmzjooINwySWXAABeeukl3HTTTfjv//5vLF++HPX19m4K3/72t22vtbS0lHEGvEPFXV5u0g8w1v6s1MBTLWxr4SSg3kkdQGqgptwYbhJ/1vSncMtfx/oFJ7PAlS/34e8XxfIGoRslk4pv8ns8pgUXp7htJIOFLWM/gsosDxjAfB9kSTrhwKlhPHrKNPmGDuHi0nayRmZBTKaidyIa5L9HpuBxho1yTGbZSibdkKHXRXB10MgZBOGAfdwqbq+pnpwoQy27XG1fbr1RqvdJ0OAXFXFJZnZIkF3OUakSRqGAgYABm2KZi3NWH/9LjUzOa+fIXU5sWnq7rR9Mk60j/aJk+uMoBKTTaVx11VUIBAL4wx/+gIMPPhgA8K1vfQsnnXQSbrzxRpx99tmYO3eucD8PP/wwli9fjgsuuAD33HNP3nV133334eqrr8ZNN92En/70p/ntf//73+PNN9/EmWeeiYceeqhoX5dccgmefPJJ/O53v8PFF19s+67vfOc7Zf7qyhEN5Ao6i7KbvTAygdzDVGosOe744yCg3klWJOVyolaYbjr+vLgtYXttZzyLNf1p7Nuaiy0cdaFkUt3WuNZsfoMr37N1OFMUnE4pmfMa1er7TQY4NXIH03y7qHe54jmMBgx2Qrfuy6xpMh2GmMSfKsVkcnUy+1womda5jgUNm3pU+HxSRfABd+Oopx1/XI7jThRv7j6RJv7k3eXq17tSMZlA7pyWjsnJjOmoGort88wtV9ptToSKu9zP5YuAGnCXr1ixAuvXr8cFF1yQNzCBnDJ49dVXI5lM4pFHHpHu58EHHwQAfO973yuKjbrsssswb948PPbYYxgdHXNpbtiwAQBwyimn2PZ16qmnAgB27drl6jeNN7IiwV4kKADeJNI4yWB14k6hHnQyJtOFkrmD6LsNFCsesnqhdJ1M+2u1EI8J8JnVW0eKzxUVk+mXFbkf4BTGXSrucsXnIxrijQfrvmS7/XBKpnJMptJmLFwJI1lMJoV1vqhzkaiQktnIXKPChbVqsXq3SqZqdnkkyN9TlhEuM7SceGIqlV0O0PddPGM6CpeqiJJJHFfplMiVL/LLuOn7Kerll18GAJx44om290466SQAwCuvvCLcRzwex5tvvomFCxfaFE/DMHDCCSdgeHgYb7/9dv71RYsWAQCeffZZ2/6efvppGIaBY489lvy+xx57DLfddhvuuusuvPTSS8hmK1QHxyWyFbZXSiYZ4+hBnUzOJefIXU486NTPdureB/gJvzADVR6TaX+NivGphcxyQK0ge088g96E/Uf6oQyHX3CuZBaWMFJ7rkVK5qig8DvAL2CrlV1OGZkZM9cRxSmWUUMmW6XlSqabmMxjiJ7ic+qD6Gwce36c9i53iqpHKBY0EA4YZHvIsexycW1fJ321BR1by4b2Yjmbr0oTfzivndcljKie5UEDmKdaSqbC+OMoBKxduxYAsGDBAtt77e3taGxsxLp164T7WL9+PbLZLObPn0++b72+du1aHHPMMQByauUZZ5yB3//+9zj22GPxiU98AkAuJnPTpk342c9+hkMPPZTc3+WXX17073322Qf33HMPDjvsMOFxWsTjcaXtnJJMJgHIM8wbgqYnx0CNVaOpjKN9UzGZdYEsuY9Qls5Mpgia9uMIG/bzMpp2drwAsH2YPo7+kQTi8dx3DCfExzqatH9vnKjCGzS8uVaVpsUwybinTQMJxOM5I/J/d9LnZO+G8fuN1jNj/X+8CWZp1aKbueciZhLxPSsW1ecjbJgwU/aQDyB338bjcfQwJX+ioJ+XkEkft207xfuZuy4R0Me1jTleEbFAbiyOBuzjwkjBONYzQt8bkWwScWbBydERBa47uB7/+u4IAKA+BPzs4w1IJMauR9BU+y1RM5Ufb5wQzKhdq4h1foLASMlHrPMTT9L7yqYSiJsGglA/P2Y6iXi8Motqam00mkpjcJR+DiiGkumie3eIWfgZ2bTyeBbI2veRyhQ/Ix/22u+/uQ2B3DkueOS9HMtisZjytr43MgcGBgAAzc3N5PtNTU35bWT74JJvrH0X7scwDPzHf/wHfvCDH+BnP/sZ3nvvvfx7F198MT75yU/a9nP66afj61//Og4++GC0trZi06ZNuP/++3HPPffgnHPOwcsvv4yOjg7hsQLA1q1bkcm4TGtWIGamAPDLwkBiCF1dvWV/TyAbQ6lYPjAcR1eXPTOfIpUF4hl7YpUZp49vYMgAUKe079HBfnR19RS9lk1GUXpehuMpdHV1Ke3TYmu/fT8A0NW9C117Bo2e/jAAXqEbGLWfp8HhCEofWSObcXx848W0cAw7ksX3w7rdw/lr+cb2IICo7XPNoz3o6hpfb0B3d/e4fr/FUB99jrb0j4K65/q7t+Zvs4FhtefDTMaxY2s/APuzt6t/EF1du7F2MADAPtEkBnajq8s+do0MhADYVTrbd6cSju7n0uuSHKK/R9LFlSSQyT37gYx9HOsfGXs+N++iv3No53Z0DTj/4nObgWOPBDaOBrCoMYv65AgKT0liWDx25L9/13Z0DTv//v4RtfskkE2jq6sLEdRhBMVWWu/wKLq6+tlxrnvLZoQCQDZFj5UUu7Zuxu4KOW6CxFzVPxxH19YBqM4pPQPDRfPSRuZ5G+6jnxGKxIj9/CWzZtEzsrqvDig5/3PC/LxV7lgWDAZZwY7C90bmeDEyMoIvf/nLeOutt3Dvvffmjco//elPuPbaa/Hcc8/hueeeQ2dnZ/4zV1xxRdE+9ttvP/zoRz9CU1MTbr31Vtx555348Y9/LP3u2bNne/pbLJLJJLq7uzGjMQr08qvVOVOb0dFhn2Cc0vC/fUDJai4QiaKjY4bS53NxVHZjcjZzfMmBDPDXPqV9T5/aio6O4gGged0AUBITaAZDSguDQgbf6QWIFXpd61R0dOQm5vC2IQD8KtkMRWznKbxuAEDx8cXCzo9vvJjzQT929BTfd31mFB0d7QCAnl3DAOwr/GMWzkLbOBUVtp6Z9vZ2RCJyI6nSzAkkgVWDttcHEQEIFW+/eXvlXW6ZwQzwdp/0O1oa6tA5dwair/WgNJQxXN+Ijo5GbNieAmBf3He2T0PHXvbzNGN0FNgwIv3uprqY0vjAXZdZ8TiwYVj6eRWa6yLo6JiOxg/67VJdaGwcC+weATBq+/x+8+Y4CuEppAMA5/dq6x0Btti/r5SFc2djesz5cxMYzgAr+6TbNUXD6OiYjoaVvegryUo0wjF0dLQjtoN+pufN3QuGYaD+7/3AoFw5jQSAzrmVG+fq3+uzxSgFIlFMnT4VgJooEojW58cyAOjdnSY/2z6tDR0d9oUixZSdw8C24vOXMQ3stVfu/PUmsuhL2+fIj8xosD1H4zWW+d7IpFTGQgYHB9Ha2qq0D6q2ZeG+C9XS22+/HX/84x/x8MMP4/TTT8+/ft555yEajWLJkiW47bbbcMcdd0h/w2WXXYZbb70Vr7/+unRbwJkU7YbWWBAA/2C31Uc8OYZoKIDSiS9tBpT3nUzRxziljj6+KQ7U34Zo2LaPutAwSo24ZNZwfC52EXGFAJBCKL+vFMQTbor43iyGbNtFgurnc7zZq3EYb5cYmdtGzfzxrx+y/76p0QDmtJS/4CmXSMSbZ6JcmusMAHYjs4e452JBoKl+bCE1hXC9UdRHgojFYoiGDCRKqjukkXsvQYSWAMDUhihiMfsE2hjNAJJ7HgBi4aCj81x6XZpj3nmA6vccS33Yfr6T5tjzOZq1G1FBA5jaEPOkAH8pDdEUKKO2lOmNda6SZaYaWQB90u3q9pyfulAApYvqxJ7zYwbs5yYSAOrqcvdlJGg/txSxkPNx2AkxZq4yQurx4Amz5BhDtIhAzT3scYXpfQQjMUSCBroG6PcXtcXY76j2WOb7xB8rFtOKzSyku7sbQ0NDUul23rx5CAQCbOym9Xph3KeV8EMl91ivvfvuuwq/AJg6dSoMw8DIiHyQrQZcFwsLr7LLyy0J5DRrs9wSRlRAttNEpWTGRB9RdgkoDgyPS/x3qm0layW7HKAzzHfFs/lzQdXIrKUi7NWgjjkdVLJZaaa3anZ5pKB0TylxSXY527u8SsXYGzx8IFSzy/uZChiVMDABtZqjXOtdFVRLBVnXlDJk8y0ZiXGsMJmFKsZezjG5hbo/nRZjL0384TPrnWSX09tacwFbvshH46bvp6jFixcDAJ5//nnbe8uXLy/ahqOurg6HH344Vq9ejU2bNhW9Z5omXnjhBTQ0NBQl5qRSOUWrp6c4bq/wtWhUTfJ+6623YJqmtJZntZCXMPLmtqAy45yUMOLai3lRJ5MsYUTs1mnJJS6zHCjOLpcXY7e/RtmlqoO0H+BqZW4fzSCeprtW+KUMh1/gsr6p26nU4HOSNQzwLSwBOiEPENTJVBxSyq2H6mQMkFEnOA+jRXUyiQoYHo2hFColjJrCAddGbjSYa4Agw2o9SmV9W55namFcuPZRvVyVKsRuQV2uhMM6maXCANX+MfddTrLL6detx48tX+STGplADRiZxx9/PObNm4elS5cWKYf9/f24/fbbEYlEcNFFF+Vf3759Oz788EOba/wLX/gCAOAHP/gBzIISAPfffz82bNiACy+8MC/hA8BRRx0FAPjRj35UVIIok8ng5ptvBlCscm7YsAG9vfbYiK1bt+Ib3/gGAOCCCy5wfgIqgEypdFN6g4KaWJysDKlC7IC4dZ3qoEU96FwZCyfsFFS5Hy0qYSTej6qSWSsdfwC+jNGW4QzWDabJHsFaySzGSS3YUiUzFDCUlMJo3njgFSpeyaS/QFW9Kbckl5etB2PKdTLtg4RsIV8OKiWM3NbIBHJJryqxpFGFxQi1FnGjZFbayKT2n8zwnizqsEvrZHIljJwozNzzIFIym8MGZtT5Z2Lw/QgeCoVwxx134Pzzz8cZZ5xR1Fayq6sLN954Y1HyzQ033IBHHnkEv/jFL7BkyZL865dccgmWLVuGpUuXYuPGjVi8eDHWrVuHJ554Ap2dnbj++uuLvvfqq6/Gk08+if/8z//EO++8kzcoV6xYgVWrVmHBggX42te+lt/+lVdewTXXXIOjjz4anZ2daG1txcaNG/HMM89geHgYn/3sZ4uM4fGkVWJkelaMnXFBqMKpJaIBtD5skMqCyrF5UYxdpGSOOFIyFTv+1JCSyRZkH86w581Pbh8/4ETpo56T+pCBpOT5sIwYkfHAeRm4BaCqkeDWxWvhNtGGQqRkxiVKplcLdQqVgvXlKql1IYMNV7Kwrim1GBkrxm7fR6TIyFQ7nkoWYgf4uYorxt4SMWw1fW3ucuazTsZsqZJJ1MjcpyVUsVANN9TECH7cccfhqaeews0334xly5YhlUrhgAMOwA033IDzzjtPaR+BQAAPP/ww/u3f/g2PPvoo7rrrLkyZMgWXXnoprr/++qK+5QDQ0dGBP/3pT7j99tuxfPly/PrXv4ZhGJg7dy6+/vWv4+qrry5KODrkkENw9tln45133sHKlSsxPDyMlpYWHHXUUfjc5z6nfJzVQDYAetlWshQn7mc+JpM/vvqggQHIv4OazCiFIGMCmaypXDR4p6Do83CBlSgvxq4Yk+mfsUQKW5B9JMPeF/vqQuxFOIlN44xMLmbYIh9rR1yuRN5dbt9HwODd1bWpZO7Zp9+UTCV3eeXDDvKxu8S2Y+5y++cKu9iotpUcj5hMUVvJlkgAvSUxTaVjNqeCOlkocs9DMmsikzWxjjIyfeQqB2rEyASAww8/HEuXLpVud/fdd+Puu+8m34tGo7j22mtx7bXXKn3nrFmzcOuttypte+CBB+Lf//3flbYdb2RKpiwxSBVqxe0kkYbrNywyklVjsuje5fS2iayJelUjU+AHd6Jkps1c399Cd1KtK5mzBEomlfQTDgCdTRVs81GDOFF0KDWrnsgELkXkBrVcgpSR2Rjik11qMSazPpg7aGpcSGRy8fyGQXtOKqpkKjzz5Rq5Kn3uVZRMOsTHKPhb7XgqrmQSxxHPmOw4nRNiisd61baSTkKcuG3TWRNdwxkynMtv3h//OO41VUPmDi93FWxBrw7VP9/PBESKjOR6xSeYUlbYVaODYxYpmSMO2koCdkO01rPLo0GDrNv3zOY4XthqL8Wxb0uophKbqoETRYfqg62i9I0pmZSCl/s/5S4XeRiqll3uoYIoiskEcmqdaZqkkum2paMKSkpmmSeyXuE8WsY3rWSKYjLH/lb1EFU6JpObq7i2wpQRP5I2i/I9PMkuZ2My+cxyvyVL1tAUpfGKFsEA0hw2HPWTFUGtuJ3EOPYRT2k4IFYrVFbgAD2ocIO3E/V1p2JMpisjs8azywHaZb5+kLbiz56n1mljMhEKqCe3lSb+AGoxizGBkSkqYcTFYwIOjMwyjQkv3apWuAB37ImMiThjiDR7FNdOoRK3Wq5QoHIexVUIcgY4tTAuislUPMxKu8vZmEyBu7yUjFl8L3BKpmrveUDsLufLF/krxEgbmZOQxrDBlqjw0s1DucvTJpA11Yy2PqLAdGtEXJpDZQUO0IoJN8E5MYx3Mf1qAedGZqnnPVPj2eUA7zIvpTls4CuLGit8NLWJatxhE2HoqHw2IlCoEoLEH0+MTB/FZIrqZAK5Z3iAkasqqWSqnKNyv1/FIxQVuMuzewwuuk5m4d/VSQiT7p84jqxpd4FbtDDxH4WlrTgD1Rt3OV++aEGzv0KMamyK0nhBwDDYmB0vV+DcYKjqfqaUzFZJcJdqTBZlUHK7duQuV84ul+/L7i63b1NLMZkAXyuzlH/8SKP0Wk9WVA02SslUeT5ECpUo8Yf6PgvVtWu5SmbAMDyLy8wrusz+4hnaVQ5UVslUOUfligWOFG9m29GMKR2zgoqH6eXigYIzYrnkU27+LDRKOXe5F4k/qayJ1SUtkAFgr4bgnrhr/+Cvo9FUDW4C9yqzHOAHQ1X3M2lkSgbvchJ/WCXTgbtcWMJoz4BlmqaikqkQk1lbNiZbxqiQ5rCBfz5Aq5gcqvFpXHa5DGtxSH3PqMBdLnLRqiZueDH8eOVarZcomYmMyZZLq2zij3ybst3lDmJ3ufMdT9Pu8rALd3nFi7Ez++dKdXHzZJGRySb+ODEy6deTWbp8kd/iMQFtZE5auAxyL41MLvZE2cgksstlx1eWkskZxYructM0hdnlVgmjXMiAfH+lSiaVXT4RYjJL+coBWsUUoewud2lkjimZ9vdS2VzYBqXgidzlqm7wct3lgFrIjEqxapGiC+QMCje1fMvFLyWMRLG7QG6RTJ2eiAt3ecWVTOY4uKYD3Pg0kpa7y71QMvsSWWwbsZ9cv2WWA9rInLRwxppXhdgBfsWt4ioGKusupyZQ/njVjMyBlCn8bdYApKJiUtuliFjWWovJlCmZTWEDV3xEq5giVFUdyn3tiUKVMRkl04Pscg8UK5XkP5VagmMxmfT7iYyJ/nFQMquSXa7wHaIqBEDuPqEMrcK2mMrF2MdNyVRP/AGKx2wuzMrJpeG2/aDP7ioH/NVO0qLGpiiNV7RG6YeqGu5ylX6wWZMewGU1PJWVTMpdziqvSrvELkH5Ims/6Sxfe62UiahkzmkQX7+vLmrEFK1iClF1B7tVMqOSrOq+pEn3ShcsUJVjMj249CpKporiI1fqgIFxUDKrUidT4fMxQYIYkFN6Za1wgz4pxs5dY85dzl3forh74rcHDfWyTQA/vq/q5TLLtZGp8QmcMelpdjnzgKgYWYMpk3Qpy41MteOvRAkjkavcYiRtshmLpRTuzjTpib3WlExRdnljyMA/f6ShikdTm6jGN9KJP+puYm7i3cXc56LEH8MwlDKEPVEyFc6PiuIjOw+JjIlBRsn0crFeiloJo+opmSLFm3aXj23vm2LszDkdIsbqiKCMXuHYniIGbKfhINz2f2eUzAVaydT4BT4m00N3ucDNJIMrxN7CKLAW6kom8VqZJYxEmeUWI2l1JbPQ9cIVBQ77qEetCg3hAJu89dUDGjCV801q8qieIkptUSthJI5F5JLbqOLvhajUB/QkJlPBQOpsCkG2mTWWcOchnjFZJbOSbSVVDHGRqqyCWjH2PUY4Y9dw7vJCdU7VE1NuJyjp/pnjoEpURQIG+xwVljCiGtaFHQ5vnBFOJf1EArnscr+hjcxJSjWyy7mBgTOYCuFaSnrhLg8HQNbaLLeEkcxdDuSMTAXBE0CxccuFGPisWoUSezXaZ6XGkI7FVKWc7PJyi7EDfFcrUeIPoGYceVEPUcVAaosFMFUSliHv+MMrmeXGRIqoSp1MhYFFSckkxrrCU+PnYuwAXcIoHOSPp0jJJMZsJ4XYAd4IpzSYzqaQZ41UvKQGpyiNF3CKpZdGJpcZp6Lk9TGDtxeJP9yDznb28NBdPuyxkllrMZkAcMbcmO21fz6wUauYipTjLnfUVpLZlnOXywwrFePYi7qvKgbSlGgAbUSL00LqJIoup2TWBY2K1q+tRgmjcuupAkA8TRtaERdKZqXd5dzihkr8ESqZkhJGzt3l6tvOb/Ln+KmNzElKNdzl3IOrkvhTSSWTW7WWYxQD4r7lFiOprHJ2eeH3ZpguSbVWjB0ArjywEWd15gzNoAFctKAO3zqkaZyPqnZQUXWiQfo+d5L4wxmFPYy7XGbYqEyYXrhFVX6jipFpGTacQcHVySzXVS3DMAzhuQwY6mFDHGr3iVjpHUlnQYWfh3yoZPIljKjWxryROSJxl3MhZBxOxve9fRiPCQD+PCpNxTmkzd7fNGAAB071ru8p9+CqlDCiyhcBHimZzINejlEMqMdkqpZ2V4rJrMFlYmM4gAdPbENfIouMaaJNK5iOUFEEGxk1z4nxwD0Pf+ujM1tlC0AVA9KL+1nJyIwE0CYZS1SUTKpOZnMVHspo0GATEpvChrD1rgoqirf12HLbct1y/Khk8o1DiG0FiT9xjxN/nIRDzW/ypzlXg1OUxgv2aQnjs/Pril67fP8GTPNwwg+X4X7uZ5XM8hN/uAedT/yR7hKAena5upI59jcfk1l7SqZFazSgDUwXqBgAnJrmJJyEM2b/siNpey1gAPu2iic5FSPTCyVTdn7qQwZiIUM41oUDY88WXyeTTgypZEtJC5Gx4kXfdJXYXZmSyfV1L+r4o9pWstJKpoP9R4OGUkwmNc85rZ7gxCidr5VMjd+4+9gp+HRHDO/uTuFj0yNkrFw5cEomtcIrhVMyvej4ww0obIciRaNQNfFHdWAtNEapGplA7bWV1JSPkpLJGBqyydrAmJrIPSe7iQXgPs0haSykykTuRXa5zECasmcMmSpwlxeeJz7mkHGXV0XJ5N/zIrNdTckUhxNwSmZhhrXq+FXp7HInsY9id/nYsyFLelL7LvVttZGp8R3BgIHz5tfjvPmV2T/3gDAiZRFU4k/QkMd9lROTWX7ij5qRqTpwqGSX12JMpqY8VIxM7jlpkDw/0eBY5QUn6tHBRPhNKSoTrCfF2CVjgNWIYprAyCx0z7Ixh5ksuobtloQsa90LRIqYF5ntXsRkci03i+tkqt1jflIyI0EgsKfua6mXy2slU9VTFTSAjkZ/eoW0u1xTMfgSRu4Sf1oiAWmskUpmKTcGc0HZKkpmOmuSCk8puexy6WYASpRM5hBqsYSRpjxU4tM4I1M2WUcVFDyKgxRiuZWUzCq4y62OUqKYzELDKRQwSMVt/UCmqMOLxYIqdF0Ru8srrwYD8lJXnJJZlPjjk2LsbvqJU89StYqxl9LRGPSt4KCnKE3FYJVBl8XYZfGYQHnucr5DkXSXbIHqUpzFZGolU2NHRdXhXLYNEhm90GBw0i/6YK+MzGq4yy0jU9FdDtDn4r3ddNeVfathZIqUTA/c9UpF+/d8TTiQi8kthYvJLLzG6m0llTZzjSMl0zIyiXNUWIydSxpyguql9GvSD6CNTE0FYd3lLmMyZZnlQHmJP6GAQQ6WKm0lVVzlQK6sh5s6mVxMZi1ml2vKQ0XV4QqjywzUiFslU8FdrqZkKn8li8yboWJklp5j6tg3E65yoDpGpmgo9KKEklzxHgurMAw6EYaKVwX82VbSSYSDZSjKlEwv3OXBgAGVT/g1HhPQRqamgpTX8cf+gMpKpAC5h1g2HomC5qnkHxV3+a5RNR+410pmqMbaSmrKp5zEn2iQVp2ofauoWQAwuz6gVJVCLSazCu7yiNxdXrpYdaLq7jMBlEzDMIQL9tKxnTo/XMvNYne52nl1cv7d4MT4s6qmUPfZiMfu8tyxybfxa41MQBuZmgrCu58rp2QC8rZyogedeqBVEpXUlUwnHX/G/uY7/ijtSjOBUHOX09sYhiHs7V1oCKq2eDyoLaK0ncxQCBjelORSd5fzP7D0WFXPxZz6IGvge4lIFfYiJhMQe4VKzw9lcLF1MgvjXRUONRLIJdpUEjfucur8xDMyJdP5sYUVfrtfu/0A2sjUVBA2kUbifjZNk0z8UVEyAfkkIxpQqPdUlEwnRuZk7/ijKQ+VCVHUR1y0CCs0HlT7LKsk/QBytcirjraqiT91IYMdK0qNKFV37UJJrVCvEK23mz06kaLzWHoPUkb4IFcns+CjKouKSrvKgZyxq/ot1umlFk3FSib1Wee/RUVI0O5yzaSErzsp/txw2iSzqa3SIzKcxJ3Z3iOOWUV5VHWXD6fcusvpbXRM5uSjTmE+ERkaouej0HgIBgyl+0sl6ad03xReZJYDKiWMxn4UF5dZamCpumsXVsFVDsjc5d6cR9Fi3WaEk+5yrk5mgZKpcH9VunwRkFP4VdVq6/ip+8zrmEyVzxgAOhu1kamZhASZRBpZ3Um3fcst6iUzo2g31HsqiT87HCmZSpuWtJWceB1/NO5QayvJbyMyHlRi7UpRqZFJ7bsUL+IxAXV3OcAbmXZ3udqxVSPpBxAfj1dKppOYTEr15IbNoraSCq7gSsdjWqgagNF8drn9PFtGpmmapDDg5tLI3OVzGoJVUXvdoo1MTUWh1ExZxx+qEDsg7/ZjIZtkRIMJ6S5XsB/VE3/Us8sTabmS6eOxRVMh1NpKCpRMD43M5oiBTsUi0LKQalX3vAxVdzkATGMOym3iT7WMTFGYjFdKpug8loazOjEEC0vRqSjlqglo5aJ6/1nHLCphxM0ZlXCX7+3jeExAG5maCuMmkYZrKama+CMblESDCWWAqhiFlYjJLC5hpGMyNTnUssv5bcRGZum/xd910NSwtEGC6r7CHs2VMnf5lAIjh2st6VbJXNiipuqWi7CEkUcxNE4Ub1WXdnPEwCEFiWJBlZjMKimZqtfYmiNEJYw471cl3OV+jscEtJGpqTDUyk2WSMO7y9UeUNkkU4kSRpXILi8sAs91/NExmZMPFWVHlOHspbtcNekHkE+WXimZAcOwKW2FFCmZzIal7kcVI6oxZGBWfXUeSHFbyWoome6M8H88oLHo3KqIlFVzlyteuohAyUxmgUzWZL117tzl4ve1kamZ1NDuZ7GRRXX7AarjLnejvJqmiV2jlVUydUymxkJlQhe5TKlYMgunpXtUk36ofZcS9tCY4AqyRwLFi1A28cdFCaOFrSFlVbdcxCWMvIrJ5PejEpNZSlPYwD8d0Fj0msqhViveUNVQzreVZI5rNGOyc4aTUkkWsjF+bx93+wG0kampMNQgIlUymZjMqrjLXSiZw2mzqJ2YCGdKpu74o7FTTp1MQJLQUXL/ywzDgxVrZAJyFcdJ1xUZ3G+cEg0UGYLTOHe5i5jMamWWA+IxrBp1Mp3eJwDwlUUNRSoyoFjCyGeJP9Z23PkZTZvsnOEmvElWW9PPhdgBbWRqKgy1cpPGZJabXV6Wkuk8JnMno2JS3zKcNovKXIhQUjJ1x59JRygg72olcpc76uQi2DYSAPZzUBeyWiWMALGRWchULvHHhTt43yrFYwJiw0MUj+sE8X1S/G+Z2tgQMnDFRxptr6tc8mqUMALUjVnr0eK2H0mbrLfOjZIpM0x14o9mUuMqJpNwlxvIBY2rIHWXC+56yi3GGXgWO5maRLPr7TvLmkA/o9SWkjbHEn50xx9NISK1PhIQT2aOjAfBfhZNCTtSZqSJPx6GfqgamWwJI78rmczxNIUNz7rjOOr4Izk/ly9qwFQi/lXlmlfLXa4ekylRMjMmWwvajedJ9PPb6wJV6TBVDv4+Ok3NQ624pTGZhJLZElEfPEUxZ7ljUncDAcUJOBSckjmXWWFySi2FpaJmdHa5pgCR0SObdJx1cuG3dZL0I9sXUB13eak35MCpYTJJ6LBpxb9NxdCpVvkigH/uvXKVA94p3vUhA1870K5iAv4pxg44yC6XxGTGBUqm19nlfk/6AbSRqakwVPD4qt40RrggQ5TXtzz3nZLJzKG7XGYU72Iyy+cy9QOHFN3lwJiRyTTP0DGZkxTRpC4zNMrt5GLhJOkHkNcI9DbxR03JbAoH8I1Dmote+4cFddivxGBU6btezQmfS0TyKukHcKZkis7Pl/dvYLP4VcJ9VDvxlIt6TGbu/5zxOyKIyXRTQUEUt+r3pB8A8P8RamqaQ9rCWLEtUfTaUNrEHzfFcf78evIzfQn7A6oajwko9C4XPLRkDKksJpMxMud5MABYnnjOZa+VzMmJSN2RxeQJXe0OlEzVTj9j+5K8Pw7ucgD4xiFNOLo9gjd2JLFoSginzInZssRlKte8xqCreDu3cAa7V+WLAInirRhOUBc0cCWjYgKKSqbPirHLlMzRjMleHzdrANHUp5VMzaTn/L3ryNf/a90o+5lylUzZoCQKmiez4bO5MkUcO5luPx2KnVBE5JVMRvgN6id4UlJOW0EvYu0MAB9xqGTKSxg52p0QbgygjEwAWDwziv97cBM+3VFHFgiXHfvC1uol/QCimEzvBgQnije37WX712NGHX9h/dVWUnU7sZFZzcSf+T5P+gG0kampMIe0hcmA+OWb4+hhEmYoI7PFwQq9HHc5t5oVtZaklMyp0QCaHQz4XK9pK8Oc7fijs8snJUIlU3L/i56PUvuUUx/nNwcdGzTVKsYOAA2MRMZlk8uQqbDVjMcExIk/XuEkdvfj7fZSVrEg8PUDm4TfUYsxmdZtX1qBwCLucQkj0Tnye/kiQBuZmgpjGAY+O9+uZqZNYNl6Ws2kirF76S4XxYZxE6EoLpNSMqfHAmhwMOBzRnQib2TSn9MxmZMTYUymVMlUL8bOqUgHTVWvj2khMyKrU8LI3XfIDJ1qZpYDvAtVdu2dIL5Piv+9b0uoqESRAeCXx07FTKLCRiEql7xqxdgdusu54xrNmKwo4Sa+VDRf1UJMpp6iNBXnwgV07OVjhMt8NG2S2dxOjEypu1xYwogxMgVxmVTiz7S6gFRRLaSZMUjjeXe5/fsNqPX+1Uw8BB7IsmIyVbPLncZj5vYlft9D+8ixu1yGTOWaiEqmk/ajhmHgpiOa8eypLbhx3wRWnt2Kc5hQqdLPyYZJvxVjD0tKGIkSf2TJb/T30a9PjQYchZGNF/4/Qk3NM68phCOn25WP13cksWEwXfQa5SoHqpddzn2NqIwR5S6fHgs6cvNIlUxizNIq5uRFpO7IjEwnxgNnrDnNLKf2XYqbCZiD+41OFquFyNS0ahuZfAkj7wYF4WKE+H7DMHDQ1BA+PSODWRIFsxCZy7xaRqaqyijLLh9Nm0hw4U0etpWc3+z/eExAG5maKvHZBfSq9rG1I0X/LrfbD8DHY1k47fgD8O7yTNZED2lkOnOXc4XmRdnlum/55EU08coMDSdKJlWGK2C4UzJlSpGX7vKpTJH1dgfGTyEiA7ktGiALjVcSziDiPCJucFInsxxkcYrVK8buTXb5SNpEihEl3AiP3HHNrwFXOaCNTE2VOHfvOtIt8l/rRosyt3klU32g8bp3OcCXMdqdyIJ6J+cuV3+85O5y+3u628/kRVyM3X3iT6nxcspeMbSWLIAuWiDOGOaQKVJeustPnB21xfsd2hZ2pLAVIjr2fR201vQK1l3uaUymenZ5Och25de2kg0hg2wd3JfIskqmm4UUt2ashaQfQBuZmirRFgvipL1ittdX96fxTk8q/28vlEx573Ln73FG5g6m28+MWFCagFRIC/P7RB1/dGb55EU0IcqqGjhRqBrDAfzprBk4rSOGg6eGcc3BjfjRUS3ODnYPskfYS3Vsr8YQ7v/kVLTX5b700LYwfn3CVNf7E53vaif9AMA+zSHyfLoJY+CYdEqmcjH23HbBgEG2Jd0ZzyLlYUwm57GqhaQfQBdj11SRz86vw9Ndcdvrj64dwaHTcjGbfUxfbycxmTI3tTAmk3mPq1O5iynD5H3ij/09HZM5eRGp9eUomZQxNa8phEdOblM/OAbDMBAJ8OXAvG4scNa8OnymM4aBlMku4lQRecPHw8hsCAdwxUca8W/vDeVfO3lO1NYOsxxECqKX0QEyj0z1Shgpbldwn06PBWyJnzvjGSSz9HVQrcVZ9Bnm/NRKTKY2MjVV47S5MTSGDFtbxd+uH8VNR7QgGDA8UTLDgVzGIte9UVjCyKG7nOv2Mz0WQCQoPo5CSl2Spd+rYzI1hZQVk+likeUV0aAh6Ovs/fcZhuGoxi6H6Lzs21LdQuwW3zu8GYdPj+DV7gT2bw3jogX1tk5F5RAMGIgFx+LCC/HyPglKjrlq2eWK42nh4zWNUDJ74gJ3uYsxm6vtukC7yzWaYupDAZzZaXeZd49m860nvcguB4B6gZojmszYEkbMoLGTcZdP37PUV1Uz+cQfvne5VjInL+UomcGAwao21TAyObzMLvcav7nLgZwBfWZnHf71yFZ8ft8GTxOnLLi4ci9d2LJxrHrZ5c7c5QDInuw7R711l584J2Y7RyfOjqKtyslmbtHTlKaqfJapmfnonixzqhA74DxrUlimRdi7nH6dK2HUzbSUnLYnFkzVyGxhfp/1vVTHH61kTl7KSfwB+Puy0mX3hEl3Vez97RTOAIkE6Az8iQJ3n3hp+MnGsaoVY1c1MguO1xrnC9mdyGKEcV+5UevnN+fii/duCiISAE6aE8Uvj5vifEfjRG3orZoJw3GzomivC6C7RAF8fuseJZNwlzeHDcdFxzmXYNAQFzDn4sI4d3nXkN3IbAobeaNYXcmkZ/e4oOOPh9VKNDWGMPFHIbSkPhhAL+z3bqWVTKEXwceLJk45XtAcmtCLPXYx4qWRKc0u9+yrhKhGZBWqitMJd7kJYDshPoQMIOAynOHMzjqcMTeGjFl74oJWMjVVJRQwcFanvWbmjtEsdoxmyMSfFhfySj3jg5ENjk7d5ZuG0rbXOhqC+dgo7jhK4ZVMHZOpsVNOMXaADyeptJEpMo79HP6RMxDsr4+Xq7xacMb1pFYyC7abzristw7bjcxylXrDMGpyzPfxY62ZqBzKZEC+vztVdt9yC85dLtsV9z7XJoxSMjsK3GeqZYwawgYCRMVNoZKpn95JSzmJPwCt9AeNyi9cRBNtpQ3ccjAMAwdMsY9bR85w3sO9luCVTO++wy8df1SNwMJTQpUwAoCtw/YB28s6sLXEJP3ZmvHkI8RgDQD/25si3eVc5rUIbgXuXsm0v5bImNhOJP50NI6pG6ru8liQHoTySqZJ1MmswVWtxhu4cJBwQM1Yo8p8VWMyF7nE/X4/X31QY1Hx7bmNQSxZ2DBux1MN+Njd6rjLo0H3LmanqPymSABFGfzTiZhMgHaX+znmuJJMbK1f40v2bw0jYAClHuD3d6fI7HKnmeUAPzjKHnRugqZiMrcQLhGgOBFA1n3IIhY0EA0ApRWRRHUyg3qJOGnhXIiqvaspI7USJYRKESlgXqpjleC8+fWY3RDE7zfGMb0ugEsX1mNKpTOlxhlqHA1J4tqdIlLPq6luq9z/pdnhVEwmAFCOLz9XT6gk2sjUVJ1YyMDC5hD+3l8cz/h+bxp9CfvTWV13OaNkEqNGFxGPCbhzl0eDBiIBEyhpVCbs+DNJBy0Nr2SqxGMCtJJZjaLXtVrCyOLj7VF8vD063odRNSgj02vFWzREVqsQO6D2u8IlhihVwohDu8s1mipCxTet6kthlDDmvFQyZS4Rtq0koSRuJOIxAXfu8miAHoSsQshkxx//z8maCsGpfqpG5sem22MJD5tW+fhCkSdhsroT/cxBRJvKg9q8LT4vUjKrFY8JqKmmpfNHS8RQjo33c8xxJdFGpmZc+AgxeHGtG90omZybWjaROen4QyX9ALnscgsVIzO0J+FCGJOps8s1BXD3t6xvucWShfU4oHVsMdQaMfDNQ5o8OTYRwjqZejbyHZ9dUI+9m8bGs3AA+L8HeXufiG5Z1XAjL1BR0sMl84dhGGTXH/Kzk3S81u5yzbjwkSnqt15r1PnDybmp3Sb+UEYe5S6PBouDwRtkqZMYW61TPzOhs8s1BJzCo6pkTosF8dQZ07F8SxwDSROn7BXD7IbKB0WK4i61kuk/ZtQF8cwZ0/Hf60fRE8/ijLkxHOqx4i1qK1ldJVO+DbUQmhYLYtsIo5AUftbnMceVQhuZmnGBUjI5WlxIHFw7NLcljEglk0j86WgIFWVDitpbWliGbS4ms5i4ILtcK5mTF07hUU38AXJF28/dm+7AVSlqPSZzMjK9Loh/PKCxYvsXrcOrqmQqGLTUPcol/6h8djKgtRDNuNDREFRuFemlu1ymZBoG7bamShhtktTIBNTc5bG8kWl/L5HmlUwFkVQzQSlXyRwvxDGZVTwQjW8QuZGrGceoUsKIOlZVd/lkVer1NKUZFwzDUFYz3ST+sNnlKsHdxDalSmY6a5JdHVwZmXv8CdTPjAtiMidrjI8ml3VL3cpuVP9qInJ/TlalZ7IjGiKr6S5XcQJQCyGqfznFBK92xVIzP3vlypW48MILMXfuXMyePRsnn3wyli1b5mgfiUQCt9xyCz760Y+ivb0d+++/P6666irs3LmT3H50dBQ///nPcdxxx6GzsxNz587F4sWL8ZOf/AT9/f3kZ9asWYMvfvGLmD9/PmbOnInFixfj3nvvhUm4Oyc7XFH2UtwUY2frZLpcrZaWMNo2kiFroXU0ODcyRe7yRAaIp00Mpoh2my7Oi2ZiEAwYOIroNvOJWf7uQCNO/NH382REVHOzmiWMDMOQxmVScwPXWlLls5OBmjAyV6xYgVNPPRV//vOfce655+Kyyy5Dd3c3LrvsMtx5551K+8hms7jkkktw8803o62tDf/0T/+EI444Ag8++CBOOeUU7Nq1q2j7VCqFz3zmM7j++uthmiYuueQSLFmyBIZh4KabbsKnP/1pjIyMFH1m1apVOPHEE/Hkk0/i5JNPxle/+lVks1lcc801+Na3vuXZ+ZgoKBuZLpaAfHa5/LPUQJMoURK5zPK5TcVhzuW6y+MZE91E9wgAmFmn/YuTmVs/3loUD3bJPvU4eU5sHI9Ijuj50+7yyYlIQaxW33ILaYm7Mtzlk7WEke8Tf9LpNK666ioEAgH84Q9/wMEHHwwA+Na3voWTTjoJN954I84++2zMnTtXuJ+HH34Yy5cvxwUXXIB77rkn3xrqvvvuw9VXX42bbroJP/3pT/Pb//73v8ebb76JM888Ew899FDRvi655BI8+eST+N3vfoeLL744//rVV1+NgYEBPPbYYzjllFMAAN/97ndx9tln45577sGFF16II4880ovTMiH4yFS128+NC5DNLldqHUYpmcX/ppJ+ALuSqVKM3Rp8KFs6ITAyZ2gjc1LzkalhvHvhTPxlZxJz6oOY3xwsannnR7iJNmRUr32gxl+EBNe9mkomsCecivAa5d8ns8tVSxi5Paraxvc/e8WKFVi/fj0uuOCCvIEJAC0tLbj66quRTCbxyCOPSPfz4IMPAgC+973vFQ3El112GebNm4fHHnsMo6Oj+dc3bNgAAHljsZBTTz0VAIrUzzVr1uDVV1/FscceW/SZSCSC7373uwCABx54QOUnTxoWKSiZjSHDlZuBLcbuMiYzWaJkbhqUd/vJHYd6CSMuu3w7Ux5jZr3vH19NhakLGThuVhQLWkK+NzAB/vmbrCqPRtweN1ZlGUzerINwlysu9nXij095+eWXAQAnnnii7b2TTjoJAPDKK68I9xGPx/Hmm29i4cKFNsXTMAyccMIJGB4exttvv51/fdGiRQCAZ5991ra/p59+GoZh4Nhjj1U6zqOPPhoNDQ3S45xsNIUDmNckfkDduMqB8tzl1GBQmvhDKZlBA5hVX0ZMJrFp2gS2jtBKZrtWMjU1BjeJT1aVRyNxl1fZMJPFZJblLp+kMZm+d5evXbsWALBgwQLbe+3t7WhsbMS6deuE+1i/fj2y2Szmz59Pvm+9vnbtWhxzzDEAcmrlGWecgd///vc49thj8YlPfAIA8NJLL2HTpk342c9+hkMPPdR2nNR3BINBdHZ2YtWqVUin0wiFxKc9Ho8L33dLMpks+r8fWNQSwIZB2ogCgOawu/MRytL7DGYz0v2FDUJRTGeLPrdxIGXbZlZ9AOlkAoUaZzDD/7b89yGLZDLJZh+u60uQr7cGUojH5fvXuMePz0wtY2Ttzw2Qc0M6ec71dfEnrq6LYIwMmfLx2ktki50g7MfTRMwXFIEq/5ZSvHxmYjH12G/fG5kDAwMAgObmZvL9pqam/DayfbS0tJDvW/su3I9hGPiP//gP/OAHP8DPfvYzvPfee/n3Lr74Ynzyk5909B1NTU3IZrMYGhpCa2ur8Hi3bt2KjIJx4pbu7u6K7dsps40wAN5tHssm0dXV5Xi/fQkDQJ3t9fjQILq6dgs/a6aiAIqXtEOjxcexvj+GUkfAjGDKdqy9SQAQF7zOJkbQ3d2HSIB+HP++cwilj2rEMDHYvQVDk3NxXHX89MzUMsN9QQBR2+sBM+PqOdfXxZ84uS6jQ/wcEB/sR1dXj0dHJcdI28f1QpKjI+jq6rO9Hg3UIZEVD8bxYfncUw3KfWaCwSAr2FH43sgcL0ZGRvDlL38Zb731Fu699968UfmnP/0J1157LZ577jk899xz6Ozs9Py7Z8+e7fk+gdwKpru7G+3t7YhE/FHq5ONmAvd2DbHvz2iKoaNjhuP9zsiYqH97N0ZKQicXzWpFR4d4Fda0egAoUSrNUBgdHdNzf5smdrxmHywWTK23HeuUlAm8IR5YpjY1oL19CqKb6cF0ZzYKoHjRMaM+iLlzO4T71ZSPH5+ZWmYWEsDf7c97fSSEjg71+1lfF3/i5rpM6RsBNo+S781smyIdr72kcVU/MEzH2wNAa1MDOjraba9Pr+vF5mFxa8m21mZ0dFS3w1Yh4/XM+N7IpFTGQgYHB6XKoLUPrrYlpZbefvvt+OMf/4iHH34Yp59+ev718847D9FoFEuWLMFtt92GO+64Q+k7BgcHYRgGGhvl7bmcSNFuiEQiFf8OVQ5rDwLgjcypdWFXxxoD8Nn59fj1h2NlptqiAZw5vwkxSV2zurD9eNLm2HXpHsmA8lLPa7Gf13BE7kqpj4QQiUTYlpZdxOA1qz7om2s4GfDTM1PLNMYA6nmPBgOuzq++Lv7EyXWJhXn3bVPM3fjvllhoUPh+XThEHs+MuqDUyGyIVPe3cFT7mfF9uLUVi2nFPBbS3d2NoaEhqXQ7b948BAIBNnbTer0w7tNK+ClM7rGwXnv33Xdtx0l9RyaTwcaNG9HZ2SmNx5xs7N0UEpapaI269wf/5OhWfOvQJhw+LYzz967DE6dNUyr7QwV3JwqMSrZ8UaN938GAAVmtXlF2OQCyELtO+tHUIlwW+WTNvNWIi5RXs3c5IK9ywN2nKv3Lfd6Mq2L4/mcvXrwYAPD888/b3lu+fHnRNhx1dXU4/PDDsXr1amzatKnoPdM08cILL6ChoQGHHXZY/vVUKucu7emxuzCt16LRsdgi0XG+9tprGB4elh7nZCQYMLBoCm94u+lbbhEKGLjusGYs/8wM3PvJqThAsfi7rIRR1xDtTukkjExAXsYoGuLrZHLMrNdGpqb24LJ3J+sErBG3lax2aStZ1ynuPm1T6PozWRdSvn+0jz/+eMybNw9Lly4tUg77+/tx++23IxKJ4KKLLsq/vn37dnz44Yc2t/UXvvAFAMAPfvCDohaP999/PzZs2IALL7wQdXVjiSJHHXUUAOBHP/oRstkxGTyTyeDmm28GUKxyLly4EMcccwxeeumlorJHyWQSP/zhDwEAn//8592fiAmMqPNPOUamW6gMw8ISRly3n45G2liWlTESdfzhaFfsl6vR+AnOaJisLfc0/mkrCciNWu4+VVMyJ+c97nvfbSgUwh133IHzzz8fZ5xxBs477zw0Njbi8ccfR1dXF2688cai5JsbbrgBjzzyCH7xi19gyZIl+dcvueQSLFu2DEuXLsXGjRuxePFirFu3Dk888QQ6Oztx/fXXF33v1VdfjSeffBL/+Z//iXfeeSdvUK5YsQKrVq3CggUL8LWvfa3oM7fddhtOPfVULFmyBOeeey5mzpyJZ555Bh988AEuv/zyvOGqKeYjUwVGpss6meVAKpmF7nLGyJzTwCmZ4sFFVCeTo10rmZoahJtodTH2yYuf2krK6ihzauQ0hUV/eJIO2TUhhxx33HF46qmncNRRR2HZsmW47777MGPGDNx333248sorlfYRCATw8MMP49prr8WuXbtw11134fXXX8ell16KZ599FtOmTSvavqOjA3/6059w+eWXI5FI4Ne//jUeeOABZDIZfP3rX8fy5cttCUeLFi3C8uXLcdppp+GZZ57BL3/5SxiGgZ/85Cf48Y9/7NXpmHD4Tckki7EXuMs3Ee7ymXUBdqKUK5m5/0eZmEwK3bdcU4twxbW1u3zy4qe2kvLe5fTr0xXc5boYu885/PDDsXTpUul2d999N+6++27yvWg0imuvvRbXXnut0nfOmjULt956q6PjXLhwoW4f6ZCPiGIyy0j8cQs1GGRNIJM1EQwYpJJJJf1YVMRdrltKamoQTimarPFqGklbSZ+5yzklXqXrz2S9x/VMpRl3psaCmM0YTeOhZHLJCYmsCdM0yezyuUw8JgA0VMDI1EqmphZhs8snqcqj8Vd2uWt3uc4uZ5mkP1vjNziX+XjEZHIDSTID9CdNsqSQUMkMq8VkqrrLA4Z6v1yNxk/oEkaaUvyUXS5TTrn40ekqpfEm6T2uZyqNLziozW5k1gWN8YnJZFbWiYyJjUz5IrG7XPwbnCqZM2IBYUamRuNXuLi0yaryaADR8Fhth428hFE5SubkHLP1o63xBZcubEDpQu/Mzti4rP6470xkTb58UQPvLlfOLlc1MrWrXFOj6JhMTSkhgfFV7exyt8XYo0EDzRKP1WRdSE3Sn63xG3s3h3Dv8VOxV0MQzWED58yrw60fbx2XY+E89KkMX75oblP5iT+q7vKZOulHU6MEDINM9DtIUMZMM7ERDY/VTvyRLXZE5ZZkauZkXUjVTHa5ZuJzzt51OGfvOvmGFUaoZA4z7nKmRiagomTu+V7FMUi3lNTUMt84pAlffrEXVlWwRa0hfKZz/J97zfjAKZnRYG5RUk1kKQAil/f0uiDWDdIihOyzExltZGo0JXAuk2SGdpdPjQbQIFjiyrLL6xy2ldSF2DW1zLl712OvhtD/v717D2rqzP8H/k6AABIhKhCw3FEUvC4iAuJosVgt3i/rdqu2Ha+Urzda66ytP+06Falr0REQdZd1UUerW7Co1VZlKUXx0rLedbSg1nu1FRSqgITfH2xSQ3KSEEJCk/drxhk55wl5cp7h5HOey+fBwZtP4d3ODuMDndHBAgv8qG0QunWauxcTMKQnU/i8/p5Mo6r0u8cgk6gJocUJNfUN+LGZOTIBw+dk2okaV44r9Iyae3FLSfqd6+8pQX9PiaWrQW2AnUBvpSWCTP1zMoXP6Q0ybbQnk99WRE0IPVnXKLTPydQ1VA4YPidTJDKsN5M9mURkLYRWl1skyNQTCOo6r2/XH1udk8kgk6gJoafZRzUK/FKj0Diua9EPoD+F0YvvZ8iNlYnYichaCA1BmzsRO6B/SNtBx/1Z3/7ltjojxEY/NpEwoSfO8sdCi350zzoxtCcTEN5t6EXcUpKIrIXQ7bFNDpfruPV66Bku1xWgWjN+WxE1IfTE+YNQkKlvTmYz8qcZssMFV5cTkbUQ2ljCIj2ZRiZjB/TPydQ3FG+tGGQSNSEU6JVVGhdk6lpd7mQHiF6Y+K7vRtTBUWT2rdaIiFpLW1pdbuy2kgDgrmdOpq7XWjMb/dhEwoSGy68KBJn+UuOHy5ve1PTcpzgfk4isitDt0RIP0/rmZOpavOOhY06mg1i9M8GWMMgkakJo3s3PWhb9tHcQwU1PFvXmBJn6bqxcWU5E1kQoGbtzm5yTKXy+o6MYQmdtdagcYJBJpKE5qSYiPCR6n1B1BZlNb2r6Fv7ImSOTiKyI4MIfC8zJ1BcM6hrytheLBDcVcLDhvgF+YxE10ZynzjEB+rfD05XCqLk9mRwuJyJr0pZ6MvV1MOg7L7TCnD2ZRKRi6FwgsQhI8HPSW87JDsLDKE3nZOq5GXG4nIisieDCHwvsR6hrJEkE4V5XJaFcmbaavghgkEmkwdA9ZmO9HOFhQM+iSCQSXGGu2ZOp+3dxS0kisiZC20papCdTx0O+xE7/4h2hXX/Yk0lEKobeEMYE6O/FVBLKldk0qOTCHyKyJe0dROioZS6jf3vzd2Xquv8asve4UK5MXUncrZ0Nf3Qi7ezEIui7n4hFwCh//fMxlYQW/zRNOMyFP0RkS+zEIkwLaad2TO4sxmsGTEUyNV3BoND2ly8SCjJtebjcArMeiNo+R7EIT+sbBM/HyCXwbMYiHKEgU2N1OedkEpGN+X/9XOHVzg6Hbj2Dn9QOc3u215vcvDWIRCJIxECtZrY6g3ojhXJl2vJwOYNMIi0kdsDTeuHzhqwqf5FQkKmZjF34ZuRiL0J7W902goisllgkwpwwKeaESS1dFTjaiVCr0OxgMKQ3UigwZgojIlKja26OCM0bKgeE0xg1J08mh8qJiFqX0L3fkJ5MoeFyW+7J5LcWkRa6JnlHySXwauawtaE9mbqCWw6VExG1LqGA0JCFP0J5Mm15TiaDTCItdPUojm3mUDkAwRRGzenJZCJ2IqLWJZTCzpCFP0Ip7QQ2ArIJNvzRiYTpemodbUSQKdyT2eRnHe8rb8c/VyKi1iQ4XG7AM76bRKQ1YXtztiq2NvzWItJC6KYQ5SmBtxHD1gavLtdxM2JPJhFR6xLqYDBkuFwsEiHIVXM9tY+L7d67GWQSaSE0L6e5q8qVBPNkNmfhD+dkEhG1KqF7sKG9kVOb5Px0tAPGBxr3vWENmMKISAuhoRFjhsoBw3sydaUw4paSREStSyiYNHTXnv/rIYVELMKe60/hJhEjqYcUvTtJTFjD3xcGmURahHVwQPG9WrVjUZ4SvGTksEc7gfyWTk13/NFxI2NPJhFR6xIaxTJk4Q/QmNB9dpgUs9tAzs+2gF0jRFpMDXGBq+S3m4qdCFgZ6Wb07zN8dTl7MomILEW4J9N2F++0BHsyibTo1dEBhxM88FnZr3hS14CpIS7o1dHB6N/X0jyZEjHQwZbzYBARmYHQnExb3rWnJRhkEgkIkTlgaT/jey9fJDwnU/1noe16PZ3tIBLxSZqIqDW1JBk7aWLXCJEZCM3lbJoOSagn04s5MomIWp3waBKDTGPwm4vIDPp0ckCXJvnTQtzsNYbghUbE5cyRSUTU6oSCTIG1m6QHLxuRGYhFIuQPd8cofyf4Su0w2t8Je151h1hk2JzM5u6VTkREzSeUvk7XokwSxjmZRGbS2cUOW+M66SzT3kEERzugpl79uJ+UQSYRUWvjnEzTYk8mURviaCdC/EtOasfsRMBof9vdMYKIyFyEUhhxdblxGGQStTEZgzpgbIAzXOxF6OZmjx1DOyFQy364RERkWlz4Y1r85iJqY9wkYmx5uSMaGhqYtoiIyIyEto/kwh/j8LIRtVEMMImIzIs9mabFIJOIiIgIOoJMri43CoNMIiIiIgj3WHK43Di8bEREREQQ3rucw+XGYZBJREREBOFgksPlxmGQSURERATAyZ7D5abEy0ZEREQEIMRNe2bH7jIHM9fEOjDIJCIiIgLgK7XH2AD1HdZG+DohiBtiGIVXjYiIiOh/Ng/ugFgvCUof1qFPJwe81c3F0lX63WKQSURERPQ/DmIRZoRKLV0Nq8DhciIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5Bhk2hg7OztLV4EEsG3aJrZL28R2aZvYLm2XJdpGVFFR0WD2dyUiIiIiq8aeTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5Bpg0oLS3FpEmT4Ofnh86dO+OVV15BXl6epatlE+7cuYPMzEyMGzcOPXv2hIeHB0JCQjB16lR89913Wl/z+PFjLFmyBD179oSnpyd69eqFpUuXoqqqysy1ty1r166FTCaDTCbDqVOnNM6zXcxr7969GDt2LAIDAyGXy9G7d29Mnz4dt27dUivHdjGPhoYG5OfnY+TIkejWrRu8vb0RERGBBQsW4Pr16xrl2S6m9dlnn2HBggUYMmQIPD09IZPJsH37dsHyzb3+CoUCGzduRExMDLy8vBAcHIzp06drbdvmYDJ2K1dUVIQJEybAyckJ48ePh1QqRX5+Pm7evIkVK1Zg7ty5lq6iVVu+fDnWrl2LwMBAxMbGwt3dHWVlZdi/fz8aGhrw97//HePHj1eVr66uxvDhw3Hu3DnExcWhd+/eOHv2LAoKChAeHo4vv/wSTk5OFvxE1unixYt4+eWXYW9vj+rqahw6dAj9+/dXnWe7mE9DQwMWLlyILVu2IDAwEEOHDoVUKsXdu3dx9OhRbN68GdHR0QDYLub0wQcfICMjA15eXnjttdfQvn17nD9/HgUFBZBKpfjqq68QFhYGgO3SGnr16oWbN2+iU6dOaNeuHW7evImMjAy88cYbGmWNuf7z5s1DTk4OQkNDMWzYMNy9exd79uyBi4sLDh8+jODgYKPqbW/Uq+h34fnz55g/fz7EYjH279+P3r17AwDef/99DB06FCtWrMCYMWPg5+dn4Zpar/DwcOzbtw+xsbFqx48dO4YxY8YgOTkZCQkJcHR0BACsW7cO586dw4IFC7B8+XJVeWWwmpmZieTkZHN+BKtXV1eHxMRE9OrVC0FBQdi1a5dGGbaL+WRlZWHLli2YMWMGUlNTNbbCe/78uer/bBfzuH//PjZs2ABfX18UFxfDzc1NdS4jI0MVgGZkZABgu7SG9evXIygoCH5+fkhLS8NHH30kWLa517+oqAg5OTmIiYnBnj17IJFIAACTJk3CpEmTsGjRIuTm5hpVbw6XW7GioiJcu3YNEydOVAWYAODm5obk5GTU1tZix44dFqyh9Rs9erRGgAkAMTExGDRoECoqKnDx4kUAjT04W7duhVQqxaJFi9TKL1q0CFKpFDk5OWapty3529/+hsuXLyM9PV3r3r5sF/N5+vQpUlNTERAQgFWrVmltD3v7xr4Rtov5/Pjjj1AoFIiKilILMAFg+PDhAICHDx8CYLu0liFDhhjUIWTM9Vf+/MEHH6gCTACIj49HbGwsCgoKcPPmTaPqzSDTihUXFwMA4uLiNM4NHToUAHD06FGz1ol+4+DgAACqL9KysjLcvXsXAwYMgIuLi1pZFxcXDBgwANevX9eYk0bGO336NNasWYPFixeje/fuWsuwXcynoKAAFRUVSEhIQH19PfLz85GWlobs7GyUl5erlWW7mE9wcDAkEgmOHz+Ox48fq507ePAgAGDw4MEA2C6WZsz1Ly4uhouLC6KiojR+X0tjBQaZVqysrAwAtM6lkMvlkEqlGjduMo+bN2+isLAQXl5e6NGjB4Df2isoKEjra5THleWoZWpqalTD5PPnzxcsx3Yxn9OnTwNofPAaOHAgpk2bho8++gjJycmIiIjAhx9+qCrLdjGfjh07YtmyZbh16xYiIyORnJyMZcuWYcKECVi+fDlmzJiBWbNmAWC7WFpzr391dTXu3bsHf39/rSMHLW0vzsm0YsonTldXV63n27dvr/FUSq2vrq4Os2fPRk1NDZYvX676w1a2RdPhKCVlO7LNTGPlypUoKytDYWGh1purEtvFfJRDrhkZGejTpw8KCgoQEhKCs2fPYsGCBUhPT0dgYCCmT5/OdjGzpKQkdO7cGfPmzUN2drbqeHR0NCZOnKiaxsB2sazmXn99cUJL24s9mURmpFAo8M477+DYsWN488038ac//cnSVbJJJ0+exPr16/Hee++pVsSS5SkUCgCARCLB9u3bER4eDqlUipiYGGzZsgVisRjp6ekWrqVtSk1NxaxZs5CcnIwLFy7g1q1bOHDgAJ49e4aRI0fiyy+/tHQVqQ1ikGnF9D2BPHnyRPDphUxPoVAgKSkJu3fvxh//+EekpaWpnVe2RWVlpdbX63viJMM8f/4ciYmJ6NGjBxYuXKi3PNvFfJTXsG/fvvD29lY7FxYWhoCAAFy7dg0VFRVsFzMqLCxESkoKZs6ciYULF+Kll16CVCpFdHQ0du7cCQcHB9VUBraLZTX3+uuLE1raXhwut2LKuZhlZWXo27ev2rn79++jqqoK4eHhFqiZ7VH2YO7cuRMTJ07Ehg0bIBarP+Mp20tonqzyuLH5yqhRVVWVan6Rh4eH1jLx8fEAgG3btqkWBLFdWl/Xrl0BCA/1KY8/e/aMfy9mdOjQIQDAoEGDNM7J5XJ07doVZ8+eRVVVFdvFwpp7/V1cXODl5YUbN26gvr5eY+pQS9uLQaYVGzhwID799FMUFBRgwoQJaueOHDmiKkOt68UAc/z48di4caPWOYDBwcHw9vbGiRMnUF1drbYysLq6GidOnIC/vz98fHzMWX2r4+joiKlTp2o9d+zYMZSVlWHEiBFwd3eHn58f28WMlEHMlStXNM7V1dWhvLwcLi4ucHd3h1wuZ7uYSW1tLYDf5sw29fPPP0MsFsPBwYF/LxZmzPUfOHAgPv/8cxw/flwjJlDGCjExMUbVh8PlVmzw4MEICAjAv//9b5w9e1Z1vLKyEp9++ikkEgnnBLYy5RD5zp07MXbsWGzatElwkYlIJMLUqVNRVVWF1atXq51bvXo1qqqq8Oabb5qj2lbN2dkZ69ev1/ovMjISAJCcnIz169ejd+/ebBczCgwMRFxcHMrLyzVy+aWlpaGyshIJCQmwt7dnu5iRMrVNZmamxjBsdnY2bt++jcjISDg6OrJdLMyY66/8+eOPP1Y9UACNPdjFxcWIi4szetMWbitp5bitpGWlpKQgNTUVUqkUc+bM0RpgJiQkqJLlV1dX49VXX8X58+cRFxeHPn364MyZM6rtwPbv3w9nZ2dzfwybkZiYiB07dmjdVpLtYh7Xrl3DsGHD8ODBA7z66quqodiioiL4+vri8OHDkMvlANgu5lJfX49Ro0bh2LFj8PDwwIgRI+Dm5oYzZ86gqKgIzs7O2LdvH/r16weA7dIacnJyUFJSAqBxG9wzZ84gKioKgYGBABpX+U+bNg2Acde/6baS9+7dQ15eHlxcXHDo0CF06dLFqHozyLQB33//PVJSUnDy5EnU1dUhLCwMSUlJantmU+tQBi26NN1/trKyEqtWrcLevXtx//59yOVyjB07FosXL0b79u1bu8o2TSjIBNgu5nTr1i2sXLkSR44cwS+//AK5XI4RI0bg/fff15hHy3Yxj5qaGmRmZiIvLw8//PADamtr4enpidjYWLz77rvo1q2bWnm2i2np+y55/fXXsWHDBtXPzb3+CoUCmzZtwr/+9S/VtJQhQ4Zg6dKlqkDWGAwyiYiIiMjkOCeTiIiIiEyOQSYRERERmRyDTCIiIiIyOQaZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIyMZt374dMpkMCQkJlq4KEVkRBplERP+TkJAAmUyGlJQU1bGKigqkpKSoHfs92bdvH1JSUvDtt99auipEZGPsLV0BIqK2rLKyEqmpqQCAv/zlLxauTfPt379ftefxoEGDtJZxdXVF165d4ePjY86qEZGVY5BJRGTjRo0ahVGjRlm6GkRkZThcTkREREQmxyCTiEhAYmIi+vTpo/pZJpOp/du+fbta+fr6emzbtg2jR49GUFAQPDw8EBoaipkzZ+LcuXOC76GcB1pZWYlly5YhIiICXl5e6NWrl6rcDz/8gLS0NIwcORI9e/aEXC6Hn58fhg0bhqysLNTW1qr93hs3bkAmk6mGylNTU9Xq/uLv1rfwp7q6GmlpaRgyZAh8fX3h7e2N/v37Y8mSJbh3757ez/X06VOsXLkSERERkMvlCA4Oxttvv42ysjKtr62pqUF6ejqGDh0KPz8/uLu7o0uXLoiJicF7772H06dPa30dEbUtHC4nIhLQpUsX/OEPf8B///tfAEBUVJTaeU9PT9X/Kyoq8Prrr6OkpAQA4O3tDR8fH1y7dg27d+/Gnj17kJWVhQkTJmh9r19++QUvv/wyrl27hpCQEHTr1g3Pnj1Tnf/rX/+K/Px8SKVSeHp6okePHnjw4AFOnjyJkydPYu/evcjLy4NEIgEAODk5ISoqCmVlZXjw4AF8fHzU5lzK5XKDrsHdu3cxbtw4XL58GSKRCCEhIXB0dMSlS5eQmZmJnTt3YteuXYiIiND6+idPniA+Ph4XLlxASEgIgoKCcPXqVeTl5eGbb75BYWEh/Pz8VOXr6+sxfvx4HD16FADg5+eHLl264NGjRygvL8fFixchk8nQt29fg+pPRJbDIJOISMC7776LiRMnqnozDx48KFh25syZKCkpQXR0NNasWYOwsDAAgEKhQFZWFj788EMkJSWhT58+6NKli8brs7OzERoaiu+++w7BwcEAgKdPn6rOT548GfPnz0d4eDhEIpHq+JUrV5CUlISjR48iIyMDCxcuBNAYRB48eBCJiYnYsWMH3njjDaMWLs2cOROXL19GcHAwtm7dqvpcP/30E2bMmIGioiJMmzYNJSUlcHNz03j95s2bERYWhu+//x5BQUEAgOvXr2PSpEm4evUqVq5ciaysLFX5AwcO4OjRo+jcuTN27dqFnj17qs49f/4c//nPf9Q+PxG1XRwuJyJqocLCQhw6dAg+Pj7YsWOHKhADALFYjHfeeQczZszAs2fPsGHDBq2/w87ODtu3b1cFmADg7Oys+n9CQgL69eunEWCFhIRg48aNAKAaGjeVY8eOobi4GMBvwaKSp6cncnJy4Orqijt37iAnJ0fr7xCLxdiyZYsqwASAgIAALF26FIBm4H716lUAwJgxY9QCTACwt7dHfHw8XnnllZZ/OCJqdezJJCJqodzcXADAxIkTIZPJtJYZPXo0Nm3ahG+++Ubr+cGDB8Pf31/n+zx48ACff/45SktL8dNPP6GmpgYNDQ2q81evXsXTp0/VgtOW+PrrrwEA0dHRCA8P1zgvk8kwZcoUZGZm4uuvv8bcuXM1ysTFxSEwMFDjeGRkJIDGaQaPHj1Chw4dAAC+vr4AGgP3hw8fwt3d3SSfhYjMj0EmEVELnT9/HgCwd+9eHD9+XGsZ5fzK27dvaz3fvXt3ne/xxRdfICkpCVVVVYJlGhoa8OjRI5MFmcpexdDQUMEyyt5NZdmmtE0NANTnsz558kQVZCYkJKBr1664dOkSevTogUGDBiE6OhqRkZGIjIyEo6OjUZ+FiMyPQSYRUQtVVFQAAMrKygRXTCu9OM/yRe3atRN8zY0bNzBr1izU1NRg3LhxmD17NkJCQuDq6gp7e3soFAp07NgRAFBXV2fch9BCGdC+GBA25eXlpVa2KaHPJRb/Nlvrxd5YZ2dnHDhwAKmpqcjNzcXhw4dx+PBhAI1J46dNm4YlS5bovF5E1DYwyCQiaiEXFxcAQHp6OqZMmWLy35+bm4uamhr069cP//jHP9QCNKBxZXprkEqlABoX+QhRpjBSljUFd3d3rF69Gp988gkuX76MEydO4MiRIzhw4ADS09Nx+/Zt/POf/zTZ+xFR6+DCHyIiHQxZyawcMr5w4UKr1OHGjRsAGlMoNQ0wAeDUqVOCr23JSuyQkBAAwKVLlwTLXLx4Ua2sKYlEIoSGhuKtt97C1q1bVXlJ8/LyWi2wJiLTYZBJRKTDi8Oyv/76q9Yy48aNAwDs3LlTZ6+fsZRzLO/fv69xrqGhAevXrxd8rbL+QsP0ugwbNgwAUFJSgtLSUo3zFRUV2LZtm1rZ1jRgwADV/+/cudPq70dELcMgk4hIh06dOsHV1RVA44pnbYYPH464uDg8evQIo0aNUiVkf9H169exbt06wVQ/ugwcOBAAsGfPHnz11Veq40+ePMHcuXO1BoBKypXdJSUlGrsC6RMdHY3Y2FgAjfkyX+zRfPDgAd5++208fvwYnTt3xtSpU5v1u4Wkp6dj3bp1+PHHH9WO//rrr1i1ahWAxrmZL6Z6IqK2iXMyiYh0EIlEmDx5MjZv3owpU6age/fuqpXQCxcuVOVszM7OxltvvYXCwkKMGDECHh4e8PX1RX19PW7fvo2HDx8CABYvXtzsOrz22muIjY1FcXExJk+eDH9/f3To0AFXrlzBs2fPkJmZiTlz5mh97ZgxY/Dxxx/j1KlTCAsLQ3BwMOzt7SGXy5Gdna33vTdv3qza8ScmJgbdunWDRCLBpUuXUFdXhw4dOiAnJ0drInZj3Lp1C1lZWVi2bBm8vLzg7e2N2tpaXL9+HdXV1bC3t8fatWtNtoKeiFoPg0wiIj1WrFgBNzc35Ofno7y8XJWO6M9//rOqjEwmQ25uLvbu3YvPPvsMpaWlOHfuHOzt7eHl5YUhQ4ZgxIgRiI+Pb/b7i8Vi7N69G5988glyc3Nx584dVFdXY9CgQZg7dy5iY2MFg0wfHx/k5uZizZo1KC0txalTp6BQKFT5KPXx9vbGkSNHsHHjRnzxxRcoKyvD8+fP4e/vj/j4eMybNw/e3t7N/kxCpk+fDnd3d3z77bcoLy/H5cuXoVAo0LlzZ8TExCAxMVEjSTsRtU2iioqKBv3FiIiIiIgMxzmZRERERGRyDDKJiIiIyOQYZBIRERGRyTHIJCIiIiKTY5BJRERERCbHIJOIiIiITI5BJhERERGZHINMIiIiIjI5BplEREREZHIMMomIiIjI5BhkEhEREZHJMcgkIiIiIpNjkElEREREJscgk4iIiIhM7v8Dptjp5bC6T7gAAAAASUVORK5CYII=",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
diff --git a/README.md b/README.md
index 97b4080..729f8e2 100644
--- a/README.md
+++ b/README.md
@@ -253,4 +253,4 @@ study.best_params  # E.g. {'x': 2.002108042}
 ---
 ## Sources:
 
-- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96
\ No newline at end of file
+- [github.com/leggedrobotics/plr-exercise](https://github.com/leggedrobotics/plr-exercise) by @JonasFrey96

From 6d73659f04845f7e37553d7d19e2c1ea5c4bd636 Mon Sep 17 00:00:00 2001
From: Michal Nedza <MicnedSQ@gmail.com>
Date: Mon, 4 Nov 2024 21:01:06 +0100
Subject: [PATCH 4/5] Update

---
 poetry-demo/README.md               |  0
 poetry-demo/poetry_demo/__init__.py |  0
 poetry-demo/pyproject.toml          | 14 ++++++++++++++
 poetry-demo/tests/__init__.py       |  0
 4 files changed, 14 insertions(+)
 create mode 100644 poetry-demo/README.md
 create mode 100644 poetry-demo/poetry_demo/__init__.py
 create mode 100644 poetry-demo/pyproject.toml
 create mode 100644 poetry-demo/tests/__init__.py

diff --git a/poetry-demo/README.md b/poetry-demo/README.md
new file mode 100644
index 0000000..e69de29
diff --git a/poetry-demo/poetry_demo/__init__.py b/poetry-demo/poetry_demo/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/poetry-demo/pyproject.toml b/poetry-demo/pyproject.toml
new file mode 100644
index 0000000..74074c0
--- /dev/null
+++ b/poetry-demo/pyproject.toml
@@ -0,0 +1,14 @@
+[tool.poetry]
+name = "poetry-demo"
+version = "0.1.0"
+description = ""
+authors = ["Michal Nedza <MicnedSQ@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
diff --git a/poetry-demo/tests/__init__.py b/poetry-demo/tests/__init__.py
new file mode 100644
index 0000000..e69de29

From 80d6080ece00ebd1f2a3c4c3e4fa915d2bc2c7aa Mon Sep 17 00:00:00 2001
From: Michal Nedza <MicnedSQ@gmail.com>
Date: Mon, 4 Nov 2024 21:25:59 +0100
Subject: [PATCH 5/5] Task3 done

---
 poetry.lock    | 568 +++++++++++++++++++++++++++++++++++++++++++++++++
 pyproject.toml |  15 ++
 2 files changed, 583 insertions(+)
 create mode 100644 poetry.lock
 create mode 100644 pyproject.toml

diff --git a/poetry.lock b/poetry.lock
new file mode 100644
index 0000000..ffb00b1
--- /dev/null
+++ b/poetry.lock
@@ -0,0 +1,568 @@
+# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand.
+
+[[package]]
+name = "contourpy"
+version = "1.3.0"
+description = "Python library for calculating contours of 2D quadrilateral grids"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "contourpy-1.3.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:880ea32e5c774634f9fcd46504bf9f080a41ad855f4fef54f5380f5133d343c7"},
+    {file = "contourpy-1.3.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:76c905ef940a4474a6289c71d53122a4f77766eef23c03cd57016ce19d0f7b42"},
+    {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:92f8557cbb07415a4d6fa191f20fd9d2d9eb9c0b61d1b2f52a8926e43c6e9af7"},
+    {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:36f965570cff02b874773c49bfe85562b47030805d7d8360748f3eca570f4cab"},
+    {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:cacd81e2d4b6f89c9f8a5b69b86490152ff39afc58a95af002a398273e5ce589"},
+    {file = "contourpy-1.3.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:69375194457ad0fad3a839b9e29aa0b0ed53bb54db1bfb6c3ae43d111c31ce41"},
+    {file = "contourpy-1.3.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a52040312b1a858b5e31ef28c2e865376a386c60c0e248370bbea2d3f3b760d"},
+    {file = "contourpy-1.3.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:3faeb2998e4fcb256542e8a926d08da08977f7f5e62cf733f3c211c2a5586223"},
+    {file = "contourpy-1.3.0-cp310-cp310-win32.whl", hash = "sha256:36e0cff201bcb17a0a8ecc7f454fe078437fa6bda730e695a92f2d9932bd507f"},
+    {file = "contourpy-1.3.0-cp310-cp310-win_amd64.whl", hash = "sha256:87ddffef1dbe5e669b5c2440b643d3fdd8622a348fe1983fad7a0f0ccb1cd67b"},
+    {file = "contourpy-1.3.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:0fa4c02abe6c446ba70d96ece336e621efa4aecae43eaa9b030ae5fb92b309ad"},
+    {file = "contourpy-1.3.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:834e0cfe17ba12f79963861e0f908556b2cedd52e1f75e6578801febcc6a9f49"},
+    {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:dbc4c3217eee163fa3984fd1567632b48d6dfd29216da3ded3d7b844a8014a66"},
+    {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4865cd1d419e0c7a7bf6de1777b185eebdc51470800a9f42b9e9decf17762081"},
+    {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:303c252947ab4b14c08afeb52375b26781ccd6a5ccd81abcdfc1fafd14cf93c1"},
+    {file = "contourpy-1.3.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:637f674226be46f6ba372fd29d9523dd977a291f66ab2a74fbeb5530bb3f445d"},
+    {file = "contourpy-1.3.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:76a896b2f195b57db25d6b44e7e03f221d32fe318d03ede41f8b4d9ba1bff53c"},
+    {file = "contourpy-1.3.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:e1fd23e9d01591bab45546c089ae89d926917a66dceb3abcf01f6105d927e2cb"},
+    {file = "contourpy-1.3.0-cp311-cp311-win32.whl", hash = "sha256:d402880b84df3bec6eab53cd0cf802cae6a2ef9537e70cf75e91618a3801c20c"},
+    {file = "contourpy-1.3.0-cp311-cp311-win_amd64.whl", hash = "sha256:6cb6cc968059db9c62cb35fbf70248f40994dfcd7aa10444bbf8b3faeb7c2d67"},
+    {file = "contourpy-1.3.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:570ef7cf892f0afbe5b2ee410c507ce12e15a5fa91017a0009f79f7d93a1268f"},
+    {file = "contourpy-1.3.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:da84c537cb8b97d153e9fb208c221c45605f73147bd4cadd23bdae915042aad6"},
+    {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0be4d8425bfa755e0fd76ee1e019636ccc7c29f77a7c86b4328a9eb6a26d0639"},
+    {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9c0da700bf58f6e0b65312d0a5e695179a71d0163957fa381bb3c1f72972537c"},
+    {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:eb8b141bb00fa977d9122636b16aa67d37fd40a3d8b52dd837e536d64b9a4d06"},
+    {file = "contourpy-1.3.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3634b5385c6716c258d0419c46d05c8aa7dc8cb70326c9a4fb66b69ad2b52e09"},
+    {file = "contourpy-1.3.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:0dce35502151b6bd35027ac39ba6e5a44be13a68f55735c3612c568cac3805fd"},
+    {file = "contourpy-1.3.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:aea348f053c645100612b333adc5983d87be69acdc6d77d3169c090d3b01dc35"},
+    {file = "contourpy-1.3.0-cp312-cp312-win32.whl", hash = "sha256:90f73a5116ad1ba7174341ef3ea5c3150ddf20b024b98fb0c3b29034752c8aeb"},
+    {file = "contourpy-1.3.0-cp312-cp312-win_amd64.whl", hash = "sha256:b11b39aea6be6764f84360fce6c82211a9db32a7c7de8fa6dd5397cf1d079c3b"},
+    {file = "contourpy-1.3.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:3e1c7fa44aaae40a2247e2e8e0627f4bea3dd257014764aa644f319a5f8600e3"},
+    {file = "contourpy-1.3.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:364174c2a76057feef647c802652f00953b575723062560498dc7930fc9b1cb7"},
+    {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:32b238b3b3b649e09ce9aaf51f0c261d38644bdfa35cbaf7b263457850957a84"},
+    {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d51fca85f9f7ad0b65b4b9fe800406d0d77017d7270d31ec3fb1cc07358fdea0"},
+    {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:732896af21716b29ab3e988d4ce14bc5133733b85956316fb0c56355f398099b"},
+    {file = "contourpy-1.3.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d73f659398a0904e125280836ae6f88ba9b178b2fed6884f3b1f95b989d2c8da"},
+    {file = "contourpy-1.3.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:c6c7c2408b7048082932cf4e641fa3b8ca848259212f51c8c59c45aa7ac18f14"},
+    {file = "contourpy-1.3.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f317576606de89da6b7e0861cf6061f6146ead3528acabff9236458a6ba467f8"},
+    {file = "contourpy-1.3.0-cp313-cp313-win32.whl", hash = "sha256:31cd3a85dbdf1fc002280c65caa7e2b5f65e4a973fcdf70dd2fdcb9868069294"},
+    {file = "contourpy-1.3.0-cp313-cp313-win_amd64.whl", hash = "sha256:4553c421929ec95fb07b3aaca0fae668b2eb5a5203d1217ca7c34c063c53d087"},
+    {file = "contourpy-1.3.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:345af746d7766821d05d72cb8f3845dfd08dd137101a2cb9b24de277d716def8"},
+    {file = "contourpy-1.3.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:3bb3808858a9dc68f6f03d319acd5f1b8a337e6cdda197f02f4b8ff67ad2057b"},
+    {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:420d39daa61aab1221567b42eecb01112908b2cab7f1b4106a52caaec8d36973"},
+    {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:4d63ee447261e963af02642ffcb864e5a2ee4cbfd78080657a9880b8b1868e18"},
+    {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:167d6c890815e1dac9536dca00828b445d5d0df4d6a8c6adb4a7ec3166812fa8"},
+    {file = "contourpy-1.3.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:710a26b3dc80c0e4febf04555de66f5fd17e9cf7170a7b08000601a10570bda6"},
+    {file = "contourpy-1.3.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:75ee7cb1a14c617f34a51d11fa7524173e56551646828353c4af859c56b766e2"},
+    {file = "contourpy-1.3.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:33c92cdae89ec5135d036e7218e69b0bb2851206077251f04a6c4e0e21f03927"},
+    {file = "contourpy-1.3.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:a11077e395f67ffc2c44ec2418cfebed032cd6da3022a94fc227b6faf8e2acb8"},
+    {file = "contourpy-1.3.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e8134301d7e204c88ed7ab50028ba06c683000040ede1d617298611f9dc6240c"},
+    {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e12968fdfd5bb45ffdf6192a590bd8ddd3ba9e58360b29683c6bb71a7b41edca"},
+    {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fd2a0fc506eccaaa7595b7e1418951f213cf8255be2600f1ea1b61e46a60c55f"},
+    {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:4cfb5c62ce023dfc410d6059c936dcf96442ba40814aefbfa575425a3a7f19dc"},
+    {file = "contourpy-1.3.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:68a32389b06b82c2fdd68276148d7b9275b5f5cf13e5417e4252f6d1a34f72a2"},
+    {file = "contourpy-1.3.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:94e848a6b83da10898cbf1311a815f770acc9b6a3f2d646f330d57eb4e87592e"},
+    {file = "contourpy-1.3.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d78ab28a03c854a873787a0a42254a0ccb3cb133c672f645c9f9c8f3ae9d0800"},
+    {file = "contourpy-1.3.0-cp39-cp39-win32.whl", hash = "sha256:81cb5ed4952aae6014bc9d0421dec7c5835c9c8c31cdf51910b708f548cf58e5"},
+    {file = "contourpy-1.3.0-cp39-cp39-win_amd64.whl", hash = "sha256:14e262f67bd7e6eb6880bc564dcda30b15e351a594657e55b7eec94b6ef72843"},
+    {file = "contourpy-1.3.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:fe41b41505a5a33aeaed2a613dccaeaa74e0e3ead6dd6fd3a118fb471644fd6c"},
+    {file = "contourpy-1.3.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eca7e17a65f72a5133bdbec9ecf22401c62bcf4821361ef7811faee695799779"},
+    {file = "contourpy-1.3.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:1ec4dc6bf570f5b22ed0d7efba0dfa9c5b9e0431aeea7581aa217542d9e809a4"},
+    {file = "contourpy-1.3.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:00ccd0dbaad6d804ab259820fa7cb0b8036bda0686ef844d24125d8287178ce0"},
+    {file = "contourpy-1.3.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8ca947601224119117f7c19c9cdf6b3ab54c5726ef1d906aa4a69dfb6dd58102"},
+    {file = "contourpy-1.3.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:c6ec93afeb848a0845a18989da3beca3eec2c0f852322efe21af1931147d12cb"},
+    {file = "contourpy-1.3.0.tar.gz", hash = "sha256:7ffa0db17717a8ffb127efd0c95a4362d996b892c2904db72428d5b52e1938a4"},
+]
+
+[package.dependencies]
+numpy = ">=1.23"
+
+[package.extras]
+bokeh = ["bokeh", "selenium"]
+docs = ["furo", "sphinx (>=7.2)", "sphinx-copybutton"]
+mypy = ["contourpy[bokeh,docs]", "docutils-stubs", "mypy (==1.11.1)", "types-Pillow"]
+test = ["Pillow", "contourpy[test-no-images]", "matplotlib"]
+test-no-images = ["pytest", "pytest-cov", "pytest-rerunfailures", "pytest-xdist", "wurlitzer"]
+
+[[package]]
+name = "cycler"
+version = "0.12.1"
+description = "Composable style cycles"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "cycler-0.12.1-py3-none-any.whl", hash = "sha256:85cef7cff222d8644161529808465972e51340599459b8ac3ccbac5a854e0d30"},
+    {file = "cycler-0.12.1.tar.gz", hash = "sha256:88bb128f02ba341da8ef447245a9e138fae777f6a23943da4540077d3601eb1c"},
+]
+
+[package.extras]
+docs = ["ipython", "matplotlib", "numpydoc", "sphinx"]
+tests = ["pytest", "pytest-cov", "pytest-xdist"]
+
+[[package]]
+name = "fonttools"
+version = "4.54.1"
+description = "Tools to manipulate font files"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "fonttools-4.54.1-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7ed7ee041ff7b34cc62f07545e55e1468808691dddfd315d51dd82a6b37ddef2"},
+    {file = "fonttools-4.54.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:41bb0b250c8132b2fcac148e2e9198e62ff06f3cc472065dff839327945c5882"},
+    {file = "fonttools-4.54.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:7965af9b67dd546e52afcf2e38641b5be956d68c425bef2158e95af11d229f10"},
+    {file = "fonttools-4.54.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:278913a168f90d53378c20c23b80f4e599dca62fbffae4cc620c8eed476b723e"},
+    {file = "fonttools-4.54.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:0e88e3018ac809b9662615072dcd6b84dca4c2d991c6d66e1970a112503bba7e"},
+    {file = "fonttools-4.54.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:4aa4817f0031206e637d1e685251ac61be64d1adef111060df84fdcbc6ab6c44"},
+    {file = "fonttools-4.54.1-cp310-cp310-win32.whl", hash = "sha256:7e3b7d44e18c085fd8c16dcc6f1ad6c61b71ff463636fcb13df7b1b818bd0c02"},
+    {file = "fonttools-4.54.1-cp310-cp310-win_amd64.whl", hash = "sha256:dd9cc95b8d6e27d01e1e1f1fae8559ef3c02c76317da650a19047f249acd519d"},
+    {file = "fonttools-4.54.1-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:5419771b64248484299fa77689d4f3aeed643ea6630b2ea750eeab219588ba20"},
+    {file = "fonttools-4.54.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:301540e89cf4ce89d462eb23a89464fef50915255ece765d10eee8b2bf9d75b2"},
+    {file = "fonttools-4.54.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:76ae5091547e74e7efecc3cbf8e75200bc92daaeb88e5433c5e3e95ea8ce5aa7"},
+    {file = "fonttools-4.54.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82834962b3d7c5ca98cb56001c33cf20eb110ecf442725dc5fdf36d16ed1ab07"},
+    {file = "fonttools-4.54.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:d26732ae002cc3d2ecab04897bb02ae3f11f06dd7575d1df46acd2f7c012a8d8"},
+    {file = "fonttools-4.54.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:58974b4987b2a71ee08ade1e7f47f410c367cdfc5a94fabd599c88165f56213a"},
+    {file = "fonttools-4.54.1-cp311-cp311-win32.whl", hash = "sha256:ab774fa225238986218a463f3fe151e04d8c25d7de09df7f0f5fce27b1243dbc"},
+    {file = "fonttools-4.54.1-cp311-cp311-win_amd64.whl", hash = "sha256:07e005dc454eee1cc60105d6a29593459a06321c21897f769a281ff2d08939f6"},
+    {file = "fonttools-4.54.1-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:54471032f7cb5fca694b5f1a0aaeba4af6e10ae989df408e0216f7fd6cdc405d"},
+    {file = "fonttools-4.54.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8fa92cb248e573daab8d032919623cc309c005086d743afb014c836636166f08"},
+    {file = "fonttools-4.54.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0a911591200114969befa7f2cb74ac148bce5a91df5645443371aba6d222e263"},
+    {file = "fonttools-4.54.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:93d458c8a6a354dc8b48fc78d66d2a8a90b941f7fec30e94c7ad9982b1fa6bab"},
+    {file = "fonttools-4.54.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:5eb2474a7c5be8a5331146758debb2669bf5635c021aee00fd7c353558fc659d"},
+    {file = "fonttools-4.54.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c9c563351ddc230725c4bdf7d9e1e92cbe6ae8553942bd1fb2b2ff0884e8b714"},
+    {file = "fonttools-4.54.1-cp312-cp312-win32.whl", hash = "sha256:fdb062893fd6d47b527d39346e0c5578b7957dcea6d6a3b6794569370013d9ac"},
+    {file = "fonttools-4.54.1-cp312-cp312-win_amd64.whl", hash = "sha256:e4564cf40cebcb53f3dc825e85910bf54835e8a8b6880d59e5159f0f325e637e"},
+    {file = "fonttools-4.54.1-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:6e37561751b017cf5c40fce0d90fd9e8274716de327ec4ffb0df957160be3bff"},
+    {file = "fonttools-4.54.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:357cacb988a18aace66e5e55fe1247f2ee706e01debc4b1a20d77400354cddeb"},
+    {file = "fonttools-4.54.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f8e953cc0bddc2beaf3a3c3b5dd9ab7554677da72dfaf46951e193c9653e515a"},
+    {file = "fonttools-4.54.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:58d29b9a294573d8319f16f2f79e42428ba9b6480442fa1836e4eb89c4d9d61c"},
+    {file = "fonttools-4.54.1-cp313-cp313-win32.whl", hash = "sha256:9ef1b167e22709b46bf8168368b7b5d3efeaaa746c6d39661c1b4405b6352e58"},
+    {file = "fonttools-4.54.1-cp313-cp313-win_amd64.whl", hash = "sha256:262705b1663f18c04250bd1242b0515d3bbae177bee7752be67c979b7d47f43d"},
+    {file = "fonttools-4.54.1-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:ed2f80ca07025551636c555dec2b755dd005e2ea8fbeb99fc5cdff319b70b23b"},
+    {file = "fonttools-4.54.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:9dc080e5a1c3b2656caff2ac2633d009b3a9ff7b5e93d0452f40cd76d3da3b3c"},
+    {file = "fonttools-4.54.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d152d1be65652fc65e695e5619e0aa0982295a95a9b29b52b85775243c06556"},
+    {file = "fonttools-4.54.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8583e563df41fdecef31b793b4dd3af8a9caa03397be648945ad32717a92885b"},
+    {file = "fonttools-4.54.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:0d1d353ef198c422515a3e974a1e8d5b304cd54a4c2eebcae708e37cd9eeffb1"},
+    {file = "fonttools-4.54.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:fda582236fee135d4daeca056c8c88ec5f6f6d88a004a79b84a02547c8f57386"},
+    {file = "fonttools-4.54.1-cp38-cp38-win32.whl", hash = "sha256:e7d82b9e56716ed32574ee106cabca80992e6bbdcf25a88d97d21f73a0aae664"},
+    {file = "fonttools-4.54.1-cp38-cp38-win_amd64.whl", hash = "sha256:ada215fd079e23e060157aab12eba0d66704316547f334eee9ff26f8c0d7b8ab"},
+    {file = "fonttools-4.54.1-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:f5b8a096e649768c2f4233f947cf9737f8dbf8728b90e2771e2497c6e3d21d13"},
+    {file = "fonttools-4.54.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:4e10d2e0a12e18f4e2dd031e1bf7c3d7017be5c8dbe524d07706179f355c5dac"},
+    {file = "fonttools-4.54.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:31c32d7d4b0958600eac75eaf524b7b7cb68d3a8c196635252b7a2c30d80e986"},
+    {file = "fonttools-4.54.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c39287f5c8f4a0c5a55daf9eaf9ccd223ea59eed3f6d467133cc727d7b943a55"},
+    {file = "fonttools-4.54.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:a7a310c6e0471602fe3bf8efaf193d396ea561486aeaa7adc1f132e02d30c4b9"},
+    {file = "fonttools-4.54.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:d3b659d1029946f4ff9b6183984578041b520ce0f8fb7078bb37ec7445806b33"},
+    {file = "fonttools-4.54.1-cp39-cp39-win32.whl", hash = "sha256:e96bc94c8cda58f577277d4a71f51c8e2129b8b36fd05adece6320dd3d57de8a"},
+    {file = "fonttools-4.54.1-cp39-cp39-win_amd64.whl", hash = "sha256:e8a4b261c1ef91e7188a30571be6ad98d1c6d9fa2427244c545e2fa0a2494dd7"},
+    {file = "fonttools-4.54.1-py3-none-any.whl", hash = "sha256:37cddd62d83dc4f72f7c3f3c2bcf2697e89a30efb152079896544a93907733bd"},
+    {file = "fonttools-4.54.1.tar.gz", hash = "sha256:957f669d4922f92c171ba01bef7f29410668db09f6c02111e22b2bce446f3285"},
+]
+
+[package.extras]
+all = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "fs (>=2.2.0,<3)", "lxml (>=4.0)", "lz4 (>=1.7.4.2)", "matplotlib", "munkres", "pycairo", "scipy", "skia-pathops (>=0.5.0)", "sympy", "uharfbuzz (>=0.23.0)", "unicodedata2 (>=15.1.0)", "xattr", "zopfli (>=0.1.4)"]
+graphite = ["lz4 (>=1.7.4.2)"]
+interpolatable = ["munkres", "pycairo", "scipy"]
+lxml = ["lxml (>=4.0)"]
+pathops = ["skia-pathops (>=0.5.0)"]
+plot = ["matplotlib"]
+repacker = ["uharfbuzz (>=0.23.0)"]
+symfont = ["sympy"]
+type1 = ["xattr"]
+ufo = ["fs (>=2.2.0,<3)"]
+unicode = ["unicodedata2 (>=15.1.0)"]
+woff = ["brotli (>=1.0.1)", "brotlicffi (>=0.8.0)", "zopfli (>=0.1.4)"]
+
+[[package]]
+name = "kiwisolver"
+version = "1.4.7"
+description = "A fast implementation of the Cassowary constraint solver"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:8a9c83f75223d5e48b0bc9cb1bf2776cf01563e00ade8775ffe13b0b6e1af3a6"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:58370b1ffbd35407444d57057b57da5d6549d2d854fa30249771775c63b5fe17"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:aa0abdf853e09aff551db11fce173e2177d00786c688203f52c87ad7fcd91ef9"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:8d53103597a252fb3ab8b5845af04c7a26d5e7ea8122303dd7a021176a87e8b9"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:88f17c5ffa8e9462fb79f62746428dd57b46eb931698e42e990ad63103f35e6c"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:88a9ca9c710d598fd75ee5de59d5bda2684d9db36a9f50b6125eaea3969c2599"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f4d742cb7af1c28303a51b7a27aaee540e71bb8e24f68c736f6f2ffc82f2bf05"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:e28c7fea2196bf4c2f8d46a0415c77a1c480cc0724722f23d7410ffe9842c407"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:e968b84db54f9d42046cf154e02911e39c0435c9801681e3fc9ce8a3c4130278"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:0c18ec74c0472de033e1bebb2911c3c310eef5649133dd0bedf2a169a1b269e5"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8f0ea6da6d393d8b2e187e6a5e3fb81f5862010a40c3945e2c6d12ae45cfb2ad"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:f106407dda69ae456dd1227966bf445b157ccc80ba0dff3802bb63f30b74e895"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:84ec80df401cfee1457063732d90022f93951944b5b58975d34ab56bb150dfb3"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-win32.whl", hash = "sha256:71bb308552200fb2c195e35ef05de12f0c878c07fc91c270eb3d6e41698c3bcc"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-win_amd64.whl", hash = "sha256:44756f9fd339de0fb6ee4f8c1696cfd19b2422e0d70b4cefc1cc7f1f64045a8c"},
+    {file = "kiwisolver-1.4.7-cp310-cp310-win_arm64.whl", hash = "sha256:78a42513018c41c2ffd262eb676442315cbfe3c44eed82385c2ed043bc63210a"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:d2b0e12a42fb4e72d509fc994713d099cbb15ebf1103545e8a45f14da2dfca54"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:2a8781ac3edc42ea4b90bc23e7d37b665d89423818e26eb6df90698aa2287c95"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:46707a10836894b559e04b0fd143e343945c97fd170d69a2d26d640b4e297935"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ef97b8df011141c9b0f6caf23b29379f87dd13183c978a30a3c546d2c47314cb"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:3ab58c12a2cd0fc769089e6d38466c46d7f76aced0a1f54c77652446733d2d02"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:803b8e1459341c1bb56d1c5c010406d5edec8a0713a0945851290a7930679b51"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f9a9e8a507420fe35992ee9ecb302dab68550dedc0da9e2880dd88071c5fb052"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:18077b53dc3bb490e330669a99920c5e6a496889ae8c63b58fbc57c3d7f33a18"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6af936f79086a89b3680a280c47ea90b4df7047b5bdf3aa5c524bbedddb9e545"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:3abc5b19d24af4b77d1598a585b8a719beb8569a71568b66f4ebe1fb0449460b"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:933d4de052939d90afbe6e9d5273ae05fb836cc86c15b686edd4b3560cc0ee36"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:65e720d2ab2b53f1f72fb5da5fb477455905ce2c88aaa671ff0a447c2c80e8e3"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:3bf1ed55088f214ba6427484c59553123fdd9b218a42bbc8c6496d6754b1e523"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-win32.whl", hash = "sha256:4c00336b9dd5ad96d0a558fd18a8b6f711b7449acce4c157e7343ba92dd0cf3d"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-win_amd64.whl", hash = "sha256:929e294c1ac1e9f615c62a4e4313ca1823ba37326c164ec720a803287c4c499b"},
+    {file = "kiwisolver-1.4.7-cp311-cp311-win_arm64.whl", hash = "sha256:e33e8fbd440c917106b237ef1a2f1449dfbb9b6f6e1ce17c94cd6a1e0d438376"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_universal2.whl", hash = "sha256:5360cc32706dab3931f738d3079652d20982511f7c0ac5711483e6eab08efff2"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:942216596dc64ddb25adb215c3c783215b23626f8d84e8eff8d6d45c3f29f75a"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:48b571ecd8bae15702e4f22d3ff6a0f13e54d3d00cd25216d5e7f658242065ee"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ad42ba922c67c5f219097b28fae965e10045ddf145d2928bfac2eb2e17673640"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:612a10bdae23404a72941a0fc8fa2660c6ea1217c4ce0dbcab8a8f6543ea9e7f"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9e838bba3a3bac0fe06d849d29772eb1afb9745a59710762e4ba3f4cb8424483"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:22f499f6157236c19f4bbbd472fa55b063db77a16cd74d49afe28992dff8c258"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:693902d433cf585133699972b6d7c42a8b9f8f826ebcaf0132ff55200afc599e"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:4e77f2126c3e0b0d055f44513ed349038ac180371ed9b52fe96a32aa071a5107"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:657a05857bda581c3656bfc3b20e353c232e9193eb167766ad2dc58b56504948"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:4bfa75a048c056a411f9705856abfc872558e33c055d80af6a380e3658766038"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:34ea1de54beef1c104422d210c47c7d2a4999bdecf42c7b5718fbe59a4cac383"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:90da3b5f694b85231cf93586dad5e90e2d71b9428f9aad96952c99055582f520"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-win32.whl", hash = "sha256:18e0cca3e008e17fe9b164b55735a325140a5a35faad8de92dd80265cd5eb80b"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-win_amd64.whl", hash = "sha256:58cb20602b18f86f83a5c87d3ee1c766a79c0d452f8def86d925e6c60fbf7bfb"},
+    {file = "kiwisolver-1.4.7-cp312-cp312-win_arm64.whl", hash = "sha256:f5a8b53bdc0b3961f8b6125e198617c40aeed638b387913bf1ce78afb1b0be2a"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:2e6039dcbe79a8e0f044f1c39db1986a1b8071051efba3ee4d74f5b365f5226e"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a1ecf0ac1c518487d9d23b1cd7139a6a65bc460cd101ab01f1be82ecf09794b6"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7ab9ccab2b5bd5702ab0803676a580fffa2aa178c2badc5557a84cc943fcf750"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f816dd2277f8d63d79f9c8473a79fe54047bc0467754962840782c575522224d"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cf8bcc23ceb5a1b624572a1623b9f79d2c3b337c8c455405ef231933a10da379"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:dea0bf229319828467d7fca8c7c189780aa9ff679c94539eed7532ebe33ed37c"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7c06a4c7cf15ec739ce0e5971b26c93638730090add60e183530d70848ebdd34"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:913983ad2deb14e66d83c28b632fd35ba2b825031f2fa4ca29675e665dfecbe1"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:5337ec7809bcd0f424c6b705ecf97941c46279cf5ed92311782c7c9c2026f07f"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:4c26ed10c4f6fa6ddb329a5120ba3b6db349ca192ae211e882970bfc9d91420b"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:c619b101e6de2222c1fcb0531e1b17bbffbe54294bfba43ea0d411d428618c27"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:073a36c8273647592ea332e816e75ef8da5c303236ec0167196793eb1e34657a"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3ce6b2b0231bda412463e152fc18335ba32faf4e8c23a754ad50ffa70e4091ee"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-win32.whl", hash = "sha256:f4c9aee212bc89d4e13f58be11a56cc8036cabad119259d12ace14b34476fd07"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-win_amd64.whl", hash = "sha256:8a3ec5aa8e38fc4c8af308917ce12c536f1c88452ce554027e55b22cbbfbff76"},
+    {file = "kiwisolver-1.4.7-cp313-cp313-win_arm64.whl", hash = "sha256:76c8094ac20ec259471ac53e774623eb62e6e1f56cd8690c67ce6ce4fcb05650"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:5d5abf8f8ec1f4e22882273c423e16cae834c36856cac348cfbfa68e01c40f3a"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:aeb3531b196ef6f11776c21674dba836aeea9d5bd1cf630f869e3d90b16cfade"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b7d755065e4e866a8086c9bdada157133ff466476a2ad7861828e17b6026e22c"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:08471d4d86cbaec61f86b217dd938a83d85e03785f51121e791a6e6689a3be95"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:7bbfcb7165ce3d54a3dfbe731e470f65739c4c1f85bb1018ee912bae139e263b"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5d34eb8494bea691a1a450141ebb5385e4b69d38bb8403b5146ad279f4b30fa3"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:9242795d174daa40105c1d86aba618e8eab7bf96ba8c3ee614da8302a9f95503"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.whl", hash = "sha256:a0f64a48bb81af7450e641e3fe0b0394d7381e342805479178b3d335d60ca7cf"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:8e045731a5416357638d1700927529e2b8ab304811671f665b225f8bf8d8f933"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:4322872d5772cae7369f8351da1edf255a604ea7087fe295411397d0cfd9655e"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:e1631290ee9271dffe3062d2634c3ecac02c83890ada077d225e081aca8aab89"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:edcfc407e4eb17e037bca59be0e85a2031a2ac87e4fed26d3e9df88b4165f92d"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:4d05d81ecb47d11e7f8932bd8b61b720bf0b41199358f3f5e36d38e28f0532c5"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-win32.whl", hash = "sha256:b38ac83d5f04b15e515fd86f312479d950d05ce2368d5413d46c088dda7de90a"},
+    {file = "kiwisolver-1.4.7-cp38-cp38-win_amd64.whl", hash = "sha256:d83db7cde68459fc803052a55ace60bea2bae361fc3b7a6d5da07e11954e4b09"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:3f9362ecfca44c863569d3d3c033dbe8ba452ff8eed6f6b5806382741a1334bd"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:e8df2eb9b2bac43ef8b082e06f750350fbbaf2887534a5be97f6cf07b19d9583"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:f32d6edbc638cde7652bd690c3e728b25332acbadd7cad670cc4a02558d9c417"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:e2e6c39bd7b9372b0be21456caab138e8e69cc0fc1190a9dfa92bd45a1e6e904"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:dda56c24d869b1193fcc763f1284b9126550eaf84b88bbc7256e15028f19188a"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:79849239c39b5e1fd906556c474d9b0439ea6792b637511f3fe3a41158d89ca8"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:5e3bc157fed2a4c02ec468de4ecd12a6e22818d4f09cde2c31ee3226ffbefab2"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:3da53da805b71e41053dc670f9a820d1157aae77b6b944e08024d17bcd51ef88"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:8705f17dfeb43139a692298cb6637ee2e59c0194538153e83e9ee0c75c2eddde"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:82a5c2f4b87c26bb1a0ef3d16b5c4753434633b83d365cc0ddf2770c93829e3c"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:ce8be0466f4c0d585cdb6c1e2ed07232221df101a4c6f28821d2aa754ca2d9e2"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:409afdfe1e2e90e6ee7fc896f3df9a7fec8e793e58bfa0d052c8a82f99c37abb"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5b9c3f4ee0b9a439d2415012bd1b1cc2df59e4d6a9939f4d669241d30b414327"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-win32.whl", hash = "sha256:a79ae34384df2b615eefca647a2873842ac3b596418032bef9a7283675962644"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-win_amd64.whl", hash = "sha256:cf0438b42121a66a3a667de17e779330fc0f20b0d97d59d2f2121e182b0505e4"},
+    {file = "kiwisolver-1.4.7-cp39-cp39-win_arm64.whl", hash = "sha256:764202cc7e70f767dab49e8df52c7455e8de0df5d858fa801a11aa0d882ccf3f"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:94252291e3fe68001b1dd747b4c0b3be12582839b95ad4d1b641924d68fd4643"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:5b7dfa3b546da08a9f622bb6becdb14b3e24aaa30adba66749d38f3cc7ea9706"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:bd3de6481f4ed8b734da5df134cd5a6a64fe32124fe83dde1e5b5f29fe30b1e6"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a91b5f9f1205845d488c928e8570dcb62b893372f63b8b6e98b863ebd2368ff2"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:40fa14dbd66b8b8f470d5fc79c089a66185619d31645f9b0773b88b19f7223c4"},
+    {file = "kiwisolver-1.4.7-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:eb542fe7933aa09d8d8f9d9097ef37532a7df6497819d16efe4359890a2f417a"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_10_9_x86_64.whl", hash = "sha256:bfa1acfa0c54932d5607e19a2c24646fb4c1ae2694437789129cf099789a3b00"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-macosx_11_0_arm64.whl", hash = "sha256:eee3ea935c3d227d49b4eb85660ff631556841f6e567f0f7bda972df6c2c9935"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_i686.manylinux2010_i686.whl", hash = "sha256:f3160309af4396e0ed04db259c3ccbfdc3621b5559b5453075e5de555e1f3a1b"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_12_x86_64.manylinux2010_x86_64.whl", hash = "sha256:a17f6a29cf8935e587cc8a4dbfc8368c55edc645283db0ce9801016f83526c2d"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:10849fb2c1ecbfae45a693c070e0320a91b35dd4bcf58172c023b994283a124d"},
+    {file = "kiwisolver-1.4.7-pp38-pypy38_pp73-win_amd64.whl", hash = "sha256:ac542bf38a8a4be2dc6b15248d36315ccc65f0743f7b1a76688ffb6b5129a5c2"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:8b01aac285f91ca889c800042c35ad3b239e704b150cfd3382adfc9dcc780e39"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:48be928f59a1f5c8207154f935334d374e79f2b5d212826307d072595ad76a2e"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f37cfe618a117e50d8c240555331160d73d0411422b59b5ee217843d7b693608"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:599b5c873c63a1f6ed7eead644a8a380cfbdf5db91dcb6f85707aaab213b1674"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:801fa7802e5cfabe3ab0c81a34c323a319b097dfb5004be950482d882f3d7225"},
+    {file = "kiwisolver-1.4.7-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:0c6c43471bc764fad4bc99c5c2d6d16a676b1abf844ca7c8702bdae92df01ee0"},
+    {file = "kiwisolver-1.4.7.tar.gz", hash = "sha256:9893ff81bd7107f7b685d3017cc6583daadb4fc26e4a888350df530e41980a60"},
+]
+
+[[package]]
+name = "matplotlib"
+version = "3.9.2"
+description = "Python plotting package"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "matplotlib-3.9.2-cp310-cp310-macosx_10_12_x86_64.whl", hash = "sha256:9d78bbc0cbc891ad55b4f39a48c22182e9bdaea7fc0e5dbd364f49f729ca1bbb"},
+    {file = "matplotlib-3.9.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:c375cc72229614632c87355366bdf2570c2dac01ac66b8ad048d2dabadf2d0d4"},
+    {file = "matplotlib-3.9.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1d94ff717eb2bd0b58fe66380bd8b14ac35f48a98e7c6765117fe67fb7684e64"},
+    {file = "matplotlib-3.9.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ab68d50c06938ef28681073327795c5db99bb4666214d2d5f880ed11aeaded66"},
+    {file = "matplotlib-3.9.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:65aacf95b62272d568044531e41de26285d54aec8cb859031f511f84bd8b495a"},
+    {file = "matplotlib-3.9.2-cp310-cp310-win_amd64.whl", hash = "sha256:3fd595f34aa8a55b7fc8bf9ebea8aa665a84c82d275190a61118d33fbc82ccae"},
+    {file = "matplotlib-3.9.2-cp311-cp311-macosx_10_12_x86_64.whl", hash = "sha256:d8dd059447824eec055e829258ab092b56bb0579fc3164fa09c64f3acd478772"},
+    {file = "matplotlib-3.9.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c797dac8bb9c7a3fd3382b16fe8f215b4cf0f22adccea36f1545a6d7be310b41"},
+    {file = "matplotlib-3.9.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d719465db13267bcef19ea8954a971db03b9f48b4647e3860e4bc8e6ed86610f"},
+    {file = "matplotlib-3.9.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8912ef7c2362f7193b5819d17dae8629b34a95c58603d781329712ada83f9447"},
+    {file = "matplotlib-3.9.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7741f26a58a240f43bee74965c4882b6c93df3e7eb3de160126d8c8f53a6ae6e"},
+    {file = "matplotlib-3.9.2-cp311-cp311-win_amd64.whl", hash = "sha256:ae82a14dab96fbfad7965403c643cafe6515e386de723e498cf3eeb1e0b70cc7"},
+    {file = "matplotlib-3.9.2-cp312-cp312-macosx_10_12_x86_64.whl", hash = "sha256:ac43031375a65c3196bee99f6001e7fa5bdfb00ddf43379d3c0609bdca042df9"},
+    {file = "matplotlib-3.9.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:be0fc24a5e4531ae4d8e858a1a548c1fe33b176bb13eff7f9d0d38ce5112a27d"},
+    {file = "matplotlib-3.9.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:bf81de2926c2db243c9b2cbc3917619a0fc85796c6ba4e58f541df814bbf83c7"},
+    {file = "matplotlib-3.9.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f6ee45bc4245533111ced13f1f2cace1e7f89d1c793390392a80c139d6cf0e6c"},
+    {file = "matplotlib-3.9.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:306c8dfc73239f0e72ac50e5a9cf19cc4e8e331dd0c54f5e69ca8758550f1e1e"},
+    {file = "matplotlib-3.9.2-cp312-cp312-win_amd64.whl", hash = "sha256:5413401594cfaff0052f9d8b1aafc6d305b4bd7c4331dccd18f561ff7e1d3bd3"},
+    {file = "matplotlib-3.9.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:18128cc08f0d3cfff10b76baa2f296fc28c4607368a8402de61bb3f2eb33c7d9"},
+    {file = "matplotlib-3.9.2-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:4876d7d40219e8ae8bb70f9263bcbe5714415acfdf781086601211335e24f8aa"},
+    {file = "matplotlib-3.9.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6d9f07a80deab4bb0b82858a9e9ad53d1382fd122be8cde11080f4e7dfedb38b"},
+    {file = "matplotlib-3.9.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f7c0410f181a531ec4e93bbc27692f2c71a15c2da16766f5ba9761e7ae518413"},
+    {file = "matplotlib-3.9.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:909645cce2dc28b735674ce0931a4ac94e12f5b13f6bb0b5a5e65e7cea2c192b"},
+    {file = "matplotlib-3.9.2-cp313-cp313-win_amd64.whl", hash = "sha256:f32c7410c7f246838a77d6d1eff0c0f87f3cb0e7c4247aebea71a6d5a68cab49"},
+    {file = "matplotlib-3.9.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:37e51dd1c2db16ede9cfd7b5cabdfc818b2c6397c83f8b10e0e797501c963a03"},
+    {file = "matplotlib-3.9.2-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:b82c5045cebcecd8496a4d694d43f9cc84aeeb49fe2133e036b207abe73f4d30"},
+    {file = "matplotlib-3.9.2-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:f053c40f94bc51bc03832a41b4f153d83f2062d88c72b5e79997072594e97e51"},
+    {file = "matplotlib-3.9.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dbe196377a8248972f5cede786d4c5508ed5f5ca4a1e09b44bda889958b33f8c"},
+    {file = "matplotlib-3.9.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5816b1e1fe8c192cbc013f8f3e3368ac56fbecf02fb41b8f8559303f24c5015e"},
+    {file = "matplotlib-3.9.2-cp39-cp39-macosx_10_12_x86_64.whl", hash = "sha256:cef2a73d06601437be399908cf13aee74e86932a5ccc6ccdf173408ebc5f6bb2"},
+    {file = "matplotlib-3.9.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:e0830e188029c14e891fadd99702fd90d317df294c3298aad682739c5533721a"},
+    {file = "matplotlib-3.9.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:03ba9c1299c920964e8d3857ba27173b4dbb51ca4bab47ffc2c2ba0eb5e2cbc5"},
+    {file = "matplotlib-3.9.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1cd93b91ab47a3616b4d3c42b52f8363b88ca021e340804c6ab2536344fad9ca"},
+    {file = "matplotlib-3.9.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:6d1ce5ed2aefcdce11904fc5bbea7d9c21fff3d5f543841edf3dea84451a09ea"},
+    {file = "matplotlib-3.9.2-cp39-cp39-win_amd64.whl", hash = "sha256:b2696efdc08648536efd4e1601b5fd491fd47f4db97a5fbfd175549a7365c1b2"},
+    {file = "matplotlib-3.9.2-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:d52a3b618cb1cbb769ce2ee1dcdb333c3ab6e823944e9a2d36e37253815f9556"},
+    {file = "matplotlib-3.9.2-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:039082812cacd6c6bec8e17a9c1e6baca230d4116d522e81e1f63a74d01d2e21"},
+    {file = "matplotlib-3.9.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6758baae2ed64f2331d4fd19be38b7b4eae3ecec210049a26b6a4f3ae1c85dcc"},
+    {file = "matplotlib-3.9.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:050598c2b29e0b9832cde72bcf97627bf00262adbc4a54e2b856426bb2ef0697"},
+    {file = "matplotlib-3.9.2.tar.gz", hash = "sha256:96ab43906269ca64a6366934106fa01534454a69e471b7bf3d79083981aaab92"},
+]
+
+[package.dependencies]
+contourpy = ">=1.0.1"
+cycler = ">=0.10"
+fonttools = ">=4.22.0"
+kiwisolver = ">=1.3.1"
+numpy = ">=1.23"
+packaging = ">=20.0"
+pillow = ">=8"
+pyparsing = ">=2.3.1"
+python-dateutil = ">=2.7"
+
+[package.extras]
+dev = ["meson-python (>=0.13.1)", "numpy (>=1.25)", "pybind11 (>=2.6)", "setuptools (>=64)", "setuptools_scm (>=7)"]
+
+[[package]]
+name = "numpy"
+version = "2.1.3"
+description = "Fundamental package for array computing in Python"
+optional = false
+python-versions = ">=3.10"
+files = [
+    {file = "numpy-2.1.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:c894b4305373b9c5576d7a12b473702afdf48ce5369c074ba304cc5ad8730dff"},
+    {file = "numpy-2.1.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b47fbb433d3260adcd51eb54f92a2ffbc90a4595f8970ee00e064c644ac788f5"},
+    {file = "numpy-2.1.3-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:825656d0743699c529c5943554d223c021ff0494ff1442152ce887ef4f7561a1"},
+    {file = "numpy-2.1.3-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:6a4825252fcc430a182ac4dee5a505053d262c807f8a924603d411f6718b88fd"},
+    {file = "numpy-2.1.3-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e711e02f49e176a01d0349d82cb5f05ba4db7d5e7e0defd026328e5cfb3226d3"},
+    {file = "numpy-2.1.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78574ac2d1a4a02421f25da9559850d59457bac82f2b8d7a44fe83a64f770098"},
+    {file = "numpy-2.1.3-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:c7662f0e3673fe4e832fe07b65c50342ea27d989f92c80355658c7f888fcc83c"},
+    {file = "numpy-2.1.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:fa2d1337dc61c8dc417fbccf20f6d1e139896a30721b7f1e832b2bb6ef4eb6c4"},
+    {file = "numpy-2.1.3-cp310-cp310-win32.whl", hash = "sha256:72dcc4a35a8515d83e76b58fdf8113a5c969ccd505c8a946759b24e3182d1f23"},
+    {file = "numpy-2.1.3-cp310-cp310-win_amd64.whl", hash = "sha256:ecc76a9ba2911d8d37ac01de72834d8849e55473457558e12995f4cd53e778e0"},
+    {file = "numpy-2.1.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:4d1167c53b93f1f5d8a139a742b3c6f4d429b54e74e6b57d0eff40045187b15d"},
+    {file = "numpy-2.1.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:c80e4a09b3d95b4e1cac08643f1152fa71a0a821a2d4277334c88d54b2219a41"},
+    {file = "numpy-2.1.3-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:576a1c1d25e9e02ed7fa5477f30a127fe56debd53b8d2c89d5578f9857d03ca9"},
+    {file = "numpy-2.1.3-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:973faafebaae4c0aaa1a1ca1ce02434554d67e628b8d805e61f874b84e136b09"},
+    {file = "numpy-2.1.3-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:762479be47a4863e261a840e8e01608d124ee1361e48b96916f38b119cfda04a"},
+    {file = "numpy-2.1.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:bc6f24b3d1ecc1eebfbf5d6051faa49af40b03be1aaa781ebdadcbc090b4539b"},
+    {file = "numpy-2.1.3-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:17ee83a1f4fef3c94d16dc1802b998668b5419362c8a4f4e8a491de1b41cc3ee"},
+    {file = "numpy-2.1.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:15cb89f39fa6d0bdfb600ea24b250e5f1a3df23f901f51c8debaa6a5d122b2f0"},
+    {file = "numpy-2.1.3-cp311-cp311-win32.whl", hash = "sha256:d9beb777a78c331580705326d2367488d5bc473b49a9bc3036c154832520aca9"},
+    {file = "numpy-2.1.3-cp311-cp311-win_amd64.whl", hash = "sha256:d89dd2b6da69c4fff5e39c28a382199ddedc3a5be5390115608345dec660b9e2"},
+    {file = "numpy-2.1.3-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:f55ba01150f52b1027829b50d70ef1dafd9821ea82905b63936668403c3b471e"},
+    {file = "numpy-2.1.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:13138eadd4f4da03074851a698ffa7e405f41a0845a6b1ad135b81596e4e9958"},
+    {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a6b46587b14b888e95e4a24d7b13ae91fa22386c199ee7b418f449032b2fa3b8"},
+    {file = "numpy-2.1.3-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:0fa14563cc46422e99daef53d725d0c326e99e468a9320a240affffe87852564"},
+    {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8637dcd2caa676e475503d1f8fdb327bc495554e10838019651b76d17b98e512"},
+    {file = "numpy-2.1.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2312b2aa89e1f43ecea6da6ea9a810d06aae08321609d8dc0d0eda6d946a541b"},
+    {file = "numpy-2.1.3-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a38c19106902bb19351b83802531fea19dee18e5b37b36454f27f11ff956f7fc"},
+    {file = "numpy-2.1.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:02135ade8b8a84011cbb67dc44e07c58f28575cf9ecf8ab304e51c05528c19f0"},
+    {file = "numpy-2.1.3-cp312-cp312-win32.whl", hash = "sha256:e6988e90fcf617da2b5c78902fe8e668361b43b4fe26dbf2d7b0f8034d4cafb9"},
+    {file = "numpy-2.1.3-cp312-cp312-win_amd64.whl", hash = "sha256:0d30c543f02e84e92c4b1f415b7c6b5326cbe45ee7882b6b77db7195fb971e3a"},
+    {file = "numpy-2.1.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:96fe52fcdb9345b7cd82ecd34547fca4321f7656d500eca497eb7ea5a926692f"},
+    {file = "numpy-2.1.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:f653490b33e9c3a4c1c01d41bc2aef08f9475af51146e4a7710c450cf9761598"},
+    {file = "numpy-2.1.3-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:dc258a761a16daa791081d026f0ed4399b582712e6fc887a95af09df10c5ca57"},
+    {file = "numpy-2.1.3-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:016d0f6f5e77b0f0d45d77387ffa4bb89816b57c835580c3ce8e099ef830befe"},
+    {file = "numpy-2.1.3-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c181ba05ce8299c7aa3125c27b9c2167bca4a4445b7ce73d5febc411ca692e43"},
+    {file = "numpy-2.1.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:5641516794ca9e5f8a4d17bb45446998c6554704d888f86df9b200e66bdcce56"},
+    {file = "numpy-2.1.3-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:ea4dedd6e394a9c180b33c2c872b92f7ce0f8e7ad93e9585312b0c5a04777a4a"},
+    {file = "numpy-2.1.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:b0df3635b9c8ef48bd3be5f862cf71b0a4716fa0e702155c45067c6b711ddcef"},
+    {file = "numpy-2.1.3-cp313-cp313-win32.whl", hash = "sha256:50ca6aba6e163363f132b5c101ba078b8cbd3fa92c7865fd7d4d62d9779ac29f"},
+    {file = "numpy-2.1.3-cp313-cp313-win_amd64.whl", hash = "sha256:747641635d3d44bcb380d950679462fae44f54b131be347d5ec2bce47d3df9ed"},
+    {file = "numpy-2.1.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:996bb9399059c5b82f76b53ff8bb686069c05acc94656bb259b1d63d04a9506f"},
+    {file = "numpy-2.1.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:45966d859916ad02b779706bb43b954281db43e185015df6eb3323120188f9e4"},
+    {file = "numpy-2.1.3-cp313-cp313t-macosx_14_0_arm64.whl", hash = "sha256:baed7e8d7481bfe0874b566850cb0b85243e982388b7b23348c6db2ee2b2ae8e"},
+    {file = "numpy-2.1.3-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:a9f7f672a3388133335589cfca93ed468509cb7b93ba3105fce780d04a6576a0"},
+    {file = "numpy-2.1.3-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d7aac50327da5d208db2eec22eb11e491e3fe13d22653dce51b0f4109101b408"},
+    {file = "numpy-2.1.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4394bc0dbd074b7f9b52024832d16e019decebf86caf909d94f6b3f77a8ee3b6"},
+    {file = "numpy-2.1.3-cp313-cp313t-musllinux_1_1_x86_64.whl", hash = "sha256:50d18c4358a0a8a53f12a8ba9d772ab2d460321e6a93d6064fc22443d189853f"},
+    {file = "numpy-2.1.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:14e253bd43fc6b37af4921b10f6add6925878a42a0c5fe83daee390bca80bc17"},
+    {file = "numpy-2.1.3-cp313-cp313t-win32.whl", hash = "sha256:08788d27a5fd867a663f6fc753fd7c3ad7e92747efc73c53bca2f19f8bc06f48"},
+    {file = "numpy-2.1.3-cp313-cp313t-win_amd64.whl", hash = "sha256:2564fbdf2b99b3f815f2107c1bbc93e2de8ee655a69c261363a1172a79a257d4"},
+    {file = "numpy-2.1.3-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:4f2015dfe437dfebbfce7c85c7b53d81ba49e71ba7eadbf1df40c915af75979f"},
+    {file = "numpy-2.1.3-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:3522b0dfe983a575e6a9ab3a4a4dfe156c3e428468ff08ce582b9bb6bd1d71d4"},
+    {file = "numpy-2.1.3-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c006b607a865b07cd981ccb218a04fc86b600411d83d6fc261357f1c0966755d"},
+    {file = "numpy-2.1.3-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:e14e26956e6f1696070788252dcdff11b4aca4c3e8bd166e0df1bb8f315a67cb"},
+    {file = "numpy-2.1.3.tar.gz", hash = "sha256:aa08e04e08aaf974d4458def539dece0d28146d866a39da5639596f4921fd761"},
+]
+
+[[package]]
+name = "packaging"
+version = "24.1"
+description = "Core utilities for Python packages"
+optional = false
+python-versions = ">=3.8"
+files = [
+    {file = "packaging-24.1-py3-none-any.whl", hash = "sha256:5b8f2217dbdbd2f7f384c41c628544e6d52f2d0f53c6d0c3ea61aa5d1d7ff124"},
+    {file = "packaging-24.1.tar.gz", hash = "sha256:026ed72c8ed3fcce5bf8950572258698927fd1dbda10a5e981cdf0ac37f4f002"},
+]
+
+[[package]]
+name = "pillow"
+version = "11.0.0"
+description = "Python Imaging Library (Fork)"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "pillow-11.0.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:6619654954dc4936fcff82db8eb6401d3159ec6be81e33c6000dfd76ae189947"},
+    {file = "pillow-11.0.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:b3c5ac4bed7519088103d9450a1107f76308ecf91d6dabc8a33a2fcfb18d0fba"},
+    {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a65149d8ada1055029fcb665452b2814fe7d7082fcb0c5bed6db851cb69b2086"},
+    {file = "pillow-11.0.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:88a58d8ac0cc0e7f3a014509f0455248a76629ca9b604eca7dc5927cc593c5e9"},
+    {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_aarch64.whl", hash = "sha256:c26845094b1af3c91852745ae78e3ea47abf3dbcd1cf962f16b9a5fbe3ee8488"},
+    {file = "pillow-11.0.0-cp310-cp310-manylinux_2_28_x86_64.whl", hash = "sha256:1a61b54f87ab5786b8479f81c4b11f4d61702830354520837f8cc791ebba0f5f"},
+    {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:674629ff60030d144b7bca2b8330225a9b11c482ed408813924619c6f302fdbb"},
+    {file = "pillow-11.0.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:598b4e238f13276e0008299bd2482003f48158e2b11826862b1eb2ad7c768b97"},
+    {file = "pillow-11.0.0-cp310-cp310-win32.whl", hash = "sha256:9a0f748eaa434a41fccf8e1ee7a3eed68af1b690e75328fd7a60af123c193b50"},
+    {file = "pillow-11.0.0-cp310-cp310-win_amd64.whl", hash = "sha256:a5629742881bcbc1f42e840af185fd4d83a5edeb96475a575f4da50d6ede337c"},
+    {file = "pillow-11.0.0-cp310-cp310-win_arm64.whl", hash = "sha256:ee217c198f2e41f184f3869f3e485557296d505b5195c513b2bfe0062dc537f1"},
+    {file = "pillow-11.0.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:1c1d72714f429a521d8d2d018badc42414c3077eb187a59579f28e4270b4b0fc"},
+    {file = "pillow-11.0.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:499c3a1b0d6fc8213519e193796eb1a86a1be4b1877d678b30f83fd979811d1a"},
+    {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c8b2351c85d855293a299038e1f89db92a2f35e8d2f783489c6f0b2b5f3fe8a3"},
+    {file = "pillow-11.0.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6f4dba50cfa56f910241eb7f883c20f1e7b1d8f7d91c750cd0b318bad443f4d5"},
+    {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_aarch64.whl", hash = "sha256:5ddbfd761ee00c12ee1be86c9c0683ecf5bb14c9772ddbd782085779a63dd55b"},
+    {file = "pillow-11.0.0-cp311-cp311-manylinux_2_28_x86_64.whl", hash = "sha256:45c566eb10b8967d71bf1ab8e4a525e5a93519e29ea071459ce517f6b903d7fa"},
+    {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:b4fd7bd29610a83a8c9b564d457cf5bd92b4e11e79a4ee4716a63c959699b306"},
+    {file = "pillow-11.0.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:cb929ca942d0ec4fac404cbf520ee6cac37bf35be479b970c4ffadf2b6a1cad9"},
+    {file = "pillow-11.0.0-cp311-cp311-win32.whl", hash = "sha256:006bcdd307cc47ba43e924099a038cbf9591062e6c50e570819743f5607404f5"},
+    {file = "pillow-11.0.0-cp311-cp311-win_amd64.whl", hash = "sha256:52a2d8323a465f84faaba5236567d212c3668f2ab53e1c74c15583cf507a0291"},
+    {file = "pillow-11.0.0-cp311-cp311-win_arm64.whl", hash = "sha256:16095692a253047fe3ec028e951fa4221a1f3ed3d80c397e83541a3037ff67c9"},
+    {file = "pillow-11.0.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:d2c0a187a92a1cb5ef2c8ed5412dd8d4334272617f532d4ad4de31e0495bd923"},
+    {file = "pillow-11.0.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:084a07ef0821cfe4858fe86652fffac8e187b6ae677e9906e192aafcc1b69903"},
+    {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:8069c5179902dcdce0be9bfc8235347fdbac249d23bd90514b7a47a72d9fecf4"},
+    {file = "pillow-11.0.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f02541ef64077f22bf4924f225c0fd1248c168f86e4b7abdedd87d6ebaceab0f"},
+    {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_aarch64.whl", hash = "sha256:fcb4621042ac4b7865c179bb972ed0da0218a076dc1820ffc48b1d74c1e37fe9"},
+    {file = "pillow-11.0.0-cp312-cp312-manylinux_2_28_x86_64.whl", hash = "sha256:00177a63030d612148e659b55ba99527803288cea7c75fb05766ab7981a8c1b7"},
+    {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:8853a3bf12afddfdf15f57c4b02d7ded92c7a75a5d7331d19f4f9572a89c17e6"},
+    {file = "pillow-11.0.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:3107c66e43bda25359d5ef446f59c497de2b5ed4c7fdba0894f8d6cf3822dafc"},
+    {file = "pillow-11.0.0-cp312-cp312-win32.whl", hash = "sha256:86510e3f5eca0ab87429dd77fafc04693195eec7fd6a137c389c3eeb4cfb77c6"},
+    {file = "pillow-11.0.0-cp312-cp312-win_amd64.whl", hash = "sha256:8ec4a89295cd6cd4d1058a5e6aec6bf51e0eaaf9714774e1bfac7cfc9051db47"},
+    {file = "pillow-11.0.0-cp312-cp312-win_arm64.whl", hash = "sha256:27a7860107500d813fcd203b4ea19b04babe79448268403172782754870dac25"},
+    {file = "pillow-11.0.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:bcd1fb5bb7b07f64c15618c89efcc2cfa3e95f0e3bcdbaf4642509de1942a699"},
+    {file = "pillow-11.0.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0e038b0745997c7dcaae350d35859c9715c71e92ffb7e0f4a8e8a16732150f38"},
+    {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0ae08bd8ffc41aebf578c2af2f9d8749d91f448b3bfd41d7d9ff573d74f2a6b2"},
+    {file = "pillow-11.0.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d69bfd8ec3219ae71bcde1f942b728903cad25fafe3100ba2258b973bd2bc1b2"},
+    {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_aarch64.whl", hash = "sha256:61b887f9ddba63ddf62fd02a3ba7add935d053b6dd7d58998c630e6dbade8527"},
+    {file = "pillow-11.0.0-cp313-cp313-manylinux_2_28_x86_64.whl", hash = "sha256:c6a660307ca9d4867caa8d9ca2c2658ab685de83792d1876274991adec7b93fa"},
+    {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:73e3a0200cdda995c7e43dd47436c1548f87a30bb27fb871f352a22ab8dcf45f"},
+    {file = "pillow-11.0.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:fba162b8872d30fea8c52b258a542c5dfd7b235fb5cb352240c8d63b414013eb"},
+    {file = "pillow-11.0.0-cp313-cp313-win32.whl", hash = "sha256:f1b82c27e89fffc6da125d5eb0ca6e68017faf5efc078128cfaa42cf5cb38798"},
+    {file = "pillow-11.0.0-cp313-cp313-win_amd64.whl", hash = "sha256:8ba470552b48e5835f1d23ecb936bb7f71d206f9dfeee64245f30c3270b994de"},
+    {file = "pillow-11.0.0-cp313-cp313-win_arm64.whl", hash = "sha256:846e193e103b41e984ac921b335df59195356ce3f71dcfd155aa79c603873b84"},
+    {file = "pillow-11.0.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:4ad70c4214f67d7466bea6a08061eba35c01b1b89eaa098040a35272a8efb22b"},
+    {file = "pillow-11.0.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:6ec0d5af64f2e3d64a165f490d96368bb5dea8b8f9ad04487f9ab60dc4bb6003"},
+    {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c809a70e43c7977c4a42aefd62f0131823ebf7dd73556fa5d5950f5b354087e2"},
+    {file = "pillow-11.0.0-cp313-cp313t-manylinux_2_28_x86_64.whl", hash = "sha256:4b60c9520f7207aaf2e1d94de026682fc227806c6e1f55bba7606d1c94dd623a"},
+    {file = "pillow-11.0.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:1e2688958a840c822279fda0086fec1fdab2f95bf2b717b66871c4ad9859d7e8"},
+    {file = "pillow-11.0.0-cp313-cp313t-win32.whl", hash = "sha256:607bbe123c74e272e381a8d1957083a9463401f7bd01287f50521ecb05a313f8"},
+    {file = "pillow-11.0.0-cp313-cp313t-win_amd64.whl", hash = "sha256:5c39ed17edea3bc69c743a8dd3e9853b7509625c2462532e62baa0732163a904"},
+    {file = "pillow-11.0.0-cp313-cp313t-win_arm64.whl", hash = "sha256:75acbbeb05b86bc53cbe7b7e6fe00fbcf82ad7c684b3ad82e3d711da9ba287d3"},
+    {file = "pillow-11.0.0-cp39-cp39-macosx_10_10_x86_64.whl", hash = "sha256:2e46773dc9f35a1dd28bd6981332fd7f27bec001a918a72a79b4133cf5291dba"},
+    {file = "pillow-11.0.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:2679d2258b7f1192b378e2893a8a0a0ca472234d4c2c0e6bdd3380e8dfa21b6a"},
+    {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eda2616eb2313cbb3eebbe51f19362eb434b18e3bb599466a1ffa76a033fb916"},
+    {file = "pillow-11.0.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:20ec184af98a121fb2da42642dea8a29ec80fc3efbaefb86d8fdd2606619045d"},
+    {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_aarch64.whl", hash = "sha256:8594f42df584e5b4bb9281799698403f7af489fba84c34d53d1c4bfb71b7c4e7"},
+    {file = "pillow-11.0.0-cp39-cp39-manylinux_2_28_x86_64.whl", hash = "sha256:c12b5ae868897c7338519c03049a806af85b9b8c237b7d675b8c5e089e4a618e"},
+    {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:70fbbdacd1d271b77b7721fe3cdd2d537bbbd75d29e6300c672ec6bb38d9672f"},
+    {file = "pillow-11.0.0-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:5178952973e588b3f1360868847334e9e3bf49d19e169bbbdfaf8398002419ae"},
+    {file = "pillow-11.0.0-cp39-cp39-win32.whl", hash = "sha256:8c676b587da5673d3c75bd67dd2a8cdfeb282ca38a30f37950511766b26858c4"},
+    {file = "pillow-11.0.0-cp39-cp39-win_amd64.whl", hash = "sha256:94f3e1780abb45062287b4614a5bc0874519c86a777d4a7ad34978e86428b8dd"},
+    {file = "pillow-11.0.0-cp39-cp39-win_arm64.whl", hash = "sha256:290f2cc809f9da7d6d622550bbf4c1e57518212da51b6a30fe8e0a270a5b78bd"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:1187739620f2b365de756ce086fdb3604573337cc28a0d3ac4a01ab6b2d2a6d2"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-macosx_11_0_arm64.whl", hash = "sha256:fbbcb7b57dc9c794843e3d1258c0fbf0f48656d46ffe9e09b63bbd6e8cd5d0a2"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:5d203af30149ae339ad1b4f710d9844ed8796e97fda23ffbc4cc472968a47d0b"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21a0d3b115009ebb8ac3d2ebec5c2982cc693da935f4ab7bb5c8ebe2f47d36f2"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_aarch64.whl", hash = "sha256:73853108f56df97baf2bb8b522f3578221e56f646ba345a372c78326710d3830"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:e58876c91f97b0952eb766123bfef372792ab3f4e3e1f1a2267834c2ab131734"},
+    {file = "pillow-11.0.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:224aaa38177597bb179f3ec87eeefcce8e4f85e608025e9cfac60de237ba6316"},
+    {file = "pillow-11.0.0-pp39-pypy39_pp73-macosx_11_0_arm64.whl", hash = "sha256:5bd2d3bdb846d757055910f0a59792d33b555800813c3b39ada1829c372ccb06"},
+    {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:375b8dd15a1f5d2feafff536d47e22f69625c1aa92f12b339ec0b2ca40263273"},
+    {file = "pillow-11.0.0-pp39-pypy39_pp73-manylinux_2_28_x86_64.whl", hash = "sha256:daffdf51ee5db69a82dd127eabecce20729e21f7a3680cf7cbb23f0829189790"},
+    {file = "pillow-11.0.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:7326a1787e3c7b0429659e0a944725e1b03eeaa10edd945a86dead1913383944"},
+    {file = "pillow-11.0.0.tar.gz", hash = "sha256:72bacbaf24ac003fea9bff9837d1eedb6088758d41e100c1552930151f677739"},
+]
+
+[package.extras]
+docs = ["furo", "olefile", "sphinx (>=8.1)", "sphinx-copybutton", "sphinx-inline-tabs", "sphinxext-opengraph"]
+fpx = ["olefile"]
+mic = ["olefile"]
+tests = ["check-manifest", "coverage", "defusedxml", "markdown2", "olefile", "packaging", "pyroma", "pytest", "pytest-cov", "pytest-timeout"]
+typing = ["typing-extensions"]
+xmp = ["defusedxml"]
+
+[[package]]
+name = "pyparsing"
+version = "3.2.0"
+description = "pyparsing module - Classes and methods to define and execute parsing grammars"
+optional = false
+python-versions = ">=3.9"
+files = [
+    {file = "pyparsing-3.2.0-py3-none-any.whl", hash = "sha256:93d9577b88da0bbea8cc8334ee8b918ed014968fd2ec383e868fb8afb1ccef84"},
+    {file = "pyparsing-3.2.0.tar.gz", hash = "sha256:cbf74e27246d595d9a74b186b810f6fbb86726dbf3b9532efb343f6d7294fe9c"},
+]
+
+[package.extras]
+diagrams = ["jinja2", "railroad-diagrams"]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+description = "Extensions to the standard Python datetime module"
+optional = false
+python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,>=2.7"
+files = [
+    {file = "python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3"},
+    {file = "python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427"},
+]
+
+[package.dependencies]
+six = ">=1.5"
+
+[[package]]
+name = "six"
+version = "1.16.0"
+description = "Python 2 and 3 compatibility utilities"
+optional = false
+python-versions = ">=2.7, !=3.0.*, !=3.1.*, !=3.2.*"
+files = [
+    {file = "six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254"},
+    {file = "six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926"},
+]
+
+[metadata]
+lock-version = "2.0"
+python-versions = "^3.10"
+content-hash = "3d77c178397a87c8a5e10ac940d83289ac13d5131481c5981ef85aac8941835e"
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..fbaccec
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,15 @@
+[tool.poetry]
+name = "mldevops-exercise"
+version = "0.1.0"
+description = ""
+authors = ["Michal Nedza <MicnedSQ@gmail.com>"]
+readme = "README.md"
+
+[tool.poetry.dependencies]
+python = "^3.10"
+matplotlib = "^3.9.2"
+
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"