experiments/callgraphs.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Studying Static and Dynamic CallGraphs"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we provide the code used to parse and postporocess the generated call graph files.\n",
    "You find the generated plots towards the end of the notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining util functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import json\n",
    "\n",
    "## get callers names but only keep the ones that are not a sub name of another caller\n",
    "def get_orig_keys(calls_dict):\n",
    "    orig_keys = []\n",
    "    for c_key in calls_dict:\n",
    "        for key in calls_dict:\n",
    "            if c_key != key:\n",
    "                if key in c_key:\n",
    "                    break\n",
    "        else:\n",
    "            orig_keys.append(c_key)\n",
    "    return orig_keys"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## extract longest common substring\n",
    "def longest_common_substring(strings):\n",
    "    if not strings:\n",
    "        return \"\"\n",
    "\n",
    "    def find_common_prefix(s1, s2):\n",
    "        common_prefix = \"\"\n",
    "        min_len = min(len(s1), len(s2))\n",
    "        for i in range(min_len):\n",
    "            if s1[i] == s2[i]:\n",
    "                common_prefix += s1[i]\n",
    "            else:\n",
    "                break\n",
    "        return common_prefix\n",
    "\n",
    "    longest_common = strings[0]\n",
    "\n",
    "    for i in range(1, len(strings)):\n",
    "        longest_common = find_common_prefix(longest_common, strings[i])\n",
    "\n",
    "    return longest_common"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Reconstructing the call graph with simpler names\n",
    "def construct_graph(dynapyt_graph, orig_keys):\n",
    "    new_graph = {}\n",
    "    replacement_rules = {}\n",
    "    processed_keys = []\n",
    "    for key in orig_keys:\n",
    "        calls = dynapyt_graph[key]\n",
    "        new_graph[key] = {k: {} for k in calls}\n",
    "        for k in dynapyt_graph:\n",
    "            if key in k and k not in orig_keys and k not in processed_keys:\n",
    "                longest_sub_root = \"\"\n",
    "                for c in new_graph[key]:\n",
    "                    if c in k and len(c) > len(longest_sub_root):\n",
    "                        longest_sub_root = c\n",
    "                if longest_sub_root == \"\":\n",
    "                    new_graph[k] = {m:{} for m in dynapyt_graph[k]}\n",
    "                else:\n",
    "                    new_graph[key][longest_sub_root] = {m:{} for m in dynapyt_graph[k]}\n",
    "                    \n",
    "                processed_keys.append(k)\n",
    "\n",
    "    return new_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dedup(seq):\n",
    "    seen = set()\n",
    "    seen_add = seen.add\n",
    "    return [x for x in seq if not (x in seen or seen_add(x))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "## simplifying PyCG callgraph to become compatible with the syntax of CallGraph\n",
    "def simplify_pycg_graph(pycg_graph, replace_list=[]):\n",
    "    new_graph = {}\n",
    "\n",
    "    for k in pycg_graph:\n",
    "        new_k = re.sub(\"<Mock id='[0-9]+'>\", \"mock Mock\",\n",
    "            re.sub(\n",
    "            \"\\(<Mock id='[0-9]+'>\\)\", \"\", \n",
    "            re.sub(\n",
    "                \"<lambda[0-9]+>\", \n",
    "                \"<lambda>\", \n",
    "                k.replace(\"<builtin>\", \"builtins\").replace(\".__init__\", \"\").replace(\"_enter__\", \"\")\n",
    "            ).replace(\".py.\", \"\")))\n",
    "        \n",
    "        new_v = [re.sub(\"<Mock id='[0-9]+'>\", \"mock Mock\",\n",
    "                re.sub(\"\\(<Mock id='[0-9]+'>\\)\", \"\",\n",
    "                re.sub(\"<lambda[0-9]+>\", \n",
    "                       \"<lambda>\", \n",
    "                       m.replace(\"<builtin>\", \"builtins\").replace(\".__init__\", \"\").replace(\"__enter__.\", \"\").replace(\"__enter__\", \"\").replace(\"_enter__.\", \"\").replace(\"_enter__\", \"\").replace(\".py.\", \"\").replace(\"flask_api.\", \"\"))))\n",
    "                for m in pycg_graph[k]]\n",
    "        if new_k in new_graph:\n",
    "            new_graph[new_k] += new_v\n",
    "        else:\n",
    "            new_graph[new_k] = new_v \n",
    "    \n",
    "    final_graph = {}\n",
    "    for k, v in new_graph.items():\n",
    "        if k.endswith(\".py\"):\n",
    "            final_graph[k[:-3]] = new_graph[k]\n",
    "        else:\n",
    "            final_graph[k] = new_graph[k]\n",
    "\n",
    "    final_graph_2 = {}\n",
    "    for k, v in final_graph.items():\n",
    "        new_k = k if k[0] != \"_\" else k[1:]\n",
    "        new_v = [\".\".join([x[1:] if x.startswith(\"_\") else x for x in e.split(\".\")]) for e in v]\n",
    "        if new_k in final_graph_2:\n",
    "            final_graph_2[new_k] += new_v\n",
    "        else:\n",
    "            final_graph_2[new_k] = new_v\n",
    "\n",
    "    final_graph_3 = {}\n",
    "    \n",
    "    for k, v in final_graph_2.items():\n",
    "        new_k = \".\".join(dedup(k.split(\".\")))\n",
    "        new_v = [\".\".join(dedup(e.split(\".\"))) for e in v]\n",
    "        if new_k in final_graph_3:\n",
    "            final_graph_3[new_k] += new_v\n",
    "        else:\n",
    "            final_graph_3[new_k] = new_v\n",
    "    #final_graph_3 = final_graph_2\n",
    "\n",
    "\n",
    "    final_graph_4 = {}\n",
    "    \n",
    "    for k, v in final_graph_3.items():\n",
    "        new_k = k\n",
    "        new_v = v\n",
    "        for r in replace_list:\n",
    "            new_k = new_k.replace(r[0], r[1])\n",
    "            new_v = [e.replace(r[0], r[1]) for e in new_v]\n",
    "\n",
    "        if new_k in final_graph_4:\n",
    "            final_graph_4[new_k] += new_v\n",
    "        else:\n",
    "            final_graph_4[new_k] = new_v\n",
    "    \n",
    "    for k in final_graph_4:\n",
    "        final_graph_4[k] = list(set(final_graph_4[k]))\n",
    "\n",
    "        \n",
    "    return final_graph_4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_pycg_graph(path_to_json, replace_list=[]):\n",
    "    with open(path_to_json) as pcgg:\n",
    "        pcg_graph = json.load(pcgg)\n",
    "\n",
    "    simple_pycg_graph = simplify_pycg_graph(pcg_graph, replace_list=replace_list)\n",
    "    #orig_keys = get_orig_keys(simple_pycg_graph)\n",
    "    #c_graph = construct_graph(simple_pycg_graph, orig_keys)\n",
    "    #return c_graph\n",
    "    return simple_pycg_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "def prepare_dynapyt_graph(path_to_json, project_number, project_folder, replace_list=[]):\n",
    "    print(replace_list)\n",
    "    with open(path_to_json) as dout:\n",
    "        dnpt_graph = json.load(dout)\n",
    "\n",
    "    new_dnpt_graph = {}\n",
    "    for key in dnpt_graph:\n",
    "        new_dnpt_graph[key.replace(\".DyPyBench.temp.project{}.{}.\".format(project_number, project_folder), \"\").replace(\".DyPyBench.temp.project{}.\".format(project_number), \"\")] = [\n",
    "            v.replace(\"{}.\".format(project_folder), \"\").replace(\".case.\", \".\") for v in dnpt_graph[key]]\n",
    "        \n",
    "    print(len(new_dnpt_graph))\n",
    "    simple_dnpt_graph = simplify_pycg_graph(new_dnpt_graph, replace_list=replace_list)\n",
    "    print(len(simple_dnpt_graph))\n",
    "    #orig_keys = get_orig_keys(simple_dnpt_graph)\n",
    "    #graph_comp = construct_graph(simple_dnpt_graph, orig_keys)\n",
    "    #return graph_comp\n",
    "    return simple_dnpt_graph"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Postprocess and munual inspection"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from thefuzz import fuzz\n",
    "from thefuzz import process"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_similar_keys(graph_comp, c_graph):\n",
    "    for key in graph_comp:\n",
    "        if key not in c_graph:\n",
    "            ext = process.extract(key, set(c_graph.keys()), limit=2)\n",
    "            print(key, ext)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_similar_values(graph_comp, c_graph):\n",
    "    all_pycg = []\n",
    "    for k, v in c_graph.items():\n",
    "        all_pycg.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "\n",
    "    all_dynapyt = []\n",
    "    for k, v in graph_comp.items():\n",
    "        all_dynapyt.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "    \n",
    "    for c1 in all_dynapyt:\n",
    "        if c1 not in all_pycg:\n",
    "            ext = process.extract(c1, set(all_pycg) , limit=2)\n",
    "            print(c1, ext)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def remove_location(dynapyt_file):\n",
    "    with open(dynapyt_file) as df:\n",
    "        d_graph = json.load(df)\n",
    "\n",
    "\n",
    "    new_graph = {}\n",
    "    for k, v in d_graph.items():\n",
    "        new_graph[k] = [e[:e.find(\"###\")] for e in v]\n",
    "\n",
    "    return new_graph"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "standards = [list, set, dict, str, bytes, int, float]\n",
    "\n",
    "funcs = []\n",
    "\n",
    "for s in standards:\n",
    "    funcs += [e for e in dir(s) if not e.startswith(\"_\")]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Project 1 (Example)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "rs_graph = remove_location(\"pycg_output/project1_pycg.json\")\n",
    "\n",
    "with open(\"pycg_output/pycg_1.json\", \"w\") as dpt:\n",
    "    json.dump(rs_graph, dpt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('unicodec.normalization', 'unicodec'), ('unicodec.main', 'unicodec'), ('stat.Stat', 'Stat'), ('threading', 'thread')]\n",
      "122\n",
      "122\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "0.9918032786885246"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pycg_graph = prepare_pycg_graph(\n",
    "    \"pycg_output/pycg_project1.json\", \n",
    "    replace_list=[\n",
    "        (\"grab.\", \"\"),\n",
    "        (\"threading\", \"thread\")\n",
    "        ])\n",
    "\n",
    "dynapyt_graph = prepare_dynapyt_graph(\n",
    "    \"DynaPyt_output/dynapyt_1.json\", \n",
    "    1, \"grab\", \n",
    "    replace_list=[\n",
    "        (\"unicodec.normalization\", \"unicodec\"),\n",
    "        (\"unicodec.main\", \"unicodec\"),\n",
    "        (\"stat.Stat\", \"Stat\"),\n",
    "        (\"threading\", \"thread\")\n",
    "        ])\n",
    "\n",
    "\n",
    "len(set(dynapyt_graph.keys()) & set(pycg_graph.keys())) / (len(set(dynapyt_graph.keys())))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "spider.service.base.ServiceWorker.wrapper [('spider.service.base.ServiceWorker.worker_callback_wrapper', 95), ('spider.service.base.ServiceWorker', 95)]\n"
     ]
    }
   ],
   "source": [
    "print_similar_keys(dynapyt_graph, pycg_graph)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "all_pycg = []\n",
    "for k, v in pycg_graph.items():\n",
    "    if k in dynapyt_graph.keys():\n",
    "        all_pycg.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "\n",
    "all_dynapyt = []\n",
    "for k, v in dynapyt_graph.items():\n",
    "    all_dynapyt.extend([\" \".join(e.split(\".\")) for e in v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5555555555555556"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(all_dynapyt)& set(all_pycg))/len(set(all_dynapyt))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "130"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(set(all_dynapyt)& set(all_pycg))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "exclude = []\n",
    "for ad in all_dynapyt:\n",
    "    ads = ad.split(\" \")\n",
    "    for f in funcs:\n",
    "        if ads[-1] ==  f:\n",
    "            exclude.append(ad)\n",
    "            break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.5803814713896458"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dyna_edges = [(k, e) for k,v in dynapyt_graph.items() for e in v]\n",
    "pycg_edges = [(k, e) for k,v in pycg_graph.items() for e in v]\n",
    "\n",
    "len(set(dyna_edges) & set(pycg_edges))/len(dyna_edges)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constructing Comparision for all Projects"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "projects = [1, 3, 4, 6, 7, 8, 9, 11, 12, 13, 15, 16, 18, 19, 20, 22, 23, 24, 25, 28, 29, 31, 32, 33, 35, 36, 37, 38, 45, 46, 48, 50, 52, 53, 56, 57, 58]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Note:** Traces of projects 14 and 17 are missing (we accidentally deleted them). The user needs to regenerate them if needed (takes around 8 Hours to get them)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "122\n",
      "122\n",
      "[]\n",
      "51\n",
      "51\n",
      "[]\n",
      "40\n",
      "40\n",
      "[]\n",
      "13\n",
      "13\n",
      "[]\n",
      "74\n",
      "74\n",
      "[]\n",
      "18\n",
      "18\n",
      "[]\n",
      "85\n",
      "85\n",
      "[]\n",
      "9\n",
      "9\n",
      "[]\n",
      "48\n",
      "48\n",
      "[]\n",
      "8\n",
      "8\n",
      "[]\n",
      "45\n",
      "45\n",
      "[]\n",
      "18\n",
      "18\n",
      "[]\n",
      "103\n",
      "103\n",
      "[]\n",
      "38\n",
      "38\n",
      "[]\n",
      "39\n",
      "39\n",
      "[]\n",
      "17\n",
      "17\n",
      "[]\n",
      "9\n",
      "9\n",
      "[]\n",
      "52\n",
      "52\n",
      "[]\n",
      "27\n",
      "27\n",
      "[]\n",
      "151\n",
      "151\n",
      "[]\n",
      "211\n",
      "211\n",
      "[]\n",
      "81\n",
      "81\n",
      "[]\n",
      "23\n",
      "23\n",
      "[]\n",
      "146\n",
      "146\n",
      "[]\n",
      "28\n",
      "28\n",
      "[]\n",
      "61\n",
      "60\n",
      "[]\n",
      "199\n",
      "199\n",
      "[]\n",
      "23\n",
      "23\n",
      "[]\n",
      "57\n",
      "56\n",
      "[]\n",
      "46\n",
      "46\n",
      "[]\n",
      "27\n",
      "27\n",
      "[]\n",
      "7\n",
      "7\n",
      "[]\n",
      "14\n",
      "14\n",
      "[]\n",
      "20\n",
      "20\n",
      "[]\n",
      "19\n",
      "19\n",
      "[]\n",
      "74\n",
      "74\n",
      "[]\n",
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "not_both = 0\n",
    "not_caller = 0\n",
    "not_callee = 0\n",
    "both_in = 0\n",
    "count_pycg_edges = 0\n",
    "d_callers = 0\n",
    "c_callers = 0\n",
    "d_callees = 0\n",
    "c_callees = 0\n",
    "d_edges = 0\n",
    "c_edges = 0\n",
    "and_callers = 0\n",
    "and_callees = 0\n",
    "and_edges = 0\n",
    "uncommon_callers = []\n",
    "for p_number in projects:\n",
    "    pycg_graph = prepare_pycg_graph(\"pycg_output/pycg_project{}.json\".format(p_number), replace_list=[])\n",
    "    dynapyt_graph = prepare_dynapyt_graph(\"DynaPyt_output/dynapyt_{}.json\".format(p_number), p_number, \"structlog.\", \n",
    "                                        replace_list=[])\n",
    "    len(set(dynapyt_graph.keys()) & set(pycg_graph.keys())) / (len(set(dynapyt_graph.keys())))\n",
    "\n",
    "    all_pycg = []\n",
    "    for k, v in pycg_graph.items():\n",
    "        if k in dynapyt_graph.keys():\n",
    "            all_pycg.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "\n",
    "    all_dynapyt = []\n",
    "    for k, v in dynapyt_graph.items():\n",
    "        all_dynapyt.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "\n",
    "    dyna_edges = [(k, e) for k,v in dynapyt_graph.items() for e in v]\n",
    "    pycg_edges = [(k, e) for k,v in pycg_graph.items() for e in v]\n",
    "    count_pycg_edges += len(set(pycg_edges))\n",
    "    dyna_diff_edges = set(dyna_edges) - (set(dyna_edges)&set(pycg_edges))\n",
    "    pycg_diff_edges = set(pycg_edges) - (set(dyna_edges)&set(pycg_edges))\n",
    "\n",
    "    d_callers += len(set(dynapyt_graph.keys()))\n",
    "    c_callers += len(set(pycg_graph.keys()))\n",
    "    d_callees += len(set(all_dynapyt))\n",
    "    c_callees += len(set(all_pycg))\n",
    "    d_edges += len(set(dyna_edges))\n",
    "    c_edges += len(set(pycg_edges))\n",
    "    and_callers += len(set(dynapyt_graph.keys()) & set(pycg_graph.keys()))\n",
    "    and_callees += len(set(all_dynapyt)& set(all_pycg))\n",
    "    and_edges += len(set(dyna_edges)&set(pycg_edges))\n",
    "    uncommon_callers.extend(list(set(dynapyt_graph.keys()) - (set(dynapyt_graph.keys())& set(pycg_graph.keys()))))\n",
    "    for e in pycg_diff_edges:\n",
    "        if e[0] not in dynapyt_graph.keys() and e[1] not in all_dynapyt:\n",
    "            not_both += 1\n",
    "        elif e[0] not in dynapyt_graph.keys():\n",
    "            not_caller += 1\n",
    "        elif e[1] not in all_dynapyt:\n",
    "            not_callee += 1\n",
    "        else:\n",
    "            both_in += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Constructing Plots of Section 4.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib_venn import venn2_unweighted \n",
    "from matplotlib import pyplot as plt\n",
    "plt.rcParams.update({'font.size': 16})\n",
    "\n",
    "# Edges\n",
    "venn2_unweighted(subsets = (6306 - 3074, \n",
    "                        60565 - 3074, \n",
    "                        3074),\n",
    "                set_labels = ('DynaPyt', \n",
    "                            'PyCG'),\n",
    "                set_colors=(\"orange\",\n",
    "                            \"blue\"),alpha=0.7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAgAAAAGNCAYAAABnvslhAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAABSt0lEQVR4nO3dd3xUdb7/8deZmfReCAmBEAlFpUkVLCBYsGLBgoplUdd11XXvNre57rrl56q769W7d3XXrivXtSMqCooIFpogvRPSezLpM5mZ8/vjmEBMIQmZ+eac83k+HvNImJkz855hMudzvudbNF3XdYQQQghhKw7VAYQQQggRelIACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQ1IACCGEEDYkBYAQQghhQy7VAYToF7oOLW7w1oC3GlpqoKUWWurBVwctdeBvAt0Huh8C3/zU/Ueua71oYeCMNC6OiCO/t10XCa4YiEiBiFTjZ3gSaFJPh0ptLVRWHrm43dDc3PHi8Rz53esFTQOnE1wu42fr5eh/R0VBbKxxiYszLomJxiUpyfjpkm9OYQHyMRbm4fdCcwk0FX1zKT7yu6cK9IC6bJoDwhMhPOWowiAVoodBzHCITDP2PqJH3G44fBjy86G0tP3OvqrK2JmrFB8PGRnGZciQ9peYGLXZhOgpTdd1XXUIIdrRA9CQB3X7oH4/NBZ+s5OvMI70zcgZ+U0xkGUUBDFZED0cIlNVJ1Oqvt7Y0eflGZfW391u1cn6Li7OKAQyM+GEE2D0aMjJgYgI1cmEaE8KAKFeU7Gxs6/bB7V7of4g+JtVpwoNVwzEjYKEk41L/BijWLCgQAAOHYKdO43L7t1QUaE6VWg4HJCVBaNGGQXBqFGQnW2cchBCFSkARGjpOjQcgqrNULMN6vYa5+eFweGEmBGQcNKRoiA8SXWqPmluNnbyu3Yd2eE326Su64nwcKOFYNw4OOUUGDsWwsJUpxJ2IgWACD5vtbHDr94M1VuMjnqi56IyIHkSJE+DxAngDFedqFO6Dvv3w/r1sGkTHDwIfr/qVOYREWEUA5MmGZesLNWJhNVJASD6X8AH7u1Q9ZWx06/PVZ3IOpyRkDQRUk6FlKnKWwc8Htiyxdjpb9xodNAT/SMlxWgZmDzZuMTGqk4krEYKANE/9ADUbIWyT6HiS2nWDwVNg9iRkDIdUqdD7IiQPG1lpbHD37ABvv5afY98O3C5jFaBM8+EGTOMoYpCHC8pAETf6Tq4d0D5Gij/DLwm7rptBdGZMHguDJ4DkYP69aGbmuCzz+Djj2H7dvMOxrCC8HCYMgVmzYJp02R0geg7KQBE79XugbI1UL4WPJWq04hv0zRIHG8UA4NO7/OoAl03jvA/+gi++MJo7hcDS2QkTJ9uFANTpsgERaJ3pAAQPeNvhpKPofh9OadvJs5ISJ0J6XMhcWKPJiPKzzeO9FetMpr7hTkkJsJ558H558Og/m0AEhYlBYDoXsNhKHoPSleBr0l1GnE8IlMh43zjEp7Q7iafDz79FN59F/buVZRP9AtNM04NXHih0XlQJqAUXZECQHQU8EHF58aOv2aH6jSivznCIG0WZF5CVUsO778Py5dDTY3qYKK/pacbLQLnnWfMUCjE0aQAEEe01EHBUqOZXzr0WVqjdiIl9edQVJXFugPprP4qEV2XQ0WrCguDM86AK6+U+QXEEVIACGNinvw3oOh9+0zBa1O1zKS45jTcVdHtrve7otheks7yL1PwtsiqhlalaTBzJlxzDYwIzahRMYBJAWBnzRVQ8AYUf2CstCcsqzpwFkVVM2io7X6uWd0Zxr7qDN5ek0azVwoBK5s2zSgExoxRnUSoIgWAHTWVQv5rULLSON8vLKuOaeRXzaW+pnfTB+vOcLaWZrLss1QCATk1YGWnnGIUAuPGqU4iQk0KADtpLofcf0PZJxCQSdqtrJGTya85H3fV8S1O73dFsT43k5UbkvspmRioxo6FRYukELATKQDswNcEea9C4dvS1G9xzWRTWDefqvIE+vMPu8UVyye7hvLl9vh+fFQxEJ12Gtx8M2RkqE4igk0KACvTdShZAYdelBX4LM5LGkWNV1BeNgg9ELznaXIm8MGWoWzbf3wtC2Jgc7ngkkuMUwMx8l9tWVIAWFX1VjjwFNQfUp1EBFFAi6So+RpKS7Pwh6w7h0atlsRra4dRWCYT0VtZQgJcd50xl4BD+oRajhQAVtNYBAefgYp1qpOIIHNzOrklZ+FpVPTN7HCypzqT1z4ZLB0FLS4rC265xZhZUFiHFABW4ffC4SVQ8Jb07Le4Fi2VvLrrqCxLOPadQ6DFFcO7m7PltIANTJsG3/8+pKaqTiL6gxQAVlC9Ffb+DzQVq04igkhHo8I/n/yiCfhaVKf5Fk2jxJvGvz8aSmOTU3UaEUSRkXDjjXDxxbLOgNlJAWBmLfVw4GljPL+wtCZGklt1BXU1A/ucu+4M57NDw1m1KUl1FBFkY8bA3XfD8OGqk4i+kgLArCo3GEf9nirVSUQQBQinyHMtxcVZQe3d39/qtGSWrM6itLJ3ExAJc3G54NprYcECcErDj+lIAWA2LfWw/5/G8rzC0uqZwMHSi2luMOk3q8PJ12VZLF0ji9Nb3ciRcM89kJ2tOonoDSkAzKR6C+z+mxz1W5yORonvagoKRpvqqL8rblJ49sNs6sxayIgecbng+uuN1gDpG2AOUgCYgR4wpvDNe9WY3EdYVouWysGam3BXRh/7ziYScEXyzpYRbN0XqzqKCLLJk+FHPzLmEBADmxQAA11zBex6GNw7VScRQVbLDA4WnoPXY9HDJ01jr3so//k4HV236GsUACQnw09/KusKDHRSAAxklRth91+hpU51EhFEOg4KPTdSXDisX+fvH6gaHQk8/9EIKmq6X5pYmJvDYXQQvOYaOSUwUEkBMBAFfHDoBWNSH/nvsTSPlsmBykW9Xq7X7HRnOCt3j5DFhWxg4kT48Y8hSUaGDjhSAAw0zWWw8yGo3aM6iQiyan0uhwpOH3iT+oSMRn5zBi98kClTCVtcYqJRBJxyiuok4mhSAAwkNdthx5+kyd8GCr2LKCo4wRZN/sfS4EjkifdyZAZBi9M0+M534PLLVScRraQAGChKPjIm9pF5/C0tQBi5Dd+jojRRdZQBxeeK5vlPRlNUbq9TIXZ03nlwxx3GsEGhlhQAqum6cb4/7zXVSUSQ+UhiX9VtA346X1V0ZxhLvx4lQwVtYMIE+MUvIFb+q5WSAkAlv8fo5V/+ueokIsiatBz2FS+kWdXSvWbhcPBF3ghWbkhWnUQEWWYm3H8/ZGSoTmJfUgCo4qmC7b+Huv2qk4ggq2UG+/PPtXFnv97SOFCfycsrhqgOIoIsLg5++UuZL0AVKQBUqD8I2x4AT6XqJCLIyv3zyc2faIkpfUOtSk/ln8uyafFJq4mVuVxw551wzjmqk9iPFAChVr3VOPL3N6tOIoJIR6PAczPFhUNVRzG1Zmc8//pgJDV10mPM6hYtMiYNEqEjBUAoVW6Enf8P/F7VSUQQ6WjkNtxBeWmK6iiW4HNF8+SHY6hyy8yBVnfllXDTTapT2IcUAKFS/rkxp78M87M0HY1DDXdSUSrTnvUnnyuKf604UaYPtoFLLoHbbpPpg0NBCoBQKF0Fux9FTgRbm46Dg/V3UlmWqDqKJfldUTz10RjKqmSuAKs77zy46y4pAoJNCoBgK/oA9v1d5vS3OF1zcaD2TqrKZW77YPK7Inn64xMprZQiwOpmz4b/+i9wygSRQSMFQDAVvA37n1KdQgRZgDAO1t1JVXmc6ii2EHBF8uwnJ8qsgTYwcyb87Gcya2CwSAEQLHmvwcHnVacQQRYgjAO1d1FdIVOahVLAFcFzq0+ksExmVbS6KVPgV7+CMOn+0e9kgG0wFL4nO38bCBDOfvfdsvNXwOHzcPPs3WSle1RHEUG2aRM88ggEpAtVv5MCoL+VfQr7n1CdQgRZgDD2ue+mpjJGdRTbcvg83HjGLoYOliLA6j7/HP7+d9UprEcKgP5U9RXs/pt0+LOB3IbbcVdGq45he5rfy42z9pIYJ8Nrre7DD+F5aVjtV1IA9Bf3btjxJxnnbwMFnptlnP8A4vQ18d15+wgPkzZiq3vtNXjzTdUprEMKgP7QcBi2/85Y3U9YWpn/UooKh6mOIb4lwl/HHZccRNOk9c3qnnkGVqxQncIapAA4Xk2lsPU30FKvOokIshp9NofzJqiOIboQr1ex+MJ81TFECPzP/8CXX6pOYX5SAByPllrYep+xtK+wtHomcCB/lnTvGOCGhJdw5ZxS1TFEkAUC8NBDsH276iTmJgVAXwX8sONBaCpWnUQEmUfLYl/hfPzSvcMUTkrM45xpUpRbXUsLPPgglJWpTmJeUgD01YF/Qc021SlEkPlIYk/JIlo8Mim5eejMzDrI5BPrVAcRQeZ2wx//CB7pftUnUgD0RfGHUPiu6hQiyAKEs7fquzQ3yGTkphMIcNG4feQMbVKdRATZwYPw6KOqU5iTFAC95d4F+/6hOoUIgbzGxdTXyHzzpuX3cfXM/URF+FUnEUG2di385z+qU5iPFAC90VwhY/1tojJwPmUlg1THEMfJ5WvilgsOq44hQuCll2D9etUpzEUKgJ7ye2HHH8FbozqJCLImbRS5BdNUxxD9JEmrYP6Z5apjiCDTdfjLXyBfRoL2mBQAPbX3MajbrzqFCDI/UewvvUp6/FvMxLTDnHhCo+oYIsgaG+H3v4eGBtVJzEEKgJ4o/hBKV6tOIULgcMOtNNVLpz/LCQRYMHU/cTHSH8DqiouNiYLEsUkBcCyNhbD/X6pTiBAo819KRWmi6hgiSBy+ZhbPO6Q6hgiBtWtluuCekAKgOwEf7HoY/M2qk4gga2Asefkyza/VxetVMlOgTfzzn1BUpDrFwCYFQHcOvQh1B1SnEEHmJ44DJZcRkMXkbOGkpDwmjpa1O6yuuRkeeQR80p+nS1IAdKX6ayiQdSft4FDdYpob5U/BNnSdiyceID5W9gxWt28f/PvfqlMMXPKt15mWOtj9V2TlF+urDMyjqjxedQwRYg6fh0Vny3gxO3j9ddgms7Z3SgqAzux5TFb4s4EWBnG4cLrqGEKRFEc5Z55SozqGCDJdh7/+FepkaYgOpAD4tuIVUCELTdtBbu31+FpUpxAqzR6ZK6cCbKCiAv73f1WnGHikADiatwYOPqM6hQiBysA8qiviVMcQiml+Lzeek6c6hgiBtWthwwbVKQYWKQCOtv9f0CK9g62uhWQOF8lUv8KQpFVwxilu1TFECDzxhDE6QBikAGhV9RWUfao6hQiB/Ibr8Xk11THEADJ7VK6sGmgDZWXw8suqUwwcUgCAsdCPLPFrC25Ol9n+RAcOn4frzilUHUOEwNtvw8GDqlMMDFIAABxeAk0lqlOIIPMTRW7xWapjiAFqSEQp43JkFRmrCwSMtQJklLcUANBwGAreUp1ChECR5zo8TfKRF13QdS6enIvDIXsGq9u3D5YtU51CPXt/G+o67P27Mee/sLRmsikpHqI6hhjgwnwNXHx6heoYIgReegkqK1WnUMveBUDJCnDvUp1ChEBB3aXoMte/6IEJgwuJjpIOgVbX2Aj/svlCr/YtAPzNxmI/wvLqmSTT/Yoe0/xeFsySPkF28NlnsHOn6hTq2LcAyHvNmPhHWF5e1XmqIwiTyY4tIS3ZqzqGCIGnn7Zvh0B7FgCeSun4ZxNV+jnU14SrjiHMJuBnwRmymLwd7N0La9aoTqGGPQuAQy+B36M6hQiyAGEUlJ6qOoYwqVRXOaOymlTHECHw/PPgs2FfcPsVAA35UPqR6hQiBMp9l9LcaL+PuOgnus4l02TJYDsoK4P331edIvTs9+146AX7nvCxER/xFBafpDqGMLmYQA0zxtWqjiFC4JVX7LdOgL0KgNo9stSvTRR7rpSlfkW/OOukfDRNDhqszu2Gt95SnSK07FUAHHpBdQIRAl5tMKXFmapjCIsI8zVw3vQq1TFECLz5JtTVqU4ROvYpANy7oHqr6hQiBEqbLyIgk/6IfjQ5q1h1BBECjY3wzjuqU4SOfQqA/NdVJxAh4CeOslI5+hf9y+Vr5LQJbtUxRAgsWwYemwwSs0cB0JAPletVpxAhUNZyEX4bDucRwXfaKGkFsIO6OvjwQ9UpQsMeBUD+G9Lz3wYChFFaNlJ1DGFRUYFaWS7YJt56C/w2WA7C+gWApxLKPlGdQoRApf8CvB5NdQxhYWdPkFYAOygrs8fsgNYvAAreluV+bUBHo6RinOoYwuLitWqGZ9hssLhNvfGG6gTBZ+0CwNcAxctVpxAhUKOfRVODU3UMYXW6zvlTZaVAOzh0CDZtUp0iuKxdABS9Bz6Zy9sOiqunq44gbCItvILURJllyg5et/jgMesWAAEfFNhoQKeN1TFFVvwToRMIcNGMUtUpRAhs2wYHDqhOETzWLQAq14O3WnUKEQKldWeqjiBsJiu2jDCXzDZlB8stfBbZugVAsU0GctpcC8lUV8apjiHsxu9j9qQa1SlECHz6qXUnBrJmAdBcAdVfqU4hQqDKNxddDsSEAhOyKlRHECHQ2Ahr16pOERzWLABKVsrEPzZRXj1KdQRhUzG6m8EpXtUxRAhYdWZA6xUAug4lK1SnECHQwMk01rlUxxB2pevMmVSpOoUIgZ07obBQdYr+Z70CoOZraC5TnUKEQEXz6aojCJsbkSSnAezigw9UJ+h/1isAii34vyQ6CBBGZcVg1TGEzTl9TUwcXa86hgiBjz8Gn8UmlbVWAdBSBxVfqk4hQsCtz8LnlXn/hXozT5RWADtwu2G9xRaVtVYBULZG5v23ifLaCaojCAHAoLAqIsNlKIodfPyx6gT9y1oFQMVnqhOIEGhhEO6qWNUxhDAEfMyeLJOO2cHmzdBsobWgrFMAtNSBe4fqFCIEKn1zZJSnGFDGZcppADvwemHjRtUp+o91CoDKdRDwq04hQqCmbrjqCEK0E63XER0l3z928MUXqhP0H+sUAOWfq04gQsBHPHU1kapjCNGeHmDmuFrVKUQIbNgALRZZDNIaBYCvCaq3qE4hQsAdmCnN/2JAGjNE+gHYQVMTbNmiOkX/sEYBULUBAhYpyUS3ahpHq44gRKeSw9xomlSndvC5RRqcrVEAVFjopIzoko4Dd3Wi6hhCdErztzB+ZIPqGCIE1q2DgAVGfpq/APB7odJC3TJFl+qZhE8aesQANimnRnUEEQJ1dbB9u+oUx8/8BYB7O/gtNDBTdKnGI5P/iIEtI7ZGdQQRIhs2qE5w/MxfANRsU51AhEiNO111BCG6FeZvJF2WCLaFrVtVJzh+FigALPC/II7Jw1Ca6mXpXzHwzRhbozqCCIFDh6De5OtAmbsA8DVC3X7VKUQI1PhPVR1BiB4ZMahGdQQRArpu/n4A5i4A3DtAt0BXTHFMtQ3DVEcQokdiqJPhgDZh9tMA5i4A5Py/bTTUyeI/wiQCfkZlNalOIUJgm8l3QVIAiAHPo2Xi9WiqYwjRYydlyXwAdnD4MNSaeAZo8xYAvgaoP6A6hQiBev9Y1RGE6JXMZJP3DhM9YvZ+AOYtAGq2I5PC20ODV1b/E+aSGC4FgF2YuR+AeQsA907VCUSI1Dckq44gRK84fc3Ex/pUxxAhsNPEuyLzFgD1B1UnECEQIIyGunDVMYToJZ1xI6QfgB3k54PPpLWeFABiQGtkrIz0FKaUkyGnAezA54O8PNUp+sacBUBzBbSYuOul6LF6nyz/K8wpLVYKALs4YNL+6OYsABoOqU4gQqS+KUN1BCH6JFprkAmBbOKQSXdJ5iwApPnfNhrqZQIgYVJ+HyMyZaVSOzho0l2SFABiwPITjafJnB9RIQCGp0sBYAeHDplzVLo5v12lALCFZrJVRxDiuKQlSgFgB42NUFKiOkXvma8A8DVCc6nqFCIEPPpQ1RGEOC7JMVIA2IUZ+wGYrwBoOGzOthbRa82+QaojCHFcYsOkALALKQBCodmE7SyiT5q9SaojCHFcwvGojiBCpNSEDdPmKwCaTPguiz5p9sSojiDEcdH8XqKj/KpjiBCQAiAUPGWqE4gQ8TSGqY4gxHE7IUNOA9hBmQl3TeYrAKQDoC34iKfFq6mOIcRxyxwkpwHsoLLSfGsCmLAAMGGZJXpNhgAKqxiUIC0AdqDrUF6uOkXvmKsA0HXwVKhOIUKgOZCpOoIQ/SIpWgoAuzDbaQBzFQCeSgiYrI1F9InHl6o6ghD9IkaGAtqGFADBJOf/bcPnj1IdQYh+4UQOWuzCbCMBzFUAyAgA2/D5I1VHEKJfOHQpAOxCWgCCyetWnUCEiM8nQwCFNWgBvywLbBNuk+2izFUA+BpUJxAhIgWAsAxdJy5GJgOygwaT7aLMVQD4Tfbuij7z+ZyqIwjRb5Li5DSAHdTXq07QO+YqAFpM9u6KPvO3mOujKUR3EmKlALADaQEIJjkFYAs6DvwtqlMI0X/iY6QAsAOzFQAu1QF6xUKnAPLLmvjzkv28v76cgvJm4qKcTBmdyA+uyOaimYM73F+bs6xHj/v8z0/hxnlD+ztuSPlIxO5dpg6XHGbdjnXszt3N7sO7yS3OxR/wc/tlt7P4ksVdbueud/PSBy/x6eZPKa4oJjwsnJzMHC6ddSkXnnZhl9s1e5r5v5X/x8oNK8kvzcehORieMZwLT7uQBXMW4HR0PCVzx0N38NWer475Wi4+/WLuW3xfz164RcUqWBCooODflJd/QG3t13g8xbS0VON0RhMTM4aMjMvJzr4blyu23TZNTfmUlb2H270Jt3sTdXXbCQS8DBt2CxMnPtXlc330UTZNTYePmWn06N8xevRv2l0XCPjIy/snBQUvUF+/k0DAR0xMDhkZV5OT8xOczs6HBOu6TmHhyxQUPIvbvQWfz43TGUNc3FiGDLmG4cO/h8MR3oN3qv+0tIDXC+Ghfdo+M1cBYJEWgA27azj/3nVU1baQkRLBBdMHUVnbwqotFXy4sZzf3DiK331nTLttbupmp55X1sSqzZVoGsyemBzs+EHn02QZ4NdXvc4rK1/p1TaF5YXc+fCdFFcWkxCbwNSTpuLxeth+cDtbnt7Cxl0buW/xfWha+zUW3PVu7nzkTvbl7yM6MpoJIyfgdDjZfnA7f3n5L6zZsoa/3vNXwlztO2bOGDeDjJSMTrO0+Fv4cN2HAEw5cUqvXocVxUaGvgXg8OF/UF39ObGxJ5GQMJmwsGQ8nlKqq7/A7d5AXt4znHbaaiIjh7RtU1z8Ojt3/levnysj40q83s5naW1pqaK09B0AUlLmtLvN7/ewYcPFVFSsxOGIIDFxBmFh8VRXr2Pv3t9QUvI6M2d+QlhYYofH3bz5WoqKXgEcJCefRmRkJh5PKVVVn1Fd/TmFhUuYOfPjLguIYGlokAIgOHzm7wPQ7PWz4P6NVNW2cM2cITx770SiIoyjqw27a7jg3nU88MI+zhifzLlTB7Vt99zPT+nyMb//t22s2lzJOVNSGZ4eHeyXEHR+PV51BOVyMnO4ft71jMkaw5jhY3ju3ed4/4v3u93mvifvo7iymMljJvPnO/9MfIzxPuaX5vPDR3/Iu5+/y4SRE7hs9mXttvvzi39mX/4+cjJz+NsP/8bgZKMFqtJdyU8f/ynrd67nqaVPcccVd7Tb7qYLb+oyy8oNK/lw3YfERsUyd+rcPrwD1hIVHvoC4OST/0JMzCjCw9sfFHi9lWzceBlVVWvZufPHTJ68pO226OgTyM6+m4SEySQkTKao6D/s3//HHjzXI13etn//Q5SWvkNMzGhSUs5sd9uePfdRUbGSyMhMpk9fTnz8OAB8vjq++upaysreZdu2O5k8+d/ttisufpOioldwuRI47bTVxMdPbLutoeEgX3wxi5qaLzl06L8ZOfLnx8zfnxoaIMkkxzDSByDE3lxTQn5ZM4mxYTzxo/FtO3+AaScm8psbRwPwwAv7evR4zV4/Sz4uAuCWC7L6P7ACPj322HeyuEtnXcoPrv4B82bMIzsjG4fW/Z/qtv3b2HFoB06Hk1/d/Ku2nT/AsMHDuOeaewB4Ztkz6PqREyzl1eV8vOljAH583Y/bdv4AKQkp/OKmXwCwZMUSGpp6/ve3dM1SAM479Twiw2VSp8iw0BcASUmndtj5A4SHpzBmzJ8AKC//sN1t6emXMm7cYwwbdjPx8RPQtOM/RszPfwaAYcPan7oKBFo4fPgfAIwZ84e2nT+AyxXHhAlP4XBEUVS0hIaG/e22raw0PrOZmde32/kDxMSMYPjw7wNQXf3FcefvLTP1AzBXAeA3/5zaG3bXADBldAKJsR3Hup8zxZgD/7PtVZRUHfv1vr66mJr6FpLjw7jsjI59B8xIN1nD1ECwM3cnABmpGQxN63i6aPpJ0wEorSplx6EdbdfvOrwLXdcJc4UxafSkDtuNGjaKpLgkPF4Pn2/7vEdZSqtK2bBzAwDzz5zf69diRY4BNhGQw+H65mdEUJ+nquozGhr2oGkuhg5t32JUX78Lv99o1U1NPafDtpGR6cTFjQN0iotfb3ebw9GzojI8PPRrijQ1hfwp+8w8BYCuGxeTq28yOgOlxHc+0U1qgnHySNfhq73HnlbqmffzAVh0TiYR4VYZO2+ej+VA0eQxvnUSYhI6vT0yIpKIcOPLfnfu7iPbNRvbxUbH4nB0/r4nxBqPufvw7k5v/7Zlny0joAcYOXQkJ2Wf1LMXYHEO7dj3CRWfr469e38LwODBwS3QWo/+09IuJDIy/Vs5jpzSDQ9P6XT71h24272p3fVpaRcAUFT0MrW1X7e7raHh4DctCxpZWbcdV/6+CARC/pR9ZqJDLfPv/AHSkowd/MHixk5vP/r6Q8Xdl5K5JY2s2lIJwC0XWqP5H0DXpQDoraQ446RjUUVRp7dXuivxeD0d7pMUb2xXXVtNY3Mj0ZHt+5AEAgFKKkuM7co7f+yj6brOu5+9C8jR/9FUTgVcXv4hhYUvo+sBvF6jE6DPV8egQedz0kl/Dtrz+nwNFBX9B4Bhw27pcHtERFrb742NB4mLG9vhPo2NB7/5eajd9ampcxk58lfs3/9HPv10MsnJpx/VCXAtUVHDmDbtbZKSZvTnS+oRMx2nmuebVjdRWdWNuZOMinbTXjeb93U8wn9i6ZGhNLWN3Z83fPb9fHQdpo5JYEKOdTrO6Sb6WA4UU06cgqZpVNdVs/qr1R1uf+OTN9p+b2g+cpJy7Alj287Rv73m7Q7bvff5ezR7mzts15VNezZRWF5IuCuc82ec3+vXYVUqC4C6up0UFDxPYeGLlJd/iM9Xx5Ah13HKKc8RFtZ5i1F/KC7+D35/PRER6aSldRyCGhMzkqgo48AlL+9fHW6vqPiEhoY9APh8tR1uP/HEP3DKKS/hdEZTVbWGoqL/o7JyFaCTmnoOsbEdC4pQMFMLgHm+aa1SAExOZdaEZHQd5v9qA+98Xoq7voWDRQ385B87eeHDAsJcRnthFy2yAAQCOs99UADA4guGhSJ6CA2g9lKTGJo2tG2H+4dn/8D7X7yPu95NaVUpL7z3As+9+xwu5zfnfY/qUBgTFcN1864D4B+v/4NXVr5CRU0FVbVVvP3p2/zl5b90ul1X3lljDPeaNWlW26kDofaLdsSIH3LxxToXXuhlzpz9nHzyXygvf59PPjmZyspPg/a8eXlPAzB06I1tfQ6+bdSo+wE4dOhx9uz5DY2Nh/F6qykqeo2vvroGTTNOlWrf+uwFAi18/fVitmxZRHr6ZcyatY0LLmjgrLP2kp19F3l5/2Lt2mm43VuC9vq6YqYCwESnAKzj1d9O4YrfbOSz7dXM/9WGdrf98MoTWLutio173CTHdb0gzspNFeSVNhEV4eC6szODHVmYwL033EtjcyOrN6/mt0/9tt1t50w7hxZfC6s3r243QgDg1vm3UlNXwxufvMFfl/yVvy75a9ttk0ZPIjsjmzdXv9lhu2+rb6xn1VerALjkjEv650VZxEBoFXY4woiJyWHEiB+RlHQ6n302k82bFzFnzp5+HytfX7+X6urPgI69/4+WlbWY5uYC9u17gH37fs++fb9vuy0ubhxZWbeyf/+fCAtrP5rhwIGHyM9/lrS0C5k06cW262NjRzF27N/w+5vIy3uSHTvu4bTTOraICYN5CoAeHH2YRVpSBGseO42Vmyr4eHMFle4WBidHcOnpg5k6JpEhV64AYPyIrr9wWzv/LZiVQUInownMbSB8XZpPVEQUD931ENv2b+OL7V9Q4a4gISaBU8edytQTp3Lrn24FjDkGjuZ0OLn3hntZMGcBa7asoaSqhOiIaCaPmczpE07n/qeMo7ScoTkdnvNoH67/EI/XQ3pyOtNPnh6cF2lSA+0TnZR0KnFxJ1NXt4Oamo0dxucfr9bOf8nJZxAbO6bb+44e/RsyMxdRUvIGjY0H0LRwkpJmkJGxoK2zYlzc+G89/nMADBlybaePmZl5HXl5T1JVtRa/34PTGdzRDkfrruV2oJECQBFN0zh36qB2k/0AHChsoLjSQ0p8GJNHdd6EWlXr5a21RsesWy60WvM/aJioDW0AGj9yPONHtv/CbGhqYG/+XpxOZ5cz840cOpKRQ0e2u07Xdbbu2wpwzJ36O2uN5v+Lz7i4yxEFdqXrA++0ltMZA4DXW9avj6vrfgoKXgA67/zXmZiYEeTk/KTD9VVVawAYNOjcdtc3N+cB4HJ1fpB0pG9DAJ+vBqczdEOkzfTRN09UixUAXXnkP0av1+9ePJzwsM5f879XFuJpCZAzJJrZEzsfPmNmmiYFQH97fdXreLwezp56NikJPf/MrNywkpKqEsbnjO92SN+BggPsPLQTTdO4+PSL+yOypQQGWAHg9Va0DZ+LiRndr49dVvYeHk8xLlccGRlX9flxqqu/pKpqLZGRwxg8+NJ2t0VGGqc9a2rWdbktGBMKhXouACkAgkUbWH9EfbUzt47ahvbL3fn8Af700j6efOcwIzOj+dWikV1sfaT5f/EFwzrM624NUgD0RUFZAdV11e2u03WdpWuW8uRbTxIfE889V9/TYbvy6nJKq0o7XL/267X8vxf+H+GucO694d5un3vpWmPmv2knTSMjtfP1Aews1C0ARs//f+PvZPK0+vq9bNp0FYGAh8TEGcTHj+/kEfouL89o/h8yZCEuV0y39/V6q6mv39Ph+urqL9m4cQGgMWHCPzt0IkxPvxKAgwf/RkXFJ+1uc7u3sGePsfhURsbVaFpo50cxUwFgnlMAAM4o8HU+ft5M/rksjyffOcyU0QlkpkbiaQnw5c4aSqs9jMyMZsUjM4iJ6vy/ZvM+N1v21+J0aNx8vvWa/wE0ZOnU3Yd389BLD7X9u7CsEIA3V7/J2q1r265/6M6HSE00jnDWfL2Gx199nBOzTmRw8mB0dHbn7qa4spik+CQe/eGjbfc92s5DO7n3f+9l1NBRDBk0BJfTxf6C/eQW5xIdEc1Ddz3EqGGjuszq8/lY/sVyQMb+dyXULQAeTxlbtixi27bbSUiYRGTkUAIBL01NebjdXwEBYmNPYsqU9gtONTcXs3Hj5Uf92xhpVFq6lLVrj4ypHz/+f0lImNzp85aVGfNA9KT5v6npMGvWTCI29iRiYkbidMZQX7+H2trNaFoYEyc+TVpax+Gko0ffR2XlJ7jdG/jyyzkkJEwjOvoEmpsLqKlZh677iYsbH9R5DroSaaKZr81VALhiLFEAXHhqGrkljXy1z83GPW4iwh2MGRbDj68ewV2XZ7dbH+DbWo/+500bxJBUE33SesGlmX/Rp+PV0NTAjoM7OlxfVl1GWfWRc7Zen7ft94kjJzJn8hx2HtrJgcIDaJpG5qBMFl+ymOvOu4646LhOn2tE5ggunHkh2w5sY/2O9fh1P+nJ6Vx77rVcN+860pLSOt2u1adbPqWmvob4mHhmT5rdx1dsbc0toT0KjYsby5gxf6Sqag319btxuzej6y2EhSWTmno2GRlXMHTodzp0jgsEPJ02q3u95Xi95W3/bmnpOC4foKDgRXS9hbi4sSQlnXrMnJGRmWRl3U519VoqK1cTCHiIjBxCVtZtjBjx4y47ELpccZx++loOH36C4uJXqavbQW3tVzidMSQkTCMjYwHZ2XeGfCVAgFgTLWWi6bqJ5i3aeDfU56pOIYKsScth24HrVMcQot/sqhnOa6ussVaH6N6LL0JiouoUPWOisxWAy0SlleizML1KdQQh+lVdk7kaW0XfxXTf7WFAMVkBYKJ3VvSZkxqZC1BYSr0UALYQHg5hJpqWRQoAMeBo6DhN9EckxLHUNVplpU7RHTMd/YMUAGKAcoXJUEBhHTV10gJgB1IABJPTZO+u6DNXmF91BCH6TU29FAB2IAVAMEkLgG04XS3HvpMQZqBp1EoBYAtSAARTeKLqBCJEXE7vse8khAnoXSyFK6wnwWQrYJurAIjsfkISYR0up0d1BCH6RQDpAGgXg0021YO5CoAIKQDsIsxp/hkfhQDwIUNa7CLNZLsokxUAKSDNabYQ4So/9p2EMIGGltCtRS/UkhaAYNI0iBikOoUIgUhHkeoIQvSL6iZrrtkhOpIWgGCTfgC2EEmu6ghC9IvyGikA7MDhgNSOi20OaFIAiAHJSR1h4eZZp0qIrhSUSwFgB8nJ4DLZGWoTFgAmO8ki+iwyWoYCCrPTyC2SPgB2YLbz/2DKAkBaAOwiIrJBdQQhjovuDKPJI8MA7cBs5//BlAVAhuoEIkQiw6pVRxDiuHiQ5n+7SE9XnaD3zFcAxAw3RgMIy4t0lamOIMRxqfdKAWAXJ5ygOkHvma8AcEVBpAlLLdFrkY4C1RGEOC5VDXL+3y5GjFCdoPfMVwAAxOWoTiBCIJJcpK1HmFmZDAG0hZgY6QQYOjEmbGsRvebQmwmPCqiOIUSfHSqOUh1BhIAZm//BrAVArAnbWkSfxMbVqY4gRN84XeQWSQuAHZix+R+kABADXGykTAkszKlBj1UdQYSIFAChFJEM4YmqU4gQiHHuVR1BiD4prZMCwC6kAAi1WJOedBG9Eq3twmHeT6mwsYPFUgDYgcsFw4apTtE35v1qjZWRAHbgoIXoeJkSWJiNxrYDMapDiBDIyjLfGgCtzFsAJJysOoEIkdjoCtURhOgVnyuS+kaZAtgOxo5VnaDvTFwAjAXNvPFFz8WG56mOIESv1Hil+d8uJkxQnaDvzLsHdUVD3EjVKUQIxDq2q44gRK8UVEoBYAeaBuPGqU7Rd+YtAAASTVx6iR4Lp5jwSF11DCF6bHeeFAB2cMIJEGvi/2qTFwAmLr1Er8iEQMI0HC7258sEQHYwfrzqBMfH3AVAwlhwSEcbO4iPPqw6ghA9UqfHoeuyioUdmPn8P5i9AHBGQtwo1SlECCS61quOIESPHChLVB1BhIDDYe4RAGD2AgCkH4BNhOtFRMf5VMcQ4hg0vtyRqDqECIGcHGMVQDOzQAFg8pMwoscS44tVRxCiW15nNOXVYapjiBAw+/l/sEIBkDDOGBIoLC8xYovqCEJ0q6guUXUEESLTpqlOcPzMXwA4XJA8VXUKEQIxfE1YuAwHFAPXV/sSVUcQIZCQYP7z/2CFAgBg0GmqE4gQ0NBJSKpRHUOITunOcHYcNPlJYdEjM2YYkwCZnTUKgOQp4AxXnUKEQGLUbtURhOhUpTdBdQQRIjNnqk7QP6xRADgjIWmS6hQiBBKcX8oSEGJA2lWQqDqCCIGYGJg4UXWK/mGdr9JUOQ1gB069nriEJtUxhGjP4WDdjnjVKUQITJtm3uV/v81CBcCpRodAYXlJcbmqIwjRTgPxNHlkVlI7OM1Cx5rWKQBcMTIngE2kuD6S0wBiQNmal6o6ggiBiAiYMkV1iv5jra9ROQ1gCy6qSUqRxYHEAOF0sXpzouoUIgSmTIFwC/U3t1YBMOgMGQ1gEymxm1VHEAKA0uYUWnzW+ioVnZs7V3WC/mWtT21YLKRaZHyG6Fai4zPCImRSIKHe57uk+d8OkpNhqsXmnLNWAQCQfp7qBCIENN1HSoqsDSDU8rmi2X5AJv+xg7lzwWmxfp7WKwASx0NUhuoUIgQGRa5RHUHY3IFKOfq3A02D8yx4bGm9AkDTIONc1SlECESxl5j4FtUxhF1pGh9/laI6hQiBceMgw4LHldYrAAAGnw0Oi7XViE6lJu1VHUHYVL2WSEWNLP1rB1Y8+gerFgARybJCoE2kuD7GYc1PsRjgtuRK878dxMZaa/Kfo1n3q1M6A9qCS68hMaVWdQxhM7ozjLVfy+I/dnDWWdYa+3806xYAKVMhUip0O0iP+0R1BGEzubVpMvbfJubNU50geKz7CdYckDlfdQoRArF8TVySR3UMYRcOJ+9+OVh1ChECkyZBdrbqFMFj3QIAION8Y40AYXkZiV+ojiBsosSTSnWtLDxmBwsWqE4QXNYuAFxRMORC1SlECCRqa4iO9amOIaxO03hvfbrqFCIERo6EiRNVpwguaxcAAEPny/oANpGe+rXqCMLiagIpFJZFqI4hQsDqR/9ghwIgPBEGW2wFB9GpFOeHRETJ+gAieFZ8LUf/dpCRAaefrjpF8Fm/AAAYdoUxQ6CwNE33MXiQTAwkgqPRkcDuQ9GqY4gQuPxye+wy7FEARGVAqkVnchDtDHItwyWTs4kgWLvHgnPBig4SE+Hss1WnCA17FAAAw2xwQkfgpJG0tHzVMYTFtLhiWbc9XnUMEQKXXGLdiX++zT4FQPwoSJ6iOoUIgcGRy2QpCNGvNubKuX87iIuDiy5SnSJ07FMAAIy40R4ndmwuTK8gPT1PdQxhEV5XLCs3JKuOIUJgwQKIsdHUMfYqAGJHwCAbdO0UZES8SliEjAgQx2/FtmGqI4gQSE42mv/txF4FAED2DbJUsA04aSQzfbvqGMLk6rQkvtodpzqGCIGFC+1z7r+V/QqA6CGQfq7qFCIEBjmXEhXjVx1DmJWm8fY6Ofq3gyFD4Fwb7hbsVwAAZF8PzkjVKUSQaQQYmvaZ6hjCpEq9aRwqlO8JO7j5ZnDZcHkHexYA4YkyLNAmkrTVxCc1q44hzMbh4rU1Q1SnECEwdizMnKk6hRr2LAAAhl0OESmqU4gQGJa0HBn7IXrjQG06VW6ZUcrqNA0WL1adQh37FgDOCBhxk+oUIgRi2EZyWo3qGMIkdFcEb6yWcf92MHs2jB6tOoU69i0AAAbPgcTxqlOIEBga+yYOe3/aRQ99VZhJs1c+LFYXGwu33KI6hVryKR99Jzikqc/qIiggPUMmBxLd87pief8LOTVoBzfdZMz7b2dSAERnQtaVqlOIEBgSsYRIGRYouqJpvLUhG12XHiNWd9JJMG+e6hTqSQEAkHWVUQgIS3PgJXvwSukQKDqV35TBnlxZ7tfqXC646y6ZFR6kADA4wmD0XapTiBCIZz2p6ZWqY4gBxu+K5OWVMuzPDq64ArKyVKcYGKQAaJU4DtJtsgi0zQ2LfknWCRBH0fhoVzbeFvk6tLqMDLjmGtUpBg75xB8t5xYIkzW/rc5FLdlDvlAdQwwQ5f5BrNsuf/d28P3v22++/+5IAXC0sDgYeZvqFCIEkrSPSElzq44hFAu4Inhhhcz3bwdz5sApp6hOMbBIAfBtg8+CtFmqU4gQGB77opwKsDWNj3adQGOTrA5qdYMHw/e+pzrFwCMFQGdGfx8i01SnEEHmoprsIbJYkF2V+wfxpTT9W57DAT/+MUTLAI8OpADojCsGTvoxaPL2WF2StorUwdWqY4gQC7gipenfJhYuNMb9i45kD9eVhJMh62rVKUQIDI95hiiZIMg+HA7e3DhSmv5t4OSTpdd/d6QA6E72tZBwouoUIsicNDIy/VWcNlwP3I62lg1n5yFpD7a6mBij6V/WAOmavDXd0Rxw4k/AJV8WVhel72P40I2qY4ggq9ZTeXvNINUxRAh8//uQJl25uiUFwLFEDYZR0n3UDlId75OWXqE6hggSvyuKp98frjqGCIE5c2CWDOY6JikAemLwHMg4T3UKEQJZ0U8THedTHUP0N4eT/3w5kiaPnPe3uqwsuOMO1SnMQQqAnhp1ByRIV1Krc+Bl5KAluGSFaEtZX5jN/vwo1TFEkMXGwq9/DVHyX90jUgD0lMMFY38Jkamqk4ggiySXE4Z+rjqG6Cfl/jQ++DJFdQwRZA4H3HuvMd+/6BkpAHojPBHG/gqcMpm01SVpH5E+pER1DHGcWlwxPPO+LP1mB4sXy1S/vSUFQG/FjYTRd6tOIUJgaORzxCc1q44h+kh3hvHSpyNllT8bOPtsuPRS1SnMR/4y+mLwWTDsCtUpRJA5aGFU0hNEx0qnQNNxOHl7y2gKSiNUJxFBNmYM3Hmn6hTmJAVAX424GZKnqE4hgsxJHaPTniM8UhYNMg1N45MDOWzbH6M6iQiy5GT45S8hTDrt9okUAH2laXDyTyFG5hO3unCKGT3kVRkZYBJby7NZsyVRdQwRZBER8KtfGUWA6BspAI6HKwYm/F5WDrSBaPYwctgKWR9qgMtrGiIz/dmAy2Uc+Y8erTqJucnX2fGKSDGKgPAE1UlEkMXzJSdkbUJTHUR0qlpP5fnlQ1XHEEGmafBf/wWTJ6tOYn5SAPSH6CEw/neyZoANpDreI3PYAdUxxLc0ORN4clm26hgiBL73PZnmt79IAdBf4nJg3H0yR4ANDAl7mbSMctUxxDd8rmieeG8kLT75OrO666+HCy9UncI65C+mPyWOg5N+hpwotr7hUf8keVCd6hi2F3BF8szHo6lvlDn+re6SS2DhQtUprEX2VP0t9VQY8wPjRJWwLI0AOfH/Q/KgWtVRbMvviuSpj0+ktFJa3azurLPgtttUp7AeKQCCIf1syLlNigCL03QfOXGPk5LmVh3FdvyuKJ76SHb+djBzJvzwh/J1Ggyarusyw0mwFH0A+/4O8hZbmo7GoYY7qShNUh3FFvyuKP654kQqamRiBqs76yxj5++UMzxBIQVAsJV+AnsehYBfdRIRRDoahxq/T0WJzEoSTD5XNP9aMUZ2/jYwb54xxa8c+QePFAChUP457HoYAjKnvJXpaBxu/B5lJbJkdDD4XNE88cGJVNe6VEcRQTZ/Ptx6q+z8g00KgFCp2gQ7/gR+r+okIoiMIuB2ykpkNrr+1OKK4YnlY6ipk52/1V19Ndxwg+oU9iAFQChVb4Xtvwe/LDFrdYebvktp8WDVMSzB64rlH++PprZedv5Wd8MNRgEgQkMKgFBz74ZtvwVfg+okIsiKvIsoLDgB+QPru0ZHIk++nyPj/C1O0+CWW+DSS1UnsRcpAFRoyIftD0BTieokIsgqA/M4lDedQEB1EvMpbRnMU+9lEQjIiWArCw835vY/4wzVSexHCgBVWmph+x/BvVN1EhFk9ZzCvoKLafHKjqxHNI1d1Vm8tkpOoVhdUhL8+teyqp8qUgCoFPDBnsegdJXqJCLIPAxlb9mNNNVLU3a3HE4+OZDDmi2JqpOIIMvOht/8BgZJf1llpAAYCA6/Arn/lgmDLM5PHPtrbsddFaU6yoCkuyJ4beModh+SVTWtbto0+OlPIUr+FJSSAmCgKFsLe/4mwwQtTtdcHG68lbJiOew5WosrlqdXjqK8Wib4sbpLLzU6/MkYf/WkABhIavfC9j+At1p1EhFkJb6ryc8bIyMEgFotmSeXjaDZK0uTWJnTCbffDhdcoDqJaCUFwEDjqYLdfzHmDBCW5uZ0DhbMsW/nQE3jQH0mS1ZkoOs2fQ9sIjUVfvYzOOkk1UnE0aQAGIh0HQ4vgcP/J/0CLM5LGodqbrRdv4CAK4L3tuWweXes6igiyKZNM4b5xcWpTiK+TQqAgax6q9Ea4KlSnUQEkY5Gccu1FBbk2KLeq9OSeebDbJnZz+JcLrjxRrjsMjnfP1BJATDQed2w6xGo3qI6iQiyek7hQPFFeJosei7c4WBbeRZvfZqmOokIsrQ0o8l/zBjVSUR3pAAwA12HvFe/GSooU8pZmY94cusWU1VurfZSvyuK1zfksCdXhvhZ3cyZcM89EBOjOok4FikAzMS9E3b9BZrLVCcRQVbmv4y8/PGWmEK4wp/Gs8uzpJe/xYWHw3e+AxdfrDqJ6CkpAMzG3wwHnoHi5dJB0OKaGM2B8gU0mnUJXKeLdfnZfLguWXUSEWQnnww//CFkZKhOInpDCgCzqt4Ke/5bWgMsTtdclHivpLBoFAG/6jQ9V62n8vKqYVS5ZWIfKwsPNzr6zZ8vHf3MSAoAM/M3w6EXoHCZtAZYnIeh5LqvwV05sM+hB1yRfLQrmy+3x6uOIoJswgS46y456jczKQCsoHYP7HkcGg6rTiKCrDIwj7ziabR4BtjhlqaR15TBKx8NkXP9FhcXB4sXwznnqE4ijpcUAFYR8EH+G5D3iqwnYHE+4ilovJ7yktQBMZWwxxnHm+uz2Zdnr8mM7GjWLPjudyEhQXUS0R+kALCa5go49DyUrZbTAhZXx2Ryy85Xt8Sww8XW8qEsXTNIpvK1uFGj4LbbZCpfq5ECwKpq98KBp8C9S3USEUQBwihpuYqSkhx8LSF6Uk2jKpDCf1YPk9X7LC411ejkd9ZZ0snPiqQAsLqyNXDwORktYHE+kihuvpzSksygzh1QpyXx7sah0txvcZGRsGABXH45RESoTiOCRQoAO/B7oXAp5P0HfE2q04gg8pJBYeNlVJSm9usZoGZnPCu2DWXLHlm8x8o0DebONY76k2X6BsuTAsBOvDVGEVD8gXQUtLhm7QQKaudTXR5/XB0FW1wxrNk7lM++ll5fVjd1Klx/PYwcqTqJCBUpAOzIWw35b0LR+8ZcAsKyGhhHQc083FW9mz8g4IpkQ14mK9YnSwc/C9M0mDEDrrkGcnJUpxGhJgWAnbXUQv5bUPQu+BpVpxFBVMsMCqtnUVfd/QndgCuCHaUZLPtsED6/7PitStPgjDPg6qshO1t1GqGKFAACWuqh8B2jn0BLveo0IojqmUhJ3Ryqy+PanRpoccXwVV4GKzckEQjIjt+qnE6YPdvY8Wdmqk4jVJMCQBzha4Ki94wWgeZy1WlEEDWTTUnj+eRXjmL1znTWydS9lhYZaXTuu/xySE9XnUYMFFIAiI50HSo3GMVA9VcyoZDVuKJg8NmQeTH1gUw+/BDefRfKZKSo5QwfDhdeCHPmQJSM3BTfIgWA6F5TidFZsGQFtNSpTiOOR3QmDLkQ0s8BV/tOgYEArFsHy5bBtm1S85mZywWnnWbs+MeOVZ1GDGRSAIieCbRA+VqjVcC9W3Ua0VNhcZB2JgyeC/FjerRJWRmsWmVcCguDnE/0m7Q0mDfPuMhc/aInpAAQvdeQB2WfQvkaaCxSnUZ8m8MFyVOMnX7KdOPffbRnD3z0EaxZA/XSP3TAiYuDmTPhzDNh4kSZrlf0jhQA4vjUHTAKgbI1Mt2wanEjjZ1+2iwI799DwJYWWL8ePv4YNm0Cv79fH170QnS0MXb/zDPhlFOMJn8h+kIKANF/avd80zKwFjxVqtNYn8MFCScbR/kp0yEqIyRPW1dnFAEbNhg/GxpC8rS2FhEB06cby/FOmQJhsgaT6AdSAIj+p+tGMVC92bjU7gE9iCvU2ElYHCRPNXb4yZPAFaM0jt8PO3YYrQPr10NxsdI4lpKZCZMmGZeJE2VRHtH/pAAQwedrgOqvjxQETaWqE5mHpkFMNiRPhuRpkHASaA7VqbpUUGC0DGzcaPQf8HhUJzKP2FhjR9+6009LU51IWJ0UACL0moqhajPUbIW6vTLp0NGcERA32mjaTzgZ4k/sMGTPLHw+OHAAdu40Lrt2gdutOtXAERtrLLwzdqyxwx89WjrxidCSAkCo53UbhUDtXqjbZ1xaalWnCo2IZGN4XvzJxtF9bM5x9dof6AoL2xcERUX2mHMgPNxYbGf0aBg1yrgMGaI6lbA7KQDEwNRcZhQE9fuhscBoNWguMe8yxuEJEDMcorOMnzFZxu9hsaqTKeX1GqcNDh+GvLwjl9JScxYGmgaDBhk79yFDYMQIY6eflWXMwy/EQCIFgDAPXQdPBTQVHbk0fvPTU6F2aWNnJESkGJfwFIhINS4xw4wdfpjMtd8bzc2Qn28UA2VlUFl55FJRYYxEUMXlguRkyMg4sqMfMsT4d3q69NAX5iEFgLAOvwe81eCtgZYaY+piX903P+uNJY91H+h+CHzzU/cfua71ooUZO3RnpHFO3hFpzJ/viDhyvSv2qJ19imnP05uV1wtVVUeKArfbKBqam42Oh01NR34/+nqHwzgSd7mMn0f/7nIZt0dGGhPsxMYaP+PiIDHxyCXW3o02wkKkABBCCCFsaOCOJxJCCCFE0EgBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBECTPPfccmqZ1uERGRjJ48GBOPPFErrrqKv785z+zb98+1XGDLjc3t9P3Q9M0YmNjGT16NDfeeCOffvqp6qjCRrr6O3U4HCQmJjJ58mR+9KMfsX///qBn2bp1K7/61a+YMWMGQ4YMISIigvj4eEaNGsU111zD888/T319/TEfR9d1li1bxh133MHEiRNJS0sjLCyMhIQEcnJyuPTSS3n44Yc5ePBg0F+TGOB0ERTPPvusDvToommafu655+p79+5VHTtoDh061OP343vf+54eCAT69fnvv/9+HdCHDx/er48rzK2nf6cRERH6M888E5QMlZWV+jXXXKNrmnbMHElJSfpjjz3W5WOtWbNGHz9+fI//1i677DI9Nzc3KK9LDHzSAhAC7733HnV1ddTV1eF2uzl8+DCff/45f/3rX5k0aRK6rrNixQomTZrE0qVLVccNul/84hdt70ddXR15eXk8//zzDB06FIAnnniChx9+WHFKYTff/jvds2cPf/zjH4mIiMDj8XDbbbfx+eef9+tz5ubmMmPGDF555RV0XWf69Ok8+eSTbN++nfLycvLz8/nss8+47777yMrKorq6mr/85S+dPtYLL7zA3Llz2bZtG06nk+uvv57//Oc/7N27l8rKSvLy8vj888/5/e9/z9ixYwF46623WLNmTb++JmEiqisQqzr6yGLVqlXd3vfFF1/Uo6OjdUCPiYnRt2zZEpqQIXR0C8D999/f6X327Nmjh4eHtx3peL3efnt+aQEQnenJ3+lzzz3Xdp+LLrqo3567ublZnzRpUlsr4KOPPnrM+z/44IP6yJEjO9y2Zs0a3eVy6YCelZWlf/31190+ViAQ0JcsWaKnpaXpL7744nG9DmFe0gIwACxatIjnnnsOgIaGBn7yk5+oDaTI6NGjue666wCorq5m48aNihMJATfeeCMnnHACAKtWrcLv9/fL4z788MNs3rwZgN/97nfcc8893d4/IiKCe++9l7feeqvd9YFAgMWLF+Pz+YiJiWHlypVMmDCh28fSNI2FCxeyefPmttYAYT9SAAwQV111Feeeey4AK1eu5OuvvwbggQceQNM0oqKiqKmp6fYx1qxZ09aJ6b333mu7/uiOTgAVFRX89Kc/ZdSoUURGRpKSksIFF1zAqlWrunxsXddZv349v/71rznttNNISUkhLCyMpKQkpk2bxv33309lZeVxvgu0+zIqKCgAYO7cuWiaxowZM465/e9///u2zpZVVVV88sknaJrG7373OwAOHz7cocNXdnb2cecW1qVpGieffDIAjY2NFBQUEB8fj6Zp/PznPz/m9meffTaapjF9+vS265qbm3nssccAyM7O5he/+EWP83x7h/3666+3dST+yU9+wqhRo3r8WEOGDGHSpEk9vr+wFikABpBbbrml7fcVK1YAsHjxYhwOB83Nzbz88svdbv/ss88CkJmZybx58zq9z86dOznllFN45JFH2L9/Px6Ph6qqKpYvX87ZZ5/NCy+80Ol2S5cu5dRTT+WPf/wjX3zxBVVVVfh8Pmpqati4cSMPPPAA48aNY8uWLX145Uc4HEc+krquA3DrrbcCsG7dOnbu3Nnltrqut7WkXHbZZSQnJx9XFiFaHf25jIqKYuHChYBx3r27FoHc3Ny2wnrx4sVt169evZry8nIAvvOd7+Byufqc7Y033mj7vfVvRYiekAJgADn99NPbfv/iiy8AGDp0aNvO/Jlnnuly2/r6el599VUAbrrpJpxOZ6f3u+SSSwgLC+OFF14gPz+f8vJy3nzzTYYNG4au69x5552dHsm7XC7mz5/Pk08+ydq1azlw4AAVFRVs376dJ598ktGjR1NSUsIVV1xBc3Nzn9+Do3fwmZmZAFxxxRUkJSUd8z1YvXp129Cm1mLqzDPPpK6uru0IKysrq10HxLq6um6LCiHgyOeytcWsdUdbXFzM+++/3+V2zz33HLquExUVxbXXXtt2/dEd72bNmnVc2VofKzs7u60jrRA9orQHgoX1phPg0SIjI3VAnzlzZtt1r7/+ettjbd26tdPtnnnmmbb77Nu3r8ssmZmZemlpaYftN23a1Haff/zjHz3O26qurk7PycnRgU6HS/WkE+DBgwfbXn9cXJze3Nzcdtvdd9+tA/rgwYP1lpaWTre/8cYb2zpB+f3+drdJJ0DRmZ78nS5ZsqTtPuedd17b9a3D7a644opOtwsEAnp2drYO6IsWLWp323XXXdf2mCUlJX3O7/V62x7n/PPP7/PjCHuSFoABJjExETA6wbW65JJLGDx4MND1EXBr8//s2bMZOXJkl4//m9/8hrS0tA7XT548ua3j0IYNG3qdOzY2liuuuAI4cvqip9xuN2+++SbnnntuW+vBj370IyIiItruc9tttwFQWlrKu+++2+Ex6urqeO211wCjSfXoJlshekvXdYqLi3n88cfbjvY1TePee+9tu0/rZ/Kdd96hoqKiw2OsWrWK3NxcoP3pPYCqqqq231v/5vuiN49TX1/f6aWxsbHPzy/MTb4lBxj9m/PerR32AMLCwrjpppsAeOmll2hpaWm3zf79+9uaAY8+z9iZCy64oMvbxowZA0BJSUmnt/t8Pp5//nnmz59PVlYW0dHR7TrTtY7d37NnT7cZfve737XbLjExkSuuuIIDBw4AsHDhQu67775224wfP76tE1VnRdArr7xCY2Mjmqbxne98p9vnF6Izc+bMaTcT4JAhQ/jBD35AQ0MDTqeTv/3tb8ydO7ft/osWLSIyMpKWlhZefPHFDo/X+jnNyclh9uzZQc9/9HfGt9XU1BAXF9fppbWDo7AfKQAGGLfbDdChA1vrUUhFRUWHyYJaj/7j4+O58soru338IUOGdHlbdHQ0QKdHBGVlZZx66qncfPPNvPPOO+Tn59PU1NTta+gpTdMYPHgwl156KUuXLmXJkiWd9mFofQ/ee+89SktL293W+h7MnTuX4cOH9+r5heiM0+kkJyeHW265hU2bNnUYppeUlNTW6tX6+WtVW1vb1jnv5ptv7rBzPvrv+1ije7rTX48j7EkKgAEkLy+vrQn82zvqUaNGtXUWOvrLJhAItPXcX7hwYdtOvCtddQ48WmsrxNFuuukmvvrqK1wuFz/4wQ9YsWIFhw4dorKysq0zXeuQKJ/P1+3jHz0TYH19PT6fj5KSEt566y0uueSSLrdbuHAhMTEx+Hy+dkdce/bsaZuh7dtNrUL01NEzATY0NODz+di/fz9PPfUUEydO7HSb1qJ027Zt7eatWLJkCU1NTTgcDm6++eYO27XOKwCwe/fuPmcOCwtr+67o7nESExPRdb3dJRStEmJgkwJgADl6mtHTTjutw+2tXzbLly+nuLgYgA8//LBtvPyxmv/76uDBgyxfvhyAxx9/nP/+7//mnHPOITs7m+TkZGJjY4mNje3xucTw8PC2bWJiYnp8vj4uLo5rrrkGaF8Etf6elJTE5Zdf3puXJkSbqKiots/lsQrpVmeddVZbn5ujT021fibPO++8Tnvmn3nmmW2/r169+nhitx0YHDp0iMLCwuN6LGEvUgAMIE8//XTb762TAh3tyiuvJDExEb/fz/PPPw8c+aIZO3Ysp556alByHT22/+ihTN+2bdu2oDz/0Vo7Xu3cuZMvv/wSv9/f1hpw3XXXERkZGfQMQrTSNK2t1WnJkiU0Nzeza9cu1q1bB3TdIjVr1ixSU1MB42/4eGYXPLrofeqpp/r8OMJ+pAAYIF599VVWrlwJwPnnn9/p9JxRUVFcf/31gDG+uKqqirfffhsI3tE/gMfjafu9qy+qvLy8kCzlO2PGDMaNGwcYX5zLly+nqKgI6P49CAsLA7rOL0Rf3XzzzbhcLmpqanjzzTfbWgJSU1OZP39+p9tERUVx9913A8ZkQX/60596/Hw7duxo9+8FCxa0tUI8/PDDtlheXPQPKQAGgH//+99t5wljY2O7XQmv9TTAnj17uPPOO/F4PISFhXHDDTcELd+IESPafm8tOI7W0tLCrbfeGrKda+tR1f/93//x97//HYCJEycyefLkLrdpPdoqLy8/Zh8FIXojPT2diy66CIB//vOfvPTSSwBcf/31hIeHd7ndz372s7a+Bb/97W/bpgbuitfr5ZFHHulwmsvpdPLss8/icrloaGjgnHPOYevWrcfzkoRNSAEQAk1NTW1jbmtra8nPz+fLL7/k0UcfZcqUKSxatIjGxkZiYmJ45ZVX2o5wO3PKKacwZcoUwNgBgjFPwKBBg4KWf+rUqW1FwD333MNjjz3GgQMHKC8vZ/ny5cyePZsVK1aEbDjRDTfcQEREBLW1tW2zsB2r89/UqVMBozXjD3/4A2VlZfh8Pnw+n7QKiOPWWph/8sknbcNoj/WZjIyM5I033iAnJ4dAIMA999zDjBkz+Ne//sWuXbuorKyksLCQL774ggceeIAxY8bw05/+FK/X2+GxzjjjDJ5++mnCwsLIy8tj8uTJLFq0iNdee439+/dTVVVFZWUlu3btYsmSJVx99dWsXbsWQObMsDOFkxBZ2tEzjB3rommaPm/evA4z+HXliSeeaLf9smXLepylOzfddJMO6LNnz+5w2+rVq/WoqKguX8NPfvKTbmfb68lMgL2xcOHCtseLiIjQKysrj7nNWWed1Wl2mR3Qvvo6Y+e3+Xw+PTMzs+2xpk6d2uNtKyoq9CuvvFLXNO2Y3xWpqan6E0880eVjrVmzRh83blyPv3cuvfRSfc+ePX1+3cLcpPQLsfDwcAYNGsSYMWNYsGABDz74IHv37mX58uXdzuB3tGuvvZaYmBjAGC54/vnnBzMyYHRaWr9+PQsXLiQtLY2wsDDS09O5+OKLWbZsWbenLYLh6EVPerrwz9KlS/nlL3/J+PHjiYmJ6XbiFCF6w+l0tpuAqjfDUVNSUnj11VfZvHkzP//5z5k+fTqDBw8mLCyM2NhYRo4cyTXXXMOLL77I4cOHuf3227t8rDPOOIOtW7eydOlSbr/9dsaNG0dqaioul4v4+HhOOOEE5s+fz4MPPkhubi5vvfUWo0ePPq7XLsxL0/VOBn2LAc3j8ZCenk5NTQ2/+MUvetWByCrWrVvXtjzwBx98wHnnnac4kbC7P//5z/z85z8nKiqK4uJiEhISVEcSolvSAmBCb775JjU1NWiaFtTe/wNZ6/DHrKwszjnnHMVphKBtKeoFCxbIzl+YghQAJvToo48CcPbZZ/f4tIGVVFRUtPW0/u53vyudmIRy77//fttMfN/73vcUpxGiZ+Sb00Sqq6v55S9/2TbJyM9+9jPFiUIvNzeXG2+8kYaGBuLi4rjjjjtURxI25vf7Wb9+PXfddRdgzOB5+umnK04lRM+4VAcQx/bcc891WOHuqquu6nS2QKu6+eab22Y/bPXggw/2qPOfEMGQnZ3N4cOH2/4dERHB448/rjCREL0jLQAm0ro62a9//esOO0O7iIqKYuLEibzwwgt8//vfVx1HCBITEzn77LP55JNPup2MSoiBRkYBCCGEEDYkLQBCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtiQFABCCCGEDUkBIIQQQtjQ/wfZZYvy3e080gAAAABJRU5ErkJggg==",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Callers\n",
    "venn2_unweighted(subsets = (2094 - 1997, \n",
    "                        33795 - 1997, \n",
    "                        1997),\n",
    "                set_labels = ('DynaPyt', \n",
    "                            'PyCG'),\n",
    "                set_colors=(\"orange\",\n",
    "                            \"blue\"),alpha=0.7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Callees\n",
    "venn2_unweighted(subsets = (3741 - 1723, \n",
    "                        10537 - 1723, \n",
    "                        1723),\n",
    "                set_labels = ('DynaPyt', \n",
    "                            'PyCG'),\n",
    "                set_colors=(\"orange\",\n",
    "                            \"blue\"),alpha=0.7)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "projects = [1, 2, 3, 4, 5,\n",
    "            6, 7, 8, 9, 10,\n",
    "            11, 12, 13, 14, 15,\n",
    "            16, 18, 19, 20, 21,\n",
    "             22, 23, 24, 25, 26,\n",
    "             28,27, 29, 30,\n",
    "            31, 32, 33, 35, 36,\n",
    "            37, 38, 39, 40, 41,\n",
    "            45, 46, 47, 48, 50, \n",
    "            52, 53, 56, 57, 58]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[]\n",
      "122\n",
      "122\n",
      "[]\n",
      "400\n",
      "390\n",
      "[]\n",
      "51\n",
      "51\n",
      "[]\n",
      "40\n",
      "40\n",
      "[]\n",
      "104\n",
      "103\n",
      "[]\n",
      "13\n",
      "13\n",
      "[]\n",
      "74\n",
      "74\n",
      "[]\n",
      "18\n",
      "18\n",
      "[]\n",
      "85\n",
      "85\n",
      "[]\n",
      "136\n",
      "136\n",
      "[]\n",
      "9\n",
      "9\n",
      "[]\n",
      "48\n",
      "48\n",
      "[]\n",
      "8\n",
      "8\n",
      "[]\n",
      "46\n",
      "46\n",
      "[]\n",
      "45\n",
      "45\n",
      "[]\n",
      "18\n",
      "18\n",
      "[]\n",
      "103\n",
      "103\n",
      "[]\n",
      "38\n",
      "38\n",
      "[]\n",
      "39\n",
      "39\n",
      "[]\n",
      "49\n",
      "49\n",
      "[]\n",
      "17\n",
      "17\n",
      "[]\n",
      "9\n",
      "9\n",
      "[]\n",
      "52\n",
      "52\n",
      "[]\n",
      "27\n",
      "27\n",
      "[]\n",
      "54\n",
      "54\n",
      "[]\n",
      "151\n",
      "151\n",
      "[]\n",
      "75\n",
      "75\n",
      "[]\n",
      "211\n",
      "211\n",
      "[]\n",
      "65\n",
      "63\n",
      "[]\n",
      "81\n",
      "81\n",
      "[]\n",
      "23\n",
      "23\n",
      "[]\n",
      "146\n",
      "146\n",
      "[]\n",
      "28\n",
      "28\n",
      "[]\n",
      "61\n",
      "60\n",
      "[]\n",
      "199\n",
      "199\n",
      "[]\n",
      "23\n",
      "23\n",
      "[]\n",
      "2\n",
      "2\n",
      "[]\n",
      "52\n",
      "52\n",
      "[]\n",
      "33\n",
      "33\n",
      "[]\n",
      "57\n",
      "56\n",
      "[]\n",
      "46\n",
      "46\n",
      "[]\n",
      "72\n",
      "72\n",
      "[]\n",
      "27\n",
      "27\n",
      "[]\n",
      "7\n",
      "7\n",
      "[]\n",
      "14\n",
      "14\n",
      "[]\n",
      "20\n",
      "20\n",
      "[]\n",
      "19\n",
      "19\n",
      "[]\n",
      "74\n",
      "74\n",
      "[]\n",
      "13\n",
      "13\n"
     ]
    }
   ],
   "source": [
    "not_both = 0\n",
    "not_caller = 0\n",
    "not_callee = 0\n",
    "both_in = 0\n",
    "count_pycg_edges = 0\n",
    "d_callers = 0\n",
    "c_callers = 0\n",
    "d_callees = 0\n",
    "c_callees = 0\n",
    "d_edges = 0\n",
    "c_edges = 0\n",
    "and_callers = 0\n",
    "and_callees = 0\n",
    "and_edges = 0\n",
    "uncommon_callers = []\n",
    "for p_number in projects:\n",
    "    dynapyt_graph = prepare_dynapyt_graph(\"DynaPyt_output/dynapyt_{}.json\".format(p_number), p_number, \"structlog.\", \n",
    "                                        replace_list=[])\n",
    "\n",
    "\n",
    "    all_dynapyt = []\n",
    "    for k, v in dynapyt_graph.items():\n",
    "        all_dynapyt.extend([\" \".join(e.split(\".\")) for e in v])\n",
    "\n",
    "    dyna_edges = [(k, e) for k,v in dynapyt_graph.items() for e in v]\n",
    "\n",
    "    d_callers += len(set(dynapyt_graph.keys()))\n",
    "    d_callees += len(set(all_dynapyt))\n",
    "    d_edges += len(set(dyna_edges))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": ".test_venv",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}