AAAI_2023_FIGURE_3_ABC.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "authorship_tag": "ABX9TyN3IDk5j2RDoXI32yItJzKc",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/yohayt/Resource-Sharing-Through-Multi-Round-Matchings/blob/main/FIGURE_3_ABC.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "A function for loading students dataset"
      ],
      "metadata": {
        "id": "04cjiU7G77cN"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from google.colab import drive\n",
        "drive.mount('/content/gdrive')\n",
        "from os import listdir\n",
        "from os.path import isfile, join, isdir\n",
        "import networkx as nx\n",
        "import sys\n",
        "import logging\n",
        "import pandas as pd\n",
        "import random\n",
        "\n",
        "shift=1000\n",
        "def sample_from_dict(d, sample=10):\n",
        "    keys = random.sample(list(d), sample)\n",
        "    values = [d[k] for k in keys]\n",
        "    return dict(zip(keys, values))\n",
        "\n",
        "def load_one_student_per_room(max_students, meaningful_pref, min_day, presources=-1, pagents=-1):\n",
        "\n",
        "    apply_alone= False\n",
        "\n",
        "    preferencesp = 'https://raw.githubusercontent.com/yohayt/Resource-Sharing-Through-Multi-Round-Matchings/4aa44a991ef92b662f2a9081ba7860953f3f8e5c/data/Lab-Space-Dataset/student_preferences.csv'\n",
        "    roomsp = 'https://raw.githubusercontent.com/yohayt/Resource-Sharing-Through-Multi-Round-Matchings/4aa44a991ef92b662f2a9081ba7860953f3f8e5c/data/Lab-Space-Dataset/lab_rooms.csv'\n",
        "    advisorsp = 'https://raw.githubusercontent.com/yohayt/Resource-Sharing-Through-Multi-Round-Matchings/main/data/Lab-Space-Dataset/student_details.csv'\n",
        "    prefs = {}\n",
        "    rooms = {}\n",
        "\n",
        "    df_prefs = pd.read_csv (preferencesp)\n",
        "    df_rooms = pd.read_csv(roomsp )\n",
        "    df_advisors = pd.read_csv(advisorsp)\n",
        "\n",
        "    prefs = df_prefs.to_dict()\n",
        "    rooms = df_rooms.to_dict()\n",
        "    advisors = df_advisors.to_dict()\n",
        "    #print(advisors)\n",
        "    #print(rooms)\n",
        "    #if presources>0:\n",
        "    #   rooms = sample_from_dict(rooms,int(presources*len(rooms)))\n",
        "\n",
        "    resource_attr = {}\n",
        "    pref_attr = {}\n",
        "\n",
        "    G = nx.Graph()\n",
        "\n",
        "    left = set()\n",
        "    right = set()\n",
        "\n",
        "    for c, pid in enumerate(prefs['id']):\n",
        "      if random.random()<pagents or pagents<0:\n",
        "        left.add((c, pid))\n",
        "        G.add_node(pid, bipartite=0)\n",
        "\n",
        "    for r,rid in rooms['id'].items():\n",
        "      if random.random()<presources or presources<0:\n",
        "        right.add((r, rid+shift))\n",
        "        G.add_node(rid+shift, bipartite=1)\n",
        "    \n",
        "    for j in range(1,max_students):\n",
        "      for r,rid in rooms['id'].items():\n",
        "          if rooms['size'][r] == 2 and rooms['seats'][r] >j:\n",
        "            if random.random()<presources or presources<0:\n",
        "              right.add((r, rid+(1+j) * shift))\n",
        "              G.add_node(rid+(1+j)*shift, bipartite=1)\n",
        "\n",
        "    fields = set()\n",
        "    resource_attr = {}\n",
        "    for rid in right:\n",
        "        resource_attr[rid[1]]={}\n",
        "        for  field in rooms:\n",
        "            if field !='id':\n",
        "                resource_attr[rid[1]][field] = rooms[field][rid[0]]\n",
        "                fields.add(field)\n",
        "\n",
        "    cost = {}\n",
        "    final_fields = set()\n",
        "    days = {}\n",
        "    for pid in left:\n",
        "      \n",
        "        cost[pid[1]] = {}\n",
        "        advisor = None\n",
        "        near = None\n",
        "        specific =False\n",
        "        sp_number = None\n",
        "        sp_level = None\n",
        "        alone_level = None\n",
        "        noise_level = None \n",
        "\n",
        "        ndays = None\n",
        "        \n",
        "        for field in prefs:\n",
        "            if field in fields:\n",
        "                final_fields.add(field)\n",
        "               \n",
        "                cost[pid[1]][field]={}\n",
        "                for rrid,rid in rooms['id'].items():\n",
        "\n",
        "                    cost[pid[1]][field][rid+shift] = 0 if rooms[field][rrid] >0 else max(prefs[field][pid[0]]-meaningful_pref+1,0) # if want, price for relaxation will be high\n",
        "\n",
        "                    for j in range(1,max_students):\n",
        "                      if (rid+((1+j)*shift )) in G.nodes():\n",
        "                        cost[pid[1]][field][(rid+((1+j)*shift ))] = cost[pid[1]][field][rid+shift]\n",
        "\n",
        "            advisor = advisors['advisor'][pid[0]]\n",
        " \n",
        "            if field == 'near_advisor':\n",
        "                near = prefs[field][pid[0]]\n",
        "            if field == 'specific_room':\n",
        "                specific = True if prefs[field][pid[0]]>0 else False\n",
        "            if field == 'specific_room_number':\n",
        "                sp_number = prefs[field][pid[0]]\n",
        "            if field == 'specific_room_importance':\n",
        "                sp_level = prefs[field][pid[0]]\n",
        "\n",
        "            if field == 'alone':\n",
        "                alone_level = prefs[field][pid[0]]\n",
        "            if field == 'silent':\n",
        "                silent_level = prefs[field][pid[0]]\n",
        "            if field =='ndays':\n",
        "                ndays = prefs[field][pid[0]]\n",
        "            if field =='d1':\n",
        "                sunday = prefs[field][pid[0]]>=min_day\n",
        "            if field =='d2':\n",
        "                monday = prefs[field][pid[0]]>=min_day\n",
        "            if field =='d3':\n",
        "                tuesday = prefs[field][pid[0]]>=min_day\n",
        "            if field =='d4':\n",
        "                wednesday = prefs[field][pid[0]]>=min_day\n",
        "            if field =='d5':\n",
        "                thursday = prefs[field][pid[0]]>=min_day\n",
        "        \n",
        "        days[pid[1]] = (ndays, [sunday,monday,tuesday, wednesday,thursday])\n",
        "\n",
        "        field = None\n",
        "        if advisor == 1:\n",
        "            field = 'distance_to_advisor0'\n",
        "        elif advisor == 2:\n",
        "            field = 'distance_to_advisor1'\n",
        "\n",
        "        if field is not None:\n",
        "\n",
        "            cost[pid[1]]['advisor']={}\n",
        "            for rrid,rid in rooms['id'].items():                    \n",
        "                    cost[pid[1]]['advisor'][rid+shift] = 0 if rooms[field][rrid] >0 else max(near-meaningful_pref+1,0) # if want, price for relaxation will be high\n",
        "\n",
        "\n",
        "                    for j in range(1,max_students):\n",
        "                      if (rid+((1+j)*shift )) in G.nodes():\n",
        "                        cost[pid[1]]['advisor'][(rid+((1+j)*shift ))] = cost[pid[1]]['advisor'][rid+shift]\n",
        "        \n",
        "        if specific:\n",
        "            cost[pid[1]]['specific']={}\n",
        "            field = 'id'\n",
        "            for rrid,rid in rooms['id'].items():                    \n",
        "                    cost[pid[1]]['specific'][rid+shift] = 0 if rooms[field][rrid] == sp_number  else max(sp_level-meaningful_pref+1,0) # if want, price for relaxation will be high\n",
        "                    for j in range(1,max_students):\n",
        "                      if (rid+((1+j)*shift )) in G.nodes():\n",
        "                        cost[pid[1]]['specific'][(rid+((1+j)*shift ))] = cost[pid[1]]['specific'][rid+shift]\n",
        "\n",
        "        else:\n",
        "            cost[pid[1]]['specific']={}\n",
        "            field = 'id'\n",
        "            for rrid,rid in rooms['id'].items():                    \n",
        "                    cost[pid[1]]['specific'][rid+shift] = 0\n",
        "                    for j in range(1,max_students):\n",
        "                      if (rid+((1+j)*shift )) in G.nodes():\n",
        "                        cost[pid[1]]['specific'][(rid+((1+j)*shift ))] = cost[pid[1]]['specific'][rid+shift]\n",
        "                      \n",
        "        if apply_alone and alone_level is not None:\n",
        "                cost[pid[1]]['alone']={}\n",
        "                field = 'seats'\n",
        "                for rrid,rid in rooms['id'].items():                    \n",
        "                    cost[pid[1]]['alone'][rid+shift] = 0 if rooms[field][rrid] == 1   else max(alone_level-meaningful_pref+1,0) # if want, price for relaxation will be high\n",
        "                    for j in range(1,max_students):\n",
        "                      if (rid+((1+j)*shift )) in G.nodes():\n",
        "                        cost[pid[1]]['alone'][(rid+((1+j)*shift ))] = cost[pid[1]]['alone'][rid+shift]\n",
        "\n",
        "                \n",
        "        if silent_level is not None:\n",
        "                cost[pid[1]]['silent']={}\n",
        "                field = 'distance_to_kitchen'\n",
        "                for rrid,rid in rooms['id'].items():                    \n",
        "                        cost[pid[1]]['silent'][rid+shift] = 0 if rooms[field][rrid] == 0  else max(silent_level-meaningful_pref+1,0) # if want, price for relaxation will be high\n",
        "                        if (rid+(2*shift )) in G.nodes():\n",
        "                            cost[pid[1]]['silent'][(rid+(2*shift ))] = cost[pid[1]]['silent'][rid+shift]\n",
        "                        for j in range(1,max_students):\n",
        "                          if (rid+((1+j)*shift )) in G.nodes():\n",
        "                            cost[pid[1]]['silent'][(rid+((1+j)*shift ))] = cost[pid[1]]['silent'][rid+shift]\n",
        "    room_failures = {}\n",
        "    pool = {}\n",
        "\n",
        "    for pid in cost:\n",
        "        restricted = set()\n",
        "        all_rooms = set()\n",
        "\n",
        "        for fname, field in cost[pid].items():\n",
        "\n",
        "            for room in field.items():\n",
        "                all_rooms.add(room[0] )\n",
        "                if room[1] > 0 :\n",
        "                    restricted.add(room[0] )\n",
        "\n",
        "        ls = tuple(sorted(list(all_rooms-restricted)))\n",
        "        if  ls not in pool:\n",
        "            pool[ls] = [pid]\n",
        "        else:\n",
        "            pool[ls].append(pid)\n",
        "\n",
        "        for room_id in all_rooms-restricted:\n",
        "            if room_id in G.nodes():\n",
        "              G.add_edge(pid, room_id)\n",
        "\n",
        "    attributes = set()\n",
        "    for item in cost.items():\n",
        "        break\n",
        "    for item in cost.values():\n",
        "        for key in item:\n",
        "            attributes.add(key)\n",
        "    #print(max_students,len(left),len(right) )\n",
        "    #print(len(left))\n",
        "  \n",
        "\n",
        "    return G, len(left),len(right),cost, attributes, days\n",
        "\n",
        "\n",
        "#G, n, m, cost, attributes, days = load_one_student_per_room()\n",
        "\n",
        "import numpy as np\n",
        "\n",
        "\n",
        "def get_delta1(G,days):\n",
        "  delta = {}\n",
        "  k = len(next(iter(days.values()))[1])\n",
        "  values = set()\n",
        "  for i in range(k+1):\n",
        "    for j in range(k+1):\n",
        "      if i<=j and j>0:\n",
        "        values.add(i/j)\n",
        "  ls = sorted(list(values), key=lambda x: -x)\n",
        "  ord = {}\n",
        "  for c,item in enumerate(ls):\n",
        "    ord[item] = c\n",
        "  xi = {}\n",
        "  for item in ls:\n",
        "    xi[item] = (k*n)**ord[item]\n",
        "    #print(xi[item])\n",
        "  mx = max(xi.values())\n",
        "  agents = {n for n, d in G.nodes(data=True) if d[\"bipartite\"] == 0}\n",
        "  for agent in agents:\n",
        "    rho = days[agent][0]\n",
        "    delta[agent] = {}\n",
        "    for i in range(1, rho+1):\n",
        "        delta[agent][i]=xi[(i-1)/rho]\n",
        " # print(\"mn mx \" , min(xi.values()),max(xi.values()))\n",
        "  return delta, max(xi.values())\n",
        "\n",
        "def get_delta2(G,days):\n",
        "  delta = {}\n",
        "  k = len(next(iter(days.values()))[1])\n",
        "  agents = {n for n, d in G.nodes(data=True) if d[\"bipartite\"] == 0}\n",
        "  for agent in agents:\n",
        "    rho = days[agent][0]\n",
        "    delta[agent] = {}\n",
        "    for i in range(1, rho+1):\n",
        "        delta[agent][i]=1\n",
        " # print(delta)\n",
        "  return delta,1\n",
        "\n",
        "def run_for_parameters(G, n, m, days, delta = 2):\n",
        "  \n",
        "  k = len(next(iter(days.values()))[1])\n",
        "  agents =    {n for n, d in G.nodes(data=True) if d[\"bipartite\"] == 0}\n",
        "  resources = {n for n, d in G.nodes(data=True) if d[\"bipartite\"] == 1}\n",
        "  \n",
        "  for i,agent in enumerate(agents):\n",
        "    G.nodes[agent]['rho'] = days[agent][0]\n",
        "\n",
        "  #generate the auxilary graph\n",
        "  G_construction = nx.Graph()\n",
        "  #for each resource in original graph, add k resources, one per matching round\n",
        "  for resource in resources:\n",
        "    for i in range(1,k+1):\n",
        "      res = str(resource) +\"_\" + str(i)\n",
        "      G_construction.add_node(res, bipartitie=1)\n",
        "  kis = {}\n",
        "\n",
        "  #for each agent in original graph, add k agents in auxilary\n",
        "  for agent in agents:\n",
        "    relevant_days = days[agent][1]\n",
        "    ki = 0\n",
        "\n",
        "    for i in range(1,k+1):\n",
        "      if not relevant_days[i-1]:\n",
        "        continue\n",
        "      ki += 1\n",
        "      ag = str(agent) +\"-\" + str(i)\n",
        "      G_construction.add_node(ag, bipartitie=0)\n",
        "    kis[agent] = ki\n",
        "    rho = G.nodes[agent]['rho']\n",
        "    #add type 2 dummy resources, with total of rho.\n",
        "    for j in range( 1, rho+1 ):\n",
        "      ag = \"x-\" + str(agent) +\"_\"+str(j)\n",
        "      G_construction.add_node(j,bipartite=1)\n",
        "\n",
        "    #add type 3 dummy resources, one per unmatched round of an agent\n",
        "    for j in range( 1, ki-rho+1 ):\n",
        "      ag = \"z-\" + str(agent) +\"_\"+str(j)\n",
        "      G_construction.add_node(j,bipartite=1)\n",
        "\n",
        "  verbose = False\n",
        "  el = []\n",
        "\n",
        "# print(\"total edges are \", len(el))\n",
        "  #add edges to type 3 dummy resources\n",
        "  bign = k+1\n",
        "  if delta==1:\n",
        "    delta, mx = get_delta1(G,days)\n",
        "  elif delta==2:\n",
        "    delta,mx = get_delta2(G,days)\n",
        "\n",
        "  #print(mx)\n",
        "  #add edges of original graph to auxilary\n",
        "  for agent in agents:\n",
        "    if agent == 2:\n",
        "      verbose = True\n",
        "    for resource in resources:\n",
        "      if (agent,resource) not in G.edges() and (resource,agent) not in G.edges():\n",
        "        continue\n",
        "      relevant_days = days[agent][1]\n",
        "      for i in range(1,k+1):\n",
        "          if relevant_days[i-1]:\n",
        "            edge = (str(agent) +\"-\" + str(i),  str(resource) +\"_\" + str(i))\n",
        "            if verbose:\n",
        "              el.append(edge)\n",
        "            G_construction.add_edge(edge[0], edge[1], weight=mx)\n",
        "    verbose = False\n",
        "\n",
        "  for agent in agents:\n",
        "    relevant_days = days[agent][1]\n",
        "    for i in range(1,k+1):\n",
        "      if relevant_days[i-1]:\n",
        "        rho = G.nodes[agent]['rho']\n",
        "        for j in range( 1, rho+1 ):\n",
        "          ag = \"x-\" + str(agent) +\"_\"+str(j)\n",
        "          try:\n",
        "            G_construction.add_edge(str(agent) +\"-\" + str(i), ag,weight=(mx-delta[agent][j]))\n",
        "          except Exception as e:\n",
        "            print(\"Exception\")\n",
        "            print(\"GOT AN EXCEPTION WHEN ADDING EDGE\", rho, j, delta[agent])\n",
        "\n",
        "        for j in range( 1, kis[agent]-rho+1 ):\n",
        "          ag = \"z-\" + str(agent) +\"_\"+str(j)\n",
        "          G_construction.add_edge(str(agent) +\"-\" + str(i), ag,weight=bign*mx)\n",
        "          \n",
        "\n",
        "  #calculate weighted matching\n",
        "  matching = nx.max_weight_matching(G_construction, weight='weight')\n",
        "  #print(matching)\n",
        "\n",
        "  #Given the resulting matching, construct k matchings in original graph\n",
        "  ret = []\n",
        "  for l in range(k):\n",
        "        ret.append(set())\n",
        "\n",
        "  agent_assignments = {}\n",
        "\n",
        "  #print(matching)\n",
        "  for (x,y) in matching:\n",
        "      if \"z-\" in y or 'z-' in x or \"x-\" in y or 'x-' in x:\n",
        "        continue\n",
        "      else:\n",
        "        if '-' in x: #sign for an agent\n",
        "          agent = x\n",
        "          resource = y\n",
        "        else:\n",
        "          agent = y\n",
        "          resource = x\n",
        "        place = int(agent.split('-')[1]) - 1\n",
        "        ag = agent.split('-')[0]\n",
        "        ret[place].add((ag,resource.split(\"_\")[0]))\n",
        "  \n",
        "\n",
        "  return agents, resources, G, ret\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "Yzj4eQaKKIpr",
        "outputId": "6e324c07-fcfb-4855-d5b7-d5ce5760a430"
      },
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Drive already mounted at /content/gdrive; to attempt to forcibly remount, call drive.mount(\"/content/gdrive\", force_remount=True).\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Given the students dataset and graph run the max total algorithm"
      ],
      "metadata": {
        "id": "zXRGs6nr8FTj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "A wrapper for showing the graphs"
      ],
      "metadata": {
        "id": "u4KDZksn8MCm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "from random import choices\n",
        "import matplotlib.pyplot as plt\n",
        "import copy\n",
        "import math\n",
        "\n",
        "grp = {}\n",
        "edges = 0 \n",
        "agn = 0\n",
        "\n",
        "for max_students_per_room in range(1,6):\n",
        "  for meaningful_pref in range(1,7):\n",
        "    for meaningful_day_pref in range(1,6):\n",
        "      total = 0\n",
        "      G, n, m, cost, attributes, days = load_one_student_per_room(max_students_per_room, meaningful_pref, meaningful_day_pref)\n",
        "      for agent in days:\n",
        "        total += days[agent][0]\n",
        "      agents, resources, G, ret = run_for_parameters(G, n, m, days)\n",
        "      if max_students_per_room not in grp:\n",
        "        grp[max_students_per_room] = {}\n",
        "      if meaningful_pref not in grp[max_students_per_room]:\n",
        "        grp[max_students_per_room][meaningful_pref] = {}  \n",
        "      if meaningful_day_pref not in grp[max_students_per_room][meaningful_pref]:\n",
        "\n",
        "        sm = 0\n",
        "        for item in ret:\n",
        "          sm += len(item)\n",
        "          \n",
        "        grp[max_students_per_room][meaningful_pref][meaningful_day_pref] = sm/total\n",
        "\n",
        "#print(grp)\n",
        "\n",
        "x = [2,3,4,5]\n",
        "\n",
        "labels = []\n",
        "\n",
        "ys = []\n",
        "for students in range(1,3):\n",
        "  for day in range(3,6,2):\n",
        "    y = [grp[students][xx][day] for xx in x]\n",
        "    y.insert(0,\"st-{}day-{}\".format(students,day))\n",
        "    ys.append(y)\n",
        "\n",
        "# seaborn plot multiple lines\n",
        "\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "from matplotlib.ticker import MaxNLocator\n",
        "import os\n",
        "\n",
        "df = pd.DataFrame(ys, columns = ['name',2,3,4,5])\n",
        "df2 = df.transpose()\n",
        "\n",
        "new_header = df2.iloc[0] #grab the first row for the header\n",
        "df2 = df2[1:] #take the data less the header row\n",
        "df2.columns = new_header #set the header row as the df header\n",
        "df2['x'] = df2.index\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
        "ax1 = sns.lineplot(x='x', y='st-1day-3', data=df2, color='blue', label=\"Max. Stud.={};Day. Affin. Thresh.={}\".format(1,3), linestyle=\"solid\")\n",
        "ax2 = sns.lineplot(x='x', y='st-1day-5', data=df2, color='red', label=\"Max. Stud.={};Day. Affin. Thresh.={}\".format(1,5), linestyle=\"solid\")\n",
        "ax3 = sns.lineplot(x='x', y='st-2day-3', data=df2, color = 'blue', label=\"Max. Stud.={};Day. Affin. Thresh.={}\".format(2,3), linestyle=\"dashed\")\n",
        "ax4 = sns.lineplot(x='x', y='st-2day-5', data=df2, color = 'red', label=\"Max. Stud.={};Day. Affin. Thresh.={}\".format(2,5), linestyle=\"dashed\")\n",
        "\n",
        "ax.set_xlabel(\"(a) Preference Affinity Threshold\", fontsize = 20)\n",
        "ax.set_ylabel(\"Avg. Assign. Ratio\", fontsize = 20)\n",
        "ax.legend(fontsize='large', title_fontsize='20')\n",
        "\n",
        "plt.xticks(fontsize=20 )\n",
        "plt.yticks([0.0, 0.2,0.4,0.6,0.8,1.0],fontsize=20 )\n",
        "\n",
        "path = \"/content/gdrive/My Drive/students_lab_results\"\n",
        "isExist = os.path.exists(path)\n",
        "\n",
        "if not isExist:\n",
        "  # Create a new directory because it does not exist \n",
        "  os.makedirs(path)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.savefig(join(path,\"StudMnPref.pdf\"), format=\"pdf\")\n",
        "\n",
        "plt.show()\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "PuACE77P10_Z",
        "outputId": "0a54a72b-66da-48d8-df44-241b985ccfad"
      },
      "execution_count": 19,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAagAAAEYCAYAAAAJeGK1AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nOydZ3hU1RaG300IEkjoJUgXCSgWmhRBikiTKgqKgqAgiqhYuCqCBS72clEUrKAUsSE2QEAEQUVponSUKkiRmlCTkHV/rBlSSJtkkkyS9T7PeSanzD57Eph11t7fXp8TEQzDMAwj0CiQ0x0wDMMwjOSwAGUYhmEEJBagDMMwjIDEApRhGIYRkFiAMgzDMAISC1CGYRhGQGIByjAMwwhIAiJAOeducM6Nc84tcc5FOufEOTc1g21Vcs5NdM7945w77Zzb7pwb65wr6e9+G4ZhGFlHwZzugIeRwOXAMWAXUDsjjTjnagA/A+WAL4GNQCNgKNDBOddMRA76pceGYRhGlhIQGRTwABABFAMGZ6Kd8Whwuk9EuovIoyJyNfA/oBbwdKZ7ahiGYWQLLtBKHTnnWgELgWki0seH99UA/gK2AzVEJC7BuTBgD+CAciJy3J99NgzDMPxPoGRQ/qC153VewuAEICJRwE9AEaBJdnfMMAzD8J28FKBqeV43p3D+T89rRDb0xTAMw8gkgSKS8AfFPa9HUzjvPV4iuZPOuUHAIICiRYs2qF07QzoNwzAMw0dWrlx5QETKJj2elwJUphCRt4G3ARo2bCgrVqzI4R4ZhmHkD5xzO5I7npeG+LwZUvEUznuPH8mGvhiGYRiZJC8FqE2e15TmmGp6XlOaozIMwzACiLwUoBZ6Xts55xJ9Lo/MvBlwAvgluztmGIZh+E6uC1DOuWDnXG3PuqeziMgWYB5QDRiS5G2jgKLAFFsDZRiGkTsICJGEc6470N2zG+55beqce9/z8wERGeb5uSKwAdiBBqOE3I2WOnrNOdfGc11jdI3UZmBEZvoZFxfHgQMHOHLkCGfOnMlMU4Zh5CIKFy5MpUqVCA4Ozumu5CsCIkABdYF+SY5d4NlAg9Ew0kBEtjjnGgKjgQ7AtWgFiVeBUSJyODOd3LVrF845qlWrRnBwMM65zDRnGEYuQEQ4ePAgu3btonr16jndnXxFQAQoEXkKeCqd125HSxaldP5v4DZ/9Cspx48fp1atWhQokOtGRg3DyCDOOUqXLs2///6b013Jd9g3rY9YcDKM/IeNluQM9m1rGIZhBCQWoIxcw6JFi6hUqVJOdyMg2LRpE3Xr1iUsLIzXXnuNkydP0qVLF4oXL07Pnj2ZNm0a7dq1y/J+vP/++zRv3jzL72N/+/yJBag8RLVq1ShUqBAHDhxIdLxevXo459i+fXuW3j86OpqHHnqISpUqERoaSrVq1bj//vsT9e+7777L0j6kh0GDBp2dS3z//fdTvfapp54iODiYsLAwwsLCiIiI4J577mHPnj3Z0tf+/ftTsGDBc+73wgsv0Lp1a6Kiorjvvvv47LPP2LdvHwcPHuTTTz/llltuYd68eZm+f506dQgNDSU0NJSgoCAKFy58dv+ZZ57JdPs5TZ8+fahQoQLFihUjIiKCd999N6e7ZCTAAlQeo3r16kyfPv3s/po1azhx4kS23PvZZ59lxYoVLFu2jKioKBYtWkT9+vWz5d6+cPnllzN+/Ph09+3GG28kKiqKQ4cOMXPmTPbu3UuDBg2yPEgdP36cGTNmULx4caZOnZro3I4dO6hTp06i/YiICAoW9K/uad26dRw7doxjx45x1VVX8frrr5/df+yxx3xqS0SIi4tL+8JsZPjw4Wzfvp3IyEi++uorRo4cycqVK3O6W4YHC1B5jL59+zJ58uSz+x988AG33npromtmzZpFvXr1KFasGJUrV+app546e+7jjz+mevXqREZGAjBnzhzCw8PTpWBavnw51113Heeff/5ZOb733n379mXnzp106dKF0NBQXnjhhWSHbRJmWSdPnqR///6ULFmSiy++mOXLl2fod5KUIUOG0KZNGwoXLnzOuR9//JESJZIteE9wcDB16tTh448/pmzZsrz88ssAHD58mM6dO1O2bFlKlixJ586d2bVrFwCffvopDRo0SNTOK6+8Qrdu3dLs54wZMyhRogRPPPEEH3zwwdnjV199NQsXLuSee+4hNDSU3r17M3r0aD7++GNCQ0N57733zhl6c87x5ptvUrNmTUqUKMGQIUPwp1npsGHDKFmyJNWrV2fOnDlnj7dq1YoRI0bQrFkzihQpwtatW9m4cSNt27alVKlS1KpVi08++eTs9bNnz+biiy8mLCyMihUr8tJLLyW6z8svv0y5cuWoUKECkyZNynS/69Spw3nnnQfo78g5x5YtWzLdruEnRMS2JFuDBg0kOdavX59of+hQkZYts3YbOjTZriRL1apVZf78+RIRESHr16+X2NhYqVixomzfvl0A2bZtm4iILFy4UP744w85c+aM/P7771KuXDmZOXPm2XZuvvlm6devnxw4cEAqVKggX3/9dbru/9///lcqV64sb7zxhvzxxx8SFxeXbP+8LFy4UCpWrJjiNY888og0b95cDh48KDt37pQ6deqcc31CihcvnuL27LPPnnN9s2bNZNKkSal+pieffFJuueWWc44//vjj0qhRIxEROXDggHz22Wdy/PhxiYyMlBtuuEG6desmIiKnTp2SkiVLJvq3U7duXfnss89Sva+IyNVXXy3/+c9/ZO/evRIUFCQrVqw4e65ly5byzjvvpNjPSZMmSbNmzc7uA9KpUyc5fPiw7NixQ8qUKSNz5sxJsw8JSXpP730KFiwob7/9tsTGxsr48eOlQoUKZ//2LVu2lMqVK8vatWslJiZGjhw5IpUqVZKJEydKTEyMrFq1SkqXLi3r1q0TEZHw8HBZvHixiIgcOnRIVq5cKSL6byUoKEgef/xxiY6OllmzZklISIgcOnQo2b526tQpxX8LnTp1SnTt4MGDJSQkRACpV6+eREVFJdtm0v//hv8AVkgy38WWQeVBvFnU/Pnzueiii6hYsWKi861ateLSSy+lQIECXHbZZfTu3Zsffvjh7Pk33niD77//nlatWtGlSxc6d+6crvsOHz6cRx55hGnTptGwYUMqVqyY6MnfVz755BNGjBhBqVKlqFy5Mvfdd1+q1x85ciTF7dFHH81wP5Lj/PPP59ChQwCULl2a66+/niJFihAWFsaIESPO/j7PO+88brzxxrNDdOvWrWP79u1p/k537tzJwoULufnmmylfvjxt2rRJlBlnhEcffZQSJUpQpUoVWrduzerVqzPVnpeqVatyxx13EBQURL9+/dizZw/79u07e75///7UqVOHggUL8u2331KtWjVuu+02ChYsSL169bj++uv59NNPAc1S169fT2RkJCVLlkw0DBscHMwTTzxBcHAw1157LaGhoWzatOmc/gB88803Kf5b+OabbxJdO378eKKioliyZAk9evQ4m1EZOU9ALNTNrYwdm9M9SJ6+ffvSokULtm3bds7wHsCvv/7Ko48+ytq1a4mOjub06dP07Nnz7PkSJUrQs2dPXnnlFWbMmJHu+wYFBTFkyBCGDBnCyZMnmThxIrfffjuNGjXioosu8vlz/PPPP1SuXPnsftWqVX1uI6vYvXs3pUqVAuDEiRM88MADfPvttxw+rMVKoqKiOHPmzNkv7d69ezNmzBimTJlCr1690vwSnDJlChdddBF169YF4JZbbuGhhx7ipZdeynC5nfDw8LM/FylShGPHjmWonbTaBRK1nfBvuGPHDn799ddEw6ixsbH07dsX0GHNMWPG8Oijj3LZZZfx3HPP0bRpU0AfBBLOsfnzMwQFBdG8eXOmTp3KhAkT0nwYMrIHnzMo59xNzrnvnHMHnXOxzrlDzrn5zrmbsqKDhu9UrVqV6tWrM3v2bHr06HHO+ZtvvpmuXbvy999/c/ToUe66665E8xGrV69m4sSJ9O7dO8P/UUNCQhgyZAglS5Zk/fr1wLmLHYsWLZpIwHHmzJlEc10VKlTg77//Pru/c+fOVO/pVZclt/lTcRYXF8fXX3/NVVddBei8yKZNm/j111+JjIxk8eLFAGd/p02aNKFQoUIsWbKEDz/88OyXcWpMnjyZrVu3Eh4eTnh4OA8++CAHDhxg9uzZfvsc2UXCv3vlypVp2bJloozm2LFjTJgwAYArrriCL7/8kv3799O9e3d69eqVoXt27NgxxX8LHTt2TPF9sbGxNgcVQKQ7QDllCjANuBooBvwLhAFtgGnOuWlZ0kvDZ9577z2+//57ihYtes65qKgoSpUqReHChVm2bBkffvjh2XOnTp2iT58+PPPMM0yaNIndu3czfvz4dN1z7NixLFq0iJMnTxIbG8sHH3xAVFQU9erVA6B8+fJs3br17PURERGcOnWKWbNmERMTw5gxYzh9+vTZ87169eLZZ5/l8OHD7Nq1i3HjxqV6f6+6LLktoeIsOjqaU6dOISLExMRw6tSps+qyRYsWpVg1IDY2lg0bNtC7d2/27t3Lgw8+ePb3GRISQokSJTh06BCjRo0657233nor99xzD8HBwWmuG1q6dClbtmxh2bJlrF69mtWrV7N27VpuvvnmTA/z5TSdO3dm8+bNTJkyhZiYGGJiYli+fDkbNmwgOjqaadOmcfToUYKDgylWrFiGK7fMmTMnxX8LXhHH/v37+eijjzh27Bhnzpxh7ty5TJ8+nTZt2vjzIxuZwJe//p3ALcAq4BqgsIhUAAp79lcCNznn7vJ7Lw2fqVGjBg0bNkz23Pjx43niiScICwtj9OjRiZ5Shw8fTuXKlRk8eDDnnXceU6dOZeTIkfz555+Aqp6mTUv+OaRIkSI89NBDhIeHU6ZMGd544w1mzJjBBRdccLbtMWPGUKJECV566SWKFy/O+PHjGThwIBUrVqRo0aKJVH1PPvnk2WywXbt252QeHTt2zFBm1K5dO0JCQvj5558ZNGgQISEhZ7Oev//+myuvvDLR9V51XPHixenatSulS5dm5cqVnH/++QDcf//9nDx5kjJlytCkSRM6dOhwzj379u3L2rVr6dOnDwBLliwhNDQ02f598MEHdOvWjUsvvfRsBhUeHs7QoUP55ptvzs59+YvU+uJvwsLCmDdvHh999BHnn38+4eHhPPLII2cfTKZMmUK1atUoVqwYb775Zor/1pLyzDPPpJoZJYdzjgkTJlCpUiVKlizJsGHDGDt2LF27dvX5cxlZg0s4tJPqhc4tA8oAdUTkZDLnQ4C1wCERucKvvcxmGjZsKCtWrDjn+IYNGzI0l2LkHgYOHEjPnj1p3769X9s9efIk5cqVY9WqVdSsWTPtNxgBh/3/zzqccytF5Jwnal9EEhcDbyUXnABE5KRz7gs00zKMXElWVRKYMGECV1xxhQUnw/ABXwKUkIrNhQcr+WsYSahWrRoiwhdffJHTXTGMXIUvAWoD0MM5NyKVIb7uwHp/dc4w8gJZXQPRMPIqvogkJgJVgMXOuTbOuYIAzrkg51xrYCFQ1XOdYRiGYWQKXzKot4CrgN7APCDOOXcIKIUGOgd8IiJv+r2XhmEYRr4j3RmUp2TSLajU/HvgKBqcjnr2bxERW6xrGIaRTxCB/fuzrn2fSx2JyHRgepoXGoZhGHkSEZg3Dx5/HGJiYOVKyOCa6lSxYrGGYRiGz4wcCfv2wb33asDKCixAGbkGs/2Oxyzfjezm11+he3c4cACcg88+g82b4fbbISgoa+6ZYoByzsV5isFGJNg/k44tNmu6aqSFWb6nD7N8Tz953fK9VatWiT5TrVq1crpLAcdvv0GXLtCkCfz8M3hqP1O1KmS1M0lqGdRiYAlwIsF+erYlWdVZI23M8j1tzPI9/eR1y3cg0WdKyV8qPxITA716Qf368OOP8MwzsHUrtGiR+LotW3SoLytIMUCJSCsRaS0iu5Lsp7llTVeN9GCW72ljlu9m+W6kjHcAJjgYihSBJ56Abdtg+HBIWFP4t9/gppsgIgJeeCGLOpOczW5+39Jr+R5onu9m+W6W717M8j19lu8tW7aUMmXKSOnSpeXKK6+UhQsXpvj587rl+44dIgMHipx3nsjGjclfExcnsmCBSLt2IiASFiby8MMiu3dn7t5k1vLdObfVOZeqe51zbohzbmtq1xhZj1m+m+V7cpjl+7mW788//zxbt25l9+7dDBo0iC5duuQ7w8I9e1SJV7MmTJ4MgwZByZKJrzlzBmbMgMaNoU0b+P13ePZZ2LkTnn8ePM4zfseXAetqQPJjH/GUQMsd+YxzrhIwGugAlAb2AF8Ao0TksA/tNAf+A1wOhAP7URuQ10Tk24z0LUUC1PPdLN+zHrN8T7ldyD2W740bNz77c79+/Zg+fTqzZ8/m3nvvzVS7uYXjx6FOHYiKgttuU+l4lSrx50+fhilT4MUXVbFXowa8+Sb06wfJjJD7HX/LzMOAaF/f5JyrgRoe3gYsA/4HbAWGAkudc6XT2c5gVKTRxvP6P+AHoCUwxzk3wte+5UbM8t0s3wOJ3GT57pzz69xcIHLkCHhdZYoWhddfh40b4e2344NTZKQGperV4Y47dO7p449h0ya4887sCU6QRoByzlXxbp5DJRIeS7BVd861BK5HA4uvjAfKAfeJSHcReVRErkYDTC3g6bQacM4FA88Cp4AGItJXRIaLSF+gIXAaGOGcy2JhZGBglu9m+R6IBJLl+5EjR5g7dy6nTp0iNjaWadOmsXjx4mQdkfMCUVHw9NPxQWfNGj1+882aGQHs3atiiCpV4OGH4eKLYf58WLFCFX1Ztd4pJdL6628Htnk20IxmWzLbX2g9vhrAO750wJM9tfPc640kp58EjgN9nXPnftMmphRQHNgsIokGpkVkA7AZCAGyx9s6hzHL95Qxy/fE5FfL95iYGEaOHEnZsmUpU6YM48aN44svviAiIsLnzxXInDoFL78MF1ygQ3gtWsDq1XDppfHX/PUX3HUXVKumc0rt2sHy5fDdd3DNNbowNydI1fLdOfc+8UaFtwK/A8nNrJ4BDgILRMSn1YHOuYFoUHtbRM5x43XOzUUD2DUisiCVdhywDx1mvExE/kxwLsLT940iUi+tPpnle/7FLN+NlMit//+PHdPgVL8+jB4NjRrFn1u1SgPSZ59BwYLQvz8MG6aCiewkQ5bvItI/QQO3AjNFZLSf++Zdur05hfN/ogEqAkgxQImIOOeGAFOBlc65mcA/QEXgOmAdYNXWjVQxy3cjtxMTAx98oHNGc+bo/NGaNVC+vJ4Xge+/18A0fz4UKwb/+Q8MHQoVKuRs35OSbhWfiGRV3b7intejKZz3Hk9LQYiIfOqc+wettp5QvrYPmEQq82POuUHAIIAqCWUshpFJzPLdyA7OnIHp0+Gpp7S6Q6NGWuGhYkUNTmfOwMyZ8NxzWn08PFx/vusuKF48zeZzhDxVLNY51wf4DlXwXQQU8bwuAF4HPkrpvSLytog0FJGGZcuWzY7uGvmE7du3s2PHjrNiEcPwN3//rXNKfftqxvTVV/DLLxqcTp1Shd5FF0HPnnD0qO5v2waPPBK4wQky4AflnLsCaI8OnSWniBMRGeBDk94MKaVfk/f4kTT6FYHazf8B9BURb9Gvjc65vuhQYk/nXCsRWeRD/wzDMAIOEdi+XVV555+vAWj0aOjRQ72Zjh7VNUtjx6o6r0ED+PRTuO667FfjZZR0ByiPCOF9oA8qmvCKJ7xIguO+BCiv4i4l6Yx30D6lOSov7YBg4IcEwUk7JhLnnFsMNPBsi3zon2EYRsAgAgsWqCLvzz81EypWTCs9gAajsWNhwgRdz9S2LUydCldfnXNqvIziyxDfPUBfYAq6rsgBY4ErgceAKHQI7QIf+7DQ89rOOZeoP865MKAZWlH9lzTa8WZzKY3PeY/7vJDYMAwjEPjxR2jdWoPOP/+o0CEkRM/99Zcuoq1WTRfZduig65fmzdPyRLktOIFvAaofsElE+ovIKs+xIyLyi4g8B7RGF+pe7UsHRGQLMA8tpTQkyelRQFFgiogc9x50ztV2ztVOcq3X5uMG59xlCU845+oCN6DZ3fe+9M8wDCMQ+OMPuOoqreYwbpxmTwMH6vFevaBWLVXv9e+v13z8sQ7r5WZ8mYOqDSSt/Hn2/SLym3PuG+BuVDHnC3cDPwOvOefaABuAxmjQ2wwkLVG0wfN69plARJY55yah5ZKWe2TmO9DA1x0oBIwVkXU+9s0wDCNH+OMPWLZMA9Fll8FHH6l5YEiIDvM9/7wupi1WTCs/DB2q6ry8gq8qvoRS8ONo9YaE/IkGMp/wZFEN0TmuxsBDaFWKV4EmInIwnU0NQAPUUlTI8RDQFvgR6C0iD/jaNyNwMNvveMzyPW+zcaN6LV1+OYwYAd6SlTfcALNmwRVX6DDf2rUapHbu1OrieSk4gW8Bajeq3POyFRUcJKQmGrh8RkT+FpHbRKSCiBQSkaoicn9ylcxFxInIOSOqHmuR90XNFUuKSEERKSUibUQkRYl5XsEs39Nm8+bNdOvWjbJly1KqVCnat2+fqouqWb7nbcv3Pn36UKFCBYoVK0ZERESWLdROL7t2aaXwOnU0EI0cqcGqQAGVhteurcN5kZHxUvGHHw5sqXhm8CVALSNxQJoDNHLOPe6cq+Op4tCNtMUMRhZilu+pc+TIEbp27cqmTZvYt28fjRo1StPd1izf867l+/Dhw9m+fTuRkZF89dVXjBw5kpUrV2Z7P7wV506f1sW0Dz6o9urDhsFbb6nw4c47oUQJLUu0YYMWfM2uquI5hS8BagYQ5Jyr7tl/AZ3jGYWuPRqHrlXyrzOc4RNm+Z46jRo1YsCAAZQqVYrg4GAeeOABNm3axMGDOopslu8ZI7davtepU+esN5dzDudcthoW7t0L998PN96o+zVqwO7dGqBeekmrig8frkN9CxbofNT11+eedUyZJjmb3fRu6CLaYcAE4BGgQmbaC5Qt3ZbvkrxL+xtv6Lnjx5M/73UZ//ff5M9/9JGe37kz2W6kiFm++2b5LiIyc+ZMCQ8PT7FNs3yPJy9avouIDB48WEJCQgSQevXqSVRUVLJt+tPy/cABkUceESlSRCQoSGTAAJGYGJHNm0XuuEOkUCGRAgVEbrxRxPMryNOQWcv3FILbURF5SUQGi8jzIpI9A/NGqpjle/os33ft2sWQIUN45ZVXfO6bWb7Hk5st30HtZ6KioliyZAk9evRI0+04s3z/vVZ/eOEFreqwYYPWw+vdW6XikyfD7berg+1HH2kV8vyKXwesnXPtgP+KSOM0L84jLFqU8rkiRVI/X6ZM6ucTOGX7hFm+p82///5Lu3btuPvuu+ndu7fP7zfL95Tbhdxj+e4lKCiI5s2bM3XqVCZMmJBhJ+mUOHZMF9ZGREC9etCtm9bB27MHBg/W4bvixeHRR1Uq7q08nt9JdwblnCvlqeyQ3LmmzrnvUeFE8i55RrZhlu+pW74fPnyYdu3a0bVrV0aMSLrELm3M8t03cpPle2xsrF/noE6ehP/9T/2YevVSMUSxYrqWqV8/NQZcv14rP+zcCc88Y8EpIWkGKOfc9c65LcC/wBHn3GrnXGPPuXLOuc/QdUatUFPAtGd/jSzHLN+Tt3yPjIykffv2NGvWjOeee+6cNszyPWsJJMv3/fv389FHH3Hs2DHOnDnD3LlzmT59Om3atMn054yO1lp4F16ogofLL4dXX1VpeK1aKoo4dgzefVel4sOGaeAyEpPqX985dxXwCVAdrdrggMuAOZ5yQsuBHsB64AYRqS8i36TUnpF9mOV78sycOZPly5czadKkRE/V3uzMLN+zlkCyfHfOMWHCBCpVqkTJkiUZNmwYY8eOpWvXrj5/rqRMnw53362Z09dfa6HWG2/UuabSpbWw6/r1MGAAZPGUV+4mOeWEd0Ol5XGoQq+MZxvpOXYAOIWWKSqQWju5bfNFxWfkLQYMGCDffvut39s9ceKEhIaGyubNm/3etpE9pPb/PzZWZNo0kenTdT86Wn8eNkwkLEwERNq3F/n+e5Ek4lZDUlbxpSWSaAIsEJHnExwb45xrjQ7pDRKR9/wYLw0jRzHLd8MXRHRh7RNPwLp1OqdUv77OKU2eDLGxOvf08MMqjjB8I60AVRZIbln1CjRApV/iZRj5FLN8z5v8+KMq7lat0nmlp59WK/XatXXYbsAAeOghXXxrZIy0AlRB1IspKScARCRVl1vDMMjyGohG9hIbCwULqsjh0CEVOCxfrkVdS5TQyg/33WdqPH/g38JdhmEYeZTTp9X4r2FDzZYOH9aA9NJLarn+0kswaBCEJbsYx8gI6QlQ/Z1zrZIcqwbgWfuUFBGRzOs0DcMwAoDjx3WR7d69am9RvrwO6W3dqq/vvQe33GJqvKwgPQGqmmdLjlbJHPNfBUrDMIwcZO9etcAICtLK4SIqIW/USDOmbt3UCsPIGtIKUK2zpReGYRgBwqlT4JxmREWKQGioGgaeOqUW6o88Ai1b6jVG1pJqgBKRH1I7bxiGkVc4fVpr4x04oHNLBQvCwYOaNZUqpVlUAicRIxuw5NTINeQ32+/UMMt3/xEdDTt26PzSwYOaOR05oj+XKQOXXqoVIQoVypLbG6lgASoPYZbvaWOW776R1y3fW7VqRbFihbnoolCuuiqUHj1qERsLFSrAZZdB1aomfshJLEDlMczyPXXM8t038qLle2ysCh8iI/Xn4cNfZ/HiYyxdeoxff93EZZdBxYqQQVcTw49YgMpjmOV76pjle/61fD9zRuXia9aoOm/LFrXDAKhWTYfywsPzkZ16biC5An35ffOpWGwAeb6b5btZvnsxy/fElu/FihWX0FDdmjfvJMuXi6xfL9KsWUspU6aMlC5dWq688kpZuHBhip/fikVnHWSF5bsRmJjlu1m+J0d+s3w/dOgIhw8fYf/+IyxbdoSFC3WbOPEbatXSmnkvv/w8W7duZffu3QwaNIguXbr41bDQyBxW6iizBKDnu1m+p41Zvuddy/e4OFXg/fOPChyOH4+XioeH639LL40bNz77c79+/Zg+fTqzZ8/m3vBOhCMAACAASURBVHvvzeivw/AjlkHlQczy3SzfA4nssnwX0TVMa9ZAt24dado0lPr1Q2nRIpRWrUK57LJQypVL3fLdOefXuTkjc/gtQDnnQpxzLZxzLfzVppFxzPLdLN8DkayyfBeBjRth+3aIiYHXX5/Dn38e4+jRYxw/nrzl+5EjR5g7dy6nTp0iNjaWadOmsXjx4mQdkY1U8K5uzgL8mUFVARYByRWQNbIZs3xPHrN8P5fcbPkeFQX//gv33/8MAwZ0pGBBqFQJLr88bal4TEwMI0eOpGzZspQpU4Zx48bxxRdfEBER4c+PnDeJjoYxY/SXXLEivPpqltzG+Suddc5VBqag1cx9ruHnnKsEjAY6AKWBPcAXwCgROexjW/WBYUAL1HTxCLAReE9E0nwEbdiwoaxYseKc4xs2bMjQXIqRexg4cCA9e/akffv2fm335MmTlCtXjlWrVpmrbiYRgaNHYedO/Z4ELeQaHq7zTFlVvNX+/6PGVw8/DEuWqG7fOS1QOHkyZOJ345xbKSLnPFH7TSQhIn+TfHXzNHHO1QB+BsoBX6LBpBEwFOjgnGsmIgfT2dY9wKvAYWAWsBsoBVwCXAvk7jESI0sxy/fA5siRxIHpvPM0YypRwoq3ZhknTsCXX8KUKfHFCEuVgltvhVGjoFixLLt1oKj4xqPB6T4ROTvR4Jx7BXgAeBq4K61GnHPtgNeA+cANIhKV5LytDTeyHbN8zzzR0bBvn24AISEqcg0Ls8CUZSxYoDbBy5erNPL889UuuEMHaJE9UoMcD1Ce7KkdsB14I8npJ4FBQF/n3EMicjyN5l4ETgI3Jw1OACISk/keG4ZvmOV7xjl8GP7+W4UPIpopVagAyWh/DH9w6hT85z8wdaqmq6Bjp/fcoz4jfi6llRY+3805Vw5oCJQEki0Kkp55ngR456vmiUiiQl0iEuWc+wkNYE2ABan06xLgMnTe6pBzrjXQADVQXA0sTNq+YRiBhQgcOqSisBMndJoDoHhxqFLFCrdmGXPmwLff6jDe4cMaiNq2heeegxysp5nuAOUZHnsTuJWU1X8ODQi+BKhantfNKZz/Ew1QEaQSoIArPK/7UTVh0hx0jXOuh4j85UPfziEuLi7d0lfDMFJHROvhRUXpw/vRo/HzSwUK6BBe1aoqgsjZfubBtVF792pWNGOGrmYODobrr4devaBLl2zPlpLDlx78F7gN2AJMA/4GYv3Qh+Ke16MpnPceT76CZzzlPK8DUGFEJ+BHoDzwBNAHmOWcu1REopO+2Tk3CB1OpEqVKsneoGjRouzevZvy5csTHByc4noZwzBSJiZGH9IPHYqv8gAakIoVg5IltchKSEjO9tOLiHDw4EEK53SU9AciMGsWDBsG3jJRhQqpd/3LL0ONGjnbvyT4EqBuRrOceiJyMov6kxm8aU0QcJOILPXsRzrnbgVqo0OT1wPTk75ZRN4G3gaVmSd3g0qVKnHgwAF27NhBbKw/YrNh5H1E1K3WOc2WIiPjg5LXWr1oUc2SYmJ081MVJr9RuHDh3G2WuXUrTJwIX32lpTYAataEhx6CO+7IOm1+JvElQJUDxmdBcPJmSMVTOO89fiSNdrzn9yYIToAuzHLOfYkGqEYkE6DSQ4ECBShXrhzlypVL+2LDyKeIwB9/6HfhZ5/BunXxc0lBQWoE2KwZDBoEl1xiKrwsIy4Oxo2DsWO1xAbomqU334TrroNc8D3mS4DaCWSF4N1bjjil5dvehSMpzVElbSelQOZd7BsgAweGkXfYvVuLsO7ZA6NHw8cfx58rXBiuugpuvx06d9YhPCML2bcPhg6Fzz/XdBT0SeCxxyADhZFzEl8C1PvAEOdccRFJab4oIyz0vLZzzhVIqLRzzoUBzYATwC9ptPMLcByo5pwrmowk/RLP6zY/9Nkw8jXHj8MPP8Ds2fD117p4tnRprSIOukapWzf9Pmzc2EwAs5zoaHj+eV2zNGeOWgUXKwb9+8Mzz+ikXi7ElwD1HHA58J1z7mFgpYhEZrYDIrLFOTcPVeoNARJWBB0FFAXeShhwnHO1Pe/dmKCdE86594D7gDHOuQc9Rlg45y4F+qOijs8y22fDyG+cOaOihrJlYcMGHaZLOA1bsKDWv+vVC669NsNOMYavLF2qi2d//FH/SKGhmj0NGJCp0kOBgi8ByrvI1QHfwbn2CR5ERHzVJ96Nljp6zTnXBtgANEbXSG0GknoibEjQl4Q8jsrL7weaetZQlQd6AIWB+0XE3MgMIx1s3Qrz58O8efpavrzKvn/7Tc+XKwfdu+vWqlXgqO7yPDExOrl3333xVcRLl9bSQ6NHa5DKI/gSSJaga5z8jieLakh8sdhr0WKxr+JDsVgRiXTOXQUMB3oC96CVJX4EXhKReVnRf8PICxw/Hl+hoXt3Lb8GKvCKi1NlXfPmunazc2e4+GITOGQr8+er6OHXX2H/fp3ca94cnn1WX/MgfqtmnpdIqZq5YeQloqPhl1/0e2/+fPj9d3jiCc2YFi/WoFS8OHTqpAGpfXutEWpkI4cOwciR8OGHuooZ9A8yeLD+QQJgMa0/yPJq5oZhBDYiGnSCguCTT3Sa4tgxzYIKFdK1So89Bpdeqo4KnTurwCGPfAfmLv74Q/8Ys2frH65gQWjXTtNXjwFofsD+6RlGHmb/fvjuu/gsafRo/b6bNk1LC4EGp2uu0QfzTp205p2RA/zzjwoeli9XJUpwsKpN7rtPhQ/58EnBl1p8T6TjsjggEhUx/JBcSSHDMLKeAwc06Pz+u+4XLqzbgAG6X7myFhDo1Alat9Y1TEYOEBcHkybBiy/Glx4qVQr+9z/o21fFD/kYX0LyUyQWSSScHk16XICDzrl7RSTBkj3DMPxJXJwGIa/armZNXQ6zcKG6JRQtquKH06e1iIB3PskqOOQwhw6ppcWIEfF1nSIitEbegAEBW3oou/ElQLVGHW69rrQ/AvtQGfdVQF/UwfZDoD5wLzDVOfePiCzxZ6cNw1Dbng8+gH//1f3wcNi2Dd59V9colSgBXbtqUOrQId8/jOc8cXHw2mvwxhvxtsBVq+qK5ueeU2tgIxG+BKiqQFvgChFZk+TcZOfc68BPwEwRGeGc+whYCQxDJeqGYWSAyEit2jB/PqxcCUuWaADas0cLBDinc01790KdOlr/s1MnaNo0X05bBB5r1qjqZMGC+NJDN94Ijz4KdevmbN8CHF/++T4AfJJMcAJARH53zn0KPAhMFZE1zrlZaKkiwzB8ZN48+O9/VQoeG6tzSBdeqFnRDz/oyNB558HVV8cLHKpVy+leG4BWdZg7Vy0svv9ejxUvDjfdpKWHTK+fLnwJULWA2Wlc8w/QK8H+n6gvk2EYKSACW7bEV2wYPhwaNdLvuIMHVer977+weTOsXateSrfcogHp6qvN/jyg+OknlYevXq2pb5kyWrp9xAjo2DGne5fr8CVARQFN07jmSiChk0tRz/sMw0jCwYMajObPj3dDqFIFZs5UR4TZs7UwtXPQpAmMGaMCh8suM4FDQHHsGIwaBe+/H196qEIFeO89TXcLFcrR7uVmfAlQs4FbnXPPAE8nKd5aFBiJ1sFLaPd+CbDdD/00jFzN6dPw888ajCpVgrvv1pJps2bpvFGDBjqntGyZzpcXL67CBq/AoWzZnP4Exjls3qyKlNdfVyfGoCBo0QKefjrPlh7KbnwJUMNRJd8jwF3OuT+IV/Fdhlqy7wQeA3DOVQAuBN70Z4cNIzfxzjuaEf3wA5w4od9hffvqtMQ33+jw3Pz5eu1FF8EDD2hQuvJKXadpBBiHDulw3fTpWnooKAhattTANHy4ZUt+xqdafM65sqjtxk0kNv47CXwMPCoi+/3awxzAavEZGWHPHq3a8Mcfuu4S4Prrdd6oWTOtBL59u65RiorS77LWrXXYrlMnqF49R7tvpMYnn+gY69q18aWH+vZVwUN4eE73Ltfjl1p8IvIvMMA5dxcqmiiOVo7YKCIxqb7ZMPIgv/8OkydrFrTGo28tU0YVxNu3a8XvXbu0WADA+eerkKtTJ2jTJk85I+Q9IiPho4/g7bdV3w+6bum++3QzDX+Wk6HfsCcYrfVzXwwjoImLg1WrNBj17q2S7t9/13WXzZvrPHnRorB+vRZc3bNHxQyNGqlcvFMnXfZiAocAJi4OJk6EF15QaWVcnJbduPtuHX+98MKc7mG+wh4BDCMVoqLg449VAr5ggU5BgKrtqlVTccOYMXr+6ae1OECxYuqE0KmTKovLlcvRj2Ckhy1btDTH7NmqaAEtPfTWWzrHZE8VOUKKAco59z1aU6+fiOzy7KcHEZE2fumdYWQzR4/qHFFoqBZbjY6GQYNUNdyli84ZhYWpIm/MGNi4Ud9Xqxbce68GpebNTeCQK4iN1aeODz6ATz/V/aJF1bf+ued0PNbIUVLLoFqhAapIgv30YA6IRq7il1/g2281C1q2TBfIdu6sAap0aT2/YYNKwocO1SBWqJA+WA8erEGpRo2c/hRGulm9WicJFyyIL1o4cKA+ffTqlfb7jWwjxQAlIgVS2zeM3EpUlH43de+u+w8/rAUAGjbU761rrlH7iTFjVAq+bJkKt8LD4YYbNCBdc41mUkYu4cwZHYN9802dHARdbDZggP6hQ0JSf7+RI9gclJFv2L8/vpj0sWNaMig0VEVaoaEq1Jo1C/r0gd279T1XXAFPPaVBqV49c0HIdaxaBV98oTLKXbviVSujR+tEoRHQ+CVAOedKAtEJq0sYRqDwzz/68Dxxos5/9+ihWdO//2p1mm++gUWL9FxYmDprd+6sAofy5XO694bPHDsGTz6pc0sHD+qxDh3giSdUfmna/lyDL466bYD2wLMicthzrBzwKdAciHXOvSEiD2ZJTw3DR06f1mrf0dEaiPr0UbXw0qU6srPWs1AiIkKPd+oEV11lxQByLT/9BPffr6mwSHyVh1degfr1c7p3RgbwJYO6F7hERB5OcOwl1KzwLyAUGOqc+0VEPvFjHw0j3YhoNvT88/r9NGuWysFXrNAH6jZtdGivYUN11e7USV1ojVzKwYP6h/3iCzXKAlXf3XmnTija00auxpcAdTnwg3fHORcC3ADMF5H2zrkwYA1wF2AByshWzpyBL79UdfDy5br26IEH9OexY7VSTVwcXHedHr/ySlvakqv5+GMdt/WW77jwQv3j9+hhTxx5CF8CVDnU78lLY6Aw8D6AiEQ5574BrvNb7wwjnYwfr9VnatRQEUTJknps+HCdV7r3Xt2s3l0uJjJSJw+nTNHKu6Dp8dChutkTR57DlwB1msQFYq9C1zwtTnAsEjCrSCPLiYxU9V3t2ipo6NNH574PH4aXXoJt2/S763//g9tv1+oORi4kLk4tLX78EWbM0MBUuLBW4X3+eVuAlsfxJUBtA65OsH898KeI7E5wrDJwwB8dM4zk2LcPXn1Vs6OjR2HIEC2V9tpr6g8XGamVw198Udc5BQXldI8Nn4iJgcWLVVr5yy/w22+qdilUCG69FW67Td0bTe+fL/AlQH0AjHXO/QpEA5cCo5JccxmwyU99M4xEPPusFmSNjtYH6A4dtAJEjRr6fdWzp84vXXFFTvfUSJOYGDX8+/13rS0FGoiWLIm3FwYdn73xRv3jW+mhfIcvAWoC0AS4EXDA18Dz3pPOuUvQoPVERjrinKsEjAY6AKWBPcAXwCivrD0DbbYAFgIFUBfgkRlpx8g5fvtNZeBFi6oTbZ8+6kD70UdanaZECa3xec89et4IMOLidLz1+HH1qt+7V7X8W7fquYSULw9Nm+r59u117LZ48ZzptxEQpDtAeSw2bvZ4QYmIRCW5ZC9QjwxYvDvnagA/o0KML4GNQCNgKNDBOddMRA762GYYmvWdQCXwRi5BRB1nn39erS1efVW94fbsgblzdSivZk0VQ/Trp8HLCCAmTtRMaM0aXWx2+rTKKosW1WAFKmi44AKt6tCxozrSVq1qQgcjET5XkhCRyBSOHyDj80/j0eB0n4iM8x50zr0CPAA8jcrXfeFV1FDxWc/7jQBHROfBn39e1y2VLw/Dhun3XOXK+hDeujVMmADXXmvTEDnGoUPxwce7nTwJX3+tq6CfflrLCsXGxmdJcXG6WPbuuzVLql/f6t8ZaZJuy3dPOaMKwBYROZ3g+G1Ad+A4MFZElvnUAc2e/kIzrxoiEpfgXBg61OeAcuktpeSc64YOD/ZFg/AkfBjiM8v37CUuLj7YtGihmVLXrmplMWeOWlf07q1FAurWzdm+5iuiotR9ce1afX3xRf1DDRoE77yj14SEqHzy5EktMQT6B2vQQANRkyb6WqmSZUdGivjD8v0ZoA+a6XgbvRcYiwYQgO7OuYYist6Hdlt7XuclDE5wdm3VT0A7dP5rQVqNecovvQN8ISJTnXP9feiLkY1ERqof3IQJ6q9UqpRWC584UavTlCkDI0fqQ3d4eE73Ng9z6pQ+DUREaBn36dPhsccSixVCQnRc9c8/4ddfNQjFxGhgKlNGU1tvMKpXT2tMGUYm8SVANQMWiMjJBMeGAbuBm4FwYDLwIDDQh3ZreV43p3D+TzRARZCOAIUGpwL4PiRoZBN79+q80oQJKhVv2VJFWp98oucuvlgf0G+5xUaBsoRt22DyZM2M1qzRoBMXBz/8oClsiRJamaF2bX2K2LJF9f2DB2vgadhQF8Y2aaJbxYo5/YmMPIovAaoiCQKEc+5idN3TIyLyo+dYT6CFj33wynSOpnDee7xEWg05524HugI3isg+XzrhnBsEDAKoUqWKL281fODQIZWFnzypVcNDQlQq/sMPKtx6/309bqNBmUAEdu5MPEe0di2MGKEp6v79qte/8EJdROa1nZg6VSWRv/2m2RHoauerr47Pji6/3OrbGdmGLwEqBDiVYL8ZWkniuwTHtgCd/dAvn3HOVUOHGz/NSLFaEXkbeBt0DsqvncvnrFypS12GDdMSRAMHqk3P3LlaFKBvX51fuvjinO5pLkNEM5u1a2HdOs142rdXM6tq1eKvq1xZA1FoqFZiOHFC/ZBWrVJRw8yZel1IiC4ie/DB+OzIxlaNHMSXALUbqJ1gvz1a2uj3BMdKAgmHANODN0NKacGD9/iRNNqZ6Ln33T7e38gCvFLx556D777TUaPgYC1PtH69fu/9979adLps2ZzubS7g8GE4ckSLCYpA27ZqXX4wweqLwYM1QFWsqGOkF12k0u516zQQjRypC2NjY/X6GjXUGtgrZrj0Uv0jGUaA4EuAWgj0c87dg2ZSXYEZSYQNNYC/feyDt/JERArnvaWJU5qj8lIfDWb/uuTHh0Y450YAX4pIdx/7aPjA2rVakWbFCl3+0qaNjhp5VXgffKDFAWwePRU++0xL/XiH53bv1mAyf76Of5Yrp5W7L7kkfitSRL1Gli7V944YocN5oIGqUSMtturNjuzJwAhwfJGZVwdWoHNBDjgGXCEimzzni6GLdSeJyJB0d8BPMnPn3GtAkWRO1UTnxVYDK4HfROSN1PpkMnPfOXVK5eHVq8OBA1oPr3RpDVKxsdCli5YhatnS5pcArde0eXPiOaLTp1VXD5ohLVmi457eANSwoc4HgWZRf/6pgcgbkP74I37dUa1a8fNGTZro+60woRGgZFpmLiLbnHN1UA8ogK9EZGeCSy4E3gI+9KVjIrLFOTcPVeoNAcYlOD0KKAq8lTA4Oedqe967MUE79yXXvkdm3gKYZaWO/M/Ro/Dmm+q5VKWKPrSPHavfvUWK6JKZoUPzsUXPmTOqmlu7FjZsUBM95+Cuu2DSJL0mKEgl3nXrauBxTms5lSgRH1QiI9XcasyY+IB06JCeCwuDxo31l9+kif5cunTOfF7D8CPpzqDS3aBzZTxVJXx5T9JSRxtQv6nW6NDelQlLHTnnBEBE0nwW9wQoW6jrZ/bsiZeKR0bq/PyxY1pAoFIl9V664w4VReQLRHQYrmxZHbucMUO18+vXq2TRy65dOke0ZAn8/bdmNrVqJR7vjIuDTZsSZ0dr1+o9QLOqhNnRRRdZdmTkavyxUDetG7RBZdpdSewblSaeLKoh8cVir0WH9l4lE8Vijaxj5kwtLBARod+bGzfqFMeLL2ql8Tw/175rl9qMJxyiO3pUA0qTJirFLl1ahQuXXKIVbi++WJV0oAVRvRw5ojp7bzD65Rc9BppFNW6sv9SmTfWXXCLNFReGkSfIVAblqdpwOzAAuACdKzoqIrn6udkyqHNZuVJr5F1zjRYKePFF+PxzDU49euj8UtOmeWx+KTJSFXDr1sUHoYce0uKmixfrhFrJkomFCt27p24LERenWVXC7GjDhvihvUsuSZwd1aplRQeNPI9fMyjnXHvgDqCLpw0H/Ai8C3yaiX4aAYQILFigUvEFC3ROacUKnVIJC1OL9Txho37ypKaAa9dqhe1mzbTMT8IPVrSoZkHR0brfuDH884/q5VOLyocOaWmgpUt1W7ZMAx9obaemTbXQYNOmugbJrH8N4yzpDlDOuQrEZ0tV0aC0Fy1xNElEBmRJD40c44471NqiWDFNFA57BlrzhI16XBzcdJOuC/rrr3j12x13aICqUkXnkOrU0aymatXEmcx550GFConbPHNGg1zC7GiTZxVFgQLqh3TzzfHZUc2aeSzlNAz/kmqAcrqgqCM6t3St5/po4HPgfWCuZ/9MlvbSyBZOndI1Sj16qLXF4cP6PRwZCc2b6zBet265cD7+zBmtRvv556p5HzdOA8aRIxp8bropfojuwgv1PQUKqOIuNf79N37OaOlSVdl5K3qXLauBqF8/fW3YMH7+yTCMdJFWBrUdqIRmSyvRoPRhQtFCCotijVzE0aOqxhs7VivnvPmmLqnJ9TbqP/2kEffLL3XBaqFCOkfkne+ZNy/9bcXG6i8lYXb01196LihIJeLeYNS0qQ4P2v8Nw8gUaQWoykAc8BwwOqEPlJH7EYHhw2H8eLX+8Q7Zbd+eS23Ujx/XAn+dOmnq9+23ah3RqRNcd52KG9I7LrlvX3wgWrpUJ99OnNBz4eEahO64Q18bNNAJOsMw/EqqKj7n3HzAs3SdSOAj4H0R+TXBNXHAuyIyKCs7mp3kdRXfvn3qVnv4sKqdt25VnUDNmlqOKFfZqB8+DN98o8N3c+fqB5k1Sy13jxzRarSFC6feRnS0zkV5g9HSpfFeSMHBKltMaL5XpYplR4bhRzKk4hORtp4SR4OAfsCdwCDn3CZ08evUrOiskTUsX65S8S+/hF69dBnPiRNaPeeBB3KRjbrXgnfDBhUexMbq4tcBA3QCzbvGKKX1QocOxdesW7pUNfSnPIX6K1bUIHTPPfHW5GkFOMMwsgRfavEFAd3QYHUNOi8Vh5oDfgP0FJHoLOpntpKXMigRrSb+/PMqFS9YUL/Pg4PVEPD++9XiJ+DZulVXB3/+uQaNceM0UP33vzp017BhytE1OloD0fz5uq1Yoe8tVCh5a3LDMLIVf9TiO4Oq9z53zlVB10HdBpyPekD945ybArwnImv9020js+zapZmRl2LFNDkYPDiXWP2MG6ce8KtX637durp4FTQgPfnkue8R0cWw3oD0ww86PxUUpOuXHn9cVxxfcYWVVDeMACZDC3U9RWIfd849iS7WvQP1hxoK3JvRdo3Mc/KkCtcWLlTV9PjxmjHVrq1FEALaRj0uTheyzp+v3kXOqSV50aLw8ssqdEhpVfC+fZoqzpunr//8o8dr1oT+/bU6eKtWUDwl2zHDMAINvxWLdc5VAgYCt4lIVb80mkPkxiG+I0dUKv7SSzrF4pwmEh066PxS27YBOq8fE6Nlg2bO1O2ff3Qccv16DS7e+aaknDihBVe9WdIff+jx0qXVgKptW92q5up/ioaRL8jyYrEisgt4yjk3yl9tGulj8WKdhvGqoIODNWkIWBv1U6d0XqhYMfU/6tZN07qOHTVL6tw5XuDgDU5xcTrMN3++Zkk//aT+SYUK6SriZ5/VgFSvXi5RehiGkRZ+H4oTf/t3GMmyaZO6NWzbBq+8osGpdGkNSnfdBWXK5HQPkxAZCbNnq8hh9mx45BGdC2rbVq0pOnQ4dy3Rzp3xGdKCBeqECGpNPmQItGunij1bg2QYeRKbK8plLFsGo0bpd3xQkFbxCWgbdRG44QZdqxQdrQuw+vRRkQJo5tSjh/4cGany73nzNCht3qzHK1RQpUfbtvq+XKHuMAwjs1iAyiX8/LNmR8uXxx+75hotFxdQNup//61zSZs2wRtvaMfKlVPpYI8eKuf2FvOLjY0XRcyfrwtlz5zRjKhlS00F27XTccqA+YCGYWQXFqACmNhYTToWLNARsQ0bdMqlf38YNiyAbNS3bVOL8pkz4yPoJZeopDAkRNUboNnUX3/FZ0gLF2rW5JyuY3rkEc2SmjYNwFTQMIzsxgJUAHLyJLz1Fjz9tH6nHzyoBQ6eflrXL+W4jboIrFql3kklS2qJocceU7fX555ToUNEhF578KBGWG+WtGOHHq9WTauIt22rpSxKlcqxj2MYRmBiASqAOHxYxWhvvBGvyIuIgNdfDwAb9TNnVDnnreawcye8/bYWTO3dWwuyVq6syrqff4ZJkzQgrVqlAa14cQ1E3iypRg0btjMMI1UsQAUIy5bpFM3u3brfsqVmTFdeGQDf45GROp64f78OvbVrB089BV27avBJqLZbvFija8GCOlQ3apQGpIYN9ZhhGEY68ds3hnMuBLgCQEQW+6vdvMzatTB0qC6yXbVKCyb07QujR+sIWI5w/LjaVHz+uYoZJk/W9Uq3365rjDp2VFO++fNVtfHdd7B3r763dm0t2Oqt2hAWlkMfwjCMvIA/H2mrAIvQArL2qJwKCxZodYc1a3S/XDk1C7ztthy0UZ81C955R+eTTp3SRVU33qjnjh+HFi00KI0eDevW6fGyZVVK6JV/V66cQ503DCMv4s9AcgJYGFIJGQAAHaNJREFUDNhC3RTYskWnYXbu1P3KlXUE7NZbc8BGfc8e9d3o10+VdsuXq+3EHXdoZYciRVRl17q1zilFR+vw3lVXaYfbttUy6Fa1wTCMLMKfpY7+Blr5q728QkyMih6WLFH/JREdKfvf/3SeKVvZsiVe5PDLL9qZ6tWhfXtV1J1/vmZJvXppQT/QVcBDh2pAat48gCvNGoaR17ChuCzi6FH9Xp8+XZOPsDB4+GGt0JNtlkMiOlwXEqKOsXXr6vF69VQWXrasRs177tH1SaB69m7dNCC1aaPjj4ZhGDmABSg/s3MnDByo80xxcWrGeued8OKL2aQZiIuDX3+Nz5SuuQbefBMuukgnvmJjdTjv2Wf12tBQFTTce68Gpdq1A0A2aBiG4UOAcs61SMdlcUAk8KeInMxwr3IxPXuqZLx0afjPf7TiQ7bNLz3xBLz7rs4vBQerOd+pUyoHX7QIoqJ0zqhRIxgxQgNS48ZansIwDCPA8CWDWkT6BRBnnHNzgWEissnnXuViXn5Zk5RWrbL4RidPxlf5HjtWs579+1V5UbOmzjf9+KNuNWqoU2Hbtip6yPFSFIZhGGnjS4Aaja5z6ghsBn4G9gHlgSuBCGA2sA2oD3QCmjrnrhCRbWk17jE8HA10AEoDe4AvgFEicjgd7y8KdPfctz5QGc3oNgHTgXEiEu3D580QzZtnYeORkSoH//xz9VE6flyH6E6f1rTtt9/0upIlE5v2peRCaxiGEcCk21HXOdcEWIjaur+T0PfJOeeAO4FXgNYi8qtzrj8wEXhPRO5Io+0aaMArB3wJbAQaAa3RANNMRA6m0UYHYA5wyNPPv4CSQFcg3NN+GxE5ldZnDShH3f37NTvyChquu04ns4oXV5vzmBgdzrvyyviA1KBBDujWDcMwMkZKjrq+BKj5wAkR6ZbKNV8B54lIe8/+YqCKiFRLo+25QDvgPhEZl+D4K8ADwFsiclcabdQF6gCfJsyUnHNh6PBkfXTI8eXU2oEACFA7d8ZboC9ZAl26aJmJ+fPh33/1mjp14gNSixaaSRmGYeRC/BGgjqLDZCNTuWYMcK+IFPfsvwrcKSKFU3lPDTTb2Q7UEJG4BOfC0KE+B5QTkePp6uy597gZmAZ8IyJd0ro+xwKUiI4R/vyz7p93ng7fgRr9XXON1sG75hpds2QYhpEHSClA+TIH5YAL0rimRpL9WOB0Gu9p7XmdlzA4AYhIlHPuJzS7agIsSGdfkxKToD+BgYhWbpgxQ1+9pYSWLtXz552nSgtvlnTppSb/NgwjX+FLgPoFuN45105E5iU96ZkDuh6d//FyIbA3jXZreV43p3D+TzRARZDxAHW75/XbDL7ff/z+u6ruvvoqvloDaHCqXz/ejuLKK3URlWEYRj7FlwA1Aq21N8c59z3wE/EqvuZoJnQaGAngnCsOtAWmptFucc/r0RTOe4+X8KGvZ3HO3YMqA1ejoo2UrhsEDAKoUqVKRm6VPKdPa827Y8dUaffZZ2riB2rS17GjzjG1aQNlyvjvvoZhGLmcdAcoEVnunGsPvAe08WyCDv0BbAEGiojH85tooB4axHIE51wPYCyaxV0vIjEpXSsibwNvg85BZerGhw7BuHHw6aewcaOa/YGWKr/qKl2L1KWLrleyYTvDMIxk8anUkYgsds5FoOue6qHZTyTwG/BTQum5p5JEehbpejOk4imc9x4/4ktfnXPdgY+A/aj0fasv788wt9+ubrJeypVTUcPAgSqAyFFbXMMwjNyDz7X4PEHoJ8/mD7xBLCKF8zU9rynNUZ2Dc64n8CGaOV0tIn9mvHs+csEFOn/UsSMMHqw1jwzDMAyf8UVm/gIwSUQ2+LUDfpaZO+duAT4AdpPBzCnH10EZhmHkI1KSmfviNjcMWOucW+acG+KcK+WPjonIFmAeUA0YkuT0KKAoMCVhcHLO1XbO1U7alnOuHzAZ2Am0yLZhPcMwDMPv+JJB3Qj0Q5V5BdC1Rd+g2cpsETmT4U6cW+poA9AYVQZuBq5MWOrIOScAIuISHGsNfOfp20Tg72RudURExqbVH8ugDMMwso9MV5JI0FB5oC8arOqgSr4DaKWGySKyOoMdrMy5xWJnkkyx2BQCVH9gEqmzI62yS2AByjAMIzvxW4BK0mg9oD/QGyiDBqs1IlI3w40GABagDMMwsg9/zEGdg4j8JiJDgfOB/6ClhC7NTJuGYRiGAZm0fPdUi/DOTTVB1XYpVYQwDMMwjHTjc4ByzhUA2qNBqStwHjq0twAVTHzuzw4ahmEY+ZN0Byjn3KXArcAtaP09hyrsJqPiiF1Z0kPDMAwjX+JLBvW75/Uo8C7wvogs9X+XDMMwDMO3ADUPeB+YKSLJejx5hv+6iMiXfuibYRiGkY/xpZp5h5TOOeeqAgOB24AKQFDmu2YYhmHkZzKs4nPOBQHdUA+la1DJuqDVHAzDMAwjU2RExXcBcAe6QLec5/AB4C3gPRHZ4bfeGYZhGPmWdAUo51xB4Do0W2qNZkvRqKT8euBLEXkiqzppGIZh5D9SDVDOuZpottQPLWXkgJWoWOJDETnsnItLuQXDMAzDyBhpZVCb0HmlfcArqLR8XZb3yjAMw8j3pKcWnwBzgBkWnAzDMIzsIq0A9Thq/ncb8JNzbr1z7mHnXIWs75phGIaRn0k1QInI0yJyAdAR9WaqATwH7HTOzXLO9cqGPhqGYRj5kHTZbYjIXBG5AagMPAbsQIPWdHQIsK5zrkGW9dIwDMPId/jkByUi+0XkORG5ELV+/wy1fm8ILHPO/eacG5IF/TQMwzDyGRk2LBSRBSJyI1AJeBj4E7gceM1PfTMMwzDyMZly1AUQkQMi8pKI1AauRof9DMMwDCNTZMpRNykisghY5M82DcMwjPxJpjMowzAMw8gKLEAZhmEYAYkFKMMwDCMgsQBlGIZhBCQWoAzDMIyAxAKUYRiGEZBYgDIMwzACkoAJUM65Ss65ic65f5xzp51z251zY51zJX1s5//tnXu8VVW1x78/wEDFC4Iv7CGEoqaZGho+UjCflVc/+UoTxQo0M/WmN8s00fJVKZpdyxdCXM0sRPMmkiFo+IhQNE1NUI5iPggJfKGJjPvHmBs2i7X22efsfc7e5Ph+PvuzPnvOucYca8615lhrzjHn7JPOa0lyXkxyP9RRugdBEAT1p64TdduLpIHA/cBGwG3AU8DOwCnA/pJ2M7NXq5DTN8kZBNwN3ARshW8X8jlJu5jZsx1zFUEQBEE9aZYvqCtx43SymR1sZt82s72AMcCWwPlVyrkAN06XmtlnkpyDcUO3UconCIIgWAOQmTVWAf96mgu0AAPNbHlZ3HrAS4CAjczszQpyegILgOVAPzN7vSyuC/AssFnKo+JX1ODBg23WrFntvqYgCIKgeiQ9ZGaDs+HN8AU1LB1/X26cAJKRuQ9YBxjSipwhwNrAfeXGKclZDkzJ5BcEQRA0Mc1goLZMx6cL4uek46BOkhMEQRA0Ac3gJNErHZcUxJfCe3ekHEmjgFHp7xuS/tZKfpXYAFhYw/lB5xD11PxEHa0Z1FpPm+UFNoOBagrM7Grg6nrIkjQrrz81aC6inpqfqKM1g46qp2bo4it92fQqiC+FL+4kOUEQBEET0AwGqtSVVjQ2tEU6Fo0t1VtOEARB0AQ0g4Galo77JnfwFSQ3892At4AHW5HzILAU2C2dVy6nC7BvJr+OpC5dhUGHE/XU/EQdrRl0SD013ECZ2TPA74H+wNcz0ecC6wITyudASdpK0lYZOW8AE1L60Rk5JyX5UzpjJYk0nhU0OVFPzU/U0ZpBR9VTwyfqQu5SR08Cn8LnLD0N7Fq+1JEkAzAzZeRklzqaCWwNHIRP4t01GcQgCIKgyWkKAwUg6cPAecD+QF98BYlJwLlm9s9M2lwDleL6AOcABwP9gFeBycD3zOyFjryGIAiCoH40jYEKgiAIgnIaPga1piOpr6SvSpokaa6kpZKWSJoh6StZx4+gcUi6WNJUSfNTPS2SNFvSOal7OGhCJB0tydLvq43WJ4C0nZEV/F6uWz7xBVUbkk4AfoZ3SU4Dngc2Br6Az72aCBxmUdANR9K/gIeBJ/AxyXXxNRwHAy8CQ8xsfuM0DLKkrv/HgK5AT2CkmV3bWK0CSS34qjyX5US/YWY/rks+0W7WhqS98Ibud5mV2DfBnTQ+DBxqZhMbpGKQkNTDzN7OCT8fOBP4mZmd2PmaBXlIEnAXMAC4BTidMFBNQTJQmFn/jswnup9qxMzuNrPbc1Zifxn4efo7tNMVC1Yjzzglbk7HLQrig8ZwMrAXvuFo4VY7wb8vsRZfx/JuOi5rqBZBaxyYjn9pqBbBCiRtDVwEXG5m96aeiqC56C7paOAj+AvEX4B7zey9emUQBqqDkNQNOCb9vbORugSrIul0fDyjFz7+tDv+cF3USL0CJz07E/Dx3DMbrE5QzCZ4PZUzT9JxZnZPPTIIA9VxXARsC9xhZlNaSxx0Kqfjjiwl7gRGmNk/GqRPsCrfA3YAdjezpY1WJsjleuCPwF+B14GP4iv2jAImS9rFzB6tNZMYg+oAJJ0MnAY8BQxvsDpBBjPbJE3y3gT3tvwoMFvSjo3VLJD0Kfyr6RIze6DR+gT5mNm5afz9FTN7y8weN7MTgEvxnc1H1yOfMFB1RtJJwOW4K/MwM1vUYJWCAtLDNQlfSLgv8IsGq/S+JnXt/QJf3uzsBqsTtI+SY9ge9RAWbuZ1RNKpwBjgceAzZragwSoFVSJpNrA9sKGZxQ6uDUBSb+CfrSZ0LjezUztSn6DtSOqF77n3jpn1qFVejEHVCUln4ONOjwD7RCO3xrFpOtbNAyloM+8A1xXE7YiPS83A936L7r/mZEg61mXXiDBQdUDS2fhCtw8B+0a3XvMhaRDwipktyYR3Ab6Pr6R/f3Zh4qDzSA4RuUsZSRqNG6jxMVG3saQpAM+Xb4GUwvsDP01//7ceeYWBqhFJx+LG6T3cq+VknwC/Ci1mNq6TVQtW5bPAhZJmAPPwVe43BvbEnSReBkY2Tr0gWGM4AjhN0r3Ac7gX30Dgc0AP4A6gLksdhYGqnQHp2BUo6hO/BxjXKdoERfwB2Byf87QDvo7Ym/iA/ATgJ/HlGwRVMQ3YEn+OdsOXeluMd79OwDeYrYtzQzhJBEEQBE1JuJkHQRAETUkYqCAIgqApCQMVBEEQNCVhoIIgCIKmJAxUEARB0JSEgQqCIAiakjBQQRAEQVMSBqoDkDRe0gJJ69YgYx1JL0uqy5IhnY2kfSXdL2mxJJN0a6N1er8gabCkuyQtTGX/SFncFpImpXvLJC1O4aPT/6E15j00yRld21V0Dmugvi2SWpopD0n9UxmOq7cusZJEnZG0E74H1OnZtaragpm9JelCYIyky83sz23QYRxwbCb4LXyJn/8DLu7INefSmly34bPLxwKv4XtjBe1E0jrAi/guwL80s6MK0v0H8Dt8yZkJwEJ8GSckdQVuxVfUmAC8ALzd4cp73tOBPdM+XB0hfzRwThtOec7M+neELkH9CANVf87HG+Sf1UHWVfhDdz6+Z1FbuQ1fXR18c74DgTOAQyXt3IFL++yNN5CnmdmNHZTH+40jcONkwBck9TWzV3PS7YwvfPtdM7sgEzcA+BhwjZmNysT9FLgJ32a9FmYCW+OGsTOZnhO2PXAQ8ChumMtZ3NEKBbUTBqqOpBWz9waurcdW1Wb2tqRfAcdL2sLM5rRRxK3li9RKOh34E95IfQM4t1YdCyhtXfFiB8l/PzIKWI4vwvkt/Av50px0lcq+MC5tD1OzUTGzt2jA17KZTSdjpCSNwA3UI2Y2urN1CmonxqDqy5cBAb/KRkj6gKSTJN0h6TlJ70haJOkPkg6oIPOmJPPLtSpnZm8A49PfnZNeK/qPJQ2S9Ks0fra8fDxC0n5J94VJ92ck/ShtMldKM1SSsdLwTUuyLSOrj6QLJT0paamkJZKmSlrtK1HSiHT+CEn7S5qe0ltZmm6STpT0oKTXJL0laXYq7y4ZeeXX21/STema3pY0S9Lni8pP0hFJz0UpfYukX0oanJP2SEnT0hjc2+laz5LUvXIt5ea7Lb7PzlTgYuBfZLalKF0XK+v3+rKyH5Hi7klx55TFjU7n545BpbDpkjaQdLWkl1L9/1XScTm6Ds3ILem1Z5k8K5PbVdL8VG89C67/ipT+0LaWXVuQtL2k36U6e0vSPZJ2zUm3oqwkHSXpT5LeUNm4jXwM+TuSHpH0Zop/QNKROfIk6Vj5mO0/0v0yX9IUSUcU6Lpuev6eT/UxV9IZ0upbKaT0h0u6Nz07SyU9lvSr+n6UtJ6kSyW9kHR8StI36UA7El9Q9WVvfNuNB3Pi+uBbwd8P3AX8A+iHd7vdIWlkwT43M4F3gX2A79RBx9INnF0leCD+dfU0cAOwNt5ViaRzgNHAInwMawGwHXA68FlJu5jZa0ALbpyG4g3S+BRG6ShpM/xNtz++Pcmd+GrInwfulHS8mV2To/ehwP7AZHxb6c2SvLWA24H98I3sbsTHVYYBVwCfwscEs2yGl+2z+HhMH7wb7TZJe5vZtBUF5g/99fhXy0LgFrz+PpTy+Rswqyz9WOA4fIxnIt6dNATfd+ozkvYxs2U5OhVR6o4bZ2aLJN0OHCLp02b2xxS3GC/7UrdWeffuIymuf7qGe1j5tVE6VqI3cB9uGH8DdAcOA8ZKWm5m4yucW9JrBF7m5V/tLWb2nqRrUviRwCp1L2lt4Gh8HO22KnRtL4PxL9MHgGuBjwCHAFMlbW9mf8s55zT8ubwdX+G7V9K5N3A3vtr3w/g4bBf8Hr1R0jZmdlaZnPPxZ3secDOwBG8bdsLLOfvCuxYwBf8ingwsAw7GN0ztQaZnRNIFSf5C/Pl4AzgAuADYT9K+ZvavSoWTDNnUpNOjeBvRGzib9PLRIZhZ/OrwwxvZZcBjBfHdgQ/lhPfCt4hfBKxdcO5s3PCtV6Uu43ADNCIT3hN4IsWdncL6p/8GXJAja1iKux/onYkbkeLGZMJHp/ChOfKm411VX8yE98Yb0qXAxjl5LAf2z5FXyusKoGtZeFd8d1YDDioLL7/eczKy9kvhd2TCR6XwmUCvTFxXoF+Ovrdk67NM11PacF/1SPfG4pI83Jgbvq1BNn0p/xE5cUNT3OgK5Tg0E14qq2sz5fsx/H5/opo8Ur1bwTX2w1/CZlW4nvPb8UyWzh1XIU1J37zn5fgUfmVBWb0J7FDh+ftWTl3eme7l7cvCX8VfZtbJkbVB5n9L6R4tv7/wccfF6bdWWfguKf3zwCZl4d1ww2rAmTl5tGTCzkxpJwJdysIHpPuzYjm391dXYe/nHzAoVdLv23HuN9O5exTET07xW1Upr/SA3JoeptG408bfU/hcYP2Utn8KexnoniNrUorfpiCv2cCCTFjpAR6aCf9ECv91gayDUvyJZWGlRmZSTvou6eF+CeiWE987NQY3l4WVrreFsga3LP45YGEm7LF0zmqNUUF5vEvGmKe4rvhb7Mw23BvDU95XlYV1S9e8tFSPOeU1IkfWUNpnoN4E/iPnnHtSfM/W8qCCgUrxv07nfTIT/gD+cta/Hc9VqSzGVUhT0ndGTtxa5BjOsrIak3NOX9xw/7kgv9Iz8MOysFfxr6fVnr+c81vS+ZvnxI1PcduWhV2TwkblpB+UyvbZnDxaMmFzUtqBFe6dwnJu7y+6+OpH33QsdN+WtA3w38Ae+Ftjj0ySDxacWvK226CNOh2UfuCNWQv+aX6Rre5m/qiZvZMjYxf8IT1M0mE58R8ANlSxV1lWFkAv5c872TAdt86Jm5kTNgjvmpsDnFXQ/b60QN4jZvZeTvj8Mj2Rz2XbFt8ufnZeBmVp18EboIXAqQX6vFOgTxGl7r3rSwFmtkzSDXgX03DgJ22Q1x7mmHfhZpmfjuvj3Ua1cCXejXs86ZolfRzvGp1sZi01ym+NWdkAM3tX0iv49eWRd0/uhL+IFM2tWisdy++BG3CnpSck3Ywb/gfMbElBvkvMbG5OeHl9lNgxHe/OJjazpyW9AAyQ1KsoP0nr4VMT5pvZMzlJptM2F/+qCQNVP0pee1mjA4CkIfhN0g3vy/0tPsaznJXjBkUDlmtn8qiW46z6reZfLgjvi+vc2g3YE38TrETJiO+TfpVkZcnTryRvCyrrlyevyM14GasO+pacQP5eQX6J9fExvg1b0acqJG2N7wD8lJllxzXH4QZqJB1voCqVFXiDXBNmNk3Sk8CRkk4zs9dZaZyvqlV+FVS6xqLrq3RP7pR+RZTfk/+Fj4UeB3w7/ZZJugOfqpE1Rm2pj17p+FLBOS/h42298bGvPEoyXimIL2o7aia8+OrHgnTsWxB/Fm5o9jWzA8zsVDP7nrn7659akV2SuaBiqtqwgvAlwD/NTK38nqsij9IDcEorslbzDivQryRvUivyBlShWxGlxqDo6zZPn9mtlVeVeZca6K0y3m+GdzsCbJvnabaG8nO84f5SmXPE33HHnGak0j05ppV7YNgKIWbvmdllZvYJYGPcOWMS8J+441CbPT9z9NmkIL5fJl0lGRsXxBfJrpkwUPXjJdyza8uC+M2BRebzNbLs2YrsLVk5kNrZPAisn7on6yEL4NN1kAU+32YxMCR589Ud89VAHgc2lrRDK2nfAP4KbCOpTy35pkZpOP6FPRZ3+Mj+pqTkI2vJq5N4D1asZlHEeHzFk1G4R2Vv4LqCrthmZSZeZ+26x81sgZndYmaH4z0uA/Eu5vZS6pYemo2QtDnuiTrPzAonLqev2bnAByUNzEmymux6EQaqTpiPFt4LbJAqPksL0EfSduWBkr6Ce4/lImkA/uYyPeXR2YxJx2skbZqNTPMxhlQjyMxm4a7lX5CUO69L0sclbVSlvGW4914/4CfprTsrr5+kj1UjrwKlLrSrJPUqj5DURVK/sqBL8XG5sSqbI1aWfn1JO2bDczgE/3KeYmZfMbOvZn/A4bgDw+FZvZqQUvfvR4oSpDGQG3H37B/gRi1vykHTYmYL8DGlwZLOzjPIkgam5xpJ3SXtlpNmLXx8Fdxot5ex6XiWpNIYb+lF4ce4DbiuCjnXp7QXq2xuYbqOk2vQryIxBlVfJuINy374G0c5l6XwGWkgdAk+92J3fG5J0STE0uTViXXXtgrMbKqkbwMXAnNSv/g8vCtmM/zrbwY+R6kajsLfDK+TdDLevbkYf5PbDn9b3IXquzO/jzsmnAAcKOluvFtoI3xsajfgu7h7fXu5Fn8jHo6XwW341/KmwF54IzAawMzGSvokcCLwjKQpuItvH9wldw/8YT+hlTxL3Xt5c+NIeb0m6de4t9rRwP+049o6i6n4nJ5b0j20FF8Pb0Im3ZX4JOQPArebWSN6DWrlJPzeOw8YLmkGPn6zKe4csRM+52se3u0/Q9Jc4CHci7QHPka7NfBbM3uyvYqY2f2SfojP8Xpc0m/wl5oD8GdtBvCjKkRdgs+1OgR4ON3XvfGXpHvx7si6EwaqvkzEG9ZjyDQWZnanpAPxsagj8LfDmfg8o49SbKCOxRvDhhgoADO7WNJ9+JvS7rhDxxLcEFyNv/VWK+uF1IB/A7/Zv4QP6r6MG5ErWDm+Uo28dyUdjDfQI/A5Qj3xMpuHTyS8oVp5BXkYcEx6KEfhD2V3vFv3j7jDS3n6r0uajBuhvfEHeRFuqH4EVFyhXr5k1p54o3Z7K+pdg1/3SJrbQF2Lv9B8EW8su+HeaqsYKDObLV99fXs6xzmi7qQXhz3xe+Uo/D7vgdfnHNwp4q6U/E18fcxhwK64EXgdeAb4Giu/gGrR5wxJs3HDeQzuSfgM3hZdYq1M0k0y3pG0N/4idgRwCt4r9ANWjpfVHTWm1+jfF0nfwWdo79iaW3IVsrbDZ22fbWY/qId+QdDMJJfmF3GDPsDMljdYpaCBxBhU/RmDvymfVwdZ5+FzGy6pg6wgWBP4Gv4FfGUYpyC6+OqM+Qrkw4Fhkta1du4JlSZ9zgYuszqsjB4EzUpy8PgaPu40Eu86vbKhSgVNQXTxBUHQUOQbXM7DV9l4CPiGmT3cSJ2C5iAMVBAEQdCUxBhUEARB0JSEgQqCIAiakjBQQRAEQVMSBioIgiBoSsJABUEQBE3J/wOt3mltMCkApgAAAABJRU5ErkJggg==\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "from random import choices\n",
        "import matplotlib.pyplot as plt\n",
        "import copy\n",
        "import math\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "retp1 = []\n",
        "retp2 = []\n",
        "\n",
        "for l in range(100):\n",
        "  for percent in np.arange (0.0, 1.1, 0.1):\n",
        "        G, n, m, cost, attributes, days = load_one_student_per_room(2, 5, 3, percent)\n",
        "        agents, resources, G, ret = run_for_parameters(G, n, m, days)\n",
        "        total = 0\n",
        "        for agent in days:\n",
        "                total += days[agent][0]\n",
        "        v =0\n",
        "        for st in ret:\n",
        "          v+=len(st)\n",
        "        v /= total\n",
        "        \n",
        "        retp1.append((percent,v))\n",
        "\n",
        "        G, n, m, cost, attributes, days = load_one_student_per_room(2, 3, 3, percent)\n",
        "        agents, resources, G, ret = run_for_parameters(G, n, m, days)\n",
        "        total = 0\n",
        "        for agent in days:\n",
        "                total += days[agent][0]\n",
        "        v =0\n",
        "        for st in ret:\n",
        "          v+=len(st)\n",
        "        v /= total\n",
        "        \n",
        "        retp2.append((percent,v))\n",
        "\n",
        "df1 = pd.DataFrame(retp1, columns =['percent',  'avg'])\n",
        "df2 = pd.DataFrame(retp2, columns =['percent',  'avg'])\n",
        "\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "from matplotlib.ticker import MaxNLocator\n",
        "\n",
        "fig, ax = plt.subplots()\n",
        "ax.xaxis.set_major_locator(MaxNLocator(integer=True))\n",
        "ax1 = sns.lineplot(x='percent', y='avg', data=df1,label=\"5\", color='blue', linestyle=\"solid\")\n",
        "ax2 = sns.lineplot(x='percent', y='avg', data=df2,label=\"3\", color='red', linestyle=\"solid\")\n",
        "\n",
        "ax.set_xlabel(\"(b) Prob. of Resource Existence\", fontsize = 20)\n",
        "#ax.set_ylabel(\"Avg. Assign. Ratio\", fontsize = 20)\n",
        "ax.set_ylabel(\"\", fontsize = 20)\n",
        "\n",
        "ax.legend(title='Pref. Affin. Thresh.', fontsize='x-large', title_fontsize='20')\n",
        "\n",
        "plt.xticks([0.0, 0.2,0.4,0.6,0.8,1.0], fontsize=20 )\n",
        "plt.yticks([0.0,0.2,0.4,0.6,0.8,1.0],fontsize=20 )\n",
        "ax.set_yticklabels([])\n",
        "#plt.yticks(fontsize=20 )\n",
        "\n",
        "path = \"/content/gdrive/My Drive/students_lab_results\"\n",
        "import os\n",
        "\n",
        "isExist = os.path.exists(path)\n",
        "\n",
        "if not isExist:\n",
        "  # Create a new directory because it does not exist \n",
        "  os.makedirs(path)\n",
        "\n",
        "plt.tight_layout()\n",
        "plt.savefig(join(path,\"StudPrb.pdf\"), format=\"pdf\")\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 297
        },
        "id": "McPFh4e_ZNDl",
        "outputId": "88ec4733-7314-4841-dfa6-a48fbfeb9c6c"
      },
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import networkx as nx\n",
        "from random import choices\n",
        "import matplotlib.pyplot as plt\n",
        "import copy\n",
        "import math\n",
        "import seaborn as sns\n",
        "import numpy as np\n",
        "\n",
        "def ratio_range2(x):\n",
        "  if x <= 0.2:\n",
        "    return \"0.0-0.2\"\n",
        "  elif x<=0.4:\n",
        "    return \"0.2-0.4\"\n",
        "  elif x<=0.6:\n",
        "    return \"0.4-0.6\"\n",
        "  elif x<=0.8:\n",
        "    return \"0.6-0.8\"\n",
        "  elif x<=1.0:\n",
        "    return \"0.8-1.0\"\n",
        "\n",
        "def ratio_range(x):\n",
        "  if x <= 0.1:\n",
        "    return \"0.0-0.1\"\n",
        "  elif x<=0.2:\n",
        "    return \"0.1-0.2\"\n",
        "  elif x<=0.3:\n",
        "    return \"0.2-0.3\"\n",
        "  elif x<=0.4:\n",
        "    return \"0.3-0.4\"\n",
        "  elif x<=0.5:\n",
        "    return \"0.4-0.5\"\n",
        "  elif x <= 0.6:\n",
        "    return \"0.5-0.6\"\n",
        "  elif x<=0.7:\n",
        "    return \"0.6-0.7\"\n",
        "  elif x<=0.8:\n",
        "    return \"0.7-0.8\"\n",
        "  elif x<=0.9:\n",
        "    return \"0.8-0.9\"\n",
        "  elif x<=1.0:\n",
        "    return \"0.9-1.0\"\n",
        "yall=[]\n",
        "expe = 100\n",
        "for exp in range(expe):\n",
        "  for stud in range(1,3):\n",
        "      for pref in range(5,6):\n",
        "        for dpref in range(2,3):\n",
        "          for agperc in [1.0]:\n",
        "            y = []\n",
        "            G, n, m, cost, attributes, days = load_one_student_per_room(stud, pref,dpref, 0.5, 1.0)\n",
        "            agents, resources, G, ret1 = run_for_parameters(G, n, m, days,delta=1)\n",
        "            agents, resources, G, ret2 = run_for_parameters(G, n, m, days,delta=2)\n",
        "\n",
        "            times_per_agent = {}\n",
        "\n",
        "            for lst in ret1:\n",
        "              for pair in lst:\n",
        "                if int(pair[0]) not in times_per_agent:\n",
        "                  times_per_agent[int(pair[0])] = 1\n",
        "                else:\n",
        "                  times_per_agent[int(pair[0])] += 1\n",
        "\n",
        "            sum = 0\n",
        "            num = 0\n",
        "            for agent in times_per_agent:\n",
        "              sum += times_per_agent[agent] \n",
        "              num +=1\n",
        "\n",
        "            for agent in agents:\n",
        "              if agent not in times_per_agent:\n",
        "                times_per_agent[agent]=0\n",
        "\n",
        "            for agent in times_per_agent:\n",
        "                ratio = times_per_agent[agent]/days[int(agent)][0]\n",
        "                y.append(('Rawlsian',days[int(agent)][0],ratio,sum))\n",
        "            #print(\"t1\", times_per_agent)\n",
        "            times_per_agent = {}\n",
        "            for lst in ret2:\n",
        "              for pair in lst:\n",
        "                if int(pair[0]) not in times_per_agent:\n",
        "                  times_per_agent[int(pair[0])] = 1\n",
        "                else:\n",
        "                  times_per_agent[int(pair[0])] += 1\n",
        "            for agent in agents:\n",
        "              if agent not in times_per_agent:\n",
        "                times_per_agent[agent]=0\n",
        "            \n",
        "            for agent in times_per_agent:\n",
        "                ratio = times_per_agent[agent]/days[int(agent)][0]\n",
        "                y.append(('Utilitarian',days[int(agent)][0],ratio,sum))\n",
        "            #print(\"t2\",times_per_agent)\n",
        "\n",
        "            yp = {}\n",
        "            for item in y:\n",
        "              if item[0] not in yp:\n",
        "                yp[item[0]] = {}\n",
        "              if item[2] not in yp[item[0]]:\n",
        "                yp[item[0]][item[2]] = 1\n",
        "              else:\n",
        "                yp[item[0]][item[2]] += 1\n",
        "            \n",
        "            for item in yp:\n",
        "              for item2 in yp[item]:\n",
        "#                print(item, item2, ratio_range2(item2))\n",
        "                yall.append((item,stud,exp, ratio_range2(item2), yp[item][item2]))\n",
        "\n",
        "#print(yall)\n",
        "\n",
        "df = pd.DataFrame(yall, columns =['Delta', 'stud','exp', 'Ratio', 'Num'])\n",
        "ord = [\"0.0-0.1\",\"0.1-0.2\",\"0.2-0.3\",\"0.3-0.4\",\"0.4-0.5\",\"0.5-0.6\",\"0.6-0.7\",\"0.7-0.8\",\"0.8-0.9\",\"0.9-1.0\"]\n",
        "df = df.sort_values(by='Ratio', key=lambda x: df[\"Ratio\"])\n",
        "df_grp = df.groupby(['Ratio','exp','Delta','stud'])['Num'].sum().reset_index()\n",
        "\n",
        "df_grp['Perc'] = df_grp['Num']/ len(agents)\n",
        "\n",
        "\n",
        "import pandas as pd\n",
        "import seaborn as sns\n",
        "from matplotlib.ticker import MaxNLocator\n",
        "\n",
        "hue = df_grp['Delta'].astype(str) + ', ' + df_grp['stud'].astype(str)\n",
        "\n",
        "ax = sns.barplot( x=\"Ratio\", y=\"Perc\", hue_order=['Rawlsian, 1','Utilitarian, 1','Rawlsian, 2','Utilitarian, 2'], hue=hue, data=df_grp, palette=[\"blue\",\"red\"], alpha=.6)\n",
        "\n",
        "ax.set_xlabel(\"(c) Assignment Ratio\", fontsize=20)\n",
        "ax.set_ylabel(\"Perc. of Agents\",fontsize=20)\n",
        "ax.get_legend().remove()\n",
        "\n",
        "import itertools\n",
        "hatches = itertools.cycle(['...', '...', '///', '///'])\n",
        "for i, bar in enumerate(ax.patches):\n",
        "    if i % 5 == 0:\n",
        "        hatch = next(hatches)\n",
        "    bar.set_hatch(hatch)\n",
        "\n",
        "plt.legend(title=\"μ, Max Stud.\", fontsize='x-large', title_fontsize='20')\n",
        "plt.xticks(fontsize=20,rotation=25 )\n",
        "plt.yticks([0,0.2,0.4,0.6,0.8,1.0],fontsize=20 )\n",
        "import os\n",
        "\n",
        "path = \"/content/gdrive/My Drive/students_lab_results\"\n",
        "isExist = os.path.exists(path)\n",
        "if not isExist:\n",
        "  # Create a new directory because it does not exist \n",
        "  os.makedirs(path)\n",
        "plt.savefig(join(path,\"StdRatioBar3.pdf\"), format=\"pdf\",bbox_inches='tight')\n"
      ],
      "metadata": {
        "id": "1Mp_Yh2udfHD",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 333
        },
        "outputId": "6f5266e3-6c67-442e-a9f2-d8023bf3a5b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    }
  ]
}