add_extra_hub.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "from staticmap import StaticMap, CircleMarker, Line\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import math\n",
    "from pprint import *\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#======we import the orders======#\n",
    "df_orders = pd.read_csv('data\\orders.csv', sep=';')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# import data from csv file\n",
    "df_cities = pd.read_csv('data\\cities_data_costs.csv')\n",
    "\n",
    "#We normalize data (co2_per_unit and cost_per_unit) from 0 to 1\n",
    "norm_par = ['co2_per_unit', 'cost_per_unit']\n",
    "df_norm = df_cities.copy()\n",
    "for par in norm_par:\n",
    "    df_norm[par] = (df_cities[par]-df_cities[par].min())/(df_cities[par].max()-df_cities[par].min())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cost(emissions, cost, alpha):\n",
    "    '''\n",
    "    Get cost of graph edge from emissions, cost and parameter alpha\n",
    "    alpha = 1   meaning concerned about reducing emissions\n",
    "    alpha = 0   meaning concerned about reducing costs\n",
    "    '''\n",
    "    return alpha*emissions + (1-alpha)*cost"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_cost_path(city_orig, city_dest, df_func):\n",
    "    '''\n",
    "    Returns cost of path city_orig -> city_dest or city_dest -> city_orig depending on which one exists\n",
    "    We take into account it is a non directed edge\n",
    "    df_func is a dataframe that contains costs to go from an origin to a destination\n",
    "    '''\n",
    "    if(city_orig[2:] == city_dest[2:]):\n",
    "        return 0\n",
    "    pes = df_func[(df_func['city_from_name']==city_orig[2:]) & (df_func['city_to_name']==city_dest[2:])]\n",
    "    if pes.empty:\n",
    "        pes = df_func[(df_func['city_from_name']==city_dest[2:]) & (df_func['city_to_name']==city_orig[2:])]\n",
    "    return pes['cost'].values[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def declare_costs_graph(G, ports, hubs, cities, df_func):\n",
    "    '''\n",
    "    Declare the edges (conncected nodes and weight) of the graph G\n",
    "        Edges from all ports to all hubs\n",
    "        Edges from all hubs to all cities\n",
    "        The cost of an edge (A,B) is defined by the cost to go from A to B\n",
    "        df_func is a dataframe that contains costs to go from an origin to a destination\n",
    "    '''\n",
    "    for p in ports:\n",
    "        for h in hubs:\n",
    "            pes = get_cost_path(p, h, df_func)\n",
    "            G.add_edge(p, h, cost=pes)\n",
    "    for h in hubs:\n",
    "        for c in cities:\n",
    "            pes = get_cost_path(c, h, df_func)\n",
    "            G.add_edge(h, c, cost=pes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_min_cost_matrix(G, ports, cities, df_func):\n",
    "    '''\n",
    "    Matrix that stores the cost of minimum path of: [port][customer][extra hub]\n",
    "        Path from port to custumer going through extra hub\n",
    "            extra_hub = 0 -> does not add any extra hub\n",
    "            extra_hub index = extra hub - 1\n",
    "        \n",
    "        We get the distance of the path without adding any extra hub with dijkstra\n",
    "        When adding a extra hub we calculate the minimum from:\n",
    "            · Distance without adding any extra hub\n",
    "            · Distance of path from port to new extra hub to customer\n",
    "    '''\n",
    "    M = np.zeros((len(ports), len(cities), len(cities)+1))\n",
    "    for p in range(len(ports)):\n",
    "        for c in range(len(cities)):\n",
    "            M[p, c, 0] = nx.dijkstra_path_length(G, ports[p], cities[c], weight='cost')\n",
    "\n",
    "    for p in range(len(ports)):\n",
    "        for c in range(len(cities)):\n",
    "            for h in range(1, len(cities)+1):\n",
    "                new_path = get_cost_path(ports[p], cities[h-1], df_func) + get_cost_path(cities[h-1], cities[c], df_func)\n",
    "                M[p, c, h] = min(M[p, c, 0], new_path)\n",
    "    return M"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Declare ports, hubs and cities\n",
    "PORTS = ['Barcelona', 'Rotterdam', 'Athens']\n",
    "HUBS = ['Hamburg', 'Lille', 'Warsaw', 'Zaragoza', 'Bratislava', 'Dusseldorf', 'Liege', 'Venlo', 'Rome']\n",
    "CITIES  = df_cities['city_from_name'].unique()\n",
    "\n",
    "#Change names of places to specify their function in the graph (port, hub or citie)\n",
    "PORTS = ['p-'+p for p in PORTS]\n",
    "HUBS = ['h-'+h for h in HUBS]\n",
    "CITIES = ['c-'+c for c in CITIES]\n",
    "\n",
    "# create graph\n",
    "G = nx.Graph()\n",
    "for x in PORTS + HUBS + CITIES:\n",
    "    G.add_node(x, bipartite= ['p-', 'h-', 'c-'].index(x[:2]))\n",
    "\n",
    "\n",
    "#It shows the estructure of a tripartite graph (yet without edges)\n",
    "\n",
    "# nodes = G.nodes()\n",
    "# # for each of the parts create a set \n",
    "# nodes_0  = set([n for n in nodes if  G.nodes[n]['bipartite']==0])\n",
    "# nodes_1  = set([n for n in nodes if  G.nodes[n]['bipartite']==1])\n",
    "# nodes_2  = set([n for n in nodes if  G.nodes[n]['bipartite']==2])\n",
    "\n",
    "# # set the location of the nodes for each set\n",
    "# pos = dict()\n",
    "# pos.update( (n, (1, i)) for i, n in enumerate(nodes_0) ) # put nodes from X at x=1\n",
    "# pos.update( (n, (2, i)) for i, n in enumerate(nodes_1) ) # put nodes from Y at x=2\n",
    "# pos.update( (n, (3, i)) for i, n in enumerate(nodes_2) ) # put nodes from X at x=1\n",
    "# # draw graph\n",
    "# nx.draw(G, pos=pos)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_matrices(alpha):\n",
    "    '''\n",
    "    For each weigh_class it generates a list where each item is a 3D tensor containing get_min_cost_matrix(Graf, ports, cities)\n",
    "    '''\n",
    "    matrices = [] # list of matrixs for each weight class\n",
    "    for weight in range(10):\n",
    "        df_cities_weight = df_norm.iloc[weight::10,:]\n",
    "        cost = [get_cost(df_cities_weight['co2_per_unit'].iloc[i], df_cities_weight['cost_per_unit'].iloc[i], alpha) for i in range(len(df_cities_weight))]\n",
    "        df_cities_weight['cost'] = cost\n",
    "        df_cities_weight = df_cities_weight.drop(columns=['co2_per_unit', 'cost_per_unit', 'city_from_coord', 'city_to_coord', 'weight_class', 'distance'])\n",
    "        declare_costs_graph(G, PORTS, HUBS, CITIES, df_cities_weight)\n",
    "        M = get_min_cost_matrix(G, PORTS, CITIES, df_cities_weight)\n",
    "        matrices.append(M)\n",
    "    return matrices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def get_freq_matrix(df_func):\n",
    "    ''' \n",
    "    Matrix that stores the frequency of  path: [weight][port][customer]\n",
    "        · Path from port to costumer of a certain weight_class weight\n",
    "    '''\n",
    "    F = np.zeros((10, len(PORTS), len(CITIES)))\n",
    "    for w in range(10):\n",
    "        for p in range(len(PORTS)):\n",
    "            for c in range(len(CITIES)):\n",
    "                F[w, p, c] = np.sum(df_func.loc[(df_func['weight_class']==w) & (df_func['origin_port']==PORTS[p][2:]) & (df_func['customer']==CITIES[c][2:])]['units'].values)\n",
    "    return F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_orders = pd.read_csv('data\\dataframefinal.csv')\n",
    "F = get_freq_matrix(df_orders)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "# we ponderate the vector with the calclated frequencies\n",
    "def ponderate_vector(matrices, F, alpha):\n",
    "    '''\n",
    "        We make a vector where each element contains the total cost of the graf when adding a certain extra hub\n",
    "            - Position 0 => not adding any extra hub\n",
    "            - Position i = adding city i-1 as extra hub\n",
    "\n",
    "        When computing the total cost of the graph we have made a ponderated sum\n",
    "            - We have added each path cost multiplied by its frequency\n",
    "    '''\n",
    "    pond_vect = []\n",
    "    for extra_h in range(len(CITIES)+1):\n",
    "        sum = 0\n",
    "        for w in range(10):\n",
    "            for p in range(len(PORTS)):\n",
    "                for c in range(len(CITIES)):\n",
    "                    sum += F[w, p, c]*matrices[w][p, c, extra_h]\n",
    "        if not CITIES[extra_h-1][2:] in [h[2:] for h in HUBS]:\n",
    "            pond_vect.append((alpha, sum, CITIES[extra_h-1][2:] if extra_h > 0 else 'No Extra Hub'))\n",
    "    return pond_vect"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sort_and_save(pond_vect, alpha):\n",
    "    ''' \n",
    "        We sort the ponderated vector\n",
    "    '''\n",
    "    pond_vect.sort()\n",
    "    df = pd.DataFrame(pond_vect, columns=['alpha', 'cost', 'extra_hub'])\n",
    "    existing_df = pd.read_csv('data/results_alpha.csv')\n",
    "    if not alpha in existing_df['alpha'].unique():\n",
    "        df.to_csv('data/results_alpha.csv', mode='a', index=False, header=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_pond_vector(pond_vect):\n",
    "    '''\n",
    "    Histogram of ponderated vector\n",
    "    '''\n",
    "    plt.bar([x[2] for x in pond_vect], [x[1] for x in pond_vect])\n",
    "    plt.xticks(rotation=90)\n",
    "    offset = 100\n",
    "    plt.ylim(pond_vect[0][1] - offset, pond_vect[-1][1] + offset)\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def generate_hub_list(alpha, show = False):\n",
    "    '''\n",
    "    Makes a sorted list of the hubs by the criterium of minimum graf cost when adding hub first\n",
    "    It saves it to a dataframe\n",
    "    '''\n",
    "    matrices = generate_matrices(alpha)\n",
    "    pond_vect = ponderate_vector(matrices, F, alpha)\n",
    "    sort_and_save(pond_vect, alpha)\n",
    "    if show:\n",
    "        show_pond_vector(pond_vect)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def better_extra_hub(alpha, port = False):\n",
    "    '''\n",
    "    Returns the better extra hub for a given alpha\n",
    "    '''\n",
    "    df = pd.read_csv('data/results_alpha.csv')\n",
    "    df = df.loc[df['alpha']==alpha]\n",
    "    for i, x in df.iterrows():\n",
    "        if port:\n",
    "            return x['extra_hub']\n",
    "        else:\n",
    "            if not x['extra_hub'] in [p[2:] for p in PORTS]:\n",
    "                return x['extra_hub']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With alpha 0 better extra hub city: Amsterdam\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAkIAAAHrCAYAAAAjXPK7AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAA9hAAAPYQGoP6dpAACTXElEQVR4nOzdd1QU19sH8O/SmyCCUhQRBcWCvWtUlAjEhibYY8MSo7FrND8LtmisoBCxYCyxGyW2qNgbEhtiiQqKYjSgxCARIyjc9w8O87KwbKEIut/POXN0Z+6dubNseXbm3ufKhBACRERERFpIp6QbQERERFRSGAgRERGR1mIgRERERFqLgRARERFpLQZCREREpLUYCBEREZHWYiBEREREWkuvpBtQmmVmZuLp06coU6YMZDJZSTeHiIiI1CCEwL///gt7e3vo6Ci/5sNASImnT5/CwcGhpJtBREREBfD48WNUqlRJaRkGQkqUKVMGQNYTaW5uXsKtISIiInWkpKTAwcFB+h5XhoGQEtm3w8zNzRkIERERfWDU6dbCztJERESktRgIERERkdZiIERERERaS+NA6MyZM+jSpQvs7e0hk8kQFhYmt93f3x+urq4wNTWFpaUlPDw8EBkZqXBfaWlpqF+/PmQyGaKioqT1Dx8+hEwmy7NcvHhRrv6uXbvg6uoKIyMjuLm54dChQ3LbhRCYOXMm7OzsYGxsDA8PD8TExGh6ykRERPSR0jgQSk1NRb169RAcHKxwe/Xq1REUFIQbN27g3LlzqFKlCjp27Ijnz5/nKTtlyhTY29vne6xjx47hr7/+kpZGjRpJ2y5cuIA+ffrAz88P165dg4+PD3x8fHDz5k2pzKJFi7BixQqEhIQgMjISpqam8PT0xJs3bzQ9bSIiIvoYiUIAIPbu3au0zMuXLwUAcezYMbn1hw4dEq6uruLWrVsCgLh27Zq0LS4uLs+63Hr27Ck6deokt65Zs2ZixIgRQgghMjMzha2trVi8eLG0PTk5WRgaGopt27Yp3OebN2/Ey5cvpeXx48cCgHj58qXScyQiIqLSIzv2UOf7u1j7CKWnp2PNmjWwsLBAvXr1pPWJiYkYNmwYNm/eDBMTk3zrd+3aFRUqVEDr1q2xb98+uW0RERHw8PCQW+fp6YmIiAgAQFxcHBISEuTKWFhYoFmzZlKZ3BYsWAALCwtpYTJFIiKij1ux5BE6cOAAevfujdevX8POzg7h4eGwtrYGkNVvZ9CgQfjqq6/QuHFjPHz4ME99MzMzLF26FK1atYKOjg5++eUX+Pj4ICwsDF27dgUAJCQkwMbGRq6ejY0NEhISpO3Z6/Irk9u0adMwYcIE6XF2QiYiIiJSrcrUgxrXebiwUzG0RH3FEgi5u7sjKioKSUlJWLt2LXr27InIyEhUqFABK1euxL///otp06blW9/a2louIGnSpAmePn2KxYsXS4FQcTA0NIShoWGx7Z+IiKg4aRqI5A5CPsRAprCK5daYqakpnJ2d0bx5c4SGhkJPTw+hoaEAgBMnTiAiIgKGhobQ09ODs7MzAKBx48YYOHBgvvts1qwZYmNjpce2trZITEyUK5OYmAhbW1tpe/a6/MoQERGRdnsveYQyMzORlpYGAFixYgWuX7+OqKgoREVFSUPed+zYgfnz5+e7j6ioKNjZ2UmPW7RogePHj8uVCQ8PR4sWLQAATk5OsLW1lSuTkpKCyMhIqQwRERFpN41vjb169UruykxcXByioqJQrlw5WFlZYf78+ejatSvs7OyQlJSE4OBgPHnyBL6+vgCAypUry+3PzMwMAFCtWjVphtiNGzfCwMAADRo0AADs2bMH69evx7p166R6Y8eORdu2bbF06VJ06tQJ27dvx+XLl7FmzRoAWfOLjBs3DvPmzYOLiwucnJwwY8YM2Nvbw8fHR9PTJiIioo+QxoHQ5cuX4e7uLj3O7sszcOBAhISE4M6dO9i4cSOSkpJgZWWFJk2a4OzZs6hdu7ZGx5k7dy4ePXoEPT09uLq6YseOHfjiiy+k7S1btsTWrVsxffp0fPfdd3BxcUFYWBjq1KkjlZkyZQpSU1MxfPhwJCcno3Xr1jh8+DCMjIw0PW0iIqJipY39c0oDmRBClHQjSquUlBRYWFjg5cuXnH2eiIiUKmwgUxSBUEl3li4twZwm39/FMmqMiIjoQ1NavsTp/WIgREREHwUGMlQQDISIiKjEMYihkvJehs8TERERlUa8IkRERIXGKzr0oWIgRET0EfhYRvsQvW+8NUZERERai4EQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLo8aIiEoBjtoiKhm8IkRERERai4EQERERaS3eGiMiKiTe1iL6cDEQIiKtx0CGSHvx1hgRERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktjhojog8eR30RUUHxihARERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktBkJERESktRgIERERkdZiIERERERaiwkViajEMSEiEZUUXhEiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBaHzxNRoXDoOxF9yDS+InTmzBl06dIF9vb2kMlkCAsLk9vu7+8PV1dXmJqawtLSEh4eHoiMjFS4r7S0NNSvXx8ymQxRUVFy26Kjo/HJJ5/AyMgIDg4OWLRoUZ76u3btgqurK4yMjODm5oZDhw7JbRdCYObMmbCzs4OxsTE8PDwQExOj6SkTERHRR0rjQCg1NRX16tVDcHCwwu3Vq1dHUFAQbty4gXPnzqFKlSro2LEjnj9/nqfslClTYG9vn2d9SkoKOnbsCEdHR1y5cgWLFy+Gv78/1qxZI5W5cOEC+vTpAz8/P1y7dg0+Pj7w8fHBzZs3pTKLFi3CihUrEBISgsjISJiamsLT0xNv3rzR9LSJiIjoI6TxrTFvb294e3vnu71v375yj5ctW4bQ0FBER0ejQ4cO0vrffvsNR48exS+//ILffvtNrs6WLVuQnp6O9evXw8DAALVr10ZUVBSWLVuG4cOHAwACAwPh5eWFyZMnAwDmzp2L8PBwBAUFISQkBEIIBAQEYPr06ejWrRsAYNOmTbCxsUFYWBh69+6dp+1paWlIS0uTHqekpGj47BAREdGHpFg7S6enp2PNmjWwsLBAvXr1pPWJiYkYNmwYNm/eDBMTkzz1IiIi0KZNGxgYGEjrPD09cffuXfzzzz9SGQ8PD7l6np6eiIiIAADExcUhISFBroyFhQWaNWsmlcltwYIFsLCwkBYHB4eCnzwRERGVesUSCB04cABmZmYwMjLC8uXLER4eDmtrawBZ/XYGDRqEr776Co0bN1ZYPyEhATY2NnLrsh8nJCQoLZNze856isrkNm3aNLx8+VJaHj9+rMlpExER0QemWEaNubu7IyoqCklJSVi7di169uyJyMhIVKhQAStXrsS///6LadOmFcehC8XQ0BCGhoYl3QwiIiJ6T4rlipCpqSmcnZ3RvHlzhIaGQk9PD6GhoQCAEydOICIiAoaGhtDT04OzszMAoHHjxhg4cCAAwNbWFomJiXL7zH5sa2urtEzO7TnrKSpDRERE2u29JFTMzMyUOiGvWLEC169fR1RUFKKioqQh7zt27MD8+fMBAC1atMCZM2fw9u1baR/h4eGoUaMGLC0tpTLHjx+XO054eDhatGgBAHBycoKtra1cmZSUFERGRkpliIiISLtpfGvs1atXiI2NlR7HxcUhKioK5cqVg5WVFebPn4+uXbvCzs4OSUlJCA4OxpMnT+Dr6wsAqFy5stz+zMzMAADVqlVDpUqVAGSNPJs9ezb8/Pzw7bff4ubNmwgMDMTy5culemPHjkXbtm2xdOlSdOrUCdu3b8fly5elIfYymQzjxo3DvHnz4OLiAicnJ8yYMQP29vbw8fHR9LSJiIjoI6RxIHT58mW4u7tLjydMmAAAGDhwIEJCQnDnzh1s3LgRSUlJsLKyQpMmTXD27FnUrl1b7WNYWFjg6NGjGDVqFBo1agRra2vMnDlTGjoPAC1btsTWrVsxffp0fPfdd3BxcUFYWBjq1KkjlZkyZQpSU1MxfPhwJCcno3Xr1jh8+DCMjIw0PW0iIiL6CGkcCLVr1w5CiHy379mzR6P9ValSReH+6tati7Nnzyqt6+vrK11pUkQmk2HOnDmYM2eORm0iIiIi7cBJV4mIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIiraVX0g0gopJVZepBjes8XNipGFpCRPT+8YoQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktBkJERESktTjFBtEHjlNkEBEVHK8IERERkdZiIERERERai4EQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLeYRIiphzANERFRyeEWIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq2lcSB05swZdOnSBfb29pDJZAgLC5Pb7u/vD1dXV5iamsLS0hIeHh6IjIyUK9O1a1dUrlwZRkZGsLOzw5dffomnT59K2x8+fAiZTJZnuXjxotx+du3aBVdXVxgZGcHNzQ2HDh2S2y6EwMyZM2FnZwdjY2N4eHggJiZG01MmIiKij5TGgVBqairq1auH4OBghdurV6+OoKAg3LhxA+fOnUOVKlXQsWNHPH/+XCrj7u6OnTt34u7du/jll19w//59fPHFF3n2dezYMfz111/S0qhRI2nbhQsX0KdPH/j5+eHatWvw8fGBj48Pbt68KZVZtGgRVqxYgZCQEERGRsLU1BSenp548+aNpqdNREREHyGNh897e3vD29s73+19+/aVe7xs2TKEhoYiOjoaHTp0AACMHz9e2u7o6IipU6fCx8cHb9++hb6+vrTNysoKtra2Co8TGBgILy8vTJ48GQAwd+5chIeHIygoCCEhIRBCICAgANOnT0e3bt0AAJs2bYKNjQ3CwsLQu3dvTU+diIiIPjLF2kcoPT0da9asgYWFBerVq6ewzIsXL7Blyxa0bNlSLggCsm6hVahQAa1bt8a+ffvktkVERMDDw0NunaenJyIiIgAAcXFxSEhIkCtjYWGBZs2aSWVyS0tLQ0pKitxCREREH69iSah44MAB9O7dG69fv4adnR3Cw8NhbW0tV+bbb79FUFAQXr9+jebNm+PAgQPSNjMzMyxduhStWrWCjo4OfvnlF/j4+CAsLAxdu3YFACQkJMDGxkZunzY2NkhISJC2Z6/Lr0xuCxYswOzZswt38qR1mBCRiOjDVSxXhNzd3REVFYULFy7Ay8sLPXv2xLNnz+TKTJ48GdeuXcPRo0ehq6uLAQMGQAgBALC2tsaECRPQrFkzNGnSBAsXLkT//v2xePHi4miuZNq0aXj58qW0PH78uFiPR0RERCWrWAIhU1NTODs7o3nz5ggNDYWenh5CQ0PlylhbW6N69er49NNPsX37dhw6dCjPqLCcmjVrhtjYWOmxra0tEhMT5cokJiZKfYqy/1VWJjdDQ0OYm5vLLURERPTxei95hDIzM5GWlqZ0OwClZaKiomBnZyc9btGiBY4fPy5XJjw8HC1atAAAODk5wdbWVq5MSkoKIiMjpTJERESk3TTuI/Tq1Su5KzNxcXGIiopCuXLlYGVlhfnz56Nr166ws7NDUlISgoOD8eTJE/j6+gIAIiMjcenSJbRu3RqWlpa4f/8+ZsyYgWrVqkkBysaNG2FgYIAGDRoAAPbs2YP169dj3bp10nHHjh2Ltm3bYunSpejUqRO2b9+Oy5cvY82aNQAAmUyGcePGYd68eXBxcYGTkxNmzJgBe3t7+Pj4FPgJIyIioo+HxoHQ5cuX4e7uLj2eMGECAGDgwIEICQnBnTt3sHHjRiQlJcHKygpNmjTB2bNnUbt2bQCAiYkJ9uzZg1mzZiE1NRV2dnbw8vLC9OnTYWhoKO137ty5ePToEfT09ODq6oodO3bI5Rpq2bIltm7diunTp+O7776Di4sLwsLCUKdOHanMlClTkJqaiuHDhyM5ORmtW7fG4cOHYWRkpPkzRURERB8djQOhdu3aSZ2aFdmzZ4/S+m5ubjhx4oTSMgMHDsTAgQNVtsXX11e60qSITCbDnDlzMGfOHJX7IiIiIu3DucaIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq2lcSB05swZdOnSBfb29pDJZAgLC5Pb7u/vD1dXV5iamsLS0hIeHh6IjIyUK9O1a1dUrlwZRkZGsLOzw5dffomnT5/KlYmOjsYnn3wCIyMjODg4YNGiRXnasmvXLri6usLIyAhubm44dOiQ3HYhBGbOnAk7OzsYGxvDw8MDMTExmp4yERERfaQ0DoRSU1NRr149BAcHK9xevXp1BAUF4caNGzh37hyqVKmCjh074vnz51IZd3d37Ny5E3fv3sUvv/yC+/fv44svvpC2p6SkoGPHjnB0dMSVK1ewePFi+Pv7Y82aNVKZCxcuoE+fPvDz88O1a9fg4+MDHx8f3Lx5UyqzaNEirFixAiEhIYiMjISpqSk8PT3x5s0bTU+biIiIPkJ6mlbw9vaGt7d3vtv79u0r93jZsmUIDQ1FdHQ0OnToAAAYP368tN3R0RFTp06Fj48P3r59C319fWzZsgXp6elYv349DAwMULt2bURFRWHZsmUYPnw4ACAwMBBeXl6YPHkyAGDu3LkIDw9HUFAQQkJCIIRAQEAApk+fjm7dugEANm3aBBsbG4SFhaF3796anjoRERF9ZIq1j1B6ejrWrFkDCwsL1KtXT2GZFy9eYMuWLWjZsiX09fUBABEREWjTpg0MDAykcp6enrh79y7++ecfqYyHh4fcvjw9PREREQEAiIuLQ0JCglwZCwsLNGvWTCqTW1paGlJSUuQWIiIi+ngVSyB04MABmJmZwcjICMuXL0d4eDisra3lynz77bcwNTWFlZUV4uPj8euvv0rbEhISYGNjI1c++3FCQoLSMjm356ynqExuCxYsgIWFhbQ4ODhoeupERET0ASmWQMjd3R1RUVG4cOECvLy80LNnTzx79kyuzOTJk3Ht2jUcPXoUurq6GDBgAIQQxdEctU2bNg0vX76UlsePH5doe4iIiKh4FUsgZGpqCmdnZzRv3hyhoaHQ09NDaGioXBlra2tUr14dn376KbZv345Dhw7h4sWLAABbW1skJibKlc9+bGtrq7RMzu056ykqk5uhoSHMzc3lFiIiIvp4vZc8QpmZmUhLS1O6HYBUpkWLFjhz5gzevn0rlQkPD0eNGjVgaWkplTl+/LjcfsLDw9GiRQsAgJOTE2xtbeXKpKSkIDIyUipDRERE2k3jUWOvXr1CbGys9DguLg5RUVEoV64crKysMH/+fHTt2hV2dnZISkpCcHAwnjx5Al9fXwBAZGQkLl26hNatW8PS0hL379/HjBkzUK1aNSlA6du3L2bPng0/Pz98++23uHnzJgIDA7F8+XLpuGPHjkXbtm2xdOlSdOrUCdu3b8fly5elIfYymQzjxo3DvHnz4OLiAicnJ8yYMQP29vbw8fEpzHNGREREHwmNA6HLly/D3d1dejxhwgQAwMCBAxESEoI7d+5g48aNSEpKgpWVFZo0aYKzZ8+idu3aAAATExPs2bMHs2bNQmpqKuzs7ODl5YXp06fD0NAQQNborqNHj2LUqFFo1KgRrK2tMXPmTGnoPAC0bNkSW7duxfTp0/Hdd9/BxcUFYWFhqFOnjlRmypQpSE1NxfDhw5GcnIzWrVvj8OHDMDIyKtizRR+dKlMPalzn4cJOxdASIiIqCRoHQu3atVPaqXnPnj1K67u5ueHEiRMqj1O3bl2cPXtWaRlfX1/pSpMiMpkMc+bMwZw5c1Qej4iIiLQP5xojIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaeiXdAKLCqDL1oMZ1Hi7sVAwtISKiDxGvCBEREZHWYiBEREREWouBEBEREWktBkJERESktRgIERERkdZiIERERERaS+NA6MyZM+jSpQvs7e0hk8kQFhYmt93f3x+urq4wNTWFpaUlPDw8EBkZKW1/+PAh/Pz84OTkBGNjY1SrVg2zZs1Cenq6XBmZTJZnuXjxotyxdu3aBVdXVxgZGcHNzQ2HDh2S2y6EwMyZM2FnZwdjY2N4eHggJiZG01MmIiKij5TGgVBqairq1auH4OBghdurV6+OoKAg3LhxA+fOnUOVKlXQsWNHPH/+HABw584dZGZmYvXq1bh16xaWL1+OkJAQfPfdd3n2dezYMfz111/S0qhRI2nbhQsX0KdPH/j5+eHatWvw8fGBj48Pbt68KZVZtGgRVqxYgZCQEERGRsLU1BSenp548+aNpqdNREREHyGNEyp6e3vD29s73+19+/aVe7xs2TKEhoYiOjoaHTp0gJeXF7y8vKTtVatWxd27d7Fq1SosWbJErq6VlRVsbW0VHicwMBBeXl6YPHkyAGDu3LkIDw9HUFAQQkJCIIRAQEAApk+fjm7dugEANm3aBBsbG4SFhaF3796anjoRERF9ZIq1j1B6ejrWrFkDCwsL1KtXL99yL1++RLly5fKs79q1KypUqIDWrVtj3759ctsiIiLg4eEht87T0xMREREAgLi4OCQkJMiVsbCwQLNmzaQyuaWlpSElJUVuISIioo9XsQRCBw4cgJmZGYyMjLB8+XKEh4fD2tpaYdnY2FisXLkSI0aMkNaZmZlh6dKl2LVrFw4ePIjWrVvDx8dHLhhKSEiAjY2N3L5sbGyQkJAgbc9el1+Z3BYsWAALCwtpcXBw0PzkiYiI6INRLHONubu7IyoqCklJSVi7di169uyJyMhIVKhQQa7ckydP4OXlBV9fXwwbNkxab21tjQkTJkiPmzRpgqdPn2Lx4sXo2rVrcTQZADBt2jS546akpDAYKmacK4yIiEpSsVwRMjU1hbOzM5o3b47Q0FDo6ekhNDRUrszTp0/h7u6Oli1bYs2aNSr32axZM8TGxkqPbW1tkZiYKFcmMTFR6lOU/a+yMrkZGhrC3NxcbiEiIqKP13vJI5SZmYm0tDTp8ZMnT9CuXTs0atQIP/30E3R0VDcjKioKdnZ20uMWLVrg+PHjcmXCw8PRokULAICTkxNsbW3lyqSkpCAyMlIqQ0RERNpN41tjr169krsyExcXh6ioKJQrVw5WVlaYP38+unbtCjs7OyQlJSE4OBhPnjyBr68vgP8PghwdHbFkyRJpWD3w/1dxNm7cCAMDAzRo0AAAsGfPHqxfvx7r1q2Tyo4dOxZt27bF0qVL0alTJ2zfvh2XL1+Wri7JZDKMGzcO8+bNg4uLC5ycnDBjxgzY29vDx8dH82eKiIiIPjoaB0KXL1+Gu7u79Di7T83AgQMREhKCO3fuYOPGjUhKSoKVlRWaNGmCs2fPonbt2gCyrtrExsYiNjYWlSpVktu3EEL6/9y5c/Ho0SPo6enB1dUVO3bswBdffCFtb9myJbZu3Yrp06fju+++g4uLC8LCwlCnTh2pzJQpU5Camorhw4cjOTkZrVu3xuHDh2FkZKTpaRMREdFHSONAqF27dnIBS2579uxRWn/QoEEYNGiQ0jIDBw7EwIEDVbbF19dXutKkiEwmw5w5czBnzhyV+6KCYWdnIiL6kHGuMSIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIa2kcCJ05cwZdunSBvb09ZDIZwsLC5Lb7+/vD1dUVpqamsLS0hIeHByIjI6XtDx8+hJ+fH5ycnGBsbIxq1aph1qxZSE9Pl9tPdHQ0PvnkExgZGcHBwQGLFi3K05Zdu3bB1dUVRkZGcHNzw6FDh+S2CyEwc+ZM2NnZwdjYGB4eHoiJidH0lImIiOgjpXEglJqainr16iE4OFjh9urVqyMoKAg3btzAuXPnUKVKFXTs2BHPnz8HANy5cweZmZlYvXo1bt26heXLlyMkJATfffedtI+UlBR07NgRjo6OuHLlChYvXgx/f3+sWbNGKnPhwgX06dMHfn5+uHbtGnx8fODj44ObN29KZRYtWoQVK1YgJCQEkZGRMDU1haenJ968eaPpaRMREdFHSE/TCt7e3vD29s53e9++feUeL1u2DKGhoYiOjkaHDh3g5eUFLy8vaXvVqlVx9+5drFq1CkuWLAEAbNmyBenp6Vi/fj0MDAxQu3ZtREVFYdmyZRg+fDgAIDAwEF5eXpg8eTIAYO7cuQgPD0dQUBBCQkIghEBAQACmT5+Obt26AQA2bdoEGxsbhIWFoXfv3pqeOhEREX1kirWPUHp6OtasWQMLCwvUq1cv33IvX75EuXLlpMcRERFo06YNDAwMpHWenp64e/cu/vnnH6mMh4eH3H48PT0REREBAIiLi0NCQoJcGQsLCzRr1kwqk1taWhpSUlLkFiIiIvp4FUsgdODAAZiZmcHIyAjLly9HeHg4rK2tFZaNjY3FypUrMWLECGldQkICbGxs5MplP05ISFBaJuf2nPUUlcltwYIFsLCwkBYHBwd1T5mIiIg+QMUSCLm7uyMqKgoXLlyAl5cXevbsiWfPnuUp9+TJE3h5ecHX1xfDhg0rjqZoZNq0aXj58qW0PH78uKSbRERERMWoWAIhU1NTODs7o3nz5ggNDYWenh5CQ0Plyjx9+hTu7u5o2bKlXCdoALC1tUViYqLcuuzHtra2Ssvk3J6znqIyuRkaGsLc3FxuISIioo/Xe8kjlJmZibS0NOnxkydP0K5dOzRq1Ag//fQTdHTkm9GiRQucOXMGb9++ldaFh4ejRo0asLS0lMocP35crl54eDhatGgBAHBycoKtra1cmZSUFERGRkpliIiISLtpHAi9evUKUVFRiIqKApDVKTkqKgrx8fFITU3Fd999h4sXL+LRo0e4cuUKhgwZgidPnsDX1xfA/wdBlStXxpIlS/D8+XMkJCTI9dvp27cvDAwM4Ofnh1u3bmHHjh0IDAzEhAkTpDJjx47F4cOHsXTpUty5cwf+/v64fPkyRo8eDQCQyWQYN24c5s2bh3379uHGjRsYMGAA7O3t4ePjU4injIiIiD4WGg+fv3z5Mtzd3aXH2cHJwIEDERISgjt37mDjxo1ISkqClZUVmjRpgrNnz6J27doAsq7axMbGIjY2FpUqVZLbtxACQNborqNHj2LUqFFo1KgRrK2tMXPmTGnoPAC0bNkSW7duxfTp0/Hdd9/BxcUFYWFhqFOnjlRmypQpSE1NxfDhw5GcnIzWrVvj8OHDMDIy0vS0iYiI6COkcSDUrl07KWBRZM+ePUrrDxo0CIMGDVJ5nLp16+Ls2bNKy/j6+kpXmhSRyWSYM2cO5syZo/J4REREpH041xgRERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktBkJERESktRgIERERkdZiIERERERai4EQERERaS2NM0vTx6PK1IMa13m4sFMxtISIiKhk8IoQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktBkJERESktRgIERERkdZiIERERERai4EQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLQZCREREpLUYCBEREZHWYiBEREREWouBEBEREWktBkJERESktRgIERERkdZiIERERERai4EQERERaS0GQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLY0DoTNnzqBLly6wt7eHTCZDWFiY3HZ/f3+4urrC1NQUlpaW8PDwQGRkpFyZ+fPno2XLljAxMUHZsmUVHkcmk+VZtm/fLlfm1KlTaNiwIQwNDeHs7IwNGzbk2U9wcDCqVKkCIyMjNGvWDL///rump0xEREQfKY0DodTUVNSrVw/BwcEKt1evXh1BQUG4ceMGzp07hypVqqBjx454/vy5VCY9PR2+vr4YOXKk0mP99NNP+Ouvv6TFx8dH2hYXF4dOnTrB3d0dUVFRGDduHIYOHYojR45IZXbs2IEJEyZg1qxZuHr1KurVqwdPT088e/ZM09MmIiKij5CephW8vb3h7e2d7/a+ffvKPV62bBlCQ0MRHR2NDh06AABmz54NAAqv4ORUtmxZ2NraKtwWEhICJycnLF26FABQs2ZNnDt3DsuXL4enp6d07GHDhmHw4MFSnYMHD2L9+vWYOnVqnn2mpaUhLS1NepySkqK0fURERPRhK9Y+Qunp6VizZg0sLCxQr149jeuPGjUK1tbWaNq0KdavXw8hhLQtIiICHh4ecuU9PT0REREhHfvKlStyZXR0dODh4SGVyW3BggWwsLCQFgcHB43bTERERB+OYgmEDhw4ADMzMxgZGWH58uUIDw+HtbW1RvuYM2cOdu7cifDwcHz++ef4+uuvsXLlSml7QkICbGxs5OrY2NggJSUF//33H5KSkpCRkaGwTEJCgsJjTps2DS9fvpSWx48fa9RmIiIi+rBofGtMHdn9dpKSkrB27Vr07NkTkZGRqFChgtr7mDFjhvT/Bg0aIDU1FYsXL8aYMWOKo8kAAENDQxgaGhbb/omIiKh0KZYrQqampnB2dkbz5s0RGhoKPT09hIaGFmqfzZo1w59//in14bG1tUViYqJcmcTERJibm8PY2BjW1tbQ1dVVWCa/fkdERESkXd5LHqHMzEy5TsgFERUVBUtLS+mKTYsWLXD8+HG5MuHh4WjRogUAwMDAAI0aNZIrk5mZiePHj0tliIiISLtpfGvs1atXiI2NlR7HxcUhKioK5cqVg5WVFebPn4+uXbvCzs4OSUlJCA4OxpMnT+Dr6yvViY+Px4sXLxAfH4+MjAxERUUBAJydnWFmZob9+/cjMTERzZs3h5GREcLDw/H9999j0qRJ0j6++uorBAUFYcqUKRgyZAhOnDiBnTt34uDBg1KZCRMmYODAgWjcuDGaNm2KgIAApKamSqPIiIiISLtpHAhdvnwZ7u7u0uMJEyYAAAYOHIiQkBDcuXMHGzduRFJSEqysrNCkSROcPXsWtWvXlurMnDkTGzdulB43aNAAAHDy5Em0a9cO+vr6CA4Oxvjx4yGEgLOzszQUPpuTkxMOHjyI8ePHIzAwEJUqVcK6deukofMA0KtXLzx//hwzZ85EQkIC6tevj8OHD+fpQE1ERETaSeNAqF27dnLD2HPbs2ePyn1s2LBBaQ4hLy8veHl5qdWWa9euKS0zevRojB49WuW+iIiISPtwrjEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0loMhIiIiEhrMRAiIiIircVAiIiIiLQWAyEiIiLSWgyEiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0ll5JN4AKrsrUgxrXebiwUzG0hIiI6MPEK0JERESktRgIERERkdZiIERERERai4EQERERaS0GQkRERKS1NA6Ezpw5gy5dusDe3h4ymQxhYWFy2/39/eHq6gpTU1NYWlrCw8MDkZGRcmXmz5+Pli1bwsTEBGXLllV4nPj4eHTq1AkmJiaoUKECJk+ejHfv3smVOXXqFBo2bAhDQ0M4Oztjw4YNefYTHByMKlWqwMjICM2aNcPvv/+u6SkTERHRR0rjQCg1NRX16tVDcHCwwu3Vq1dHUFAQbty4gXPnzqFKlSro2LEjnj9/LpVJT0+Hr68vRo4cqXAfGRkZ6NSpE9LT03HhwgVs3LgRGzZswMyZM6UycXFx6NSpE9zd3REVFYVx48Zh6NChOHLkiFRmx44dmDBhAmbNmoWrV6+iXr168PT0xLNnzzQ9bSIiIvoIaZxHyNvbG97e3vlu79u3r9zjZcuWITQ0FNHR0ejQoQMAYPbs2QCg8AoOABw9ehS3b9/GsWPHYGNjg/r162Pu3Ln49ttv4e/vDwMDA4SEhMDJyQlLly4FANSsWRPnzp3D8uXL4enpKR172LBhGDx4MAAgJCQEBw8exPr16zF16tQ8x01LS0NaWpr0OCUlRc1nhYiIiD5ExdpHKD09HWvWrIGFhQXq1aundr2IiAi4ubnBxsZGWufp6YmUlBTcunVLKuPh4SFXz9PTExEREdKxr1y5IldGR0cHHh4eUpncFixYAAsLC2lxcHBQu81ERET04SmWQOjAgQMwMzODkZERli9fjvDwcFhbW6tdPyEhQS4IAiA9TkhIUFomJSUF//33H5KSkpCRkaGwTPY+cps2bRpevnwpLY8fP1a7zURERPThKZYpNrL77SQlJWHt2rXo2bMnIiMjUaFCheI4XJExNDSEoaFhSTeDiIiI3pNiuSJkamoKZ2dnNG/eHKGhodDT00NoaKja9W1tbZGYmCi3Lvuxra2t0jLm5uYwNjaGtbU1dHV1FZbJ3gcRERFpt/eSRygzM1OuE7IqLVq0wI0bN+RGd4WHh8Pc3By1atWSyhw/flyuXnh4OFq0aAEAMDAwQKNGjeTKZGZm4vjx41IZIiIi0m4a3xp79eoVYmNjpcdxcXGIiopCuXLlYGVlhfnz56Nr166ws7NDUlISgoOD8eTJE/j6+kp14uPj8eLFC8THxyMjIwNRUVEAAGdnZ5iZmaFjx46oVasWvvzySyxatAgJCQmYPn06Ro0aJd26+uqrrxAUFIQpU6ZgyJAhOHHiBHbu3ImDB/9/RvYJEyZg4MCBaNy4MZo2bYqAgACkpqZKo8iIiIhIu2kcCF2+fBnu7u7S4wkTJgAABg4ciJCQENy5cwcbN25EUlISrKys0KRJE5w9exa1a9eW6sycORMbN26UHjdo0AAAcPLkSbRr1w66uro4cOAARo4ciRYtWsDU1BQDBw7EnDlzpDpOTk44ePAgxo8fj8DAQFSqVAnr1q2Ths4DQK9evfD8+XPMnDkTCQkJqF+/Pg4fPpynAzURERFpJ40DoXbt2kEIke/2PXv2qNzHhg0b8s0hlM3R0RGHDh1S2ZZr164pLTN69GiMHj1aZZtKQpWpB1UXyuXhwk7F0BIiIiLtxLnGiIiISGsxECIiIiKtxUCIiIiItBYDISIiItJaDISIiIhIazEQIiIiIq3FQIiIiIi0FgMhIiIi0lrFMvv8xyI7cWRKSkqx7D8z7bXGdXK2paTrl4Y2lHT90tCGD71+aWhDSdcvDW340OuXhjaUdP2C7KO0PYdFJXufyhJAZ5MJdUppqT///BMODg4l3QwiIiIqgMePH6NSpUpKyzAQUiIzMxNPnz5FmTJlIJPJ3ttxU1JS4ODggMePH8Pc3Jz1C6Ck2/Ch1y8NbSjp+qWhDR96/dLQhpKuXxra8KHXLwghBP7991/Y29tDR0d5LyDeGlNCR0dHZSRZnMzNzQv1otH2+qWhDR96/dLQhpKuXxra8KHXLw1tKOn6paENH3p9TVlYWKhVjp2liYiISGsxECIiIiKtxUCoFDI0NMSsWbNgaGjI+gVU0m340OuXhjaUdP3S0IYPvX5paENJ1y8NbfjQ6xc3dpYmIiIircUrQkRERKS1GAgRERGR1mIgRERERFqLgRARERFpLQZCREREpLWYWboUysjIwI0bN+Do6AhLS8uSbs57kZycjN9//x3Pnj1DZmam3LYBAwaUUKuIqDDevHkDIyOjkm4GlYB//vkHoaGh+OOPPwAANWvWxJAhQ1CuXLkSblleHD5fCowbNw5ubm7w8/NDRkYG2rZtiwsXLsDExAQHDhxAu3bt3ks73r17h1OnTuH+/fvo27cvypQpg6dPn8Lc3BxmZmbFdtz9+/ejX79+ePXqFczNzeXmdZPJZHjx4kWxHTunIUOGIDAwEGXKlJFbn5qaim+++Qbr168v1uM/ffoU586dUxgMjhkzpliPXVTmzJmDSZMmwcTERG79f//9h8WLF2PmzJkq9/Hff/9BCCHt49GjR9i7dy9q1aqFjh07Fqp9QohinTfw7du38PLyQkhICFxcXAq0j9TUVJw+fRrx8fFIT0+X26bO6yAjIwMbNmzA8ePHFb6WTpw4UaB2qSszMxPz589HSEgIEhMTce/ePVStWhUzZsxAlSpV4OfnV6zHLw3+/vtvzJw5EydPnlT4N3hfn2kl5cyZM+jatSvMzc3RuHFjAMCVK1eQnJyM/fv3o02bNiXcQnkMhEqBSpUqISwsDI0bN0ZYWBhGjRqFkydPYvPmzThx4gTOnz+v9r5u376t8AO0a9euSus9evQIXl5eiI+PR1pamvThNXbsWKSlpSEkJETlsVNTU7Fw4cJ8P4AfPHigsF716tXx2Wef4fvvv8/zBaqJxMRETJo0STp+7pd2RkaG0vq6urr466+/UKFCBbn1SUlJsLW1xbt371S24fjx4/mev7JAasOGDRgxYgQMDAxgZWWVJxjM77lT5M2bN4iOjlbYBlWvg6tXr0JfXx9ubm4AgF9//RU//fQTatWqBX9/fxgYGCitn99z+Pfff6NChQoq/wYA0LFjR/To0QNfffUVkpOT4erqCn19fSQlJWHZsmUYOXKk0vqDBg1CcHAwTE1N5dY/fPgQX375Jc6ePauyDZmZmYiNjVX4HKr6EC9fvjwuXLhQoEDo2rVr+Oyzz/D69WukpqaiXLlySEpKgomJCSpUqKDW62D06NHYsGEDOnXqBDs7uzyB3/Lly5XWz8jIwPLly7Fz506FnyWqvsTnzJmDjRs3Ys6cORg2bBhu3ryJqlWrYseOHQgICEBERITKcwCAzZs3IyQkBHFxcYiIiICjoyMCAgLg5OSEbt26qaxfmL9htuTkZLmrGrVr18aQIUNUzmH12WefITY2Fn5+frCxscnzNxg4cKDCej169FCrXQCwZ88epdsLGhBHR0ejTp060NHRQXR0tNJj1K1bV+F6Nzc3tGjRAqtWrYKurq7Unq+//hoXLlzAjRs3lO73vRNU4gwNDcXjx4+FEEIMGzZMjB07VgghxIMHD0SZMmXU2sf9+/dF3bp1hUwmEzo6OkImk0n/19HRUVm/W7duon///iItLU2YmZmJ+/fvCyGEOHnypHB2dlarDb179xZ2dnZiypQpYvny5SIgIEBuyY+JiYl0vMLw8vIStWrVEj/++KPYu3evCAsLk1vy8/LlS5GcnCxkMpmIjY0VL1++lJYXL16IjRs3Cjs7O5XH9/f3Fzo6OqJp06aiW7duwsfHR25RplKlSmLevHkiIyND4/PO6bfffhPly5eX/v45F3VeB40bNxa7d+8WQmS9poyMjESfPn2Es7Oz9LpURiaTiWfPnuVZf/z4cWFtba3WOVhZWYmbN28KIYRYu3atqFu3rsjIyBA7d+4Urq6uKuvXr19fVK1aVVy4cEFat2HDBmFubq7y7yCEEBEREcLJyUnufaTJczhu3Djx7bffqiynSNu2bcWwYcNERkaG9D6Mj48Xbdq0Eb/88ota+7CyshIHDx4s0PGFEGLGjBnCzs5OLFmyRBgZGYm5c+cKPz8/YWVlJQIDA1XWr1atmjh27JgQQsh9lvzxxx+ibNmyarXhxx9/FNbW1mLevHnC2NhY2sdPP/0k2rVrp7J+Qf+G169fl96Dly5dEuXKlRMVK1YU3bt3F927dxeVKlUSVlZW4sqVK0qPb2ZmJqKiotQ615wGDRokLQMHDhTm5ubCwcFBOn7lypWFubm5GDRokMp9jRo1SpiamoqePXuKsWPHinHjxskt+ZHJZCIxMVH6f+7nMPuxsufRyMhI3LlzJ8/6O3fuCCMjIzWeifeLgVApULlyZXHkyBHx7t074eDgIA4cOCCEEOLmzZtqf3B07txZdOvWTTx//lyYmZmJ27dvi7Nnz4qmTZuKM2fOqKxfrlw56YWb88MrLi5OGBsbq9UGCwsLce7cObXK5tS9e3exY8cOjevlZmZmJq5du6ZxvZwBo6JFV1dXzJs3T+V+bG1txaZNmwrQ8qznPzY2tkB1c3J2dhZff/21SEhIKFB9c3NzqR0LFy4UHTt2FEIIce7cOVGpUqV865UtW1ZYWloKHR0d6f/Zi7m5udDR0RFff/21Wm0wNjYWjx49EkII4evrK/z9/YUQQsTHx6v1WkxPTxeTJk0SBgYGYtq0acLX11eYmZmJNWvWqHX8evXqCV9fX3H79m3xzz//iOTkZLlFldGjRwtzc3PRqFEjMXz4cDF+/Hi5RRkLCwvpfWhhYSFu374thBDi4sWLokaNGmq1387OTty9e1etsopUrVpV+gwyMzOTXg+BgYGiT58+KusbGRmJhw8fSvWzP0tu3bolTE1N1WpDzZo1xd69e/Ps48aNG8LKykpl/YL+DXMGAa1btxaDBg0Sb9++lba/fftWDBw4UHzyySdKj9+4cWMRERGhsp3KTJkyRQwdOlS8e/dOWvfu3TsxfPhwMWnSJJX1CxoQP3z4UGRmZkr/V7bkp2XLltLfL6e9e/eKZs2aadym4sbO0qXA4MGD0bNnT+kytoeHBwAgMjISrq6uau0jIiICJ06cgLW1NXR0dKCjo4PWrVtjwYIFGDNmDK5du6a0fmZmpsLbFn/++WeePjP5sbS0LFBHuE6dOmHy5Mm4ffs23NzcoK+vL7dd1e2cbA4ODnluh6nj5MmTEEKgffv2+OWXX+TOwcDAAI6OjrC3t1e5n/T0dLRs2VLj4wOAn58fdu3ahalTpxaofrbExERMmDABNjY2BaovhJAuoR87dgydO3cGkPXcJiUl5VsvICAAQggMGTIEs2fPlrt1YGBggCpVqqBFixZqtcHZ2RlhYWHo3r07jhw5gvHjxwMAnj17BnNzc5X19fX1sXjxYpiYmGDu3LnQ09PD6dOn1T5+TEwMdu/eDWdnZ7XK53bz5k00bNgQAHDv3j25bar6J+nr60NHJ2swb4UKFRAfH4+aNWvCwsICjx8/Vuv4EydORGBgIIKCggrUHyohIUG6NWpmZoaXL18CADp37owZM2aorF+rVi2cPXsWjo6Ocut3796NBg0aqNWGuLg4hWUNDQ2Rmpqqsn5B/4ZxcXEoX748AODy5ctYu3Yt9PT+/2tST08PU6ZMkfq95OfHH3/E1KlTMXPmTNSpUyfPZ5o6r+P169fj3Llz0q0lIOvW84QJE9CyZUssXrxYaX0DA4MCvYZz/t0sLS3zbWtsbKzc45y30caMGYOxY8ciNjYWzZs3BwBcvHgRwcHBWLhwocZtKnYlG4dRtl27dolly5ZJt8iEyLqcr+yWTk5ly5YVDx48EEJk/aI7ceKEEEKI2NhYtX5F9+zZUwwbNkwIkfUL7MGDB+Lff/8V7du3V+syrBBCbN68WXzxxRciNTVVrfLZFN3G0eRWRLYjR46Ijh07iri4OI2Ony3nL6GCmDJlipgzZ06B6r579054eXmJtm3bitGjR2t0FSGnwYMHi3Xr1hWoDUII4e7uLgYMGCA2bdok9PX1RUxMjBBCiFOnTglHR0eV9U+dOiX3C7ogdu3aJfT19YWOjo749NNPpfXff/+98PLyUlk/PT1dTJgwQRgaGorvvvtOtGnTRtja2qr969jd3V389ttvBW5/YXz66adiy5YtQgghhg4dKpo2bSp+/vln4enpKZo2barWPnx8fISFhYVwcnISnTt3lm6rZC+qVK9eXVy8eFEIIUSrVq3EggULhBBCbN++XZQvX15l/bCwMGFhYSEWLlwoTExMxOLFi8XQoUOFgYGBOHr0qFrnULNmTemzL+cVoRUrVogGDRqorF/Qv+H48ePFq1evhBBCVKhQQRw5ciRPmcOHD4sKFSoo3c+9e/dE48aN81xd1uQzrWzZsgo//8PCwtS6U7BkyRLx9ddfF+ozrXXr1uK///7Ls/7OnTuiYsWKcusU3UYr7Gf6+8IrQqXEF198kWddfh3qFKlTpw6uX78OJycnNGvWDIsWLYKBgQHWrFmDqlWrqqy/dOlSeHp6olatWnjz5g369u2LmJgYWFtbY9u2bWq1YenSpbh//z5sbGxQpUqVPL+Crl69qrBe7k58BdWrVy+8fv0a1apVg4mJSZ7jq+rk+ccff+Dx48do3bo1ACA4OBhr165FrVq1EBwcrDCVwYQJE6T/Z2ZmYs2aNTh27Bjq1q2b5/jLli3L99gLFizAkSNHUKNGDQDI01laXUFBQfD19cXZs2cVXl1TNeooICAA/fr1Q1hYGP73v/9Jvyh3796t1tWuMmXK4I8//ihwZ2sg673QunVr/PXXX6hXr560vkOHDujevbvK+o0bN8br169x6tQpNG/eHEIILFq0CD169MCQIUPw448/Kq3/zTffYOLEidKVkdzPYX4dRHOLjY3F/fv30aZNGxgbG6s1Yu3777/Hv//+CwCYP38+BgwYgJEjR8LFxUXtUYtly5ZV63nKT/fu3XH8+HE0a9YM33zzDfr374/Q0FDEx8dLV+eU6datG/bv3485c+bA1NQUM2fORMOGDbF//358+umnarVhwoQJGDVqFN68eQMhBH7//Xds27YNCxYswLp161TWL+jf8Nq1a3j79i2ArM8TPz8/LFmyRHrtnz9/HpMnT0afPn2UHr9fv37Q19fH1q1bFXaWVsfgwYPh5+eH+/fvo2nTpgCy7hIsXLgQgwcPVln/3LlzOHnyJH777TfUrl07z3OgqrM1kHVFsEePHti3b590ZeyPP/5A+/bt0bNnT7mycXFx6p5aqcNRY6VEQUcbZTty5AhSU1PRo0cPxMbGonPnzrh37x6srKywY8cOtG/fXuU+3r17h+3btyM6OhqvXr1Cw4YN0a9fPxgbG6t1DrNnz1a6fdasWWrtp6A2btyodLuqwNLNzQ0//PADPvvsM9y4cQONGzfGxIkTcfLkSbi6uuKnn37KU8fd3V2ttslkMqXDli0tLbF8+XIMGjRIrf3lJzQ0FF999RWMjIwKPfospzdv3kBXVzfPh2luTZo0wdSpU/H555/jwYMHqFWrFnr06IFLly6hU6dOCAgIKNDxNeHn54cVK1bkGTV27do1fPnll7h586bS+tm3pnKSyWRSIKNq5Nvff/+Nnj174uTJk5DJZIiJiUHVqlUxZMgQWFpaYunSpZqfVAmKiIhAREQEXFxc0KVLl/d23C1btsDf3x/3798HANjb22P27NlqDb8v7N8QyLrVPXnyZISEhEgjRvX19TFy5EgsXLgQhoaG+dY1MTHBtWvXpB82BZGZmYklS5YgMDAQf/31FwDAzs4OY8eOxcSJE+VumSmiKlhS9HmW23///QcPDw9UqlQJ27dvx61bt9ChQwf069dP6Q+7Dw0DoVJg9uzZmDNnDho3bqxwuOvevXsLtN8XL17A0tKyWPOmFNSKFSswfPhwGBkZYcWKFUrLvq8cOmZmZrh58yaqVKkCf39/3Lx5E7t378bVq1fx2WefISEhodiObWtri7NnzxY490zO/YwZMwZTp05V+GWgjuTkZOzevRv379/H5MmTUa5cOVy9ehU2NjaoWLGi0roWFha4evUqqlWrhh9++AEnTpzAkSNHcP78efTu3Tvffi49evTAhg0bYG5urnIIsTq/ZPOTlpam9AsMyEoloUzuvi+5DRgwAM+ePcO6detQs2ZNXL9+HVWrVsWRI0cwYcIE3Lp1S+N2a6qkcoLllJ6ervCHXeXKlTXaz+vXr/Hq1as8KRmUKezfMPfxs4Ox7KvNqrRp0wYzZ86U+nsWVkpKCgD1+hYVteTkZLRr1w4uLi44c+YMBgwYoLJ/0qZNm5RuL21JcnlrrBQICQnBhg0b8OWXXxbpflV1XN63b5/a+1K3wzKQlTgrZ94NRZ0ely9fjn79+sHIyEhpXhOZTFagQOjNmzd58p+o+hAxMDDA69evAWR1FM5+s5YrV076IFLm5cuXyMjIyPO8v3jxAnp6ekqPP3bsWKxcuVJlUKhKeno6evXqVeAgKDo6Gh06dEDZsmXx8OFDDBs2DOXKlcOePXsQHx+v8gNOFLCztYWFhRSwq8rRokp8fLzS7aq+iDX5klTk6NGjOHLkCCpVqiS33sXFReUXdGFzYQF5c4J9+umnKFOmDH744Yd8c4Lt27cP3t7e0NfXV/m5oOqzICYmBkOGDMGFCxfk1mtyNSYnExMTjfOLFfZvmPv42bd61fXNN99g7NixmDx5cqFur2YrTAD0/Plz3L17FwBQo0YNqTN4fnJ/1uno6GDHjh349NNP8fnnn2PGjBkqA7OxY8fKPX779i1ev34NAwMDmJiYlLpAiFeESgErKyv8/vvvqFatWoH3UZBkhup+War74fXs2TP07t0bp06dQtmyZQFk/Zpwd3fH9u3bVb4BCys1NRXffvstdu7cib///jvPdlXn0LVrV6Snp6NVq1aYO3cu4uLiULFiRRw9ehSjR4/OMwIoN29vb3Tp0gVff/213PqQkBDs27cPhw4dyrdu9+7dceLECVhZWRX4fj4AjB8/HuXLl8d3332nVvncPDw80LBhQyxatAhlypSRrmZcuHABffv2xcOHD5XWb9++PRwcHODh4QE/Pz/cvn0bzs7OOH36NAYOHKiyvhACjx8/Rvny5dW+JZubjo6O0qugil4HRRkIlClTBlevXoWLi4vcc3j58mV4enoqfG1m8/b2Rnx8PEaPHq3w6rA6iQR9fHxQpkwZhIaGwsrKSjr+qVOnMGzYMMTExOSpo6Ojg4SEBFSoUEHp54I6nwWtWrWCnp4epk6dqvAccvb7yo+Tk5PSv6E6t3gLm5DxzZs3WLlyZb7ZofPr8wgU/NZcw4YNcfz4cVhaWqJBgwZKnwNlxwf+PyP+pk2bpLbr6upiwIABWLlyZb7BZX7vn+xQQdNbjNliYmIwcuRITJ48GZ6enmrXex94RagUGDp0KLZu3arW0FRl+zh9+jS+/PJLhR8+ihRVJ+Vs33zzDf7991/cunULNWvWBJCV6XrgwIEYM2aMwk7Xb9++haurKw4cOCDVKagpU6bg5MmTWLVqFb788ksEBwfjyZMnWL16tVpDNoOCgvD1119j9+7dWLVqlXQb6LfffoOXl5fK+pGRkQrvm7dr1w7/+9//lNYtW7asRlll85ORkYFFixbhyJEjGnfYBoBLly5h9erVedZXrFhRrVuDhe1sLYSAs7Mzbt26VeDbhLlTRbx9+xbXrl3DsmXLMH/+fIV1fHx8pEDAx8cn332r8+H/ySefYNOmTZg7d65UJzMzE4sWLVLZp+zcuXM4e/Ys6tevr7ScMmfPnsWFCxfydEyvUqUKnjx5orBOzs+Cwn4uREVF4cqVK2qn/lBk3Lhxco+z/4aHDx/G5MmTVdZftWoVZs6ciXHjxmH+/PnS36xs2bIICAhQKxDy8/PD0aNH8cUXX6Bp06YadTEoaMfhbt26Sbdulb0O1TFhwgScPn0a+/fvR6tWrQBkvb7GjBmDiRMnYtWqVQrrnTx5slDHzY+LiwsWLlyI/v37486dO8VyjAJ7z6PUSIExY8aIsmXLijZt2hR46HRBkxkWJXNzc/H777/nWR8ZGSksLCzyrWdvby8ljisMBwcHcfLkSSGEEGXKlJGGfm/atEl4e3sXev+qmJiYiOjo6Dzro6Oj1U5KWVjt2rXLd3F3d1dZv3z58uLq1atCCPlhy0ePHlWaUFGV//77T6Snp6tVtlatWoVORqfIgQMHRNu2bYt8v7nduHFDVKhQQXh5eQkDAwPxxRdfiJo1awobGxuVSTNr1qwpPf8FVbZsWXHr1i0hhPzf8OzZsyqHfReFxo0bi7NnzxbLvoOCgtRK51HYhIxCZH2eldRn6rt378Tp06fFP//8U+B9WFlZSZ+HOZ04cULtLO9F7dq1a2rPlvA+8YpQKRAdHS39Asw9okXdXyEFSWaoSX8UdfrpZGZmKhxVpK+vr/RX5qhRo/DDDz9g3bp1csnLNPXixQspVYC5ubk0XL5169Yq56fKdv/+ffz000+4f/8+AgMDUaFCBfz222+oXLkyateurbRu06ZNsWbNGqxcuVJufUhICBo1alSAM9JcYX/Nde3aFXPmzMHOnTsBZL3+4uPj8e233+Lzzz9Xax+KOlvfvn1brc7WALBw4UJMnjwZq1atQp06dQp1PjnVqFEDly5dKrL95adOnTq4d+8egoKCUKZMGbx69Qo9evTAqFGjYGdnp7RuQEAApk6ditWrV6NKlSoFOn7Hjh0REBCANWvWAMj6G7569QqzZs3CZ599prL+mDFj4OzsnOc9HxQUhNjYWJUj/3744QdMmTIF33//vcL+MYXp7+Lt7Y1p06apHPFU2ISMQNZVUHWTyQJF2+dSV1cXHTt2xB9//CF1M9DU69evFSZWrVChgtQXUh3Jycn4/fffFd4ezK+vT+7nQgiBv/76C0FBQdLVqdKEfYQ+Ej///DN+/fVXbNy4Ue2OhU5OTmqVU3fYdbdu3ZCcnIxt27ZJmZifPHmCfv36wdLSMt/Rb9l5S8zMzODm5pZn2LO6/WPq1q2LlStXom3btvDw8ED9+vWxZMkSrFixAosWLcKff/6ptP7p06fh7e2NVq1a4cyZM/jjjz9QtWpVLFy4EJcvX8bu3buV1j9//jw8PDzQpEkTdOjQAUBWWoRLly7h6NGj+OSTT5TW3717d74TXarqD1BUXr58iS+++AKXL1/Gv//+C3t7eyQkJKBFixY4dOhQnr9Nbrk7W9+9exdVq1bF9OnT1epsDWQF9a9fv8a7d+9gYGCQp6+QqnxQuTt7Zn8I+/v7486dO4iKispTp6h/FBRUznMvSC4sICsbvKenJ4QQiImJQePGjaWcYGfOnFE5+qpixYrYt29fnuD96tWr6Nq1q8r3UXb/mNw/4kQBO0vntGjRIvz4448q+5rVqlULCxYsQLdu3eT6aa1cuRI//fSTWu+n3377DStWrEBISIhana+Lus9l48aN8cMPP0ifJZrq0KEDrKyssGnTJhgZGQHIGg4/cOBAvHjxAseOHVO5j/3796Nfv3549eoVzM3N86TjyO/1mPu5kMlkKF++PNq3b4+lS5eq/EHwvvGKUClSkARs2QqSzLCoE2AFBQWha9euqFKlChwcHAAAjx8/Rp06dfDzzz/nW69s2bJqX21QZvDgwbh+/Tratm2LqVOnokuXLggKCsLbt2/VynkxdepUzJs3DxMmTJD7Jdi+fXsEBQWprN+qVStERERg8eLF2LlzJ4yNjVG3bl2Ehoaq7O+yYsUK/O9//8OgQYPw66+/YvDgwbh//z4uXbqEUaNGqT75HC5fvpxvQKUqqLSwsEB4eDjOnTsnl09K3WHAEyZMwODBg6XO1tk+++wz9O3bV619FDbXUNmyZRV+CTs4OGD79u0K66iakT2bOqMYnZ2d0b9/f/Tr10/jfk5FkWepUqVKuH79ulxOMD8/P7Vzgv39998KR+6Zm5srHfmXrSj6mOTuKCyEQEJCAp4/f64yISZQ+ISMQFYg8ubNG1StWlWtoLSo+1zOmzcPkyZNwty5c9GoUaM8P0JUXVkLDAyEp6cnKlWqJHVQv379OoyMjHDkyBG12jBx4kQMGTIE33//vUYj94r6uShuvCJUChRFAraSTmaYTQiBY8eOSZ3hatasWWS5NDT16NEjXLlyBc7OzmoNVzUzM8ONGzfg5OQk9yvy4cOHcHV1xZs3b4qtra6urpg1axb69Okjd+yZM2fixYsXagViALB9+3YMGDAAnp6eOHr0KDp27Ih79+4hMTER3bt3VyuJWmHkzCOU8zwePXqEGjVqFOtzmO306dNyj3V0dFC+fHk4OzsX6tarupYvX46tW7fiypUraNSoEfr3749evXrB1ta22I9dFOrUqYOvvvoKo0ePllu/cuVKrFq1Crdv3y72NuT+PMv+G7Zr107tTtiFScgIZI2gjI+Ph5+fn8Ls0Jpk/i+InFdVcgeF6l5Vev36NbZs2SL3eaxJklxTU1PcuHFDrdkJPmQMhEqBkkrANmHCBMydOxempqZyU0Uoos4VlQcPHnzQb5hKlSph586daNmypdyX+N69ezFp0iTpAzWnlJQU6ZeZqlxDyn7BmZiY4I8//oCjoyMqVKiA8PBw1KtXDzExMWjevLnSIdc51a1bFyNGjMCoUaOkc3BycsKIESNgZ2enMGAuyttCFSpUwJEjR9CgQQO55zA8PBxDhgxRe+LQbAXJB1UYRTmK8d69e9iyZQu2bduGuLg4uLu7o3///ipzqGRmZiI2NlZhn4w2bdqoPG5+fVVkMhmMjIzg7Oys9Lb4+vXrMXr0aEyePFnKSH/8+HEsXboUAQEBGDZsmNLj55x8U9HxK1eurDKpZVEqSEJGIOs9GRERodZwf0VOnz6NJUuWSDnVatWqhcmTJ6u8RZ6zvjJt27YtULs00aNHD/Tu3TvPdBr5UfU9kq20ZaXmrbFSoDAJ2HJTJ5lhtpzz6iibnV7d23POzs5o27Yt/Pz88MUXX0j3pVUpTM6QovwS7927N7799lvs2rVLGvJ8/vx5TJo0Kd8vL0tLS/z111+oUKGCwlsygHq/4GxtbfHixQs4OjqicuXKuHjxIurVq4e4uLg8SfWUuX//Pjp16gQgK0FkamoqZDIZxo8fj/bt2ysMhIrytlBRdLYubD6obLdv31Z4e1BZR1V9ff0iu2pVvXp1zJ49G7Nnz8bFixcxcuRIDB48WGkgdPHiRfTt2xePHj3K83dX9yqAj4+PlOsld/3s12Lr1q0RFhamcP68IUOGIC0tDfPnz5dSAFSpUgWrVq1SKxFe/fr1lb6f9fX10atXL6xevTrfz4j8flTIZDIYGhqqNWddtoIkZASyrtL+999/GtcDsvpsDh48GD169JDeM+fPn0eHDh2wYcMGtW4TF0Wgc/fuXaxcuVL6TqhZsyZGjx6t9lW1Tp06YfLkybh9+7bCju+530u5v0fOnTuHRo0ayV2BKo0zHXD4fClgZmYm7t27J/0/e6jnpUuXRLly5dTaR2JionB3dxcymUxYWloKS0tLIZPJRPv27cWzZ8+Kre05Xbt2TYwZM0aUL19eWFhYiOHDh0uzWCsTEBAgtyxevFj07dtXlCtXTpr5Oj9VqlRRa3FyclLZjrS0NDF06FChp6cnZDKZNAN6//79xbt37xTWyTnb+qlTp5Quyvj5+Ql/f38hRNYQYWNjY+Hh4SHKli0rhgwZorLt2SpWrCgN4XdzcxNbt24VQghx4cIFYW5urvZ+Cio5OVlqt66urnBwcBD6+vqiTZs20qzeqnz99deiZs2aYvfu3cLY2FisX79ezJ07V1SqVEn8/PPPKuvfv39f1K1bN89s2NkzgKsyf/58MXDgQOnvWhiRkZFi7NixwtbWVpiYmIhevXopLV+vXj3h6+srbt++Lf755x+RnJwst6jj2LFjolmzZuLYsWMiJSVFpKSkiGPHjokWLVqIgwcPinPnzonatWur9bp69uyZ+Pfff9U6brawsDBRo0YNsW7dOhEdHS2io6PFunXrRM2aNcX27dvFzz//LCpVqiQmTpyY7z5y/r0ULZUrVxYzZ84UGRkZCusnJSVJryMrKyvpMzF7UceRI0dEy5YtxcmTJ0VSUpJ4+fKl3KKMq6urWLZsWZ71S5cuFa6urvnWu379utqLKrt37xZ6enqiefPmUiqWFi1aCD09PbF7927VT4AQhZ5FPuf3WWnGQKgU8Pb2FtOnTxdCZL1wHjx4IDIyMoSvr6/4/PPP1dpHz549RePGjeXy8dy6dUs0btxY9O7dW+22xMTEiMOHD4vXr18LIYTIzMzU4EyyvH37Vvzyyy+iS5cuQl9fX9SuXVssXbpU44BM3ZwhRSEzM1M8evRIvH79WsTHx4uDBw+KHTt2SAFqccvIyJD74t22bZv45ptvxIoVK0RaWpra++nTp49YunSpEEKIOXPmiPLly4uhQ4cKR0dH0b17d43alJmZWaC/vxBZOWuCg4PFDz/8IMLDwzWqW9h8UJ07dxbdunUTz58/F2ZmZuL27dvi7NmzomnTpuLMmTMq6/v4+IgyZcoIOzs70bFjR9G9e3e5RZW7d++KmTNnChcXF6Gnpyc6duwoNm7cqFZAYWJiIp1vQdWuXVucP38+z/pz586JWrVqCSGECA8PFw4ODoU6Tn6aNGkiDh8+nGf94cOHRZMmTYQQQuzdu1dUrVo1331s3LhRVKpUSUyfPl3s27dP7Nu3T0yfPl04ODiI1atXi3nz5omyZcuK+fPnK6zv7e0tXFxcxMKFC8VPP/0kNmzYILeoI3cAnb2oEwQYGBgo/DvGxMQIQ0NDpcfMeQxliypVq1YVM2bMyLN+5syZSp/7osRAiNRWmARs2QqazDBbUlKSaN++vfQGzH7xDh48WEyYMEGj88n25s0bsWzZMmFoaChkMpkwNDQUX375pXj69Kla9e/fv//ekm9lZGQIfX39Qgc+//zzjzhy5IjYvHmz2Lhxo9zyPvz999/iyZMnQoisc1qwYIHo0qWLmDBhgnjx4oVa+1i3bp2oXbu2MDAwEAYGBqJ27dpi7dq1xdlsOaampuLRo0dCiKwrXJGRkUIIIR48eCBMTU1V1reyspJ+MZubm4s7d+4IIYQ4fvy4qF+/vsr6gwYNUrqoIpPJRNOmTUVAQIBISEhQWT4nd3d38dtvv2lUJzcjIyNx48aNPOujo6OFkZGREEKIhw8f5pvkMyEhQfTv31/Y2dkJXV1djb+AjYyMxB9//JFn/R9//CEdPy4uTmmS0fbt24sdO3bkWb9jxw7Rvn17IURWYFyjRg2F9c3MzERUVJTKtipTmCu81apVEyEhIXnWr1q1Sjg7O+db7+HDh9Kyd+9eaT/ZV4FCQkKEi4uLlCxSGWNjY4XB2L17995bgtcPJRBiH6FSoDAJ2LIVNJlhtvHjx0NfXx/x8fFynUR79eqFCRMmqDVyLdvly5exfv16bN++Haamppg0aRL8/Pzw559/Yvbs2ejWrRt+//13lfvZvXu3yiSRRdXhW0dHBy4uLvj7778LPLWDqpwbuftX5NepVBF1J2nM+Xzp6Ohg6tSpah8DAGbOnIlly5bhm2++QYsWLQAAERERGD9+POLj4zFnzhyV+zh+/DiWL18u1y9h3Lhxao8erFq1KuLi4lC5cmW4urpi586daNq0Kfbv369WcrmMjAxp6L61tTWePn2KGjVqwNHRUZp8UpnCjqy7e/dugV9D33zzDSZOnIiEhIQCT9bZqFEjTJ48GZs2bZLm93v+/DmmTJmCJk2aAMia9yk7xUVugwYNQnx8PGbMmKH2dD05ubq6YuHChVizZo3Ul+ft27dYuHCh1DflyZMnCpP9Zbtw4YLCyWEbNGiAiIgIAFmJUvObYLcw/XuyFaaPzsSJEzFmzBhERUVJU8ucP38eGzZsQGBgYL71cuYr8vX1xYoVK+SSYNatWxcODg6YMWOGyik42rVrh7Nnz0rT3GQ7d+6c0g7bK1aswPDhw2FkZKSyD2Zx5tR6r0o6EqOi0bVrV9GmTRvpaoAQQvz555+ibdu2wsfHR2V9Gxsb6RdUzij+/v37av0KFyLr/nedOnWEvr6+6Natm9i/f7/IyMgQjx8/FsOGDRNCCPH48WOhq6srhBBi9uzZ4tWrV6J+/fqiQYMG0lK/fn1ha2srdHV1xerVq5Ues127dlIaemXTS7Rr105l+/ft2ydat26t8Ne0OlxcXMTYsWNFamqqWuWL6jJ47r4LyhZVrK2tpX5FOW3dulWtqQmCg4OFnp6e6N27twgMDBSBgYGiT58+Ql9fXwQFBamsL4QQy5YtE4GBgUKIrFs4RkZGwtDQUOjo6IiAgACV9Vu3bi39Yu7Tp4/w8vIS586dEwMGDBC1a9dWqw1v374V4eHhIiQkRKSkpAghhHjy5IlG/WUuX74sNm/eLDZv3iyuXLmiVp38+mKo2ydDCCHu3LkjatSoIQwMDES1atVEtWrVhIGBgXB1dRV3794VQmTdmtq0aZPC+mZmZuLatWtqHUuR8+fPCysrK1G+fHnRoUMH0aFDB1GhQgVhZWUlTZ2yadMmsWjRonz34eLiIr799ts867/99ltRvXp1IURWH0p7e3uF9X///XfRvn17cerUKY369xRlH509e/aIVq1aiXLlyoly5cqJVq1aibCwMJX1shkZGSmceuj27dvSlbXcfv31V2lZtWqVKF++vBg1apT0Ohw1apSoUKGCWLVqVb7HrVKlikhKSpL+r0m/y9zPkampqTh48KDGz937xuHzpURB0pjn9PjxY3Tt2hW3bt3Kk8xw3759eUak5VaYGbOzubi4YMiQIRg0aJDclazr16+jYcOGyMjIQHp6OrZt24aBAwdCV1cXf/31F3788Ue5X50FyRlSFAqb0VjTnBs5RwReu3YNkyZNwuTJk+WuxCxduhSLFi1S+utP1WzrOakadVS2bFlcunQpzxWNe/fuoWnTpkhOTlZav1KlSpg6dWqeHDTBwcH4/vvv8530E8i6qrl48WLs27cP6enp6NChA2bNmoVnz55plA/qyJEjSE1NRY8ePRAbG4vOnTvj3r17sLKywo4dO6Qh4fl59OgRvLy8EB8fj7S0NNy7dw9Vq1bF2LFjkZaWpvBKRU7Pnj1Dr169cPr0aekKVnJyMtzd3bF9+3bpKk1+x1ZGnQzHQNZzefToUdy7dw9A1vQin376qVrZj2vVqoUtW7YoHXGqyr///ostW7bIHb9v375qT1mxb98++Pr6wtXVVbqKdfnyZdy5cwe7d+9G586dsWrVKsTExCi80hsTE4O+ffvmSSQrVIzgzH4vqfpaLGyGbHU0bNgQderUwbp166Qra+np6Rg6dChu3rypMEluUWe31pSy56+gs9a/DwyESoGCpjHPTRQimeFnn32GRo0aYe7cuShTpgyio6Ph6OiI3r17IzMzU+X0EsrkDIRy0tHRkWb8LowhQ4aoLCOTyRAaGqq0zMaNG5VuV5VATdOcGzk1bdoU/v7+eeaCOnToEGbMmIErV67kWzdnvpGHDx9i6tSpGDRokFxAtXHjRixYsEDlOXzzzTfQ19fP8+UyadIk/PfffwgODlZa38zMDFFRUXkux8fExKBBgwZ49epVvnXnzp0Lf39/eHh4wNjYGEeOHEGfPn2wfv16pcdUx4sXL2BpaalWwOjj44MyZcogNDQUVlZW0o+CU6dOYdiwYYiJiVFav1evXnjw4AE2bdok3Wa+ffs2Bg4cCGdnZ2zbtq3Q51Ocjh49iqVLlxZqvrOi8PDhQ6xevVq6nVmjRg2MGDFCrTY1bdoUenp6GDt2rMJkiPnd9tIkXYk6QWl6errCH7eVK1dWWff3339Hly5dIISQfgBER0dDJpNh//79aNq0qdptLSoZGRm4ceMGHB0dFaZeUPf5Uzegf18YCJUC1atXx2effaZxGvOidPPmTXTo0AENGzbEiRMnpKtLL168wPnz51GtWrUC71tZIJSYmKj0F7I6dHR04OjoiAYNGij9JZffXGdFJTQ0FHPmzMHgwYPVyrmRk7GxMa5evZonid8ff/yBhg0bqt3foUOHDhg6dCj69Okjt37r1q1Ys2YNTp06pbT+N998g02bNsHBwQHNmzcHAERGRiI+Ph4DBgyQOydFv8T79u2LBg0aYPLkyXLrlyxZgsuXL+c7xQWQdUVx0qRJGDFiBADg2LFj6NSpE/777z+1f+nmVNApa6ysrHDhwgXUqFEjT4bxWrVqqZyw0sLCAseOHZOuZGT7/fff0bFjR5VX1TZv3oyQkBDExcUhIiICjo6OCAgIgJOTE7p166ay/UBWLqbTp08rzKOkql9HUcx3dv/+fQQEBMjlNBszZkyhPkc0YWJigmvXrqFGjRrv5Xi5xcTEYMiQIbhw4YLcek2viKSmpubJDN23b1+Vc/7lJzk5WaNJXMeNGwc3Nzf4+fkhIyMDbdq0QUREBExMTHDgwAG0a9euQO0obdhZuhR48uQJxowZo3EQVJTJBIuiw3ZBVK9eXeWXk6oP3pEjR0rZewcPHoz+/fur7GStSkEyGmdn3FXUoVjVh1/NmjWleZByXgZfsGCBRhmOIyIiFN66ady4MYYOHaqy/s2bN9GwYUMAkDJpW1tbw9raGjdv3pQ7H0Vq1aqF+fPn49SpU9IVqYsXL+L8+fOYOHGi3Gs292syPj5e7oqYh4cHZDIZnj59qvLWbk75TVnj5+en1pQ1mZmZCv9Wf/75p1q3dgozcGHVqlWYOXMmxo0bh/nz50vtKFu2LAICAtQKhK5du4bPPvsMr1+/RmpqKsqVK4ekpCSYmJigQoUKKj8LCjvf2ZEjR9C1a1fUr19fmmn8/PnzWL16Nfbv349PP/1U7X29fv1aYTCn6hZp48aN8fjx4yIJhAqSmHPQoEHQ09PDgQMHCtThPJupqSmGDx9eoLo//PADqlSpgl69egHI6nz9yy+/wM7ODocOHVIrY/bu3bvRv39/AFl3Lh4+fIg7d+5g8+bN+N///ofz588XqG2lDa8IlQIFvaVS1LPHF1SPHj2Ubk9OTsbp06cVXhEKCAhQOMFjTurM6ZOWloY9e/Zg/fr1uHDhAjp16gQ/Pz907NhR7Q+hospoXBBFdRm8Ro0a6NatGxYtWiS3fsqUKfj111/VGjVVGIV5Terq6iIhIUHuCmH2bVp19wsUfsqaXr16wcLCAmvWrJGOX758eXTr1g2VK1dWOaqsW7duSE5OxrZt22Bvbw8g68dOv379YGlpqfTKZK1atfD9999Lt+ey237z5k20a9dOrUlP27Vrh+rVqyMkJAQWFha4fv069PX10b9/f4wdO1bl+7WwGjRoAE9PTyxcuFBu/dSpU3H06FG1Zn5//vw5Bg8ejN9++03hdlXvxV27dsHf3x+TJ08u8Oi7Bw8eoHv37rhx44Zcv5fszxNlbTA1NcWVK1eKpI9jQQIxIOu9uGXLFrRs2RLh4eHo2bMnduzYIU3IfPToUZXHNjIyQmxsLCpVqoThw4fDxMQEAQEBiIuLQ7169VROK/ShYCBUQnLOB/T8+fMC31IpKocPH4aZmRlat24NIKtz69q1a1GrVi0EBwcrvB+cbfDgwWodI/cXSFH1Ecrt0aNH2LBhAzZt2oR3797h1q1bMDMzU1lv1KhROHnyJObOnYsvv/wSwcHBePLkCVavXo2FCxeiX79+RdrO3IriMvihQ4fw+eefw9nZGc2aNQOQFWTFxMTgl19+ydMHqTTR0dGBt7e33DxU+/fvR/v27eWegz179ijdj62tLY4cOYJ69erJBRMPHjxA3bp1lfZTArKu/Hh6ekIIgZiYGDRu3BgxMTGwsrLC2bNnVb5eCzNwwdjYGHfu3IGjo6Nc22NiYlC3bl21bpGWLVsWkZGRqFGjBsqWLYuIiAjUrFkTkZGRGDhwoPT6Uub+/fv46aefcP/+fQQGBqJChQr47bffULlyZdSuXVtpXSMjI9y4cUNhh/u6deuqNYVJv3798OjRIwQEBKBdu3bYu3cvEhMTMW/ePCxdulSaRiY/im6latpZt0uXLtDV1cW6devg5OSE33//HX///TcmTpyIJUuWKB2C3qRJEyxfvlz6PC2IwgRiQNZr6d69e3BwcMDYsWPx5s0brF69Gvfu3UOzZs3wzz//qGyDo6Mj1q5diw4dOsDJyQmrVq1Cp06dcOvWLbRu3VqtfXwIeGushCgaBVSQWyq5paenIy4uDtWqVdNopu3Jkyfjhx9+AADcuHEDEyZMwMSJE3Hy5ElMmDBB6a/gguZdKa45Z3KOXNDkudu/fz82bdqEdu3aYfDgwfjkk0/g7OwMR0dHbNmyRWUgpCrHzsyZMxWuzznRZ0Evg2f77LPPEBMTg1WrVkn9M7p06YKvvvoq37wxuV2+fFn61Zj7V6iqIKQwFF35y74sr4nU1FSFt5lfvHih1mSflSpVwvXr17F9+3ZER0fj1atX8PPzU3vWbgcHB1y9erVAAxecnJwQFRWVpzPp4cOH1b5Fqq+vLwUCFSpUkHKDWVhYqDXp7enTp+Ht7Y1WrVrhzJkzmD9/PipUqIDr168jNDRU5cCJ8uXLIyoqKk8gFBUVpfaPnhMnTuDXX39F48aNpT6An376KczNzbFgwQKVgVBcXJxax1EmIiICJ06cgLW1NXR0dKCjo4PWrVtjwYIFGDNmTJ55tXJeHfnhhx8wZcoUfP/99wp/3KozcfDYsWPh5OSE48ePKwzEVLG0tMTjx4/h4OCAw4cPY968eQCg0efi4MGD0bNnT+n2XvZrODIy8r2O6C1272ucPhWv1NRUMWTIEKGrqyt0dXWlPECjR49WOV+XEFnZfOPi4oQQQsyaNUua2uPKlSvCxsamWNosk8lEYmJikezrzZs3YuvWrcLDw0MYGRmJL774Qhw8eDDfuYgUKWxG4/r168sttWvXFiYmJsLc3Fw0aNBAaV17e3uFOUM0kZ6eLtq3b1+o7Njbtm0T+vr6onPnzsLAwEB07txZVK9eXVhYWKg93cnjx49FcHCw+Pbbb6U5jrKX96GwU9Zk51ARQoj4+HgxY8YMMWnSJLWm5yistWvXiooVK4rt27cLU1NTsW3bNjFv3jzp/+r49NNPxZYtW4QQQgwdOlQ0bdpU/Pzzz8LT01M0bdpUZf3mzZtL07TkzCkWGRkpKlasqLL+7NmzRdmyZcXChQvFmTNnxJkzZ8SCBQtE2bJlxZw5c9Q6hzJlykifR5UrVxbnzp0TQmS9F99XVuSyZcuKBw8eCCGypqs4ceKEEEKI2NhYhW3InQ+soNNzZCtshvRRo0YJR0dH4eHhIaysrKQcWNu2bVP5eZTTrl27xLJly8Tjx4+ldRs2bNAoJ1Jpx0CoFNi4caN48+ZNnvVpaWlqT80wZswY0ahRI3H27FlhamoqfXiFhYWp9aaxtLQUt27dEkII0apVKymRoapU+KXByJEjhaWlpahbt64ICAgQz58/L9B+3NzcpNT5HTp0kCaFDAwMVOsLQJGXL1+K7t2755u8LltRTfRpbW1dqEDIzc1NSnyY/SWYmZkphg0bJmbOnKmy/rFjx4SJiYmoU6eO0NPTE/Xr1xdly5YVFhYWwt3dvcDt0kRBp6yJjo4Wjo6OQkdHR9SoUUNcu3ZN2NjYCDMzM2Fubi50dXXVmtpAiKznYdq0acLPz08MHjxYblHl559/Fs7OzlJCxYoVK4p169ape/ri0qVL0pd2YmKi8PT0FGXKlBENGzZUa9oJU1NTKQDIGQjFxcUpnScrW2Zmpli2bJmoWLGi3DkEBASoPXdd48aNpfnKunTpIr788kvx559/iilTpqg9T9amTZtEy5YthZ2dnXj48KEQQojly5er/QWuaWJOVVNyqDs9RzZNA7Hc0tPTxeLFi8WYMWPE1atXpfXLli17L1Pm7Nq1S/j6+opmzZrJJczVJAh7X9hHqBTITiyY+7Lx33//jQoVKqh1GdPR0RE7duxA8+bN5foWxMbGomHDhio7tXXp0gVv375Fq1atMHfuXMTFxaFixYo4evQoRo8eLSVGK410dHRQuXJlNGjQQOntNlW3dZYvXw5dXV2MGTMGx44dkzovv337FsuWLcPYsWML1L4bN26gS5cuePjwYb5lunfvjuPHj8PMzAxubm55+gWpe0tq/PjxMDQ0zNNRVV2mpqa4desWqlSpAisrK5w6dQpubm74448/0L59e/z1119K6zdt2hTe3t6YPXu29DqsUKEC+vXrBy8vL4wcObJA7dLUy5cvERQUhOvXr+PVq1do2LChyhGQ3t7e0NPTw9SpU7F582YcOHAAnp6eWLt2LYCs1AJXrlzBxYsXlR579uzZmDNnDho3bqxwxJC6aRxev36NV69eFXkfOlUqVaqEnTt3omXLlnKfJXv37sWkSZOk0YTq+PfffwFA7USK2X7++We8e/cOgwYNwpUrV+Dl5YUXL17AwMAAGzZskEZC5Sf36LubN2+iatWq2LBhAzZu3IiTJ0+qbEPOxJwxMTHo0qWLlJhz+/bt6NChQ7513759q3DkIAAkJSXB2tpa5fE/+eQTTJw4ET4+Pujbty/++ecfTJ8+HWvWrMGVK1fkRnEWpaIYjbxixQr873//w6BBg7BmzRoMHjwY9+/fx6VLlzBq1CjMnz+/qJpbJBgIlQL55dO5fv063N3d1crbYWJiIr3Zc354Xb9+HW3atMHLly+V1o+Pj8eoUaMQHx+PMWPGwM/PD0DWF2tGRoZGb473bdCgQWr1N9K0L9OjR480ymicn3PnzqFLly5KOxaq6nCubtuz8wC5uLigUaNGeQIqZfOtAVlfgr/99hvc3NxQt25dTJs2DX369EFERAS8vLxUvo7KlCmDqKgoVKtWDZaWljh37hxq166N69evo1u3bkqDwZJmbW2NEydOSB2qzc3NcenSJTRq1AgAcOfOHTRv3lxlHiA7OzssWrQIX3755XtoddGbNGkSIiMjsWvXLlSvXh1Xr15FYmIiBgwYgAEDBmDWrFnvvU2vX7/GnTt3ULlyZbWCiKIYfaeIuok5P//8c+zevTtPucTERHTo0EGtIKYggdi+ffvg7e0NfX19uQE5iuQ3CKcoRiO7urpi1qxZ6NOnj9zzP3PmTLx48QJBQUFqHeN9YWfpEpR9BUMmk6FDhw5ynZszMjIQFxcHLy8vtfbVuHFjHDx4EN988w2A/++IvG7dOimfS37evXuHU6dOYe3atbC1tZXbtnz5ck1OqURs2LChWPbr6OioUQbU3MGiEAJ//fUXNm/eDG9vb6V1CzvRZ7aceYByX8VTJ1hs06YNwsPD4ebmBl9fX4wdOxYnTpxAeHi40l/A2UxNTaUO1nZ2drh//740yqigXz7qKIoJbF+8eCG9/s3MzGBqaio3WtLS0lK6wqFMenq6NNGmOho2bIjjx4/D0tJS5VVNdYaeJyYmYtKkSTh+/DiePXuWJ8moqivM33//PUaNGgUHBwdkZGSgVq1ayMjIQN++fTF9+nSFdVS1W5NzyDl4ILuDuImJifS6VkdcXJzCKUIMDQ2RmpqqtK46meoBKM14Hh8fj6FDh8pls//rr7/Qvn17laPusnl6ekr/d3FxwZ07d1QGYj4+PtJIXGXT8igbhFMUHc3j4+Ol94CxsbH0vvnyyy/RvHlzBkL0/7JfqFFRUfD09JQb4m1gYIAqVaqgTp06au3r+++/h7e3N27fvo13794hMDAQt2/fxoULF+SmYFBET08PX331lTTKSJsdP35c+gLJnfxO1VQPuYPG7DnTBg4ciGnTpqk8dnZAev/+fWlepqdPn8Lc3Fyt4f8A1Lrkr0xQUJA0vPl///sf9PX1ceHCBXz++ef5fgnm1Lx5c5w7dw41a9bEZ599hokTJ+LGjRvYs2ePlKm6ONSvX19ueHQ2kWvIMaA8EMj9BVOQkY1Dhw7F1q1bMWPGDLXKd+vWDU+fPoWlpaXKGcXVUdjZ4w0MDLB27VrMmDEDN2/exKtXr9CgQYM8o8ByKop2Z9PX11driL0yhRl9t2HDBrUy1Stz6NAhtGnTBhMmTMCyZcvw9OlTuLu7o169ekqzqwOFC8Ryfmbll7zz8ePHKke45qbpaGRbW1u8ePECjo6OqFy5Mi5evIh69eohLi6uwM9psSqhvkmUw4YNG8R///0nPU5JSRGrV68WTZo0UXuEgRBZneiGDh0qmjRpImrWrCn69esnoqOj1arbtm1btTuCfqz8/f2Fjo6OaNq0qejWrZvw8fGRW4rTw4cPhaurqzAxMZEb9TdmzBgxYsQIjfcXExMjDh8+LF6/fi2EEGp3Ui2s+/fvSyNdXr16JUaMGCHc3NxEjx49pA6rxeHhw4fSsnfvXlGtWjUREhIizXYdEhIiXFxclL7GZTKZ+Oyzz0T37t1F9+7dhZ6enujYsaP0+LPPPlPr/ThmzBhRtmxZ0aZNGzF69Gi1Rs7JZDLRtGlTsXr1amm2+4Iq7OzxpUFhBw8UZvTd119/LSwtLUX9+vVFYGCg+PvvvwvUhvj4eFG5cmUxfvx44eLiInr16iXevXunsp5MJhNVqlQR3bt3z/MZVBSfR1FRUWp/rxR0NLKfn5/w9/cXQggRFBQkjI2NhYeHhyhbtqwYMmRIgdteXNhHqBQ5c+YMQkND8csvv8De3h49evTA559/nmfOouKwc+dOTJs2DePHj1fYt6QwfWQ+FAXt21EUl9ILO9FntvymlxgyZIjS6SXUmcFeJpPh3bt3arWjJBV0AtuCJgbNzd3dPd9tMpkMJ06cyLP+7Nmz+Omnn7B7925kZmbiiy++gJ+fn9KkffkpyOzxEyZMULusqn5m2a5cuSI315gm7SmKwQNbtmyBv7+/1Lnb3t4es2fPlvo/KlMUmeqBrNvTn3zyCT799FNs3rxZrbqjRo3Ctm3b4OjoWGRTBuWU39yPiowdOxbnz59HQEAAvLy8EB0djapVq+LXX3+Fv79/nlxK2TIzM5GZmSldPdq+fTsuXLgAFxcXjBgxQppGqLRgIFTCEhISsGHDBoSGhiIlJQU9e/ZESEgIrl+/jlq1aqm9n0OHDkFXV1fuvjKQ1eEuMzNTZR+VosjE+qGzsrLC77//rvHEkEUx6WthJ/rMVtDpJX799dd89xkREYEVK1YgMzOz0Lcs3oeimsC2JKSmpmLnzp3YsGEDzp49C2dnZ/j5+WHgwIF5+u/lpyCzxysL3nLKL5DL6dmzZ+jduzdOnTolTfCZnJwMd3d3bN++Xa1JlgszeODdu3fYunUrPD09YWNjU+jRd+pmqs+v787r169haGgIXV1daZ2qATBFFYgpokkgVJDRyO/evcP333+PIUOGaDRHYEliH6ES1KVLF5w5cwadOnWSIm5dXV2Fk2aqMnXqVIVDpoUQmDp1qspAqCg6yH3oNO3bka0oJn0t7ESf2Y4ePYojR47k+QBycXHBo0eP8q2naDLPu3fvYurUqdi/fz/69euXb78CdUbRZFNnBGRhFdUEtiXB1NQUgwcPxuDBgxEbG4uffvoJwcHBmDFjBry8vPIdCZT7b5Camopq1aqpPXt8YfuW5fTNN9/g33//xa1bt6Tn+/bt2xg4cCDGjBmDbdu25Vs3MzMTixcvxr1795Ceno727dvD399frYze2XL3eTQxMdF4Quuc1M1UX9jJanMyNDREnz590KdPHykQ+/rrrzWaMqgoPH/+XGEAmZqamu97Xk9PD4sWLcKAAQOKu3lFhoFQCfrtt98wZswYjBw5UmlHRHXExMQovILk6uqK2NhYlfU1GR31Mcl5SyAzMxNr1qzBsWPHULdu3TxfIPndEggODsayZcukX3DTpk3T+Bdcx44dERAQgDVr1gDI+uX96tUrzJo1S6P5wQo7vQQAPH36FLNmzcLGjRvh6emJqKgopZ32c34B/P3335g3bx48PT2l0YoRERE4cuSIxgFmQYWEhKBLly6oVKmSwgls34eimKbE2dkZ3333HRwdHTFt2jQcPHgw37JF+SVcWIcPH8axY8fkgs7sOQs7duyotO78+fPh7+8PDw8PGBsbY8WKFXj+/LnKgQq5NW3aFNeuXSvw51rOKzLnzp1D586dERQUBC8vL4VXzwH1JocuCE2nDFJnEmx1FXQ0cocOHXD69Gm1r0iWNAZCJejcuXMIDQ1Fo0aNULNmTXz55Zfo3bt3gfZlYWGBBw8e5HnhxcbGajRpZ0FnOv5Q5b7HXb9+fQDIk+dDVTBT2F9wS5cuhaenJ2rVqoU3b96gb9++iImJgbW1tdJf0Ll98skn2LRpE+bOnSu1OzMzE4sWLVJ5++Ply5f4/vvvsXLlStSvXx/Hjx9Xq49Kzi+Azz//HHPmzMHo0aOldWPGjEFQUBCOHTuG8ePHq30uBdW0aVM8ePBAbgLbXr16aTyBbUFt374dAwYMgKenJ44ePYqOHTvi3r17SExMRPfu3dXax5kzZ7B+/Xr88ssv0NHRQc+ePZX2bSnqL+HCBHKZmZkKkwnq6+vnO5Ip26ZNm/Djjz9ixIgRAIBjx46hU6dOWLduXb4BiCJff/01Jk6ciD///FPjPo9ff/01tm/fDgcHBwwZMgTbtm1TK3dRTvl1VTh69CgyMjJUXqEvSCCWzcLCQuV2da/WFHQ0sre3N6ZOnYobN24ofP5L3fdJiXXTJsmrV69EaGioaNWqldDX1xc6OjoiICBAo9Ejw4cPF25ubnJTCMTExIi6desKPz8/lfXv378v6tatK82Fk50aP3uOHFJffHy8mD17tnBychIVK1aU5vhR5e3bt+Lnn38WkydPFiNHjhRr166VRn2pq6DTS/zwww+iXLlyolatWoWaQ8jU1FTExMTkWR8TE6PWfG2FlZ6eLqpWrVroedsKo6DTlDx58kTMnz9fuLi4CJlMJlq1aiXWr18vXr16pXEbMjIyxN27d8XZs2fF6dOn5RZVCjvfXNeuXUWbNm3EkydPpHV//vmnaNu2rcrRTgYGBiI+Pl5unaGhodw8V+rI/vxStKj6PJPJZMLR0VH4+PhIIwYVLcq4ubmJgwcP5ln/22+/ibp16yqtW1RTBhWVgoxGLszzXxLYWbqUuXv3LkJDQ7F582YkJyfj008/VZkhFMj6Ne/l5YXLly9L/UP+/PNPfPLJJ9izZ4/UaTE/Xbp0ga6uLtatW6dwpuOCjF750Lx8+RIZGRl5+ve8ePECenp6SmeMVvQLbvDgwWr9ggOyrgC0bNkyT46Od+/e4cKFC2jTpo1G56Hp9BI6OjowNjaGh4eHXKfO3FRdDXB0dMSYMWMwceJEufVLly7FihUrlPZTKioVK1bMc2vmfSrINCXe3t44duwYrK2tMWDAAAwZMgQ1atQo0PEvXryIvn374tGjR3k676sz8KFu3boYMWIERo0aJXWQdXJywogRI2BnZ4fZs2crrf/48WN07doVt27dgoODg7SuTp062Ldvn9IOtLq6ukhISJDrUF2mTBlER0ernfEYgMrXmbJbZkWRqd7Y2Bh//PFHniv0Dx8+RO3atZUmdSyqKYMKQ9WUTNmUfSZ+SHhrrJSpUaMGFi1ahAULFmD//v1q3xu3sLDAhQsXEB4ejuvXr8PY2Bh169ZV+ws0IiICJ06cgLW1NXR0dKCjo4PWrVtjwYIFGDNmTL7DJD8mvXv3RpcuXfD111/Lrd+5cyf27duHQ4cOKaxXFJfS3d3dFc439/LlS7i7u6s9ai8+Ph4ODg743//+p3Bb5cqVFdYbMGBAoUejAFnzbA0dOhSnTp1Cs2bNAACRkZE4fPiwNGdXcRs1ahR++OEHrFu3Tq3kb0UtZwbqihUr4ubNm3Bzc0NycnK+o//09fWxe/dudO7cWWkgqo6vvvpK6ttRkISK9+/fR6dOnQBkJVfM7hg7fvx4tG/fXmUg5ODggKtXr+LYsWPSrcmaNWvCw8ND5bGFEBg0aJBcf7Y3b97gq6++kru9oioIMDMzg5WVFYCsIGzt2rX477//0LVrV5U/6ooiU31huioU1XuxMMqWLau0DULFaOJNmzahV69eefolpqenS7eOSxNeEfoIvH37FsbGxio7tSpjaWmJq1evwsnJCdWqVcO6devg7u6O+/fvw83NTe3h2x+ycuXK4fz583muJNy5cwetWrXC33//rbBeUfyCy2++uXv37qFx48Zq/0Irigl8CysyMhIrVqyQRu3UrFkTY8aMkQKj4lZUE9gWVN++fdG4cWNMmDABc+fOxcqVK9GtWzeEh4ejYcOGxX58U1NTXL9+Hc7OzgWqX9D55k6cOIHRo0fj4sWLea4UvHz5Ei1btkRISIjSQKSwuZyyJzh+/PgxXFxcsH37dnh5eSE1NRU6OjpITU3F7t27izQTtiIjRoxAREQE9u7dK6XjiI2NlfLCrVu3rliPX1g5+/8IIfDZZ59h3bp1qFixoly5tm3bKqxfGj6HNMErQh8BfX19VK5cuVAvrjp16kiXwJs1a4ZFixbBwMAAa9asQdWqVYuwtaVXWlqawoSBb9++VZp7pjC/4LJHeMhksjy/hDMyMhAdHa3RvFUi1xQT2V69egUjI6MCtVFTzZo1w5YtW97LsRQpW7YsPv/88xI7fmGnKSmsZs2aITY2VuNA6ObNm6hTp06B55sLCAjAsGHDFN4usbCwwIgRI7Bs2TKlgVBh59ybMmUK3NzcsGXLFmzevBmdO3dGp06dpKuR33zzDRYuXFjsgdCiRYvg5eUFV1fXPF0VlixZUqzHLgq5AxxdXV00b95c7e+C/D6H/vzzT5WduUsCrwh9JEJDQ7Fnzx5s3ry5QFlICzLT8cfG3d0dderUwcqVK+XWjxo1CtHR0Th79myRHzP7F/DGjRvRs2dPuXwp2fPNDRs2TOWttuw0AIGBgRg2bJjcEPqMjAxERkZCV1cX58+fL/JzyCk+Pl7p9vxuzX0MSku/ir1792L69OmYPHky3Nzc8ozgym/ElI6ODpo0aQIfHx/0798fDg4O0ojD7KzA06dPl5uINidHR0elc3nduXMHHTt2VPkaKQxra2ucOHECdevWxatXr2Bubo5Lly6hUaNGUhuaN2+u0RDyghJCFLirQmmTM5miMtlXxa9fv47atWvnO5H4zp07i7vJGmEg9JFo0KABYmNj8fbtWzg6Oua5HaDOrNW5qZrp+GNz/vx5eHh4oEmTJlLgd/z4cVy6dAlHjx4t1g7js2fPxqRJkwo8vDt7aPzp06fRokULuRT22QHVpEmTCp2vShVVU3W8z0viz58/x927dwFk9b1TJ6NxYagzTQlQ/M9BQbPE557m4/PPP8fQoUPVft0bGRnh5s2b+V6Jio2NhZubW7Fm9tbR0ZFmXwfyfoEnJibC3t6+1N2aKe3UDYSy+4/Nnj0bEydOVDiR+Oeff17qptjgrbGPREEv9RbFPFkfi1atWiEiIgKLFy/Gzp07pV9xoaGhxR5ATJkyRW6Ez6NHj7B3717UqlVLZRI64P8zAw8ePBiBgYElNpojd6f6t2/f4tq1a1i2bBnmz5//XtqQmpqKb775Bps2bZLy1ujq6mLAgAFYuXJlobIMK5MzO7OyfhXFraBZ4j/55BN88sknWLlypTTNR9u2bdWe5iO7Y3h+gVB0dLTSkYtFJXcwWlI/5E6fPo0lS5ZIfeVq1aqFyZMnf7AjcNV5HmfNmgUAqFKlCnr16vXebscXFq8IabmimCeLCq9jx47o0aMHvvrqKyQnJ6NGjRowMDBAUlISli1bhpEjR6q1nyFDhiAwMDDPtBzZwUFJBbQHDx7E4sWLcerUqWI/1ogRI3Ds2DEEBQWhVatWALKSl44ZMwaffvopVq1aVextANT/FV2aZU/zsXnzZiQkJCid5uObb77BqVOncOnSpTxfgP/99x+aNm0Kd3d3rFixotjaq6OjA29vb6mv3f79+9G+fXvpSmtaWhoOHz5c7FeEfv75ZwwePBg9evSQXoPnz5/H3r17sWHDBvTt27dYj19YubNT534es+XX8f/kyZP5JnBdvXq1lDCztGAgpOWKe6bjD0lJ9m+xtrbG6dOnUbt2baxbtw4rV67EtWvX8Msvv2DmzJnSr0pV8hutkZSUBFtb2xKbPT42Nhb16tVTmj+lqFhbW2P37t1o166d3PqTJ0+iZ8+eeP78ebG3ASjZQGjz5s0ICQlBXFwcIiIi4OjoiICAADg5OSmcV06Z1NRUbNmyBdOmTUNycnK+QURiYiIaNmwIXV1djB49WsqDdOfOHQQHByMjIwNXr16FjY1Noc8vP4UddVZUatasieHDh+fJpL5s2TKsXbtW7fdzSSns82hoaIgxY8bg+++/l/qoJSUlYfDgwTh37hz++eefImtrkXiPyRupGL17904sXrxYNGnSRNjY2AhLS0u5RZk3b96IrVu3Cg8PD2FiYiJ8fX3F4cOHRWZm5ntqfemQM5O2oqU4GRsbi0ePHgkhhPD19RX+/v5CiKws1cbGxirrv3z5UiQnJwuZTCZiY2PFy5cvpeXFixdi48aNws7OrljPIbsdOZfk5GTxxx9/iF69eol69eoV+/GFyHouFWWWvnnzpjAxMXkvbRDi/7NKv28//vijsLa2FvPmzRPGxsZSG3766SfRrl07tfdz+vRpMXDgQGFmZibMzc3F0KFDRUREhNI6Dx8+FN7e3nmy03t7e4sHDx4U6rw+JAYGBvlmWDc0NCyBFr1f58+fF9WqVRP16tUTt27dEgcOHBA2NjaiTZs24uHDhyXdvDwYCH0kZsyYIezs7MSSJUuEkZGRmDt3rvDz8xNWVlYiMDBQ7f08fPhQ+Pv7i6pVq4rKlSurPT3ExyAqKkpuuXTpklizZo1wdXUVv/zyS7Ee283NTQQGBor4+Hhhbm4uLly4IIQQ4vLly8LGxkZlfVVBnK6urpg3b16xnkN+7ZDJZKJy5crSORW39u3bC19fX/Hff/9J616/fi18fX1Fhw4d3ksbhMgKhEriy79mzZpi7969UhuyA6EbN24IKysrpXWLapqPFy9eiN9//11ERkaKFy9eFOg8PmTVqlUTISEhedavWrVKODs7l0CL3r9///1X9OvXTxgaGgp9fX2xcOHCUvvjmp2lPxJbtmzB2rVr0alTJ/j7+6NPnz6oVq0a6tati4sXL2LMmDFq7UfTmY4/JvXq1cuzrnHjxrC3t8fixYtVzupcGDNnzkTfvn0xfvx4dOjQQZrZ+ejRo2jQoIHK+idPnoQQAu3bt8cvv/wid3vTwMAAjo6OsLe3L7b2Zztx4oRcp0odHR2UL18ezs7O7y3Lc2BgIDw9PVGpUiXpb3r9+nUYGhri6NGjxXbc3K8PRRmRgeJP6BgXF6fwNWNoaKj01mRRTvNhaWmJJk2aFKjux2DixIkYM2YMoqKipDxg58+fx4YNGxAYGFjCrXs/7t27J0359PTpU9y9exevX79+LxMfa4qB0EciISEBbm5uALLSy2dnf+3cuTNmzJihtG5hZjrWBjVq1MClS5eK9RhffPEFWrdujb/++ksuIOvQoYNaM5ZnJ0CLi4uDg4NDif3d3NzcCjy1QVGpU6cOYmJi5Gaf79OnD/r16yeXp6mo5U4U179//2I7ljJOTk6IiorKM5+Wshw/QNFO86HtRo4cCVtbWyxdulTKmVOzZk3s2LFD4z5aH6KFCxdi1qxZGD58OBYvXozY2Fh8+eWXqFu3Ln7++Wfph16pUdKXpKhoVK9eXVy8eFEIIUSrVq3EggULhBBCbN++XZQvXz7feqVtpuOSVBr6txSFf/75RyxZskT4+fkJPz8/sWzZMpGcnFysx4yOjhaOjo5CR0dH1KhRQ1y7dk3Y2NhI/Ut0dXWl2zXFLSkpSfr/o0ePxIwZM8SkSZPEmTNn3svxS9ratWtFxYoVxfbt24WpqanYtm2bmDdvnvR/ouJma2srDh06JLcuPT1dTJo0SRgYGJRQq/LHUWMfialTp8Lc3BzfffcdduzYgf79+6NKlSqIj4/H+PHjsXDhQoX1SsNMx6WFooR4Qgg4ODhg+/btxfor5s2bN1i5ciVOnjyJZ8+eSflvsqmbEPPy5cvw9PSEsbExmjZtCgC4dOkS/vvvPxw9ehQNGzYs8rYDWbdV9PT0MHXqVGzevBkHDhyAp6en3NQGV65cwcWLF4vl+EDpmWeqNNiyZQv8/f1x//59AIC9vT1mz54NPz+/Em6ZdqhatSouXbokXR3NlpycjIYNG+LBgwcl1LL3IykpKd9s+KdPn853jrKSwkDoI3Xx4kUpLX6XLl3yLTdo0CC1EmUV93DT0uDUqVMl1r+lX79+OHr0KL744gvY2Njk+ZtkJypT5ZNPPoGzszPWrl0rtfndu3cYOnQoHjx4gDNnzhR524HSMbVBaQjGSpvXr1/j1atXedIpUPHKneE6W2JiIipXroy0tLQSalnJe/bsWal7PTIQ+kj8/fffCvtmdOnS5YOd3+Z9y+85fB/9WywsLHDo0CEp+VpBGRsb49q1a3B1dZVbf/v2bTRu3BivX78u1P7zUxqmNigNwVhp8uzZM2mKEVdX12KfYoQgJZv08fHBxo0b5fqNZWRk4Pjx4wgPD5f+Lh8bExMTPHr0SHqtderUCevWrZMyipfaKU5K8LYcFYHS1DfjQ1UansOaNWuK69evF3o/FSpUEEeOHMmz/vDhw6JChQqF3n9+ZDKZePbsmfQ499DxhISEYs/FJJPJRGJiolwbcubxeR9tKA1SUlJE//79ha6urpTLR09PT/Tr16/Y+4ppu5y5k7L/n70YGBiI6tWri/3795d0M4uNOu9BmUxWEk1TikOCPnBTpkyBm5sbzpw5g3bt2qFz587o1KkTXr58iX/++QcjRozIt38QZSkNz+HSpUvx7bff4tGjR4XaT69eveDn54cdO3bg8ePHePz4MbZv3w4/Pz/07t27iFqr2KBBg9CjRw/06NFDGjqe/VjdOe0Kq7TMM1WShg4disjISBw8eBDJyclITk7GgQMHcPny5VI3tcHHJjMzE5mZmahcubLU1y97SUtLw927d9G5c+eSbmaJKo3vSd4a+8DxdkDhlYbn8Pnz5+jZsyfOnDkDExMTKS19thcvXqi1n/T0dEyePBkhISF49+4dhBAwMDDA119/jfnz5xfb8PHSMLVBaZlnqqSZmpriyJEjaN26tdz6s2fPSp3HqXhERETg77//lgt2Nm3ahFmzZiE1NRU+Pj5YuXKl9Br92JSGW+QFwTxCH7gXL15IM0KbmZnB1NQUlpaW0nZLS0v8+++/JdW8D0JpeA779OmDJ0+e4Pvvv1fYWVpdBgYGCAwMxIIFC6QRQ9WqVcOqVavg5OSEhISEomy2pDR0ph84cKDcY0V5fAYMGPC+mlNirKys8uQ0ArL6oeV8XVPRmz17Ntzd3aVA6MaNG/Dz88OgQYNQs2ZNLF68GPb29vD39y/ZhhYTmUwm99mV+3FpxUDoI8DbAYVX0s/hhQsXEBERoTC7tTrS0tLg7++P8PBwGBoaYvLkyfDx8cFPP/0ELy8v6Orq5pkA8mNTGoKx0mD69OmYMGECNm/eLAX4CQkJmDx5ssrkqlQ4169fx7x586TH27dvR7NmzaSRiw4ODpg1a9ZHGwgJIVC9enXp8/PVq1do0KCBlOC1tN6AYiD0ERg0aJB0qTV3Wn9tHqapiZJ+Dl1dXfHff/8VuP7MmTOxevVqeHh44MKFC/D19cXgwYNx8eJFLF26FL6+vswWrCVWrVqF2NhYVK5cGZUrVwYAxMfHw9DQEM+fP8fq1aulsurmpyL1/PPPP7CxsZEenz59Gt7e3tLjJk2a4PHjxyXRtPfiQ/0xwkDoA8fbAYVXGp7DhQsXYuLEiZg/fz7c3Nzy9BEyNzdXWn/Xrl3YtGkTunbtips3b6Ju3bp49+4drl+/ziuEWkYbEkaWVjY2NtI0N+np6bh69Spmz54tbf/333/zvLc/Jrk/Sz8U7CxNVApkXzpWlNlaJpOp7FxoYGCAuLg4VKxYEUBWPqHff/9dmn+OiIrfyJEjcf36dfzwww8ICwvDxo0b8fTpUxgYGADIyvgdEBBQ7HMXkmZ4RYioFDh58mS+227cuKGyfkZGhvRhCwB6enowMzMrkrbRh+nKlSv4448/AAC1a9dWOCM9Fa25c+eiR48eaNu2LczMzLBx40a59+X69evRsWPHEmwhKcIrQkSl0L//1979hEL+xnEAfzOrdkLDHjD+JEUaayTlJAcMSoxcrNpdymmVIbm4aHDwLyFSDsifwxiFcGALu+3aSNlaO4pMCRHSyEhcZvwOGyVj7e+3v+b5mu/7Vd/DPN85vI+fnu/n+TwXFzCZTOjr68Pa2tqTO0JPHR2/JYc74+Tu5OQERUVF+Pz5MwICAgD8uuMqLS0No6OjnDDtBufn5/Dz83vQl2ez2eDn53evOCLxOFCRSEK+fPmCkpISqNVqtLW1IT09/Y/uxiopKUFQUBBUKhVUKhXevXuH0NDQu9+3D3k+g8GAi4sLbGxswGazwWazwWKxwG63o6KiQnQ8WVCpVC4PJ7x69YpFkARxR4hIsKOjIwwODqK/vx92ux2FhYXo7e3Fjx8/EBcXJzoePTMqlQrz8/NITk6+t766uoqsrCwOVyW3ui0xpHxogztCRALl5eUhNjYW6+vr6OzsxOHhIbq7u0XHomfM6XS6PJnk4+MDp9MpIBHJ0fDwMLRaLZRKJZRKJRISEjAyMiI6lktsliYSaHZ2FhUVFSgrK0NMTIzoOOQB0tPTUVlZCZPJhNDQUADAwcEBqqqqkJGRITgdyUF7eztqa2tRXl6OlJQUAMDS0hI+fPiA09NTyQ135acxIoFWVlbQ398Ps9kMjUaD9+/fo6ioCGq1mp/G6D/Z39+HXq/HxsYGIiIi7tbi4+MxPT2N8PBwwQnJ00VFRaG+vv7B/LWhoSHU1dVhZ2dHUDLXWAgRScDl5SXMZjMGBgawuroKh8OB9vZ2lJaWwt/fX3Q8emZubm4wPz+Pzc1NAIBGo4FOpxOciuTi5cuXsFgsiI6Ovre+vb0NrVaL6+trQclcY48QkQT4+vqitLQUS0tL+PnzJ6qrq9Hc3IygoCDo9XrR8egZWFxcRFxcHOx2O7y8vJCZmQmDwQCDwYDk5GS8fv0aX79+FR2TZCA6OhpjY2MP1s1msyRbALgjRCRRDocDMzMzGBgYwPT0tOg4JHF6vR5paWmP9l90dXXh06dPmJycdHMykpvx8XG8efMGOp3urkfo27dvWFhYwNjYGAoKCgQnvI+FEBGRB4iMjMTc3Bw0Go3L95ubm8jKysLe3p6bk5Ecra2toaOj4266uUajQXV1tSQnnLMQIiLyAI/1ZdyyWq3QarW4urpyczIiaWOPEBGRBwgLC4PFYnn0/fr6OtRqtRsTET0PLISIiDxATk4OamtrXZ7Iubq6gtFoRG5uroBkJBfe3t5QKBS/fV68kN74Qn4aIyLyAMfHx0hKSoJCoUB5eTliY2MB/OoN6unpgcPhwPfv3xEcHCw4KXmqqampR98tLy+jq6sLTqdTcsfnWQgREXmI3d1dlJWV4ePHj/fueMrOzkZPTw+ioqIEJyS52draQk1NDWZmZvD27Vs0NDQgMjJSdKx7WAgREXmYs7MzWK1W3NzcICYmBoGBgaIjkcwcHh7CaDRiaGgI2dnZaGpqQnx8vOhYLrEQIiIiov/F+fk5Ghsb0d3djcTERLS0tCA1NVV0rN+SXtcSERERPTutra1oaWlBSEgITCYT8vPzRUf6I9wRIiIior/m7e0NpVIJnU4HhULx6P8mJibcmOpp3BEiIiKiv1ZcXAwvLy/RMf417ggRERGRbHGgIhEREckWCyEiIiKSLRZCREREJFsshIiIiEi2WAgRERGRbLEQIiIiItliIURERESyxUKIiIiIZOsfEivRD27AKOwAAAAASUVORK5CYII=",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "With alpha 1 better extra hub city: Marseille\n"
     ]
    }
   ],
   "source": [
    "for alpha in [0, 1]:\n",
    "    generate_hub_list(alpha, True)\n",
    "    print('With alpha', alpha, 'better extra hub city:',better_extra_hub(alpha))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "def show_pond_vector(pond_vect, y_label):\n",
    "    '''\n",
    "    Historgram of cost reduction when adding certain new hob\n",
    "    '''\n",
    "    plt.bar([x[2] for x in pond_vect], [x[1] for x in pond_vect])\n",
    "    plt.xticks(rotation=90)\n",
    "    offset = 0\n",
    "    plt.ylim(pond_vect[0][1] - offset, pond_vect[-1][1] + offset+2)\n",
    "    # the y-axis is in millions of euros\n",
    "    plt.ylabel(y_label)\n",
    "    # change the graph color to purple\n",
    "    plt.rcParams['axes.prop_cycle'] = plt.cycler(color=['purple'])\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'pond_vect0' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [20], line 1\u001b[0m\n\u001b[1;32m----> 1\u001b[0m show_pond_vector(pond_vect0, \u001b[39m'\u001b[39m\u001b[39mCost reduction (in millions of euros)\u001b[39m\u001b[39m'\u001b[39m)\n\u001b[0;32m      2\u001b[0m show_pond_vector(pond_vect1, \u001b[39m'\u001b[39m\u001b[39mEmissions reduction (in tons of CO2)\u001b[39m\u001b[39m'\u001b[39m)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'pond_vect0' is not defined"
     ]
    }
   ],
   "source": [
    "show_pond_vector(pond_vect0, 'Cost reduction (in millions of euros)')\n",
    "show_pond_vector(pond_vect1, 'Emissions reduction (in tons of CO2)')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "matrices0 = generate_matrices(0)\n",
    "matrices1 = generate_matrices(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 241166.73943432677, 'Marseille')\n"
     ]
    }
   ],
   "source": [
    "pv0 = ponderate_vector(matrices0, F, 0)\n",
    "pv1 = ponderate_vector(matrices1, F, 1)\n",
    "print(pv0[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "COST without adding hubs: 340_613_818.2\n",
      "COST with Amsterdam hub: 327_413_735.4\n",
      "EMISSIONS without adding hubs: 578_136_244.7\n",
      "EMISSIONS with Amsterdam hub: 566_732_476.3\n"
     ]
    }
   ],
   "source": [
    "'''\n",
    "Calculate and print next values\n",
    "    - Cost graph without adding any extra hubs\n",
    "    - Cost graph when adding best new hub\n",
    "    - Emissions graph without adding any extra hubs\n",
    "    - Emissions graph when adding best new hub\n",
    "'''\n",
    "normalized_cost = pv0[0][1]\n",
    "without_COST = normalized_cost*(df_cities['cost_per_unit'].max() - df_cities['cost_per_unit'].min()) + df_cities['cost_per_unit'].min()\n",
    "print(f\"COST without adding hubs: {without_COST:_.1f}\")\n",
    "normalized_cost = pv0[10][1]\n",
    "original_cost = normalized_cost*(df_cities['cost_per_unit'].max() - df_cities['cost_per_unit'].min()) + df_cities['cost_per_unit'].min()\n",
    "print(f\"COST with Amsterdam hub: {original_cost:_.1f}\")\n",
    "\n",
    "normalized_cost = pv1[0][1]\n",
    "without_EMISSIONS = normalized_cost*(df_cities['co2_per_unit'].max() - df_cities['co2_per_unit'].min()) + df_cities['co2_per_unit'].min()\n",
    "print(f\"EMISSIONS without adding hubs: {without_EMISSIONS:_.1f}\")\n",
    "normalized_cost = pv1[3][1]\n",
    "original_cost = normalized_cost*(df_cities['co2_per_unit'].max() - df_cities['co2_per_unit'].min()) + df_cities['co2_per_unit'].min()\n",
    "print(f\"EMISSIONS with Marseille hub: {original_cost:_.1f}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pond_vects = []\n",
    "for alpha in [0, 1]:\n",
    "    matrices = generate_matrices(alpha)\n",
    "    pond_vect = list(ponderate_vector(matrices, F, alpha))\n",
    "    sort_and_save(pond_vect, alpha)\n",
    "    pond_vects.append(pond_vect)\n",
    "# denormalize the data\n",
    "MULTIPLIER = 1/10**6\n",
    "pond_vect0 = [(x[0], (without_COST - x[1]*(df_cities['cost_per_unit'].max() - df_cities['cost_per_unit'].min()) + df_cities['cost_per_unit'].min())*MULTIPLIER, x[2]) for x in pond_vects[0]]\n",
    "pond_vect1 = [(x[0], (without_EMISSIONS - x[1]*(df_cities['co2_per_unit'].max() - df_cities['co2_per_unit'].min()) + df_cities['co2_per_unit'].min())*MULTIPLIER, x[2]) for x in pond_vects[1]]\n",
    "pond_vect0.sort()\n",
    "pond_vect1.sort()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Graphical view of the Graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['Dusseldorf', 'Zaragoza', 'Venlo', 'Bratislava', 'Hamburg', 'Rome', 'Lille', 'Liege', 'Warsaw', 'Paris', 'Lyon', 'Marseille', 'Bordeaux', 'Milan', 'Berlin', 'Madrid', 'Vienna', 'Munich', 'Amsterdam', 'Stockholm', 'Copenhagen', 'Barcelona', 'Cologne', 'Athens', 'Bucharest', 'Budapest', 'Naples', 'Lisbon', 'Turin', 'Hanover', 'Malmö', 'Helsinki', 'Prague', 'Valencia', 'Bremen', 'Porto', 'Rotterdam'])\n"
     ]
    }
   ],
   "source": [
    "# extracts the city coordinates from the dataframe\n",
    "df_cities = pd.read_csv('data\\cities_data_costs.csv')\n",
    "df_cities.head()\n",
    "city_coords = {}\n",
    "for i, x in df_cities.iterrows():\n",
    "    temp = x['city_from_coord'].replace('(','').replace(')','').split(',')\n",
    "    city_coords[x['city_from_name']] = (float(temp[1]), float(temp[0]))\n",
    "    temp = x['city_to_coord'].replace('(','').replace(')','').split(',')\n",
    "    city_coords[x['city_to_name']] = (float(temp[1]), float(temp[0]))\n",
    "print(city_coords.keys())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0.         0.         0.         0.         0.         0.13098329\n",
      "  0.         0.         0.         0.22257829 0.17714587 0.12996917\n",
      "  0.0511926  0.33311699 0.33753854 0.31064417 0.24071069 0.20894856\n",
      "  0.17840337 0.17264319 0.16915463 0.1415301  0.14027259 0.12104495\n",
      "  0.11763751 0.08802531 0.09528639 0.06563362 0.07050138 0.0774785\n",
      "  0.07549083 0.05131429 0.05224728 0.05703391 0.05220672 0.        ]\n",
      " [0.         0.         0.         0.         0.         0.38382281\n",
      "  0.         0.         0.         0.68148629 0.50847801 0.40463248\n",
      "  0.17394126 0.99882362 1.         0.94158689 0.72274055 0.63698686\n",
      "  0.57463897 0.49886419 0.51582022 0.45817784 0.41254259 0.32873601\n",
      "  0.34139218 0.27782736 0.27072854 0.22237547 0.22387636 0.22525556\n",
      "  0.21552004 0.15958137 0.17211585 0.17909297 0.1683839  0.        ]\n",
      " [0.         0.         0.         0.         0.         0.17807886\n",
      "  0.         0.         0.         0.29287685 0.2042025  0.17146682\n",
      "  0.06766185 0.41736979 0.44296609 0.42166964 0.31920331 0.25738277\n",
      "  0.23438261 0.21742658 0.20598734 0.18144572 0.16578777 0.13779815\n",
      "  0.14733085 0.12096382 0.11240467 0.08936395 0.0922846  0.10084374\n",
      "  0.08660555 0.0767889  0.07447672 0.07115041 0.07033912 0.        ]]\n"
     ]
    }
   ],
   "source": [
    "# we save the frequency of each city path (port/city)\n",
    "# in a dictionary and normalize it between 0 and 1\n",
    "freq = np.zeros((len(PORTS), len(CITIES)))\n",
    "for w in range(10):\n",
    "    freq += F[w]\n",
    "freq /= np.amax(freq)\n",
    "print(freq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HUB: AMSTERDAM\n",
    "visualization when adding Amsterdam as a new hub to minimize costs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generates the Graph with Amsterdam as hub\n",
    "\n",
    "PORTS = ['Barcelona', 'Rotterdam', 'Athens']\n",
    "HUBS = ['Hamburg', 'Lille', 'Warsaw', 'Zaragoza', 'Bratislava', 'Dusseldorf', 'Liege', 'Venlo', 'Rome']\n",
    "CITIES  = df_cities['city_from_name'].unique()\n",
    "PORTS = ['p-'+p for p in PORTS]\n",
    "HUBS = ['h-'+h for h in HUBS]\n",
    "CITIES = ['c-'+c for c in CITIES]\n",
    "\n",
    "HUBS.append('h-Amsterdam')\n",
    "\n",
    "G_tri = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G_tri.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "\n",
    "WEIGHT = 5\n",
    "alpha = 0\n",
    "df_cities_weight = df_norm.iloc[WEIGHT::10,:]\n",
    "cost = [get_cost(df_cities_weight['co2_per_unit'].iloc[i], df_cities_weight['cost_per_unit'].iloc[i], alpha) for i in range(len(df_cities_weight))]\n",
    "df_cities_weight['cost'] = cost\n",
    "declare_costs_graph(G_tri, PORTS, HUBS, CITIES, df_cities_weight)\n",
    "\n",
    "# create graph\n",
    "G = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "\n",
    "for p in PORTS:\n",
    "    for h in HUBS:\n",
    "        for c in CITIES:\n",
    "            G.add_edge(p, h, pes = 0.0)\n",
    "            G.add_edge(h, c, pes = 0.0)\n",
    "\n",
    "for i, p in enumerate(PORTS):\n",
    "        for j, c in enumerate(CITIES):\n",
    "            h = nx.dijkstra_path(G_tri, p, c, weight='cost')[1]\n",
    "            G[p][h]['pes'] +=  freq[i][j]\n",
    "            G[h][c]['pes'] += freq[i][j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Visualize the Graph and saves the image file\n",
    "\n",
    "SIZE_X = 2000\n",
    "SIZE_Y = 2000\n",
    "PADDING = 10\n",
    "\n",
    "map= StaticMap(\n",
    "    SIZE_X, SIZE_Y, padding_x=PADDING, padding_y=PADDING,)\n",
    "\n",
    "# we iterate through the edges\n",
    "for node1, node2, data in G.edges(data=True):\n",
    "    # we get the coordinates of the nodes\n",
    "    x1, y1 = G.nodes[node1]['pos']\n",
    "    x2, y2 = G.nodes[node2]['pos']\n",
    "    color = '#d64747' if 'h-Amsterdam' in [node1, node2] else '#666463'\n",
    "    if ['p-Rotterdam','h-Amsterdam'] == [node1, node2]:\n",
    "        map.add_line(Line(((x1, y1), (x2, y2)), color, int(data['pes']*7)))\n",
    "    else:\n",
    "        map.add_line(Line(((x1, y1), (x2, y2)), color, int(data['pes']*10)))\n",
    "color_type = {'p':'#003785', 'h':'#851d1d', 'c':'#377d34'}\n",
    "size_type = {'p':25, 'h':15, 'c':12}\n",
    "\n",
    "for u, d in G.nodes(data=True):\n",
    "    if (u == 'h-Amsterdam'):\n",
    "        map.add_marker(CircleMarker(d['pos'], \"#4f0a0a\", 25))\n",
    "    else:\n",
    "        map.add_marker(CircleMarker(d['pos'], color_type[d['type']], size_type[d['type']]))\n",
    "\n",
    "image = map.render()\n",
    "image.save('data/Amsterdam-hub.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# HUB: MARSEILLE\n",
    "visualization when adding Marseille as a new hub to minimize emissions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PORTS = ['Barcelona', 'Rotterdam', 'Athens']\n",
    "HUBS = ['Hamburg', 'Lille', 'Warsaw', 'Zaragoza', 'Bratislava', 'Dusseldorf', 'Liege', 'Venlo', 'Rome']\n",
    "CITIES  = df_cities['city_from_name'].unique()\n",
    "PORTS = ['p-'+p for p in PORTS]\n",
    "HUBS = ['h-'+h for h in HUBS]\n",
    "CITIES = ['c-'+c for c in CITIES]\n",
    "\n",
    "HUBS.append('h-Marseille')\n",
    "\n",
    "G_tri = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G_tri.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "\n",
    "WEIGHT = 5\n",
    "alpha = 1\n",
    "df_cities_weight = df_norm.iloc[WEIGHT::10,:]\n",
    "cost = [get_cost(df_cities_weight['co2_per_unit'].iloc[i], df_cities_weight['cost_per_unit'].iloc[i], alpha) for i in range(len(df_cities_weight))]\n",
    "df_cities_weight['cost'] = cost\n",
    "declare_costs_graph(G_tri, PORTS, HUBS, CITIES, df_cities_weight)\n",
    "\n",
    "# create graph\n",
    "G = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "    \n",
    "for p in PORTS:\n",
    "    for h in HUBS:\n",
    "        for c in CITIES:\n",
    "            G.add_edge(p, h, pes = 0.0)\n",
    "            G.add_edge(h, c, pes = 0.0)\n",
    "\n",
    "for i, p in enumerate(PORTS):\n",
    "        for j, c in enumerate(CITIES):\n",
    "            h = nx.dijkstra_path(G_tri, p, c, weight='cost')[1]\n",
    "            G[p][h]['pes'] +=  freq[i][j]\n",
    "            G[h][c]['pes'] += freq[i][j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SIZE_X = 2000\n",
    "SIZE_Y = 2000\n",
    "PADDING = 10\n",
    "\n",
    "map= StaticMap(\n",
    "    SIZE_X, SIZE_Y, padding_x=PADDING, padding_y=PADDING,)\n",
    "\n",
    "# we iterate through the edges\n",
    "for node1, node2, data in G.edges(data=True):\n",
    "    # we get the coordinates of the nodes\n",
    "    x1, y1 = G.nodes[node1]['pos']\n",
    "    x2, y2 = G.nodes[node2]['pos']\n",
    "    color = '#d64747' if 'h-Marseille' in [node1, node2] else '#666463'\n",
    "    map.add_line(Line(((x1, y1), (x2, y2)), color, int(data['pes']*10)))\n",
    "color_type = {'p':'#003785', 'h':'#851d1d', 'c':'#377d34'}\n",
    "size_type = {'p':25, 'h':15, 'c':12}\n",
    "\n",
    "for u, d in G.nodes(data=True):\n",
    "    if (u == 'h-Marseille'):\n",
    "        map.add_marker(CircleMarker(d['pos'], \"#4f0a0a\", 25))\n",
    "    else:\n",
    "        map.add_marker(CircleMarker(d['pos'], color_type[d['type']], size_type[d['type']]))\n",
    "\n",
    "image = map.render()\n",
    "image.save('data/Marseille-hub.png')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# NO EXTRA HUBS\n",
    "visualization of the graph when no extra hubs are added"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "PORTS = ['Barcelona', 'Rotterdam', 'Athens']\n",
    "HUBS = ['Hamburg', 'Lille', 'Warsaw', 'Zaragoza', 'Bratislava', 'Dusseldorf', 'Liege', 'Venlo', 'Rome']\n",
    "CITIES  = df_cities['city_from_name'].unique()\n",
    "PORTS = ['p-'+p for p in PORTS]\n",
    "HUBS = ['h-'+h for h in HUBS]\n",
    "CITIES = ['c-'+c for c in CITIES]\n",
    "\n",
    "G_tri = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G_tri.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "\n",
    "WEIGHT = 5\n",
    "alpha = 1\n",
    "df_cities_weight = df_norm.iloc[WEIGHT::10,:]\n",
    "cost = [get_cost(df_cities_weight['co2_per_unit'].iloc[i], df_cities_weight['cost_per_unit'].iloc[i], alpha) for i in range(len(df_cities_weight))]\n",
    "df_cities_weight['cost'] = cost\n",
    "declare_costs_graph(G_tri, PORTS, HUBS, CITIES, df_cities_weight)\n",
    "\n",
    "# create graph\n",
    "G = nx.Graph()\n",
    "for x in CITIES + PORTS + HUBS:\n",
    "    G.add_node(x, pos=city_coords[x[2:]], type= x[:1])\n",
    "\n",
    "for p in PORTS:\n",
    "    for h in HUBS:\n",
    "        for c in CITIES:\n",
    "            G.add_edge(p, h, pes = 0.0)\n",
    "            G.add_edge(h, c, pes = 0.0)\n",
    "\n",
    "for i, p in enumerate(PORTS):\n",
    "        for j, c in enumerate(CITIES):\n",
    "            h = nx.dijkstra_path(G_tri, p, c, weight='cost')[1]\n",
    "            G[p][h]['pes'] += freq[i][j]\n",
    "            G[h][c]['pes'] += freq[i][j]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "SIZE_X = 2000\n",
    "SIZE_Y = 2000\n",
    "PADDING = 10\n",
    "\n",
    "map= StaticMap(\n",
    "    SIZE_X, SIZE_Y, padding_x=PADDING, padding_y=PADDING,)\n",
    "\n",
    "# we iterate through the edges\n",
    "for node1, node2, data in G.edges(data=True):\n",
    "    # we get the coordinates of the nodes\n",
    "    x1, y1 = G.nodes[node1]['pos']\n",
    "    x2, y2 = G.nodes[node2]['pos']\n",
    "    color = '#d64747' if 'h-Amsterdam' in [node1, node2] else '#666463'\n",
    "    map.add_line(Line(((x1, y1), (x2, y2)), color, int(data['pes']*10)))\n",
    "color_type = {'p':'#003785', 'h':'#851d1d', 'c':'#377d34'}\n",
    "size_type = {'p':25, 'h':15, 'c':12}\n",
    "\n",
    "for u, d in G.nodes(data=True):\n",
    "    map.add_marker(CircleMarker(d['pos'], color_type[d['type']], size_type[d['type']]))\n",
    "\n",
    "image = map.render()\n",
    "image.save(f'data/No-extra-hub-alpha{alpha}.png')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.11.0 64-bit",
   "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.11.0"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "aee8b7b246df8f9039afb4144a1f6fd8d2ca17a180786b69acc140d282b71a49"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}