SCM_GPT_2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import networkx as nx\n",
    "\n",
    "# Load nodes and edges from CSV files\n",
    "nodes_df = pd.read_csv('Node.csv')\n",
    "edges_df = pd.read_csv('Edge.csv')\n",
    "\n",
    "# Create a graph\n",
    "G = nx.Graph()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "    edge_id  transportation_cost\n",
      "12     13.0                 2.25\n",
      "32     33.0                 2.40\n",
      "22     23.0                 2.40\n",
      "42     43.0                 2.40\n",
      "10     11.0                 2.40\n",
      "17     18.0                 3.00\n",
      "1       2.0                 3.00\n",
      "31     32.0                 3.00\n",
      "21     22.0                 3.00\n",
      "41     42.0                 3.00\n",
      "26     27.0                 3.50\n",
      "46     47.0                 3.50\n",
      "36     37.0                 3.50\n",
      "24     25.0                 3.60\n",
      "44     45.0                 3.60\n",
      "34     35.0                 3.60\n",
      "6       7.0                 3.85\n",
      "14     15.0                 4.00\n",
      "8       9.0                 4.00\n",
      "16     17.0                 4.20\n",
      "4       5.0                 5.40\n",
      "20     21.0                 5.50\n",
      "40     41.0                 5.50\n",
      "30     31.0                 5.50\n",
      "37     38.0                 6.00\n",
      "27     28.0                 6.00\n",
      "47     48.0                 6.00\n",
      "2       3.0                 6.00\n",
      "39     40.0                 7.20\n",
      "49     50.0                 7.20\n",
      "29     30.0                 7.20\n",
      "28     29.0                 7.50\n",
      "25     26.0                 7.50\n",
      "48     49.0                 7.50\n",
      "45     46.0                 7.50\n",
      "9      10.0                 7.50\n",
      "35     36.0                 7.50\n",
      "18     19.0                 7.50\n",
      "38     39.0                 7.50\n",
      "19     20.0                 8.00\n",
      "11     12.0                 8.10\n",
      "15     16.0                 8.25\n",
      "5       6.0                 9.35\n",
      "0       1.0                10.00\n",
      "23     24.0                10.80\n",
      "43     44.0                10.80\n",
      "33     34.0                10.80\n",
      "3       4.0                10.80\n",
      "13     14.0                12.00\n",
      "7       8.0                14.00\n",
      "5\n",
      "    edge_id  is_optimal\n",
      "0         1           0\n",
      "1         2           0\n",
      "2         3           0\n",
      "3         4           0\n",
      "4         5           0\n",
      "5         6           0\n",
      "6         7           0\n",
      "7         8           0\n",
      "8         9           0\n",
      "9        10           0\n",
      "10       11           1\n",
      "11       12           0\n",
      "12       13           1\n",
      "13       14           0\n",
      "14       15           0\n",
      "15       16           0\n",
      "16       17           0\n",
      "17       18           0\n",
      "18       19           0\n",
      "19       20           0\n",
      "20       21           0\n",
      "21       22           0\n",
      "22       23           1\n",
      "23       24           0\n",
      "24       25           0\n",
      "25       26           0\n",
      "26       27           0\n",
      "27       28           0\n",
      "28       29           0\n",
      "29       30           0\n",
      "30       31           0\n",
      "31       32           0\n",
      "32       33           1\n",
      "33       34           0\n",
      "34       35           0\n",
      "35       36           0\n",
      "36       37           0\n",
      "37       38           0\n",
      "38       39           0\n",
      "39       40           0\n",
      "40       41           0\n",
      "41       42           0\n",
      "42       43           1\n",
      "43       44           0\n",
      "44       45           0\n",
      "45       46           0\n",
      "46       47           0\n",
      "47       48           0\n",
      "48       49           0\n",
      "49       50           0\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_8149/950695611.py:12: FutureWarning: The behavior of DataFrame concatenation with empty or all-NA entries is deprecated. In a future version, this will no longer exclude empty or all-NA columns when determining the result dtypes. To retain the old behavior, exclude the relevant entries before the concat operation.\n",
      "  transportation_costs = transportation_costs._append({'edge_id': edge_id, 'transportation_cost': transportation_cost}, ignore_index=True)\n"
     ]
    }
   ],
   "source": [
    "#Generating Binary Labels for Optimal Route --- Binary Classification\n",
    "#Create a DataFrame to store transportation costs for each edge\n",
    "transportation_costs = pd.DataFrame(columns=['edge_id', 'transportation_cost'])\n",
    "\n",
    "# Calculate transportation costs based on the provided edges data\n",
    "for _, edge_data in edges_df.iterrows():\n",
    "    edge_id = edge_data['edge_id']\n",
    "    distance = edge_data['distance']\n",
    "    cost_per_km = edge_data['cost_per_km']\n",
    "    transportation_cost = distance * cost_per_km\n",
    "    #print(transportation_cost)\n",
    "    transportation_costs = transportation_costs._append({'edge_id': edge_id, 'transportation_cost': transportation_cost}, ignore_index=True)\n",
    "    #print(transportation_costs)\n",
    "\n",
    "# Sort edges by transportation cost in ascending order\n",
    "sorted_edges = transportation_costs.sort_values(by='transportation_cost', ascending=True)\n",
    "print(sorted_edges)\n",
    "\n",
    "# Assuming you want to label the top 10% of edges as optimal routes #top 10%?\n",
    "num_optimal_routes = int(0.1 * len(sorted_edges))\n",
    "print(num_optimal_routes)\n",
    "optimal_edges = sorted_edges.head(num_optimal_routes)['edge_id'].tolist()\n",
    "\n",
    "# Create binary labels based on whether the edge is in the optimal routes list #binary labels?\n",
    "edges_df['is_optimal'] = edges_df['edge_id'].isin(optimal_edges).astype(int)\n",
    "\n",
    "# Display the resulting DataFrame with binary labels\n",
    "print(edges_df[['edge_id', 'is_optimal']])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Node Features:\n",
      "tensor([[  37.7749, -122.4194, 1000.0000],\n",
      "        [  34.0522, -118.2437,  500.0000],\n",
      "        [  40.7128,  -74.0060,  800.0000],\n",
      "        [  41.8781,  -87.6298,       nan],\n",
      "        [  32.7767,  -96.7970, 1200.0000],\n",
      "        [  29.7604,  -95.3698,  600.0000],\n",
      "        [  35.6895, -105.9378, 1000.0000],\n",
      "        [  39.9526,  -75.1652,       nan],\n",
      "        [  40.7128,  -74.0060,  800.0000],\n",
      "        [  37.7749, -122.4194,  400.0000],\n",
      "        [  34.0522, -118.2437,  600.0000],\n",
      "        [  32.7767,  -96.7970,       nan],\n",
      "        [  29.7604,  -95.3698, 1100.0000],\n",
      "        [  35.6895, -105.9378,  550.0000],\n",
      "        [  39.9526,  -75.1652,  750.0000],\n",
      "        [  41.8781,  -87.6298,       nan],\n",
      "        [  34.0522, -118.2437,  900.0000],\n",
      "        [  32.7767,  -96.7970,  450.0000],\n",
      "        [  29.7604,  -95.3698,  700.0000],\n",
      "        [  35.6895, -105.9378,       nan],\n",
      "        [  39.9526,  -75.1652, 1000.0000],\n",
      "        [  41.8781,  -87.6298,  500.0000],\n",
      "        [  37.7749, -122.4194,  700.0000],\n",
      "        [  34.0522, -118.2437,       nan],\n",
      "        [  32.7767,  -96.7970, 1300.0000],\n",
      "        [  29.7604,  -95.3698,  650.0000],\n",
      "        [  35.6895, -105.9378, 1100.0000],\n",
      "        [  39.9526,  -75.1652,       nan],\n",
      "        [  40.7128,  -74.0060,  850.0000],\n",
      "        [  37.7749, -122.4194,  550.0000],\n",
      "        [  34.0522, -118.2437,  800.0000],\n",
      "        [  32.7767,  -96.7970,       nan],\n",
      "        [  29.7604,  -95.3698, 1200.0000],\n",
      "        [  35.6895, -105.9378,  600.0000],\n",
      "        [  39.9526,  -75.1652,  900.0000],\n",
      "        [  41.8781,  -87.6298,       nan],\n",
      "        [  34.0522, -118.2437,  950.0000],\n",
      "        [  32.7767,  -96.7970,  500.0000],\n",
      "        [  29.7604,  -95.3698,  750.0000],\n",
      "        [  35.6895, -105.9378,       nan],\n",
      "        [  39.9526,  -75.1652, 1100.0000],\n",
      "        [  41.8781,  -87.6298,  550.0000],\n",
      "        [  37.7749, -122.4194,  750.0000],\n",
      "        [  34.0522, -118.2437,       nan],\n",
      "        [  32.7767,  -96.7970, 1400.0000],\n",
      "        [  29.7604,  -95.3698,  700.0000],\n",
      "        [  35.6895, -105.9378, 1200.0000],\n",
      "        [  39.9526,  -75.1652,       nan],\n",
      "        [  40.7128,  -74.0060,  900.0000],\n",
      "        [  37.7749, -122.4194,  600.0000]])\n",
      "\n",
      "Edge Index:\n",
      "tensor([[ 1,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17,\n",
      "         18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,\n",
      "         36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49],\n",
      "        [ 0,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16, 17, 18,\n",
      "         19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36,\n",
      "         37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,  0]])\n",
      "\n",
      "Edge Features:\n",
      "tensor([[50.0000,  0.2000],\n",
      "        [30.0000,  0.1000],\n",
      "        [40.0000,  0.1500],\n",
      "        [60.0000,  0.1800],\n",
      "        [45.0000,  0.1200],\n",
      "        [55.0000,  0.1700],\n",
      "        [35.0000,  0.1100],\n",
      "        [70.0000,  0.2000],\n",
      "        [40.0000,  0.1000],\n",
      "        [50.0000,  0.1500],\n",
      "        [30.0000,  0.0800],\n",
      "        [45.0000,  0.1800],\n",
      "        [25.0000,  0.0900],\n",
      "        [60.0000,  0.2000],\n",
      "        [40.0000,  0.1000],\n",
      "        [55.0000,  0.1500],\n",
      "        [35.0000,  0.1200],\n",
      "        [30.0000,  0.1000],\n",
      "        [50.0000,  0.1500],\n",
      "        [40.0000,  0.2000],\n",
      "        [55.0000,  0.1000],\n",
      "        [25.0000,  0.1200],\n",
      "        [30.0000,  0.0800],\n",
      "        [60.0000,  0.1800],\n",
      "        [40.0000,  0.0900],\n",
      "        [50.0000,  0.1500],\n",
      "        [35.0000,  0.1000],\n",
      "        [30.0000,  0.2000],\n",
      "        [50.0000,  0.1500],\n",
      "        [40.0000,  0.1800],\n",
      "        [55.0000,  0.1000],\n",
      "        [25.0000,  0.1200],\n",
      "        [30.0000,  0.0800],\n",
      "        [60.0000,  0.1800],\n",
      "        [40.0000,  0.0900],\n",
      "        [50.0000,  0.1500],\n",
      "        [35.0000,  0.1000],\n",
      "        [30.0000,  0.2000],\n",
      "        [50.0000,  0.1500],\n",
      "        [40.0000,  0.1800],\n",
      "        [55.0000,  0.1000],\n",
      "        [25.0000,  0.1200],\n",
      "        [30.0000,  0.0800],\n",
      "        [60.0000,  0.1800],\n",
      "        [40.0000,  0.0900],\n",
      "        [50.0000,  0.1500],\n",
      "        [35.0000,  0.1000],\n",
      "        [30.0000,  0.2000],\n",
      "        [50.0000,  0.1500],\n",
      "        [40.0000,  0.1800]])\n",
      "\n",
      "Binary Labels (is_optimal):\n",
      "tensor([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0,\n",
      "        0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,\n",
      "        0, 0])\n"
     ]
    }
   ],
   "source": [
    "#Converting the Categorical cols - type from node_df and mode from edge_df to convert to tensors \n",
    "import torch\n",
    "import pandas as pd\n",
    "import networkx as nx\n",
    "from torch_geometric.data import Data\n",
    "\n",
    "for _, node_data in nodes_df.iterrows():\n",
    "    node_id = node_data['node_id']\n",
    "    G.add_node(node_id, type=node_data['type'], latitude=node_data['latitude'], longitude=node_data['longitude'], capacity=node_data['capacity'])\n",
    "\n",
    "# One-hot encode the 'type' column\n",
    "one_hot_encoded_types = pd.get_dummies(nodes_df['type'], prefix='type')\n",
    "#print(one_hot_encoded_types)\n",
    "\n",
    "# Concatenate the one-hot encoded types with the original node features\n",
    "node_features = pd.concat([nodes_df[['latitude', 'longitude', 'capacity']], one_hot_encoded_types], axis=1)\n",
    "\n",
    "# Convert only numeric columns in node_features to a tensor\n",
    "numeric_node_features = node_features.select_dtypes(include=['float64', 'float32', 'int64', 'int32']).values\n",
    "node_features_tensor = torch.tensor(numeric_node_features, dtype=torch.float)\n",
    "\n",
    "# Extract only numeric columns for edge features\n",
    "numeric_edge_features = edges_df[['distance', 'cost_per_km']].values\n",
    "edge_features_tensor = torch.tensor(numeric_edge_features, dtype=torch.float)\n",
    "\n",
    "# Extract edge_index\n",
    "edge_index = torch.tensor(list(G.edges()), dtype=torch.long).t().contiguous()\n",
    "\n",
    "# Extract binary labels for optimal routes (assuming you have already generated these labels)\n",
    "labels = torch.tensor(edges_df['is_optimal'].values, dtype=torch.long)\n",
    "\n",
    "# Create a PyTorch Geometric Data object with one-hot encoded types and binary labels\n",
    "data = Data(x=node_features_tensor, edge_index=edge_index, edge_attr=edge_features_tensor, y=labels)\n",
    "\n",
    "# Display the data\n",
    "print(\"Node Features:\")\n",
    "print(node_features_tensor)\n",
    "print(\"\\nEdge Index:\")\n",
    "print(edge_index)\n",
    "print(\"\\nEdge Features:\")\n",
    "print(edge_features_tensor)\n",
    "print(\"\\nBinary Labels (is_optimal):\")\n",
    "print(labels)\n",
    "\n",
    "# You can use the 'data' object in your GNN model for training and testing."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Node Mapping -- Index out of bounds for edge_index\n",
    "import torch\n",
    "import networkx as nx\n",
    "from torch_geometric.data import Data\n",
    "\n",
    "# Assuming you have nodes_df and edges_df dataframes\n",
    "\n",
    "# Create a NetworkX graph and add nodes with attributes\n",
    "G = nx.Graph()\n",
    "\n",
    "# Mapping to keep track of node indices\n",
    "node_mapping = {}\n",
    "\n",
    "for _, node_data in nodes_df.iterrows():\n",
    "    node_id = node_data['node_id']\n",
    "    G.add_node(node_id, type=node_data['type'], latitude=node_data['latitude'], longitude=node_data['longitude'], capacity=node_data['capacity'])\n",
    "    \n",
    "    # Add the node to the mapping\n",
    "    node_mapping[node_id] = len(node_mapping)\n",
    "\n",
    "# Add edges with attributes\n",
    "for _, edge_data in edges_df.iterrows():\n",
    "    source_node_id = edge_data['source_node_id']\n",
    "    destination_node_id = edge_data['destination_node_id']\n",
    "    \n",
    "    # Check if the node indices are within bounds\n",
    "    if source_node_id not in node_mapping or destination_node_id not in node_mapping:\n",
    "        print(f\"Error: Invalid node indices in edge ({source_node_id}, {destination_node_id}). Check the graph construction.\")\n",
    "    else:\n",
    "        # Use the mapped indices\n",
    "        source_node_index = node_mapping[source_node_id]\n",
    "        destination_node_index = node_mapping[destination_node_id]\n",
    "        \n",
    "        G.add_edge(source_node_index, destination_node_index, edge_id=edge_data['edge_id'],\n",
    "                   distance=edge_data['distance'], mode=edge_data['mode'],\n",
    "                   cost_per_km=edge_data['cost_per_km'],\n",
    "                   time_window_start=edge_data['time_window_start'],\n",
    "                   time_window_end=edge_data['time_window_end'])\n",
    "\n",
    "# Get the edge_index from the NetworkX graph\n",
    "edge_index = torch.tensor(list(G.edges()), dtype=torch.long).t().contiguous()\n",
    "\n",
    "# Create a PyTorch Geometric Data object\n",
    "data = Data(x=node_features_tensor, edge_index=edge_index, edge_attr=edge_features_tensor, y=labels)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAD8aElEQVR4nOzdd3hTZfvA8W9W070XBcpugTIE2bsIqIAgoIIiCm4RB6+LH/IqKOJCAQdOFEUExRcUBZFVthSUXdnQwWrp3mmTnN8fIaGhm7Z03Z/r8jLJOTk5KW1yn+d57vtWKYqiIIQQQgghxHVSV/cJCCGEEEKI2k0CSiGEEEIIUSESUAohhBBCiAqRgFIIIYQQQlSIBJRCCCGEEKJCJKAUQgghhBAVIgGlEEIIIYSoEAkohRBCCCFEhUhAKYQQQgghKkQCSiGEEEIIUSESUAohhBBCiAqRgFIIIYQQQlSIBJRCCCGEEKJCJKAUQgghhBAVIgGlEEIIIYSoEAkohRBCCCFEhUhAKYQQQgghKkQCSiGEEEIIUSESUAohhBBCiAqRgFIIIYQQQlSIBJRCCCGEEKJCJKAUQgghhBAVIgGlEEIIIYSoEAkohRBCCCFEhUhAKYQQQgghKkQCSiGEEEIIUSESUAohhBBCiAqRgFIIIYQQQlSIBJRCCCGEEKJCJKAUQgghhBAVIgGlEEIIIYSoEAkohRBCCCFEhUhAKYQQQgghKkQCSiGEEEIIUSESUAohhBBCiAqRgFIIIYQQQlSIBJRCCCGEEKJCtNV9AnVFlsFIdFIWeUYzDlo1TX1ccNHLj1cIIYQQdZ9EPBVwMj6DpZGxRBxPIDY5G6XANhUQ7O1MeKg/47sH0yrArbpOUwghhBCiSqkURVFK300UFJeczfRVh9l+KhGNWoXJXPyP0Lq9b0tf5oxqT2Nv5xt4pkIIIYQQVU8CynJavjeW11ZHYTQrJQaS19KoVWjVKmaNCGNc1+AqPEMhhBBCiBtLAspy+DjiJHPXn6jwcV4YEsKU8FaVcEZCCCGEENVPsrzLaPne2EoJJgHmrj/Bj3tjK+VYQgghhBDVTUYoyyAuOZtB87ZiMJptjyWsmEnO6b9t94Me/RSdT2Pb/axjO8j4+zfyEs6A2YzWqwGuHYfg1nkYKrUGvVbNxqn9ZU2lEEIIIWo9GaEsg+mrDmMssF4yMyrCLpi8Vur2pST+8jaGc1EoeTkoRgP5l6NJ2fgFib9/AIDRrDB91eEqP3chhBBCiKomAWUpTsZnsP1Uoi0Bx5SdRsrGLwEVaApXXcpPPk/arh8BUOkc8b5tCn5j/ovO15KIk/3vVrKO7cBkVth+KpFTCRk37L0IIYQQQlQFCShLsTQyFo1aZbufsulLzDnpuN50KxoX70L7557dD4platy5dR/cbroN51bd8eg9zrZP5oF1gCXz+/vdspZSCCGEELWbBJSliDieYBudzDnzD1lRW9C4euM1YFKR+5sN2bbbap3edlulc7TdNpw/hqKYMZkVIk4kVNGZCyGEEELcGBJQliDTYCQ22RIgmvNySFr3CQDeQyajdnQp8jla74a229knd5OfFIcpN5PM/X/YHlfyczHnZgIQm5RNlsFYVW9BCCGEEKLKSevFEsQkZdnaKaZu/Q5TegLOrfvgHNKj2Oc4t+qG1rshxuTzmDKSuPDlk0XupxjzLP8HopOyCAvysNtuMBjQ6/VFPLP8pM+4EEIIIaqSRBUlyLtSJig/KY6MfWtQO7riPfjxEp+j0ugIGPsGiWvmY4g9ZHvcqUVXcmMO2gJJtd7V7nUURUGlsqzVPH/+PC+99BJbt27ls88+Y/jw4eU+d+kzLoQQQogbRQLKEjhoLSsCTJkpoJgx52Zy7qMJRe574csn0fk3I+ihj9B6+BN43xyMGUmYMpPQuvujmPI5v9Cy7lLj7o/a4eqaSgeN2hZMfvvtt0RERLB9+3b8/PyIj4+37Zednc2pU6do3769bf9rlaXPuALEJGezJDKGxX9FS59xIYQQQlSIrKEsQVMfF4oO28pG6+aDvkEIGhdP0iNX2h53btnVdlsFNPW1rMd85ZVX+PTTT3nyyScZOXIkwcHBdO7cGYD//e9/3HfffYwdOxYvLy9uu+02du/ebfd6y/fGMmjeVnadSQIotde4dfuuM0kMmreV5dK9RwghhBDXQTrllKLHm39y7sIlso/vLLQtbecyW3KNe8+70fkG4xoWTtK6j1HrXdAHhYJKTfbJ3WQd3ghYsr0bPPwxOs9AAJr4OPPp0AC+/PJLtm3bxooVKwgODuaWW26hQ4cOzJ07F71eT6tWrWjfvj0vvvgi3t7ezJkzh8uXL/PVV18RFBQkfcaFEEIIUW1kyrsEFy5c4PKBCHQt++DedWSh7el7f4UrAaVru4G21oumrFRbrUk7ai0+w6bagkmNWkXvpp48+uijeHp68s8//wCwa9cu0tPTCQsLQ6/Xc+nSJXJzcxkyZAg9e/YE4J133iEoKIgDBw6w7byxUvuM+7nqGds1uFKOJ4QQQoi6r94HlCVlQB85cgTPxMMktexbrmM6t+qBOTuN/OTzmA3ZaJzd0Qe3x6Pn3Tj4NbXtZzIr3NHWk0uhoSxZsoTGjRszZswY0tLS8PHxYeRISxAbGBjIf//7X9asWcPo0aPx9/dn586duLq6kpQLs1dH2b1+SX3GFbOJjH1ryYqKID8pDiXfgNrRFQf/Zrh2GopL6968ujqKXi18ZU2lEEIIIcqkXk55lzUD2iFuD/Nnvcytb/3GrjNJpa5JLA+NWkWv5j4sebg7+fn5XLhwgU2bNrFixQo2btyITqejX79+rFu3jo8//piff/6Z6Ohozp8/j6enJ7169aJz586canSb3bllRkWQ9Nv7dq9VMKBMWvshmYfWF3te3kMm49llmO3chBBCCCFKU68CyrJkQFtZt5vPR9FRe5HjQYPJM1Xej0qvVbNxan/bKKDZbEatVrNv3z4mTpxI586d8ff3Z8yYMfTp04cvv/ySoUOHkp6ezqxZs/D09OTJaa8z9ONdtmOastO48OWTmHMyQKMBk6VgujWgNOdmErfgPltrSM9+E3AICiXz4Hqyj24DQOfXhKCHLQXcN07tR0t/KSkkhBBCiJLVmynv5XtjeW11FMYrQWRZM6C1DdtyyNgK07HtaFv1qbTzeX1EWJFTyr/++isuLi48+uij9O7dm2effZbOnTszceJEFEXB39+fRx99lJEjR6LuOtYuML7aZ/w2cs7sw5Ru39bRnJdjCybVTu549BoLgMbFyxZQKmaT5bErfcZnjgirtPcshBBCiLqpXpQN+jjiJNNWHsZgNJd72tqMCpXWAW2rPnTwd6iU83lxSGihpBe12vJP4eDgQOvWrQkNDQVAURQuX77MyZMnbbUn8/PzadmyJdtPp5Srz7jGzRetVwPL+8pJJ23Xj+REHyBt13LbPq5h4QDSZ1wIIYQQZVbnp7yX741l2srDlXa8MZ0b8vuhi+QZjSjliMc1ahVatYrXR4SVK4P6woULjBs3Dj8/PyZOnIhWq+Wpp56ifaeuHAx5ALCMPF746ilM6Qn4jZ6Bc0gPzi18yDZCWXANZd7laBJXzyX/crTd66id3PHsez9unYfaHlMBR2beKm0ahRBCCFGiOh0p/LR6HfeOvL3Y7R6978Wz73jbfcOlU6TtWIbh3L+Y83PReQbi0i4c926jUGl0APx24Dyd0nbxV4YH6qCwMq/F7NXc57q60QQFBfHZZ5/x0UcfMXnyZPz8/OjevTv3PfUST6+5AJS9zziA2tEVnW/jQgGlOSedrGM7cA7ticbFCyi+z7gQQgghREF1OqD8cvuZMu+bc3YfCT+/bktkAUsP79St35Ebexj/u2eiUmswoSIlqDtbxrXD5OJnyRY/kUBsUhHZ4j7OhIf4c3+P4Aolt7Rt25ZPP/2UTz/9lISEBDw9PYm6lAVcKFefccVkJP6H6RhTLoBGh//dM9EHhZJ54A9SNi/CEHuIxN8+IGDcG7bnWPuZCyGEEEIUp84GlCfjMzh8Ps1232vQ4zgENLfbR+vuB4A530DSmvm2YNKj11gcAlqQumMp+ZdjyD27n8z9f+B283BMZoUTGRrMrn608ndj5ogwZhJWYj3LyuTv7w+AgzYHKF+fca/whyzBJODYpANOTTsC4N5tFKnbv0fJN5AbvR9zfi5qneOV16kXy2yFEEIIUQF1NqBcGhmLWn21E7eDXxMcGxedsZxzag+mzGQAHJt1xrOfJTDTuHpzackLAGQcsASUUHQGtItee0Onhq+nz7g5J912W8nLvXrbmIdiMtlv0zla+oz7uFTwTIUQQghR19XZgDLieALmAmsbE3+biyknHbVWj0ODENx7jMGp6U0AGM79a9tP37CN7bZDg1ag1oLZSP7lGEy5mWgcXW0Z0DOpvpI6Lnotwd7OnE4PwuuWRwttL6rPuM73ajKQ4VwUqTuXow8KIfPwJjBbRmc1rt6onS2BcbCPsyTkCCGEEKJUdTJayDQYiU3OtnvMOgJpNhnJjd5PbvQBfIY+i2uHQRjT4m37aVw8bbdVag1qJ1fMWamWY6TGowl0BSA2KZssg7FaA67wUH/OpeagLUefcefWfck+th2AtO3fF3qeZ/8HUalUaNQqwkP8q/DshRBCCFFX1MmAMiYpy5Igo1ajD+6Ac2hPdF5BmHMzSd/zC3mXTgIKyZu+xLl1H5T8q9O/Ko39j8Sa3Q1gLrBfTciAHt89mMV/RZfrOb4jXiCjYWuy/t1q38u7QSvcu4zAqfnNgKUO5f09yl7eSAghhBD1V50MKK2ZyY6N2xF43xy7bU7Nb+bcpw+jGLJQDFkYzh9FdSUBBUAx5dvtX/C+usB+BV+nurQKcKNvS98i+4w3mvx1kc9RqTW4dx2JexGjmlYatYqezb1p4WcZjVUUBZVKZWsPKYQQQghRUJ2MDkrKTFY7uqLzCrLdN2enofUIsN03XZneBksbQnNOhu2+xvPqfqW9zo0yZ1R7tOrypueUTKtW8daoDuTn52Mymdi4cSOrVq1i+vTp/Pbbb5X6WkIIIYSo/erkCKU1Azr30in0gS3ttplzM8lPOW+7r3bxRN+oLRn/WAIlw/mjtm15F0/Ald7WOr8maBxdbdtqSgZ0Y29nZo0Iq9RuQOFul/lqwTv89ttv+Pj4oFKp8PLyYs2aNXzzzTds376dkJCQSns9IYQQQtRudTKgtGZARy79CrMhy5KU4t8Mc3Ya6Xt+QTFYEnbUTu62rG6NqzemzGRyz+4nZet36ANbklogacXtJvuOOzUpA3pc12ASMw3MXX+iwsfq4XyZL6Y9xLJly+jevTvdunXDx8eHF154gT59+tCvXz+Cg2VtpRBCCCGuqhkRURUID/Vnj0pFfsJZUjYvKryDWovP7U+j1ukB8Bn2nK1TTvpfP9nt6tisE66drgaUNTEDekp4K3xd9by2OgqjWSmxHeS1CvYZ7+iWzf7vW7F06VJWr14NwPTp09m0aRN33XUXTz/9NI6Ojnz77bccPHiQDz74oKrekhBCCCFqCZWiKGWPPGqRk/EZ9Hv5K7KitpIbcxBTZjJmQxYaZw/0jdvh0X0MDoEt7J5j6eX9w5Ve3oYie3lbbZzar0LtFKtKXHI201cdZvupxDL3Ge/b0teuz/jp06e56667cHJy4vbbb+e3335j8ODBPP/883h7ewOwf/9+evTowcMPP8zChQtvyHsTQgghRM1UZwNKgAmLIovMgK4IjVpFr+Y+LHm4e6UdsyqcjM+4rj7j1kzujIwM2rdvT1JSEo899hhz585FpVJh/XVRqVQcP36c8PBw+vXrx/Lly2/sGxRCCCFEjVGnA8q45GwGzduKoZLK+yiKgoNGxebnw22jebXB9fQZ/+KLL/jkk09ITU3l8uXLZGdnYzKZ0Gg0ALbbCQkJdO3ala5du/Lzzz/fiLcjhBBCiBqm+uveVCFrBnRlUalUeJz6s1YFk3C1z3inYC/CgjxKDSZ///133njjDfr168eqVauYN28eABqNBrPZbLsNlqnvnj17snLlSr7++mrtyyyDkagLaeyPTSHqQhpZBmMVvTshhBBCVLc6PUJp9XHEyYplQCsKqFRM7OzN62N7k5SUhJeXV+WdYA1jMpn44IMPuPXWW+nQoUOR+/z8888sX76cDRs2cPPNN/PII4/Q6ua+rDmeTsTxBGKTi5hm93YmPNSf8d2DaRVQ89afCiGEEOL61IuAEmD53tjryoBWKWZQzLw6rDWT+oXy7LPPMnHiRDp16lSFZ1uzWDvlJCQk8PfffzNr1iwSEhLw9fXlzTffxLdJKPN2XKpQIpAQQgghaq96E1DC9WVAm84d4Y4GWSx893VbYFXfnDx5kqNHjzJr1iySk5Np0aIF06dPp0uXLqw9nlqhUkWzRoQxrqvUtRRCCCFqs3oVUFqVlAGNoqDOTsYtMxbDkY209Hflu+++s5XLKZjlXF989tlnTJ48mQkTJjB69GhGjrT0Aa/wUoIrXhgSwpTwVhU+jhBCCCGqR70MKAsqmAGtVUPmxbN88O5b6PV62rdvT48ePdBoNGzevJnNmzeTkZHB7bffzpgxY+rVtPf+/fvt3u+yyBj+75cjlXb8d0a3Z6yMVAohhBC1Ur0PKEty9OhR3nnnHVatWoWTmyf9ho3BPzCIndu2Ykg6x+4dW3F3d6/u07whrNP9iqJwLiWnUDmmhBUzyTn9t+1+0KOfovNpTG7MIeKXTS/x2Bp3f1o8s5iNU/vLmkohhBCiFqqzrRcratGiRTz9yps0ueV+Wk1dSpJBxR6APKBHG1AUer+9kTE9QutF1rJ1il+lUjF91WGMBdZLZkZF2AWT5T62RoPRrDB91eEaXzBeCCGEEIVJQFmEE+eTeCcyC/9JH5GnVpFjKGIQV6UiQ9GzJDKGxX9F15us5ZPxGWw/lWi7b8pOI2Xjl4AKNBow2debdAhoQcD4dwodJ33vL+Sc+AsA51Y9MZkVtp9K5FRCRo1saSmEEEKI4tXpwubXY/neWIYt3E2eV1OAUjOXrdt3nUli0LytLN8bW9WnWK2WRsaiUV9NSErZ9CXmnHRcb7oVjYt3of3Vji44Ng6z+0/fIARDXJRlB5Ua185DAUvm9/e76/bPTwghhKiLJKAs4OOIk0xbeZh8M6DWlOu5JrOCwWhm2srDfBxxsmpOsAaIOJ5gC6JzzvxDVtQWNK7eeA2YVOZjZB3bjjknHQCn5p3ReQYClp9hxImEyj9pIYQQQlQpCSivWL43tlJK4ADMXX+CH+vgSGWmwUhscjYA5rwcktZ9AoD3kMmoHV3KfJyMfWtst906D7PbFpuULW0ahRBCiFpG1lBiKXj+2uqoIreZcjJIj/wfhvPHyLt4EsVoAMCl3S34Dp9a7DFfXR1Frxa+dWpNZUxSlq1mZ+rW7zClJ+Dcug/OIT3KfIy8S6fJu3AcAK1nII7Nb7bbrgDRSVmEBXlU0lkLIWqygqXbHLRqmvq44KKXryYhahv5q4VCWcsFmdIvk77753Ifsy5mLeddKROUnxRHxr41qB1d8R78eLmOUXB00rXTUFSqwoPkeQXKEQkh6h5bc4njCcQm2zeXUAHB3s6Eh/rXiwoaQtQV9T6gvDZruRCNFn3jdugbtsaUnUbWoQ1lOm5dzFp20FqCP1NmCihmzLmZnPtoQpH7XvjySXT+zQh66CPbY+bcTLKObgVApdXj2mFwia8jhKhbytL+VgFikrPrXQUNIWq7ev/NfW3W8rUcfIMJHP82XgMmom9QvvaAdS1ruamPCxVpOJl5eBNKvmXJgHObvmicCgfaqiuvI4SoW5bvjWXQvK3sOpMESAUNIeqaej9CWTBrubJZs5ZnElYlx7/RXPRagr2dOZ0ehNctjxbanrZzGebcTADce96NzvdqK0VFUcjYv9Z23+3m4UW+RrCPs6yfEqKO+Tji5HUnPZrMCiazwrSVh0nMNDAlvHwX9kKIG6Nef3MXzFquKtas5boSJIWH+nMuNQdt15GFtqXv/RWuBJSu7Qai82ls25YbfQBj8nkAHIJC0Qe2LPR8jVpFeIh/FZ25EKI6VHYFDT9XPWO7Bpe+sxDihqobUc51Kpi1XFXqWtby+O7BLP4rutzPK6lUkJXJrHB/D/miEKKu+GPLLia/Mp/smMMY0xIwZaej1jujDwrFvccYHBu3s+2b+Ps8so5sKvZYDZ9YhNYzoE5W0BCiLqjXAeWNyiauS1nLrQLc6NvSl11nkgotFWg0+etin+c/ZkaJx9WoVfRq7lNnEpiEuB51rYTOszPnkrJrld1j5px0ck7vJefMP/jdOQ3n0F7lOmZdrKAhRF1Qez+pKsGNyiaua1nLc0a1Z9C8rZW69lSrVjFnVPtKO54QtUVdLaFzMj6Di2k5aFy8cOk4BMdGbTHnZpK6YxnG5HOgmEne9FWhgFLj4oXvndMKHU/jamntWhcraNS1CwlRP9Xr31hr1nJVTnvXxazlxt7OzBoRxrSVhyvtmK+PCJMpLFGv1PUSOksjY3FvPxCvWx5BrXO0Pa7zaczFb54BwJSegCkrFY2L59UnanQ4Ni45kdFaQWPmiNqb8FhXLyRE/VWvA0pr1nJMCYk55vxcck7/DUBe/Bnb48b0BLKO7QBA3yAErUfRySR1NWt5XNdgEjMNlbLY/sUhobLIXtQry/fG8trqKFtDhfKW0Jk1IoxxVfw3k5yczKeffopKpeLxxx/Hx8enXM+POJ6ArmHbQo9rvYPs7qt0erv7pqxkzn00AVNOBhpXL5xadMGj971or4xQQu2uoFHXLyRE/VX3Ip1yCg/1Z0lkTLEf6OasNBJ/ebvQ44bYwxhiLSN0PkOfw7XDoEL71PWs5SnhrfB11du+GMszBa5Rq9CqVbw+IkyCSVGvVGcJHUVRiIuL4/jx4yQkJNCmTRs6d+5caB+VSsX27dv573//S4MGDRg9enS5AsqSKmhkH99lu61vFIbawcl+B5MRU1aK5Wb6ZTL3/0HOqT0EPvABWrer53A9FTROnDjBp59+yrlz52jUqBEDBgxg8ODBODvfmECtNlxICHG96n1Aeb1Zy2VRH7KWx3UNpncL31KvuK2s23s197G74jYajWi1WtuXmRB1UXWW0MnLy+Ppp58mIiICk8mEn58f+fn5jB07lpdeegmz2YxarUalUnHu3DmWLFnC7Nmzeeedd8jJySnXuRVXQcNw6RTJGz633NHo8Bp0tZ6t2tEF145D0Ae3R+PsSV78adL++gnFkI0pI4m07UvxGfqMbf/rqaCxatUqkpKSaN68OfHx8UyfPp2TJ0/y7LPPotFoUKvVLF68mO3btxMYGEibNm1o3bo1bdq0wcWlYkuXpBanqOtUiqJUdeWcGm/Cosgis5Yrwpq1XJ8yEW1rgk4kEJtUxJogH2fCQ/y566YAzhzYRVRUFH369MHHx4e2bQtPjQlRl8QlZ9Pn5a9JPbIVQ9yRUsvoFJSfeomLi6ag5OcCllquDR54H71Wzcap/cs0FZqfn8/w4cN59dVX6dGjB9nZ2cybN4+3336bo0eP0qRJE9u+X3zxBb/99hurVq3CwcGB9evXM2hQ4VkYsASqJ06cICYmhujoaKKjo4m6lMW/jezLg+XGRZHw8ywUQzaoNfiNfLnUDO/MQxtIWrsAsCTlNJrynd32KSE59G/XhObNm+Pt7V3qxWhGRgYmkwlPT08Avv76ax599FEOHDhA+/aWpMB77rmH7du3ExoayuXLlzl79iz9+/dn8eLFBAQElHj84izfG1upa87fGd1eZnZEjSMBJZYP+kHztmKoxPI+Zfmgr8ujcSVlLaakpNC3b1+SkpIYNmwYO3fupEGDBri7uzN48GCaN2/O7bffXs3vQIjKNWFRJL9+MouM/X8UvYNKXWwZnfjl/yU3er/tvjWgrOiFq6IoaDQadu/eTbdu3QBIS0ujY8eOrF69mg4dOqDX6/niiy+4//770Wg0ds83m82sWbOGESNGAKDT6QgODiawTRfOtZtg2y/n7D4ur3zT0npVo7MEkyE9Sj2/vMsxXFz0lOWOWkuTl36x237h66fJTzgLgJubG82bN+fBBx9k6tSpZf4ZaDQa1q1bx+DBgwEYPnw4N910E7Nnz7btYzAY0Ov1xR2iRH9s2cX4MtbitMo+GUnGvjXkXTyJOT8HjbMHDv7Nce8+BsfgduW6kBDiRqn3U95QPVnLSUlJ/Pnnn7Rv3952ZVyXuOi1xU5FeXl5cdttt7Fz506++uorFEUhKiqK1NRUHnroIU6dOsXy5cu55557bvBZC1E1TsZnsP1UoiWAK2cZnczDm8iN3o9K64BizLPbdr0ldKzT27/88gseHh40aNDAtu21117jwQcfpEOHDgD4+fmRnZ1dKJgEUKvV9OvXjx07dtC0aVMCAwPRaDRkGYy0m/knCpY1k5dXvwsmIyqdI35jZuDU9Cb78zFkY8pKQefd0O7xvAvHbbftMsGxzHqcPbSHS+diOHv2LGfOnOHs2bN4eXnZltAUpeCF/Keffoqzs7PtvWZnZ3Pu3DnOnTuHl5cXnTp1okuXLri7u5flx1qk8tbiTNm8iPQ99vubMpLIyUjCISgUx+B2UotT1EgSUF5xo7OWo6Ki+PXXX5k5cyYvv/wyDz/8cIVftzZ57LHHWLhwIf/++y9t27YlLi6O5cuX07BhQwIDA0lNTa3uUxSi0iyNjEWjVuESFl6uMjqmrFRSNn0FqPDoNZbUbUsKHft6Suio1WoyMjJ47bXXePLJJ2nY0BLInThxgj/++IMXXniBVatWcerUKQwGA6+++iqfffYZ33zzTaEkHg8PD3r37m33mLWCxr+71pP467ugmC3voc+9qDQ6cuOibPvqG4RgzsngwldP4RzaE6eW3dC4eJF36RRpf/1k28+5lX3wFOzjTMMAXxoG+HLzzTeX6X0XDCY/+ugj3n33XaZPn26bys7KyqJv377k5eWxYcMGli5dyoABA3jvvfeKDKhLU95anFlHt9mCSY2bD+5dR6HzC0bJyyUv4Sw6L0vgXxdrcYraTwLKAm5k1nK/fv3o1KkT48eP59FHH6VLly507NixIqdfK1hHRkJCQrjzzju5++67adu2LSdPnqRx48bceuut3HLLLXTt2rW6T1WIShNxPAGTWSmyvmJJZXSSN36OOTcDt87D0DdsU+SxTWaFPw7G0irjANHR0cTExNCyZUteeumlEs/pP//5Dz4+PjzzzDOo1ZbmC0ePHkWj0fDSSy/h4+NDSEgInp6eqFQqXnrpJVq1KnsySHioP/uW7L0STAIopEZ8U2i/hk8sstwwG8k+up3so9sL7aP1boRH3/G2+9dbQUOlUpGRkcHLL7/Mpk2beOWVV3jiiSdsgaa3tzevvvoqnp6e6HQ6li5dytSpU/Hx8eGVV16xC0gVRSErKwudTlfsdHh5a3Gm7VxuOU+tAwH3zrEbsS1UAL4O1OIUdYsElNeorKzlkuTl5eHg4MD+/ftZt24dM2bMsI0Q1HVqtZr4+HhWrFjB6dOnOXnyJE2bNmXq1Kl06dKFsDD5cBR1S0kldKD4MjrZJyPJProdjbsfnv0fJO/SqWKPcSnLxIRJj+Dt7kKTJk2KTR6xBkQfffQRERERfPfddwQGBtqmiAcNGkS3bt1wcnLCyckJvV7Pm2++ycqVKxk6dChubmUfDRvfPZi5Zbwm17j54DP8eXJO/EVewllMWcmggNYrEOdWPXHvPhq1/upn6/VW0Dh8+DBPPvkkJpOJL774gv79+9sucsGyntLPz+/qexg/ns2bN7NlyxZeeeUVu2Pl5+ezePFinnnmGRo2bEjz5s1p1qyZ3f83/Jtd5lqc+amXyE+MBSwBZ3rkSnLO/I05JwOdX1M8eo21G6WtzbU4Rd0kAWURGns7s+Th7mXOWr6/R3CZpx2MRiMODg6cPn2aoUOHMn78eKZMmYKvr2+VvJea6IUXXuCff/6hV69eJCQkkJWVxYMPPghAZmYmW7ZsoW3btgQEBFS4VIcQ1a24EjpQfBkdsyGb5PWfAuBz62S7YKooKpWKPf+epUvLwFL327ZtG5999hmzZs2iVy/LqJd1vaGLi4vtb85stowsNmjQgP3795OSkoKXl1ep79eqVYAbo557k11n/lOm2R7XduG4tgsvdT9rIlJ5p3p37drFQw89xG233cbs2bNxdXUFsAWTBVnfu1qtJicnB71eT25uLo6OBUYZdTpuvfVWvvzyS9v6zWPHjvHHH3+QkJCAysGJxlN/KjLxsqiLiNzYq2v48+JPkxd/+ur9iye4/L/Z+Az/j93P6HpqcQpRVeS3sAStAtyYOSKMmYRVSq9Vk8mEVqvFYDAwcOBA+vTpw2uvvYa/f90tfl6UZ599lhMnTnD77beTkpLCwYMH2bx5M0uXLmXZsmU0bNjQli36zDPPMHTo0Oo+ZSGuW14x1SMKldEZ8SL6wJYApO1egSkjEee2/XFqUbblHxqH0rOQc3JyeOyxxyyvn5vLE088wbFjx1Cr1bz11lt07351BMwaCA0fPpzff//9umZR5oxqz6B5Wyu1JJtWrWLOqPInMs6dO5cTJ06Qm5vL6dOnad68Oc2bN2f48OG0aNGCtLQ01q9fT48ePWjcuDEAO3fuZMuWLUyZMsUumATLz6dVq1ZFLgPIzMxk874TPPPHxULbir2IyM2y28+x6U24dx1Jzpl9ZPzzG6CQsvkrXNr0RaWxfPdcTy1OIaqKBJRlVFLWcmlycnJQFMXWjaF///54enoyd+5cmjZtWolnWTt06dKFLl262O5v2bKFhQsXYjKZaNCgAW+//TahoaH8/vvvPPbYY/z111+2D3ghahsHbeERsNLK6JgykgHI/ncrMf9uLfT8vAvHiXl7OF63PIp715HFvs611Go1J06coF27dixcuJCQkBAGDBhAx44dC9WCtQaU/v7+131RVx0VNIrzww8/EBsby4EDBzh8+DDHjh1j/fr16HQ6W5C9aNEi5syZQ0hICIGBgaxfv57mzZszceLEcr2Wq6srjZs2A+wDypIuIlRand2+3kOeROfdEMfmXcg+sQtTRhLm7DTyLkfbngPFX7AIcaNJQFnFFEXhk08+YfPmzfz222+MHz+e2NhYfvrpp3KtF6yMEdKaxmg0Mm3aNDZv3szs2bMJCQnhyJEjzJw5k6+//ppp06axc+dOXnvtNb7++uvqPl0hrktTHxdUYJv2LksZnfJSXXmd0uj1ett07o1yoytoFMfR0ZGQkBBCQkKKLEnm4eHBhx9+yN69e9m/fz/p6en85z//YeLEieh0uiKOWLJrA/zSLiK07n52+2s9LDNXKpUKjZsvpowkAEswWsLrCFFdandEUguoVComTZrEggUL8PT0xGw289NPP9GzZ89Si5rb1nAeTyA2uYg1nN7OhIf6M757MK0Cal/piGPHjrFy5UrefPNNHnroIbRaLaNGjSI5OZlZs2bx+++/M3HiRF566aUKFRYWojrs3LmTnTt34uPjQ0PPppxLzSXr2I4yldFxCeuPQ0Bzu+MZUy6QsW8NABp3f9y7jrQVxQ72ca7RF5g3soJGRVgDzvHjx5e+cykKXkiU5SLCwb8ZKp2jrRuSMf0yOq8gFEWxBZMAGver6+3LeiEhxI1Qcz+B6hAfHx/i4uK49957WbVqFY6OjiXWNItLzi41y1wBYpKzWRIZw+K/ounb0rfMWeY1RVRUFM2bN2fSpEl2RYjd3d3x9PREURRat27NwoULcXBwqMYzFaJ8Jk6cyJo1a7j55pvZv38/Xrc8hqZZT3JOla2MjlOzzjg1s6/3mBtz6GpA6eplm+q+3hI6N9qNqKBRk5S3FqdK64BLu3Ayr3RSSl7/Ke5dRpJzdj+mjEQAdP7N0HldzRAv64VEXe7KJmoOCShvoGXLlvHQQw/xwAMP8NtvvxUqEKwoCj/+HWe7igdKvZK3bt91JolB87Yya0QY42pJj9fw8HAmTZrE33//Tc+ePQHYuHEjc+fO5T//+Q/ZeSbwaoS/WxD/XkyvE9P8om6Li4vjkUceITc3l507d9KoUSMuXLhA+z6DCZhUeqvB63G9JXSqQ1VW0KiJylOLU+sZgGe/B8iNOYwx+Ry5Z/eTe/Zqu02VgxM+tz999b5ipoNv2Yqtf/PNN1y4cMHWVlKIqiC9vKvBr7/+SocOHWjWrJnd43fPXMReQ8llP8rihSEhTAkvewHi6jR58mQOHjyIm5sbLi4uxKblo209AG3wTZxLyalz0/yi9riedctxcXG8//77TJ48mZCQEACio6N54okncB8xnX/OZ1ZqxnNFe3nXBHVxfbjVyfgMOg0aRdaRTSXuZw0oAUw5GaTtXE72ib8wZSajdnTBsUlHPPvci87HPjnx/JdP0K9jCO+8845domNBiYmJ3HPPPfj5+bF+/XratWvHBx98IM0jRKWTgLKG+GbbCWb9cbLSjvfO6PZVvt6oMmRlZVmyvL/7kUuNwkly8EetgpK+c61TYbVxml/UbJWxbvnixYu23tinTp1i1KhRxMXF0bj1TWT2fw5FXf4Ej+LotWo2Tu0vfwM12IRFkew6k1TpFxI9mnox3DWajz76iAULFtC5c+dil1JlZGSg1+vJyMjgueeew2Qy8d133xXb71yI6yEBZQ0Ql5zNoHlbMRRR/iHv0mmyjm3HEHcEY1oCpux01Hpn9EGhuPcYY1uUf63a9EWzfG9shRbr16ZpflEzlWXdslXBC5rQ9H0EuGrx8fFh9OjRdvudO3eOp556Cnd3d55++mnUajUTZn5GTvtRlXbeteXCsT4r6fP9epXn8/3a9ZN//fUX/fr1Y/v27fToUTXLMET9JAFlDVDSFWzSuo/JPLCu6Ceq1PjdOa1Qj1eoPVNhH0ecrJRyIrVpml/ULNd7QaOYTagUMx6n1nP4l8948803mTZtmu3L22w2c/HiRRo2bGhr77dp0ybGvPolnv0mVPi8XxwSylPhLUvfUVS75XtjK7UWZ3kvJPLz822lj3bt2sWAAQOIioqyFWU3m838/fff7Nmzh4CAAO6+++5KO1dRf0gBq2p2Mj6D7acSSx4RcfHCvddY/O+Zhe+IF9F6N7JsUMwkb/qqyOeYzArbTyVyKiGjKk67UizfG1spwSTA3PUn+HFvbKUcS9QfH0ecZNrKwxiM5nJPSarUGtDoSAsdxgPv/MCcOXNIS0sDLKNCarXa1l3G2t7v0KFDtFViee32lui1ajTq8mXeatQq9Fo174xuL8FkLTKuazAvDAmplGNdTy1OazD59ddfM2HCBO677z5bs4gDBw7w2GOPMWTIEHbu3MkLL7xAgwYNmD9//g2vWSpqN1lAUc2WRsaWOMXmEhaO1y2PoNYV6CHr05iL3zwDgCk9AVNWKhoXz0LP1ahVfL87lpkjyl5A/UaJS87mtdVRdo8lrJhJzum/bfeDHv200CL07JORZOxbQ97Fk5jzc9A4e+Dg3xz37mN4dbWaXi18a8U0v6h+lXlBsyXZDY9Ot/P3338zaNCgIku0bNmyhW+//ZbRo0czqV8og9o1rjcldET11eK8ePEiP/74I//73/84ceIEDz/8MP/9739trSQfeeQRWrVqRUREBJ06dQLgs88+48iRI0X2OS+PupxwJQqTf9lqFnE8ocQPFsfGhYNBrXeQ3X2VruiC3yazQsSJBGZS8wLK6asO20ojAWRGRdgFk0VJ2byI9D2r7B4zZSSRk5GEQ1AoLk3bM33V4Ro/zS+qX1xyNi9/sZrUI1vLtD454+CfZB/bQX5iHOacdBRFQePqjWPjdnj0vAudT2M03e/FrYF95Ya0tDR++uknIiMjWbp0KdOmTePVV18F6l8JHXFja3Hu2rWLH374gRUrVtC0aVPuvfde7rzzTlu7X6PRyM8//8y+ffvo1asXr7/+Ou3bt+fZZ5/l8ccfJyEhASh/Dcu63pBDFE8CymqUaTASm5xd+o7XyD6+y3Zb3ygMtYNTsfvGJmWTZTDWqKtC6zS/lSk7jZSNXwIq0GjAZCz0nKyj22zBpMbNB/euo9D5BaPk5ZKXcBadVwO7aX754hUlmb7qMCn/rCXjShFpK3NOOjmn95Jz5h+79cnZ/24jN+ag3b6mtHiy0uLJPrGLBhPno/MM5MNdCXwb2sSWPavRaEhJSSE1NZV9+/bRpk2bQufSKsCNmSPCmEmYjOjUAzfiQuLs2bP06dOHxo0b88svv9jq/BZkNBr55htLTczExERuv/12li1bxqFDh/jpp58ICLCUMSprMFlfGnKI4sknVTWKScqivBlRhkunSN7wueWORofXoEdL3F8BopOyCAvyuK5zrArXTvOnbPoSc046rjfdRs6ZfZjSEwo9J23ncgBUWgcC7p2DzruhbVvBpKSaPM0vagbrBY2iKGhcvHDpOATHRm0x52aSumMZxuRztvXJ1t8tnX8z9MHtcPBtgkrvTH5iLKnbv0cxZKPk5ZB5aANeAyay80wy0ck5NPd14cKFCzRq1Ihnn322zG1DXfTaGvW3KqpOVV5IuLm58cQTT7BkyRKeffZZnnzySe6//367nuSXL19m8+bNzJ49m+effx69Xs+AAQPo27cvy5Yt48EHHyzz6xVMbIO63ZBDFE+ScqpRXjnLSOTGRRG/bDqKIQvUGvxGvIg+sPSF+eV9napWcJo/58w/ZEVtQePqjdeASUXun596ifxES8KNzqcx6ZErOffJg8TOHc3Fb/9D9slI277WaX4himO9oHEJCyfoiS/x6jcBp+Y349K2P34jX7LtZ12fDOB9yyN49r4X59BeODW9CfcuI3BtP8i2r5KXA1guaN5dtZtmzZrx/fffYzKZpAe9KJX1QqJTsBdhQR4VHpX29fVl4cKFpKamMmrUKF555RVcXFxYtWoVJpMJsEyJ+/r6cvvtt9t+R0NCQvDy8iIjo+zJnBVJbDOZFQxGM9NWHubjiMqrwyyqhwSU1chBW/Yff87ZfST89CqKIRs0Ovzu/L8iywVV9HWqWsFpfnNeDknrPgHAe8hk1I4uRT7HGkwC5MWfJvPgn5gyklCMeeRdPMHl/80m80iEbR/rNL8QRbFe0Dg2DrNLdoOyrU9WjPkYLp2yW/OrD+4AWL4g1+6PZsyYMUybNq3YQtNC3AgajYb/+7//48KFC/z22294eHjYfif9/f0xmUx2weOWLVvw8fEhPz+/TMeXSh2iIJnyrkZNfVxQQanT3tnHd3F59btgMqLSOeI3ZgZOTW8q02uorrxOTVFwmj9163eY0hNwbt0H55DiC+yac7Ps7js2vQn3riPJObOPjH9+AxRSNn+FS5u+qDTaGjnNL2qG0tYtl7Q+OT8pjgtfPmm3v1rvgnuPu3Bp3dv2mNYriDdmFj3aLkR1ufXWW+3ud+vWjfbt2/Pnn3/SsWNHEhMTeeONN3Bzc2PgwIF2++bn5xMVZanKYe0FXp7EttyYQ8Qvm17i+Wnc/XlVu1gqddRiNWfoqh5y0WsJLuUPJ+vYDi7/8vaVRBUVHn3uRaXRkRsXZftPMRZ/NRns41yjFvVbp9/zk+LI2LcGtaMr3oMfL/E5Kq19qzrvIU/i1KIrXoMeQ+PmA4A5O428y9GFXkeIgkpat1ze9ckAqDUUdUkYnZRVeF8haghFUXBxceGll15i+fLltGnThvvuu4/z58/z1ltv0bFjR7v9dTodb731Fp06daJfv36sWLGCaSsPkfLPWtJ3/4zh/DFMmclgNtoS2+J/mG53gVYalUaD0awwfVXlFYAXN1bNiTTqqfBQf5ZExhS79iTn1F5QrMGRQmrEN4X2afjEIrSeAYUe16hVhIf4V+bpVph1+t2UmQKKGXNuJuc+KrpryIUvn0Tn3wyf26bYPa71sLwnlUqFxs0XU0YSgGU5wDWvI0RBxV1o5MZFkfDzLMvvUDHrkzXu/gSMfwfFaCAv/gzpu3/GnJNO6tbvUDk44X7zHaW+jhA1gTVz+9Zbb+X06dPs2rULrVZLaGgoHh5Fz+wsXbqUe+65hw8//JDxTz5P0KOfljmxzSGgBQHj3yl0zPS9v5Bz4i8AnFv1lEodtZwElNVsfPdgFv8VXSXHNpkV7rm5QZUc+3pZp/nLw8G/GSqdI0p+LgDG9MvovIJQFMUWTAJo3H2BmjfNL2qOoi40cs7u4/LKN1HyDZb1ySNfLnIJhlqnt9WFdWrWGY2zB0lrFwCQ/e9Wu4Dy2tcpby2/a0k5IVGVevUqfT2+VqtlzJgxjBkzhqe+3sraE+nlarxxbU1lxZiPIe5KcwuVGtfOQwGp1FGbySdSNWsV4Ebflr7F9vL2HT4V3+FTy31clWImJ/ogdw1+kYULFzJgwIAS97f2Gq5q1mn+0+lBeN1SeEoxbecyzLmZALj3vBudbzAqrQMu7cLJvFIzMHn9p7h3GUnO2f2YMiz1LHX+zdB5WRIqato0v6g5rl23XJb1yYoxHzTaIgLCq/cLrvO99oLGbDZz6dIl/Pz8bGVbyhJgSoFoUVMdSTKjqNQVaryRdWw75px0AJyad0bnGQjU7IYcomTyrVsDzBnVnkHztpa75EJJHHRaPn/6dma99Afh4eEcOnSIdu3aFfsltmDBAg4ePMgdd9zBmDFjKu08ihIe6s+51By0XUcW2pa+91e4ElC6thtoa73o2e8BcmMOY0w+R+7Z/eSe3W97jsrBCZ/bnwZq5jS/qDmsFzQxydlkHdtB4q/vXllSYr8+2UrfIATD+aMk/fERLu3C0fk2Qa13Jv9yNGm7frLt5xDYwnbbekFjDRoPHDjA7bffzqVLlwC4dOkSn376KampqQwbNowhQ4bYnaMUiBY1WUUS2wrK2LfGdtut8zC7bTWxIYconSw0qwEaezszq5KH918fEcaQ3jezfft2Nm3aRPv27YsNJnNzc4mNjaVhw4ZMmTKFwYMHc/HixUo9n4LGdw8ud/CscXIjcMJ7uHUZicbdH9Ra1M4eOLfpR4MHP0DfIASwXN3e30MK5IrihYf6o1GrilyfHL/0Zbv/TJnJABhTL5K24wcSf3mLhB//S8rmRZhzLeVWNC5eePS933L7ygVNwRHIt99+mzZt2pCba1mycfjwYQ4dOkR2djYPPvggnTp1YsuWLYClDMugeVvZdcaylKO8BaKXS9kVUcUqI7Et79Jp8i4cB0DrGYhj85vttlsrdYjaRaUoSuUNi4kK+TjiZKXU9HpxSChPhdsnFJR1DVdycjITJkygZcuWLFiwoMLnUpwJiyKLnea/Xhq1il7NfaSXtyjRyfgMBs/fRuLv88g6sqnEfRs+sQg0Wksm67l/MaZfxpybiUqnR+cVhGPzzrh3vRON89VEho1T+9HS342DBw8yc+ZMtm3bxq+//kqfPn1s+2RnZ+Ps7IzBYOCJJ54gMzOTPo/PZt6mUxV+fy8MCWFKeKsKH0eIouyPTWHUp4Wztwslto18udhayUlrPyTz0HoAPMMfwqP76EL7rHqyF52CvSr35EWVkvHkGmRKeCt8XfW2FlblCbY0ahVatYrXR4QxtogWViUFk9ZgU1EUvL29GTFiBG+++SYvv/wyQUFBxT6vIqpiml+rVjFnVPtKO56om2zrlkf8B1MZ1yeXVtoKLH+DPZv7cPH4AaZNXsCBAwdo3bo169ato2vXrnZ/Z87OlqlpvV7PqFGjePzd79hbCcEkWApE+7nqi/wcqEkk0ah2qkhiG4A5N5Oso1sBUGn1uHYYXObXETWb/PXWMOO6BtO7hW+pa6isrNt7Nfe57jVUKpUKo9GIVmv5dUhKSkKlUtGgQdVliFun+aetrLyaY6+PCJM1ZKJMquKCRqWYSf7zY0a+uIYxY8bw888/24pAF5whUKlUmEwmNBoNeXl57PjnMNl5JlKWvFBicWiAzCObyY0+QN6lU5gykjAbDWjd/HBq0QWP3uNsI6Wvro6qkQWiJdGo9ruexLaCMg9vsgSegHObvmicCv87S6WO2kmmvGsw24fviQRik4r48PVxJjzEn/t7BFe4ZpfBYODw4cMsX76cBQsWsGDBAp588skKlTopi6qc5heiJMv3xlbqBU3SHx/SyBDL2rVradasGVB4qYk1kARISUlh3rx5zPtpI5nH/yr6oCo1fndOs00dxrw3CkxFNzLQegQQOHE+Gie3Grf8oyyJRlbW7ZJoVHP1fy+iyMQ2z/CJ6INa2+2rbxBia06hKAoXvnwCY/J5AAInzi9U7xWgiY8zW18Ir/L3ISqXjFDWYK0C3Jg5IoyZhFX69FB2djanTp1i+/bt7Nmzhz179pCcnEyXLl2YP38+kydPrtC5l/V8q3KaX4iSjOsaTGKmoVIuaCb3aUS6piuLFh2iZ8+e3H333Tz++OO0a9fObj+NRkNqaioLFizg+++/R+cbDE4eZSoODZbRTYdGbXEJC0fr1QDD+WOk7VoOJiPGtHgy/l6NZ9/xNapA9PK9sba/byh/otGsEWGMk7/vGsXakKO8jTdyow/YgkmHoNAig0mp1FF7SUBZS7jotZXWm9poNNK6dWuysrLo2rUroaGhTJ8+nSFDhhAQULjjTlld73RWdUzzCwGVfEEzrCOzZ89m3bp1fPDBB3To0IG5c+cyZcoUHBwciIyM5H//+x/Lli2jYcOGvPDCC5wL6MXXK9eVuTi035gZODXrbNvPqelNmHMyyPj7VwAMF0/YnV9JBaI//fRT1q1bR3x8PE2aNGHEiBGMHz/ebp+K1qetyAyE6cq/x7SVh0nMNEiiUQ1yvQ05SioVZCWVOmovmfKuhxITE7n11lvZv38/K1assKs7af11KM9Ud2VOZ93IaX4hrKpiSjY3N5cLFy7QvHlzduzYQb9+/XBzc2PlypXccsstwNWpw2uZ83OJe/8u2/3G/1lRYj2/5PWfAuAc2hu/Uf9n21bc1KGiKPTv359hw4bh7OxMdHQ069ev58knn7TNTpjNZj766CNWr17N6dOnadiwIRERETg4OBT7symospcUvDO6vcxE1CBSqUNcSwLKeuyLL77gueeeo1u3bixcuJC2bdsWuZ+iKOTn5xf5RVJwOut6RndKms6SLFBxo1XVBU1SUhKzZs3ixx9/xMXFhVGjRjHp0Se449sTRdb0yzyymaTfPwAsxaED7y/cB9kqftkr5MYcBMDn9mdw7Xi1ULoKODLz1iL/bjIyMnByckKrtRRh/+9//8sXX3zB+fPn0el0ZGVl8emnn2I0GomKiuLnn38mJyenTCXI/tiyi/GvzCc75nCpiUa5sYfJPLIZw/mjGJPOY033CLh3Do5NOtj202vVbJzaX2Ykaoi45GwGzduKoRL71su/ce0mAWU9l5+fzwMPPMBPP/3Ehg0bGDhwoN12k8nE0aNHGTlyJPPmzWPEiBG2bZWVUFOWunmKopCcnIyPj0+FX0+IsqiqC5oVK1bw0UcfEXniPA0mfVhou+HSKeKXvYJiyAKNjsAJ7xW51gwgZdsS0nf9CFjWpAXe/y4qtcZunzVP9ylxuYx1WnvDhg3cfffdHD161K7Cg9lsZu7cuXz++eecPn26TAFlyIDRnNy6quiN1yQaJW/8goy/Vxfa7dqAUkavap7KHoV+a1Q77u3WpNjtZa2nLKqHFHqq53Q6HcuWLSMqKoqGDRsW2q7RaPD09KRVq1aMHDmSESNGcPbsWZbvja2UYBIsdfN+LKXDR2pqqq3g+rJlyzAYDLZtck0kqoJ13XKnYC/CgjwqbXT87rvvZtu2bfy5sXBR9dy4KOKXTbcEk2oNfiNeLD6Y3LzIFkxqfRrhf9erhYJJgOzcvGLPxWQyoVarSU5OZsGCBXTv3t0WTFr/rtRqNRcuXMDX19fu8eKcjM/gYloOGhcv3HuNxf+eWfiOeBGtdyPLDlcSjaw0Lp44h/bGa+DDaL0LfwbZzrVAopGoGcZ1DeaFISGVcqznB7UqMZi8fPky77zzDkeOHKmU1xOVT+YPBQCtW7cudlujRo34448/WLlyJc8++yztegwg8KGPufZ6JC8hmvTInzFcOoUpMwUlPxe13gUH/6a4dhiCS9iAYl+jtLp5Wq2Wf/75h4kTJ7Jq1So+/PBDZsyYQZ8+ffDwqJxkJSFuJD9v+y4gZS0OrShmkv9cSOaBdQDo/JoSMO4Nu249BTk56Ip83FrCKCkpiUceeYTLly+zcOFCwD4Zx2g0cvHixTLXpV0aGYt7+4FlTjTy6HmPbZ+sYztKPHZpiUbixrtRlTo+/vhj/v33Xz7++GM++OAD7rnnnhL3FzeeBJSiTFQqFWPGjOHWW2/lltmruGRWUF0zvp2XcJasqC12j5lz0smNOURuzCGM6Ql2Xx4FGc0K01cdLnI6y9pZpFGjRjRt2pR33nmHVatWMWfOHNq1a8eYMWPo3bs3Li5SCFfUHgULRJe1OLRiNpH4+wdk/2vpNOIQFIr/PbPQOLoW+RoqoJlf4W2KoqDRaDh69CiPPPIIrq6uLFq0iHbt2hXK7DYajcTHxxcqgXStixcvcvToUf48nI+uYeH12Fpv+65bKp2+xOMVxWRWiDiRwEwkoKxJbkSljlmzZpGens7PP//MlClT0Gg0dgmlovrJlLcol4tZCvEq7yKn1jROrrh2vBWf4c/jP242vndOQ9/w6shnxt+/FXvckqazVCoVGo2GsLAwoqKiABg1ahS///47KpWKESNGVGnfcSGqgoteS7C3M1nHdnD5l7fBZARUePS5F5VGR25clO0/xWgpZn555RxbMKlx98Ozz33kX46x7ZeXEG33GsE+zkVO1atUKtavX8+wYcNo2bIl33zzTZHBJFiaHiQkJNC4ceNi30t+fj5//vkng24fzoWMoguvZx+/2v9Z3yis2Kz10sQmZZNlMF7Xc0XVaeztzJKHu7PhuX5M6N6EJj7OXLvaUYWl8sCE7k3YOLUfSx7uXqZg0rrMwt3dnYceeogxY8awfv36yn8TokJkhFKUy9LI2GKvPp1adMWpRVe7x3ReQbZpLnNeTonHLmo6Kzc3l3379pGYmMjFixfZvHkzmZmZxMbGkpmZiaOjI82aNePgwYOV8O6EuLHCQ/3Zt6TsxaFzTkXaHjOlXybhp9fs9tM3bkfg+LeBkgtEr169msmTJ/PMM8/w0ksv2R4vquakwWAgOTmZ4ODgYvfR6XTcd999NGjblcdXRRc+xqVTJG/43HJHo8Nr0KNFnldZKEB0UpZdopHZbGbv3r14eXkRElI5a/pKIhUoileZDTlMJhNgWctvNlv+RtRqNQ4ODmzdupWcnBwcHR0lUaeGkL8AUS4RxxPKtEZGUcyYMlPIOPCH7THH4PYlPqeo6ayYmBjGjRtHUFAQaWlppKeno9FoaNu2Lf7+/vj6+uLt7U2rVlL0WNQ+47sHM7eKcspKKhD99ttvc+HCBd577z2+++47AgIC8PX15cknn6Rv375oNBrOnTtHamoqycnJZGdn25JyiuPg4IB/YBAQbfd4blwUCT/PQjFkl5poVFZ515SqOXz4MFOnTiU+Pp7U1FSGDh3KK6+8UuLa8PKSPuTlV9GGHNY2pVZxcXEcOXKEzz77jBkzZuDkZBnlTk9Px93dvULnKipOAkpRZpkGI7FFFGG+1sXvnifvwvECj6hwatEFn6HPlvpc63SW9Sq2adOmzJgxg+DgYM6cOcOUKVNYuHAhWq220IeNELVNqwA3Rj33JrvO/KdMF2pNpv1epuNaS+wUVytzy5YtJCUlcebMGWJiYoiOjub06dNkZmbaRntWrVrFSy+9ZKuoMG7cOHx9fXnzzTcZPXp0kSOVDlr7x8qaaFRe176Ok5MTM2bMICwsjEuXLvHaa6/x7rvv8uGHH+Lq6lqhcjNlKXqvADHJ2SyJjGHxX9HSh7yCli1bxoYNG0hLS+Py5cukp6ejKAqJiYnk5+fz5JNPMmXKFNv+8+fP58MPP+TMmTMSWFYjqUMpyizqQhrDPio5CxOKCChVapxadsPn1qfQuHoV/8QriqubZzab+fPPP7n99tsByMzM5Ny5c5w7d46YmBjGjh2Lq2vRyQlC1FQ1vUB0cnIySUlJnDp1iujoaLp27UqXLl2K3DfLYKTdzD/LlWhUUMHPjmvrUFqVVKzdaufOnfTt25c9e/bYzjU9PZ0ffviBX3/9lQYNGvDYY4/Ro0fJwW1VNm4QRcvIyLBV7pg/fz4ajQYHBwdCQkJwcXHB09OTli0Lj3Dfc889bN++ne3btxe5XVQ9GaEUZXbtNFNxfG6bgjk3E2N6Ipn712I4f5Sck7tJyEiiwcR55X6dXbt2cfr0aUaOHGkLJv/880/mzp3LxYsXcXd3Z/fu3bRq1Yp+/fqV/40JUY0aezsza0RYpRaIfn1EWKWNjnl7e5d5WYk10ejfXetJ/PXdK2tD7RONrPQNQlBpdeQlxpKfaKlDa865mpSXG3cEU0665bit+9geLyrRSFEUFEWxjZo2aWKpZ2gdlVQUhXvvvZeDBw/y0EMPcfLkSSZNmsSPP/5Ihw6Fg1aQPuTVxc3NjUuXLtG7d2927drF8uXL7bZb11JaR52t///pp5947rnn6NixI5s2bSr1YkFUPgkoRZldO81U7H7+zWy3nUN7cm7BfSjGPPIunSQ/+Ty6EooXF/U6X3zxBTk5Odxxxx22x9q2bYvJZKJt27Y888wzTJw4kcjISAkoRa00rmswiZmGSmkW8OKQ0GrteV3eRKPso9tJ27ms0Pa0HT/YbrtcmeovLtHIbDbblsAcP36cZ599lu7du9O5c2cAvvrqK7Zt28aGDRvo0aMHOTk5jBkzhmnTprF27dpCx6vsxg1+rnrpQ14O/v7+HD58mG7dutG9e3f++OMPvL29gatJYdaLBZVKZatOMH/+fNLS0ujVqxfbt2+nd+/e1fYe6iMJKEWZFaybVxRzvgF1kbXlrq5dMudmlvgaqiuvU5CTkxMODg54enraPjgaN25MUFAQjRs3pk+fPgwZMoTDhytvhEeIG+1GFYiuajc60chaoF1RFL7++mtmz57NTTfdxJtvvolKpeL8+fMsXryYsWPH0qNHD0wmE05OTtxxxx289957gH1Lv7jkbF7+YjWpR7ZiiDtSai9ygPyUC6RuX0pu9EHMhky0br44h/bGo9dY1HrnUhs3iMIcHR05dOgQvXr1YtSoUaxdu7ZQrWHrv31+fj6XL1/m5Zdf5vjx4wQEBBAXF0d+fj46XdGF/UXlk4BSlJl1OiummMScS99OxSEoFMdGbdG4+2HOTiNj3xoUo2VRv0qrR+dTfC07KHo6q3Xr1vzyyy/A1avTrKwsdDodWVlZlucFB/PDDz8gRG12IwpEV7XyJhp59h2PZ9/xpe5XXKKRRqNhy5YtvPPOOxw4cIDZs2czfvx4HB0tXXpiY2M5fPgwr7/+OmAp1K7RaDhz5gxNmjQp1AVo+qrDpPyzloz9f9i9jjknnZzTe8k5849dL/K8+DNc+uH/LO0yrzCmXiI98n/knN1P4Pi3Mapdim3cIEq2a9cuNm3aZCshVJBGoyEmJoa5c+fy66+/4u7uzoMPPsgTTzyBm5tk2t9oElCKcgkP9WdJZEyRXxTmvFyyDm0g69CGIp/rNfAh1Priv/CKm87q3bs3ixcv5v333+f5558HLHX0/vzzTz777DMAevXqxbp1667nLQlRo1gLRNvK1JxIIDapiDI1Ps6Eh/hzf4/gYrO5q8ucUe0ZNG9ruUZZS6NVq5gzyr70WGZmJq+88go7d+7kpptu4rvvvsPPz88u+IiNjSUvL48BAwYAlvJGYJkab9SoEXr91VmVk/EZbD+VaOkk5OKFS8chODZqizk3k9QdyzAmn7P1IrcGlElrF9iCSdebbsOpRVfS96zCEHeE/IQzpO1cjtfAh2yNG2rav1VtcMsttxR67J9//mH16tW8//77tGnThvHjxzNz5kzbv2dRRfqtpI5o1ZCfoCiX8d2DWfxXdJHb3LuPIufUHvIT4zBlpwEKGlcf9A1b49bp9kLTRNcqrm5ehw4dmDhxIjNmzOCHH34gNTWV2NhYJk2axIgRIwDo2rUrH3zwQUXfnhA1RmUWiL7RblSi0YoVK/joo4/o2rUrTzzxhG2dXcGSYgkJCQQEBNimRnU6HZcvXyY6OpoxY8bYngPwfWQMGhW4hIWXqRe5MS2evPjTtu3etz6FSqXCoUErzn/8IKCQeWg9nv0fQKvTSR/ySrB3715+/fVXPv/8c5o0acLUqVN54YUXbJnh1kDy2mBS6ohWvZr7iSRqpFYBbvRt6cuuM0mFRh/cb74D95vvKOaZJSupbp6DgwPPPvssPj4+HDp0CGdnZwYNGkSfPlczP52cnGwL8IWoaypaILo63IhEozvvvBMnJye+//572whkixYteOuttxg8eDA6nY68vDxcXV05d+4cjRo1AuD3338nJyeHXr162R0v4ngCJgUcGxcO+orqRW4496/tvkNQqG0dptbVG62HP8a0eMy5meQnxqIKaC59yCuBTqdjyZIlPPfcc9x1112EhobathXM9LeSOqI3jgSUotxu1HRWQYqicP/99wOQkZNHbEoO+2NTasVojRD1VVUnGnl5eTFu3DjGjRsHWKaxV6xYQWZmpi2wGD58OF9++SUrVqxg6tSprF27llmzZjFs2DD69u1rO1amwUhccvHtYYvqRW5MS7h6vi6edvurXTwhLR6wrKl0CGheqHGDKL+bbrqJI0eO2K2RtCZVXVu8vmAdUaDU3z/r9l1nkhg0b6vUES0n+a0W5VYddfNOJWTyfWQMW45flukKIWqRG5loFBoayowZMwo9NmXKFGbOnMn777+Ps7Mz3bp144033rAl7gDEJGUVW8GiuF7k5vxc2z4qjX02sUp99evVnG9JTCyqD7koP2sDi+ICSbPZzCcRp3h/48nrOr7UEb0+ElCK63Kj6uZdz3RF7xY+vD26g0xXCFFDVHei0ZQpU3jiiSfYtm0bZrOZQYMGFdqnuMYNJfUiL7jGUjHl2z1PMRtttwuWUytrgwhRvII1KIvy0z/nrjuYvJbUES07CSjFdavq6azrna7460wSA97bxOxRHbm3m3wICFFTVGeikVarZeDAgcVuL6pxQ2m9yLUeV6tSmLJS7Z5ryky5up9nYImvIyrP1TqiWzDERZVaR1Qxm8jYt5asqAjyk+JQ8g2oHV1x8G+Ga6ehuLTuLXVEy0gCSlEhVTWdVZG2Z2YFUFT836rDJGXJdIUQNVFNSzS6tnFDWXqR6xu1td02nD9mm4I1ZiRiSr8MgNrRFZ2v5cJWBfjqFVJTU/H09Kzy91QflbeOaPK6T8g8tL7QvrkxB8mNOYh5yGQ0XYZJHdEykIBSVFhlT2dVStuzK1MhMl0hhCiLgo0bso7tKFMvcn1QKA4BLciLP40x+RzJ6z7GqWU30veswhqaunYYgkpj+apt7O3E/378gbVr13LXXXcxceLEG/9G67Dy1hE152aSeXij7fme/SbgEBRK5sH1ZB/dBkDG/jW4dR4qdUTLQAJKUWkqYzorLjmb11ZH2T2WsGImOaf/tt0PevRTW8edxN/nkXVkU7HHa/jEIl5drZbpCiFEqayNG3JOlb0Xuc/QZ22dcjIP/knmwT9t++j8m+PR25KBrlGrGBgaQBNNDn379uWhhx4iKirK1v5RVNzSyFg0alWZ64gqpnzbv7PayR2PXmMB0Lh42QJKxWwpkq9Rq6SOaClkMYeoEtbprE7BXoQFeZR5bdT0VYdtayYBMqMi7ILJ62E0K0xfVbGM9CyDkagLaeyPTSHqQhpZBmPpTxJC1CrjuweXuxyaQ0BzGjz4Ac5t+6N29gSNFq1HAO7dxxA4/m1bdzBr44Zhw4bRp08fVCoVbm5utvaxouIijidgMis4Ng6zCyah6DqiGjdftF6WtpvmnHTSdv1ITvQB0nYtt+3nGhYOWP79Ik4kIIonI5SixrBOV1iZstNI2fgloAKNBkzFB3EaFy9875xW+HFXb0xm5bqmK6SzghD1i61xw4j/YBo+tczP03k3xG/Ei8Vu16hV9GzmTUt/NxRFYdy4cYwZM4bHHnsMFxcX4GoJHHF9Mg1GYpOzi91eVB1RAL/Rr5C4ei75l6NJ3bbEto/ayR3Pvvfj1nmo7TGpI1oyGaEUNYZ1usIqZdOXmHPScb3pVjQu3iU8E9DocGwcVug/ldZSG846XVEWccnZTFgUyeD521gSGUPMNcEk2JcqGjx/GxMWRRJXwoeZEKJ2mDOqPVp15QZ2WrWKt0Z3ACzdfZydnXn11VcJDLya/W0wGMjOls+Q63U9dUTBmjTVuNBzzDnpZB3bgSnrara+tY6oKJoElKLGsE5XAOSc+YesqC1oXL3xGjCp1OeaspI599EEYt69k3MLJ5H05ycYM5Ovbjcr/PbPGczmkmvALd8by6B5W9l1Jsn2vBJf95rOCsv3li1oFULUTNbGDZVp5h1taeztzLx581i3bh3vv/8+bdq0sW3fsGED/fr1Y/jw4QwZMoS//67YMp/6qKQ6ovHLpqMYsgrVEVVMRuJ/mE720e2g0eE/7k0a/+dnvAY+DIAh9hCJv31QptcRElCKGqLgdIU5L4ekdZ8A4D1kMmpHl9IPYDJariTNRkzpl8nc/weXvp2KMSPJtkuiQcVNXbqzevVqFKVwoPhxxEmmrTyMwWgu9zoqk1nBYDQzbeVhPo6onIK6QojqMa5rMC8MCamUY03pG8y93Zqwf/9+nn/+eV599VUGDhyIRqMB4NChQ9x5552EhYUxbtw4evbsSf/+/VmxYkWlvH59UVwd0YSfXrUUpdfo8Lvz/2zlggByYw9jTLkAgGOTDjg17YjawRH3bqNQXSlGnxu9364jktQRLZ4sBBA1QsHpitSt32FKT8C5dR+7IsJFUTu64NpxCPrg9micPcmLP03aXz+hGLIxZSSRtn0pPkMtmX0qlQrXBs0YOXIk3bp1Y/bs2QwaNAiVSlU5pYqukFJFQtR+ldG44WblFF/953kGBS1n9OjRjBo1ikceeQRn56sVJ959913atm3LN99czSQ3GAxs2rSJu+++2+64N7oYfG1yPXVEzTnptttK3tWgUTHmoZhM9tt0jqiuvI4omvwmihrBOo2QnxRHxr41qB1d8R78eKnP8x70mN19p2ad0Dh7kLR2AQA5Z+ynjj7+9HNSTj7OK6+8wpAhQ+jXrx/PvvIGr20vfV1MSeWLriWdFYSo/SreuOF2hu77g86dO+Pm5sarr75KQECA3XO8vLxo3rw5AFlZWbi4uNCyZUtmz55NdnY25zNMkhxYBtdTR9RacB7AcC6K1J3L0QeFkHl4E1xpnalx9UbtbCnAH+zjLAF8CeQnI2oE6zSCKTMFFDPm3EzOfTShyH0vfPkkOv9mBD30UdHHanB1qsqUnW63Ta9Vc8sttzBw4EDWrFnDjBkzePLrrZYrV1XxUxnlLV9kLVUknRWEqN0q2rhh7dq1LFmyhIkTJzJv3jw++ugj3Nyubg8LC+Pbb7/lwIED3HTTTZjNZpYtW8bN/Ybw+LKSA9mCyYGL/4qmb0vfEjuQ1XXlrSPq4N8M59Z9yT62HYC07d8X2s+z/4OoVCo0ahXhIf6FtourJKAUNYJ1uqI8zIZsTFkp6Lwb2j2ed+G47bbGxdN2u+B0hUqlYvjw4bTq0pdbF+wo8XXKU77I9pzrLFUkhKiZKtK4YcKECXTo0IGJEyfy888/M2nSJC5cuEBQUBBPPPEEFy9epFu3btx7770cOHCA845N8Gx0B8p1JgfOGhHGuHq45GZ892AW/xVdruf4jniBjIatyfp3q30v7watcO8yAqfmNwNX64iK4qmUorIThKgG/d+L4HR0LNnHdxbalrZzGebcTADce96NzjcYx4ZtOf/F4ziH9sSpZTc0Ll7kXTplW0MJ4NZ5GN5DngSgiY8zW18ItzvuzNVRLImMKfEDO/G3uWRFbcH1ptvIObMPU7qluG1JU95gmf6a0L2JdFYQQtjk5ORw9OhRNm7cyOTJk3F1dQUgPj6e119/nfXnVeS3ub3Cr/PCkBCmhLeq8HFqmwmLItl1JqnciZUl0ahV9GruIzNOpZARSlFjhIf6cy41B23XkYW2pe/9Fa4ElK7tBqLzaYwxNR7MRrKPbreUfbiG1rsRHn3HAxQ7XVGwVFFRri1flHNmX5nfj7WzwkwkoBRCWDg5OWEymfjkk0+Ii4vj9ddfx2w2k5WVxbbzRvLbjKiU16mvyYFzRrVn0LytlRpQatUq5oxqX2nHq6skoBQ1RnmnKzRuPvgMf56cE3+Rl3AWU1YyKKD1CsS5VU/cu48u1PasoNI6K1xX+aJrSGcFIcS1unbtytq1axk1ahS7du0iKSmJNKMWz/HvY8rJID3yfxjOHyPv4kkUowEAl3a34HtN9x5FUcg8sI7Mg+vJT4oFVOj8muDWeTiu7cLrZXKgtY7otJUVa7db0OsjwurVz/B6ybecqDFsbc+KmK5oNPnrQvurNFpc24Xj2i680LaCrNMV165lLKmzApSvfFFxrJ0VwoI8ruv5Qoi6KSwsjBMnTrBy5Ur0ej2f/KvmeKqC6XIs6bt/LtMxktbMI+vIZrvH8i4cJ+nCcfKTYvENn1gvkwPHdQ0mMdNQKaXgXhwSWu9Gea+XVOgUNUpVtT0rarqipI4H5S1fVBLprCCEKM7o0aMJ6dKPf5OvNFTQaNE3bod7j7tw6TC42OflRB+0BZNqF098R7yI78iX0bha2tSm//Uz2eeP25ID65sp4a14e3R79Fq1XUvfstCoVei1at4Z3Z6nwltW0RnWPRJQihqlKtqeFTddUVLHg2vLF8W8PZyYt4fbEnLAUr7owtdPl/r60llBCFGSpZGxtqDHwTeYwPFv4zVgIvoGxSfV5J75x3bbrdNQXNr2x6VNX9y6WNdgWqbDNWoV3++uny1hx3UNZuPU/vRq7gNQamBp3d6ruQ8bp/YvNDKZnZ1davve+ky+6USNU5ltz0qarrieUkXlJZ0VhBClKS05sChmw9VmDCqdY4Hbetttw7mjtuTA+spaR3TDc/2Y0L0JTXycC33uq7BUAZnQvQkbp/ZjycPdCw1CfPbZZwwdOpTly5ffsHOvbWQNpaiRKqPt2esjwkpc+1Kws8K1tF5BeN3yaKHHiypfVBLprCCEKElpyYHFKVh/NysqApc2/UClIuvw1TWVxoxEQJID4frriJrNZtRqNXfeeSc5OTnMmDGD++677waffe0gI5Sixqrs6YqihIf6F3lcrbsv7l1HFvpP5XD1qtW13UBcw4pPCJLOCkKI0pSWHFgcl/a3oHZyByA/4SznF07k/CcPknfppG0fxZhn+T+W5EBh4aLXEhbkQadgL8KCPOyCSWtpbkVRbMEkQGBgIJMnT8bT05OPPiq6S1t9JwGlqNEqa7qiOOO7B1dqvbKCpLOCEKI015u0p3H2IGDcbBwCWhR4VIVzaC/bPbX+6nIbSQ4smaIozJ49m/Hjx/P777+Tk5NjCyYB8vPz0ev1DBgwgF27dlXjmdZc9Xf8W9QqFWl7VtpxiytVVJSiyhcVpbhSRUIIUVBFkvYcAprTYNICjKnxmHLS0Xo1IP9yNNnHLQFPwSU5khxYMpVKRUREBBEREcTGxvLss88yatQo7r77brp3745OpwNg06ZNTJgwoZrPtmaSgFLUOtbpisoinRWEENXFmhxYkU8frWcAWs8AAJIiV9ked2rZDZDkwLKaM2cOt9xyCz/++CORkZF8+OGHrFy5EkdHR9q2bcvu3bsxGo3079+/uk+1RpKAUtR71dFZQVEUVCrL5H12djY6nc52BSyEqD+uTQ405+eSc/pvAPLiz9j2M6YnkHVsBwD6BiFoPfxJ+N9sHAKa4xDYEsWYR9aRCHJORQKgcfXGreMQQJIDy6p79+40aNCA7777jv/7v/9j9OjRHD9+nL///pu1a9cyZcoU7rzzTlq3bl3dp1ojqRTrClQhaoGCi6Qr28cRJyuts0JZiuHu37+f6OhovvjiC86cOcO3335Ljx7X15FHCFF7zVwdxZLIGExmBWNqPOc/e7jE/X2GPodrh0Fc+Ppp8hPOFtqu0jvjf/dMHBu1RaNWMaF7E2ZWcn3fumr58uVMmTKFhISEKvuuqavkpyVqFbVazbFjx7h8+XKlH/tGdFbYt28fn3zyCXfeeSfjx4/n1KlTJCQkYDQaiYiIqOhbEELUQtebHOgSNgCHwJaoHV1Bo0Xj7ofrTbcR9NDHODZqC0hyYHmNGzcOBwcHNm7caHvMZDIBVzPAlyxZwnPPPceePXvIzc2tlvOsiWSEUtRY//77L3l5eXh4eODk5IRarcbf359bbrmFO++8k6efLr1LzfWIS85m+qrDbD+ViEatKvGD3rq9b0tf5oxqX+w0d05ODrNnz+arr77ikUceoU2bNgwfPpyLFy8yadIkunbtyrRp02jYsKHddLgQon6YsCiyzMmBZWVNDqxvvbwr6tChQzg6OtKqVSvbZ7F1duytt97inXfeISQkhJycHEaNGsXrr79ezWdcM0hAKWqsbt26cfbsWbRaLU5OTvj4+NCoUSPWr19Pv379GDRoEI6OjkyYMAF3d/dKf/2T8RksjYwl4kQCsUnZdovmVVjWJYWH+HN/j+BSs7kzMzN5+umn+fbbb9m9ezfdunUjKyuLcePGYTKZeOWVV+jdu3eZzqsys9yFEDVDXHI2g+ZtxVBZ5X0UBb1Wzcb/DChzGTVR2K5du/jvf/9LWload999N1FRUbRr144HHniAQ4cOcffddxMTE4Onp2d1n2q1k4BS1FgDBw4kOjqat956i7S0NP7991/S0tJYtmwZgYGBmEwmzp8/T1xcHA0bNiz9gBVQGUFceno6c+bM4f3332f69OmYzWYiIiJ46KGHeOihh0p8ri24PZ5AbHIRwa23M+Gh/ozvHkyrAClVJERttHxvbKUmBz7awYlX7h1YacerbyIjIwkPD2fQoEHcc889/PTTT2zcuJF9+/bZEnP69OnDsGHD+L//+79qPtvqJwGlqLFSUlJYsGABx44d49tvv0Wvt/SodXR05Pjx4zRp0qSaz/D67Ny5kxEjRpCfn88jjzzCBx98UOy+VTH9LoSouSqaHGhdMpO69Tt+fO0hbr311ko8u/rliy++4OOPP2bTpk34+fmRn5/PiBEj8PPz47vvvgNg8ODBDBs2jOeee656T7YGkKQcUWN5eXkxefJkQkNDuf322/nzzz8By1qWnJwczGYztel6yLqwOzAwkBYtWuDt7c38+fM5ffq0bVtBy/fGMmjeVnadSbI8v5S1Vdbtu84kMWjeVpbvja3kdyCEqGoVSQ5UoaBTw6QwB/6c9x+6du1aRWdZP1y6dIlGjRrZgkmdTsddd93Fzz//zAMPPEDv3r3ZunWr/JyvkBFKUeMZjUbef/9929rDGTNmcP78eQIDA6v71MrNbDYzfPhwjEYjzz33HLm5uYwePdq23Tq6UFkljF4YEsKU8FYVPo4Q4sYq1+yECkwK9Gnpy1syO1FpTp8+zU033cRff/1Fu3btALjvvvsICgoiKCiIo0ePMmzYMO68887qPdEaQgJKUWMpioLZbEaj0QDw5Zdf8vHHHxMUFMSyZctq5SLo7Oxsnn/+eZo3b86LL75ot81oNBIbG8vS3WdZdLjySlG8M7o9Y7tK2RAhaqOKJAdKxYiKGzt2LImJiTRv3hyNRsOWLVuYP38+t912myRIXkMCSlGrrFu3jg0bNvD+++9X96lUSG5uLo6OjnYf+IqicN+jT7PTcyBqnQOWr4sr+8ccIn7Z9GKP59H7Xjz7ji9ym16rZuPU/jJqIUQtZw1gYuLOs3vXTl6ePKnIAMZgMJCfn4+rq2s1nGXdcunSJRYvXsyPP/5I06ZNadm5D47th7DtZKIkSF5DAkpRIx04cIDVq1cTEBCAh4cHzs7OtGrViu+++45ly5axe/dunJ2dcXFxsY1g1gX3f7WbnacTUbAfVahIQCm16ISom9ZtjGDZ7xtJzchk3N13MSK8J88/O4WtW7fSvn173n77bZo3b17dp1knnLyQzIzVUUTGpEuCZDEkoBQ10muvvcacOXPo378/SUlJqFQq3NzciI6OJjc3l/79+5OTk8ODDz7IXXfdVd2nWylOxmcweP62IrcVDCi9Bj2OQ4D9l4TW3Q+th3+Jx984tV+p9TKFEDWbdQr8j0NxXMo0XjOlraDOSibMGy5uX4G3xsBvv/1mq5Ahrs/yvbG8tjoKo1kpV+F5jVqFVq1i1ogwxtWDZUf1d7Jf1Gj9+/dn0aJFtGjRgrlz5xIdHY3BYODdd98lNzcXHx8fTp48WafWBy2NjC31yhfAwa8Jjo3L15dXo1bx/e5Y6ecrRC1VVJJO4c8/FWYXH/7NV2Hq9gQJF6LYdfA44d06VMs51wUVSZA0XQlAp608TGKmoc4nSMoIpaixjhw5wowZM+jSpQszZswAYOjQoXTt2pVZs2ZV89lVvv7vRRCTnF3ktoIjlBpXb0w56ai1ehwahODeYwxOTW8q9fhNfJzZ+kJ4ZZ6yEOIGuN4RMswmdFoNb9zZvl6MkFW2yi40X9cTJGWEUtRY7dq144033uDNN99k7Nix/PjjjyQmJuLmZpm2rUsZjJkGI7HFBJPXMmUmA2A2GcmN3k9u9AF8hj6La4dBJT4vNimbLIOxXmchClHbVKiEmFpDvpl6M0JWmeKSs3n5i9WkHtmKIe4IxrQETNnpqPXO6INCce8xBsfG7eyek3VsBxl//0Zewhkwm9F6NcC14xDcOg9Dpdbw6uooerXwrbNrKqWwuajR2rdvz5w5c3B1deWpp57i77//pkGDBgB1JpgEiEnKosRxB7UafXAHvAY/jv89s/Ad8SIOgdYvB4XkTV9iziu51JACRCdlVdIZCyGq2vK9sZVSjxZg7voT/CjNDsps+qrDpPyzlvTdP2M4f8xyIW82Ys5JJ+f0XuJ/mE728V22/VO3LyXxl7cxnItCyctBMRrIvxxNysYvSPzd0g3NaFaYvqryRjxrGhmqEDWaoig0b96c+fPn88orr9CxY0dCQ0Or+7QqXZ7RXOJ2x8btCLxvjt1jTs1v5tynD6MYslAMWRjOH8WpWacKvY4QomaIS85mxo+7Sdm5AsP5Y+RdPIliNADg0u4WfIdPtdvfnG8gfc8qso/vxJhyEcWUj9rJDX1gK9y7jcKxSYc6P0JWWU7GZ7D9VCKKoqBx8cKl4xAcG7XFnJtJ6o5lGJPPgWImedNXOIf2Ij/5PGm7fgRApXPE65ZH0Lh4kbr1W/ITY8n+dytZIT1xad2H7acSOZWQUScTJGWEUtRoKpWKLIOR2Awzk16YxSc//EqrNu1Kf2It46At/5+i2tEVnVeQ7b45O61KXkcIceNNX3WY3NR4ywhZ3BFbMFmcy/97g7Tt35OfcBYlPxfMJsxZqZbRtOUzyD61t86PkFUWa4KkS1g4QU98iVe/CTg1vxmXtv3xG/mSbT9TegKmrFRyz+4HxXKx7ty6D2433YZzq+549B5n2zfzwDrgaoJkXSQjlKJGsnWHOJ5QL4rHNvVxQQXFTnsbLp1CH9jS7jFzbib5Kedt99UuniW+hurK6wghajbrCJlZpUXfuB36hq0xZaeRdWhDkfvnJZwlN/qA5Y5ai/egR9F6NSB998/kxhwCxUzm/rU4t+xap0fIKkvE8QRMZqXIahpa7yC7+yqdHrPh6vp3tU5fYJuj7bbh/DEUxYzJrCbiRAIzqXsVNySgFDVKWfrXKkBMcjZLImNY/Fd0nSge66LXEuztXGyWd8qmrzAbsnBtNxCdfzPM2Wmk7/kF5coHmdrJHX3DNiW+RrCPsyTkCFELWEfIHHyDCRz/NgAZ+9cWG1CaDVfXRjv4N8Ot8zAAFJPJElACypURNCkhVrLSEiQLrpvUNwpD7eCE1rvh1e0nd+N283DULl5k7v/D9riSn4s5NxONk3udTZCsW+9G1GoFS2MApZbHsG7fdSaJQfO21vriseGh/iyJjCn2fecnnCVl86LCG9RafG5/2u7K+FoatYrwkJILnwshagbrCFlZOfg3R613wWzIIi/hLBn71qL1CiRj7yrbPi5hAwDL52ZdHSGrDCUlSBounSJ5w+eWOxodXoMeBcC5VTe03g0xJp/HlJHEhS+fLPL5ijHP8n8sCZJhQR6VfPbVSxZUiRrh44iTTFt5GIPRXL46a1g+IA1GM9NWHubjiJNVdIZVb3z34GLfu9fAh3DrMhKdX1PUTu6g1qBx9ca5TT8aPPA+ziE9Szy2yaxwf4/aG2wLUV+Up4SYlVrvjN/oV9B4BIDZSPL6hST8+Cq5MYfQuPvjO/JlXMOu1qC1jpCJwopLXMyNiyJ+2XQUQxaoNfiNeNG2DEml0REw9g30wfYF5J1adEWldbDdV+uv9laviwmSMkIpql1ll8bwc9XXyuKxrQLc6NvSl11nkgoFlvoGIegbhFzXca29vGXNlBA1X6klxIqhdvFE590QU1q83eOm9MtkH9+JU4uuqB0sa/rq6ghZZSgqcTHn7D4ur3wTJd8AGh1+I1/GOaSH3T5aD38C75uDMSMJU2YSWnd/FFM+5xdOAkDj7m/7+Rf3OrWdBJSiWsUlZ/Pa6ii7xxJWzCTn9N+2+0GPforOp3Gh5+anXuLioimWjEbAISiUBg+8X6tLY8wZ1Z5B87aWe5S2JFq1ijmj2lfa8YQQVed6Rq5MORnEf/8y5twM1M6e+N8zE51XEKk7lpKx91eyj+1ArXfB5/anK/Q69cG1CZLZx3dxefW7YDKi0jniN2ZGiZ3JtG4+aN18AK5OjwPOLbvabtfVBMm6FyKLWmX6qsO2NZMAmVERdsFkSZLXfWILJguqzaUxGns7M6uSF8u/PiKsVgbXQtRH1zNylX18J+bcDACcQ3uhD2yJWu+MR4+7r+5zcneFX6c+sCZIgqXzzeVf3gaTEVDh0edeVBoduXFRtv8UYz4ASes+JiXiG7KP7yL7xG4S18wn45/fAEu2t1u3UbbXqKsJknXvHYlaw1oaw8qUnUbKxi8BFWg0V/6Ii5Z5eBO50ftRaR1sC51txzErtbo0xriuwSRmGiplGcCLQ0Jr5fS/EPVVaSXEimLOSbfdVvJyrj5e4LZSoJNWXR0hqyzWBMmcU3tt9SVBITXim0L7NnxiEVrPAExZqbZak3bUWnyGTUXnGQjU7QRJuUQR1cZaGsMqZdOXmHPScb3pVjQu3sU+z5SVSsqmrwAVHr3GFrlPbS8eOyW8FW+Pbo9eq7b7GZWFRgU6lcIg93ieCm9Z+hOEEDVGwREyc34uWcd2kHVsB3nxZ2z7GNMTbI8b0xLQ+Taxbcs6toP0f34j58w/JP/5ie1xh4Bmttt1dYSsspSUIFkc51Y90DdscyVpUmtJmmzbnwaT5uPSurdtv7qcICm/UaLaFCyNkXPmH7KitqBx9cZrwCRyzuwr9nnJGz/HnJuBW+dhxdZerAulMcZ1DaZ3C99S63JaqVEwo4KEk2gOrODrfX/x1iN34OfndwPPWghRUdYRMmNWGom/vF1ouyH2MIZYy7Ien6HP4dIuHH3DNhjOHwVTPikF1u4BoNbg0XcCULdHyCqLLUFyxH8wXdPisjiuHQbh2mFQifvU9QRJGaEU1aJgaQxzXg5J6yxX0t5DJqN2LH4qJvtkJNlHt6Nx98Oz/4MlvkZdKI3R2NuZJQ93Z8Nz/ZjQvQlNfJy5drxSBTTxceb2Vm6YVs/k3sBEtq5ZSVBQEDt27KiGsxZCVER5R8hUag3+497Ao894dP7NUOn0oNagdvHEOaQXgfe/i1PTjkDdHiGrTHNGtUdbztmh0tT1BEkZoRTVomBpjNSt32FKT8C5dZ9CpRgKMhuySV7/KQA+t05GrS850aQulcZoFeDGzBFhzCSMLIORW++6n+49e/PQxAdo6uNim76KWRlA8+bNCQgIoFOnTmzfvp1Ro0aVcnQhRE3ipmRdKSGmosm038v0HLXOEc8+9+LZ595i96nrI2SVyZogOW1l5SV41vUESRmhFNXCWrIiPymOjH1rUDu64j348RKfk7Z7BaaMRJzb9sepRdcS9732deoSF72WLi0CuXjkL8KCPHDUqsgyGIk8cZ4c5wD2nLxAlsFIz5492bVrV+kHFELUGI888giLFy+WEbIaYFzXYF4Ycn31f69VHxIkVYqiVF7BOyHKKOpCGsM+2kFuzCHil00vdX+dfzMc/JuTdWRTqft63fIo7l1HArDm6T51YoTyWn/++SdTZ77LzWOfJTbfjdjkbLusUBXg76wm58zf/O/t52gVICMSQtR0jz32GF999RVeXl7s2LGDg5kulTpC9s7o9nU+qKkKBdsCl2cpgkatQqtW8fqIsHrxc5cRSlEtrKUxqlJdLY0Rl5zNt7FuZA/4D9suQsw1wSRYpvvjs81kBd3M4PnbmLAokrhytnMTQtw47733HsuXL2fTpk107NiRL774grs7N+T5Qa0q5fj1YYSsqozrGszGqf3p1dxSsLy0yhvW7b2a+7Bxav9683OXEUpRbfq/F8Hp6Fiyj+8stC1t5zLMuZkAuPe8G51vMBpnD/IT4+z2M6ZcIGPfGsDS2sq960gcG7fDIbAFTXyc2fpCeKFj12YVvVKeNSKMcfXkw02I2mLNmjWMHj2atWvXcsstt/Dqq68yb948/v77b0JDQ2WErAY5GZ/B0shYIk4kEJtUeGYo2MeZ8BB/7u8RXO/WqkpAKarNzNVRLImMKfID8tzChzClJwDFt14E7KbMra0XwfJBOqF7E2ZWcteZ6vRxxMlKKXb+wpAQpoRXzqiHEKJi4uPjadCgAfPnz+eZZ56xPT5gwADc3NxYsmQJnp6exCVnl7mEmHV735a+zBnVvk4nglSnLIOR6KQs8oxmHLRquwTJ+qj+vnNR7cZ3D2bxX9FVcuy6Vhpj+d7YSgkmAeauP4Gfq15GLISoAQICAli3bh1DhgwBwGw2o1KpGDt2LG+++SbHjx+ne/fuNPR0ZMnD3WWErAZx0Wvr5Br96yUjlKJaTVgUya4zSeXuSlASa2mMJQ93r7RjVqe45GwGzduKoZiMdWNaAml//UTO2f2YMpNQ65zQegXiHNITj573FPkcvVbNxqn9ZeRCiBps0KBBpKamsnnzZtzd3QttlxGy6pOXl4fRaKlzrNPp0Ol01XxG1U8CSlGtSguWrkddC5ZKCrpzz/1LwoqZKIbCCTdazwY0fOLLIo9Z14JuIWqq4oK+o0ePEhwcjItL4cRBk8mERqNhw4YNTJkyhZkzZ3LvvfeiKAoqVVWnM4qSpKWlsXnzZrZs2cKFCxfQarX4+vpy6623Eh4eXuS/Z30hAaWodsv3xkppjGKcjM9g8PxtRW4z52Zy4avJmDKTQaXG9aZbcWrWGZXWAWPqJfKTzpVa23Pj1H4yLSZEJbNNSx9PKLKkl7smj4T9ETwzrDNTJozBza3ov0FFURg9ejR79uzh7NmzODg43JDzF0VLSUnhoYceYvPmzXh4eHDx4kVCQkLQ6/UcPHiQfv36sXjxYpo0aVL6weogKRskqp0Ujy3e0sjYYktUZBz80xJMAh597sPn1qdwDumJU/Obces8rNRgUqNW8f3u2Eo/ZyHqq7jkbCYsimTw/G0siYwptqRXmskBfbvBfB7nx5A5q9l/8mr1CusYj3Ut5SuvvELfvn0lmKwBXnnlFbKysvj333+JjY1l6dKlNG7cmN9//52srCzS0tKYPn06KSkp1X2q1UICSlEjTAlvxduj26PXqkut8XUtjVqFXqvmndHteSq8ZRWdYfWIOJ5Q7PrSnJN7rt5RFC4seorYuaM5t3ASKVsWoxjzSjy2yawQcSKhMk9XiHpr+d5YBs3byq4zSQClrwtXW75+L5hcGbNoHx+u+QfANqWtvrK9ffv2fP/991V01qI8tm3bxqRJk2jYsCE5OTncc889HDt2jJ07d+Lo6MhXX33FP//8w5kzZ6r7VKuFBJSixpDisfYyDUZiSyhGnp90dVQjbcdS8i/HoBjzMKVfJn33zyT87w1KW9ESm5RNlsFYaecsRH30ccRJpq08jMFoLneCoUqjxYSGD3Zc4v++32r7m922bRvR0dHo9Xq0Wkm0qQk8PDy4fPkyAE5OToAlOce6brJDhw6kpKSQn59fbedYneS3VNQojb2dq6U0Rk3MloxJyio0XVaQtfA7gNrRFa9BjwGQsvELzLmZ5J7dT87JSJxDehR7DAWITsqS0hdCXKfKKOllHZVcFpWJfsl62rtk8sQTT7By5UqaNm1aCWcpKsOYMWP4+uuvadKkCT169OD9999Hr9cTGhoKwPnz53Fxcam3iTkSUIoaqVWAGzNHhDGTsCoL9kpbOB/s7Ux4qD/juwdXWi/srKysMn/Y5JWS+a7S6lDyDQC4dhqKa7uBgGXkMv2vFQDkRh8oMaAsy+sIIYoWl5zNa6ujMOVkkB75Pwznj5F38SSK0fJ36dLuFnyHT7Xtn3loI0lr55d4zLcbhaFkJ/Psw5Po27dvVZ6+KKepU6dy6NAh7rvvPvLz83FxceHLL7+0Bf1HjhxhzJgxNGjQoHpPtJpIQClqvMouHluWjhMKlh7ZSyJjWPxX9HV3nLh06RJff/01P/30E5cvX+att97i3nvvLVPNstSkxBK3a9z9MCadA0Dr4W97XOt+9bY5r/T+3Q5aWfkixPWYvuqwpR3ilWUmlUGl0RI28U3efXdSpRxPVB6VSsXixYt57bXXSEhIoH379jg7X/1OGDZsGMOGDavGM6xeElCKeqVgT1wofeG8dfuuM0kMmre1zL2wrfXi3n//fXbt2sWkSZNo3749DRo0wGg0FhlQKorC8ePH+eCDD4iIiOB0zDka/2dFsXXnHBu2JfNKQGlMv2x7vOBtjbtfieepApr61M/pGSEq4mR8BttPXbno02jRN26HvmFrTNlpZB3aUORznFp0IWD8O4UeT93yDYbzxwBwDulJkoM/pxIypKRXDdWsWTOaNWtW3adR40hAKeqNivTCNpkVTGaFaSsPk5hpKLUXtkqlYtmyZSxbtozIyEgaNmxY6muoVCpMJhM7duxgyJAhhIeHM/+UI+fSDEXu79pxCJmHNgAKmfvWovNuBEDm/j9s+7iE9CrxNYN9nKt9ragQtZG1pJfJrODgG0zg+LcByNi/ttiAUuPiicbF0+4xU2YKhounAFA5OOHSbqCtpNfMEWFV+h5E+Z06dYodO3bg6upK3759CQgIsNv+zTffMHbsWLuRy/pCvklEvXCje2ErisLu3bvp378/KSkpPPfccyQlJTFw4EAefPBBGjduXOTzwsLC+Pfff233j6yOYklkTJEjqfqGrXHvPor0yJWYczNI+v19u+3uPe7CIbBFseeoUasID/EvdrsQongllfQqj4yD68BsqbTg0m4gar2zraTXTCSgrEkOHjzI8OHDycjIwGw24+fnx7fffkufPn0AS8b3o48+ytChQyWgFKK6WaeKK7PFmHXh/LXOLXwIU3rJdRgD7p2DY5MOhR5/dXUUvVr4FrumUqVSER0djZeXFy+++CKtWrViyJAhzJ49m507d/LBBx/Qpk2bUs99fPdgFv8VXex2r/CH0Pk2IWPf7+QnWoqU6/ya4nbzcFzDwks8tsmscH+PulVqSYgbobSSXmWlmE1kHvjTdt+t01DbbWtJL5lBqDmmTZtG3759+fbbb1Gr1Tz//PPceeedrFq1ir59+9qK0dfXvt7ymyrK7EaU1rEGkQWDSaPRSF5e3nVf8VkXzl8XTdHvz2hWmL7qsF0v7GuD4MGDB/PMM8/w6KOP8sEHH6DVaunQoQPPP/8833zzDe+++26pL98qwI2+LX2L7eUN4Nr+Flzb31K+t3Wll7es0RKi/Eor6VVWOScjMWVY1mHqg9vj4He1ZZ+U9Kp5/vnnHzZu3IhOp0NRFObPn09gYCCjR4/m119/pWPHjiiKIgGlEEW5kaV18vLymDZtGnv27KFz5868//777NmzhxUrVmAwGBg7diz9+/cv18il3cL5a/iN+r9C3WTyk8+R/MdHAGhcvdE3KLolpMmssP1UIktWb+D4nq3odDpee+01u30GDx4MQOfOnW2FicPCwujcuTO7d+8u83uYM6o9g+ZtrZTpNSutWsWcUe0r7XhC1CeVVWorY98a2223zoWzg6WkV82Tk5MDWAY9MnLyuOOBJ7lgcODOiVNYtOBtFEWpt4Xo6+e7FqW6kaV1rGbNmsXq1au57bbbiIiIYMGCBSxatAgvLy9yc3P5/PPPiYiIoH///mU+ZsGF89fSNyicWJN9dLvttmvHW1EVM0IJlumqZz/6Ge3BVYwaNarQ9hYtWuDr68upU6euHtPVlYsXL9KyZUuMRmOZPngaezsza0QY01YeLnXfsnp9RNh1/zsJUd9VRqmt/OTz5MYcAiwXr84hPavkdUTl6dixIyvWb+ePeNdrBllCcR7zBlO25hH46Oe8tf4UE3o0rbT6xbWF/LaKQsrbk/ba0jrL98Ze1+t+9913vPvuu3z88cd89tlnzJgxgzFjxrBr1y727dvHo48+yvz580ttJ1hQeRbOm/NyyYzabLmj1uB6020l7q9SawgdMJr4+Hg+//zzQtu1Wi2PPfYYP/74I6tWrcJkMvH333+zd+9ebrvttnJdxY7rGswLQ4oeLS2vF4eE1rk2lULcSE19XKjoCm/L6KTls8n1pttRqTV226WkV80Sl5yNdtBz/JzdhiWRMcRcM2MHllFLnVcDlu6JY/D8bUxYFElcJay1rS0koBR2KtKT1mRWMBjNTFt5mI8jTpbruampqaSkpDBo0CDAMk2cl5fHY489hslkwmw2M2nSJPbt21fmKe/yLpzPiopAMVj2dw7pidbNp9TnXMo0kp1nKnb7jBkz6NevH6+//jqhoaEMGjSIcePGcccdd5T5vKymhLfi7dHt0WvVpfY5v5ZGrUKvVfPO6PY8Fd6y3K8thLjKRa8luMAIvzk/l6xjO8g6toO8+DO2x43pCbbHjWkJdvtnHt5kuaPW4lbExauU9Ko5rIMsJ9Itn7s3apCltpHfVmFzo0vrFJSamoqPjw9ZWVm4u7uTmprK4MGD8fb2RqOxXLmbzWYyMjLKfA7lXThf2nqmopS2cN7R0ZHFixezd+9e4uPj6d+/P15eXuU4K3vjugbTu4VvqcsRrKzbezX3qdByBCGEvfBQf1tJL3NWGom/vF1oH0PsYQyxlqUqPkOfw7WD5YI5K2oLiiELAOfQnmhc7T8TpKRXzXEj6xfXdhJQCqD40joAhvPHSIv8H3kXjmPKTkOl1qL1CsS5VQ/cu49BrS86SCmttE5BJpOJ0NBQDh06RIMGDfD09GT+/Pm2vtdms5mDBw+W2p3AbDYTFRXF2bNn2XX8AlB0vcdr5cZFkX85GgCdbzCOwWVPWClt4bxWq6Vnz8Lro65XY29nljzc/WrC1IkEYpOKSJjycSY8xJ/7ewRLNrcQ12Hfvn2EhITg6upaaFtpJb1KUrD5QFEXr1LSq2aozkGW2killGdBmqizJiyKLLI0TW7MIeJ//C+Yi57WdQgKJXDC3CKnoa2laQqW1ilOfn4+sbGxuLi4EBgYWGj7pUuXeOONN/D09OTNN98s9jh79uyhe3fL67k2bo3P+LmlvjbA5dXvkf3vVgC8h0zGrfPQUp5x1Zqn+1R7aY8bUdJJiPriwIEDPPnkk1y6dIkvv/yS8PBw20xJQcV9blZEeT43RdXZsGMPY56cRs7Fk5gyU1Dyc1HrXXDwb4prhyG4hA2w2z8/5QKp25eSG30QsyETrZsvzqG98eg11jbooteq2Ti1f52dKZI1lMJWWqeoD8X0f36zBZOOTTrgf88svIdMBrUlWMm7cJy8+NNFHtdaWudUQunT1DqdjhYtWhQKJs+dO8fff/9NYGAgr7/+OjNmzCj2GIqiEBQUxM6dO7lw4QIXTxwq08J5U1Yq2cd3AqDSO+PSruSC4AXVlIXzLnotYUEedAr2IizIQ4JJIa7T+vXrGTlyJJ06dWLjxo106dKlyGASLCW9tOVcz1waKelVM8xcvJaMIxEYk85ZlieYTZhz0smNOUTib3NJ++sn27558We4uHgq2f9uxZydCiYjxtRLpEf+j0tLp2G+sjbfWr+4rpJvHVFiaR3rOh8At66jcGp+MwCZhzaQd+lK4k0xo5dAmXvS7t+/n61bt+Ln54e7uztOTk60bt2aGTNmsGvXLiIjI3F0dMTBwaHYY6hUKho1akSjRo1sjwV7OxNTSmJO5sE/wWRpfeYaNhC1g1OJ+xckC+eFqFuWL1/O2LFjbY0Hzp49C4Cnp2ehfaWkV910Mj6DU+mW0nH6xu3QuHphzs0kY+8vGM4fAyDj79/w6HkPAElrF9i+K11vug2nFl1J37MKQ9wR8hPOkLZzOV4DH7IbZKmLy5Dkm1CUWFpHH9zeVistY+8qVBoNxpRL5CVYPmR1vsE4BBTfL9pkVvh5178c+e41zpw5Q4MGDVizZk2h/ZYsWcJXX31Ft27dSE5ORqPR4OHhwalTpzCbzUyePJmsrCyeeOIJhg4t+3R0wYXzRVHMJjIOrLPdL2syDsjCeSHqor179zJz5kwOHDjAhAkTcHZ25vz580ybNo1x48bh6+tr1xVrXNdgEjMNlbLWTkp61QxLI2NxbdUNpxZd7R7XeQVx8ZtnADDnWQqcGwrM0ul8GuN961OoVCocGrTi/McPAgqZh9bj2f8BVBptmQdZaiMJKG+wmrbWrbTSOh7d78KUdpnMwxvJjTlkCy4BXNoNxCv8oRKLfwNk4kRKRjZdunThttuKru3Yq1cvvv76a0JCQhg3bhxnz57FaDQyd+5cdDqdrSB4eZW2cD7n1F5M6ZcBy5S+zrdsSTwgC+eFqG4V+TzdvXs358+fZ+jQoTg5WWYl4uLicHJy4tKlSyxcuJCxY8cydOhQlixZwnfffcfJkydZsGBBoTXjU8Jb4euq57XVURivZPaWlUatQqtW8fqIMAkma4hrB1kUxYwpM4WMA1eTqayJm4Zz/9oecwgKtf1uaF290Xr4Y0yLx5ybSX5iLA4BzTGZFSJOJDATCSjFdbiR7QvLq9TSOhotWp+GqB1dMeek223KPbsfQ+hxnFuVsnhcpeLDb5aVmLgyatQo/Pz8WLBgAUePHuXxxx8HLCOXw4YN48UXXyzjO7JXWi9s55AeNJn2e7mPK72whageFf08TUtLY9q0aXz++ecEBASwYcMG2rVrB0Djxo1xdHRk2rRp9OrVi+effx4nJyc6d+7MG2+8wa+//srhw4dp377wGkcp6VU3XDvIcvG758m7cLzAHiqcWnTBZ+izAHb1RTUunnbHUrt4Qlq8Zb/USzgENAcgNimbLIOxzi2XkqScKhSXnM2ERZEMnr+t2Mr6BdsXXk9lfWuSfnR0NO+++y7Dhg3jkUceYdu2bWV6fmklb9J2/EBqxDeYc9Jxu/kOGk/9iQaTPkTt4okpK4XLv7yFMTW+wq+j0Wjo378/zzzzDH/88QePPfYYACkpKbbRg+stSCAL54Wo/Srj89RsNrNmzRpOnz7NL7/8gtls5uuvvyY7++o+s2bNIisrC61Wa7dmu1+/fqSmpqJWF/+1aS3pteG5fkzo3oQmPs6FEgNVQBMfZyZ0b8LGqf1Y8nB3CSZrkFIHWVQqUGvgyveROT/36iaNzn5X9dWA0ZxvsN221i+ua+pWeFyDLN8ba5v+gPJX1p81IoxxZZj+UKlUHDlyhMcffxy9Xk+fPn04deoU9957L++99x733Xdfya9b4Je8KJkH/7TdtpY/cAhojnNILzL3rwWTkZwzf5e69rCsPWkHDBiAt7c3b775Ji+++CKHDx8mICDA9l6vhyycF6J2q6zPU7VaTadOnXBzc+OOO+4gOTmZyZMnM2bMGHr37g1AeHg4o0aN4q+//mLr1q0MHDgQsHz+ZGdno9frSz3fVgFuzBwRxkzCatwyJ1Gyawc/fG6bgjk3E2N6Ipn712I4f5Sck7tJyEiiwcR5qHWOtn0VU77dcxWz0XZbrbP/vSltkKU2khHKKnAj2xeazWYWLlxIdnY2a9eu5fXXX+ejjz6iQ4cO7Nmzp9jnzZ49m+7du9OrfasSR/5MBaa5C16JKVcWJMPVxcnFKU9pHbPZTIcOHfjss8+4fPkyrVu3pnnz5mV6bkmkF7YQtVNlf562adPG1vp04sSJNG3alAULFpCSkmJ73sKFC3F2dmbGjBl89NFH/PHHHzz//PPceeedNG3atFznICW9apdrBz8c/JvhGNwe13bh+I97A5XWMmqdd+kk+cnn0XpcTcw0ZaXaPdeUefV3SutpXxKvrIMstUnde0fVrLIr6/9YSg9QtVrNxYsXad++PY6OlislHx8fTp48SZ8+fYp93uXLl2nZsiUffvAeDdx0xe7n4NvEdjv5j4/IOf03Gf/8TtaxHVf3CSg54CtPaR3rdJKXlxeLFy8mIiKCjh07lum5pZFe2ELULlX5eZqfbxlNWrhwIT///DPbtm2zXVwHBASwfPlyOnbsyHfffceTTz5J3759WbhwIVqtBIR1WVMfF1TYT1Hbu/rdYc7NRN+ore2+4fwx2++QMSPRlvCpdnRF5xtsd4SaUL+4sslfRiUqqX0hWCrpp+1YRm7MQUzZ6Wic3XFq3gWPvvehdfMt8jllaV/48MMP8+KLL/L000+Tnp7On3/+SdeuXWnVqui+oYqisGDBAtv9S6ujii2t49F3PJf/NxsUM7kxB8mNOWi33bFJRxybdir23K6ntI79FJEjriaorM9wWTgvRO0Ql5zNjB93k7JzBYbzx8i7eBLFaPmSd2l3C77DpxZ6jqIoZB3ZTObB9eRdjgZTPmpnD/RBoXj0Hserq9W2z1OdToeiKAwYMIAhQ4bw7rvv0rVrV4KCgkhJSaFLly506dKFhIQEHB0dcXd3v8E/AVEdXPRagr2d+evdyTgEheLYqC0adz/M2Wlk7Ftj+x1UafXofBpfWQbWgrz40xiTz5G87mOcWnYjfc8quLIa07XDELtqKHW1frG0XqxEJbXhyos/w6UfpqEYCifcaFy9Cbz/PbSeAYW3lbEN119//cXjjz9O06ZNGTRoEJGRkezZs4dXXnmFiRMnlvjck/EZDJ5ffBJP7rl/SY9caenlnZOOSqNF6xWES+u+uHe70zYFUJyNU/uVmg1dHZnw0gtbiJprwqJIIv7aw/lFzxTaVlRAqZhNJK6eS/ax7UUez2f483h0GGj3eWoymdBoNERHR9OqVSvee+89UlJS2LBhA3PnzqVXr16V/8ZEjTdzdRRvPjDQLoP7Wt5DnrTlDli+3//PrhGIlc6/OYHj37a1X9SoVUzo3qRO1qGUgLKSlBaUXfr+ZQz/3959BzZVrg8c/2Y13Zu2FFo2BSnInrJkKIoIKAoCbq4Cet3I5XdVxr2AyhURFa/IvSoyLogoIA5Q9iggIFBWy2jKaumgK03S5OT3R2ho6V508Hz+Mcl5z8lJpMmT97zP81xwzF56tBuER6u7MJ7eQ+b1otpuzboQNOqdIvff/EofAnRWfH19CySn2O12Xn31VU6dOsW6devQarVkZGQwZ84c1qxZw6lTp4o46g3V1ZM2PsVY5tnC3s0DK322UBbOC1Fz5H6eWpIMpPzyKfoGrbAZ08g6sgkoPKBM2/st17Z+CYDWvyHeXR5E61cfxZSJ5dJpXJt2xK1xeyD/j9zcIuV9+/Zlx44dBAQE8OGHHzJ27Nhb9npFzRKTkEG38W+QHbuPnKR4bMY0wI7GMwB9g1Z4dRiCa1hkvn1yUi5ybefyG728PQNwb3VXvl7euUozyVIbyTdmJSmufaFiyb5R/FSjJeCeSag0Olwbtyfr+DbslmyyzxzAmn4VrXe9Avur7ApDXpxD7Ko5HD161FkzLa///e9/fPLJJ871PV5eXri5ueHu7s61a9cKbRuW1+wRbRk4f1ulBpQllda5VZnwpZG7cF4IUf1yP09dAsMJGTsXgIxDG50B5c3sVgvpe9cAjtp/IePfQ+N24xK1R6sb68lv7lQSFxfHyJEjOX78OPPnz+ell16qqpclaokWwV7c/+hT7D47rNTfiTr/BtQbVny95Lpev1iScipJce0LHY3hHdtUaq2zVpVKrclTt8ru7BF6M7tKja6RY3F4eHh4gaxslUpFt27dWLVqFdHRjlnQc+fOsXr1agYMGICHR8mLf3NL61Sm4krr3MpMeCFE7VLc52lhTBdOoJgyAHCp14SUXxcR/9E4DP96iCvLp2HK080kt1NJLrVazdChQ0lMTJRgUjhJ/eKyk4CyEpTUvlDj4YtK7wjq7DkmMg79hJJjIvPI5nzdZ3IzwgqTrfFk5CNj8Pb2LrQe47Rp0zh27BjPPvss3bp1cyblvPjii+h0RWdx53WrSuvc6kx4IUTtUdLnaWFykm98BpjOH8J4YgeK8Rr2HDNmwxESlk/L1zY2t1MJQHh4ODNnzpSkG5HPrZ5kqQvkknclKKmyvkqtwbvzMNJ2rQAg5ZdPSPnlkwLjbi6Kmm8bjsr6RV2W7dKlCz/++CMbNmzA1dWVfv36lat+Y1X3pC0sEz5x9XSyzxxw3g+dsAhdgKOndsafv2A8uZOcpHiU7HTsdjsaT39cwyLx6fEwuoCwUmXCCyFqhxI7lRRCMeVPhnC/oy+ebfqTGb0F4/FtoFhJ+e0LQp/+CCj581QIcEyyJGWaK2UC5HaoXywBZSUoTcV7n7vGYFdsZOz/wVl2QONdD42HH5bLjn+san3xl6ZLep7w8HAmTZpUyrMuWlWW1pm29qhzzSRAZvSWfMHkzYzHtxcoVWRLSyArLQHj6d3Uf/JDNIENmbb2aImZ8EKImq88HURU2jxXYTRaAu59EbWLK/qwNhhP7gLFSk7iWWzZ6c61lXWxU4mofFU9yVKXSEBZCUpT8V6lUuPX93F8ej5CTvIF1DpXtH71SfzfW84xeQuflvd5KktuT9rKLK0Tk5DBjtgk532bMY3UzYsdR9JowGYtsI8uqAn68EhcAhuh0ruTk2Tg2o5vsJuN2C3ZZB7ZhK7fk+yITSI2MaPOLnYW4nZRns+5vMmMGjdv1C6OJg9qFzc0bl7YshwdSxSz0RlQ1sVOJaJqSP3i0pGAshLkVtYvze8Wtc4VfYij04r5SiwmwzHH427e6Bu0KnK/6qqsX5k9aW/OhE/9bTFKdjqe7e8l++xBbOkFa375D3g23323xu2xXrtCxoF1wI0WkDdnbgohaqeyfJ7m0oe2gut72bLTUXJMqHWuKBYTtuvJOqi1aDz8gLrbqURUnaqYZKlrJKCsBLmV9eOKWUhujN1P1pFNuDXvisbLn5zE86TtWQV2x2UX724jiy0QXhMq61e0tE7ezM3ss3+QFb0Vjac/fv2eIvvswRL3t1tzsCTF5btErg9vB9zI3JyOBJRC1FS5NR+LYzFm4Ku1kmrVouSYnH/vloSzzjHW9ERn+1d9/ZZofYJwbdoR09k/wGYl5eeP8WjTn8xjvzuvfLg17YRapwdqxuepqNny/lvNe7syJ1nqmtv3lVey/hFBRbYvBECxYjy9G+Pp3QU2ube6C++uI4o8dnnaF9Y0eTM3FUs2yT87kpL8B09C7Vr8TEFOcjyXFk/M95ha74F394fxaNXL+Vhu5ubt/ActRE2yatUqvvjiC7p3787MmTOLDCbtdjvHjh3jrbfeYuPGjXj1exqvjvejZKWR9P3cAuPNhqOYDUcBCLjvZTzbDcR/8EQSlr6BLSuVrOitZEVvdY5Xe/jiP/AvQN34PBVVL++/1cICS5D6xTeTRSSVZGy38GLXVOgCwnCP6InGux5odKj07ugb3kHA/a8Q+OCbqNSaIve1KXbGda/dC3rzZm5e2/Y1tvRE3FvdhXvL7uU7oFrDzRfFcjM3hRDVJzo6mjFjxuDq6spLL71E27ZtefbZZ4vdx263o9fruXz5Mu+//z7rP5gCqrJ9Pel8Qwh54gM82g1C4+kPag0aT3887xxM/Sc/dLa2rQufp6JqnT17lsWLF/PDDz+wadMmYmNjAUqcXb/dyVROJVAUhbijUYSq07ii+FBY7qAuoCH1Rkwr87HrSmX93IzKnOR4Mg7+iNrVE/9Bz5VqX413EMFj38VuNWNJOEv63m9RstO5tu1rVC5ueHd6oMDzCCFuuJWX5hYsWMCGDRtYvnw5I0eOzLetqEvearWali1bEhUV5Xysd/Or7D6rotHUDaV+bq13PQLvK7o4eV35PBVVZ9asWaxatYrk5GTS09MJCwujefPm3HXXXQwfPpyIiAgURUGtlvm4m0lAWQnuv/9+UlNTMWk9UHq+CGotVNIvmbpSWT83o9KWmQp2BcWUyYWF4wsde2nxRHRBTQh9eiEAap0e1zDH2ki3Jh3RuPuQvHEBAMbj2/IFlJK5KYSDM3ngVCKGlEKSB/zd6R8RxNhu4bQILnuAZTAYWLJkCeHh4YwdOxZXV0dm9eDBg4mNjUWv15Oens7y5cupV68e/fr1IyAgoFTrKKF62sGK21tSUhJz585l4cKFPPzww+j1etatW8f333/P4sWL+fnnn1m4cCGRkZGl/nd8O5Fv3zLIMluJvpTGIUMq0ZfSyDJbee+994iLi2P16tUc3vkbk7sHVVowCXWnsn5u5mZZ2K05BdpMOtw4Ut6CxpK5KYSjecD4JVEM+nA7S6PiiLspmATH8pC4FCNLo+IY9OF2xi+JIr6U3WlMJhMff/wx9957L7NmzeKTTz4hNTXVub1Hjx5oNBrGjRtHREQEq1atYsqUKXTo0IE9e/aU+ktYOpWIW23NmjW0adOGp59+Gm9vb/R6PaNGjWLZsmV89913aDQahg0bxpUrVySYLITMUJagpF/5LjlhtBj1JiYXX3JycnhjZE92H/yMQ7YwsNsrFFzWpcr6uZnwZ9JD8RswocD2tF0rUEyZAHj3GIUuMBzzxRMk/7QQj8j+6AIboda7k3P1PGm7Vzn3cwlp5rwtmZvidrdyv8FZgBkocXYvd/vus8kMnL+NGcPaMLqEzxy1Wo3ZbGby5Mm0adOGQYMGceLECerXrw9AgwYNGDhwIB07dmT8+PE0bdqU+Ph4pkyZwmuvvcY333xT6i5e0qlE3Er169fn8uXLbN++nT59+pCTk4OiKOh0Otq1a8cXX3zBkCFD2LJlC2PGjKnu061x5Nu3CPEpxhKLmNoBs86bY2aFQR9up3fzQGaPaEvqzpX06jOKvTnhWBWl2ISbm9Xlyvr9I4K4cC0bbZcHC2xL3/8DXA8oPSPvRhcQhinuCNZrl0nbubzQ42k8/PDpPc5xWzI3xW3u4y0x5Q68bNc7gEz97ihJmWZe6N+iyLEuLi488cQT+Pv7o1aradCgARs3buSuu+7CxcVR+mzs2LHo9Xrq1XMUHI+IiOCdd95hwIABnDhxokxtYaVTibhVBg4cSLNmzXjnnXf47LPPiIiIyLe9cePGBAQEcP78+eo5wRpOLnkXYuV+AwPnb2P32WSg5F/5udmIu2Kv0ve9TcQoQSybOZmtbwyAhFOA44OtOLnbezYNYPMrfevkh19JmfA30/o3wKvTA7gEN0Pt5g0qNSoXN1yCm+HdYxT1n/kYnW8IIJmb4va2cr+hUmbxAOb9epr/7TcUOyYwMNB5e/z48fzwww8kJCQ4H2vYsKEzmMzVoUMHjEYjVmvBjlglGd0lnM2v9KVn0wBAPk9F1XB3d2fx4sUAtGnThnvuuYcNGzZgsVg4f/48X3/9NYcPH+axxx6r5jOtmVT2whep3bYq8isfcF7mfn1wSx67M4AhQ4Yw+i8vk1avnVTWB8YviWL32eRKXWifm7kpvbzF7Sg+xUj/2Ru4ums15osnsVyOwW41A+AROYDAoa/kG39l2VTM8ceKPF6jqRvQa9VsfqVvsesNczNd4+PjadSoEevXr+f+++8vcvycOXP45JNPWL9+PR06dCjjq7xBOpWIqpCYmMj58+fx8fGhYcOGrF27lmXLlrF3714yMjIICwvDxcWFcePG8dZbb5V8wNuQXPLOo1J+5V9fMznv19OYUv0wGAx0atGAPn2ksj5I5qYQlW3a2qOYriWQvvfbSjumVbEzbe1Rvn66K+fPn6dJkyYFxqjVahRFISwsjDvuuIN169YxYMAAZ7b3uXPn2LNnD/Xr12fZsmXs2rWLqVOnViiYBOlUIirfxo0bWbhwIb/88guhoaF89tlnjBs3jkGDBnH27FnUajWnT5+mf//+NGjQoLpPt8aSGcrryvorHxy9uNN2rsB84ThKjgmdbwgekf3x7joClUYHVgsDLHtZsuDdW/1yarSV+w1M/e5opR3v3ZFt5ZKWuC3FJGQw6MPtWJIMpPzyKfoGrbAZ08g6sgkofoZSF9S00FqwuSW6APSb3yM+ej/Jycm4ubkVGGu1WtFqtXz44YfMmzePXbt2ERwczNWrV9HpdNx7772kpKTQrVs3XnnlFXr27FnJ74AQFde6dWvuv/9+Jk6cyPz58zGZTLRv356tW7eSnZ3NhAkTGD58eHWfZo0nP+WuK+uv/OxzB0n8dqazTyw4inZf2/Y1JsNRgkZNR63RYmk3spij3J4kc1OIyrEsyoBGrcIlMJyQsY4WhRmHNjoDyuKo9e75gseb2RUbgd1H8NE/pqHX6wsdo9U6vkJGjx7Nq6++yoQJE4iOjqZ9+/asWrWKNWvW0KxZs0L3FaIm2Lx5M+np6cycORN3d3fefvttmjZtyvnz52ndujVXrlzhhRdeIDQ0lK5du1b36dZoElDi+JW/IzYJRaVFHxZZ4Ff+zZQcM8k/fugMJn16PopLcDOu7VxGztU4TOcOkXnoJ7w6DWVHbBKxiRmylucmkrkpRMVtOZVY7uUjloQzxC94DMViROtdD/eWPfDpORq13rFuUqXWoG10J/fc07/IY+Tk5PDRRx85ExkUReGdd97h6aefRqvVSjAparyVK1dy33334e7u+He/bt06fH19WbJkCY0aNSI9PZ0+ffpw8OBBCShLIFneFPyV79fvSfT1iy6bkR27D1tmCgCuTTri22c87hE9Cbj3ReeYjMM/AY7g55u9xWdM3q4kc1OI8ss0WzGUshh5YeyWbJTsdLBZsaZeJj3qO658MwXFku0cY0g2kmUuOitbURSSkpIYPXo0qampbN68mb/85S/OmUshajJFUWjUqBF9+vRBURxtew8cOMDEiRNp1KgRNpsNb29vunXrxpEjR6r5bGs++aun7L/yzReOO2/rG7R23nap38LRdlGxknM1DpspE1w92XI6kelUbseHuiLM352lz3STzE0hyiguOatAB5zS0Hj64dX5QfQNIlDrPTBfOE5a1BqwWcm5ep70/T/g22s04Ki1ez45izahPoUeS6/XM2fOnPK/CCGqSW5C15BxE7GYjGTnKHjo1cybN89ZT1Wj0WCz2fjtt9947733qvmMa77bPqAsz698a9qNemsaD1/nbZVag9rNEyXrGgC2awloQjydv/Il+7BokrkpRNlYrEq59qv34Jv57rs17QQqNWm7VgBgOvsHXA8oK/I8QtQ0xXe+O+rsb/9Y1zBahrhgtVpZu3YtGRkZjBwp+RAlue2/pcvzK9+eY3LeVmnyv4Uqjc55W7k+rqRf+SI/D71W3itR6WrSDxVFUdi5cyfnz59nyJAh1KtXD7vdXqb+wC7aylux5FK/pfO2zZhWZc8jRHUobee73P72X+45T+/mgQzwucqSjz7ilVcKVnkRBd32AWV5fn2rdK7O23ZbTr5tee+r84zL+zyHDh1i//799OjRg7ZtpX6iEFWl+BkJnDMSY7uF0yK46pdS5AaNUVFR3H333TRo0IAmTZoU6CpTlJSUFPbt28e+ffvYvf8P7G0mlCkItWYkg0qF1tM/3+OWS6ect/NddQEaB3iU+vhC1DQV6W+/T63h1XcWMb5n6VuF3s5u+4CyPL++tT7Bztu265e3wVFmQ8nOcN7X+N4Yl/s8FouFXbt28eOPP/L666/TqVMnli9fTv369ctx9kKIwpR3RmL2iLbFdocpjYsXL/Lbb79x9epVxowZQ2hoqHObSqXCZrOxe/du+vXrx5UrV7hy5Ypz280UReH06dP885//JCoqipiYGAD8/Pzo2rUr3iozGbii5JjIPnMAAEvCWef+1vREsk7uBEBfvyXWa1dI/HYGHq374tq0I2q9O+b4aMcayuvcWnR33g4PcJflJqLWqoz+9nN+iyNHoy+2v71wuO0/KRoHeKCCMl321je8g4w/1gNgvnjC+bjl8mlQbADo6jVC4+oJ5P+V7+LiwmOPPcZTTz3Fww8/zNWrVzGbzZXxUmqt3Ow6lUpVptkWIQpTkRmJgfO3MWNYG0aXo4KA3W5n7dq1zJ07l4sXL3L58mV69uyZL6AEyMzMZMGCBfz555907dqVs2fPOtsY3kytVuPq6sqpU6e45557ePvtt+natSstWrRApVIxfV00S6PisGalkfT93AL7mw1HMRscTQQC7nsZrU8Q9hwzmUd+JfPIrwXG6xvegXenoYCjqkL/lkFlfh+EqAkqu799PU+9VBYpwW0fUHrotYT7uxOXYiz1r3y35l3RePpjy0zBdO4Qqdu+Rh/SnGs7vnHu49V+iPN23l/5iqLg7++43PT7778zf/58wsLC8p1Tamoq165dK7TdWV2U94u0qC9WIUqjMmYkpn53lKRMc5lnJFQqFRqNhkcffZQRI0YQGRnJuXPn6NGjB3Djcve7777Lww8/jJ+fH02bNuX48eMkJycXuY6ycePG7Nu3r9DnHNstnC/3nC/1ObrUb4H/vS9gPL2HnOQLKFmpoFKjC2iIR+s+eHV+wLkO3KbYGdddvkBF7ROfYmTqFxtI2rUa85VYbJmp2HNMqPUeuAQ1xrPdYDza9HOONxmOknnsd8wXT2BNvkjuFFPwmNm4NmoHwNvrounZLLDCVzDqsts+oAToHxFUpl/5nu0GEnD/y85OOel7VuUb79qkA54dHAHlzb/ycwOmefPm4efnx4ABA9BoNM7tX3zxBYsXLyYpKQmAOXPm8Mgjj5TqddSkpIPS2L59O1OnTiUuLs45+9K4cWNsNhsajYbExESys7Np1KhRdZ+qqAVqwozE0KFDnX/PjRs35sCBA4waNQqdTodKpSItLY2dO3fy8ssvA3DXXXexbds2Z91GlUpVpuScFsFe9G4eyO6zKhpN3VCqfbza34tX+3uLHaNRq+jZNEBKdIlaadraoxivnCUremu+x5XsdExxRzDFHcGanohPD8d3q/H0nhK7S+X2t1/6TLeqOu1ar+ZGG7dQWX/lA7g16UjI+Hmk7Vx+vZe3OX8vb7XjS+XmX/m5XxwfffQRY8aMITz8xrYPP/yQDz74gEGDBvHGG2+watUqZs6cSdeuXWncuHGh51HTkg5Ka+vWrbz22ms0aNCAxx57jOXLlzNhwgT+85//OGds586dy7Fjx/j114KX5oTIKz7FyN//t5fUXasxXzyJ5XIMdqtjKUlh/azzMl88yZVvpoDdsfTCvXVv6j34ZrlmJDQaDTk5Oeh0Onr27MmBAwfIysrC19cXgG+//ZYmTZowcuRILl68yJUrV9i3bx/NmjVjyJAhLFu2rMzZ3rNHtGXg/G3l7phTGK1axewRkjAoap/czncqvSeed96DPiwSjacfiimTjP3fY754EoCMA+udAaXGwxf3iF7oG7Qi4/DPWFMuFjiuTbFL57sSSEBJ+X7lA+hDmhP08NtFbr/5V37uzNsvv/zClStXGDVqFG5ubgAYDAZmzZrFa6+9xptvvolGo+G1115j5cqV/Pvf/y5QPLg6kw4qw+rVq2nbti3z58/Hz8+Pe+65h+eee47XX3+dL7/8Ejc3Ny5fvkzLli1LPpi47U1bexTTtQTS935bpv3sthySf/rIGUzmVd4ZidwlG4MGDeL7778nKSkJX19fLBYL0dHRLF26lLVr12Kz2QgLC0NRFIYPH860adPy7V9aYf7uzBjWhqnfHS3TfsWZOaxNjficEKKscjvfuTXrgluzLvm26fxCufzfvwLk6wiVG1gCzuVthcntfDd9mDQqKYwsVrtu9oi2aEto/VdWN//Kz70UNmfOHO69915at3Z02VEUhS+//BKtVsvLL7/sHOfh4YFWq3Xez01eWbnfwMD529h9Nhkoe9LByv3V3woyOjqa1q1b4+fnB0CLFi347LPPOH78ODNnzgQgLi6O5s2bl+p4WWYr0ZfSOGRIJfpSWrHt4m4Xt8t7kjsjoai06MMi8e7+MB7tBpVq37Q9q8lJMqDSuhTYlndGAhx9qw8ePMiiRYt4/vnnnX+PN8v9e+3duzcpKSnEx8cDjoS8QYMGsWjRItavX8+ZM2c4efIkERERhIeH57taUVaju4Tz+uDK+fH1xuAIST4QtVZhne/sdgVrRrKzJTKAa3jZZ+Btip0tpxMrfI51lcxQXleVv/IVRWHlypV4e3vTrFkzdu7cyapVq5zBlNVqZfny5Tz99NO4u7tjtVrRarWcPHkSvV5PQICj17Vara7WpIPK5OHhgd1ud64ptdlstGzZknnz5vH000/TtWtXEhMTiw0oa+vl/qp0O74nuTMSLoHhhIx1rIHOOLSxxDVRliQDaXtWodLq8e46nLTd/yswRo2d5+Ytw7z7Gw4ePEh2djZarZZ27dpx9epVgoODCzmyQ2hoKJ6enhw/fpx+/fqhUqkYMuRGsp7N5qgIERAQwI4dO0hJSSEkJKQ8bwEAL/RvQaCn3pnhXpZL4Bq1Cq1axcxhbSSYFLVWYZ3vLn/9Wr46q6DCrVlnAu57qVzPIZ3viibvSB6ju4STlGmulIX9N//Kj4mJYcaMGahUKtzd3WnYsKFzW3x8PDExMYwaNQq4cclr06ZNqNVqWrRwBH4r9lV/0kFl6du3L1u3bmXy5Ml4eXmh0WhQFIV77rmH1157jddee43z589zxx13FNi3tl/urwq383tS2IxESex2hZSfPgKbFZ/+j6Nx8y50nIKKM0Y93Ro0YOTIkXTr1o2OHTs6l6oUfXzHOsiOHTuye/du2rZtS0JCAp06daJp06bY7TfOd8aMGWg0GoKCKl6iZ3SXcHo1Cyzx30Ku3O09mwbUiX8L4vZWqs53KhWoNWAv35pj6XxXNAkob1IVv/LVajXvvPMOb7/9Nl9++SVz5syhV69e/P3vf+ett97i+PHjNG3aFFdXV+f41NRUNm/eTMOGDenXrx/xKUamr4/Glp1BetSaUiUeGE/vxXhqJ+YLJ/L1H2/w/BK0vsHVWgbh5Zdf5v7778fLywu73Z7vC/bVV1/lxIkTLFu2rEANv+qqMViT1bb3JDs7G4PBwOXLlwkICKhQt6jCZiRKI+OPHzFfPIlLSHO8uzxI1rEtRY5VeQXxn38tK/WMhN1uZ9euXaxdu5bDhw+zfft2VqxYQYcOHViwYAFNmzZ1lhgCnGWFKkuYvztLn+l2Y7b6dCKG5EJmqwPc6d8yiHHdwyXJQNQJhXW+C7j3BRRTJtb0JDIPbcR88QTZMXtJzEim/pPzK+15hASUhaqqX/kqlYqnnnqKp556it9++42jR4+iVqtp3749RqORw4cPO2fkPvvsM+Li4nj99dfx9PTk+SVRjgA3/WqpEw8yj24mO2ZvkdurswyCoii0aeNY2Jy3oPnHH3/M5MmTWbx4MS+99JIzyIbqrTFYU9XE9+Tq1avExMSQmZlJ586dnXVXr169yltvvcWGDRswmUz4+/sTEBDAQw89xOuvv17m7GYo5YzETaxpiVzb/jWoNQQM+auzIkNRyjMjERUVxZYtW5g2bRqDBw+mXbt2t7y+aotgL6YPa8N02tS6kmJClEdhne9cgm7Uc3aP6MGFBY9ht1qwXIkhJ+UiOv8GlfI8QgLKIlX1r/wBAwYwYMAAwLHWatSoUUyfPp0zZ84QGxvL0qVL+de//sXw4cOJSchgZ6yjLiUaR+KBvkErbMa0YteJab3r4dGmH/oGrbm27WsUc1a+7dVVBuHMmTO88cYbNG/eHG9vb/z8/AgLCyMuLo6XXnqJHj16EBYWli/DuybUGKxpatp7Yrfb+fbbb/nXv/7FqVOnnDUXe/bsCYCbmxsdO3bk6aefpl27dphMJr744gumTJnC8OHDS5WAZbfbSUpKwmAwEB8fT1RsAtCwxP3ySt32FXZLNt49RuESXLoevWWZkVCpVM5lGzWFh14rl+hEnZe3852SY0at0xcy6saPVsWUWebnkP72RZOAsgS34le+RqPhww8/JCIigm+++YY77riDr7/+mnHjxgGw7Pdo5yxoWRIP/Ac957x9bdcKKKTDY3nKIJjNZj7//HO+/fZbYmJiGD58OLNmzXImD2VkZLB//35OnjzJX/7yF2ftzVzR0dF8//339OnTh+zsbEwmE3q9nrS0NDw9Pfn73/+OSqWiX79+TJkyhfgUI++sK/3lfrsth8wjmzHF/Ykl8Ty2zGRQbGh9gnGP6IV394drfdeDsr4n4Mhozj77B9bUS9iy01Gp1Gi86+HWuD3e3UdV+D1RqVTodDrGjRtH586d6du3LyaTybnd09OTZ555xnmp19XVlTFjxjBlypQi248aDAbefvtt4uPjMRgMXLhwId8xPRpGEDjuX2U6T1uGozpC+p7VpO9ZXWC78cQO4k7soN7I/8O9peNytMxICFHz5e18d+WrV3AJjcC14R1ovOuhGNPIOPij8zNSpdWjC3DUPLYkGchJclQ/UbIznMczxR/Dlp3uOHaruwDpb18ceVfKoKp/5U+cOJGJEyc6s7zBMSNTnqSD0sotgzCd0geUJpOJ9PR0HnroIVasWMGRI0fyrYGMi4tj5cqVJCYmMmnSpAL7d+7cmeHDh6PT6fjoo49IT08nIyOD999/nz179tCuXTtOnz6Ni4ujlMu0tUfLdLlfyc4k5ZdPCjyekxxP2u6VZJ/7gwaPv1+pl/tzS8jcfFnTZrNhsVicGb0uLi7O11URZX1PADL//BXrtcvO+3bAmnKRjJSLGE/voeGzn1T4PRk+fPiN49vtJCQk5NueG0zGxcURExPDf//7X1566SWaNWtW6PF0Oh2nTp0iPDycDh06EB4eTlhYGGFhYYSHh+Pu7UfbGb+W+bJ3WciMhBC1R27nO8ViIuvIpiInXfzufhq13vHj2XhiB2m7VhQYk7ZzufO2x9QN0t++BBJQ1kB5Z/SyLLZyJR2URVnLIPj4+PDqq6/i5ubGoUOHuHz5Mnr9jUsL9evX55lnnimyu09oaCjffvstzz77LE8++SRLly6lRYsW+Pn50adPH959913n2Nwag0CZLveDCtemHfFo3QeNpx+mc4dI37cWAMvlGNKPbmGHalCFL/dv3ryZefPmcfDgQVJTU/nxxx8ZPHgwAEajkddee42tW7cSHx+Pr68v/fr1Y86cOQX6t5dFed8TfcM78OxwLzq/BqhcXLFcOsW1nStAsWLLTCHjxE52uHpV+D3JLeDv5+fHxYsXC/RnP3z4MOPGjePSpUvodDpGjx7NtWvXCi2ZU79+ffbs2VPs8+XOSCg5JrLPHADAknDWud2anugsVqyv3xKvTkOdM4+5zJdPYzy+DQCX4GZ4RN6Nrl5jx/FlRkKIWiO38513txFkx+4jJykemzENsKPxDEDfoBVeHYbgGhZZ5mNLf/viyadkDVeepIOysgNfrvmR1iFeeHt74+XlhZeXFyEhIUUmEuTOsqWlpeHu7u6cebLb7QQEBDgvfxdFpVLxn//8h3feeYdBgwbxyy+/cOHCBSIiIoAbPc9zawyW5XK/SqcnZPx76Bu0dj7m1qQjOamXnUlK5ssx+LQfXOGuB9nZ2fTs2ZMJEybwyCOP5Hu/MjMzMRgMfPTRR0RGRnL58mUmTZrEiBEjOHDgQLmfszzvCVDgErhb4/aYL8c43xPFkl3oEgi73U5aWppz3aKPjw89e/YsMcmkfv36XLhwAZvNlm9sZGQke/fuRavVcuzYMZ566iksFgtz5sxxtigsi9wZCWtWGknfzy2w3Ww4itngqC8bcN/LeLYbWGBM5pHNzoBS6x+Kd5cHAWRGQohaxtn5Tj0M704PlGof395j8e09ttgx0t++ZBJQ1nC3qjzBq69PwXI5f4JHQkJCkbXxci9xX7t2jfDwcGdAmZule/Os1M1yx/3f//0ffn5+PPfcc2zYsMFZ+Dl33/Jc7lfr3fMFk7l0/qHkNttS61zLdbn/Zg888AAPPPAA2dnZ+S77AwQFBfHjjz8679evX58FCxbQs2dPkpKSCAwMLNdzVsYSCCXHjOXSKcwXTzgfc23UDpti57u9J7m4/kPnusX4+HgyM28sXh85ciR33XVXkcfOfR8aNWpEfHw8FosFnU7n3K7VavH09CQnJ4fOnTszadIk/v3vfxMbG0vnzp3L/FpyZySqgsxICFH7SH/76iEBZQ13q5IBfvv1F+q72cjIyHCuacwt91Kc9PR0vLy8CgSPpS2R4uLiwosvvoiLiwtms5kuXW70Xi1vjcHC2G1WjLH7nPddm3YCKq/rQd5AujgGgwG9Xu/sklQauR2F7HY76dmWCr0n2Wf/IHHVO/ke03j44dv3cfQhjizrNEXPoaPHCQ8NZtCgQQXWLZa2m0uzZs3YvXs3OTk5zteRtyyQTqdDURR27dqFRqOhadPSZVzfzDkjcVZFo6kbynUMz3YDC8xcyoyEELWT9LevHhJQ1nB5yyBUFRXQoUXDcgVVmZmZeHp6FqgfmBs8/P777/Tr16/YAFOj0TBp0iSefPLJfHUnK+tyv92ukPzTR1iTLwDgHtETt8Z3OrYBfYc+jDbjijNou/m/X3/9NXfeeWexz5H7+m+epcwrtw7jX/7yF+eMbl4Wi4UlS5bw4osvOp//ZrqgJoQ+vbC0L710NNp8561Sqfjqu43lTkDL/X/dqlUr1q1bh9FoxNfXF5VKxaFDh/jpp5/o06cPCQkJbN++nVOnTjF58uRS/YApisxICCHyqsrOd6JwElDWcHnLIAClTjzQ+gRhvhxzo0OONcc5NvvsH6jdvVHrXHFr1rlcSQe5QUNmZiY+Pj4FAiSVSoXNZuPZZ59l3759RV7eLViKyQUPvePYlXG5326zkrThXxhP7ABA37ANAUNfzTemcdPm+NoCUavVziLrubfVajVeXiXPUJUUUKalpTFq1CgaNmzIBx98UOgYjUZD7969+fjjjwucQ+5/L5h0LD5fhjfgJvrQCILHvovdYsR86TRpe7/Fln6VlJ8+QuPhi3vzrkDF3vv4+Hj27NnDzp07OXv2LA888AB2u53nn3+eIUOG8MMPP/DZZ5/h4uJCp06deOuttxg2bFj5XxQyIyGEKEj6299aElDWArlJBzbFjlKGxIOMPzaQdey3AmNTfv0UAI13EI1e+G+Zkw5ycnIwGAyEhIRgNpvR6XQYjUbc3NzyzURarVZSU1PZu3cvQ4cOdT7uLBZ/KhFDSiHF4v3d6R8RRLem5Z+xArBbLVxdO4fsM/sBcG10J/Ueegu1zjXfuBnvvFXhclDFBZS5JZYUReGnn34qcrZWo9EQGRlJZGTR2YfRl9JYvHBnuc9T7eqJa5hjzahbM8fygtxyGVnHtzkDyoostdixYwfPP/88kZGRTJgwgcDAQJo3b07//v0JCwtj7969Ze6IUxoyIyGEuJn0t791JKCsBWpa0sHx48fp1auXMxFlypQpvPfeezz00EMsXLiQ3bt3M2/ePMAxM7dkyRIOHTpEm259+S5ez85i/qjtQFyKkaVRcRV6zYolm6trZmGKOwKAW4vu1HvwTVRaXb5xlVVjMDdIvDmgzMrK4pFHHiE7O5stW7bkS04pj/IugSi6a0SeMde7RlT0PRk3bpyzKH9hqiKYzCUzEkLcXkrTslX6298aElDWAjeSDpLBN7jUiQeBQ18pUComr/ImHdx5551cvHiRjIwMTCYTycnJJCcnOy99+/v707x5c1JTU3n22Wc5f/48K/bFYTamwfW+ySV90Re2vbSX+9XuPiSs/DuWS6cA0NVrjHfnYZjzZLFrPHzR+TeocI3BzMxMYmJinIknJ0+epF69egQGBhIaGsoDDzzA6dOnWbduHefOncNut2O322ncuDFubm5lfr7yLoEwxR0h/cAPeNzRF51/Q1RaHeZLp0mPWuPcx+V6Uk5tr7soMxJC1H1GoxF3d3dUKlWJVUVySX/7qqWyF5dFIGqM+BQjA+dvw1yJZYT0WjWbX+lb5V+gH2+JqZTLkNZrCVz87JlixwTc9zKu4W1LHOcROYDgYa8yvlujCtWh3Lp1K3fffTdqtRqNRuNMpHnyySf5+9//TqtWrdBqtc7WgrlrITdv3kyvXr3K9ZzT10U7l0CU9j0BSN74YZFjtAENCRk/Dxd3rwq/JzWJzEgIUTe1atWK4OBg1q1bh4+PT6lmKkXVknC8lqitSQcr9xsqJZisCpVRY7Bfv37FlgrKzs4uclt5lWcJhL5BBJ7t78V88QS2jGQUsxG1ixvagIa4t+iGV8ehqPXuda7uosxICFH3/N///R9ZWVkkJCQQGRnJt99+S7dujpaxElhWH5mhrGUqa7bvjcERTO7fvBLOqGiFzaomrp7uvEQLEDphEboARxvCzGO/Yzp/GMuVWEfQYzWj9aqHW7PO+PQajca98vqo517ur6xe3rfa+CVR7D6bXKllcmr7eyKEqPvOnj3Lm2++Sc+ePbn//vt5++23WbNmDQsXLuT5558HbgSVpb0ULiqHvNO1zAv9WzB3ZFv0WjUaddl+hWnUKvRaNe+ObFvlwSTAtLVHseYJeDKjt+QLJm+W/NNCso79Tk6SAcWcBTYr1muXyfhjPVe+ehVbdkalnVttrzE4e0RbtGX8/1+S2v6eCCHqvuDgYIYMGcLAgQNp2bIlixYt4p133uHFF1/k2WefBRxLiy5fvszq1atJT0+v5jO+fcgMZS0Vn2Isc9JB7+aBtyzpICYhg0EfbnfetxnTuLR4Ikp2Bmg0YLMC+WcoDfNG4hLSHI82/dH61cd88SRpu1c6x/r0GlNiv9XSendk21qfybtyv6FSl0DUhfdECFF32Wy2QptC5OTksH79eiZPnkxYWBgrVqxg8uTJmEwmtm7deutP9DYlC4hqqZpeBmFZlCFfoJv622KU7HQ8299L9tmD2NITC+xT76G/49ako/O+W+P2KNkZZBz4ASBflnZF1JUag1J3UQhxu/j000/ZsWMHer2eJ5980rl+Xa1Wo9PpGDFiBE2bNuWll16iRYsW+Pv7c/Lkyeo+7duKBJS1XE1NOthyKtEZTGaf/YOs6K1oPP3x6/cU2WcPFrpP3mAyl84/1Hn75oLkZVFXawxK3UUhRF334osvsmnTJvr27cuuXbs4ePAgUVFR+UqvqVQq2rdvz6hRo9ixYwfr168vskObqBoSUNYhHnpthTu+VIZMsxVDbp1ESzbJP38CgP/gSahdy1Yw23hqt/O2W9NOBbZLjUGpuyiEqLtWrFjBihUr2Lp1K5GRkSQnJzN06FDOnz+P2WxGq9U6u4udO3eOt956i+nTp9OjR49qPvPbjwSUotLFJWc5L71f2/Y1tvRE3FvdhXvL7mU6Tur2pZji/gTAJTQCj7YD8m1f9FhHos6l1LjL/dWhpi+BEEKIskpJSWHJkiW89dZbzqAxJSWFo0ePMm7cOC5cuECzZs146qmnmDBhAteuXWPWrFm88MIL1XzmtydJyhGV7pAhlRGLdpOTHM+lLyaj1rsTOmERGg8/AC58+rRzDWXepJy8Un9fQvq+tcD1ottj3y1QNmjtxJ50CHccsyZd7q8p5D0RQtRmZrOZFStW0K1bN1q3bg1A06ZNadeuHbNmzUKj0TBjxgwuXbrEzz//jIdHxdvoivKTbxdR6Vy0jmpUtsxUsCsopkwuLBxf6NhLiyeiC2pC6NMLAbDbFVJ++ZTMwz8DjraJwaNnFVqDMvd5oOZc7q9J5D0RQtRmer2eJ554wlmo/MyZMwwaNIj33nsPHx/HZ9uoUaN49dVXSUtLk4CymklAKSpd4wAPylMh0a7YSNrwAcbj2wDHZe6gR2agcfUsMFZ1/XmEEELUbsVdTcnb9aZZs2Z8+umnaDSafMXLGzZsKAXMawAJKEWl89BrCfd350x6KH4DJhTYnrZrBYopEwDvHqPQBToyjK9+N5vs2CgANN718L3rMXKuxpFzfT+13gOXoMaAYy2gXL4VQojaybne+1QihpRC1nv7u9M/Ioix3cJpEXxjvXdu4KhSqbh69SpvvfUW48aNIyQk5Na+AFGArKEUVWL6umiWRsUVmm1c1BrKuLlDiz2mPiySkLFz0ahVjO/WiOnD2lT+iQshhKgyldWUY/369SxatAir1cqvv/56K05dlEDmiEWVGNstvFL7TOdlU+yM6y51E4UQojZZud/AwPnb2H02GaDE74jc7bvPJjNw/jZW7jcAjl7dBoMBb29vNm7cWLUnLUpNZihFlRm/JIrdZ5MrNbDUqFX0bBrA0me6VdoxhRBCVK2Pt8RUSlev1we35IX+LQBHFrher6/wMUXlkBlKUWVmj2iLVl2e9JyiadUqZo9oW6nHFEIIUXVW7jdUSjAJMO/X0/zv+kylBJM1i8xQiiq1cr+Bqd8drbTjvTuyrbQJFEKIWmLTzn08NHEq2ZdjsGWmYs8xORMsPdsNxqNNP+fYzGO/Yzp/GMuVWGwZyShWM1qverg164xPr9HO8nF6rZrNr/SVLl81jASUospV1qWONwZHMLl/80o4IyGEELdCr2ens3vJjCK3+/Z9HJ8ejwAQ9/4IsOUUOk7rE0zIkx+icfOSpU81lNRdEVXuhf4tCPTU8866aKyKvUxrKjVqFVq1ipnD2sjMpBBC1CIxCRnEpoPnnfegD4tE4+mHYsokY//3mC+eBCDjwHpnQKlSqXBpeAcebfqj9auP+eJJ0navBJsVa1oCGQfW4dt7LDbFzo7YJGITM6SFbA0iAaW4JUZ3CadXs8Ayl4vo2TSgQLkIIYQQNd+yKAOeLbri1qxLvsd1fqFc/u9fAVAs2c7H6z30d9yadHTed2vcHiU7g4wDPwBgvnzjSpdGreKbvQYpH1eDSEApbpkwf3eWPtPtRkHb04kYkgspaBvgTv+WQYzrHi6/PoUQopbaciox38SB3a5gy0wl4/BPzsdcw28kWeYNJnPp/EOdt9U6V+dtm2Jny+lEpiMBZU0hAaW45VoEezF9WBum0yZ/yy2NmsaBHtIBRwgharlMsxVDitF5//LXr2G5dCrPCBVuzToTcN9LxR7HeGq387Zb0075thmSjWSZrfKdUUNI2SBRrTz0WtqE+tDMV8Om1f/l5w0/kJmZWd2nJYQQogLikrModrW8SgVqDRSTF5y6fSmmuD8BcAmNwKPtgHzb7cD55KyKn6yoFBLWixohOTmZV199lcaNG7Njxw7Gjh1Lly6OdTd2ux2VqnLrWQohhKg6FquS737AvS+gmDKxpieReWgj5osnyI7ZS2JGMvWfnF9g/9Tfl5C+by0A2oCGBD38Niq1psTnEdVHZihFjeDq6oqrqytbt27FbDYzZcoUPv74YzIzMyWYFEKIWsZFmz+8cAlqgmt4Wzwj+xM0ehYqrQsAlisx5KRcdI6z2xWSf/7YGUzq6jUm5LE5zhqUJT2PqD4yQylqBE9PT9RqNSqVikWLFrFr1y4WLFiAwWBg9OjRdOjQQQJLIYSoJRoHeKACbDlm1LrCOtrc+DxXTI5lTnbFRtKGDzAe3wY4LnMHPTIDjatnoc+huv48omaQgFJUK4vFgslk4urVq2g0Gv744w8yMjLw9vZmwoQJ/PWvf2XFihXs3LmTRo0aVffpCiGEKAUPvZZwf3f2vDcJl9AIXBvegca7HooxjYyDP2K3mgFQafXoAsIAuPrdbLJjowDQeNfD967HyLkaR26p89wOO7nCA9wlIacGkf8TolpNnDiR/fv3o9frMZvNvPnmm3h7e2M2m9HpdDRu3Jhdu3aRkpIiAaUQQtQi/SOC2J1jIuvIJrKObCp0jN/dT6PWO+oM5waTALb0qySueiffWH1YJCFj5wKOOpT9WwZV0ZmL8pCAUlSrHj16EBwcjKenJ8eOHaNfv370798fi8WCq6srOp2OSZMm0axZs+o+VSGEEGUwtls4H3UdQXbsPnKS4rEZ0wA7Gs8A9A1a4dVhCK5hkeU6tk2xM667dE+rSaSXt6gxhgwZwrRp0+jdu3d1n4oQQohKMPRfP3M00VJohnZ5SS/vmklmKEW1UhQFRVHQarX89JOje4LVakWlUqHRaDAYDCQlJdGyZUs8PQtfmC2EEKLmsdvt9Pe8QnSCL3YqL6DUqlXMHtG25IHilpJ8e1Gtli1bxpo1a/I9ptVq0WgcHz4nTpxg3rx5HDlypDpOTwghRDmpVCpee+5J/vlQ+0o97sxhbQjzd6/UY4qKk4BSVKtff/2Vb7/9tsDjNpsNgLCwMC5cuMCff/55q09NCCFEKZS0cu6xbo15fXDLSnmuNwZH8GgXWTtZE8klb1Gt6tWrx6ZNm/jmm29IT08nMzOT7OxsMjIynP/duXMnnTt3ru5TFUIIAaSnp3PhwgVcXV1p2rQpKpUKRVFQq4ueo3qhfwsCPfW8sy4aq2LHppQ+fUOjVqFVq5g5rI0EkzWYBJSiWoWGhhIdHc0rr7yCWq3G1dUVd3d33N3d8fDwwMfHh+HDh3P33XdX96kKIcRtb+PGjbz55psoikJGRgbDhg3j448/LjaYzDW6Szi9mgUybe1RdsQmoVGrig0sc7f3bBrA7BFt5TJ3DScBpahWVquVzp07s2/fvuo+FSGEEMX4/PPPmTJlCrNmzaJjx46cOnWKyZMn06tXL8aMGVOqY4T5u7P0mW7EJGSwLMrAltOJGJKN5A0rVTiKlvdvGcS47uE0D/KqktcjKpcElKJa+fn5YbfbsVqtaLVaFEUpdJxKpZLWi0IIUU1OnDjB119/zfz583nqqacA6NSpE+vXr+ePP/5gzJgxJV72zqtFsBfTh7VhOm3IMls5n5yFxargolXTOMBDOuDUQvJ/TFSrIUOG0LRpU8w2OJWYJh8oQghRA4WEhNC1a9d869lzlyilpaUBlDqYvJmHXkubUJ9KOU9RfeQbW1SbmIQMlh3OYMspLYbffyl4ycPfnf4RQYztFk6LYLnkIYQQt9L27ds5efIkdrudESNGMHfuXFxcXACcV5XS0tJo2rQp4KjOkVvyTdx+JKAUt1x8irHERdl2IC7FyNKoOL7cc57ezQNlUbYQQtwiU6dO5YsvvqBbt2788ssv/PLLL3zxxRf4+fnlW36UlpaGv78/ABqNhpMnT9KyZctyz1aK2kv+j4tbauV+AwPnb2P32WSAEktH5G7ffTaZgfO3sXK/ocrPUQghbmfPPvssa9as4eeff+bHH39k//79fP/991y4cMEZTGq1jvmopKQkmjdvDsC8efO44447+OOPP6rt3EX1kRlKcct8vCWGeb+eLte+tut1y6Z+d5SkTDMv9G9RyWcnhBDi1KlTqNVqli5d6lwv2aRJE+69916MRiMXL14kICAAV1dXrly5gs1mIywsjGeeeYbvvvuOjRs30qVLl2p+FaI6qOwllbgXohKs3G9g6ndHK+14745sKwVuhRCiGOXNnj569CgRERG4uLiQnp7OwIEDiY2NpV69emg0GgYOHMicOXNISEggMjIStVpNWFgY27dvp169erfglYmaSGYoRZWLTzHyzrrofI8lrp5O9pkDzvuhExahCwgDwGQ4Suax3zFfPIE1+SJcT9cJHjMb10btAHh7XTQ9mwXKmkohhMjDWd/xVCKGlELqO5Yi2bFt27YA5OTk8Oqrr+Lt7c2ePXuoV68eX3zxBcuXL+fQoUPUr18fq9XKM888w6JFi6r+xYkaTWYoRZUbvySK3WeTneshM6O3kLz+X/nG5A0oUzZ/TsaBdQWOkzeg1KhV9GwawNJnulXx2QshRM1XmmTHXLnbS5PsmJycjL+/v3Pt5OXLlwkLC+Orr77i0Ucf5dSpU7Rp06bSX4+ofSQpR1SpmIQMdsQmOT/cbMY0UjcvBlSgKXyCXOPhi3tEL/zufgatf4NCx9gUOztik4hNzKiqUxdCiFqhKpMd8waTAOfOnaNr16507NgRrVYrwaRwkoBSVKllUQY06hsfRqm/LUbJTsez/T1oPPwL3cenxyPUG/E3vLuOQO3qWeSxNWoV3+yVrG8hxO3r4y0xTP3uKGarUmIgeTObYsdsVZj63VE+2nyq0DF5g8mjR48yefJkmjdvTosWkhgp8pOAUlSpLacSnR9y2Wf/ICt6KxpPf/z6PVXhY9sUO1tOJ1b4OEIIURut3G8od+WMm33wWyyvL/qu0Pa3v//+O1OmTGHgwIF0796dr7/+2lk2SIhc8i9CVJlMsxVDihEAxZJN8s+fAOA/eBJqV49KeQ5DspEss1XaNAohbivxKUamfrGBpF2rMV+JxZaZij3HhFrvgUtQYzzbDcajTT/n+Iw/f8F4cic5SfEo2enY7XY0nv64hkXi0+NhtP4N+eGCnpeumQqsqezZsyfLly9n0aJFjBw58ha/UlFbyLewqDJxyVnODMNr277Glp6Ie6u7cG/ZvdKeww6cT86SPrBCiNvKtLVHMV45S1b01nyPK9npmOKOYIo7gjU9EZ8ejwBgPL4dU9yf+cba0hLISkvAeHo39Z/8EG1gQ6atPVog2dHV1ZV///vf0lZRFEsCSlFlLFbHpZOc5HgyDv6I2tUT/0HPVdnzCCHE7SA32VGl98TzznvQh0Wi8fRDMWWSsf97zBdPApBxYL0zoNQFNUEfHolLYCNUendykgxc2/ENdrMRuyWbzCOb0PV70pns2Dwof0khCSZFSSSgFFXGRetYomvLTAW7gmLK5MLC8YWOvbR4IrqgJoQ+vbDczyOEELeD3GRHt2ZdcGuWvyuNzi+Uy//9K+BYapTLf8Cz+ca5NW6P9doVZ4k2+/WxucmO04dJ9rYoG/kmFlWmcYAHqpKHVYjq+vMIIcTtIm+yYy67XcGakUzG4Z+cj7mGty10f7s1B/OV2HzNJfThjhq/kuwoyktmKEWV8dBrCfd350x6KH4DJhTYnrZrBYopEwDvHqPQBTpaKVqSDOQkOcoBKdk36kya4o9hy053HLvVXQCEB7hLQo4Q4raRN9kx1+WvX8NyKW/ZHxVuzToTcN9L+cblJMdzafHEfI+p9R54d38Yj1a9nI9JsqMoD/nXIqpU/4ggLlzLRtvlwQLb0vf/ANcDSs/Iu52dcowndpC2a0WB8Wk7lztve0zdgEaton/LoCo6cyGEqHnyJjsWSaUCtQZK0whPrYGbjijJjqI8JKAUVWpst3C+3HO+So5tU+yM6x5eJccWQoiaqLAkxIB7X0AxZWJNTyLz0EbMF0+QHbOXxIxk6j853zlO4x1E8Nh3sVvNWBLOkr73W5TsdK5t+xqVixvenR4o9nmEKI4ElKJKtQj2onfzwHy9vHM1nPSfQvfx7T0W395jiz1ubi/vmzMRhRCiLissCdElqInztntEDy4seAy71YLlSgw5KRfRXW9hq9bpcQ1zJNu4NemIxt2H5I0LADAe35YvoJRkR1FW8i9GVLnZI9qiVVdueo5WrWL2iMIXnAshRF2VN9lRyTEXMerG561iysRuzcFe6OXvvOOy8j0qyY6irGSGUlS5MH93Zgxrw9TvjlbaMWcOa1Ogm4MQQtR1ucmOcSlGrnz1Ci6hEbg2vAONdz0UYxoZB3/EbnUEmiqtHl1AGOaLJ0j+aSEekf3RBTZCrXcn5+p50navch7XJaSZ87YkO4rykH8x4pYY3SWcpExzpfSdfWNwBI92kbWTQojbU/+IIJZGxaFYTGQd2UTWkU2FjvO7+2nUescPb+u1y/kSG/PSePjh03uc47YkO4pykoBS3DIv9G9BoKeed9ZFY1XsBdZUFkejVqFVq5g5rI0Ek0KI25aiKASmncSmuOLdbQTZsfvISYrHZkwD7Gg8A9A3aIVXhyG4hkUCoPVvgFenBzBfOI41/SqKKROVTo/OLxTXph3x7jIcjbsjo1uSHUV5qeyFL6wQosrEpxiZtvYoO2KT0KhVxQaWudt7Nw/kn8MjCZd1PUKI25Ddbmf9+vW8/fbb/Pnnn7Se9Akmn0aU4Xd5iXKTHW/u5S1EaUhAKapNTEIGy6IMbDmdiCHZmK8SmgrHOp7u4V481C6Ido2DcHV1dW5XFAW1WnLKhBC11/Hjxzlz5gyRkZE0adKkxPHdu3fH1dWVWbNm0bhNJwbO34a5Esv76LVqNr/SV9ani3KRgFLUCFlmK+eTs7BYFVy0ahoHeJCTncnYsWPZtGkT48aNQ6/X88QTTxASEkLjxo2r+5SFEKJcTpw4wV//+leOHDlCgwYNiI2N5YMPPuDZZ58tch+r1Up6ejp+fn6oVI7s7JX7DZWa7PjuyLaypEiUmwSUosay2WwMHToUT09P/va3v/HNN99w+PBhXFxcCA0NpWfPnsV+AAshRE2zYsUKZs2aRa9evZg+fTpms5klS5awZMkSrly5UubjfbwlptKSHSf3b17h44jblwSUokZbtmwZf/3rX0lOTnY+tmfPHp599llOnDjBxo0buffee6vxDIUQongWiwUXFxcAduzYwZEjR3jmmWecy3iWL1/Of/7zH9avX4+bm1uZl/Ss3G+QZEdR7SSgFDVS7geqoigEBwfzySefoNfrWbNmDcePHycoKAi9Xs/zzz/PPffcU92nK4QQBVy4cIEZM2aQnp5OgwYNmDJlCiEhIeTk5KDT6QCIiori6aefpl27dgwbNowxY8aU67nKm+w4e0RbWTMpKoUElKJG27lzJxMnTuTixYu0bNmSwMBAunTpQufOnencuTPBwcHVfYpCCJGP0Wjk7bffZvHixQwaNIgOHTqwYMECevXqxaJFi5xB5ZIlS3jttdcYNmwYXl5erFu3jgEDBjBnzhzCw8s3Y1iaZMf+LYMY1z1cWteKSiUBpaiRLl68yMMPP4zVagXg0KFDfPXVVwwePJh69epV89kJIUTRNm3axH//+1+efvppBg4cCMCvv/7KkCFDSExMJCAgAHAk53h7e9OggaPX9qFDh+jVqxc//fQTffv2rfB5FJbsKB1wRFWRf1miRmrQoAE9evQgLCyMLl268Nhjj6HX63FxcWHDhg0cOHCAU6dO0bt3b0aMGEH9+vWr+5SFELVcZQVgvXr1IjAwkHbt2jkfu3TpEhMmTHCupQSIiIhArVZjt9tRqVSEhIRgMplISkqqlNfjodfSJtSnUo4lRElkhlLUWCaTybloPTk5mf/973/Mnz+f8+fP07hxY+68804OHDhASEgIK1asKFUdNyGEyMt5ifhUIoaUQi4R+7vTPyKIsd3CaRFc9kvECQkJPPHEE/z666+0b98ek8nEP/7xDx544AHnOspc//jHP9i2bRurV6/G19e3Qq9LiFtNZihFjZUbTO7YsYMnn3ySxMREnn/+eSZPnuysQxkfH8/kyZOZPXs2ixcvrsazFULUJqVJYrEDcSlGlkbF8eWe8+VKYjl27Bje3t7s3LkTHx8fPv74Y/7xj3+gKAoPP/wwmzdvxmazMXfuXM6ePcvcuXMlmBS1ksxQihor9zLQ+PHjuXLlSr5f7VarFZVKhUajYcGCBSxbtox9+/ZV7wkLIWqFipbZmTGsDaNLWWYn93MsV2pqKj169OCNN97g3nvvZdq0aWzfvp3777+fuXPn4unpWebXI0RNIDOUosZSqVQcO3aMAwcOMGfOHHx9fTGbzajV6nyXir799lsGDBhQjWcqhKgtKlII3HY9AJ363VGSMs280L9Fvu03B4+FOXfuHFeuXCEwMJAGDRowbdo0PvnkEwkkRa0nzZBFjdaiRQvi4uJo2bIlAHq9Hp1Oh91u57v1P9Jl8AhOJGYT2ftesszWaj5bIURNtnK/oVK6ygDM+/U0/9tvAODatWt88cUXhQaTKpUKi8UCQHR0NNOnT2fIkCHO7O+IiAgJJkWdIJe8RY03atQoLl68yNNPP417/WZ8uTOWsyY3rHpfyPMBXhkL6IUQdVN8ipHef/uSpF2rMV+JxZaZij3HhFrvgUtQYzzbDcajTb9C9825doXLS17AnmMCwCU0gvqP/wu9Vs1wl2N8/sFsTCYThw8fpmXLlvkCS7PZzLRp04iPj2fdunWMHj2aefPmERgYeCtethC3jFzyFjXe+++/z4eLlzJjWzKahvXBHgKuBSfXK2MBvRCibpq29ijGK2fJit6a73ElOx1T3BFMcUewpifi0+ORAvum/PyJM5jMy2TJ4atYC+PHj+dvf/tboeXL9Ho9HTp0QKPRcPLkSWdCoRB1jcxQihrPuYDepmArw7/W8iygF0LUPTEJGQz6cDvZZ/ZjPL0XfVgkGk8/FFMmGfu/x3zxJAAaDz8avrg0376ZR38j+cf5qLQu2K2OS9e5M5S5Nr/Sp9iuM6VZWylEbSdrKEWN9vGWGKZ+dxSztWzBJDgW0JutClO/O8rHW2Kq5gSFEDXesigDGrUKt2ZdCBjyIp6R/XFr3B6PVnfhP3iSc5xiyc63ny3rGqm/fQGo8On5aKHH1qhVfLPXUOzzSzApbgcSUIoaq6oW0Ashbi9bTiUWKA9ktytYM5LJOPyT8zHX8Lb5xqRs/jeKKQOvjvehb9C60GPbFDtbTidW/kkLUcvIGkpRI8WnGHlnXXSBxxNXTyf7zAHn/dAJi9AFhDnv56Re4tqOZZjO/4lizkTrFYh7RC98ej7K2+ui6dksUNZUCnEbyTRbMaQY8z12+evXsFw6lecRFW7NOhNw30vOR4wxURhP7EDjXQ/fvk9guRJb5HMYko1kma3SJ1vc1mSGUtRI09YexXrTjEJm9JZ8weTNLAlnufzlKxiPb0MxXgObFeu1K6RHreHKsqlYsrOYtvZoFZ+5EKImiUvOosTVMioVqDVwPaVAMRtJ+XURAAH3TEKtL/5HqB04n5xV8ZMVohaTn1OixolJyGBHbFK+x2zGNFI3LwZUoNGArWDNyeSNC7CbHR/qnu3vxa1ZF9L3rcUcf4ycxLOk7FjBDt3TxCZmFLuAXghRd1isSoHHAu59AcWUiTU9icxDGzFfPEF2zF4SM5Kp/+R80vauxpaRhPsdfXFr1qXczyPE7URmKEWNk7uAPq/U3xajZKfj2f4eNB7+BfYxXzqFJeEMALqAMPzvmYx7i24EPjgFR4VKyDzyK2q7rcQF9EKIusNFW/BrziWoCa7hbfGM7E/Q6FmotC4AWK7EkJNyEVtGCgDG49uImzuUuLlDSVgxzbm/5dIp4uYOJX3/D8U+jxC3E/kLEDXOzQvos8/+QVb0VjSe/vj1e6rQfcwXjjtvu4RGOLMqtZ7+aH2CAFBMmZgS42QBvRC3kcYBHuT+PFVyzEWMuvEDVjFllvk5VNefR4jbmVzyFjXKzQvoFUs2yT9/AoD/4EmoXQv/0Lam3QgSNR6++bapPXwhLcEx7toVDMlNZQG9ELcJD72WcH934lKMXPnqFVxCI3BteAca73ooxjQyDv6I3eoINFVaPbqAMDza9MUluGm+41hTL5Fx8EcANN5BeHd5ENewSADCA9zl80Tc9uQvQNQoNy+gv7bta2zpibi3ugv3lt2L3E/J08VCpdHl26ZSa/OMMzsX0LcJ9ams0xZC1GD9I4JYGhWHYjGRdWQTWUc2FTrO7+6nUevdcWvSEbcmHfNtM8UduRFQevrh3eVBx221iv4tg6r2BQhRC8glb1Gj5F3YnpMcT8bBH1G7euI/6Lli91PrXJ237bacfNvsijXPOH2B5xFC1G1ju4VjU+x4dxuBa5MOaLwCQaMDjRaNTzDud/QleOxcvDreX+Zj2xQ747pLJy4hZIZS1Ch5F7bbMlPBrqCYMrmwcHyh4y8tnoguqAmekXff2C/rWr4xtsxU522tb0iB5xFC1G3NgzwJUlKgw314d3qgXMdwbdSORlM35HtMo1bRs2mAVI0QApmhFDVM3gX0ZaFveIfztvniSXJb1FszkrClXwVA7eqJLjBcFtALUYecO3cOs7moZBsHlUrFyteGoXfRFTuurLRqFbNHtC15oBC3AZmhFDVK3gX0Wr9Q/AZMKDAmbdcKZyamd49R6ALD0YdG4BLcDEvCGawpF0j5+WPcmnclfd9auL4q07PdYFQarSygF6KWs9vtmEwmxo8fz549e1izZg3duxe9xhqgaZAPM4a1Yep3ldfcYOawNtJ5S4jr5FtV1Di5C+jxDnQufM8rff8PcD2g9Iy829l6MeC+l7iy/G/YzVlk/vkLmX/+4txHF9QUn16jZQG9EHWASqXCbrdz7tw5Ll++zJIlS2jVqhW+vr7F7je6SzhJmWbm/Xq6wufwxuAIHu0iayeFyCWXvEWNk7uAvqxcgptS/4kPcL+jL2p3X9Bo0foE493tIULGzkWtd5cF9ELUEQaDgfbt27NhwwaWLFnCb7/9hsViAUBRik66e6F/C+aObIteqy7QQKEkGrUKvVbNuyPbMrl/8wqdvxB1jcqeu9hMiBpk/JIodp9NLldgWZTcBfRLn+kGgNlsxmQy4eMj5YOEqMkURUGtdsx/2O12VCoVCQkJ9O3bl5MnT/LQQw9x+vRptm/fjp+fX6mOGZ9iZNrao+yITUKjVhX7WZO7vXfzQGaPaCuXuYUohASUokaKTzEycP42zJVY3kevVbP5lb6E+buTk5PD559/zqZNm/jwww9p3LhxpT2PEKLyfP755+zduxcfHx+eeuopIiMjUavVbN68menTp7Nz506ys7MJCAjgiSee4NSpUzz33HM8+uijpTp+TEIGy6IMbDmdiCHZmK8OrgpH0fL+LYMY1z1csrmFKIasoRQ1Upi/e5UuoNfpdPTt25fDhw9z1113sXv3bsLD5VK4EDXF8ePHefLJJ0lJSeHBBx9k48aN/Pbbbyxbtoy2bdvi7u7uvLrg5uZGt27d+Pe//80999xDv379Sv08LYK9mD6sDdNpQ5bZyvnkLCxWBRetmsYBHpLAJ0QpyRpKUWON7hLO64NbVsqxCltAHxkZyeeff86wYcMYMWIEmZll7+ErhChaltlK9KU0DhlSib6URpbZWvJOwJkzZ3jttdfo0KEDhw8f5l//+heHDh3i2LFjXL58GYCYmBh8fX3Zvn079evXJyUlhSZNmqDT6dBoNOU6Xw+9ljahPnQI96NNqI8Ek0KUgfy1iBrthf4tCPTU8866aKyKvUxrKjVqFVq1ipnD2uQLJq9evcqff/7JwIEDAXjllVcYM2YMZ8+epV27dpX+GoS4nTgvIZ9KxJBSyCVkf3f6RwQxtls4LYILv4QcHh7O+PHjufvuu/H09AQcf7f33nsvoaGh2O12fH19WblyJWvWrOHNN99kxowZHDt2jHbt2rFy5UomTpxY7sBSCFF2soZS1AqVuYD+4MGDdO7cmU8++YSJEyeybt06hg8fzu7du0usZSeEKFxlJ7lYrVa0WsecxzfffMPLL7+MXq9HpVLRr18/mjdvTlhYGF27dqVt27bOxJ3XX3+dvn378sAD5euII4QoHwkoRa1SngX0sbGxHDp0iFGjRjnHLlmyhAkTJnDfffexceNGnnvuORYtWoTJZMLV1dWZSSqEKNnK/YYKXUWYMawNo4uo6ZiWlsaECRPo3LkzY8aM4eLFi8yePRtFUViyZAnBwcFA/kxwIcStJwGlqLVKs4A+JyeH8ePHExQUxEcffeQMFJOSkrj//vuZO3cu7u7uhISEsGvXLmbNmkWzZs0IDQ1l0aJFcslMiBJ8vCWmUgqFvz64JS/0b1HoNovFgouLizNo/OCDD/joo4/Yt28fQUHSqECImkB+zolaqzQL6HU6HX/7299YunQp8+bNcxY8Pn/+POfOnXNmh27atIknn3ySgQMHMnDgQOLj4+nateutfklC1Cor9xsqJZgEmPfraVbuNxS6zcXFBcB51SA1NZVWrVrh7e1dKc8thKg4maEUt4Xt27czevRohg4dSk5ODmfPnsXFxYUvv/wST09P2rVrx7Bhw1i4cCHguHzWrVs3xo8fz1//+tdqPnshap5NO/fx0MSpZF+OwZaZij3HhFrvgUtQYzzbDcajTT/n2KQN88k69luRx2rw/BK0vkG4aNT8+lJvGtcrmKxjtVpRqVR8+umnLFiwgLfffpvHH3+8Kl6aEKIcJMtb3Bb69OnDunXrWL16NVu2bKF79+7cc889NGjQgGvXrhESEuJMyElPT8fb25vw8HBnKzchRH7Tv9xIxrEt+R5TstMxxR3BFHcEa3oiPj0eKcMRVeTYFN5ad9zZzSrX5cuXmTdvHlFRUZw5c4bPPvuMBx98sBJehRCiskhAKW4bnTt3pnPnzvnWYwH4+vrStGlTPvjgA8aOHYu3tzc2m43t27fTp0+fAseR4sfidheTkEFsOnjeeQ/6sEg0nn4opkwy9n+P+eJJADIOrC8QUGo8/AgcPrXA8TSe/gDYUbEjNonYxIx8XWnq169PQEAADzzwAG+++WYVvjIhRHnJJW9xW7p06RLLly/n0UcfJSwsjJycHDp37kxAQADh4eH8+uuvBAYGsmXLFgICAiqltp4QdcX0ddEsjYorkNFtSTjL5f86loiodK6Ev/YtcOOSt8Y7iIaT/lPssTVqFeO7NWL6sDb5HpcsbiFqNplWEbeltLQ0vvrqK4KCgnj88cfR6XT8+eefLFiwgE8//RRXV1fefPNNsnDl5SVRxdbWswNxKUaWRsXx5Z7zxdbWE6Iu2HIqMd/fgt2uYMtMJePwT87HXMPbFtjPlpXChYXjsWVnoPH0w61ZZ3x6jUF7fYYSwKbY2XI6kenkDyglmBSiZpOAUtyWWrduzauvvspzzz1HWloaAQEBBAcH89lnnxEcHMxDDz2EuvldDPpwO9brX5wl1dfL3b77bDID528rtraeELVVptmKIcXovH/569ewXDqVZ4QKt2adCbjvpYI726zYslIdN9OvknnoJ7Jj9xHy+AdovQKcwwzJRrLMVllKIkQtIn+t4rb11FNPodFoWLZsGcePH0etVtOnTx8ef/xxTmkb87fvj5XruLbrxZ2nfneUpExzkbX1hKiN4pKzKPanlUoFag3kWU2ldvXA887B6MPbonH3xZJwhrQ9q7CbjdgykknbsYyA+25UU7AD55OzaBPqU2WvQwhRuWQNpbjtXbt2DbvdTlZWFg0bNmTlfgNTvztaacd/d2TbfL3EhajNDhlSGbFot/O+JfEciikTa3oSmYc2Yr54AgCXkBbUf3J+kcfJPLKJ5I0LAEdSTsMXvs63fe3EnnQI96uCVyCEqAoyQyluez4+PqhUKvz8/Ni0cx9/KWVtPYCskzvJOLAeS+JZUBS0fvXxvHMwXh3vR6V2dNl5e100PZsFyppKUSe4aPOvZXQJauK87R7RgwsLHsNutWC5EkNOykV0/g0KP079ls7bNmN6ic8jhKjZ5C9W3Pby9uzOra1nTb6A3ZwFis1ZWy9p/TzS9qxyjr22YxlJ38/FfCEauyUbu9VMztXzpG7+nKQNHzjHWRU709ZW3oynENWpcYAHKkDJMRcx4sbfk2LKRDEbyUm5WGBU3nWXGg/fAkdoHOBR8ZMVQtwyMkMpxHVlqa2Xk3KRtN3/AxzlUfwGPIvGw49r274iJ8mA8fg2slr2wKPVXdgUe6G19YSojTz0WsL93dnz3iRcQiNwbXgHGu96KMY0Mg7+iN3qCDRVWj26gDCU7AwufTEZ94geuDXvisbDD8uV2Hw/ztxb5C9kHh7gLgk5QtQy8hcrxHXLogx4tuiKW7Mu+R7X+YU6a+splmwATOcOgd1RGN291V14tb8XALvVTNIP7wGQefhnPFrdBThq632z11Cgtp4QNZHdbs83c3+zvi0D2W0xkXVkE1lHNhU6xu/up1Hr3VGyM0CxYjyxA+OJHQXGaf0b4tN7rPO+Rq2if8ugir8IIcQtJZe8hbiusNp61ozkQmvrKeYbZVPUOr3ztkrn6rxtvngS+/WgM7e2nhA11ZIlS5gyZQrZ2dnFBpN2ux3L8d/x6jYC1yYd0HgFgkYHGi0an2Dc7+hL8Ni5eHW8HwCNVwABQ1/DvWVPtL71Uen0jtnLeo3w6Tma+k98gMbN23l8m2JnXHdJYhOitpEZSiEoe209bZ5EA2PMXrw6DUXt4UfmoRvBpz3HhGLKdH5ZSm09URMtWLCA2bNnY7Va+fjjj3Fzcyt2vEql4u8vPsNJ970cTRxWYn1WlUaLZ2R/PCP7l3guGrWKnk0DZGmIELWQfLMJQdlr67m36IrWvwHWlIvYMpK5tHhiobvZrZYbt5HaeqLmOHr0KA8//DCXLl3is88+Y+zYsSXvdJ2npycLx/dk4PxtJQaUZaFVq5g9omCHHSFEzSeXvIUALFYl3/2Ae18g+LE5BAx9DX2D1mBXyI7ZS+K3MwFQaXQEPzoLfXi7fPu5NeuCSuvivK/Wexb7PELcaori+Dfo5+eHXq9n0qRJjB07FqvVyrp16zh27BhpaWn5xhYmzN+dGZW8JnjmsDZSXkuIWkpmKIWgfLX1tD5BhDw2G2tGMrbMZLTeQdhtOVz89CkANN5BqF1ci30eIW6FrKws/vnPf3Lw4EFatGjB6NGj6dWrF48++ijff/89Dz74IAcPHqR+/foYDAaaNGnC6tWradiwYbHHHd0lnKRMM/N+PV3hc3xjcIQ0ABCiFpNvNyEoe229vLReAejrt0Tj4Ut61HfOx92b588WL6q23q+//sqsWbM4dqx8rR5F3ZZlthJ9KY1DhlSiL6WRZbaWel+LxcL7779Po0aN2Lt3L3fffTdRUVE89dRTxMbG8vjjj2Oz2cjJyeHf//43q1ev5ssvv8RisTBhwgSuXbtW4nO80L8Fc0e2Ra9Vo1EXncxTGI1ahV6r5t2RbZncv3mZ9hVC1CwyQykEZa+tB5D888eo9R7oQyNApcYYs5eso5sd43SueHUdke85CqutZ7VaSUhIIDo6mvnz5xMREcG7775Lnz59bsGrFjVVTEIGy6IMbDmViCHFmG99rwoI93enf0QQY7uF0yK46ASWxMREYmJi+Pjjjxk9ejQAL7zwAp6enhgMBu6++27+/ve/06hRIzp16gRAo0aNCAwMpGvXrpw5c8b5eHFGdwmnV7NApq09yo7YJDRqVbFrK3O392wawOwRbeUytxB1gPTyFuK66eui+efjd2NNK7q8j//gic5yKIlr/kF2zN6Cg9RaAoe9gUerXs6HNGoV47s1KrQOpcViQVEUMjMzmTFjBtHR0Xz99dclXm4UdU98irHMQVnv5oFFBmV2u50jR47QunVrXFwca3v/+OMPZsyYwaeffkrDhg2x2WxoNJp8+6WmptK0aVMWLFjA448/XqbX4AyGTydiSC4kGA5wp3/LIMZ1D5dsbiHqEAkohbguJiGDbuPfIDt2HzlJ8diMaYAdjWcA+gat8OowBNewSOf4zCObyfzzF3JSLqKYjWjcvdGHt8Wnxyhc6jUucPzNr/Qp9gtUURSMRiOhoaG8//77PPfccwBcvXoVgHr16lXq6xU1y8r9Bt5ZF41VsZcpc1qjVqFVq5gxrA2ji1mDmJWVxeTJk1m+fDmNGjXCw8ODadOmMWTIELy88v+7/Pzzz3nvvfdYv349rVu3LvdryjJbOZ+chcWq4KJV0zjAQ8pmCVFHyV+2ENe1CPbi/kefYvfZkmvrAXi2G4hnu4Eljiuutp6iKCxevJgmTZowePBgjh07ht1ux9/fH4A33niD/fv3Ex8fT1hYGDNnzpTL4XXQx1tiyp3YYrsegE797ihJmWZe6N+i0HEXLlzAaDTy/fffExYWxn/+8x/mzp1LUlISkyZN4tixY/j6+rJixQqWLFnCuHHjKhRMgmMpiZTJEuL2IDOUQuQRn2Jk4PxtmCuxvI9eq2bzK30LXJK02+0oisKsWbOYO3cuPj4+tGvXDj8/P1atWsWPP/7ImDFjePXVVxkxYgRfffUV69ev55NPPmHw4MFlOgeZKaq5Vu43MPW7o5V2vHdHti11tnSPHj245557eP7555k5cybff/89vr6+TJ8+nUceeaTSzkkIUfdJQCnETarjC/7UqVNMnjyZUaNGMWHCBNRqNf/85z9Zs2YNmzdvds5YPvzww5hMJjZs2FDi81ZWYoeoOpt27uOhiVPJvhyDLTMVe44Jtd4Dl6DGeLYbjEebfgX2McZEkXHwRyyXY1BystG4++AS1BTvbg/hGh6JXqtm08t9CL+posDN/bkvXLhAx44dmTp1Kq+++ip79uzBarXSu3fvqn7ZQog6SMoGCXGT0V3CeX1wy0o5VlG19X7//XdycnIAR6Z3REQEXbp04b///S9qtePPcvz48fj5+bF3743En7S0NFxdXbFYLAWOmSs+xcj4JVEM+nA7S6PiiLspmARH1564FCNLo+IY9OF2xi+JIj5P60lxa0z/ciMZx7ZgTb6A3ZwFig0lOx1T3BGS1s8jbc+qfONTf1/C1TWzMJ07iGLKAJsVW0Yy2Wf2Y4p3lJ0yW3KY8u2hAs+lUqmc/24uXLjA9OnT6dSpE+PGjQMcs5USTAohykuueQlRiBf6tyDQU1+hJImZw9oUGkympqYyc+ZM3njjDe6//360WsefYWZmJp6eniQnJ/Ppp5/y888/k56ezvDhw2ncuDEdO3YkKiqKtWvXOjN2b5Y3sQMo8bxzt+8+m8zA+dtKTOwQlScmIYPYdPC88x70YZFoPP1QTJlk7P8e88WTAGQcWI9PD8el56wT20nftxYAjVcA3l1GoKsXjt1iwpJ4Dp1ffceB1Rr2nk8jNjEj37pdq9XKtGnTSExMZM2aNfTp04d58+YRFBR0a1+4EKJOkoBSiCJUVW09V1dX+vXrx7hx42jZsiXDhw9n165d7N+/nxdffJETJ07wzjvv8MMPP9CpUycUReH111/H09OT2NjYIgOAW5HYISrPsigDni264tYsfwF8nV8ol//7VwAUS7bz8bRdKwFQaV0IHjMbnX8D5zb3iJ75jqFRq/hmryFfmSqtVkvPnj3Zvn07e/bsoV27/G1DhRCiImQNpRClUBW19cxmMwsXLmTbtm00b96c9u3b88QTTzB16lR+/vlnDh8+7Fz3FhUVRd++fTl69CgtWhQM9qozsaMmqI1JR33f30JcnmUGdruCLTOVtN0ryTz0E+DoDR806h1yrl3h0mfPAuAS3AyXkOZknz2Akp2Brl5jfHo+inuLbvmO3yjAnW2v98/32M3rKIUQorLU7E9cIWqIFsFeTB/Whum0qbTgRa/X8/rrr/P666/n+6KvV68emZmZnDhxwlm2xWw206ZNG2JjYwsElJt27uMvpUzssCs2Mg5uJCt6CznJ8dhzzKhdPXEJaoJnh/ucxdjfXhdNz2aBNbqDSW1OOso0WzHkCSYvf/0alkun8oxQ4dasMwH3vQRATpLBucWScAZLwpkb9y+f5uqafxAw9FU8I28EkIZkI1lma75/mxJMCiGqigSUQpRRVdTWy/tF/9hjj7F+/XpeeOEFJk+ejFardbbHa9KkSYF9cxM78spN7DDFHcGanuhch5fy8ydkHvm1kLF/Yor7E2XwJLw63odVsTNt7VGWPpN/1qsmKE03mbxJR1/uOV9sN5nKcPbsWdLT02nfvn2pZgHjkrMKJErlo1KBWgPXLyAppqx8m10bt8e7y4Nknz1Ixh/rATupv3+BR+veqDSOj3U7cD45S+pACiFuCcnyFqKGqV+/PuvWraNz5868/PLLzJkzhwYNGjBjxgxatWqVb+zJy2nOxI6Aoa8RNPofBA6fir7BjXEZB9YDoJgyybzeaxzAt894gkb/A/fWNwqlZxz6EXCsqdwRm0RsYkZVvtQyW7nfwMD529h9Nhkoe9LRyv2GYseXxaVLl3jooYfw8vKiS5cu/OMf/wBKNwtouanOacC9LxD82BwChr6GvkFrsCtkx+wl8duZjmNqdfnG+w+eiFuzLvgN/AsarwAAFGMalqvni30eIYSoKjJDKUQN5O3tzbvvvsu7776LwWAgNDTUmQ2e18r9F/Bo3qVUiR2KJRvsjgBD7eaNT89HAdB4+GE8sR1wXBLPVVhiR3W61UlHycnJ7N27l6ioKBRFYcyYMbRp43gvsrOzee655wgICGDTpk20a9eO8+fPk5OTg06nK/KYVquVI0eO8EtUNODvfNwl6MbMs3tEDy4seAy71YLlSgw5KRfReudvu6n1cSRmqVQqNF6B2DIcAbbdnL/0k4tW5gyEELeGfNoIUcOFh4cXGkwCbDmVSN5JOrtdwZqRTMbhn5yPuYa3BUDjFYj2emkZJTudtN3/I/v8YdJ2r3SO9WxzYw2eTbGz5XRiief3xRdfMHDgQLp168aDDz7IggULSE9PBxxrP0+ePElaWlrpX3AhVu43lDuYvNm8X0/zvxJmKleuXMnAgQN59dVXOXr0KEeOHKFfv378/PPPAGzatIn4+HhmzpxJ9+7dMRqNNGvWrNhg0mazsXbtWjp16sTfX34O7HaUHHMRo2/MciqmTFyCmqDSuTofs6Y7+rvb7XZnMAmg8Q7Md4TGNxU3F0KIqiJZ3kLUUplmK22n/+Jci1dcYofGwxcAy9XzJK2bR85Nl0bVbt749h6HV8f78j2uAo5Nv6fIpCO73c7KlSu5du0aGo2Gs2fPsnXrVrp3786HH37I8ePHadeuHWq1GpvNhpubG/Xq1SMyMpK3336bLl26FHrcvErbTcYUd4SEFdOKPZbGO4iGk/5TZDvMXAcOHCAlJYUePXrg5eVI6Onfvz/16tVj1apVjB8/HpVKRY8ePZg3bx45OTncddddPPHEE9xzzz1FPn96ejrR0dG0bduW+xftZ897T+ISGoFrwzvQeNdDMaaRcfBHzBeOA6DS6mn44lLUeneSf/nEmf3t2qQD3p0fJPvcITIO/ACALqgJoU8vdD5XYVneQghRVeSStxC1VFkTOwDUrp7oAsMKBJRKdjpZJ3fiHtEDjYef8/GSEjtUKhWPPPIIKpXK2eHnf//7H0899RQTJ07kjjvuwGq1kpmZSXp6OufPn2fOnDls3ryZL774olSvsyxJRyVRaTQAJSYddezY0fl6crm4uJD7+9vX15fFixeTmprKBx98QEhICDNnzmTy5Ml8++23RSbneHt706NHDwD6RwSxO8dE1pFNZB3ZVOh5+N39NGq9I+j17fM4prijWFMuYDp3CNO5G91wVC5uBAx50Xlfo1bRv6UULBdC3DoSUApRSxWW2KGYMrGmJ5F5aCPmiycciR0ZydR/cj52m5WE5dOwpl4CjY6gUdPRh0aQefgnUn9fgtlwhKT1HxA8ela+4+7YtYemQ/vi5uZW6HlorgdpuXLXEea2+VMUBXd3dzw9PTEajVy6dImJEycSHByMzWYrsH9eZekm4xLcjOCx7xY4Rvr+78k+vQcA9xaOYC5v0lFhdUNzg8kLFy6wfPlytm7dSk5ODnPmzAGgadOmWCwW2rVrx4MPPgjA0qVLGTp0KMuXL6d9+/YlJueM7RbOR11HkB27j5ykeGzGNMCOxjMAfYNWeHUYgmtY5I332c2LkPHvk7ZrJcbTe7BlpqB29cC10Z343jUGXUCYc6xNsTOue+2pIyqEqP0koBSilro54aKkxA5rWqIjmARcG7XDrfGdAHh3HcG1Hd9gzzFjOn8IJceEOs96vb++MIkH79pVZEAJ8NFHH/Hpp58SGhqKq6sr//znP2nb1rF2U6VSOYOr5cuXk5KSwqRJkwAKzALerCzdZNSuHriG5U8gsltzMMdHO+6o1HjmuaSfm3T09tDW+c4xryNHjrBy5Upat27N1atXefDBB1m7di133ul47zp16uQc6+/vT8OGDUlMTCwxUAZHbdP7H32K3WeHlbq1p8bNC/+BE/AfOKHoMWoVPZsGlLrAvhBCVAZJyhGilmoc4IEKSp3YoWSnO+/bLaYbt60W7DZbodtUwOGdmwgJCSn2XHr37s2TTz6Jv78/GRkZdOzY8cbxrl8mPnDgAN9//z3Dhw+nefPmKIpS4izellOJ+YKt4pKOCpN1cofzdbs17YjO98brsCl2lv52kEGDBhV5Hvfddx8HDx5k2bJlrFy5koYNG/J///d/dOjQgYCAAP78809sed67Q4cOERERUWIwmWv2iLZo1ZVbbFyrVjF7RNHviRBCVAWZoRSilvLQawn3d2fPe5MKTeywWx2BpkqrRxcQhkrr4tzXfCGaa7tWog9tSebR30CxAqDx9EftfmO9ZHiAO3e0aFbiuXTo0IEOHTpgs9kYPXo07733Hl999RU+Pj7OgHLFihVYrVbGjx9f7LFmzZrF1atX8Q8OJS4zktzAuKRuMoXJOPij87ZXx/sLbLe5+XHv0AdLLEZus9nw9/enbdu27N+/Hy8vL1555RUWLlyIXq9n7NixrFixAnd3d/r3L30iTJi/OzOGtanUtpkzh7Wp0R2OhBB1kwSUQtRiZUnscAlqgnur3hhP7gAgbcc3Bcb69n3CGViVNbHDarWi1WoZNGgQn3/+ObGxsXTq1AmNRsPx48dZs2YNEyZMcM5eFnW522AwsHfvXhItLriNLGamrZCko7wsV844A1CtbwiuTTsVHKRScd+jTxQZTFosFlxcXNBoNJw6dYpvv/2WAQMGoNVqefnll/Hx8WHp0qXMnj2bRo0aMWvWLLp3717Mu1TQ6C7hJGWaK6Us0huDI2pVD3YhRN0hAaUQtVhZEzsCh71ORoNWZB3flr+Xd/0WeHcehlueoKs0iR2rV68mICCAvn37otVqOXnyJAsWLOCOO+6gYcOGznGfffYZfn5+zgSW4mYEFy9eDMAhQyojFu12Pl5S0tHN8s5Oena4D5Wq8AC2qG4ycXFxLFy4kJCQEA4fPszx48fp06ePsyOOu7s7kydP5uGHHyYgIKDIWqGl8UL/FgR66nlnXTTW60XYS0ujVqFVq5g5rI0Ek0KIaiMBpRC1WFkTO1RqDd5dHsS7y4PFjittYseZM2eYNm0aWVlZhISE4ObmRmhoKG+88QbBwcEAJCQk8M033zBt2jRn68jStCcsa9KRzr+Bc7tiyiTrxDbHc2n1eLYbVOrnyVWvXj0MBgNHjhwhIiKC6dOn06dPH3x9ffONy32dFTW6Szi9mgWW2Kc8V+72nk0DqrRPuRBClIYElELUcrNHtGXg/G1lmtUqSWkTO6ZMmcITTzxBXFwcV65cQaVS0bt3b/z9b7QVXL58OZ6enjz11FNlmsXLTTqy5ZhR6/SFjMifdJRX5tHfsF9PVnJv3RuNW+GBcXHdZNzd3Vm1alWpz7cyhPm7s/SZbsQkZLAsysCW04kYko356o2qcKxt7d8yiHHdwyWbWwhRI0inHCHqgJX7DZWa2PHuyLY14vJp3/e3lKmbDDgup19a/DzWlIsAhDz5IfqQ5oUevzZ0k8kyWzmfnIXFquCiVdM4wKPIzkVCCFFd5FNJiDqgriZ2lLWbDIDp/GFnMOkSGlFkMFlbusl46LVFdioSQoiaQgJKIeqIupjYUdakIyi5VFAu6SYjhBCVRy55C1HHxKcYy5zY0bt5YI1N7Bi/JIrdZ5MrdY1obtJRUb28hRBClI0ElELUUXUlsSM+xcjA+dswF1Hepzz0WjWbX+lbIwNoIYSojSSgFOI2UNsTO+pq0pEQQtQVElAKIWqFj7fEVFrS0eT+hSfqCCGEKB8JKIUQtcbK/YY6lXQkhBB1hQSUQohapa4lHQkhRF0gAaUQolaqK0lHQghRF0hAKYSo9Wp70pEQQtR2ElAKIYQQQogKUVf3CQghhBBCiNpNAkohhBBCCFEhElAKIYQQQogKkYBSCCGEEEJUiASUQgghhBCiQiSgFEIIIYQQFSIBpRBCCCGEqBAJKIUQQgghRIVIQCmEEEIIISpEAkohhBBCCFEhElAKIYQQQogKkYBSCCGEEEJUiASUQgghhBCiQiSgFEIIIYQQFSIBpRBCCCGEqBAJKIUQQgghRIVIQCmEEEIIISpEAkohhBBCCFEhElAKIYQQQogKkYBSCCGEEEJUiASUQgghhBCiQiSgFEIIIYQQFSIBpRBCCCGEqBAJKIUQQgghRIVIQCmEEEIIISpEAkohhBBCCFEhElAKIYQQQogKkYBSCCGEEEJUiASUQgghhBCiQiSgFEIIIYQQFSIBpRBCCCGEqBAJKIUQQgghRIVIQCmEEEIIISpEAkohhBBCCFEhElAKIYQQQogKkYBSCCGEEEJUiASUQgghhBCiQv4f6eVCWOWbkyoAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#Optional: Visualize the graph\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "pos = nx.spring_layout(G)  # Choose a layout for visualization\n",
    "nx.draw(G, pos, with_labels=True, font_weight='bold')\n",
    "edge_labels = nx.get_edge_attributes(G, 'edge_id')\n",
    "nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of nodes: 50\n",
      "Number of edges: 50\n"
     ]
    }
   ],
   "source": [
    "# Print basic information about the graph\n",
    "print(\"Number of nodes:\", G.number_of_nodes())\n",
    "print(\"Number of edges:\", G.number_of_edges())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from torch_geometric.nn import GCNConv\n",
    "\n",
    "class YourGNNModel(nn.Module):\n",
    "    def __init__(self, node_feature_dim, edge_feature_dim, hidden_dim, output_dim):\n",
    "        super(YourGNNModel, self).__init__()\n",
    "        self.conv1 = GCNConv(node_feature_dim, hidden_dim)\n",
    "        self.conv2 = GCNConv(hidden_dim, output_dim)\n",
    "      \n",
    "\n",
    "    def forward(self, data):\n",
    "        x, edge_index, edge_attr = data.x, data.edge_index, data.edge_attr\n",
    "\n",
    "        # Use the first dimension of edge features as edge weights\n",
    "        edge_weight = edge_attr[:, 0].view(-1, 1)  \n",
    "\n",
    "        x = F.relu(self.conv1(x, edge_index, edge_weight=edge_weight))\n",
    "        x = self.conv2(x, edge_index, edge_weight=edge_weight)\n",
    "                \n",
    "\n",
    "        return F.log_softmax(x, dim=1)\n",
    "\n",
    "    \n",
    "# Assuming your node features have a dimensionality of 3 and edge features have a dimensionality of 2\n",
    "node_feature_dim = 3\n",
    "edge_feature_dim = 2\n",
    "hidden_dim = 64\n",
    "output_dim = 2\n",
    "\n",
    "model = YourGNNModel(node_feature_dim, edge_feature_dim, hidden_dim, output_dim)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch_geometric.nn as gnn\n",
    "from torch_geometric.data import Data, DataLoader\n",
    "\n",
    "# Create a DataLoader for the data\n",
    "data_list = [data]  # You can extend this list if you have multiple graphs\n",
    "loader = DataLoader(data_list, batch_size=1, shuffle=False)\n",
    "\n",
    "# Instantiate the GNN model\n",
    "node_feature_dim = node_features_tensor.shape[1]\n",
    "edge_feature_dim = edge_features_tensor.shape[1]\n",
    "hidden_dim = 64\n",
    "output_dim = 2  # Binary classification: optimal route or not\n",
    "\n",
    "model = YourGNNModel(node_feature_dim, edge_feature_dim, hidden_dim, output_dim)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 0, Loss: nan\n",
      "Epoch 10, Loss: nan\n",
      "Epoch 20, Loss: nan\n",
      "Epoch 30, Loss: nan\n",
      "Epoch 40, Loss: nan\n",
      "Epoch 50, Loss: nan\n",
      "Epoch 60, Loss: nan\n",
      "Epoch 70, Loss: nan\n",
      "Epoch 80, Loss: nan\n",
      "Epoch 90, Loss: nan\n"
     ]
    }
   ],
   "source": [
    "# Define loss function and optimizer\n",
    "criterion = nn.CrossEntropyLoss() #Loss used for Classification\n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=0.001)\n",
    "\n",
    "# Training the model (you can adjust this based on your data)\n",
    "for epoch in range(100): \n",
    "        for batch in loader:\n",
    "                # Forward pass\n",
    "                #print(\"Node Features Shape:\", batch.x.shape)\n",
    "                #print(\"Edge Index Shape:\", batch.edge_index.shape)\n",
    "                #print(\"Edge Features Shape:\", batch.edge_attr.shape)\n",
    "        \n",
    "                output = model(batch)\n",
    "                \n",
    "                # Example: Assuming you have binary labels for optimal routes (1) or not (0)\n",
    "                labels = batch.y\n",
    "\n",
    "                # Compute loss\n",
    "                loss = criterion(output, labels)\n",
    "\n",
    "                # Backward pass and optimization\n",
    "                optimizer.zero_grad()\n",
    "                loss.backward()\n",
    "                optimizer.step()\n",
    "\n",
    "        if epoch % 10 == 0:\n",
    "                print(f'Epoch {epoch}, Loss: {loss.item()}')\n",
    "\n",
    "        # After training, you can use the trained model to predict optimal routes for new instances."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Recommended Routes:\n",
      "    edge_id  source_node_id  destination_node_id  distance   mode  \\\n",
      "31       32              32                   33        25  Truck   \n",
      "37       38              38                   39        30  Truck   \n",
      "36       37              37                   38        35  Train   \n",
      "35       36              36                   37        50  Truck   \n",
      "34       35              35                   36        40  Train   \n",
      "33       34              34                   35        60  Truck   \n",
      "32       33              33                   34        30  Train   \n",
      "28       29              29                   30        50  Train   \n",
      "26       27              27                   28        35  Train   \n",
      "27       28              28                   29        30  Truck   \n",
      "\n",
      "    cost_per_km time_window_start time_window_end  is_optimal  \n",
      "31         0.12           3:00 PM         6:00 PM           0  \n",
      "37         0.20           8:00 AM        12:00 PM           0  \n",
      "36         0.10           2:00 PM         6:00 PM           0  \n",
      "35         0.15           1:00 PM         5:00 PM           0  \n",
      "34         0.09          12:00 PM         4:00 PM           0  \n",
      "33         0.18          11:00 AM         3:00 PM           0  \n",
      "32         0.08          10:00 AM         2:00 PM           1  \n",
      "28         0.15           1:00 PM         5:00 PM           0  \n",
      "26         0.10           2:00 PM         6:00 PM           0  \n",
      "27         0.20           8:00 AM        12:00 PM           0  \n"
     ]
    }
   ],
   "source": [
    "# Recommendation System: Get the predictions for the edges\n",
    "model.eval()\n",
    "with torch.no_grad():\n",
    "            predictions = model(data)\n",
    "\n",
    "# Assuming you want to recommend the top k cost-effective routes\n",
    "k = min(10, len(data.edge_index[0]))\n",
    "top_k_indices = torch.topk(predictions[:, 1], k).indices.numpy()\n",
    "\n",
    "# Display recommended routes\n",
    "recommended_routes = edges_df.iloc[top_k_indices]\n",
    "print(\"Recommended Routes:\")\n",
    "print(recommended_routes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}