colab_notebooks/Protein_Metrics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "toc_visible": true,
      "authorship_tag": "ABX9TyM1pkRWND79sLDeeH9a5W4Y",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "accelerator": "GPU",
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/seanrjohnson/protein_scoring/blob/main/colab_notebooks/Protein_Metrics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "#Protein Metrics\n",
        "\n",
        "This notebook calculates various sequence- and structure-based quality scores for proteins, such as those produced by generative models. Many different kinds of metrics can be calculated. For all of the metrics, proteins with higher scores (closer to zero for negative numbers) are predicted to be more likely to fold and have function than proteins with lower scores.\n",
        "\n",
        "**inputs**: Please provide protein sequences in fasta format, AlphaFold2-predicted structures, and/or reference protein sequences in fasta format as appropriate (see sections below).\n",
        "\n",
        "**outputs**: A comma-separated values (csv) text file with the calculated metrics.\n"
      ],
      "metadata": {
        "id": "RzIc-rg5CHP9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Setup"
      ],
      "metadata": {
        "id": "LSWLh0lnAu36"
      }
    },
    {
      "cell_type": "code",
      "execution_count": null,
      "metadata": {
        "id": "tkjy0gbXI_Ji",
        "cellView": "form"
      },
      "outputs": [],
      "source": [
        "%%capture cap --no-stderr\n",
        "#@title 1. Install dependencies and set up directories\n",
        "\n",
        "# set up directories\n",
        "!rm -r sample_data\n",
        "!mkdir -p pdbs target_seqs reference_seqs\n",
        "\n",
        "!mkdir -p /opt/bin \n",
        "\n",
        "#install esm\n",
        "!pip -q install  git+https://github.com/facebookresearch/esm.git@e5e7b06b9a093706607c229ab1c5c9821806814d \n",
        "\n",
        "#install hmmer, mafft, emboss, biotite, and sequence-models\n",
        "!apt-get -qq update > /dev/null\n",
        "!apt-get -qq install  hmmer mafft emboss > /dev/null\n",
        "!pip -q install  biotite pytest-datadir sequence-models > /dev/null\n",
        "\n",
        "#install fasta3\n",
        "!wget https://github.com/wrpearson/fasta36/releases/download/v36.3.8i_14-Nov-2020/fasta-36.3.8i-linux64.tar.gz > /dev/null\n",
        "!tar xf fasta-36.3.8i-linux64.tar.gz > /dev/null\n",
        "!mv fasta-36.3.8i/bin/* /opt/bin \n",
        "!rm -r fasta*\n",
        "\n",
        "\n",
        "#install protein_gibbs_sampler\n",
        "!git clone https://github.com/seanrjohnson/protein_gibbs_sampler > /dev/null\n",
        "!cd protein_gibbs_sampler ; git checkout 7de11ff63f7dca3cb52ef84109152ac8f988b7a0 2>&1 > /dev/null ; yes | pip install -q --no-dependencies . > /dev/null\n",
        "!yes | pip -q install  biopython~=1.79 pytest-datadir~=1.4.1 > /dev/null\n",
        "\n",
        "\n",
        "#install ProteinMPNN\n",
        "!git clone https://github.com/dauparas/ProteinMPNN.git > /dev/null\n",
        "!cd ProteinMPNN ; git checkout 0a721279f6706478193f50dff9c1e5ff96214778 > /dev/null\n",
        "\n",
        "\n",
        "### FROM ESM-IF example notebook https://github.com/facebookresearch/esm/blob/e5e7b06b9a093706607c229ab1c5c9821806814d/examples/inverse_folding/notebook.ipynb\n",
        "import torch\n",
        "def format_pytorch_version(version):\n",
        "  return version.split('+')[0]\n",
        "\n",
        "TORCH_version = torch.__version__\n",
        "TORCH = format_pytorch_version(TORCH_version)\n",
        "\n",
        "def format_cuda_version(version):\n",
        "  return 'cu' + version.replace('.', '')\n",
        "\n",
        "CUDA_version = torch.version.cuda\n",
        "CUDA = format_cuda_version(CUDA_version)\n",
        "\n",
        "!pip install -q torch-scatter -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html > /dev/null\n",
        "!pip install -q torch-sparse -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html > /dev/null\n",
        "!pip install -q torch-cluster -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html > /dev/null\n",
        "!pip install -q torch-spline-conv -f https://data.pyg.org/whl/torch-{TORCH}+{CUDA}.html > /dev/null\n",
        "!pip install -q torch-geometric > /dev/null\n",
        "### END OF CODE FROM ESM-IF\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "#@title 2. Reset calculated metrics (creates a new datastructure to store results, clearing any existing results)\n",
        "\n",
        "results = dict()\n",
        "device = 'cuda:0'\n",
        "\n",
        "from google.colab import files\n",
        "import os\n",
        "import re\n",
        "import torch\n",
        "\n",
        "#from sequence_models.utils import parse_fasta\n",
        "from typing import List\n",
        "from pgen.utils import parse_fasta\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "from scipy.spatial.distance import pdist\n",
        "from pathlib import Path\n",
        "from glob import glob\n",
        "from random import randrange\n",
        "import esm\n",
        "from biotite.structure.io import pdb\n",
        "from biotite.structure import get_residue_count\n",
        "from biotite.structure.residues import get_residues\n",
        "from biotite.sequence import ProteinSequence\n",
        "import tempfile\n",
        "from Bio.Align import substitution_matrices\n",
        "import subprocess\n",
        "from dataclasses import dataclass\n",
        "\n",
        "from sequence_models.pretrained import load_model_and_alphabet\n",
        "from sequence_models.pdb_utils import parse_PDB, process_coords\n",
        "\n",
        "def residues_in_pdb(pdb_path):\n",
        "    with open(pdb_path) as f:\n",
        "        pdb_file = pdb.PDBFile.read(pdb_path)\n",
        "        atoms  = pdb_file.get_structure()\n",
        "    return get_residue_count(atoms)\n",
        "\n",
        "gap_open=10\n",
        "gap_extend=2\n",
        "\n",
        "def add_metric(metrics_dict, protein_name, metric_name, value):\n",
        "  if protein_name not in metrics_dict:\n",
        "    metrics_dict[protein_name] = dict()\n",
        "  metrics_dict[protein_name][metric_name] = value\n",
        "\n",
        "def get_pdb_sequence(pdb_path):\n",
        "    with open(pdb_path) as f:\n",
        "        pdb_file = pdb.PDBFile.read(pdb_path)\n",
        "        atoms  = pdb_file.get_structure()\n",
        "        residues = get_residues(atoms)[1]\n",
        "    return ''.join([ProteinSequence.convert_letter_3to1(r) for r in residues])\n",
        "\n",
        "with open(\"/tmp/PFASUM15.mat\", \"w\") as f:\n",
        "  f.write(\"\"\"    A   R   N   D   C   Q   E   G   H   I   L   K   M   F   P   S   T   W   Y   V   B   Z   J   X   *\n",
        "A   3  -1  -1  -1   0  -1   0   1  -1   0   0  -1  -1  -2   0   1   0  -2  -2   1  -7  -6  -6 -26  -6\n",
        "R  -1   6   1   0  -3   2   1  -1   0  -4  -3   4  -2  -4   0   0   1  -3  -3  -3  -5  -4 -10 -26  -6\n",
        "N  -1   1   6   3  -3   2   1   1   3  -5  -4   1  -1  -4   0   2   0  -5  -2  -4  -4  -4 -10 -26  -6\n",
        "D  -1   0   3   8  -3   1   3   0   1  -5  -5   1  -5  -5   0   1   0  -5  -4  -4  -3  -3 -11 -27  -6\n",
        "C   0  -3  -3  -3  16  -2  -1   0  -1   0   0  -4   2   1  -2   0   0   0  -2   1  -9  -7  -6 -26  -6\n",
        "Q  -1   2   2   1  -2   5   3   0   1  -4  -4   2  -2  -3  -1   1   1  -1  -3  -3  -5  -5 -10 -26  -6\n",
        "E   0   1   1   3  -1   3   6   0   1  -5  -4   3  -3  -6   0   0   0  -3  -3  -4  -4  -5 -10 -26  -6\n",
        "G   1  -1   1   0   0   0   0   9   0  -4  -4   0  -2  -3   0   1  -1  -2  -4  -3  -5  -6 -10 -27  -6\n",
        "H  -1   0   3   1  -1   1   1   0  10  -4  -3   1  -2  -1  -1   0   0   0   2  -2  -4  -5  -9 -26  -6\n",
        "I   0  -4  -5  -5   0  -4  -5  -4  -4   5   4  -4   3   3  -4  -3  -1  -1   0   5 -11 -10  -3 -26  -6\n",
        "L   0  -3  -4  -5   0  -4  -4  -4  -3   4   5  -4   2   3  -3  -3  -2   1   1   3 -10 -10  -5 -27  -6\n",
        "K  -1   4   1   1  -4   2   3   0   1  -4  -4   5  -2  -4   0   1   0  -4  -2  -4  -5  -3 -10 -26  -6\n",
        "M  -1  -2  -1  -5   2  -2  -3  -2  -2   3   2  -2   8   2  -2  -2   0   2   1   2  -9  -9  -4 -26  -6\n",
        "F  -2  -4  -4  -5   1  -3  -6  -3  -1   3   3  -4   2   8  -3  -4  -2   5   5   1 -11 -11  -3 -26  -6\n",
        "P   0   0   0   0  -2  -1   0   0  -1  -4  -3   0  -2  -3  12   0   0  -3  -2  -3  -6  -6 -10 -27  -6\n",
        "S   1   0   2   1   0   1   0   1   0  -3  -3   1  -2  -4   0   4   2  -3  -2  -2  -5  -5  -9 -26  -6\n",
        "T   0   1   0   0   0   1   0  -1   0  -1  -2   0   0  -2   0   2   3  -3  -1   0  -6  -6  -7 -26  -6\n",
        "W  -2  -3  -5  -5   0  -1  -3  -2   0  -1   1  -4   2   5  -3  -3  -3  20   6  -2 -11  -8  -6 -27  -6\n",
        "Y  -2  -3  -2  -4  -2  -3  -3  -4   2   0   1  -2   1   5  -2  -2  -1   6  10   0  -9  -9  -6 -26  -6\n",
        "V   1  -3  -4  -4   1  -3  -4  -3  -2   5   3  -4   2   1  -3  -2   0  -2   0   5 -10 -10  -2 -26  -6\n",
        "B  -7  -5  -4  -3  -9  -5  -4  -5  -4 -11 -10  -5  -9 -11  -6  -5  -6 -11  -9 -10  -5 -10 -17 -32  -6\n",
        "Z  -6  -4  -4  -3  -7  -5  -5  -6  -5 -10 -10  -3  -9 -11  -6  -5  -6  -8  -9 -10 -10  -6 -16 -32  -6\n",
        "J  -6 -10 -10 -11  -6 -10 -10 -10  -9  -3  -5 -10  -4  -3 -10  -9  -7  -6  -6  -2 -17 -16  -6 -33  -6\n",
        "X -26 -26 -26 -27 -26 -26 -26 -27 -26 -26 -27 -26 -26 -26 -27 -26 -26 -27 -26 -26 -32 -32 -33 -40  -6\n",
        "*  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6  -6   1\"\"\")\n",
        "\n",
        "with open(\"/tmp/BLOSUM62.mat\", \"w\") as f:\n",
        "  f.write(\"\"\"   A  R  N  D  C  Q  E  G  H  I  L  K  M  F  P  S  T  W  Y  V  B  Z  X  *\n",
        "A  4 -1 -2 -2  0 -1 -1  0 -2 -1 -1 -1 -1 -2 -1  1  0 -3 -2  0 -2 -1  0 -4 \n",
        "R -1  5  0 -2 -3  1  0 -2  0 -3 -2  2 -1 -3 -2 -1 -1 -3 -2 -3 -1  0 -1 -4 \n",
        "N -2  0  6  1 -3  0  0  0  1 -3 -3  0 -2 -3 -2  1  0 -4 -2 -3  3  0 -1 -4 \n",
        "D -2 -2  1  6 -3  0  2 -1 -1 -3 -4 -1 -3 -3 -1  0 -1 -4 -3 -3  4  1 -1 -4 \n",
        "C  0 -3 -3 -3  9 -3 -4 -3 -3 -1 -1 -3 -1 -2 -3 -1 -1 -2 -2 -1 -3 -3 -2 -4 \n",
        "Q -1  1  0  0 -3  5  2 -2  0 -3 -2  1  0 -3 -1  0 -1 -2 -1 -2  0  3 -1 -4 \n",
        "E -1  0  0  2 -4  2  5 -2  0 -3 -3  1 -2 -3 -1  0 -1 -3 -2 -2  1  4 -1 -4 \n",
        "G  0 -2  0 -1 -3 -2 -2  6 -2 -4 -4 -2 -3 -3 -2  0 -2 -2 -3 -3 -1 -2 -1 -4 \n",
        "H -2  0  1 -1 -3  0  0 -2  8 -3 -3 -1 -2 -1 -2 -1 -2 -2  2 -3  0  0 -1 -4 \n",
        "I -1 -3 -3 -3 -1 -3 -3 -4 -3  4  2 -3  1  0 -3 -2 -1 -3 -1  3 -3 -3 -1 -4 \n",
        "L -1 -2 -3 -4 -1 -2 -3 -4 -3  2  4 -2  2  0 -3 -2 -1 -2 -1  1 -4 -3 -1 -4 \n",
        "K -1  2  0 -1 -3  1  1 -2 -1 -3 -2  5 -1 -3 -1  0 -1 -3 -2 -2  0  1 -1 -4 \n",
        "M -1 -1 -2 -3 -1  0 -2 -3 -2  1  2 -1  5  0 -2 -1 -1 -1 -1  1 -3 -1 -1 -4 \n",
        "F -2 -3 -3 -3 -2 -3 -3 -3 -1  0  0 -3  0  6 -4 -2 -2  1  3 -1 -3 -3 -1 -4 \n",
        "P -1 -2 -2 -1 -3 -1 -1 -2 -2 -3 -3 -1 -2 -4  7 -1 -1 -4 -3 -2 -2 -1 -2 -4 \n",
        "S  1 -1  1  0 -1  0  0  0 -1 -2 -2  0 -1 -2 -1  4  1 -3 -2 -2  0  0  0 -4 \n",
        "T  0 -1  0 -1 -1 -1 -1 -2 -2 -1 -1 -1 -1 -2 -1  1  5 -2 -2  0 -1 -1  0 -4 \n",
        "W -3 -3 -4 -4 -2 -2 -3 -2 -2 -3 -2 -3 -1  1 -4 -3 -2 11  2 -3 -4 -3 -2 -4 \n",
        "Y -2 -2 -2 -3 -2 -1 -2 -3  2 -1 -1 -2 -1  3 -3 -2 -2  2  7 -1 -3 -2 -1 -4 \n",
        "V  0 -3 -3 -3 -1 -2 -2 -3 -3  3  1 -2  1 -1 -2 -2  0 -3 -1  4 -3 -2 -1 -4 \n",
        "B -2 -1  3  4 -3  0  1 -1  0 -3 -4  0 -3 -3 -2  0 -1 -4 -3 -3  4  1 -1 -4 \n",
        "Z -1  0  0  1 -3  3  4 -2  0 -3 -3  1 -1 -3 -1  0 -1 -3 -2 -2  1  4 -1 -4 \n",
        "X  0 -1 -1 -1 -2 -1 -1 -1 -1 -1 -1 -1 -1 -1 -2  0  0 -2 -1 -1 -1 -1 -1 -4 \n",
        "* -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4 -4  1\n",
        "\"\"\")\n",
        "\n",
        "with open(\"/tmp/extract_mif.py\", \"w\") as f:\n",
        "  f.write(\"\"\"import argparse\n",
        "\n",
        "import torch.cuda\n",
        "from tqdm import tqdm\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "\n",
        "from sequence_models.utils import parse_fasta\n",
        "from sequence_models.pretrained import load_model_and_alphabet\n",
        "from sequence_models.pdb_utils import parse_PDB, process_coords\n",
        "\n",
        "\n",
        "parser = argparse.ArgumentParser()\n",
        "parser.add_argument('model')\n",
        "parser.add_argument('tsv_fpath')\n",
        "parser.add_argument('out_dir')\n",
        "parser.add_argument('result')\n",
        "parser.add_argument('--include', nargs='*', default=['mean'])\n",
        "parser.add_argument('--device', default=None)\n",
        "args = parser.parse_args()\n",
        "\n",
        "# Check inputs\n",
        "if args.model not in ['mif', 'mifst']:\n",
        "    raise ValueError(\"Valid models ars 'mif' and 'mifst'.\")\n",
        "if args.result == 'logits':\n",
        "    for inc in args.include:\n",
        "        if inc not in ['per_tok', 'logp']:\n",
        "            raise ValueError(\"logits can be included as 'per_tok' or as 'logp'.\")\n",
        "elif args.result == 'repr':\n",
        "    for inc in args.include:\n",
        "        if inc not in ['per_tok', 'mean']:\n",
        "            raise ValueError(\"repr can be included as 'per_tok' or as 'mean'.\")\n",
        "else:\n",
        "    raise ValueError(\"Valid results ars 'repr' and 'logits'.\")\n",
        "\n",
        "# load model\n",
        "print('Loading model...')\n",
        "model, collater = load_model_and_alphabet(args.model)\n",
        "# detect device and move model to it\n",
        "if args.device is None:\n",
        "    if torch.cuda.is_available():\n",
        "        device = torch.device('cuda:0')\n",
        "    else:\n",
        "        device = torch.device('cpu')\n",
        "else:\n",
        "    device = torch.device(args.device)\n",
        "model = model.to(device)\n",
        "# load data\n",
        "print('Loading data...')\n",
        "df = pd.read_table(args.tsv_fpath).reset_index()\n",
        "if 'logp' in args.include:\n",
        "    logps = np.empty(len(df))\n",
        "with tqdm(total=len(df)) as pbar:\n",
        "    for i, row in df.iterrows():\n",
        "        seq = row['sequence']\n",
        "        pdb = row['pdb']\n",
        "        name = row['name']\n",
        "        coords, wt, _ = parse_PDB(pdb)\n",
        "        coords = {\n",
        "            'N': coords[:, 0],\n",
        "            'CA': coords[:, 1],\n",
        "            'C': coords[:, 2]\n",
        "        }\n",
        "        dist, omega, theta, phi = process_coords(coords)\n",
        "        batch = [[seq, torch.tensor(dist, dtype=torch.float),\n",
        "                  torch.tensor(omega, dtype=torch.float),\n",
        "                  torch.tensor(theta, dtype=torch.float), torch.tensor(phi, dtype=torch.float)]]\n",
        "        src, nodes, edges, connections, edge_mask = collater(batch)\n",
        "        src = src.to(device)\n",
        "        nodes = nodes.to(device)\n",
        "        edges = edges.to(device)\n",
        "        connections = connections.to(device)\n",
        "        edge_mask = edge_mask.to(device)\n",
        "        rep = model(src, nodes, edges, connections, edge_mask, result=args.result)[0]\n",
        "        if args.result == 'repr':\n",
        "            if 'mean' in args.include:\n",
        "                torch.save(rep.mean(dim=0).detach().cpu(),\n",
        "                           args.out_dir + '_'.join([name, args.model, 'mean']) + '.pt')\n",
        "            if 'per_tok' in args.include:\n",
        "                torch.save(rep.detach().cpu(),\n",
        "                           args.out_dir + '_'.join([name, args.model, 'per_tok']) + '.pt')\n",
        "        else:\n",
        "            if 'logp' in args.include:\n",
        "                rep = rep.log_softmax(dim=-1)\n",
        "                logps[i] = rep[torch.arange(len(src[0])), src].mean().detach().cpu().numpy()\n",
        "            if 'per_tok' in args.include:\n",
        "                torch.save(rep.detach().cpu(), args.out_dir + '_'.join([name, args.model, 'logits']) + '.pt')\n",
        "        pbar.update(1)\n",
        "    if 'logp' in args.include:\n",
        "        df['logp'] = logps\n",
        "        out_fpath = args.out_dir + args.model + '_logp.tsv'\n",
        "        print('Writing results to ' + out_fpath)\n",
        "        df = df.to_csv(out_fpath, index=False, sep=\"\\t\")\n",
        "  \"\"\")\n",
        "\n",
        "with open(\"/tmp/extract.py\", \"w\") as f:\n",
        "  f.write(\"\"\"import argparse\n",
        "\n",
        "import torch.cuda\n",
        "from tqdm import tqdm\n",
        "import numpy as np\n",
        "import pandas as pd\n",
        "\n",
        "from sequence_models.utils import parse_fasta\n",
        "from sequence_models.pretrained import load_model_and_alphabet\n",
        "\n",
        "parser = argparse.ArgumentParser()\n",
        "parser.add_argument('model')\n",
        "parser.add_argument('in_fpath')\n",
        "parser.add_argument('out_dir')\n",
        "parser.add_argument('--repr_layers', nargs='*', default=[-1])\n",
        "parser.add_argument('--include', nargs='*', default=['mean'])\n",
        "parser.add_argument('--device', default=None)\n",
        "parser.add_argument('--batchsize', default=1, type=int)\n",
        "args = parser.parse_args()\n",
        "\n",
        "# load model\n",
        "print('Loading model...')\n",
        "model, collater = load_model_and_alphabet(args.model)\n",
        "# detect device and move model to it\n",
        "if args.device is None:\n",
        "    if torch.cuda.is_available():\n",
        "        device = torch.device('cuda:0')\n",
        "    else:\n",
        "        device = torch.device('cpu')\n",
        "else:\n",
        "    device = torch.device(args.device)\n",
        "model = model.to(device)\n",
        "# load data\n",
        "print('Loading data...')\n",
        "seqs, names = parse_fasta(args.in_fpath, return_names=True)\n",
        "ells = [len(s) for s in seqs]\n",
        "seqs = [[s] for s in seqs]\n",
        "n_total = len(seqs)\n",
        "repr_layers = []\n",
        "for r in args.repr_layers:\n",
        "    if r == 'logits':\n",
        "        logits = True\n",
        "    else:\n",
        "        repr_layers.append(int(r))\n",
        "if 'logp' in args.include:\n",
        "    logps = np.empty(len(seqs))\n",
        "with tqdm(total=n_total) as pbar:\n",
        "    for i in range(0, n_total, args.batchsize):\n",
        "        start = i\n",
        "        end = start + args.batchsize\n",
        "        bs = seqs[start:end]\n",
        "        bn = names[start:end]\n",
        "        bl = ells[start:end]\n",
        "        # tokenize\n",
        "        x = collater(bs)[0].to(device)\n",
        "        # pass through the model\n",
        "        results = model(x, repr_layers=repr_layers, logits=logits)\n",
        "        if 'representations' in results:\n",
        "            for layer, rep in results['representations'].items():\n",
        "                for r, ell, name in zip(rep, bl, bn):\n",
        "                    r = r[:ell]\n",
        "                    if 'mean' in args.include:\n",
        "                        torch.save(r.mean(dim=0).detach().cpu(),\n",
        "                                   args.out_dir + '_'.join([name, args.model, str(layer), 'mean']) + '.pt')\n",
        "                    if 'per_tok' in args.include:\n",
        "                        torch.save(r.detach().cpu(),\n",
        "                                   args.out_dir + '_'.join([name, args.model, str(layer), 'per_tok']) + '.pt')\n",
        "        if logits:\n",
        "            rep = results['logits']\n",
        "            for r, ell, name, src in zip(rep, bl, bn, x):\n",
        "                if 'per_tok' in args.include:\n",
        "                    r = r[:ell]\n",
        "                    torch.save(r.detach().cpu(), args.out_dir + '_'.join([name, args.model, 'logits']) + '.pt')\n",
        "                if 'logp' in args.include:\n",
        "                    r = r.log_softmax(dim=-1)[:ell]\n",
        "                    # print(src.shape, r.shape)\n",
        "                    logps[i] = r[torch.arange(len(src)), src].mean().detach().cpu().numpy()\n",
        "        pbar.update(len(bs))\n",
        "    if 'logp' in args.include:\n",
        "        df = pd.DataFrame()\n",
        "        df['name'] = names\n",
        "        df['sequence'] = [s[0] for s in seqs]\n",
        "        df['logp'] = logps\n",
        "        out_fpath = args.out_dir + args.model + '_logp.tsv'\n",
        "        print('Writing results to ' + out_fpath)\n",
        "        df = df.to_csv(out_fpath, index=False, sep=\"\\t\")\n",
        "\"\"\")"
      ],
      "metadata": {
        "cellView": "form",
        "id": "nbLdSpLNtelA"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "### 3. Upload files\n",
        "\n",
        "Different files are required depending on which kinds of metrics you want to calculate.\n",
        "\n",
        "Please upload protein PDB files or protein fasta files to the appropriate directories in `/content`\n",
        "\n",
        "- Structures as PDB files (used for structure metrics). \n",
        "   - In this notebook we assume every strucure has a single chain, chain A.\n",
        "   - pLDDT score assumes that the scores are stored in the b-factor field of the PDB file, which is the case for PDB files generated by AlphaFold2.\n",
        "- Target sequences (used for single-sequence and alignment-based metrics)\n",
        "  - If the directory contains more than one fasta file, metrics will be calculated for all sequences from all files in the directory.\n",
        "- Reference sequences (used for alignment-based metrics)\n",
        "  - If the directory contains more than one fasta file, all of them will be used as reference sequences.\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "Mr-DKOrIHR3k"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Calculate Metrics"
      ],
      "metadata": {
        "id": "LlwTAVzWA-zp"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#@title ## Structure Metrics\n",
        "\n",
        "#@markdown Requires PDB uploaded files. All metrics will execute on all uploaded PDB files.\n",
        "\n",
        "#@markdown __ESM-IF, ProteinMPNN, MIF-ST__\n",
        "\n",
        "#@markdown The proteinMPNN and ESM-IF scores are the average log likelihood of the query residues. The ProteinMPNN score calculation is performed using the --score_only option of the protein_mpnn_run.py script from the ProteinMPNN repository (https://github.com/dauparas/ProteinMPNN). The ProteinMPNN score is multiplied by -1 so that higher is better, like with other metrics. The ESM-IF score is calculated using the esm.inverse_folding.util.score_sequence function from the ESM repository (https://github.com/facebookresearch/esm). The MIF-ST score is calculated using the extract_mif.py script from the Protein Sequence Models repository (https://github.com/microsoft/protein-sequence-models). \n",
        "\n",
        "#@markdown __AlphaFold2 pLDDT__\n",
        "\n",
        "#@markdown Average taken from the b-factors in AlphaFold2-produced pdb files.\n",
        "\n",
        "#@markdown \n",
        "\n",
        "#@markdown ### __Metrics__\n",
        "# CHECKBOXES\n",
        "ESM_IF = True #@param {type:\"boolean\"}\n",
        "ProteinMPNN = True #@param {type:\"boolean\"}\n",
        "MIF_ST = True #@param {type:\"boolean\"}\n",
        "AlphaFold2_pLDDT = True #@param {type:\"boolean\"}\n",
        "\n",
        "\n",
        "# ESM-IF\n",
        "if ESM_IF: #TODO: move to GPU? Maybe spin off into a subprocess when moving to GPU, to avoid memory leaks?\n",
        "  esm_if_model, esm_if_alphabet = esm.pretrained.esm_if1_gvp4_t16_142M_UR50()\n",
        "  # esm_if_model = esm_if_model.to(device) # TODO: for some reason it crashes when I move it to the GPU\n",
        "  esm_if_model.eval()\n",
        "        # with open(output[0],'w') as f:\n",
        "        #     f.write('id,esm-if\\n')\n",
        "  for pdb_file in glob(\"/content/pdbs/*.pdb\"):\n",
        "    fstem = Path(pdb_file).stem\n",
        "    name = fstem\n",
        "    coords, seq = esm.inverse_folding.util.load_coords(pdb_file, \"A\")\n",
        "    ll, _ = esm.inverse_folding.util.score_sequence(\n",
        "    esm_if_model, esm_if_alphabet, coords, str(seq))\n",
        "    add_metric(results, name, \"ESM-IF\", ll)\n",
        "  del esm_if_model\n",
        "  del esm_if_alphabet\n",
        "# ProteinMPNN\n",
        "if ProteinMPNN:\n",
        "  with tempfile.TemporaryDirectory() as output_dir:\n",
        "    for i, pdb_file in enumerate(glob(\"/content/pdbs/*.pdb\")):\n",
        "      command_line_arguments=[\n",
        "      \"python\",\n",
        "      \"ProteinMPNN/vanilla_proteinmpnn/protein_mpnn_run.py\",\n",
        "      \"--pdb_path\", pdb_file,\n",
        "      \"--pdb_path_chains\", \"A\",\n",
        "      \"--score_only\", \"1\",\n",
        "      \"--save_score\", \"1\",\n",
        "      \"--out_folder\", output_dir,\n",
        "      \"--batch_size\", \"1\"\n",
        "      ]\n",
        "      fstem = Path(pdb_file).stem\n",
        "      name = fstem\n",
        "      outfile = output_dir + f\"outfile_{i}.txt\"\n",
        "      with open(outfile,\"w\") as fh:\n",
        "        proc = subprocess.run(command_line_arguments, stdout=subprocess.PIPE, check=True)\n",
        "        print(proc.stdout.decode('utf-8'), file=fh)\n",
        "      with open(outfile,\"r\") as score_file_h:\n",
        "        score_file_lines = score_file_h.readlines()\n",
        "      score_line = score_file_lines[-2].split(\",\")\n",
        "      score_parts = score_line[1].strip().split(\": \")\n",
        "      assert score_parts[0] == \"mean\" \n",
        "      score = -1 * float(score_parts[1]) \n",
        "      add_metric(results, name, \"ProteinMPNN\", score)\n",
        " \n",
        " # MIF-ST\n",
        "\n",
        "if MIF_ST: \n",
        "  with tempfile.TemporaryDirectory() as output_dir:\n",
        "    spec_file_path = output_dir + \"/spec_file.tsv\"\n",
        "    with open(spec_file_path, 'w') as f:\n",
        "      f.write('name\\tsequence\\tpdb\\n')\n",
        "      for pdb_file in glob(\"/content/pdbs/*.pdb\"):\n",
        "        seq = get_pdb_sequence(pdb_file) \n",
        "        name = Path(pdb_file).stem\n",
        "        f.write(name + '\\t' + seq + '\\t' + pdb_file + '\\n')\n",
        "    #print(spec_file_path)\n",
        "    proc = subprocess.run(['python', \"/tmp/extract_mif.py\", \"mifst\", spec_file_path, output_dir + \"/\", \"logits\", \"--include\", \"logp\", \"--device\", device], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)\n",
        "    # print(proc.stderr.decode(\"utf-8\"))\n",
        "    # print(proc.stdout.decode(\"utf-8\"))\n",
        "    df = pd.read_table(output_dir + '/mifst_logp.tsv')\n",
        "    df = df.rename(columns={'name': 'id', 'logp': 'mifst_logp'}, )\n",
        "    for _, row in df.iterrows():\n",
        "      add_metric(results, row[\"id\"], \"MIF-ST\", row[\"mifst_logp\"])\n",
        "\n",
        "\n",
        "  \n",
        "# pLDDT\n",
        "if AlphaFold2_pLDDT:\n",
        "  for pdb_file in glob(\"/content/pdbs/*.pdb\"):\n",
        "    fstem = Path(pdb_file).stem\n",
        "    name = fstem\n",
        "    pdb_file = pdb.PDBFile.read(pdb_file)\n",
        "    atoms = pdb_file.get_structure(extra_fields = ['b_factor'])\n",
        "    prev_residue = -1\n",
        "    plddt_sum = 0\n",
        "    residue_count = 0\n",
        "    for a in atoms[0]:\n",
        "      if a.res_id != prev_residue:\n",
        "        prev_residue = a.res_id\n",
        "        residue_count += 1\n",
        "        plddt_sum += a.b_factor\n",
        "    add_metric(results, name, \"AlphaFold2 pLDDT\", plddt_sum/residue_count)\n"
      ],
      "metadata": {
        "id": "6d-D639O-iyM",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Single-sequence metrics\n",
        "\n",
        "#@markdown This might take a while the first execution because it needs to download the ESM-1v weights.\n",
        "\n",
        "#@markdown __ESM-1v, ESM-1v mask6, CARP-640m__\n",
        "\n",
        "#@markdown Scores calculated from the ESM-1v and CARP-640M models are the average of the log probabilities of the amino acid in each position. Without masking, this calculation can be done with a single forward pass over each sequence. With partial masking, it can be done in a number of passes equal to 1 / masked_fraction. At the most extreme each position could be masked one at a time. We found that masking in six passes, with the masked positions at a regular interval that shifts on every pass gave scores nearly equivalent to masking one position at a time. Furthermore, when no masking was applied, the scores were shifted towards zero but still strongly correlated with the masked scores. Therefore, we used ESM-1v and CARP-640M scores calculated in one pass without any masking.\n",
        "\n",
        "#@markdown __repeat 1, 2, 3, 4__\n",
        "\n",
        "#@markdown Scores are calculated for the longest single amino acid repeat, the longest 2-mer, 3-mer, and 4-mer repeat in each sequence. The score is calculated as -1 * the number of repeat units. So the sequence MAAAAAAI has a single amino acid repeat score of -6, a 2-mer score of -3, a 3-mer score of -2, and a 4-mer score of -1.\n",
        "\n",
        "#@markdown ### __Metrics__\n",
        "# CHECKBOXES\n",
        "CARP_640m_logp = True #@param {type:\"boolean\"}\n",
        "ESM_1v = True #@param {type:\"boolean\"}\n",
        "ESM_1v_mask6 = True #@param {type:\"boolean\"}\n",
        "repeat_1 = True #@param {type:\"boolean\"}\n",
        "repeat_2 = True #@param {type:\"boolean\"}\n",
        "repeat_3 = True #@param {type:\"boolean\"}\n",
        "repeat_4 = True #@param {type:\"boolean\"}\n",
        "\n",
        "target_seqs_file = \"/tmp/target_seqs.fasta\"\n",
        "with open(target_seqs_file,\"w\") as fh:\n",
        "  for target_fasta in glob(\"/content/target_seqs/*\"):\n",
        "    for name, seq in zip(*parse_fasta(target_fasta, return_names=True, clean=\"unalign\")):\n",
        "      print(f\">{name}\\n{seq}\", file=fh)\n",
        "\n",
        "#CARP\n",
        "if CARP_640m_logp: \n",
        "  with tempfile.TemporaryDirectory() as output_dir:\n",
        "    proc = subprocess.run(['python', \"/tmp/extract.py\", \"carp_640M\", \"/tmp/target_seqs.fasta\", output_dir + \"/\", \"--repr_layers\", \"logits\", \"--include\", \"logp\", \"--device\", device], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)\n",
        "    # print(proc.stderr)\n",
        "    # print(proc.stdout)\n",
        "    df = pd.read_table(output_dir + '/carp_640M_logp.tsv')\n",
        "    df = df.rename(columns={'name': 'id', 'logp': 'carp640m_logp'},)\n",
        "    for _, row in df.iterrows():\n",
        "      add_metric(results, row[\"id\"], \"CARP-640m\", row[\"carp640m_logp\"])\n",
        "\n",
        "\n",
        "# ESM1v (unmasked)\n",
        "if ESM_1v: #TODO: allow other devices?\n",
        "  if device=='cuda:0':\n",
        "    torch.cuda.empty_cache()\n",
        "  for targets_fasta in glob(\"/content/target_seqs/*\"):\n",
        "    with tempfile.TemporaryDirectory() as output_dir:\n",
        "      outfile = output_dir + \"/esm_results.tsv\"\n",
        "      proc = subprocess.run(['python', \"protein_gibbs_sampler/src/pgen/likelihood_esm.py\", \"-i\", targets_fasta, \"-o\", outfile, \"--model\", \"esm1v\", \"--masking_off\", \"--score_name\", \"score\", \"--device\", \"gpu\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)\n",
        "      # print(proc.stdout)\n",
        "      # print(proc.stderr)\n",
        "      df = pd.read_table(outfile)\n",
        "      for i, row in df.iterrows():\n",
        "        add_metric(results, row[\"id\"], \"ESM-1v\", row[\"score\"])\n",
        "      del df\n",
        "\n",
        "# ESM1v mask 6\n",
        "if ESM_1v_mask6: #TODO: allow other devices?\n",
        "  if device=='cuda:0':\n",
        "    torch.cuda.empty_cache()\n",
        "  for targets_fasta in glob(\"/content/target_seqs/*\"):\n",
        "    with tempfile.TemporaryDirectory() as output_dir:\n",
        "      outfile = output_dir + \"/esm_results.tsv\"\n",
        "      proc = subprocess.run(['python', \"protein_gibbs_sampler/src/pgen/likelihood_esm.py\", \"-i\", targets_fasta, \"-o\", outfile, \"--model\", \"esm1v\", \"--mask_distance\", \"6\", \"--score_name\", \"score\", \"--device\", \"gpu\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)\n",
        "      # print(proc.stdout)\n",
        "      # print(proc.stderr)\n",
        "      df = pd.read_table(outfile)\n",
        "      for i, row in df.iterrows():\n",
        "        add_metric(results, row[\"id\"], \"ESM-1v mask6\", row[\"score\"])\n",
        "      del df\n",
        "\n",
        "# repeat\n",
        "def find_longest_repeat(seq, k):\n",
        "  longest = [1] * len(seq)\n",
        "  pattern = [None] * len(seq)\n",
        "  \n",
        "  seq_len = len(seq)\n",
        "  for i in range(seq_len):\n",
        "    if i + k <= seq_len:\n",
        "      pattern[i] = seq[i:i+k]\n",
        "    if i - k >= 0:\n",
        "      if pattern[i-k] == pattern[i]:\n",
        "        longest[i] = longest[i-k] + 1\n",
        "  return -1 * max(longest)\n",
        "\n",
        "repeat_ks = list()\n",
        "if repeat_1:\n",
        "  repeat_ks.append(1)\n",
        "if repeat_2:\n",
        "  repeat_ks.append(2)\n",
        "if repeat_3:\n",
        "  repeat_ks.append(3)\n",
        "if repeat_4:\n",
        "  repeat_ks.append(4)\n",
        "\n",
        "for k in repeat_ks:\n",
        "  for targets_fasta in glob(\"/content/target_seqs/*\"):\n",
        "    for name, seq in zip(*parse_fasta(targets_fasta, return_names=True, clean=\"unalign\")):\n",
        "      score = find_longest_repeat(seq, k)\n",
        "      add_metric(results, name, f\"longest_repeat_{k}\", score)\n",
        "\n"
      ],
      "metadata": {
        "id": "IwJ-zDe7HFad",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Alignment-based metrics\n",
        "\n",
        "## Alignment-based methods\n",
        "\n",
        "#@markdown __ESM-MSA__\n",
        "\n",
        "#@markdown Calculated by using pHMMER to find the 31 closest training sequences to each query, aligning the 32 sequences with MAFFT, and calculating the average log probabilities from six passes with a masking interval of six.\n",
        "\n",
        "#@markdown __Identity to closest reference__\n",
        "\n",
        "#@markdown The most similar training sequence was found using ggsearch36 from the FASTA3 package, the BLOSUM62 scoring matrix, a gap open penalty of 10 and a gap extend penalty of 2. The hamming distance is then calculated from the gapped alignment between the query and the top hit sequences. Identity is calculated as 1 - hamming_distance.\n",
        "\n",
        "#@markdown __Subtitution matix (BLOSUM62 or PFASUM15) score mean of mutated positions__\n",
        "#@markdown The closest training sequence was found by FASTA3 ggsearch36. From the alignment to the closest training sequence, the mean BLOSUM62 score across all mismatched positions was calculated, ignoring positions where either query or reference had a gap.\n",
        "\n",
        "#@markdown\n",
        "\n",
        "#@markdown ### __Metrics__\n",
        "\n",
        "#@markdown Select a substitution model\n",
        "\n",
        "substitution_matrix = \"BLOSUM62\" #@param [\"BLOSUM62\", \"PFASUM15\"]\n",
        "\n",
        "# CHECKBOXES\n",
        "ESM_MSA = True #@param {type:\"boolean\"}\n",
        "Subtitution_matix_score_mean_of_mutated_positions = True #@param {type:\"boolean\"}\n",
        "Identity_to_closest_reference = True #@param {type:\"boolean\"}\n",
        "\n",
        "substitution_matrix_file = f'/tmp/{substitution_matrix}.mat'\n",
        "\n",
        "#concatenate reference sequences\n",
        "reference_seqs_file = \"/tmp/reference_seqs.fasta\"\n",
        "with open(reference_seqs_file,\"w\") as fh:\n",
        "  for reference_fasta in glob(\"/content/reference_seqs/*\"):\n",
        "    for name, seq in zip(*parse_fasta(reference_fasta, return_names=True, clean=\"unalign\")):\n",
        "      print(f\">{name}\\n{seq}\", file=fh)\n",
        "\n",
        "target_seqs_file = \"/tmp/target_seqs.fasta\"\n",
        "with open(target_seqs_file,\"w\") as fh:\n",
        "  for target_fasta in glob(\"/content/target_seqs/*\"):\n",
        "    for name, seq in zip(*parse_fasta(target_fasta, return_names=True, clean=\"unalign\")):\n",
        "      print(f\">{name}\\n{seq}\", file=fh)\n",
        "\n",
        "# ESM-MSA\n",
        "if ESM_MSA:\n",
        "  with tempfile.TemporaryDirectory() as output_dir:\n",
        "    outfile = output_dir + \"/esm_results.tsv\"\n",
        "    proc = subprocess.run(['python', \"protein_gibbs_sampler/src/pgen/likelihood_esm_msa.py\", \"-i\", target_seqs_file, \"-o\", outfile, \"--reference_msa\", reference_seqs_file, \"--subset_strategy\", \"top_hits\", \"--alignment_size\", \"31\", \"--count_gaps\", \"--mask_distance\", \"6\", \"--device\", \"gpu\"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)\n",
        "    # print(proc.stdout)\n",
        "    # print(proc.stderr)\n",
        "    df = pd.read_table(outfile)\n",
        "    for i, row in df.iterrows():\n",
        "      add_metric(results, row[\"id\"], \"ESM-MSA\", row[\"esm-msa\"])\n",
        "    del df\n",
        "\n",
        "# substitution score\n",
        "if Subtitution_matix_score_mean_of_mutated_positions or Identity_to_closest_reference:\n",
        "  #SEARCH #/tmp/mat.mat\n",
        "  search_results_file = f\"/tmp/ggsearch_results_{substitution_matrix}.txt\"\n",
        "  with open(search_results_file,\"w\") as fh:\n",
        "    proc = subprocess.run(['ggsearch36', '-f', str(gap_open), '-g', str(gap_extend), '-s', substitution_matrix_file, '-b,' '1', target_seqs_file, reference_seqs_file], stdout=subprocess.PIPE, check=True)\n",
        "    print(proc.stdout.decode('utf-8'), file=fh)\n",
        "  \n",
        "  df = pd.read_csv(substitution_matrix_file, delimiter=r\"\\s+\")\n",
        "  blosum62 = {}\n",
        "  for aa1 in df.columns:\n",
        "    for aa2 in df.index:\n",
        "      blosum62[(aa1, aa2)] = df.loc[aa1, aa2]\n",
        "  i = np.random.randint(100000)\n",
        "  n_train, s_train = parse_fasta(reference_seqs_file,return_names=True)\n",
        "  n_query,s_query = parse_fasta(target_seqs_file,return_names=True)\n",
        "  n_query = [nq.strip() for nq in n_query]\n",
        "  train_seqs = {nt: st for st, nt in zip(s_train,n_train)}\n",
        "  query_seqs = {nq: sq for sq, nq in zip(s_query,n_query)}\n",
        "\n",
        "  # with open(output[0],'w') as f: # ell is the number of non-gaps in the query sequence.\n",
        "      # f.write(f'id,{substitution_matrix},{substitution_matrix}_n_aligned,{substitution_matrix}_ell,{substitution_matrix}_mut_mean,{substitution_matrix}_n_mut,{substitution_matrix}_worst,closest\\n')\n",
        "  \n",
        "\n",
        "  with open(search_results_file) as f:\n",
        "    lines = f.readlines()\n",
        "  train_coming = False\n",
        "  qns = [] #query names\n",
        "  tns = [] #target names\n",
        "  for i, line in enumerate(lines):\n",
        "    if '!! No sequences' in line:\n",
        "      tns.append(None)\n",
        "\n",
        "    if not train_coming:\n",
        "      if 'The best scores are:' in line:\n",
        "        train_coming = True\n",
        "    else:\n",
        "      tns.append(line.split()[0])\n",
        "      train_coming = False\n",
        "    if 'Library: ' in line:\n",
        "      qns.append(lines[i - 1].split('>')[-1].split()[0])\n",
        "  for qn, tn in zip(qns,tns):\n",
        "    if tn is None: #No hits found\n",
        "      average_score = str(0) #TODO: I'm not sure what sensible defaults for any of these are\n",
        "      n_aligned = 0\n",
        "      mutant_score = 0\n",
        "      worst_score = 0\n",
        "      ell = sum([s != '-' for s in query_seqs[qn]]) # just the length of the query sequence.\n",
        "      tn=\"\"\n",
        "      identity = 0\n",
        "    else:\n",
        "      # write a temporary fasta file\n",
        "      with tempfile.TemporaryDirectory() as output_dir:\n",
        "\n",
        "        pairwise_target_fasta = output_dir + '/a_sequence.fasta'\n",
        "        pairwise_query_fasta = output_dir + '/b_sequence.fasta'\n",
        "        pairwise_result_file = output_dir + '/pairwise_result.fasta'\n",
        "        with open(pairwise_target_fasta,'w') as f:\n",
        "          f.write('>' + tn + '\\n' + train_seqs[tn] + '\\n')\n",
        "        with open(pairwise_query_fasta,'w') as f:\n",
        "          f.write('>' + qn + '\\n' + query_seqs[qn] + '\\n')\n",
        "        subprocess.run([\"needle\", \"-gapopen\", str(gap_open), \"-gapextend\", str(gap_extend), \"-datafile\", substitution_matrix_file, pairwise_target_fasta, pairwise_query_fasta, '-aformat', 'fasta', '-outfile', pairwise_result_file], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, check=True)\n",
        "        # score it\n",
        "        seqs = parse_fasta(pairwise_result_file)\n",
        "        global_score = 0\n",
        "        mutant_score = 0\n",
        "        worst_score = np.inf\n",
        "        n_mutants = 0\n",
        "        n_aligned = 0\n",
        "        #print(seqs)\n",
        "        seqs_array = np.array([[ord(ss) for ss in list(s)] for s in seqs])\n",
        "        dist = pdist(seqs_array, metric='hamming')[0]\n",
        "        identity = 1.0 - dist\n",
        "        for aa1, aa2 in zip(*seqs):\n",
        "          if '-' in aa1 + aa2:\n",
        "            continue\n",
        "          score = blosum62[(aa1, aa2)]\n",
        "          global_score += score\n",
        "          n_aligned += 1\n",
        "          if aa1 != aa2:\n",
        "            mutant_score += score\n",
        "            n_mutants += 1\n",
        "            if score < worst_score:\n",
        "                worst_score = score\n",
        "        if n_mutants > 0:\n",
        "          mutant_score /= n_mutants\n",
        "        ell = sum([s != '-' for s in seqs[1]]) # ell is the number of non-gaps in the query sequence.\n",
        "        if n_aligned == 0: #TODO: same here, are these defaults sensible?\n",
        "          mutant_score = 0\n",
        "          worst_score = 0\n",
        "          average_score = str(0)\n",
        "          tn=\"\"\n",
        "        else:\n",
        "          average_score = str(global_score / n_aligned)\n",
        "    add_metric(results, qn, f\"Closest training sequence ({substitution_matrix})\", tn)\n",
        "    if Subtitution_matix_score_mean_of_mutated_positions:\n",
        "      add_metric(results, qn, substitution_matrix, mutant_score)\n",
        "    if Identity_to_closest_reference:      \n",
        "      add_metric(results, qn, \"Identity\", identity)\n",
        "\n"
      ],
      "metadata": {
        "id": "Qm-jJapHpBqj",
        "cellView": "form"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "#@title Download results\n",
        "# OPTION FOR \n",
        "df = pd.DataFrame.from_dict(results, orient=\"index\")\n",
        "df.to_csv(f\"/tmp/calculated_metrics.csv\")\n",
        "\n",
        "files.download(f\"/tmp/calculated_metrics.csv\")"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 17
        },
        "cellView": "form",
        "id": "ZNLh4J1H8h4J",
        "outputId": "f7246485-e283-4485-8343-252553e5fb21"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "\n",
              "    async function download(id, filename, size) {\n",
              "      if (!google.colab.kernel.accessAllowed) {\n",
              "        return;\n",
              "      }\n",
              "      const div = document.createElement('div');\n",
              "      const label = document.createElement('label');\n",
              "      label.textContent = `Downloading \"${filename}\": `;\n",
              "      div.appendChild(label);\n",
              "      const progress = document.createElement('progress');\n",
              "      progress.max = size;\n",
              "      div.appendChild(progress);\n",
              "      document.body.appendChild(div);\n",
              "\n",
              "      const buffers = [];\n",
              "      let downloaded = 0;\n",
              "\n",
              "      const channel = await google.colab.kernel.comms.open(id);\n",
              "      // Send a message to notify the kernel that we're ready.\n",
              "      channel.send({})\n",
              "\n",
              "      for await (const message of channel.messages) {\n",
              "        // Send a message to notify the kernel that we're ready.\n",
              "        channel.send({})\n",
              "        if (message.buffers) {\n",
              "          for (const buffer of message.buffers) {\n",
              "            buffers.push(buffer);\n",
              "            downloaded += buffer.byteLength;\n",
              "            progress.value = downloaded;\n",
              "          }\n",
              "        }\n",
              "      }\n",
              "      const blob = new Blob(buffers, {type: 'application/binary'});\n",
              "      const a = document.createElement('a');\n",
              "      a.href = window.URL.createObjectURL(blob);\n",
              "      a.download = filename;\n",
              "      div.appendChild(a);\n",
              "      a.click();\n",
              "      div.remove();\n",
              "    }\n",
              "  "
            ]
          },
          "metadata": {}
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<IPython.core.display.Javascript object>"
            ],
            "application/javascript": [
              "download(\"download_e6c32fec-10c9-4496-8f91-332029225fc6\", \"calculated_metrics.csv\", 735)"
            ]
          },
          "metadata": {}
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "### Missing metrics\n",
        "Phobius and Rosetta are discussed in the paper, but not available here because of licensing issues."
      ],
      "metadata": {
        "id": "sZ5vnK82W9I9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# References\n",
        "\n",
        "### Metrics manuscript\n",
        "TBA\n",
        "\n",
        "### BLOSUM62\n",
        "Henikoff, S, and J G Henikoff. “Amino Acid Substitution Matrices from Protein Blocks.” Proceedings of the National Academy of Sciences of the United States of America 89, no. 22 (November 15, 1992): 10915–19.\n",
        "\n",
        "### PFASUM15\n",
        "Keul, Frank, Martin Hess, Michael Goesele, and Kay Hamacher. “PFASUM: A Substitution Matrix from Pfam Structural Alignments.” BMC Bioinformatics 18, no. 1 (June 5, 2017): 293. https://doi.org/10.1186/s12859-017-1703-z.\n",
        "\n",
        "### ESM-IF\n",
        "Hsu, Chloe, Robert Verkuil, Jason Liu, Zeming Lin, Brian Hie, Tom Sercu, Adam Lerer, and Alexander Rives. “Learning Inverse Folding from Millions of Predicted Structures.” bioRxiv, April 10, 2022. https://doi.org/10.1101/2022.04.10.487779.\n",
        "\n",
        "### ESM-MSA\n",
        "Rao, Roshan M., Jason Liu, Robert Verkuil, Joshua Meier, John Canny, Pieter Abbeel, Tom Sercu, and Alexander Rives. “MSA Transformer.” BioRxiv, February 13, 2021, 2021.02.12.430858. https://doi.org/10.1101/2021.02.12.430858.\n",
        "\n",
        "### ProteinMPNN\n",
        "Dauparas, Justas, Ivan Anishchenko, Nathaniel Bennett, Hua Bai, Robert J. Ragotte, Lukas F. Milles, Basile I. M. Wicky, et al. “Robust Deep Learning Based Protein Sequence Design Using ProteinMPNN.” bioRxiv, June 4, 2022. https://doi.org/10.1101/2022.06.03.494563.\n",
        "\n",
        "### MIF-ST\n",
        "Yang, Kevin K., Hugh Yeh, and Niccolò Zanichelli. “Masked Inverse Folding with Sequence Transfer for Protein Representation Learning.” bioRxiv, May 28, 2022. https://doi.org/10.1101/2022.05.25.493516.\n",
        "\n",
        "### CARP-640M\n",
        "Yang, Kevin K., Alex X. Lu, and Nicolo K. Fusi. “Convolutions Are Competitive with Transformers for Protein Sequence Pretraining.” bioRxiv, May 20, 2022. https://doi.org/10.1101/2022.05.19.492714.\n"
      ],
      "metadata": {
        "id": "jBbdWuMrZDje"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Troubleshooting\n",
        "\n",
        "This notebook expects to be run on a GPU instance. Depending on what kind of GPU you get, some of the metrics, such as ESM-1v may crash on large sequences. We tested the notebook on CuSOD proteins (150-250 aa) on a Tesla T4 GPU (16 Gb).\n",
        "\n",
        "![image.png](data:image/png;base64,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)\n",
        "\n",
        "![image.png](data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAXsAAAEcCAYAAAAmzxTpAAAAAXNSR0IArs4c6QAAAARnQU1BAACxjwv8YQUAAAAJcEhZcwAADsMAAA7DAcdvqGQAAEYoSURBVHhe7Z0HeBXF14dPEtIgFAFF6V1AOioqoBQFK0Wx8FnBCiJFFLFQFDt/BVRQVARUioiooAiISrGA0hSw0HvvJQkJSb59T+7GyzWVBEjY8z7Z5967Ozs7Mzv7O2fOTO4NSnIQwzAM44wm2PdqGIZhnMGY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA9gYm8YhuEBTOwNwzA8gIm9YRiGBzCxN06YtWvXypdffin79u3z7TEMI7fiGbGPiYmRHj16SMWKFeXTTz/17T31+Jfj1Vdf9e3Nexw8eFAGDBggPXv2lFGjRvn2GoaRW8m22COcCNell14qy5cv9+09HkQtu+KWE3kYaZNW+6ZlJPPnzy8NGzaUAgUK6DHDMHI3OebZ79ixQ9566y05dOiQb49xJpMvXz55+OGHZdmyZdK2bVvfXsMwcis5GsaZOXOmfPPNN2K/dGgYhpG7yPGY/YgRI3TiLjNgFH777Te59957pXr16lK1alW5/fbbZd68eZKYmKhpFixYoGGCd955Rz/zGhhuIB9CSF26dNF82O6++275+eefUzU8cXFxMnbsWGnUqJHm1bp1a5k7d+5/0mamfP6sWrVKunfvLvXq1UvJd+rUqXq9jODcFi1a6Hmvv/56uufExsbKBx98kJKe6z311FOyceNGX4p/iY6OPi7tFVdcIYMHD06ZVE2vfQnbXHDBBTJlyhQ99sQTT+gx9qcW3vHf98knn8j06dO1DfjM9SdPnizHjh3TtC67d++WgQMHah1oY9qP0cKNN94oTZo0kdWrV/tSipaZshM+Ik9e+UwehmGkT46JfalSpeSiiy6SdevWqeDz4KcHQvrZZ5+peP7www9y9OhRFYJffvlFxXX06NH6OTw8XOrUqSNnn322nscrnwsXLqyfyefzzz+Xm2++WcWFfNgQ5HvuuUevESjiL7/8svTt21e2bdumnzEU9913n45KXDJbPhcMyy233KLifuDAAd1HvojXK6+8km577Ny5U/r166dth8g9+OCDEhYW5jt6PEeOHJFnnnlGnn/+edm7d6/UqlVL006YMEHbYOnSpb6Uyfl27txZ05I3bNq0Sd588001jBxPr32Jx5O/29ZlypTRY+zPiPfff1+6deuWMo/D9fv06aOjPxeu/8gjj+gEL21GG9N+t91223/mf0hLmSk7UC4MIp+5z9TLMIy0yTGxRyTw6ipUqCBffPGFCmR6rFixQl577TV9j/jiwbGxDwHiIcbDq1u3ror5TTfdpGl55TOCCGvWrFHvLiIiQgWYz+RDnvDRRx+pUPhzzjnnqKiQFlHp2LGjCjfe/v79+zVNZssHGI2XXnpJBatr167y999/a97jxo2TEiVKaBnSag/EGy8aDxtPtXfv3umKKeXF08bjpg4sffz+++/VSOzatUsmTpwo8fHxWp+PP/5YjR4x9T/++ENHXD/99JNeh+shvOm177XXXqtGhNEAUDeOsT8jGPmQlnbg2tdff72W6ccff9TyYUwZEVAO+oz//bjjjjuOM6QwZ84cTXvVVVdpuan3jBkztC5//vmnnm8YRtrkaBjn/PPPV5HgQX377bdTPOfUIGzCpG67du1UjIKDg3W77rrrVEwQzlmzZv3HKw8EMduyZYvmcdlll0lQUJDm07JlS/VCEeT169f7Uidz//33q1iSllUlHTp00JEJouSmzUr58KYxDqxI6tSpk3ra5I0QucKFQAV693im7733noY3ELznnntODVF64M2TX6FChSQqKkr3YRwYQWBUqAvXJrSBEShWrJiORNy05513no5AYOHChRmOwE4U/zbm2oRkYM+ePVpvJvIRb8DY+t+P9u3bazn9wZBBkSJFJDIyUt/TVs8++6zW+8orr9R9hmGkTo6KPQ/rNddco0KL+OFZBnpogMCsXLlS3xOr9Q9Z8P7CCy/U9wzN0xMjPERi3TBmzBiNqRPLZatfv74sWrRIjwXGskNCQnzvkilevLice+656mUTbshq+VwPv2bNmikhD6A93LTkS/zcn/Hjx8vw4cP1PSGOKlWq6Pv0qFGjhqYjnIQXPnToUDU2lJ85CMIbrJTZvn27bNiwQcX1hhtuSGkXtl69emletAvx/5NBYBu7INqIPeXi+hgq2s0f2g3D6g+GlLZlNIAxYB6Ce099qDf33jCMtMlRsYeCBQuqd8+D+eGHH2osOz3SEgXYvHmzxnHTAkPiCqgbT05tyyjGTFgGzx4CjVNWykdahCo18MgD/9MUQ+Fe79tvv03XsLmUK1dORwNXX321GhvEnhDOxRdfrJOrrnhTLowXdcNrTq1dSpcunWZ5TzYJCQm64am7o470INyEQXf/n4N5iFatWmmIKbWJX8MwjifHxR54MBF8xIbJWkQxLXjg06Js2bIai88MiB8PPXHiwC2jGDMjBMQY8Ir9yUr5SJtW2Ik5DUIq/iDEhDAwNMxzfP311xmGrYDrMiL49ddf1aASlkHkif2/++67xwlf0aJFdXVPau3yxhtvqNieDjCMbJQ7PYPuglGqXbu2jhYZ1VBPRpCMFBgVuSuGDMNInZMi9jyYrAzBC+PB/Oqrr3xHkiHmimDBkiVLjltmyHtiyYAIpif25OMO3/H23FUwLq73GMjhw4d975JhApcwCyMAYudZLZ8bfgksA8Ltpk3NcN11113y9NNP64oUBJp5DiaB0wKjNGnSJBkyZIjGuxHqxo0b6wSyuxSVOQzqV7JkSalcubLOmzBhHAh5nU4wfLQJ4RwmWP2h3fyXtuI0ELah3rQPk97E6Gkv5ipoO0aQmTEahuFVTorYAw8z3n1aIZRmzZppqGfatGnq0fJws7FqhclMjvFAu2EG1+NmRYn/f+k2b95cH36MCg+/G9YhDQL4wgsvqFj4g3e4ePFiFRXSEztnkhfPsXz58pomK+VjfsCNo5MXBoG8MRSMNig7Xqg7seiCZ+tO+hJXx+AwEgosr0toaKgaJjxy0iGUQLncCUwMECMGJjjdVTSIpFtf0mKAmMjlfwhc0mpfyucew2jkVLiEcB8T6kD4iTkeysdqKFZF+U/uM0+CyFNvVly5oSoMlrvGnj7gP7diGMbxnDSxBx5mvNfUINSDV4s3xoRhgwYNdJ0+68IRO7xdJhtdOI7oILTEm11PlhVAnM8xYtnky4QdafiMeCAi/iCYTPJVqlRJJwdZ5835rKl3wxpZKR9x9P79+6sBGDRokF6bunMNBPzOO+9U45EWGES+egChJhyR3n8hkyerfGbPnq3Gpk2bNhq7JobN9QnpYFSoDytiSEsZOI/JYupBGpY5MkfgXiet9sVw0BZAOzGScv+JKjtgJJlrcMuHseN+YDjJn7K4YOQIdzHqwphixFglxTJM4vjsZ8WU6xgYhvFfTqrY88Cy9JAJwkB4MFlNgqfGsjy8NTxKQj8jR47Uf5Txf+ARcGKzCBr73RGDmw8eNB4y+/EKEXEE68UXX/zPBCCCzH9tIhJAWv4JiJVELlktH+KOR0oZCNewbJN8mUDlP08DvfpAGBnwj114zpzjrjIKhOWGXJ9/rCIez0ogvFuuyxJEyufin7ZatWopE8T809LEiRPl8ssvTxHItNoXEFYMB8LPll5oLStQPv5fASHnuuSN6PMdS3jq/tA+/FcuRhZ+//13vSeMUDBCbijNMIzUCXI8u4xnBA3jJIFx8zeaQPwdJ4FlphhhlpUahpE9TqpnbxjpQTiN/8plroO5BGBEhMADIZ3AFUyGYZwY5tkbpw2+AoGv2GAFE2EcwlLE74GwDOEcC88YRs5gYm+cVvgvWlYW8dUTrCjin+OYbGVSm/9sNgwjZzCxNwzD8AAWszcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA9gYm8YhuEBTOwNwzA8gIm9YRiGBzCxNwzD8AAm9oZhGB7AxN4wDMMDmNgbhmF4ABN7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA+QZ8T+008/lYoVK+qr11mwYIG2xauvvurbYxiGkT7ZEvvVq1dLkyZN5MYbb5R9+/b59oq+Z1/gfiNvYMbEMM48LIxjGIbhAU6J2CclJcncuXOldevW6jE2bNhQ3nnnHYmNjdXjeJCMEEaOHKnHCNUwIujdu7dUrVpVbr/9dlm+fLmmhZ9//lnzmTBhQspn0uGRwvDhw6VWrVqydOlSzWfgwIFSr149TXP33Xen5OWOTJ5++mnp06dPykjEPad69ep6Hu9TG6FkVK9jx47J5MmTpUWLFno8sB5btmyR7t27p1wntXMbNWr0n3IH4pbjmmuu0etQHj6zP7U67t27N81y0/YdOnTQfNnXo0cPiYmJkd27d6fZJmm1o2EYuYdTIvaIFKIWEhIiQ4YMUQFD4KdOnepLkSx8L7zwguzatUsSEhJUsCdNmiSXXnqplC9fXiZOnOhLKVKmTBmpXLmy/PPPPyqKiDqvixYtkvj4eNm8ebOUK1dOihcvLoMHD5aPPvpIhbZ///6ydu1aef755/U6LuPHj0/JH8F76aWXZNy4cSpaiBjnv/XWW3oNfzKq18yZM1X8ChcuLHfeeaeKYq9evWTDhg2yf/9+eeqppzQN16ldu7aeO3r0aBXpKVOm6LnU84477pC///5bnnzySdm2bZvm7c+vv/6q5YiMjJT7779fDh06JE888YSsWLHCl+L4Ov71119plvuSSy6RZ555RtPdcMMNcu+992qbsI92aNOmTUqb0E4YAhf/axiGkctwhOWEWbVqVVLjxo2TKlSokOrWrl27JMeL9KX+F0ckky688MKkF198MSkxMTHplVde0fTTp0/Xz46gJV133XVJ//d//5fkeIh6zgcffKBpHDFJOnz4cNIDDzyQ5AhokmMk9D3HHAFL2rp1a1L79u31fXR0tJ7r4hiCpAEDBiRddtllSStXrkwpf6dOnVKus2TJkqSaNWsmOeKuZTl69GiSM8JIuuqqq5I2btyoadLCv16O4CY99NBDSc2bN09av369HnfEUMv5/fffJ82ePTupSpUqKddxPOckx9PWulB/6uZff0f89dxp06YlzZ8/X9/TbnFxcUmOETjuOgsXLtQ6DBs2LNU6BhJ4P/zzBz5TVsdIahuy9e3bV69Be2XmGoZhnF5yxLMvUaKEepTdunXTjffsc3Guc1zYAI9xz549smPHjpSwBRQpUkSCgoLEEXM5cOCAeucFChTQY1FRUfoK7Dv//PNl+/bt6qXi4TvCKH/++adu7Cf0gafriM9xYZwxY8aod0wow6VgwYISHh6u7x3hkiNHjshrr70mlSpVkmrVqmloAw/WEX5N45JevfCuecWrL1SokKa/7bbbdGTRrFkz2blzp44UzjnnHK1zsWLF5Msvv5QRI0Zo/detWye//PKL1K9fX/PGEweO+cNnvH7Sky9pb775Zq2Df1r/Omb2frg4Rk7LSvvly5dPN8JkXIPruvhfwzCM3EWOiP15550njher8V023rPPhTALYuV4izJnzhwNz/gfPxEQb8eTlRkzZqghQLDg22+/1ZBQ3bp1xfF6VbSJfTteq4Z57rnnHk2XER07dtRQhbsNGjRIzj33XN/RZE5Gvfy56KKL5P333z+uHIRZUgPDSKjJP23btm19R4/nZJfbMIzcxymJ2ROrxlN3hvoab8f7Q4jTAvHGIya2jfcIgR4t+TB6QKiIdzNxWKNGDY0ZE+fmOOfi6SNqiCSeJ15tepQtW1Y9VyYkMRjEs0uXLq2jBP/RBaRXr9DQUC0fxw8ePKj7iIm3a9dOJ5Lx6LkOHj5lYgTStWtX6devn16Lc7du3arXpgx4+OQdKMoRERFaZspL+UjLPAdpS5Uq5Ut1PFm9H26brFy5Uj18tmXLlukIi7Y1DCP3c0rE3hU2QihMBPbt21fDBmnBxCqCRRgDD/TZZ5+VN954w3c0GfJ0hQYvn1BJnTp19DP7ixYtKmFhYSqaTKS+8sorOkHrruBJi5o1a2p4A2Hu0qWLlpfRwHvvvSfR0dG+VMmkVy+EkNHGpk2bpGfPnnptJobJgxECZaWOeONMfjIimjZtmpQsWVIFnZAPYZUHH3xQ82a0xIQuYSB/MAy33HKLluPxxx+X5557TvPCcCxZssSX6ngyuh8YDcJK33zzja7IYYK8efPmmp6yPvroo9qOrP4hnGYYRu7nlIg93iYrSwivEJdu2rSpCjJx8MTERF+qf0GIEFpWsCD4eJS89wcvHW8eUcKjB0TfjefzyoYAEg4hlMPo4KabbtK0gcLtwjksIXz44Yfljz/+kFGjRunIgZUw+fPn96VKJqN6tWzZUl5++WX1olmpQvyfsBIhF+YnCC2RhrIRd2epKYYlODhYQzCkxXNHcPH8MVhVqlTxXf1fMBrDhg1TUWY1D6twmKdIK+STUblpP8rB3AdhHjx/Vt5wD0g/b948fU+bYGwMw8j9BCVlFNcwDMMw8jynxLM3DMMwTi8m9oZhGB7AxN4wDMMDmNgbhmF4ABN7wzAMD2BibxiG4QFs6aWRK5k9+5jMmROvr2zlywdL06b59PWKK0L1vWEYmcfE3shVrF+fKB07HlGBTw9E/4cfCuqrYRgZY0+KkWt49tkYqVDhQIonP2BAhAp6UtJZsm5dYRk1qoDu4xhGoVmzQ3qOYRgZY569kStAtAcMSP56ZQS9f/+0v4YBoR8z5mim0xuGcZI8e+zHwoUL9deh+A50vrOGL9Dii71c3B+19t/4ArLZs2enfF8OX9LFd8n7w/e38EVfgfuNvAvi7Qo3nrwr3G5IJyhon3r8vGcfnj1pSAujR8dlGPYxDK9zUsSeLy/jGxo7deokv//+u/NQ/qBfMMYXffFzfC58hTDfMc83OfIDJBgEfpqQL98yvAMiDvfcE5Yy8YqoI/AIufuZ94RueA+kxat3jYJhGGmT42LPd8jzwxl33XWX/tA234rINzx27txZvwc9ra/d5fvfL774Yv3FKX6AhN+SNU4/Q4cO1d/0DYR9/JZAdnG9crx1YvIubiweQSdez8b7QGG/++7wlP3m3RtG2uS42PNzf4RrCN34g+CPHTtWfzrPyBsg9GwYYH/B5z2jNLbsCv6GDQn6ilfvjyvchGswBP7GwPXsgf3uaIClmoZhpE6Oiz2/00rMPqu/Rco5a9as0R8NwVDg6RunF777n1/KQtxdwXeFfv78+Xqsffv2vtQnhivc5cqF6KsLnjyrcFwhBzetv9gD6+7BPHvDSJuTErP3h5/Aa9KkScokrP/EKr+F2qBBA93Pj3sjKNdff720adPGl8I4nSDm48aNO07w/YWeHy3PLq5A+4t6aiDwbmiHOL0/ePcQaAQMw/iXHBd7ftIuKCgo5Tdj+T1YftmIX09itY0//hO0bKzQYVKXnxM0cgeBgp+TQp9ZEHHi9BgGwj2ByyxN7A0jY3Jc7PntV34676efftLQTHbg5wn5wXAmdl0IE+3atUt/p9Y4NfgLfk4LfWaEGo8eocf795/EdXFX7ATG/Q3D+JccF3u88vvuu09/rJqQzcGDB3VtPJ493js/DJ5ZmMydNWuWrs4hD5ZtstInJCREfxfWOHW4gp/THn1mJlfdUE9qQg/uJK9rOAzD+C8n5enAsx8+fLh69w0bNpQ6deroD2/ff//9uhwzsxDm4Ye0J0yYoHkg/qz0GTRokP7QuHFqQfBzGndy1fXOU8OdrE1LzF1jEDjJaxjGv9jXJRinlcB4fGreO/9BCwh+IJyLoWCE4P5HrWEY/8XE3jjtIPj8tywg9oGx97TEHgPBf9QCQp/Rih7D8DIW5DROO4RnXI8eTz3wmywR+UChJ40r9CzFNKE3jPQxz97IFeDd+3+TJQYAAff/oRLSMJFL2MZdvWPfeGkYmcPE3shV+Mfw0wNjQOjGVuAYRuYwsTdyHQi+u7k/TQipefuGYWSObIk9/zpvGKnBbxEYhpF7MM/eMAzDA1jA0zAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA+Qre/GWbVqle+dYRiGcSrht76zQrbFvkyZMr5PhmEYxqlg06ZNWRZ7C+MYhmF4ABN7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTdOKZs3b9bNMIxTy0n/iuMffvhBFi5cKF27dpXIyEjd9/PPP8u0adOkV69ectZZZ+m+33//XSZNmiSPPvpoyr4TYf369fLee+/J/fffL+XLl/ftPXNYunSpttNjjz0mRYoU8e3NO3z44Ydy+PBhue+++yQsLMy39+RA1/7jjz/k888/l127dklISIicf/75csstt8jZZ5+taWjPd999V9+70K433HCDNGzYUIKDg7Wvbtu2Te69915fimRGjhypr4H7A4mLi5MpU6bIjz/+KMeOHZMKFSpIx44dpWjRor4UhpE1cuVXHJcqVUoOHTqkG/AA/v3333LgwAHZunWr7oPVq1fLOeecIwUKFPDtMc5E7rrrLunSpctJF3pYtGiRjB07Vq688kr53//+JwMHDtTrvv3223Lw4EFfKlHRffHFF2X48OEyZMgQNQaTJ0+W+fPn+1JkD0Qeo/PII49I3759JSgoSA12QkKCL4VhnHxCBjj43meZvXv3SuHChX2fUidfvnz60DACOPfcc9WrmzNnjkRERGinr1Gjhno+s2fPVk+cz7GxsfowvP/++/LVV1/JX3/9JdWqVdORAZ77m2++qQ/KO++8I19++aVs2bJFz/v2229l1KhRev5PP/2k+QdaPzyrmTNnyogRI/RcBAFPy62HexxBwBtbvny5VKpUSQoWLKiG6tdff9Xr4y3+9ttvWqfixYvrubQH3h7e63fffad1p06UIyYmRsaMGSOjR4+Wb775RkMZ1Anx4Zrkh4fp1pdyBxo+8uY4eZE/hrREiRIqJAjVp59+KgsWLFCvFcMZyP79+1X0KCft9MUXX+jorHr16no/3OM7duyQDz74QNuYctAGb731luZPncuVK6ejr9Ty+/PPP/X4J598ovsoJ3V024E6LFmyROrXr68e89y5c/W9W77nn39exZd2JS35zZgxQ8aNG6dpqRftQ3mmTp2acu9DQ0M1DxfaaPz48VKvXj1p2bKlHqeOlStXll9++UXvJ31y+/bteo3LLrtMj+P9c22ck5UrV+r5a9eu1X7rltOFegD707uHiYmJUrduXe1HUVFRWhby5rzAchtGZsBZKVasmO9T5jjpnj2d+7zzzpONGzfqZ4bDPFBNmzZV4eahPHLkiOzevVsqVqyoaRBhvP7nnntOXn/9da2UvyeEKKxZs0a9pD59+mjeGJRrr71WevfurULEK58DwQiQtmfPniraDRo0UFGgHDBr1iw9Tohp8ODBUrVqVRVvjjPk54Fm2M65zZo1UxEiRMBxxA2h4zy8OMRp8eLFmi+GgxuEmLEhJogjBoQyLVu2TMuMeCJ25IsR9IfrPvDAAymeKAKCaFD+Nm3ayBtvvCHXXHONGpV//vnHd9bxYAgp71NPPSXY+fj4eBVmt205jrh1795d60c7c/yOO+6QoUOHyuWXXy4fffSR7NmzJyW9m1+/fv3k6NGj6h0jdK+99pq0b99ejbD/KC4rUA/yoF2oLwaA8j377LN67zGaqXngGCAEGkPgD0adeiPuOUl69xCRZwPuN3XC2JyK0Y1huJx0sUfYy5Ytq8JOxydcU7JkSY2dIgyIHmLBQ4BHyut1110nnTt3lkKFCukDwUNOjIqHF9iPuGFISpcurV7jhg0b9FhGXHTRRfpAUgbisRdccEFKGaKjo1Wc8QQ5zrV5T1kRarxmzscAUK9LL71U47oIPaEp6teiRQv11ihT7dq11SsGyk478JBT/ltvvVU9O7w+jB0eKxveZdu2bdUYZoRrKGrVqqV5MZK45JJLtL3Yz/FAwsPDNayB6NHerVq1UmPpijdlb9eunZaVsjAKIz/qzDHy59WdZPXPj1FGnTp19JV24RijBtqZ9j0RLr74Yh15Marj2tzz5s2bp9x7yon4B4IRo/5ZFVTOoa/itSPQmT0/M/eQvKdPn64jsauvvlr7kGGcKk7Jahy8XcQEweTBRACYBEP0GIazITzsY6jPQ4DX26NHD43vMjTmQXHFi+OBD2Fm458IIgL2+OOPa96vvvqqijWii1iTDyMRF4bhPLiUlQeaurhQBgwTgsOIBYPExCn5shHCcMuF+GEs8Mh54BEE2oG6YBQIJzCS+eyzz9RbZl9GQkO6ffv2qRjSbsArhor9HA+E425aQDARZQwd+Letmz/1cOtE/ainey8C8+N8xD2nID8X91r+18ssCDijNbcehJBcGAUwMmH/ww8/rCMTDBxGLLNk5h4yMqTvPfjgg9pnDONUckrE3hVP4pgIPrFmHgLCNuxbt25diieNOBI2QDwZbhOLJnSRU7hhGsIUw4YNUy8f4c0JEG+EgjK7m7tSo2bNmjpBiHFgFILos1IJEFxCILfddpsaFMIACEZmDVgggeGf9CDWjKFLj5tvvvm4OrEhhrmZ/Pnzq1GgPYGRFmElNjek4uI/QcvGPSR0lJGx9Scz95BRIwbADVcaxqnklIg9Q27i7iyv5NWdWCCeisdFSICJM0CoGAUwVHeXFiJIOQVGBC+bhxMx8B8x8HDjSZLGBQ+NWCxhAbx8/3AR5VqxYoV6vwgGnh2rjFwQUfKmTtSdEQQiiWfHfAIPP+EdDB6TorQHq1Xuvvtuvaa7giktMFLMT2As3TrwyvwH+zNjxJj/QJAQx0BoD8JOTOL6i9aJGqHUcNsop6HvMFrEm85u/vQJ7o87+gHuKfeO69AembmHHTp00BCZYZwOTonYIxp4Vqx6cOPdQHwTeIhc759jxGcJeSBECBmrGzIL4RbCCJzLnEAgGB5ipggzGxOubjoEj9g3q3GYUOSBZuUMQ37i1BgJVqMwKcoDTlycUQiiz0NOOITwE6KOd8eKlu+//17znjdvnk4ycwwDQr2oJ/kiSEzmEU4gLwwg+9kCITaOkaJ+lK9Ro0bartSJc1ldxHv2pxbu4NpMmFI+Rlm0LZ5majP73AsmMplQZPkgdSa+j9eaE/8YxT1nApj60gdoKwxnTkCfY608gsv9Q5hpe+4dzkRWlvgyr0NbEX5z86ENcQouvPBC7W+ZuYccc+dGDONUc9KXXrrwACBKTHi6HjsPAvFfvLvGjRvrZwSGYTahFtY641XiDSPMrJzBw0bMmLhzPVf/JXA85Agh51K+wHADeTNJzDJChJHjTB4SZkHwMEqI6Mcff6wigYDfeeedWk+W5GFMeKhZMYQXjwdHCIp0CD5LMydOnKjChYhSX44xyYvwcC5LCWkDPD08Z1auIBysCf/666/V+OAduks6/aHOCAn1I1/agXJzTQwX7cnkL2UJFHuEnjojshgpDBllZ105hofjlJ9Qg3uP8I6ZcGU1EfkzQmHFDyEryhmYnvvFyIKJbO4nefJPdJSH9vO/V+SNiLKaiJAWbYGYMuHspnXbB7ivjIboB+71/PMLhNENy1vJm5AKRpw5I0aNTZo0UZGmX/kvvUwN7jn5sLqKfBB66t6xY0edw6GdM7qHGEruEfeHSWzDyA48N6k5aOlx0v+D1sg9IJasT2cZJUbNMIy8CU6D6wRlllMSxjEMwzBOLyb2hmEYHsDCOIZhGHkMC+MYhmEYqWJibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPIAnxX76inip9MwBfc1LdPskWpoMOiQ7Dqb+dUb+x1ftTJBb3zsss/9JvY77opOk05gjMuaX//7AS05DeSgX5TNODL7B6vVZsdJjYrQcis3eL29x/i3vHtYtu3kZeYfTLvauECC+7lZ9wEEVoo170/9tVCNtDsSIrNyRKJv3J7dhoIHjIV+9K1HW7bGHPSucLkfhmHMb1+1OlH+ce8p7yMj4G4Y/ucazr1cmRAbfkl+3ey8Lk8WbEqTTh0dk6wET/BPhwnIhsuSZQnJHw3DfnuMpWzRY5j5WUAZcnzM/tm6cXEJDRN68Lb9880iUnJX/vz83aRgZcdq/4hivpP2Iw1KvbIi8ceu/P3o97tc46TslRl5uFylVS4TI3aOPyL2NwuWRZsnihVezZGOCTHowSpZsOiYPj4+WNnVCZfbKY3LnJWHSrVmEjP31qAybfVR2H06SCsWD5dkbIqVRpXzqlZG+w0VhMn/dMdmwJ1HqlHau7zxMJQsHy+GjSTLEGTJPWhIvR5z3FYuHyMs3RqpBgp2HkqSfU7bv/4mXkOAguaJKiDzXOr+cU5AfMBf54vd4GTQzRuvmf91AMrrOP9sTpPvEGFmzK0HLx43a6eRJnUsUCkr3+PaDiSltRkjn62X/eqLX1QqVp6+JPK7dA8tN/o+3jJS2Tpvy64Zue7e6IJ9MWhwvR4+J3H5xqDzRKsIRoiBtk5enx8g3K45JQmKS1mHQTfnVqKR1j10YwfWfGiM/rTmm7dm+fnK+UeFBEp+QJO/9GCcjfzwqB53RCG3UzzFQtCejk3sdhyAmPkmqnBOi1w53mrl78wgpHCnyyoxYDVddVT3U6Uf5paBj16jHH5sTpK5Tvhl/Jqd/oEm43N84TGKdJiI/GHlXASd9UEpfGdYhv0xbHv+fdqQ+tO+Tn8fIH1sSJH9YUEp+tIs//nldfUFoSvmB6z39ZUy6bezeg7f/r4B0Hne8I0SejSvn0zpzLvegdqkQecl5fmgbf9zrHo4TOf+cYJnuawfa7Z5Lw/R+J/fxaJmzKvnH5f3vCeVY4Dw3DRyH4pc1CfLB3QWkrtP/MtvvjexzRn3FcdECyQ/K7iOZt0UznU57Ufl8UrNkiHy2JE5emBYrl1XMpwYjLF+Q9P4sRoXd5UdHXO5sGOYYh3BZtjVBPp7v9H6H4Y6BGPub82A2DZcJ90epiPaZHCO7HKMR7/T9AVOj5ffNx/QBe7FtpPy2PkH3cWzOynh5xnloGzrl+N9NkVKqSLD0nBgtf21Lfmj8Se86h2JFnnAEZNehRHny6khpXi3UEfV/y57RcX+ebxMpLzjlBF75HAjlfuqLGBUG2otXPrPfBXFZtTPRMRQRcnH5EPloQZwKtNsmcxxDS3vQLq6Ax8Slf/8Q467jj6Tki7ghVrQNfOxcY+h3sXJ5lXyaN79VH9ieq3claX/p7xiBIpFBanQ++DlOHrsqQq6rGer0i3inP/w7N7Flf6IcjEmS526IUCM59PtYFf6MSK0duVddx8dItNNMLzifEUUcDMp9IqTVxv5Q18mdo+RKx4hhlL/sEiVNq+bTNvtiabz0uy5CPnCMB07O406fp6+kxmrHSAU7CkA7nFMwWN53DCr3jXv2xORoWb41Ufq0Snawpv4Rr4bEdQ3Je9nmRLnGad9iTnmy0u+N00OuFHs8ODotXtKFjjeYWZ5yHpARt+eXJo6HgwdWtUSwDHC8i5sbhEm/ayNkv/OA/+V4wy6Iwd2XhqvYlisaIiucjomHfc9l4Rri6OS8NnCuf0PtUNnhiOpWRyRiHS+Sjl7p7BBp7HgteL5vO9dsXz/M8cSSZJwj3hWLB+l129ULk0evjJA455KzVx3/wCY4upzedRZtjNeydmkaIZ0ahUmXK8JV8FwyOu5PIcdDRQSBVz77g1hT7lJFgtQbp7145TP7OQ7nFgpWT5HjnS8Pl3yOF/7X9mQD0+/6SPm2R0FtDzxpjO5qR7QOpiE0LhjNf5x03ZuH6714olWk3r+FG47J5n2JMtkx2uSF0HPd19rn17abvPRfMa1xXrB0c7zS2y4Mk5uc+yBO9Xq2CNf0jzveKEK22PGIXfj8vC8/vE/CIrP+ik8RsrRIrR2ZAGdehP5FfnjHFzjlwfGgL2WV9NrYJcR5as+OClJvPMRxw8+OCpaI0CAtB+LfwjH8ePnDnRHAQ04eaVHL8fz7O/eNa/2fY2R3H2EOJ8G5Jwnyq+PAuPeEcmBM5jl9GOMGxZ3rj74n2dk5zxkNZ7bfG6ePXCP2iLM7QVvv+YMaIrnnsjAdbmcWdzTA5ORax8ut4Az5C/sezkscD39F/0I6fHbJ56t9mHOJIo7DhkfjjH6dUYA4w9FYqTPwoJZniONZujC0b+GI2a/rj0nT1w9JX8d7DXdGDc3OD9Vh93pn5PDntkSp/0LyuTe+k7zi4di/WqPwwKZ3nV3OMJoHHeFIjYyOZwWMK+UmROLGg3nl87YDCRLt886dy6m4QKRjiIkjUy9e45y6PzYpWmo8m1wX/3BHeizbkiiRjlARqgPyeveO/DLxgSgVy+0Hk6S6U0euByULB0lJxwht2OO0qU8DiZYkH02G/Io7AgiUl3L7418PvNKyZwWrgT2SwSgkNRBGHIDbPzii9a7r9N1FjmEhjEJfyipptXFmuNbxsrcfSJKWQw9J90+iZeehBDW8hK9Sw7/dMDJch1DW3zuS69THGTlSp8p9D6hnj5F1DWKYc3JUeHIbu/0nM/3eOH1kXylyCP8J2vfvzC/znygkvRzvIDDuebLBix34VYx853h6IxzRWflcYenR4vin5YHG4fJ11yjHEw+T7/+O13j0s1/HaseOc7x7Jke/71lQfu5dKGUjFupPRtdxH/RwR7hSI6PjOcXRY0EpopoWPNQI/fq9ifL5QwVk9cDCGs8+mTCKQlBPNzgIePhj7ilw3P1+5/YCGt8+leDITO8WJfc1CpflWxPk/o+i5aFx0RmG0gKJcQQfR4hwjH+dCB3h0QeCEchsvzdOH7lG7EsWCZbWtUN1w0t2vXR/jvkebrwLOlhaMDlX8exgWbc7wfHyk89h2RoxxWVb0nc1EJFN+xKlknM+E1x44O51gZgm3jyezDPO0H1Or4JyedVQHc7HJSRJuWLBsnlfcnqG1Gz5HFEOfPDxnNK7TpQz+mbi0Q0/BNY5o+NZAbEq75R7rdNexNCBVz6zPzDsE0h0nDgjgCSdK6l2rlNZh8yWpVapYK3HSsebBOrB2n/i3kWc0cW5Tvv95XiMrmBtda6zdX+ShugYUZ0INHOCz0XdcyRJNjr3gf5XwDd6cG6jzp9ARoauVukQnWjfeSg5hMIW6ehbpGPrfA76f3Dz5BpcKyfAu37+6xiZvTJeujYLl1k9CmoIZqEzAl3j9P2sUP1cpzM6ZWfuwK1TIccP0bBRKorBscz2e+P0kWvEPj1KO8Ns4qxfLo2XCQvj5IVvWAmTdiyQ+CWeJevMBzjC/PmSOHnU8Ty/c7zwAmmHMBW85YKRwbLS6ehMjg2fc9QRn3/jw4Q3Vm5P0MnfH1cfkwXrEmTNzgQtY3HHQLHCZ68jlI9MOCKfLkouaytnWE1Yyp+MrtOgbKjz0IXIiLmxMurnOJ1EZALUJaPjgfCQEiIgDWEGfyjLjfVCZYsjoo9/Fq3l5pXP7Od4ehCOinIMAoYHoc7o/vhTp3Q+YUXI0O+p/1EZ/F2svDyDlTeJes+vqRkmvzmCxWQx5erl3EdgVJUWhH8Q37Tg2KAZsdovmEQm7MdcQ6HI5HAS4QgmKynPy9OPn3QIbMeWNUJV6J53+sPbc5PPaT38sLzk5B9o8Co46XBiRv50NPnaU2J0ZdCJEuqU5ZBTV0IsB5w+h4EePMvJ23lOVmxLcMp3TIo5njjtmBUalM2n24fzk/sv7c4/6HWbEJ0S0vOH5y29fs/I78Gx0TLgq9iU+R/j1JMnxJ646uMtw9UD7Ot450xY1XY8wvS4qV6YPO143j+vPSa9J8dI9FHRCSvi0OmBtziwdYRUdjzuwbNidYKQFRYIyLYDiRqzJ9SEB8v/AbDhxTBRRWillfPw855VRMQ8p/weL52viPjP5CkPSPrXERnkDKPxbF90HhzEpXm1f/PI6Hggl1QI1WVwkxbHySeOwQzELTfLCCk3r3xmf0ZgAF+9MdKpk6joLd2U4BjbfCpELAFND859q0MBqeII/gvfxMoHP8XpipwezSPUM2YJY/cWETJ3VbLgJzhiwRJZRkNpoZ57OpdFcJk8fOrLWI25M1HfpEpyPbs0Ddd5kLcd4zti3lGdLPYnsB1Zqvv2/+V3+lXyfcRQ1S8TIl2bRvzHC8aQdHH6AqNMVlKxgqeKb67iRGAVWX7H5r06M8ZxGhKk/w2RujqGdmr39mHt80y0syQ4K9DHhzh9vHHlEPl4QbwuCS2cP1ifJxZNpEZ6/Z6RDCNi+nVuCL15ldO+zt4wTiX+/5+BkTaMvMgZtc7eMAzDyDlM7A3DMDyAhXEMwzDyGBbGMQzDMFLFxN4wDMMDmNgbhmF4ABN7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPkO0vQjMMwzBOPVn9IrRsib1hGIaRN7AwjmEYhgcwsTcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA9gYm8YhuEBMhT7mJgY3zvDMAwjr5Ku2B84cECCg835NwzDyOuk+R+00dHREhISIuHh4b49hmEYRl7Fvi7BMAzDA1iMxjAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgfI1tLLTz/9VF555RXZu3evb0/WKFq0qDzxxBNy8803+/YYhmEYJ4Nsif2FF154wkLvguAvXLjQ98kwDMM4GWQrjOMK/dq1a09og+wai+xw7NgxWbZsmRw8eNC359TCyOjVV1/1fTo1cD33mly/R48envr+o9WrV0unTp1k3759vj15i9jYWPn999/19WSTUVvt3LlT/v77b8nt/5dJf6evnwxoG9qItsrt5KmY/fLly+Xuu++WqlWrSr169eS1117L1kN7+PBhefnll+WXX37RzwsWLJAbb7wxzwpBbiKn29LuTTLbtm2Tvn37yqpVq3x7cg5/RyAzzJ8/XwYNGqTP0anE+sKJkWfEfsmSJdK5c2e57rrrVJynTJmiN7tfv35y6NAhX6qsUaRIERk7dqy0atXKt8cwcjcVKlTQvl+rVi3fntNH69atZeTIkVKwYEHfHiM3kyfEPi4uTiZMmCD33XefTuYWK1ZMypQpI4899piGgX788UdNx1DqnnvukdGjR0ujRo2kevXq8tJLL8mGDRuke/fuOiK45pprUuYIMBZ4CHgKeDQdOnSQpUuXSoMGDXRfIIR9Jk+erHmTV5cuXWTLli2+oyI7duyQZ555Rq9LGgwJ57gQurr99ttTzl23bp3vSDIYtFtvvVUqVqyo6dLy3hg2z507V+vipmXU47Jnz57jyjF16lRJTEz0Hc0cXIN2csvDK+VzCQxBZdSWqd2b119/PSUckdX8/GE/x92Q4KZNm/TcFStW6OcjR47Igw8+KD/88IN+pi1wGGg/t4+QxiWt+0CZGLLTnu59pF/R3qlBnowcGYWycR3XC6be77zzjjRs2FDL0LNnT82Hdh82bJh6zG54hHweeughmTNnjrZju3bt9DUz5Qnsc4yGA0N3bltTHjbesw/Sa6vAMCD9BQNAu/H666+/phri4bxnn31WPvjgA20X+sPXX3+dkpZrTp8+Xa9Juan7+vXr9VhafSGjPr99+/ZUNQC4J0OHDk25T7z37w8ZHfeHvnL99dfr85la3U8neULsEVEakQnhoKAg395kz5wby413G5ZOQZqZM2eqBzRv3jzp2rWr3HnnnRqfv+uuu+TNN9/8T5y+d+/eMn78eKlbt64sWrRIH8JAyO+zzz6TTz75RMX10ksvTen8jC4GDBggpUuXVrEgzVdffaWCT9n2798vAwcOlJYtW2p5ebh/++03X84iK1eulBdffFFHKv/8848+oKTftWuXL8W/8BDR6f/3v/9pu1An0tJOlIX3NWvWlD/++EM+/PBDLQND7qyAUFIfHmbKxqgK4+pvVNIirbb0vzc83IjIpEmT9Fh6ZHRvypYtK6GhoRriAISQNv7zzz/1M0YAQapcubJ+XrNmjca9uUeIyuLFi/XhhIzuA/dx1qxZaqhoU+4t+aQG7U5cGyPDRh5jxozRc7gvXGvGjBlaFpwXhDYhIUH7NGVyBRfjRf+qVq2afvYnvfJwDFF186PPpdYPzjrrLHViEFU23rMP0msrfzZv3qyG7dFHH9V68Uq7bdy40ZfieL744gspWbKklod01J08AKP2/vvvy5AhQ7QfNm3aVIWa+5taX8hMn+d6/hrwwgsv6POCMzZ48GBta/c+4RzSnhzL6Lg/3GueGZyaJk2aHKdVuYE8IfZHjx7VTpza1y2fffbZetNcD7F8+fJqWQsUKKAPN41+2WWXqRfA+RdddJEKPTcmK9CheDAZXSDoYWFh0rZtWxV8LD/CQprbbrtNIiIiNA3iyANCR0E4eJDbtGkj+fPnlypVqshNN92keVO3L7/8Uq699lq54IILVLiuuOIKTUfH8ocORp6cS1q+hrpZs2bSvn17vT5iTFvccMMNmk+lSpU0TJXaQ54WlOebb75RD+iSSy6RfPnyaXnw+NjP8RPB/97g/fHQYYwpd3YoVKiQ1hORoWx4bffee68+2PHx8bJ161YdDRYvXlzTlytXTjp27Kjn8Z4+8ddff2XqPvD+gQcekBIlSuhKMvoX3jN9NBDEFgEqXLiwOiaI7eWXX673kH6C4LCfvuQ6LfQl2obruCM/6lGjRg2tQyDplYc+x1eVc62oqCjtc7fccovvzMyRVlsFQp/j+Tr//PO1v/DM9e/fP80QD8/OlVdeqefgLfPKc4xR5h4wN0de3AP6HYbOHcEHkpk+f//996uzyHUYdZxzzjlquHBAMBDUkXvBhmFhH8cyOu5CH8YBo32oW24TesgTYp8V+LEV9wdXaHDEkC27jU8oiQcIEXehI+P58aDhwdDJeKhc6FAICJ4lxzkXoXOhXEBHJRyEd8KDzkZMFg8YA+EP4oXx4EFwQSwIb3Ee1+E8znfzIt9ALyQ93PIgMG678Upe7Of4ieB/b4AHmDalbbMD4nLxxRfrA4jAIu4INu8Z3mOIa9euLZGRkZqe9uKh94f2ycx9SOvc1MJkV111lXqYOAh4yzgB5IcgUWa8fDxTrkNogmvQXxBWN0RB2yBKjRs31nMCSa889IVSpUql1PtESCv/QLgO/QXDgujhkeN9Y4BSgzL514fyUn/uwe7du7VNXCgDhiYw7OmSmT7vPmuAgcTxwLDSPyij6wgAoxrKx7GMjgNlJzzJKIjwX2r3KTeQJ8SezobYpOY9MTRGbHmQcht0ttQejLQgVotX5r+lFk7KCB44vDr/fBj+ZpcTFfm0QMiy0j7pgddKGACR4WHEkDDqY2kgbYH3mFly6j5wTcJVeN6UC4+Pz9SZsAUjEUZK5E9owh88Y4wUAoL4pRbCyU0gfk899ZSMGzdOhZmQDuFTNxSVXTLqeznZ5xHv9JYjBx7HaHC/CNES7sqpPp3T5AmxR8x5mBme+4cQiGPizeFBZNdzzwjXw3HjikAHxOviZhM35sHkvQsePV4cngHHOdc/ZOF6i6RBmMjLv6Ok1mlIi5jRsV1IR1yV6zGaYJjtTlYCndO/3TICw4mnhti45/GKx8x+17C6nuiJQiiNkQ5tC9nJ77zzzlOPDU+aSTrEB2+YiX3E8txzz/WlTJus3IeMwJDRXwmjYChYLtmnTx/59ttvNYyIN4oX6Hq+bl9wwTvluhgHRoSphXAygpU79IPUnKSchnkFwik8q9RrxIgR+nxi0LICfQsvGrF2oS0J8VCf1MhMn/dvX+4JIRhG4bQr59FHXPg5VuBYRseBkRiGnRAZITfm1HIjeULsEQMsN5M2zOQzfKJz8VUNWFji5jkBDx5hBvIPfEAQJeKAlAHRpgNSFlYUYGgYwpKGeCNGgMkkPMSrr75axZmwC0NJjtPZ6JzuRBrDPsIOxOK/++477Zh0diZHA2P2pCVPJorxFknLOUwqEuKpU6eOdj7KxXV44BhWM1mcWagP8Xom/pgEQ3Tc5a7s5zjGi3g7k6EYMI75T96m1pbUiXS0D2347rvvatyWdjuR/PxB6BFFBJZ7AczZcE3EIDNimZX7kBmYFET0uA/UGePJvUHQeCX0gJAwyU5f8YfjGAlCPcT5TyQ0QP3dPocTwnUmTpzoO/pfuAeIGn0mqwaO85588kl1vhBa7i/7uC9ZASPNvNbHH3+sbU+fZmUNjhTGGwL7Qmb6/Hvvvad9g/T0LRyN+vXraziHEB8jEs4j9Eda9nEso+P+0MeYa+BeYpxyG3lC7AHL+fbbb6ung7gzyYKIMmPPpElOgFhwHR74adOm+fb+C9dkYhTPhQ6Gd43HhlgRv2cmnkk28mDCtEWLFhqLRRwpI2l5wBmJsCLI30ixj2VxdBRGMQ8//LB6CjyAgRCfZojKBDBe7Oeff65ij1fFdejodGbivggF+4gfZwUmKHl4n3vuOV2uxnIzJhTZD+RNHWmT5s2b69I25ixcUmtLRgUYZ9qF8jCZyKQanEh+/tDGTMDRHqxsATxEhJ/z8NozQ1buQ3rgoPTq1UtFk8lXyoBYMLmHAPKKGDIBTr+hXpTR35Bxnyk/dToR/PscwsaqEiYQ04L+iFHjnuBMZQXajT5JXTAyjz/+uNafCeqswqT4HXfcoZOq9DdGQzh2jN4gsC9kps8TQvvoo480rk/IjFVKPC8YUSbOgfNY7MDojn0cy+h4IIRzCLnhyJzIiPBkkq3vxnEnUbDAJ0J2zzfyDnjsGCSEFCNtnBoQHH9RGjVqlM5z5cQcjpG3yDOevWEYWYMQEd414QtCUoT9CD264RDDW5jYG8YZCrFtQiGEDAkFdevWTf85jtCR4T3sK44NwzA8QLY8e354BLE+UTiXPAzDMIyTS7Y8e8MwDCNvYDF7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTcMw/AAJvaGYRgewMTeMAzDA5jYG4ZheAATe8MwDA9gYm8YhuEBTOwNwzA8gIm9YRiGBzCxNwzD8AAm9oZhGB7AxN4wDMMDmNgbhmF4ABN7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwPICJvWEYhgcwsTcM45Syb98+ufHGG+XVV1/17TFOBSb2hnGGcvjwYRk6dKg0bNhQKlasKK1bt5bZs2dLYmKiL4VxIuw4mCjdxh+Qyk/ulFKP7ZAGA3fJqJ+iJSGXN6uJvWGcgRw5ckQGDBgg48aNk4ceekhGjhwp1apVk4cffli++OILXyojqxyKTZKHxx6QmSuOyn1N8svQ2wpJ/bKhMuDLQzLshyO+VLkTE3vDOAOZO3euTJkyRV5++WXp2LGjNGvWTPr37y+XX365iv3BgwclKSlJfv75Z7n11lvV82/RooVMnTpVPf+YmBjp0aOHdO7cWd58802pV6+eNGrUSL7++ms9D3bs2CHPPPOMVK9eXY+/8847Ehsbq8dIQxkYTZD37bffLsuXL9djeZnVO4/J8i3x0qFhpPS5NkraXxgpr91aWGqXCZWv/4iV/dGJ6vk/Mu6AVOizU8r23iHthu2VDXsS1FC0fWuvtBq8R9PB938flXJP7JARc6L188odx6T1m3v1vGrP7JQ3vjsi8QnJ7Z1dTOwN4wwDoV26dKmKcO3atX17RQoUKCA9e/ZU7z4kJET++ecf6dWrl9SsWVN++OEHFeZ+/frJ77//7jtD5LvvvpOjR4/K66+/riMDwkKbN2+WQ4cOqfFYsWKFDB48WB555BEZMWKETJo0Sc/j+uSNcRk9erSUK1dOP2/YsEGP51XOyh8sUeHBMn3ZUVnmiD4UigiSqY8UlRk9i0kB59gznx+UH/6Ok0E3F5L37i6iQv/U5IOSz1HbK84Pl20HEmW7s8G8VXFSODJYrqgaJjsPJcoDYw7IkbgkebV9Ibnt4kgZOuuIjPk5RtNmFxN7wzjDwLvG60bQg4OPf8SrVq2qMXyEv3Tp0jJt2jTp06ePivF1110nUVFRsnr1al9qkauvvlq6dOmiI4M77rhD1q9fr3mvWbNGfvrpJ+nWrZumueuuu6Rt27aycOFCNQSMKurXr68jAwS/U6dOEh0dLYsXL/blnDcpXzxE+t4QJbscYb52yF5p/PJu9b4POl67y3NtC8qc3sXkpvoR0uqCcGlYMUxW7UiQAzFJclmlUIlxxHzppnj19JdsiJcLSubTfL//66hs2pcgA9sUVKHv1TJKapXKJ984huXI0ex79yb2huFR8ufPLwsWLJCbbrpJQy0tW7aULVu2+I4mg7EICgrS96Q/duyYJCQkyKpVq6RIkSJSpkwZPZYvXz719IcMGaIjC4zBt99+K7Vq1Toub87P67SpGyGL+58tj18dpZ8HTT8sTRzRX+wId2iISJxTxe7jD0hF3wTulKXJoS2ofl6oVCmRTz36TXsTZO3uBGnqePsRoUGyZGO8xMYnyc3v7NPzCOP8tj5eEhKTxPnLNib2hnGGERERISVKlFBRDlx5s3LlShV4JnDnz58vTz75pHTo0EFDOjNnzpRSpUr5Up44bsy/TZs28ssvv8iiRYtStuuvv96XKm9D6KZbiwLyY5/i8mnns3QlzqAZh9XjR+jX7UmQad2LyuZBJaS1YxxcCkUGSePKYbJ8yzH57u+jTluJNK4Spsfw+AnpjH/gLFnU9+yUbeQ9RSQqPNngZgcTe8M4w8ATr1u3rqxdu1Zj6i4I8PDhw2XYsGFqCPC0CdtcdNFFEhoaqh55ZpdlVqlSRfbv3y+bNm3Sz5w7ffp0jdmHhYXpca4PZ511lm6ElTBEeZmRP0ZLmcd36GSsywUlQ6XyOSGydX+iij2vtUuHOl58Pj0euCSz6flhsudwooxbEKPnlS3qDAcc6pQNlUOxTPAmyLmFg3XL74h8/rAg555qkmxhYm8YZyCNGzeWpk2bytNPPy1jx47VCVjCLIRWiK0XKlRIt7179+rqHI6zcmfbtm2+HNKnUqVKujrnjTfeUJGfMGGCjhIYMURGRqpXv3HjRr0meY8aNUrDRXk9Zn9l9XApWyxEek86JK9MPyyfL4mVpz8/KIs3xkuDcqFSLCpYohyvf+H6ePnAMQzPTj0k3/551Hd2MjVK5pNSZwXLRsf7Z8K2oJMerq4ZrrH7AVMOy5vfH9HzWbnz3FeHcmQNf8gAFuMahnFGER4eLpdeeql68yyJnDhxosbfn3/+eWnVqpV6/+XLl9eJ2vfff1/mzZunAo34Fy5cWL19VuLAlVdeqZ4/I4HPPvtM2rdvr3F40qxbt05X4yxZskQnclliSfyecFCNGjVkxowZmj+Tul27dlUjFBcXpxO4TBBjMPISRfIH66TrtgMJ8smvsRqPZ2XN7Q0j5enrC0rRAsFSt0yozHQE/gvHEMAllULlz63HpJUj5ucVdkY3oUEaq2eZ5WOtonQfFIoI1pAOhmLy4liZtypeRwG9ry6YYhCyQ5Az/MqZRZyGYRhGrsXCOIZhGB7AxN4wDMMDmNgbhmF4ABN7wzAMD2BibxiG4QFM7A3DMDyAib1hGIYHMLE3DMPwACb2hmEYHsDE3jAMwwOY2BuGYXgAE3vDMAwPYGJvGIbhAUzsDcMwznhE/h+4x0LcBEi2/gAAAABJRU5ErkJggg==)"
      ],
      "metadata": {
        "id": "MqhZIbThDzXR"
      }
    }
  ]
}