notebook/Polymer_Similarity_Case3_Varying_Both_Repeat_Units_and_Topologies.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nVg45IXBOyyO"
      },
      "source": [
        "\n",
        "\n",
        "<a target=\"_blank\" href=\"https://colab.research.google.com/github/olsenlabmit/Polymer-Graph-Similarity/blob/main/notebook/Polymer_Similarity_Case3_Varying_Both_Repeat_Units_and_Topologies.ipynb\">\n",
        "  <img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/>\n",
        "</a>"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "cellView": "form",
        "id": "9ExWfHqV1EXI"
      },
      "outputs": [],
      "source": [
        "# @title Copyright & License (click to expand)\n",
        "# MIT License\n",
        "\n",
        "# Copyright (c) 2022 olsenlabmit\n",
        "\n",
        "# Permission is hereby granted, free of charge, to any person obtaining a copy\n",
        "# of this software and associated documentation files (the \"Software\"), to deal\n",
        "# in the Software without restriction, including without limitation the rights\n",
        "# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\n",
        "# copies of the Software, and to permit persons to whom the Software is\n",
        "# furnished to do so, subject to the following conditions:\n",
        "\n",
        "# The above copyright notice and this permission notice shall be included in all\n",
        "# copies or substantial portions of the Software.\n",
        "\n",
        "# THE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\n",
        "# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\n",
        "# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\n",
        "# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\n",
        "# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\n",
        "# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE\n",
        "# SOFTWARE."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_sKD4LKzw0QJ"
      },
      "source": [
        "# Case 3: Varying Both Repeat Units and Topologies"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kA0PTW_O3VxE"
      },
      "source": [
        "This notebook is to perform the calculations and reproduce the results of **Case 3** in the manuscript, Jiale Shi, Nathan J. Rebello, Dylan Walsh, Weizhong Zou, Michael E. Deagen, Bruno Salomao Leao, Debra J. Audus, Bradley D. Olsen, \"Quantifying Pairwise Chemical Similarity for Polymers\", submitted."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-9n8-Ciyiy7G"
      },
      "source": [
        "# Import and Install Necessary Libraries"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "psnOpmYlL_sw"
      },
      "outputs": [],
      "source": [
        "# import necessary libraries available in colab\n",
        "import numpy as np\n",
        "import networkx as nx\n",
        "import matplotlib.pyplot as plt\n",
        "import shutil\n",
        "import sys\n",
        "import os.path\n",
        "\n",
        "# install necessary libraries not available in colab\n",
        "if not shutil.which(\"rdkit\"):\n",
        "    !pip install -q rdkit\n",
        "\n",
        "from rdkit import Chem\n",
        "from rdkit import DataStructs\n",
        "from rdkit.Chem import AllChem\n",
        "from rdkit.Chem import MACCSkeys\n",
        "from rdkit.Chem.AtomPairs import Pairs\n",
        "\n",
        "if not shutil.which(\"pyomo\"):\n",
        "    !pip install -q pyomo\n",
        "    assert shutil.which(\"pyomo\")\n",
        "\n",
        "if not (shutil.which(\"cbc\") or os.path.isfile(\"cbc\")):\n",
        "    if \"google.colab\" in sys.modules:\n",
        "        !apt-get install -y -qq coinor-cbc\n",
        "    else:\n",
        "        try:\n",
        "            !conda install -c conda-forge coincbc\n",
        "        except:\n",
        "            pass\n",
        "\n",
        "assert shutil.which(\"cbc\") or os.path.isfile(\"cbc\")\n",
        "\n",
        "from pyomo.environ import *"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "D2aVwhkeZcX8"
      },
      "source": [
        "# Similarity Score Functions"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HsMcsqU-Pv6Y"
      },
      "source": [
        "## Earth Mover's Distance (EMD) Similarity Function\n",
        "\n",
        "Use the earth mover's distance to compute similarity for repeating units and end groups.\n",
        "\n",
        "\n",
        "$ EMD (P,Q)= \\min_{F}\\sum_{i=1}^{m}\\sum_{j=1}^{n}f_{i,j}d_{i,j}$\n",
        "\n",
        "$ {\\rm subject\\ to\\ } f_{i,j} \\geq 0, {\\rm\\ for\\ any\\ } \\ 1 \\leq i \\leq m, 1 \\leq j \\leq n $\n",
        "\n",
        "$     \\sum_{j=1}^{n}f_{i,j} =w_{pi}, {\\rm for\\ any} \\ 1 \\leq i \\leq m $\n",
        "\n",
        "$     \\sum_{i=1}^{m}f_{i,j} =w_{qj}, {\\rm for\\ any} \\ 1 \\leq j \\leq n $\n",
        "\n",
        "$     \\sum_{i=1}^{m}\\sum_{j=1}^{n}f_{i,j} = \\sum_{i}^{m} w_{pi} = \\sum_{j}^{n} w_{qj} = 1 $ \n",
        "\n",
        "\n",
        "Molecular fragment ensemble $P = \\{(p_1,w_{p_1}) ,(p_2,w_{p_2}),...,(p_i,w_{p_i}),...,(p_m,w_{p_m})\\}$ has $m$ molecular fragments, where $p_i$ is a molecular fragment such as a repeat unit or end group and $w_{p_i}>0$ is the weight, related to the average probability (or frequency, $z$) of the molecular fragment being present in the polymer. Similarly, the second ensemble $Q = {(q_1,w_{q_1}),(q_2,w_{q_2}),...,(q_j,w_{q_j}),...,(q_n,w_{q_n})}$ has $n$ molecular fragments.  The sums of the weights for $P$ and $Q$ are both normalized and equal to one.\n",
        "The distance $d_{i,j}$ is calculated by the converting the pairwise similarity score $s_{i,j}$ between $p_{i}$ and $q_{j}$, where $d_{i,j} = 1 - s_{i,j}$.\n",
        "Transport flow $f_{i,j}$ represents the amount of weight at $p_i$ which is transported to $q_j$. \n",
        "\n",
        "The EMD linear optimization code  refers to [3.1. Transportation Networks, ND Pyomo Notebook](https://jckantor.github.io/ND-Pyomo-Cookbook/notebooks/03.01-Transportation-Networks.html)\n",
        "\n",
        "Once $EMD (P,Q)$ is calculated, the similarity score between $P$ and $Q$ is \n",
        "\n",
        "$S(P,Q) = 1- EMD (P,Q)$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "eOlNnWbfY8Va"
      },
      "outputs": [],
      "source": [
        "def Similarity_Score_EMD_Calculation(\n",
        "    query_smiles_list=None,\n",
        "    query_smiles_weight_list=None,\n",
        "    target_smiles_list=None,\n",
        "    target_smiles_weight_list=None,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "):\n",
        "    # obtain the length of query smiles list and target smiles list\n",
        "    query_smiles_list_length = len(query_smiles_list)\n",
        "\n",
        "    target_smiles_list_length = len(target_smiles_list)\n",
        "\n",
        "    # check whether the query is identical to the target\n",
        "    if set(query_smiles_list) == set(target_smiles_list):\n",
        "        query_smiles_array = np.array(query_smiles_list)\n",
        "        query_smiles_level_array = np.array(query_smiles_weight_list)\n",
        "        inds_query = query_smiles_array.argsort()\n",
        "        sorted_query_smiles_array = query_smiles_array[inds_query]\n",
        "        sorted_query_smiles_level_array = query_smiles_level_array[inds_query]\n",
        "\n",
        "        target_smiles_array = np.array(target_smiles_list)\n",
        "        target_smiles_level_array = np.array(target_smiles_weight_list)\n",
        "        inds_target = target_smiles_array.argsort()\n",
        "        sorted_target_smiles_array = target_smiles_array[inds_target]\n",
        "        sorted_target_smiles_level_array = target_smiles_level_array[inds_target]\n",
        "\n",
        "        if np.array_equal(\n",
        "            sorted_query_smiles_array, sorted_target_smiles_array\n",
        "        ) and np.array_equal(\n",
        "            sorted_query_smiles_level_array, sorted_target_smiles_level_array\n",
        "        ):\n",
        "            return 1.0\n",
        "\n",
        "        query_smiles_reduced_list = list(set(query_smiles_list))\n",
        "        query_smiles_reduced_list_number = []\n",
        "\n",
        "        for i in range(0, len(query_smiles_reduced_list)):\n",
        "            query_smiles_reduced_list_number_i = 0\n",
        "            for j in range(0, len(query_smiles_list)):\n",
        "                if query_smiles_reduced_list[i] == query_smiles_list[j]:\n",
        "                    query_smiles_reduced_list_number_i = (\n",
        "                        query_smiles_reduced_list_number_i + query_smiles_weight_list[j]\n",
        "                    )\n",
        "\n",
        "            query_smiles_reduced_list_number.append(\n",
        "                query_smiles_reduced_list_number_i / sum(query_smiles_weight_list)\n",
        "            )\n",
        "\n",
        "        target_smiles_reduced_list = list(set(target_smiles_list))\n",
        "        target_smiles_reduced_list_number = []\n",
        "\n",
        "        for i in range(0, len(target_smiles_reduced_list)):\n",
        "            target_smiles_reduced_list_number_i = 0\n",
        "            for j in range(0, len(target_smiles_list)):\n",
        "                if target_smiles_reduced_list[i] == target_smiles_list[j]:\n",
        "                    target_smiles_reduced_list_number_i = (\n",
        "                        target_smiles_reduced_list_number_i\n",
        "                        + target_smiles_weight_list[j]\n",
        "                    )\n",
        "\n",
        "            target_smiles_reduced_list_number.append(\n",
        "                target_smiles_reduced_list_number_i / sum(target_smiles_weight_list)\n",
        "            )\n",
        "\n",
        "        if query_smiles_reduced_list_number == target_smiles_reduced_list_number:\n",
        "            return 1.0\n",
        "\n",
        "    # transfer SMILES to fingerprints\n",
        "    if embedding_function == \"RDKFingerprint\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [Chem.RDKFingerprint(x) for x in query_mol_list]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [Chem.RDKFingerprint(x) for x in target_mol_list]\n",
        "\n",
        "    elif embedding_function == \"MorganFingerprint\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [\n",
        "            AllChem.GetMorganFingerprintAsBitVect(x, 2, nBits=2048)\n",
        "            for x in query_mol_list\n",
        "        ]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [\n",
        "            AllChem.GetMorganFingerprintAsBitVect(x, 2, nBits=2048)\n",
        "            for x in target_mol_list\n",
        "        ]\n",
        "\n",
        "    elif embedding_function == \"MACCSkeys\":\n",
        "        query_mol_list = [Chem.MolFromSmiles(x) for x in query_smiles_list]\n",
        "        query_fingerprint_list = [MACCSkeys.GenMACCSKeys(x) for x in query_mol_list]\n",
        "        target_mol_list = [Chem.MolFromSmiles(x) for x in target_smiles_list]\n",
        "        target_fingerprint_list = [MACCSkeys.GenMACCSKeys(x) for x in target_mol_list]\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            embedding_function\n",
        "            + \" is not included in the current vision.\"\n",
        "            + \" Please choose an available embedding function:\"\n",
        "        )\n",
        "        print(\"MorganFingerprint, RDKFingerprint, MACCSkeys.\")\n",
        "        return False\n",
        "\n",
        "    # define the required three sets\n",
        "    Demand = {}  # query\n",
        "    Supply = {}  # target\n",
        "    T = {}  # transport flow\n",
        "\n",
        "    # define the weight for SMILES in query, w_i\n",
        "    if len(set(query_smiles_weight_list)) == 1:\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            Demand[\"P\" + str(i + 1)] = 1 / query_smiles_list_length\n",
        "\n",
        "    else:\n",
        "        query_weight_sum = sum(query_smiles_weight_list)\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            Demand[\"P\" + str(i + 1)] = query_smiles_weight_list[i] / query_weight_sum\n",
        "\n",
        "    # define weight for SMILES in target, w_j\n",
        "    if len(set(target_smiles_weight_list)) == 1:\n",
        "        for j in range(0, target_smiles_list_length):\n",
        "            Supply[\"Q\" + str(j + 1)] = 1 / target_smiles_list_length\n",
        "\n",
        "    else:\n",
        "        target_weight_sum = sum(target_smiles_weight_list)\n",
        "        for j in range(0, target_smiles_list_length):\n",
        "            Supply[\"Q\" + str(j + 1)] = target_smiles_weight_list[j] / target_weight_sum\n",
        "\n",
        "    # use similarity function to calculate d_ij\n",
        "    if similarity_score_function == \"Tanimoto\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i], target_fingerprint_list[j]\n",
        "                )\n",
        "\n",
        "    elif similarity_score_function == \"Dice\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i],\n",
        "                    target_fingerprint_list[j],\n",
        "                    metric=DataStructs.DiceSimilarity,\n",
        "                )\n",
        "\n",
        "    elif similarity_score_function == \"Cosine\":\n",
        "        for i in range(0, query_smiles_list_length):\n",
        "            for j in range(0, target_smiles_list_length):\n",
        "                T[\n",
        "                    (\"P\" + str(i + 1), \"Q\" + str(j + 1))\n",
        "                ] = 1 - DataStructs.FingerprintSimilarity(\n",
        "                    query_fingerprint_list[i],\n",
        "                    target_fingerprint_list[j],\n",
        "                    metric=DataStructs.CosineSimilarity,\n",
        "                )\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            similarity_score_function\n",
        "            + \" is not included in the current vision.\"\n",
        "            + \" Please choose an available similarity function:\"\n",
        "        )\n",
        "        print(\"Tanimoto, Dice, or Cosine\")\n",
        "        return\n",
        "\n",
        "    # linear optimization with pyomo\n",
        "    # step 0: Create an instance of the model\n",
        "    model = ConcreteModel()\n",
        "    model.dual = Suffix(direction=Suffix.IMPORT)\n",
        "\n",
        "    # step 1: define index sets\n",
        "    CUS = list(Demand.keys())\n",
        "    SRC = list(Supply.keys())\n",
        "\n",
        "    # step 2: define the decision\n",
        "    model.x = Var(CUS, SRC, domain=NonNegativeReals)\n",
        "\n",
        "    # step 3: define objective\n",
        "    model.Cost = Objective(\n",
        "        expr=sum([T[c, s] * model.x[c, s] for c in CUS for s in SRC]), sense=minimize\n",
        "    )\n",
        "\n",
        "    # step 4: define constraints\n",
        "    model.src = ConstraintList()\n",
        "    for s in SRC:\n",
        "        model.src.add(sum([model.x[c, s] for c in CUS]) == Supply[s])\n",
        "\n",
        "    model.dmd = ConstraintList()\n",
        "    for c in CUS:\n",
        "        model.dmd.add(sum([model.x[c, s] for s in SRC]) == Demand[c])\n",
        "\n",
        "    # step 5: solve the model\n",
        "    results = SolverFactory(\"cbc\").solve(model)\n",
        "\n",
        "    if \"ok\" == str(results.Solver.status):\n",
        "        SimilarityScore = 1 - model.Cost()\n",
        "        return SimilarityScore\n",
        "\n",
        "    else:\n",
        "        print(\"No Valid Solution Found\")\n",
        "        return False"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fNpt-pIDQLOX"
      },
      "source": [
        "## Topology Similarity Function\n",
        "\n",
        "Use graph edit distance $GED(g_1, g_2)$ to compute the topological similarity $S_{\\rm TOP}(g_1,g_2)$.\n",
        "\n",
        "$GED(g_1, g_2)$  is computed via a networkx function [graph_edit_distance](https://networkx.org/documentation/stable/reference/algorithms/generated/networkx.algorithms.similarity.graph_edit_distance.html), while the topological similarity score $S_{\\rm TOP}(g_1,g_2)$ in the range of (0,1] is computed via a exponential decay function:\n",
        "\n",
        "\n",
        "$S_{\\rm TOP}(g_1, g_2) = \\exp(-\\frac{\\alpha \\cdot GED(g_1, g_2)}{(N_1 + N_2)/2})$\n",
        "\n",
        "where $N_i$ is the number of nodes in graph $g_i$."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "id": "oyUi54M_IorG"
      },
      "outputs": [],
      "source": [
        "def Topology_Similarity_Score_Calculation(Graph1=None, Graph2=None, alpha=1):\n",
        "    if Graph1 == None:\n",
        "        print(\"Missing Graph1\")\n",
        "        return\n",
        "    if Graph2 == None:\n",
        "        print(\"Missing Graph2\")\n",
        "        return\n",
        "\n",
        "    Graph1_number_nodes = Graph1.number_of_nodes()\n",
        "    Graph2_number_nodes = Graph2.number_of_nodes()\n",
        "\n",
        "    graph_edit_distance = nx.graph_edit_distance(Graph1, Graph2)\n",
        "\n",
        "    topology_similarity_score = np.exp(\n",
        "        -alpha * graph_edit_distance / ((Graph1_number_nodes + Graph2_number_nodes) / 2)\n",
        "    )\n",
        "\n",
        "    return topology_similarity_score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "v_4bM0zPQRGC"
      },
      "source": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "7bdTaiEZQelj"
      },
      "source": [
        "## Weighted Mean Function for Overall Pairwise Similarity Score $S_{\\rm OA}$ \n",
        "\n",
        "From the above EMD and GED calculations, three similarity scores are obtained: $S_{\\rm RU}$  for repeat units, $S_{\\rm EG}$  for end groups, and $S_{\\rm TOP}$   for topology. To calculate the overall similarity score $S_{\\rm OA}$. Two weighted mean functions are provided. \n",
        "\n",
        "1. weighted geometric mean\n",
        "\n",
        "$S_{\\rm OA} =  S_{\\rm RU}^{W_{\\rm RU}} \\cdot S_{\\rm TOP}^{W_{\\rm TOP}} \\cdot S_{\\rm EG}^{W_{\\rm EG}} $ \n",
        "\n",
        "2. weighted arithmetic mean\n",
        "\n",
        "$S_{\\rm OA} =  S_{\\rm RU} \\cdot W_{\\rm RU} + S_{\\rm TOP} \\cdot W_{\\rm TOP} +  S_{\\rm EG} \\cdot W_{\\rm EG} $ \n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "id": "tnGFkpht12nw"
      },
      "outputs": [],
      "source": [
        "def Overall_Similarity_Score_Calculation(\n",
        "    query=None,\n",
        "    target=None,\n",
        "    embedding_function=\"RDKFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"geometric\",\n",
        "    details_print=False,\n",
        "    return_with_components=False,\n",
        "):\n",
        "    if query == None or target == None:\n",
        "        print(\n",
        "            \"Either query polymer or target polymer is missing! Please check the input.\"\n",
        "        )\n",
        "        return\n",
        "\n",
        "    Repeat_Unit_Similarity_Score = Similarity_Score_EMD_Calculation(\n",
        "        query_smiles_list=query.repeat_unit_smiles_list,\n",
        "        query_smiles_weight_list=query.repeat_unit_smiles_weight_list,\n",
        "        target_smiles_list=target.repeat_unit_smiles_list,\n",
        "        target_smiles_weight_list=target.repeat_unit_smiles_weight_list,\n",
        "        embedding_function=embedding_function,\n",
        "        similarity_score_function=similarity_score_function,\n",
        "    )\n",
        "\n",
        "    Topology_Similarity_Score = Topology_Similarity_Score_Calculation(\n",
        "        Graph1=query.graph_representation,\n",
        "        Graph2=target.graph_representation,\n",
        "        alpha=alpha,\n",
        "    )\n",
        "\n",
        "    if len(query.end_group_smiles_list) == 0 and len(target.end_group_smiles_list) == 0:\n",
        "        End_Group_Similarity_Score = 1.0\n",
        "\n",
        "    elif (\n",
        "        len(query.end_group_smiles_list) == 0 and len(target.end_group_smiles_list) != 0\n",
        "    ) or (\n",
        "        len(query.end_group_smiles_list) != 0 and len(target.end_group_smiles_list) == 0\n",
        "    ):\n",
        "        End_Group_Similarity_Score = 1.0\n",
        "\n",
        "    else:\n",
        "        End_Group_Similarity_Score = Similarity_Score_EMD_Calculation(\n",
        "            query_smiles_list=query.end_group_smiles_list,\n",
        "            query_smiles_weight_list=query.end_group_smiles_weight_list,\n",
        "            target_smiles_list=target.end_group_smiles_list,\n",
        "            target_smiles_weight_list=target.end_group_smiles_weight_list,\n",
        "            embedding_function=embedding_function,\n",
        "            similarity_score_function=similarity_score_function,\n",
        "        )\n",
        "\n",
        "    # verify whether the weight sum is normalized.\n",
        "    if abs(Repeat_Unit_Weight + Topology_Weight + End_Group_Weight - 1) != 0.0:\n",
        "        Weight_Sum = Repeat_Unit_Weight + Topology_Weight + End_Group_Weight\n",
        "\n",
        "        Repeat_Unit_Weight = Repeat_Unit_Weight / Weight_Sum\n",
        "\n",
        "        Topology_Weight = Topology_Weight / Weight_Sum\n",
        "\n",
        "        End_Group_Weight = End_Group_Weight / Weight_Sum\n",
        "\n",
        "    if Mean_Function == \"geometric\":\n",
        "        Overall_Similarity_Score = (\n",
        "            pow(Repeat_Unit_Similarity_Score, Repeat_Unit_Weight)\n",
        "            * pow(Topology_Similarity_Score, Topology_Weight)\n",
        "            * pow(End_Group_Similarity_Score, End_Group_Weight)\n",
        "        )\n",
        "\n",
        "    elif Mean_Function == \"arithmetic\":\n",
        "        Overall_Similarity_Score = (\n",
        "            Repeat_Unit_Weight * Repeat_Unit_Similarity_Score\n",
        "            + Topology_Weight * Topology_Similarity_Score\n",
        "            + End_Group_Weight * End_Group_Similarity_Score\n",
        "        )\n",
        "\n",
        "    else:\n",
        "        print(\n",
        "            \"Your input mean function \",\n",
        "            Mean_Function,\n",
        "            \" is not implemented currently.\"\n",
        "            + \" Please choose those implemented mean functions, such as arithmetic, geometric\",\n",
        "        )\n",
        "        return\n",
        "\n",
        "    if details_print == True:\n",
        "        print(\"Details of the Similarity Score:\\n\")\n",
        "        print(\n",
        "            \"Repeat Unit Similarity Score = \",\n",
        "            Repeat_Unit_Similarity_Score,\n",
        "            \", Normalized Weight for Repeat Unit = \",\n",
        "            Repeat_Unit_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"Topology Similarity Score = \",\n",
        "            Topology_Similarity_Score,\n",
        "            \", Normalized Weight for Topology = \",\n",
        "            Topology_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"End Group Similarity  = \",\n",
        "            End_Group_Similarity_Score,\n",
        "            \", Normalized Weight for End Group = \",\n",
        "            End_Group_Weight,\n",
        "        )\n",
        "        print(\n",
        "            \"Overall Pairwise Similarity Score with \"\n",
        "            + Mean_Function\n",
        "            + \" mean function = \",\n",
        "            Overall_Similarity_Score,\n",
        "        )\n",
        "        print(\"\\n\")\n",
        "\n",
        "    if return_with_components == True:\n",
        "        return (\n",
        "            Overall_Similarity_Score,\n",
        "            Repeat_Unit_Similarity_Score,\n",
        "            Topology_Similarity_Score,\n",
        "            End_Group_Similarity_Score,\n",
        "        )\n",
        "\n",
        "    return Overall_Similarity_Score"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bijKjSMqQ-gw"
      },
      "source": [
        "# Define Polymer Class for Importing Polymer data\n",
        "\n",
        "The polymer graph is decomposed into three components: repeat units, end groups and topology. \n",
        "\n",
        "(I) To compute $S_{\\rm RU}$  for repeat units, we need the polymer's (1) repeat unit SMILES list and (2) corresponding weight list.\n",
        "\n",
        "(II) To compute $S_{\\rm EG}$  for end groups, we need the polymer's (3) end group SMILES list and (4) corresponding weight list.\n",
        "\n",
        "(III) To compute $S_{\\rm TOP}$ for topology, we need the polymers' (5) topological graph representation.\n",
        "\n",
        "Therefore, in the Polymer Class, we have to define the above five elements which are required to perform polymer similarity calculation."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "k-I92q5zfd_L"
      },
      "outputs": [],
      "source": [
        "class Polymer:\n",
        "    def __init__(\n",
        "        self,\n",
        "        repeat_unit_smiles_list=None,\n",
        "        repeat_unit_smiles_weight_list=None,\n",
        "        end_group_smiles_list=None,\n",
        "        end_group_smiles_weight_list=None,\n",
        "        graph_representation=None,\n",
        "    ):\n",
        "        if repeat_unit_smiles_list == None:\n",
        "            print(\n",
        "                \"Error: Repeat Unit SMILES are missing.\"\n",
        "                + \" Please define the Repeat Unit SMILES.\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.repeat_unit_smiles_list = repeat_unit_smiles_list\n",
        "\n",
        "        if repeat_unit_smiles_weight_list == None:\n",
        "            print(\n",
        "                \"Error: Repeat Unit weights are missing.\"\n",
        "                + \" Please re-enter the correct Repeat Unit weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        elif len(repeat_unit_smiles_weight_list) != len(repeat_unit_smiles_list):\n",
        "            print(\n",
        "                \"Error: Repeat Unit weights are not correct.\"\n",
        "                + \" Please re-enter the correct Repeat Unit SMILES and weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.repeat_unit_smiles_weight_list = repeat_unit_smiles_weight_list\n",
        "\n",
        "        if end_group_smiles_list == None and end_group_smiles_weight_list == None:\n",
        "            self.end_group_smiles_list = []\n",
        "            self.end_group_smiles_weight_list = []\n",
        "            print(\n",
        "                \"Notice: The Polymer has NO End Group.\\n\"\n",
        "                + \"If this is what you want, this message is NOT Error.\\n\"\n",
        "                + \"Otherwise, please enter the correct End Group SMILES and weights.\\n\"\n",
        "            )\n",
        "\n",
        "        elif (\n",
        "            end_group_smiles_list == None and end_group_smiles_weight_list != None\n",
        "        ) or (end_group_smiles_list != None and end_group_smiles_weight_list == None):\n",
        "            print(\n",
        "                \"Error: End Group SMILES and weights are not matching.\"\n",
        "                + \" Please re-enter the correct End Group SMILES and weights.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            if len(end_group_smiles_list) != len(end_group_smiles_weight_list):\n",
        "                print(\n",
        "                    \"Error: End Group SMILES and weights are not matching.\"\n",
        "                    + \" Please re-enter the correct End Group SMILES and weights.\\n\"\n",
        "                )\n",
        "                return\n",
        "\n",
        "            else:\n",
        "                if (\n",
        "                    len(end_group_smiles_list) == 0\n",
        "                    and len(end_group_smiles_weight_list) == 0\n",
        "                ):\n",
        "                    print(\n",
        "                        \"Notice: The Polymer has NO End Group.\\n\"\n",
        "                        + \"If this is what you want, this message is NOT Error.\\n\"\n",
        "                        + \"Otherwise, please enter the correct End Group SMILES and weights.\\n\"\n",
        "                    )\n",
        "\n",
        "                self.end_group_smiles_list = end_group_smiles_list\n",
        "                self.end_group_smiles_weight_list = end_group_smiles_weight_list\n",
        "\n",
        "        if graph_representation == None:\n",
        "            print(\n",
        "                \"Error: Topology graph representation is missing.\"\n",
        "                + \" Please define the topology graph representation.\\n\"\n",
        "            )\n",
        "            return\n",
        "\n",
        "        else:\n",
        "            self.graph_representation = graph_representation"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "vE5C5Cf0zSbF"
      },
      "source": [
        "# Case 3: Varying Both Repeat Units and Topologies\n",
        "\n",
        "Case 3 computes the similarity between polymers that have both different chemistries and different topologies. Three block copolymers which have both different repeat units and different topological graph representations are shown below: C3-1, a diblock polymer; C3-2, a triblock polymer; and C3-3, a tetrablock polymer. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "93332dHdzs9Y"
      },
      "source": [
        "# Define Polymers in Case 3"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eIHJx_8wpS33"
      },
      "source": [
        "## Polymer C3-1\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1Pm0DV0rW4YHwpIlROJMw9MFADels7xlP\"  width=\"50%\" height=\"50%\">"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "4gg0HbRJzsNw",
        "outputId": "b982161f-6956-4535-9dfa-e3ca43db605b"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polymer_C3_1_top_graph_representation number of nodes:  8\n",
            "Polymer_C3_1_top_graph_representation number of edges:  11\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABRuUlEQVR4nO3df3zNdf/H8ec5ZzY2v6eJq61hKLP8yO9fo5/om5CiqKsrXZWUIlRKftWQ+VGEonJFNaGhJOJazO/5FUY22owMbWPsLJvtnO8fZVeKMuecfc7Oedz/uW4cfT5PLuzp/fp83m+T3W63CwAAALhGZqMDAAAAoHSjUAIAAMAhFEoAAAA4hEIJAAAAh1AoAQAA4BAKJQAAABxCoQQAAIBDKJQAAABwCIUSAAAADqFQAgAAwCEUSgAAADiEQgkAAACHUCgBAADgEAolAAAAHEKhBAAAgEMolAAAAHAIhRIAAAAOoVACAADAIRRKAAAAOIRCCQAAAIdQKAEAAOAQCiUAAAAcQqEEAACAQyiUAAAAcAiFEgAAAA6hUAIAAMAhFEoAAAA4hEIJAAAAh1AoAQAA4BAKJQAAABxCoQQAAIBDKJQAAABwCIUSAAAADqFQAgAAwCEUSgAAADiEQgkAAACHUCgBAADgEB+jAwCeyJpXoNRMq/ILbPL1MSs0MEABfvxxAwB4Jr7CAU6SfPKcPtmapriDp5SWlSv77z4zSQqp6q9O9YPUt2WI6lavYFRMAACczmS32+1//8MAXMnRrFyNiN2r+EMZsphNKrRd+Y/Uxc/bh1VTVI8IBVf1L8GkAAC4BoUScEBMQppGLU9Ugc3+l0Xyjyxmk3zMJo3pFq4+zUNcmBAAANejUALXaEZcsqJXJzl8naF31dOzneo6IREAAMbgLW/gGsQkpDmlTEpS9OokLUxIc8q1AAAwAoUSKKajWbkatTzRqdd8fXmijmblOvWaAACUFAolUEwjYveqoBjPS16NAptdI2L3OvWaAACUFAolUAzJJ88p/lBGsV7AuRqFNrviD2Xo0KlzTr0uAAAlgUIJFMMnW9NkMZtccm2L2aQFW3iWEgBQ+lAogWKIO3jK6auTFxXa7IpLOuWSawMA4EoUSuAq5eQVKM3FL86kZebKmlfg0nsAAOBsFErgKh3JtMrVm7baJaVmWl18FwAAnItCCVyl/AKbR90HAABnoVACV8nXp2T+uJTUfQAAcBa+cgFXKTQwQK55v/t/TL/dBwCA0oRCCVylAD8fhVT1d+k9QgL9FeDn49J7AADgbBRKoBg61Q9y6T6UneoFueTaAAC4EoUSKIa+LUNcug9lv1YhLrk2AACuRKEEiqFu9QpqH1bN6auUFrNJ7cOqKSyoglOvCwBASaBQAsUU1SNCPk4ulD5mk6J6RDj1mgAAlBQKJVBMwVX9NaZbuFOvObZbuIJd/MIPAACuQqEErkGf5iEaelc9p1xr2F311bs5z04CAEovk91ud/VpcoDHiklI06jliSqw2Yv1so7FbJKP2aSx3cIpkwCAUo9CCTjoaFauRsTuVfyhDFnMpr8slmaTZLNL7cOqKapHBGNuAIBHoFACTpJ88pw+2ZqmuKRTSsvM1e//YJkk5Wcdl/34Pq2ZNUoNbqhqVEwAAJyOQgm4gDWvQKmZVuUX2OTrY1Y1P7uur1ZFktS5c2ctXbpUfn5+BqcEAMA5KJRACdi1a5eaNm1a9O177rlHX3zxhXx9fQ1MBQCAc/CWN1ACkpKSLvn2ypUr1atXL+Xn5xuUCAAA56FQAiUgOTlZPj4+Rd+22Wz68ssvNWDAAANTAQDgHBRKoAQkJyfLZrNd8n3VqlVTRASn4wAASj+fv/8hABx17Ngx2Ww2VatWTRkZGWrSpIkSEhJksViMjgYAgMN4KQcoAfv379eZM2fUqlUr1alTR+np6Tp//rzRsQAAcApG3kAJaNCggdq0aSOz2aw+ffooLy9PK1euNDoWAABOwQolUMKysrIUGBio22+/XWvWrDE6DgAADqNQAga48cYbderUKf3yyy9GRwEAwGGMvAEDPPjggzp//ry+/fZbo6MAAOAwVigBA2RkZOi6667TXXfdpVWrVhkdBwAAh1AoAYMEBwcrMzNTubm5RkcBAMAhjLwBgzzwwAP65ZdfFBcXZ3QUAAAcwgolYJBTp06pevXq6tKli77++muj4wAAcM0olICBbrjhBp0+fVpWq9XoKAAAXDNG3oCBevbsqdzcXMXHxxsdBQCAa8YKJWCg48eP6x//+IfuueceffXVV0bHAQDgmlAoAYPVrFlTZ8+eVU5OjtFRAAC4Joy8AYP16NFDVqtVmzdvNjoKAADXhBVKwGDHjh1TcHCw7rvvPi1dutToOAAAFBuFEnAD119/vaxWq86dO2d0FAAAio2RN+AGunfvrpycHCUkJBgdBQCAYmOFEnADR44cUWhoqHr06KEvvvjC6DgAABQLhRJwE9WrV9f58+eVnZ1tdBQAAIqFkTfgJu69916dPXtWO3fuNDoKAADFwgol4CZSUlJUu3Zt9erVS4sWLTI6DgAAV41CCbiR6667ThcuXNCZM2eMjgIAwFVj5A24kf/7v/9Tdna29uzZY3QUAACuGoUScCOvvvqqJCkqKsrgJAAAXD1G3oCbqVatmgoLC3X69GmjowAAcFVYoQTcTNeuXXXmzBklJiYaHQUAgKtCoQTcDGNvAEBpw8gbcEOBgYGy2+3KysoyOgoAAH+LFUrADXXu3FmnT5/WgQMHjI4CAMDfolACbmjEiBGSpPHjxxucBACAv8fIG3BTVapUkcViUUZGhtFRAAD4S6xQAm7q7rvvVmZmppKTk42OAgDAX6JQAm7q4tibt70BAO6OkTfgxipXrqwyZcro559/NjoKgCuw5hUoNdOq/AKbfH3MCg0MUICfj9GxgBLF73jAjd15551avHixUlJSVKtWLaPjAPhN8slz+mRrmuIOnlJaVq5+vzJjkhRS1V+d6gepb8sQ1a1ewaiYQIlhhRJwYzt37tStt96q/v37a+7cuUbHAbze0axcjYjdq/hDGbKYTSq0XflL6MXP24dVU1SPCAVX9S/BpEDJ8vpCyagC7q5SpUry8/PTqVOnjI4CeLWYhDSNWp6oApv9L4vkH1nMJvmYTRrTLVx9moe4MCFgHK8slIwqUJr07NlTsbGxSk1N1Y033mh0HMArzYhLVvTqJIevM/Suenq2U10nJALci1cVSkYVKI0SEhLUokULPfXUU5o9e7bRcQCvE5OQppe/2Ou0603sGaHerFTCw3hNoWRUgdKsQoUKKl++vNLT042OAniVo1m5umPqOuUV2Jx2TT8fs9YMjmShAh7FK/ahnBGXrJe/2Ku8AluxyqQkFdrsyiuw6eUv9mpGHBtMwxi33367Tpw4oWPHjhkdBfAqI2L3qqCYXzf+ToHNrhGxzlvxBNyBxxfKmIQ0pzz3IknRq5O0MCHNKdcCiuOll16SxNneQElKPnlO8Ycyir0Q8XcKbXbFH8rQoVPnnHpdwEgeXSiPZuVq1PJEp17z9eWJOpqV69RrAn+ndevWCggIUGxsrNFRAK/xydY0Wcwml1zbYjZpwRYWKOA5PLpQMqqAJ+nYsaPS09N1/Phxo6MAXiHu4Cmnr05eVGizKy6JrcDgOTy2UDKqgKd5+eWXJUkTJkwwOAng+XLyCpTm4mlUWmaurHkFLr0HUFI8tlAyqoCnadeunfz9/fXFF18YHQXweEcyrXL1Fih2SamZVhffBSgZHlsoGVXAE0VGRuqnn37i1BzAxfKduE2QO9wHcDWPLJSMKuCphg8fLomxN+Bqvj4l8+WxpO4DuJpH/k5mVAFP1bFjR5UrV06LFi0yOgrg0UIDA+Sah6b+x/TbfQBP4JGFklEFPFn79u117NgxZWRkGB0F8FgBfj4KcfFJNiGB/grw83HpPYCS4pGFklEFPNnQoUMlSRMnTjQ4CeDZOtUPcunLnZ3qBbnk2oARPLIRlcSowm63q999d2vw4MGKjY1ltQgl5s4771TZsmX1+eefGx0F8Gh9W4a49OXOfq1CXHJtwAgeWShLYlRR1bdQjcJv0tKlS9WzZ09dd911atiwoQYOHKiFCxcqPT3dpfeHd2vXrp3S0tKUlZVldBTAY9WtXkHtw6o5fZXSYjapfVg1hQVVcOp1ASN5ZKGUXD+quK9ZmObNm6eUlBQdOXJE8+fPV5s2bbR27Vr16dNHNWvWVL169fTEE09o/vz5OnLkiEuywDsNGTJEkjRp0iSDkwCeLapHhHyc/LXEx2xSVI8Ip14TMJrJbre7+oVoQySfPKc7p6132fXXDO5wxX9dnjhxQvHx8Vq3bp3Wr1+vvXt/ParxxhtvVIcOHRQZGakOHTooLCxMJpOrh/PwVOXKlVP16tWVmppqdBTAo8UkpOnlL5x35O7EnhHq3ZxxNzyLxxZKSXrkg63a9GOmU5+BsZhNalM7UPP7t7zq/yYzM1MbNmwoKpi7du2SzWZTjRo11KFDh6KSefPNN8ts9thFYzjZbbfdpri4OJ0+fVqVK1c2Og7g0WbEJSt6dZLD1xl2V30N7BTmhESAe/HoQnk0K1d3TF2nPCdu7+PnY9aawZEKduAZzezsbG3atKmoYCYkJKigoECBgYGXFMxbbrlFFovFadnhWb766ivde++9evXVV/XGG28YHQfweDEJaRq1PFEFNnuxFiosZpN8zCaN7RbOyiQ8lkcXSql0jCqsVqu2bNmi9evXa926ddqyZYvy8vJUqVIltWvXrqhk3nrrrSpTpoxT743SrWzZsvrHP/6hw4cPGx0F8ApHs3I1Inav4g9lyGS3yW668lTJYjap0GZX+7BqiuoR4dBCBODuPL5QSqVvVJGXl6dt27Zp/fr1Wr9+vTZu3Cir1Sp/f3+1adOm6BnMFi1aqGzZsi7PA/fVsWNHrVu3TtnZ2apYsaLRcQCvsW7XQfUcPlWVG7SVzb/qJaezmfTrpuWd6gWpX6sQ3uaGV/CKQimV7lHFhQsXtGvXrqIReXx8vLKzs+Xn56eWLVsWFczWrVsrIIBjvLxJbGysevbsqVGjRmn06NFGxwG8QmZmpho2bKgTJ06oWbNm+m7DZqVmWpVfYJOvj1mhgQGcgAOv4zWFUrp0VHFxFHEl7jyqKCws1N69e4sK5vr165WRkSEfHx81a9as6BnMtm3bqlKlSkbHhQvZbDaVK1dOwcHBOnTokNFxAI+Xk5Ojjh07aseOHZKkm2++Wfv37zc4FWA8ryqUFyWfPKdPtqYpLumU0jJzS/2owm6368CBA0XPYK5bt07p6ekym81q3LhxUcFs3769AgMDjY4LJ2vfvr02btyos2fPqnz58kbHATxWfn6+unbtqri4ONlsv77s6ePjI6vVKl9fX4PTAcbyykL5e9a8Ao8bVdjtdh0+fLioYK5fv75or8KGDRsWveTToUMH1ahRw9iwcNiiRYv04IMPauzYsRo5cqTRcQCP1adPH33++ef645fN77//XrfccotBqQD34PWF0lukpaUVjcfXrVunpKRfX1KqW7du0TOYkZGRCglhS4vSxmazqWzZsgoNDS36/xWAc50/f17BwcHKyMiQ2WwuWqGUpHnz5umf//yngekA41EovdSJEycuKZj79u2T9OtpPhcLJqf5lB5t27bV5s2blZOTI39/93neF/Ak58+f1/r169W7d2+dOXOm6PuHDx+uiRMnGhcMcAMUSkj69a3F+Pj4ooK5e/fuS07zuVgyGzRoQMF0Q5999pkefvhhRUVF6ZVXXjE6DuCxbDabypQpoyZNmmjRokVas2aN2rdvr5tuusnoaIChKJS4rCud5lOtWjW1b9++qGBymo97sNls8vPzU506dfTDDz8YHQfwWAsXLlSfPn301ltvadiwYUbHAdwGhRJX5eJpPhcL5uVO84mMjFTTpk05zccgrVq10rZt25Sbm8uG94CL3H333Vq9ejWHCQB/QKHENTl//rwSEhKKRuSbNm2S1WpVQECA2rRpU1QwmzdvTrkpIfPnz9ejjz7KygngQpUqVZK/v7/S09ONjgK4FQolnOLChQvauXNnUcHcsGEDp/mUsItj77p167LRMuACR44cUWhoqB5++GF98sknRscB3AqFEi5RWFioPXv2FL1J/sfTfC4WTE7zca4WLVpo+/btOn/+PBstA0724osvasqUKdq4caPatGljdBzArVAoUSJsNpt++OGHomcw/3iaz8WCyWk+jvnoo4/0+OOPa/LkyRoyZIjRcQCPUq9ePR05ckR5eXlGRwHcDoUShrh4ms/vC+aRI0ck/e80n4sl8/rrrzc4belhs9nk6+urm2++WXv37jU6DuAxfr9d0Pbt242OA7gdCiXcxpEjRxQfH19UMi+e+lKvXr1LCian+fy1Zs2aadeuXfrll18YewNOwnZBwF+jUMJtpaenX1IwL3eaT2RkpOrUqcNm678zZ84cPfnkk3rnnXfUuXNnxcXF6cEHH1TlypWNjgaUWp07d9aqVavYLgi4AgolSo2MjAxt2LChqGBePM2nZs2aRUdFRkZG6uabb/bqgrlv3z7dcsst8vX1LXrWa+nSpbrvvvsMTgaUXmwXBPw1CiVKrezsbG3cuLHoGczt27cXnebz+4IZERHhFaf5HD9+XHfddZcSExP/9Nnu3bvVqFEjA1IBpd/F7YIeeughffrpp0bHAdwShRIew2q1avPmzUUFc+vWrZec5nNxTO6pp/lkZmaqQYMG+vnnn/XHP9Y5OTns/wlco4vbBW3YsEFt27Y1Og7gliiU8FgXT/O5OCLfuHGjcnNzi07zuVgwW7RoIT8/P6PjOkVycrLatm2rrKwsFRYWSpKCgoJ08uRJg5MBpRfbBQF/j0IJr3HxNJ+LBTM+Pl5nz56Vn5+fWrVqVVQwW7VqVapX8w4ePKj27dvr559/liS1a9dO8fHxBqcCSie2CwKuDoUSXuviaT4XC+b69euVmZkpHx8fNW/evOgZzLZt25a6tzoPHjyoW2+9VVarVe3bt9f69euNjgSUSp9//rl69+7NdkHA36BQAr+x2Ww6cOBA0TOY69at04kTJ2Q2m9WkSZOigtmuXbtScZrPnj171KhRIzVt2lQ7duyQNa9AqZlW5RfY5OtjVmhggAL8fIyOCbg1tgsCrg6FErgCu92uQ4cOFRXM9evXX3Kaz8URuTuf5vPIs8O16ZRZNzS/W2lZufr9H3aTpJCq/upUP0h9W4aobvUKRsUE3BbbBQFXh0IJFMORI0eKxuPr1q1TcnKypF8f2v/9ZuvBwcGG5jyalasRsXsVfyhDZtll05X35bSYTSq02dU+rJqiekQouKp/CSYF3BfbBQFXj0IJOCA9Pf2SgnlxD8jQ0NBLVjBL8jSfmIQ0jVqeqAKbXYW2q//jbTGb5GM2aUy3cPVpzvGWANsFAVePQgk4UUZGhuLj44tK5h9P87lYMl11ms+MuGRFr05y+DpD76qnZzvVdUIioPRiuyDg6lEoARe6eJrPxWcw/3iaz8WC+Xen+axZs0Y7d+7Uiy++eMUfF5OQppe/2Ou07BN7Rqg3K5XwUmwXBBQPhRIoQTk5OdqyZUtRwbx4mk/lypXVrl27opLZpEmTS07z6dChg+Lj49W1a1fFxMSoQoVLX6A5mpWrO6auU16BzWlZ/XzMWjM4kmcq4ZUubhc0ceJEDR8+3Og4gNujUAIGOn/+vLZt21b0DOamTZuKTvNp27atOnTooNatW6tLly7Kz8+XxWJR/fr19c0331zy4s8jH2zVph8zi/XM5N+xmE1qUztQ8/u3dNo1gdKC7YKA4qFQAm7kwoUL2rFjR1HB3LBhg86ePXvJjzGbzapSpYpWrlyp5s2bK/nkOd05zXUbl68Z3EFhQWwpBO9SuXJllStXju2CgKtkNjoAgP8pU6aMWrVqpeHDh2vFihXKysrSwIEDL3mBx2azKTMzUy1bttRHH32kT7amyWJ2zRvkFrNJC7akueTagLs6cuSIsrOz1alTJ6OjAKUGhRJwYxaLRQcPHpTdbpfJZLrkhZyKFSuqsLBQcQdPOXXU/XuFNrvikk655NqAu5o+fbokaeDAgQYnAUoPzl0D3FxGRob8/f3VunVrtWvXTm3btlXLli1VsWJF5eQV6M3Rq1x6/7TMXFnzCjimEV7jyy+/lK+vL3tPAsXAVwjAzW3btk1ms/my2wUdybTK1Q9B2yWlZloVXrOSi+8EGM9ms+nQoUNq0qSJ0VGAUoVCCbi5328f9Ef5Ttwm6K+U1H0Aoy1evFg2m00PPvig0VHg5qx5BUrNtCq/wCZfH7NCAwO8epLjvT9zwAP4+pTMY9AldR/AaB9++KEk6emnnzY4CdxR8slz+mRrmuIOnlJaVu4lEyKTpJCq/upUP0h9W4aobnXv2h2DbYMAN7d3717t379fDRo0UL169eTn51f0mTWvQA1Hr3Lp2Nskad/ou736X97wHpUrV1bZsmV14sQJo6PAjRzNytWI2L2KP5Qhi9n0ly9CXvy8fVg1RfWI8JrDIfgKAbi5MWPGaMmSJZJ+3YPyxhtvVIMGDZSTk6OyZcvKXL+vCv2ruuz+IYH+lEl4hbS0NGVnZ6tLly5GR4EbiUlI06jliSr4rUT+3a4aFz/f9GOm7pi6TmO6hauPFxxjy1cJwM3ddtttRYXSZrMpJSVFKSkpkn59vjKycU/9+Df/Yr5WFrNJneoFOf26gDtiuyD80Yy4ZEWvTrqm/7bQZlehza6Xv9irjJw8PduprpPTuRcejALc2Pbt2/XNN99c9rObb75ZGRkZmjn4IZfuQ1nb9pN4MgbeYPny5fL19VW7du2MjgI3EJOQds1l8o+iVydpYYJnHxJBoQTciM1m07Jly3TnnXeqfPnyat68ub788stLtgwym8264447tH37dlWsWFF1q1dQ+7BqTj8tx2ySfDMP65897lb79u21du1aiiU81sXtgiIiIoyOAjdwNCtXo5YnOvWary9P1NGsXKde051QKAGD5efna+bMmWrWrJnKli2r7t27a82aNapcubIGDBigH3/8UWPGjJHZbJbJZNI999yjr776Sv7+/3vQO6pHhHycXCjLWMxaM76/VqxYoby8PN1xxx2KjIzUf//7X4olPM6SJUvYLghFRsTuLXpm0lkKbHaNiN3r1Gu6EwolYICsrCy99tprqlevnsqWLauBAwdq165dqlOnjkaPHq3Tp0/r2LFjmjlzpmrVqqUePXrIbrfrgQce0JIlSy5501uSgqv6a0y3cKdmHNstXCGBAeratau2bdumr776Srm5ubr99tvVsWNHxcXFOfV+gJHYLggXJZ88p/hDGU5/lKjQZlf8oQwdOnXOqdd1F2wbBJSQ5ORkTZo0SV999ZXS09Ml/fpSTZMmTdS/f389/vjj8vG58ntyhw4dUq1atS57Ys5FjjxA/nvD7qqvgZ3C/vT9drtdX331lUaPHq2dO3cqMjJSY8aMUWRkpMP3BIzEdkG4aPTyRM3fesRlLzo+0vJGjXbyAoA7YIUScKH4+Hj16NFDVapUUb169TRnzhydO3dOnTt31ooVK5Sfn6+tW7fqySef/MsyKUlhYWF/WSYl6dlOdTWhZ4T8fMzFfqbSYjbJz8esiT0jLlsmJclkMunee+/V9u3btWzZMp09e1YdO3ZUp06dtH79+mLdD3AXF7cL6tSpk9FR4AbiDp5y6YuOcUmnXHJto1EoASey2Wz67LPPFBkZqXLlyqlDhw5aunSpypQpo759+2rXrl06d+6cVq5cqa5du7okQ5/mIVozOFJtagdK0t8Wy4uft6kdqDWDI9X7KvZLM5lM6tatm3bs2KGlS5fqzJkzioyM1O233674+HjHfxJACWK7IFyUk1egNBe/OJOWmStrXoFL72EERt6Ag3JzczVr1ix9/PHHSkxMVGFhoSTpxhtvVM+ePTV06FDVrFnTkGxFx4QlnVJa5mWOCQv0V6d6QerXKkRhQdd+TJjdbteyZcs0evRoff/997r99ts1ZswYtW3b1uGfA+Bq9evXV2pqqvLy8oyOAoMlHs/WPdM3uPw+K55rp/CalVx+n5JEoQSuwYkTJzR58mQtWbJEqampstvtslgsatCggfr166dnnnlG5cuXNzrmJax5BUrNtCq/wCZfH7NCAwOcfgKOzWbT0qVLNWbMGO3Zs0d33HGHxowZozZt2jj1PoCz2Gy2omeZt2/fbnQcGGxX2mn1mLXJ5feJHdBGTUKquPw+JYmRN3CV9u3bp0cffVTVq1dXjRo1FB0drfT0dLVt21bz589Xfn6+9uzZo+HDh7tdmZSkAD8fhdespCYhVRRes5JLjlM0m83q2bOndu3apcWLF+vEiRNq27at7r77bm3evNnp9wMcxXZB+D1fn5KpRSV1n5LkeT8jwIlWrVqlrl27qmLFioqIiND8+fOVl5enbt266b///a9++eUXxcfHq1+/fjKb+eN0kdls1v3336/vv/9eixYt0k8//aQ2bdqoc+fO2rJli9HxgCJsF4TfCw0MkHN39P0z02/38TR8BQR+p6CgQB988IFat24tPz8/de7cWStXrlRAQID69++vAwcO6MyZM1q2bBlvhF4Fs9msXr16ac+ePVq4cKGOHj2q1q1bq0uXLtq2bZvR8QBt3rxZ1atXV8WKFY2OAjcQ4OejkKr+f/8DHRAS6O+SCZHRPO9nBBTT2bNn9c477+jTTz/VwYMHZbPZZDKZVKdOHT3wwAMaMmSIqlWrZnTMUs1sNuvBBx9Ur169tGjRIo0ZM0YtW7ZU165dNWrUKLVo0cLoiPBCR48eVXZ2trp06WJ0FJSwlJQU7d69W2XLllW5cuWK/tdut6vahZM6Yg+QTM5fc7OYTepUL8jp13UHvJQDr3TkyBFNmjRJy5cv19GjRyVJPj4+uuWWW/TYY4/p3//+t8qWLWtwSs9VWFhYVCx/+OEH3XPPPRo9erSaNWtmdDR4kWHDhik6Olrx8fFq166d0XFQgu6//3598cUXl/2sTGCwav57lsvuvWZwB4d21XBXjLzhNRISEtS7d28FBgYqNDRU7777rjIzM3Xbbbdp8eLFysvL044dO/Tcc89RJl3MYrGoT58+2rdvnz799FMdOnRIzZs317333qsdO3YYHQ9eYvny5fL19aVMeqGHH374ip+9/sKTah9WrdiHQ/wdi9mk9mHVPLJMShRKeDCbzabY2FjdcccdCggIUIsWLfT5559Lkh544AFt3rxZVqtVa9eu1f33389LNQawWCx66KGHlJiYqAULFigpKUnNmjXTfffdp507dxodDx7MZrPp0KFDatiwodFRYAAfH5/Lnk42YcIEvfbaa4rqESEfJxdKH7NJUT0inHpNd8JXUHiU/Px8zZgxQ82aNZOfn5969uyptWvXqmrVqnrmmWeUkpKizMxMff7552rVqpXRcfEbi8Wivn37KjExUfPnz9eBAwd06623qnv37tq1a5fR8eCBvvjiC7YL8jI2m00zZ87U9ddfr+7duxcdQiH97wXC4cOHS5KCq/prjJPP2x7bLVzBLn7hx0g8Q4lSLzMzU1OmTNGiRYt06NAh2e12mc1m1atXTw899JCef/55VarkWScSeLqCggJ99tlnGjt2rA4dOqTu3btr1KhRaty4sdHR4CG6dOmib775RtnZ2bzh7eEuXLig1157TTNnzlROTo78/PzUr18/jR8/XvXr19fp06fVoEEDbdu2TQEBl27nMyMuWdGrkxzOMOyu+hrYKczh67gzCiVKpaSkJL311lv6+uuvlZ6eLkny9fVVkyZN9MQTT+ixxx677DgDpUtBQYE++eQTjRs3TocPH1aPHj00evRo3XLLLUZHQylXuXJllS1bVidOnDA6ClzkzJkzGjRokGJiYnThwgVVqlRJzz//vEaOHFn09WHKlCmaMGGCtmzZotq1a1/2OjEJaRq1PFEFNrsKbVdfmSxmk3zMJo3tFq7ezUOc8nNyZxRKlBrr1q3T1KlT9d133yk7O1uSVL58ebVr107PPfecunbtanBCuEpBQYEWLFigcePG6ccff9T999+vUaNGKSLCc59HguscPXpUISEh6tOnjz777DOj48DJUlJS9NRTT2nt2rWy2WyqWbOmxo4dq/79+1/2x+fn58vX1/cvr3k0K1cjYvcq/lCGLGbTXxbLi5+3D6umqB4RHj3m/j0KJdyWzWbTZ599pvfee08JCQk6f/68JOm6667T3XffraFDh6pRo0YGp0RJunDhQlGxTElJUa9evTRq1CherECxsF2QZ9q8ebMGDhxY9Nz1zTffrGnTpumuu+5y2j2ST57TJ1vTFJd0SmmZufp9gTLp103LO9ULUr9WIR77NveVUCjhVnJzc/Xuu+9q/vz52r9/f9FD06GhoerZs6defPFF1axZ0+CUMNqFCxc0f/58jRs3TqmpqXrggQc0atQohYc79yF6eKb69esrNTVVeXl5RkeBEyxevFjDhw9XSkqKTCaT2rRpo9mzZ7v8H5rWvAKlZlqVX2CTr49ZoYEBHnkCztWiUMJwx48f1+TJk/XFF1/oyJEjstvtslgsatCggR555BENHDhQ/v7eMTJA8Vy4cEH/+c9/9MYbbygtLU0PPvigXn/9dTVo0MDoaHBTNptNZcqUUePGjdnztBSz2WyaOnWqxo8fr8zMTFksFnXr1q3oLW6UPLYNgiH27NmjRx99VEFBQfrHP/6hKVOm6MSJE2rXrp0WLFig/Px87dmzR8OGDaNM4orKlCmjJ554QklJSXrvvfe0efNmNWzYUA899JAOHDhgdDy4IbYLKt3Onz+v559/XhUqVNDQoUNltVr1zDPP6OzZs/riiy8okwZihRIlZuXKlXrnnXe0YcMG5eTkSJIqVaqkjh076oUXXlDHjh2NDYhSLz8/X/PmzdObb76po0ePqk+fPnr99dd10003GR0NboLtgkqnjIwMPfPMM4qNjVVBQYGqVq2qoUOH6qWXXuJQCjdBoYTLFBQUaN68eZo7d6527dql/Px8SVKNGjV0zz33aOjQoapfv77BKeGJ8vLy9NFHHykqKko//fSTHnroIY0cOZLfb2C7oFLm4MGDeuqpp7R+/XrZ7XaFhIQoKipKffv2NToa/oBCCac6e/aspk2bps8++0xJSUmy2WwymUwKCwvTAw88oMGDB6tatWpGx4SXyMvL04cffqioqCgdP35cDz/8sEaOHKl69eoZHQ0GOHbsmIKDg9W7d2/FxMQYHQd/4bvvvtOgQYO0d+9eSdItt9yi6dOnq0OHDgYnw5VQKOGw1NRUTZo0ScuXL9exY8ck/XpOaqNGjfTYY4/pySef/Ns9vgBXysvL09y5czV+/Hilp6erb9++GjlypOrWrWt0NJSg4cOHa9KkSVq/fr3at29vdBxcxscff6zXXntNR48elclkUseOHTVr1iymC6UAhRLXZOvWrZo8ebLWrl2rrKwsSZK/v79at26tgQMH6r777uO5Frid8+fPFxXLEydOqF+/fho5cqTCwjz7SDT86qabblJKSgrbBbkZm82m8ePHa/LkyTp9+rR8fHzUq1cvTZ8+nYlWKUKhxFWx2WyKjY3VzJkztWXLFuXm5kqSqlatqjvuuEMvvviiWrRoYXBK4OqcP39ec+bM0fjx43Xq1Ck98sgjeu2111SnTh2jo8FF2C7I/eTm5urFF1/UvHnzdP78efn7++upp57ShAkTmGqVQiwh4Yry8vI0ffp03XrrrfLz81OvXr303//+V4GBgRo4cKBSU1OVmZmphQsXUiZRqpQtW1bPPfecDh8+rClTpuibb75R/fr19fjjj+vHH380Oh5cIDY2VjabTQ888IDRUbze8ePH1b17d1WsWFGzZ89WhQoVNHXqVJ07d05TpkyhTJZSrFDiEhkZGZoyZYoWLVqkw4cPy263y2w2q379+nr44Yc1aNAgttqAx/nll1/03nvvacKECcrIyNA///lPvfbaa6pVq5bR0eAkXbt21cqVK9kuyEB79uzRgAEDtHnzZtntdtWuXVtvvfWW7r//fqOjwQkolNDBgwc1adIkrVixomgrDV9fXzVt2lRPPPGE/vnPf8rHx3uPk4L3yM3N1XvvvaeJEycqMzNTjz32mF599VWFhoYaHQ0Oqly5svz8/HTy5Emjo3idlStXasiQIfrhhx8kSbfeeqveffddtWzZ0uBkcCZG3l7qu+++03333afKlSvrpptu0gcffCCr1aouXbro66+/Vl5enjZv3qz+/ftTJuE1/P39NXjwYP3444+aOHGili9frrp16+rJJ5/UkSNHjI6Ha3Ts2DFlZ2erU6dORkfxKu+//75q1qyprl27KikpSXfffbdSU1O1fft2yqQHYoXSBdzxwHibzaZPP/1U7733nrZv367z589LkoKCgtS5c2cNGzZMDRs2NDQj4G6sVqtmzZqlt956S2fOnNG//vUvvfrqqwoJCTE6Gorh4nZB69atYx9DFysoKNCYMWP0zjvv6OzZs/L19dVDDz2kd955h0cNPByF0kmST57TJ1vTFHfwlNKycvX7X1STpJCq/upUP0h9W4aobvUKJZIpNzdXM2bM0IIFC7R//34VFhbKZDIpNDRU999/v1588UXOPQWugtVq1cyZM/XWW28pOztb/fv31yuvvEKxLCXYLsj1zp49q+eff16ffvqp8vPzVaFCBT377LMaO3YsUy4vQaF00NGsXI2I3av4QxmymE0qtF35l/Pi5+3DqimqR4SCq/o7Pc9PP/2k6OhoxcbGFo3oLBaLwsPD9eijj2rAgAHy93f+fQFvkJOTo5kzZ2rSpEnKzs7WE088oVdeeUXBwcFGR8MVsF2Qa6Wlpenpp5/WqlWrZLPZdP311+v111/XgAEDjI6GEkahdEBMQppGLU9Ugc3+l0Xyjyxmk3zMJo3pFq4+zf96hSM9PV3Vq1f/y03Cd+/erejoaK1evVo///yzpF+3RWnRooWefvpp9e7dm03GASfKycnRu+++q0mTJuncuXNFxfKGG24wOhr+YMmSJerVq5fGjx+vl19+2eg4HiMhIUHPPPOMtm/fLkmqX7++pkyZoq5duxqcDEahUF6jGXHJil6d5PB1ht5VT892uvzxbwsXLlTfvn0VHR2tF1544ZLPvv76a73zzjvauHGjcnJyJP36FmPHjh01ePBgnhMCSsC5c+c0Y8YMRUdHKycnR08++aRefvll/eMf/zA6Gn7DdkHOtXTpUg0dOlSHDx+WJLVq1UqzZs1S48aNjQ0Gw1Eor0FMQppe/mKv0643sWeEev9hpXLevHl6/PHHZbfb1bx5c23atEkffvihPvjgA+3atUsXLlyQJNWoUUP/93//p6FDh6pevXpOywTg6p07d07Tp09XdHS0cnNzi4plzZo1jY7m9dguyHE2m00zZszQm2++qVOnTslisahLly6aNWsWq/IoQqEspqNZubpj6jrlFdicdk0/H7PWDI4seqZy1qxZeuaZZy75MSaTSXa7XSaTSWFhYerdu7cGDx6sqlWrOi0HAMecPXtW06dP1+TJk5Wbm6unnnpKL7/8smrUqGF0NK907NgxBQcHq3fv3oqJiTE6TqmTn5+vV199VbNmzZLVapWfn58effRRTZkyReXLlzc6HtwMD9YV04jYvSooxvOSV6PAZteI2F9XPEeMGPGnMilJISEhevfdd3X+/HklJSVp3LhxlEnAzVSsWFGvvvqqUlJS9Oqrr+rjjz9W7dq19cILLyg9Pd3oeF7nnXfekaTL/p2KK8vKylLfvn1Vvnx5RUdHq0yZMhozZoxyc3P1/vvvUyZxWaxQFkPyyXO6c9p6l13fZ9V4Hd618U/fbzKZ1LlzZ3399dcuuzcA58vOztbbb7+tKVOmKC8vTwMGDNDw4cPZrquEsF1Q8Rw+fFhPPfWU/vvf/8put+uGG27QuHHj9NhjjxkdDaUAhbIYRi9P1PytR4r1RvdVs9tUPn2nLLu/UNWqVXXs2DGlpKSosLBQ0q9vbVutVt7WBkqhM2fO6O2339bUqVOVn59fVCyrV69udDSPdXG7oEaNGmnnzp1Gx3FrGzZs0HPPPafdu3dLksLDw/X222/r9ttvNzYYShXaSTHEHTzlmjIpSSazAiM66Pvvv1dcXJySk5OVm5urxMRELVq0SP/5z38ok0ApVblyZY0aNUqpqakaPny45s6dq1q1amno0KE6deqU0fE8UmxsrGw2mx544AGjo7ithQsXKjQ0VO3bt9f333+vDh06aN++fdq3bx9lEsXGCuVVyskrUMToVXLlL5ZJ0r7Rdxt+TCMA1zp9+rSmTp2qadOmqbCwUAMHDtTQoUMVFBRkdDSPcXG7oDNnzqhSpUpGx3EbNptN0dHReuutt5SZmSmLxaLu3btr5syZ/P6DQ1jyukpHMq0uLZOSZJeUmml18V0AGK1KlSoaO3asUlNTNWTIEM2ePVu1atXSSy+9VHQ4ARyzefNmBQUFUSZ/c/78eT333HMqX768XnrpJeXm5urZZ59VTk6OFi9eTJmEwyiUVynfidsEucN9ABivatWqGjdunFJSUjR48GDNnDlTtWrV0ssvv6yMjAyj45Vax44d05kzZ9SpUyejoxju1KlT6tWrlypUqKAZM2bI399fEydOVE5OjqZPn66yZcsaHREegkJ5lXx9SuaXqqTuA8B9BAYG6o033lBqaqoGDRqkd999V6GhoXrllVeUmZlpdLxSZ/r06ZK8e7ug/fv3q0OHDrr++uu1ZMkS/eMf/1BMTIwyMjI0fPhwnsmH0/EM5VWy5hWoIc9QAigBGRkZmjx5sqZPny6TyaRBgwbpxRdfZO/Zq+TN2wWtXbtWgwYN0v79+yVJjRs31vTp09WuXTuDk8HT8U+UqxTg56OQ306ycZWQQH/KJABVq1ZN48ePV2pqqgYOHKi3335boaGheu2115SVlWV0PLdms9mUnJys8PBwo6OUqP/85z8KDg7WHXfcoQMHDuj2229XUlKSdu3aRZlEiaBQFkOn+kGymE0uubbFbFKnejwUDeB/qlWrpgkTJiglJUVPP/20pk6dqtDQUI0cOVKnT582Op5b8qbtgmw2m8aOHasqVaroscce08mTJ/Xwww8rIyNDa9asUd26dY2OCC/CyLsYXH1SzprBHRQWVMFl1wdQup06dUqTJk3Su+++qzJlyuiFF17QCy+8oCpVqhgdzW1c3C7o9OnTqly5stFxXCInJ0dDhgzRxx9/rLy8PAUEBGjAgAF688035evra3Q8eCkKZTE98sFWbfox06kbnFvMJrWpHaj5/Vs67ZoAPNfJkyc1adIkzZw5U76+vkXF0lMLVHFUqVJFvr6+OnnypNFRnO6nn37SgAED9PXXX6uwsFBBQUF67bXXNHDgQF6ygeH4HVhMUT0i5OPksbeP2aSoHhFOvSYAz1W9enVFR0frxx9/VP/+/TVx4kSFhoZqzJgxys7ONjqeYS5uFxQZGWl0FKfavXu3WrdurRtuuEFffvmlatWqpaVLl+rkyZN67rnnKJNwC/wuLKbgqv4a0825D3uP7RauYBe/8APA81x//fWaPHmyUlJS9K9//UsTJkxQaGioxo4d65XF0tO2C/r6669Vv359NWnSRFu2bFHz5s21bds2JScn67777jM6HnAJRt7XaEZcsqJXJzl8nWF31dfATmFOSATA26Wnp2vixImaPXu2/P39NWTIEA0aNEgVK1Y0OlqJuPnmm/Xjjz+W+u2CZs+erTFjxujEiRMym826++67NXv2bIWEhBgdDbgiCqUDYhLSNGp5ogps9mI9U2kxm+RjNmlst3D1bs5fEACc6/jx45o4caLee+89+fv768UXX9Rzzz3n0cXSZrPJ19dXt9xyi3bu3Gl0nGIrKCjQ66+/rhkzZujcuXPy9fXVww8/rLffftuj/3+D52Dk7YA+zUO0ZnCk2tQOlKS/3VLo4udtagdqzeBIyiQAl6hZs6befvttHT58WH379tXYsWNVq1YtRUVF6dy5c0bHc4lly5apsLCw1G0XlJ2drX/+858KCAjQ+PHjZTKZ9Nprr8lqteqjjz6iTKLUYIXSSZJPntMnW9MUl3RKaZm5l5yoY9Kvm5Z3qhekfq1C2BoIQIk6duyYJkyYoDlz5qhChQoaOnSoBg4cqAoVPOfvotK2XdCRI0f01FNP6dtvv5XNZlONGjU0evRoPfnkk0ZHA64JhdIFrHkFSs20Kr/AJl8fs0IDAzgBB4Dhjh07pvHjx2vu3LmqUKGChg0bpoEDB6p8+fJGR3NYadkuaOvWrRo4cKB27Ngh6ddjIqdMmaIuXboYnAxwDIUSALzM0aNHi4plpUqVioplQECA0dGuybFjxxQcHKwHHnhAn3/+udFxLmvJkiUaPny4fvzxR5lMJrVu3VqzZs3SLbfcYnQ0wCl4hhIAvExwcLBmzpypQ4cO6f7779drr72mWrVqadKkSbJarUbHKzZ33S7IZrNp2rRpCgoKUq9evXTkyBHdd999OnbsmDZu3EiZhEdhhRIAvNyRI0cUFRWlDz/8UFWrVtXw4cM1YMAA+fuXjv1xb775Zh0+fFj5+flGR5Ek5efn65VXXtF7770nq9WqsmXL6rHHHtPkyZNLza8pUFysUAKAl7vxxhv13nvvFW2Y/fLLL6tWrVqaMmWKcnNzjY53WY8++qhq1qypJ598UklJSbrpppuMjqSsrCw99NBDCggI0JQpU+Tr66s33nhDVqtVs2bNokzCo1EoAQCSpNDQUL3//vtKSkrSvffeq+HDh6t27dqaOnWqfvnlF6PjXSI/P1/p6en68MMPZbPZlJiYqMjISMXExJR4luTkZN12222qVq2aYmJiVKNGDX388cfKysrSq6++ytGI8Ar8LgcAXKJWrVqaO3eukpKSdM8992jYsGGqXbu23n77bbcplk2aNJHFYlFhYaGkX59XXL9+fdHzlCVh/fr1atSokerVq6e4uDg1bNhQcXFxSktL0yOPPFJiOQB3QKEEAFxW7dq19cEHH+jgwYPq0qWLXnzxRdWpU0fvvPOOzp8/b2i2xo0bF5VJSbJYLKpZs6YWLlzo8nt/8sknuvHGGxUZGam9e/cqMjJSBw4c0J49e9SxY0eX3x9wR7yUAwC4KocOHdKbb76p+fPnq3r16nr55Zf173//W2XLli3xLCdPntT1119f9O3KlStry5Ytql+/vkvuZ7PZNHHiREVHRysrK0s+Pj7q0aOHZs6cqWrVqrnknkBpQqEEABTLoUOHNG7cOC1YsEA1atTQK6+8ov79+5d4sfT399cvv/wiX19fbdiwQc2bN3f6PXJzczVs2DB9+OGHOn/+vPz9/fXvf/9bEyZMMKRIA+6KkTcAoFjCwsL0n//8RwcOHNBtt92mQYMGKSwsTDNnzlReXl6J5bBYLJKkFStWOL1MnjhxQj179lTFihU1c+ZMBQQEKDo6WufOndO0adMok8AfsEIJAHDIwYMH9cYbb+jTTz9VzZo1NWLECD3++OPy8/Nz2j3+eKTtjVX9FXpDDd16661atWqV0+6TmJiop59+Whs3bpTdbletWrU0YcIEPfjgg067B+CJKJQAAKf44YcfNG7cOH322We64YYb9Oqrr+pf//qXfH19JUn79u3TI488oo8//lgRERF/e73kk+f0ydY0xR08pbSsXP3+i5VJkik3U3dH3KAh9zZX3eoV/vZ6NptNGzZsULt27f60lc+3336r559/XgcOHJD061vkM2bMUJs2ba765w94MwolAMCpDhw4oHHjxikmJkbBwcF69dVX9dhjj6lXr1768ssvFRYWpl27dql8+fKX/e+PZuVqROxexR/KkMVsUqHtyl+mLn7ePqyaonpEKLjqlTcPf/311zVu3DjNmTNHTzzxhCTpgw8+0Ouvv67jx4/LbDbr9ttv13vvvadatWo59osAeBkKJQDAJfbv369x48Zp4cKFql69uk6cOCFJMpvNeuihhzR//nyZTKZL/puYhDSNWp6oApv9L4vkH1nMJvmYTRrTLVx9mof86fOlS5eqR48ekn7dDqlfv356++23lZ2drTJlyqh3796aPn26KleufO0/YcCLUSgBAC6VmJioO++8U+np6Zd8/4cffqh//etfRd+eEZes6NVJDt9v6F319GynukXf3r9/v5o1a6bz58/r91/yypcvr2eeeUbjxo0rGssDuDYUSgCAS23fvv2yb2H7+PgoISFBjRs3VkxCml7+Yq/T7jmxZ4R6Nw/RmTNndMstt+jYsWOXlMnQ0FAdPnyYYxEBJ+FPEgDApWbPni1JMplMMpvNRWPugoIC3XXXXTqalatRyxOdes/Xlydq+4EU1alTR0ePHtUf105SU1O1efNmp94T8GY+RgcAAHi2IUOGqEmTJpJUVOzsdruOHz+u2rVra0TsXhUU43nJq3Gh0Kb/G/uJsrKyVKZMGZUtW1YFBQXKz88vOrIxMTFRbdu2dep9AW/FyBsAYJjkk+d057T1Lrt+7BNN1aROjUu+r6CgQHl5eQoICHDZfQFvw8gbAGCYT7amyWI2/f0PvAYWs0nLErP+9P0+Pj6UScDJKJQAAMPEHTxVrO2BiqPQZldc0imXXBvApSiUAABD5OQVKC0r16X3SMvMlTWvwKX3AEChBAAY5EimVa5+iN8uKTXT6uK7AKBQAgAMkV9g86j7AN6MQgkAMISvT8l8CSqp+wDejD9lAABDhAYGyDXvd/+P6bf7AHAtCiUAwBABfj4Kqerv0nuEBPorwI8zPABXo1ACAAzTqX6QS/eh7FQvyCXXBnApCiUAwDB9W4a4dB/Kfq1CXHJtAJeiUAIADFO3egW1D6vm9FVKi9mk9mHVFBZUwanXBXB5FEoAgKGiekTIx8mF0sdsUlSPCKdeE8CVUSgBAIYKruqvMd3CnXrNsd3CFeziF34A/A+FEgBguD7NQzT0rnq/fsPu2DOVw+6qr97NeXYSKEkUSgCAW3i2U101zkuUvTBflmJOwC1mk/x8zJrYM0IDO4W5JiCAK6JQAgDcQnx8vJZPe1mPX39cbepUk6S/fVnn4udtagdqzeBIViYBg5jsdgdnCwAAOCg3N1eNGjVSUFCQ1q9fL4vFouST5/TJ1jTFJZ1SWmaufv/FyqRfNy3vVC9I/VqF8DY3YDAKJQDAcC+++KJmzpyp3bt3q379+n/63JpXoNRMq/ILbPL1MSs0MIATcAA3QqEEABhq8+bNatu2rd566y0NHTrU6DgArgGFEgBgmPPnz6tJkyaqVKmSNm7cKIvFYnQkANeAeQEAwDCjR4/Wjz/+qF27dlEmgVKMQgkAMMS2bds0adIkvfHGG2rQoIHRcQA4gJE3AKDE5eXlqWnTpipXrpy2bNkiHx/WN4DSjD/BAIASN27cOCUnJ2vHjh2UScADsLE5AKBE7dy5UxMmTNDIkSMVERFhdBwATsDIGwBQYvLz89WsWTNZLBZt27ZNZcqUMToSACdgzgAAKDFRUVE6cOCAEhISKJOAB2HkDQAoEd9//73efPNNjRgxQo0bNzY6DgAnYuQNAHC5CxcuqGXLliooKND27dvl6+trdCQATsTIGwDgchMnTtSePXu0detWyiTggVihBAC41L59+9S0aVMNHTpUUVFRRscB4AIUSgCAyxQUFKh169ayWq3auXOnypYta3QkAC7AyBsA4DKTJ0/Wzp07tWnTJsok4MFYoQQAuMSBAwfUpEkTDRo0SG+99ZbRcQC4EIUSAOB0hYWFateunbKysrR7926VK1fO6EgAXIiRNwDA6aZNm6atW7dqw4YNlEnAC7BCCQBwqqSkJDVq1EgDBgzQlClTjI4DoARQKAEATlNYWKjIyEidPHlS33//vfz9/Y2OBKAEMPIGADjNjBkztHHjRq1bt44yCXgRVigBAE5x+PBhRUREqH///po+fbrRcQCUIAolAMBhNptNt912m9LS0rRnzx6VL1/e6EgAShAjbwCAw2bPnq1169Zp7dq1lEnAC7FCCQBwSGpqqho2bKhHHnlEs2bNMjoOAANQKAEA18xut+vOO+9UcnKy9u3bpwoVKhgdCYABGHkDAK7ZnDlztHbtWq1atYoyCXgxVigBANckLS1NDRs21IMPPqi5c+caHQeAgSiUAIBis9vt6tKlixITE7Vv3z5VqlTJ6EgADMTIGwBQbB999JFWrVqlr7/+mjIJgBVKAEDx/PTTTwoPD1f37t01b948o+MAcAMUSgDAVbPb7br33nu1c+dOJSYmqkqVKkZHAuAGGHkDAK7aggULtGLFCi1fvpwyCaAIK5QAgKuSnp6uBg0a6J577tGCBQuMjgPAjVAoAQB/y263q0ePHtqyZYsSExMVGBhodCQAboSRNwDgb8XExGjZsmVasmQJZRLAn7BCCQD4SydPnlR4eLhuv/12LVy40Og4ANwQhRIA8JceeOABfffdd9q/f7+uu+46o+MAcEOMvAEAV7Ro0SItXrxYCxcupEwCuCJWKAEAl/Xzzz8rPDxc7du31+LFi2UymYyOBMBNmY0OAABwT4MGDVJhYaFmzpxJmQTwlxh5AwD+JDY2VjExMVqwYIGqV69udBwAbo6RNwDgEpmZmQoPD1fLli21dOlSVicB/C1G3gCAS7zwwgvKy8vT7NmzKZMArgojbwBAka+++koLFizQvHnzVKNGDaPjACglGHkDACRJp0+fVsOGDdWoUSOtWLGC1UkAV42RNwBAkjRkyBDl5OTo/fffp0wCKBZG3gAArVy5UvPmzdPcuXN1ww03GB0HQCnDyBsAvFx2drYaNmyoBg0a6JtvvmF1EkCxMfIGAC83bNgwnTlzRnPmzKFMArgmjLwBwIutWbNGc+bM0axZsxQSEmJ0HAClFCNvAPBS586dU8OGDRUWFqZvv/1WZjNDKwDXhhVKAPBSL730kjIzM/Xdd99RJgE4hEIJAF4oLi5Os2bN0vTp01WrVi2j4wAo5Rh5A4CXsVqtioiIUHBwsOLi4lidBOAwVigBwMu88sorOnHihFavXk2ZBOAUFEoA8CLx8fGaPn26pk6dqrCwMKPjAPAQjLwBwEvk5uaqUaNGCgoK0vr162WxWIyOBMBDsEIJAF5i5MiROnbsmL766ivKJACnolACgBfYtGmTpk6dqokTJ6p+/fpGxwHgYRh5A4CH++WXX9SkSRNVrlxZGzduZHUSgNOxQgkAHm706NFKSUnRrl27KJMAXIJCCQAebNu2bYqOjtYbb7yhBg0aGB0HgIdi5A0AHiovL09NmzZVuXLltGXLFvn4sIYAwDX42wUAPNTYsWOVnJysHTt2UCYBuBRHJACAB9qxY4cmTpyokSNHKiIiwug4ADwcI28A8DD5+flq1qyZLBaLtm3bpjJlyhgdCYCHYwYCAB4mKipKBw4cUEJCAmUSQIlg5A0AHmT37t1688039corr6hx48ZGxwHgJRh5A4CHuHDhglq0aKHCwkJt375dvr6+RkcC4CUYeQOAh5g4caL27t2rrVu3UiYBlChWKAHAA+zbt09NmzbV0KFDFRUVZXQcAF6GQgkApVxBQYFat24tq9WqnTt3qmzZskZHAuBlGHkDQCkXHR2tnTt3atOmTZRJAIZghRIASrEDBw6ocePGev755/XWW28ZHQeAl6JQAkApVVhYqHbt2ikrK0u7d+9WuXLljI4EwEsx8gaAUmratGnaunWrNmzYQJkEYChWKAGgFEpKSlKjRo309NNPa+rUqUbHAeDlKJQAUMoUFhYqMjJSJ06c0J49e+Tv7290JABejpE3AJQyM2bM0MaNG7Vu3TrKJAC3wAolAJQihw8fVkREhPr376/p06cbHQcAJFEoAaDUsNlsuu2225SWlqY9e/aofPnyRkcCAEmMvAGg1Jg1a5bWrVuntWvXUiYBuBVWKAGgFEhJSVFERIT69eun2bNnGx0HAC5BoQQAN2e323XnnXcqOTlZ+/btU4UKFYyOBACXYOQNAG5uzpw5Wrt2rVatWkWZBOCWWKEEADeWlpamhg0b6sEHH9TcuXONjgMAl0WhBAA3Zbfb1blzZyUmJioxMVGVKlUyOhIAXBYjbwBwUx999JFWr16tFStWUCYBuDVWKAHADf30008KDw9X9+7dNW/ePKPjAMBfolACgJux2+269957tXPnTiUmJqpKlSpGRwKAv8TIGwDczPz587VixQotW7aMMgmgVGCFEgDcSHp6uho0aKB77rlHCxYsMDoOAFwVCiUAuAm73a4ePXpoy5YtSkxMVGBgoNGRAOCqMPIGADcRExOjZcuWacmSJZRJAKUKK5QA4AZOnjypBg0a6I477tDChQuNjgMAxUKhBAA30KtXL61bt0779+/XddddZ3QcACgWRt4AYLBFixZpyZIlWrhwIWUSQKnECiUAGOjnn39WeHi42rdvr8WLF8tkMhkdCQCKzWx0AADwZoMGDVJhYaFmzpxJmQRQajHyBgCDxMbGKiYmRgsWLFD16tWNjgMA14yRNwAYIDMzU+Hh4WrZsqWWLl3K6iSAUo2RNwAY4IUXXlBeXp5mz55NmQRQ6jHyBoAS9uWXX2rBggWaN2+eatSoYXQcAHAYI28AKEGnT59WeHi4GjdurBUrVrA6CcAjMPIGgBI0ZMgQWa1Wvf/++5RJAB6DkTcAlJCVK1dq3rx5mjt3rm644Qaj4wCA0zDyBoASkJ2drYYNG6pBgwb65ptvWJ0E4FEYeQNACRg2bJjOnDmjOXPmUCYBeBxG3gDgYt9++63mzJmjWbNmKSQkxOg4AOB0jLwBwIXOnTunhg0bqk6dOlqzZo3MZgZDADwPK5QA4EIvvfSSMjMz9d1331EmAXgsCiUAuEhcXJxmzZql6dOnq1atWkbHAQCXYeQNAC5gtVoVERGh4OBgxcXFsToJwKOxQgkALvDKK6/oxIkTWr16NWUSgMejUAKAk8XHx2v69OmaOnWqwsLCjI4DAC7HyBsAnCg3N1eNGjVSUFCQ1q9fL4vFYnQkAHA5VigBwIlGjhypY8eO6auvvqJMAvAaFEoAcJJNmzZp6tSpmjhxourXr290HAAoMYy8AcAJfvnlFzVp0kSVKlXSpk2bWJ0E4FVYoQQAJxg9erRSUlK0a9cuyiQAr0OhBAAHbdu2TdHR0XrjjTfUoEEDo+MAQIlj5A0ADsjLy1PTpk1Vrlw5bdmyRT4+/DsdgPfhbz4AcMDYsWOVnJysHTt2UCYBeC2ObwCAa7Rjxw5NnDhRI0eOVEREhNFxAMAwjLwB4Brk5+erWbNmslgs2rZtm8qUKWN0JAAwDPMZALgGUVFROnDggBISEiiTALweI28AKKbdu3frzTff1CuvvKLGjRsbHQcADMfIGwCK4cKFC2rRooUKCgq0Y8cO+fr6Gh0JAAzHyBsAimHixInau3evtmzZQpkEgN+wQgkAV2nfvn1q2rSphg4dqqioKKPjAIDboFACwFUoKChQ69atZbVatXPnTpUtW9boSADgNhh5A8BViI6O1s6dO7Vp0ybKJAD8ASuUAPA3Dhw4oMaNG2vQoEGaNGmS0XEAwO1QKAHgLxQWFqpdu3bKysrS7t27Va5cOaMjAYDbYeQNAH9h2rRp2rp1qzZs2ECZBIArYIUSAK4gKSlJjRo10tNPP62pU6caHQcA3BaFEgAuo7CwUJGRkTpx4oT27Nkjf39/oyMBgNti5A0AlzFjxgxt3LhR69ato0wCwN9ghRIA/uDw4cOKiIhQ//79NX36dKPjAIDbo1ACwO/YbDbddtttSktL0549e1S+fHmjIwGA22PkDQC/M2vWLK1bt05r166lTALAVWKFEgB+k5KSooiICPXr10+zZ882Og4AlBoUSgCQZLfbdeeddyo5OVl79+5VxYoVjY4EAKUGI28AkDRnzhytXbtWq1atokwCQDGxQgnA66Wlpalhw4Z68MEHNXfuXKPjAECpQ6EE4NXsdrs6d+6sxMREJSYmqlKlSkZHAoBSh5E3AK/20UcfafXq1VqxYgVlEgCuESuUALzWTz/9pPDwcHXv3l3z5s0zOg4AlFoUSgBeyW63695779XOnTuVmJioKlWqGB0JAEotRt4AvNL8+fO1YsUKLVu2jDIJAA5ihRKA10lPT1eDBg3UtWtXffLJJ0bHAYBSj0IJwKvY7Xb16NFDmzdv1v79+xUYGGh0JAAo9Rh5A/AqMTExWrZsmZYsWUKZBAAnYYUSgNc4efKkwsPDdfvtt2vhwoVGxwEAj0GhBOA1evXqpXXr1mn//v267rrrjI4DAB6DkTcAr7Bo0SItWbJEMTExlEkAcDJWKAF4vJ9//lnh4eFq3769Fi9eLJPJZHQkAPAoZqMDAICrDRo0SIWFhZo5cyZlEgBcgJE3AI8WGxurmJgYLViwQNWrVzc6DgB4JEbeADxWZmamwsPD1aJFCy1btozVSQBwEUbeADzWCy+8oLy8PM2ePZsyCQAuRKEE4DGio6P1xBNPKDMzU1999ZUWLFigadOmqWbNmkZHAwCPxsgbgMeIiIjQvn37VLVqVdntdrVq1UorVqxgdRIAXIwVSgAeIy0tTZKUlZWl06dPy2KxKCMjw+BUAOD5WKEE4BFycnJUoUKFS77PbDarcuXK2r17t4KDgw1KBgCejxVKAB7hyJEjl3zbZDLJZrOpTp06fyqaAADnolACKBWseQVKPJ6tXWmnlXg8W9a8gks+/32hNJvNCgoK0oIFC7R161ZVrly5hNMCgHdhY3MAbiv55Dl9sjVNcQdPKS0rV79/PsckKaSqvzrVD1LfliGKi4uTJFksFo0YMUIvvfSSAgICDMkNAN6GZygBuJ2jWbkaEbtX8YcyZDGbVGi78l9TFz+vV6FQGSuna/F/3lPt2rVLMC0AgBVKAG4lJiFNo5YnquC3EvlXZfL3nx+2+sin4xBty/QRfRIAShYrlADcxoy4ZEWvTnL4OkPvqqdnO9V1QiIAwNXgpRwAbiEmIc0pZVKSolcnaWFCmlOuBQD4exRKAIY7mpWrUcsTnXrN15cn6mhWrlOvCQC4PAolAMONiN1b9MyksxTY7BoRu9ep1wQAXB6FEoChkk+eU/yhjL99+aa4Cm12xR/K0KFT55x6XQDAn1EoARjqk61psphNLrm2xWzSgi08SwkArkahBGCouIOnnL46eVGhza64pFMuuTYA4H8olAAMk5NXoDQXvziTlpn7p2MaAQDORaEEYJgjmVa5eiNcu6TUTKuL7wIA3o1CCcAw+QU2j7oPAHgrCiUAw/j6lMxfQSV1HwDwVvwtC8AwoYEBcs373f9j+u0+AADXoVACMEyAn49Cqvq79B4hgf4K8PNx6T0AwNtRKAEYqlP9IJfuQ9mpXpBLrg0A+B8KJQBD9W0Z4tJ9KPu1CnHJtQEA/0OhBGCoutUrqH1YNaevUlrMJrUPq6awoApOvS4A4M8olAAMF9UjQj5OLpQ+ZpOiekQ49ZoAgMujUAIwXHBVf43pFu7Ua47tFq5gF7/wAwD4FYUSgFvo0zxEQ++q55RrDburvno359lJACgpJrvd7uqTzwDgqsUkpGnU8kQV2OzFelnHYjbJx2zS2G7hlEkAKGEUSgBu52hWrkbE7lX8oQxZzKa/LJYXP28fVk1RPSIYcwOAASiUANxW8slz+mRrmuKSTiktM1e//8vKpF83Le9UL0j9WoXwNjcAGIhCCaBUsOYVKDXTqvwCm3x9zAoNDOAEHABwExRKAAAAOIS3vAEAAOAQCiUAAAAcQqEEAACAQyiUAAAAcAiFEgAAAA6hUAIAAMAhFEoAAAA4hEIJAAAAh1AoAQAA4BAKJQAAABxCoQQAAIBDKJQAAABwCIUSAAAADqFQAgAAwCEUSgAAADiEQgkAAACHUCgBAADgEAolAAAAHEKhBAAAgEMolAAAAHAIhRIAAAAOoVACAADAIRRKAAAAOIRCCQAAAIdQKAEAAOAQCiUAAAAcQqEEAACAQyiUAAAAcAiFEgAAAA6hUAIAAMAhFEoAAAA4hEIJAAAAh1AoAQAA4BAKJQAAABxCoQQAAIBDKJQAAABwCIUSAAAADvl/CUPWf8sg7UwAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Polymer_C3_1_top_graph_representation = nx.MultiDiGraph()\n",
        "Polymer_C3_1_top_graph_representation.add_nodes_from(\n",
        "    [\"E1\", \"D1\", \"R1\", \"R1'\", \"D2\", \"R2\", \"R2'\", \"E2\"]\n",
        ")\n",
        "Polymer_C3_1_top_graph_representation.add_edges_from(\n",
        "    [\n",
        "        (\"E1\", \"D1\"),\n",
        "        (\"D1\", \"R1\"),\n",
        "        (\"R1\", \"D1\"),\n",
        "        (\"D1\", \"R1'\"),\n",
        "        (\"R1'\", \"D1\"),\n",
        "        (\"D1\", \"D2\"),\n",
        "        (\"D2\", \"R2\"),\n",
        "        (\"R2\", \"D2\"),\n",
        "        (\"D2\", \"R2'\"),\n",
        "        (\"R2'\", \"D2\"),\n",
        "        (\"D2\", \"E2\"),\n",
        "    ]\n",
        ")\n",
        "nx.draw(Polymer_C3_1_top_graph_representation)\n",
        "print(\n",
        "    \"Polymer_C3_1_top_graph_representation number of nodes: \",\n",
        "    Polymer_C3_1_top_graph_representation.number_of_nodes(),\n",
        ")\n",
        "print(\n",
        "    \"Polymer_C3_1_top_graph_representation number of edges: \",\n",
        "    Polymer_C3_1_top_graph_representation.number_of_edges(),\n",
        ")\n",
        "\n",
        "Polymer_C3_1 = Polymer(\n",
        "    repeat_unit_smiles_list=[\"*CC(*)(C)C\", \"*CC(*)c1ccccc1\"],\n",
        "    repeat_unit_smiles_weight_list=[1, 1],\n",
        "    end_group_smiles_list=[\"*C(C)(C)C#N\", \"*C(C)(C)C#N\"],\n",
        "    end_group_smiles_weight_list=[1, 1],\n",
        "    graph_representation=Polymer_C3_1_top_graph_representation,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "pkO_5dOtpY_E"
      },
      "source": [
        "## Polymer C3-2\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1xsvp9WHGkAxIcU5-8qLlm5dG61jp594J\"  width=\"50%\" height=\"50%\">"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "FUemADZ3SN0d",
        "outputId": "1f9e0a4d-f8c2-4dec-9067-6f8385aabebd"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polymer_C3_2_top_graph_representation number of nodes:  11\n",
            "Polymer_C3_2_top_graph_representation number of edges:  16\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Polymer_C3_2_top_graph_representation = nx.MultiDiGraph()\n",
        "Polymer_C3_2_top_graph_representation.add_nodes_from(\n",
        "    [\"E1\", \"D1\", \"R1\", \"R1'\", \"D2\", \"R2\", \"R2'\", \"D3\", \"R3\", \"R3'\", \"E2\"]\n",
        ")\n",
        "Polymer_C3_2_top_graph_representation.add_edges_from(\n",
        "    [\n",
        "        (\"E1\", \"D1\"),\n",
        "        (\"D1\", \"R1\"),\n",
        "        (\"R1\", \"D1\"),\n",
        "        (\"D1\", \"R1'\"),\n",
        "        (\"R1'\", \"D1\"),\n",
        "        (\"D1\", \"D2\"),\n",
        "        (\"D2\", \"R2\"),\n",
        "        (\"R2\", \"D2\"),\n",
        "        (\"D2\", \"R2'\"),\n",
        "        (\"R2'\", \"D2\"),\n",
        "        (\"D2\", \"D3\"),\n",
        "        (\"D3\", \"R3\"),\n",
        "        (\"R3\", \"D3\"),\n",
        "        (\"D3\", \"R3'\"),\n",
        "        (\"R3'\", \"D3\"),\n",
        "        (\"D3\", \"E2\"),\n",
        "    ]\n",
        ")\n",
        "nx.draw(Polymer_C3_2_top_graph_representation)\n",
        "print(\n",
        "    \"Polymer_C3_2_top_graph_representation number of nodes: \",\n",
        "    Polymer_C3_2_top_graph_representation.number_of_nodes(),\n",
        ")\n",
        "print(\n",
        "    \"Polymer_C3_2_top_graph_representation number of edges: \",\n",
        "    Polymer_C3_2_top_graph_representation.number_of_edges(),\n",
        ")\n",
        "\n",
        "Polymer_C3_2 = Polymer(\n",
        "    repeat_unit_smiles_list=[\n",
        "        \"*CC(*)(C)C(=O)OC(C)C\",\n",
        "        \"*CC(*)c1ccccc1\",\n",
        "        \"*CC(*)c1ccc(C)c(C)n1\",\n",
        "    ],\n",
        "    repeat_unit_smiles_weight_list=[1, 1, 1],\n",
        "    end_group_smiles_list=[\"*C(C)(C)C#N\", \"*C(C)(C)C#N\"],\n",
        "    end_group_smiles_weight_list=[1, 1],\n",
        "    graph_representation=Polymer_C3_2_top_graph_representation,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i5-QuC93pa17"
      },
      "source": [
        "## Polymer C3-3\n",
        "\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=12ic4l4X7U3sgeky5G2nIG_U_QcigqC28\"  width=\"50%\" height=\"50%\">"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 553
        },
        "id": "8l7h3jW95f4B",
        "outputId": "96698159-8478-411d-9c03-9ba0cdb248ed"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Polymer_C3_3_top_graph_representation number of nodes:  14\n",
            "Polymer_C3_3_top_graph_representation number of edges:  21\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 640x480 with 1 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAApQAAAHzCAYAAACe1o1DAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABXq0lEQVR4nO3deXhU5f3+8fvMDAkkgJBAQJCwBRBjLCqrEDCg0IpScAkoqLi0WosLlUWisioUARG0X62tyq9KCy5Q0VZFMCURWYIihKishsECWVlCAgmTmd8flMgOYebMmeX9ui4uJSc8z2cgDHee1fB4PB4BAAAAF8lmdQEAAAAIbgRKAAAAeIVACQAAAK8QKAEAAOAVAiUAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAArxAoAQAA4BUCJQAAALxCoAQAAIBXCJQAAADwCoESAAAAXiFQAgAAwCsESgAAAHiFQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFcIlAAAAPAKgRIAAABeIVACAADAKwRKAAAAeIVACQAAAK8QKAEAAOAVAiUAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAArxAoAQAA4BUCJQAAALzisLoAVF9puUu5RaWqcLkV4bCpRWy0oiP5owQAANYghQSJrXklmr/GqfTN+XIWl8lzwjNDUnxMlFLaxWlol3i1aVTHqjIBAEAYMjwej+f8nwar7CouU9ribGVuK5TdZqjSffY/ruPPkxMaaOqgJDWLifJjpQAAIFwRKAPYgiynJizJkcvtOWeQPJXdZshhMzRpQKKGdIo3sUIAAAACZcB6JX2rZi7d4nU7o/q21YiUNj6oCAAA4MzY5R2AFmQ5fRImJWnm0i1amOX0SVsAAABnQqAMMLuKyzRhSY5P2xy/JEe7ist82iYAAMBxBMoAk7Y4W65qrJe8EC63R2mLs33aJgAAwHEEygCyNa9EmdsKq7UB50JUuj3K3FaobfklPm0XAABAIlAGlPlrnLLbDFPattsMvbOatZQAAMD3CJQBJH1zvs9HJ4+rdHuUviXflLYBAEB4I1AGiEPlLjlN3jjjLCpTabnL1D4AAED4IVAGiJ1FpTL7QFCPpNyiUpN7AQAA4YZAGSAqXO6Q6gcAAIQPAmWAiHD454/CX/0AAIDwQboIEC1io2XO/u6fGf/rBwAAwJcIlAEiOtKh+JgoU/uIj41SdKTD1D4AAED4IVAGkJR2caaeQ5nSNs6UtgEAQHgjUAaQoV3iTT2HcljXeFPaBgAA4Y1AGUDaNKqj5IQGPh+ltNsMJSc0UEJcHZ+2CwAAIBEoA87UQUly+DhQOmyGpg5K8mmbAAAAxxEoA0yzmChNGpDo0zYnD0hUM5M3/AAAgPBFoAxAQzrFa1Tftj5pa3TfdhrcibWTAADAPIbH4zH7xj9cpAVZTk1YkiOX21OtzTp2myGHzdDkAYmESQAAYDoCZYDbVVymtMXZytxWKLvNOGewPP48OaGBpg5KYpobAAD4BYEySGzIzdevn5yheu2760BlDZ34h2bo2KHlKW3jNKxrPLu5AQCAX3FtShBwu90a/dth2vn552rec61WLl2u3KJSVbjcinDY1CI2mhtwAACAZUghQWDcuHH6/PPPJUnbt29XdKRDiU0usbgqAACAY5jyDnBvvfWW7r///pM+tnfvXjVq1MiiigAAAE7GsUEBbMWKFfrtb3972sdXrlxpQTUAAABnRqAMYI8//rhcLpcM4+ebcxwOB4ESAAAEFAJlAHvnnXc0efJkJSb+fHOOy+XSV199ZWFVAAAAJ2NTTgC78sordeWVV2rfvn06ePCg3n33Xa1YsULx8RxWDgAAAgebcoJAx44ddcUVV+hvf/ub1aUAAACchinvAHfw4EGtX79ePXv2tLoUAACAMyJQBrhVq1bJ7XYrOTnZ6lIAAADOiEAZ4DIyMhQXF6e2bdtaXQoAAMAZESgDXEZGhnr27HnS0UEAAACBhEAZwA4fPqy1a9eyfhIAAAQ0AmUAW7t2rSoqKgiUAAAgoBEoA1hGRobq1aunK6+80upSAAAAzopAGcAyMjLUo0cP2e12q0sBAAA4KwJlgDp69KhWrVrFdDcAAAh4BMoAtX79epWWlnL+JAAACHgEygCVkZGhqKgoXXPNNVaXAgAAcE4EygCVkZGhbt26KSIiwupSAAAAzolAGYDcbrcyMzNZPwkAAIICgTIAbdq0Sfv37ydQAgCAoECgDEAZGRmqUaOGunTpYnUpAAAA50WgDECZmZnq3LmzatWqZXUpAAAA50WgDDAej0cZGRlMdwMAgKBBoAww27Zt0969ewmUAAAgaBAoA0xGRoZsNpuuu+46q0sBAAC4IATKAJORkaEOHTqobt26VpcCAABwQQiUAYb1kwAAINgQKAOI0+lUbm4ugRIAAAQVAmUAyczMlCT16NHD4koAAAAuHIEygGRmZuqKK65Qw4YNrS4FAADgghEoAwjrJwEAQDAiUAaI/Px8ff/99wRKAAAQdAiUAeLLL7+UJCUnJ1tcCQAAQPUQKANERkaGWrZsqcsuu8zqUgAAAKqFQBkgWD8JAACCFYEyABw4cEDffvstgRIAAAQlAmUAWLlypTweD4ESAAAEJQJlAMjMzNSll16q1q1bW10KAABAtREoA8Dx9ZOGYVhdCgAAQLURKC1WVlamrKwsprsBAEDQIlBabM2aNTp69CiBEgAABC0CpcUyMjJUv359XXHFFVaXAgAAcFEIlBbLyMhQcnKybDb+KAAAQHAixViooqJCq1atYrobAAAENQKlhb7++msdPnyYQAkAAIIagdJCGRkZio6O1tVXX211KQAAABeNQGmhjIwMde/eXQ6Hw+pSAAAALhqB0iKVlZVauXIl090AACDoESgtkp2drQMHDhAoAQBA0CNQWiQjI0MRERHq1KmT1aUAAAB4hUBpkYyMDHXp0kU1a9a0uhQAAACvECgt4PF4lJGRwXQ3AAAICQRKC2zevFkFBQUESgAAEBIIlBbIyMiQ3W5Xt27drC4FAADAaxyAaIGMjAxdc801qlOnjtWlAAhRpeUu5RaVqsLlVoTDphax0YqO5C0fgDl4d7FARkaGUlNTrS4DQIjZmlei+WucSt+cL2dxmTwnPDMkxcdEKaVdnIZ2iVebRnxDC8B3DI/H4zn/p8FXdu7cqRYtWujDDz/UgAEDrC4HQAjYVVymtMXZytxWKLvNUKX77G/rx58nJzTQ1EFJahYT5cdKAYQq1lD6WUZGhiSpe/fuFlcCIBQsyHLqhtkr9NWOIkk6Z5g88flXO4p0w+wVWpDlNL1GAKGPKW8/y8jI0JVXXqnY2FirSwEQ5F5J36qZS7dc1K+tdHtU6fboqUXZKjxUrhEpbXxcHYBwwgiln3H+JABfWJDlvOgweaqZS7doISOVALxAoPSjvXv3asuWLQRKAF7ZVVymCUtyfNrm+CU52lVc5tM2AYQPAqUfZWZmSpKSk5MtrgRAMEtbnC3XedZKVpfL7VHa4myftgkgfBAo/SgjI0MJCQlq0qSJ1aUACFJb80qUua3wvJtvqqvS7VHmtkJtyy/xabsAwgOB0o9YPwnAW/PXOGW3Gaa0bbcZemc1aykBVB+B0k+Ki4uVnZ1NoATglfTN+T4fnTyu0u1R+pZ8U9oGENoIlH6ycuVKeTwe1k8CuGiHyl1ymrxxxllUptJyl6l9AAg9BEo/yczMVNOmTdWyZUurSwEQpHYWlcrsq808knKLSk3uBUCoIVD6yfH1k4ZhztonAKGvwuUOqX4AhA5uyjFJablLuUWlqnC5VVlRrm825mj48OFWl+U3J77+CIdNLWKjFR3JlxvgjQiHf8YA/NUPgNDBv/A+tDWvRPPXOJW+OV/O4rKTpqYufewf+n/FNbR3SY6GdolXm0Z1LKvTLOd6/Yak+JgopbSLC9nXD5itRWy0DMnUaW/jf/0AQHUYHo/H7CU5IW9XcZnSFmcrc1uh7DbjnDswjz9PTmigqYOS1Cwmyo+VmiPcXz/gT71mpGuniRtzmsdGacWoFNPaBxCamNfw0oIsp26YvUJf7SiSpPMe53H8+Vc7inTD7BVaEOT354b76wf8rWdCrOwmLcW22wyltI0zp3EAIY0RSi+8kr5VM5du8bqdUX3bakRKGx9U5F/h/voBswwfPlxbtmxRdHS0oqKiVKtWLVVWVmrdunUqMaJVe/B00/peNrKnEuJYkgKgelhDeZEWZDl9EqYkaebSLWpYO1KDO8X7pD1/CPfXD5hp/fr12rhx4xmftW/fXpc3qaUNe4/49IBzu83Qda1iCZMALgpT3hdhV3GZJizJ8Wmb45fkaJfJBxb7Sri/fsBsY8aMOePHr7/+em3atElzhnaVw8fXLzpshqYOSvJpmwDCB4HyIqQtzpbLx1efudwepS3O9mmbZgn31w+Yxe1268UXX9QTTzxx0sdtNpvatWunJUuWyGazqVlMlCYNSPRp35MHJLJJDsBFI1BW09a8EmVuK/T5XbqVbo8ytxVqW36JT9v1tXB//YAZjhw5oscff1x16tTRk08+qUOHDum6666TJBmGoejoaH388ceqU+fn6eghneI1qm9bn/Q/um87lpwA8AqBsprmr3HK7uOppuPsNkPvrD7zrueSkhK53ebfXuHxeHSufVpWvX4gFOXn5+uOO+5QnTp1NHfuXEVGRmrq1KkqLS3VZ599prp160qS3nvvPSUkJJz260ektNEfb01SpMNW7b+XdpuhSIdN029N0u9TTm8bAKqDQFlN6ZvzfT46d1yl26P0LfknfWzbtm0aPny46tevr3feeceUfk+UnJysdu3aacGCBaqsrDztub9fPxCKvv/+e/Xq1UuNGzfW+++/r6ZNm+qdd95RcXGxxo0bJ5vNptq1a2vevHn6xz/+oX79+p21rSGd4rVsZC9d1ypWks4bLI8/v65VrJaN7MXIJACfYJd3NRwqd8lp8sYRZ1GZSstd2u38UVOmTNH8+fNls9lUWVmpoqIiU/uWpF27dsnpdOrOO+/UhAkTNGXKFN1+++2y2Wx+ff1c04hQtHz5cj3++OPKyTm2qe0Xv/iFXnnlFfXo0eOMnz9o0KALardZTJTefqDLz7dVbcmXs+gMt1XFRimlbZyGdY1nNzcAn+IcymrI2X1A/V/+0vyOPp2mnd+ulGEYJ00/JyQkqEePHjIMQzbbscFlwzBO+yHprM+PPzv+/6e29dprr6mk5OR1jDExMRo4cKA63ThIf9xg0onKJ/jXoz2U2OQS0/sB/OXNN9/U+PHj9d///leGYah379569dVX1aaNeeevlpa7lFtUqgqXWxEOm1rERvONGgDT8O5SDRUu89cwStKevAJJOm0t47Zt27Rt2za/1HCi4uJivfnmm3rnky916b0vmt6fv36fATO5XC5NnjxZc+fO1YEDB1SjRg0NHTpUc+fOVUxMjOn9R0c6+MYMgN8QKKshwuGfJacOm1Rxho/fcsstev/996s2zrjdbq//X9JJH+/Ro4f27t0r6dhIpsfj0cCBA/XYY4/JFhuve/7+vemv31+/z4AZDh48qCeeeEJ///vfVV5ertq1a2vMmDGaMmWKIiIirC4PAExBoKyGFrHRMiSZu0bAoyMFu8745IsvvlC/fv3UsmXL0340bty4auraGw7HsS8Ju92u4cOH6+mnn1bLli0lHZtCM/S9qa/f0LHfZyDYOJ1OPfzww/rss8/kdrvVqFEjjR8/Xg8//LBP/m4CQCAjUFZDdKRD8TFR2mnixpTmsdH6dMM3Gjp0qNavX3/StHfv3r0VFRWlnJwcffzxxyooKKh6VrNmTTVv3lwtW7ZUq1atTguc9evXv6D+Bw0apCNHjigtLU0tWrQ46Zk/Xn98bBTrvBBUsrKy9Mgjj2jdunWSpLZt22rWrFm6+eabLa4MAPyHTTnVNHFJjt5es9OUo3PsNkN3d2muiQMS5XK5NGvWLD3zzDOqrKyUx+PRgQMHqs6lk6RDhw4pNzdXP/744xl/nLi55pJLLjnjyGbLli3VokULRUVd2A0Z/nr9QKBbtGiRxowZo+3bt0uSunbtqldffVUdOnSwtjAAsACBspq25pXoxpcyTGt/2cieJx3nkZOTo6FDh2rfvn3auXPnBbfj8XhUXFx81rCZm5urioqfV2o2atTorIGzWbNmqlGjhiT/v34gkLjdbs2ZM0fTpk1TQUGB7Ha7+vfvr1dffVVNmjSxujwAsAyB8iLc/cYafbWjyKejdHaboetaxertB7qc9qyyslJHjhxRdLTv1ha63W7t2bOnKmDu2LHjpMD5008/VU2322w2NWvWrCpgbr70Ru1x15FbvjtC6FyvH7DakSNHNG7cOL3++usqKytTzZo1NXz4cM2aNeuCR/cBIJQRKC/CruIy3TB7hcp9eLxNpMOmZSN7qVlMYPzjVFFRIafTeebRzYISRd76nAxHRNV5lt4KtNcPSFJhYaEeeeQRLV68WC6XS/Xr19eTTz5ZdZsNAOAYAuVFWpDl1FOLsn3W3vRbk4LqCrR5mVs18d9bfNZesL1+hLbvv/9eDz/8sDIzM+XxeBQfH6+pU6dq6NChVpcGAAGJQOmFV9K3auZS70PV6L7t9PuUBB9U5F/evn6PxyPDMHR03QdqVvLdGddvxsfHV63fBMx26tWIV111lV5++WX17NnT4soAILARKL20IMupCUty5HJ7qrWm0m4z5LAZmjwgMahH5i769RuSzZD6NzqkmP2bT1u/6XYfW05w6vpNs87fRHh766239Oyzz1ZdjZiSkqLXXnvN1KsRASCUECh9YFdxmdIWZytzW6EMeeQ5x2YVu81Qpduj5IQGmjooKSTWDJ74+o+/vrO5kNdfUVGhXbt2nXWHen5+ftXnRkZGqkWLFmcNnPXr1/fZOk+EFpfLpeeee04vvfRS1dWId9xxh15++WW/XI0IAKGEQOkje/bsUcsO1+mGhyeqpE68nEVlJ90oY+jYod0pbeM0rGt8SB6NszWvRPPXOJW+Jd/U119aWnrS+Zun7lA/8fzNunXrnvP8TV/unEdwKCkp0RNPPKH58+dXXY34yCOPcDUiAHiBQOkDR44cUbt27eR0OvXyyy9rxIgRKi13KbeoVBUutyIcNrWIjQ6rG2Csev3VPX8zLi7urIGT9Zvm8+fXidPp1O9+9zt9+umnVVcjPvvss/rd737HsgkA8FL4JByTVFRU6LbbbpPT6ZR07A5s6dg1hYlNLrGyNEtZ9foNw1BsbKxiY2PVsWPH056fev7miT+++uqr09ZvXnbZZWcNnJdeeilB5CJUjWRvzpez+Awj2TFRSmkXp6Fd4tWmkfcj+VyNCADmY4TSC0ePHlVqaqo+/PDDqh3LI0aM0Ny5c60uDRepuus3j9+ffqYfMTExrN88ga/X2h63du1azZo1S2+88YZq165d9fHFixdr9OjRXI0IAH5AoLxIlZWVuuuuu/Tee+/pxN/CPn36aNmyZRZWBjOdun7z1B8HDx6s+tw6deqcNWy2bNkyrNZvensawqQBiRpyhtMQdu/erQ4dOqigoEAvvfSSHn30Uc2dO1dTp07lakQA8CMC5UV66623dP/995/28caNG2vPnj0WVASreTwe7du377SQeXzT0KnrNxs2bKiWLVuqVatWIb1+01fntY7q21YjUn4+xqe8vFzJyclav369XC6XoqOj5Xa7dfjwYdWsWVP33nuvXnzxRa5GBAA/IFBepP3792vOnDl699139d133530rKSk5KSpN0A69/rNM52/GQrrN826Ucrj8ejBBx/UvHnzqn7PJCk6Olrjxo3jakQA8DMCpZdef/11PfTQQxo4cKD27Nmj77//Xj/++CPn2KHajh49etb704Nx/aaZd97/dc50TZ48+aRnhmHoyiuv1IYNGyx/7QAQbgiUXurcubPWrVunI0eOKCIiompzDuBrwbZ+8+431uirHUXVWjN5PnZDqnN4jza89JuqjzkcDhmGocrKSrndbn355Zfq3r27z/oEAJwfgdILbrdbNWvWVOvWrfX9999bXQ7C2NnWb554/mZ5eXnV5x9fv3m28ze9PeB7a16Jbnwpw9uXdVYNs15T72uvUO3atXX48OGqH263W88884zi44P3OlMACEacQ+mFf/7znzp69KjuvPNOq0tBmDMMQzExMYqJidG111572nO32629e/ee8WahVatWnbZ+s2nTpmcNnE2aNDnv+sT5a5znPRroYtlthvo/9kdNHJDo87YBABeHEUov9O7dW+np6Tpw4IDq1q1rdTnARavO+s2IiIhzrt+MjY3V9TP/o53FZabV2zw2SitGpZjWPgCgegiUXoiKilLDhg21c+dOq0sBTFWt9ZsxDRXzmzclE9cSG5I2TewXVteZAkAg4934ImVkZOjw4cO69dZbrS4FMF10dLQSExOVmHj6NPOp6zfXbt2tdw+auzHNIym3qDSsrzcFgEBCoLxIL774oiRp9OjRFlcCWOvU9Zutnfv07qtfmd5vhQ+PIwIAeIeTfy9Senq64uLiuM4NOEWEwz9vK/7qBwBwfrwjX4RNmzbp4MGDuummm6wuBQg4LWKjZfZJrMb/+gEABAamvC/CCy+8IEkaM2aMxZUAgSc60qH4mChTd3k3rGWoYM9PWrNjh7Zu3aqtW7dqy5Yt+v7779W5c2fNnz/ftL4BAKcjUF6ETz/9VJdcconat29vdSlAQEppF6e31+w05RxKuSu1LfNfajmhf9WHatSoIZfLJY/Hc8aNQwAAczHlXU0//fSTCgoK1Lt3b6tLAQLW0C7x5oRJSbLZ9divrpbdbq/60NGjR3X8BLRBgwaZ0y8A4KwIlNV0fLr7ySeftLgSIHC1aVRHyQkNZLf5djWl3WYoOaGBJv7hYX3zzTeqV6/eabf2DB8+XJdffrmmTZumsjLzpt0BAD/jYPNqio+PV2FhIf9QAeexq7hMN8xeoXIfHu8T6bBp2cheahYTJUnKzs5Wz549VVJSIo/Ho1/84heKiIjQ119/LZfLJcMw1KZNG91zzz0aOXKkoqKifFYLAOBnjFBWw/79+7Vr1y5dd911VpcCBLxmMVGa5OP7ticPSKwKk5KUlJSkjIwM1a1bV263W6NGjdLq1atVXl6ud955R126dNGOHTv0zDPPqHbt2mrbtq0mT56sQ4cO+bQuAAh3BMpqOH6Y+WOPPWZxJUBwGNIpXqP6tvVJW6P7ttPgTvGnffx4qPzNb36jX//615Ikm82moUOHatWqVSovL9eCBQvUrVs35ebmasKECapbt64SEhI0ceJEwiUA+ABT3tXQtm1b5ebm6siRI6et2wJwdguynJqwJEcut6dam3XsNkMOm6HJAxLPGCary+126/3339fcuXO1du1aHT16VJLUqlUrDR06VKNGjVLdunW97gcAwg2B8gIdOXJEUVFR6ty5s1avXm11OUDQ2VVcprTF2crcVii7zThnsDz+PDmhgaYOSjppmttX3G63Fi9erDlz5mjNmjWqqKiQJLVs2VJ33nmnRo8erXr16vm8XwAIRQTKCzRnzhw98cQT+utf/6oHHnjA6nKAoLU1r0Tz1ziVviVfzqIynfgGZEiKj6mlWvt/1KyHByqxWaxfavJ4PPrwww/10ksvVa3BlKQWLVrozjvv1JgxYwiXAHAOBMoLdPXVV2vjxo0qLy+Xw8F58IAvlJa7lFtUqgqXWxEOm1rERuvfSxYrNTVVnTp10pdffqmIiAi/17VkyRLNnj27ag2mJDVv3lyDBw/W2LFjFRMT4/eaACCQESgvgNvtVkREhNq3b6/s7GyrywFC2uuvv66HHnpIktS/f3998MEHioyMtKyejz/+WLNnz9ZXX32lI0eOSDp2fFhqaqqeeuopxcb6ZxQVAAIZO0suwN///ndVVlbqnnvusboUIOTt2LGjatPbJ598okGDBlWNElrh5ptv1vLly3X48GH9+9//Vp8+fZSfn6+ZM2eqQYMGio+P15NPPqnCwkLLagQAqzFCeQF69Oihr776SocOHeJgZMBkt912mxYvXlx1laLNZlPfvn21ePFi1axZ0+LqfvbZZ59p1qxZ+vLLL3X48GFJ0mWXXabbb79d48aNU1xcnMUVAoD/ECgvQM2aNdW0aVNt377d6lKAkJeYmKjvvvvutI/PnDkzYK88Xb58uWbMmKGMjIyqcNm0aVPddtttGjdunBo3bmxxhQBgLqa8z+Ozzz5TeXm5UlNTrS4FCHkej0c7duyQJBnGsXvAW7durYkTJ2r48OEWVnZuffr00aeffqqysjItX75cv/zlL7Vv3z7NnTtXl156qZo2bapHH31Uu3fvtrpUADAFI5Tn8atf/UqffvqpCgoK1KBBA6vLAULa0aNHFRsbq4YNG+qXv/yl/u///k+LFi3SoEGDrC7toqxYsUIvvPCCVqxYodLSUknSpZdeqkGDBiktLU1Nmza1uEIA8A0C5XnUrl1bdevWZWQB8JOjR4/K4XDIMAx16NBB7du31z/+8Q+ry/Lal19+qenTpys9Pb0qXDZu3FgDBw5UWlqamjVrZnGFAHDxmPI+h3Xr1qm0tFQDBgywuhQgbNSoUaNqujs1NVUfffSRysrKLK7Kez169NBHH32kQ4cOaeXKlRowYIAOHTqk1157TfHx8WrcuLEeeugh7dy50+pSAaDaGKE8h9TUVL333nvasWOHWrZsaXU5QNjZtm2b2rRpo/fee0+333671eWYYs2aNZo2bZq++OILlZSUSJLi4uI0YMAAPfPMM2revLnFFQLA+REozyEmJkaGYaioqMjqUoCwde2116p169Z69913rS7FdFlZWZo2bZqWLVtWFS4bNmyoW265Rc888wzf2AIIWEx5n8Dj8eiGG27QbbfdptmzZ2vfvn3q27ev1WUBYS01NVUff/xx1brDUNapUyctWrRIBw8eVFZWlm677TaVl5frzTffVKtWrdSwYUPdd999HGEGIOAwQnmKevXq6cCBA1U/79y5s+6//37deeedqlu3roWVAeFpx44dat26tRYsWKDBgwdbXY4lvvnmG02bNk2ff/551ftTbGys+vfvr6efflpt27a1uEIA4Y5AeYpu3bpp9erVVT83DEMej0djxozR9OnTLawMCF+dOnVSfHy8PvjgA6tLsdyGDRs0bdo0ffbZZ9q/f7+kY8tz+vfvr7S0NF1++eXWFgggLDHlfYorr7xSdru96uc2m00tW7bUE088YV1RQJgbPHiw/v3vf1etKwxnv/jFL7RgwQLt27dP2dnZGjJkiNxut95++221b99esbGxGjZs2BlvGwIAsxAoT9G+fXtVVlZKOhYmmzRpooyMDF166aUWVwaErzvuuENHjhzRxx9/bHUpAeXKK6/UP/7xD+3bt0+bNm3SXXfdJY/Ho/nz5ysxMVExMTG66667tGnTJqtLBRDiCJSnOHG6qHHjxsrIyNBll11mYUUAmjdvri5dumjhwoVWlxKwEhMTNX/+fBUXF+u7777TsGHDZBiG/vGPfygpKUn169fXkCFDtHHjRqtLBRCCCJSnaNWqlaRjhytnZGSoRYsW1hYEQNKx3d6ffPKJDh48aHUpAa99+/Z6++23VVRUpB9++EH33HOP7Ha7Fi5cqF/84heqV6+eUlNT9e2331pdKoAQEfaBsrTcpZzdB7TeuU85uw9oy45jt1S8/vrrat26tcXVATjujjvuUEVFhZYsWWJ1KUGlXbt2+n//7/+psLBQW7Zs0fDhw1WjRg299957uvrqq3XJJZfo9ttv1zfffGN1qQCCWFju8t6aV6L5a5xK35wvZ3GZTv4N8MgoLdY9N1yjYV2aq02jOhZVCeBU3bt3V0xMjD766COrSwl627dv1/PPP6+PP/5YBQUFkqS6deuqT58+SktLU8eOHS2uEEAwCatAuau4TGmLs5W5rVB2m6FK99lf+vHnyQkNNHVQkprFRPmxUgBnMmfOHI0ePVr5+fmqV6+e1eWEjB9//FFTp07VkiVLlJ+fL0mqU6eO+vTpo3Hjxqlz584WVwgg0IVNoFyQ5dSEJTlyuT3nDJKnstsMOWyGJg1I1JBO8SZWCOB8/vvf/6pZs2Z66623dO+991pdTkjauXOnpk6dqg8//FB5eXmSpNq1a6t379566qmn1K1bN4srPLZUKbeoVBUutyIcNrWIjVZ0pMPqsoCwFhaB8pX0rZq5dIvX7Yzq21YjUtr4oCIAF6tnz56qU6eO/vWvf1ldSshzOp2aNm2a/vnPf2rv3r2SpOjoaKWkpOipp55S9+7d/VbLuZYqGZLiY6KU0i5OQ7vEs1QJsEDIB8oFWU49tSjbZ+1NvzVJgxmpBCzzyiuvaOTIkcrLy1NMTIzV5YSNn376SdOmTdPixYu1Z88eScfC5fXXX6+xY8cqOTnZlH5ZqgQEh5AOlLuKy3TD7BUqd7l91makw6ZlI3vxRgVYZM+ePWratKn++te/6v7777e6nLC0e/duTZs2TYsWLdLu3bslSVFRUerVq5fGjBmj66+/3if9sFQJCB4hHSjvfmONvtpRVK03ovOx2wxd1ypWbz/QxWdtAqie66+/XjVr1tSnn35qdSlhb+/evZo2bZo++OAD/fe//5Uk1apVSz179tSYMWPUu3fv037NlClTlJeXpzlz5px01e2JWKoEBJeQDZRb80p040sZprW/bGRPJcSxTgewwquvvqpHH31UeXl5io2Ntboc/M/evXs1ffp0vf/++/rpp58kHQuXycnJGjNmjPr06aPy8nLFxsaqtLRUQ4YM0dtvvy2H4+QNNSxVAoJPyB5sPn+NU3abYUrbdpuhd1Y7TWkbwPndeuut8ng8WrRokdWl4ASNGzfW7NmztWvXLuXl5ekPf/iDGjRooKVLl+qGG25QrVq11KVLF5WWlkqSFi5cqLvvvlsul6uqjV3FZZqwJMendY1fkqNdxWU+bRPAyUI2UKZvzvfpVPeJKt0epW/JN6VtAOfXqFEjXX/99Xr33XetLgVnERcXp1mzZsnpdKqgoECjRo1SXFycNmzYUPU5Ho9HCxYs0NChQ6tCZdribLl8/N7tcnuUtth3I54ATheSgfJQuUtOk78bdRaVqbTcdf5PBGCK1NRUffHFF1W3vCBwNWjQQDNmzNCWLVtUq1at056/++67io+P16dffavMbYU+HwyodHuUua1Q2/JLfNougJ+FZKDcWVQqsxeGeiTlFpWa3AuAs7n11ltlGAbT3kFk2bJlOnz4sGw222mbcfbs2aO7Jrwqw6R3b5YqAeYKyUBZ4cNjggKhHwCna9iwoXr37q2FCxdaXQouUKNGjdSnTx8NHz5czz33nN5//31t2LBBpaWlOnz4sFonD5BH5qx9Z6kSYK6QvKsqwuGfnOyvfgCcWWpqqh566CHt3btXjRs3trocnEfHjh21bNmyMz47VO5S4WFz+z++VIlrGgHfC8lE1CI22qTvcX9m/K8fANYZNGiQbDYb094hgKVKQHALyUAZHelQvMk32cTHRvFdLmCx2NhY3XDDDez2DgEsVQKCW0gGSklKaRdn6jmUKW3jTGkbQPWkpqYqIyOj6gpABCeWKgHBLWT/Zg3tEm/qOZTDunLrAhAIBg4cKIfDoQ8++MDqUuAFlioBwS1kA2WbRnWUnNDA56OUdpuh5IQGXLsIBIj69evrxhtvZNo7yLFUCQhuIRsoJWnqoCQ5fBwoHTZDUwcl+bRNAN4ZPHiwvvzyS/33v/+1uhR4gaVKQPAK6UDZLCZKkwYk+rTNyQMS1czk76IBVM+AAQMUERGh9957z+pS4AWWKgHBK6QDpSQN6RSvUX3b+qSt0X3baXAn3pCAQFOvXj3169ePae8gx1IlIHiFfKCUpBEpbfTHW5MU6bBV+43KbjMU6bBp+q1J+n1KgkkVAvBWamqqVq1aJaeT6/WCGUuVgOAUFoFSOjZSuWxkL13XKlaSzhssjz+/rlWslo3sxcgkEOAGDBigyMhIvf/++1aXAi+wVAkITobH4zH7coKAszWvRPPXOJW+JV/OorKTbmcwdGwnYErbOA3rGs8UCRBEBg0apN27d2vNmjVWlwIvvZK+VTOXbvG6ndF92zG7BPhBWAbKE5WWu5RbVKoKl1sRDptaxEZzrAQQpP7xj3/orrvu0o8//qgWLVpYXQ68tCDLqQlLcuRye6q1WcduM+SwGZo8IJHZJcBPwj5QAggdJSUliouL06RJkzRmzBiry4EP7CouU9ribGVuK5TdZpwzWB5/npzQQFMHJTHNDfgRgRJASLn99tu1c+dOZWVlWV0KfIilSkBgI1ACCCnvvvuuBg8erG3btql169ZWlwMTsFQJCDxhs8sbQHjo37+/atWqxSHnISw60qHEJpfo6vj6SmxyCWESCAAESgAhJTo6WjfffDOHnAOAHxEoAYScwYMHa/369dq6davVpQBAWCBQAgg5v/rVrxQdHc0oJQD4CYESQMiJiorSLbfcQqAEAD8hUAIISYMHD9bGjRv1ww8/WF0KAIQ8AiWAkPTLX/5StWvXZrc3APgBgRJASKpZs6Z+/etfa+HChVaXAgAhj0AJIGSlpqYqJydHOTk5VpcCACGNQAkgZPXr109169Zl2hsATEagBBCyIiMjNXDgQL377rvillkAMA+BEkBIS01N1ffff69NmzZZXQoAhCwCJYCQduONN6pevXqcSQkAJiJQAghpERERGjRoENPeAGAiAiWAkJeamqotW7Zo48aNVpcCACGJQAkg5PXp00f169fnTEoAMAmBEkDIq1Gjhm699VamvQHAJARKAGFh8ODB2r59u9avX291KQAQcgiUAMJCSkqKYmNj2e0NACYgUAIICw6HQ7fddpsWLlzItDcA+BiBEkDYSE1NVW5urtatW2d1KQAQUgiUAMJGr169FBcXx7Q3APgYgRJA2Dg+7c1ubwDwLQIlgLCSmpoqp9OpNWvWWF0KAIQMAiWAsJKcnKzGjRsz7Q0APkSgBBBW7Ha7br/9dr333ntyu91WlwMAIYFACSDspKam6qefftKqVausLgUAQgKBEkDY6d69u5o0acK0NwD4CIESQNix2Wy64447mPYGAB8hUAIIS6mpqdqzZ49WrlxpdSkAEPQIlADCUteuXXXZZZdp4cKFVpcCAEGPQAkgLB2f9n7//fdVWVlpdTkAENQIlADC1uDBg5WXl6fMzEyrSwGAoEagBBC2OnfurPj4eHZ7A4CXCJQAwpZhGEpNTdX7778vl8tldTkAELQIlADCWmpqqgoKCrRixQqrSwGAoEWgBBDWOnbsqJYtWzLtDQBeIFACCGvHp70/+OADpr0B4CIRKAGEvdTUVBUVFemLL76wuhQACEoESgBh7+qrr1ZCQgLT3gBwkQiUAMLe8WnvRYsW6ejRo1aXAwBBh0AJADo27b1v3z4tX77c6lIAIOgQKAFA0lVXXaW2bdtytzcAXAQCJQDo2LT34MGDtXjxYlVUVKi03KWc3Qe03rlPObsPqLScHeAAcDYOqwsAgEBx3a9u02tri3T9zP9oT8lReU54ZkiKj4lSSrs4De0SrzaN6lhVJgAEHMPj8XjO/2kAELp2FZcpbXG2MrcVym5Iled4V7TbDFW6PUpOaKCpg5LULCbKf4UCQIAiUAIIawuynJqwJEcut0eV7gt/O7TbDDlshiYNSNSQTvEmVggAgY9ACSBsvZK+VTOXbvG6nVF922pEShsfVAQAwYlNOQDC0oIsp0/CpCTNXLpFC7OcPmkLAIIRgRJA2NlVXKYJS3J82ub4JTnaVVzm0zYBIFgQKAGEnbTF2XJVY73khXC5PUpbnO3TNgEgWBAoAYSVrXklytxWWK0NOBei0u1R5rZCbcsv8Wm7ABAMCJQAwsr8NU7ZbYYpbdttht5ZzVpKAOGHQAkgrKRvzvf56ORxlW6P0rfkm9I2AAQyAiWAsHGo3CWnyRtnnEVlXNMIIOwQKAGEjZ1FpTL74F2PpNyiUpN7AYDAQqAEEDYqXO6Q6gcAAgWBEkDYiHD45y3PX/0AQKDgXQ9A2GgRGy1z9nf/zPhfPwAQTgiUAMJGdKRD8TFRpvYRHxul6EiHqX0AQKAhUAIIKynt4kw9hzKlbZwpbQNAICNQAggrQ7vEm3oO5bCu8aa0DQCBjEAJIKy0aVRHyQkNfD5KabcZuvwSj3b/sF4FBQXyeMw+oAgAAofh4V0PQJjZVVymG2avULkPj/eJdNj0458e0NF9eyRJNWvWVLNmzZSQkKBWrVrpiSeeUEJCgs/6A4BAwgglgLDTLCZKkwYk+rTNyQMS9fCw26t+fuTIEW3dulWffPKJ/vSnP2n16tU+7Q8AAgkjlADC1ivpWzVz6Rav2xndt51+n5KgsrIytW7dWnv37q16Zrfb1bFjR61cuVJ2u93rvgAgEDFCCSBsjUhpo2dubCmPq0LyVHP62+OWx1Whp29sod+nHJvKjoqK0syZM0/6tMrKSrVv317l5eW+KhsAAg6BEkDYysjI0IibrtHuv/xO115WW5LOu1nn+POrGtXU7r/8TiN+dY2WLFlS9fzOO+/UtddeK5vt2NvrLbfcogULFqhDhw766quvTHolAGAtAiWAsFNcXKz7779fvXr1Unl5uTyHCvXBiBR9/kRP3d2luZrHRp12o44hqXlslO7u0lzLRvbUPx/vI9eBPFVUVOjXv/61br75Zv3444+y2Wx65ZVX5Ha71bVrVy1evFjffvutYmNj1aNHDz355JM6fPiwFS8bAEzDGkoAYcPj8Wj+/Pl67LHHdPDgQVVWVkqSmjdvrtzc3JM+t7TcpdyiUlW43Ipw2NQiNvq0G3AaNmyowsJCScfWStrtdo0fP16jRo3S559/ro4dO6px48aSjk19z549W88884yaN2+uefPmqVu3bua/aADwA0YoAYSNWbNm6e6779a+ffuqwqQkXXrppad9bnSkQ4lNLtHV8fWV2OSSM16neOKvq6ysVEVFhZ555hnNnTtXN998c1WYlI4FzlGjRunbb79VTEyMevToodGjRzNaCSAkECgBhI2bbrpJV1xxxUkfMwzjjIHyQjRr1uy0j6Wmpuq+++4766+5/PLL9eWXX+qPf/yjXn75ZV199dUcKQQg6BEoAYSNK664Qhs2bKgKkHa7XYZhKC7u4u7fbtKkiQzDkGEcW3EZFxenhQsXqkGDBuf8dXa7XaNHj9b69etVr149de/eXWPGjNGRI0cuqg4AsBqBEkBYWbBggfbs2aO+ffvqtttuk9vt1mWXXXZRbbVp00Y2m02jRo3Sfffdp/z8fD3//PMX/Ovbt2+vL7/8UtOmTdPcuXMZrQQQtNiUAyBsVFRUKCYmRpWVlSouLlatWrWUnZ2tFi1aqE6dOtVur7y8XPv371ejRo3kdrvVoEEDlZSUaM+ePecdpTzVd999p/vuu0/r1q3TqFGjNGnSJNWsWbPaNQGAFRihBBA27rvvPpWWlmrWrFmqVauWJCkpKemiwqQkRUZGqlGjRpIkm82mBQsWyOVy6ZZbbql2W1dccYVWrlyp559/Xi+99JKuueYarV279qLqAgB/Y4QSQFj47rvvdOWVVyohIUFbtnh/3eLZ9OnTR1988YXef/993XbbbRfVRk5OjoYPH65vvvlGo0eP1sSJExmtBBDQCJQAwkKbNm20fft25eTkqH379qb1c+jQIcXGxioiIkL79u2Tw3H6cUMXwuVyacaMGZo4caISEhI0b948derUycfVAoBvMOUNIOT96U9/0rZt23TXXXeZGiYlqXbt2po1a5YOHTqke+6556LbcTgcGjdunL7++mvVqlVLXbt21bhx47gTHEBAYoQSQEgrKytTTEyMHA6H9u/ff9EjhtV1+eWXa/PmzVq/fr06dOjgVVsul0svvPCCJk6cqDZt2jBaCSDgMEIJIKTdeeedKi8v15///Ge/hUlJ+te//iXDMDRgwACv23I4HEpLS9M333yjWrVqqVu3bnr66acZrQQQMAiUAEJWVlaWlixZoquuukpDhw71a9+tW7fW7373O+3atUuTJk3ySZtXXnmlVq1apUmTJmnGjBnq2LGj1q1b55O2AcAbTHkDCFnNmjXT7t279eOPPyo+Pt7v/bvdbsXFxWn//v3avXv3Rd/IcybZ2dkaPny4NmzYoLFjx2r8+PGKjIz0WfsAUB2MUAIISc8//7x++uknPfzww5aESenY2ZTvvvuuKisr1b9/f5+2nZSUpNWrV2vixIlVo5Vff/21T/sAgAvFCCWAkLN//37FxcUpOjpaRUVFstms/d75l7/8pT777DMtWLBAgwcP9nn7Gzdu1PDhw7Vx40aNGzdOzz77rCIiInzeDwCcDYESQMjp3bu30tPT9dFHH+nmm2+2upyTdpoXFxebEvaOHj2qadOmacqUKWrfvr3mzZuna665xuf9AMCZMOUNIKR88cUXSk9PV7du3QIiTEpSVFSU5s6dq9LSUtM2B9WoUUPjx4/XunXrZLfb1blzZ40fP14VFRWm9AcAJ2KEEkDIcLvdaty4sYqLi32+CcYXEhMT9d1332nt2rWmniN59OhRTZ06Vc8995yuuOIKzZs3T1dffbVp/QEAI5QAQsa4ceNUUFCgMWPGBFyYlKR///vfstlsGjhwoKn91KhRQxMmTFBWVpYMw1Dnzp01YcIERisBmIYRSgAhYe/evbrssssUGxurPXv2WL4R52xGjhypl156SWlpaXr++edN76+iokJTp07V888/r8TERM2bN8/rm3sA4FQESgAhoUuXLlq7dq1WrFihnj17Wl3OWZ04Le90OtWkSRO/9Lt+/XoNHz5c3333nZ555hmNGzeOneAAfCYwv4UHgGr48MMPtXbtWvXp0yegw6R07GzKRYsWqbKy0q+bhq6++mplZWVp3LhxmjJlijp37qwNGzb4rX8AoY1ACSCoud1u3XvvvapRo4YWLVpkdTkXpEePHurfv7/Wr1+vd955x2/9RkREaPLkyVq7dq3cbrc6duyoSZMm6ejRo36rAUBoIlACCGqPPPKIDhw4oClTpqhu3bpWl3PB3n33XdWsWVO//e1vdeTIEb/2fc0112jdunVVo5VdunTRxo0b/VoDgNBCoAQQtHJzc/X666+rWbNmGjt2rNXlVEtUVJT+7//+T4cPH9aQIUP83v/x0co1a9bo6NGj6tixo6ZMmcJoJYCLQqAEEDQ8Ho9mz56tb7/9VpJ0yy23yOPx6J///KeldV2s++67T0lJSfrwww+1atUqS2q49tprtW7dOo0ZM0aTJk1S165dlZ2dbUktAIIXu7wBBA2n06nmzZvLMAzdeOONWrp0qQYOHKjFixdbXdpF++mnn9S8eXM1bNhQu3fvtvS4o3Xr1mn48OHasmWLxo8fr7Fjx6pGjRqW1QMgeDBCCSBo5OfnSzo2Url06VJJ0sCBAxXM3xdfdtllevLJJ5WXl6ennnrK0lo6duyor7/+WqNHj9bEiRPVtWtXbdq0ydKaAAQHRigBBI1PPvlEN91002kf79+/vz766CMZhmFBVd5zu91q2rSp8vPzlZubq2bNmlldktatW6d7771XW7du1YQJEzR27Fg5HA6rywIQoBihBBA0CgoKTvr58QAZqLfiXKjjZ1O63W7179/f6nIkHRut/OabbzRq1CiNHz+e0UoA5xTc78IAwsrxKW/pWAirX7++5s+frw8//DBoRyeP69atmwYOHKjs7Gy9+eabVpcjSYqMjNTUqVO1evVqHT58WNdee62mTp0ql8tldWkAAgxT3gACRmm5S7lFpapwuRXhsKlFbLSiI3+eZr3hhhu0fPlySdIDDzygF154QTExMVaV63Pl5eWKiYmR2+1WUVGRoqKirC6pypEjRzRx4kTNmDFD11xzjebNm6fExESrywIQIAiUACy1Na9E89c4lb45X87iMp34hmRIio+JUkq7OKVe20TXJbbUoUOH9PnnnyslJcWqkk01f/58DRs2TDfddJP+9a9/WV3OadasWaPhw4drx44dmjhxokaPHs3aSgAESgDW2FVcprTF2crcVii7zVCl++xvRcefH/lxveb9vp9+mdzJj5X63zXXXKP169crIyNDycnJVpdzmiNHjmjChAmaOXOmrr32Ws2bN09XXHGF1WUBsBCBEoDfLchyasKSHLncnnMGyVPZDclht2nSgEQN6RRvYoXW2rt3ry677DLVr19feXl5Abvp6MTRysmTJ+vJJ59ktBIIU4H5LgUgZL2SvlVPLcpWuctdrTApSZUeqdzl1lOLsvVK+laTKrRe48aNNW7cOBUWFuoPf/iD1eWcVZcuXbR+/Xo9/vjjSktLU/fu3fX9999bXRYACzBCCcBvFmQ59dQi313rN/3WJA0O4ZHKpk2bau/evdqxY4eaN29udTnntHr1ag0fPly5ublVo5V2u93qsgD4CSOUAPxiV3GZJizJ8Wmb45fkaFdxmU/bDCQffvih3G73GQ9zDzRdu3bV+vXr9eijj+qpp55S9+7d9cMPP1hdFgA/IVAC8Iu0xdlyVXOK+3xcbo/SFvtuxDPQdOzYUbfffru+++47/fnPf7a6nPOqVauWZsyYoZUrV2rfvn3q0KGDZsyYocrKSqtLA2AyprwBmG5rXolufCnDtPaXjeyphLg6prVvpYqKCsXExMjlcqmoqEjR0dFWl3RBDh8+rGeffVYvvviiunTporfeekuXX3651WUBMAkjlABMN3+NU3abOTfZ2G2G3lntNKXtQBAREaE333xT5eXluvXWW60u54LVqlVLM2fOVGZmpoqKitShQwfNnDmT0UogRBEoAZgufXN+tXd0X6hKt0fpW/LP/4lBLDU1VZ06ddLSpUv1xRdfWF1OtXTv3l3ffvutHnnkEY0ZM0bJycnavHmz1WUB8DECJQBTHSp3yWnyxhlnUZlKy0P7fumPP/5Ydrtdd9xxh9xut9XlVEtUVJRefPFFZWRkqKCgQB06dNCsWbMYrQRCCIESgKl2FpXK7IXaHkm5RaUm92KtuLg4jR8/XsXFxRoxYoTV5VyUHj16aMOGDXr44Yc1evRo9ezZU1u2bLG6LAA+QKAEYKoKl39G0/zVj5XGjx+vZs2a6bXXXtP27dutLueiREVFafbs2VqxYoXy8/P1i1/8QrNnz2a0EghyBEoApopw+Odtxl/9WG3JkiXyeDxBcTbluSQnJ2vDhg166KGH9OSTT6pXr16MVgJBLDzegQFYpkVstMzZ3/0z43/9hIMOHTrozjvv1JYtW/Tyyy9bXY5XoqKi9NJLL2nFihXau3cvo5VAEOMcSgCm6zUjXTtN3JjTPDZKK0almNZ+oHG5XKpfv74qKipUUFCgunXrWl2S10pLS5WWlqa5c+eqR48eeuutt5SQkGB1WQAuECOUAEyX0i7O1HMoU9rGmdJ2oHI4HPrb3/6miooKDRw40OpyfCI6Olpz5szRihUrtHv3bl111VWaM2dO0O1oB8IVgRKA6YZ2iTf1HMphXeNNaTuQDRo0SN26dVN6ero+++wzq8vxmZ49e2rjxo168MEH9cQTT+j666/Xtm3brC4LwHkQKAGYrk2jOkpOaODzUUq7zVByQoOQvXbxfD7++GM5HA4NGTIkpEbyoqOjNXfuXKWnp+unn37SVVddpblz54bUawRCDYESgF9MHZQkh48DpcNmaOqgJJ+2GUxiYmI0efJk7d+/Xw899JDV5fjc9ddfr40bN+r+++/X448/rpSUlKA9LgkIdWzKAeA3C7KcempRts/am35rkgZ3Cr/p7lO1bNlSO3fu1Pfff6927dpZXY4p0tPTdf/99ys/P19//OMf9fvf/142G2MiQKDgbyMAvxnSKV6j+rb1SVuj+7YjTP7Pxx9/LEnq37+/xZWYJyUlRdnZ2Ro+fLgee+wx9e7dWzt27LC6LAD/Q6AE4FcjUtroj7cmKdJhq/aaSrvNUKTDpum3Jun3KRwpc1xiYqLuvvtubd++XbNmzbK6HNPUrl1bf/rTn7R8+XLt3LlTSUlJeuWVV1hbCQQAprwBWGJXcZnSFmcrc1uh7DbjnLvAjz9PTmigqYOS1Cwmyo+VBgeXy6XY2FgdPnxY+fn5qlevntUlmaqkpERjx47Vq6++quuvv15vvPGGWrVqZXVZQNgiUAKw1Na8Es1f41T6lnw5i8p04huSISk+NkopbeM0rGt82O7mvlAff/yxbrnlFiUnJysjI8Pqcvxi+fLleuCBB1RYWKjp06frd7/7HWsrAQsQKAEEjNJyl3KLSlXhcivCYVOL2GhFRzqsLiuo9OzZU5mZmfroo4908803W12OX5SUlGjMmDF67bXXlJKSojfeeEMtW7a0uiwgrBAoASCE7N+/X3FxcapVq5aKiorkcIRPIF++fLnuv/9+FRUVacaMGXrooYcYrQT8hL9pABBC6tWrp2nTpungwYN68MEHrS7Hr/r06aNNmzZp2LBheuSRR3TjjTcqNzfX6rIQokrLXcrZfUDrnfuUs/uASstdVpdkKUYoASAEJSQkaMeOHcrOzlatWrX03HPPacSIEbrmmmusLs0vPv/8cz3wwAPat29f1WilYVzcwfosxcBxVWu+N+fLWXyGNd8xUUppF6ehXeLVplF4rfkmUAJACNq8ebPat2+vevXqqaysTOXl5Ro/frwmTZpkdWl+c/DgQY0aNUp/+ctf1KdPH73xxhtq3rz5Bf1aggNOxKkU50egBIAQtHr1av3yl7/UgQMHJEkOh0P33XefXn/9dYsr87+lS5fqwQcf1L59+zRz5kz99re/PetoJcEBp1qQ5dSEJTlyuT3n/Ho4ld1myGEzNGlAooaEwSUMrKEEgBDz5ptv6rrrrtPBgwerPuZyubR7924Lq7JO3759lZ2drSFDhujhhx9W3759tXPnztM+b0GWUzfMXqGvdhRJ0nnDw/HnX+0o0g2zV2hBltP3xcNSr6Rv1VOLslXuclcrTErHvj7KXW49tShbr6RvNanCwEGgBIAQ07JlS11yySWn7XDetWuXRRVZ75JLLtFf/vIXffrpp/rhhx+UlJSk119/Xccn6QgOONWCLKdmLt3ik7ZmLt2ihSH+DQeBEgBCTEpKirZv364HH3zwpKlddjxL/fr106ZNm5SamqqHHnpI/fr101++yCE44CS7iss0YUmOT9scvyRHu4rLfNpmIGENJQCEsLVr1+r+++9XTs6xfxyPHj162tmU4bqL+dNPP9XjT09RZb9xcnkubgf4mUQ6bFo2shdrKoPY3W+s0Vc7iqo9Wn0udpuh61rF6u0HuviszUBCoASAEFdZWamhQ4dq4cKF+tOf/qRHHnmEXcz/Q3DAqbbmlejGl8y7unTZyJ4heY0sgRIAwsQjjzyinNy9ir9tLLuYRXDAmU1ckqO31+z06TcZx9lthu7u0lwTByT6vG2rsYYSAMJE8vCntPfa37CL+X/mr3HKbvPdVPeJ7DZD76w+/ferpKREc+bMUVZWlin9wnvpm/NNCZPSsb9T6VvyTWnbagRKAAgDr6Rv1bjF7GI+kT+DQ2lpqV544QU1a9ZMTzzxRFieBxoMDpW75DR544yzqCwkr2kM/VXXABDmfH38ScPakRoc5Ac1+ys4FOw/qLff/Kuee+457d+/Xx6PR3a7XW6329S+z8bj8cjtdlf998T/N+u/wdRGXkUNeWTu17ZHUm5RqRKbXGJqP/5GoASAEGbW8SfXtW4Q1GsqdxaVyuwNBB5JzRM76vDuk0d1KysrtWjRIq1atcr0MHfif9ky8TObzSbDME77b8SlbVUv9XnT+69wWfMNhZkIlAAQwtIWZ8vl42ldl9ujtMXZQb2L2V//oMc0iNN/d2+VYRhVgc4wDF166aXq16/fWYPNif+9kM8JtF8bqG0c/3E2ObsPqP/LX5r+dRHhCL0VhwRKAAhRW/NKlLmt0OftVro9ytxWqG35JUG7i9lf/6B/9sm/VLRtgyZOnKj09PSq6e6OHTtq9uzZfqkBF65FbLQMydTRa+N//YSa0IvIAABJ1uxiDhbHg4OZjgeHnj176osvvtDKlSvVu3dveTweRUZGmtw7LkZ0pEPxJi/liI+NCsmLAwiUABCiOP7k7KwIDtddd52WLl2qjRs3asqUKab2jYuX0i7O1G/EUtrGmdK21UIvIgMA/Hr8SbCOtqS0izPtAGuPu1K7132ue+55S5JUXFysgoICFRYWyuFw6MsvzV+nh4sztEu85q3KNaXtSrdHw7oG9wkJZxOc7wIAgHPy1y7mYD7+xMzgYNjsyl32trYV/XTas+joaNWqVcuUfuG9No3qKDmhgWlXcgbruuPzYcobAEKQv3YxB/PxJ8eDg6+nN+02Q8kJDfToPXec9swwDN11112qXbu2T/uEb00dlCSHj78uHDZDUwcl+bTNQEKgBIAQ5K9dzMF+/ImZwWHWrFm67777TjqmxuPx6C9/+Ys6duyo5cuX+7Rf+E6zmChN8vF925MHJAb12a3nE9zvBACAM/LnLuZgZmZwMAxDf/7zn9WrVy/Z7XbZbDZ16NBBnTp10jfffKMbbrhBDRs21Pjx41VRUeHTGuC9IZ3iNapvW5+0Nbpvu6C/Xep8CJQAEII4/uTCmRkcatSoocWLF6t169Zyu92aMGGC1q5dq8LCQj3wwAMqKyvTlClTFB0drZtuukk//PCDT+qAb4xIaaM/3pqkSIet2ksj7DZDkQ6bpt+apN+nJJhUYeAgUAJAiOL4kwtnZnCoV6+ePv/8c73wwgu6+eabJUkxMTH661//qtLSUr311ltq3ry5PvnkE7Vv316tW7fWm2++yVWJAWJIp3gtG9lL17WKlaTzfn0cf35dq1gtG9kr5EcmjzM8fMUCQEjamleiG1/KMK39ZSN7htyO1V3FZUpbnK3MbYWy24xz7vL1uCtl2OxKTmigqYOSvF4ft3nzZv3hD3/Q0qVL5XK5FBUVpcGDB2vmzJmKiYnxqm34xta8Es1f41T6lnw5i8pOOknB0LFR+5S2cRrWNT7k/m6cD4ESAELY3W+sMe34k2C+y/t8zhccmtWvpU2fL5Rt+0rlblzt013bFRUVev755/Xqq6+qoKBAhmHo2muv1fTp09W7d2+f9QPvlJa7lFtUqgqXWxEOm1rERofEEpCLRaAEgBC2q7hMN8xeoXIfHu8T6bBp2cheIb1j9URnCw42m00ej0dXXXWVPv/8c8XF+X4JwBdffKGxY8fq66+/lsfjUcOGDfXII48oLS1NERERPu8PuFgESgAIcQuynHpqUbbP2pt+a1LYrAs7m7KyMkVHH9vhbhiG4uPjtWzZMiUkmLP5oqioSKNHj9bChQtVVlYmh8OhG2+8US+99JLatvXNhiLAG2zKAYAQx/EnvldQUFD1/x6PR//973/VuXNnZWVlmdJfbGys3nzzTR06dEhvvPGG4uPj9cknn6hdu3ZKSEjQvHnzTOkXuFCMUAJAmFiQ5dSEJTlyuT3VWlNptxly2AxNHpBImPyfdevWqVOnTqd9PDo6Wnv37vXLTTg//PCDRo4cqc8//1yVlZWKiorSnXfeqRdeeIFNPPA7RigBIExw/Inv5Ofnn/ax+Pj4qjMl/eHyyy/XJ598orKyMj377LOKiorSG2+8oQYNGqhz585asWKFX+oAJEYoASAscfyJd+bPn69hw4bJ4XAoOjpaBw8e1MGDBy2/o3v58uUaO3asvvnmm5M28Tz99NOqUaOGpbUhtBEoASDMcfxJ9RUXF+vDDz9U//79lZmZqdtvv12jRo3SjBkzrC5NklRYWFi1iefw4cNyOBzq16+fZs+erTZt2lhdHkIQgRIAAC/VqVNHkZGRKiwstLqUk7jdbr311lt6/vnn9eOPP0qSWrdurWeffVb33nuvxdUhlLCGEgAAL6WmpqqoqEgZGebdTHQxbDabHnjgAe3YsUM5OTnq16+fcnNzNXz4cNWuXVsPPvig9u3bZ3WZCAGMUAIA4KWCggLFxcXpuuuu08qVK60u55wqKio0efJkvfbaayoqKpJhGOrUqZNmzJihnj17Wl0eghSBEgAAH0hKStJ3332nkpISRUUFxy1Cy5Yt09ixY7V+/fqqTTwjRoxQWlqaHA7W0eLCMeUNAIAPPPvss3K73Zo0aZLVpVywG264QV9//bXy8/N177336tChQ5owYYJq1aqlm2++Wdu3b7e6RAQJRigBAPCR2rVrq1atWifdpBNM3G633njjDU2dOlW5ubmSpDZt2ujZZ5/V3XffbW1xCGiMUAIA4CN33HGHCgsL9eWXX1pdykWx2Wz6zW9+ox9//FGbNm1S3759tWPHDt1zzz2qXbu2fvvb32r//v1Wl4kAxAglAAA+kpeXp8aNG6tHjx7KzMy0uhyfqKio0KRJk/TnP/+5ahNP586dNWPGDCUnJ1tdHgIEgRIAAB9KTEzUDz/8oNLSUtWsWdPqcnzqs88+07hx47R+/XpJUqNGjfT73/9e48aNYxNPmGPKGwAAHxo/frzcbrcmT55sdSk+169fP33zzTfKy8vTPffco4MHD2r8+PGKiorSgAED2MQTxhihBADAx2rXrq2oqCjl5+dbXYqp3G63/vrXv2ratGknbeKZMGGChg4dam1x8CtGKAEA8LHbbrtNBQUFWrVqldWlmMpms+m3v/1t1SaeG2+8UTt27NCwYcNUp04dPfzww2ziCROMUAIA4GN79+7VpZdequTk5IC7jtFsR44c0aRJk/T666+ruLhYhmGoS5cumjFjhnr06GF1eTAJgRIAABNcccUV2rx5c0huzrlQn3zyidLS0vTtt99KOraJ59FHH9XYsWPZxBNimPIGAMAETz/9tNxut6ZMmWJ1KZb51a9+pfXr1ysvL0/Dhg3TgQMH9MwzzygqKkq//vWv9eOPP/qljtJyl3J2H9B65z7l7D6g0nKXX/oNJ4xQAgBgkujoaEVHR4f85pwL5Xa79ec//1nTp0/Xzp07JUlt27bVxIkTdeedd/q0r615JZq/xqn0zflyFpfpxLBjSIqPiVJKuzgN7RKvNo3q+LTvcESgBADAJMOGDdP8+fP11VdfqVu3blaXE1A2bdqkkSNHKj09XZWVlapdu7aGDRum6dOnq27duqd9/vfff69WrVopMjLynO3uKi5T2uJsZW4rlN1mqNJ99phz/HlyQgNNHZSkZjFRXr+ucEWgBADAJLt371bTpk3Vq1cv/ec//7G6nIB05MgRTZw4UX/5y1+qNvF07dpVM2bMUPfu3SVJ27dvV9u2bXXTTTfpn//8p+x2+xnbWpDl1IQlOXK5PecMkqey2ww5bIYmDUjUkE7xPnld4YZACQCAidq3b6+tW7fq0KFDYbs550J98sknGjdunDZs2CBJaty4sR577DEVFBRozpw58ng8evTRRzVnzpzTfu0r6Vs1c+kWr2sY1betRqS08bqdcEOgBADARH/7299077336tlnnw3J23PMkJeXpyeffFIffPCBjhw5ctrzuXPn6tFHH636+YIsp55alO2z/qffmqTBjFRWC4ESAAATud1u1a5dW3Xr1tXevXutLieouN1u3XPPPZo/f/5pz5YsWaJbbrlFu4rLdMPsFSp3uX3Wb6TDpmUje7Gmsho4NggAABPZbDYNGjRIeXl5ysrKsrqcoGIYhjZt2iTDME57NmDAAKWlpempDzbIVY31khfC5fYobbHvRjzDASOUAACY7KefflKzZs2UkpKiL774wupygsaBAwdUr169qp8bhqHo6GgZhqHDhw/LuORSNfnNq6b1v2xkTyXEcaTQhWCEEgAAk1122WVq166dMjIyVFFRYXU5QeOSSy5Rbm6utm3bpuLiYrlcLpWUlOjgwYM6evSoHp71d9lOH7z0CbvN0DurneY0HoIIlAAA+MG4ceNUWVmpadOmWV1KUGnevLlat26t+vXry2Y7ObZsyD8qH892V6l0e5S+hQPpLxRT3gAA+MHxzTmXXHKJ9uzZY3U5Qe9QuUtJEz+TmSHGkLRpYj9FR3Lv+PkwQgkAgB/YbDb9+te/1t69e7Vu3Tqrywl6O4tKTQ2TkuSRlFtUanIvoYFACQCAn0yfPl2SNHbsWIsrCX4VPjwmKBD6CXYESgAA/CQ+Pl5t2rTRihUr2JzjpQiHfyKMv/oJdvwuAQDgR2PHjlVlZWXVaCUuTovYaJm0wbuK8b9+cH4ESgAA/Oi+++5TzZo19eqrx85PdLvdOnTokMVVBZ/oSIfiTb7JJj42ig05F4hACQCAH9lsNt1yyy3as2ePRowYoRYtWqhJkyZyu1mrV10p7eJkN+kgSrvNUErbOFPaDkUESgAA/MTtduvTTz/V/v37JUl/+tOftGvXLh09evS0MxZxfkO7xKvSpIMoK90eDesab0rboYhxXAAA/OSdd97Rvffee1p4jImJsaii4NamUR0lJzTQVzuKfBos7TZD17WK5drFauDbIQAA/KR///7q1KnTaR9v1KiRBdWEhqmDkuTw8bS3w2Zo6qAkn7YZ6giUAAD4SWxsrP7zn//oV7/61Ukfv/TSSy2qKPg1i4nSpAGJPm1z8oBENTN5w0+oIVACAOBHUVFR+uc//6kHH3yw6mMOByvQvDGkU7xG9W3rk7ZG922nwZ1YO1ldfAUDAOBnDodDr7/+uurWrasXX3xRP/zwQ9Wz0nKXcotKVeFyK8JhU4vYaI6uuQAjUtqoQe1ITViSI5fbU601lXabIYfN0OQBiYTJi2R4PB6zr8IEAABn0a1bN/1UUqn7p76p/2wukLO47KQ7qg1J8TFRSmkXp6Fd4tWmERtFzmVXcZnSFmcrc1uh7DbjnMHy+PPkhAaaOiiJaW4vECgBALDIruIyPfr2Kn279wjhx8e25pVo/hqn0rfky1l0hpAeG6WUtnEa1jWe3dw+QKAEAMACC7KcXk3PThqQqCFMz14QlhGYj0AJAICfvZK+VTOXbvG6nVF922pEShsfVAR4h13eAAD40YIsp0/CpCTNXLpFC7OcPmkL8AaBEgAAP9lVXKYJS3J82ub4JTnaVVzm0zaB6iJQAgDgJ2mLs+Xy8d3TLrdHaYuzfdomUF0ESgAA/GBrXokytxX69M5pSap0e5S5rVDb8kt82i5QHQRKAAD8YP4ap+w+vnP6OLvN0DurWUsJ6xAoAQDwg/TN+T4fnTyu0u1R+pZ8U9oGLgSBEgAAkx0qd8lp8sYZZ1GZSstdpvYBnA2BEgAAk+0sKpXZhz57JOUWlZrcC3BmBEoAAExW4XKHVD/AqQiUAACYLMLhn39u/dUPcCq+8gAAMFmL2GiZs7/7Z8b/+gGsQKAEAMBk0ZEOxcdEmdpHfGyUoiMdpvYBnA2BEgAAP0hpF2fqOZQpbeNMaRu4EARKAAD8YGiXeFPPoRzWNd6UtoELQaAEAMAP2jSqo+SEBj4fpbTbDCUnNFBCXB2ftgtUB4ESAAA/mTooSQ4fB0qHzdDUQUk+bROoLgIlAAB+0iwmSpMGJPq0zckDEtXM5A0/wPkQKAEA8KMhneI1qm9bn7Q1um87De7E2klYz/B4PGbfBgUAAE6xIMupCUty5HJ7qrVZx24z5LAZmjwgkTCJgEGgBADAIruKy5S2OFuZ2wpltxnnDJbHnycnNNDUQUlMcyOgECgBALDY1rwSzV/jVPqWfDmLynTiP8yGjh1antI2TsO6xrObGwGJQAkAQAApLXcpt6hUFS63Ihw2tYiN5gYcBDwCJQAAALzCLm8AAAB4hUAJAAAArxAoAQAA4BUCJQAAALxCoAQAAIBXCJQAAADwCoESAAAAXiFQAgAAwCsESgAAAHiFQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFcIlAAAAPAKgRIAAABeIVACAADAKwRKAAAAeIVACQAAAK8QKAEAAOAVAiUAAAC8QqAEAACAVwiUAAAA8AqBEgAAAF4hUAIAAMArBEoAAAB4hUAJAAAArxAoAQAA4BUCJQAAALxCoAQAAIBXCJQAAADwCoESAAAAXiFQAgAAwCsESgAAAHiFQAkAAACvECgBAADgFQIlAAAAvEKgBAAAgFf+P0fKbSrPsunXAAAAAElFTkSuQmCC\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "Polymer_C3_3_top_graph_representation = nx.MultiDiGraph()\n",
        "Polymer_C3_3_top_graph_representation.add_nodes_from(\n",
        "    [\n",
        "        \"E1\",\n",
        "        \"D1\",\n",
        "        \"R1\",\n",
        "        \"R1'\",\n",
        "        \"D2\",\n",
        "        \"R2\",\n",
        "        \"R2'\",\n",
        "        \"D3\",\n",
        "        \"R3\",\n",
        "        \"R3'\",\n",
        "        \"D4\",\n",
        "        \"R4\",\n",
        "        \"R4'\",\n",
        "        \"E2\",\n",
        "    ]\n",
        ")\n",
        "Polymer_C3_3_top_graph_representation.add_edges_from(\n",
        "    [\n",
        "        (\"E1\", \"D1\"),\n",
        "        (\"D1\", \"R1\"),\n",
        "        (\"R1\", \"D1\"),\n",
        "        (\"D1\", \"R1'\"),\n",
        "        (\"R1'\", \"D1\"),\n",
        "        (\"D1\", \"D2\"),\n",
        "        (\"D2\", \"R2\"),\n",
        "        (\"R2\", \"D2\"),\n",
        "        (\"D2\", \"R2'\"),\n",
        "        (\"R2'\", \"D2\"),\n",
        "        (\"D2\", \"D3\"),\n",
        "        (\"D3\", \"R3\"),\n",
        "        (\"R3\", \"D3\"),\n",
        "        (\"D3\", \"R3'\"),\n",
        "        (\"R3'\", \"D3\"),\n",
        "        (\"D3\", \"D4\"),\n",
        "        (\"D4\", \"R4\"),\n",
        "        (\"R4\", \"D4\"),\n",
        "        (\"D4\", \"R4'\"),\n",
        "        (\"R4'\", \"D4\"),\n",
        "        (\"D4\", \"E2\"),\n",
        "    ]\n",
        ")\n",
        "nx.draw(Polymer_C3_3_top_graph_representation)\n",
        "print(\n",
        "    \"Polymer_C3_3_top_graph_representation number of nodes: \",\n",
        "    Polymer_C3_3_top_graph_representation.number_of_nodes(),\n",
        ")\n",
        "print(\n",
        "    \"Polymer_C3_3_top_graph_representation number of edges: \",\n",
        "    Polymer_C3_3_top_graph_representation.number_of_edges(),\n",
        ")\n",
        "\n",
        "Polymer_C3_3 = Polymer(\n",
        "    repeat_unit_smiles_list=[\n",
        "        \"*CC(*)(C)C\",\n",
        "        \"*CC(*)c1ccccc1\",\n",
        "        \"*CC(*)(C)C(=O)OC\",\n",
        "        \"*CC(*)c1ccccc1\",\n",
        "    ],\n",
        "    repeat_unit_smiles_weight_list=[1, 1, 1, 1],\n",
        "    end_group_smiles_list=[\"*C(C)(C)C#N\", \"*C(C)(C)C#N\"],\n",
        "    end_group_smiles_weight_list=[1, 1],\n",
        "    graph_representation=Polymer_C3_3_top_graph_representation,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "jbS9tSrxzq8Q"
      },
      "source": [
        "# Calculate Similarity Scores\n",
        "## Calculate the Pairwise Similarity Score between C3-1 and C3-2"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "8p8pHgcmPcg7",
        "outputId": "e43b7e53-73df-47f1-a241-3708199467d5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Details of the Similarity Score:\n",
            "\n",
            "Repeat Unit Similarity Score =  0.5260215026967742 , Normalized Weight for Repeat Unit =  0.475\n",
            "Topology Similarity Score =  0.43080261519743523 , Normalized Weight for Topology =  0.475\n",
            "End Group Similarity  =  1.0 , Normalized Weight for End Group =  0.05\n",
            "Overall Pairwise Similarity Score with geometric mean function =  0.49403630923059505\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.49403630923059505"
            ]
          },
          "metadata": {},
          "execution_count": 10
        }
      ],
      "source": [
        "Overall_Similarity_Score_Calculation(\n",
        "    query=Polymer_C3_1,\n",
        "    target=Polymer_C3_2,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"geometric\",\n",
        "    details_print=True,\n",
        "    return_with_components=False,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m6Y5cyomz8pi"
      },
      "source": [
        "## Calculate the Pairwise Similarity Score between C3-1 and C3-3"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 11,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "3UQmmuAt5e2H",
        "outputId": "240668d5-cc3c-41d3-8eb9-8cf384f0c4e5"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Details of the Similarity Score:\n",
            "\n",
            "Repeat Unit Similarity Score =  0.8409090909090909 , Normalized Weight for Repeat Unit =  0.475\n",
            "Topology Similarity Score =  0.23350647909091338 , Normalized Weight for Topology =  0.475\n",
            "End Group Similarity  =  1.0 , Normalized Weight for End Group =  0.05\n",
            "Overall Pairwise Similarity Score with geometric mean function =  0.46152772153383426\n",
            "\n",
            "\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0.46152772153383426"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ],
      "source": [
        "Overall_Similarity_Score_Calculation(\n",
        "    query=Polymer_C3_1,\n",
        "    target=Polymer_C3_3,\n",
        "    embedding_function=\"MorganFingerprint\",\n",
        "    similarity_score_function=\"Tanimoto\",\n",
        "    alpha=1,\n",
        "    Repeat_Unit_Weight=0.475,\n",
        "    Topology_Weight=0.475,\n",
        "    End_Group_Weight=0.05,\n",
        "    Mean_Function=\"geometric\",\n",
        "    details_print=True,\n",
        "    return_with_components=False,\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "0CvXvv8Bx2yX"
      },
      "source": [
        "## Calculate the Whole Similarity Matrix"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {
        "id": "riJpZumorBcY"
      },
      "outputs": [],
      "source": [
        "Polymer_C3 = [Polymer_C3_1, Polymer_C3_2, Polymer_C3_3]"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 13,
      "metadata": {
        "id": "hZ6mW-U3rsN6"
      },
      "outputs": [],
      "source": [
        "Polymer_C3_RU_matrix = np.ones([3, 3])\n",
        "Polymer_C3_TOP_matrix = np.ones([3, 3])\n",
        "Polymer_C3_EG_matrix = np.ones([3, 3])\n",
        "Polymer_C3_OA_matrix = np.ones([3, 3])"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {
        "id": "mkUp5pS1r1_s"
      },
      "outputs": [],
      "source": [
        "for i in range(0, 2):\n",
        "    for j in range(i + 1, 3):\n",
        "        SOAij, SRUij, STOPij, SEGij = Overall_Similarity_Score_Calculation(\n",
        "            query=Polymer_C3[i],\n",
        "            target=Polymer_C3[j],\n",
        "            embedding_function=\"MorganFingerprint\",\n",
        "            similarity_score_function=\"Tanimoto\",\n",
        "            alpha=1,\n",
        "            Repeat_Unit_Weight=0.475,\n",
        "            Topology_Weight=0.475,\n",
        "            End_Group_Weight=0.05,\n",
        "            Mean_Function=\"geometric\",\n",
        "            details_print=False,\n",
        "            return_with_components=True,\n",
        "        )\n",
        "\n",
        "        Polymer_C3_OA_matrix[i, j] = SOAij\n",
        "        Polymer_C3_OA_matrix[j, i] = SOAij\n",
        "\n",
        "        Polymer_C3_RU_matrix[i, j] = SRUij\n",
        "        Polymer_C3_RU_matrix[j, i] = SRUij\n",
        "\n",
        "        Polymer_C3_TOP_matrix[i, j] = STOPij\n",
        "        Polymer_C3_TOP_matrix[j, i] = STOPij\n",
        "\n",
        "        Polymer_C3_EG_matrix[i, j] = SEGij\n",
        "        Polymer_C3_EG_matrix[j, i] = SEGij"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "tXpuWDkUx6jc"
      },
      "source": [
        "# Visualize the Similarity Matrices"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {
        "id": "oqnlmFD1tTn4"
      },
      "outputs": [],
      "source": [
        "# libraries for visualization\n",
        "import seaborn as sns\n",
        "import matplotlib.pyplot as plt"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wY3wGH6gyALM"
      },
      "source": [
        "##  Repeat Unit Similarity,   $S_{\\rm RU}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 560
        },
        "id": "GZcQ4V1kubb_",
        "outputId": "eb276dcc-908a-4e74-b330-5d90f250eb0f"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots(figsize=(6, 6), sharey=True)\n",
        "\n",
        "x_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "y_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "\n",
        "sns.heatmap(\n",
        "    Polymer_C3_RU_matrix,\n",
        "    linewidth=0.3,\n",
        "    annot=True,\n",
        "    fmt=\".2f\",\n",
        "    cmap=\"Blues\",\n",
        "    cbar_kws={\"label\": \"Similarity Score\"},\n",
        ")\n",
        "ax.set_title(r\"$S_{\\rm RU}$\", fontsize=20)\n",
        "ax.set_xticklabels(x_labels, rotation=0, fontsize=15, horizontalalignment=\"center\")\n",
        "ax.set_yticklabels(y_labels, rotation=360, fontsize=15, horizontalalignment=\"right\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "j9w3qcrcyI70"
      },
      "source": [
        "## Topology Similarity,     $S_{\\rm TOP}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 560
        },
        "id": "ThI0SatduqXc",
        "outputId": "f6152dd3-bffa-46e4-89b2-80ce1c2f875d"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "iVBORw0KGgoAAAANSUhEUgAAAiMAAAIfCAYAAACiktxnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABd4ElEQVR4nO3deVxUVf8H8M8MwgAiCIKDIoKioriASyJqpolh+JRbPqamSGpZair6U8kFlwy1JIswl8Q1y9xFDTFcMnFX3HLfwGVGQARF9rm/P3ycmgDl4h0uyOfd675ezZlzz5wzo/jle5ZRCIIggIiIiEgmSrk7QERERBUbgxEiIiKSFYMRIiIikhWDESIiIpIVgxEiIiKSFYMRIiIikhWDESIiIpIVgxEiIiKSFYMRIiIikhWDESIiIpIVgxEiIiKSVSW5O0BERUtNTcXKlSuxe/dunD59Gg8ePEBeXh6sra3h6uoKLy8vdOjQAf/5z39gZ2cnd3eJiEpEwS/KIyp7BEFAREQEJk2ahIyMjBfWHzhwIFatWlUKPSMikh4zI0Rl0KhRoxAREQEAqFmzJj788EO0bdsWarUaOTk5uHXrFuLi4rBp0ybcvn0bLVu2lLnHREQlx8wIURmzYsUKBAYGAgB69eqFVatWoXLlyoXW1el02Lx5Mxo1agQPD4/S7CYRkWQYjBCVIYIgwMXFBYmJiXBycsKVK1dgYWEhd7eIiIyKu2mIypD4+HgkJiYCAPz9/RmIEFGFwGCEqAy5efOm/v9NTEzk6wgRUSliMEJUhvwzANmwYQOuXbsmY2+IiEoH14wQlSFJSUlwdnZGdnY2AMDU1BTdunVDjx494OvrCycnJ5l7SEQkPQYjRGXM0qVL8cknnyA/P7/Ac+7u7vjPf/6DwYMHo0mTJjL0johIegxGiMqgc+fO4euvv8bGjRvx+PHjQuv0798fixcvhpWVVSn3johIWlwzQlQGNWnSBCtWrEBKSgp+//13TJgwAc2bNzeos3btWvTr10//WKFQiLr+be/evejbty+cnZ2hUqlgZ2eH9u3b45tvvkFWVlaB+jdv3izQppmZGZydndG/f3+cOXNG+jeGiF5JzIwQlSPXrl3D559/jl9//VVfdu7cOTRu3BjTp08vUH/BggVIS0tDSEhIgeee1c/Ly8OIESOwZMkSVK5cGW+//Tbq1auHtLQ0xMTE4Nq1a2jQoAF27NiBevXq6e+/efMm6tSpAzc3N3zwwQcAgMePH+Pw4cM4ePAgVCoVYmNj0a5dO2nfBCJ69QhEVK7k5eUJDRo0EAAIAITVq1cXWdfFxUV40V/z8ePHCwCE1157Tbh9+3aB15o2bZoAQHBzcxPS0tL0z924cUMAIPj5+RVoc/LkyQIA4Y033hA3OCKqkDhNQ1TOmJiYwNvbW/+4sCmX4rp8+TLCwsJgZ2eHqKioArt1TExMMGPGDPTv3x/Xrl3D119/Xax2R40aBQA4duxYiftGRBUHgxGicujBgwf6/69Tp06J21m5ciV0Oh0++ugjqNXqIutNnToVABAZGSmq/ZcJlIio4mAwQlQGCCKWbt26dQuxsbEAAEdHR4MsiVhxcXEAgM6dOz+3XsOGDVGzZk3cuXNHf1z98yxcuBAA0Lp16xL3jYgqjkpyd4CInmYc9u/fj5CQELi5uRVZ7/r16+jevbt+d8vs2bNf6th4jUYDAHB2dn5hXWdnZ9y9exf37t0zqH/16lX9YtiMjAwcOXIEBw4cgLm5OWbPnl3ivhFRxcFghKgMOHr0KFavXo01a9agU6dO8PPzQ/PmzWFvb4/c3Fxcv34dMTEx+Pnnn/WByOjRo/Hhhx/K3POnO3xmzJgB4OmJsWq1Gv3798ekSZPQtGlTmXtHROUBgxGiMuD+/fsAnk7X7NmzB3v27CmybtWqVfH1119jyJAhL/26jo6OuHjxIhITE+Hu7v7cus+mZ2rUqGFQ7ufnh+jo6JfuCxFVXAxGiMqAzZs3Iz4+Hrt27cKhQ4dw8eJF3Lt3DxkZGbC0tISDgwOaN28OPz8/9O/fH5UrV5bkddu2bYt9+/YhNjYWvr6+Rda7ePEi7t69Cycnp2JN6RARicFghKiM8PLygpeXV6m+5qBBgzBnzhwsXboUQUFBcHBwKLTes7UfZWFaiIhePdxNQ1SBubu7Y/To0UhJScE777yDe/fuGTyv0+kwa9YsrFmzBm5ubhg/frxMPSWiVxkzI0QV3Lx585CWlobIyEjUr18f3bp1g5ubG9LT0xETE4MrV66gfv362LlzJ6ytreXuLhG9ghiMEFVwlSpVwrJly9CvXz8sWbIEf/75JzZv3ozKlSujUaNGGD58OD755BNYWFjI3VUiekXxi/KIiIjKsT/++ANfffUVTpw4gXv37mHz5s3o0aPHc+/Zt28fgoKCcP78eTg7O2PKlCkYPHhwqfS3MFwzQkREVI5lZGTA09MTERERxap/48YNdOvWDZ06dUJ8fDzGjBmDoUOHYteuXUbuadGYGSEiInpFKBSKF2ZGJk6ciB07duDcuXP6svfffx8PHz6U7cwgZkaIiIjKmOzsbKSnpxtc2dnZkrR96NChAucK+fn54dChQ5K0XxJcwEpERCSSRfORRm1/Ynd7/dcsPBMSEqL/HqiXodFoCnxLt1qtRnp6OjIzM2VZrM5gpBDG/kNGZUPmqe8BAAevpMrcEyoN7erbAgCy8mTuCJUK83L+r1twcDCCgoIMylQqlUy9Mb5y/nERERHJQGHcVQ4qlcpowYejoyO0Wq1BmVarhbW1tWxb+LlmhIiIqALx8fFBbGysQdnu3bvh4+MjU48YjBAREYmnUBj3EuHx48eIj49HfHw8gKdbd+Pj45GQkADg6ZTPoEGD9PWHDx+O69evY8KECbh48SIWLlyIX3/9FWPHjpXs7RGLwQgREVE5dvz4cTRv3hzNmzcHAAQFBaF58+aYNm0aAODevXv6wAQA6tSpgx07dmD37t3w9PTE/Pnz8eOPP8LPz0+W/gNcM0JERCSekdeMiNGxY0c878iwFStWFHrPqVOnjNgrcRiMEBERiSVyKoWer+yEdkRERFQhMTNCREQkVhmapnkV8N0kIiIiWTEzQkREJBbXjEiKmREiIiKSFTMjREREYnHNiKT4bhIREZGsmBkhIiISi2tGJMXMCBEREcmKmREiIiKxuGZEUgxGiIiIxOI0jaQY2hEREZGsmBkhIiISi9M0kuK7SURERLJiZoSIiEgsrhmRFDMjREREJCtmRoiIiMTimhFJ8d0kIiIiWTEzQkREJBYzI5JiMEJERCSWkgtYpcTQjoiIiGTFzAgREZFYnKaRFN9NIiIikhUzI0RERGLx0DNJMTNCREREsmJmhIiISCyuGZEU300iIiKSFTMjREREYnHNiKQYjBAREYnFaRpJ8d0kIiIiWTEzQkREJBanaSTFzAgRERHJipkRIiIisbhmRFJ8N4mIiEhWzIwQERGJxTUjkmJmhIiIiGTFzAgREZFYXDMiKQYjREREYnGaRlIM7YiIiEhWzIwQERGJxWkaSfHdJCIiIlkxM0JERCQWMyOS4rtJREREsmJmhIiISCzuppEUMyNEREQkK2ZGiIiIxOKaEUkxGCEiIhKL0zSSYmhHREREsmIwQkREJJZCadxLpIiICLi6usLc3Bze3t44evRokXVzc3Mxc+ZMuLm5wdzcHJ6enoiOjn6Zd+OlMRghIiIqx9atW4egoCCEhITg5MmT8PT0hJ+fH+7fv19o/SlTpmDx4sUIDw/HX3/9heHDh6Nnz544depUKff8bwxGiIiIxFIojHuJEBYWhmHDhiEwMBAeHh5YtGgRLC0tERkZWWj91atX4/PPP4e/vz/q1q2LTz75BP7+/pg/f74U70yJMBghIiIqp3JycnDixAn4+vrqy5RKJXx9fXHo0KFC78nOzoa5ublBmYWFBf7880+j9vV5uJuGiIhIJIWRd9NkZ2cjOzvboEylUkGlUhmUJScnIz8/H2q12qBcrVbj4sWLhbbt5+eHsLAwdOjQAW5uboiNjcWmTZuQn58v7SBEYGaEiIiojAkNDYWNjY3BFRoaKknb3377LerXr4+GDRvCzMwMI0eORGBgIJRK+UICZkaIiIhEMnZmJDg4GEFBQQZl/86KAIC9vT1MTEyg1WoNyrVaLRwdHQtt28HBAVu2bEFWVhZSUlJQs2ZNTJo0CXXr1pVuACIxM0JERCSWwriXSqWCtbW1wVVYMGJmZoaWLVsiNjZWX6bT6RAbGwsfH5/nDsHc3BxOTk7Iy8vDxo0b0b1795K/Hy+JmREiIqJyLCgoCAEBAWjVqhVat26NBQsWICMjA4GBgQCAQYMGwcnJST/Nc+TIEdy5cwdeXl64c+cOpk+fDp1OhwkTJsg2BgYjREREIhl7mkaMvn37IikpCdOmTYNGo4GXlxeio6P1i1oTEhIM1oNkZWVhypQpuH79OqysrODv74/Vq1ejatWqMo0AUAiCIMj26mWURfORcneBSkHmqe8BAAevpMrcEyoN7erbAgCy8mTuCJUKcyP/qm313xVGbf/xr4ON2n5ZU+I1IxkZGQgLC0OnTp2gVqthZmYGW1tb+Pj4YNq0aUhISNDXPXPmDEaOHIk2bdqgZs2aUKlUsLGxgY+PD8LDw5Gbmyv69RMTE7Fw4UIMHjwYjRo1glKphEKhwL59+0o6JCIiomJRKBRGvSqaEsWOcXFx6N27NzQaDSwtLdGmTRuo1WqkpaXh2LFjOHz4MObNm4ft27fD19cXf/zxByIiIuDi4gIPDw84ODggKSkJBw8exOHDh7Fx40bExMTAzMys2H3YuHEjxo4dW5LuExERURkiOhiJj49H586dkZWVhYkTJ2Lq1KmoXLmy/nmdToctW7ZgwoQJuH37NgDA399ff+zsP2m1Wvj6+mL//v1YsmQJRo4s/vRI3bp1MWbMGLz22mt47bXXMHLkSMTExIgdDhERkWgVMXthTKKCEUEQMHDgQGRlZWH69OkICQkpUEepVKJXr17o3LkzEhMTAaDIvctqtRoTJ07EwIEDsWfPHlHByLvvvot3331X/5h/MIiIiMonUcFIdHQ0zp07h1q1amHy5MnPrfvsxLgXMTU1BQBRUzRUtHYt3DB2kC9aeNRGDQcb/HfsEkTtO/Pce15vWR9zx/WCh5sjbmseYs6P0VgTdcSgzsf/7YCxAZ2hrmaNs5fvIGjuehw/f8uYQyERYrdvQPSmNUhLfQDnOvUw4ONxqOve+IX3Hdm/G4u/mormbTpg1JR5+vItPy3F0QO/40GSFpUqmcKlnjt6DRoON/cmxhwGFdMva3/CyuXLkJychAbuDTHp86lo2qxZoXU3rv8VUdu24OrVKwAAD4/GGDU6yKD+DxHhiP5tBzQaDUxNTeHh0RgjR49Fs2aepTKe8oi/AEtL1ALWHTt2AAD69OmDSpVefqlyamqq/lsCu3Xr9tLtEVDZQoWzl+9gTOi6YtV3qVkNm8OH44/jl+H9/hx8v3YvfpjWH74+jfR13nurBeaO64nZi3+DT/+5OHP5DrYtHAEHWytjDYNEOPrHbqz78Vu8228oQr5dCec69RE2bQzSHz547n3J2rv4NfI7NGjsVeA5R6faGDB8HGZG/ITgeYthr66BsKmjkZ7GnUdyi/5tJ76eF4qPPx2BX9Zvhrt7Q3zy8RCkpKQUWv/4sSN4278bfoxchdU//QK1Yw188tGHBid2uri4InjyNGzcHIUVq9eippMTPhn2IR48eP6foQrNyIeeVTSigpH4+HgAQIsWLUr0YleuXMHgwYMxaNAg+Pn5oXbt2jh27BiGDx+OAQMGlKhNMhRz8C/MWLgd2/Y+PxvyzLD32uPmnRRMCtuMSze0WLTuD2yOjceoAZ30dT774E0s3xSH1dsO4+J1DUbN/gWZWTkI6PH80/2odOza8jM6+HXH613+A6fadTBoxESYqcxxYPf2Iu/R5edjydch6D5gGBwcaxZ4vk1HPzT2ao3qjk5wcqmL94eOQeaTDNy+cdWYQ6FiWL1yOXq991/06NkbbvXqYUrIDJibm2PLpo2F1g+dNx99+w1Aw0aNUKeuG6bP/AI6nQ5HD//9ja7+/3kHbXzaopazM+rVq4/xE4Lx+PFjXLl8qbSGRRWcqGDkWeTt4OBQohfTarVYuXIlVq9ejZiYGDx+/BifffYZ5s6dK+sX9FRk3p51sPeI4Q+c3XEX4N2sDgDAtJIJmjdyxp5/1BEEAXuOXELr/9Uh+eTl5uLW1Uvw8HpNX6ZUKuHh9RquXTxb5H3bfolEFRs7dHjr3SLr/PM19kdvgUVlKzjXqS9Jv6lkcnNycOGv82jj01ZfplQq0aZNW5w5fapYbWRlZSIvLw/WRUyj5+bkYOP6dahSpQoauLtL0u9XEbf2SqtUT2Bt3749BEFAfn4+EhISsHnzZsyYMQO//fYbYmJi4OrqWprdIQDqatbQPnhkUHb/QTpsqljAXGUKW2tLVKpkgvv/rpOSDndXw6+sptL3KP0hdLp8WFe1Myi3rmqLe7dvFnrP5fPxOBCzDdO/W/3ctuOP/onF86YiJzsLNrb2GD/rO1SxqSpRz6kkUh+mIj8/H9WqVTMor1atGm7cuF6sNhbM/xoO1asbBDQAsH/fXkwcH4SsrEzYOzhg0dJI2NraFdEKkbREBSPP/gIkJSW91IuamJigTp06CAoKgqurK3r37o1Ro0YhKioKAHDx4kXMmTOnwH2TJk1Cw4YNX+q1/yk7OxvZ2dkGZYV9ERHRqyLzSQZ+DJuBgFHBLwwsGjVrienfrcLj9DTs37UVP8ydjCnzlxUIfKj8WLZ0CaJ/24llK1YV+Fn3Wmtv/LpxCx4+TMXGDb/i/8aNwZqf1xcIfOipipi9MCZRwYiXlxcOHjyIkydP4oMPPpCkAz179oSVlRWio6ORk5MDMzMzaDQarFy5skDdwYMHSxqMhIaGYsaMGQZlhW1XfpVpU9KhtqtiUFbdzhppjzKRlZ2L5NTHyMvLR/V/16lmDU1Keml2lQpRxboqlEqTAotV0x+mwsa24D8iSZo7SNbew3cz/09fJgg6AMDQd9vhy8XrUL1GLQCAytwC6prOUNd0hlvDJpg07D0ciIlCt/8GGHFE9Dy2VW1hYmJSYLFqSkoK7O3tn3vvyuXLsHzZEiz+cTkauBf8OWppaYnaLi6o7eKCZp5eeOftt7Bl0wYMGfaxpGMgKoyohRrPdrysX78eeXnSfMGDQqGAnZ0d8vLykJr6dKV+x44dIQhCgatjx46SvOYzwcHBSEtLM7iCg4MlfY2y7sjpG+jY2nBeuHObhjhy5gYAIDcvH6cuJKKT9991FAoFOrVugKP/q0PyqWT6dNvthdPH9GU6nQ4XTh+DW8OmBerXqOWCmd//hOnfrdJfXt6vo2HTp1kQO/uip94EQUBubo5RxkHFY2pmhkYejXHkH4tPdTodjhw5hGaezYu8b/mypViyaCEWLv4RjZsU/HNRGJ2gQ04OP++icM2ItERlRrp27YrGjRvj/PnzmD179nOzCOnp6UhMTETjxs8/6+D69etITEyEtbX1CyN7qalUqlduWqayhRncnP9eYOzqVA3NGjghNf0JEjWpmDnqXdSsboOhU5+uF1i64U8Mf78DZo/ujpVbD6Pjaw3Qu0tz9Pxskb6N79bswdKZA3HirwQcP3cTI/t3gqWFCqu2Hi718VFBfj364cdvZsG1fiPUaeCB3VvXITsrC+19n/7ysHT+DNhWc8B7gz+FqZkKtVzdDO63rPx0i/az8uysTGxftwJe3q/Dxq4aHqenYc/2DUhNScJr7TuX7uCogIEBgZj6+UQ0btwETZo2w5rVK5GZmYkePXsBACYHT0D16mqMHjsOABD54xIs/P47zJk3HzVrOiH5f9PslpaWsKxcGU+ePMGPSxahY6c3Ye/ggIepqfjl559wX6tFF7+uso2TKhZRwYhCocCaNWvg4+OD6dOn67+G+J/HwQuCgKioKIwfPx6ff/45GjdujPDwcPTp0weOjo4G7V26dAkBAQEQBAGDBg2CiYmJNKOqwFp4uCDmx9H6x/PG9wYArN52GB+FrIGjvTWcHf+e8791NwU9Ry3CvPG9MKJ/R9zRPsQnM9fi90MX9HU2xJyEva0Vpn3SDepqVXDm0h10HxFRYFEryaN1hy54lPYQW9YsRVpqCpzr1sfYmd/op2keJGmgVBb/Ny2lUol7t2/iYOxOPE5/iMrWNqhTvxGC5y6Ck0vhpylT6en6tj9SHzzAwu+/Q3JyEtwbNsLCxT+i2v9+mdPcuwel4u+k9/p1vyA3Nxfjxn5m0M7wT0fikxGjYGJighs3rmPb1s14mJqKqlWronGTpli+6ifUq8fdU0WpiNkLY1IIgiCIvengwYPo3bs3tFotLC0t4ePjo/+ivOPHj0Or1cLc3Bzbt29H586d4erqisTERHh6eqJevXoQBAG3bt3CiRMnoNPp0KFDB+zYsQNWVsU/ROvevXvo2bOn/vHFixeRlpaGRo0awdraGsDTaaWpU6eKHR4smhf/WHoqvzJPfQ8AOHiFB3lVBO3q2wIAsqSZYaYyztzIe0WrBfxs1PZTVvYzavtlTYk+rnbt2uHq1atYvHgxoqKicObMGaSmpsLKygru7u4YPnw4hg4dilq1ni6Emz17Nnbu3Injx49j165dyMzMhJ2dHbp06YJ+/fph4MCBos8Zyc7OxpEjRwqUX7jw92/0Ui52JSIiIuMoUWbkVcfMSMXAzEjFwsxIxWLszIj94F+M2n7yiveN2n5Zw2NPiYiISFalegIrERHRq4ALWKXFzAgRERHJipkRIiIikZgZkRYzI0RERCQrZkaIiIjEYmJEUsyMEBERkayYGSEiIhKJa0akxWCEiIhIJAYj0uI0DREREcmKmREiIiKRmBmRFjMjREREJCtmRoiIiERiZkRazIwQERGRrJgZISIiEouJEUkxM0JERESyYmaEiIhIJK4ZkRaDESIiIpEYjEiL0zREREQkK2ZGiIiIRGJmRFrMjBAREZGsmBkhIiISi4kRSTEzQkRERLJiZoSIiEgkrhmRFjMjREREJCtmRoiIiERiZkRaDEaIiIhEYjAiLU7TEBERkayYGSEiIhKJmRFpMTNCREREsmJmhIiISCwmRiTFzAgRERHJisEIERGRSAqFwqiXWBEREXB1dYW5uTm8vb1x9OjR59ZfsGAB3N3dYWFhAWdnZ4wdOxZZWVklfTteGoMRIiKicmzdunUICgpCSEgITp48CU9PT/j5+eH+/fuF1l+7di0mTZqEkJAQXLhwAcuWLcO6devw+eefl3LP/8ZghIiISKSylBkJCwvDsGHDEBgYCA8PDyxatAiWlpaIjIwstH5cXBzatWuH/v37w9XVFW+99Rb69ev3wmyKMTEYISIiEkmhMO5VXDk5OThx4gR8fX31ZUqlEr6+vjh06FCh97Rt2xYnTpzQBx/Xr1/Hzp074e/v/1LvycvgbhoiIqIyJjs7G9nZ2QZlKpUKKpXKoCw5ORn5+flQq9UG5Wq1GhcvXiy07f79+yM5ORnt27eHIAjIy8vD8OHDOU1DRERUnhh7miY0NBQ2NjYGV2hoqCR937dvH7788kssXLgQJ0+exKZNm7Bjxw7MmjVLkvZLgpkRIiKiMiY4OBhBQUEGZf/OigCAvb09TExMoNVqDcq1Wi0cHR0LbXvq1KkYOHAghg4dCgBo2rQpMjIy8NFHH2Hy5MlQKks/T8HMCBERkUjGXjOiUqlgbW1tcBUWjJiZmaFly5aIjY3Vl+l0OsTGxsLHx6fQvj958qRAwGFiYgIAEARBwnep+JgZISIiKseCgoIQEBCAVq1aoXXr1liwYAEyMjIQGBgIABg0aBCcnJz00zzvvPMOwsLC0Lx5c3h7e+Pq1auYOnUq3nnnHX1QUtoYjBAREYlUlr4or2/fvkhKSsK0adOg0Wjg5eWF6Oho/aLWhIQEg0zIlClToFAoMGXKFNy5cwcODg545513MHv2bLmGAIUgV06mDLNoPlLuLlApyDz1PQDg4JVUmXtCpaFdfVsAQFaezB2hUmFu5F+13SfuMmr7l+b6GbX9soaZESIiIpHKUGLklcBghIiISCSlktGIlLibhoiIiGTFzAgREZFInKaRFjMjREREJCtmRoiIiEQqS1t7XwXMjBAREZGsmBkhIiISiYkRaTEzQkRERLJiZoSIiEgkrhmRFoMRIiIikRiMSIvTNERERCQrZkaIiIhEYmJEWsyMEBERkayYGSEiIhKJa0akxcwIERERyYqZESIiIpGYGJEWMyNEREQkK2ZGiIiIROKaEWkxGCEiIhKJsYi0OE1DREREsmJmhIiISCRO00iLmREiIiKSFTMjREREIjExIi1mRoiIiEhWzIwQERGJxDUj0mIwUojMU9/L3QUqRe3q28rdBSpF5vypR1Tm8K8lERGRSEyMSIvBSCEOXkmVuwtUCp5lRCyaj5S5J1QanmU8lx65JXNPqDQM83YxavucppEWF7ASERGRrJgZISIiEomJEWkxM0JERESyYmaEiIhIJK4ZkRYzI0RERCQrZkaIiIhEYmJEWsyMEBERkayYGSEiIhKJa0akxcwIERERyYqZESIiIpGYGZEWgxEiIiKRGItIi9M0REREJCtmRoiIiETiNI20mBkhIiIiWTEzQkREJBITI9JiZoSIiIhkxcwIERGRSFwzIi1mRoiIiEhWzIwQERGJxMSItBiMEBERiaRkNCIpTtMQERGRrBiMEBERiaRQGPcSKyIiAq6urjA3N4e3tzeOHj1aZN2OHTtCoVAUuLp16/YS78jLYTBCRERUjq1btw5BQUEICQnByZMn4enpCT8/P9y/f7/Q+ps2bcK9e/f017lz52BiYoI+ffoU+zXz8vLw+++/Y/HixXj06BEA4O7du3j8+HGJxsBghIiISKTCMgtSXmKEhYVh2LBhCAwMhIeHBxYtWgRLS0tERkYWWt/Ozg6Ojo76a/fu3bC0tCx2MHLr1i00bdoU3bt3x4gRI5CUlAQAmDt3LsaPHy+q788wGCEiIipjsrOzkZ6ebnBlZ2cXqJeTk4MTJ07A19dXX6ZUKuHr64tDhw4V67WWLVuG999/H5UrVy5W/dGjR6NVq1ZITU2FhYWFvrxnz56IjY0tVhv/xmCEiIhIJKXCuFdoaChsbGwMrtDQ0AL9SE5ORn5+PtRqtUG5Wq2GRqN54TiOHj2Kc+fOYejQocUe+4EDBzBlyhSYmZkZlLu6uuLOnTvFbuefuLWXiIiojAkODkZQUJBBmUqlkvx1li1bhqZNm6J169bFvken0yE/P79A+e3bt1GlSpUS9YOZESIiIpGMvWZEpVLB2tra4CosGLG3t4eJiQm0Wq1BuVarhaOj43PHkJGRgV9++QVDhgwRNfa33noLCxYsMHgvHj9+jJCQEPj7+4tq6xkGI0RERCKVla29ZmZmaNmypcFaDZ1Oh9jYWPj4+Dz33vXr1yM7OxsffPCBqLF//fXXOHjwIDw8PJCVlYX+/fvrp2jmzp0rqq1nOE1DRERUjgUFBSEgIACtWrVC69atsWDBAmRkZCAwMBAAMGjQIDg5ORVYc7Js2TL06NED1apVE/V6zs7OOH36NNatW4fTp0/j8ePHGDJkCAYMGGCwoFUMBiNEREQiKVB2joPv27cvkpKSMG3aNGg0Gnh5eSE6Olq/qDUhIQFKpeFEyKVLl/Dnn38iJiZG1Gvl5uaiYcOG2L59OwYMGIABAwZIMgYGI0REROXcyJEjMXLkyEKf27dvX4Eyd3d3CIIg+nVMTU2RlZUl+r4X4ZoRIiIikYy9tbcsGzFiBObOnYu8vDzJ2mRmhIiIiIrt2LFjiI2NRUxMDJo2bVrgsLRNmzaJbpPBCBERkUhij2x/lVStWhW9e/eWtE0GI0RERFRsy5cvl7xNBiNEREQiVeDEiF5SUhIuXboE4OmCWAcHhxK3xQWsREREIikVCqNeZVlGRgY+/PBD1KhRAx06dECHDh1Qs2ZNDBkyBE+ePClRmwxGiIiIqNiCgoKwf/9+REVF4eHDh3j48CG2bt2K/fv3Y9y4cSVqk9M0REREIpXx5IVRbdy4ERs2bEDHjh31Zf7+/rCwsMB///tf/PDDD6LbZGaEiIiIiu3Jkyf6013/qXr16pymISIiKi3G/tbesszHxwchISEGJ7FmZmZixowZL/xyvqJwmoaIiIiK7dtvv4Wfnx9q1aoFT09PAMDp06dhbm6OXbt2lahNBiNEREQilfHkhVE1adIEV65cwU8//YSLFy8CAPr168dv7SUiIqLSY2lpiWHDhknWHteMEBERiVSRzxkJDQ1FZGRkgfLIyEjMnTu3RG0yGCEiIhJJYeSrLFu8eDEaNmxYoLxx48ZYtGhRidpkMEJERETFptFoUKNGjQLlDg4OuHfvXonaZDBCREQkUkXe2uvs7IyDBw8WKD948CBq1qxZoja5gJWIiIiKbdiwYRgzZgxyc3Px5ptvAgBiY2MxYcIEHgdPRERUWpRlO3lhVP/3f/+HlJQUfPrpp8jJyQEAmJubY+LEiQgODi5RmwxGiIiIqNgUCgXmzp2LqVOn4sKFC7CwsED9+vWhUqlK3CbXjBAREYlUkdeMPGNlZYXXXnsNVapUwbVr16DT6UrcFoMRIiIieqHIyEiEhYUZlH300UeoW7cumjZtiiZNmiAxMbFEbTMYISIiEkmhMO5VFi1ZsgS2trb6x9HR0Vi+fDlWrVqFY8eOoWrVqpgxY0aJ2uaaESIiIpHKy1SKlK5cuYJWrVrpH2/duhXdu3fHgAEDAABffvklAgMDS9Q2MyNERET0QpmZmbC2ttY/jouLQ4cOHfSP69atC41GU6K2GYwQERGJpFQY9yqLXFxccOLECQBAcnIyzp8/j3bt2umf12g0sLGxKVHbnKYhIiKiFwoICMCIESNw/vx57NmzBw0bNkTLli31z8fFxaFJkyYlapvBCBERkUgVcc3IhAkT8OTJE2zatAmOjo5Yv369wfMHDx5Ev379StQ2gxEiIiJ6IaVSiZkzZ2LmzJmFPv/v4EQMBiNEREQiVby8iHFxASsRERHJipkRIiIikZQVcM2IMTEYISIiEomxiLRKPE2TkZGBsLAwdOrUCWq1GmZmZrC1tYWPjw+mTZuGhIQEfd0zZ85g5MiRaNOmDWrWrAmVSgUbGxv4+PggPDwcubm5ol5bp9PhwIEDmDBhAlq2bIkqVapApVLBzc0Nw4cPx40bN0o6LCIiInqOvXv3St5miTIjcXFx6N27NzQaDSwtLdGmTRuo1WqkpaXh2LFjOHz4MObNm4ft27fD19cXf/zxByIiIuDi4gIPDw84ODggKSkJBw8exOHDh7Fx40bExMTAzMysWK9//fp1/alvjo6OePPNN2FiYoKjR49i8eLFWLt2LXbu3In27duXZHhERETPVRG39j7TtWtX1KpVC4GBgQgICICzs/NLtyk6MxIfH4/OnTtDo9Fg4sSJuH//PmJjY7F27Vrs2LEDGo0GGzduRK1atXD79m0AgL+/P65du4abN2/i999/x88//4zff/8dN2/eRJMmTbB//34sWbKk2H1QKBTo0qULYmNjcffuXWzduhWbNm3CtWvXMHjwYDx69AgDBgwQnXEhIiKi57tz5w5GjhyJDRs2oG7duvDz88Ovv/6KnJycErcpKhgRBAEDBw5EVlYWpk+fjjlz5qBy5cqGDSqV6NWrF06cOKH/Qp26deuibt26BdpTq9WYOHEiAGDPnj3F7oebmxtiYmLw5ptvGkSnKpUKCxcuhI2NDRISEhAXFydmeERERMVSEb+19xl7e3uMHTsW8fHxOHLkCBo0aIBPP/0UNWvWxGeffYbTp0+LblPUNE10dDTOnTuHWrVqYfLkyc+ta2NjU6wz6k1NTQGg2FM0L2JhYYEGDRrg2LFjuHv3riRtlkex2zcgetMapKU+gHOdehjw8TjUdW/8wvuO7N+NxV9NRfM2HTBqyjx9+ZafluLogd/xIEmLSpVM4VLPHb0GDYebe8mO/iVptGvhhrGDfNHCozZqONjgv2OXIGrfmefe83rL+pg7rhc83BxxW/MQc36MxpqoIwZ1Pv5vB4wN6Ax1NWucvXwHQXPX4/j5W8YcColw6vdtOLZzPTLSHsDBuS46DxyBGm4NC6177kAMopd+bVBmYmqKsct26B8f3LQKl47sQ3pKEkwqmULtWh+v9xmMGm6NjDoOKv9atGgBR0dHVKtWDXPmzEFkZCQWLlwIHx8fLFq0CI0bv/jfHUBkZmTHjqd/ePv06YNKlV5+I05qairmz58PAOjWrdtLtwc8Xdx669bTH5qOjo6StFneHP1jN9b9+C3e7TcUId+uhHOd+gibNgbpDx88975k7V38GvkdGjT2KvCco1NtDBg+DjMjfkLwvMWwV9dA2NTRSE9LNdIoqDgqW6hw9vIdjAldV6z6LjWrYXP4cPxx/DK835+D79fuxQ/T+sPX5+9/dN57qwXmjuuJ2Yt/g0//uThz+Q62LRwBB1srYw2DRLh4eB/2rV0Mnx4fYODMhaheuy42fPU5MtKL/rtoZmGJT777RX99FLbG4Hk7x1roPHAkBn+5BP2mhMHGQY3184LxJP2hkUdTfikVCqNeZV1ubi42bNgAf39/uLi4YNeuXfj++++h1Wpx9epVuLi4oE+fPsVuT1REER8fD+BpJFQSV65cwezZs6HT6aDVahEXF4fHjx9j+PDhGDBgQIna/Leff/4Z9+/fh4ODA9q2bStJm+XNri0/o4Nfd7ze5T8AgEEjJuLMsTgc2L0d3foMKvQeXX4+lnwdgu4DhuHK+Xg8yXhs8Hybjn4Gj98fOgYHYqJw+8ZVeHi9ZpyB0AvFHPwLMQf/Knb9Ye+1x807KZgUthkAcOmGFm2bu2HUgE74/dAFAMBnH7yJ5ZvisHrbYQDAqNm/4O3XGyOghw++Xr5b+kGQKMejN6Jpx7fRtMPTv5NdBo/G9dNHcW7/Lni/836h9ygUClSualdkm43avmnwuGP/j3F2fzSSEm/ApXFz6TpPr4RRo0bh559/1i/dmDdvnsEX5FWuXBlff/01atasWew2RQUjKSkpAAAHBwcxt+lptVqsXLnSoOyzzz7DrFmzoFS+/GGwiYmJGDNmDABg5syZUKlUL91meZOXm4tbVy+hW58AfZlSqYSH12u4dvFskfdt+yUSVWzs0OGtd3HlfPwLX2N/9BZYVLaCc536UnWdSoG3Zx3sPXLJoGx33AV8Nb43AMC0kgmaN3LGV5Ex+ucFQcCeI5fQulmdUu0rFZSflwvtzSsGQYdCqURtj+a4e/VCkfflZGVi8dgPAEGH6i718XqfQNjXci3yNc7s3QmVZWU41C641o+eKgfJC6P566+/EB4ejl69ehX576y9vb2oLcCleuhZ+/btIQgC8vPzkZCQgM2bN2PGjBn47bffEBMTA1dX1xK3nZGRgV69eiE5ORk9evTA8OHDpet4OfIo/SF0unxY/+u3IOuqtrh3+2ah91w+H48DMdsw/bvVz207/uifWDxvKnKys2Bja4/xs75DFZuqEvWcSoO6mjW0Dx4ZlN1/kA6bKhYwV5nC1toSlSqZ4P6/66Skw91VXZpdpUJkPkqHoNOhsrWtQXllG1s8uJdY6D12jrXQdeg4ODjXRXZmBo7tXI+1s8YgMHQpqtj9/YvltVOHsX3hl8jNyYZVVTu8N2EOLKu8eN1fRVWRt/aGhISgbdu2BZZr5OXlIS4uDh06dEClSpXwxhtvFLtNUcFItWrVAABJSUlibivAxMQEderUQVBQEFxdXdG7d2+MGjUKUVFRAICLFy9izpw5Be6bNGkSGjYsuEgrNzcXffr0wfHjx9G+fXusXbu2WP3Izs5Gdna2QVlFy6ZkPsnAj2EzEDAq+IWBRaNmLTH9u1V4nJ6G/bu24oe5kzFl/rICgQ8RlR0163ugZn2Pvx/X88DySUNxes8OtH9vsL7c2cMTg774AZmP0nFm305Eff8FBkz/rkDgQ9SpUyfcu3cP1atXNyhPS0tDp06dkJ+fL7pNUXMjXl5eAICTJ0+KfqGi9OzZE1ZWVoiOjtbvUdZoNFi5cmWBS6PRFLhfp9MhICAAv/32G7y8vBAVFQULC4tivXZoaKh+18+zKzQ0VLKxyaGKdVUolSYFFqumP0yFjW21AvWTNHeQrL2H72b+H4a+2w5D322HuD2/If7IAQx9tx3u37utr6syt4C6pjPcGjbBh6MnQ6k0wYGYKKOPiaSjTUmH2q6KQVl1O2ukPcpEVnYuklMfIy8vH9X/XaeaNTQp6aXZVSqERRVrKJTKAotVM9JSUdmmeL8UmFSqhOoubnh433C3oZnKArZqJ9Ss1whdh46D0sQE5/ZHS9b3V43SyFdZJghCoZmhlJSUAsd9FJeozEi3bt0QERGB9evXY968eZLsqFEoFLCzs0NCQgJSU1OhVqvRsWNHCIJQrPufLaRp0KABdu3ahapVqxb7tYODgxEUFGRQplKpcDzhiZghlCmVTJ9uu71w+hha+DxNkel0Olw4fQxv/qfgyuYatVww8/ufDMo2r1mMrCdP0O+jsbCzLzo1LwgCcnNLfsgNlb4jp2/Ar73hVrvObRriyJmnX6GQm5ePUxcS0cnbXb9FWKFQoFPrBli07o9S7y8ZerbtNuF8POq3bAcAEHQ6JPwVj+a+7xarDZ0uH8m3b6BOs9bPrScIAvJ4cCT9Q69evQA8/ZkwePBgg5mE/Px8nDlzpsQbR0RFE127dkXjxo1x/vx5zJ49GyEhIUXWTU9PR2Ji4gv3GF+/fh2JiYmwtraGvb29mO5gypQpWLhwIWrXro3du3cXSBm9iEqlKmJapvwGIwDg16MffvxmFlzrN0KdBh7YvXUdsrOy0N736fbppfNnwLaaA94b/ClMzVSo5epmcL9l5adbOJ+VZ2dlYvu6FfDyfh02dtXwOD0Ne7ZvQGpKEl5r37l0B0cGKluYwc3573l/V6dqaNbACanpT5CoScXMUe+iZnUbDJ36dD3Q0g1/Yvj7HTB7dHes3HoYHV9rgN5dmqPnZ4v0bXy3Zg+WzhyIE38l4Pi5mxjZvxMsLVRYtfVwqY+PCmrVtTd+W/oV1HXqo0bdhjgRswm52Vlo8r/dNTsXz4OVbTV0+O8QAEDcljWo6dYQVdVOyH7yGMd2rkd68n007fg2ACAnOxNHtv0Mt+Y+qFzVDpmP0hD/exQepybDvXUH2cZZ1lXENSPPzg4TBAFVqlQxmIUwMzNDmzZtMGzYsBK1LSoYUSgUWLNmDXx8fDB9+nRkZWVhypQpBmkZQRAQFRWF8ePH4/PPP0fjxo0RHh6OPn36FDj349KlSwgICIAgCBg0aBBMTEyK3ZdvvvkGs2fPhqOjI37//XfUrl1bzFBeaa07dMGjtIfYsmYp0lJT4Fy3PsbO/EY/TfMgSQOlsvh/kZRKJe7dvomDsTvxOP0hKlvboE79RgieuwhOLlxtL6cWHi6I+XG0/vG8/+2KWb3tMD4KWQNHe2s4O/6dvr91NwU9Ry3CvPG9MKJ/R9zRPsQnM9fqt/UCwIaYk7C3tcK0T7pBXa0Kzly6g+4jIgosaiV5NGzTEU8epeHgplV4kpYKh9p18d7/zUZlm6drO9JT7hv8Q5md8Qi7IhfgSVoqVJWtoHatj35TF8DeyQUAoFSY4MHdRJz/czcyH6XD3KoKHOu44/3JYUXuuKGKafny5QAAV1dXjB8/vsRTMoVRCMWdD/mHgwcPonfv3tBqtbC0tISPj4/+i/KOHz8OrVYLc3NzbN++HZ07d4arqysSExPh6emJevXqQRAE3Lp1CydOnIBOp0OHDh2wY8cOWFkV71Cl+Ph4tGjRAoIgwMfHBw0aNCi03tChQ0v0ZXkHr/Agr4qgXf2nP7wtmo+UuSdUGjJPfQ8AWHqEJ8lWBMO8XYza/pitF43a/oLuhZ+o+6oq0aKPdu3a4erVq1i8eDGioqJw5swZpKamwsrKCu7u7hg+fDiGDh2KWrVqAQBmz56NnTt34vjx49i1axcyMzNhZ2eHLl26oF+/fhg4cKCoc0YePnyoX1Ny6NAhHDp0qNB6HTt25Df3EhERvaQWLVogNjYWtra2aN68+XOnqUqyyaXEK1CtrKwwbtw4jBs37oV1BwwYINkJqwBELXAlIiKSmoiZ7lIRERGBr776ChqNBp6enggPD0fr1kUvUn748CEmT56MTZs24cGDB3BxccGCBQvg7+9faP3u3bvr11j26NFD8v6X6qFnREREr4KytIB13bp1CAoKwqJFi+Dt7Y0FCxbAz88Ply5dKnRjR05ODrp06YLq1atjw4YNcHJywq1bt567G/XZhpX8/Hx06tQJzZo1E7V79UUYjBAREZVjYWFhGDZsGAIDAwEAixYtwo4dOxAZGYlJkyYVqB8ZGYkHDx4gLi4OpqamAFDsE9BNTEzw1ltv4cKFC5IGI2X9bBUiIqIyR6kw7pWdnY309HSD698nhgNPsxwnTpyAr6/v331TKuHr61vkespt27bBx8cHI0aMgFqtRpMmTfDll18W++TUJk2a4Pr16yV744rAYISIiKiMKe4J4cnJycjPz4dabXhApVqtLvTUcuDp+V4bNmxAfn4+du7cialTp2L+/Pn44osvitW3L774AuPHj8f27dtx7969AkFTSXCahoiISCRjLxkp6oRwKeh0OlSvXh1LliyBiYkJWrZsiTt37uCrr7567mGmzzxb5Pruu+8arJ15dkx8Sb6bhsEIERFRGVP0CeGG7O3tYWJiAq1Wa1Cu1WoLHDT6TI0aNWBqampw0GijRo2g0WiQk5MDMzOz577m3r17izECcRiMEBERiaQsI7tpzMzM0LJlS8TGxuq33Op0OsTGxmLkyMIPdGzXrh3Wrl0LnU6nP+Pr8uXLqFGjxgsDEQB44403JOv/MwxGiIiIyrGgoCAEBASgVatWaN26NRYsWICMjAz97ppBgwbByclJv+bkk08+wffff4/Ro0dj1KhRuHLlCr788kt89tlnol73yZMnSEhIQE6O4RemNmvWTPQYGIwQERGJVJZ2f/Tt2xdJSUmYNm0aNBoNvLy8EB0drV/UmpCQYHDKubOzM3bt2oWxY8eiWbNmcHJywujRozFx4sRivV5SUhICAwPx22+/Ffo814wQERFVQCNHjixyWmbfvn0Fynx8fHD4cMm+iXvMmDF4+PAhjhw5go4dO2Lz5s3QarX44osvMH/+/BK1yWCEiIhIpDKyZEQWe/bswdatW9GqVSsolUq4uLigS5cusLa2RmhoKLp16ya6zbKUaSIiIioXlAqFUa+yLCMjQ3/MvK2tLZKSkgAATZs2LdGX5AEMRoiIiEgEd3d3XLp0CQDg6emJxYsX486dO1i0aBFq1KhRojY5TUNERCRSGU9eGNXo0aNx7949AE+/QK9r16746aefYGZmhhUrVpSoTQYjREREVGwffPCB/v9btmyJW7du4eLFi6hduzbs7e1L1CaDESIiIpGUFTgz8m+WlpZo0aLFS7XBYISIiIie69/fk/M8YWFhottnMEJERCRSWd/xIrVTp04Vq56ihO8LgxEiIiJ6LmN8Od4/MRghIiISqYIlRoyOwQgREZFIFW0Ba69evbBixQpYW1ujV69ez627adMm0e0zGCEiIqLnsrGx0a8HsbGxkbx9BiNEREQiKVCxUiPLly8v9P+lwuPgiYiISFbMjBAREYlU0daM/FNKSgqmTZuGvXv34v79+9DpdAbPP3jwQHSbDEaIiIio2AYOHIirV69iyJAhUKvVJT5b5J8YjBAREYlUkTMjBw4cwJ9//glPT0/J2uSaESIiIiq2hg0bIjMzU9I2GYwQERGJpFAojHqVZQsXLsTkyZOxf/9+pKSkID093eAqCU7TEBERiVSRp2mqVq2K9PR0vPnmmwblgiBAoVAgPz9fdJsMRoiIiKjYBgwYAFNTU6xdu5YLWImIiORSxmdSjOrcuXM4deoU3N3dJWuTa0aIiIio2Fq1aoXExERJ22RmhIiISCRlBU6NjBo1CqNHj8b//d//oWnTpjA1NTV4vlmzZqLbZDBCRERExda3b18AwIcffqgvUygUXMBKRERUmirybpobN25I3iaDESIiIio2FxcXydtkMEJERCRSRVsysm3bNrz99tswNTXFtm3bnlv33XffFd0+gxEiIiKRlKhY0UiPHj2g0WhQvXp19OjRo8h6XDNCRERERqHT6Qr9f6kwGCEiIhKpok3TGBsPPSMiIqIXOnToELZv325QtmrVKtSpUwfVq1fHRx99hOzs7BK1zWCEiIhIJKXCuFdZNHPmTJw/f17/+OzZsxgyZAh8fX0xadIkREVFITQ0tERtMxghIiKiF4qPj0fnzp31j3/55Rd4e3tj6dKlCAoKwnfffYdff/21RG1zzQgREZFIFfE4+NTUVKjVav3j/fv34+2339Y/fu2110r8nTXMjBAREdELqdVq/emrOTk5OHnyJNq0aaN//tGjRwW+p6a4GIwQERGJpFAY9yqL/P39MWnSJBw4cADBwcGwtLTE66+/rn/+zJkzcHNzK1HbnKYhIiISqSJO08yaNQu9evXCG2+8ASsrK6xcuRJmZmb65yMjI/HWW2+VqG0GI0RERPRC9vb2+OOPP5CWlgYrKyuYmJgYPL9+/XpYWVmVqG0GI0RERCJVwMSIno2NTaHldnZ2JW6Ta0aIiIhIVsyMEBERicTf5KXF95OIiIhkxcwIERGRSIqKvGjECJgZISIiIlkxM0JERCQS8yLSYjBCREQkUkU89MyYOE1DREREsmJmhIiISCTmRaTFzAgREVE5FxERAVdXV5ibm8Pb2xtHjx4tsu6KFSugUCgMLnNz81LsbUEMRoiIiEQqS9/au27dOgQFBSEkJAQnT56Ep6cn/Pz8cP/+/SLvsba2xr179/TXrVu3XvIdeTkMRoiIiMqxsLAwDBs2DIGBgfDw8MCiRYtgaWmJyMjIIu9RKBRwdHTUX2q1uhR7XBCDESIiIpH+Pc0h9VVcOTk5OHHiBHx9ffVlSqUSvr6+OHToUJH3PX78GC4uLnB2dkb37t1x/vz5l3o/XhaDESIiojImOzsb6enpBld2dnaBesnJycjPzy+Q2VCr1dBoNIW27e7ujsjISGzduhVr1qyBTqdD27Ztcfv2baOMpTgYjBAREYmkNPIVGhoKGxsbgys0NFSSvvv4+GDQoEHw8vLCG2+8gU2bNsHBwQGLFy+WpP2S4NZeIiIikYz93TTBwcEICgoyKFOpVAXq2dvbw8TEBFqt1qBcq9XC0dGxWK9lamqK5s2b4+rVqyXv8EtiZoSIiKiMUalUsLa2NrgKC0bMzMzQsmVLxMbG6st0Oh1iY2Ph4+NTrNfKz8/H2bNnUaNGDcn6LxYzI0RERCKVpUPPgoKCEBAQgFatWqF169ZYsGABMjIyEBgYCAAYNGgQnJyc9NM8M2fORJs2bVCvXj08fPgQX331FW7duoWhQ4fKNgYGI0REROVY3759kZSUhGnTpkGj0cDLywvR0dH6Ra0JCQlQKv+eCElNTcWwYcOg0Whga2uLli1bIi4uDh4eHnINAQpBEATZXp2IiKgc2nD6nlHbf89TvikTOXDNCBEREcmK0zSFyMqTuwdUGsz/96d/6RF5j0Gm0jHM2wUAYNF8pMw9odKQeep7o7bP3+SlxfeTiIiIZMXMCBERkUjGPmekomEwQkREJBJDEWlxmoaIiIhkxcwIERGRSJylkRYzI0RERCQrZkaIiIhEUnLViKSYGSEiIiJZMTNCREQkEteMSIuZESIiIpIVMyNEREQiKbhmRFLMjBAREZGsmBkhIiISiWtGpMVghIiISCRu7ZUWp2mIiIhIVsyMEBERicRpGmkxM0JERESyYmaEiIhIJGZGpMXMCBEREcmKmREiIiKReOiZtJgZISIiIlkxM0JERCSSkokRSTEYISIiEonTNNLiNA0RERHJipkRIiIikbi1V1rMjBAREZGsmBkhIiISiWtGpMXMCBEREcmKmREiIiKRuLVXWsyMEBERkayYGSEiIhKJa0akxWCEiIhIJG7tlRanaYiIiEhWzIwQERGJxMSItJgZISIiIlkxM0JERCSSkotGJMXMCBEREcmKmREiIiKRmBeRFjMjREREJCtmRoiIiMRiakRSDEaIiIhE4gms0uI0DREREcmKmREiIiKRuLNXWsyMEBERkayYGSEiIhKJiRFpMTNCREREsmJmhIiISCymRiTFzAgREVE5FxERAVdXV5ibm8Pb2xtHjx4t1n2//PILFAoFevToYdwOvgCDESIiIpEURv5PjHXr1iEoKAghISE4efIkPD094efnh/v37z/3vps3b2L8+PF4/fXXX+atkASDESIiIpEUCuNeYoSFhWHYsGEIDAyEh4cHFi1aBEtLS0RGRhZ5T35+PgYMGIAZM2agbt26L/luvDwGI0REROVUTk4OTpw4AV9fX32ZUqmEr68vDh06VOR9M2fORPXq1TFkyJDS6OYLcQErERGRSMZev5qdnY3s7GyDMpVKBZVKZVCWnJyM/Px8qNVqg3K1Wo2LFy8W2vaff/6JZcuWIT4+XtI+vwxmRoiIiMqY0NBQ2NjYGFyhoaEv3e6jR48wcOBALF26FPb29hL0VBrMjBAREYll5NRIcHAwgoKCDMr+nRUBAHt7e5iYmECr1RqUa7VaODo6Fqh/7do13Lx5E++8846+TKfTAQAqVaqES5cuwc3NTYohiMJghIiIqIwpbEqmMGZmZmjZsiViY2P123N1Oh1iY2MxcuTIAvUbNmyIs2fPGpRNmTIFjx49wrfffgtnZ2dJ+i8WgxEiIiKRxG6/NaagoCAEBASgVatWaN26NRYsWICMjAwEBgYCAAYNGgQnJyeEhobC3NwcTZo0Mbi/atWqAFCgvDQxGCEiIirH+vbti6SkJEybNg0ajQZeXl6Ijo7WL2pNSEiAUlm2l4gqBEEQ5O5EWZOVJ3cPqDSY/y8UX3rklrwdoVIxzNsFAGDRvGDqml49mae+N2r78QmPjNq+V+0qRm2/rGFmhIiISKSyM0nzaijbeRsiIiJ65TEzQkREJBZTI5JiZoSIiIhkxcwIERGRSGVpa++rgJkRIiIikhUzI0RERCIpmBiRVIkzIxkZGQgLC0OnTp2gVqthZmYGW1tb+Pj4YNq0aUhISNDXPXPmDEaOHIk2bdqgZs2aUKlUsLGxgY+PD8LDw5Gbmyv69bdt24aAgAA0bdoU9vb2MDU1RfXq1eHv74/t27eXdFhERERUykqUGYmLi0Pv3r2h0WhgaWmJNm3aQK1WIy0tDceOHcPhw4cxb948bN++Hb6+vvjjjz8QEREBFxcXeHh4wMHBAUlJSTh48CAOHz6MjRs3IiYmBmZmZsXuw6pVq7Bp0yY0btwY3t7eqFKlCm7evInffvsNv/32G4KDg/Hll1+WZHhERETPxcSItEQHI/Hx8ejcuTOysrIwceJETJ06FZUrV9Y/r9PpsGXLFkyYMAG3b98GAPj7+8Pf3x9169Y1aEur1cLX1xf79+/HkiVLCv1Sn6JMnjwZixcvRrVq1QzKjxw5Al9fX8yZMwf9+vVD06ZNxQ6RiIjo+RiNSErUNI0gCBg4cCCysrIwffp0zJkzxyAQAQClUolevXrhxIkTaNWqFQCgbt26BQIRAFCr1Zg4cSIAYM+ePaI63rx58wKBCAB4e3ujb9++EAQBe/fuFdUmERERlT5RmZHo6GicO3cOtWrVwuTJk59b18bGBjY2Ni9s09TUFABETdHI0WZ588van7By+TIkJyehgXtDTPp8Kpo2a1Zo3Y3rf0XUti24evUKAMDDozFGjQ4yqP9DRDiif9sBjUYDU1NTeHg0xsjRY9GsmWepjIee79Tv23Bs53pkpD2Ag3NddB44AjXcGhZa99yBGEQv/dqgzMTUFGOX7dA/PrhpFS4d2Yf0lCSYVDKF2rU+Xu8zGDXcGhl1HPR87Vq4YewgX7TwqI0aDjb479gliNp35rn3vN6yPuaO6wUPN0fc1jzEnB+jsSbqiEGdj//bAWMDOkNdzRpnL99B0Nz1OH6e39n0PNzaKy1RmZEdO57+sOrTpw8qVXr5jTipqamYP38+AKBbt24v3R4AnD17FuvWrYOpqSm6dOkiSZvlTfRvO/H1vFB8/OkI/LJ+M9zdG+KTj4cgJSWl0PrHjx3B2/7d8GPkKqz+6ReoHWvgk48+hFar1ddxcXFF8ORp2Lg5CitWr0VNJyd8MuxDPHjwoLSGRUW4eHgf9q1dDJ8eH2DgzIWoXrsuNnz1OTLSU4u8x8zCEp9894v++ihsjcHzdo610HngSAz+cgn6TQmDjYMa6+cF40n6QyOPhp6nsoUKZy/fwZjQdcWq71KzGjaHD8cfxy/D+/05+H7tXvwwrT98ff4OKt97qwXmjuuJ2Yt/g0//uThz+Q62LRwBB1srYw2DqABREUV8fDwAoEWLFiV6sStXrmD27NnQ6XTQarWIi4vD48ePMXz4cAwYMKBEbUZFRWHjxo3Izc1FQkIC4uLiYGpqiqVLl8LNza1EbZZ3q1cuR6/3/osePXsDAKaEzMAff+zDlk0bMWTYRwXqh86bb/B4+swvELt7F44ePoR3uvcAAPj/5x2DOuMnBGPzxg24cvkSvNv4GGcgVCzHozeiace30bSDHwCgy+DRuH76KM7t3wXvd94v9B6FQoHKVe2KbLNR2zcNHnfs/zHO7o9GUuINuDRuLl3nSZSYg38h5uBfxa4/7L32uHknBZPCNgMALt3Qom1zN4wa0Am/H7oAAPjsgzexfFMcVm87DAAYNfsXvP16YwT08MHXy3dLP4hXBLf2SktUMPLsN2sHB4cSvZhWq8XKlSsNyj777DPMmjULSmXJdhmfPn3aoE0LCwt8++23GDhwYInaK+9yc3Jw4a/zGDLsY32ZUqlEmzZtceb0qWK1kZWViby8PFgXMc2Wm5ODjevXoUqVKmjg7i5Jv6lk8vNyob15xSDoUCiVqO3RHHevXijyvpysTCwe+wEg6FDdpT5e7xMI+1quRb7Gmb07obKsDIfaBdd+Udnl7VkHe49cMijbHXcBX41/+ouKaSUTNG/kjK8iY/TPC4KAPUcuoXWzOqXaV6rYSvUE1vbt20MQBOTl5eH69euYP38+VqxYgVatWuHmzZslanPKlCkQBAGZmZk4e/YsAgMD8dFHH6F79+7IycmRdgDlQOrDVOTn5xdY3FutWjUkJycXq40F87+GQ/XqaOPT1qB8/769aNOqOV5r0QyrV63AoqWRsLUt+rdrMr7MR+kQdDpUtrY1KK9sY4uMtMKn0Owca6Hr0HHoOWYG/IdPgiDosHbWGDx6kGRQ79qpw/h22Lv4Zsh/cGLXJrw3YQ4sq7x4HRiVHepq1tA+eGRQdv9BOmyqWMBcZQp7WytUqmSC+/+uk5IOx2rWpdnVckdh5KuiEZUZefYPXFJS0gtqPp+JiQnq1KmDoKAguLq6onfv3hg1ahSioqIAABcvXsScOXMK3Ddp0iQ0bFj4ojxzc3M0adIEERERMDExQXh4OMLDwzFu3Lgi+5GdnY3s7GyDMpVKBZioXmJ05duypUsQ/dtOLFux6ul78Q+vtfbGrxu34OHDVGzc8Cv+b9wYrPl5faG7mqjsqlnfAzXre/z9uJ4Hlk8aitN7dqD9e4P15c4enhj0xQ/IfJSOM/t2Iur7LzBg+ncFAh8iopclKjPi5eUFADh58qRkHejZsyesrKwQHR2tz2RoNBqsXLmywKXRaIrV5rMpmq1btz63XmhoqH7Xz7MrNDT05QYkM9uqtjAxMSmwWDUlJQX29vbPvXfl8mVYvmwJFi1dhgbuBYM+S0tL1HZxQTNPL8yY9SUqmVTClk0bJO0/iWNRxRoKpbLAYtWMtFRUtile1sqkUiVUd3HDw/t3DcrNVBawVTuhZr1G6Dp0HJQmJji3P1qyvpPxaVPSobarYlBW3c4aaY8ykZWdi+TUx8jLy0f1f9epZg1NSnppdrX8YWpEUqKCkWc7XtavX4+8vDxJOqBQKGBnZ4e8vDykpj79gdqxY0cIglDg6tixY7HafPaP7osyOMHBwUhLSzO4goODX2o8cjM1M0Mjj8Y4cviQvkyn0+HIkUNo5ln0wsPly5ZiyaKFWLj4RzRuUryD4nSCrkJOhZUlz7bdJpyP15cJOh0S/opHzXrF24ar0+Uj+faNFwYvgiAgrwRf3UDyOXL6Bjq2NlzX1blNQxw5cwMAkJuXj1MXEtHJ++86CoUCnVo3wNH/1aHCKYz8X0UjKhjp2rUrGjdujNu3b2P27NnPrZueno7z58+/sM3r168jMTER1tbWL/zNvbj2798PAC/cTaNSqWBtbW1w/XtqojwaGBCITRt+xbYtm3H92jV8MXM6MjMz0aNnLwDA5OAJ+Pabv3fQRP64BBHh32LGrC9Rs6YTkpOSkJyUhCcZGQCAJ0+e4LsFYThzOh53797BX+fPYdqUYNzXatHFr6scQ6R/aNW1N87s34lzB2KQcicBu1d+h9zsLDT53+6anYvn4Y9fl+nrx21Zg5tnj+Ph/XvQ3ryCnYvmIj35Ppp2fBsAkJOdiQPrI3H36gWkJWuhuXEZ0Uvn43FqMtxbd5BljPRUZQszNGvghGYNnAAArk7V0KyBE5wdn06dzRz1Ln6c9ffi/aUb/kSdWtUwe3R3NHBV46M+r6N3l+YI/+nvAyG/W7MHgT3bYsA73nCvo8Z3n/eFpYUKq7YeLt3BUYUmas2IQqHAmjVr4OPjg+nTpyMrKwtTpkwxOIVVEARERUVh/Pjx+Pzzz9G4cWOEh4ejT58+cHR0NGjv0qVLCAgIgCAIGDRoEExMTIrVj6SkJGzZsgUDBgyApaWlwXO7d+/GhAkTAACBgYFihvfK6Pq2P1IfPMDC779DcnIS3Bs2wsLFP6La/4I9zb17UCr+jkPXr/sFubm5GDf2M4N2hn86Ep+MGAUTExPcuHEd27ZuxsPUVFStWhWNmzTF8lU/oV69+qU6NiqoYZuOePIoDQc3rcKTtFQ41K6L9/5vNirbPP0HKj3lPhT/2IeYnfEIuyIX4ElaKlSVraB2rY9+UxfA3skFAKBUmODB3USc/3M3Mh+lw9yqChzruOP9yWFF7rih0tHCwwUxP47WP573v10xq7cdxkcha+Bobw1nx78zXLfupqDnqEWYN74XRvTviDvah/hk5lr9tl4A2BBzEva2Vpj2STeoq1XBmUt30H1ERIFFrWSIW3ulpRAEQRB708GDB9G7d29otVpYWlrCx8dH/0V5x48fh1arhbm5ObZv347OnTvD1dUViYmJ8PT0RL169SAIAm7duoUTJ05Ap9OhQ4cO2LFjB6ysinfIzs2bN1GnTh1YWlqiZcuWqFWrFjIyMnD58mVcvHgRADB27FiEhYWJHRoAIEuaGSgq48z/F4ovPcKTJiuCYd5Pgy2L5sX/DiwqvzJPfW/U9i9pnhi1fXdHyxdXeoWUKBgBgMePH2Px4sWIiorCX3/9hdTUVFhZWcHd3R1du3bF0KFDUatWLQDATz/9hJ07d+L48ePQaDTIzMyEnZ0dvLy80K9fPwwcOFDUOSNPnjxBREQE9u3bh/Pnz+P+/fvQ6XSoUaMG2rRpg48//rjY60sKw2CkYmAwUrEwGKlYjB2MXDZyMNKAwQgxGKkYGIxULAxGKhYGI+XLy3/BDBERUUXDNSOSKtUTWImIiIj+jZkRIiIikSriWSDGxMwIERERyYqZESIiIpF4zoi0GIwQERGJxFhEWpymISIiIlkxM0JERCQWUyOSYmaEiIiIZMXMCBERkUjc2istZkaIiIhIVsyMEBERicStvdJiZoSIiIhkxcwIERGRSEyMSIvBCBERkViMRiTFaRoiIiKSFTMjREREInFrr7SYGSEiIiJZMTNCREQkErf2SouZESIiIpIVMyNEREQiMTEiLWZGiIiISFbMjBAREYnENSPSYjBCREQkGqMRKXGahoiIiGTFzAgREZFInKaRFjMjRERE5VxERARcXV1hbm4Ob29vHD16tMi6mzZtQqtWrVC1alVUrlwZXl5eWL16dSn2tiAGI0RERCIpjHyJsW7dOgQFBSEkJAQnT56Ep6cn/Pz8cP/+/ULr29nZYfLkyTh06BDOnDmDwMBABAYGYteuXSJfWToKQRAE2V69jMrKk7sHVBrM/zdJufTILXk7QqVimLcLAMCi+UiZe0KlIfPU90Zt/+7DHKO2X7OqWbHrent747XXXsP33z8ds06ng7OzM0aNGoVJkyYVq40WLVqgW7dumDVrVon6+7KYGSEiIhJJoTDulZ2djfT0dIMrOzu7QD9ycnJw4sQJ+Pr66suUSiV8fX1x6NChF45DEATExsbi0qVL6NChg6TvkRgMRoiIiMqY0NBQ2NjYGFyhoaEF6iUnJyM/Px9qtdqgXK1WQ6PRFNl+WloarKysYGZmhm7duiE8PBxdunSRfBzFxd00REREIimMfM5IcHAwgoKCDMpUKpVk7VepUgXx8fF4/PgxYmNjERQUhLp166Jjx46SvYYYDEaIiIjEMvLWXpVKVazgw97eHiYmJtBqtQblWq0Wjo6ORd6nVCpRr149AICXlxcuXLiA0NBQ2YIRTtMQERGVU2ZmZmjZsiViY2P1ZTqdDrGxsfDx8Sl2OzqdrtA1KaWFmREiIiKRytKZZ0FBQQgICECrVq3QunVrLFiwABkZGQgMDAQADBo0CE5OTvo1J6GhoWjVqhXc3NyQnZ2NnTt3YvXq1fjhhx9kGwODESIionKsb9++SEpKwrRp06DRaODl5YXo6Gj9otaEhAQolX9PhGRkZODTTz/F7du3YWFhgYYNG2LNmjXo27evXEPgOSOF4TkjFQPPGalYeM5IxWLsc0buP8o1avvVq5gatf2yhmtGiIiISFacpiEiIhLJ2Ft7KxpmRoiIiEhWzIwQERGJxcSIpBiMEBERicRYRFqcpiEiIiJZMTNCREQkkoKpEUkxM0JERESyYmaEiIhIJG7tlRYzI0RERCQrZkaIiIhE4poRaTEzQkRERLJiMEJERESy4jQNERGRSJymkRYzI0RERCQrZkaIiIhE4tZeaTEzQkRERLJiZoSIiEgkrhmRFjMjREREJCtmRoiIiERiYkRazIwQERGRrJgZISIiEoupEUkxGCEiIhKJW3ulxWkaIiIikhUzI0RERCJxa6+0mBkhIiIiWTEzQkREJBITI9JiZoSIiIhkxcwIERGRWEyNSIqZESIiIpIVMyNEREQi8ZwRaTEYISIiEolbe6WlEARBkLsTRERE5UlWnnHbN69gqQKuGSFkZ2dj+vTpyM7OlrsrVAr4eVcs/LyNw7ySca+KhpkRQnp6OmxsbJCWlgZra2u5u0NGxs+7YuHnTeUBMyNEREQkKwYjREREJCsGI0RERCQrBiMElUqFkJAQqFQqubtCpYCfd8XCz5vKAy5gJSIiIlkxM0JERESyYjBCREREsmIwQkRERLJiMFJOZWRkICwsDJ06dYJarYaZmRlsbW3h4+ODadOmISEhQV/3zJkzGDlyJNq0aYOaNWtCpVLBxsYGPj4+CA8PR25urujXT0xMxMKFCzF48GA0atQISqUSCoUC+/btk3CU9Iycn7dOp8OBAwcwYcIEtGzZElWqVIFKpYKbmxuGDx+OGzduSD3cCk/uv9/btm1DQEAAmjZtCnt7e5iamqJ69erw9/fH9u3bpRwq0VMClTsHDx4UHB0dBQCCpaWl8Oabbwr9+vUT/P39BQcHBwGAoFKphN27dwuCIAjh4eECAMHFxUXo3Lmz8P777wudO3cWzM3NBQDCG2+8IWRnZ4vqwzfffCMAKHDt3bvXCCOu2OT+vK9cuaL/fB0dHYV3331X6Nmzp+Dk5CQAEKpUqSIcOHDAWMOvcOT+vAVBEHr37i0oFAqhSZMmgr+/v9C3b1/B29tb/+cgODjYGEOnCozBSDlz6tQp/Q+ZiRMnCo8fPzZ4Pj8/X9i4caPg5uYmLF++XBAEQbh27Zpw7dq1Am1pNBqhSZMmAgAhPDxcVD+2bt0qjBkzRvjpp5+Ey5cvC2+99RaDESMoC5/31atXhS5dugixsbGCTqfTl2dlZQmDBw8WAAi1a9cWcnJySjZI0isLn7cgCMLJkyeF5OTkAuWHDx8WrKysBIVCIZw5c0ZUm0TPw2CkHNHpdPofLtOnT39u3YcPHwpnz559YZurV68WAAg9e/Z8qb75+fkxGJFYWf68n3ny5IlgY2MjABD27dsnSZsVVXn4vAVBEIYMGSIAEL799lvJ2iSqgN8NWH5FR0fj3LlzqFWrFiZPnvzcujY2NrCxsXlhm6ampgAAMzMzSfpI0ikPn7eFhQUaNGiAY8eO4e7du5K0WVGVh8/bWG0ScQFrObJjxw4AQJ8+fVCp0svHkampqZg/fz4AoFu3bi/dHkmrPHzeOp0Ot27dAgA4OjpK0mZFVR4+77Nnz2LdunUwNTVFly5dJGmTCACYGSlH4uPjAQAtWrQo0f1XrlzB7NmzodPpoNVqERcXh8ePH2P48OEYMGCAhD0lKZSHz/vnn3/G/fv34eDggLZt20rSZkVVFj/vqKgobNy4Ebm5uUhISEBcXBxMTU2xdOlSuLm5lahNosIwGClHUlJSAAAODg4lul+r1WLlypUGZZ999hlmzZoFpZJJsrKmrH/eiYmJGDNmDABg5syZ/O6Tl1QWP+/Tp08btGlhYYFvv/0WAwcOLFF7REXhv0AVSPv27SEIAvLy8nD9+nXMnz8fK1asQKtWrXDz5k25u0cSM+bnnZGRgV69eiE5ORk9evTA8OHDpek0lZgxPu8pU6ZAEARkZmbi7NmzCAwMxEcffYTu3bsjJydH2gFQhcbMSDlSrVo1AEBSUtJLtWNiYoI6deogKCgIrq6u6N27N0aNGoWoqCgAwMWLFzFnzpwC902aNAkNGzZ8qdem4iurn3dubi769OmD48ePo3379li7du1L9Y+eKqufNwCYm5ujSZMmiIiIgImJCcLDwxEeHo5x48a9VF+J9OTdzENijBgxQgAgjB07VrI2dTqdYGVlJVSqVEl/MNLevXtFH2jGrb3SK4ufd35+vtCvXz8BgODl5SWkpqZK1reKrix+3oU5evSoAEB4/fXXJesnEadpypFnK+LXr1+PvLw8SdpUKBSws7NDXl4eUlNTAQAdO3aE8PQMGoOrY8eOkrwmFU9Z/LxHjRqFn3/+GQ0aNMCuXbtQtWpVSfpFZfPzLoy9vT2Al8/gEP0Tg5FypGvXrmjcuDFu376N2bNnP7dueno6zp8//8I2r1+/jsTERFhbW+t/yFDZUNY+7ylTpmDhwoWoXbs2du/ejerVq4u6n56vrH3eRdm/fz8AcDcNSYrBSDmiUCiwZs0amJubY/r06QgODkZGRoZBHUEQsG3bNrRq1QrHjh0DAISHh0Oj0RRo79KlS+jfvz8EQcCgQYNgYmJSKuOg4ilLn/c333yD2bNnw9HREb///jtq1679coOjAsrK552UlISlS5fiyZMnBZ7bvXs3JkyYAAAIDAwUO0SiIikEQRDk7gSJc/DgQfTu3RtarRaWlpbw8fGBWq1GWloajh8/Dq1WC3Nzc2zfvh2dO3eGq6srEhMT4enpiXr16kEQBNy6dQsnTpyATqdDhw4dsGPHDlhZWRW7D/fu3UPPnj31jy9evIi0tDQ0atQI1tbWAJ6mnadOnSr5+CsauT/v+Ph4tGjRAoIgwMfHBw0aNCi03tChQ9G+fXsph14hyf1537x5E3Xq1IGlpSVatmyJWrVqISMjA5cvX8bFixcBAGPHjkVYWJgx3waqaEppbQpJ7NGjR8LXX38tvPHGG4KDg4NQqVIloWrVqoK3t7cQEhIiJCYm6uuuWbNG6N+/v9CgQQPB2tpaMDU1FdRqteDn5yesWLFCyM/PF/36N27cKHQR3D+vgIAACUdcscn5eRe14PHf17MvbqOXJ+fnnZGRIcybN0/w9/cXXFxcBAsLC0GlUgmurq7C+++/z0XqZBTMjBAREZGsuGaEiIiIZMVghIiIiGTFYISIiIhkxWCEiIiIZMVghIiIiGTFYISIiIhkxWCEiIiIZMVghIiIiGTFYISIiIhkxWCEiIiIZMVghIiIiGTFYISIiIhkxWCEiIiIZPX/7gYOOajpKKkAAAAASUVORK5CYII=\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots(figsize=(6, 6), sharey=True)\n",
        "\n",
        "x_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "y_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "\n",
        "sns.heatmap(\n",
        "    Polymer_C3_TOP_matrix,\n",
        "    linewidth=0.3,\n",
        "    annot=True,\n",
        "    fmt=\".2f\",\n",
        "    cmap=\"Blues\",\n",
        "    cbar_kws={\"label\": \"Similarity Score\"},\n",
        ")\n",
        "ax.set_title(r\"$S_{\\rm TOP}$\", fontsize=20)\n",
        "ax.set_xticklabels(x_labels, rotation=0, fontsize=15, horizontalalignment=\"center\")\n",
        "ax.set_yticklabels(y_labels, rotation=360, fontsize=15, horizontalalignment=\"right\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EwMscKpDyLED"
      },
      "source": [
        "## End Group Similarity,     $S_{\\rm EG}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 560
        },
        "id": "QyWxtuHhxq4q",
        "outputId": "85fbdafe-c9e7-4182-8b7d-1199ddfe9457"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots(figsize=(6, 6), sharey=True)\n",
        "\n",
        "x_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "y_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "\n",
        "sns.heatmap(\n",
        "    Polymer_C3_EG_matrix,\n",
        "    linewidth=0.3,\n",
        "    annot=True,\n",
        "    fmt=\".2f\",\n",
        "    cmap=\"Blues\",\n",
        "    cbar_kws={\"label\": \"Similarity Score\"},\n",
        ")\n",
        "ax.set_title(r\"$S_{\\rm EG}$\", fontsize=20)\n",
        "ax.set_xticklabels(x_labels, rotation=0, fontsize=15, horizontalalignment=\"center\")\n",
        "ax.set_yticklabels(y_labels, rotation=360, fontsize=15, horizontalalignment=\"right\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Pe1ealHoyMrq"
      },
      "source": [
        "## Overall Similarity,     $S_{\\rm OA}$"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 560
        },
        "id": "JbAgnupdxvOE",
        "outputId": "9822ec43-cf6e-4933-f5cd-0f7841f4182b"
      },
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 600x600 with 2 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ],
      "source": [
        "fig, ax = plt.subplots(figsize=(6, 6), sharey=True)\n",
        "\n",
        "x_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "y_labels = [\"C3-1\", \"C3-2\", \"C3-3\"]\n",
        "\n",
        "sns.heatmap(\n",
        "    Polymer_C3_OA_matrix,\n",
        "    linewidth=0.3,\n",
        "    annot=True,\n",
        "    fmt=\".2f\",\n",
        "    cmap=\"Blues\",\n",
        "    cbar_kws={\"label\": \"Similarity Score\"},\n",
        ")\n",
        "ax.set_title(r\"$S_{\\rm OA}$\", fontsize=20)\n",
        "ax.set_xticklabels(x_labels, rotation=0, fontsize=15, horizontalalignment=\"center\")\n",
        "ax.set_yticklabels(y_labels, rotation=360, fontsize=15, horizontalalignment=\"right\")\n",
        "\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 19,
      "metadata": {
        "id": "i8u6EwBlxydt"
      },
      "outputs": [],
      "source": []
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "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.9.7"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}