diff --git a/analysis/review-proteome_coverage.ipynb b/analysis/revision-proteome_coverage.ipynb
similarity index 100%
rename from analysis/review-proteome_coverage.ipynb
rename to analysis/revision-proteome_coverage.ipynb
diff --git a/analysis/revision-remote_species.ipynb b/analysis/revision-remote_species.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..3de2f255d2ee3a5081aeb969efbacee500475b9d
--- /dev/null
+++ b/analysis/revision-remote_species.ipynb
@@ -0,0 +1,394 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "56159bf4-7e59-4416-a5ed-8054179cd39d",
+   "metadata": {},
+   "source": [
+    "How good is protein structure at finding conserved function? To find out, we tried to compare enzyme function between distantly related species, to see how often function was correctly annotated by structural similarity. In particular, we were interested in cases where orthology via sequence similarity was no longer detectable but the annotated protein function was still similar. Enzymes are an interesting test case, since they have an easily accessible function description (EC number).\n",
+    "\n",
+    "The detailed strategy I am going to pursue here:\n",
+    "\n",
+    "1. take the proteome of a species distantly related to human (yeast, arabidopsis)\n",
+    "2. foldseek against Alphafold/proteomes\n",
+    "3. keep only significant human hits\n",
+    "4. remove query/target pairs that clearly share evolutionary history (same root orthogroup/same most specific orthogroup)\n",
+    "5. for all remaining cases: only keep enzymes (valid EC is available)\n",
+    "6. calculate how many digits of the EC overlap\n",
+    "7. plot the results\n",
+    "\n",
+    "```\n",
+    "# download Alphafold proteomes:\n",
+    "\n",
+    "> foldseek databases Alphafold/Proteome proteomes tmp/\n",
+    "\n",
+    "# download and untar yeast protein structures, then:\n",
+    "\n",
+    "> foldseek createdb UP000002311_559292_YEAST_v4/*.pdb.gz yeast\n",
+    "> foldseek search yeast proteomes annot_yeast tmp\n",
+    "> foldseek convertalis yeast proteomes annot_yeast yeast.m8\n",
+    "```\n",
+    "\n",
+    "(same for _Arabidopsis_)."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "d46b79e8-e6a3-4503-89a4-687527ce3256",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import pandas as pd\n",
+    "import numpy as np\n",
+    "\n",
+    "from matplotlib import pyplot as plt\n",
+    "import seaborn as sns"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "11891bb5-7525-46ac-b944-49464fa4e5dd",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def keep_term(row, term=\"root\"):\n",
+    "    \"\"\"\n",
+    "    A function to isolate an EggNOG orthogroup by term.\n",
+    "    \n",
+    "    Expects a comma-separated string where the target orthogroup\n",
+    "    contains the term.\n",
+    "    \"\"\"\n",
+    "    x = np.array(row.split(','))\n",
+    "    keep = np.zeros(len(x), dtype=bool)\n",
+    "    for i, og in enumerate(x):\n",
+    "        keep[i] = term in og\n",
+    "#     print(x, keep)\n",
+    "    try:\n",
+    "        return x[keep][0]\n",
+    "    except IndexError:\n",
+    "        return None"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "8d4c0fd8-6c3c-4e8f-8e3d-36b4abc2a40a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def compare_EC(x, slot1=\"query_EC\", slot2=\"target_EC\"):\n",
+    "    query = [np.array(ec.split(\".\")) for ec in x[slot1].split(\",\")]\n",
+    "    target = [np.array(ec.split(\".\")) for ec in x[slot2].split(\",\")]\n",
+    "    max_agreement = 0\n",
+    "    for q in query:\n",
+    "        for t in target:\n",
+    "            tmp = np.sum(q == t)\n",
+    "            if tmp > max_agreement:\n",
+    "                max_agreement = tmp\n",
+    "    return max_agreement"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "7fa6da37-7faf-404a-87cd-0d690a9a4ea6",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def same_structure_same_EC(query_annot, query_foldseek, target_annot, lowest_relevant_OG=\"Opisthokonta\"):\n",
+    "    in_target = query_foldseek[\"target\"].isin(target_annot[\"id\"])\n",
+    "\n",
+    "    best = query_foldseek[in_target].sort_values(\"e value\").drop_duplicates(\"query\")\n",
+    "\n",
+    "    informative_columns = [\"eggNOG_OGs\", \"Preferred_name\", \"GOs\", \"EC\"]\n",
+    "\n",
+    "    best[\"corrected bit score\"] = best[\"bit score\"] / best[\"alignment length\"]\n",
+    "\n",
+    "    best = best[[\"query\", \"target\", \"corrected bit score\"]]\n",
+    "\n",
+    "    query = query_annot.set_index(\"id\").loc[best[\"query\"]][informative_columns]\n",
+    "    query.columns = \"query_\" + query.columns\n",
+    "\n",
+    "    target = target_annot.set_index(\"id\").loc[best[\"target\"]][informative_columns]\n",
+    "    target.columns = \"target_\" + target.columns\n",
+    "\n",
+    "    best = best.reset_index(drop=True).join(target.reset_index(drop=True))\n",
+    "\n",
+    "    best = best.join(query, on=\"query\")\n",
+    "\n",
+    "    best['query_root'] = best['query_eggNOG_OGs'].apply(keep_term, term=\"root\")\n",
+    "    best['target_root'] = best['target_eggNOG_OGs'].apply(keep_term, term=\"root\")\n",
+    "    best['query_op'] = best['query_eggNOG_OGs'].apply(keep_term, term=lowest_relevant_OG)\n",
+    "    best['target_op'] = best['target_eggNOG_OGs'].apply(keep_term, term=lowest_relevant_OG)\n",
+    "\n",
+    "    best[\"homolog\"] = best[\"query_root\"] == best[\"target_root\"]\n",
+    "    best[\"ortholog\"] = best[\"query_op\"] == best[\"target_op\"]\n",
+    "\n",
+    "    no_homology_whatsoever = ~best[\"homolog\"] & ~best[\"ortholog\"]\n",
+    "    unrelated = best[no_homology_whatsoever].reset_index(drop=True).copy()\n",
+    "\n",
+    "    unrelated[\"target_EC\"].replace(\"-\", None, inplace=True)\n",
+    "    unrelated[\"query_EC\"].replace(\"-\", None, inplace=True)\n",
+    "\n",
+    "    target_has_EC = ~unrelated[\"target_EC\"].isnull()\n",
+    "    query_has_EC = ~unrelated[\"query_EC\"].isnull()\n",
+    "\n",
+    "    keep = target_has_EC & query_has_EC\n",
+    "\n",
+    "    unrelated_with_EC = unrelated[keep].reset_index(drop=True).copy()\n",
+    "\n",
+    "    unrelated_with_EC[\"ec overlap\"] = unrelated_with_EC.apply(compare_EC, axis=1)\n",
+    "\n",
+    "    fig, ax = plt.subplots()\n",
+    "    b = sns.boxplot(data=unrelated_with_EC, y='corrected bit score', x='ec overlap', ax=ax, fliersize=0, whis=[5, 95])\n",
+    "    counts = unrelated_with_EC.groupby(['ec overlap']).apply(len)\n",
+    "    for i, c in enumerate(counts.values):\n",
+    "        ax.text(i-0.1, 4., str(c), fontsize='x-large')\n",
+    "        ax.set_ylim(0, 5);"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "22f00eeb-722e-4820-a797-18e76e50de82",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/md/d6lwwbv97xb6g6ddypntnprh0000gp/T/ipykernel_488/2997960917.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support skipfooter; you can avoid this warning by specifying engine='python'.\n",
+      "  yeast_annot = pd.read_csv(\"../data/eggnog/S_cerevisiae_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "yeast_annot = pd.read_csv(\"../data/eggnog/S_cerevisiae_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n",
+    "yeast_annot[\"max_annot_lvl\"].unique()\n",
+    "yeast_annot[\"id\"] = yeast_annot[\"#query\"].str.split(\"|\").str[1]\n",
+    "\n",
+    "yeast_foldseek = pd.read_csv(\"/Users/npapadop/Documents/data/foldseek/yeast.m8\", sep=\"\\t\", header=None)\n",
+    "yeast_foldseek.columns = [\"query\", \"target\", \"seq. id.\", \"alignment length\", \"no. mismatches\",\n",
+    "                       \"no. gap open\", \"query start\", \"query end\", \"target start\", \"target end\",\n",
+    "                       \"e value\", \"bit score\"]\n",
+    "yeast_foldseek[\"query\"] = yeast_foldseek[\"query\"].str.split(\"-\").str[1]\n",
+    "yeast_foldseek[\"target\"] = yeast_foldseek[\"target\"].str.split(\"-\").str[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "d8ad897d-3c5e-4ab5-b79d-c0ca22af20fd",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(5994, 5537, 5520)"
+      ]
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = yeast_foldseek[\"query\"].unique()\n",
+    "b = yeast_annot[\"id\"].unique()\n",
+    "c = np.intersect1d(a, b)\n",
+    "\n",
+    "len(a), len(b), len(c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4437ebdf-5878-43ce-8e7a-f21c77bc6277",
+   "metadata": {},
+   "source": [
+    "we don't want to get into quibbly territory, so we'll proceed with the IDs that are in both lists and will not wonder why they don't match to 100%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "f57728f2-f505-4195-9df1-a606ec65f40d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keep = yeast_annot[\"id\"].isin(c)\n",
+    "yeast_annot = yeast_annot[keep]\n",
+    "\n",
+    "keep = yeast_foldseek[\"query\"].isin(c)\n",
+    "yeast_foldseek = yeast_foldseek[keep]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "d4a421da-3d5d-47f3-90eb-f77441d929d1",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/md/d6lwwbv97xb6g6ddypntnprh0000gp/T/ipykernel_488/2273340934.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support skipfooter; you can avoid this warning by specifying engine='python'.\n",
+      "  human_annot = pd.read_csv(\"../data/eggnog/H_sapiens_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "human_annot = pd.read_csv(\"../data/eggnog/H_sapiens_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n",
+    "human_annot[\"id\"] = human_annot[\"#query\"].str.split(\"|\").str[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "f7f4835c-03b8-4117-b494-387c570e5c12",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "same_structure_same_EC(yeast_annot, yeast_foldseek, human_annot)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "ff056da6-2246-41c0-85cd-01eda6589dda",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/var/folders/md/d6lwwbv97xb6g6ddypntnprh0000gp/T/ipykernel_488/2842444695.py:1: ParserWarning: Falling back to the 'python' engine because the 'c' engine does not support skipfooter; you can avoid this warning by specifying engine='python'.\n",
+      "  arabidopsis_annot = pd.read_csv(\"../data/eggnog/A_thaliana_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n"
+     ]
+    }
+   ],
+   "source": [
+    "arabidopsis_annot = pd.read_csv(\"../data/eggnog/A_thaliana_annotations.tsv\", sep=\"\\t\", skiprows=4, skipfooter=3)\n",
+    "arabidopsis_annot[\"max_annot_lvl\"].unique()\n",
+    "arabidopsis_annot[\"id\"] = arabidopsis_annot[\"#query\"].str.split(\"|\").str[1]\n",
+    "\n",
+    "arabidopsis_foldseek = pd.read_csv(\"/Users/npapadop/Documents/data/foldseek/arabidopsis.m8\", sep=\"\\t\", header=None)\n",
+    "arabidopsis_foldseek.columns = [\"query\", \"target\", \"seq. id.\", \"alignment length\", \"no. mismatches\",\n",
+    "                       \"no. gap open\", \"query start\", \"query end\", \"target start\", \"target end\",\n",
+    "                       \"e value\", \"bit score\"]\n",
+    "arabidopsis_foldseek[\"query\"] = arabidopsis_foldseek[\"query\"].str.split(\"-\").str[1]\n",
+    "arabidopsis_foldseek[\"target\"] = arabidopsis_foldseek[\"target\"].str.split(\"-\").str[1]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "cfd46099-627e-4b12-aee3-5979914eaff7",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "(27298, 25145, 25071)"
+      ]
+     },
+     "execution_count": 11,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "a = arabidopsis_foldseek[\"query\"].unique()\n",
+    "b = arabidopsis_annot[\"id\"].unique()\n",
+    "c = np.intersect1d(a, b)\n",
+    "\n",
+    "len(a), len(b), len(c)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "21080634-fbcd-4e68-9dbf-e1589e3dfe41",
+   "metadata": {},
+   "source": [
+    "we don't want to get into quibbly territory, so we'll proceed with the IDs that are in both lists and will not wonder why they don't match to 100%."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "007206af-b083-45d1-9132-5d36b6d3f8aa",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "keep = arabidopsis_annot[\"id\"].isin(c)\n",
+    "arabidopsis_annot = arabidopsis_annot[keep]\n",
+    "\n",
+    "keep = arabidopsis_foldseek[\"query\"].isin(c)\n",
+    "arabidopsis_foldseek = arabidopsis_foldseek[keep]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 13,
+   "id": "a5fbe0b2-1545-410a-9416-053cab1514cc",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAioAAAG2CAYAAABRfK0WAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjYuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8o6BhiAAAACXBIWXMAAA9hAAAPYQGoP6dpAAA4IklEQVR4nO3dd3hUZeL28XsIyUwCSegoPVTp0haDG6o0WUnWCqI0FRQQeMOuFHUBFZF1C1hgYV1QUIGfrhBsREApFpAWRUQEREgQpC0JbSbtef9gmSVOwAxMck4y38915bqSZ848uSeHTG5OdRhjjAAAAGyolNUBAAAALoeiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbIuiAgAAbMvSojJlyhQ5HI48H9ddd52VkQAAgI2UtjpA06ZNtXr1au/XISEhFqYBAAB2YnlRKV26NFtRAABAviwvKnv27FG1atXkdDrVvn17Pfvss6pbt26+y3o8Hnk8Hu/Xubm5OnnypCpWrCiHw1FUkQEAwDUwxuj06dOqVq2aSpW68lEoDmOMKaJcPj788EOdO3dODRs21M8//6xnnnlG3333nXbu3KmKFSv6LD9lyhRNnTrVgqQAACDQUlNTVaNGjSsuY2lR+aWzZ8+qXr16euyxx5SYmOjz+C+3qKSnp6tWrVpKTU1VVFRUUUYFAABXKSMjQzVr1tSpU6cUHR19xWUt3/VzqTJlyqh58+bas2dPvo87nU45nU6f8aioKIoKAADFTEEO27DVdVQ8Ho927dql66+/3uooAADABiwtKn/4wx+0bt067d+/X5s2bdKdd96pjIwMDRo0yMpYAADAJizd9ZOWlqb+/fvr+PHjqly5sm666SZt3LhRtWvXtjIWAACwCUuLypIlS6z89gAAwOZsdYwKAADApSgqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtkpbHQAAgJLKGCO32x3Q+TwejyTJ6XTK4XAEZF6XyxWwuQKNogIAQCFxu93q2bOn1TF+VXJyssLDw62OkS92/QAAANtiiwoAAIXE5XIpOTk5YPO53W7Fx8dLkpKSkuRyuQIyb6DmKQwUFQAAConD4Si0XSoul8u2u2sCiV0/AADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtigqAADAtrgpIQCUMMYYud3ugM3l8XgkSU6nUw6HIyDzShduqhfI+VAyUVQAoIRxu93q2bOn1TF+VXJyclDc/RfXhl0/AADAttiiAgAljMvlUnJyckDmcrvdio+PlyQlJSXJ5XIFZF5JAZ0LJRdFBQBKGIfDUSi7VFwuF7tqUOTY9QMAAGyLogIAAGyLogIAAGyLogIAAGyLolJE6tSpI4fDke/Hddddl2fZPXv2aMaMGeratatq1qypsLAwVa1aVX379tUnn3xi0SsoWfxZH5J0/vx5vfjii2rXrp0qVaqksmXLqnHjxho9erQOHDhgwSsoOfxZF6mpqRoxYoTat2+v6667Tk6nU9WqVVNcXJwWLFigrKwsi15FyfD222/r0UcfVVxcnKKiouRwODR06NDLLn/mzBk9+eSTaty4sVwul8qVK6du3brpgw8+yHf59evX6/7771ezZs1UsWJFuVwuxcTEqG/fvlqzZk1hvaxiKb91cd999+W77ODBgy/7O3Txo1u3bvk+98yZM3r66afVsmVLlS1bVpGRkWratKmGDRtmm98nzvopQtHR0Ro7dqzPeNmyZfN8/eSTT2rp0qVq3Lixbr31VlWoUEG7d+/WihUr9O6772rmzJkaM2ZMEaUuuQq6PrKystS1a1dt3LhRN9xwg/r37y+n06nNmzfrxRdf1MKFC/XZZ5+padOmRZS85Cnouti3b5/eeOMNtW/fXgkJCapQoYJOnDihDz/8UEOHDtXChQu1atUqlS7NW9vVeOaZZ/TVV1+pbNmyqlGjhr777rvLLnvq1CnFxcXpm2++UdOmTTV8+HCdPXtWK1asUJ8+fTRr1iyNHj06z3M+/vhjffzxx2rfvr26du2qMmXK6ODBg973tieeeEJPP/10Yb/MYsGfdZGQkKA6derk+9iiRYv0ww8/qHfv3j6P/fjjj+revbv27t2ruLg4PfLIIzLG6Mcff9Tbb7+tv/3tbwoNDQ3US7p6phhLT083kkx6errVUX5V7dq1Te3atQu07Pz5882WLVt8xteuXWtCQ0NNaGio+emnnwKcMLj4sz6WLl1qJJlu3bqZnJycPI/96U9/MpLM4MGDCyFlcPBnXXg8Hp91YIwxmZmZplOnTkaSWbJkSYATBo+PP/7YfP/99yY3N9d88sknRpLp16+fiYuLM3FxcebcuXPeZceMGWMkmdtvv91kZWV5x48ePWrq1KljQkNDze7du/PMf/78+Xy/b2pqqqlSpYopVaoU723/ld+6GDBggDl37ly+6yM///nPf0x4eLgJCwszx44dy/OYx+MxN954owkNDTVJSUk+z83Ozja5ubkBfU2X8ufvN7t+bGjIkCFq06aNz3inTp3UuXNnZWVl6bPPPrMgWXDav3+/JKlPnz4qVSrvr8zFC2EdP368yHMFo7CwMJ91IEmhoaH6/e9/L+nCVhdcnS5duqhBgwYFuv/OO++8I0l66qmn8mzBqly5ssaNG6esrCzNnTs3z3Mud4G3GjVqqEOHDsrNzfX+vgU7f9bF5SxatEjnz5/X7bffrkqVKvk8lpKSojFjxqhv374+zw0JCbHNfZjYPlqEPB6PXn/9dR08eFBlypRRixYt1LFjR4WEhBR4jrCwMEmyx+a4Yq6g66NZs2aSpA8++EBjxozJ84cyKSlJktS9e/eiC14CXevvRk5Ojve4iBYtWhRmVPzXkSNHJEl169b1eezi2OrVqws019GjR7Vp0yY5nU41bNgwcCGD3D//+U9J0rBhw3weW7x4saQLx7ccOHBAH3zwgU6dOqVatWqpV69eqlixYpFmvRKKShE6cuSI7r///jxjMTExWrBggTp16vSrzz9w4IBWr16tiIgIdezYsbBiBo2Cro8+ffrorrvu0ltvvaWmTZuqe/fu3mNUvvjiC40ePVojR44s6vglir+/G8ePH9dLL70kY4yOHTumVatWae/evRo4cKB+97vfFVXsoFapUiUdPnxY+/fvV5MmTfI89sMPP0iSdu/ene9zt2zZovfee0/Z2dlKS0vTihUrdPr0ab388ss+//PH1fniiy+0Y8cONWzYUF26dPF5fPPmzd5bLYwfP17Z2dnex8qUKaMXXnjhigdSF6lC2wFVBIrTMSpTpkwxa9asMUeOHDFnz541O3bsMMOHDzcOh8OEh4eblJSUKz7f7Xabm2++2UgyM2bMKKLUJZe/6yM3N9dMnTrVhISEGEnej27dupkvvvjColdRMlzN78auXbvyrAeHw2Eee+wxk5mZacErKJl+7RiVhx56yEgyd911l8nOzvaOHz9+3MTExHjXTX7HUcyZMyfP+ouKijKvv/56kbyu4uhqjlEZPHiwkWSef/55n8fcbreRZEJCQozD4TATJkwwBw8eNCdOnDDz5883ZcuWNQ6Hw6xZs6bQXpM/f78pKhYbN26ckWQSEhIuu0xWVpa54447jCRz5513FuoBTsEuv/Vx7tw5c/vtt5uyZcuaf/zjH+bw4cMmPT3dfPDBB6Z+/fomNDTULF++3MLUJVNBfjeys7PNgQMHzMyZM01UVJS56aabzIkTJ4owZcn1a0Xl8OHDpnbt2kaSadasmRkzZox56KGHTJUqVUy9evVMRESEkWQ8Hs9lv8f58+fNt99+a0aPHm0kmeHDhxfFSyt2/C0qp06dMhEREfkeRGuMMWfPnvWWxLvuusvn8RdeeMFIMj169Aj4a7mIolKM7Nmzx0gyFSpUyPfxrKwsc9ddd3n/QV16dD0CL7/18eSTTxpJZtasWT7Lp6SkGEkFPmsFBfdrvxu/tGTJEiPJjBw5spCTBYdfKyrGXDjDZ/To0SYmJsaEhoaaKlWqmKFDh5r9+/cbh8NhoqOjC/z9Hn74YSPJvPXWWwF+JcWfv0XlpZde8q67ywkLCzOS8t2SlZqaaiSZcuXKBew1/BJn/RQjVapUkSSdPXvW57GsrCzdfffdeuutt3Tvvfdq8eLFXB+ikOW3Pt5//31Jync/b8uWLVWhQgUdOHCAM38C7Eq/G/np1auXJGnt2rWFFQm/ULlyZc2aNUs//PCDMjMz9fPPP+tf//qX9u/fL2OM2rVrV+C5WH+Bc/Eg2uHDh192mUaNGkmSypUr5/NY+fLlJV240KUd2KaoTJ8+XQ6HI9+LPpVkmzZtkuR75HxmZqbuuOMOLVu2TAMHDtSiRYv8OjsIVye/9ZGZmSlJOnbsmM/yHo9HGRkZkiSn01kECYPH5X43LufQoUOSRJm3gYt/KAcMGFDg57D+AmPTpk366quv1LBhQ3Xu3Pmyy128Uu3OnTt9Hvvmm28k6bIXkStqtigqmzdv1rx580rsaYU7d+7UyZMnfcZTU1M1atQoScpzaWSPx6Pf//73evfdd/XAAw9owYIF+V47AlfH3/URFxcnSXr22Wfl8XjyPGfKlCnKzs5Wu3btFBkZWYipSyZ/18WmTZt07tw5n+XPnDnjvVpznz59CiktLpWbm6szZ874jL/yyitavHixbrzxRp+ism7dOuXm5vo8Z9++fZo2bZok1t+1mjdvnqT8T0m+1PDhw1W6dGnNnDlTP/30k3fc7Xbr8ccflyT169ev8IL6wWGMMVYGOHPmjFq3bq3Zs2frmWee0Y033qiZM2cW6LkZGRmKjo5Wenq6oqKiCjfoNZgyZYqee+45denSRTExMYqMjNQPP/yg9957T263W7feequWLVvmvUbKkCFD9Oqrr6pSpUoaMWJEvhfd6dy58xXbMi7P3/Vx6NAh3XTTTUpLS1OdOnXUq1cvhYeH67PPPtOXX36p8PBwrVmzRrGxsRa/suLH33WRkJCgtWvXqlOnTqpVq5YiIiKUmpqqDz/8UKdOnVKHDh2UnJzsc+l9FMzy5cu1fPlySRdOGU9OTlZMTIx391v//v29789nzpxR1apV1aNHD9WrV0+StGHDBn355ZeqV6+eVq9e7fM/8nLlyqlcuXJq3769atasqezsbO3bt08rV65Udna2Hn30Ub3wwgtF9XJtLb91UbduXXXo0EEfffSRQkNDtWfPHoWHh3ufk5GRoWrVqikrK0uHDh361VO9//a3v2ncuHGqWLGiEhISFBERoeTkZH3//fdq3769PvnkkzzzB5Jff78L7UiZAho4cKAZO3asMcaYTp06mTFjxlx2WbfbbdLT070fFw/4sfvBtGvXrjX9+vUzjRo1MtHR0aZ06dKmUqVK5pZbbjGvvfaaz1k8Fy8FfqWPyZMnW/NiSgB/14cxFw4aHDdunLnhhhuM0+k0oaGhplatWmbw4MFm165dFryKksHfdfHee++Ze++91zRo0MBERUWZ0qVLm8qVK5tu3bqZuXPncrD5NZo8efIV33dq1arlXTYzM9MMHTrUNGzY0ERERJiIiAjTvHlzM3XqVHP69Ol85585c6a59dZbTa1atbyXdq9Zs6a58847zcqVK4vqZRYLv7YunE6nz8G0s2fP/tWDaH/pvffeM126dDFRUVHG6XSaxo0bm6eeeupXL89/rfw5mNbSLSpLlizRtGnTvBee6dy58xW3qEyZMkVTp071Gbf7FhUAKK7Onz+vnj17SpKSk5ML7X/YKJiSsj782aJi2YEPqampGjNmjF5//fXL3v/hlyZOnKj09HTvR2pqaiGnBAAAVrLs8OqtW7fq6NGjeW6+l5OTo/Xr1+ull16Sx+PxOcvF6XRyZgUAAEHEsqLSrVs37dixI8/YkCFDdMMNN2j8+PGcigsAAKwrKpGRkd670l5UpkwZVaxY0WccAAAEJy7OAQAAbMtWlwDk0skAAOBSbFEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2RVEBAAC2dVVFZd++fXriiSfUv39/HT16VJK0cuVK7dy5M6DhAABAcPO7qKxbt07NmzfXpk2b9M477+jMmTOSpK+//lqTJ08OeEAAABC8/C4qEyZM0DPPPKNVq1YpLCzMO96lSxd98cUXAQ0HAACCm99FZceOHfr973/vM165cmWdOHEiIKEAAACkqygq5cqV0+HDh33Gt2/frurVqwckFAAAgHQVReXee+/V+PHjdeTIETkcDuXm5uqzzz7TH/7wBw0cOLAwMgIAgCDld1GZNm2aatWqperVq+vMmTNq0qSJOnbsqA4dOuiJJ54ojIwAACBIlfZnYWOMfvrpJ/3zn//U008/rW3btik3N1etWrVSgwYNCisjAJszxsjtdgd0Po/HI0lyOp1yOBwBm9vlcgV0PgCFy++i0qBBA+3cuVMNGjRQ3bp1CysXgGLE7XarZ8+eVscokOTkZIWHh1sdA0AB+bXrp1SpUmrQoAFn9wAAgCLh1xYVSfrzn/+sP/7xj5ozZ46aNWtWGJkAFDMul0vJyckBm8/tdis+Pl6SlJSUJJfLFbC5AzkXgMLnd1G57777dO7cObVs2VJhYWE+m1BPnjwZsHAAigeHw1Fou1NcLhe7aoAg5ndRmTlzZiHEAAAA8OV3URk0aFBh5AAAAPDhd1GRpJycHC1fvly7du2Sw+FQkyZN1LdvX4WEhAQ6HwAACGJ+F5W9e/fq1ltv1aFDh9SoUSMZY/T999+rZs2aev/991WvXr3CyAkAAIKQ31emHT16tOrVq6fU1FRt27ZN27dv18GDBxUTE6PRo0cXRkYAABCk/N6ism7dOm3cuFEVKlTwjlWsWFHPPfecbr755oCGAwAAwc3vLSpOp1OnT5/2GT9z5ozCwsICEgoAAEC6iqLyu9/9TsOGDdOmTZtkjJExRhs3btTDDz+svn37FkZGAAAQpPwuKi+88ILq1aun2NhYuVwuuVwu3Xzzzapfv75mzZpVGBkBAECQ8vsYlXLlyikpKUl79+7Vrl27ZIxRkyZNVL9+/cLIZzvcJRYAgKJzVddRkaT69esHTTm5FHeJBQCg6Pi96+fOO+/Uc8895zP+/PPP66677vJrrjlz5qhFixaKiopSVFSUYmNj9eGHH/obCQAAlFBXdXry5MmTfcZ79eqlv/zlL37NVaNGDT333HPeLTOvvfaa4uPjtX37djVt2tTfaEWCu8QCAFB0/C4qlzsNOTQ0VBkZGX7Nddttt+X5etq0aZozZ442btxo26LCXWIBACg6fu/6adasmZYuXeozvmTJEjVp0uSqg+Tk5GjJkiU6e/asYmNj813G4/EoIyMjzwcAACi5/N6i8uSTT+qOO+7Qvn371LVrV0nSmjVrtHjxYr311lt+B9ixY4diY2PldrtVtmxZLVu27LKFZ/r06Zo6darf3wMAABRPfm9R6du3r5YvX669e/dqxIgRGjdunNLS0rR69WolJCT4HaBRo0ZKSUnRxo0b9cgjj2jQoEH69ttv81124sSJSk9P936kpqb6/f0AAEDxcVWnJ/fp00d9+vQJSICwsDDvwbRt27bV5s2bNWvWLM2dO9dnWafTKafTGZDvCwAA7M/vLSqpqalKS0vzfv3ll19q7NixmjdvXkACXXoBNAAAENz8Lir33nuvPvnkE0nSkSNHdMstt+jLL7/UpEmT9NRTT/k116RJk7Rhwwb9+OOP2rFjhx5//HGtXbtWAwYM8DcWAAAogfwuKt98841+85vfSJL+7//+T82bN9fnn3+uN998U6+++qpfc/3888+6//771ahRI3Xr1k2bNm3SypUr1b17d39jAQCAEsjvY1SysrK8x4msXr3ae8fkG264QYcPH/Zrrn/961/+fnsAABBE/N6i0rRpU/3jH//Qhg0btGrVKvXq1UuS9NNPP6lixYoBDwgAAIKX30VlxowZmjt3rjp37qz+/furZcuWkqQVK1Z4dwkBAAAEgt+7fjp37qzjx48rIyND5cuX944PGzZMERERAQ0HAACC21VdRyUkJCRPSZGkOnXqBCIPAACAl9+7fgAAAIrKVW1RAQCgJDLGyO12Wx3jsi7NZuecLpdLDocjIHNRVAAA+C+3262ePXtaHaNA4uPjrY5wWcnJyQoPDw/IXH7v+lm4cGG+l7jPzMzUwoULAxIKAABAuootKkOGDFGvXr1UpUqVPOOnT5/WkCFDNHDgwICFAwDAKn1vHKHSpUKtjpGHMUY5udmSpJBSpQO2eyUQsnOztCJldsDn9buoGGPy/cGkpaUpOjo6IKEAALBa6VKhKh0SZnUMH6FyWh2hSBW4qLRq1UoOh0MOh0PdunVT6dL/e2pOTo7279/vvUotAABAIBS4qCQkJEiSUlJS1LNnT5UtW9b7WFhYmOrUqaM77rgj4AEBAEDwKnBRmTx5sqQLF3a755575HK5Ci0UAACAdBXHqAwaNKgwcgAAAPgoUFGpUKGCvv/+e1WqVEnly5e/4lHGJ0+eDFg4AAAQ3ApUVP7+978rMjJSkjRz5szCzAMAAOBVoKJy6e4edv0AAICiclWX0M/JydGyZcu0a9cuORwONW7cWPHx8XlOWQYAALhWfjeLb775RvHx8Tpy5IgaNWokSfr+++9VuXJlrVixQs2bNw94SAAAEJz8vtfPgw8+qKZNmyotLU3btm3Ttm3blJqaqhYtWmjYsGGFkREAAAQpv7eofPXVV9qyZYvKly/vHStfvrymTZumdu3aBTQcAAAIbn5vUWnUqJF+/vlnn/GjR4+qfv36AQkFAAAgFbCoZGRkeD+effZZjR49Wm+//bbS0tKUlpamt99+W2PHjtWMGTMKOy8AAAgiBdr1U65cuTwXeTPG6O677/aOGWMkSbfddptycnIKISYAAAhGBSoqn3zySWHnAAAA8FGgotKpU6fCzgEAAODD74NpAQAAigpFBQAA2BZFBQAA2BZFBQAA2BZFBQAA2FaBzvpp1apVnuuoXMm2bduuKRBQUMYYud3ugM7n8XgkSU6ns8D/5gvC5XIFdD4ACBYFKioJCQnez91ut2bPnq0mTZooNjZWkrRx40bt3LlTI0aMKJSQQH7cbrd69uxpdYwCSU5OVnh4uNUxAKDYKVBRmTx5svfzBx98UKNHj9bTTz/ts0xqampg0wEAgKDm992T33rrLW3ZssVn/L777lPbtm01f/78gAQDfo3L5VJycnLA5nO73YqPj5ckJSUlyeVyBWzuQM4FAMHE76ISHh6uTz/9VA0aNMgz/umnn/JmjCLlcDgKbXeKy+ViVw0A2IDfRWXs2LF65JFHtHXrVt10002SLhyjMn/+fP3pT38KeEAAABC8/C4qEyZMUN26dTVr1iy9+eabkqTGjRvr1Vdf1d133x3wgAAAIHj5XVQk6e6776aUAACAQndVF3w7deqUXnnlFU2aNEknT56UdOH6KYcOHQpoOAAAENz83qLy9ddf65ZbblF0dLR+/PFHPfjgg6pQoYKWLVumAwcOaOHChYWREwAABCG/t6gkJiZq8ODB2rNnT56zfHr37q3169cHNBwAAAhufheVzZs3a/jw4T7j1atX15EjRwISCgAAQLqKouJyuZSRkeEzvnv3blWuXDkgoQAAAKSrKCrx8fF66qmnlJWVJenCRbcOHjyoCRMm6I477gh4QAAAELz8Lip/+ctfdOzYMVWpUkXnz59Xp06dVL9+fUVGRmratGmFkREAAAQpv8/6iYqK0qeffqqPP/5Y27ZtU25urlq3bq1bbrmlMPIBQIlnjJHb7bY6Rr4uzWXXjBe5XC45HA6rYyDA/C4qCxcu1D333KOuXbuqa9eu3vHMzEwtWbJEAwcODGhAACjp3G63evbsaXWMX3Xxpp12lZyczD26SiC/d/0MGTJE6enpPuOnT5/WkCFDAhIKAABAuootKsaYfDetpaWlKTo6OiChACBYjZcUZnWISxhJWf/9PFSS3XasZEqaYXUIFKoCF5VWrVrJ4XDI4XCoW7duKl36f0/NycnR/v371atXr0IJCQDBIkxSmM3qgNPqAFdkrA6AQlbgopKQkCBJSklJUc+ePVW2bFnvY2FhYapTpw6nJwMAgIAqcFGZPHmyJKlOnTrq16+fnE57d+yL7Hw0vVR8jqjnaHoAgBX8PkalSZMmSklJUfv27fOMb9q0SSEhIWrbtm3AwgVCcTmaXrL3EfUcTQ8AsILfZ/2MHDlSqampPuOHDh3SyJEjAxIKAABAuootKt9++61at27tM96qVSt9++23AQlVWM62HiCV8vslFy5jpNzsC5+XKi3ZafdKbrbKbHvD6hQAgCDm919tp9Opn3/+WXXr1s0zfvjw4TxnAtlSqdJSSKjVKfJhp5MRASB4GfO/s4iyc7KusCR+6dKf16U/x2vld7Po3r27Jk6cqKSkJO91U06dOqVJkyape/fuAQsGAEBR83g83s9XfDXbwiTFm8fjUUREREDm8ruo/PWvf1XHjh1Vu3ZttWrVStKFU5arVq2qRYsWBSQUAACAdBVFpXr16vr666/1xhtv6KuvvlJ4eLiGDBmi/v37KzTUjrtVAAAomEsvvdG35QiVtuXhAvaUnZPl3QoVyEuYXNVBJWXKlNGwYcMCFgIAADu49HpRpUNCVTqEYwivRiCvu+X36cmStGjRIv32t79VtWrVdODAAUnS3//+dyUlJQUsGAAAgN9FZc6cOUpMTFTv3r31n//8Rzk5OZKk8uXLa+bMmYHOBwAAgpjfReXFF1/UP//5Tz3++ON5Tkdu27atduzY4ddc06dPV7t27RQZGakqVaooISFBu3fv9jcSAAAoofwuKvv37/ee7XMpp9Ops2fP+jXXunXrNHLkSG3cuFGrVq1Sdna2evTo4fc8AACgZPL7YNqYmBilpKSodu3aecY//PBDNWnSxK+5Vq5cmefrBQsWqEqVKtq6das6duzobzQAAFDC+F1U/vjHP2rkyJFyu90yxujLL7/U4sWLNX36dL3yyivXFCY9PV2SVKFChXwf93g8eS7Gk5GRcU3fDwAA2JvfRWXIkCHKzs7WY489pnPnzunee+9V9erVNWvWLPXr1++qgxhjlJiYqN/+9rdq1qxZvstMnz5dU6dOvervAQAAihe/ikp2drbeeOMN3XbbbXrooYd0/Phx5ebmqkqVKtccZNSoUfr666/16aefXnaZiRMnKjEx0ft1RkaGatasec3fGwAA2JNfRaV06dJ65JFHtGvXLklSpUqVAhLi0Ucf1YoVK7R+/XrVqFHjsss5nc6AXu0OAADYm99n/bRv317bt28PyDc3xmjUqFF655139PHHHysmJiYg8wIAgJLB72NURowYoXHjxiktLU1t2rRRmTJl8jzeokWLAs81cuRIvfnmm0pKSlJkZKSOHDkiSYqOjlZ4eLi/0QAAQAnjd1G55557JEmjR4/2jjkcDhlj5HA4vFeqLYg5c+ZIkjp37pxnfMGCBRo8eLC/0QAAQAnjd1HZv39/wL65MSZgc8H+jDFyu91Wx7isS7PZOackuVyugN70CwDsyq+ikpWVpS5duui9997z++JugNvtVs+ePa2OUSDx8fFWR7ii5ORkdo8CCAp+HUwbGhoqj8fD/+QAAECR8HvXz6OPPqoZM2bolVdeyXNTQsAfL3c8JWeIvXb9GSNl5l74PKyUZLc+7slxaOT6clbHAIAi5XfT2LRpk9asWaOPPvpIzZs39znr55133glYOJRczhAjV4jVKXzZe2eKvYodABQFv4tKuXLldMcddxRGFgAAgDz8LioLFiwojBwAAAA+rvogk2PHjmn37t1yOBxq2LChKleuHMhcAAAA/l9C/+zZsxo6dKiuv/56dezYUXFxcapWrZoeeOABnTt3rjAyAgCAIOV3UUlMTNS6dev07rvv6tSpUzp16pSSkpK0bt06jRs3rjAyAgCAIOX3rp9///vfevvtt/Nc9v7WW29VeHi47r77bu9l8QEAAK6V31tUzp07p6pVq/qMV6lShV0/AAAgoPwuKrGxsZo8eXKee6GcP39eU6dOVWxsbEDDAQCA4Ob3rp9Zs2apV69eqlGjhlq2bCmHw6GUlBS5XC4lJycXRkYAABCk/C4qzZo10549e/T666/ru+++kzFG/fr104ABA7hJGgAACKiruo5KeHi4HnrooUBnAQAAyMPvojJ9+nRVrVpVQ4cOzTM+f/58HTt2TOPHjw9YOACFwxiT5zgzu7k0m51zSpLL5eKO8kAh8ruozJ07V2+++abPeNOmTdWvXz+KClAMuN1u9ezZ0+oYBRIfH291hCtKTk5mt3cJlZ2bZXUEH8YY5eRmS5JCSpW2VUkurJ+X30XlyJEjuv76633GK1eurMOHDwckFAAAVluRMtvqCNBVFJWaNWvqs88+U0xMTJ7xzz77TNWqVQtYMABFI+e2nGu461chMZJy/vt5iCT7/Kfxgmwp5N0Qq1MAQcHvt6cHH3xQY8eOVVZWlrp27SpJWrNmjR577DEuoQ8UR6Vlv6IiSaFWB0AwsvulNtxut3d3aFJSklwul8WJ8hfIXH6/PT322GM6efKkRowYoczMTG+g8ePHa+LEiQELBgBAUXM4HMXmmCOXy1Vssl4Lv4uKw+HQjBkz9OSTT2rXrl0KDw9XgwYN5HQ6CyMfAAAIYle9wbds2bJq165dILMAAADk4fe9fgAAAIqKHQ+hCyhjzP++yLHfOfG2dsnPK8/P8SpdOocn5woLIl+X/swCsT4AoDgo8UXF4/F4Py+z3fdCdSgYj8ejiIiIa57jopHry19rpKAWiPUBAMUBu34AAIBtlfgtKpeejXS21b1SCBdnKLCcLO9WqECc1XXpHC93/I+cXC/LL56c/22J4iw7AMGixBeVPPdBCAmlqFylQNxP4tI5nCGSi6Jy1ex0fw8AKEzs+gEAALZFUQEAALZFUQEAALZFUQEAALZFUQEAALZFUQEAALZFUQEAALZFUQEAALZFUQEAALZV4q9MC8BXnrsvZ1uXo9i65GcW6DuLZ14YueY5g0XmJZ9zV/GSiaICBKFL72Qd8i73MrgWgb6z+IxrDRTEuKt4ycSuHwAAYFtsUQGC0KV3X865LYd3An9l/29LVKDvLD5eUtg1zxg8MvW/rVDcVbxk4u0JCEJ57r5cWrwTXINA31k8TFKYuDt2wf3vuBTuKl4ysesHAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYFkUFAADYVnDd4SM32+oEvoz5X65SpSU73avCjj8vAEBQCaqiUmbbG1ZHAAAAfmDXDwAAsK0Sv0XF5XIpOTnZ6hiX5Xa7FR8fL0lKSkqSy+WyOFH+7JoLAFCylfii4nA4FB4ebnWMAnG5XMUmKwAARYFdPwAAwLYoKgAAwLYoKgAAwLYoKgAAwLYsLSrr16/XbbfdpmrVqsnhcGj58uVWxgEAADZjaVE5e/asWrZsqZdeesnKGAAAwKYsPT25d+/e6t27t5URAACAjRWr66h4PB55PB7v1xkZGRamwbXw5DgkGatj5GGMlJl74fOwUva67ZJ08WcGAMGlWBWV6dOna+rUqVbHQACMXF/O6ggAgGKgWBWViRMnKjEx0ft1RkaGatasaWEioASw402yjaSc/34eIsluG5Ps+DMDSqhiVVScTqecTqfVMXCVuO9S4AQyW8i7IQGbC9cuU5KddosaSVn//TxU9uuMmVYHQKErVkUFxRv3XQJ+3QyrAwA2Y2lROXPmjPbu3ev9ev/+/UpJSVGFChVUq1YtC5MBJRtbtwLHztmAksDSorJlyxZ16dLF+/XF408GDRqkV1991aJUQMnH1i17sXNxpDTCapYWlc6dO8sY++yLBQArFJfiGAylEfbDvX4AAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtUVQAAIBtWXpTQgAlgzFGbrc7YPNdOlcg55Uu3FjP4XAEdE4AhYeiAuCaud1u9ezZs1Dmjo+PD+h8ycnJ3AEYKEYoKn7if472wboAYHfF5X3Kzu9RDmOMsTrE1crIyFB0dLTS09MVFRVVJN/z/PnzhfY/x0Ar6f9zZF3YR6DfjI0x8ng8kiSn0xnQN1A7vyEHSiDXh9vt9m7VSkpKksvlCsi8UnCsi+LyPlXU71H+/P1miwqAa+ZwOAL+JhcRERHQ+YJJYe2KYzccrEBR8ZPL5VJycnLA5ivs/zmWZKwLAHZXXN6n7Pwexa4fAChhArnrh91wKAzs+gGAIBboXXHshoOVuOAbAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLYoKAACwLcuLyuzZsxUTEyOXy6U2bdpow4YNVkcCAAA2YWlRWbp0qcaOHavHH39c27dvV1xcnHr37q2DBw9aGQsAANiEwxhjrPrm7du3V+vWrTVnzhzvWOPGjZWQkKDp06f/6vMzMjIUHR2t9PR0RUVFFWZUAAAQIP78/S5dRJl8ZGZmauvWrZowYUKe8R49eujzzz/P9zkej0cej8f7dXp6uqQLLxgAABQPF/9uF2RbiWVF5fjx48rJyVHVqlXzjFetWlVHjhzJ9znTp0/X1KlTfcZr1qxZKBkBAEDhOX36tKKjo6+4jGVF5SKHw5Hna2OMz9hFEydOVGJiovfr3NxcnTx5UhUrVrzsc4qDjIwM1axZU6mpqezCshjrwj5YF/bBurCXkrA+jDE6ffq0qlWr9qvLWlZUKlWqpJCQEJ+tJ0ePHvXZynKR0+mU0+nMM1auXLnCiljkoqKiiu0/upKGdWEfrAv7YF3YS3FfH7+2JeUiy876CQsLU5s2bbRq1ao846tWrVKHDh0sSgUAAOzE0l0/iYmJuv/++9W2bVvFxsZq3rx5OnjwoB5++GErYwEAAJuwtKjcc889OnHihJ566ikdPnxYzZo10wcffKDatWtbGavIOZ1OTZ482We3Fooe68I+WBf2wbqwl2BbH5ZeRwUAAOBKLL+EPgAAwOVQVAAAgG1RVAAAgG1RVAAAgG1RVCw2e/ZsxcTEyOVyqU2bNtqwYYPVkYLS+vXrddttt6latWpyOBxavny51ZGC1vTp09WuXTtFRkaqSpUqSkhI0O7du62OFZTmzJmjFi1aeC8sFhsbqw8//NDqWNCF3xOHw6GxY8daHaXQUVQstHTpUo0dO1aPP/64tm/frri4OPXu3VsHDx60OlrQOXv2rFq2bKmXXnrJ6ihBb926dRo5cqQ2btyoVatWKTs7Wz169NDZs2etjhZ0atSooeeee05btmzRli1b1LVrV8XHx2vnzp1WRwtqmzdv1rx589SiRQuroxQJTk+2UPv27dW6dWvNmTPHO9a4cWMlJCRo+vTpFiYLbg6HQ8uWLVNCQoLVUSDp2LFjqlKlitatW6eOHTtaHSfoVahQQc8//7weeOABq6MEpTNnzqh169aaPXu2nnnmGd14442aOXOm1bEKFVtULJKZmamtW7eqR48eecZ79Oihzz//3KJUgP2kp6dLuvAHEtbJycnRkiVLdPbsWcXGxlodJ2iNHDlSffr00S233GJ1lCJj+d2Tg9Xx48eVk5PjcwPGqlWr+tyoEQhWxhglJibqt7/9rZo1a2Z1nKC0Y8cOxcbGyu12q2zZslq2bJmaNGlidaygtGTJEm3btk2bN2+2OkqRoqhYzOFw5PnaGOMzBgSrUaNG6euvv9ann35qdZSg1ahRI6WkpOjUqVP697//rUGDBmndunWUlSKWmpqqMWPG6KOPPpLL5bI6TpGiqFikUqVKCgkJ8dl6cvToUZ+tLEAwevTRR7VixQqtX79eNWrUsDpO0AoLC1P9+vUlSW3bttXmzZs1a9YszZ071+JkwWXr1q06evSo2rRp4x3LycnR+vXr9dJLL8nj8SgkJMTChIWHY1QsEhYWpjZt2mjVqlV5xletWqUOHTpYlAqwnjFGo0aN0jvvvKOPP/5YMTExVkfCJYwx8ng8VscIOt26ddOOHTuUkpLi/Wjbtq0GDBiglJSUEltSJLaoWCoxMVH333+/2rZtq9jYWM2bN08HDx7Uww8/bHW0oHPmzBnt3bvX+/X+/fuVkpKiChUqqFatWhYmCz4jR47Um2++qaSkJEVGRnq3OkZHRys8PNzidMFl0qRJ6t27t2rWrKnTp09ryZIlWrt2rVauXGl1tKATGRnpc5xWmTJlVLFixRJ//BZFxUL33HOPTpw4oaeeekqHDx9Ws2bN9MEHH6h27dpWRws6W7ZsUZcuXbxfJyYmSpIGDRqkV1991aJUweni6fqdO3fOM75gwQINHjy46AMFsZ9//ln333+/Dh8+rOjoaLVo0UIrV65U9+7drY6GIMJ1VAAAgG1xjAoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigoAALAtigqAEmvt2rVyOBw6deqU1VEAXCWKCgAAsC2KCoASKSsry+oIAAKAogIgD2OM/vznP6tu3boKDw9Xy5Yt9fbbb+dZZufOnerTp4+ioqIUGRmpuLg47du377Jzrlu3Tr/5zW/kdDp1/fXXa8KECcrOzpYkzZ07V9WrV1dubm6e5/Tt21eDBg3yfv3uu++qTZs2crlcqlu3rqZOneqdQ5IcDof+8Y9/KD4+XmXKlNEzzzzjk+PEiRPq37+/atSooYiICDVv3lyLFy/Os0znzp01atQojRo1SuXKlVPFihX1xBNPiLuNABYxAHCJSZMmmRtuuMGsXLnS7Nu3zyxYsMA4nU6zdu1aY4wxaWlppkKFCub22283mzdvNrt37zbz58833333Xb7zpaWlmYiICDNixAiza9cus2zZMlOpUiUzefJkY4wxJ06cMGFhYWb16tXe55w8edKEhYWZ5ORkY4wxK1euNFFRUebVV181+/btMx999JGpU6eOmTJlivc5kkyVKlXMv/71L7Nv3z7z448/mk8++cRIMv/5z3+8WZ5//nmzfft2s2/fPvPCCy+YkJAQs3HjRu88nTp1MmXLljVjxowx3333nXn99ddNRESEmTdvXiB/zAAKiKICwOvMmTPG5XKZzz//PM/4Aw88YPr372+MMWbixIkmJibGZGZmFmjOSZMmmUaNGpnc3Fzv2Msvv2zKli1rcnJyjDHG9O3b1wwdOtT7+Ny5c811111nsrOzjTHGxMXFmWeffTbPvIsWLTLXX3+992tJZuzYsXmW+WVRyc+tt95qxo0b5/26U6dOpnHjxnnyjh8/3jRu3LhArxdAYJW2dnsOADv59ttv5Xa71b179zzjmZmZatWqlSQpJSVFcXFxCg0NLdCcu3btUmxsrBwOh3fs5ptv1pkzZ5SWlqZatWppwIABGjZsmGbPni2n06k33nhD/fr1U0hIiCRp69at2rx5s6ZNm+adIycnR263W+fOnVNERIQkqW3btlfMkpOTo+eee05Lly7VoUOH5PF45PF4VKZMmTzL3XTTTXnyxsbG6q9//atycnK8mQAUDYoKAK+Lx4m8//77ql69ep7HnE6nJCk8PNyvOY0xef7oXxyT5B2/7bbblJubq/fff1/t2rXThg0b9Le//S1PrqlTp+r222/3md/lcnk//2Xh+KW//vWv+vvf/66ZM2eqefPmKlOmjMaOHavMzEy/XhOAokNRAeDVpEkTOZ1OHTx4UJ06dcp3mRYtWui1115TVlZWgbaqNGnSRP/+97/zFJbPP/9ckZGR3jIUHh6u22+/XW+88Yb27t2rhg0bqk2bNt45Wrdurd27d6t+/frX9Po2bNig+Ph43XfffZIuFKA9e/aocePGeZbbuHGjz9cNGjRgawpgAc76AeAVGRmpP/zhD/p//+//6bXXXtO+ffu0fft2vfzyy3rttdckSaNGjVJGRob69eunLVu2aM+ePVq0aJF2796d75wjRoxQamqqHn30UX333XdKSkrS5MmTlZiYqFKl/vcWNGDAAL3//vuaP3++t0hc9Kc//UkLFy7UlClTtHPnTu3atUtLly7VE0884dfrq1+/vlatWqXPP/9cu3bt0vDhw3XkyBGf5VJTU5WYmKjdu3dr8eLFevHFFzVmzBi/vheAALH4GBkANpObm2tmzZplGjVqZEJDQ03lypVNz549zbp167zLfPXVV6ZHjx4mIiLCREZGmri4OLNv377Lzrl27VrTrl07ExYWZq677jozfvx4k5WVlWeZ7Oxsc/311xtJ+c61cuVK06FDBxMeHm6ioqLMb37zmzxn4kgyy5Yty/OcXx5Me+LECRMfH2/Kli1rqlSpYp544gkzcOBAEx8f731Op06dzIgRI8zDDz9soqKiTPny5c2ECRPyHFwLoOg4jOHiAABwUefOnXXjjTdq5syZVkcBIHb9AAAAG6OoAAAA22LXDwAAsC22qAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANuiqAAAANv6/0BXt4Sto0QOAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "same_structure_same_EC(arabidopsis_annot, arabidopsis_foldseek, human_annot, lowest_relevant_OG=\"Eukaryota\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "48d39bb0-ed6d-4aea-9235-374a37592fbb",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.10.8"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}