ClusterProperty_v2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "b7cf6623",
   "metadata": {},
   "source": [
    "## This script computes the static and dynamic properties of clusters that can be mapped to its fusion bahavior"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "dbdd32ae",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "path: ./ClusterProperty/Relax_Es_10kT_Ens_0.3kT\n",
      "\n",
      "Topology_calc Progress : [****************************************] 100%\n",
      "\n",
      "path: ./ClusterProperty/Relax_Es_10kT_Ens_0.5kT\n",
      "\n",
      "Topology_calc Progress : [****************************************] 100%\n",
      "\n",
      "path: ./ClusterProperty/Relax_Es_15kT_Ens_0.3kT\n",
      "\n",
      "Topology_calc Progress : [****************************************] 100%\n",
      "\n",
      "path: ./ClusterProperty/Relax_Es_15kT_Ens_0.5kT\n",
      "\n",
      "Topology_calc Progress : [****************************************] 100%\n"
     ]
    }
   ],
   "source": [
    "import re, sys, os  \n",
    "import numpy as np \n",
    "from scipy.spatial.distance import pdist\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy import *  \n",
    "from time import time \n",
    "import networkx as nx \n",
    "from scipy.spatial import ConvexHull, convex_hull_plot_2d\n",
    "from glob import glob \n",
    "from scipy.spatial.distance import cdist\n",
    "\n",
    "\n",
    "def ProgressBar(jobName, progress, length=40):\n",
    "    completionIndex = round(progress*length)\n",
    "    msg = \"\\r{} : [{}] {}%\".format(jobName, \"*\"*completionIndex + \"-\"*(length-completionIndex), round(progress*100))\n",
    "    if progress >= 1: msg += \"\\r\\n\"\n",
    "    sys.stdout.write(msg)\n",
    "    sys.stdout.flush()\n",
    "\n",
    "def calc_RadGy(posList):\n",
    "    # posList = N,3 array for N sites\n",
    "    com = np.mean(posList, axis=0) # center of mass\n",
    "    Rg2 = np.mean(np.sum((posList - com)**2, axis=1))\n",
    "    return com, np.sqrt(Rg2) \n",
    "\n",
    "def connected_component_subgraphs(G):\n",
    "    for c in nx.connected_components(G):\n",
    "        yield G.subgraph(c)\n",
    "\n",
    "def readFile(file):\n",
    "    with open(file,'r') as tf:\n",
    "        lines = tf.readlines()\n",
    "    return lines \n",
    "\n",
    "def getBlock(lines, str1='', str2='', skipName=True):\n",
    "    # skipName => whether to return heading  \n",
    "    i1, i2 = 0, 0\n",
    "    for i, line in enumerate(lines):\n",
    "        if re.search(str1, line):\n",
    "            i1 = i \n",
    "        if re.search(str2, line):\n",
    "            i2 = i \n",
    "    if str2 == '':\n",
    "        i2 = len(lines)\n",
    "        \n",
    "    if skipName:\n",
    "        return lines[i1+1:i2]\n",
    "    else:\n",
    "        return lines[i1:i2]\n",
    "    \n",
    "def processCoorBlock(cBlock):\n",
    "    tmp_frame = array([line.strip().split() for line in cBlock[1:-1]])\n",
    "    atomId = tmp_frame[:,0].astype(np.int32)\n",
    "    atomTyp = tmp_frame[:,2].astype(np.int32)\n",
    "    charge = tmp_frame[:,3].astype(np.float32)\n",
    "    mId = tmp_frame[:,1].astype(np.int32)\n",
    "    pos = tmp_frame[:,[4,5,6]].astype(np.float32)\n",
    "    return atomId, mId, atomTyp, charge, pos\n",
    "\n",
    "def processBondBlock(bBlock):\n",
    "    tmp_frame = array([line.strip().split() for line in bBlock[1:-1]])\n",
    "    bId = tmp_frame[:,0].astype(np.int32)\n",
    "    bTyp = tmp_frame[:,1].astype(np.int32)\n",
    "    bPair = tmp_frame[:,[-2,-1]].astype(np.int32)\n",
    "    return bId, bTyp, bPair \n",
    "\n",
    "\n",
    "def parseDataFile(dfile):\n",
    "    lines = readFile(dfile)\n",
    "    coor_block = getBlock(lines, 'Atoms', 'Velocities')\n",
    "    bond_block = getBlock(lines, 'Bonds', 'Angles')\n",
    "    \n",
    "    atomId, mId, atomTyp, charge, pos = processCoorBlock(coor_block)\n",
    "    _, _, aPair = processBondBlock(bond_block)\n",
    "    a2m = dict(zip(atomId, mId))\n",
    "    mBonds = [(a2m[a1], a2m[a2]) for a1,a2 in aPair if a2m[a1] != a2m[a2]]\n",
    "    \n",
    "    return mBonds, atomId, mId, pos, aPair, atomTyp  \n",
    "\n",
    "def getMolecularLocation(G, aID, mID, posArr):\n",
    "    \n",
    "    nodes = G.nodes()\n",
    "    clus_com, clus_Rg = calc_RadGy(posArr)\n",
    "    hull = ConvexHull(posArr)\n",
    "    \n",
    "    dist_stat = {} # distance of molecules from cluster center of mass\n",
    "    for i, mol in enumerate(nodes):\n",
    "        idx = np.where(mID == mol)\n",
    "        com = mean(posArr[idx], axis=0)\n",
    "        dist = sqrt(np.sum((com - clus_com)**2))\n",
    "        dist_stat[mol] = dist\n",
    "    \n",
    "    return dist_stat, clus_Rg, hull.area \n",
    "\n",
    "def getGeodesicLength(G):\n",
    "    test_node = list(G.nodes())[0]\n",
    "    geo_dist_dict = nx.shortest_path_length(G, test_node) # source node : test_node, target: all other nodes \n",
    "    gdst = list(geo_dist_dict.values())\n",
    "    return mean(array(gdst))\n",
    "\n",
    "def getSpatialTopology(dfile, valency=5):\n",
    "    GList = [] # GList: GeoDesic Length \n",
    "    mBonds, aId, mId, pos, bonds, _ = parseDataFile(dfile)\n",
    "    G = nx.Graph()\n",
    "    G.add_edges_from(bonds)\n",
    "    for g in connected_component_subgraphs(G):\n",
    "        if len(g.nodes) < 250:\n",
    "            pass \n",
    "        else:\n",
    "            GList.append(getGeodesicLength(g))\n",
    "    \n",
    "    mG = nx.MultiGraph()\n",
    "    mG.add_edges_from(mBonds)\n",
    "    \n",
    "    satList, distList, RgList, HAList = [], [], [], []\n",
    "    \n",
    "    for g in connected_component_subgraphs(mG):\n",
    "        if len(g.nodes) < 10:\n",
    "            pass \n",
    "        else:\n",
    "            #print(len(g.nodes))\n",
    "            mol_dist, Rg, hA = getMolecularLocation(g, aId, mId, pos)\n",
    "            satList.extend([(mG.degree(mol))/valency for mol in mol_dist.keys()])\n",
    "            distList.extend(mol_dist.values())\n",
    "            RgList.append(Rg)\n",
    "            HAList.append(hA)\n",
    "            \n",
    "            \n",
    "    return satList, distList, RgList, HAList, GList\n",
    "\n",
    "def getStickerLocation(dfile):\n",
    "    mBonds, aId, mId, pos, bonds, aTyp = parseDataFile(dfile)\n",
    "    sticker_idx = [i for i, a in enumerate(aTyp) if (a==1) or (a==3)]\n",
    "    spacer_idx = [i for i, a in enumerate(aTyp) if (a==2) or (a==4)]\n",
    "    #spacers_idx = np.where((aId==2) or (aId==4))\n",
    "    com, Rg = calc_RadGy(pos)\n",
    "    \n",
    "    dist_stickers = cdist(array([com]), pos[sticker_idx], metric='euclidean')\n",
    "    dist_spacers = cdist(array([com]), pos[spacer_idx], metric='euclidean')\n",
    "    \n",
    "    return dist_stickers[0], dist_spacers[0]\n",
    "\n",
    "def getEventCount(path):\n",
    "    files = glob(path + '/BondData_*.dat')\n",
    "    onCount, offCount = [], []\n",
    "    for file in files:\n",
    "        data = np.loadtxt(file)\n",
    "        onCount.extend(np.diff(data[:,1]))\n",
    "        offCount.extend(np.diff(data[:,2]))\n",
    "    \n",
    "    np.savetxt(path + '/00_KineticEvents.txt', array([onCount, offCount]).T, \n",
    "               fmt='%.3e', header='Binding\\tUnbinding')\n",
    "\n",
    "    \n",
    "def getClusterGenotypes(path):\n",
    "    print(f'\\npath: {path}\\n')\n",
    "    \n",
    "    dfiles = glob(path + '/Run*.DATA')\n",
    "    \n",
    "    satList, distList, RgList, HAList, GList = [], [], [], [], []\n",
    "    N_elem = len(dfiles)\n",
    "    sticker_dist, spacer_dist = [], []\n",
    "    \n",
    "    for i,dfile in enumerate(dfiles):\n",
    "        s,d,r,hA, GL = getSpatialTopology(dfile, valency=5)\n",
    "        satList.extend(s)\n",
    "        distList.extend(d)\n",
    "        RgList.extend(r)\n",
    "        HAList.extend(hA)\n",
    "        GList.extend(GL)\n",
    "        \n",
    "        s1, s2 = getStickerLocation(dfile)\n",
    "        sticker_dist.extend(s1)\n",
    "        spacer_dist.extend(s2)\n",
    "        \n",
    "        \n",
    "        ProgressBar(\"Topology_calc Progress\", (i+1)/N_elem)\n",
    "    \n",
    "    \n",
    "    np.savetxt(path + '/00_Spatial_saturation.txt', array([distList, satList]).T, fmt='%.4e', \n",
    "               header='Dist_from_COM\\tSticker_Saturation')\n",
    "    \n",
    "    np.savetxt(path + '/00_Sphericity.txt', array([RgList, HAList, GList]).T, fmt='%.4e', \n",
    "               header='RadGy\\tHullArea\\tGeodesicLength')\n",
    "    \n",
    "\n",
    "path1 = './ClusterProperty/Relax_Es_10kT_Ens_0.3kT'\n",
    "path2 = './ClusterProperty/Relax_Es_10kT_Ens_0.5kT'\n",
    "path3 = './ClusterProperty/Relax_Es_15kT_Ens_0.3kT'\n",
    "path4 = './ClusterProperty/Relax_Es_15kT_Ens_0.5kT'\n",
    "\n",
    "\n",
    "for path in [path1, path2, path3, path4]:\n",
    "    # Genotype means causal biophysical properties that dictate the fusion behavior (phenotype)\n",
    "    getClusterGenotypes(path)\n",
    "    \n",
    "    # get the rate of inter-sticker bond dissociations\n",
    "    getEventCount(path)\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c84081ed",
   "metadata": {},
   "source": [
    "## Visualization of the cluster property \n",
    "#### C1: Es, Ens = 10kT, 0.3kT\n",
    "#### C2: Es, Ens = 10kT, 0.5kT\n",
    "#### C3: Es, Ens = 15kT, 0.3kT\n",
    "#### C4: Es, Ens = 15kT, 0.5kT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "cf3ed77b",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from numpy import mean, array, pi  \n",
    "from seaborn import kdeplot \n",
    "import re\n",
    "import pandas as pd  \n",
    "from glob import glob \n",
    "from scipy.stats import gaussian_kde\n",
    "\n",
    "font = {'family' : 'Arial',\n",
    "        'size'   : 16}\n",
    "\n",
    "plt.rc('font', **font)\n",
    "\n",
    "def plotSaturationGradient(x, y, Rg, fs=14, title=''):\n",
    "    plt.subplots(figsize=(4.8,4))\n",
    "    # Calculate the point density\n",
    "    xy = np.vstack([x,y])\n",
    "    z = gaussian_kde(xy)(xy)\n",
    "    plt.scatter(x/mean(Rg), y, c=z)\n",
    "    plt.ylabel('Fraction of sticker occupied', fontsize=fs, fontweight='bold')\n",
    "    plt.xlabel('Radial location of molecules (R / R$_g$) ', fontsize=fs)\n",
    "    #plt.title(self.labels[i])\n",
    "    plt.axvline(1, ls='dotted', c='k', lw=2)\n",
    "    plt.ylim(0,1.1)\n",
    "    plt.xlim(-0.1,2.5)\n",
    "    plt.title(title, pad=12)\n",
    "    plt.tight_layout()\n",
    "    #plt.show()\n",
    "    \n",
    "def drawBoxPlot(data, ylabel='', fs=16, labels=[], ylim=None, logScale=False):\n",
    "    if logScale:\n",
    "        fig, ax = plt.subplots(figsize=(4.4,3.6))\n",
    "        logData = []\n",
    "        for dat in data:\n",
    "            logData.append(np.log10(array(dat)))\n",
    "            \n",
    "        green_diamond = dict(markerfacecolor='grey', marker='o')\n",
    "        ax.boxplot(logData, medianprops=dict(color='b'), flierprops=green_diamond)\n",
    "        ax.set_ylabel(ylabel, fontsize=fs, fontweight='bold')\n",
    "        ax.set_yticks([1,2,3,4], labels=['$10$','10$^2$', '10$^3$', '10$^4$'])\n",
    "        ax.set_xticks([i for i in range(1, len(labels)+1)], labels=labels)\n",
    "        mycolors =['g','g','r','r']\n",
    "        for ticklabel, tickcolor in zip(plt.gca().get_xticklabels(), mycolors):\n",
    "            ticklabel.set_color(tickcolor)\n",
    "        \n",
    "    else:\n",
    "        fig, ax = plt.subplots(figsize=(4.4,3.6))\n",
    "        \n",
    "        green_diamond = dict(markerfacecolor='grey', marker='o')\n",
    "        \n",
    "        ax.boxplot(data, medianprops=dict(color='b'), flierprops=green_diamond)\n",
    "        \n",
    "        ax.set_ylabel(ylabel, fontsize=fs, fontweight='bold')\n",
    "        \n",
    "        ax.set_xticks([i for i in range(1, len(labels)+1)], labels=labels)\n",
    "        \n",
    "        mycolors =['g','g','r','r']\n",
    "        \n",
    "        for ticklabel, tickcolor in zip(plt.gca().get_xticklabels(), mycolors):\n",
    "            ticklabel.set_color(tickcolor)\n",
    "        \n",
    "        #plt.xlabel.set_color('r')\n",
    "        \n",
    "    if ylim != None:\n",
    "        plt.ylim(ylim)\n",
    "    plt.tight_layout()\n",
    "    \n",
    "\n",
    "def parseData(path):\n",
    "    d1 = np.loadtxt(path + '/00_Spatial_saturation.txt')\n",
    "    d2 = np.loadtxt(path + '/00_Sphericity.txt')\n",
    "    \n",
    "    m_Rg, m_HA = mean(d2[:,0]), mean(d2[:,1])\n",
    "    \n",
    "    return d1[:,0], d1[:,1], d2[:,0], d2[:,1] \n",
    "\n",
    "def getSaturationData(path):\n",
    "    d1 = np.loadtxt(path + '/00_Spatial_saturation.txt')\n",
    "    d2 = np.loadtxt(path + '/00_Sphericity.txt')\n",
    "    \n",
    "    m_Rg, m_HA = mean(d2[:,0]), mean(d2[:,1])\n",
    "    \n",
    "    idx = np.where(d1[:,1] == 1) # saturation is 1 \n",
    "    dist_full = d1[:,0][idx]\n",
    "    \n",
    "    return dist_full/m_Rg  \n",
    "\n",
    "def getDensity(path):\n",
    "    _, _, Rg, _ = parseData(path)\n",
    "    vol = (4/3)*pi* (Rg/10)**3 \n",
    "    return 7000/vol \n",
    "\n",
    "def getBF(path):\n",
    "    d = np.loadtxt(path + '/00_BondCount_stat.txt')\n",
    "    bf = d/500\n",
    "    return bf  \n",
    "\n",
    "def getGL(path):\n",
    "    d = np.loadtxt(path + '/00_Sphericity.txt')\n",
    "    return d[:,-1]\n",
    "\n",
    "def getSphericity(path):\n",
    "    d = np.loadtxt(path + '/00_Sphericity.txt')\n",
    "    area, Rg = d[:,1], d[:,0]\n",
    "    return 4*pi*Rg**2 / area\n",
    "\n",
    "def getEvents(path):\n",
    "    d = np.loadtxt(path + '/00_KineticEvents.txt')\n",
    "    return d[:,1]\n",
    "    \n",
    "\n",
    "p1 = './ClusterProperty/Relax_Es_10kT_Ens_0.3kT'\n",
    "p2 = './ClusterProperty/Relax_Es_10kT_Ens_0.5kT'\n",
    "p3 = './ClusterProperty/Relax_Es_15kT_Ens_0.3kT'\n",
    "p4 = './ClusterProperty/Relax_Es_15kT_Ens_0.5kT'\n",
    "\n",
    "labels = ['C1', 'C2', 'C3', 'C4']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8a46acb",
   "metadata": {},
   "source": [
    "### Density of clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "83c980fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_density = [getDensity(p1), getDensity(p2), getDensity(p3), getDensity(p4)]\n",
    "drawBoxPlot(data_density, labels=labels, ylabel='Cluster Density (beads / nm$^3$)', fs=13)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5aa77931",
   "metadata": {},
   "source": [
    "### Degree of sticker saturation "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "599a9b24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_bf = [getBF(p1), getBF(p2), getBF(p3), getBF(p4)]\n",
    "drawBoxPlot(data_bf, labels=labels, ylabel='Fraction of stickers occupied', ylim=(0.85,1), fs=13)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61b3afcf",
   "metadata": {},
   "source": [
    "### Distribution of shortest path (geodesic) length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "393ed259",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_GL = [getGL(p1), getGL(p2), getGL(p3), getGL(p4)]\n",
    "drawBoxPlot(data_GL, labels=labels, ylabel='Shortest path length\\nin sticker network', fs=14)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a5c24cdf",
   "metadata": {},
   "source": [
    "### Number of dissociation events (rate of bond breakge)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "15304203",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\chatt\\AppData\\Local\\Temp\\ipykernel_24412\\3066753127.py:36: RuntimeWarning: divide by zero encountered in log10\n",
      "  logData.append(np.log10(array(dat)))\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZwAAAFLCAYAAADiejquAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA1j0lEQVR4nO3de1xUZf4H8M8Z5X4ZUERFULwRpiteCjNFRM3d9RYlZuUFWyWzm1nirtWa1q7u5iWx1nV/XtnV1E0z87IpjrBqqRlGlopiQIKGwnKXkYs8vz8mpobrcObMMDN83q/XvPI558zDd55l58tzznORhBACREREZqZq6QCIiKh1YMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMJpwI8//gi1Wg1JkiBJEl588cWWDomIyKYx4TTg1VdfRXFxcUuHQURkN5hw6qHRaLBr1y64ubm1dChERHaDCaeWiooKvPDCC5AkCW+++WZLh0NEZDesMuFkZWVh06ZNmD17Nvr27QuVSqV/liJJEpKSkpqsIykpCVOnToW/vz+cnJzg6+uLMWPGID4+Ho2tV/ruu+/iypUrePbZZ/HQQw8p+KmIiFq3ti0dQH02b96MZcuWyX7/woULsXr1aoNjubm50Gg00Gg0iI+Px4EDB+rcMsvIyMDy5cvRoUMHrFixAt98843sGIiIyJBV9nBMsWbNmjrJRq1WQ6X6+aMmJiZixowZdd770ksvQavVYtWqVfD29jZ7rERErYlVJpwuXbogOjoaGzZsQEpKCsLCwox6X15eHpYsWaIvOzs7Q6PRoLCwEOnp6QgKCtKf27dvHxISEvTlr776CocOHcJ9992H/v37IyUlBdeuXTOoOyUlBRUVFQp8QiKiVkjYgPDwcAFA/0pMTKz3unXr1hlcN2/ePIPzu3btMjg/ZcoU/bnExESDcw29MjIyzPhJiYjsl1X2cOTSaDQG5YiIiEbLx44dM3tMRESkY5WDBuS6cOGCQTkwMNCg7OvrCxcXF2i1WgBAQUEBsrOz4e/vj5EjR9YZvZaUlKRPUi+88AI++OCDBn92eXk5ysvL9eXq6mrk5+ejffv2kCTJlI9FRGS1hBAoKSmBn5+fwbPy+thVwsnLyzMoe3l51blGrVbrEw6gG73m7+9v8s9esWKFSSPriIhsWVZWVpPfpXaVcMrKygzKbdvW/XgODg4G5Tt37jRYX329noYsXrwYr776qr5cVFSErl27IisrC56enkbVQURka4qLixEQEAAPD48mr7WrhOPq6oqSkhJ9ubKyss41tY8ptXyNk5MTnJyc6hz39PRkwiEiu2fMowO7GjTg4+NjUC4sLKxzTe1jHTp0MGNERERUw64STv/+/Q3KGRkZBuWcnBzcvXtXX/b29lbk+Q0RETXNrhLO6NGjDcqJiYmNlmtfT0RE5mNXCeepp56Cq6urvhwfH6+fm5OZmWmwCgEAzJkzx6LxERG1ZpIwdhiWBe3evRvz58/Xl/Pz8w0e9nt7e8PR0VFfzsnJ0f975cqVWLRokUF9arUaJSUlqK6u1h+bNGkS9u/fb47wAehGbqjVahQVFXHQABHZreZ811nlKDWtVotbt241eL6goKDBc7Gxsbhx4wbi4uL0x4qKigyuCQ8Px44dO0wPlIiIjGZXt9RqrF27FsePH0dUVBT8/Pzg4OCA9u3bY9SoUdiyZQuOHz8Od3f3lg6TiKhVscpbavaAt9SIqDVoznedXfZwiIjI+jDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRTDhEBGRRSiWcO7du4czZ84gOTlZqSqJiMiOyE44+/btw5QpUwAAFRUViIiIwLBhwxAaGopHH30UVVVVigVJRES2T1bCOXjwIKZMmYKDBw9CCIFt27bh1KlTEEJACIGDBw8iLi5O6ViJiMiGyUo4q1atQnV1NXx8fFBcXIw9e/ZAkiRMmzYNY8eOhRACH374odKxEhGRDZOEEKK5b2rXrh2Kiopw9OhRjBw5Emq1GlqtFjdu3EBWVhaGDBkCNzc3lJSUmCNmm1BcXAy1Wo2ioiJ4enq2dDhERGbRnO+6tnJ+QE0i6dWrF1JSUlBWVoZu3bqhU6dOKCsrA6AbREBERFRD1i21mix2/fp1/Oc//wEAjBgxAgBw6tQpAECXLl2UiI+IiOyErB7OwIEDkZiYiGnTpqGwsBCSJGH8+PE4dOgQ5s2bB0mSMHz4cKVjJSIiGyarh7NgwQIAQHZ2NkpLS9G9e3c89thjqKqqglarhYuLC2JjYxUNlIiIbJushDN+/Hjs3bsXEyZMQHR0NBISEuDg4IDg4GAEBQXhwIEDuP/++5WOlYiIbJisUWrGKC8vh5OTkzmqNptDhw4hLi4Oly5dQl5eHgCga9euGDduHN588034+PgYXRdHqRFRa9Cc7zpZPZzu3bujZ8+euH37dp1zX331FTw8PDBy5Eg5Vbeo06dPIyEhATdu3EB5eTnKy8uRlpaGuLg4jBo1CtXV1S0dIhGRzZKVcH744QdkZmbWO/S5rKwMd+7cwcWLF00OztJCQ0OxZ88eZGdnQ6vVIikpCe3atQMAfPvtt/jmm29aOEIiIttl1Ci1ixcvIiQkBDV33yRJAgD4+/s3+B5nZ2cFwrOsSZMmGZTDw8MxcuRIfPzxxwAAR0fHlgiLiMguGNXD6du3L6Kjo/VrpdWoKdd+AT/Py5EjKysLmzZtwuzZs9G3b1+oVCpIkqR/JSUlNVlHUlISpk6dCn9/fzg5OcHX1xdjxoxBfHw8jHlsdffuXSQlJel/1siRI9G3b1/Zn4mIqLUzeh7OO++8g6ysLAghoNFo9HNtfjkwQJIkODs7Y8CAAZg/f77soDZv3oxly5bJfv/ChQuxevVqg2O5ubnQaDTQaDSIj4/HgQMH4ObmVue9paWl8PDwMDg2duxY7NmzR3Y8RETUjITj5+eHo0ePAgACAwMhSRL27NkDX19fswUnx5o1a+okG7VajZKSEv1D/8TERMyYMUN/q6wpR48exWOPPYYjR46gTZs2isdMRNQayBo0kJmZiYyMDLMlmy5duiA6OhobNmxASkoKwsLCjHpfXl4elixZoi87OztDo9GgsLAQ6enpCAoK0p/bt28fEhIS6tTh7u4OIQTKyspw9uxZ9OvXDwCg0Wiwf/9+Ez8ZEVHrJWtpGwDIyMjA9u3bkZOTg8rKyjrnJUnCP/7xD1l1x8TEICYmRl9WqYzLizt37sSdO3f05WeeeQajRo0CAHTr1g1vv/02nnzySf35jRs34pFHHqm3LhcXF4SGhmLOnDl45ZVXAABXr15t7kchIqKfyEo4CQkJmDBhQpO7espNOHJpNBqDckRERKPlY8eOGZRnz56Np59+Gv369YOXlxcuXbqErVu36s/36NGjwZ9dM2+nRnFxcbPjJyKyZ7ISzpIlS+rt1fxSzdBpS7pw4YJBOTAw0KDs6+sLFxcXaLVaAEBBQQGys7P1w7u3bNmCLVu21Ft3aGgoIiMjG/zZK1asMGmgAxGRvZP1DOebb76BJEkYPXo0zpw5g2vXriEjI8PglZ6ernSsTapZjqaGl5dXnWvUarVBOTc3V//vV155BYMHD0b79u3Rpk0beHp64sEHH8Ty5ctx/PjxRufhLF68GEVFRfpXVlaWaR+GiMjOyOrheHl54datW1i9ejX69++vdEyy1Wz+VqNt27ofz8HBwaD8y2c+7733nuyf7eTkZHNrxxERWZKsHs7kyZMBoN611FqSq6urQbm+2361j9U3F4eIiJQnq4fz5z//GZ9//jmeffZZrFmzBv369avzZQ/o5u5Yko+Pj377awAoLCysc03tYx06dDBzVEREBMhMOL169UJFRQWKi4v1vZ3aJElqchSb0vr374+MjAx9OSMjA6GhofpyTk4O7t69qy97e3s3uh4cEREpR9Yttby8PP2w34bWUzPTNjuNGj16tEE5MTGx0XLt64mIyHxk9XCio6OVjkMRTz31FP7whz/oBw/Ex8djypQpGD16NDIzMw1WIQCAOXPmtESYREStktl2/DTF7t27DRb/zM/PN3jY7+3tbTBEOScnR//vlStXYtGiRQb11V5LDdBtRWDOpWq44ycRtQbN+a6TvbTNL2VlZSE3NxeDBg1SojpotVrcunWrwfMFBQUNnouNjcWNGzcQFxenP1ZUVGRwTXh4OHbs2GF6oEREZDRZz3AA3fyV2NhYdOzYEYGBgfqH80OGDMGJEycUC1COtWvX4vjx44iKioKfnx8cHBzQvn17jBo1Clu2bMHx48fh7u7eojESEbU2sm6pFRcXY/jw4bh48aLBLqBZWVnw9/eHm5sbTp48iQEDBigdr83gLTUiag2a810nq4fzpz/9Cd999x1cXV0xY8YM/fGCggK4ubmhrKwMK1askFM1ERHZKVkJ5+OPP4YkSdi4cSOWL1+uP963b19s2bIFQgh8/vnnigVJRES2T1bCyc7OBgA8+OCDdc7V3EarvZAmERG1brISTrt27QAAZ86cqXMuKSkJANCxY0f5URERkd2RlXDGjRsHIQTmzp2L3//+9/rjL7zwAubPnw9JkhrcSZOIiFonWaPUbt68icGDB+PWrVt1NloTQqB9+/b46quv0K1bN8UCtTUcpUZErYHZR6n5+fnh9OnT+O1vfwtJkgzWT5s4cSJOnjzZqpMNERHVJXulgcDAQBw6dAhFRUVIS0tD27Zt0bNnT3h4eCgZHylMq9UiNjYWaWlp6N27N1auXAkXF5eWDouIWgFZt9R+97vfYe7cuRgyZIg5YrIL1nhLLTIyEgcOHDBYU06lUmHixIn45JNPWi4wG1FRUYH169fj+++/R8+ePfH88883uu04UWvQnO86WQlHpVJBkiT069cPc+fOxfTp063mS9VaWFvCiYyMxP79+xEUFISwsDD4+vri9u3bOHnyJK5evYpHH32USacRixYtwnvvvWewx1Pbtm2xYMECvPvuuy0YGVHLMnvCadOmjcGSNi4uLpg6dSpiYmLw0EMPyYvazlhTwtFqtXB3d0evXr3w5JNPQqX6+dFddXU1du3ahWvXrqG0tJS31+qxaNEirFy5Eo6OjqioqNAfrynHxsYy6VCrZfZBAz/88APeeecdBAUFQQiBsrIybNu2DcOGDUNISAjWr1+v36CNWl5sbCyqq6sRFhZmkGwAXW81LCwM1dXViI2NbaEIrVdFRQXWrFkDQPfccvbs2Vi8eDFmz56NwMBAAMCaNWsMEhER1U9WwvH398cbb7yB1NRUfPHFF4iJiYGXlxeEEPjuu+/w0ksvoUuXLkrHSkYoKyvD+fPnDV7JyckAAF9f33rfU3M8OTm5zntrNrNrrT744AMIIRAUFIQnn3wSAQEBcHJyQkBAAJ588kn9H10ffPBBS4dKZPVM3g/noYcewkMPPYSYmBi89NJL+PLLL/W9HrK81NRUDB48uN5zt2/fRkBAQL3HAd3KEbXfm5ycrNg+R9aurKwMqampBsdqBlk01ju8evUqDhw4gJEjRxqcDw4Ohqurq7nDJrIZJiWcW7duYceOHYiPj8d3330HAPpnOxzBZh5paWkoKSlp8LxWq8X27dsNjlVUVGDOnDk4efJkvc9wTp48CZVKhU2bNtUZdaXVanH+/PkGf56Hhwd69+4t89NYl8aSdVO9w6SkpFadrImMISvhfPTRR4iPj8fRo0dx7949fZJxd3fH008/jXnz5iEkJETRQAm4cOEaQkKmynx3CK5eBbZtu4CBAweiXbt2yM/Px9dfX8D1624AQvC7370vq+Zvvvk3+vfvJTMu6xEcHKy//VjjzJkzeOGFF5rsHf7tb3+rM2AmODjYfMES2SBZCWfq1Kn6FQYAICQkRD88mjtpms+5cyUAGu5tGOP6dd1LSd9+exn9+ytbpzk01Tusz4MPPgh3d3ecOHECTz31VJ3e4YkTJ+Du7l7vyum1b8/VZk+9QyJjyL6l5uzsjClTpuC5557jUGgLuXs3BcBsk+rw9w9A27ZtUV5eDicnJ1RWVuLGjWyT6vzVr/5t0vstwbTeYW+kpQFbt36DQYMG6XuH589/g6wsdwC9ERo6V1bN9tI7JDKGrISzZs0azJo1C15eXgqHQ42ZOnUinJzuNfthdGlpKSIiIn6ahzOgzl/pO3em4vvvv0diYmKze6i6v9Kt/wtTid5hVpbupSRb6R0SKcGohFMzp6ZmUs8rr7zS4LXl5eU4cuQIAGDSpEkmhke/5OPjgzlz5jR6TX0jrd54441GR1qNGDECaWlpeOONNxAXF2dw3l5GWinRO2zbtm2dlQZ+WZbDFnqHREoxKuF4eXlBpVLh+vXr8PPzA6BLQkuXLoUkSVi9erX+2ry8PERGRkKlUpn8f0ZqPlNGWp06dcpuR1rJ7R1qtVqEhYVBCIEePepfFkiSJJw8ebLZqzTYSu+QSClG31KrvQJOSUkJ1q5dWyfhNHQ9WUZ9I61Gjx6NwsLCJkdaeXl5QaPR1KnPHsjtHdb8jvfu3dtgSHnNxM+aZYHWrl2LxYsXG7zXXnqHREoxeeInWRdXV9c6PZKoqChs2bKlyXk4UVFRdtGbkaux3mFTEz/37NmDPXv2GJy3l94hkVKYcFqBdevWYfPmzbh69Sp27drV4G2hdevWtXSoLaq+3uHzzz+Ps2fPNnk7csiQIVi/fn2d+ojoZ0w4rYCLiwsmTZqE/fv3IzMzE1evXtWfq1lZYNKkSa1+pej6eofLli3Db37zmyZvRy5btoy9GaImyFq8k2zPJ598gkcffRSVlZUGxysrK7kXTiPGjBkDV1dXnDhxwmDjOuDniZ9ubm4YM2ZMC0VIZDvYw2lFPvnkE24x3Uxt2rTBv/71L0yePBk7d+7EiBEj9LcjT5w4gbS0NOzduxdt2rRp6VCJrF6zEs66dev0c3F+ud/N8uXL9f/mPjjWzcXFhUvpN9Pjjz+OvXv34pVXXsHmzZv1x7t27Yq9e/fi8ccfb8HoiGyHUTt+1mwpbSwhBCRJwr1790wKzpZZ046fpIx79+7h5MmT+PHHH9G5c2eEhYWxZ0OtXnO+62TPwyFqbdq0aVNnzxsiMp5RCScxMdHccRARkZ0zKuGEh4ebOw4iIrJzHBZNREQWwYRDREQWwYRDREQWwYRDREQWwYRDREQWwYRDREQWIXsttZMnT2Lbtm3IycmpsyAkAEiSpN9qmoiISFbC2blzJ6ZPn97g+ZqlbYiIiGrISjh/+ctfuNQNERE1i6xnODU7RE6bNg05OTmoqqpCdXW1was1L9xJRER1yUo4HTt2BAAsXrwYvr6+dfZ6JyIiqk1WppgxYwaEELhy5YrS8RARkZ2S9QxnwYIFOHHiBGJiYvDDDz+gX79+cHV1rXPdww8/bHKAlnTgwAHs3r0b586dQ05ODgCgR48emDVrFubNmwdHR8cWjpCIyHYZtQFbbcZsOiVJEqqqqmQF1VJ+85vfNDiUe8KECThw4IDRdXEDNiJqDZrzXSfrlpoQwqiXrXFycsKLL76IlJQUaLVaJCQkwMPDAwBw8OBBfPXVVy0cIRGR7ZJ1S+2tt95SOg6rsH37dn2CAYAxY8Zg5syZ+Nvf/gYASEtLwwMPPNBS4RER2TSrTDhZWVk4cuQITp8+jTNnzuDy5csGPabExMQmt/pNSkrC3//+d3z++efIzc2FWq1G//79MWPGDMycObPeiam/TDY1ysvL9f/29/eX/6GIiFo52Uvb1Lh27RouXLgASZIwYMAAdO/e3eSgNm/ejGXLlsl+/8KFC7F69WqDY7m5udBoNNBoNIiPj8eBAwfg5ubWaD2XLl3Chx9+CAC47777MGzYMNkxERG1drIn0OTm5mLcuHG47777MGXKFERFRaFXr16YOHEicnNzlYyxWdasWVMn2ajVaoO5QomJiZgxY0aj9Vy+fBljx45FWVkZ1Go1/v3vf3O+ERGRCWR9g5aWliI8PBxHjhypM1Dg8OHDiIiIwJ07d2QH1aVLF0RHR2PDhg1ISUlBWFiYUe/Ly8vDkiVL9GVnZ2doNBoUFhYiPT0dQUFB+nP79u1DQkJCvfV8/fXXCA8Px40bN+Dt7Y0jR46gf//+sj8PERHJTDgrV65EamoqhBCYMGEC4uLisHbtWkyYMAFCCFy+fBmrVq2SHVRMTAy2bduGuXPnIiQkxOiexc6dOw0S3TPPPINRo0YBALp164a3337b4PqNGzfWqeOLL75AREQEcnNz4evri8TERAwZMkT2ZyEiIh1ZCWfPnj2QJAmvvvoqPv30U7z00kt4+eWX8emnn+K1116DEAK7d+9WOtYmaTQag3JERESj5WPHjtV5/9ixY1FUVAR/f3+cOHECISEhRv3s8vJyFBcXG7yIiOhnshJOeno6AF0PorZZs2YBADIyMuRHJdOFCxcMyoGBgQZlX19fuLi46MsFBQXIzs7Wl9955x19Dyk7OxvBwcGQJEn/Wrp0aYM/e8WKFVCr1fpXQECA6R+IiMiOyEo47u7uAHTPTGqrGTBQc40l1Y7Hy8urzjVqtdqgrNQAh8WLF6OoqEj/ysrKUqReIiJ7IWtY9IABA6DRaBAbG4tPP/0UnTp1AgDk5ORg0aJFkCQJgwcPVjRQY5SVlRmU27at+/EcHBwMyr985pOUlCT7Zzs5OcHJyUn2+4mI7J2shDN37lxoNBokJyejZ8+e6NOnDyRJwqVLl3D37l0Augf/lubq6oqSkhJ9ub6tr2sfa2ouDhERKUPWLbWoqCg899xzEEJAq9Xi66+/xvnz56HVaiGEwPTp0zF58mSlY22Sj4+PQbmwsLDONbWPdejQwYwRERFRDdkzGdevX49du3Zh+PDhcHNzg1qtxtChQ7Fp0ybEx8crGaPRas+VqT1wIScnR98DAwBvb28uV0NEZCEmTZ1/4okncOLECRQXFyM/Px+ff/45fve73ykVW7ONHj3aoJyYmNhoufb1RERkPna1VstTTz1lsBFcfHy8fm5OZmamwSoEADBnzhyLxkdE1JoZtQFb7969oVKpcPLkSfj6+hosEdNgxZIkewvq3bt3Y/78+fpyfn6+wcN+b29vg903a3bnBHSrICxatMigPrVajZKSElRXV+uPTZo0Cfv375cVnzG4ARsRtQbN+a4zapTa999/b7CD57Vr1yBJUr2brNUcr2/5f2NptVrcunWrwfMFBQUNnouNjcWNGzcQFxenP1ZUVGRwTXh4OHbs2CE7PiIiaj6jEk7Xrl0hSZJ+XktN2VqtXbsWjz76KNavX48vvvgCubm58PT0REhICKZPn47o6Giu/ExEZGFG3VKj5uMtNSJqDRS/pVbbiRMnAABDhw6tM3M/Ly8P//3vf+Hs7Izx48fLqZ6IiOyQrB6OSqWCSqXC9evX4efnZ3Du4sWL+NWvfoUePXrg2rVrigVqa9jDIaLWQPEezg8//ID//ve/BseEEPjoo4/g7e1tcOz8+fMAgBs3bjQ3biIismNG9XDu3LmDXr164fbt20ZX3KtXL9nDou0BezhE1Bo057vOqKFabm5ueOutt/TbSNeovb30L1/PPvusaZ+CiIjsitGDBmJiYuDp6QkhBGbMmAFJkrBu3TqDW2qSJMHZ2RkDBgxAjx49zBIwERHZJqMTTps2bfD0008DANLS0iBJEmbNmtUiG60REZHtUXweTnV1NXJycvDpp5/iueeeU7Jqm8JnOETUGij+DKe28vJyxMTEoGPHjnBwcECbNm30LwcHBwQEBODFF1+UFTwREdknWRM///rXv2Lz5s1Kx0JERHZMVg/no48+giRJ6Nq1K4YNGwZJkhAZGYlx48ZBpVJBkiTs2bNH6ViJiMiGyUo4169fBwB8+OGH2LhxI4QQiI6OxsGDB/H2229DCIEDBw4oGigREdk2WQmnZm8aPz8/BAcHw8vLC19++SUAYMqUKQCApKQkZSIkIiK7ICvhdOrUCQCQkJAAABg4cCD279+PqqoqnD59GgAa3c+GiIhaH1kJZ8yYMRBCYN68ebhy5QpGjhyJS5cuoVOnTpg9ezYkSUKXLl2UjpWIiGyYrITzxz/+EYGBgVCpVOjevTtmzpwJZ2dn5Ofn4969exBCYPbs2UrHSkRENkzWsOiAgACkpKTgk08+gaOjI7p166YfMFBSUoLJkydj0aJFSsdKREQ2jDt+mglXGiCi1sDsKw0QERE1l1G31BwcHKBSqZCZmYnOnTvD0dGxyfdIkoTy8nKTAyQiIvtgVMK5d+8eqqur9XvhVFVVNfkeSZJMi4yIiOyKUQlnxIgRkCQJTk5OBmUiIiJjcdCAmXDQABG1BhYbNHD37l39MjcAkJ6eDq1Wa0qVRERkp2QnnB07dqBr1644c+aM/thf//pXdO7cGdu3b1ckOCIish+yEk5CQgJmzpyJ//3vf/j222/1x1NTU1FcXIzo6GgkJiYqFiQREdk+WQln5cqVEEKga9eu6NOnj/74/Pnz0aNHDwgh8O677yoWJBER2T5ZS9tcuHABkiRh69atGDlypP74448/jvbt2yMiIgIXLlxQKkYiIrIDsno4RUVFAICOHTvWOefj4wMAyM/PNyEsIiKyN7ISTteuXQEAGzdurHPu/fffBwD4+/ubEBYREdkbWbfUIiMjsXLlSsTFxeHo0aMICQlBZWUlzp8/j4yMDEiShMjISIVDJSIiWyZr4mdRURFCQ0ORlpZWZ8UBIQR69+6Ns2fPwsvLS6k4bQ4nfhJRa2D2iZ9qtRqnT59GTEwM1Go1hBAQQsDT0xNz5szBF1980aqTDRER1WXy0jZCCOTl5UEIgQ4dOnCNtZ+wh0NErUFzvutkPcP5pe+//14/THrAgAHo3r27qVUSEZEdkp1wcnNzER0djSNHjhgcHzduHLZs2YIOHTqYHBwREdkPWc9wSktLER4ejiNHjuif39S8Dh8+jIiICNy5c0fpWImIyIbJXtomNTUVQghMmDABcXFxWLt2LSZMmAAhBC5fvoxVq1YpHSsREdkwWYMG+vbti9TUVCxYsKBOYomNjcXq1asRHByMS5cuKRaoreGgASJqDcw+LDo9PR0A8Mwzz9Q5N2vWLABARkaGnKqJiMhOyUo47u7uAIC8vLw653Jzcw2uISIiAmQmnAEDBkAIgdjYWOTk5OiP5+TkYNGiRZAkCYMHD1YsSCIisn2yhkXPnTsXGo0GycnJ6NmzJ/r06QNJknDp0iXcvXsXABATE6NooEREZNtk9XCioqLw3HPPQQgBrVaLr7/+GufPn4dWq4UQAtOnT8fkyZOVjpWIiGyYrIQDAOvXr8euXbswfPhwuLm5Qa1WY+jQodi0aRPi4+OVjJGIiOyAyWupUf04LJqIWgOzD4uuz71793DmzBkkJycrVaVRsrKysGnTJsyePRt9+/aFSqWCJEn6V1JSUpN1JCUlYerUqfD394eTkxN8fX0xZswYxMfHg/mYiEghQqaPP/5YREVFCSGEKC8vF2FhYUKlUgmVSiUmTZokKisr5VbdLG+99ZYA0OArMTGx0fe/9tprjb4/IiJClJaWNjuuoqIiAUAUFRXJ/GRERNavOd91sno4Bw8exJQpU3Dw4EEIIbBt2zacOnVKv57awYMHERcXZ2ouNLs1a9Zg9erVBsfUajVUqp+bJTExETNmzLB0aEREdkdWwlm1ahWqq6vh4+OD4uJi7NmzB5IkYdq0aRg7diyEEPjwww+VjrVeXbp0QXR0NDZs2ICUlBSEhYUZ9b68vDwsWbJEX3Z2doZGo0FhYSHS09MRFBSkP7dv3z4kJCQoHjsRUasipwvl7e0tVCqVOHbsmKiqqhJubm5CpVKJH3/8UXz55ZdCkiTh7u4up2qThYeHG3VLbd26dQbXzZs3z+D8rl27DM5PmTKlWXHwlhoRtQbN+a6TNfGzpKQEANCrVy+kpKSgrKwM3bp1Q6dOnVBWVgZAN4jAmmk0GoNyREREo+Vjx46ZPSYiInsm65ZazdC369ev4z//+Q8AYMSIEQCAU6dOAdDd6rJmFy5cMCgHBgYalH19feHi4qIvFxQUIDs72xKhERHZJVk9nIEDByIxMRHTpk1DYWEhJEnC+PHjcejQIcybNw+SJGH48OFKx6qo2guPenl51blGrVZDq9Xqy7m5ufD396+3vvLycpSXl+vLxcXFygRKZAPKysqQmpra6DVarRaZmZkIDAw0+GOuPsHBwXB1dVUyRLICshLOggULkJiYqP+Lv0ePHnjsscdw+PBhaLVauLq6IjY2VtFAlVZz669G27Z1m8LBwcGg3NgupitWrMCyZcuUCY7IxqSmpiq6YG9ycjIGDRqkWH1kHWQlnPHjx2Pv3r3YsmUL2rdvjyVLlsDBwQHBwcEICgrChg0bcP/99ysdq6JcXV31z6IAoLKyss41tY+5ubk1WN/ixYvx6quv6svFxcUICAhQIFIi6xccHNzkpO/Lly9j+vTp2L59O/r06dNkfWR/ZCUcAIiMjERkZKTBsfvuu6/JbrW18PHxMUg4hYWFda6pfaxDhw4N1ufk5AQnJyelwiOyKa6urkb3SPr06cPeyy8oeTvS2m9Fyk44tZWUlODQoUNwcHDApEmT6tyOsjb9+/c32JU0IyMDoaGh+nJOTo5+qwUA8Pb2bvD5DRGRXErejrT2W5GyE857772HPXv24PPPP0dJSQkefPBBpKWlAQAGDRqExMREq971c/To0di/f7++nJiYiKlTpxqUa19PRKQ0JW9HWv2tSDkTfbZu3SokSRKOjo6isrJSrF69WkiSpH+pVCrxxz/+UU7VJjN24mdubq5wdXXVX+fs7CyOHTsmhBAiIyND9OrVy6Cezz77rFlxcOInkaHk5GQBQCQnJ7d0KDbHmtvO7GupbdiwAYDumY1Wq8W+ffsgSRIWLlyIadOmQQiBffv2mZwMjbF792506tRJ//riiy8Mzj/++OMG52v4+Phg6dKl+vLdu3cxZswYeHl5oWfPnrh27Zr+3KRJk/DrX//a7J+FiMieybqldvnyZUiShH/84x9wdHTEuXPnAAB/+MMfcOPGDezYsQPp6emKBtoQrVaLW7duNXi+oKCgwXOxsbG4ceOGwUKjRUVFBteEh4djx44dpgdKRNTKyerh1Mxh6dy5M86dO4eKigr07t0b7dq104+g+OWKy9Zs7dq1OH78OKKiouDn5wcHBwe0b98eo0aNwpYtW3D8+HGrfhZFRGQrZPVw2rVrh7y8PKSmpuo3OBs5ciQA3dYFgOWWtpk1axZmzZplUh0RERF11k4jIiJlyUo4oaGhOHz4MJ544gncvXsXkiRh4sSJ2L17NxYuXAhJkvjMg4iIDMi67/X666/DwcEBpaWlqKqqwsCBAzFu3Dh4eHjo98l57bXXlI6ViIhsmKweztChQ3Hq1Cn885//RPv27fHyyy9DkiT06dMHY8aMwZo1a9C1a1elYyUiIhsme+LnAw88gAceeMDgWPfu3XH06FGTgyIiIvtjVMK5efMmAN2oNEmS9OWm+Pn5yY+MiIjsilEJx9/fHyqVCtevX4efnx/8/f0hSVKj75EkCVVVVYoESUREts/oW2pCiEbLREREjTEq4cycOROSJOn3g4mOjjZrUEREZH+MSjjbtm0zKG/dutUcsRARkR2zjfVniIjI5jUr4VRWVmLr1q2IjIxEt27d4OHhARcXF3Tp0gXjx4/Hpk2bUFFRYa5YiYjIhhk9aODbb79FVFSUwbL9NQMHcnJy8Nlnn+Gzzz7DihUr8PHHHyMkJET5aImIyGYZ1cO5efMmHnnkEVy7dg1CCAgh4OzsjM6dO6NTp05wcXHRH8/IyMDYsWNx+/Ztc8dOREQ2xKiEs2rVKn0Cef7553Hp0iXcuXMHN27cwM2bN1FaWoq0tDS88cYbcHBwQF5eHt577z2zBk5ERLbFqIRz5MgRSJKEefPm4YMPPqh33+yePXvinXfeweLFiyGE0G9TQEREBBj5DOf69esAgOnTpzd5bWRkJN5++21kZmaaFBgRWY+0tDSUlJSYVMfly5cN/iuXh4cHevfubVIdlsS2+5lRCadmh89OnTo1eW379u0N3kNEti0tLQ1BQUGK1WfMH65NuXr1qk0kHbadIaMSjhACkiTB0dGxyWttZWtpIjJOzV/n27dvR58+fWTXo9VqkZmZicDAQP1W9M11+fJlTJ8+3eQeg6Ww7Qw1a3uCW7duKXINEdmePn36YNCgQSbVMWzYMIWisS1sO51mJZza+98QEREZS/Zq0URERM1hVMLh6tBERGQqoxIOV4cmIiJTNesZDhG1PlqtBGAgLl+WNzpKSboYBv4Uk/Vj2xliwiGiRmVmOgM4DwWmgCigD4DzyMy8DFsYtMW2M8SEQ0SNCgy8C2AQtm/fYdJcEiXo5pJMQ2Dg5haNw1hsO0NMOETUKBcXAeBr9OmjhYlTSRSgBfD1TzFZP7adIS4LQEREFsGEQ0REFsGEQ0REFsGEQ0REFsGEQ0REFsGEQ0REFsGEQ0REFsGEQ0REFsGJn0TUqJrt4s+fP29SPUrtWmlL2HaGmHCIqFGpqakAgJiYmBaO5GceHh4tHYJR2HaGmHCIqFGRkZEAgODgYLi6usquR7eW13Rs377dpHXFPDw80Lt3b9nvtyS2nSEmHCJqlI+PD+bMmaNYfX369MGgll9YzCLYdoY4aICIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCCYeIiCyCG7ARkcnKysr02yk35PLlywb/bYypO2TaEiXbztrbTRJCiJYOwh4VFxdDrVajqKgInp6eLR0OkVmdP38egwcPVqy+5ORkm97ZsjmUbLuWaLfmfNexh0NEJgsODkZycnKj12i1WmRmZiIwMBAuLi5N1tdaKNl21t5u7OGYCXs4RNQaNOe7joMGiIjIIphwiIjIIphwiIjIIphwiIjIIjhKzUxqxmIUFxe3cCREROZT8x1nzPgzJhwzKSkpAQAEBAS0cCREROZXUlICtVrd6DUcFm0m1dXVuHnzJjw8PCBJUkuHY6C4uBgBAQHIysrikO1mYtvJx7aTz5rbTgiBkpIS+Pn5QaVq/CkNezhmolKp4O/v39JhNMrT09PqfnltBdtOPradfNbadk31bGpw0AAREVkEEw4REVkEE04r5OTkhLfeegtOTk4tHYrNYdvJx7aTz17ajoMGiIjIItjDISIii2DCISIii2DCISIii2DCISIii2DCsTPlVeXY/d1uTPhwAnrE9YDzn5zh/VdvhG0Nw/tn30d5VXmTdfzrm39BWibhWPoxC0RsPeS0XbWoxv8l/x+Gbh4KzxWecP6TM+774D78PuH3KLxbaPkP0VLKy4Hdu4EJE4AePQBnZ8DbGwgLA95/X3e+tspKYPVq4Fe/0l3fvj3w298CR45YPv6WJKft6qujf39AkoBr18wfs0wcpWZHLuVewhMfPYGLuRfh6uCK/h37o4tHF/xY+iOSbyaj/F45+nboC81MDTq6d6y3jnM3zmHMv8aguLwYCTMSMKbHGAt/ipYhp+2qRTWi/h2Ffan74NLWBaFdQuHu6I4vb3yJ3LJc9GrXC6eeOdVgW9uNS5eAJ54ALl4EXF11X3xdugA//ggkJ+u+DPv2BTQaoONPbSEEMHkysG8f4OUFDBsG3L0LnDihS0R/+hPwxhst+rEsQk7b1ee114A1a3T/TksDevWyTPzNJcgupP0vTXgs9xBYCvHy4ZdF3p08g/NZRVnikX8+IrAU4v6/3S/KKsrq1PFp6qfC6y9eAkshsBQi4fsES4XfouS23cbkjQJLIXqv6y2+z/9ef33x3WIx8cOJAkshnvjoCYt+FotLSxPCw0MIQIiXXxYiz7DtRFaWEI88ojt///1ClP30e/f3v+uODRhg+J5vvhHC01MISRLi0iXLfY6WILftajt+XNdeujSuq9dKMeHYgerqavHg/z0osBTi9WOvN3hdaXmp6L2ut8BSiHVn1umPZxdli1mfzBLSUkm4/tlVdFzZsdUkHFPa7uHNDwsshThw5UCd62+X3hbSUkk4vuNYb3K3C9XVQjz4oO5L7vWG206UlgrRu7fuunU//d49/LCufPx43evnzdOdW73aPHFbA1Pa7pcKCoQICBAiKEiITp2sPuHwGY4dOHX9FM7dPIfO7p3x5og3G7zOzdENr4e9jrCuYQbH3zj+BralbMNgv8E4M/sMgn2CzR2y1TCl7dq5tEOwTzCG+g+tc30Htw7wdvFGxb0K5JXlmSX2FnfqFHDuHNC5M/Bmw20HNzfg9dd1zyRqaDRASgowYkTd60tLdf9ta8drC5vSdr/0/PPAzZvAP/8J2MAqBHb8v2jrsfvibgBAZHAkXBxcGr121oBZmDVglsGxYJ9gxEfGY3r/6VBJretvEFPa7sBTBxq8NqMgA/nafDi2cUQHtw6KxGp1duvaDpGRgEvjbYdZs3SvGs7OQEhI3ev27wc++kj3POPxxxUK1AqZ0nY1du7Uvd58ExgyROEAzYMJxw6k5qUCAIZ0kfdL94fhf1AyHJtiats15I3jugfe43uPh3NbZ0XrthqpurYz+cuuoACYM0f3AD01FQgIALZtA6x8ew+TmNp2WVm63s3AgcCSJcrFZWat689ZO/Vj6Y8AYP+joczAHG33/tn3sfO7nXB1cMXy0csVq9fq/Khru0ZHTxkjPR34+OOfv4QlSTdqy56Z0nZCANHRgFYL/OtfgIODsrGZEROOHWir0nVUq6qrWjgS26N02607uw7zP5sPCRI2T9ps38/Dap6xVJnYdvfdB+TnA//7H7Brl24o8MsvA3/+s+kxWitT2m7NGiAxUdc+ffsqG5eZMeHYgc7unQEAt+/cbuFIbI9SbSeEwO8Tfo/5n82HSlJh66Nb8WS/J5UI0Xp11rUdbpv4e+furpvo2K4dMHWqrrcjScCKFT8PILA3ctvu229185NGjAAWLFA+LjNjwrEDgzsPBgCczT7b5LVFd4uw8OhCHE47zB4RlGk7baUWUR9F4d0v3oVLWxfsfWIvogdEmy1mqzFY13Y423TboagIWLgQOHy46b/qH34Y6NkTuHMHuHrV9Ditkdy2W7xY1wNUqYCZM4Hp039+5f00GnLhQl358mXzxS9XS4/LJtOdzT4rsBTCb7Wf0FZqG712U/ImgaUQHd7tIKruVdV7TfjW8FYzD8fUtiu6WySGbhoqsBTCd6WvOJN1xhJhW4ezZ3XzPvz8hNA23nZi0ybdtR066OaWvPqqENOm6eaj1KdvX931Z+y0PeW23fDhP0/wbOqVmGiRj9Ic7OHYgdAuoQjrGoabJTex/GTDD6nztflYfkp3fu7guWijamOpEK2WKW1Xea8S4z8cj9PZp9GrXS+cnn0aQ/xtY3iqIkJDdfNDbt4EljcyOCI//+fzc+fqhjzHxwM7duiWsqktIwO4ckU3r6RfP/PE3tLktt3Jkw2nmG7ddNelpenKI0ea/WM0W0tnPFLGd7e+Ey5/chFYCrHwyEJRoC0wOJ+en67/Szzo/SBRUl7SYF2tqYcjhPy2e/3Y6wJLITqt6iSyi7JbIHIr8N13Qri46L7yFi7UzXz/pfR0IYYO1Z0PChKi5Kffu8WLdcf69BHi5s2fr8/KEiI0VHfulVcs9jFahNy2a0i3bla/0gAX77QjZ7LPYOLOicgry4Orgyse8HsAndw7Ibs4G2ezz+KeuId+vv1w6OlD6Kru2mA9I7eNxH9/+G+rWryzuW1XoC2A/3v+KKssQ0jHEPTzbfgv8dVjV9v3kPUzZ4CJE3XPEFxdgQceADp1ArKzdc8o7t3T9VQOHQK6/vR7p9UCv/mNrofj7g4MHw5UVOiuv3MH+PWvdZNAbWD2vEnktF1DAgOBH36w6sU7mXDsTO6dXKw/tx6Hrx3GlbwrKK0ohaeTJ/p37I+pfadi9qDZcGzj2GgdrTHhAM1ru8+ufYbf7vitUfWmvZSGXu2s8wtAMbm5wPr1ugfbV67oRpd5eupWP546FZg9G3Cs9XtXWQnExenmkly5ohsq3K8f8MwzuomgbVrJLV85bVcfJhwiIiIdDhogIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKLYMIhIiKL+H+9hlfm5jhQCAAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 440x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "data_events = [getEvents(p1), getEvents(p2), getEvents(p3), getEvents(p4) ]\n",
    "\n",
    "drawBoxPlot(data_events, labels=labels, ylabel='Dissociation Events', fs=14, logScale=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d9f83bc8",
   "metadata": {},
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}