From 6223c1c7db1410ce2df21a4630a7985ace982e97 Mon Sep 17 00:00:00 2001
From: Henry Dowd <henrydowd@outlook.com>
Date: Wed, 11 Mar 2026 02:40:20 +0000
Subject: [PATCH] Final_Evaluation notebook and model

---
 notebooks/04_fusion_model.ipynb              |   740 +-
 notebooks/05_final_evaluation.ipynb          |  1414 +-
 notebooks/htmls/02_baseline_experiments.html | 12386 +++++++++--------
 requirments.txt                              |     2 +
 4 files changed, 8368 insertions(+), 6174 deletions(-)

diff --git a/notebooks/04_fusion_model.ipynb b/notebooks/04_fusion_model.ipynb
index 7b684ec..59430f9 100644
--- a/notebooks/04_fusion_model.ipynb
+++ b/notebooks/04_fusion_model.ipynb
@@ -13,10 +13,164 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "id": "1c45d83192facfc6",
    "metadata": {},
    "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "b0d416371b6c438bbcdc750301240d68",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "modules.json:   0%|          | 0.00/349 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "a7b1657fc75346a18c7d2a7a3f096313",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config_sentence_transformers.json:   0%|          | 0.00/116 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ae3f3f6247a5440abfe73a13fa69283e",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "README.md: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "629b99694e654a469d04c4b42385ba69",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "sentence_bert_config.json:   0%|          | 0.00/53.0 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ec714af14453479f84ea91fbdeb0a5e0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/612 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "70e163142ab04a53ae2b6d1eb83e08b0",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "model.safetensors:   0%|          | 0.00/90.9M [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "538150e747e04bccb34bb691ebb1f3ab",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer_config.json:   0%|          | 0.00/350 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ad4b584258754059b6f04052a8605813",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "vocab.txt: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "cef8aab72d51486dba9737d8e30e4239",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "tokenizer.json: 0.00B [00:00, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "979d08190f344bcaa4c87b3d697dc702",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "special_tokens_map.json:   0%|          | 0.00/112 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "049f02fb6f964b148a613c65cf0a3a69",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "config.json:   0%|          | 0.00/190 [00:00<?, ?B/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
     {
      "name": "stdout",
      "output_type": "stream",
@@ -36,7 +190,11 @@
     "from sklearn.linear_model import LogisticRegression\n",
     "from sklearn.metrics import classification_report, confusion_matrix, roc_auc_score, roc_curve\n",
     "from sentence_transformers import SentenceTransformer\n",
-    "import pickle\n",
+    "\n",
+    "from scipy.stats import mannwhitneyu\n",
+    "from statsmodels.stats.multitest import multipletests\n",
+    "\n",
+    "# import pickle\n",
     "\n",
     "# Load models\n",
     "nlp = spacy.load(\"en_core_web_lg\")\n",
@@ -86,7 +244,7 @@
     "    \n",
     "    # Partial overlap (high word similarity, low semantic similarity)\n",
     "    (\"The bank is on the river.\", \"The bank account is overdrawn.\"),                           # \"bank\" is only shared word; different meanings\n",
-    "    (\"I read the book last night.\", \"The book was read by many people.\"),                      # Same key words (book, read) but different focus/meaning\n",
+    "    (\"I read the book last night.\", \"The book was read by many people.\"),                      # Same key words (book, read) but different focus\n",
     "    \n",
     "    # Length variation (tests robustness to sentence length)\n",
     "    (\"Cat sat.\", \"The cat sat on the mat for hours and hours.\"),                               # Very different lengths, similar core meaning\n",
@@ -111,7 +269,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 29,
+   "execution_count": 2,
    "id": "9665682bd5a7951e",
    "metadata": {},
    "outputs": [
@@ -119,66 +277,314 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "TED Similarity: 0.857\n",
-      "(Higher score = more similar dependency structures)\n"
+      "Tree Structure Demo:\n",
+      "======================================================================\n",
+      "Sentence: 'The cat sat on the mat.'\n",
+      "Root token ID: 2\n",
+      "\n",
+      "Tree nodes:\n",
+      "  ID 0: 'The       ' POS=DET    DEP=det      Children=[]\n",
+      "  ID 1: 'cat       ' POS=NOUN   DEP=nsubj    Children=[0]\n",
+      "  ID 2: 'sat       ' POS=VERB   DEP=ROOT     Children=[1, 3, 6]\n",
+      "  ID 3: 'on        ' POS=ADP    DEP=prep     Children=[5]\n",
+      "  ID 4: 'the       ' POS=DET    DEP=det      Children=[]\n",
+      "  ID 5: 'mat       ' POS=NOUN   DEP=pobj     Children=[4]\n",
+      "  ID 6: '.         ' POS=PUNCT  DEP=punct    Children=[]\n"
      ]
     }
    ],
    "source": [
-    "def get_dependency_tree(text):\n",
-    "    \"\"\"Extract dependency tree structure from sentence.\"\"\"\n",
+    "def build_tree_from_dependencies(text):\n",
+    "    \"\"\"Build hierarchical tree structure from dependency parse.\"\"\"\n",
     "    doc = nlp(text)\n",
+    "    \n",
+    "    # node dictionary with parent-child relationships\n",
     "    tree = {}\n",
+    "    root_token = None\n",
+    "    \n",
     "    for token in doc:\n",
     "        tree[token.i] = {\n",
     "            'text': token.text,\n",
+    "            'lemma': token.lemma_,\n",
     "            'pos': token.pos_,\n",
     "            'dep': token.dep_,\n",
-    "            'head': token.head.i\n",
+    "            'head_id': token.head.i,\n",
+    "            'children': []\n",
     "        }\n",
-    "    return tree\n",
+    "    \n",
+    "    # parent-child relationships\n",
+    "    for token in doc:\n",
+    "        if token.head.i != token.i:  # Not root\n",
+    "            tree[token.head.i]['children'].append(token.i)\n",
+    "        else:  # Root node\n",
+    "            root_token = token.i\n",
+    "    \n",
+    "    return tree, root_token\n",
     "\n",
-    "def tree_edit_distance(tree1, tree2):\n",
+    "# small demo\n",
+    "s1 = \"The cat sat on the mat.\"\n",
+    "tree1, root1 = build_tree_from_dependencies(s1)\n",
+    "\n",
+    "print(\"Tree Structure Demo:\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"Sentence: '{s1}'\")\n",
+    "print(f\"Root token ID: {root1}\")\n",
+    "print(\"\\nTree nodes:\")\n",
+    "for node_id in sorted(tree1.keys()):\n",
+    "    node = tree1[node_id]\n",
+    "    print(f\"  ID {node_id}: '{node['text']:<10}' POS={node['pos']:<6} DEP={node['dep']:<8} Children={node['children']}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d36fd1dd",
+   "metadata": {},
+   "source": [
+    "### Helper functions for tree comparison"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "9d936f69",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Postorder Traversals:\n",
+      "======================================================================\n",
+      "Sentence 1: 'The cat sat on the mat.'\n",
+      "Postorder: [0, 1, 4, 5, 3, 6, 2]\n",
+      "Labels: [('DET', 'det'), ('NOUN', 'nsubj'), ('DET', 'det'), ('NOUN', 'pobj'), ('ADP', 'prep'), ('PUNCT', 'punct'), ('VERB', 'ROOT')]\n",
+      "\n",
+      "Sentence 2: 'On the mat, the cat was sitting.'\n",
+      "Postorder: [1, 2, 0, 3, 4, 5, 6, 8, 7]\n",
+      "Labels: [('DET', 'det'), ('NOUN', 'pobj'), ('ADP', 'prep'), ('PUNCT', 'punct'), ('DET', 'det'), ('NOUN', 'nsubj'), ('AUX', 'aux'), ('PUNCT', 'punct'), ('VERB', 'ROOT')]\n"
+     ]
+    }
+   ],
+   "source": [
+    "def get_nodes_postorder(node_id, tree):\n",
     "    \"\"\"\n",
-    "    Simple Tree Edit Distance approximation.\n",
-    "    Compares dependency structures without full algorithm (O(n^3) complexity).\n",
+    "    Get all nodes in postorder traversal (children before parents).\n",
+    "    This is required for Zhang-Shasha algorithm.\n",
     "    \"\"\"\n",
-    "    if not tree1 and not tree2:\n",
-    "        return 0.0\n",
-    "    if not tree1 or not tree2:\n",
+    "    nodes = []\n",
+    "    if node_id in tree:\n",
+    "        # traverse children first\n",
+    "        for child_id in tree[node_id]['children']:\n",
+    "            nodes.extend(get_nodes_postorder(child_id, tree))\n",
+    "        # then add parent\n",
+    "        nodes.append(node_id)\n",
+    "    return nodes\n",
+    "\n",
+    "def node_label(node_id, tree):\n",
+    "    \"\"\"\n",
+    "    Get label for a node (combination of POS tag and dependency relation).\n",
+    "    Two nodes match if they have the same (POS, DEP) pair.\n",
+    "    \"\"\"\n",
+    "    if node_id in tree:\n",
+    "        return (tree[node_id]['pos'], tree[node_id]['dep'])\n",
+    "    return ('', '')\n",
+    "\n",
+    "def nodes_match(node_id1, tree1, node_id2, tree2):\n",
+    "    \"\"\"Check if two nodes have matching labels (same POS and DEP).\"\"\"\n",
+    "    label1 = node_label(node_id1, tree1)\n",
+    "    label2 = node_label(node_id2, tree2)\n",
+    "    return label1 == label2\n",
+    "\n",
+    "# small demo\n",
+    "s2 = \"On the mat, the cat was sitting.\"\n",
+    "tree2, root2 = build_tree_from_dependencies(s2)\n",
+    "\n",
+    "print(\"Postorder Traversals:\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"Sentence 1: '{s1}'\")\n",
+    "nodes1 = get_nodes_postorder(root1, tree1)\n",
+    "print(f\"Postorder: {nodes1}\")\n",
+    "labels1 = [node_label(n, tree1) for n in nodes1]\n",
+    "print(f\"Labels: {labels1}\")\n",
+    "\n",
+    "print(f\"\\nSentence 2: '{s2}'\")\n",
+    "nodes2 = get_nodes_postorder(root2, tree2)\n",
+    "print(f\"Postorder: {nodes2}\")\n",
+    "labels2 = [node_label(n, tree2) for n in nodes2]\n",
+    "print(f\"Labels: {labels2}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5f99f2ea",
+   "metadata": {},
+   "source": [
+    "### Zhang-Shasha Tree Edit Distance"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "6a91abd3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Tree Edit Distance Calculation:\n",
+      "======================================================================\n",
+      "Sentence 1: 'The cat sat on the mat.'\n",
+      "Sentence 2: 'On the mat, the cat was sitting.'\n",
+      "\n",
+      "Tree 1 size: 7 nodes\n",
+      "Tree 2 size: 9 nodes\n",
+      "\n",
+      "Zhang-Shasha Tree Edit Distance Similarity: 0.444\n",
+      "(Higher = more similar tree structures)\n"
+     ]
+    }
+   ],
+   "source": [
+    "def tree_edit_distance_zhang_shasha(tree1, tree2, root1, root2):\n",
+    "    \"\"\"\n",
+    "    Full Tree Edit Distance using Zhang-Shasha algorithm.\n",
+    "    \n",
+    "    Compares two trees by:\n",
+    "    1. Computing minimum edit operations (insert, delete, replace)\n",
+    "    2. Preserving hierarchical structure and node ordering\n",
+    "    3. Matching nodes by (POS tag, dependency relation)\n",
+    "    \n",
+    "    Returns: Normalized similarity score (0-1)\n",
+    "    \"\"\"\n",
+    "    \n",
+    "    # get postorder traversals of both trees\n",
+    "    nodes1 = get_nodes_postorder(root1, tree1)\n",
+    "    nodes2 = get_nodes_postorder(root2, tree2)\n",
+    "    \n",
+    "    m, n = len(nodes1), len(nodes2)\n",
+    "    \n",
+    "    # Initialize DP table\n",
+    "    # dp[i][j] = minimum edit distance between first i nodes of tree1 and first j nodes of tree2\n",
+    "    dp = [[0] * (n + 1) for _ in range(m + 1)]\n",
+    "    \n",
+    "    # Base cases: converting empty tree to/from another tree\n",
+    "    for i in range(m + 1):\n",
+    "        dp[i][0] = i  # Delete all i nodes from tree1\n",
+    "    for j in range(n + 1):\n",
+    "        dp[0][j] = j  # Insert all j nodes to get tree2\n",
+    "    \n",
+    "    # Fill DP table\n",
+    "    for i in range(1, m + 1):\n",
+    "        for j in range(1, n + 1):\n",
+    "            node1 = nodes1[i - 1]\n",
+    "            node2 = nodes2[j - 1]\n",
+    "            \n",
+    "            if nodes_match(node1, tree1, node2, tree2):\n",
+    "                # nodes match: no operation needed\n",
+    "                cost = dp[i - 1][j - 1]\n",
+    "            else:\n",
+    "                # nodes don't match: choose cheapest operation\n",
+    "                delete_cost = dp[i - 1][j] + 1      # Delete node from tree1\n",
+    "                insert_cost = dp[i][j - 1] + 1      # Insert node into tree1\n",
+    "                replace_cost = dp[i - 1][j - 1] + 1 # Replace node\n",
+    "                cost = min(delete_cost, insert_cost, replace_cost)\n",
+    "            \n",
+    "            dp[i][j] = cost\n",
+    "    \n",
+    "    # convert edit distance to similarity (0-1)\n",
+    "    max_size = max(m, n)\n",
+    "    if max_size == 0:\n",
     "        return 1.0\n",
     "    \n",
-    "    # Extract dependency edges\n",
-    "    edges1 = set()\n",
-    "    edges2 = set()\n",
+    "    edit_distance = dp[m][n]\n",
+    "    similarity = 1.0 - (edit_distance / max_size)\n",
     "    \n",
-    "    for i, node1 in tree1.items():\n",
-    "        edges1.add((node1['dep'], node1['pos']))\n",
-    "    \n",
-    "    for i, node2 in tree2.items():\n",
-    "        edges2.add((node2['dep'], node2['pos']))\n",
-    "    \n",
-    "    # Jaccard similarity on edges\n",
-    "    if not edges1 and not edges2:\n",
-    "        return 1.0\n",
-    "    \n",
-    "    intersection = len(edges1.intersection(edges2))\n",
-    "    union = len(edges1.union(edges2))\n",
-    "    \n",
-    "    return intersection / union if union > 0 else 0.0\n",
+    "    return max(0.0, similarity)\n",
     "\n",
+    "# small demo\n",
+    "ted_score = tree_edit_distance_zhang_shasha(tree1, tree2, root1, root2)\n",
+    "\n",
+    "print(\"Tree Edit Distance Calculation:\")\n",
+    "print(\"=\" * 70)\n",
+    "print(f\"Sentence 1: '{s1}'\")\n",
+    "print(f\"Sentence 2: '{s2}'\")\n",
+    "print(f\"\\nTree 1 size: {len(tree1)} nodes\")\n",
+    "print(f\"Tree 2 size: {len(tree2)} nodes\")\n",
+    "print(f\"\\nZhang-Shasha Tree Edit Distance Similarity: {ted_score:.3f}\")\n",
+    "print(\"(Higher = more similar tree structures)\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c01a28b5",
+   "metadata": {},
+   "source": [
+    "### Wrapper for TED similarity"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "16436c70",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Sentence Similarity using Tree Edit Distance:\n",
+      "======================================================================\n",
+      "\n",
+      "'The cat sat on the mat.'\n",
+      "  vs\n",
+      "'The cat sat on the mat.'\n",
+      "  → Similarity: 1.000\n",
+      "\n",
+      "'The cat sat on the mat.'\n",
+      "  vs\n",
+      "'On the mat, the cat was sitting.'\n",
+      "  → Similarity: 0.444\n",
+      "\n",
+      "'The cat sat on the mat.'\n",
+      "  vs\n",
+      "'The dog ran in the park.'\n",
+      "  → Similarity: 1.000\n"
+     ]
+    }
+   ],
+   "source": [
     "def sentence_similarity_ted(sent1, sent2):\n",
-    "    \"\"\"Compute similarity using Tree Edit Distance.\"\"\"\n",
-    "    tree1 = get_dependency_tree(sent1)\n",
-    "    tree2 = get_dependency_tree(sent2)\n",
-    "    return tree_edit_distance(tree1, tree2)\n",
+    "    \"\"\"\n",
+    "    Compute similarity between two sentences using Tree Edit Distance.\n",
+    "    Analyzes full hierarchical tree structure.\n",
+    "    \"\"\"\n",
+    "    if not sent1.strip() or not sent2.strip():\n",
+    "        return 0.0\n",
+    "    \n",
+    "    try:\n",
+    "        tree1, root1 = build_tree_from_dependencies(sent1)\n",
+    "        tree2, root2 = build_tree_from_dependencies(sent2)\n",
+    "        return tree_edit_distance_zhang_shasha(tree1, tree2, root1, root2)\n",
+    "    except:\n",
+    "        return 0.0\n",
     "\n",
     "# Demo\n",
-    "s1 = \"The cat sat on the mat.\"\n",
-    "s2 = \"On the mat, the cat was sitting.\"\n",
+    "print(\"\\nSentence Similarity using Tree Edit Distance:\")\n",
+    "print(\"=\" * 70)\n",
+    "test_pairs_demo = [\n",
+    "    (\"The cat sat on the mat.\", \"The cat sat on the mat.\"),\n",
+    "    (\"The cat sat on the mat.\", \"On the mat, the cat was sitting.\"),\n",
+    "    (\"The cat sat on the mat.\", \"The dog ran in the park.\"),\n",
+    "]\n",
     "\n",
-    "print(f\"TED Similarity: {sentence_similarity_ted(s1, s2):.3f}\")\n",
-    "print(\"(Higher score = more similar dependency structures)\")"
+    "for sent1, sent2 in test_pairs_demo:\n",
+    "    sim = sentence_similarity_ted(sent1, sent2)\n",
+    "    print(f\"\\n'{sent1}'\")\n",
+    "    print(f\"  vs\")\n",
+    "    print(f\"'{sent2}'\")\n",
+    "    print(f\"  → Similarity: {sim:.3f}\")"
    ]
   },
   {
@@ -192,7 +598,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 30,
+   "execution_count": 6,
    "id": "91282393",
    "metadata": {},
    "outputs": [
@@ -242,7 +648,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 31,
+   "execution_count": 7,
    "id": "54916598",
    "metadata": {},
    "outputs": [
@@ -253,7 +659,7 @@
       "Feature Extraction Demo:\n",
       "============================================================\n",
       "bert           : 0.930\n",
-      "ted            : 0.857\n",
+      "ted            : 0.444\n",
       "jaccard        : 0.375\n",
       "len_ratio      : 0.719\n"
      ]
@@ -303,7 +709,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 32,
+   "execution_count": 8,
    "id": "e8a13c18",
    "metadata": {},
    "outputs": [
@@ -359,14 +765,14 @@
        "    <tr>\n",
        "      <th>mean</th>\n",
        "      <td>0.671</td>\n",
-       "      <td>0.671</td>\n",
+       "      <td>0.663</td>\n",
        "      <td>0.405</td>\n",
        "      <td>0.786</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>std</th>\n",
        "      <td>0.271</td>\n",
-       "      <td>0.338</td>\n",
+       "      <td>0.330</td>\n",
        "      <td>0.328</td>\n",
        "      <td>0.266</td>\n",
        "    </tr>\n",
@@ -380,14 +786,14 @@
        "    <tr>\n",
        "      <th>25%</th>\n",
        "      <td>0.506</td>\n",
-       "      <td>0.364</td>\n",
+       "      <td>0.429</td>\n",
        "      <td>0.200</td>\n",
        "      <td>0.760</td>\n",
        "    </tr>\n",
        "    <tr>\n",
        "      <th>50%</th>\n",
        "      <td>0.652</td>\n",
-       "      <td>0.800</td>\n",
+       "      <td>0.714</td>\n",
        "      <td>0.333</td>\n",
        "      <td>0.857</td>\n",
        "    </tr>\n",
@@ -412,11 +818,11 @@
       "text/plain": [
        "         bert     ted  jaccard  len_ratio\n",
        "count  29.000  29.000   29.000     29.000\n",
-       "mean    0.671   0.671    0.405      0.786\n",
-       "std     0.271   0.338    0.328      0.266\n",
+       "mean    0.671   0.663    0.405      0.786\n",
+       "std     0.271   0.330    0.328      0.266\n",
        "min     0.067   0.000    0.000      0.000\n",
-       "25%     0.506   0.364    0.200      0.760\n",
-       "50%     0.652   0.800    0.333      0.857\n",
+       "25%     0.506   0.429    0.200      0.760\n",
+       "50%     0.652   0.714    0.333      0.857\n",
        "75%     0.930   1.000    0.600      0.957\n",
        "max     1.000   1.000    1.000      1.000"
       ]
@@ -457,13 +863,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 33,
+   "execution_count": 9,
    "id": "292e3d91",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 2 Axes>"
       ]
@@ -479,10 +885,10 @@
       "Feature Correlation Insights:\n",
       "================================================================================\n",
       "               bert       ted   jaccard  len_ratio\n",
-      "bert       1.000000  0.257085  0.770717   0.157109\n",
-      "ted        0.257085  1.000000  0.337151   0.531403\n",
-      "jaccard    0.770717  0.337151  1.000000   0.149126\n",
-      "len_ratio  0.157109  0.531403  0.149126   1.000000\n"
+      "bert       1.000000  0.219195  0.770717   0.157109\n",
+      "ted        0.219195  1.000000  0.272899   0.621469\n",
+      "jaccard    0.770717  0.272899  1.000000   0.149126\n",
+      "len_ratio  0.157109  0.621469  0.149126   1.000000\n"
      ]
     }
    ],
@@ -513,7 +919,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 34,
+   "execution_count": 10,
    "id": "4bea7544",
    "metadata": {},
    "outputs": [
@@ -568,6 +974,188 @@
     "plt.show()"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "id": "db7ede30",
+   "metadata": {},
+   "source": [
+    "### Statistical Feature Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "27a74280",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mann-Whitney U Test: Feature Discrimination Power\n",
+      "==========================================================================================\n",
+      "Tests whether each feature separates Paraphrases from Non-Paraphrases\n",
+      "\n",
+      "Feature         U-stat     p-value    p-corrected  Effect   Sig?   Med(Para)  Med(Diff)\n",
+      "------------------------------------------------------------------------------------------\n",
+      "bert            210.0      0.0000     0.0000       -1.000 (LARGE) ✓✓✓    0.938      0.506\n",
+      "jaccard         189.5      0.0002     0.0005       -0.805 (LARGE) ✓✓✓    0.600      0.200\n",
+      "ted             142.0      0.1013     0.1351       -0.352 (MED  ) ✗      0.929      0.429\n",
+      "len_ratio       125.5      0.3821     0.3821       -0.195 (SMALL) ✗      0.899      0.818\n",
+      "\n",
+      "==========================================================================================\n",
+      "Interpretation:\n",
+      "  - Effect size: >0 means feature is higher for paraphrases\n",
+      "  - p-corrected: Benjamini-Hochberg FDR correction (controls false discoveries)\n",
+      "  - ✓✓✓ = p<0.001 (highly significant), ✓✓ = p<0.01, ✓ = p<0.05, ✗ = not significant\n"
+     ]
+    }
+   ],
+   "source": [
+    "def mann_whitney_feature_test(df, feature_col, label_col='label'):\n",
+    "    \"\"\"\n",
+    "    Test if feature distributions differ significantly between classes.\n",
+    "    \n",
+    "    Returns:\n",
+    "    - U statistic, p-value, effect size, medians\n",
+    "    \"\"\"\n",
+    "    group0 = df[df[label_col] == 0][feature_col].dropna().values\n",
+    "    group1 = df[df[label_col] == 1][feature_col].dropna().values\n",
+    "    \n",
+    "    if len(group0) < 2 or len(group1) < 2:\n",
+    "        return None  # Not enough data\n",
+    "    \n",
+    "    # Two-sided test: are distributions different?\n",
+    "    u_stat, p_val = mannwhitneyu(group1, group0, alternative='two-sided')\n",
+    "    \n",
+    "    # Rank-biserial correlation (effect size: -1 to +1)\n",
+    "    n1, n0 = len(group1), len(group0)\n",
+    "    rbc = 1 - (2 * u_stat) / (n1 * n0)\n",
+    "    \n",
+    "    return {\n",
+    "        \"feature\": feature_col,\n",
+    "        \"n_paraphrase\": n1,\n",
+    "        \"n_different\": n0,\n",
+    "        \"U_statistic\": u_stat,\n",
+    "        \"p_value\": p_val,\n",
+    "        \"effect_size\": rbc,  # >0.5 = large, >0.3 = medium, >0.1 = small\n",
+    "        \"median_paraphrase\": np.median(group1),\n",
+    "        \"median_different\": np.median(group0),\n",
+    "    }\n",
+    "\n",
+    "# Test all features\n",
+    "print(\"Mann-Whitney U Test: Feature Discrimination Power\")\n",
+    "print(\"=\" * 90)\n",
+    "print(\"Tests whether each feature separates Paraphrases from Non-Paraphrases\\n\")\n",
+    "\n",
+    "test_results = []\n",
+    "for feature in ['bert', 'ted', 'jaccard', 'len_ratio']:\n",
+    "    result = mann_whitney_feature_test(feature_df, feature)\n",
+    "    if result:\n",
+    "        test_results.append(result)\n",
+    "\n",
+    "# Apply Benjamini-Hochberg correction for multiple testing\n",
+    "p_values = [r['p_value'] for r in test_results]\n",
+    "reject, p_corrected, _, _ = multipletests(p_values, alpha=0.05, method='fdr_bh')\n",
+    "\n",
+    "# Add corrected p-values\n",
+    "for i, result in enumerate(test_results):\n",
+    "    result['p_corrected'] = p_corrected[i]\n",
+    "    result['significant'] = reject[i]\n",
+    "\n",
+    "# Display results\n",
+    "results_df = pd.DataFrame(test_results)\n",
+    "results_df = results_df.sort_values('effect_size', ascending=False, key=abs)\n",
+    "\n",
+    "print(f\"{'Feature':<15} {'U-stat':<10} {'p-value':<10} {'p-corrected':<12} {'Effect':<8} {'Sig?':<6} {'Med(Para)':<10} {'Med(Diff)'}\")\n",
+    "print(\"-\" * 90)\n",
+    "\n",
+    "for _, row in results_df.iterrows():\n",
+    "    sig_mark = \"✓✓✓\" if row['p_corrected'] < 0.001 else (\"✓✓\" if row['p_corrected'] < 0.01 else (\"✓\" if row['significant'] else \"✗\"))\n",
+    "    effect_interp = \"LARGE\" if abs(row['effect_size']) > 0.5 else (\"MED\" if abs(row['effect_size']) > 0.3 else \"SMALL\")\n",
+    "    \n",
+    "    print(f\"{row['feature']:<15} {row['U_statistic']:<10.1f} {row['p_value']:<10.4f} {row['p_corrected']:<12.4f} \"\n",
+    "          f\"{row['effect_size']:>+.3f} ({effect_interp:<5}) {sig_mark:<6} {row['median_paraphrase']:<10.3f} {row['median_different']:.3f}\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\" * 90)\n",
+    "print(\"Interpretation:\")\n",
+    "print(\"  - Effect size: >0 means feature is higher for paraphrases\")\n",
+    "print(\"  - p-corrected: Benjamini-Hochberg FDR correction (controls false discoveries)\")\n",
+    "print(\"  - ✓✓✓ = p<0.001 (highly significant), ✓✓ = p<0.01, ✓ = p<0.05, ✗ = not significant\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "4d9fc526",
+   "metadata": {},
+   "source": [
+    "#### Visualize Mann-Whitney U"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "2c877a29",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Key Insight: BERT has the strongest separation between classes\n",
+      "Effect size: -1.000 (p=0.0000)\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "# 1: Effect sizes\n",
+    "features_sorted = results_df.sort_values('effect_size')\n",
+    "colors = ['green' if x else 'red' for x in features_sorted['significant']]\n",
+    "\n",
+    "axes[0].barh(features_sorted['feature'], features_sorted['effect_size'], color=colors, alpha=0.7)\n",
+    "axes[0].axvline(x=0, color='black', linestyle='--', linewidth=1)\n",
+    "axes[0].axvline(x=0.3, color='orange', linestyle=':', linewidth=1, alpha=0.5, label='Medium effect')\n",
+    "axes[0].axvline(x=-0.3, color='orange', linestyle=':', linewidth=1, alpha=0.5)\n",
+    "axes[0].set_xlabel('Effect Size (Rank-Biserial Correlation)')\n",
+    "axes[0].set_title('Feature Discrimination: Effect Sizes\\n(Green = significant after FDR correction)')\n",
+    "axes[0].legend()\n",
+    "axes[0].grid(axis='x', alpha=0.3)\n",
+    "\n",
+    "# 2: Distribution comparison for best feature\n",
+    "best_feature = results_df.iloc[0]['feature']\n",
+    "group0 = feature_df[feature_df['label'] == 0][best_feature]\n",
+    "group1 = feature_df[feature_df['label'] == 1][best_feature]\n",
+    "\n",
+    "axes[1].hist(group0, bins=10, alpha=0.6, label=f'Non-Paraphrase (n={len(group0)})', color='red', edgecolor='black')\n",
+    "axes[1].hist(group1, bins=10, alpha=0.6, label=f'Paraphrase (n={len(group1)})', color='green', edgecolor='black')\n",
+    "axes[1].axvline(np.median(group0), color='darkred', linestyle='--', linewidth=2, label=f'Median Non-Para: {np.median(group0):.3f}')\n",
+    "axes[1].axvline(np.median(group1), color='darkgreen', linestyle='--', linewidth=2, label=f'Median Para: {np.median(group1):.3f}')\n",
+    "axes[1].set_xlabel(f'{best_feature.upper()} Score')\n",
+    "axes[1].set_ylabel('Frequency')\n",
+    "axes[1].set_title(f'Distribution Comparison: {best_feature.upper()}\\n(Best discriminating feature)')\n",
+    "axes[1].legend()\n",
+    "axes[1].grid(axis='y', alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "print(f\"\\nKey Insight: {best_feature.upper()} has the strongest separation between classes\")\n",
+    "print(f\"Effect size: {results_df.iloc[0]['effect_size']:+.3f} (p={results_df.iloc[0]['p_corrected']:.4f})\")"
+   ]
+  },
   {
    "cell_type": "markdown",
    "id": "64c8b61b",
@@ -579,7 +1167,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 35,
+   "execution_count": 12,
    "id": "0d0a4596",
    "metadata": {},
    "outputs": [
@@ -597,10 +1185,10 @@
       "\n",
       "Feature Importance (Model Coefficients):\n",
       "================================================================================\n",
-      "bert           : +1.7731\n",
-      "ted            : +0.2136\n",
-      "jaccard        : +0.9931\n",
-      "len_ratio      : +0.0666\n"
+      "bert           : +1.7775\n",
+      "ted            : +0.2371\n",
+      "jaccard        : +0.9941\n",
+      "len_ratio      : +0.0367\n"
      ]
     }
    ],
@@ -646,7 +1234,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 36,
+   "execution_count": 13,
    "id": "ed9f0973",
    "metadata": {},
    "outputs": [
@@ -725,13 +1313,13 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 37,
+   "execution_count": 14,
    "id": "6dc8a0c6",
    "metadata": {},
    "outputs": [
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA94AAAHqCAYAAADyGZa5AAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjgsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvwVt1zgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAZABJREFUeJzt3Xd4FOX+/vF70xtJKKkQQu9dioAcimCoB0RFAgKhWRE5UsQGRKoFlaKICgSRIl1EAZFDExQQCDXSpOkJvYYSSHZ+f/DLfl2ygSTusht4v65rL7Mzzz7zmX1miHdm9lmTYRiGAAAAAACAQ7g5uwAAAAAAAO5nBG8AAAAAAByI4A0AAAAAgAMRvAEAAAAAcCCCNwAAAAAADkTwBgAAAADAgQjeAAAAAAA4EMEbAAAAAAAHIngDAAAAAOBABG8AAIDbmEwmDRs2zNll5FqjRo3UqFEjZ5dxTxUrVkxxcXG5em1eH28Aro/gDQC45xISEmQymWw+Bg8e7JBtbty4UcOGDdOFCxcc0v8/kfF+/Pbbb84uJdc+/fRTJSQkOLsMlxUXF5flMb98+XJnl2c3a9assezX119/bbNN/fr1ZTKZVKlSpXtcHQA4j4ezCwAAPLjeeecdFS9e3GqZo/5nfOPGjYqPj1dcXJyCg4Mdso0H2aeffqpChQrl+oqjq7l27Zo8POz7v0ne3t768ssvMy2vWrWqXbcjST/++KPd+8wJHx8fzZo1S88884zV8iNHjmjjxo3y8fFxUmUA4BwEbwCA07Ro0UI1a9Z0dhn/yJUrV+Tv7+/sMpzm6tWr8vPzc3YZdueIYOjh4ZEpiDqKl5fXPdlOVlq2bKklS5bozJkzKlSokGX5rFmzFBYWptKlS+v8+fNOrBAA7i1uNQcAuKxly5apQYMG8vf3V758+dSqVSvt2bPHqs3OnTsVFxenEiVKyMfHR+Hh4erRo4fOnj1raTNs2DANHDhQklS8eHHLrbBHjhzRkSNHZDKZbN4mffvnPocNGyaTyaS9e/eqU6dOyp8/vx555BHL+q+//loPPfSQfH19VaBAAXXs2FHHjx/P1b7HxcUpICBAx44dU+vWrRUQEKDChQvrk08+kSTt2rVLTZo0kb+/v6KjozVr1iyr12fcvr5u3To999xzKliwoAIDA9W1a1ebgefTTz9VxYoV5e3trcjISL300kuZbstv1KiRKlWqpK1bt+pf//qX/Pz89MYbb6hYsWLas2eP1q5da3lvMz5ffO7cOQ0YMECVK1dWQECAAgMD1aJFC+3YscOq74xblOfOnauRI0eqSJEi8vHx0aOPPqqDBw9mqnfTpk1q2bKl8ufPL39/f1WpUkXjxo2zavP777/rySefVIECBeTj46OaNWtqyZIl2Xr/sxr7gwcPWu6aCAoKUvfu3XX16tVs9XknGfu/Zs0aq+W2js8TJ06oe/fuKlKkiLy9vRUREaG2bdvqyJEjlja2PuN96tQp9ezZU2FhYfLx8VHVqlU1ffp0m9v74IMP9Pnnn6tkyZLy9vZWrVq1tGXLlmzvT9u2beXt7a158+ZZLZ81a5Y6dOggd3f3TK9JS0vT8OHDLdssVqyY3njjDaWmplq1MwxDI0aMUJEiReTn56fGjRtn+nchw4ULF9SvXz9FRUXJ29tbpUqV0rvvviuz2ZztfQEAe+CKNwDAaS5evKgzZ85YLcu4OjZjxgx169ZNMTExevfdd3X16lVNmjRJjzzyiLZv365ixYpJklauXKk//vhD3bt3V3h4uPbs2aPPP/9ce/bs0a+//iqTyaT27dtr//79mj17tj766CPLNkJCQnT69Okc1/3UU0+pdOnSGjVqlAzDkCSNHDlSb7/9tjp06KBevXrp9OnTmjBhgv71r39p+/btubq9PT09XS1atNC//vUvvffee5o5c6b69Okjf39/vfnmm+rcubPat2+vzz77TF27dlXdunUz3brfp08fBQcHa9iwYdq3b58mTZqko0ePWoKedCtUxsfHq2nTpnrhhRcs7bZs2aINGzbI09PT0t/Zs2fVokULdezYUc8884zCwsLUqFEjvfzyywoICNCbb74pSQoLC5Mk/fHHH1q8eLGeeuopFS9eXCdPntTkyZPVsGFD7d27V5GRkVb1jhkzRm5ubhowYIAuXryo9957T507d9amTZssbVauXKnWrVsrIiJCr7zyisLDw5WUlKSlS5fqlVdekSTt2bNH9evXV+HChTV48GD5+/tr7ty5ateunRYsWKDHH388x+MhSR06dFDx4sU1evRobdu2TV9++aVCQ0P17rvvZuv1tx/vnp6eCgoKylENTzzxhPbs2aOXX35ZxYoV06lTp7Ry5UodO3bMcl7c7tq1a2rUqJEOHjyoPn36qHjx4po3b57i4uJ04cIFy/uWYdasWbp8+bKee+45mUwmvffee2rfvr3++OMPq+MhK35+fmrbtq1mz56tF154QZK0Y8cO7dmzR19++aV27tyZ6TW9evXS9OnT9eSTT6p///7atGmTRo8eraSkJC1atMjSbsiQIRoxYoRatmypli1batu2bXrsscd048YNq/6uXr2qhg0b6q+//tJzzz2nokWLauPGjXr99deVnJysjz/++K77AQB2YwAAcI9NmzbNkGTzYRiGcfnyZSM4ONjo3bu31etOnDhhBAUFWS2/evVqpv5nz55tSDLWrVtnWfb+++8bkozDhw9btT18+LAhyZg2bVqmfiQZQ4cOtTwfOnSoIcmIjY21anfkyBHD3d3dGDlypNXyXbt2GR4eHpmWZ/V+bNmyxbKsW7duhiRj1KhRlmXnz583fH19DZPJZMyZM8ey/Pfff89Ua0afDz30kHHjxg3L8vfee8+QZHz77beGYRjGqVOnDC8vL+Oxxx4z0tPTLe0mTpxoSDKmTp1qWdawYUNDkvHZZ59l2oeKFSsaDRs2zLT8+vXrVv0axq333Nvb23jnnXcsy1avXm1IMsqXL2+kpqZalo8bN86QZOzatcswDMNIS0szihcvbkRHRxvnz5+36tdsNlt+fvTRR43KlSsb169ft1pfr149o3Tp0pnqvF1WY9+jRw+rdo8//rhRsGDBu/aXMZ63PzLes4z9X716tdXrbj8+z58/b0gy3n///Ttur2HDhlbj8fHHHxuSjK+//tqy7MaNG0bdunWNgIAA49KlS1bbK1iwoHHu3DlL22+//daQZHz33Xd33G7GfsybN89YunSpYTKZjGPHjhmGYRgDBw40SpQoYamvYsWKltclJiYakoxevXpZ9TdgwABDkvHf//7XMIz/O15btWplNd5vvPGGIcno1q2bZdnw4cMNf39/Y//+/VZ9Dh482HB3d7fUZRiZxxsA7I1bzQEATvPJJ59o5cqVVg/p1hXNCxcuKDY2VmfOnLE83N3dVadOHa1evdrSh6+vr+Xn69ev68yZM3r44YclSdu2bXNI3c8//7zV84ULF8psNqtDhw5W9YaHh6t06dJW9eZUr169LD8HBwerbNmy8vf3V4cOHSzLy5Ytq+DgYP3xxx+ZXv/ss89aXaF84YUX5OHhoR9++EGS9NNPP+nGjRvq16+f3Nz+738LevfurcDAQH3//fdW/Xl7e6t79+7Zrt/b29vSb3p6us6ePauAgACVLVvW5vh0797d6vPJDRo0kCTLvm3fvl2HDx9Wv379Mt1FkHEF/9y5c/rvf/+rDh066PLly5bxOHv2rGJiYnTgwAH99ddf2d6Hv7t97Bs0aKCzZ8/q0qVLd32tj49PpuN97NixOdq+r6+vvLy8tGbNmhx9RvqHH35QeHi4YmNjLcs8PT3Vt29fpaSkaO3atVbtn376aeXPn9/y/PZxyI7HHntMBQoU0Jw5c2QYhubMmWO1/dvrk6RXX33Vann//v0lyXIcZhyvL7/8smW8Jalfv36Z+pw3b54aNGig/PnzW52XTZs2VXp6utatW5ftfQGAf4pbzQEATlO7dm2bk6sdOHBAktSkSRObrwsMDLT8fO7cOcXHx2vOnDk6deqUVbuLFy/asdr/c/vt3AcOHJBhGCpdurTN9tm5NdcWHx8fhYSEWC0LCgpSkSJFrEJHxnJbQez2mgICAhQREWH5PPDRo0cl3Qrvf+fl5aUSJUpY1mcoXLhwjibuMpvNGjdunD799FMdPnxY6enplnUFCxbM1L5o0aJWzzPCX8a+HTp0SNKdZ78/ePCgDMPQ22+/rbfffttmm1OnTqlw4cLZ3o/s1Pf349IWd3d3NW3aNMfb/Dtvb2+9++676t+/v8LCwvTwww+rdevW6tq1q8LDw7N83dGjR1W6dGmrP65IUvny5S3r/+5u45Adnp6eeuqppzRr1izVrl1bx48fV6dOnbKsz83NTaVKlbJaHh4eruDgYEt9Gf+9/bgOCQmx+kOBdOu83LlzZ6ZzKMPt/14AgCMRvAEALidj4qMZM2bYDBN//5qnDh06aOPGjRo4cKCqVaumgIAAmc1mNW/ePFsTKN0eYDP8PSDe7u9X2TPqNZlMWrZsmc1JowICAu5ahy22+rrTcuP/f97ckW7f97sZNWqU3n77bfXo0UPDhw9XgQIF5Obmpn79+tkcH3vsW0a/AwYMUExMjM02twe87HLUe5+T47Bfv35q06aNFi9erBUrVujtt9/W6NGj9d///lfVq1f/R3VksNd+durUSZ999pmGDRumqlWrqkKFCndsn9X7kBtms1nNmjXToEGDbK4vU6aM3bYFAHdD8AYAuJySJUtKkkJDQ+94hfD8+fNatWqV4uPjNWTIEMvyjCvmf5fV/9BnXCW7fQbv268A3q1ewzBUvHhxl/uf+QMHDqhx48aW5ykpKUpOTlbLli0lSdHR0ZKkffv2qUSJEpZ2N27c0OHDh7N9hTar93f+/Plq3LixpkyZYrX8woULVl8zlV0Zx8bu3buzrC1jPzw9Pf/xFeZ7JafHYcmSJdW/f3/1799fBw4cULVq1TR27Fh9/fXXNttHR0dr586dMpvNVle9f//9d8t6R3jkkUdUtGhRrVmz5o4T0EVHR8tsNuvAgQOWq/CSdPLkSV24cMFSX8Z/Dxw4YHW8nj59OtPV+JIlSyolJSXPHAMA7m98xhsA4HJiYmIUGBioUaNG6ebNm5nWZ8xEnnFV7varcLZmK874ru3bg01gYKAKFSqU6fOen376abbrbd++vdzd3RUfH5+pFsMwrL7a7F77/PPPrd7DSZMmKS0tTS1atJAkNW3aVF5eXho/frxV7VOmTNHFixfVqlWrbG3H398/03sr3Rqj29+TefPm5foz1jVq1FDx4sX18ccfZ9pexnZCQ0PVqFEjTZ48WcnJyZn6yM1M9o4WHR0td3f3ux6HV69e1fXr162WlSxZUvny5cv0tVt/17JlS504cULffPONZVlaWpomTJiggIAANWzY0A57kZnJZNL48eM1dOhQdenS5Y71SZnP3Q8//FCSLMdh06ZN5enpqQkTJlgdV7bO+Q4dOuiXX37RihUrMq27cOGC0tLScro7AJBrXPEGALicwMBATZo0SV26dFGNGjXUsWNHhYSE6NixY/r+++9Vv359TZw4UYGBgZav2rp586YKFy6sH3/8UYcPH87U50MPPSRJevPNN9WxY0d5enqqTZs28vf3V69evTRmzBj16tVLNWvW1Lp167R///5s11uyZEmNGDFCr7/+uo4cOaJ27dopX758Onz4sBYtWqRnn31WAwYMsNv7kxM3btzQo48+qg4dOmjfvn369NNP9cgjj+jf//63pFufjX399dcVHx+v5s2b69///relXa1atfTMM89kazsPPfSQJk2apBEjRqhUqVIKDQ1VkyZN1Lp1a73zzjvq3r276tWrp127dmnmzJlWVytzws3NTZMmTVKbNm1UrVo1de/eXREREfr999+1Z88eS8j65JNP9Mgjj6hy5crq3bu3SpQooZMnT+qXX37Rn3/+mel7xJ0tKChITz31lCZMmCCTyaSSJUtq6dKlmT6HvH//fst4VqhQQR4eHlq0aJFOnjypjh07Ztn/s88+q8mTJysuLk5bt25VsWLFNH/+fG3YsEEff/yx8uXL57B9a9u2rdq2bXvHNlWrVlW3bt30+eef68KFC2rYsKE2b96s6dOnq127dpa7NkJCQjRgwACNHj1arVu3VsuWLbV9+3YtW7Ys0x0UAwcO1JIlS9S6dWvFxcXpoYce0pUrV7Rr1y7Nnz9fR44cydVdFwCQGwRvAIBL6tSpkyIjIzVmzBi9//77Sk1NVeHChdWgQQOrWbVnzZqll19+WZ988okMw9Bjjz2mZcuWZfp+6Fq1amn48OH67LPPtHz5cpnNZh0+fFj+/v4aMmSITp8+rfnz52vu3Llq0aKFli1bptDQ0GzXO3jwYJUpU0YfffSR4uPjJUlRUVF67LHHLCHXGSZOnKiZM2dqyJAhunnzpmJjYzV+/HirW8OHDRumkJAQTZw4Uf/5z39UoEABPfvssxo1alS2J4YbMmSIjh49qvfee0+XL19Ww4YN1aRJE73xxhu6cuWKZs2apW+++UY1atTQ999/r8GDB+d6n2JiYrR69WrFx8dr7NixMpvNKlmypHr37m1pU6FCBf3222+Kj49XQkKCzp49q9DQUFWvXt3qYwmuZMKECbp586Y+++wzeXt7q0OHDnr//fetJpKLiopSbGysVq1apRkzZsjDw0PlypXT3Llz9cQTT2TZt6+vr9asWaPBgwdr+vTpunTpksqWLatp06YpLi7uHuzd3X355ZcqUaKEEhIStGjRIoWHh+v111/X0KFDrdqNGDFCPj4++uyzz7R69WrVqVNHP/74Y6a7M/z8/LR27VqNGjVK8+bN01dffaXAwECVKVNG8fHxOf7+dAD4J0zGvZiJBQAA3FMJCQnq3r27tmzZYnPmeAAAcO/wGW8AAAAAAByI4A0AAAAAgAMRvAEAAAAAcCA+4w0AAAAAgANxxRsAAAAAAAcieAMAAAAA4EB8jzf+EbPZrP/973/Kly+f1XfCAgAAAMD9zDAMXb58WZGRkXJzu/M1bYI3/pH//e9/ioqKcnYZAAAAAOAUx48fV5EiRe7YhuCNfyRfvnySpN27dxPA8yCz2azTp08rJCTkrn+lg2th7PI2xi9vY/zyNsYvb2P88rb7bfwuXbqkqKgoSya6E4I3/pGM28vz5cunwMBAJ1eDnDKbzbp+/boCAwPvi3/8HiSMXd7G+OVtjF/exvjlbYxf3na/jl92PnJ7/+wtAAAAAAAuiOANAAAAAIADEbxhF9n5XAMAAAAAPIgI3rALs9ns7BIAAAAAwCURvGEXV65ccXYJAAAAAOCSCN4AAAAAADgQwRsAAAAAAAcieAMAAAAA4EAEb9hFYGCgs0sAAAAAAJdE8IZdpKWlObsEAAAAAHBJBG/YxdWrV51dAgAAAAC4JII3AAAAAAAORPAGAAAAAMCBCN6wCzc3DiUAAAAAsIW0BLsICAhwdgkAAAAA4JII3rCLGzduOLsEAAAAAHBJHs4uAPeHznM7y6egT65e+13sd3auBgAAAABcB1e8AQAAAABwIII3AAAAAAAORPCGfXAkAQAAAIBNxCXYhYc30wUAAAAAgC0Eb9hFelq6s0sAAAAAAJdE8IZdGDcNZ5cAAAAAAC6J4A0AAAAAgAMRvAEAAAAAcCCCN+zC5GFydgkAAAAA4JII3rALd093Z5cAAAAAAC6J4A27SL/JrOYAAAAAYAvBG3ZhpDGrOQAAAADYQvAGAAAAAMCBCN4AAAAAADgQwRt2YfJkVnMAAAAAsIXgDbtw92BWcwAAAACwheANu0hLTXN2CQAAAADgkgjesA+zswsAAAAAANdE8AYAAAAAwIEI3gAAAAAAOBDBG3bh5sWhBAAAAAC2kJZgF27uHEoAAAAAYAtpCXbBrOYAAAAAYBvBG/bBrOYAAAAAYBPBGwAAAAAAByJ4AwAAAADgQARv2IWbN4cSAAAAANhCWoJduLlxKAEAAACALaQl2EXaNWY1BwAAAABbCN4AAAAAADgQwRsAAAAAAAcieAMAAAAA4EAEbweKi4tTu3btnF2GFZPJpMWLF9u9X3dvd7v3CQAAAAD3gzwfvF0h3B45ckQmk0mJiYn/uK+EhASZTCaZTCa5ubkpIiJCTz/9tI4dO5ajfoYNG6Zq1aplWp6cnKwWLVr84zozMdm/SwAAAAC4H+T54H0/CgwMVHJysv766y8tWLBA+/bt01NPPWWXvsPDw+Xt7W2Xvv4u/Xq63fsEAAAAgPvBfR+8d+/erRYtWiggIEBhYWHq0qWLzpw5Y1nfqFEj9e3bV4MGDVKBAgUUHh6uYcOGWfXx+++/65FHHpGPj48qVKign376yeqW7eLFi0uSqlevLpPJpEaNGlm9/oMPPlBERIQKFiyol156STdv3rxjzSaTSeHh4YqIiFC9evXUs2dPbd68WZcuXbK0ee2111SmTBn5+fmpRIkSevvtty39JiQkKD4+Xjt27LBcPU9ISLD0/fdbzXft2qUmTZrI19dXBQsW1LPPPquUlJQcvMMAAAAAgDu5r4P3hQsX1KRJE1WvXl2//fabli9frpMnT6pDhw5W7aZPny5/f39t2rRJ7733nt555x2tXLlSkpSenq527drJz89PmzZt0ueff64333zT6vWbN2+WJP30009KTk7WwoULLetWr16tQ4cOafXq1Zo+fboSEhIsITg7Tp06pUWLFsnd3V3u7v/3Oep8+fIpISFBe/fu1bhx4/TFF1/oo48+kiQ9/fTT6t+/vypWrKjk5GQlJyfr6aefztT3lStXFBMTo/z582vLli2aN2+efvrpJ/Xp0yfLelJTU3Xp0iWrBwAAAAAgax7OLsCRJk6cqOrVq2vUqFGWZVOnTlVUVJT279+vMmXKSJKqVKmioUOHSpJKly6tiRMnatWqVWrWrJlWrlypQ4cOac2aNQoPD5ckjRw5Us2aNbP0GRISIkkqWLCgpU2G/Pnza+LEiXJ3d1e5cuXUqlUrrVq1Sr17986y7osXLyogIECGYejq1auSpL59+8rf39/S5q233rL8XKxYMQ0YMEBz5szRoEGD5Ovrq4CAAHl4eGSq5+9mzZql69ev66uvvrL0PXHiRLVp00bvvvuuwsLCMr1m9OjRio+Pz7JPAAAAAIC1+zp479ixQ6tXr1ZAQECmdYcOHbIK3n8XERGhU6dOSZL27dunqKgoqwBbu3btbNdQsWJFqyvVERER2rVr1x1fky9fPm3btk03b97UsmXLNHPmTI0cOdKqzTfffKPx48fr0KFDSklJUVpamgIDA7NdlyQlJSWpatWqVoG+fv36MpvN2rdvn83g/frrr+vVV1+1PL906ZKioqLk7sOs5gAAAABgy30dvFNSUixXb28XERFh+dnT09NqnclkktlstksNuenbzc1NpUqVkiSVL19ehw4d0gsvvKAZM2ZIkn755Rd17txZ8fHxiomJUVBQkObMmaOxY8fapeY78fb2tj05m+HwTQMAAABAnnRfB+8aNWpowYIFKlasmDw8crerZcuW1fHjx3Xy5EnLFeAtW7ZYtfHy8pJ06/PgjjB48GCVLFlS//nPf1SjRg1t3LhR0dHRVp81P3r0aKaa7lZP+fLllZCQoCtXrliuem/YsEFubm4qW7ZsjmpMT02XZ4Dn3RsCAAAAwAPmvphc7eLFi0pMTLR6HD9+XC+99JLOnTun2NhYbdmyRYcOHdKKFSvUvXv3bIfkZs2aqWTJkurWrZt27typDRs2WD5fbTLd+vLq0NBQ+fr6WiZvu3jxol33LyoqSo8//riGDBki6dbn0I8dO6Y5c+bo0KFDGj9+vBYtWmT1mmLFiunw4cNKTEzUmTNnlJqamqnfzp07y8fHR926ddPu3bu1evVqvfzyy+rSpYvN28wBAAAAADl3XwTvNWvWqHr16laP+Ph4RUZGasOGDUpPT9djjz2mypUrq1+/fgoODpabW/Z23d3dXYsXL1ZKSopq1aqlXr16Wa40+/j4SJI8PDw0fvx4TZ48WZGRkWrbtq3d9/E///mPvv/+e23evFn//ve/9Z///Ed9+vRRtWrVtHHjRr399ttW7Z944gk1b95cjRs3VkhIiGbPnp2pTz8/P61YsULnzp1TrVq19OSTT+rRRx/VxIkT7V4/AAAAADyoTIZh8OncHNqwYYMeeeQRHTx4UCVLlnR2OU516dIlBQUFqemEpvIp6JOrPr6L/c7OVSG7zGazTp06pdDQ0Gz/MQqugbHL2xi/vI3xy9sYv7yN8cvb7rfxy8hCFy9evOtE1/f1Z7ztZdGiRQoICFDp0qV18OBBvfLKK6pfv/4DH7r/zsOXQwkAAAAAbCEtZcPly5f12muv6dixYypUqJCaNm16T2YQz0vsNQs8AAAAANxvCN7Z0LVrV3Xt2tXZZbg0c6pZyvx16QAAAADwwMv7N9YDAAAAAODCCN4AAAAAADgQwRv2wZEEAAAAADYRl2AXHt5MFwAAAAAAthC8YRfmdGY1BwAAAABbCN6wC/MNgjcAAAAA2ELwBgAAAADAgQjeAAAAAAA4EMEb9sGRBAAAAAA2EZdgF8xqDgAAAAC2EbxhF+lp6c4uAQAAAABcEsEbdmHcNJxdAgAAAAC4JII3AAAAAAAORPAGAAAAAMCBCN6wC5OHydklAAAAAIBLInjDLtw93Z1dAgAAAAC4JII37CL9JrOaAwAAAIAtBG/YhZHGrOYAAAAAYAvBGwAAAAAAByJ4AwAAAADgQARv2IXJk1nNAQAAAMAWgjfswt2DWc0BAAAAwBaCN+wiLTXN2SUAAAAAgEsieMM+zM4uAAAAAABcE8EbAAAAAAAHIngDAAAAAOBABG/YhZsXhxIAAAAA2EJagl24uXMoAQAAAIAtpCXYBbOaAwAAAIBtHs4uAPeHKa2nqGjRos4uAwAAAABcDle8AQAAAABwIII3AAAAAAAORPCGXfj5+Tm7BAAAAABwSQRv2IWHB9MFAAAAAIAtBG/YxaVLl5xdAgAAAAC4JII3AAAAAAAORPAGAAAAAMCBCN4AAAAAADgQwRt24e/v7+wSAAAAAMAlEbxhF25uHEoAAAAAYAtpCXZx+fJlZ5cAAAAAAC6J4A0AAAAAgAMRvAEAAAAAcCCCNwAAAAAADkTwhl3ky5fP2SUAAAAAgEsieMMuzGazs0sAAAAAAJdE8IZdXLlyxdklAAAAAIBLIngDAAAAAOBAHs4uAPeHnkt6yqegj7PLQA6ZZFKUe5SOpx+XIcPZ5SAHGLu8jfHLu76L/c7ZJQAA8iCueAMAAAAA4EAEb9iFhy83TwAAAACALQRv2AWzmgMAAACAbQRv2IU5leANAAAAALYQvAEAAAAAcCCCNwAAAAAADkTwhn1wJAEAAACATcQl2IWHN7OaAwAAAIAtBG/YhTmdydUAAAAAwBaCN+zCfIPgDQAAAAC2ELwBAAAAAHAggjcAAAAAAA5E8IZ9cCQBAAAAgE3EJdgFs5oDAAAAgG0Eb9hFelq6s0sAAAAAAJdE8IZdGDcNZ5cAAAAAAC6J4A0AAAAAgAMRvAEAAAAAcCCCN+zC5GFydgkAAAAA4JII3rALd093Z5cAAAAAAC6J4A27SL/JrOYAAAAAYAvBG3ZhpDGrOQAAAADYQvAGAAAAAMCBCN4AAAAAADgQwRt2YfJkVnMAAAAAsIXgDbtw92BWcwAAAACwheANu0hLTXN2CQAAAADgkgjesA+zswsAAAAAANdE8AYAAAAAwIEI3gAAAAAAOBDBG3bh5sWhBAAAAAC2kJZgF27uHEoAAAAAYAtpCXbBrOYAAAAAYNsDEbwbNWqkfv363bXdv/71L82aNcvxBeXAkSNHZDKZlJiYKElas2aNTCaTLly4YLdtnDlzRqGhofrzzz9z3wmzmgMAAACATTkK3nFxcWrXrp2DSnGuJUuW6OTJk+rYsaNlWbFixWQymWQymeTu7q7IyEj17NlT58+fd1qd9erVU3JysoKCguzWZ6FChdS1a1cNHTrUbn0CAAAAAG65b654G4ahtLTc3+48fvx4de/eXW5u1m/JO++8o+TkZB07dkwzZ87UunXr1Ldv339abq55eXkpPDxcJpPJrv12795dM2fO1Llz5+zaLwAAAAA86HIdvJcvX65HHnlEwcHBKliwoFq3bq1Dhw5Ztfnzzz8VGxurAgUKyN/fXzVr1tSmTZss67/77jvVqlVLPj4+KlSokB5//HHLuhkzZqhmzZrKly+fwsPD1alTJ506dcqyPuOW62XLlumhhx6St7e3fv75Z125ckVdu3ZVQECAIiIiNHbs2Lvuy+nTp/Xf//5Xbdq0ybQuY/uFCxdW48aN1a1bN23bts2y/uzZs4qNjVXhwoXl5+enypUra/bs2VZ9zJ8/X5UrV5avr68KFiyopk2b6sqVK5b1X375pcqXLy8fHx+VK1dOn376aZa13n6reUJCgoKDg7VixQqVL19eAQEBat68uZKTk61ed7dtVKxYUZGRkVq0aNFd3y9b3Lzvm7/hAAAAAIBd5TotXblyRa+++qp+++03rVq1Sm5ubnr88cdlNt/6sG9KSooaNmyov/76S0uWLNGOHTs0aNAgy/rvv/9ejz/+uFq2bKnt27dr1apVql27tqX/mzdvavjw4dqxY4cWL16sI0eOKC4uLlMdgwcP1pgxY5SUlKQqVapo4MCBWrt2rb799lv9+OOPWrNmjVVQtuXnn3+Wn5+fypcvf8d2f/31l7777jvVqVPHsuz69et66KGH9P3332v37t169tln1aVLF23evFmSlJycrNjYWPXo0UNJSUlas2aN2rdvL8MwJEkzZ87UkCFDNHLkSCUlJWnUqFF6++23NX369LsPwv939epVffDBB5oxY4bWrVunY8eOacCAAZb12d1G7dq1tX79+jtuKzU1VZcuXbJ6SMp0pwAAAAAA4BaP3L7wiSeesHo+depUhYSEaO/evapUqZJmzZql06dPa8uWLSpQoIAkqVSpUpb2I0eOVMeOHRUfH29ZVrVqVcvPPXr0sPxcokQJjR8/XrVq1VJKSooCAgIs69555x01a9ZM0q2wP2XKFH399dd69NFHJUnTp09XkSJF7rgvR48eVVhYmM3w+Nprr+mtt95Senq6rl+/rjp16ujDDz+0rC9cuLBVyH355Ze1YsUKzZ07V7Vr11ZycrLS0tLUvn17RUdHS5IqV65saT906FCNHTtW7du3lyQVL15ce/fu1eTJk9WtW7c71p3h5s2b+uyzz1SyZElJUp8+ffTOO+/keBuRkZHavn37Hbc1evRoqzHLkHYtTR5+uT6cAAAAAOC+levLlAcOHFBsbKxKlCihwMBAFStWTJJ07NgxSVJiYqKqV69uCd23S0xMtIRjW7Zu3ao2bdqoaNGiypcvnxo2bGjVf4aaNWtafj506JBu3LhhdUW6QIECKlu27B335dq1a/Lx8bG5buDAgUpMTNTOnTu1atUqSVKrVq2Unp4uSUpPT9fw4cNVuXJlFShQQAEBAVqxYoWlzqpVq+rRRx9V5cqV9dRTT+mLL76wTM525coVHTp0SD179lRAQIDlMWLEiEy37d+Jn5+fJXRLUkREhOW2/Jxsw9fXV1evXr3jtl5//XVdvHjR8jh+/Hi26wQAAACAB1GuL1G2adNG0dHR+uKLLxQZGSmz2axKlSrpxo0bkm6FuDu50/orV64oJiZGMTExmjlzpkJCQnTs2DHFxMRY+s/g7++f212wKFSoUJYzlRcqVMhypb506dL6+OOPVbduXa1evVpNmzbV+++/r3Hjxunjjz9W5cqV5e/vr379+lnqdHd318qVK7Vx40b9+OOPmjBhgt58801t2rRJfn5+kqQvvvjC6o8FGa/LLk9PT6vnJpPJcit7SkpKtrdx7tw5hYSE3HFb3t7e8vb2znZtAAAAAPCgy9UV77Nnz2rfvn1666239Oijj6p8+fKZgmuVKlWUmJiY5SzZVapUsVxBvt3vv/+us2fPasyYMWrQoIHKlStnNbFaVkqWLClPT0+rCdzOnz+v/fv33/F11atX14kTJ7L1NWEZYfXatWuSpA0bNqht27Z65plnVLVqVZUoUSLT9kwmk+rXr6/4+Hht375dXl5eWrRokcLCwhQZGak//vhDpUqVsnoUL178rrVkR062sXv3blWvXt0u2wUAAAAA3JKrK9758+dXwYIF9fnnnysiIkLHjh3T4MGDrdrExsZq1KhRateunUaPHq2IiAht375dkZGRqlu3roYOHapHH31UJUuWVMeOHZWWlqYffvhBr732mooWLSovLy9NmDBBzz//vHbv3q3hw4ffta6AgAD17NlTAwcOVMGCBRUaGqo333zzrhN/Va9eXYUKFdKGDRvUunVrq3WXL1/WiRMnZBiGjh8/rkGDBikkJET16tWTdOsq+Pz587Vx40blz59fH374oU6ePKkKFSpIkjZt2qRVq1bpscceU2hoqDZt2qTTp09bJnKLj49X3759FRQUpObNmys1NVW//fabzp8/r1dffTXbY3In2dnG1atXtXXrVo0aNSpX23D3zv4VegAAAAB4kOToirfZbJaHh4fc3Nw0Z84cbd26VZUqVdJ//vMfvf/++1Ztvby89OOPPyo0NFQtW7ZU5cqVNWbMGMsV40aNGmnevHlasmSJqlWrpiZNmlhmAg8JCVFCQoLmzZunChUqaMyYMfrggw+yVeP777+vBg0aqE2bNmratKkeeeQRPfTQQ3d8jbu7u+V7rG83ZMgQRUREKDIyUq1bt5a/v79+/PFHFSxYUJL01ltvqUaNGoqJiVGjRo0UHh6udu3aWV4fGBiodevWqWXLlipTpozeeustjR07Vi1atJAk9erVS19++aWmTZumypUrq2HDhkpISLDbFe/sbuPbb79V0aJF1aBBg9xtxL5fKw4AAAAA9w2TkfFh4Gxo3ry5SpUqpYkTJzqyJqc4ceKEKlasqG3btllmH3+QPPzww+rbt686deqUo9ddunRJQUFBajqhqXwK2p6gDq7LJJOi3KN0PP24DGX7nwK4AMYub2P88q7vYr+T2WzWqVOnFBoaytdp5kGMX97G+OVt99v4ZWShixcvKjAw8I5ts7W358+f19KlS7VmzRo1bdrULkW6mvDwcE2ZMiXTrOkPgjNnzqh9+/aKjY11dikAAAAAcN/J1me8e/TooS1btqh///5q27ato2tymr/fIv4gKVSokAYNGuTsMgAAAADgvpSt4L1o0SJH1wEAAAAAwH0p799YD5fg7sOs5gAAAABgC8Eb9sHcQAAAAABgE8EbdpGemu7sEgAAAADAJRG8AQAAAABwIII3AAAAAAAORPAGAAAAAMCBCN6wCw/fbH0zHQAAAAA8cAjesAuz2ezsEgAAAADAJRG8YRfmVII3AAAAANhC8AYAAAAAwIEI3gAAAAAAOBDBG/bBkQQAAAAANhGXYBce3sxqDgAAAAC2ELxhF+Z0JlcDAAAAAFsI3rAL8w2CNwAAAADYQvAGAAAAAMCBCN4AAAAAADgQwRv2wZEEAAAAADYRl2AXzGoOAAAAALYRvGEX6Wnpzi4BAAAAAFwSwRt2Ydw0nF0CAAAAALgkgjcAAAAAAA5E8AYAAAAAwIEI3rALk4fJ2SUAAAAAgEsieMMu3D3dnV0CAAAAALgkgjfsIv0ms5oDAAAAgC0Eb9iFkcas5gAAAABgC8EbAAAAAAAHIngDAAAAAOBAHs4uAPeHr5/6WmFhYc4uAzlkNpt16tQphYaGys2Nv8PlJYxd3sb4AQDwYOG3PezC29vb2SUAAAAAgEsieMMurly54uwSAAAAAMAlEbxhF+npfJ0YAAAAANhC8AYAAAAAwIEI3gAAAAAAOBDBG3bh4+Pj7BIAAAAAwCURvGEXXl5ezi4BAAAAAFwSwRt2kZKS4uwSAAAAAMAlEbxhF2az2dklAAAAAIBLIngDAAAAAOBABG8AAAAAAByI4A278PPzc3YJAAAAAOCSCN6wCw8PD2eXAAAAAAAuieANu7h06ZKzSwAAAAAAl0TwBgAAAADAgQjeAAAAAAA4EMEbAAAAAAAHInjDLvz9/Z1dAgAAAAC4JKaihl10XtRZnv6ezi4Dd/Bd7HfOLgEAAAB4IHHFG3aRfj3d2SUAAAAAgEsieAMAAAAA4EAEbwAAAAAAHIjgDQAAAACAAxG8YRfuPu7OLgEAAAAAXBLBG/ZhOLsAAAAAAHBNBG/YRXoqs5oDAAAAgC0EbwAAAAAAHIjgDQAAAACAAxG8AQAAAABwIII37MLD18PZJQAAAACASyJ4wy7MZrOzSwAAAAAAl0Twhl2YUwneAAAAAGALwRsAAAAAAAcieAMAAAAA4EAEb9gHRxIAAAAA2ERcgl14eDOrOQAAAADYQvCGXZjTmVwNAAAAAGwheMMuzDcI3gAAAABgC8EbAAAAAAAHIngDAAAAAOBABG/YB0cSAAAAANhEXIJdMKs5AAAAANhG8IZdpKelO7sEAAAAAHBJBG/YhXHTcHYJAAAAAOCSCN4AAAAAADgQwRsAAAAAAAcieMMuTB4mZ5cAAAAAAC6J4A27cPd0d3YJAAAAAOCSCN6wi/SbzGoOAAAAALYQvGEXRhqzmgMAAACALQRvAAAAAAAc6IEN3l26dNGoUaOcXYZDFStWTB9//HG22i5fvlzVqlWT2Wx2bFEAAAAA8IC5p8HbZDLd8TFs2DAdOXIky/W//vqrJCkhIcGyzN3dXfnz51edOnX0zjvv6OLFi3etY8eOHfrhhx/Ut29fy7LDhw+rU6dOioyMlI+Pj4oUKaK2bdvq999/t9v+Z+xbYmKi3fqUbr0fwcHBmZZv2bJFzz77bLb6aN68uTw9PTVz5sxc1WDyZFZzAAAAALDF415uLDk52fLzN998oyFDhmjfvn2WZQEBATpz5owk6aefflLFihWtXl+wYEHLz4GBgdq3b58Mw9CFCxe0ceNGjR49WtOmTdOGDRsUGRmZZR0TJkzQU089pYCAAEnSzZs31axZM5UtW1YLFy5URESE/vzzTy1btkwXLlywx647RUhISI7ax8XFafz48erSpUuOt+XuwazmAAAAAGDLPb3iHR4ebnkEBQXJZDJZLcsIwtKtkP33deHh4fL09LSsz3htRESEypcvr549e2rjxo1KSUnRoEGDsqwhPT1d8+fPV5s2bSzL9uzZo0OHDunTTz/Vww8/rOjoaNWvX18jRozQww8/LElq0qSJ+vTpY9XX6dOn5eXlpVWrVkm6dWv3qFGj1KNHD+XLl09FixbV559/bmlfvHhxSVL16tVlMpnUqFEjSbeuTDdr1kyFChVSUFCQGjZsqG3btllt68KFC3ruuecUFhYmHx8fVapUSUuXLtWaNWvUvXt3Xbx40erOgYx6/n6reVZ9ZGjTpo1+++03HTp0KMv3LytpqWk5fg0AAAAAPAjuq894h4aGqnPnzlqyZInS021/vdXOnTt18eJF1axZ07IsJCREbm5umj9/fpav69Wrl2bNmqXU1FTLsq+//lqFCxdWkyZNLMvGjh2rmjVravv27XrxxRf1wgsvWK7qb968WdKtq/nJyclauHChJOny5cvq1q2bfv75Z/36668qXbq0WrZsqcuXL0uSzGazWrRooQ0bNujrr7/W3r17NWbMGLm7u6tevXr6+OOPFRgYqOTkZCUnJ2vAgAGZ6r9THxmKFi2qsLAwrV+/Plvvt/UGcv4SAAAAAHgQ3NNbzXOiXr16cnOz/rtASkrKXV9Xrlw5Xb58WWfPnlVoaGim9UePHpW7u7vVusKFC2v8+PEaNGiQ4uPjVbNmTTVu3FidO3dWiRIlJEnt27dXnz599O2336pDhw6Sbn22Oi4uTibT/32+uWXLlnrxxRclSa+99po++ugjrV69WmXLlrXc+p1xNT/D34O7JH3++ecKDg7W2rVr1bp1a/3000/avHmzkpKSVKZMGUmy1CXJ6u6BrNytjwyRkZE6evRolv2kpqZa/fHh0qVLWbYFAAAAALjwFe9vvvlGiYmJVo/sMIxb3yf99zD8d9euXZO3t3em9S+99JJOnDihmTNnqm7dupo3b54qVqyolStXSpJ8fHzUpUsXTZ06VZK0bds27d69W3FxcVb9VKlSxfJzRhg+derUHWs+efKkevfurdKlSysoKEiBgYFKSUnRsWPHJEmJiYkqUqSIJTDnRnb78PX11dWrV7NcP3r0aAUFBVkeUVFRua4JAAAAAB4ELhu8o6KiVKpUKatHdiQlJSkwMNBqIra/K1SokK5evaobN25kWpcvXz61adNGI0eO1I4dO9SgQQONGDHCsr5Xr15auXKl/vzzT02bNk1NmjRRdHS0VR9//xy6dCt83+0rurp166bExESNGzdOGzduVGJiogoWLGip0dfXN1v7fifZ7ePcuXN3nJTt9ddf18WLFy2P48ePS5LcvFz2UAIAAAAAp7qv0tKpU6c0a9YstWvXLtNt6hmqVasmSdq7d+8d+zKZTCpXrpyuXLliWVa5cmXVrFlTX3zxhWbNmqUePXrkqD4vLy9JyvQ58g0bNqhv375q2bKlKlasKG9vb8vs7tKtq+h//vmn9u/fn2W/WX02Pbt9SNL169d16NAhVa9ePcs23t7eCgwMtHpIkpv7fXUoAQAAAIDduGxaOnv2rE6cOGH1uH79umW9YRg6ceKEkpOTlZSUpKlTp6pevXoKCgrSmDFjsuw3JCRENWrU0M8//2xZlpiYqLZt22r+/Pnau3evDh48qClTpmjq1Klq27at1et79eqlMWPGyDAMPf744znap9DQUPn6+mr58uU6efKk5TvHS5curRkzZigpKUmbNm1S586dra5QN2zYUP/617/0xBNPaOXKlTp8+LCWLVum5cuXS7o1e3lKSopWrVqlM2fO2LxV/G59SNKvv/4qb29v1a1bN0f7JTGrOQAAAABkxWWDd9OmTRUREWH1WLx4sWX9pUuXFBERocKFC6tu3bqaPHmyunXrpu3btysiIuKOfffq1UszZ860PC9SpIiKFSum+Ph41alTRzVq1NC4ceMUHx+vN9980+q1sbGx8vDwUGxsrHx8fHK0Tx4eHho/frwmT56syMhIS6ifMmWKzp8/rxo1aqhLly7q27dvponhFixYoFq1aik2NlYVKlTQoEGDLFe569Wrp+eff15PP/20QkJC9N5779nc/p36kKTZs2erc+fO8vPzy9F+SWJWcwAAAADIgsnImI3sAXLt2jWVLVtW33zzTY6v7h45ckQlS5bUli1bVKNGDQdVeO+dOXNGZcuW1W+//Wb5vvHsuHTpkoKCgtR0QlP5FMzZHyJwb30X+12mZWazWadOnVJoaGiWH8+Aa2Ls8jbGL29j/PI2xi9vY/zytvtt/DKy0MWLFy0fwc2Ky36dmCP5+vrqq6++svoc9d3cvHlTZ8+e1VtvvaWHH374vgrd0q0/KHz66ac5Ct0AAAAAgLt7IIO3JDVq1ChH7Tds2KDGjRurTJkymj9/vmOKcqKaNWuqZs2auX69m3fe/4sVAAAAADjCAxu8c6pRo0Z6AO/Kz7b74VYRAAAAAHAE0hLsIu0as5oDAAAAgC0EbwAAAAAAHIjgDQAAAACAAxG8AQAAAABwIII37MLd293ZJQAAAACASyJ4wz5Mzi4AAAAAAFwTwRt2kX493dklAAAAAIBLIngDAAAAAOBABG8AAAAAAByI4A0AAAAAgAMRvGEX7j7Mag4AAAAAthC8YR+GswsAAAAAANdE8IZdpKcyqzkAAAAA2ELwBgAAAADAgQjeAAAAAAA4EMEbAAAAAAAHInjDLjx8PZxdAgAAAAC4JII37MJsNju7BAAAAABwSQRv2IU5leANAAAAALYQvAEAAAAAcCCCNwAAAAAADkTwhn1wJAEAAACATcQl2IWHN7OaAwAAAIAtBG/YhTmdydUAAAAAwBaCN+zCfIPgDQAAAAC2ELwBAAAAAHAggjcAAAAAAA5E8IZ9cCQBAAAAgE3EJdgFs5oDAAAAgG0Eb9hFelq6s0sAAAAAAJfEZUrYxZctvlTRokWdXQYAAAAAuByueAMAAAAA4EAEbwAAAAAAHIjgDbvw9PR0dgkAAAAA4JII3rALX19fZ5cAAAAAAC6J4A27uHbtmrNLAAAAAACXRPCGXdy8edPZJQAAAACASyJ4AwAAAADgQARvAAAAAAAciOANu/D29nZ2CQAAAADgkgjesAuCNwAAAADYRvCGXVy5csXZJQAAAACASyJ4wy7S09OdXQIAAAAAuCSCNwAAAAAADkTwBgAAAADAgQjesAsfHx9nlwAAAAAALongDbvw8vJydgkAAAAA4JII3rCLlJQUZ5cAAAAAAC6J4A27MJvNzi4BAAAAAFySh7MLwP2h55Ke8inI57zzGpNMinKP0vH04zJkOLsc5ABjl7cxfnkb45e3MX55G+OXt+Vm/L6L/c7BVd0bXPEGAAAAAMCBCN6wCzdvDiUAAAAAsIW0BLtwc+NQAgAAAABbSEuwi7Rrac4uAQAAAABcEsEbAAAAAAAHIngDAAAAAOBABG8AAAAAAByI4A27cPd2d3YJAAAAAOCSCN6wD5OzCwAAAAAA10Twhl2kX093dgkAAAAA4JII3gAAAAAAOBDBGwAAAAAAByJ4AwAAAADgQARv2IW7D7OaAwAAAIAtBG/Yh+HsAgAAAADANRG8YRfpqcxqDgAAAAC2ELwBAAAAAHAggjcAAAAAAA5E8AYAAAAAwIEI3rALD18PZ5cAAAAAAC6J4A27MJvNzi4BAAAAAFwSwRt2YU4leAMAAACALQRvAAAAAAAciOANAAAAAIADEbxhHxxJAAAAAGATcQl24eHNrOYAAAAAYAvBG3ZhTmdyNQAAAACwheANuzDfIHgDAAAAgC0EbwAAAAAAHIjgDQAAAACAAxG8YR8cSQAAAABgE3EJdsGs5gAAAABgG8EbdpGelu7sEgAAAADAJT2QwXvfvn0KDw/X5cuXnV2KQzVq1Ej9+vXLVtu9e/eqSJEiunLlSq62Zdw0cvU6AAAAALjf2T14x8XFyWQyWR4FCxZU8+bNtXPnTqt2f2/z98ecOXMkSWvWrLFaHhISopYtW2rXrl13fH3GY9iwYVnW+Prrr+vll19Wvnz5LMu++OILVa1aVQEBAQoODlb16tU1evRoe789DpHxXl24cMFq+cKFCzV8+PBs9VGhQgU9/PDD+vDDDx1QIQAAAAA8uBxyxbt58+ZKTk5WcnKyVq1aJQ8PD7Vu3TpTu2nTplnaZTzatWtn1Wbfvn1KTk7WihUrlJqaqlatWunGjRtWr/n4448VGBhotWzAgAE2azt27JiWLl2quLg4y7KpU6eqX79+6tu3rxITE7VhwwYNGjRIKSkp9nxb7rkCBQpY/XHhbrp3765JkyYpLS3NgVUBAAAAwIPFIcHb29tb4eHhCg8PV7Vq1TR48GAdP35cp0+ftmoXHBxsaZfx8PHxsWoTGhqq8PBw1ahRQ/369dPx48f1+++/W70mKChIJpPJallAQIDN2ubOnauqVauqcOHClmVLlixRhw4d1LNnT5UqVUoVK1ZUbGysRo4cafXaL7/8UuXLl5ePj4/KlSunTz/91LLuyJEjMplMmjt3rho0aCBfX1/VqlVL+/fv15YtW1SzZk0FBASoRYsWVu/Dli1b1KxZMxUqVEhBQUFq2LChtm3bZrVdk8mkL7/8Uo8//rj8/PxUunRpLVmyxLLdxo0bS5Ly588vk8lk+aPC7beap6am6rXXXlNUVJS8vb1VqlQpTZkyxbK+WbNmOnfunNauXWvzvbsTk4cpx68BAAAAgAeBwz/jnZKSoq+//lqlSpVSwYIFc93PxYsXLbehe3l55bqf9evXq2bNmlbLwsPD9euvv+ro0aNZvm7mzJkaMmSIRo4cqaSkJI0aNUpvv/22pk+fbtVu6NCheuutt7Rt2zZ5eHioU6dOGjRokMaNG6f169fr4MGDGjJkiKX95cuX1a1bN/3888/69ddfVbp0abVs2TLT58/j4+PVoUMH7dy5Uy1btlTnzp117tw5RUVFacGCBZL+7+6AcePG2dyHrl27avbs2Ro/frySkpI0efJkqz9QeHl5qVq1alq/fn2W70NqaqouXbpk9ZAkd0/3LF8DAAAAAA8yh3wH1NKlSy2B7sqVK4qIiNDSpUvl5mad82NjY+Xubh3Y9u7dq6JFi1qeFylSxNKPJP373/9WuXLlcl3b0aNHMwXvoUOHqn379ipWrJjKlCmjunXrqmXLlnryySctNQ8dOlRjx45V+/btJUnFixfX3r17NXnyZHXr1s3S14ABAxQTEyNJeuWVVxQbG6tVq1apfv36kqSePXsqISHB0r5JkyZWtXz++ecKDg7W2rVrrW7Pj4uLU2xsrCRp1KhRGj9+vDZv3qzmzZurQIECkm7dHRAcHGxzv/fv36+5c+dq5cqVatq0qSSpRIkSmdpFRkbe8Q8Qo0ePVnx8fKbl6TfT5eGYwwkAAAAA8jSHXPFu3LixEhMTlZiYqM2bNysmJkYtWrTIFOg++ugjS7uMR2RkpFWb9evXa+vWrUpISFCZMmX02Wef/aParl27lul29oiICP3yyy/atWuXXnnlFaWlpalbt25q3ry5zGazrly5okOHDqlnz54KCAiwPEaMGKFDhw5Z9VWlShXLz2FhYZKkypUrWy07deqU5fnJkyfVu3dvlS5dWkFBQQoMDFRKSoqOHTuWZb/+/v4KDAy06uduEhMT5e7uroYNG96xna+vr65evZrl+tdff10XL160PI4fPy5JMtKY1RwAAAAAbHHIJUp/f3+VKlXK8vzLL79UUFCQvvjiC40YMcKyPDw83KqdLcWLF1dwcLDKli2rU6dO6emnn9a6detyXVuhQoV0/vx5m+sqVaqkSpUq6cUXX9Tzzz+vBg0aaO3atapQoYKkWzOf16lTx+o1t1+x9/T0tPxsMplsLjObzZbn3bp109mzZzVu3DhFR0fL29tbdevW1Y0bN7Ls11Y/d+Pr65utdufOnVPJkiWzXO/t7S1vb+9sbxcAAAAAHnT35Hu8TSaT3NzcdO3atX/Uz0svvaTdu3dr0aJFue6jevXq2rt3713bZYTtK1euKCwsTJGRkfrjjz9UqlQpq0fx4sVzXYskbdiwQX379lXLli1VsWJFeXt768yZMznqI+Mz7+np6Vm2qVy5ssxm810nTtu9e7eqV6+eo+0DAAAAALLmkCveqampOnHihCTp/PnzmjhxolJSUtSmTRurdhcuXLC0y5AvXz75+/vb7NfPz0+9e/fW0KFD1a5dO8sV5ZyIiYlRr169lJ6ebrla/cILLygyMlJNmjRRkSJFlJycrBEjRigkJER169aVdGtys759+yooKEjNmzdXamqqfvvtN50/f16vvvpqjuvIULp0ac2YMUM1a9bUpUuXNHDgwGxfnc4QHR0tk8mkpUuXqmXLlvL19c00q3uxYsXUrVs39ejRQ+PHj1fVqlV19OhRnTp1Sh06dJB0a4b0v/76y/IZ8JwweTKrOQAAAADY4pAr3suXL1dERIQiIiJUp04dbdmyRfPmzVOjRo2s2nXv3t3SLuMxYcKEO/bdp08fJSUlad68ebmqrUWLFvLw8NBPP/1kWda0aVP9+uuveuqpp1SmTBk98cQT8vHx0apVqywzsffq1Utffvmlpk2bpsqVK6thw4ZKSEj4x1e8p0yZovPnz6tGjRrq0qWL+vbtq9DQ0Bz1UbhwYcXHx2vw4MEKCwtTnz59bLabNGmSnnzySb344osqV66cevfubZm0TpJmz56txx57TNHR0TneD3cPZjUHAAAAAFtMhmE8cLNiffLJJ1qyZIlWrFjh7FJcxo0bN1S6dGnNmjXLMgN7dly6dElBQUFq+klT+eT3ufsL4FJMMinKPUrH04/L0AP3T0GextjlbYxf3sb45W2MX97G+OVtuRm/72K/c3BVuZeRhS5evKjAwMA7tn0gv//pueee04ULF3T58mXly5fP2eW4hGPHjumNN97IUei2kv153gAAAADggfJABm8PDw+9+eabzi7DpWRMFgcAAAAAsK97Mqs5AAAAAAAPKoI37MLNi0MJAAAAAGwhLcEu3Nw5lAAAAADAFtIS7CItNc3ZJQAAAACASyJ4wz6Y1RwAAAAAbCJ4AwAAAADgQARvAAAAAAAciOANu3Dz5lACAAAAAFtIS7ALNzcOJQAAAACwhbQEu0i7xqzmAAAAAGALwRsAAAAAAAcieAMAAAAA4EAEbwAAAAAAHIjgDbtw93Z3dgkAAAAA4JII3rAPk7MLAAAAAADXRPCGXaRfT3d2CQAAAADgkgjeAAAAAAA4EMEbAAAAAAAHIngDAAAAAOBABG/YhbsPs5oDAAAAgC0Eb9iH4ewCAAAAAMA1EbxhF+mpzGoOAAAAALYQvAEAAAAAcCCCNwAAAAAADkTwBgAAAADAgQjesAsPXw9nlwAAAAAALongDbswm83OLgEAAAAAXBLBG3ZhTiV4AwAAAIAtBG8AAAAAAByID+bCLqb8e4qKFi3q7DKQQ2azWadOnVJoaKjc3Pg7XF7C2OVtjF/exvjlbYxf3sb45W0P8vg9WHsLh3nQThwAAAAAyC7SEuwiICDA2SUAAAAAgEsieMMubty44ewSAAAAAMAlEbxhF9evX3d2CQAAAADgkgjeAAAAAAA4EMEbAAAAAAAHInjDLtzd3Z1dAgAAAAC4JII37MLf39/ZJQAAAACASyJ4wy5SU1OdXQIAAAAAuCSCN+yC4A0AAAAAthG8AQAAAABwIII3AAAAAAAORPCGXXh6ejq7BAAAAABwSQRv2IWvr6+zSwAAAAAAl0Twhl1cu3bN2SUAAAAAgEsieMMubt686ewSAAAAAMAlEbwBAAAAAHAgD2cXgLzNMAxJ0uXLl3Xp0iUnV4OcMpvNunz5snx8fOTmxt/h8hLGLm9j/PI2xi9vY/zyNsYvb7vfxi8j/2RkojsheOMfOXv2rCSpUqVKTq4EAAAAAO69y5cvKygo6I5tCN74RwoUKCBJOnbs2F0PNrieS5cuKSoqSsePH1dgYKCzy0EOMHZ5G+OXtzF+eRvjl7cxfnnb/TZ+hmHo8uXLioyMvGtbgjf+kYxbRIKCgu6Lk+dBFRgYyPjlUYxd3sb45W2MX97G+OVtjF/edj+NX3YvPub9G+sBAAAAAHBhBG8AAAAAAByI4I1/xNvbW0OHDpW3t7ezS0EuMH55F2OXtzF+eRvjl7cxfnkb45e3PcjjZzKyM/c5AAAAAADIFa54AwAAAADgQARvAAAAAAAciOANAAAAAIADEbxh5ZNPPlGxYsXk4+OjOnXqaPPmzXdsP2/ePJUrV04+Pj6qXLmyfvjhB6v1hmFoyJAhioiIkK+vr5o2baoDBw44chceaDkZvy+++EINGjRQ/vz5lT9/fjVt2jRT+7i4OJlMJqtH8+bNHb0bD6ycjF9CQkKmsfHx8bFqw/l3b+Vk/Bo1apRp/Ewmk1q1amVpw/l3b6xbt05t2rRRZGSkTCaTFi9efNfXrFmzRjVq1JC3t7dKlSqlhISETG1y+vsUuZPT8Vu4cKGaNWumkJAQBQYGqm7dulqxYoVVm2HDhmU698qVK+fAvXhw5XT81qxZY/PfzhMnTli14/y7N3I6frZ+r5lMJlWsWNHS5n4+/wjesPjmm2/06quvaujQodq2bZuqVq2qmJgYnTp1ymb7jRs3KjY2Vj179tT27dvVrl07tWvXTrt377a0ee+99zR+/Hh99tln2rRpk/z9/RUTE6Pr16/fq916YOR0/NasWaPY2FitXr1av/zyi6KiovTYY4/pr7/+smrXvHlzJScnWx6zZ8++F7vzwMnp+ElSYGCg1dgcPXrUaj3n372T0/FbuHCh1djt3r1b7u7ueuqpp6zacf453pUrV1S1alV98skn2Wp/+PBhtWrVSo0bN1ZiYqL69eunXr16WYW33JzPyJ2cjt+6devUrFkz/fDDD9q6dasaN26sNm3aaPv27VbtKlasaHXu/fzzz44o/4GX0/HLsG/fPqvxCQ0Ntazj/Lt3cjp+48aNsxq348ePq0CBApl+9923558B/H+1a9c2XnrpJcvz9PR0IzIy0hg9erTN9h06dDBatWpltaxOnTrGc889ZxiGYZjNZiM8PNx4//33LesvXLhgeHt7G7Nnz3bAHjzYcjp+t0tLSzPy5ctnTJ8+3bKsW7duRtu2be1dKmzI6fhNmzbNCAoKyrI/zr9765+efx999JGRL18+IyUlxbKM8+/ek2QsWrTojm0GDRpkVKxY0WrZ008/bcTExFie/9PjAbmTnfGzpUKFCkZ8fLzl+dChQ42qVavarzBkS3bGb/Xq1YYk4/z581m24fxzjtycf4sWLTJMJpNx5MgRy7L7+fzjijckSTdu3NDWrVvVtGlTyzI3Nzc1bdpUv/zyi83X/PLLL1btJSkmJsbS/vDhwzpx4oRVm6CgINWpUyfLPpE7uRm/2129elU3b95UgQIFrJavWbNGoaGhKlu2rF544QWdPXvWrrUj9+OXkpKi6OhoRUVFqW3bttqzZ49lHeffvWOP82/KlCnq2LGj/P39rZZz/rmeu/3us8fxgHvHbDbr8uXLmX73HThwQJGRkSpRooQ6d+6sY8eOOalC2FKtWjVFRESoWbNm2rBhg2U551/eMmXKFDVt2lTR0dFWy+/X84/gDUnSmTNnlJ6errCwMKvlYWFhmT43k+HEiRN3bJ/x35z0idzJzfjd7rXXXlNkZKTVL6vmzZvrq6++0qpVq/Tuu+9q7dq1atGihdLT0+1a/4MuN+NXtmxZTZ06Vd9++62+/vprmc1m1atXT3/++ackzr976Z+ef5s3b9bu3bvVq1cvq+Wcf64pq999ly5d0rVr1+zy7zHunQ8++EApKSnq0KGDZVmdOnWUkJCg5cuXa9KkSTp8+LAaNGigy5cvO7FSSFJERIQ+++wzLViwQAsWLFBUVJQaNWqkbdu2SbLP/w/h3vjf//6nZcuWZfrddz+ffx7OLgCA840ZM0Zz5szRmjVrrCbo6tixo+XnypUrq0qVKipZsqTWrFmjRx991Bml4v+rW7eu6tata3ler149lS9fXpMnT9bw4cOdWBlyasqUKapcubJq165ttZzzD3CsWbNmKT4+Xt9++63VZ4RbtGhh+blKlSqqU6eOoqOjNXfuXPXs2dMZpeL/K1u2rMqWLWt5Xq9ePR06dEgfffSRZsyY4cTKkFPTp09XcHCw2rVrZ7X8fj7/uOINSVKhQoXk7u6ukydPWi0/efKkwsPDbb4mPDz8ju0z/puTPpE7uRm/DB988IHGjBmjH3/8UVWqVLlj2xIlSqhQoUI6ePDgP64Z/+efjF8GT09PVa9e3TI2nH/3zj8ZvytXrmjOnDnZ+p8Jzj/XkNXvvsDAQPn6+trlfIbjzZkzR7169dLcuXMzfXTgdsHBwSpTpgznnouqXbu2ZWw4//IGwzA0depUdenSRV5eXndsez+dfwRvSJK8vLz00EMPadWqVZZlZrNZq1atsrqq9nd169a1ai9JK1eutLQvXry4wsPDrdpcunRJmzZtyrJP5E5uxk+6Nev18OHDtXz5ctWsWfOu2/nzzz919uxZRURE2KVu3JLb8fu79PR07dq1yzI2nH/3zj8Zv3nz5ik1NVXPPPPMXbfD+eca7va7zx7nMxxr9uzZ6t69u2bPnm31FX5ZSUlJ0aFDhzj3XFRiYqJlbDj/8oa1a9fq4MGD2fqj8311/jl7dje4jjlz5hje3t5GQkKCsXfvXuPZZ581goODjRMnThiGYRhdunQxBg8ebGm/YcMGw8PDw/jggw+MpKQkY+jQoYanp6exa9cuS5sxY8YYwcHBxrfffmvs3LnTaNu2rVG8eHHj2rVr93z/7nc5Hb8xY8YYXl5exvz5843k5GTL4/Lly4ZhGMbly5eNAQMGGL/88otx+PBh46effjJq1KhhlC5d2rh+/bpT9vF+ltPxi4+PN1asWGEcOnTI2Lp1q9GxY0fDx8fH2LNnj6UN59+9k9Pxy/DII48YTz/9dKblnH/3zuXLl43t27cb27dvNyQZH374obF9+3bj6NGjhmEYxuDBg40uXbpY2v/xxx+Gn5+fMXDgQCMpKcn45JNPDHd3d2P58uWWNnc7HmA/OR2/mTNnGh4eHsYnn3xi9bvvwoULljb9+/c31qxZYxw+fNjYsGGD0bRpU6NQoULGqVOn7vn+3e9yOn4fffSRsXjxYuPAgQPGrl27jFdeecVwc3MzfvrpJ0sbzr97J6fjl+GZZ54x6tSpY7PP+/n8I3jDyoQJE4yiRYsaXl5eRu3atY1ff/3Vsq5hw4ZGt27drNrPnTvXKFOmjOHl5WVUrFjR+P77763Wm81m4+233zbCwsIMb29v49FHHzX27dt3L3blgZST8YuOjjYkZXoMHTrUMAzDuHr1qvHYY48ZISEhhqenpxEdHW307t2bX1wOlJPx69evn6VtWFiY0bJlS2Pbtm1W/XH+3Vs5/ffz999/NyQZP/74Y6a+OP/unYyvJ7r9kTFe3bp1Mxo2bJjpNdWqVTO8vLyMEiVKGNOmTcvU752OB9hPTsevYcOGd2xvGLe+Hi4iIsLw8vIyChcubDz99NPGwYMH7+2OPSByOn7vvvuuUbJkScPHx8coUKCA0ahRI+O///1vpn45/+6N3Pz7eeHCBcPX19f4/PPPbfZ5P59/JsMwDAdfVAcAAAAA4IHFZ7wBAAAAAHAggjcAAAAAAA5E8AYAAAAAwIEI3gAAAAAAOBDBGwAAAAAAByJ4AwAAAADgQARvAAAAAAAciOANAAAAAIADEbwBAA+sNWvWyGQy6cKFC9l+TbFixfTxxx87rKacuHr1qp544gkFBgZa9sPWspzUnJCQoODgYIfWfTddunTRqFGjnFoD7iwuLk7t2rWzPG/UqJH69ev3j/q0Rx+3Gzx4sF5++WW79gkAuUHwBgC4pLi4OJlMJj3//POZ1r300ksymUyKi4u794Vlw6VLl/Tmm2+qXLly8vHxUXh4uJo2baqFCxfKMAy7bWf69Olav369Nm7cqOTkZAUFBdlctmXLFj377LPZ6vPpp5/W/v377VajlLM/cOzYsUM//PCD+vbta1nmiEDmCLn5Q449ZZwzJpNJXl5eKlWqlN555x2lpaU5fNsLFy7U8OHDs9U2q/cpJ31k14ABAzR9+nT98ccfdu0XAHKK4A0AcFlRUVGaM2eOrl27Zll2/fp1zZo1S0WLFnViZVm7cOGC6tWrp6+++kqvv/66tm3bpnXr1unpp5/WoEGDdPHiRbtt69ChQypfvrwqVaqk8PBwmUwmm8tCQkLk5+eXrT59fX0VGhpqtxpzasKECXrqqacUEBDgtBrysubNmys5OVkHDhxQ//79NWzYML3//vs22964ccNu2y1QoIDy5cvn9D5uV6hQIcXExGjSpEl27RcAcorgDQBwWTVq1FBUVJQWLlxoWbZw4UIVLVpU1atXt2qbmpqqvn37KjQ0VD4+PnrkkUe0ZcsWqzY//PCDypQpI19fXzVu3FhHjhzJtM2ff/5ZDRo0kK+vr6KiotS3b19duXIl2zW/8cYbOnLkiDZt2qRu3bqpQoUKKlOmjHr37q3ExERLoDx//ry6du2q/Pnzy8/PTy1atNCBAweyXUujRo00duxYrVu3TiaTSY0aNbK5TMp8e/yFCxf03HPPKSwsTD4+PqpUqZKWLl0qyfat5t9++61q1KghHx8flShRQvHx8VZXUU0mk7788ks9/vjj8vPzU+nSpbVkyRJJ0pEjR9S4cWNJUv78+e94p0J6errmz5+vNm3a3PE9LlasmEaMGKGuXbsqICBA0dHRWrJkiU6fPq22bdsqICBAVapU0W+//WZ5TcZ+LV68WKVLl5aPj49iYmJ0/PhxS5tDhw6pbdu2CgsLU0BAgGrVqqWffvrJatupqal67bXXFBUVJW9vb5UqVUpTpkzJ0X5K0oIFC1SxYkV5e3urWLFiGjt2bKZ9HDVqlHr06KF8+fKpaNGi+vzzz+/4vkiSt7e3wsPDFR0drRdeeEFNmza1jEXG7eEjR45UZGSkypYtK0k6fvy4OnTooODgYBUoUEBt27a1OjfS09P16quvKjg4WAULFtSgQYMy3blx+10JuXmfbu/jbudIxpiuWLFC5cuXV0BAgOUPD3/Xpk0bzZkz567vHQA4EsEbAODSevTooWnTplmeT506Vd27d8/UbtCgQVqwYIGmT5+ubdu2qVSpUoqJidG5c+ck3QoX7du3V5s2bZSYmKhevXpp8ODBVn0cOnRIzZs31xNPPKGdO3fqm2++0c8//6w+ffpkq1az2aw5c+aoc+fOioyMzLQ+ICBAHh4ekm6FoN9++01LlizRL7/8IsMw1LJlS928eTNbtSxcuFC9e/dW3bp1lZycrIULF9pcZqvGFi1aaMOGDfr666+1d+9ejRkzRu7u7jb3af369eratateeeUV7d27V5MnT1ZCQoJGjhxp1S4+Pl4dOnTQzp071bJlS3Xu3Fnnzp1TVFSUFixYIEnat2+fkpOTNW7cOJvb2rlzpy5evKiaNWve9b3+6KOPVL9+fW3fvl2tWrVSly5d1LVrVz3zzDPatm2bSpYsqa5du1oFxKtXr2rkyJH66quvtGHDBl24cEEdO3a0rE9JSVHLli21atUqbd++Xc2bN1ebNm107NgxS5uuXbtq9uzZGj9+vJKSkjR58mQFBATkaD+3bt2qDh06qGPHjtq1a5eGDRumt99+WwkJCVbtxo4dq5o1a2r79u168cUX9cILL2jfvn13fW/+ztfX1+rK9qpVq7Rv3z6tXLlSS5cu1c2bNxUTE6N8+fJp/fr12rBhgyXAZrxu7NixSkhI0NSpU/Xzzz/r3LlzWrRo0R23a4/36W7niHRrTD/44APNmDFD69at07FjxzRgwACrfmrXrq0///zT5h/aAOCeMQAAcEHdunUz2rZta5w6dcrw9vY2jhw5Yhw5csTw8fExTp8+bbRt29bo1q2bYRiGkZKSYnh6ehozZ860vP7GjRtGZGSk8d577xmGYRivv/66UaFCBattvPbaa4Yk4/z584ZhGEbPnj2NZ5991qrN+vXrDTc3N+PatWuGYRhGdHS08dFHH9ms+eTJk4Yk48MPP7zjvu3fv9+QZGzYsMGy7MyZM4avr68xd+7cbNfyyiuvGA0bNrRqY2vZ32tesWKF4ebmZuzbt89mbdOmTTOCgoIszx999FFj1KhRVm1mzJhhREREWJ5LMt566y3L85SUFEOSsWzZMsMwDGP16tVW73NWFi1aZLi7uxtms9lqecOGDY1XXnnFan+eeeYZy/Pk5GRDkvH2229blv3yyy+GJCM5OdmyX5KMX3/91dImKSnJkGRs2rQpy5oqVqxoTJgwwTAMw9i3b58hyVi5cqXNttndz06dOhnNmjWzWjZw4ECr4/P2fTSbzUZoaKgxadKkLPvNOGcy2q9cudLw9vY2BgwYYFkfFhZmpKamWl4zY8YMo2zZslbveWpqquHr62usWLHCMAzDiIiIsJxHhmEYN2/eNIoUKWLZlmFYj1Fu36e/95GdcyRjTA8ePGhp88knnxhhYWFW/V68eNGQZKxZsyartw4AHM7jnid9AAByICQkRK1atVJCQoIMw1CrVq1UqFAhqzaHDh3SzZs3Vb9+fcsyT09P1a5dW0lJSZKkpKQk1alTx+p1devWtXq+Y8cO7dy5UzNnzrQsMwxDZrNZhw8fVvny5e9Yq5HNidOSkpLk4eFhVU/BggVVtmxZS73/tJasJCYmqkiRIipTpky22u/YsUMbNmywusKdnp6u69ev6+rVq5bPjlepUsWy3t/fX4GBgTp16lSOart27Zq8vb1lMpnu2vbv2wsLC5MkVa5cOdOyU6dOKTw8XJLk4eGhWrVqWdqUK1dOwcHBSkpKUu3atZWSkqJhw4bp+++/V3JystLS0nTt2jXLFe/ExES5u7urYcOGOdqv2yUlJalt27ZWy+rXr6+PP/5Y6enplrsP/r6PJpNJ4eHhd31Ply5dqoCAAN28eVNms1mdOnXSsGHDLOsrV64sLy8vy/MdO3bo4MGDmT5bff36dR06dEgXL15UcnKy1bHq4eGhmjVrZnm82+N9ys45Ikl+fn4qWbKk5XlERESm98jX11fSravjAOAsBG8AgMvr0aOH5RbrTz75xGHbSUlJ0XPPPWc1o3aG7EzmFhISouDgYP3+++9OryUrGSEkJ3XEx8erffv2mdb5+PhYfvb09LRaZzKZZDabc7StQoUK6erVq7px44ZVOLTl79vLCOq2luWkhgEDBmjlypX64IMPVKpUKfn6+urJJ5+03HKd0/fun8rNe9q4cWNNmjRJXl5eioyMtHy0IYO/v7/V85SUFD300ENWf+DJEBISkqu67+X7ZOs9uv0PAhkfN8nt/gCAPfAZbwCAy8v4vGnG51FvV7JkSXl5eWnDhg2WZTdv3tSWLVtUoUIFSVL58uW1efNmq9f9+uuvVs9r1KihvXv3qlSpUpkedwuCkuTm5qaOHTtq5syZ+t///pdpfUpKitLS0lS+fHmlpaVp06ZNlnVnz57Vvn37LPX+01qyUqVKFf3555/Z/sqwGjVqaN++fTbrcHPL3v9GZNSbnp5+x3bVqlWTJO3duzdb/eZUWlqa1YRr+/bt04ULFyx3D2zYsEFxcXF6/PHHVblyZYWHh1t9Lrhy5coym81au3atzf6zu5/ly5e3OlYztl2mTJksP2ufXf7+/ipVqpSKFi2aKXTbUqNGDR04cEChoaGZxjcoKEhBQUGKiIiwOlbT0tK0devWLPu0x/uUnXMku3bv3i1PT09VrFgxR68DAHsieAMAXJ67u7uSkpK0d+9em8HE399fL7zwggYOHKjly5dr79696t27t65evaqePXtKkp5//nkdOHBAAwcO1L59+zRr1qxMk1m99tpr2rhxo/r06aPExEQdOHBA3377bbYnV5OkkSNHKioqSnXq1NFXX32lvXv36sCBA5o6daqqV6+ulJQUlS5dWm3btlXv3r31888/a8eOHXrmmWdUuHBhyy3I9qjFloYNG+pf//qXnnjiCa1cuVKHDx/WsmXLtHz5cpvthwwZoq+++krx8fHas2ePkpKSNGfOHL311lvZ3mZ0dLRMJpOWLl2q06dPKyUlxWa7kJAQ1ahRQz///HOu9u1uPD099fLLL2vTpk3aunWr4uLi9PDDD6t27dqSpNKlS2vhwoVKTEzUjh071KlTJ6srzMWKFVO3bt3Uo0cPLV68WIcPH9aaNWs0d+7cHO1n//79tWrVKg0fPlz79+/X9OnTNXHixEyTgt0LnTt3VqFChdS2bVutX7/esk99+/bVn3/+KUl65ZVXNGbMGC1evFi///67XnzxxTt+V7k93qfsnCPZtX79esu3AwCAsxC8AQB5QmBgoAIDA7NcP2bMGD3xxBPq0qWLatSooYMHD2rFihXKnz+/pFu3Zy9YsECLFy9W1apV9dlnn2nUqFFWfVSpUkVr167V/v371aBBA1WvXl1DhgyxOUN5VgoUKKBff/1VzzzzjEaMGKHq1aurQYMGmj17tt5//30FBQVJkqZNm6aHHnpIrVu3Vt26dWUYhn744QfLrbP2qCUrCxYsUK1atRQbG6sKFSpo0KBBWV59jImJ0dKlS/Xjjz+qVq1aevjhh/XRRx8pOjo629srXLiw4uPjNXjwYIWFhd3xjwe9evWyeduzPfj5+em1115Tp06dVL9+fQUEBOibb76xrP/www+VP39+1atXT23atFFMTIxq1Khh1cekSZP05JNP6sUXX1S5cuXUu3dvy1e8ZXc/a9Sooblz52rOnDmqVKmShgwZonfeeeeOXz/mKH5+flq3bp2KFi2q9u3bq3z58urZs6euX79uOd/69++vLl26qFu3bqpbt67y5cunxx9//I792uN9uts5kl1z5sxR7969c/QaALA3k5HdmWAAAAAc7Nq1aypbtqy++eabTJPf/RMJCQnq16/fHa/U4v6zbNky9e/fXzt37szWrfcA4Chc8QYAAC7D19dXX331lc6cOePsUnAfuHLliqZNm0boBuB0/CsEAABcSqNGjZxdAu4TTz75pLNLAABJ3GoOAAAAAIBDcas5AAAAAAAORPAGAAAAAMCBCN4AAAAAADgQwRsAAAAAAAcieAMAAAAA4EAEbwAAAAAAHIjgDQAAAACAAxG8AQAAAABwIII3AAAAAAAO9P8A1fkaT3aBgWgAAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 1000x500 with 1 Axes>"
       ]
@@ -745,10 +1333,10 @@
      "text": [
       "Feature Importance Summary:\n",
       "================================================================================\n",
-      "BERT (Semantic)          : +1.7731 ↑ Increases paraphrase likelihood\n",
-      "TED (Syntactic)          : +0.2136 ↑ Increases paraphrase likelihood\n",
-      "Jaccard (Baseline)       : +0.9931 ↑ Increases paraphrase likelihood\n",
-      "Length Ratio             : +0.0666 ↑ Increases paraphrase likelihood\n"
+      "BERT (Semantic)          : +1.7775 ↑ Increases paraphrase likelihood\n",
+      "TED (Syntactic)          : +0.2371 ↑ Increases paraphrase likelihood\n",
+      "Jaccard (Baseline)       : +0.9941 ↑ Increases paraphrase likelihood\n",
+      "Length Ratio             : +0.0367 ↑ Increases paraphrase likelihood\n"
      ]
     }
    ],
@@ -784,7 +1372,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 38,
+   "execution_count": 15,
    "id": "611b74f9",
    "metadata": {},
    "outputs": [
@@ -954,7 +1542,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 39,
+   "execution_count": 16,
    "id": "53e53eb5",
    "metadata": {},
    "outputs": [
@@ -966,12 +1554,12 @@
       "================================================================================\n",
       "\n",
       "1. Feature Correlations:\n",
-      "   - BERT & TED correlation: 0.257\n",
+      "   - BERT & TED correlation: 0.219\n",
       "     → Low = both branches provide independent information ✓\n",
       "\n",
       "2. Feature Importance:\n",
       "   - Most important feature: BERT (Semantic)\n",
-      "     → Coefficient: 1.7731\n",
+      "     → Coefficient: 1.7775\n",
       "\n",
       "3. Model Performance:\n",
       "   - Test Accuracy: 0.833\n",
diff --git a/notebooks/05_final_evaluation.ipynb b/notebooks/05_final_evaluation.ipynb
index 5ec7fbc..1b31660 100644
--- a/notebooks/05_final_evaluation.ipynb
+++ b/notebooks/05_final_evaluation.ipynb
@@ -1,15 +1,1419 @@
 {
  "cells": [
   {
+   "cell_type": "markdown",
+   "id": "aa82a715",
    "metadata": {},
+   "source": [
+    "# Phase 4: Final Evaluation\n",
+    "Comprehensive assessment of plagiarism detection models on real MSRP corpus.\n",
+    "\n",
+    "**Goal:** Evaluate fusion model and baseline methods on held-out test set with proper metrics and analysis."
+   ]
+  },
+  {
    "cell_type": "code",
-   "outputs": [],
-   "execution_count": null,
-   "source": "",
-   "id": "91a93904e31e87aa"
+   "execution_count": 17,
+   "id": "23c0dbf3",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Loading MSRP corpus from pickle files...\n",
+      "Train file: /home/henry/code/plagiarism-detector/data/processed/msr_train.pkl\n",
+      "Test file: /home/henry/code/plagiarism-detector/data/processed/msr_test.pkl\n",
+      "\n",
+      "✓ Loaded 4076 training pairs\n",
+      "✓ Loaded 1725 test pairs\n",
+      "\n",
+      "Train data structure: <class 'pandas.DataFrame'>\n"
+     ]
+    }
+   ],
+   "source": [
+    "import spacy\n",
+    "import numpy as np\n",
+    "import pandas as pd\n",
+    "import matplotlib.pyplot as plt\n",
+    "import seaborn as sns\n",
+    "import pickle\n",
+    "from pathlib import Path\n",
+    "\n",
+    "from sklearn.preprocessing import StandardScaler\n",
+    "from sklearn.linear_model import LogisticRegression\n",
+    "from sklearn.metrics import (\n",
+    "    classification_report, confusion_matrix, roc_auc_score, roc_curve,\n",
+    "    precision_recall_curve, f1_score, precision_score, recall_score,\n",
+    "    accuracy_score\n",
+    ")\n",
+    "from scipy.stats import mannwhitneyu\n",
+    "from statsmodels.stats.multitest import multipletests\n",
+    "from sentence_transformers import SentenceTransformer\n",
+    "\n",
+    "# Load models\n",
+    "nlp = spacy.load(\"en_core_web_lg\")\n",
+    "model_bert = SentenceTransformer(\"all-MiniLM-L6-v2\")\n",
+    "\n",
+    "# Define paths\n",
+    "data_path = Path(\"/home/henry/code/plagiarism-detector/data/processed\")\n",
+    "train_file = data_path / \"msr_train.pkl\"\n",
+    "test_file = data_path / \"msr_test.pkl\"\n",
+    "\n",
+    "print(\"Loading MSRP corpus from pickle files...\")\n",
+    "print(f\"Train file: {train_file}\")\n",
+    "print(f\"Test file: {test_file}\")\n",
+    "\n",
+    "# Load data\n",
+    "with open(train_file, 'rb') as f:\n",
+    "    train_data = pickle.load(f)\n",
+    "    \n",
+    "with open(test_file, 'rb') as f:\n",
+    "    test_data = pickle.load(f)\n",
+    "\n",
+    "print(f\"\\n✓ Loaded {len(train_data)} training pairs\")\n",
+    "print(f\"✓ Loaded {len(test_data)} test pairs\")\n",
+    "\n",
+    "# Inspect structure\n",
+    "print(f\"\\nTrain data structure: {type(train_data)}\")\n",
+    "if isinstance(train_data, list) and len(train_data) > 0:\n",
+    "    print(f\"First sample: {train_data[0]}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "37970853",
+   "metadata": {},
+   "source": [
+    "## Data Preparation\n",
+    "Extract sentences and labels from pickle files"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 18,
+   "id": "fef76fa2",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Data Preparation Summary:\n",
+      "================================================================================\n",
+      "Training pairs: 4076\n",
+      "Test pairs: 1725\n",
+      "\n",
+      "Training label distribution:\n",
+      "  Class 0: 1323 (32.5%)\n",
+      "  Class 1: 2753 (67.5%)\n",
+      "\n",
+      "Test label distribution:\n",
+      "  Class 0: 578 (33.5%)\n",
+      "  Class 1: 1147 (66.5%)\n",
+      "\n",
+      "✓ Header row removed where necessary and data validation passed\n"
+     ]
+    }
+   ],
+   "source": [
+    "def prepare_data_from_pickle(data):\n",
+    "    \"\"\"\n",
+    "    Convert processed MSRP pickle content to a standard format.\n",
+    "\n",
+    "    Supported inputs:\n",
+    "    - pandas DataFrame with sentence and label columns\n",
+    "    - list/tuple rows in the form (sent1, sent2, label)\n",
+    "    - either format may include a first row containing column headings\n",
+    "    \"\"\"\n",
+    "    def row_looks_like_header(values):\n",
+    "        joined = \" \".join(str(value).strip().lower() for value in values)\n",
+    "        header_tokens = [\"quality\", \"label\", \"#1 string\", \"#2 string\", \"string\", \"sentence\"]\n",
+    "        return any(token in joined for token in header_tokens)\n",
+    "\n",
+    "    if isinstance(data, pd.DataFrame):\n",
+    "        df = data.copy()\n",
+    "\n",
+    "        # If the first row contains headings rather than data, promote it to columns.\n",
+    "        if len(df) > 0 and row_looks_like_header(df.iloc[0].tolist()):\n",
+    "            promoted_columns = [str(value).strip() for value in df.iloc[0].tolist()]\n",
+    "            df = df.iloc[1:].copy()\n",
+    "            df.columns = promoted_columns\n",
+    "\n",
+    "        normalized_columns = {str(col).strip().lower(): col for col in df.columns}\n",
+    "\n",
+    "        label_col = None\n",
+    "        for candidate in [\"quality\", \"label\", \"class\", \"target\"]:\n",
+    "            if candidate in normalized_columns:\n",
+    "                label_col = normalized_columns[candidate]\n",
+    "                break\n",
+    "\n",
+    "        sent1_col = None\n",
+    "        for candidate in [\"#1 string\", \"sentence1\", \"sent1\", \"text1\", \"string1\"]:\n",
+    "            if candidate in normalized_columns:\n",
+    "                sent1_col = normalized_columns[candidate]\n",
+    "                break\n",
+    "\n",
+    "        sent2_col = None\n",
+    "        for candidate in [\"#2 string\", \"sentence2\", \"sent2\", \"text2\", \"string2\"]:\n",
+    "            if candidate in normalized_columns:\n",
+    "                sent2_col = normalized_columns[candidate]\n",
+    "                break\n",
+    "\n",
+    "        if label_col is None or sent1_col is None or sent2_col is None:\n",
+    "            raise ValueError(\n",
+    "                f\"Could not identify required columns. Found columns: {list(df.columns)}\"\n",
+    "            )\n",
+    "\n",
+    "        df = df[[sent1_col, sent2_col, label_col]].dropna().copy()\n",
+    "        df[label_col] = pd.to_numeric(df[label_col], errors=\"coerce\")\n",
+    "        df = df.dropna(subset=[label_col])\n",
+    "\n",
+    "        sentence_pairs = list(zip(df[sent1_col].astype(str), df[sent2_col].astype(str)))\n",
+    "        labels = df[label_col].astype(int).to_numpy()\n",
+    "        return sentence_pairs, labels\n",
+    "\n",
+    "    sentence_pairs = []\n",
+    "    labels = []\n",
+    "    rows = list(data)\n",
+    "\n",
+    "    if rows and isinstance(rows[0], (tuple, list)) and row_looks_like_header(rows[0]):\n",
+    "        rows = rows[1:]\n",
+    "\n",
+    "    for item in rows:\n",
+    "        if isinstance(item, (tuple, list)) and len(item) >= 3:\n",
+    "            sent1, sent2, label = item[0], item[1], item[2]\n",
+    "            sentence_pairs.append((str(sent1), str(sent2)))\n",
+    "            labels.append(int(label))\n",
+    "        else:\n",
+    "            print(f\"Warning: Unexpected data format: {item}\")\n",
+    "\n",
+    "    return sentence_pairs, np.array(labels)\n",
+    "\n",
+    "# Prepare data\n",
+    "train_pairs, train_labels = prepare_data_from_pickle(train_data)\n",
+    "test_pairs, test_labels = prepare_data_from_pickle(test_data)\n",
+    "\n",
+    "print(\"Data Preparation Summary:\")\n",
+    "print(\"=\" * 80)\n",
+    "print(f\"Training pairs: {len(train_pairs)}\")\n",
+    "print(f\"Test pairs: {len(test_pairs)}\")\n",
+    "print(f\"\\nTraining label distribution:\")\n",
+    "unique, counts = np.unique(train_labels, return_counts=True)\n",
+    "for label, count in zip(unique, counts):\n",
+    "    percent = 100 * count / len(train_labels)\n",
+    "    print(f\"  Class {label}: {count} ({percent:.1f}%)\")\n",
+    "\n",
+    "print(f\"\\nTest label distribution:\")\n",
+    "unique, counts = np.unique(test_labels, return_counts=True)\n",
+    "for label, count in zip(unique, counts):\n",
+    "    percent = 100 * count / len(test_labels)\n",
+    "    print(f\"  Class {label}: {count} ({percent:.1f}%)\")\n",
+    "\n",
+    "print(\"\\n✓ Header row removed where necessary and data validation passed\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "958bd0eb",
+   "metadata": {},
+   "source": [
+    "## Feature Extraction Pipeline\n",
+    "Extract BERT, TED, Jaccard, and length ratio for all pairs"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 19,
+   "id": "6749dabb",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Extracting features for training set...\n",
+      "  Processed 500/4076 training pairs...\n",
+      "  Processed 1000/4076 training pairs...\n",
+      "  Processed 1500/4076 training pairs...\n",
+      "  Processed 2000/4076 training pairs...\n",
+      "  Processed 2500/4076 training pairs...\n",
+      "  Processed 3000/4076 training pairs...\n",
+      "  Processed 3500/4076 training pairs...\n",
+      "  Processed 4000/4076 training pairs...\n",
+      "✓ Extracted features for 4076 training pairs\n",
+      "\n",
+      "Extracting features for test set...\n",
+      "  Processed 500/1725 test pairs...\n",
+      "  Processed 1000/1725 test pairs...\n",
+      "  Processed 1500/1725 test pairs...\n",
+      "✓ Extracted features for 1725 test pairs\n"
+     ]
+    }
+   ],
+   "source": [
+    "def build_tree_from_dependencies(text):\n",
+    "    \"\"\"Build hierarchical tree from dependency parse.\"\"\"\n",
+    "    doc = nlp(text)\n",
+    "    tree = {}\n",
+    "    root_token = None\n",
+    "    \n",
+    "    for token in doc:\n",
+    "        tree[token.i] = {\n",
+    "            'text': token.text,\n",
+    "            'pos': token.pos_,\n",
+    "            'dep': token.dep_,\n",
+    "            'head_id': token.head.i,\n",
+    "            'children': []\n",
+    "        }\n",
+    "    \n",
+    "    for token in doc:\n",
+    "        if token.head.i != token.i:\n",
+    "            tree[token.head.i]['children'].append(token.i)\n",
+    "        else:\n",
+    "            root_token = token.i\n",
+    "    \n",
+    "    return tree, root_token\n",
+    "\n",
+    "def get_nodes_postorder(node_id, tree):\n",
+    "    \"\"\"Get nodes in postorder traversal.\"\"\"\n",
+    "    nodes = []\n",
+    "    if node_id in tree:\n",
+    "        for child_id in tree[node_id]['children']:\n",
+    "            nodes.extend(get_nodes_postorder(child_id, tree))\n",
+    "        nodes.append(node_id)\n",
+    "    return nodes\n",
+    "\n",
+    "def node_label(node_id, tree):\n",
+    "    \"\"\"Get (POS, DEP) label for a node.\"\"\"\n",
+    "    if node_id in tree:\n",
+    "        return (tree[node_id]['pos'], tree[node_id]['dep'])\n",
+    "    return ('', '')\n",
+    "\n",
+    "def nodes_match(node_id1, tree1, node_id2, tree2):\n",
+    "    \"\"\"Check if nodes match.\"\"\"\n",
+    "    return node_label(node_id1, tree1) == node_label(node_id2, tree2)\n",
+    "\n",
+    "def tree_edit_distance_zhang_shasha(tree1, tree2, root1, root2):\n",
+    "    \"\"\"Zhang-Shasha Tree Edit Distance.\"\"\"\n",
+    "    nodes1 = get_nodes_postorder(root1, tree1)\n",
+    "    nodes2 = get_nodes_postorder(root2, tree2)\n",
+    "    \n",
+    "    m, n = len(nodes1), len(nodes2)\n",
+    "    dp = [[0] * (n + 1) for _ in range(m + 1)]\n",
+    "    \n",
+    "    for i in range(m + 1):\n",
+    "        dp[i][0] = i\n",
+    "    for j in range(n + 1):\n",
+    "        dp[0][j] = j\n",
+    "    \n",
+    "    for i in range(1, m + 1):\n",
+    "        for j in range(1, n + 1):\n",
+    "            node1, node2 = nodes1[i - 1], nodes2[j - 1]\n",
+    "            \n",
+    "            if nodes_match(node1, tree1, node2, tree2):\n",
+    "                cost = dp[i - 1][j - 1]\n",
+    "            else:\n",
+    "                cost = min(\n",
+    "                    dp[i - 1][j] + 1,\n",
+    "                    dp[i][j - 1] + 1,\n",
+    "                    dp[i - 1][j - 1] + 1\n",
+    "                )\n",
+    "            dp[i][j] = cost\n",
+    "    \n",
+    "    max_size = max(m, n)\n",
+    "    return 1.0 - (dp[m][n] / max_size) if max_size > 0 else 1.0\n",
+    "\n",
+    "def sentence_similarity_ted(sent1, sent2):\n",
+    "    \"\"\"TED similarity wrapper.\"\"\"\n",
+    "    if not sent1.strip() or not sent2.strip():\n",
+    "        return 0.0\n",
+    "    try:\n",
+    "        tree1, root1 = build_tree_from_dependencies(sent1)\n",
+    "        tree2, root2 = build_tree_from_dependencies(sent2)\n",
+    "        return tree_edit_distance_zhang_shasha(tree1, tree2, root1, root2)\n",
+    "    except:\n",
+    "        return 0.0\n",
+    "\n",
+    "def sentence_similarity_jaccard(sent1, sent2):\n",
+    "    \"\"\"Jaccard similarity.\"\"\"\n",
+    "    words1 = set(sent1.lower().split())\n",
+    "    words2 = set(sent2.lower().split())\n",
+    "    \n",
+    "    if not words1 and not words2:\n",
+    "        return 1.0\n",
+    "    if not words1 or not words2:\n",
+    "        return 0.0\n",
+    "    \n",
+    "    intersection = len(words1.intersection(words2))\n",
+    "    union = len(words1.union(words2))\n",
+    "    return intersection / union if union > 0 else 0.0\n",
+    "\n",
+    "def extract_features(sent1, sent2):\n",
+    "    \"\"\"Extract all features for a sentence pair.\"\"\"\n",
+    "    # BERT\n",
+    "    embeddings = model_bert.encode([sent1, sent2])\n",
+    "    bert_sim = np.dot(embeddings[0], embeddings[1]) / (\n",
+    "        np.linalg.norm(embeddings[0]) * np.linalg.norm(embeddings[1])\n",
+    "    )\n",
+    "    \n",
+    "    # TED\n",
+    "    ted_sim = sentence_similarity_ted(sent1, sent2)\n",
+    "    \n",
+    "    # Jaccard\n",
+    "    jaccard_sim = sentence_similarity_jaccard(sent1, sent2)\n",
+    "    \n",
+    "    # Length ratio\n",
+    "    len_ratio = min(len(sent1), len(sent2)) / max(len(sent1), len(sent2)) if max(len(sent1), len(sent2)) > 0 else 0.0\n",
+    "    \n",
+    "    return {\n",
+    "        'bert': bert_sim,\n",
+    "        'ted': ted_sim,\n",
+    "        'jaccard': jaccard_sim,\n",
+    "        'len_ratio': len_ratio\n",
+    "    }\n",
+    "\n",
+    "print(\"Extracting features for training set...\")\n",
+    "train_features = []\n",
+    "for i, (sent1, sent2) in enumerate(train_pairs):\n",
+    "    features = extract_features(sent1, sent2)\n",
+    "    features['label'] = train_labels[i]\n",
+    "    train_features.append(features)\n",
+    "    \n",
+    "    if (i + 1) % 500 == 0:\n",
+    "        print(f\"  Processed {i + 1}/{len(train_pairs)} training pairs...\")\n",
+    "\n",
+    "train_df = pd.DataFrame(train_features)\n",
+    "print(f\"✓ Extracted features for {len(train_df)} training pairs\")\n",
+    "\n",
+    "print(\"\\nExtracting features for test set...\")\n",
+    "test_features = []\n",
+    "for i, (sent1, sent2) in enumerate(test_pairs):\n",
+    "    features = extract_features(sent1, sent2)\n",
+    "    features['label'] = test_labels[i]\n",
+    "    test_features.append(features)\n",
+    "    \n",
+    "    if (i + 1) % 500 == 0:\n",
+    "        print(f\"  Processed {i + 1}/{len(test_pairs)} test pairs...\")\n",
+    "\n",
+    "test_df = pd.DataFrame(test_features)\n",
+    "print(f\"✓ Extracted features for {len(test_df)} test pairs\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "d85b9414",
+   "metadata": {},
+   "source": [
+    "## Feature Statistics & Validation"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "934bbab5",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Feature Summary Statistics:\n",
+      "================================================================================\n",
+      "           bert       ted   jaccard  len_ratio\n",
+      "count  4076.000  4076.000  4076.000   4076.000\n",
+      "mean      0.794     0.541     0.452      0.847\n",
+      "std       0.141     0.170     0.159      0.102\n",
+      "min       0.238     0.000     0.048      0.494\n",
+      "25%       0.710     0.421     0.325      0.772\n",
+      "50%       0.818     0.545     0.444      0.860\n",
+      "75%       0.907     0.667     0.577      0.934\n",
+      "max       0.997     1.000     0.917      1.000\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x600 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "print(\"Feature Summary Statistics:\")\n",
+    "print(\"=\" * 80)\n",
+    "print(train_df[['bert', 'ted', 'jaccard', 'len_ratio']].describe().round(3))\n",
+    "\n",
+    "# Feature correlation\n",
+    "feature_corr = train_df[['bert', 'ted', 'jaccard', 'len_ratio']].corr()\n",
+    "\n",
+    "plt.figure(figsize=(8, 6))\n",
+    "sns.heatmap(feature_corr, annot=True, cmap='coolwarm', center=0, vmin=-1, vmax=1, \n",
+    "            square=True, fmt='.3f', cbar_kws={'label': 'Correlation'})\n",
+    "plt.title('Feature Correlation Matrix (Training Set)')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "53c9f622",
+   "metadata": {},
+   "source": [
+    "## Model Training\n",
+    "Train Logistic Regression on full training set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 21,
+   "id": "e01bb875",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Training Logistic Regression Model...\n",
+      "================================================================================\n",
+      "Training set: 4076 pairs\n",
+      "Test set: 1725 pairs\n",
+      "\n",
+      "Training Performance:\n",
+      "  Accuracy: 0.7159\n",
+      "  F1-Score: 0.7712\n",
+      "\n",
+      "Feature Coefficients:\n",
+      "  BERT (Semantic)               : +0.6518\n",
+      "  TED (Syntactic)               : +0.2077\n",
+      "  Jaccard (Baseline)            : +0.5407\n",
+      "  Length Ratio                  : +0.4087\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Prepare training data\n",
+    "X_train = train_df[['bert', 'ted', 'jaccard', 'len_ratio']].values\n",
+    "y_train = train_df['label'].values\n",
+    "\n",
+    "X_test = test_df[['bert', 'ted', 'jaccard', 'len_ratio']].values\n",
+    "y_test = test_df['label'].values\n",
+    "\n",
+    "# Standardize\n",
+    "scaler = StandardScaler()\n",
+    "X_train_scaled = scaler.fit_transform(X_train)\n",
+    "X_test_scaled = scaler.transform(X_test)\n",
+    "\n",
+    "print(\"Training Logistic Regression Model...\")\n",
+    "print(\"=\" * 80)\n",
+    "print(f\"Training set: {len(X_train)} pairs\")\n",
+    "print(f\"Test set: {len(X_test)} pairs\")\n",
+    "\n",
+    "# Train model\n",
+    "model = LogisticRegression(random_state=42, max_iter=1000, class_weight='balanced')\n",
+    "model.fit(X_train_scaled, y_train)\n",
+    "\n",
+    "# Training performance\n",
+    "train_pred = model.predict(X_train_scaled)\n",
+    "train_acc = accuracy_score(y_train, train_pred)\n",
+    "train_f1 = f1_score(y_train, train_pred)\n",
+    "\n",
+    "print(f\"\\nTraining Performance:\")\n",
+    "print(f\"  Accuracy: {train_acc:.4f}\")\n",
+    "print(f\"  F1-Score: {train_f1:.4f}\")\n",
+    "\n",
+    "# Feature importance\n",
+    "print(f\"\\nFeature Coefficients:\")\n",
+    "feature_names = ['BERT (Semantic)', 'TED (Syntactic)', 'Jaccard (Baseline)', 'Length Ratio']\n",
+    "for name, coef in zip(feature_names, model.coef_[0]):\n",
+    "    print(f\"  {name:<30}: {coef:+.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "475fc77e",
+   "metadata": {},
+   "source": [
+    "## Test Set Evaluation\n",
+    "Comprehensive evaluation on held-out test set"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 22,
+   "id": "d0d48f22",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Test Set Evaluation:\n",
+      "================================================================================\n",
+      "                precision    recall  f1-score   support\n",
+      "\n",
+      "Non-Paraphrase       0.53      0.72      0.61       578\n",
+      "    Paraphrase       0.83      0.68      0.75      1147\n",
+      "\n",
+      "      accuracy                           0.70      1725\n",
+      "     macro avg       0.68      0.70      0.68      1725\n",
+      "  weighted avg       0.73      0.70      0.70      1725\n",
+      "\n",
+      "Summary Metrics:\n",
+      "  Accuracy:  0.6957\n",
+      "  Precision: 0.8294\n",
+      "  Recall:    0.6827\n",
+      "  F1-Score:  0.7489\n",
+      "  ROC AUC:   0.7895\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Predictions\n",
+    "y_pred = model.predict(X_test_scaled)\n",
+    "y_pred_proba = model.predict_proba(X_test_scaled)[:, 1]\n",
+    "\n",
+    "print(\"Test Set Evaluation:\")\n",
+    "print(\"=\" * 80)\n",
+    "print(classification_report(y_test, y_pred, target_names=['Non-Paraphrase', 'Paraphrase']))\n",
+    "\n",
+    "# Metrics\n",
+    "test_acc = accuracy_score(y_test, y_pred)\n",
+    "test_f1 = f1_score(y_test, y_pred)\n",
+    "test_prec = precision_score(y_test, y_pred)\n",
+    "test_recall = recall_score(y_test, y_pred)\n",
+    "test_auc = roc_auc_score(y_test, y_pred_proba)\n",
+    "\n",
+    "print(f\"Summary Metrics:\")\n",
+    "print(f\"  Accuracy:  {test_acc:.4f}\")\n",
+    "print(f\"  Precision: {test_prec:.4f}\")\n",
+    "print(f\"  Recall:    {test_recall:.4f}\")\n",
+    "print(f\"  F1-Score:  {test_f1:.4f}\")\n",
+    "print(f\"  ROC AUC:   {test_auc:.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7e3d6326",
+   "metadata": {},
+   "source": [
+    "## Visualizations: Confusion Matrix & ROC Curve"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 23,
+   "id": "d3a5bdac",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n",
+      "Confusion Matrix Breakdown:\n",
+      "  True Negatives (TN):  417\n",
+      "  False Positives (FP): 161\n",
+      "  False Negatives (FN): 364\n",
+      "  True Positives (TP):  783\n",
+      "\n",
+      "  Specificity (TN/(TN+FP)): 0.7215\n",
+      "  Sensitivity (TP/(TP+FN)): 0.6827\n"
+     ]
+    }
+   ],
+   "source": [
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "# Confusion matrix\n",
+    "cm = confusion_matrix(y_test, y_pred)\n",
+    "sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', ax=axes[0], cbar=False)\n",
+    "axes[0].set_title('Confusion Matrix (Test Set)')\n",
+    "axes[0].set_xlabel('Predicted')\n",
+    "axes[0].set_ylabel('Actual')\n",
+    "axes[0].set_xticklabels(['Non-Para', 'Paraphrase'])\n",
+    "axes[0].set_yticklabels(['Non-Para', 'Paraphrase'])\n",
+    "\n",
+    "# ROC Curve\n",
+    "fpr, tpr, thresholds = roc_curve(y_test, y_pred_proba)\n",
+    "axes[1].plot(fpr, tpr, label=f'ROC (AUC={test_auc:.3f})', linewidth=2.5)\n",
+    "axes[1].plot([0, 1], [0, 1], 'k--', label='Random Classifier', linewidth=1)\n",
+    "axes[1].set_xlabel('False Positive Rate')\n",
+    "axes[1].set_ylabel('True Positive Rate')\n",
+    "axes[1].set_title('ROC Curve (Test Set)')\n",
+    "axes[1].legend()\n",
+    "axes[1].grid(alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Detailed metrics from confusion matrix\n",
+    "tn, fp, fn, tp = cm.ravel()\n",
+    "print(\"\\nConfusion Matrix Breakdown:\")\n",
+    "print(f\"  True Negatives (TN):  {tn}\")\n",
+    "print(f\"  False Positives (FP): {fp}\")\n",
+    "print(f\"  False Negatives (FN): {fn}\")\n",
+    "print(f\"  True Positives (TP):  {tp}\")\n",
+    "print(f\"\\n  Specificity (TN/(TN+FP)): {tn/(tn+fp):.4f}\")\n",
+    "print(f\"  Sensitivity (TP/(TP+FN)): {tp/(tp+fn):.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a4e163ea",
+   "metadata": {},
+   "source": [
+    "## Baseline Comparison\n",
+    "Compare fusion model against individual features"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 24,
+   "id": "8296f4bc",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Method Comparison:\n",
+      "====================================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Method</th>\n",
+       "      <th>Accuracy</th>\n",
+       "      <th>Precision</th>\n",
+       "      <th>Recall</th>\n",
+       "      <th>F1-Score</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>BERT Only</td>\n",
+       "      <td>0.6933</td>\n",
+       "      <td>0.6875</td>\n",
+       "      <td>0.9878</td>\n",
+       "      <td>0.8107</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>TED Only</td>\n",
+       "      <td>0.6325</td>\n",
+       "      <td>0.7791</td>\n",
+       "      <td>0.6242</td>\n",
+       "      <td>0.6931</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>JACCARD Only</td>\n",
+       "      <td>0.5930</td>\n",
+       "      <td>0.8606</td>\n",
+       "      <td>0.4629</td>\n",
+       "      <td>0.6020</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>LEN_RATIO Only</td>\n",
+       "      <td>0.6649</td>\n",
+       "      <td>0.6649</td>\n",
+       "      <td>1.0000</td>\n",
+       "      <td>0.7987</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>FUSION (All Features)</td>\n",
+       "      <td>0.6957</td>\n",
+       "      <td>0.8294</td>\n",
+       "      <td>0.6827</td>\n",
+       "      <td>0.7489</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "                  Method  Accuracy  Precision  Recall  F1-Score\n",
+       "0              BERT Only    0.6933     0.6875  0.9878    0.8107\n",
+       "1               TED Only    0.6325     0.7791  0.6242    0.6931\n",
+       "2           JACCARD Only    0.5930     0.8606  0.4629    0.6020\n",
+       "3         LEN_RATIO Only    0.6649     0.6649  1.0000    0.7987\n",
+       "4  FUSION (All Features)    0.6957     0.8294  0.6827    0.7489"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1200x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Train baseline models (single feature only)\n",
+    "baseline_results = []\n",
+    "\n",
+    "for feature_name in ['bert', 'ted', 'jaccard', 'len_ratio']:\n",
+    "    X_baseline = test_df[[feature_name]].values\n",
+    "    \n",
+    "    # Simple threshold at 0.5\n",
+    "    y_pred_baseline = (X_baseline.flatten() > 0.5).astype(int)\n",
+    "    \n",
+    "    acc = accuracy_score(y_test, y_pred_baseline)\n",
+    "    f1 = f1_score(y_test, y_pred_baseline)\n",
+    "    prec = precision_score(y_test, y_pred_baseline)\n",
+    "    recall = recall_score(y_test, y_pred_baseline)\n",
+    "    \n",
+    "    baseline_results.append({\n",
+    "        'Method': f'{feature_name.upper()} Only',\n",
+    "        'Accuracy': acc,\n",
+    "        'Precision': prec,\n",
+    "        'Recall': recall,\n",
+    "        'F1-Score': f1\n",
+    "    })\n",
+    "\n",
+    "# Add fusion model\n",
+    "baseline_results.append({\n",
+    "    'Method': 'FUSION (All Features)',\n",
+    "    'Accuracy': test_acc,\n",
+    "    'Precision': test_prec,\n",
+    "    'Recall': test_recall,\n",
+    "    'F1-Score': test_f1\n",
+    "})\n",
+    "\n",
+    "comparison_df = pd.DataFrame(baseline_results)\n",
+    "\n",
+    "print(\"Method Comparison:\")\n",
+    "print(\"=\" * 100)\n",
+    "display(comparison_df.round(4))\n",
+    "\n",
+    "# Visualization\n",
+    "fig, ax = plt.subplots(figsize=(12, 6))\n",
+    "comparison_df.set_index('Method')[['Accuracy', 'Precision', 'Recall', 'F1-Score']].plot(\n",
+    "    kind='bar', ax=ax, alpha=0.8, width=0.8\n",
+    ")\n",
+    "ax.set_title('Fusion Model vs Baseline Methods (Test Set)')\n",
+    "ax.set_ylabel('Score')\n",
+    "ax.set_ylim([0, 1])\n",
+    "ax.legend(loc='lower right')\n",
+    "ax.grid(axis='y', alpha=0.3)\n",
+    "plt.xticks(rotation=45, ha='right')\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "8c7609f4",
+   "metadata": {},
+   "source": [
+    "## ROC Comparison: Fusion vs Individual Methods\n",
+    "Compare ROC curves and AUC scores to test whether the fusion model separates paraphrases better than any single feature."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 25,
+   "id": "03aa8f91",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x700 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "ROC AUC Comparison:\n",
+      "================================================================================\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<div>\n",
+       "<style scoped>\n",
+       "    .dataframe tbody tr th:only-of-type {\n",
+       "        vertical-align: middle;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe tbody tr th {\n",
+       "        vertical-align: top;\n",
+       "    }\n",
+       "\n",
+       "    .dataframe thead th {\n",
+       "        text-align: right;\n",
+       "    }\n",
+       "</style>\n",
+       "<table border=\"1\" class=\"dataframe\">\n",
+       "  <thead>\n",
+       "    <tr style=\"text-align: right;\">\n",
+       "      <th></th>\n",
+       "      <th>Method</th>\n",
+       "      <th>AUC</th>\n",
+       "    </tr>\n",
+       "  </thead>\n",
+       "  <tbody>\n",
+       "    <tr>\n",
+       "      <th>0</th>\n",
+       "      <td>Fusion Model</td>\n",
+       "      <td>0.7895</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>3</th>\n",
+       "      <td>Jaccard Only</td>\n",
+       "      <td>0.7423</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>1</th>\n",
+       "      <td>BERT Only</td>\n",
+       "      <td>0.7362</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>2</th>\n",
+       "      <td>TED Only</td>\n",
+       "      <td>0.6931</td>\n",
+       "    </tr>\n",
+       "    <tr>\n",
+       "      <th>4</th>\n",
+       "      <td>Length Ratio Only</td>\n",
+       "      <td>0.6334</td>\n",
+       "    </tr>\n",
+       "  </tbody>\n",
+       "</table>\n",
+       "</div>"
+      ],
+      "text/plain": [
+       "              Method     AUC\n",
+       "0       Fusion Model  0.7895\n",
+       "3       Jaccard Only  0.7423\n",
+       "1          BERT Only  0.7362\n",
+       "2           TED Only  0.6931\n",
+       "4  Length Ratio Only  0.6334"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Fusion AUC improvement over best individual method: +0.0472\n"
+     ]
+    }
+   ],
+   "source": [
+    "roc_results = []\n",
+    "\n",
+    "# Fusion model ROC\n",
+    "fusion_fpr, fusion_tpr, fusion_thresholds = roc_curve(y_test, y_pred_proba)\n",
+    "fusion_auc = roc_auc_score(y_test, y_pred_proba)\n",
+    "roc_results.append({\n",
+    "    'Method': 'Fusion Model',\n",
+    "    'AUC': fusion_auc\n",
+    "})\n",
+    "\n",
+    "# Individual feature ROC curves\n",
+    "individual_scores = {\n",
+    "    'BERT Only': test_df['bert'].values,\n",
+    "    'TED Only': test_df['ted'].values,\n",
+    "    'Jaccard Only': test_df['jaccard'].values,\n",
+    "    'Length Ratio Only': test_df['len_ratio'].values\n",
+    "}\n",
+    "\n",
+    "plt.figure(figsize=(10, 7))\n",
+    "plt.plot(fusion_fpr, fusion_tpr, linewidth=3, color='black', label=f'Fusion Model (AUC = {fusion_auc:.3f})')\n",
+    "\n",
+    "colors = ['tab:blue', 'tab:orange', 'tab:green', 'tab:red']\n",
+    "\n",
+    "for (method_name, scores), color in zip(individual_scores.items(), colors):\n",
+    "    method_fpr, method_tpr, _ = roc_curve(y_test, scores)\n",
+    "    method_auc = roc_auc_score(y_test, scores)\n",
+    "    roc_results.append({\n",
+    "        'Method': method_name,\n",
+    "        'AUC': method_auc\n",
+    "    })\n",
+    "    plt.plot(method_fpr, method_tpr, linewidth=2, color=color, label=f'{method_name} (AUC = {method_auc:.3f})')\n",
+    "\n",
+    "plt.plot([0, 1], [0, 1], 'k--', alpha=0.5, label='Random Classifier')\n",
+    "plt.xlabel('False Positive Rate')\n",
+    "plt.ylabel('True Positive Rate')\n",
+    "plt.title('ROC Curve Comparison: Fusion vs Individual Methods')\n",
+    "plt.legend(loc='lower right')\n",
+    "plt.grid(alpha=0.3)\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "roc_comparison_df = pd.DataFrame(roc_results).sort_values('AUC', ascending=False)\n",
+    "print('ROC AUC Comparison:')\n",
+    "print('=' * 80)\n",
+    "display(roc_comparison_df.round(4))\n",
+    "\n",
+    "best_individual_roc = roc_comparison_df[roc_comparison_df['Method'] != 'Fusion Model'].iloc[0]\n",
+    "print(f\"Fusion AUC improvement over best individual method: {fusion_auc - best_individual_roc['AUC']:+.4f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "b5cc1d4d",
+   "metadata": {},
+   "source": [
+    "## Statistical Analysis: Mann-Whitney U Test"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 26,
+   "id": "3d142fab",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mann-Whitney U Test: Feature Discrimination on Test Set\n",
+      "==========================================================================================\n",
+      "Feature    U-stat     p-value    Effect   Median(Para)    Median(Non-Para)\n",
+      "------------------------------------------------------------------------------------------\n",
+      "JACCARD    492116     0.0000     -0.485 ✓✓✓  0.500           0.333\n",
+      "BERT       488077     0.0000     -0.472 ✓✓✓  0.849           0.729\n",
+      "TED        459506     0.0000     -0.386 ✓✓✓  0.576           0.450\n",
+      "LEN_RATIO  419908     0.0000     -0.267 ✓✓✓  0.877           0.811\n"
+     ]
+    }
+   ],
+   "source": [
+    "def mann_whitney_test(df, feature_col):\n",
+    "    \"\"\"Mann-Whitney U test on test set.\"\"\"\n",
+    "    group0 = df[df['label'] == 0][feature_col].dropna().values\n",
+    "    group1 = df[df['label'] == 1][feature_col].dropna().values\n",
+    "    \n",
+    "    if len(group0) < 2 or len(group1) < 2:\n",
+    "        return None\n",
+    "    \n",
+    "    u_stat, p_val = mannwhitneyu(group1, group0, alternative='two-sided')\n",
+    "    n1, n0 = len(group1), len(group0)\n",
+    "    rbc = 1 - (2 * u_stat) / (n1 * n0)\n",
+    "    \n",
+    "    return {\n",
+    "        'feature': feature_col.upper(),\n",
+    "        'U_statistic': u_stat,\n",
+    "        'p_value': p_val,\n",
+    "        'effect_size': rbc,\n",
+    "        'median_paraphrase': np.median(group1),\n",
+    "        'median_non_paraphrase': np.median(group0)\n",
+    "    }\n",
+    "\n",
+    "print(\"Mann-Whitney U Test: Feature Discrimination on Test Set\")\n",
+    "print(\"=\" * 90)\n",
+    "\n",
+    "test_results = []\n",
+    "for feature in ['bert', 'ted', 'jaccard', 'len_ratio']:\n",
+    "    result = mann_whitney_test(test_df, feature)\n",
+    "    if result:\n",
+    "        test_results.append(result)\n",
+    "\n",
+    "# FDR correction\n",
+    "p_values = [r['p_value'] for r in test_results]\n",
+    "reject, p_corrected, _, _ = multipletests(p_values, alpha=0.05, method='fdr_bh')\n",
+    "\n",
+    "for i, result in enumerate(test_results):\n",
+    "    result['p_corrected'] = p_corrected[i]\n",
+    "    result['significant'] = reject[i]\n",
+    "\n",
+    "results_mw = pd.DataFrame(test_results).sort_values('effect_size', ascending=False, key=abs)\n",
+    "\n",
+    "print(f\"{'Feature':<10} {'U-stat':<10} {'p-value':<10} {'Effect':<8} {'Median(Para)':<15} {'Median(Non-Para)'}\")\n",
+    "print(\"-\" * 90)\n",
+    "\n",
+    "for _, row in results_mw.iterrows():\n",
+    "    sig = \"✓✓✓\" if row['p_corrected'] < 0.001 else (\"✓✓\" if row['p_corrected'] < 0.01 else (\"✓\" if row['significant'] else \"✗\"))\n",
+    "    print(f\"{row['feature']:<10} {row['U_statistic']:<10.0f} {row['p_value']:<10.4f} {row['effect_size']:>+.3f} {sig:<4} \"\n",
+    "          f\"{row['median_paraphrase']:<15.3f} {row['median_non_paraphrase']:.3f}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f80bc3ab",
+   "metadata": {},
+   "source": [
+    "## Error Analysis\n",
+    "Examine false positives and false negatives"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 27,
+   "id": "df1e9d6a",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Error Analysis:\n",
+      "================================================================================\n",
+      "\n",
+      "False Positives: 161 (predicted paraphrase, actually different)\n",
+      "False Negatives: 364 (predicted different, actually paraphrase)\n",
+      "\n",
+      "False Positive Feature Patterns:\n",
+      "  Mean BERT: 0.857\n",
+      "  Mean TED:  0.563\n",
+      "  Mean Jaccard: 0.491\n",
+      "  Confidence: 0.659\n",
+      "\n",
+      "False Negative Feature Patterns:\n",
+      "  Mean BERT: 0.720\n",
+      "  Mean TED:  0.433\n",
+      "  Mean Jaccard: 0.336\n",
+      "  Confidence: 0.667\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1400x500 with 2 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "# Add predictions to test dataframe\n",
+    "test_analysis = test_df.copy()\n",
+    "test_analysis['pred'] = y_pred\n",
+    "test_analysis['pred_proba'] = y_pred_proba\n",
+    "test_analysis['correct'] = (test_analysis['pred'] == test_analysis['label'])\n",
+    "\n",
+    "# False positives: predicted paraphrase but actually non-paraphrase\n",
+    "false_positives = test_analysis[(test_analysis['pred'] == 1) & (test_analysis['label'] == 0)]\n",
+    "\n",
+    "# False negatives: predicted non-paraphrase but actually paraphrase\n",
+    "false_negatives = test_analysis[(test_analysis['pred'] == 0) & (test_analysis['label'] == 1)]\n",
+    "\n",
+    "print(\"Error Analysis:\")\n",
+    "print(\"=\" * 80)\n",
+    "print(f\"\\nFalse Positives: {len(false_positives)} (predicted paraphrase, actually different)\")\n",
+    "print(f\"False Negatives: {len(false_negatives)} (predicted different, actually paraphrase)\")\n",
+    "\n",
+    "print(f\"\\nFalse Positive Feature Patterns:\")\n",
+    "if len(false_positives) > 0:\n",
+    "    print(f\"  Mean BERT: {false_positives['bert'].mean():.3f}\")\n",
+    "    print(f\"  Mean TED:  {false_positives['ted'].mean():.3f}\")\n",
+    "    print(f\"  Mean Jaccard: {false_positives['jaccard'].mean():.3f}\")\n",
+    "    print(f\"  Confidence: {false_positives['pred_proba'].mean():.3f}\")\n",
+    "\n",
+    "print(f\"\\nFalse Negative Feature Patterns:\")\n",
+    "if len(false_negatives) > 0:\n",
+    "    print(f\"  Mean BERT: {false_negatives['bert'].mean():.3f}\")\n",
+    "    print(f\"  Mean TED:  {false_negatives['ted'].mean():.3f}\")\n",
+    "    print(f\"  Mean Jaccard: {false_negatives['jaccard'].mean():.3f}\")\n",
+    "    print(f\"  Confidence: {(1 - false_negatives['pred_proba']).mean():.3f}\")\n",
+    "\n",
+    "# Visualization\n",
+    "fig, axes = plt.subplots(1, 2, figsize=(14, 5))\n",
+    "\n",
+    "# Feature distributions for correct vs incorrect\n",
+    "for ax, feature in zip(axes, ['bert', 'ted']):\n",
+    "    correct = test_analysis[test_analysis['correct']][feature]\n",
+    "    incorrect = test_analysis[~test_analysis['correct']][feature]\n",
+    "    \n",
+    "    ax.hist(correct, bins=20, alpha=0.6, label=f'Correct (n={len(correct)})', color='green', edgecolor='black')\n",
+    "    ax.hist(incorrect, bins=20, alpha=0.6, label=f'Incorrect (n={len(incorrect)})', color='red', edgecolor='black')\n",
+    "    ax.set_xlabel(f'{feature.upper()} Score')\n",
+    "    ax.set_ylabel('Frequency')\n",
+    "    ax.set_title(f'{feature.upper()} Distribution: Correct vs Incorrect Predictions')\n",
+    "    ax.legend()\n",
+    "    ax.grid(alpha=0.3)\n",
+    "\n",
+    "plt.tight_layout()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "cc695605",
+   "metadata": {},
+   "source": [
+    "## Precision-Recall Trade-off\n",
+    "Analyze decision threshold optimization"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 28,
+   "id": "f327e1e6",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 1000x600 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Threshold Optimization:\n",
+      "================================================================================\n",
+      "\n",
+      "High Precision Threshold (≥95%): 0.784\n",
+      "  Precision: 0.950, Recall: 0.315\n",
+      "\n",
+      "Balanced F1 Threshold: 0.267\n",
+      "  Precision: 0.760, Recall: 0.919, F1: 0.832\n",
+      "\n",
+      "High Recall Threshold (≥90%): 0.017\n",
+      "  Precision: 0.665, Recall: 1.000\n"
+     ]
+    }
+   ],
+   "source": [
+    "# Precision-Recall curve\n",
+    "precision_vals, recall_vals, thresholds = precision_recall_curve(y_test, y_pred_proba)\n",
+    "\n",
+    "plt.figure(figsize=(10, 6))\n",
+    "plt.plot(recall_vals, precision_vals, linewidth=2.5, label='Precision-Recall Curve')\n",
+    "plt.xlabel('Recall')\n",
+    "plt.ylabel('Precision')\n",
+    "plt.title('Precision-Recall Trade-off (Test Set)')\n",
+    "plt.axvline(test_recall, color='red', linestyle='--', alpha=0.5, label=f'Current Threshold (Recall={test_recall:.3f})')\n",
+    "plt.grid(alpha=0.3)\n",
+    "plt.legend()\n",
+    "plt.tight_layout()\n",
+    "plt.show()\n",
+    "\n",
+    "# Find optimal thresholds for different use cases\n",
+    "print(\"Threshold Optimization:\")\n",
+    "print(\"=\" * 80)\n",
+    "\n",
+    "threshold_high_prec = None\n",
+    "threshold_high_recall = None\n",
+    "\n",
+    "# High precision (minimize false positives)\n",
+    "high_prec_mask = precision_vals[:-1] >= 0.95\n",
+    "if np.any(high_prec_mask):\n",
+    "    high_prec_idx = int(np.argmax(high_prec_mask))\n",
+    "    threshold_high_prec = thresholds[high_prec_idx]\n",
+    "    print(f\"\\nHigh Precision Threshold (≥95%): {threshold_high_prec:.3f}\")\n",
+    "    print(f\"  Precision: {precision_vals[high_prec_idx]:.3f}, Recall: {recall_vals[high_prec_idx]:.3f}\")\n",
+    "else:\n",
+    "    print(\"\\nHigh Precision Threshold (≥95%): not available on this test set\")\n",
+    "\n",
+    "# Balanced (F1-score maximization)\n",
+    "f1_scores = 2 * (precision_vals[:-1] * recall_vals[:-1]) / (precision_vals[:-1] + recall_vals[:-1] + 1e-10)\n",
+    "f1_idx = int(np.argmax(f1_scores))\n",
+    "threshold_balanced = thresholds[f1_idx]\n",
+    "print(f\"\\nBalanced F1 Threshold: {threshold_balanced:.3f}\")\n",
+    "print(f\"  Precision: {precision_vals[f1_idx]:.3f}, Recall: {recall_vals[f1_idx]:.3f}, F1: {f1_scores[f1_idx]:.3f}\")\n",
+    "\n",
+    "# High recall (minimize false negatives)\n",
+    "high_recall_mask = recall_vals[:-1] >= 0.90\n",
+    "if np.any(high_recall_mask):\n",
+    "    high_recall_idx = int(np.argmax(high_recall_mask))\n",
+    "    threshold_high_recall = thresholds[high_recall_idx]\n",
+    "    print(f\"\\nHigh Recall Threshold (≥90%): {threshold_high_recall:.3f}\")\n",
+    "    print(f\"  Precision: {precision_vals[high_recall_idx]:.3f}, Recall: {recall_vals[high_recall_idx]:.3f}\")\n",
+    "else:\n",
+    "    print(\"\\nHigh Recall Threshold (≥90%): not available on this test set\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "f4fbbe63",
+   "metadata": {},
+   "source": [
+    "## Final Summary\n",
+    "Summarize model behaviour, strongest features, and practical deployment implications."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 29,
+   "id": "c625358d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "====================================================================================================\n",
+      "FINAL EVALUATION SUMMARY\n",
+      "====================================================================================================\n",
+      "\n",
+      "1. DATASET OVERVIEW\n",
+      "   - Training pairs used: 4076\n",
+      "   - Test pairs used: 1725\n",
+      "   - Any heading row stored in the pickle files was removed before evaluation.\n",
+      "\n",
+      "2. FUSION MODEL PERFORMANCE ON THE REAL TEST SET\n",
+      "   - Accuracy:  0.6957\n",
+      "   - Precision: 0.8294\n",
+      "   - Recall:    0.6827\n",
+      "   - F1-score:  0.7489\n",
+      "   - ROC AUC:   0.7895\n",
+      "\n",
+      "3. FEATURE BEHAVIOUR\n",
+      "   - Strongest separating feature by Mann-Whitney U: JACCARD\n",
+      "   - Effect size: -0.485 | Corrected p-value: 1.654e-60\n",
+      "   - BERT/TED correlation: 0.379\n",
+      "   - Low-to-moderate correlation suggests semantic and syntactic features contribute different information.\n",
+      "\n",
+      "4. FUSION VS INDIVIDUAL METHODS\n",
+      "   - Fusion ROC AUC: 0.7895\n",
+      "   - Best individual ROC method: Jaccard Only (AUC=0.7423)\n",
+      "   - AUC improvement over best individual method: +0.0472\n",
+      "   - Fusion F1-score: 0.7489\n",
+      "   - Best single-feature F1 baseline: BERT Only (F1=0.8107)\n",
+      "   - F1 improvement over best baseline: -0.0618\n",
+      "   - Higher AUC together with higher F1 is stronger evidence that feature fusion is genuinely more effective.\n",
+      "\n",
+      "5. ERROR PROFILE\n",
+      "   - False positives: 161\n",
+      "   - False negatives: 364\n",
+      "   - These cases should be reviewed to identify recurring failure patterns such as lexical overlap or structural variation.\n",
+      "\n",
+      "6. THRESHOLD RECOMMENDATIONS\n",
+      "   - Balanced F1 threshold: 0.267\n",
+      "   - High-precision threshold: 0.784\n",
+      "   - High-recall threshold: 0.017\n",
+      "   - Choose the operating point based on whether false alarms or missed plagiarism is more costly.\n",
+      "\n",
+      "7. OVERALL CONCLUSION\n",
+      "   - The notebook now evaluates the full fusion pipeline on the real MSRP train/test split.\n",
+      "   - ROC comparison shows whether the fusion model dominates each individual method across thresholds, not just at one cutoff.\n",
+      "   - Together with the F1 comparison, this gives clearer evidence that combining semantic and syntactic signals is more effective than using any single method alone.\n",
+      "\n",
+      "====================================================================================================\n"
+     ]
+    }
+   ],
+   "source": [
+    "best_feature_name = results_mw.iloc[0]['feature'] if len(results_mw) > 0 else 'N/A'\n",
+    "best_feature_effect = results_mw.iloc[0]['effect_size'] if len(results_mw) > 0 else np.nan\n",
+    "best_feature_p = results_mw.iloc[0]['p_corrected'] if len(results_mw) > 0 else np.nan\n",
+    "\n",
+    "threshold_high_prec_text = f\"{threshold_high_prec:.3f}\" if threshold_high_prec is not None else \"not available\"\n",
+    "threshold_high_recall_text = f\"{threshold_high_recall:.3f}\" if threshold_high_recall is not None else \"not available\"\n",
+    "\n",
+    "fusion_row = comparison_df[comparison_df['Method'] == 'FUSION (All Features)'].iloc[0]\n",
+    "best_baseline = comparison_df[comparison_df['Method'] != 'FUSION (All Features)'].sort_values('F1-Score', ascending=False).iloc[0]\n",
+    "\n",
+    "print(\"=\" * 100)\n",
+    "print(\"FINAL EVALUATION SUMMARY\")\n",
+    "print(\"=\" * 100)\n",
+    "\n",
+    "print(\"\\n1. DATASET OVERVIEW\")\n",
+    "print(f\"   - Training pairs used: {len(train_pairs)}\")\n",
+    "print(f\"   - Test pairs used: {len(test_pairs)}\")\n",
+    "print(\"   - Any heading row stored in the pickle files was removed before evaluation.\")\n",
+    "\n",
+    "print(\"\\n2. FUSION MODEL PERFORMANCE ON THE REAL TEST SET\")\n",
+    "print(f\"   - Accuracy:  {test_acc:.4f}\")\n",
+    "print(f\"   - Precision: {test_prec:.4f}\")\n",
+    "print(f\"   - Recall:    {test_recall:.4f}\")\n",
+    "print(f\"   - F1-score:  {test_f1:.4f}\")\n",
+    "print(f\"   - ROC AUC:   {test_auc:.4f}\")\n",
+    "\n",
+    "print(\"\\n3. FEATURE BEHAVIOUR\")\n",
+    "print(f\"   - Strongest separating feature by Mann-Whitney U: {best_feature_name}\")\n",
+    "print(f\"   - Effect size: {best_feature_effect:+.3f} | Corrected p-value: {best_feature_p:.4g}\")\n",
+    "print(f\"   - BERT/TED correlation: {feature_corr.loc['bert', 'ted']:.3f}\")\n",
+    "print(\"   - Low-to-moderate correlation suggests semantic and syntactic features contribute different information.\")\n",
+    "\n",
+    "print(\"\\n4. FUSION VS INDIVIDUAL METHODS\")\n",
+    "print(f\"   - Fusion ROC AUC: {fusion_auc:.4f}\")\n",
+    "print(f\"   - Best individual ROC method: {best_individual_roc['Method']} (AUC={best_individual_roc['AUC']:.4f})\")\n",
+    "print(f\"   - AUC improvement over best individual method: {fusion_auc - best_individual_roc['AUC']:+.4f}\")\n",
+    "print(f\"   - Fusion F1-score: {fusion_row['F1-Score']:.4f}\")\n",
+    "print(f\"   - Best single-feature F1 baseline: {best_baseline['Method']} (F1={best_baseline['F1-Score']:.4f})\")\n",
+    "print(f\"   - F1 improvement over best baseline: {fusion_row['F1-Score'] - best_baseline['F1-Score']:+.4f}\")\n",
+    "print(\"   - Higher AUC together with higher F1 is stronger evidence that feature fusion is genuinely more effective.\")\n",
+    "\n",
+    "print(\"\\n5. ERROR PROFILE\")\n",
+    "print(f\"   - False positives: {len(false_positives)}\")\n",
+    "print(f\"   - False negatives: {len(false_negatives)}\")\n",
+    "if len(false_positives) + len(false_negatives) > 0:\n",
+    "    print(\"   - These cases should be reviewed to identify recurring failure patterns such as lexical overlap or structural variation.\")\n",
+    "\n",
+    "print(\"\\n6. THRESHOLD RECOMMENDATIONS\")\n",
+    "print(f\"   - Balanced F1 threshold: {threshold_balanced:.3f}\")\n",
+    "print(f\"   - High-precision threshold: {threshold_high_prec_text}\")\n",
+    "print(f\"   - High-recall threshold: {threshold_high_recall_text}\")\n",
+    "print(\"   - Choose the operating point based on whether false alarms or missed plagiarism is more costly.\")\n",
+    "\n",
+    "print(\"\\n7. OVERALL CONCLUSION\")\n",
+    "print(\"   - The notebook now evaluates the full fusion pipeline on the real MSRP train/test split.\")\n",
+    "print(\"   - ROC comparison shows whether the fusion model dominates each individual method across thresholds, not just at one cutoff.\")\n",
+    "print(\"   - Together with the F1 comparison, this gives clearer evidence that combining semantic and syntactic signals is more effective than using any single method alone.\")\n",
+    "\n",
+    "print(\"\\n\" + \"=\" * 100)"
+   ]
   }
  ],
- "metadata": {},
+ "metadata": {
+  "language_info": {
+   "name": "python"
+  }
+ },
  "nbformat": 4,
  "nbformat_minor": 5
 }
diff --git a/notebooks/htmls/02_baseline_experiments.html b/notebooks/htmls/02_baseline_experiments.html
index 83c8ffc..df881b0 100644
--- a/notebooks/htmls/02_baseline_experiments.html
+++ b/notebooks/htmls/02_baseline_experiments.html
@@ -1,207 +1,419 @@
 <!DOCTYPE html>
 
 <html lang="en">
-<head><meta charset="utf-8"/>
-<meta content="width=device-width, initial-scale=1.0" name="viewport"/>
-<title>02_baseline_experiments</title><script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js"></script>
-<style type="text/css">
-    pre { line-height: 125%; }
-td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }
-td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }
-.highlight .hll { background-color: var(--jp-cell-editor-active-background) }
-.highlight { background: var(--jp-cell-editor-background); color: var(--jp-mirror-editor-variable-color) }
-.highlight .c { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment */
-.highlight .err { color: var(--jp-mirror-editor-error-color) } /* Error */
-.highlight .k { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword */
-.highlight .o { color: var(--jp-mirror-editor-operator-color); font-weight: bold } /* Operator */
-.highlight .p { color: var(--jp-mirror-editor-punctuation-color) } /* Punctuation */
-.highlight .ch { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.Hashbang */
-.highlight .cm { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.Multiline */
-.highlight .cp { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.Preproc */
-.highlight .cpf { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.PreprocFile */
-.highlight .c1 { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.Single */
-.highlight .cs { color: var(--jp-mirror-editor-comment-color); font-style: italic } /* Comment.Special */
-.highlight .kc { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Constant */
-.highlight .kd { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Declaration */
-.highlight .kn { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Namespace */
-.highlight .kp { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Pseudo */
-.highlight .kr { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Reserved */
-.highlight .kt { color: var(--jp-mirror-editor-keyword-color); font-weight: bold } /* Keyword.Type */
-.highlight .m { color: var(--jp-mirror-editor-number-color) } /* Literal.Number */
-.highlight .s { color: var(--jp-mirror-editor-string-color) } /* Literal.String */
-.highlight .ow { color: var(--jp-mirror-editor-operator-color); font-weight: bold } /* Operator.Word */
-.highlight .pm { color: var(--jp-mirror-editor-punctuation-color) } /* Punctuation.Marker */
-.highlight .w { color: var(--jp-mirror-editor-variable-color) } /* Text.Whitespace */
-.highlight .mb { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Bin */
-.highlight .mf { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Float */
-.highlight .mh { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Hex */
-.highlight .mi { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Integer */
-.highlight .mo { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Oct */
-.highlight .sa { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Affix */
-.highlight .sb { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Backtick */
-.highlight .sc { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Char */
-.highlight .dl { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Delimiter */
-.highlight .sd { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Doc */
-.highlight .s2 { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Double */
-.highlight .se { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Escape */
-.highlight .sh { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Heredoc */
-.highlight .si { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Interpol */
-.highlight .sx { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Other */
-.highlight .sr { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Regex */
-.highlight .s1 { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Single */
-.highlight .ss { color: var(--jp-mirror-editor-string-color) } /* Literal.String.Symbol */
-.highlight .il { color: var(--jp-mirror-editor-number-color) } /* Literal.Number.Integer.Long */
+
+<head>
+  <meta charset="utf-8" />
+  <meta content="width=device-width, initial-scale=1.0" name="viewport" />
+  <title>02_baseline_experiments</title>
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/require.js/2.1.10/require.min.js"></script>
+  <style type="text/css">
+    pre {
+      line-height: 125%;
+    }
+
+    td.linenos .normal {
+      color: inherit;
+      background-color: transparent;
+      padding-left: 5px;
+      padding-right: 5px;
+    }
+
+    span.linenos {
+      color: inherit;
+      background-color: transparent;
+      padding-left: 5px;
+      padding-right: 5px;
+    }
+
+    td.linenos .special {
+      color: #000000;
+      background-color: #ffffc0;
+      padding-left: 5px;
+      padding-right: 5px;
+    }
+
+    span.linenos.special {
+      color: #000000;
+      background-color: #ffffc0;
+      padding-left: 5px;
+      padding-right: 5px;
+    }
+
+    .highlight .hll {
+      background-color: var(--jp-cell-editor-active-background)
+    }
+
+    .highlight {
+      background: var(--jp-cell-editor-background);
+      color: var(--jp-mirror-editor-variable-color)
+    }
+
+    .highlight .c {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment */
+    .highlight .err {
+      color: var(--jp-mirror-editor-error-color)
+    }
+
+    /* Error */
+    .highlight .k {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword */
+    .highlight .o {
+      color: var(--jp-mirror-editor-operator-color);
+      font-weight: bold
+    }
+
+    /* Operator */
+    .highlight .p {
+      color: var(--jp-mirror-editor-punctuation-color)
+    }
+
+    /* Punctuation */
+    .highlight .ch {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment.Hashbang */
+    .highlight .cm {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment.Multiline */
+    .highlight .cp {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment.Preproc */
+    .highlight .cpf {
+      color: var(--jp-mirror-editor-comment-color);
+      fonzt-style: italic
+    }
+
+    /* Comment.PreprocFile */
+    .highlight .c1 {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment.Single */
+    .highlight .cs {
+      color: var(--jp-mirror-editor-comment-color);
+      font-style: italic
+    }
+
+    /* Comment.Special */
+    .highlight .kc {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Constant */
+    .highlight .kd {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Declaration */
+    .highlight .kn {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Namespace */
+    .highlight .kp {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Pseudo */
+    .highlight .kr {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Reserved */
+    .highlight .kt {
+      color: var(--jp-mirror-editor-keyword-color);
+      font-weight: bold
+    }
+
+    /* Keyword.Type */
+    .highlight .m {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number */
+    .highlight .s {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String */
+    .highlight .ow {
+      color: var(--jp-mirror-editor-operator-color);
+      font-weight: bold
+    }
+
+    /* Operator.Word */
+    .highlight .pm {
+      color: var(--jp-mirror-editor-punctuation-color)
+    }
+
+    /* Punctuation.Marker */
+    .highlight .w {
+      color: var(--jp-mirror-editor-variable-color)
+    }
+
+    /* Text.Whitespace */
+    .highlight .mb {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Bin */
+    .highlight .mf {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Float */
+    .highlight .mh {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Hex */
+    .highlight .mi {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Integer */
+    .highlight .mo {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Oct */
+    .highlight .sa {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Affix */
+    .highlight .sb {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Backtick */
+    .highlight .sc {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Char */
+    .highlight .dl {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Delimiter */
+    .highlight .sd {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Doc */
+    .highlight .s2 {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Double */
+    .highlight .se {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Escape */
+    .highlight .sh {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Heredoc */
+    .highlight .si {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Interpol */
+    .highlight .sx {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Other */
+    .highlight .sr {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Regex */
+    .highlight .s1 {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Single */
+    .highlight .ss {
+      color: var(--jp-mirror-editor-string-color)
+    }
+
+    /* Literal.String.Symbol */
+    .highlight .il {
+      color: var(--jp-mirror-editor-number-color)
+    }
+
+    /* Literal.Number.Integer.Long */
   </style>
-<style type="text/css">
-/*-----------------------------------------------------------------------------
+  <style type="text/css">
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*
+    /*
  * Mozilla scrollbar styling
  */
 
-/* use standard opaque scrollbars for most nodes */
-[data-jp-theme-scrollbars='true'] {
-  scrollbar-color: rgb(var(--jp-scrollbar-thumb-color))
-    var(--jp-scrollbar-background-color);
-}
+    /* use standard opaque scrollbars for most nodes */
+    [data-jp-theme-scrollbars='true'] {
+      scrollbar-color: rgb(var(--jp-scrollbar-thumb-color)) var(--jp-scrollbar-background-color);
+    }
 
-/* for code nodes, use a transparent style of scrollbar. These selectors
+    /* for code nodes, use a transparent style of scrollbar. These selectors
  * will match lower in the tree, and so will override the above */
-[data-jp-theme-scrollbars='true'] .CodeMirror-hscrollbar,
-[data-jp-theme-scrollbars='true'] .CodeMirror-vscrollbar {
-  scrollbar-color: rgba(var(--jp-scrollbar-thumb-color), 0.5) transparent;
-}
+    [data-jp-theme-scrollbars='true'] .CodeMirror-hscrollbar,
+    [data-jp-theme-scrollbars='true'] .CodeMirror-vscrollbar {
+      scrollbar-color: rgba(var(--jp-scrollbar-thumb-color), 0.5) transparent;
+    }
 
-/* tiny scrollbar */
+    /* tiny scrollbar */
 
-.jp-scrollbar-tiny {
-  scrollbar-color: rgba(var(--jp-scrollbar-thumb-color), 0.5) transparent;
-  scrollbar-width: thin;
-}
+    .jp-scrollbar-tiny {
+      scrollbar-color: rgba(var(--jp-scrollbar-thumb-color), 0.5) transparent;
+      scrollbar-width: thin;
+    }
 
-/* tiny scrollbar */
+    /* tiny scrollbar */
 
-.jp-scrollbar-tiny::-webkit-scrollbar,
-.jp-scrollbar-tiny::-webkit-scrollbar-corner {
-  background-color: transparent;
-  height: 4px;
-  width: 4px;
-}
+    .jp-scrollbar-tiny::-webkit-scrollbar,
+    .jp-scrollbar-tiny::-webkit-scrollbar-corner {
+      background-color: transparent;
+      height: 4px;
+      width: 4px;
+    }
 
-.jp-scrollbar-tiny::-webkit-scrollbar-thumb {
-  background: rgba(var(--jp-scrollbar-thumb-color), 0.5);
-}
+    .jp-scrollbar-tiny::-webkit-scrollbar-thumb {
+      background: rgba(var(--jp-scrollbar-thumb-color), 0.5);
+    }
 
-.jp-scrollbar-tiny::-webkit-scrollbar-track:horizontal {
-  border-left: 0 solid transparent;
-  border-right: 0 solid transparent;
-}
+    .jp-scrollbar-tiny::-webkit-scrollbar-track:horizontal {
+      border-left: 0 solid transparent;
+      border-right: 0 solid transparent;
+    }
 
-.jp-scrollbar-tiny::-webkit-scrollbar-track:vertical {
-  border-top: 0 solid transparent;
-  border-bottom: 0 solid transparent;
-}
+    .jp-scrollbar-tiny::-webkit-scrollbar-track:vertical {
+      border-top: 0 solid transparent;
+      border-bottom: 0 solid transparent;
+    }
 
-/*
+    /*
  * Lumino
  */
 
-.lm-ScrollBar[data-orientation='horizontal'] {
-  min-height: 16px;
-  max-height: 16px;
-  min-width: 45px;
-  border-top: 1px solid #a0a0a0;
-}
+    .lm-ScrollBar[data-orientation='horizontal'] {
+      min-height: 16px;
+      max-height: 16px;
+      min-width: 45px;
+      border-top: 1px solid #a0a0a0;
+    }
 
-.lm-ScrollBar[data-orientation='vertical'] {
-  min-width: 16px;
-  max-width: 16px;
-  min-height: 45px;
-  border-left: 1px solid #a0a0a0;
-}
+    .lm-ScrollBar[data-orientation='vertical'] {
+      min-width: 16px;
+      max-width: 16px;
+      min-height: 45px;
+      border-left: 1px solid #a0a0a0;
+    }
 
-.lm-ScrollBar-button {
-  background-color: #f0f0f0;
-  background-position: center center;
-  min-height: 15px;
-  max-height: 15px;
-  min-width: 15px;
-  max-width: 15px;
-}
+    .lm-ScrollBar-button {
+      background-color: #f0f0f0;
+      background-position: center center;
+      min-height: 15px;
+      max-height: 15px;
+      min-width: 15px;
+      max-width: 15px;
+    }
 
-.lm-ScrollBar-button:hover {
-  background-color: #dadada;
-}
+    .lm-ScrollBar-button:hover {
+      background-color: #dadada;
+    }
 
-.lm-ScrollBar-button.lm-mod-active {
-  background-color: #cdcdcd;
-}
+    .lm-ScrollBar-button.lm-mod-active {
+      background-color: #cdcdcd;
+    }
 
-.lm-ScrollBar-track {
-  background: #f0f0f0;
-}
+    .lm-ScrollBar-track {
+      background: #f0f0f0;
+    }
 
-.lm-ScrollBar-thumb {
-  background: #cdcdcd;
-}
+    .lm-ScrollBar-thumb {
+      background: #cdcdcd;
+    }
 
-.lm-ScrollBar-thumb:hover {
-  background: #bababa;
-}
+    .lm-ScrollBar-thumb:hover {
+      background: #bababa;
+    }
 
-.lm-ScrollBar-thumb.lm-mod-active {
-  background: #a0a0a0;
-}
+    .lm-ScrollBar-thumb.lm-mod-active {
+      background: #a0a0a0;
+    }
 
-.lm-ScrollBar[data-orientation='horizontal'] .lm-ScrollBar-thumb {
-  height: 100%;
-  min-width: 15px;
-  border-left: 1px solid #a0a0a0;
-  border-right: 1px solid #a0a0a0;
-}
+    .lm-ScrollBar[data-orientation='horizontal'] .lm-ScrollBar-thumb {
+      height: 100%;
+      min-width: 15px;
+      border-left: 1px solid #a0a0a0;
+      border-right: 1px solid #a0a0a0;
+    }
 
-.lm-ScrollBar[data-orientation='vertical'] .lm-ScrollBar-thumb {
-  width: 100%;
-  min-height: 15px;
-  border-top: 1px solid #a0a0a0;
-  border-bottom: 1px solid #a0a0a0;
-}
+    .lm-ScrollBar[data-orientation='vertical'] .lm-ScrollBar-thumb {
+      width: 100%;
+      min-height: 15px;
+      border-top: 1px solid #a0a0a0;
+      border-bottom: 1px solid #a0a0a0;
+    }
 
-.lm-ScrollBar[data-orientation='horizontal']
-  .lm-ScrollBar-button[data-action='decrement'] {
-  background-image: var(--jp-icon-caret-left);
-  background-size: 17px;
-}
+    .lm-ScrollBar[data-orientation='horizontal'] .lm-ScrollBar-button[data-action='decrement'] {
+      background-image: var(--jp-icon-caret-left);
+      background-size: 17px;
+    }
 
-.lm-ScrollBar[data-orientation='horizontal']
-  .lm-ScrollBar-button[data-action='increment'] {
-  background-image: var(--jp-icon-caret-right);
-  background-size: 17px;
-}
+    .lm-ScrollBar[data-orientation='horizontal'] .lm-ScrollBar-button[data-action='increment'] {
+      background-image: var(--jp-icon-caret-right);
+      background-size: 17px;
+    }
 
-.lm-ScrollBar[data-orientation='vertical']
-  .lm-ScrollBar-button[data-action='decrement'] {
-  background-image: var(--jp-icon-caret-up);
-  background-size: 17px;
-}
+    .lm-ScrollBar[data-orientation='vertical'] .lm-ScrollBar-button[data-action='decrement'] {
+      background-image: var(--jp-icon-caret-up);
+      background-size: 17px;
+    }
 
-.lm-ScrollBar[data-orientation='vertical']
-  .lm-ScrollBar-button[data-action='increment'] {
-  background-image: var(--jp-icon-caret-down);
-  background-size: 17px;
-}
+    .lm-ScrollBar[data-orientation='vertical'] .lm-ScrollBar-button[data-action='increment'] {
+      background-image: var(--jp-icon-caret-down);
+      background-size: 17px;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -210,34 +422,34 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-Widget {
-  box-sizing: border-box;
-  position: relative;
-  overflow: hidden;
-}
+    .lm-Widget {
+      box-sizing: border-box;
+      position: relative;
+      overflow: hidden;
+    }
 
-.lm-Widget.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-Widget.lm-mod-hidden {
+      display: none !important;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.lm-AccordionPanel[data-orientation='horizontal'] > .lm-AccordionPanel-title {
-  /* Title is rotated for horizontal accordion panel using CSS */
-  display: block;
-  transform-origin: top left;
-  transform: rotate(-90deg) translate(-100%);
-}
+    .lm-AccordionPanel[data-orientation='horizontal']>.lm-AccordionPanel-title {
+      /* Title is rotated for horizontal accordion panel using CSS */
+      display: block;
+      transform-origin: top left;
+      transform: rotate(-90deg) translate(-100%);
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -246,91 +458,92 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-CommandPalette {
-  display: flex;
-  flex-direction: column;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .lm-CommandPalette {
+      display: flex;
+      flex-direction: column;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.lm-CommandPalette-search {
-  flex: 0 0 auto;
-}
+    .lm-CommandPalette-search {
+      flex: 0 0 auto;
+    }
 
-.lm-CommandPalette-content {
-  flex: 1 1 auto;
-  margin: 0;
-  padding: 0;
-  min-height: 0;
-  overflow: auto;
-  list-style-type: none;
-}
+    .lm-CommandPalette-content {
+      flex: 1 1 auto;
+      margin: 0;
+      padding: 0;
+      min-height: 0;
+      overflow: auto;
+      list-style-type: none;
+    }
 
-.lm-CommandPalette-header {
-  overflow: hidden;
-  white-space: nowrap;
-  text-overflow: ellipsis;
-}
+    .lm-CommandPalette-header {
+      overflow: hidden;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+    }
 
-.lm-CommandPalette-item {
-  display: flex;
-  flex-direction: row;
-}
+    .lm-CommandPalette-item {
+      display: flex;
+      flex-direction: row;
+    }
 
-.lm-CommandPalette-itemIcon {
-  flex: 0 0 auto;
-}
+    .lm-CommandPalette-itemIcon {
+      flex: 0 0 auto;
+    }
 
-.lm-CommandPalette-itemContent {
-  flex: 1 1 auto;
-  overflow: hidden;
-}
+    .lm-CommandPalette-itemContent {
+      flex: 1 1 auto;
+      overflow: hidden;
+    }
 
-.lm-CommandPalette-itemShortcut {
-  flex: 0 0 auto;
-}
+    .lm-CommandPalette-itemShortcut {
+      flex: 0 0 auto;
+    }
 
-.lm-CommandPalette-itemLabel {
-  overflow: hidden;
-  white-space: nowrap;
-  text-overflow: ellipsis;
-}
+    .lm-CommandPalette-itemLabel {
+      overflow: hidden;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+    }
 
-.lm-close-icon {
-  border: 1px solid transparent;
-  background-color: transparent;
-  position: absolute;
-  z-index: 1;
-  right: 3%;
-  top: 0;
-  bottom: 0;
-  margin: auto;
-  padding: 7px 0;
-  display: none;
-  vertical-align: middle;
-  outline: 0;
-  cursor: pointer;
-}
-.lm-close-icon:after {
-  content: 'X';
-  display: block;
-  width: 15px;
-  height: 15px;
-  text-align: center;
-  color: #000;
-  font-weight: normal;
-  font-size: 12px;
-  cursor: pointer;
-}
+    .lm-close-icon {
+      border: 1px solid transparent;
+      background-color: transparent;
+      position: absolute;
+      z-index: 1;
+      right: 3%;
+      top: 0;
+      bottom: 0;
+      margin: auto;
+      padding: 7px 0;
+      display: none;
+      vertical-align: middle;
+      outline: 0;
+      cursor: pointer;
+    }
 
-/*
+    .lm-close-icon:after {
+      content: 'X';
+      display: block;
+      width: 15px;
+      height: 15px;
+      text-align: center;
+      color: #000;
+      font-weight: normal;
+      font-size: 12px;
+      cursor: pointer;
+    }
+
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -339,71 +552,71 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-DockPanel {
-  z-index: 0;
-}
+    .lm-DockPanel {
+      z-index: 0;
+    }
 
-.lm-DockPanel-widget {
-  z-index: 0;
-}
+    .lm-DockPanel-widget {
+      z-index: 0;
+    }
 
-.lm-DockPanel-tabBar {
-  z-index: 1;
-}
+    .lm-DockPanel-tabBar {
+      z-index: 1;
+    }
 
-.lm-DockPanel-handle {
-  z-index: 2;
-}
+    .lm-DockPanel-handle {
+      z-index: 2;
+    }
 
-.lm-DockPanel-handle.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-DockPanel-handle.lm-mod-hidden {
+      display: none !important;
+    }
 
-.lm-DockPanel-handle:after {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  content: '';
-}
+    .lm-DockPanel-handle:after {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      content: '';
+    }
 
-.lm-DockPanel-handle[data-orientation='horizontal'] {
-  cursor: ew-resize;
-}
+    .lm-DockPanel-handle[data-orientation='horizontal'] {
+      cursor: ew-resize;
+    }
 
-.lm-DockPanel-handle[data-orientation='vertical'] {
-  cursor: ns-resize;
-}
+    .lm-DockPanel-handle[data-orientation='vertical'] {
+      cursor: ns-resize;
+    }
 
-.lm-DockPanel-handle[data-orientation='horizontal']:after {
-  left: 50%;
-  min-width: 8px;
-  transform: translateX(-50%);
-}
+    .lm-DockPanel-handle[data-orientation='horizontal']:after {
+      left: 50%;
+      min-width: 8px;
+      transform: translateX(-50%);
+    }
 
-.lm-DockPanel-handle[data-orientation='vertical']:after {
-  top: 50%;
-  min-height: 8px;
-  transform: translateY(-50%);
-}
+    .lm-DockPanel-handle[data-orientation='vertical']:after {
+      top: 50%;
+      min-height: 8px;
+      transform: translateY(-50%);
+    }
 
-.lm-DockPanel-overlay {
-  z-index: 3;
-  box-sizing: border-box;
-  pointer-events: none;
-}
+    .lm-DockPanel-overlay {
+      z-index: 3;
+      box-sizing: border-box;
+      pointer-events: none;
+    }
 
-.lm-DockPanel-overlay.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-DockPanel-overlay.lm-mod-hidden {
+      display: none !important;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -412,57 +625,57 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-Menu {
-  z-index: 10000;
-  position: absolute;
-  white-space: nowrap;
-  overflow-x: hidden;
-  overflow-y: auto;
-  outline: none;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .lm-Menu {
+      z-index: 10000;
+      position: absolute;
+      white-space: nowrap;
+      overflow-x: hidden;
+      overflow-y: auto;
+      outline: none;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.lm-Menu-content {
-  margin: 0;
-  padding: 0;
-  display: table;
-  list-style-type: none;
-}
+    .lm-Menu-content {
+      margin: 0;
+      padding: 0;
+      display: table;
+      list-style-type: none;
+    }
 
-.lm-Menu-item {
-  display: table-row;
-}
+    .lm-Menu-item {
+      display: table-row;
+    }
 
-.lm-Menu-item.lm-mod-hidden,
-.lm-Menu-item.lm-mod-collapsed {
-  display: none !important;
-}
+    .lm-Menu-item.lm-mod-hidden,
+    .lm-Menu-item.lm-mod-collapsed {
+      display: none !important;
+    }
 
-.lm-Menu-itemIcon,
-.lm-Menu-itemSubmenuIcon {
-  display: table-cell;
-  text-align: center;
-}
+    .lm-Menu-itemIcon,
+    .lm-Menu-itemSubmenuIcon {
+      display: table-cell;
+      text-align: center;
+    }
 
-.lm-Menu-itemLabel {
-  display: table-cell;
-  text-align: left;
-}
+    .lm-Menu-itemLabel {
+      display: table-cell;
+      text-align: left;
+    }
 
-.lm-Menu-itemShortcut {
-  display: table-cell;
-  text-align: right;
-}
+    .lm-Menu-itemShortcut {
+      display: table-cell;
+      text-align: right;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -471,37 +684,37 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-MenuBar {
-  outline: none;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .lm-MenuBar {
+      outline: none;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.lm-MenuBar-content {
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex-direction: row;
-  list-style-type: none;
-}
+    .lm-MenuBar-content {
+      margin: 0;
+      padding: 0;
+      display: flex;
+      flex-direction: row;
+      list-style-type: none;
+    }
 
-.lm-MenuBar-item {
-  box-sizing: border-box;
-}
+    .lm-MenuBar-item {
+      box-sizing: border-box;
+    }
 
-.lm-MenuBar-itemIcon,
-.lm-MenuBar-itemLabel {
-  display: inline-block;
-}
+    .lm-MenuBar-itemIcon,
+    .lm-MenuBar-itemLabel {
+      display: inline-block;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -510,45 +723,45 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-ScrollBar {
-  display: flex;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .lm-ScrollBar {
+      display: flex;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.lm-ScrollBar[data-orientation='horizontal'] {
-  flex-direction: row;
-}
+    .lm-ScrollBar[data-orientation='horizontal'] {
+      flex-direction: row;
+    }
 
-.lm-ScrollBar[data-orientation='vertical'] {
-  flex-direction: column;
-}
+    .lm-ScrollBar[data-orientation='vertical'] {
+      flex-direction: column;
+    }
 
-.lm-ScrollBar-button {
-  box-sizing: border-box;
-  flex: 0 0 auto;
-}
+    .lm-ScrollBar-button {
+      box-sizing: border-box;
+      flex: 0 0 auto;
+    }
 
-.lm-ScrollBar-track {
-  box-sizing: border-box;
-  position: relative;
-  overflow: hidden;
-  flex: 1 1 auto;
-}
+    .lm-ScrollBar-track {
+      box-sizing: border-box;
+      position: relative;
+      overflow: hidden;
+      flex: 1 1 auto;
+    }
 
-.lm-ScrollBar-thumb {
-  box-sizing: border-box;
-  position: absolute;
-}
+    .lm-ScrollBar-thumb {
+      box-sizing: border-box;
+      position: absolute;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -557,53 +770,53 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-SplitPanel-child {
-  z-index: 0;
-}
+    .lm-SplitPanel-child {
+      z-index: 0;
+    }
 
-.lm-SplitPanel-handle {
-  z-index: 1;
-}
+    .lm-SplitPanel-handle {
+      z-index: 1;
+    }
 
-.lm-SplitPanel-handle.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-SplitPanel-handle.lm-mod-hidden {
+      display: none !important;
+    }
 
-.lm-SplitPanel-handle:after {
-  position: absolute;
-  top: 0;
-  left: 0;
-  width: 100%;
-  height: 100%;
-  content: '';
-}
+    .lm-SplitPanel-handle:after {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: 100%;
+      height: 100%;
+      content: '';
+    }
 
-.lm-SplitPanel[data-orientation='horizontal'] > .lm-SplitPanel-handle {
-  cursor: ew-resize;
-}
+    .lm-SplitPanel[data-orientation='horizontal']>.lm-SplitPanel-handle {
+      cursor: ew-resize;
+    }
 
-.lm-SplitPanel[data-orientation='vertical'] > .lm-SplitPanel-handle {
-  cursor: ns-resize;
-}
+    .lm-SplitPanel[data-orientation='vertical']>.lm-SplitPanel-handle {
+      cursor: ns-resize;
+    }
 
-.lm-SplitPanel[data-orientation='horizontal'] > .lm-SplitPanel-handle:after {
-  left: 50%;
-  min-width: 8px;
-  transform: translateX(-50%);
-}
+    .lm-SplitPanel[data-orientation='horizontal']>.lm-SplitPanel-handle:after {
+      left: 50%;
+      min-width: 8px;
+      transform: translateX(-50%);
+    }
 
-.lm-SplitPanel[data-orientation='vertical'] > .lm-SplitPanel-handle:after {
-  top: 50%;
-  min-height: 8px;
-  transform: translateY(-50%);
-}
+    .lm-SplitPanel[data-orientation='vertical']>.lm-SplitPanel-handle:after {
+      top: 50%;
+      min-height: 8px;
+      transform: translateY(-50%);
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -612,104 +825,105 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-TabBar {
-  display: flex;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .lm-TabBar {
+      display: flex;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.lm-TabBar[data-orientation='horizontal'] {
-  flex-direction: row;
-  align-items: flex-end;
-}
+    .lm-TabBar[data-orientation='horizontal'] {
+      flex-direction: row;
+      align-items: flex-end;
+    }
 
-.lm-TabBar[data-orientation='vertical'] {
-  flex-direction: column;
-  align-items: flex-end;
-}
+    .lm-TabBar[data-orientation='vertical'] {
+      flex-direction: column;
+      align-items: flex-end;
+    }
 
-.lm-TabBar-content {
-  margin: 0;
-  padding: 0;
-  display: flex;
-  flex: 1 1 auto;
-  list-style-type: none;
-}
+    .lm-TabBar-content {
+      margin: 0;
+      padding: 0;
+      display: flex;
+      flex: 1 1 auto;
+      list-style-type: none;
+    }
 
-.lm-TabBar[data-orientation='horizontal'] > .lm-TabBar-content {
-  flex-direction: row;
-}
+    .lm-TabBar[data-orientation='horizontal']>.lm-TabBar-content {
+      flex-direction: row;
+    }
 
-.lm-TabBar[data-orientation='vertical'] > .lm-TabBar-content {
-  flex-direction: column;
-}
+    .lm-TabBar[data-orientation='vertical']>.lm-TabBar-content {
+      flex-direction: column;
+    }
 
-.lm-TabBar-tab {
-  display: flex;
-  flex-direction: row;
-  box-sizing: border-box;
-  overflow: hidden;
-  touch-action: none; /* Disable native Drag/Drop */
-}
+    .lm-TabBar-tab {
+      display: flex;
+      flex-direction: row;
+      box-sizing: border-box;
+      overflow: hidden;
+      touch-action: none;
+      /* Disable native Drag/Drop */
+    }
 
-.lm-TabBar-tabIcon,
-.lm-TabBar-tabCloseIcon {
-  flex: 0 0 auto;
-}
+    .lm-TabBar-tabIcon,
+    .lm-TabBar-tabCloseIcon {
+      flex: 0 0 auto;
+    }
 
-.lm-TabBar-tabLabel {
-  flex: 1 1 auto;
-  overflow: hidden;
-  white-space: nowrap;
-}
+    .lm-TabBar-tabLabel {
+      flex: 1 1 auto;
+      overflow: hidden;
+      white-space: nowrap;
+    }
 
-.lm-TabBar-tabInput {
-  user-select: all;
-  width: 100%;
-  box-sizing: border-box;
-}
+    .lm-TabBar-tabInput {
+      user-select: all;
+      width: 100%;
+      box-sizing: border-box;
+    }
 
-.lm-TabBar-tab.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-TabBar-tab.lm-mod-hidden {
+      display: none !important;
+    }
 
-.lm-TabBar-addButton.lm-mod-hidden {
-  display: none !important;
-}
+    .lm-TabBar-addButton.lm-mod-hidden {
+      display: none !important;
+    }
 
-.lm-TabBar.lm-mod-dragging .lm-TabBar-tab {
-  position: relative;
-}
+    .lm-TabBar.lm-mod-dragging .lm-TabBar-tab {
+      position: relative;
+    }
 
-.lm-TabBar.lm-mod-dragging[data-orientation='horizontal'] .lm-TabBar-tab {
-  left: 0;
-  transition: left 150ms ease;
-}
+    .lm-TabBar.lm-mod-dragging[data-orientation='horizontal'] .lm-TabBar-tab {
+      left: 0;
+      transition: left 150ms ease;
+    }
 
-.lm-TabBar.lm-mod-dragging[data-orientation='vertical'] .lm-TabBar-tab {
-  top: 0;
-  transition: top 150ms ease;
-}
+    .lm-TabBar.lm-mod-dragging[data-orientation='vertical'] .lm-TabBar-tab {
+      top: 0;
+      transition: top 150ms ease;
+    }
 
-.lm-TabBar.lm-mod-dragging .lm-TabBar-tab.lm-mod-dragging {
-  transition: none;
-}
+    .lm-TabBar.lm-mod-dragging .lm-TabBar-tab.lm-mod-dragging {
+      transition: none;
+    }
 
-.lm-TabBar-tabLabel .lm-TabBar-tabInput {
-  user-select: all;
-  width: 100%;
-  box-sizing: border-box;
-  background: inherit;
-}
+    .lm-TabBar-tabLabel .lm-TabBar-tabInput {
+      user-select: all;
+      width: 100%;
+      box-sizing: border-box;
+      background: inherit;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -718,20 +932,20 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-TabPanel-tabBar {
-  z-index: 1;
-}
+    .lm-TabPanel-tabBar {
+      z-index: 1;
+    }
 
-.lm-TabPanel-stackedPanel {
-  z-index: 0;
-}
+    .lm-TabPanel-stackedPanel {
+      z-index: 0;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -740,3654 +954,3624 @@ span.linenos.special { color: #000000; background-color: #ffffc0; padding-left:
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-Collapse {
-  display: flex;
-  flex-direction: column;
-  align-items: stretch;
-}
+    .jp-Collapse {
+      display: flex;
+      flex-direction: column;
+      align-items: stretch;
+    }
 
-.jp-Collapse-header {
-  padding: 1px 12px;
-  background-color: var(--jp-layout-color1);
-  border-bottom: solid var(--jp-border-width) var(--jp-border-color2);
-  color: var(--jp-ui-font-color1);
-  cursor: pointer;
-  display: flex;
-  align-items: center;
-  font-size: var(--jp-ui-font-size0);
-  font-weight: 600;
-  text-transform: uppercase;
-  user-select: none;
-}
+    .jp-Collapse-header {
+      padding: 1px 12px;
+      background-color: var(--jp-layout-color1);
+      border-bottom: solid var(--jp-border-width) var(--jp-border-color2);
+      color: var(--jp-ui-font-color1);
+      cursor: pointer;
+      display: flex;
+      align-items: center;
+      font-size: var(--jp-ui-font-size0);
+      font-weight: 600;
+      text-transform: uppercase;
+      user-select: none;
+    }
 
-.jp-Collapser-icon {
-  height: 16px;
-}
+    .jp-Collapser-icon {
+      height: 16px;
+    }
 
-.jp-Collapse-header-collapsed .jp-Collapser-icon {
-  transform: rotate(-90deg);
-  margin: auto 0;
-}
+    .jp-Collapse-header-collapsed .jp-Collapser-icon {
+      transform: rotate(-90deg);
+      margin: auto 0;
+    }
 
-.jp-Collapser-title {
-  line-height: 25px;
-}
+    .jp-Collapser-title {
+      line-height: 25px;
+    }
 
-.jp-Collapse-contents {
-  padding: 0 12px;
-  background-color: var(--jp-layout-color1);
-  color: var(--jp-ui-font-color1);
-  overflow: auto;
-}
+    .jp-Collapse-contents {
+      padding: 0 12px;
+      background-color: var(--jp-layout-color1);
+      color: var(--jp-ui-font-color1);
+      overflow: auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/* This file was auto-generated by ensureUiComponents() in @jupyterlab/buildutils */
+    /* This file was auto-generated by ensureUiComponents() in @jupyterlab/buildutils */
 
-/**
+    /**
  * (DEPRECATED) Support for consuming icons as CSS background images
  */
 
-/* Icons urls */
-
-:root {
-  --jp-icon-add-above: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzN18xOTQ5MikiPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGQ9Ik00Ljc1IDQuOTMwNjZINi42MjVWNi44MDU2NkM2LjYyNSA3LjAxMTkxIDYuNzkzNzUgNy4xODA2NiA3IDcuMTgwNjZDNy4yMDYyNSA3LjE4MDY2IDcuMzc1IDcuMDExOTEgNy4zNzUgNi44MDU2NlY0LjkzMDY2SDkuMjVDOS40NTYyNSA0LjkzMDY2IDkuNjI1IDQuNzYxOTEgOS42MjUgNC41NTU2NkM5LjYyNSA0LjM0OTQxIDkuNDU2MjUgNC4xODA2NiA5LjI1IDQuMTgwNjZINy4zNzVWMi4zMDU2NkM3LjM3NSAyLjA5OTQxIDcuMjA2MjUgMS45MzA2NiA3IDEuOTMwNjZDNi43OTM3NSAxLjkzMDY2IDYuNjI1IDIuMDk5NDEgNi42MjUgMi4zMDU2NlY0LjE4MDY2SDQuNzVDNC41NDM3NSA0LjE4MDY2IDQuMzc1IDQuMzQ5NDEgNC4zNzUgNC41NTU2NkM0LjM3NSA0Ljc2MTkxIDQuNTQzNzUgNC45MzA2NiA0Ljc1IDQuOTMwNjZaIiBmaWxsPSIjNjE2MTYxIiBzdHJva2U9IiM2MTYxNjEiIHN0cm9rZS13aWR0aD0iMC43Ii8+CjwvZz4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTExLjUgOS41VjExLjVMMi41IDExLjVWOS41TDExLjUgOS41Wk0xMiA4QzEyLjU1MjMgOCAxMyA4LjQ0NzcyIDEzIDlWMTJDMTMgMTIuNTUyMyAxMi41NTIzIDEzIDEyIDEzTDIgMTNDMS40NDc3MiAxMyAxIDEyLjU1MjMgMSAxMlY5QzEgOC40NDc3MiAxLjQ0NzcxIDggMiA4TDEyIDhaIiBmaWxsPSIjNjE2MTYxIi8+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzEzN18xOTQ5MiI+CjxyZWN0IGNsYXNzPSJqcC1pY29uMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0ibWF0cml4KC0xIDAgMCAxIDEwIDEuNTU1NjYpIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg==);
-  --jp-icon-add-below: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzN18xOTQ5OCkiPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGQ9Ik05LjI1IDEwLjA2OTNMNy4zNzUgMTAuMDY5M0w3LjM3NSA4LjE5NDM0QzcuMzc1IDcuOTg4MDkgNy4yMDYyNSA3LjgxOTM0IDcgNy44MTkzNEM2Ljc5Mzc1IDcuODE5MzQgNi42MjUgNy45ODgwOSA2LjYyNSA4LjE5NDM0TDYuNjI1IDEwLjA2OTNMNC43NSAxMC4wNjkzQzQuNTQzNzUgMTAuMDY5MyA0LjM3NSAxMC4yMzgxIDQuMzc1IDEwLjQ0NDNDNC4zNzUgMTAuNjUwNiA0LjU0Mzc1IDEwLjgxOTMgNC43NSAxMC44MTkzTDYuNjI1IDEwLjgxOTNMNi42MjUgMTIuNjk0M0M2LjYyNSAxMi45MDA2IDYuNzkzNzUgMTMuMDY5MyA3IDEzLjA2OTNDNy4yMDYyNSAxMy4wNjkzIDcuMzc1IDEyLjkwMDYgNy4zNzUgMTIuNjk0M0w3LjM3NSAxMC44MTkzTDkuMjUgMTAuODE5M0M5LjQ1NjI1IDEwLjgxOTMgOS42MjUgMTAuNjUwNiA5LjYyNSAxMC40NDQzQzkuNjI1IDEwLjIzODEgOS40NTYyNSAxMC4wNjkzIDkuMjUgMTAuMDY5M1oiIGZpbGw9IiM2MTYxNjEiIHN0cm9rZT0iIzYxNjE2MSIgc3Ryb2tlLXdpZHRoPSIwLjciLz4KPC9nPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMi41IDUuNUwyLjUgMy41TDExLjUgMy41TDExLjUgNS41TDIuNSA1LjVaTTIgN0MxLjQ0NzcyIDcgMSA2LjU1MjI4IDEgNkwxIDNDMSAyLjQ0NzcyIDEuNDQ3NzIgMiAyIDJMMTIgMkMxMi41NTIzIDIgMTMgMi40NDc3MiAxMyAzTDEzIDZDMTMgNi41NTIyOSAxMi41NTIzIDcgMTIgN0wyIDdaIiBmaWxsPSIjNjE2MTYxIi8+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzEzN18xOTQ5OCI+CjxyZWN0IGNsYXNzPSJqcC1pY29uMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0ibWF0cml4KDEgMS43NDg0NmUtMDcgMS43NDg0NmUtMDcgLTEgNCAxMy40NDQzKSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=);
-  --jp-icon-add: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE5IDEzaC02djZoLTJ2LTZINXYtMmg2VjVoMnY2aDZ2MnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-bell: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE2IDE2IiB2ZXJzaW9uPSIxLjEiPgogICA8cGF0aCBjbGFzcz0ianAtaWNvbjIganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMzMzMzMzIgogICAgICBkPSJtOCAwLjI5Yy0xLjQgMC0yLjcgMC43My0zLjYgMS44LTEuMiAxLjUtMS40IDMuNC0xLjUgNS4yLTAuMTggMi4yLTAuNDQgNC0yLjMgNS4zbDAuMjggMS4zaDVjMC4wMjYgMC42NiAwLjMyIDEuMSAwLjcxIDEuNSAwLjg0IDAuNjEgMiAwLjYxIDIuOCAwIDAuNTItMC40IDAuNi0xIDAuNzEtMS41aDVsMC4yOC0xLjNjLTEuOS0wLjk3LTIuMi0zLjMtMi4zLTUuMy0wLjEzLTEuOC0wLjI2LTMuNy0xLjUtNS4yLTAuODUtMS0yLjItMS44LTMuNi0xLjh6bTAgMS40YzAuODggMCAxLjkgMC41NSAyLjUgMS4zIDAuODggMS4xIDEuMSAyLjcgMS4yIDQuNCAwLjEzIDEuNyAwLjIzIDMuNiAxLjMgNS4yaC0xMGMxLjEtMS42IDEuMi0zLjQgMS4zLTUuMiAwLjEzLTEuNyAwLjMtMy4zIDEuMi00LjQgMC41OS0wLjcyIDEuNi0xLjMgMi41LTEuM3ptLTAuNzQgMTJoMS41Yy0wLjAwMTUgMC4yOCAwLjAxNSAwLjc5LTAuNzQgMC43OS0wLjczIDAuMDAxNi0wLjcyLTAuNTMtMC43NC0wLjc5eiIgLz4KPC9zdmc+Cg==);
-  --jp-icon-bug-dot: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiPgogICAgICAgIDxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMTcuMTkgOEgyMFYxMEgxNy45MUMxNy45NiAxMC4zMyAxOCAxMC42NiAxOCAxMVYxMkgyMFYxNEgxOC41SDE4VjE0LjAyNzVDMTUuNzUgMTQuMjc2MiAxNCAxNi4xODM3IDE0IDE4LjVDMTQgMTkuMjA4IDE0LjE2MzUgMTkuODc3OSAxNC40NTQ5IDIwLjQ3MzlDMTMuNzA2MyAyMC44MTE3IDEyLjg3NTcgMjEgMTIgMjFDOS43OCAyMSA3Ljg1IDE5Ljc5IDYuODEgMThINFYxNkg2LjA5QzYuMDQgMTUuNjcgNiAxNS4zNCA2IDE1VjE0SDRWMTJINlYxMUM2IDEwLjY2IDYuMDQgMTAuMzMgNi4wOSAxMEg0VjhINi44MUM3LjI2IDcuMjIgNy44OCA2LjU1IDguNjIgNi4wNEw3IDQuNDFMOC40MSAzTDEwLjU5IDUuMTdDMTEuMDQgNS4wNiAxMS41MSA1IDEyIDVDMTIuNDkgNSAxMi45NiA1LjA2IDEzLjQyIDUuMTdMMTUuNTkgM0wxNyA0LjQxTDE1LjM3IDYuMDRDMTYuMTIgNi41NSAxNi43NCA3LjIyIDE3LjE5IDhaTTEwIDE2SDE0VjE0SDEwVjE2Wk0xMCAxMkgxNFYxMEgxMFYxMloiIGZpbGw9IiM2MTYxNjEiLz4KICAgICAgICA8cGF0aCBkPSJNMjIgMTguNUMyMiAyMC40MzMgMjAuNDMzIDIyIDE4LjUgMjJDMTYuNTY3IDIyIDE1IDIwLjQzMyAxNSAxOC41QzE1IDE2LjU2NyAxNi41NjcgMTUgMTguNSAxNUMyMC40MzMgMTUgMjIgMTYuNTY3IDIyIDE4LjVaIiBmaWxsPSIjNjE2MTYxIi8+CiAgICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-bug: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0yMCA4aC0yLjgxYy0uNDUtLjc4LTEuMDctMS40NS0xLjgyLTEuOTZMMTcgNC40MSAxNS41OSAzbC0yLjE3IDIuMTdDMTIuOTYgNS4wNiAxMi40OSA1IDEyIDVjLS40OSAwLS45Ni4wNi0xLjQxLjE3TDguNDEgMyA3IDQuNDFsMS42MiAxLjYzQzcuODggNi41NSA3LjI2IDcuMjIgNi44MSA4SDR2MmgyLjA5Yy0uMDUuMzMtLjA5LjY2LS4wOSAxdjFINHYyaDJ2MWMwIC4zNC4wNC42Ny4wOSAxSDR2MmgyLjgxYzEuMDQgMS43OSAyLjk3IDMgNS4xOSAzczQuMTUtMS4yMSA1LjE5LTNIMjB2LTJoLTIuMDljLjA1LS4zMy4wOS0uNjYuMDktMXYtMWgydi0yaC0ydi0xYzAtLjM0LS4wNC0uNjctLjA5LTFIMjBWOHptLTYgOGgtNHYtMmg0djJ6bTAtNGgtNHYtMmg0djJ6Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-build: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE0LjkgMTcuNDVDMTYuMjUgMTcuNDUgMTcuMzUgMTYuMzUgMTcuMzUgMTVDMTcuMzUgMTMuNjUgMTYuMjUgMTIuNTUgMTQuOSAxMi41NUMxMy41NCAxMi41NSAxMi40NSAxMy42NSAxMi40NSAxNUMxMi40NSAxNi4zNSAxMy41NCAxNy40NSAxNC45IDE3LjQ1Wk0yMC4xIDE1LjY4TDIxLjU4IDE2Ljg0QzIxLjcxIDE2Ljk1IDIxLjc1IDE3LjEzIDIxLjY2IDE3LjI5TDIwLjI2IDE5LjcxQzIwLjE3IDE5Ljg2IDIwIDE5LjkyIDE5LjgzIDE5Ljg2TDE4LjA5IDE5LjE2QzE3LjczIDE5LjQ0IDE3LjMzIDE5LjY3IDE2LjkxIDE5Ljg1TDE2LjY0IDIxLjdDMTYuNjIgMjEuODcgMTYuNDcgMjIgMTYuMyAyMkgxMy41QzEzLjMyIDIyIDEzLjE4IDIxLjg3IDEzLjE1IDIxLjdMMTIuODkgMTkuODVDMTIuNDYgMTkuNjcgMTIuMDcgMTkuNDQgMTEuNzEgMTkuMTZMOS45NjAwMiAxOS44NkM5LjgxMDAyIDE5LjkyIDkuNjIwMDIgMTkuODYgOS41NDAwMiAxOS43MUw4LjE0MDAyIDE3LjI5QzguMDUwMDIgMTcuMTMgOC4wOTAwMiAxNi45NSA4LjIyMDAyIDE2Ljg0TDkuNzAwMDIgMTUuNjhMOS42NTAwMSAxNUw5LjcwMDAyIDE0LjMxTDguMjIwMDIgMTMuMTZDOC4wOTAwMiAxMy4wNSA4LjA1MDAyIDEyLjg2IDguMTQwMDIgMTIuNzFMOS41NDAwMiAxMC4yOUM5LjYyMDAyIDEwLjEzIDkuODEwMDIgMTAuMDcgOS45NjAwMiAxMC4xM0wxMS43MSAxMC44NEMxMi4wNyAxMC41NiAxMi40NiAxMC4zMiAxMi44OSAxMC4xNUwxMy4xNSA4LjI4OTk4QzEzLjE4IDguMTI5OTggMTMuMzIgNy45OTk5OCAxMy41IDcuOTk5OThIMTYuM0MxNi40NyA3Ljk5OTk4IDE2LjYyIDguMTI5OTggMTYuNjQgOC4yODk5OEwxNi45MSAxMC4xNUMxNy4zMyAxMC4zMiAxNy43MyAxMC41NiAxOC4wOSAxMC44NEwxOS44MyAxMC4xM0MyMCAxMC4wNyAyMC4xNyAxMC4xMyAyMC4yNiAxMC4yOUwyMS42NiAxMi43MUMyMS43NSAxMi44NiAyMS43MSAxMy4wNSAyMS41OCAxMy4xNkwyMC4xIDE0LjMxTDIwLjE1IDE1TDIwLjEgMTUuNjhaIi8+CiAgICA8cGF0aCBkPSJNNy4zMjk2NiA3LjQ0NDU0QzguMDgzMSA3LjAwOTU0IDguMzM5MzIgNi4wNTMzMiA3LjkwNDMyIDUuMjk5ODhDNy40NjkzMiA0LjU0NjQzIDYuNTA4MSA0LjI4MTU2IDUuNzU0NjYgNC43MTY1NkM1LjM5MTc2IDQuOTI2MDggNS4xMjY5NSA1LjI3MTE4IDUuMDE4NDkgNS42NzU5NEM0LjkxMDA0IDYuMDgwNzEgNC45NjY4MiA2LjUxMTk4IDUuMTc2MzQgNi44NzQ4OEM1LjYxMTM0IDcuNjI4MzIgNi41NzYyMiA3Ljg3OTU0IDcuMzI5NjYgNy40NDQ1NFpNOS42NTcxOCA0Ljc5NTkzTDEwLjg2NzIgNC45NTE3OUMxMC45NjI4IDQuOTc3NDEgMTEuMDQwMiA1LjA3MTMzIDExLjAzODIgNS4xODc5M0wxMS4wMzg4IDYuOTg4OTNDMTEuMDQ1NSA3LjEwMDU0IDEwLjk2MTYgNy4xOTUxOCAxMC44NTUgNy4yMTA1NEw5LjY2MDAxIDcuMzgwODNMOS4yMzkxNSA4LjEzMTg4TDkuNjY5NjEgOS4yNTc0NUM5LjcwNzI5IDkuMzYyNzEgOS42NjkzNCA5LjQ3Njk5IDkuNTc0MDggOS41MzE5OUw4LjAxNTIzIDEwLjQzMkM3LjkxMTMxIDEwLjQ5MiA3Ljc5MzM3IDEwLjQ2NzcgNy43MjEwNSAxMC4zODI0TDYuOTg3NDggOS40MzE4OEw2LjEwOTMxIDkuNDMwODNMNS4zNDcwNCAxMC4zOTA1QzUuMjg5MDkgMTAuNDcwMiA1LjE3MzgzIDEwLjQ5MDUgNS4wNzE4NyAxMC40MzM5TDMuNTEyNDUgOS41MzI5M0MzLjQxMDQ5IDkuNDc2MzMgMy4zNzY0NyA5LjM1NzQxIDMuNDEwNzUgOS4yNTY3OUwzLjg2MzQ3IDguMTQwOTNMMy42MTc0OSA3Ljc3NDg4TDMuNDIzNDcgNy4zNzg4M0wyLjIzMDc1IDcuMjEyOTdDMi4xMjY0NyA3LjE5MjM1IDIuMDQwNDkgNy4xMDM0MiAyLjA0MjQ1IDYuOTg2ODJMMi4wNDE4NyA1LjE4NTgyQzIuMDQzODMgNS4wNjkyMiAyLjExOTA5IDQuOTc5NTggMi4yMTcwNCA0Ljk2OTIyTDMuNDIwNjUgNC43OTM5M0wzLjg2NzQ5IDQuMDI3ODhMMy40MTEwNSAyLjkxNzMxQzMuMzczMzcgMi44MTIwNCAzLjQxMTMxIDIuNjk3NzYgMy41MTUyMyAyLjYzNzc2TDUuMDc0MDggMS43Mzc3NkM1LjE2OTM0IDEuNjgyNzYgNS4yODcyOSAxLjcwNzA0IDUuMzU5NjEgMS43OTIzMUw2LjExOTE1IDIuNzI3ODhMNi45ODAwMSAyLjczODkzTDcuNzI0OTYgMS43ODkyMkM3Ljc5MTU2IDEuNzA0NTggNy45MTU0OCAxLjY3OTIyIDguMDA4NzkgMS43NDA4Mkw5LjU2ODIxIDIuNjQxODJDOS42NzAxNyAyLjY5ODQyIDkuNzEyODUgMi44MTIzNCA5LjY4NzIzIDIuOTA3OTdMOS4yMTcxOCA0LjAzMzgzTDkuNDYzMTYgNC4zOTk4OEw5LjY1NzE4IDQuNzk1OTNaIi8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-caret-down-empty-thin: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwb2x5Z29uIGNsYXNzPSJzdDEiIHBvaW50cz0iOS45LDEzLjYgMy42LDcuNCA0LjQsNi42IDkuOSwxMi4yIDE1LjQsNi43IDE2LjEsNy40ICIvPgoJPC9nPgo8L3N2Zz4K);
-  --jp-icon-caret-down-empty: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik01LjIsNS45TDksOS43bDMuOC0zLjhsMS4yLDEuMmwtNC45LDVsLTQuOS01TDUuMiw1Ljl6Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-caret-down: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik01LjIsNy41TDksMTEuMmwzLjgtMy44SDUuMnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-caret-left: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwYXRoIGQ9Ik0xMC44LDEyLjhMNy4xLDlsMy44LTMuOGwwLDcuNkgxMC44eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-caret-right: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik03LjIsNS4yTDEwLjksOWwtMy44LDMuOFY1LjJINy4yeiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-caret-up-empty-thin: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwb2x5Z29uIGNsYXNzPSJzdDEiIHBvaW50cz0iMTUuNCwxMy4zIDkuOSw3LjcgNC40LDEzLjIgMy42LDEyLjUgOS45LDYuMyAxNi4xLDEyLjYgIi8+Cgk8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-caret-up: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwYXRoIGQ9Ik01LjIsMTAuNUw5LDYuOGwzLjgsMy44SDUuMnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-case-sensitive: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KICA8ZyBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiM0MTQxNDEiPgogICAgPHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+CiAgPC9nPgogIDxnIGNsYXNzPSJqcC1pY29uLWFjY2VudDIiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTcuNiw4aDAuOWwzLjUsOGgtMS4xTDEwLDE0SDZsLTAuOSwySDRMNy42LDh6IE04LDkuMUw2LjQsMTNoMy4yTDgsOS4xeiIvPgogICAgPHBhdGggZD0iTTE2LjYsOS44Yy0wLjIsMC4xLTAuNCwwLjEtMC43LDAuMWMtMC4yLDAtMC40LTAuMS0wLjYtMC4yYy0wLjEtMC4xLTAuMi0wLjQtMC4yLTAuNyBjLTAuMywwLjMtMC42LDAuNS0wLjksMC43Yy0wLjMsMC4xLTAuNywwLjItMS4xLDAuMmMtMC4zLDAtMC41LDAtMC43LTAuMWMtMC4yLTAuMS0wLjQtMC4yLTAuNi0wLjNjLTAuMi0wLjEtMC4zLTAuMy0wLjQtMC41IGMtMC4xLTAuMi0wLjEtMC40LTAuMS0wLjdjMC0wLjMsMC4xLTAuNiwwLjItMC44YzAuMS0wLjIsMC4zLTAuNCwwLjQtMC41QzEyLDcsMTIuMiw2LjksMTIuNSw2LjhjMC4yLTAuMSwwLjUtMC4xLDAuNy0wLjIgYzAuMy0wLjEsMC41LTAuMSwwLjctMC4xYzAuMiwwLDAuNC0wLjEsMC42LTAuMWMwLjIsMCwwLjMtMC4xLDAuNC0wLjJjMC4xLTAuMSwwLjItMC4yLDAuMi0wLjRjMC0xLTEuMS0xLTEuMy0xIGMtMC40LDAtMS40LDAtMS40LDEuMmgtMC45YzAtMC40LDAuMS0wLjcsMC4yLTFjMC4xLTAuMiwwLjMtMC40LDAuNS0wLjZjMC4yLTAuMiwwLjUtMC4zLDAuOC0wLjNDMTMuMyw0LDEzLjYsNCwxMy45LDQgYzAuMywwLDAuNSwwLDAuOCwwLjFjMC4zLDAsMC41LDAuMSwwLjcsMC4yYzAuMiwwLjEsMC40LDAuMywwLjUsMC41QzE2LDUsMTYsNS4yLDE2LDUuNnYyLjljMCwwLjIsMCwwLjQsMCwwLjUgYzAsMC4xLDAuMSwwLjIsMC4zLDAuMmMwLjEsMCwwLjIsMCwwLjMsMFY5Ljh6IE0xNS4yLDYuOWMtMS4yLDAuNi0zLjEsMC4yLTMuMSwxLjRjMCwxLjQsMy4xLDEsMy4xLTAuNVY2Ljl6Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-check: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik05IDE2LjE3TDQuODMgMTJsLTEuNDIgMS40MUw5IDE5IDIxIDdsLTEuNDEtMS40MXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-circle-empty: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyIDJDNi40NyAyIDIgNi40NyAyIDEyczQuNDcgMTAgMTAgMTAgMTAtNC40NyAxMC0xMFMxNy41MyAyIDEyIDJ6bTAgMThjLTQuNDEgMC04LTMuNTktOC04czMuNTktOCA4LTggOCAzLjU5IDggOC0zLjU5IDgtOCA4eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-circle: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPGNpcmNsZSBjeD0iOSIgY3k9IjkiIHI9IjgiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-clear: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8bWFzayBpZD0iZG9udXRIb2xlIj4KICAgIDxyZWN0IHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgZmlsbD0id2hpdGUiIC8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSI4IiBmaWxsPSJibGFjayIvPgogIDwvbWFzaz4KCiAgPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxyZWN0IGhlaWdodD0iMTgiIHdpZHRoPSIyIiB4PSIxMSIgeT0iMyIgdHJhbnNmb3JtPSJyb3RhdGUoMzE1LCAxMiwgMTIpIi8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIgbWFzaz0idXJsKCNkb251dEhvbGUpIi8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-close: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbi1ub25lIGpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIGpwLWljb24zLWhvdmVyIiBmaWxsPSJub25lIj4KICAgIDxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjExIi8+CiAgPC9nPgoKICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIGpwLWljb24tYWNjZW50Mi1ob3ZlciIgZmlsbD0iIzYxNjE2MSI+CiAgICA8cGF0aCBkPSJNMTkgNi40MUwxNy41OSA1IDEyIDEwLjU5IDYuNDEgNSA1IDYuNDEgMTAuNTkgMTIgNSAxNy41OSA2LjQxIDE5IDEyIDEzLjQxIDE3LjU5IDE5IDE5IDE3LjU5IDEzLjQxIDEyeiIvPgogIDwvZz4KCiAgPGcgY2xhc3M9ImpwLWljb24tbm9uZSBqcC1pY29uLWJ1c3kiIGZpbGw9Im5vbmUiPgogICAgPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iNyIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-code-check: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBzaGFwZS1yZW5kZXJpbmc9Imdlb21ldHJpY1ByZWNpc2lvbiI+CiAgICA8cGF0aCBkPSJNNi41OSwzLjQxTDIsOEw2LjU5LDEyLjZMOCwxMS4xOEw0LjgyLDhMOCw0LjgyTDYuNTksMy40MU0xMi40MSwzLjQxTDExLDQuODJMMTQuMTgsOEwxMSwxMS4xOEwxMi40MSwxMi42TDE3LDhMMTIuNDEsMy40MU0yMS41OSwxMS41OUwxMy41LDE5LjY4TDkuODMsMTZMOC40MiwxNy40MUwxMy41LDIyLjVMMjMsMTNMMjEuNTksMTEuNTlaIiAvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-code: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjIiIGhlaWdodD0iMjIiIHZpZXdCb3g9IjAgMCAyOCAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTExLjQgMTguNkw2LjggMTRMMTEuNCA5LjRMMTAgOEw0IDE0TDEwIDIwTDExLjQgMTguNlpNMTYuNiAxOC42TDIxLjIgMTRMMTYuNiA5LjRMMTggOEwyNCAxNEwxOCAyMEwxNi42IDE4LjZWMTguNloiLz4KCTwvZz4KPC9zdmc+Cg==);
-  --jp-icon-collapse-all: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTggMmMxIDAgMTEgMCAxMiAwczIgMSAyIDJjMCAxIDAgMTEgMCAxMnMwIDItMiAyQzIwIDE0IDIwIDQgMjAgNFMxMCA0IDYgNGMwLTIgMS0yIDItMnoiIC8+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTE4IDhjMC0xLTEtMi0yLTJTNSA2IDQgNnMtMiAxLTIgMmMwIDEgMCAxMSAwIDEyczEgMiAyIDJjMSAwIDExIDAgMTIgMHMyLTEgMi0yYzAtMSAwLTExIDAtMTJ6bS0yIDB2MTJINFY4eiIgLz4KICAgICAgICA8cGF0aCBkPSJNNiAxM3YyaDh2LTJ6IiAvPgogICAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-console: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwMCAyMDAiPgogIDxnIGNsYXNzPSJqcC1jb25zb2xlLWljb24tYmFja2dyb3VuZC1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiMwMjg4RDEiPgogICAgPHBhdGggZD0iTTIwIDE5LjhoMTYwdjE1OS45SDIweiIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtY29uc29sZS1pY29uLWNvbG9yIGpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIiBmaWxsPSIjZmZmIj4KICAgIDxwYXRoIGQ9Ik0xMDUgMTI3LjNoNDB2MTIuOGgtNDB6TTUxLjEgNzdMNzQgOTkuOWwtMjMuMyAyMy4zIDEwLjUgMTAuNSAyMy4zLTIzLjNMOTUgOTkuOSA4NC41IDg5LjQgNjEuNiA2Ni41eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-copy: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTExLjksMUgzLjJDMi40LDEsMS43LDEuNywxLjcsMi41djEwLjJoMS41VjIuNWg4LjdWMXogTTE0LjEsMy45aC04Yy0wLjgsMC0xLjUsMC43LTEuNSwxLjV2MTAuMmMwLDAuOCwwLjcsMS41LDEuNSwxLjVoOCBjMC44LDAsMS41LTAuNywxLjUtMS41VjUuNEMxNS41LDQuNiwxNC45LDMuOSwxNC4xLDMuOXogTTE0LjEsMTUuNWgtOFY1LjRoOFYxNS41eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-copyright: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGVuYWJsZS1iYWNrZ3JvdW5kPSJuZXcgMCAwIDI0IDI0IiBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCI+CiAgPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0xMS44OCw5LjE0YzEuMjgsMC4wNiwxLjYxLDEuMTUsMS42MywxLjY2aDEuNzljLTAuMDgtMS45OC0xLjQ5LTMuMTktMy40NS0zLjE5QzkuNjQsNy42MSw4LDksOCwxMi4xNCBjMCwxLjk0LDAuOTMsNC4yNCwzLjg0LDQuMjRjMi4yMiwwLDMuNDEtMS42NSwzLjQ0LTIuOTVoLTEuNzljLTAuMDMsMC41OS0wLjQ1LDEuMzgtMS42MywxLjQ0QzEwLjU1LDE0LjgzLDEwLDEzLjgxLDEwLDEyLjE0IEMxMCw5LjI1LDExLjI4LDkuMTYsMTEuODgsOS4xNHogTTEyLDJDNi40OCwyLDIsNi40OCwyLDEyczQuNDgsMTAsMTAsMTBzMTAtNC40OCwxMC0xMFMxNy41MiwyLDEyLDJ6IE0xMiwyMGMtNC40MSwwLTgtMy41OS04LTggczMuNTktOCw4LThzOCwzLjU5LDgsOFMxNi40MSwyMCwxMiwyMHoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-cut: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTkuNjQgNy42NGMuMjMtLjUuMzYtMS4wNS4zNi0xLjY0IDAtMi4yMS0xLjc5LTQtNC00UzIgMy43OSAyIDZzMS43OSA0IDQgNGMuNTkgMCAxLjE0LS4xMyAxLjY0LS4zNkwxMCAxMmwtMi4zNiAyLjM2QzcuMTQgMTQuMTMgNi41OSAxNCA2IDE0Yy0yLjIxIDAtNCAxLjc5LTQgNHMxLjc5IDQgNCA0IDQtMS43OSA0LTRjMC0uNTktLjEzLTEuMTQtLjM2LTEuNjRMMTIgMTRsNyA3aDN2LTFMOS42NCA3LjY0ek02IDhjLTEuMSAwLTItLjg5LTItMnMuOS0yIDItMiAyIC44OSAyIDItLjkgMi0yIDJ6bTAgMTJjLTEuMSAwLTItLjg5LTItMnMuOS0yIDItMiAyIC44OSAyIDItLjkgMi0yIDJ6bTYtNy41Yy0uMjggMC0uNS0uMjItLjUtLjVzLjIyLS41LjUtLjUuNS4yMi41LjUtLjIyLjUtLjUuNXpNMTkgM2wtNiA2IDIgMiA3LTdWM3oiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-delete: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2cHgiIGhlaWdodD0iMTZweCI+CiAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIiAvPgogICAgPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjI2MjYyIiBkPSJNNiAxOWMwIDEuMS45IDIgMiAyaDhjMS4xIDAgMi0uOSAyLTJWN0g2djEyek0xOSA0aC0zLjVsLTEtMWgtNWwtMSAxSDV2MmgxNFY0eiIgLz4KPC9zdmc+Cg==);
-  --jp-icon-download: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE5IDloLTRWM0g5djZINWw3IDcgNy03ek01IDE4djJoMTR2LTJINXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-duplicate: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTIuNzk5OTggMC44NzVIOC44OTU4MkM5LjIwMDYxIDAuODc1IDkuNDQ5OTggMS4xMzkxNCA5LjQ0OTk4IDEuNDYxOThDOS40NDk5OCAxLjc4NDgyIDkuMjAwNjEgMi4wNDg5NiA4Ljg5NTgyIDIuMDQ4OTZIMy4zNTQxNUMzLjA0OTM2IDIuMDQ4OTYgMi43OTk5OCAyLjMxMzEgMi43OTk5OCAyLjYzNTk0VjkuNjc5NjlDMi43OTk5OCAxMC4wMDI1IDIuNTUwNjEgMTAuMjY2NyAyLjI0NTgyIDEwLjI2NjdDMS45NDEwMyAxMC4yNjY3IDEuNjkxNjUgMTAuMDAyNSAxLjY5MTY1IDkuNjc5NjlWMi4wNDg5NkMxLjY5MTY1IDEuNDAzMjggMi4xOTA0IDAuODc1IDIuNzk5OTggMC44NzVaTTUuMzY2NjUgMTEuOVY0LjU1SDExLjA4MzNWMTEuOUg1LjM2NjY1Wk00LjE0MTY1IDQuMTQxNjdDNC4xNDE2NSAzLjY5MDYzIDQuNTA3MjggMy4zMjUgNC45NTgzMiAzLjMyNUgxMS40OTE3QzExLjk0MjcgMy4zMjUgMTIuMzA4MyAzLjY5MDYzIDEyLjMwODMgNC4xNDE2N1YxMi4zMDgzQzEyLjMwODMgMTIuNzU5NCAxMS45NDI3IDEzLjEyNSAxMS40OTE3IDEzLjEyNUg0Ljk1ODMyQzQuNTA3MjggMTMuMTI1IDQuMTQxNjUgMTIuNzU5NCA0LjE0MTY1IDEyLjMwODNWNC4xNDE2N1oiIGZpbGw9IiM2MTYxNjEiLz4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNOS40MzU3NCA4LjI2NTA3SDguMzY0MzFWOS4zMzY1QzguMzY0MzEgOS40NTQzNSA4LjI2Nzg4IDkuNTUwNzggOC4xNTAwMiA5LjU1MDc4QzguMDMyMTcgOS41NTA3OCA3LjkzNTc0IDkuNDU0MzUgNy45MzU3NCA5LjMzNjVWOC4yNjUwN0g2Ljg2NDMxQzYuNzQ2NDUgOC4yNjUwNyA2LjY1MDAyIDguMTY4NjQgNi42NTAwMiA4LjA1MDc4QzYuNjUwMDIgNy45MzI5MiA2Ljc0NjQ1IDcuODM2NSA2Ljg2NDMxIDcuODM2NUg3LjkzNTc0VjYuNzY1MDdDNy45MzU3NCA2LjY0NzIxIDguMDMyMTcgNi41NTA3OCA4LjE1MDAyIDYuNTUwNzhDOC4yNjc4OCA2LjU1MDc4IDguMzY0MzEgNi42NDcyMSA4LjM2NDMxIDYuNzY1MDdWNy44MzY1SDkuNDM1NzRDOS41NTM2IDcuODM2NSA5LjY1MDAyIDcuOTMyOTIgOS42NTAwMiA4LjA1MDc4QzkuNjUwMDIgOC4xNjg2NCA5LjU1MzYgOC4yNjUwNyA5LjQzNTc0IDguMjY1MDdaIiBmaWxsPSIjNjE2MTYxIiBzdHJva2U9IiM2MTYxNjEiIHN0cm9rZS13aWR0aD0iMC41Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-edit: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTMgMTcuMjVWMjFoMy43NUwxNy44MSA5Ljk0bC0zLjc1LTMuNzVMMyAxNy4yNXpNMjAuNzEgNy4wNGMuMzktLjM5LjM5LTEuMDIgMC0xLjQxbC0yLjM0LTIuMzRjLS4zOS0uMzktMS4wMi0uMzktMS40MSAwbC0xLjgzIDEuODMgMy43NSAzLjc1IDEuODMtMS44M3oiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-ellipses: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPGNpcmNsZSBjeD0iNSIgY3k9IjEyIiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSIxOSIgY3k9IjEyIiByPSIyIi8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-error: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjE5IiByPSIyIi8+PHBhdGggZD0iTTEwIDNoNHYxMmgtNHoiLz48L2c+CjxwYXRoIGZpbGw9Im5vbmUiIGQ9Ik0wIDBoMjR2MjRIMHoiLz4KPC9zdmc+Cg==);
-  --jp-icon-expand-all: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTggMmMxIDAgMTEgMCAxMiAwczIgMSAyIDJjMCAxIDAgMTEgMCAxMnMwIDItMiAyQzIwIDE0IDIwIDQgMjAgNFMxMCA0IDYgNGMwLTIgMS0yIDItMnoiIC8+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTE4IDhjMC0xLTEtMi0yLTJTNSA2IDQgNnMtMiAxLTIgMmMwIDEgMCAxMSAwIDEyczEgMiAyIDJjMSAwIDExIDAgMTIgMHMyLTEgMi0yYzAtMSAwLTExIDAtMTJ6bS0yIDB2MTJINFY4eiIgLz4KICAgICAgICA8cGF0aCBkPSJNMTEgMTBIOXYzSDZ2MmgzdjNoMnYtM2gzdi0yaC0zeiIgLz4KICAgIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-extension: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIwLjUgMTFIMTlWN2MwLTEuMS0uOS0yLTItMmgtNFYzLjVDMTMgMi4xMiAxMS44OCAxIDEwLjUgMVM4IDIuMTIgOCAzLjVWNUg0Yy0xLjEgMC0xLjk5LjktMS45OSAydjMuOEgzLjVjMS40OSAwIDIuNyAxLjIxIDIuNyAyLjdzLTEuMjEgMi43LTIuNyAyLjdIMlYyMGMwIDEuMS45IDIgMiAyaDMuOHYtMS41YzAtMS40OSAxLjIxLTIuNyAyLjctMi43IDEuNDkgMCAyLjcgMS4yMSAyLjcgMi43VjIySDE3YzEuMSAwIDItLjkgMi0ydi00aDEuNWMxLjM4IDAgMi41LTEuMTIgMi41LTIuNVMyMS44OCAxMSAyMC41IDExeiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-fast-forward: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTQgMThsOC41LTZMNCA2djEyem05LTEydjEybDguNS02TDEzIDZ6Ii8+CiAgICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-file-upload: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTkgMTZoNnYtNmg0bC03LTctNyA3aDR6bS00IDJoMTR2Mkg1eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-file: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkuMyA4LjJsLTUuNS01LjVjLS4zLS4zLS43LS41LTEuMi0uNUgzLjljLS44LjEtMS42LjktMS42IDEuOHYxNC4xYzAgLjkuNyAxLjYgMS42IDEuNmgxNC4yYy45IDAgMS42LS43IDEuNi0xLjZWOS40Yy4xLS41LS4xLS45LS40LTEuMnptLTUuOC0zLjNsMy40IDMuNmgtMy40VjQuOXptMy45IDEyLjdINC43Yy0uMSAwLS4yIDAtLjItLjJWNC43YzAtLjIuMS0uMy4yLS4zaDcuMnY0LjRzMCAuOC4zIDEuMWMuMy4zIDEuMS4zIDEuMS4zaDQuM3Y3LjJzLS4xLjItLjIuMnoiLz4KPC9zdmc+Cg==);
-  --jp-icon-filter-dot: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTE0LDEyVjE5Ljg4QzE0LjA0LDIwLjE4IDEzLjk0LDIwLjUgMTMuNzEsMjAuNzFDMTMuMzIsMjEuMSAxMi42OSwyMS4xIDEyLjMsMjAuNzFMMTAuMjksMTguN0MxMC4wNiwxOC40NyA5Ljk2LDE4LjE2IDEwLDE3Ljg3VjEySDkuOTdMNC4yMSw0LjYyQzMuODcsNC4xOSAzLjk1LDMuNTYgNC4zOCwzLjIyQzQuNTcsMy4wOCA0Ljc4LDMgNSwzVjNIMTlWM0MxOS4yMiwzIDE5LjQzLDMuMDggMTkuNjIsMy4yMkMyMC4wNSwzLjU2IDIwLjEzLDQuMTkgMTkuNzksNC42MkwxNC4wMywxMkgxNFoiIC8+CiAgPC9nPgogIDxnIGNsYXNzPSJqcC1pY29uLWRvdCIgZmlsbD0iI0ZGRiI+CiAgICA8Y2lyY2xlIGN4PSIxOCIgY3k9IjE3IiByPSIzIj48L2NpcmNsZT4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-filter-list: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEwIDE4aDR2LTJoLTR2MnpNMyA2djJoMThWNkgzem0zIDdoMTJ2LTJINnYyeiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-filter: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTE0LDEyVjE5Ljg4QzE0LjA0LDIwLjE4IDEzLjk0LDIwLjUgMTMuNzEsMjAuNzFDMTMuMzIsMjEuMSAxMi42OSwyMS4xIDEyLjMsMjAuNzFMMTAuMjksMTguN0MxMC4wNiwxOC40NyA5Ljk2LDE4LjE2IDEwLDE3Ljg3VjEySDkuOTdMNC4yMSw0LjYyQzMuODcsNC4xOSAzLjk1LDMuNTYgNC4zOCwzLjIyQzQuNTcsMy4wOCA0Ljc4LDMgNSwzVjNIMTlWM0MxOS4yMiwzIDE5LjQzLDMuMDggMTkuNjIsMy4yMkMyMC4wNSwzLjU2IDIwLjEzLDQuMTkgMTkuNzksNC42MkwxNC4wMywxMkgxNFoiIC8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-folder-favorite: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMjRweCIgZmlsbD0iIzAwMDAwMCI+CiAgPHBhdGggZD0iTTAgMGgyNHYyNEgwVjB6IiBmaWxsPSJub25lIi8+PHBhdGggY2xhc3M9ImpwLWljb24zIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzYxNjE2MSIgZD0iTTIwIDZoLThsLTItMkg0Yy0xLjEgMC0yIC45LTIgMnYxMmMwIDEuMS45IDIgMiAyaDE2YzEuMSAwIDItLjkgMi0yVjhjMC0xLjEtLjktMi0yLTJ6bS0yLjA2IDExTDE1IDE1LjI4IDEyLjA2IDE3bC43OC0zLjMzLTIuNTktMi4yNCAzLjQxLS4yOUwxNSA4bDEuMzQgMy4xNCAzLjQxLjI5LTIuNTkgMi4yNC43OCAzLjMzeiIvPgo8L3N2Zz4K);
-  --jp-icon-folder: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTAgNEg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMThjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY4YzAtMS4xLS45LTItMi0yaC04bC0yLTJ6Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-home: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMjRweCIgZmlsbD0iIzAwMDAwMCI+CiAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPjxwYXRoIGNsYXNzPSJqcC1pY29uMyBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xMCAyMHYtNmg0djZoNXYtOGgzTDEyIDMgMiAxMmgzdjh6Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-html5: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDUxMiA1MTIiPgogIDxwYXRoIGNsYXNzPSJqcC1pY29uMCBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiMwMDAiIGQ9Ik0xMDguNCAwaDIzdjIyLjhoMjEuMlYwaDIzdjY5aC0yM1Y0NmgtMjF2MjNoLTIzLjJNMjA2IDIzaC0yMC4zVjBoNjMuN3YyM0gyMjl2NDZoLTIzbTUzLjUtNjloMjQuMWwxNC44IDI0LjNMMzEzLjIgMGgyNC4xdjY5aC0yM1YzNC44bC0xNi4xIDI0LjgtMTYuMS0yNC44VjY5aC0yMi42bTg5LjItNjloMjN2NDYuMmgzMi42VjY5aC01NS42Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI2U0NGQyNiIgZD0iTTEwNy42IDQ3MWwtMzMtMzcwLjRoMzYyLjhsLTMzIDM3MC4yTDI1NS43IDUxMiIvPgogIDxwYXRoIGNsYXNzPSJqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiNmMTY1MjkiIGQ9Ik0yNTYgNDgwLjVWMTMxaDE0OC4zTDM3NiA0NDciLz4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1zZWxlY3RhYmxlLWludmVyc2UiIGZpbGw9IiNlYmViZWIiIGQ9Ik0xNDIgMTc2LjNoMTE0djQ1LjRoLTY0LjJsNC4yIDQ2LjVoNjB2NDUuM0gxNTQuNG0yIDIyLjhIMjAybDMuMiAzNi4zIDUwLjggMTMuNnY0Ny40bC05My4yLTI2Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIiBmaWxsPSIjZmZmIiBkPSJNMzY5LjYgMTc2LjNIMjU1Ljh2NDUuNGgxMDkuNm0tNC4xIDQ2LjVIMjU1Ljh2NDUuNGg1NmwtNS4zIDU5LTUwLjcgMTMuNnY0Ny4ybDkzLTI1LjgiLz4KPC9zdmc+Cg==);
-  --jp-icon-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1icmFuZDQganAtaWNvbi1zZWxlY3RhYmxlLWludmVyc2UiIGZpbGw9IiNGRkYiIGQ9Ik0yLjIgMi4yaDE3LjV2MTcuNUgyLjJ6Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzNGNTFCNSIgZD0iTTIuMiAyLjJ2MTcuNWgxNy41bC4xLTE3LjVIMi4yem0xMi4xIDIuMmMxLjIgMCAyLjIgMSAyLjIgMi4ycy0xIDIuMi0yLjIgMi4yLTIuMi0xLTIuMi0yLjIgMS0yLjIgMi4yLTIuMnpNNC40IDE3LjZsMy4zLTguOCAzLjMgNi42IDIuMi0zLjIgNC40IDUuNEg0LjR6Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-info: url(data:image/svg+xml;base64,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);
-  --jp-icon-inspector: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaW5zcGVjdG9yLWljb24tY29sb3IganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMjAgNEg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMThjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY2YzAtMS4xLS45LTItMi0yem0tNSAxNEg0di00aDExdjR6bTAtNUg0VjloMTF2NHptNSA1aC00VjloNHY5eiIvPgo8L3N2Zz4K);
-  --jp-icon-json: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtanNvbi1pY29uLWNvbG9yIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI0Y5QTgyNSI+CiAgICA8cGF0aCBkPSJNMjAuMiAxMS44Yy0xLjYgMC0xLjcuNS0xLjcgMSAwIC40LjEuOS4xIDEuMy4xLjUuMS45LjEgMS4zIDAgMS43LTEuNCAyLjMtMy41IDIuM2gtLjl2LTEuOWguNWMxLjEgMCAxLjQgMCAxLjQtLjggMC0uMyAwLS42LS4xLTEgMC0uNC0uMS0uOC0uMS0xLjIgMC0xLjMgMC0xLjggMS4zLTItMS4zLS4yLTEuMy0uNy0xLjMtMiAwLS40LjEtLjguMS0xLjIuMS0uNC4xLS43LjEtMSAwLS44LS40LS43LTEuNC0uOGgtLjVWNC4xaC45YzIuMiAwIDMuNS43IDMuNSAyLjMgMCAuNC0uMS45LS4xIDEuMy0uMS41LS4xLjktLjEgMS4zIDAgLjUuMiAxIDEuNyAxdjEuOHpNMS44IDEwLjFjMS42IDAgMS43LS41IDEuNy0xIDAtLjQtLjEtLjktLjEtMS4zLS4xLS41LS4xLS45LS4xLTEuMyAwLTEuNiAxLjQtMi4zIDMuNS0yLjNoLjl2MS45aC0uNWMtMSAwLTEuNCAwLTEuNC44IDAgLjMgMCAuNi4xIDEgMCAuMi4xLjYuMSAxIDAgMS4zIDAgMS44LTEuMyAyQzYgMTEuMiA2IDExLjcgNiAxM2MwIC40LS4xLjgtLjEgMS4yLS4xLjMtLjEuNy0uMSAxIDAgLjguMy44IDEuNC44aC41djEuOWgtLjljLTIuMSAwLTMuNS0uNi0zLjUtMi4zIDAtLjQuMS0uOS4xLTEuMy4xLS41LjEtLjkuMS0xLjMgMC0uNS0uMi0xLTEuNy0xdi0xLjl6Ii8+CiAgICA8Y2lyY2xlIGN4PSIxMSIgY3k9IjEzLjgiIHI9IjIuMSIvPgogICAgPGNpcmNsZSBjeD0iMTEiIGN5PSI4LjIiIHI9IjIuMSIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-julia: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDMyNSAzMDAiPgogIDxnIGNsYXNzPSJqcC1icmFuZDAganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjY2IzYzMzIj4KICAgIDxwYXRoIGQ9Ik0gMTUwLjg5ODQzOCAyMjUgQyAxNTAuODk4NDM4IDI2Ni40MjE4NzUgMTE3LjMyMDMxMiAzMDAgNzUuODk4NDM4IDMwMCBDIDM0LjQ3NjU2MiAzMDAgMC44OTg0MzggMjY2LjQyMTg3NSAwLjg5ODQzOCAyMjUgQyAwLjg5ODQzOCAxODMuNTc4MTI1IDM0LjQ3NjU2MiAxNTAgNzUuODk4NDM4IDE1MCBDIDExNy4zMjAzMTIgMTUwIDE1MC44OTg0MzggMTgzLjU3ODEyNSAxNTAuODk4NDM4IDIyNSIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzM4OTgyNiI+CiAgICA8cGF0aCBkPSJNIDIzNy41IDc1IEMgMjM3LjUgMTE2LjQyMTg3NSAyMDMuOTIxODc1IDE1MCAxNjIuNSAxNTAgQyAxMjEuMDc4MTI1IDE1MCA4Ny41IDExNi40MjE4NzUgODcuNSA3NSBDIDg3LjUgMzMuNTc4MTI1IDEyMS4wNzgxMjUgMCAxNjIuNSAwIEMgMjAzLjkyMTg3NSAwIDIzNy41IDMzLjU3ODEyNSAyMzcuNSA3NSIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzk1NThiMiI+CiAgICA8cGF0aCBkPSJNIDMyNC4xMDE1NjIgMjI1IEMgMzI0LjEwMTU2MiAyNjYuNDIxODc1IDI5MC41MjM0MzggMzAwIDI0OS4xMDE1NjIgMzAwIEMgMjA3LjY3OTY4OCAzMDAgMTc0LjEwMTU2MiAyNjYuNDIxODc1IDE3NC4xMDE1NjIgMjI1IEMgMTc0LjEwMTU2MiAxODMuNTc4MTI1IDIwNy42Nzk2ODggMTUwIDI0OS4xMDE1NjIgMTUwIEMgMjkwLjUyMzQzOCAxNTAgMzI0LjEwMTU2MiAxODMuNTc4MTI1IDMyNC4xMDE1NjIgMjI1Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-jupyter-favicon: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTUyIiBoZWlnaHQ9IjE2NSIgdmlld0JveD0iMCAwIDE1MiAxNjUiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgPGcgY2xhc3M9ImpwLWp1cHl0ZXItaWNvbi1jb2xvciIgZmlsbD0iI0YzNzcyNiI+CiAgICA8cGF0aCB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwLjA3ODk0NywgMTEwLjU4MjkyNykiIGQ9Ik03NS45NDIyODQyLDI5LjU4MDQ1NjEgQzQzLjMwMjM5NDcsMjkuNTgwNDU2MSAxNC43OTY3ODMyLDE3LjY1MzQ2MzQgMCwwIEM1LjUxMDgzMjExLDE1Ljg0MDY4MjkgMTUuNzgxNTM4OSwyOS41NjY3NzMyIDI5LjM5MDQ5NDcsMzkuMjc4NDE3MSBDNDIuOTk5Nyw0OC45ODk4NTM3IDU5LjI3MzcsNTQuMjA2NzgwNSA3NS45NjA1Nzg5LDU0LjIwNjc4MDUgQzkyLjY0NzQ1NzksNTQuMjA2NzgwNSAxMDguOTIxNDU4LDQ4Ljk4OTg1MzcgMTIyLjUzMDY2MywzOS4yNzg0MTcxIEMxMzYuMTM5NDUzLDI5LjU2Njc3MzIgMTQ2LjQxMDI4NCwxNS44NDA2ODI5IDE1MS45MjExNTgsMCBDMTM3LjA4Nzg2OCwxNy42NTM0NjM0IDEwOC41ODI1ODksMjkuNTgwNDU2MSA3NS45NDIyODQyLDI5LjU4MDQ1NjEgTDc1Ljk0MjI4NDIsMjkuNTgwNDU2MSBaIiAvPgogICAgPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMC4wMzczNjgsIDAuNzA0ODc4KSIgZD0iTTc1Ljk3ODQ1NzksMjQuNjI2NDA3MyBDMTA4LjYxODc2MywyNC42MjY0MDczIDEzNy4xMjQ0NTgsMzYuNTUzNDQxNSAxNTEuOTIxMTU4LDU0LjIwNjc4MDUgQzE0Ni40MTAyODQsMzguMzY2MjIyIDEzNi4xMzk0NTMsMjQuNjQwMTMxNyAxMjIuNTMwNjYzLDE0LjkyODQ4NzggQzEwOC45MjE0NTgsNS4yMTY4NDM5IDkyLjY0NzQ1NzksMCA3NS45NjA1Nzg5LDAgQzU5LjI3MzcsMCA0Mi45OTk3LDUuMjE2ODQzOSAyOS4zOTA0OTQ3LDE0LjkyODQ4NzggQzE1Ljc4MTUzODksMjQuNjQwMTMxNyA1LjUxMDgzMjExLDM4LjM2NjIyMiAwLDU0LjIwNjc4MDUgQzE0LjgzMzA4MTYsMzYuNTg5OTI5MyA0My4zMzg1Njg0LDI0LjYyNjQwNzMgNzUuOTc4NDU3OSwyNC42MjY0MDczIEw3NS45Nzg0NTc5LDI0LjYyNjQwNzMgWiIgLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-jupyter: url(data:image/svg+xml;base64,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);
-  --jp-icon-jupyterlab-wordmark: url(data:image/svg+xml;base64,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);
-  --jp-icon-kernel: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgZmlsbD0iIzYxNjE2MSIgZD0iTTE1IDlIOXY2aDZWOXptLTIgNGgtMnYtMmgydjJ6bTgtMlY5aC0yVjdjMC0xLjEtLjktMi0yLTJoLTJWM2gtMnYyaC0yVjNIOXYySDdjLTEuMSAwLTIgLjktMiAydjJIM3YyaDJ2MkgzdjJoMnYyYzAgMS4xLjkgMiAyIDJoMnYyaDJ2LTJoMnYyaDJ2LTJoMmMxLjEgMCAyLS45IDItMnYtMmgydi0yaC0ydi0yaDJ6bS00IDZIN1Y3aDEwdjEweiIvPgo8L3N2Zz4K);
-  --jp-icon-keyboard: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMjAgNUg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMTdjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY3YzAtMS4xLS45LTItMi0yem0tOSAzaDJ2MmgtMlY4em0wIDNoMnYyaC0ydi0yek04IDhoMnYySDhWOHptMCAzaDJ2Mkg4di0yem0tMSAySDV2LTJoMnYyem0wLTNINVY4aDJ2MnptOSA3SDh2LTJoOHYyem0wLTRoLTJ2LTJoMnYyem0wLTNoLTJWOGgydjJ6bTMgM2gtMnYtMmgydjJ6bTAtM2gtMlY4aDJ2MnoiLz4KPC9zdmc+Cg==);
-  --jp-icon-launch: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIgMzIiIHdpZHRoPSIzMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0yNiwyOEg2YTIuMDAyNywyLjAwMjcsMCwwLDEtMi0yVjZBMi4wMDI3LDIuMDAyNywwLDAsMSw2LDRIMTZWNkg2VjI2SDI2VjE2aDJWMjZBMi4wMDI3LDIuMDAyNywwLDAsMSwyNiwyOFoiLz4KICAgIDxwb2x5Z29uIHBvaW50cz0iMjAgMiAyMCA0IDI2LjU4NiA0IDE4IDEyLjU4NiAxOS40MTQgMTQgMjggNS40MTQgMjggMTIgMzAgMTIgMzAgMiAyMCAyIi8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-launcher: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkgMTlINVY1aDdWM0g1YTIgMiAwIDAwLTIgMnYxNGEyIDIgMCAwMDIgMmgxNGMxLjEgMCAyLS45IDItMnYtN2gtMnY3ek0xNCAzdjJoMy41OWwtOS44MyA5LjgzIDEuNDEgMS40MUwxOSA2LjQxVjEwaDJWM2gtN3oiLz4KPC9zdmc+Cg==);
-  --jp-icon-line-form: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGZpbGw9IndoaXRlIiBkPSJNNS44OCA0LjEyTDEzLjc2IDEybC03Ljg4IDcuODhMOCAyMmwxMC0xMEw4IDJ6Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-link: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTMuOSAxMmMwLTEuNzEgMS4zOS0zLjEgMy4xLTMuMWg0VjdIN2MtMi43NiAwLTUgMi4yNC01IDVzMi4yNCA1IDUgNWg0di0xLjlIN2MtMS43MSAwLTMuMS0xLjM5LTMuMS0zLjF6TTggMTNoOHYtMkg4djJ6bTktNmgtNHYxLjloNGMxLjcxIDAgMy4xIDEuMzkgMy4xIDMuMXMtMS4zOSAzLjEtMy4xIDMuMWgtNFYxN2g0YzIuNzYgMCA1LTIuMjQgNS01cy0yLjI0LTUtNS01eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-list: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xOSA1djE0SDVWNWgxNG0xLjEtMkgzLjljLS41IDAtLjkuNC0uOS45djE2LjJjMCAuNC40LjkuOS45aDE2LjJjLjQgMCAuOS0uNS45LS45VjMuOWMwLS41LS41LS45LS45LS45ek0xMSA3aDZ2MmgtNlY3em0wIDRoNnYyaC02di0yem0wIDRoNnYyaC02ek03IDdoMnYySDd6bTAgNGgydjJIN3ptMCA0aDJ2Mkg3eiIvPgo8L3N2Zz4K);
-  --jp-icon-markdown: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDAganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjN0IxRkEyIiBkPSJNNSAxNC45aDEybC02LjEgNnptOS40LTYuOGMwLTEuMy0uMS0yLjktLjEtNC41LS40IDEuNC0uOSAyLjktMS4zIDQuM2wtMS4zIDQuM2gtMkw4LjUgNy45Yy0uNC0xLjMtLjctMi45LTEtNC4zLS4xIDEuNi0uMSAzLjItLjIgNC42TDcgMTIuNEg0LjhsLjctMTFoMy4zTDEwIDVjLjQgMS4yLjcgMi43IDEgMy45LjMtMS4yLjctMi42IDEtMy45bDEuMi0zLjdoMy4zbC42IDExaC0yLjRsLS4zLTQuMnoiLz4KPC9zdmc+Cg==);
-  --jp-icon-move-down: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNMTIuNDcxIDcuNTI4OTlDMTIuNzYzMiA3LjIzNjg0IDEyLjc2MzIgNi43NjMxNiAxMi40NzEgNi40NzEwMVY2LjQ3MTAxQzEyLjE3OSA2LjE3OTA1IDExLjcwNTcgNi4xNzg4NCAxMS40MTM1IDYuNDcwNTRMNy43NSAxMC4xMjc1VjEuNzVDNy43NSAxLjMzNTc5IDcuNDE0MjEgMSA3IDFWMUM2LjU4NTc5IDEgNi4yNSAxLjMzNTc5IDYuMjUgMS43NVYxMC4xMjc1TDIuNTk3MjYgNi40NjgyMkMyLjMwMzM4IDYuMTczODEgMS44MjY0MSA2LjE3MzU5IDEuNTMyMjYgNi40Njc3NFY2LjQ2Nzc0QzEuMjM4MyA2Ljc2MTcgMS4yMzgzIDcuMjM4MyAxLjUzMjI2IDcuNTMyMjZMNi4yOTI4OSAxMi4yOTI5QzYuNjgzNDIgMTIuNjgzNCA3LjMxNjU4IDEyLjY4MzQgNy43MDcxMSAxMi4yOTI5TDEyLjQ3MSA3LjUyODk5WiIgZmlsbD0iIzYxNjE2MSIvPgo8L3N2Zz4K);
-  --jp-icon-move-up: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNMS41Mjg5OSA2LjQ3MTAxQzEuMjM2ODQgNi43NjMxNiAxLjIzNjg0IDcuMjM2ODQgMS41Mjg5OSA3LjUyODk5VjcuNTI4OTlDMS44MjA5NSA3LjgyMDk1IDIuMjk0MjYgNy44MjExNiAyLjU4NjQ5IDcuNTI5NDZMNi4yNSAzLjg3MjVWMTIuMjVDNi4yNSAxMi42NjQyIDYuNTg1NzkgMTMgNyAxM1YxM0M3LjQxNDIxIDEzIDcuNzUgMTIuNjY0MiA3Ljc1IDEyLjI1VjMuODcyNUwxMS40MDI3IDcuNTMxNzhDMTEuNjk2NiA3LjgyNjE5IDEyLjE3MzYgNy44MjY0MSAxMi40Njc3IDcuNTMyMjZWNy41MzIyNkMxMi43NjE3IDcuMjM4MyAxMi43NjE3IDYuNzYxNyAxMi40Njc3IDYuNDY3NzRMNy43MDcxMSAxLjcwNzExQzcuMzE2NTggMS4zMTY1OCA2LjY4MzQyIDEuMzE2NTggNi4yOTI4OSAxLjcwNzExTDEuNTI4OTkgNi40NzEwMVoiIGZpbGw9IiM2MTYxNjEiLz4KPC9zdmc+Cg==);
-  --jp-icon-new-folder: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIwIDZoLThsLTItMkg0Yy0xLjExIDAtMS45OS44OS0xLjk5IDJMMiAxOGMwIDEuMTEuODkgMiAyIDJoMTZjMS4xMSAwIDItLjg5IDItMlY4YzAtMS4xMS0uODktMi0yLTJ6bS0xIDhoLTN2M2gtMnYtM2gtM3YtMmgzVjloMnYzaDN2MnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-not-trusted: url(data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI1IDI1Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDMgMykiIGQ9Ik0xLjg2MDk0IDExLjQ0MDlDMC44MjY0NDggOC43NzAyNyAwLjg2Mzc3OSA2LjA1NzY0IDEuMjQ5MDcgNC4xOTkzMkMyLjQ4MjA2IDMuOTMzNDcgNC4wODA2OCAzLjQwMzQ3IDUuNjAxMDIgMi44NDQ5QzcuMjM1NDkgMi4yNDQ0IDguODU2NjYgMS41ODE1IDkuOTg3NiAxLjA5NTM5QzExLjA1OTcgMS41ODM0MSAxMi42MDk0IDIuMjQ0NCAxNC4yMTggMi44NDMzOUMxNS43NTAzIDMuNDEzOTQgMTcuMzk5NSAzLjk1MjU4IDE4Ljc1MzkgNC4yMTM4NUMxOS4xMzY0IDYuMDcxNzcgMTkuMTcwOSA4Ljc3NzIyIDE4LjEzOSAxMS40NDA5QzE3LjAzMDMgMTQuMzAzMiAxNC42NjY4IDE3LjE4NDQgOS45OTk5OSAxOC45MzU0QzUuMzMzMTkgMTcuMTg0NCAyLjk2OTY4IDE0LjMwMzIgMS44NjA5NCAxMS40NDA5WiIvPgogICAgPHBhdGggY2xhc3M9ImpwLWljb24yIiBzdHJva2U9IiMzMzMzMzMiIHN0cm9rZS13aWR0aD0iMiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOS4zMTU5MiA5LjMyMDMxKSIgZD0iTTcuMzY4NDIgMEwwIDcuMzY0NzkiLz4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDkuMzE1OTIgMTYuNjgzNikgc2NhbGUoMSAtMSkiIGQ9Ik03LjM2ODQyIDBMMCA3LjM2NDc5Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-notebook: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtbm90ZWJvb2staWNvbi1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiNFRjZDMDAiPgogICAgPHBhdGggZD0iTTE4LjcgMy4zdjE1LjRIMy4zVjMuM2gxNS40bTEuNS0xLjVIMS44djE4LjNoMTguM2wuMS0xOC4zeiIvPgogICAgPHBhdGggZD0iTTE2LjUgMTYuNWwtNS40LTQuMy01LjYgNC4zdi0xMWgxMXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-numbering: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjIiIGhlaWdodD0iMjIiIHZpZXdCb3g9IjAgMCAyOCAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTQgMTlINlYxOS41SDVWMjAuNUg2VjIxSDRWMjJIN1YxOEg0VjE5Wk01IDEwSDZWNkg0VjdINVYxMFpNNCAxM0g1LjhMNCAxNS4xVjE2SDdWMTVINS4yTDcgMTIuOVYxMkg0VjEzWk05IDdWOUgyM1Y3SDlaTTkgMjFIMjNWMTlIOVYyMVpNOSAxNUgyM1YxM0g5VjE1WiIvPgoJPC9nPgo8L3N2Zz4K);
-  --jp-icon-offline-bolt: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyIDIuMDJjLTUuNTEgMC05Ljk4IDQuNDctOS45OCA5Ljk4czQuNDcgOS45OCA5Ljk4IDkuOTggOS45OC00LjQ3IDkuOTgtOS45OFMxNy41MSAyLjAyIDEyIDIuMDJ6TTExLjQ4IDIwdi02LjI2SDhMMTMgNHY2LjI2aDMuMzVMMTEuNDggMjB6Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-palette: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE4IDEzVjIwSDRWNkg5LjAyQzkuMDcgNS4yOSA5LjI0IDQuNjIgOS41IDRINEMyLjkgNCAyIDQuOSAyIDZWMjBDMiAyMS4xIDIuOSAyMiA0IDIySDE4QzE5LjEgMjIgMjAgMjEuMSAyMCAyMFYxNUwxOCAxM1pNMTkuMyA4Ljg5QzE5Ljc0IDguMTkgMjAgNy4zOCAyMCA2LjVDMjAgNC4wMSAxNy45OSAyIDE1LjUgMkMxMy4wMSAyIDExIDQuMDEgMTEgNi41QzExIDguOTkgMTMuMDEgMTEgMTUuNDkgMTFDMTYuMzcgMTEgMTcuMTkgMTAuNzQgMTcuODggMTAuM0wyMSAxMy40MkwyMi40MiAxMkwxOS4zIDguODlaTTE1LjUgOUMxNC4xMiA5IDEzIDcuODggMTMgNi41QzEzIDUuMTIgMTQuMTIgNCAxNS41IDRDMTYuODggNCAxOCA1LjEyIDE4IDYuNUMxOCA3Ljg4IDE2Ljg4IDkgMTUuNSA5WiIvPgogICAgPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik00IDZIOS4wMTg5NEM5LjAwNjM5IDYuMTY1MDIgOSA2LjMzMTc2IDkgNi41QzkgOC44MTU3NyAxMC4yMTEgMTAuODQ4NyAxMi4wMzQzIDEySDlWMTRIMTZWMTIuOTgxMUMxNi41NzAzIDEyLjkzNzcgMTcuMTIgMTIuODIwNyAxNy42Mzk2IDEyLjYzOTZMMTggMTNWMjBINFY2Wk04IDhINlYxMEg4VjhaTTYgMTJIOFYxNEg2VjEyWk04IDE2SDZWMThIOFYxNlpNOSAxNkgxNlYxOEg5VjE2WiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-paste: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTE5IDJoLTQuMThDMTQuNC44NCAxMy4zIDAgMTIgMGMtMS4zIDAtMi40Ljg0LTIuODIgMkg1Yy0xLjEgMC0yIC45LTIgMnYxNmMwIDEuMS45IDIgMiAyaDE0YzEuMSAwIDItLjkgMi0yVjRjMC0xLjEtLjktMi0yLTJ6bS03IDBjLjU1IDAgMSAuNDUgMSAxcy0uNDUgMS0xIDEtMS0uNDUtMS0xIC40NS0xIDEtMXptNyAxOEg1VjRoMnYzaDEwVjRoMnYxNnoiLz4KICAgIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-pdf: url(data:image/svg+xml;base64,PHN2ZwogICB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyMiAyMiIgd2lkdGg9IjE2Ij4KICAgIDxwYXRoIHRyYW5zZm9ybT0icm90YXRlKDQ1KSIgY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI0ZGMkEyQSIKICAgICAgIGQ9Im0gMjIuMzQ0MzY5LC0zLjAxNjM2NDIgaCA1LjYzODYwNCB2IDEuNTc5MjQzMyBoIC0zLjU0OTIyNyB2IDEuNTA4NjkyOTkgaCAzLjMzNzU3NiBWIDEuNjUwODE1NCBoIC0zLjMzNzU3NiB2IDMuNDM1MjYxMyBoIC0yLjA4OTM3NyB6IG0gLTcuMTM2NDQ0LDEuNTc5MjQzMyB2IDQuOTQzOTU0MyBoIDAuNzQ4OTIgcSAxLjI4MDc2MSwwIDEuOTUzNzAzLC0wLjYzNDk1MzUgMC42NzgzNjksLTAuNjM0OTUzNSAwLjY3ODM2OSwtMS44NDUxNjQxIDAsLTEuMjA0NzgzNTUgLTAuNjcyOTQyLC0xLjgzNDMxMDExIC0wLjY3Mjk0MiwtMC42Mjk1MjY1OSAtMS45NTkxMywtMC42Mjk1MjY1OSB6IG0gLTIuMDg5Mzc3LC0xLjU3OTI0MzMgaCAyLjIwMzM0MyBxIDEuODQ1MTY0LDAgMi43NDYwMzksMC4yNjU5MjA3IDAuOTA2MzAxLDAuMjYwNDkzNyAxLjU1MjEwOCwwLjg5MDAyMDMgMC41Njk4MywwLjU0ODEyMjMgMC44NDY2MDUsMS4yNjQ0ODAwNiAwLjI3Njc3NCwwLjcxNjM1NzgxIDAuMjc2Nzc0LDEuNjIyNjU4OTQgMCwwLjkxNzE1NTEgLTAuMjc2Nzc0LDEuNjM4OTM5OSAtMC4yNzY3NzUsMC43MTYzNTc4IC0wLjg0NjYwNSwxLjI2NDQ4IC0wLjY1MTIzNCwwLjYyOTUyNjYgLTEuNTYyOTYyLDAuODk1NDQ3MyAtMC45MTE3MjgsMC4yNjA0OTM3IC0yLjczNTE4NSwwLjI2MDQ5MzcgaCAtMi4yMDMzNDMgeiBtIC04LjE0NTg1NjUsMCBoIDMuNDY3ODIzIHEgMS41NDY2ODE2LDAgMi4zNzE1Nzg1LDAuNjg5MjIzIDAuODMwMzI0LDAuNjgzNzk2MSAwLjgzMDMyNCwxLjk1MzcwMzE0IDAsMS4yNzUzMzM5NyAtMC44MzAzMjQsMS45NjQ1NTcwNiBRIDkuOTg3MTk2MSwyLjI3NDkxNSA4LjQ0MDUxNDUsMi4yNzQ5MTUgSCA3LjA2MjA2ODQgViA1LjA4NjA3NjcgSCA0Ljk3MjY5MTUgWiBtIDIuMDg5Mzc2OSwxLjUxNDExOTkgdiAyLjI2MzAzOTQzIGggMS4xNTU5NDEgcSAwLjYwNzgxODgsMCAwLjkzODg2MjksLTAuMjkzMDU1NDcgMC4zMzEwNDQxLC0wLjI5ODQ4MjQxIDAuMzMxMDQ0MSwtMC44NDExNzc3MiAwLC0wLjU0MjY5NTMxIC0wLjMzMTA0NDEsLTAuODM1NzUwNzQgLTAuMzMxMDQ0MSwtMC4yOTMwNTU1IC0wLjkzODg2MjksLTAuMjkzMDU1NSB6IgovPgo8L3N2Zz4K);
-  --jp-icon-python: url(data:image/svg+xml;base64,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);
-  --jp-icon-r-kernel: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMjE5NkYzIiBkPSJNNC40IDIuNWMxLjItLjEgMi45LS4zIDQuOS0uMyAyLjUgMCA0LjEuNCA1LjIgMS4zIDEgLjcgMS41IDEuOSAxLjUgMy41IDAgMi0xLjQgMy41LTIuOSA0LjEgMS4yLjQgMS43IDEuNiAyLjIgMyAuNiAxLjkgMSAzLjkgMS4zIDQuNmgtMy44Yy0uMy0uNC0uOC0xLjctMS4yLTMuN3MtMS4yLTIuNi0yLjYtMi42aC0uOXY2LjRINC40VjIuNXptMy43IDYuOWgxLjRjMS45IDAgMi45LS45IDIuOS0yLjNzLTEtMi4zLTIuOC0yLjNjLS43IDAtMS4zIDAtMS42LjJ2NC41aC4xdi0uMXoiLz4KPC9zdmc+Cg==);
-  --jp-icon-react: url(data:image/svg+xml;base64,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);
-  --jp-icon-redo: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIi8+PHBhdGggZD0iTTE4LjQgMTAuNkMxNi41NSA4Ljk5IDE0LjE1IDggMTEuNSA4Yy00LjY1IDAtOC41OCAzLjAzLTkuOTYgNy4yMkwzLjkgMTZjMS4wNS0zLjE5IDQuMDUtNS41IDcuNi01LjUgMS45NSAwIDMuNzMuNzIgNS4xMiAxLjg4TDEzIDE2aDlWN2wtMy42IDMuNnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-refresh: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTkgMTMuNWMtMi40OSAwLTQuNS0yLjAxLTQuNS00LjVTNi41MSA0LjUgOSA0LjVjMS4yNCAwIDIuMzYuNTIgMy4xNyAxLjMzTDEwIDhoNVYzbC0xLjc2IDEuNzZDMTIuMTUgMy42OCAxMC42NiAzIDkgMyA1LjY5IDMgMy4wMSA1LjY5IDMuMDEgOVM1LjY5IDE1IDkgMTVjMi45NyAwIDUuNDMtMi4xNiA1LjktNWgtMS41MmMtLjQ2IDItMi4yNCAzLjUtNC4zOCAzLjV6Ii8+CiAgICA8L2c+Cjwvc3ZnPgo=);
-  --jp-icon-regex: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KICA8ZyBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiM0MTQxNDEiPgogICAgPHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+CiAgPC9nPgoKICA8ZyBjbGFzcz0ianAtaWNvbi1hY2NlbnQyIiBmaWxsPSIjRkZGIj4KICAgIDxjaXJjbGUgY2xhc3M9InN0MiIgY3g9IjUuNSIgY3k9IjE0LjUiIHI9IjEuNSIvPgogICAgPHJlY3QgeD0iMTIiIHk9IjQiIGNsYXNzPSJzdDIiIHdpZHRoPSIxIiBoZWlnaHQ9IjgiLz4KICAgIDxyZWN0IHg9IjguNSIgeT0iNy41IiB0cmFuc2Zvcm09Im1hdHJpeCgwLjg2NiAtMC41IDAuNSAwLjg2NiAtMi4zMjU1IDcuMzIxOSkiIGNsYXNzPSJzdDIiIHdpZHRoPSI4IiBoZWlnaHQ9IjEiLz4KICAgIDxyZWN0IHg9IjEyIiB5PSI0IiB0cmFuc2Zvcm09Im1hdHJpeCgwLjUgLTAuODY2IDAuODY2IDAuNSAtMC42Nzc5IDE0LjgyNTIpIiBjbGFzcz0ic3QyIiB3aWR0aD0iMSIgaGVpZ2h0PSI4Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-run: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTggNXYxNGwxMS03eiIvPgogICAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-running: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDUxMiA1MTIiPgogIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICA8cGF0aCBkPSJNMjU2IDhDMTE5IDggOCAxMTkgOCAyNTZzMTExIDI0OCAyNDggMjQ4IDI0OC0xMTEgMjQ4LTI0OFMzOTMgOCAyNTYgOHptOTYgMzI4YzAgOC44LTcuMiAxNi0xNiAxNkgxNzZjLTguOCAwLTE2LTcuMi0xNi0xNlYxNzZjMC04LjggNy4yLTE2IDE2LTE2aDE2MGM4LjggMCAxNiA3LjIgMTYgMTZ2MTYweiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-save: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTE3IDNINWMtMS4xMSAwLTIgLjktMiAydjE0YzAgMS4xLjg5IDIgMiAyaDE0YzEuMSAwIDItLjkgMi0yVjdsLTQtNHptLTUgMTZjLTEuNjYgMC0zLTEuMzQtMy0zczEuMzQtMyAzLTMgMyAxLjM0IDMgMy0xLjM0IDMtMyAzem0zLTEwSDVWNWgxMHY0eiIvPgogICAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-search: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyLjEsMTAuOWgtMC43bC0wLjItMC4yYzAuOC0wLjksMS4zLTIuMiwxLjMtMy41YzAtMy0yLjQtNS40LTUuNC01LjRTMS44LDQuMiwxLjgsNy4xczIuNCw1LjQsNS40LDUuNCBjMS4zLDAsMi41LTAuNSwzLjUtMS4zbDAuMiwwLjJ2MC43bDQuMSw0LjFsMS4yLTEuMkwxMi4xLDEwLjl6IE03LjEsMTAuOWMtMi4xLDAtMy43LTEuNy0zLjctMy43czEuNy0zLjcsMy43LTMuN3MzLjcsMS43LDMuNywzLjcgUzkuMiwxMC45LDcuMSwxMC45eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-settings: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkuNDMgMTIuOThjLjA0LS4zMi4wNy0uNjQuMDctLjk4cy0uMDMtLjY2LS4wNy0uOThsMi4xMS0xLjY1Yy4xOS0uMTUuMjQtLjQyLjEyLS42NGwtMi0zLjQ2Yy0uMTItLjIyLS4zOS0uMy0uNjEtLjIybC0yLjQ5IDFjLS41Mi0uNC0xLjA4LS43My0xLjY5LS45OGwtLjM4LTIuNjVBLjQ4OC40ODggMCAwMDE0IDJoLTRjLS4yNSAwLS40Ni4xOC0uNDkuNDJsLS4zOCAyLjY1Yy0uNjEuMjUtMS4xNy41OS0xLjY5Ljk4bC0yLjQ5LTFjLS4yMy0uMDktLjQ5IDAtLjYxLjIybC0yIDMuNDZjLS4xMy4yMi0uMDcuNDkuMTIuNjRsMi4xMSAxLjY1Yy0uMDQuMzItLjA3LjY1LS4wNy45OHMuMDMuNjYuMDcuOThsLTIuMTEgMS42NWMtLjE5LjE1LS4yNC40Mi0uMTIuNjRsMiAzLjQ2Yy4xMi4yMi4zOS4zLjYxLjIybDIuNDktMWMuNTIuNCAxLjA4LjczIDEuNjkuOThsLjM4IDIuNjVjLjAzLjI0LjI0LjQyLjQ5LjQyaDRjLjI1IDAgLjQ2LS4xOC40OS0uNDJsLjM4LTIuNjVjLjYxLS4yNSAxLjE3LS41OSAxLjY5LS45OGwyLjQ5IDFjLjIzLjA5LjQ5IDAgLjYxLS4yMmwyLTMuNDZjLjEyLS4yMi4wNy0uNDktLjEyLS42NGwtMi4xMS0xLjY1ek0xMiAxNS41Yy0xLjkzIDAtMy41LTEuNTctMy41LTMuNXMxLjU3LTMuNSAzLjUtMy41IDMuNSAxLjU3IDMuNSAzLjUtMS41NyAzLjUtMy41IDMuNXoiLz4KPC9zdmc+Cg==);
-  --jp-icon-share: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTSAxOCAyIEMgMTYuMzU0OTkgMiAxNSAzLjM1NDk5MDQgMTUgNSBDIDE1IDUuMTkwOTUyOSAxNS4wMjE3OTEgNS4zNzcxMjI0IDE1LjA1NjY0MSA1LjU1ODU5MzggTCA3LjkyMTg3NSA5LjcyMDcwMzEgQyA3LjM5ODUzOTkgOS4yNzc4NTM5IDYuNzMyMDc3MSA5IDYgOSBDIDQuMzU0OTkwNCA5IDMgMTAuMzU0OTkgMyAxMiBDIDMgMTMuNjQ1MDEgNC4zNTQ5OTA0IDE1IDYgMTUgQyA2LjczMjA3NzEgMTUgNy4zOTg1Mzk5IDE0LjcyMjE0NiA3LjkyMTg3NSAxNC4yNzkyOTcgTCAxNS4wNTY2NDEgMTguNDM5NDUzIEMgMTUuMDIxNTU1IDE4LjYyMTUxNCAxNSAxOC44MDgzODYgMTUgMTkgQyAxNSAyMC42NDUwMSAxNi4zNTQ5OSAyMiAxOCAyMiBDIDE5LjY0NTAxIDIyIDIxIDIwLjY0NTAxIDIxIDE5IEMgMjEgMTcuMzU0OTkgMTkuNjQ1MDEgMTYgMTggMTYgQyAxNy4yNjc0OCAxNiAxNi42MDE1OTMgMTYuMjc5MzI4IDE2LjA3ODEyNSAxNi43MjI2NTYgTCA4Ljk0MzM1OTQgMTIuNTU4NTk0IEMgOC45NzgyMDk1IDEyLjM3NzEyMiA5IDEyLjE5MDk1MyA5IDEyIEMgOSAxMS44MDkwNDcgOC45NzgyMDk1IDExLjYyMjg3OCA4Ljk0MzM1OTQgMTEuNDQxNDA2IEwgMTYuMDc4MTI1IDcuMjc5Mjk2OSBDIDE2LjYwMTQ2IDcuNzIyMTQ2MSAxNy4yNjc5MjMgOCAxOCA4IEMgMTkuNjQ1MDEgOCAyMSA2LjY0NTAwOTYgMjEgNSBDIDIxIDMuMzU0OTkwNCAxOS42NDUwMSAyIDE4IDIgeiBNIDE4IDQgQyAxOC41NjQxMjkgNCAxOSA0LjQzNTg3MDYgMTkgNSBDIDE5IDUuNTY0MTI5NCAxOC41NjQxMjkgNiAxOCA2IEMgMTcuNDM1ODcxIDYgMTcgNS41NjQxMjk0IDE3IDUgQyAxNyA0LjQzNTg3MDYgMTcuNDM1ODcxIDQgMTggNCB6IE0gNiAxMSBDIDYuNTY0MTI5NCAxMSA3IDExLjQzNTg3MSA3IDEyIEMgNyAxMi41NjQxMjkgNi41NjQxMjk0IDEzIDYgMTMgQyA1LjQzNTg3MDYgMTMgNSAxMi41NjQxMjkgNSAxMiBDIDUgMTEuNDM1ODcxIDUuNDM1ODcwNiAxMSA2IDExIHogTSAxOCAxOCBDIDE4LjU2NDEyOSAxOCAxOSAxOC40MzU4NzEgMTkgMTkgQyAxOSAxOS41NjQxMjkgMTguNTY0MTI5IDIwIDE4IDIwIEMgMTcuNDM1ODcxIDIwIDE3IDE5LjU2NDEyOSAxNyAxOSBDIDE3IDE4LjQzNTg3MSAxNy40MzU4NzEgMTggMTggMTggeiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-spreadsheet: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDEganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNENBRjUwIiBkPSJNMi4yIDIuMnYxNy42aDE3LjZWMi4ySDIuMnptMTUuNCA3LjdoLTUuNVY0LjRoNS41djUuNXpNOS45IDQuNHY1LjVINC40VjQuNGg1LjV6bS01LjUgNy43aDUuNXY1LjVINC40di01LjV6bTcuNyA1LjV2LTUuNWg1LjV2NS41aC01LjV6Ii8+Cjwvc3ZnPgo=);
-  --jp-icon-stop: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik02IDZoMTJ2MTJINnoiLz4KICAgIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-tab: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIxIDNIM2MtMS4xIDAtMiAuOS0yIDJ2MTRjMCAxLjEuOSAyIDIgMmgxOGMxLjEgMCAyLS45IDItMlY1YzAtMS4xLS45LTItMi0yem0wIDE2SDNWNWgxMHY0aDh2MTB6Ii8+CiAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-table-rows: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik0yMSw4SDNWNGgxOFY4eiBNMjEsMTBIM3Y0aDE4VjEweiBNMjEsMTZIM3Y0aDE4VjE2eiIvPgogICAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-tag: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHZpZXdCb3g9IjAgMCA0MyAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTI4LjgzMzIgMTIuMzM0TDMyLjk5OTggMTYuNTAwN0wzNy4xNjY1IDEyLjMzNEgyOC44MzMyWiIvPgoJCTxwYXRoIGQ9Ik0xNi4yMDk1IDIxLjYxMDRDMTUuNjg3MyAyMi4xMjk5IDE0Ljg0NDMgMjIuMTI5OSAxNC4zMjQ4IDIxLjYxMDRMNi45ODI5IDE0LjcyNDVDNi41NzI0IDE0LjMzOTQgNi4wODMxMyAxMy42MDk4IDYuMDQ3ODYgMTMuMDQ4MkM1Ljk1MzQ3IDExLjUyODggNi4wMjAwMiA4LjYxOTQ0IDYuMDY2MjEgNy4wNzY5NUM2LjA4MjgxIDYuNTE0NzcgNi41NTU0OCA2LjA0MzQ3IDcuMTE4MDQgNi4wMzA1NUM5LjA4ODYzIDUuOTg0NzMgMTMuMjYzOCA1LjkzNTc5IDEzLjY1MTggNi4zMjQyNUwyMS43MzY5IDEzLjYzOUMyMi4yNTYgMTQuMTU4NSAyMS43ODUxIDE1LjQ3MjQgMjEuMjYyIDE1Ljk5NDZMMTYuMjA5NSAyMS42MTA0Wk05Ljc3NTg1IDguMjY1QzkuMzM1NTEgNy44MjU2NiA4LjYyMzUxIDcuODI1NjYgOC4xODI4IDguMjY1QzcuNzQzNDYgOC43MDU3MSA3Ljc0MzQ2IDkuNDE3MzMgOC4xODI4IDkuODU2NjdDOC42MjM4MiAxMC4yOTY0IDkuMzM1ODIgMTAuMjk2NCA5Ljc3NTg1IDkuODU2NjdDMTAuMjE1NiA5LjQxNzMzIDEwLjIxNTYgOC43MDUzMyA5Ljc3NTg1IDguMjY1WiIvPgoJPC9nPgo8L3N2Zz4K);
-  --jp-icon-terminal: url(data:image/svg+xml;base64,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);
-  --jp-icon-text-editor: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtdGV4dC1lZGl0b3ItaWNvbi1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xNSAxNUgzdjJoMTJ2LTJ6bTAtOEgzdjJoMTJWN3pNMyAxM2gxOHYtMkgzdjJ6bTAgOGgxOHYtMkgzdjJ6TTMgM3YyaDE4VjNIM3oiLz4KPC9zdmc+Cg==);
-  --jp-icon-toc: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik03LDVIMjFWN0g3VjVNNywxM1YxMUgyMVYxM0g3TTQsNC41QTEuNSwxLjUgMCAwLDEgNS41LDZBMS41LDEuNSAwIDAsMSA0LDcuNUExLjUsMS41IDAgMCwxIDIuNSw2QTEuNSwxLjUgMCAwLDEgNCw0LjVNNCwxMC41QTEuNSwxLjUgMCAwLDEgNS41LDEyQTEuNSwxLjUgMCAwLDEgNCwxMy41QTEuNSwxLjUgMCAwLDEgMi41LDEyQTEuNSwxLjUgMCAwLDEgNCwxMC41TTcsMTlWMTdIMjFWMTlIN000LDE2LjVBMS41LDEuNSAwIDAsMSA1LjUsMThBMS41LDEuNSAwIDAsMSA0LDE5LjVBMS41LDEuNSAwIDAsMSAyLjUsMThBMS41LDEuNSAwIDAsMSA0LDE2LjVaIiAvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-tree-view: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik0yMiAxMVYzaC03djNIOVYzSDJ2OGg3VjhoMnYxMGg0djNoN3YtOGgtN3YzaC0yVjhoMnYzeiIvPgogICAgPC9nPgo8L3N2Zz4K);
-  --jp-icon-trusted: url(data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI1Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDIgMykiIGQ9Ik0xLjg2MDk0IDExLjQ0MDlDMC44MjY0NDggOC43NzAyNyAwLjg2Mzc3OSA2LjA1NzY0IDEuMjQ5MDcgNC4xOTkzMkMyLjQ4MjA2IDMuOTMzNDcgNC4wODA2OCAzLjQwMzQ3IDUuNjAxMDIgMi44NDQ5QzcuMjM1NDkgMi4yNDQ0IDguODU2NjYgMS41ODE1IDkuOTg3NiAxLjA5NTM5QzExLjA1OTcgMS41ODM0MSAxMi42MDk0IDIuMjQ0NCAxNC4yMTggMi44NDMzOUMxNS43NTAzIDMuNDEzOTQgMTcuMzk5NSAzLjk1MjU4IDE4Ljc1MzkgNC4yMTM4NUMxOS4xMzY0IDYuMDcxNzcgMTkuMTcwOSA4Ljc3NzIyIDE4LjEzOSAxMS40NDA5QzE3LjAzMDMgMTQuMzAzMiAxNC42NjY4IDE3LjE4NDQgOS45OTk5OSAxOC45MzU0QzUuMzMzMiAxNy4xODQ0IDIuOTY5NjggMTQuMzAzMiAxLjg2MDk0IDExLjQ0MDlaIi8+CiAgICA8cGF0aCBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiMzMzMzMzMiIHN0cm9rZT0iIzMzMzMzMyIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOCA5Ljg2NzE5KSIgZD0iTTIuODYwMTUgNC44NjUzNUwwLjcyNjU0OSAyLjk5OTU5TDAgMy42MzA0NUwyLjg2MDE1IDYuMTMxNTdMOCAwLjYzMDg3Mkw3LjI3ODU3IDBMMi44NjAxNSA0Ljg2NTM1WiIvPgo8L3N2Zz4K);
-  --jp-icon-undo: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyLjUgOGMtMi42NSAwLTUuMDUuOTktNi45IDIuNkwyIDd2OWg5bC0zLjYyLTMuNjJjMS4zOS0xLjE2IDMuMTYtMS44OCA1LjEyLTEuODggMy41NCAwIDYuNTUgMi4zMSA3LjYgNS41bDIuMzctLjc4QzIxLjA4IDExLjAzIDE3LjE1IDggMTIuNSA4eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-user: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE2IDdhNCA0IDAgMTEtOCAwIDQgNCAwIDAxOCAwek0xMiAxNGE3IDcgMCAwMC03IDdoMTRhNyA3IDAgMDAtNy03eiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-users: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZlcnNpb249IjEuMSIgdmlld0JveD0iMCAwIDM2IDI0IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogPGcgY2xhc3M9ImpwLWljb24zIiB0cmFuc2Zvcm09Im1hdHJpeCgxLjczMjcgMCAwIDEuNzMyNyAtMy42MjgyIC4wOTk1NzcpIiBmaWxsPSIjNjE2MTYxIj4KICA8cGF0aCB0cmFuc2Zvcm09Im1hdHJpeCgxLjUsMCwwLDEuNSwwLC02KSIgZD0ibTEyLjE4NiA3LjUwOThjLTEuMDUzNSAwLTEuOTc1NyAwLjU2NjUtMi40Nzg1IDEuNDEwMiAwLjc1MDYxIDAuMzEyNzcgMS4zOTc0IDAuODI2NDggMS44NzMgMS40NzI3aDMuNDg2M2MwLTEuNTkyLTEuMjg4OS0yLjg4MjgtMi44ODA5LTIuODgyOHoiLz4KICA8cGF0aCBkPSJtMjAuNDY1IDIuMzg5NWEyLjE4ODUgMi4xODg1IDAgMCAxLTIuMTg4NCAyLjE4ODUgMi4xODg1IDIuMTg4NSAwIDAgMS0yLjE4ODUtMi4xODg1IDIuMTg4NSAyLjE4ODUgMCAwIDEgMi4xODg1LTIuMTg4NSAyLjE4ODUgMi4xODg1IDAgMCAxIDIuMTg4NCAyLjE4ODV6Ii8+CiAgPHBhdGggdHJhbnNmb3JtPSJtYXRyaXgoMS41LDAsMCwxLjUsMCwtNikiIGQ9Im0zLjU4OTggOC40MjE5Yy0xLjExMjYgMC0yLjAxMzcgMC45MDExMS0yLjAxMzcgMi4wMTM3aDIuODE0NWMwLjI2Nzk3LTAuMzczMDkgMC41OTA3LTAuNzA0MzUgMC45NTg5OC0wLjk3ODUyLTAuMzQ0MzMtMC42MTY4OC0xLjAwMzEtMS4wMzUyLTEuNzU5OC0xLjAzNTJ6Ii8+CiAgPHBhdGggZD0ibTYuOTE1NCA0LjYyM2ExLjUyOTQgMS41Mjk0IDAgMCAxLTEuNTI5NCAxLjUyOTQgMS41Mjk0IDEuNTI5NCAwIDAgMS0xLjUyOTQtMS41Mjk0IDEuNTI5NCAxLjUyOTQgMCAwIDEgMS41Mjk0LTEuNTI5NCAxLjUyOTQgMS41Mjk0IDAgMCAxIDEuNTI5NCAxLjUyOTR6Ii8+CiAgPHBhdGggZD0ibTYuMTM1IDEzLjUzNWMwLTMuMjM5MiAyLjYyNTktNS44NjUgNS44NjUtNS44NjUgMy4yMzkyIDAgNS44NjUgMi42MjU5IDUuODY1IDUuODY1eiIvPgogIDxjaXJjbGUgY3g9IjEyIiBjeT0iMy43Njg1IiByPSIyLjk2ODUiLz4KIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-vega: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtaWNvbjEganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMjEyMTIxIj4KICAgIDxwYXRoIGQ9Ik0xMC42IDUuNGwyLjItMy4ySDIuMnY3LjNsNC02LjZ6Ii8+CiAgICA8cGF0aCBkPSJNMTUuOCAyLjJsLTQuNCA2LjZMNyA2LjNsLTQuOCA4djUuNWgxNy42VjIuMmgtNHptLTcgMTUuNEg1LjV2LTQuNGgzLjN2NC40em00LjQgMEg5LjhWOS44aDMuNHY3Ljh6bTQuNCAwaC0zLjRWNi41aDMuNHYxMS4xeiIvPgogIDwvZz4KPC9zdmc+Cg==);
-  --jp-icon-word: url(data:image/svg+xml;base64,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);
-  --jp-icon-yaml: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtaWNvbi1jb250cmFzdDIganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjRDgxQjYwIj4KICAgIDxwYXRoIGQ9Ik03LjIgMTguNnYtNS40TDMgNS42aDMuM2wxLjQgMy4xYy4zLjkuNiAxLjYgMSAyLjUuMy0uOC42LTEuNiAxLTIuNWwxLjQtMy4xaDMuNGwtNC40IDcuNnY1LjVsLTIuOS0uMXoiLz4KICAgIDxjaXJjbGUgY2xhc3M9InN0MCIgY3g9IjE3LjYiIGN5PSIxNi41IiByPSIyLjEiLz4KICAgIDxjaXJjbGUgY2xhc3M9InN0MCIgY3g9IjE3LjYiIGN5PSIxMSIgcj0iMi4xIi8+CiAgPC9nPgo8L3N2Zz4K);
-}
-
-/* Icon CSS class declarations */
-
-.jp-AddAboveIcon {
-  background-image: var(--jp-icon-add-above);
-}
-
-.jp-AddBelowIcon {
-  background-image: var(--jp-icon-add-below);
-}
-
-.jp-AddIcon {
-  background-image: var(--jp-icon-add);
-}
-
-.jp-BellIcon {
-  background-image: var(--jp-icon-bell);
-}
-
-.jp-BugDotIcon {
-  background-image: var(--jp-icon-bug-dot);
-}
-
-.jp-BugIcon {
-  background-image: var(--jp-icon-bug);
-}
-
-.jp-BuildIcon {
-  background-image: var(--jp-icon-build);
-}
-
-.jp-CaretDownEmptyIcon {
-  background-image: var(--jp-icon-caret-down-empty);
-}
-
-.jp-CaretDownEmptyThinIcon {
-  background-image: var(--jp-icon-caret-down-empty-thin);
-}
-
-.jp-CaretDownIcon {
-  background-image: var(--jp-icon-caret-down);
-}
-
-.jp-CaretLeftIcon {
-  background-image: var(--jp-icon-caret-left);
-}
-
-.jp-CaretRightIcon {
-  background-image: var(--jp-icon-caret-right);
-}
-
-.jp-CaretUpEmptyThinIcon {
-  background-image: var(--jp-icon-caret-up-empty-thin);
-}
-
-.jp-CaretUpIcon {
-  background-image: var(--jp-icon-caret-up);
-}
-
-.jp-CaseSensitiveIcon {
-  background-image: var(--jp-icon-case-sensitive);
-}
-
-.jp-CheckIcon {
-  background-image: var(--jp-icon-check);
-}
-
-.jp-CircleEmptyIcon {
-  background-image: var(--jp-icon-circle-empty);
-}
-
-.jp-CircleIcon {
-  background-image: var(--jp-icon-circle);
-}
-
-.jp-ClearIcon {
-  background-image: var(--jp-icon-clear);
-}
-
-.jp-CloseIcon {
-  background-image: var(--jp-icon-close);
-}
-
-.jp-CodeCheckIcon {
-  background-image: var(--jp-icon-code-check);
-}
-
-.jp-CodeIcon {
-  background-image: var(--jp-icon-code);
-}
-
-.jp-CollapseAllIcon {
-  background-image: var(--jp-icon-collapse-all);
-}
+    /* Icons urls */
+
+    :root {
+      --jp-icon-add-above: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzN18xOTQ5MikiPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGQ9Ik00Ljc1IDQuOTMwNjZINi42MjVWNi44MDU2NkM2LjYyNSA3LjAxMTkxIDYuNzkzNzUgNy4xODA2NiA3IDcuMTgwNjZDNy4yMDYyNSA3LjE4MDY2IDcuMzc1IDcuMDExOTEgNy4zNzUgNi44MDU2NlY0LjkzMDY2SDkuMjVDOS40NTYyNSA0LjkzMDY2IDkuNjI1IDQuNzYxOTEgOS42MjUgNC41NTU2NkM5LjYyNSA0LjM0OTQxIDkuNDU2MjUgNC4xODA2NiA5LjI1IDQuMTgwNjZINy4zNzVWMi4zMDU2NkM3LjM3NSAyLjA5OTQxIDcuMjA2MjUgMS45MzA2NiA3IDEuOTMwNjZDNi43OTM3NSAxLjkzMDY2IDYuNjI1IDIuMDk5NDEgNi42MjUgMi4zMDU2NlY0LjE4MDY2SDQuNzVDNC41NDM3NSA0LjE4MDY2IDQuMzc1IDQuMzQ5NDEgNC4zNzUgNC41NTU2NkM0LjM3NSA0Ljc2MTkxIDQuNTQzNzUgNC45MzA2NiA0Ljc1IDQuOTMwNjZaIiBmaWxsPSIjNjE2MTYxIiBzdHJva2U9IiM2MTYxNjEiIHN0cm9rZS13aWR0aD0iMC43Ii8+CjwvZz4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTExLjUgOS41VjExLjVMMi41IDExLjVWOS41TDExLjUgOS41Wk0xMiA4QzEyLjU1MjMgOCAxMyA4LjQ0NzcyIDEzIDlWMTJDMTMgMTIuNTUyMyAxMi41NTIzIDEzIDEyIDEzTDIgMTNDMS40NDc3MiAxMyAxIDEyLjU1MjMgMSAxMlY5QzEgOC40NDc3MiAxLjQ0NzcxIDggMiA4TDEyIDhaIiBmaWxsPSIjNjE2MTYxIi8+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzEzN18xOTQ5MiI+CjxyZWN0IGNsYXNzPSJqcC1pY29uMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0ibWF0cml4KC0xIDAgMCAxIDEwIDEuNTU1NjYpIi8+CjwvY2xpcFBhdGg+CjwvZGVmcz4KPC9zdmc+Cg==);
+      --jp-icon-add-below: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPGcgY2xpcC1wYXRoPSJ1cmwoI2NsaXAwXzEzN18xOTQ5OCkiPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGQ9Ik05LjI1IDEwLjA2OTNMNy4zNzUgMTAuMDY5M0w3LjM3NSA4LjE5NDM0QzcuMzc1IDcuOTg4MDkgNy4yMDYyNSA3LjgxOTM0IDcgNy44MTkzNEM2Ljc5Mzc1IDcuODE5MzQgNi42MjUgNy45ODgwOSA2LjYyNSA4LjE5NDM0TDYuNjI1IDEwLjA2OTNMNC43NSAxMC4wNjkzQzQuNTQzNzUgMTAuMDY5MyA0LjM3NSAxMC4yMzgxIDQuMzc1IDEwLjQ0NDNDNC4zNzUgMTAuNjUwNiA0LjU0Mzc1IDEwLjgxOTMgNC43NSAxMC44MTkzTDYuNjI1IDEwLjgxOTNMNi42MjUgMTIuNjk0M0M2LjYyNSAxMi45MDA2IDYuNzkzNzUgMTMuMDY5MyA3IDEzLjA2OTNDNy4yMDYyNSAxMy4wNjkzIDcuMzc1IDEyLjkwMDYgNy4zNzUgMTIuNjk0M0w3LjM3NSAxMC44MTkzTDkuMjUgMTAuODE5M0M5LjQ1NjI1IDEwLjgxOTMgOS42MjUgMTAuNjUwNiA5LjYyNSAxMC40NDQzQzkuNjI1IDEwLjIzODEgOS40NTYyNSAxMC4wNjkzIDkuMjUgMTAuMDY5M1oiIGZpbGw9IiM2MTYxNjEiIHN0cm9rZT0iIzYxNjE2MSIgc3Ryb2tlLXdpZHRoPSIwLjciLz4KPC9nPgo8cGF0aCBjbGFzcz0ianAtaWNvbjMiIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMi41IDUuNUwyLjUgMy41TDExLjUgMy41TDExLjUgNS41TDIuNSA1LjVaTTIgN0MxLjQ0NzcyIDcgMSA2LjU1MjI4IDEgNkwxIDNDMSAyLjQ0NzcyIDEuNDQ3NzIgMiAyIDJMMTIgMkMxMi41NTIzIDIgMTMgMi40NDc3MiAxMyAzTDEzIDZDMTMgNi41NTIyOSAxMi41NTIzIDcgMTIgN0wyIDdaIiBmaWxsPSIjNjE2MTYxIi8+CjxkZWZzPgo8Y2xpcFBhdGggaWQ9ImNsaXAwXzEzN18xOTQ5OCI+CjxyZWN0IGNsYXNzPSJqcC1pY29uMyIgd2lkdGg9IjYiIGhlaWdodD0iNiIgZmlsbD0id2hpdGUiIHRyYW5zZm9ybT0ibWF0cml4KDEgMS43NDg0NmUtMDcgMS43NDg0NmUtMDcgLTEgNCAxMy40NDQzKSIvPgo8L2NsaXBQYXRoPgo8L2RlZnM+Cjwvc3ZnPgo=);
+      --jp-icon-add: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE5IDEzaC02djZoLTJ2LTZINXYtMmg2VjVoMnY2aDZ2MnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-bell: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE2IDE2IiB2ZXJzaW9uPSIxLjEiPgogICA8cGF0aCBjbGFzcz0ianAtaWNvbjIganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMzMzMzMzIgogICAgICBkPSJtOCAwLjI5Yy0xLjQgMC0yLjcgMC43My0zLjYgMS44LTEuMiAxLjUtMS40IDMuNC0xLjUgNS4yLTAuMTggMi4yLTAuNDQgNC0yLjMgNS4zbDAuMjggMS4zaDVjMC4wMjYgMC42NiAwLjMyIDEuMSAwLjcxIDEuNSAwLjg0IDAuNjEgMiAwLjYxIDIuOCAwIDAuNTItMC40IDAuNi0xIDAuNzEtMS41aDVsMC4yOC0xLjNjLTEuOS0wLjk3LTIuMi0zLjMtMi4zLTUuMy0wLjEzLTEuOC0wLjI2LTMuNy0xLjUtNS4yLTAuODUtMS0yLjItMS44LTMuNi0xLjh6bTAgMS40YzAuODggMCAxLjkgMC41NSAyLjUgMS4zIDAuODggMS4xIDEuMSAyLjcgMS4yIDQuNCAwLjEzIDEuNyAwLjIzIDMuNiAxLjMgNS4yaC0xMGMxLjEtMS42IDEuMi0zLjQgMS4zLTUuMiAwLjEzLTEuNyAwLjMtMy4zIDEuMi00LjQgMC41OS0wLjcyIDEuNi0xLjMgMi41LTEuM3ptLTAuNzQgMTJoMS41Yy0wLjAwMTUgMC4yOCAwLjAxNSAwLjc5LTAuNzQgMC43OS0wLjczIDAuMDAxNi0wLjcyLTAuNTMtMC43NC0wLjc5eiIgLz4KPC9zdmc+Cg==);
+      --jp-icon-bug-dot: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiPgogICAgICAgIDxwYXRoIGZpbGwtcnVsZT0iZXZlbm9kZCIgY2xpcC1ydWxlPSJldmVub2RkIiBkPSJNMTcuMTkgOEgyMFYxMEgxNy45MUMxNy45NiAxMC4zMyAxOCAxMC42NiAxOCAxMVYxMkgyMFYxNEgxOC41SDE4VjE0LjAyNzVDMTUuNzUgMTQuMjc2MiAxNCAxNi4xODM3IDE0IDE4LjVDMTQgMTkuMjA4IDE0LjE2MzUgMTkuODc3OSAxNC40NTQ5IDIwLjQ3MzlDMTMuNzA2MyAyMC44MTE3IDEyLjg3NTcgMjEgMTIgMjFDOS43OCAyMSA3Ljg1IDE5Ljc5IDYuODEgMThINFYxNkg2LjA5QzYuMDQgMTUuNjcgNiAxNS4zNCA2IDE1VjE0SDRWMTJINlYxMUM2IDEwLjY2IDYuMDQgMTAuMzMgNi4wOSAxMEg0VjhINi44MUM3LjI2IDcuMjIgNy44OCA2LjU1IDguNjIgNi4wNEw3IDQuNDFMOC40MSAzTDEwLjU5IDUuMTdDMTEuMDQgNS4wNiAxMS41MSA1IDEyIDVDMTIuNDkgNSAxMi45NiA1LjA2IDEzLjQyIDUuMTdMMTUuNTkgM0wxNyA0LjQxTDE1LjM3IDYuMDRDMTYuMTIgNi41NSAxNi43NCA3LjIyIDE3LjE5IDhaTTEwIDE2SDE0VjE0SDEwVjE2Wk0xMCAxMkgxNFYxMEgxMFYxMloiIGZpbGw9IiM2MTYxNjEiLz4KICAgICAgICA8cGF0aCBkPSJNMjIgMTguNUMyMiAyMC40MzMgMjAuNDMzIDIyIDE4LjUgMjJDMTYuNTY3IDIyIDE1IDIwLjQzMyAxNSAxOC41QzE1IDE2LjU2NyAxNi41NjcgMTUgMTguNSAxNUMyMC40MzMgMTUgMjIgMTYuNTY3IDIyIDE4LjVaIiBmaWxsPSIjNjE2MTYxIi8+CiAgICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-bug: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0yMCA4aC0yLjgxYy0uNDUtLjc4LTEuMDctMS40NS0xLjgyLTEuOTZMMTcgNC40MSAxNS41OSAzbC0yLjE3IDIuMTdDMTIuOTYgNS4wNiAxMi40OSA1IDEyIDVjLS40OSAwLS45Ni4wNi0xLjQxLjE3TDguNDEgMyA3IDQuNDFsMS42MiAxLjYzQzcuODggNi41NSA3LjI2IDcuMjIgNi44MSA4SDR2MmgyLjA5Yy0uMDUuMzMtLjA5LjY2LS4wOSAxdjFINHYyaDJ2MWMwIC4zNC4wNC42Ny4wOSAxSDR2MmgyLjgxYzEuMDQgMS43OSAyLjk3IDMgNS4xOSAzczQuMTUtMS4yMSA1LjE5LTNIMjB2LTJoLTIuMDljLjA1LS4zMy4wOS0uNjYuMDktMXYtMWgydi0yaC0ydi0xYzAtLjM0LS4wNC0uNjctLjA5LTFIMjBWOHptLTYgOGgtNHYtMmg0djJ6bTAtNGgtNHYtMmg0djJ6Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-build: url(data:image/svg+xml;base64,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);
+      --jp-icon-caret-down-empty-thin: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwb2x5Z29uIGNsYXNzPSJzdDEiIHBvaW50cz0iOS45LDEzLjYgMy42LDcuNCA0LjQsNi42IDkuOSwxMi4yIDE1LjQsNi43IDE2LjEsNy40ICIvPgoJPC9nPgo8L3N2Zz4K);
+      --jp-icon-caret-down-empty: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik01LjIsNS45TDksOS43bDMuOC0zLjhsMS4yLDEuMmwtNC45LDVsLTQuOS01TDUuMiw1Ljl6Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-caret-down: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik01LjIsNy41TDksMTEuMmwzLjgtMy44SDUuMnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-caret-left: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwYXRoIGQ9Ik0xMC44LDEyLjhMNy4xLDlsMy44LTMuOGwwLDcuNkgxMC44eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-caret-right: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiIHNoYXBlLXJlbmRlcmluZz0iZ2VvbWV0cmljUHJlY2lzaW9uIj4KICAgIDxwYXRoIGQ9Ik03LjIsNS4yTDEwLjksOWwtMy44LDMuOFY1LjJINy4yeiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-caret-up-empty-thin: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwb2x5Z29uIGNsYXNzPSJzdDEiIHBvaW50cz0iMTUuNCwxMy4zIDkuOSw3LjcgNC40LDEzLjIgMy42LDEyLjUgOS45LDYuMyAxNi4xLDEyLjYgIi8+Cgk8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-caret-up: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSIgc2hhcGUtcmVuZGVyaW5nPSJnZW9tZXRyaWNQcmVjaXNpb24iPgoJCTxwYXRoIGQ9Ik01LjIsMTAuNUw5LDYuOGwzLjgsMy44SDUuMnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-case-sensitive: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KICA8ZyBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiM0MTQxNDEiPgogICAgPHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+CiAgPC9nPgogIDxnIGNsYXNzPSJqcC1pY29uLWFjY2VudDIiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTcuNiw4aDAuOWwzLjUsOGgtMS4xTDEwLDE0SDZsLTAuOSwySDRMNy42LDh6IE04LDkuMUw2LjQsMTNoMy4yTDgsOS4xeiIvPgogICAgPHBhdGggZD0iTTE2LjYsOS44Yy0wLjIsMC4xLTAuNCwwLjEtMC43LDAuMWMtMC4yLDAtMC40LTAuMS0wLjYtMC4yYy0wLjEtMC4xLTAuMi0wLjQtMC4yLTAuNyBjLTAuMywwLjMtMC42LDAuNS0wLjksMC43Yy0wLjMsMC4xLTAuNywwLjItMS4xLDAuMmMtMC4zLDAtMC41LDAtMC43LTAuMWMtMC4yLTAuMS0wLjQtMC4yLTAuNi0wLjNjLTAuMi0wLjEtMC4zLTAuMy0wLjQtMC41IGMtMC4xLTAuMi0wLjEtMC40LTAuMS0wLjdjMC0wLjMsMC4xLTAuNiwwLjItMC44YzAuMS0wLjIsMC4zLTAuNCwwLjQtMC41QzEyLDcsMTIuMiw2LjksMTIuNSw2LjhjMC4yLTAuMSwwLjUtMC4xLDAuNy0wLjIgYzAuMy0wLjEsMC41LTAuMSwwLjctMC4xYzAuMiwwLDAuNC0wLjEsMC42LTAuMWMwLjIsMCwwLjMtMC4xLDAuNC0wLjJjMC4xLTAuMSwwLjItMC4yLDAuMi0wLjRjMC0xLTEuMS0xLTEuMy0xIGMtMC40LDAtMS40LDAtMS40LDEuMmgtMC45YzAtMC40LDAuMS0wLjcsMC4yLTFjMC4xLTAuMiwwLjMtMC40LDAuNS0wLjZjMC4yLTAuMiwwLjUtMC4zLDAuOC0wLjNDMTMuMyw0LDEzLjYsNCwxMy45LDQgYzAuMywwLDAuNSwwLDAuOCwwLjFjMC4zLDAsMC41LDAuMSwwLjcsMC4yYzAuMiwwLjEsMC40LDAuMywwLjUsMC41QzE2LDUsMTYsNS4yLDE2LDUuNnYyLjljMCwwLjIsMCwwLjQsMCwwLjUgYzAsMC4xLDAuMSwwLjIsMC4zLDAuMmMwLjEsMCwwLjIsMCwwLjMsMFY5Ljh6IE0xNS4yLDYuOWMtMS4yLDAuNi0zLjEsMC4yLTMuMSwxLjRjMCwxLjQsMy4xLDEsMy4xLTAuNVY2Ljl6Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-check: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik05IDE2LjE3TDQuODMgMTJsLTEuNDIgMS40MUw5IDE5IDIxIDdsLTEuNDEtMS40MXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-circle-empty: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyIDJDNi40NyAyIDIgNi40NyAyIDEyczQuNDcgMTAgMTAgMTAgMTAtNC40NyAxMC0xMFMxNy41MyAyIDEyIDJ6bTAgMThjLTQuNDEgMC04LTMuNTktOC04czMuNTktOCA4LTggOCAzLjU5IDggOC0zLjU5IDgtOCA4eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-circle: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPGNpcmNsZSBjeD0iOSIgY3k9IjkiIHI9IjgiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-clear: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8bWFzayBpZD0iZG9udXRIb2xlIj4KICAgIDxyZWN0IHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgZmlsbD0id2hpdGUiIC8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSI4IiBmaWxsPSJibGFjayIvPgogIDwvbWFzaz4KCiAgPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxyZWN0IGhlaWdodD0iMTgiIHdpZHRoPSIyIiB4PSIxMSIgeT0iMyIgdHJhbnNmb3JtPSJyb3RhdGUoMzE1LCAxMiwgMTIpIi8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIxMCIgbWFzaz0idXJsKCNkb251dEhvbGUpIi8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-close: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbi1ub25lIGpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIGpwLWljb24zLWhvdmVyIiBmaWxsPSJub25lIj4KICAgIDxjaXJjbGUgY3g9IjEyIiBjeT0iMTIiIHI9IjExIi8+CiAgPC9nPgoKICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIGpwLWljb24tYWNjZW50Mi1ob3ZlciIgZmlsbD0iIzYxNjE2MSI+CiAgICA8cGF0aCBkPSJNMTkgNi40MUwxNy41OSA1IDEyIDEwLjU5IDYuNDEgNSA1IDYuNDEgMTAuNTkgMTIgNSAxNy41OSA2LjQxIDE5IDEyIDEzLjQxIDE3LjU5IDE5IDE5IDE3LjU5IDEzLjQxIDEyeiIvPgogIDwvZz4KCiAgPGcgY2xhc3M9ImpwLWljb24tbm9uZSBqcC1pY29uLWJ1c3kiIGZpbGw9Im5vbmUiPgogICAgPGNpcmNsZSBjeD0iMTIiIGN5PSIxMiIgcj0iNyIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-code-check: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBzaGFwZS1yZW5kZXJpbmc9Imdlb21ldHJpY1ByZWNpc2lvbiI+CiAgICA8cGF0aCBkPSJNNi41OSwzLjQxTDIsOEw2LjU5LDEyLjZMOCwxMS4xOEw0LjgyLDhMOCw0LjgyTDYuNTksMy40MU0xMi40MSwzLjQxTDExLDQuODJMMTQuMTgsOEwxMSwxMS4xOEwxMi40MSwxMi42TDE3LDhMMTIuNDEsMy40MU0yMS41OSwxMS41OUwxMy41LDE5LjY4TDkuODMsMTZMOC40MiwxNy40MUwxMy41LDIyLjVMMjMsMTNMMjEuNTksMTEuNTlaIiAvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-code: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjIiIGhlaWdodD0iMjIiIHZpZXdCb3g9IjAgMCAyOCAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTExLjQgMTguNkw2LjggMTRMMTEuNCA5LjRMMTAgOEw0IDE0TDEwIDIwTDExLjQgMTguNlpNMTYuNiAxOC42TDIxLjIgMTRMMTYuNiA5LjRMMTggOEwyNCAxNEwxOCAyMEwxNi42IDE4LjZWMTguNloiLz4KCTwvZz4KPC9zdmc+Cg==);
+      --jp-icon-collapse-all: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTggMmMxIDAgMTEgMCAxMiAwczIgMSAyIDJjMCAxIDAgMTEgMCAxMnMwIDItMiAyQzIwIDE0IDIwIDQgMjAgNFMxMCA0IDYgNGMwLTIgMS0yIDItMnoiIC8+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTE4IDhjMC0xLTEtMi0yLTJTNSA2IDQgNnMtMiAxLTIgMmMwIDEgMCAxMSAwIDEyczEgMiAyIDJjMSAwIDExIDAgMTIgMHMyLTEgMi0yYzAtMSAwLTExIDAtMTJ6bS0yIDB2MTJINFY4eiIgLz4KICAgICAgICA8cGF0aCBkPSJNNiAxM3YyaDh2LTJ6IiAvPgogICAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-console: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwMCAyMDAiPgogIDxnIGNsYXNzPSJqcC1jb25zb2xlLWljb24tYmFja2dyb3VuZC1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiMwMjg4RDEiPgogICAgPHBhdGggZD0iTTIwIDE5LjhoMTYwdjE1OS45SDIweiIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtY29uc29sZS1pY29uLWNvbG9yIGpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIiBmaWxsPSIjZmZmIj4KICAgIDxwYXRoIGQ9Ik0xMDUgMTI3LjNoNDB2MTIuOGgtNDB6TTUxLjEgNzdMNzQgOTkuOWwtMjMuMyAyMy4zIDEwLjUgMTAuNSAyMy4zLTIzLjNMOTUgOTkuOSA4NC41IDg5LjQgNjEuNiA2Ni41eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-copy: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTExLjksMUgzLjJDMi40LDEsMS43LDEuNywxLjcsMi41djEwLjJoMS41VjIuNWg4LjdWMXogTTE0LjEsMy45aC04Yy0wLjgsMC0xLjUsMC43LTEuNSwxLjV2MTAuMmMwLDAuOCwwLjcsMS41LDEuNSwxLjVoOCBjMC44LDAsMS41LTAuNywxLjUtMS41VjUuNEMxNS41LDQuNiwxNC45LDMuOSwxNC4xLDMuOXogTTE0LjEsMTUuNWgtOFY1LjRoOFYxNS41eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-copyright: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGVuYWJsZS1iYWNrZ3JvdW5kPSJuZXcgMCAwIDI0IDI0IiBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCI+CiAgPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0xMS44OCw5LjE0YzEuMjgsMC4wNiwxLjYxLDEuMTUsMS42MywxLjY2aDEuNzljLTAuMDgtMS45OC0xLjQ5LTMuMTktMy40NS0zLjE5QzkuNjQsNy42MSw4LDksOCwxMi4xNCBjMCwxLjk0LDAuOTMsNC4yNCwzLjg0LDQuMjRjMi4yMiwwLDMuNDEtMS42NSwzLjQ0LTIuOTVoLTEuNzljLTAuMDMsMC41OS0wLjQ1LDEuMzgtMS42MywxLjQ0QzEwLjU1LDE0LjgzLDEwLDEzLjgxLDEwLDEyLjE0IEMxMCw5LjI1LDExLjI4LDkuMTYsMTEuODgsOS4xNHogTTEyLDJDNi40OCwyLDIsNi40OCwyLDEyczQuNDgsMTAsMTAsMTBzMTAtNC40OCwxMC0xMFMxNy41MiwyLDEyLDJ6IE0xMiwyMGMtNC40MSwwLTgtMy41OS04LTggczMuNTktOCw4LThzOCwzLjU5LDgsOFMxNi40MSwyMCwxMiwyMHoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-cut: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTkuNjQgNy42NGMuMjMtLjUuMzYtMS4wNS4zNi0xLjY0IDAtMi4yMS0xLjc5LTQtNC00UzIgMy43OSAyIDZzMS43OSA0IDQgNGMuNTkgMCAxLjE0LS4xMyAxLjY0LS4zNkwxMCAxMmwtMi4zNiAyLjM2QzcuMTQgMTQuMTMgNi41OSAxNCA2IDE0Yy0yLjIxIDAtNCAxLjc5LTQgNHMxLjc5IDQgNCA0IDQtMS43OSA0LTRjMC0uNTktLjEzLTEuMTQtLjM2LTEuNjRMMTIgMTRsNyA3aDN2LTFMOS42NCA3LjY0ek02IDhjLTEuMSAwLTItLjg5LTItMnMuOS0yIDItMiAyIC44OSAyIDItLjkgMi0yIDJ6bTAgMTJjLTEuMSAwLTItLjg5LTItMnMuOS0yIDItMiAyIC44OSAyIDItLjkgMi0yIDJ6bTYtNy41Yy0uMjggMC0uNS0uMjItLjUtLjVzLjIyLS41LjUtLjUuNS4yMi41LjUtLjIyLjUtLjUuNXpNMTkgM2wtNiA2IDIgMiA3LTdWM3oiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-delete: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2cHgiIGhlaWdodD0iMTZweCI+CiAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIiAvPgogICAgPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjI2MjYyIiBkPSJNNiAxOWMwIDEuMS45IDIgMiAyaDhjMS4xIDAgMi0uOSAyLTJWN0g2djEyek0xOSA0aC0zLjVsLTEtMWgtNWwtMSAxSDV2MmgxNFY0eiIgLz4KPC9zdmc+Cg==);
+      --jp-icon-download: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE5IDloLTRWM0g5djZINWw3IDcgNy03ek01IDE4djJoMTR2LTJINXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-duplicate: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBmaWxsLXJ1bGU9ImV2ZW5vZGQiIGNsaXAtcnVsZT0iZXZlbm9kZCIgZD0iTTIuNzk5OTggMC44NzVIOC44OTU4MkM5LjIwMDYxIDAuODc1IDkuNDQ5OTggMS4xMzkxNCA5LjQ0OTk4IDEuNDYxOThDOS40NDk5OCAxLjc4NDgyIDkuMjAwNjEgMi4wNDg5NiA4Ljg5NTgyIDIuMDQ4OTZIMy4zNTQxNUMzLjA0OTM2IDIuMDQ4OTYgMi43OTk5OCAyLjMxMzEgMi43OTk5OCAyLjYzNTk0VjkuNjc5NjlDMi43OTk5OCAxMC4wMDI1IDIuNTUwNjEgMTAuMjY2NyAyLjI0NTgyIDEwLjI2NjdDMS45NDEwMyAxMC4yNjY3IDEuNjkxNjUgMTAuMDAyNSAxLjY5MTY1IDkuNjc5NjlWMi4wNDg5NkMxLjY5MTY1IDEuNDAzMjggMi4xOTA0IDAuODc1IDIuNzk5OTggMC44NzVaTTUuMzY2NjUgMTEuOVY0LjU1SDExLjA4MzNWMTEuOUg1LjM2NjY1Wk00LjE0MTY1IDQuMTQxNjdDNC4xNDE2NSAzLjY5MDYzIDQuNTA3MjggMy4zMjUgNC45NTgzMiAzLjMyNUgxMS40OTE3QzExLjk0MjcgMy4zMjUgMTIuMzA4MyAzLjY5MDYzIDEyLjMwODMgNC4xNDE2N1YxMi4zMDgzQzEyLjMwODMgMTIuNzU5NCAxMS45NDI3IDEzLjEyNSAxMS40OTE3IDEzLjEyNUg0Ljk1ODMyQzQuNTA3MjggMTMuMTI1IDQuMTQxNjUgMTIuNzU5NCA0LjE0MTY1IDEyLjMwODNWNC4xNDE2N1oiIGZpbGw9IiM2MTYxNjEiLz4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNOS40MzU3NCA4LjI2NTA3SDguMzY0MzFWOS4zMzY1QzguMzY0MzEgOS40NTQzNSA4LjI2Nzg4IDkuNTUwNzggOC4xNTAwMiA5LjU1MDc4QzguMDMyMTcgOS41NTA3OCA3LjkzNTc0IDkuNDU0MzUgNy45MzU3NCA5LjMzNjVWOC4yNjUwN0g2Ljg2NDMxQzYuNzQ2NDUgOC4yNjUwNyA2LjY1MDAyIDguMTY4NjQgNi42NTAwMiA4LjA1MDc4QzYuNjUwMDIgNy45MzI5MiA2Ljc0NjQ1IDcuODM2NSA2Ljg2NDMxIDcuODM2NUg3LjkzNTc0VjYuNzY1MDdDNy45MzU3NCA2LjY0NzIxIDguMDMyMTcgNi41NTA3OCA4LjE1MDAyIDYuNTUwNzhDOC4yNjc4OCA2LjU1MDc4IDguMzY0MzEgNi42NDcyMSA4LjM2NDMxIDYuNzY1MDdWNy44MzY1SDkuNDM1NzRDOS41NTM2IDcuODM2NSA5LjY1MDAyIDcuOTMyOTIgOS42NTAwMiA4LjA1MDc4QzkuNjUwMDIgOC4xNjg2NCA5LjU1MzYgOC4yNjUwNyA5LjQzNTc0IDguMjY1MDdaIiBmaWxsPSIjNjE2MTYxIiBzdHJva2U9IiM2MTYxNjEiIHN0cm9rZS13aWR0aD0iMC41Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-edit: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTMgMTcuMjVWMjFoMy43NUwxNy44MSA5Ljk0bC0zLjc1LTMuNzVMMyAxNy4yNXpNMjAuNzEgNy4wNGMuMzktLjM5LjM5LTEuMDIgMC0xLjQxbC0yLjM0LTIuMzRjLS4zOS0uMzktMS4wMi0uMzktMS40MSAwbC0xLjgzIDEuODMgMy43NSAzLjc1IDEuODMtMS44M3oiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-ellipses: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPGNpcmNsZSBjeD0iNSIgY3k9IjEyIiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSIxMiIgY3k9IjEyIiByPSIyIi8+CiAgICA8Y2lyY2xlIGN4PSIxOSIgY3k9IjEyIiByPSIyIi8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-error: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj48Y2lyY2xlIGN4PSIxMiIgY3k9IjE5IiByPSIyIi8+PHBhdGggZD0iTTEwIDNoNHYxMmgtNHoiLz48L2c+CjxwYXRoIGZpbGw9Im5vbmUiIGQ9Ik0wIDBoMjR2MjRIMHoiLz4KPC9zdmc+Cg==);
+      --jp-icon-expand-all: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTggMmMxIDAgMTEgMCAxMiAwczIgMSAyIDJjMCAxIDAgMTEgMCAxMnMwIDItMiAyQzIwIDE0IDIwIDQgMjAgNFMxMCA0IDYgNGMwLTIgMS0yIDItMnoiIC8+CiAgICAgICAgPHBhdGgKICAgICAgICAgICAgZD0iTTE4IDhjMC0xLTEtMi0yLTJTNSA2IDQgNnMtMiAxLTIgMmMwIDEgMCAxMSAwIDEyczEgMiAyIDJjMSAwIDExIDAgMTIgMHMyLTEgMi0yYzAtMSAwLTExIDAtMTJ6bS0yIDB2MTJINFY4eiIgLz4KICAgICAgICA8cGF0aCBkPSJNMTEgMTBIOXYzSDZ2MmgzdjNoMnYtM2gzdi0yaC0zeiIgLz4KICAgIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-extension: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIwLjUgMTFIMTlWN2MwLTEuMS0uOS0yLTItMmgtNFYzLjVDMTMgMi4xMiAxMS44OCAxIDEwLjUgMVM4IDIuMTIgOCAzLjVWNUg0Yy0xLjEgMC0xLjk5LjktMS45OSAydjMuOEgzLjVjMS40OSAwIDIuNyAxLjIxIDIuNyAyLjdzLTEuMjEgMi43LTIuNyAyLjdIMlYyMGMwIDEuMS45IDIgMiAyaDMuOHYtMS41YzAtMS40OSAxLjIxLTIuNyAyLjctMi43IDEuNDkgMCAyLjcgMS4yMSAyLjcgMi43VjIySDE3YzEuMSAwIDItLjkgMi0ydi00aDEuNWMxLjM4IDAgMi41LTEuMTIgMi41LTIuNVMyMS44OCAxMSAyMC41IDExeiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-fast-forward: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTQgMThsOC41LTZMNCA2djEyem05LTEydjEybDguNS02TDEzIDZ6Ii8+CiAgICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-file-upload: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTkgMTZoNnYtNmg0bC03LTctNyA3aDR6bS00IDJoMTR2Mkg1eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-file: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkuMyA4LjJsLTUuNS01LjVjLS4zLS4zLS43LS41LTEuMi0uNUgzLjljLS44LjEtMS42LjktMS42IDEuOHYxNC4xYzAgLjkuNyAxLjYgMS42IDEuNmgxNC4yYy45IDAgMS42LS43IDEuNi0xLjZWOS40Yy4xLS41LS4xLS45LS40LTEuMnptLTUuOC0zLjNsMy40IDMuNmgtMy40VjQuOXptMy45IDEyLjdINC43Yy0uMSAwLS4yIDAtLjItLjJWNC43YzAtLjIuMS0uMy4yLS4zaDcuMnY0LjRzMCAuOC4zIDEuMWMuMy4zIDEuMS4zIDEuMS4zaDQuM3Y3LjJzLS4xLjItLjIuMnoiLz4KPC9zdmc+Cg==);
+      --jp-icon-filter-dot: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTE0LDEyVjE5Ljg4QzE0LjA0LDIwLjE4IDEzLjk0LDIwLjUgMTMuNzEsMjAuNzFDMTMuMzIsMjEuMSAxMi42OSwyMS4xIDEyLjMsMjAuNzFMMTAuMjksMTguN0MxMC4wNiwxOC40NyA5Ljk2LDE4LjE2IDEwLDE3Ljg3VjEySDkuOTdMNC4yMSw0LjYyQzMuODcsNC4xOSAzLjk1LDMuNTYgNC4zOCwzLjIyQzQuNTcsMy4wOCA0Ljc4LDMgNSwzVjNIMTlWM0MxOS4yMiwzIDE5LjQzLDMuMDggMTkuNjIsMy4yMkMyMC4wNSwzLjU2IDIwLjEzLDQuMTkgMTkuNzksNC42MkwxNC4wMywxMkgxNFoiIC8+CiAgPC9nPgogIDxnIGNsYXNzPSJqcC1pY29uLWRvdCIgZmlsbD0iI0ZGRiI+CiAgICA8Y2lyY2xlIGN4PSIxOCIgY3k9IjE3IiByPSIzIj48L2NpcmNsZT4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-filter-list: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEwIDE4aDR2LTJoLTR2MnpNMyA2djJoMThWNkgzem0zIDdoMTJ2LTJINnYyeiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-filter: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiNGRkYiPgogICAgPHBhdGggZD0iTTE0LDEyVjE5Ljg4QzE0LjA0LDIwLjE4IDEzLjk0LDIwLjUgMTMuNzEsMjAuNzFDMTMuMzIsMjEuMSAxMi42OSwyMS4xIDEyLjMsMjAuNzFMMTAuMjksMTguN0MxMC4wNiwxOC40NyA5Ljk2LDE4LjE2IDEwLDE3Ljg3VjEySDkuOTdMNC4yMSw0LjYyQzMuODcsNC4xOSAzLjk1LDMuNTYgNC4zOCwzLjIyQzQuNTcsMy4wOCA0Ljc4LDMgNSwzVjNIMTlWM0MxOS4yMiwzIDE5LjQzLDMuMDggMTkuNjIsMy4yMkMyMC4wNSwzLjU2IDIwLjEzLDQuMTkgMTkuNzksNC42MkwxNC4wMywxMkgxNFoiIC8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-folder-favorite: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMjRweCIgZmlsbD0iIzAwMDAwMCI+CiAgPHBhdGggZD0iTTAgMGgyNHYyNEgwVjB6IiBmaWxsPSJub25lIi8+PHBhdGggY2xhc3M9ImpwLWljb24zIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzYxNjE2MSIgZD0iTTIwIDZoLThsLTItMkg0Yy0xLjEgMC0yIC45LTIgMnYxMmMwIDEuMS45IDIgMiAyaDE2YzEuMSAwIDItLjkgMi0yVjhjMC0xLjEtLjktMi0yLTJ6bS0yLjA2IDExTDE1IDE1LjI4IDEyLjA2IDE3bC43OC0zLjMzLTIuNTktMi4yNCAzLjQxLS4yOUwxNSA4bDEuMzQgMy4xNCAzLjQxLjI5LTIuNTkgMi4yNC43OCAzLjMzeiIvPgo8L3N2Zz4K);
+      --jp-icon-folder: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTAgNEg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMThjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY4YzAtMS4xLS45LTItMi0yaC04bC0yLTJ6Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-home: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjRweCIgdmlld0JveD0iMCAwIDI0IDI0IiB3aWR0aD0iMjRweCIgZmlsbD0iIzAwMDAwMCI+CiAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPjxwYXRoIGNsYXNzPSJqcC1pY29uMyBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xMCAyMHYtNmg0djZoNXYtOGgzTDEyIDMgMiAxMmgzdjh6Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-html5: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDUxMiA1MTIiPgogIDxwYXRoIGNsYXNzPSJqcC1pY29uMCBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiMwMDAiIGQ9Ik0xMDguNCAwaDIzdjIyLjhoMjEuMlYwaDIzdjY5aC0yM1Y0NmgtMjF2MjNoLTIzLjJNMjA2IDIzaC0yMC4zVjBoNjMuN3YyM0gyMjl2NDZoLTIzbTUzLjUtNjloMjQuMWwxNC44IDI0LjNMMzEzLjIgMGgyNC4xdjY5aC0yM1YzNC44bC0xNi4xIDI0LjgtMTYuMS0yNC44VjY5aC0yMi42bTg5LjItNjloMjN2NDYuMmgzMi42VjY5aC01NS42Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI2U0NGQyNiIgZD0iTTEwNy42IDQ3MWwtMzMtMzcwLjRoMzYyLjhsLTMzIDM3MC4yTDI1NS43IDUxMiIvPgogIDxwYXRoIGNsYXNzPSJqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiNmMTY1MjkiIGQ9Ik0yNTYgNDgwLjVWMTMxaDE0OC4zTDM3NiA0NDciLz4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1zZWxlY3RhYmxlLWludmVyc2UiIGZpbGw9IiNlYmViZWIiIGQ9Ik0xNDIgMTc2LjNoMTE0djQ1LjRoLTY0LjJsNC4yIDQ2LjVoNjB2NDUuM0gxNTQuNG0yIDIyLjhIMjAybDMuMiAzNi4zIDUwLjggMTMuNnY0Ny40bC05My4yLTI2Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZS1pbnZlcnNlIiBmaWxsPSIjZmZmIiBkPSJNMzY5LjYgMTc2LjNIMjU1Ljh2NDUuNGgxMDkuNm0tNC4xIDQ2LjVIMjU1Ljh2NDUuNGg1NmwtNS4zIDU5LTUwLjcgMTMuNnY0Ny4ybDkzLTI1LjgiLz4KPC9zdmc+Cg==);
+      --jp-icon-image: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1icmFuZDQganAtaWNvbi1zZWxlY3RhYmxlLWludmVyc2UiIGZpbGw9IiNGRkYiIGQ9Ik0yLjIgMi4yaDE3LjV2MTcuNUgyLjJ6Ii8+CiAgPHBhdGggY2xhc3M9ImpwLWljb24tYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzNGNTFCNSIgZD0iTTIuMiAyLjJ2MTcuNWgxNy41bC4xLTE3LjVIMi4yem0xMi4xIDIuMmMxLjIgMCAyLjIgMSAyLjIgMi4ycy0xIDIuMi0yLjIgMi4yLTIuMi0xLTIuMi0yLjIgMS0yLjIgMi4yLTIuMnpNNC40IDE3LjZsMy4zLTguOCAzLjMgNi42IDIuMi0zLjIgNC40IDUuNEg0LjR6Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-info: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDUwLjk3OCA1MC45NzgiPgoJPGcgY2xhc3M9ImpwLWljb24zIiBmaWxsPSIjNjE2MTYxIj4KCQk8cGF0aCBkPSJNNDMuNTIsNy40NThDMzguNzExLDIuNjQ4LDMyLjMwNywwLDI1LjQ4OSwwQzE4LjY3LDAsMTIuMjY2LDIuNjQ4LDcuNDU4LDcuNDU4CgkJCWMtOS45NDMsOS45NDEtOS45NDMsMjYuMTE5LDAsMzYuMDYyYzQuODA5LDQuODA5LDExLjIxMiw3LjQ1NiwxOC4wMzEsNy40NThjMCwwLDAuMDAxLDAsMC4wMDIsMAoJCQljNi44MTYsMCwxMy4yMjEtMi42NDgsMTguMDI5LTcuNDU4YzQuODA5LTQuODA5LDcuNDU3LTExLjIxMiw3LjQ1Ny0xOC4wM0M1MC45NzcsMTguNjcsNDguMzI4LDEyLjI2Niw0My41Miw3LjQ1OHoKCQkJIE00Mi4xMDYsNDIuMTA1Yy00LjQzMiw0LjQzMS0xMC4zMzIsNi44NzItMTYuNjE1LDYuODcyaC0wLjAwMmMtNi4yODUtMC4wMDEtMTIuMTg3LTIuNDQxLTE2LjYxNy02Ljg3MgoJCQljLTkuMTYyLTkuMTYzLTkuMTYyLTI0LjA3MSwwLTMzLjIzM0MxMy4zMDMsNC40NCwxOS4yMDQsMiwyNS40ODksMmM2LjI4NCwwLDEyLjE4NiwyLjQ0LDE2LjYxNyw2Ljg3MgoJCQljNC40MzEsNC40MzEsNi44NzEsMTAuMzMyLDYuODcxLDE2LjYxN0M0OC45NzcsMzEuNzcyLDQ2LjUzNiwzNy42NzUsNDIuMTA2LDQyLjEwNXoiLz4KCQk8cGF0aCBkPSJNMjMuNTc4LDMyLjIxOGMtMC4wMjMtMS43MzQsMC4xNDMtMy4wNTksMC40OTYtMy45NzJjMC4zNTMtMC45MTMsMS4xMS0xLjk5NywyLjI3Mi0zLjI1MwoJCQljMC40NjgtMC41MzYsMC45MjMtMS4wNjIsMS4zNjctMS41NzVjMC42MjYtMC43NTMsMS4xMDQtMS40NzgsMS40MzYtMi4xNzVjMC4zMzEtMC43MDcsMC40OTUtMS41NDEsMC40OTUtMi41CgkJCWMwLTEuMDk2LTAuMjYtMi4wODgtMC43NzktMi45NzljLTAuNTY1LTAuODc5LTEuNTAxLTEuMzM2LTIuODA2LTEuMzY5Yy0xLjgwMiwwLjA1Ny0yLjk4NSwwLjY2Ny0zLjU1LDEuODMyCgkJCWMtMC4zMDEsMC41MzUtMC41MDMsMS4xNDEtMC42MDcsMS44MTRjLTAuMTM5LDAuNzA3LTAuMjA3LDEuNDMyLTAuMjA3LDIuMTc0aC0yLjkzN2MtMC4wOTEtMi4yMDgsMC40MDctNC4xMTQsMS40OTMtNS43MTkKCQkJYzEuMDYyLTEuNjQsMi44NTUtMi40ODEsNS4zNzgtMi41MjdjMi4xNiwwLjAyMywzLjg3NCwwLjYwOCw1LjE0MSwxLjc1OGMxLjI3OCwxLjE2LDEuOTI5LDIuNzY0LDEuOTUsNC44MTEKCQkJYzAsMS4xNDItMC4xMzcsMi4xMTEtMC40MSwyLjkxMWMtMC4zMDksMC44NDUtMC43MzEsMS41OTMtMS4yNjgsMi4yNDNjLTAuNDkyLDAuNjUtMS4wNjgsMS4zMTgtMS43MywyLjAwMgoJCQljLTAuNjUsMC42OTctMS4zMTMsMS40NzktMS45ODcsMi4zNDZjLTAuMjM5LDAuMzc3LTAuNDI5LDAuNzc3LTAuNTY1LDEuMTk5Yy0wLjE2LDAuOTU5LTAuMjE3LDEuOTUxLTAuMTcxLDIuOTc5CgkJCUMyNi41ODksMzIuMjE4LDIzLjU3OCwzMi4yMTgsMjMuNTc4LDMyLjIxOHogTTIzLjU3OCwzOC4yMnYtMy40ODRoMy4wNzZ2My40ODRIMjMuNTc4eiIvPgoJPC9nPgo8L3N2Zz4K);
+      --jp-icon-inspector: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaW5zcGVjdG9yLWljb24tY29sb3IganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMjAgNEg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMThjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY2YzAtMS4xLS45LTItMi0yem0tNSAxNEg0di00aDExdjR6bTAtNUg0VjloMTF2NHptNSA1aC00VjloNHY5eiIvPgo8L3N2Zz4K);
+      --jp-icon-json: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtanNvbi1pY29uLWNvbG9yIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI0Y5QTgyNSI+CiAgICA8cGF0aCBkPSJNMjAuMiAxMS44Yy0xLjYgMC0xLjcuNS0xLjcgMSAwIC40LjEuOS4xIDEuMy4xLjUuMS45LjEgMS4zIDAgMS43LTEuNCAyLjMtMy41IDIuM2gtLjl2LTEuOWguNWMxLjEgMCAxLjQgMCAxLjQtLjggMC0uMyAwLS42LS4xLTEgMC0uNC0uMS0uOC0uMS0xLjIgMC0xLjMgMC0xLjggMS4zLTItMS4zLS4yLTEuMy0uNy0xLjMtMiAwLS40LjEtLjguMS0xLjIuMS0uNC4xLS43LjEtMSAwLS44LS40LS43LTEuNC0uOGgtLjVWNC4xaC45YzIuMiAwIDMuNS43IDMuNSAyLjMgMCAuNC0uMS45LS4xIDEuMy0uMS41LS4xLjktLjEgMS4zIDAgLjUuMiAxIDEuNyAxdjEuOHpNMS44IDEwLjFjMS42IDAgMS43LS41IDEuNy0xIDAtLjQtLjEtLjktLjEtMS4zLS4xLS41LS4xLS45LS4xLTEuMyAwLTEuNiAxLjQtMi4zIDMuNS0yLjNoLjl2MS45aC0uNWMtMSAwLTEuNCAwLTEuNC44IDAgLjMgMCAuNi4xIDEgMCAuMi4xLjYuMSAxIDAgMS4zIDAgMS44LTEuMyAyQzYgMTEuMiA2IDExLjcgNiAxM2MwIC40LS4xLjgtLjEgMS4yLS4xLjMtLjEuNy0uMSAxIDAgLjguMy44IDEuNC44aC41djEuOWgtLjljLTIuMSAwLTMuNS0uNi0zLjUtMi4zIDAtLjQuMS0uOS4xLTEuMy4xLS41LjEtLjkuMS0xLjMgMC0uNS0uMi0xLTEuNy0xdi0xLjl6Ii8+CiAgICA8Y2lyY2xlIGN4PSIxMSIgY3k9IjEzLjgiIHI9IjIuMSIvPgogICAgPGNpcmNsZSBjeD0iMTEiIGN5PSI4LjIiIHI9IjIuMSIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-julia: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDMyNSAzMDAiPgogIDxnIGNsYXNzPSJqcC1icmFuZDAganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjY2IzYzMzIj4KICAgIDxwYXRoIGQ9Ik0gMTUwLjg5ODQzOCAyMjUgQyAxNTAuODk4NDM4IDI2Ni40MjE4NzUgMTE3LjMyMDMxMiAzMDAgNzUuODk4NDM4IDMwMCBDIDM0LjQ3NjU2MiAzMDAgMC44OTg0MzggMjY2LjQyMTg3NSAwLjg5ODQzOCAyMjUgQyAwLjg5ODQzOCAxODMuNTc4MTI1IDM0LjQ3NjU2MiAxNTAgNzUuODk4NDM4IDE1MCBDIDExNy4zMjAzMTIgMTUwIDE1MC44OTg0MzggMTgzLjU3ODEyNSAxNTAuODk4NDM4IDIyNSIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzM4OTgyNiI+CiAgICA8cGF0aCBkPSJNIDIzNy41IDc1IEMgMjM3LjUgMTE2LjQyMTg3NSAyMDMuOTIxODc1IDE1MCAxNjIuNSAxNTAgQyAxMjEuMDc4MTI1IDE1MCA4Ny41IDExNi40MjE4NzUgODcuNSA3NSBDIDg3LjUgMzMuNTc4MTI1IDEyMS4wNzgxMjUgMCAxNjIuNSAwIEMgMjAzLjkyMTg3NSAwIDIzNy41IDMzLjU3ODEyNSAyMzcuNSA3NSIvPgogIDwvZz4KICA8ZyBjbGFzcz0ianAtYnJhbmQwIGpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iIzk1NThiMiI+CiAgICA8cGF0aCBkPSJNIDMyNC4xMDE1NjIgMjI1IEMgMzI0LjEwMTU2MiAyNjYuNDIxODc1IDI5MC41MjM0MzggMzAwIDI0OS4xMDE1NjIgMzAwIEMgMjA3LjY3OTY4OCAzMDAgMTc0LjEwMTU2MiAyNjYuNDIxODc1IDE3NC4xMDE1NjIgMjI1IEMgMTc0LjEwMTU2MiAxODMuNTc4MTI1IDIwNy42Nzk2ODggMTUwIDI0OS4xMDE1NjIgMTUwIEMgMjkwLjUyMzQzOCAxNTAgMzI0LjEwMTU2MiAxODMuNTc4MTI1IDMyNC4xMDE1NjIgMjI1Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-jupyter-favicon: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTUyIiBoZWlnaHQ9IjE2NSIgdmlld0JveD0iMCAwIDE1MiAxNjUiIHZlcnNpb249IjEuMSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgPGcgY2xhc3M9ImpwLWp1cHl0ZXItaWNvbi1jb2xvciIgZmlsbD0iI0YzNzcyNiI+CiAgICA8cGF0aCB0cmFuc2Zvcm09InRyYW5zbGF0ZSgwLjA3ODk0NywgMTEwLjU4MjkyNykiIGQ9Ik03NS45NDIyODQyLDI5LjU4MDQ1NjEgQzQzLjMwMjM5NDcsMjkuNTgwNDU2MSAxNC43OTY3ODMyLDE3LjY1MzQ2MzQgMCwwIEM1LjUxMDgzMjExLDE1Ljg0MDY4MjkgMTUuNzgxNTM4OSwyOS41NjY3NzMyIDI5LjM5MDQ5NDcsMzkuMjc4NDE3MSBDNDIuOTk5Nyw0OC45ODk4NTM3IDU5LjI3MzcsNTQuMjA2NzgwNSA3NS45NjA1Nzg5LDU0LjIwNjc4MDUgQzkyLjY0NzQ1NzksNTQuMjA2NzgwNSAxMDguOTIxNDU4LDQ4Ljk4OTg1MzcgMTIyLjUzMDY2MywzOS4yNzg0MTcxIEMxMzYuMTM5NDUzLDI5LjU2Njc3MzIgMTQ2LjQxMDI4NCwxNS44NDA2ODI5IDE1MS45MjExNTgsMCBDMTM3LjA4Nzg2OCwxNy42NTM0NjM0IDEwOC41ODI1ODksMjkuNTgwNDU2MSA3NS45NDIyODQyLDI5LjU4MDQ1NjEgTDc1Ljk0MjI4NDIsMjkuNTgwNDU2MSBaIiAvPgogICAgPHBhdGggdHJhbnNmb3JtPSJ0cmFuc2xhdGUoMC4wMzczNjgsIDAuNzA0ODc4KSIgZD0iTTc1Ljk3ODQ1NzksMjQuNjI2NDA3MyBDMTA4LjYxODc2MywyNC42MjY0MDczIDEzNy4xMjQ0NTgsMzYuNTUzNDQxNSAxNTEuOTIxMTU4LDU0LjIwNjc4MDUgQzE0Ni40MTAyODQsMzguMzY2MjIyIDEzNi4xMzk0NTMsMjQuNjQwMTMxNyAxMjIuNTMwNjYzLDE0LjkyODQ4NzggQzEwOC45MjE0NTgsNS4yMTY4NDM5IDkyLjY0NzQ1NzksMCA3NS45NjA1Nzg5LDAgQzU5LjI3MzcsMCA0Mi45OTk3LDUuMjE2ODQzOSAyOS4zOTA0OTQ3LDE0LjkyODQ4NzggQzE1Ljc4MTUzODksMjQuNjQwMTMxNyA1LjUxMDgzMjExLDM4LjM2NjIyMiAwLDU0LjIwNjc4MDUgQzE0LjgzMzA4MTYsMzYuNTg5OTI5MyA0My4zMzg1Njg0LDI0LjYyNjQwNzMgNzUuOTc4NDU3OSwyNC42MjY0MDczIEw3NS45Nzg0NTc5LDI0LjYyNjQwNzMgWiIgLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-jupyter: url(data:image/svg+xml;base64,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);
+      --jp-icon-jupyterlab-wordmark: url(data:image/svg+xml;base64,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);
+      --jp-icon-kernel: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgZmlsbD0iIzYxNjE2MSIgZD0iTTE1IDlIOXY2aDZWOXptLTIgNGgtMnYtMmgydjJ6bTgtMlY5aC0yVjdjMC0xLjEtLjktMi0yLTJoLTJWM2gtMnYyaC0yVjNIOXYySDdjLTEuMSAwLTIgLjktMiAydjJIM3YyaDJ2MkgzdjJoMnYyYzAgMS4xLjkgMiAyIDJoMnYyaDJ2LTJoMnYyaDJ2LTJoMmMxLjEgMCAyLS45IDItMnYtMmgydi0yaC0ydi0yaDJ6bS00IDZIN1Y3aDEwdjEweiIvPgo8L3N2Zz4K);
+      --jp-icon-keyboard: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMjAgNUg0Yy0xLjEgMC0xLjk5LjktMS45OSAyTDIgMTdjMCAxLjEuOSAyIDIgMmgxNmMxLjEgMCAyLS45IDItMlY3YzAtMS4xLS45LTItMi0yem0tOSAzaDJ2MmgtMlY4em0wIDNoMnYyaC0ydi0yek04IDhoMnYySDhWOHptMCAzaDJ2Mkg4di0yem0tMSAySDV2LTJoMnYyem0wLTNINVY4aDJ2MnptOSA3SDh2LTJoOHYyem0wLTRoLTJ2LTJoMnYyem0wLTNoLTJWOGgydjJ6bTMgM2gtMnYtMmgydjJ6bTAtM2gtMlY4aDJ2MnoiLz4KPC9zdmc+Cg==);
+      --jp-icon-launch: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMzIgMzIiIHdpZHRoPSIzMiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik0yNiwyOEg2YTIuMDAyNywyLjAwMjcsMCwwLDEtMi0yVjZBMi4wMDI3LDIuMDAyNywwLDAsMSw2LDRIMTZWNkg2VjI2SDI2VjE2aDJWMjZBMi4wMDI3LDIuMDAyNywwLDAsMSwyNiwyOFoiLz4KICAgIDxwb2x5Z29uIHBvaW50cz0iMjAgMiAyMCA0IDI2LjU4NiA0IDE4IDEyLjU4NiAxOS40MTQgMTQgMjggNS40MTQgMjggMTIgMzAgMTIgMzAgMiAyMCAyIi8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-launcher: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkgMTlINVY1aDdWM0g1YTIgMiAwIDAwLTIgMnYxNGEyIDIgMCAwMDIgMmgxNGMxLjEgMCAyLS45IDItMnYtN2gtMnY3ek0xNCAzdjJoMy41OWwtOS44MyA5LjgzIDEuNDEgMS40MUwxOSA2LjQxVjEwaDJWM2gtN3oiLz4KPC9zdmc+Cg==);
+      --jp-icon-line-form: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGZpbGw9IndoaXRlIiBkPSJNNS44OCA0LjEyTDEzLjc2IDEybC03Ljg4IDcuODhMOCAyMmwxMC0xMEw4IDJ6Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-link: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTMuOSAxMmMwLTEuNzEgMS4zOS0zLjEgMy4xLTMuMWg0VjdIN2MtMi43NiAwLTUgMi4yNC01IDVzMi4yNCA1IDUgNWg0di0xLjlIN2MtMS43MSAwLTMuMS0xLjM5LTMuMS0zLjF6TTggMTNoOHYtMkg4djJ6bTktNmgtNHYxLjloNGMxLjcxIDAgMy4xIDEuMzkgMy4xIDMuMXMtMS4zOSAzLjEtMy4xIDMuMWgtNFYxN2g0YzIuNzYgMCA1LTIuMjQgNS01cy0yLjI0LTUtNS01eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-list: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xOSA1djE0SDVWNWgxNG0xLjEtMkgzLjljLS41IDAtLjkuNC0uOS45djE2LjJjMCAuNC40LjkuOS45aDE2LjJjLjQgMCAuOS0uNS45LS45VjMuOWMwLS41LS41LS45LS45LS45ek0xMSA3aDZ2MmgtNlY3em0wIDRoNnYyaC02di0yem0wIDRoNnYyaC02ek03IDdoMnYySDd6bTAgNGgydjJIN3ptMCA0aDJ2Mkg3eiIvPgo8L3N2Zz4K);
+      --jp-icon-markdown: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDAganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjN0IxRkEyIiBkPSJNNSAxNC45aDEybC02LjEgNnptOS40LTYuOGMwLTEuMy0uMS0yLjktLjEtNC41LS40IDEuNC0uOSAyLjktMS4zIDQuM2wtMS4zIDQuM2gtMkw4LjUgNy45Yy0uNC0xLjMtLjctMi45LTEtNC4zLS4xIDEuNi0uMSAzLjItLjIgNC42TDcgMTIuNEg0LjhsLjctMTFoMy4zTDEwIDVjLjQgMS4yLjcgMi43IDEgMy45LjMtMS4yLjctMi42IDEtMy45bDEuMi0zLjdoMy4zbC42IDExaC0yLjRsLS4zLTQuMnoiLz4KPC9zdmc+Cg==);
+      --jp-icon-move-down: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNMTIuNDcxIDcuNTI4OTlDMTIuNzYzMiA3LjIzNjg0IDEyLjc2MzIgNi43NjMxNiAxMi40NzEgNi40NzEwMVY2LjQ3MTAxQzEyLjE3OSA2LjE3OTA1IDExLjcwNTcgNi4xNzg4NCAxMS40MTM1IDYuNDcwNTRMNy43NSAxMC4xMjc1VjEuNzVDNy43NSAxLjMzNTc5IDcuNDE0MjEgMSA3IDFWMUM2LjU4NTc5IDEgNi4yNSAxLjMzNTc5IDYuMjUgMS43NVYxMC4xMjc1TDIuNTk3MjYgNi40NjgyMkMyLjMwMzM4IDYuMTczODEgMS44MjY0MSA2LjE3MzU5IDEuNTMyMjYgNi40Njc3NFY2LjQ2Nzc0QzEuMjM4MyA2Ljc2MTcgMS4yMzgzIDcuMjM4MyAxLjUzMjI2IDcuNTMyMjZMNi4yOTI4OSAxMi4yOTI5QzYuNjgzNDIgMTIuNjgzNCA3LjMxNjU4IDEyLjY4MzQgNy43MDcxMSAxMi4yOTI5TDEyLjQ3MSA3LjUyODk5WiIgZmlsbD0iIzYxNjE2MSIvPgo8L3N2Zz4K);
+      --jp-icon-move-up: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTQiIGhlaWdodD0iMTQiIHZpZXdCb3g9IjAgMCAxNCAxNCIgZmlsbD0ibm9uZSIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KPHBhdGggY2xhc3M9ImpwLWljb24zIiBkPSJNMS41Mjg5OSA2LjQ3MTAxQzEuMjM2ODQgNi43NjMxNiAxLjIzNjg0IDcuMjM2ODQgMS41Mjg5OSA3LjUyODk5VjcuNTI4OTlDMS44MjA5NSA3LjgyMDk1IDIuMjk0MjYgNy44MjExNiAyLjU4NjQ5IDcuNTI5NDZMNi4yNSAzLjg3MjVWMTIuMjVDNi4yNSAxMi42NjQyIDYuNTg1NzkgMTMgNyAxM1YxM0M3LjQxNDIxIDEzIDcuNzUgMTIuNjY0MiA3Ljc1IDEyLjI1VjMuODcyNUwxMS40MDI3IDcuNTMxNzhDMTEuNjk2NiA3LjgyNjE5IDEyLjE3MzYgNy44MjY0MSAxMi40Njc3IDcuNTMyMjZWNy41MzIyNkMxMi43NjE3IDcuMjM4MyAxMi43NjE3IDYuNzYxNyAxMi40Njc3IDYuNDY3NzRMNy43MDcxMSAxLjcwNzExQzcuMzE2NTggMS4zMTY1OCA2LjY4MzQyIDEuMzE2NTggNi4yOTI4OSAxLjcwNzExTDEuNTI4OTkgNi40NzEwMVoiIGZpbGw9IiM2MTYxNjEiLz4KPC9zdmc+Cg==);
+      --jp-icon-new-folder: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIwIDZoLThsLTItMkg0Yy0xLjExIDAtMS45OS44OS0xLjk5IDJMMiAxOGMwIDEuMTEuODkgMiAyIDJoMTZjMS4xMSAwIDItLjg5IDItMlY4YzAtMS4xMS0uODktMi0yLTJ6bS0xIDhoLTN2M2gtMnYtM2gtM3YtMmgzVjloMnYzaDN2MnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-not-trusted: url(data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI1IDI1Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDMgMykiIGQ9Ik0xLjg2MDk0IDExLjQ0MDlDMC44MjY0NDggOC43NzAyNyAwLjg2Mzc3OSA2LjA1NzY0IDEuMjQ5MDcgNC4xOTkzMkMyLjQ4MjA2IDMuOTMzNDcgNC4wODA2OCAzLjQwMzQ3IDUuNjAxMDIgMi44NDQ5QzcuMjM1NDkgMi4yNDQ0IDguODU2NjYgMS41ODE1IDkuOTg3NiAxLjA5NTM5QzExLjA1OTcgMS41ODM0MSAxMi42MDk0IDIuMjQ0NCAxNC4yMTggMi44NDMzOUMxNS43NTAzIDMuNDEzOTQgMTcuMzk5NSAzLjk1MjU4IDE4Ljc1MzkgNC4yMTM4NUMxOS4xMzY0IDYuMDcxNzcgMTkuMTcwOSA4Ljc3NzIyIDE4LjEzOSAxMS40NDA5QzE3LjAzMDMgMTQuMzAzMiAxNC42NjY4IDE3LjE4NDQgOS45OTk5OSAxOC45MzU0QzUuMzMzMTkgMTcuMTg0NCAyLjk2OTY4IDE0LjMwMzIgMS44NjA5NCAxMS40NDA5WiIvPgogICAgPHBhdGggY2xhc3M9ImpwLWljb24yIiBzdHJva2U9IiMzMzMzMzMiIHN0cm9rZS13aWR0aD0iMiIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOS4zMTU5MiA5LjMyMDMxKSIgZD0iTTcuMzY4NDIgMEwwIDcuMzY0NzkiLz4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDkuMzE1OTIgMTYuNjgzNikgc2NhbGUoMSAtMSkiIGQ9Ik03LjM2ODQyIDBMMCA3LjM2NDc5Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-notebook: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtbm90ZWJvb2staWNvbi1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiNFRjZDMDAiPgogICAgPHBhdGggZD0iTTE4LjcgMy4zdjE1LjRIMy4zVjMuM2gxNS40bTEuNS0xLjVIMS44djE4LjNoMTguM2wuMS0xOC4zeiIvPgogICAgPHBhdGggZD0iTTE2LjUgMTYuNWwtNS40LTQuMy01LjYgNC4zdi0xMWgxMXoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-numbering: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjIiIGhlaWdodD0iMjIiIHZpZXdCb3g9IjAgMCAyOCAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTQgMTlINlYxOS41SDVWMjAuNUg2VjIxSDRWMjJIN1YxOEg0VjE5Wk01IDEwSDZWNkg0VjdINVYxMFpNNCAxM0g1LjhMNCAxNS4xVjE2SDdWMTVINS4yTDcgMTIuOVYxMkg0VjEzWk05IDdWOUgyM1Y3SDlaTTkgMjFIMjNWMTlIOVYyMVpNOSAxNUgyM1YxM0g5VjE1WiIvPgoJPC9nPgo8L3N2Zz4K);
+      --jp-icon-offline-bolt: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyIDIuMDJjLTUuNTEgMC05Ljk4IDQuNDctOS45OCA5Ljk4czQuNDcgOS45OCA5Ljk4IDkuOTggOS45OC00LjQ3IDkuOTgtOS45OFMxNy41MSAyLjAyIDEyIDIuMDJ6TTExLjQ4IDIwdi02LjI2SDhMMTMgNHY2LjI2aDMuMzVMMTEuNDggMjB6Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-palette: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE4IDEzVjIwSDRWNkg5LjAyQzkuMDcgNS4yOSA5LjI0IDQuNjIgOS41IDRINEMyLjkgNCAyIDQuOSAyIDZWMjBDMiAyMS4xIDIuOSAyMiA0IDIySDE4QzE5LjEgMjIgMjAgMjEuMSAyMCAyMFYxNUwxOCAxM1pNMTkuMyA4Ljg5QzE5Ljc0IDguMTkgMjAgNy4zOCAyMCA2LjVDMjAgNC4wMSAxNy45OSAyIDE1LjUgMkMxMy4wMSAyIDExIDQuMDEgMTEgNi41QzExIDguOTkgMTMuMDEgMTEgMTUuNDkgMTFDMTYuMzcgMTEgMTcuMTkgMTAuNzQgMTcuODggMTAuM0wyMSAxMy40MkwyMi40MiAxMkwxOS4zIDguODlaTTE1LjUgOUMxNC4xMiA5IDEzIDcuODggMTMgNi41QzEzIDUuMTIgMTQuMTIgNCAxNS41IDRDMTYuODggNCAxOCA1LjEyIDE4IDYuNUMxOCA3Ljg4IDE2Ljg4IDkgMTUuNSA5WiIvPgogICAgPHBhdGggZmlsbC1ydWxlPSJldmVub2RkIiBjbGlwLXJ1bGU9ImV2ZW5vZGQiIGQ9Ik00IDZIOS4wMTg5NEM5LjAwNjM5IDYuMTY1MDIgOSA2LjMzMTc2IDkgNi41QzkgOC44MTU3NyAxMC4yMTEgMTAuODQ4NyAxMi4wMzQzIDEySDlWMTRIMTZWMTIuOTgxMUMxNi41NzAzIDEyLjkzNzcgMTcuMTIgMTIuODIwNyAxNy42Mzk2IDEyLjYzOTZMMTggMTNWMjBINFY2Wk04IDhINlYxMEg4VjhaTTYgMTJIOFYxNEg2VjEyWk04IDE2SDZWMThIOFYxNlpNOSAxNkgxNlYxOEg5VjE2WiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-paste: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTE5IDJoLTQuMThDMTQuNC44NCAxMy4zIDAgMTIgMGMtMS4zIDAtMi40Ljg0LTIuODIgMkg1Yy0xLjEgMC0yIC45LTIgMnYxNmMwIDEuMS45IDIgMiAyaDE0YzEuMSAwIDItLjkgMi0yVjRjMC0xLjEtLjktMi0yLTJ6bS03IDBjLjU1IDAgMSAuNDUgMSAxcy0uNDUgMS0xIDEtMS0uNDUtMS0xIC40NS0xIDEtMXptNyAxOEg1VjRoMnYzaDEwVjRoMnYxNnoiLz4KICAgIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-pdf: url(data:image/svg+xml;base64,PHN2ZwogICB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAyMiAyMiIgd2lkdGg9IjE2Ij4KICAgIDxwYXRoIHRyYW5zZm9ybT0icm90YXRlKDQ1KSIgY2xhc3M9ImpwLWljb24tc2VsZWN0YWJsZSIgZmlsbD0iI0ZGMkEyQSIKICAgICAgIGQ9Im0gMjIuMzQ0MzY5LC0zLjAxNjM2NDIgaCA1LjYzODYwNCB2IDEuNTc5MjQzMyBoIC0zLjU0OTIyNyB2IDEuNTA4NjkyOTkgaCAzLjMzNzU3NiBWIDEuNjUwODE1NCBoIC0zLjMzNzU3NiB2IDMuNDM1MjYxMyBoIC0yLjA4OTM3NyB6IG0gLTcuMTM2NDQ0LDEuNTc5MjQzMyB2IDQuOTQzOTU0MyBoIDAuNzQ4OTIgcSAxLjI4MDc2MSwwIDEuOTUzNzAzLC0wLjYzNDk1MzUgMC42NzgzNjksLTAuNjM0OTUzNSAwLjY3ODM2OSwtMS44NDUxNjQxIDAsLTEuMjA0NzgzNTUgLTAuNjcyOTQyLC0xLjgzNDMxMDExIC0wLjY3Mjk0MiwtMC42Mjk1MjY1OSAtMS45NTkxMywtMC42Mjk1MjY1OSB6IG0gLTIuMDg5Mzc3LC0xLjU3OTI0MzMgaCAyLjIwMzM0MyBxIDEuODQ1MTY0LDAgMi43NDYwMzksMC4yNjU5MjA3IDAuOTA2MzAxLDAuMjYwNDkzNyAxLjU1MjEwOCwwLjg5MDAyMDMgMC41Njk4MywwLjU0ODEyMjMgMC44NDY2MDUsMS4yNjQ0ODAwNiAwLjI3Njc3NCwwLjcxNjM1NzgxIDAuMjc2Nzc0LDEuNjIyNjU4OTQgMCwwLjkxNzE1NTEgLTAuMjc2Nzc0LDEuNjM4OTM5OSAtMC4yNzY3NzUsMC43MTYzNTc4IC0wLjg0NjYwNSwxLjI2NDQ4IC0wLjY1MTIzNCwwLjYyOTUyNjYgLTEuNTYyOTYyLDAuODk1NDQ3MyAtMC45MTE3MjgsMC4yNjA0OTM3IC0yLjczNTE4NSwwLjI2MDQ5MzcgaCAtMi4yMDMzNDMgeiBtIC04LjE0NTg1NjUsMCBoIDMuNDY3ODIzIHEgMS41NDY2ODE2LDAgMi4zNzE1Nzg1LDAuNjg5MjIzIDAuODMwMzI0LDAuNjgzNzk2MSAwLjgzMDMyNCwxLjk1MzcwMzE0IDAsMS4yNzUzMzM5NyAtMC44MzAzMjQsMS45NjQ1NTcwNiBRIDkuOTg3MTk2MSwyLjI3NDkxNSA4LjQ0MDUxNDUsMi4yNzQ5MTUgSCA3LjA2MjA2ODQgViA1LjA4NjA3NjcgSCA0Ljk3MjY5MTUgWiBtIDIuMDg5Mzc2OSwxLjUxNDExOTkgdiAyLjI2MzAzOTQzIGggMS4xNTU5NDEgcSAwLjYwNzgxODgsMCAwLjkzODg2MjksLTAuMjkzMDU1NDcgMC4zMzEwNDQxLC0wLjI5ODQ4MjQxIDAuMzMxMDQ0MSwtMC44NDExNzc3MiAwLC0wLjU0MjY5NTMxIC0wLjMzMTA0NDEsLTAuODM1NzUwNzQgLTAuMzMxMDQ0MSwtMC4yOTMwNTU1IC0wLjkzODg2MjksLTAuMjkzMDU1NSB6IgovPgo8L3N2Zz4K);
+      --jp-icon-python: url(data:image/svg+xml;base64,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);
+      --jp-icon-r-kernel: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMjE5NkYzIiBkPSJNNC40IDIuNWMxLjItLjEgMi45LS4zIDQuOS0uMyAyLjUgMCA0LjEuNCA1LjIgMS4zIDEgLjcgMS41IDEuOSAxLjUgMy41IDAgMi0xLjQgMy41LTIuOSA0LjEgMS4yLjQgMS43IDEuNiAyLjIgMyAuNiAxLjkgMSAzLjkgMS4zIDQuNmgtMy44Yy0uMy0uNC0uOC0xLjctMS4yLTMuN3MtMS4yLTIuNi0yLjYtMi42aC0uOXY2LjRINC40VjIuNXptMy43IDYuOWgxLjRjMS45IDAgMi45LS45IDIuOS0yLjNzLTEtMi4zLTIuOC0yLjNjLS43IDAtMS4zIDAtMS42LjJ2NC41aC4xdi0uMXoiLz4KPC9zdmc+Cg==);
+      --jp-icon-react: url(data:image/svg+xml;base64,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);
+      --jp-icon-redo: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGhlaWdodD0iMjQiIHZpZXdCb3g9IjAgMCAyNCAyNCIgd2lkdGg9IjE2Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgICA8cGF0aCBkPSJNMCAwaDI0djI0SDB6IiBmaWxsPSJub25lIi8+PHBhdGggZD0iTTE4LjQgMTAuNkMxNi41NSA4Ljk5IDE0LjE1IDggMTEuNSA4Yy00LjY1IDAtOC41OCAzLjAzLTkuOTYgNy4yMkwzLjkgMTZjMS4wNS0zLjE5IDQuMDUtNS41IDcuNi01LjUgMS45NSAwIDMuNzMuNzIgNS4xMiAxLjg4TDEzIDE2aDlWN2wtMy42IDMuNnoiLz4KICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-refresh: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDE4IDE4Ij4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTkgMTMuNWMtMi40OSAwLTQuNS0yLjAxLTQuNS00LjVTNi41MSA0LjUgOSA0LjVjMS4yNCAwIDIuMzYuNTIgMy4xNyAxLjMzTDEwIDhoNVYzbC0xLjc2IDEuNzZDMTIuMTUgMy42OCAxMC42NiAzIDkgMyA1LjY5IDMgMy4wMSA1LjY5IDMuMDEgOVM1LjY5IDE1IDkgMTVjMi45NyAwIDUuNDMtMi4xNiA1LjktNWgtMS41MmMtLjQ2IDItMi4yNCAzLjUtNC4zOCAzLjV6Ii8+CiAgICA8L2c+Cjwvc3ZnPgo=);
+      --jp-icon-regex: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIwIDIwIj4KICA8ZyBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiM0MTQxNDEiPgogICAgPHJlY3QgeD0iMiIgeT0iMiIgd2lkdGg9IjE2IiBoZWlnaHQ9IjE2Ii8+CiAgPC9nPgoKICA8ZyBjbGFzcz0ianAtaWNvbi1hY2NlbnQyIiBmaWxsPSIjRkZGIj4KICAgIDxjaXJjbGUgY2xhc3M9InN0MiIgY3g9IjUuNSIgY3k9IjE0LjUiIHI9IjEuNSIvPgogICAgPHJlY3QgeD0iMTIiIHk9IjQiIGNsYXNzPSJzdDIiIHdpZHRoPSIxIiBoZWlnaHQ9IjgiLz4KICAgIDxyZWN0IHg9IjguNSIgeT0iNy41IiB0cmFuc2Zvcm09Im1hdHJpeCgwLjg2NiAtMC41IDAuNSAwLjg2NiAtMi4zMjU1IDcuMzIxOSkiIGNsYXNzPSJzdDIiIHdpZHRoPSI4IiBoZWlnaHQ9IjEiLz4KICAgIDxyZWN0IHg9IjEyIiB5PSI0IiB0cmFuc2Zvcm09Im1hdHJpeCgwLjUgLTAuODY2IDAuODY2IDAuNSAtMC42Nzc5IDE0LjgyNTIpIiBjbGFzcz0ic3QyIiB3aWR0aD0iMSIgaGVpZ2h0PSI4Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-run: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTggNXYxNGwxMS03eiIvPgogICAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-running: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDUxMiA1MTIiPgogIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICA8cGF0aCBkPSJNMjU2IDhDMTE5IDggOCAxMTkgOCAyNTZzMTExIDI0OCAyNDggMjQ4IDI0OC0xMTEgMjQ4LTI0OFMzOTMgOCAyNTYgOHptOTYgMzI4YzAgOC44LTcuMiAxNi0xNiAxNkgxNzZjLTguOCAwLTE2LTcuMi0xNi0xNlYxNzZjMC04LjggNy4yLTE2IDE2LTE2aDE2MGM4LjggMCAxNiA3LjIgMTYgMTZ2MTYweiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-save: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTE3IDNINWMtMS4xMSAwLTIgLjktMiAydjE0YzAgMS4xLjg5IDIgMiAyaDE0YzEuMSAwIDItLjkgMi0yVjdsLTQtNHptLTUgMTZjLTEuNjYgMC0zLTEuMzQtMy0zczEuMzQtMyAzLTMgMyAxLjM0IDMgMy0xLjM0IDMtMyAzem0zLTEwSDVWNWgxMHY0eiIvPgogICAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-search: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMTggMTgiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyLjEsMTAuOWgtMC43bC0wLjItMC4yYzAuOC0wLjksMS4zLTIuMiwxLjMtMy41YzAtMy0yLjQtNS40LTUuNC01LjRTMS44LDQuMiwxLjgsNy4xczIuNCw1LjQsNS40LDUuNCBjMS4zLDAsMi41LTAuNSwzLjUtMS4zbDAuMiwwLjJ2MC43bDQuMSw0LjFsMS4yLTEuMkwxMi4xLDEwLjl6IE03LjEsMTAuOWMtMi4xLDAtMy43LTEuNy0zLjctMy43czEuNy0zLjcsMy43LTMuN3MzLjcsMS43LDMuNywzLjcgUzkuMiwxMC45LDcuMSwxMC45eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-settings: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIiBkPSJNMTkuNDMgMTIuOThjLjA0LS4zMi4wNy0uNjQuMDctLjk4cy0uMDMtLjY2LS4wNy0uOThsMi4xMS0xLjY1Yy4xOS0uMTUuMjQtLjQyLjEyLS42NGwtMi0zLjQ2Yy0uMTItLjIyLS4zOS0uMy0uNjEtLjIybC0yLjQ5IDFjLS41Mi0uNC0xLjA4LS43My0xLjY5LS45OGwtLjM4LTIuNjVBLjQ4OC40ODggMCAwMDE0IDJoLTRjLS4yNSAwLS40Ni4xOC0uNDkuNDJsLS4zOCAyLjY1Yy0uNjEuMjUtMS4xNy41OS0xLjY5Ljk4bC0yLjQ5LTFjLS4yMy0uMDktLjQ5IDAtLjYxLjIybC0yIDMuNDZjLS4xMy4yMi0uMDcuNDkuMTIuNjRsMi4xMSAxLjY1Yy0uMDQuMzItLjA3LjY1LS4wNy45OHMuMDMuNjYuMDcuOThsLTIuMTEgMS42NWMtLjE5LjE1LS4yNC40Mi0uMTIuNjRsMiAzLjQ2Yy4xMi4yMi4zOS4zLjYxLjIybDIuNDktMWMuNTIuNCAxLjA4LjczIDEuNjkuOThsLjM4IDIuNjVjLjAzLjI0LjI0LjQyLjQ5LjQyaDRjLjI1IDAgLjQ2LS4xOC40OS0uNDJsLjM4LTIuNjVjLjYxLS4yNSAxLjE3LS41OSAxLjY5LS45OGwyLjQ5IDFjLjIzLjA5LjQ5IDAgLjYxLS4yMmwyLTMuNDZjLjEyLS4yMi4wNy0uNDktLjEyLS42NGwtMi4xMS0xLjY1ek0xMiAxNS41Yy0xLjkzIDAtMy41LTEuNTctMy41LTMuNXMxLjU3LTMuNSAzLjUtMy41IDMuNSAxLjU3IDMuNSAzLjUtMS41NyAzLjUtMy41IDMuNXoiLz4KPC9zdmc+Cg==);
+      --jp-icon-share: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTSAxOCAyIEMgMTYuMzU0OTkgMiAxNSAzLjM1NDk5MDQgMTUgNSBDIDE1IDUuMTkwOTUyOSAxNS4wMjE3OTEgNS4zNzcxMjI0IDE1LjA1NjY0MSA1LjU1ODU5MzggTCA3LjkyMTg3NSA5LjcyMDcwMzEgQyA3LjM5ODUzOTkgOS4yNzc4NTM5IDYuNzMyMDc3MSA5IDYgOSBDIDQuMzU0OTkwNCA5IDMgMTAuMzU0OTkgMyAxMiBDIDMgMTMuNjQ1MDEgNC4zNTQ5OTA0IDE1IDYgMTUgQyA2LjczMjA3NzEgMTUgNy4zOTg1Mzk5IDE0LjcyMjE0NiA3LjkyMTg3NSAxNC4yNzkyOTcgTCAxNS4wNTY2NDEgMTguNDM5NDUzIEMgMTUuMDIxNTU1IDE4LjYyMTUxNCAxNSAxOC44MDgzODYgMTUgMTkgQyAxNSAyMC42NDUwMSAxNi4zNTQ5OSAyMiAxOCAyMiBDIDE5LjY0NTAxIDIyIDIxIDIwLjY0NTAxIDIxIDE5IEMgMjEgMTcuMzU0OTkgMTkuNjQ1MDEgMTYgMTggMTYgQyAxNy4yNjc0OCAxNiAxNi42MDE1OTMgMTYuMjc5MzI4IDE2LjA3ODEyNSAxNi43MjI2NTYgTCA4Ljk0MzM1OTQgMTIuNTU4NTk0IEMgOC45NzgyMDk1IDEyLjM3NzEyMiA5IDEyLjE5MDk1MyA5IDEyIEMgOSAxMS44MDkwNDcgOC45NzgyMDk1IDExLjYyMjg3OCA4Ljk0MzM1OTQgMTEuNDQxNDA2IEwgMTYuMDc4MTI1IDcuMjc5Mjk2OSBDIDE2LjYwMTQ2IDcuNzIyMTQ2MSAxNy4yNjc5MjMgOCAxOCA4IEMgMTkuNjQ1MDEgOCAyMSA2LjY0NTAwOTYgMjEgNSBDIDIxIDMuMzU0OTkwNCAxOS42NDUwMSAyIDE4IDIgeiBNIDE4IDQgQyAxOC41NjQxMjkgNCAxOSA0LjQzNTg3MDYgMTkgNSBDIDE5IDUuNTY0MTI5NCAxOC41NjQxMjkgNiAxOCA2IEMgMTcuNDM1ODcxIDYgMTcgNS41NjQxMjk0IDE3IDUgQyAxNyA0LjQzNTg3MDYgMTcuNDM1ODcxIDQgMTggNCB6IE0gNiAxMSBDIDYuNTY0MTI5NCAxMSA3IDExLjQzNTg3MSA3IDEyIEMgNyAxMi41NjQxMjkgNi41NjQxMjk0IDEzIDYgMTMgQyA1LjQzNTg3MDYgMTMgNSAxMi41NjQxMjkgNSAxMiBDIDUgMTEuNDM1ODcxIDUuNDM1ODcwNiAxMSA2IDExIHogTSAxOCAxOCBDIDE4LjU2NDEyOSAxOCAxOSAxOC40MzU4NzEgMTkgMTkgQyAxOSAxOS41NjQxMjkgMTguNTY0MTI5IDIwIDE4IDIwIEMgMTcuNDM1ODcxIDIwIDE3IDE5LjU2NDEyOSAxNyAxOSBDIDE3IDE4LjQzNTg3MSAxNy40MzU4NzEgMTggMTggMTggeiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-spreadsheet: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8cGF0aCBjbGFzcz0ianAtaWNvbi1jb250cmFzdDEganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNENBRjUwIiBkPSJNMi4yIDIuMnYxNy42aDE3LjZWMi4ySDIuMnptMTUuNCA3LjdoLTUuNVY0LjRoNS41djUuNXpNOS45IDQuNHY1LjVINC40VjQuNGg1LjV6bS01LjUgNy43aDUuNXY1LjVINC40di01LjV6bTcuNyA1LjV2LTUuNWg1LjV2NS41aC01LjV6Ii8+Cjwvc3ZnPgo=);
+      --jp-icon-stop: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik02IDZoMTJ2MTJINnoiLz4KICAgIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-tab: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTIxIDNIM2MtMS4xIDAtMiAuOS0yIDJ2MTRjMCAxLjEuOSAyIDIgMmgxOGMxLjEgMCAyLS45IDItMlY1YzAtMS4xLS45LTItMi0yem0wIDE2SDNWNWgxMHY0aDh2MTB6Ii8+CiAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-table-rows: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik0yMSw4SDNWNGgxOFY4eiBNMjEsMTBIM3Y0aDE4VjEweiBNMjEsMTZIM3Y0aDE4VjE2eiIvPgogICAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-tag: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjgiIGhlaWdodD0iMjgiIHZpZXdCb3g9IjAgMCA0MyAyOCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KCTxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CgkJPHBhdGggZD0iTTI4LjgzMzIgMTIuMzM0TDMyLjk5OTggMTYuNTAwN0wzNy4xNjY1IDEyLjMzNEgyOC44MzMyWiIvPgoJCTxwYXRoIGQ9Ik0xNi4yMDk1IDIxLjYxMDRDMTUuNjg3MyAyMi4xMjk5IDE0Ljg0NDMgMjIuMTI5OSAxNC4zMjQ4IDIxLjYxMDRMNi45ODI5IDE0LjcyNDVDNi41NzI0IDE0LjMzOTQgNi4wODMxMyAxMy42MDk4IDYuMDQ3ODYgMTMuMDQ4MkM1Ljk1MzQ3IDExLjUyODggNi4wMjAwMiA4LjYxOTQ0IDYuMDY2MjEgNy4wNzY5NUM2LjA4MjgxIDYuNTE0NzcgNi41NTU0OCA2LjA0MzQ3IDcuMTE4MDQgNi4wMzA1NUM5LjA4ODYzIDUuOTg0NzMgMTMuMjYzOCA1LjkzNTc5IDEzLjY1MTggNi4zMjQyNUwyMS43MzY5IDEzLjYzOUMyMi4yNTYgMTQuMTU4NSAyMS43ODUxIDE1LjQ3MjQgMjEuMjYyIDE1Ljk5NDZMMTYuMjA5NSAyMS42MTA0Wk05Ljc3NTg1IDguMjY1QzkuMzM1NTEgNy44MjU2NiA4LjYyMzUxIDcuODI1NjYgOC4xODI4IDguMjY1QzcuNzQzNDYgOC43MDU3MSA3Ljc0MzQ2IDkuNDE3MzMgOC4xODI4IDkuODU2NjdDOC42MjM4MiAxMC4yOTY0IDkuMzM1ODIgMTAuMjk2NCA5Ljc3NTg1IDkuODU2NjdDMTAuMjE1NiA5LjQxNzMzIDEwLjIxNTYgOC43MDUzMyA5Ljc3NTg1IDguMjY1WiIvPgoJPC9nPgo8L3N2Zz4K);
+      --jp-icon-terminal: url(data:image/svg+xml;base64,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);
+      --jp-icon-text-editor: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8cGF0aCBjbGFzcz0ianAtdGV4dC1lZGl0b3ItaWNvbi1jb2xvciBqcC1pY29uLXNlbGVjdGFibGUiIGZpbGw9IiM2MTYxNjEiIGQ9Ik0xNSAxNUgzdjJoMTJ2LTJ6bTAtOEgzdjJoMTJWN3pNMyAxM2gxOHYtMkgzdjJ6bTAgOGgxOHYtMkgzdjJ6TTMgM3YyaDE4VjNIM3oiLz4KPC9zdmc+Cg==);
+      --jp-icon-toc: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIyNCIgaGVpZ2h0PSIyNCIgdmlld0JveD0iMCAwIDI0IDI0Ij4KICA8ZyBjbGFzcz0ianAtaWNvbjMganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjNjE2MTYxIj4KICAgIDxwYXRoIGQ9Ik03LDVIMjFWN0g3VjVNNywxM1YxMUgyMVYxM0g3TTQsNC41QTEuNSwxLjUgMCAwLDEgNS41LDZBMS41LDEuNSAwIDAsMSA0LDcuNUExLjUsMS41IDAgMCwxIDIuNSw2QTEuNSwxLjUgMCAwLDEgNCw0LjVNNCwxMC41QTEuNSwxLjUgMCAwLDEgNS41LDEyQTEuNSwxLjUgMCAwLDEgNCwxMy41QTEuNSwxLjUgMCAwLDEgMi41LDEyQTEuNSwxLjUgMCAwLDEgNCwxMC41TTcsMTlWMTdIMjFWMTlIN000LDE2LjVBMS41LDEuNSAwIDAsMSA1LjUsMThBMS41LDEuNSAwIDAsMSA0LDE5LjVBMS41LDEuNSAwIDAsMSAyLjUsMThBMS41LDEuNSAwIDAsMSA0LDE2LjVaIiAvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-tree-view: url(data:image/svg+xml;base64,PHN2ZyBoZWlnaHQ9IjI0IiB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICAgIDxnIGNsYXNzPSJqcC1pY29uMyIgZmlsbD0iIzYxNjE2MSI+CiAgICAgICAgPHBhdGggZD0iTTAgMGgyNHYyNEgweiIgZmlsbD0ibm9uZSIvPgogICAgICAgIDxwYXRoIGQ9Ik0yMiAxMVYzaC03djNIOVYzSDJ2OGg3VjhoMnYxMGg0djNoN3YtOGgtN3YzaC0yVjhoMnYzeiIvPgogICAgPC9nPgo8L3N2Zz4K);
+      --jp-icon-trusted: url(data:image/svg+xml;base64,PHN2ZyBmaWxsPSJub25lIiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDI0IDI1Ij4KICAgIDxwYXRoIGNsYXNzPSJqcC1pY29uMiIgc3Ryb2tlPSIjMzMzMzMzIiBzdHJva2Utd2lkdGg9IjIiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDIgMykiIGQ9Ik0xLjg2MDk0IDExLjQ0MDlDMC44MjY0NDggOC43NzAyNyAwLjg2Mzc3OSA2LjA1NzY0IDEuMjQ5MDcgNC4xOTkzMkMyLjQ4MjA2IDMuOTMzNDcgNC4wODA2OCAzLjQwMzQ3IDUuNjAxMDIgMi44NDQ5QzcuMjM1NDkgMi4yNDQ0IDguODU2NjYgMS41ODE1IDkuOTg3NiAxLjA5NTM5QzExLjA1OTcgMS41ODM0MSAxMi42MDk0IDIuMjQ0NCAxNC4yMTggMi44NDMzOUMxNS43NTAzIDMuNDEzOTQgMTcuMzk5NSAzLjk1MjU4IDE4Ljc1MzkgNC4yMTM4NUMxOS4xMzY0IDYuMDcxNzcgMTkuMTcwOSA4Ljc3NzIyIDE4LjEzOSAxMS40NDA5QzE3LjAzMDMgMTQuMzAzMiAxNC42NjY4IDE3LjE4NDQgOS45OTk5OSAxOC45MzU0QzUuMzMzMiAxNy4xODQ0IDIuOTY5NjggMTQuMzAzMiAxLjg2MDk0IDExLjQ0MDlaIi8+CiAgICA8cGF0aCBjbGFzcz0ianAtaWNvbjIiIGZpbGw9IiMzMzMzMzMiIHN0cm9rZT0iIzMzMzMzMyIgdHJhbnNmb3JtPSJ0cmFuc2xhdGUoOCA5Ljg2NzE5KSIgZD0iTTIuODYwMTUgNC44NjUzNUwwLjcyNjU0OSAyLjk5OTU5TDAgMy42MzA0NUwyLjg2MDE1IDYuMTMxNTdMOCAwLjYzMDg3Mkw3LjI3ODU3IDBMMi44NjAxNSA0Ljg2NTM1WiIvPgo8L3N2Zz4K);
+      --jp-icon-undo: url(data:image/svg+xml;base64,PHN2ZyB2aWV3Qm94PSIwIDAgMjQgMjQiIHdpZHRoPSIxNiIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTEyLjUgOGMtMi42NSAwLTUuMDUuOTktNi45IDIuNkwyIDd2OWg5bC0zLjYyLTMuNjJjMS4zOS0xLjE2IDMuMTYtMS44OCA1LjEyLTEuODggMy41NCAwIDYuNTUgMi4zMSA3LjYgNS41bDIuMzctLjc4QzIxLjA4IDExLjAzIDE3LjE1IDggMTIuNSA4eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-user: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMTYiIHZpZXdCb3g9IjAgMCAyNCAyNCIgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzIwMDAvc3ZnIj4KICA8ZyBjbGFzcz0ianAtaWNvbjMiIGZpbGw9IiM2MTYxNjEiPgogICAgPHBhdGggZD0iTTE2IDdhNCA0IDAgMTEtOCAwIDQgNCAwIDAxOCAwek0xMiAxNGE3IDcgMCAwMC03IDdoMTRhNyA3IDAgMDAtNy03eiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-users: url(data:image/svg+xml;base64,PHN2ZyB3aWR0aD0iMjQiIGhlaWdodD0iMjQiIHZlcnNpb249IjEuMSIgdmlld0JveD0iMCAwIDM2IDI0IiB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciPgogPGcgY2xhc3M9ImpwLWljb24zIiB0cmFuc2Zvcm09Im1hdHJpeCgxLjczMjcgMCAwIDEuNzMyNyAtMy42MjgyIC4wOTk1NzcpIiBmaWxsPSIjNjE2MTYxIj4KICA8cGF0aCB0cmFuc2Zvcm09Im1hdHJpeCgxLjUsMCwwLDEuNSwwLC02KSIgZD0ibTEyLjE4NiA3LjUwOThjLTEuMDUzNSAwLTEuOTc1NyAwLjU2NjUtMi40Nzg1IDEuNDEwMiAwLjc1MDYxIDAuMzEyNzcgMS4zOTc0IDAuODI2NDggMS44NzMgMS40NzI3aDMuNDg2M2MwLTEuNTkyLTEuMjg4OS0yLjg4MjgtMi44ODA5LTIuODgyOHoiLz4KICA8cGF0aCBkPSJtMjAuNDY1IDIuMzg5NWEyLjE4ODUgMi4xODg1IDAgMCAxLTIuMTg4NCAyLjE4ODUgMi4xODg1IDIuMTg4NSAwIDAgMS0yLjE4ODUtMi4xODg1IDIuMTg4NSAyLjE4ODUgMCAwIDEgMi4xODg1LTIuMTg4NSAyLjE4ODUgMi4xODg1IDAgMCAxIDIuMTg4NCAyLjE4ODV6Ii8+CiAgPHBhdGggdHJhbnNmb3JtPSJtYXRyaXgoMS41LDAsMCwxLjUsMCwtNikiIGQ9Im0zLjU4OTggOC40MjE5Yy0xLjExMjYgMC0yLjAxMzcgMC45MDExMS0yLjAxMzcgMi4wMTM3aDIuODE0NWMwLjI2Nzk3LTAuMzczMDkgMC41OTA3LTAuNzA0MzUgMC45NTg5OC0wLjk3ODUyLTAuMzQ0MzMtMC42MTY4OC0xLjAwMzEtMS4wMzUyLTEuNzU5OC0xLjAzNTJ6Ii8+CiAgPHBhdGggZD0ibTYuOTE1NCA0LjYyM2ExLjUyOTQgMS41Mjk0IDAgMCAxLTEuNTI5NCAxLjUyOTQgMS41Mjk0IDEuNTI5NCAwIDAgMS0xLjUyOTQtMS41Mjk0IDEuNTI5NCAxLjUyOTQgMCAwIDEgMS41Mjk0LTEuNTI5NCAxLjUyOTQgMS41Mjk0IDAgMCAxIDEuNTI5NCAxLjUyOTR6Ii8+CiAgPHBhdGggZD0ibTYuMTM1IDEzLjUzNWMwLTMuMjM5MiAyLjYyNTktNS44NjUgNS44NjUtNS44NjUgMy4yMzkyIDAgNS44NjUgMi42MjU5IDUuODY1IDUuODY1eiIvPgogIDxjaXJjbGUgY3g9IjEyIiBjeT0iMy43Njg1IiByPSIyLjk2ODUiLz4KIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-vega: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtaWNvbjEganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjMjEyMTIxIj4KICAgIDxwYXRoIGQ9Ik0xMC42IDUuNGwyLjItMy4ySDIuMnY3LjNsNC02LjZ6Ii8+CiAgICA8cGF0aCBkPSJNMTUuOCAyLjJsLTQuNCA2LjZMNyA2LjNsLTQuOCA4djUuNWgxNy42VjIuMmgtNHptLTcgMTUuNEg1LjV2LTQuNGgzLjN2NC40em00LjQgMEg5LjhWOS44aDMuNHY3Ljh6bTQuNCAwaC0zLjRWNi41aDMuNHYxMS4xeiIvPgogIDwvZz4KPC9zdmc+Cg==);
+      --jp-icon-word: url(data:image/svg+xml;base64,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);
+      --jp-icon-yaml: url(data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxNiIgdmlld0JveD0iMCAwIDIyIDIyIj4KICA8ZyBjbGFzcz0ianAtaWNvbi1jb250cmFzdDIganAtaWNvbi1zZWxlY3RhYmxlIiBmaWxsPSIjRDgxQjYwIj4KICAgIDxwYXRoIGQ9Ik03LjIgMTguNnYtNS40TDMgNS42aDMuM2wxLjQgMy4xYy4zLjkuNiAxLjYgMSAyLjUuMy0uOC42LTEuNiAxLTIuNWwxLjQtMy4xaDMuNGwtNC40IDcuNnY1LjVsLTIuOS0uMXoiLz4KICAgIDxjaXJjbGUgY2xhc3M9InN0MCIgY3g9IjE3LjYiIGN5PSIxNi41IiByPSIyLjEiLz4KICAgIDxjaXJjbGUgY2xhc3M9InN0MCIgY3g9IjE3LjYiIGN5PSIxMSIgcj0iMi4xIi8+CiAgPC9nPgo8L3N2Zz4K);
+    }
+
+    /* Icon CSS class declarations */
+
+    .jp-AddAboveIcon {
+      background-image: var(--jp-icon-add-above);
+    }
+
+    .jp-AddBelowIcon {
+      background-image: var(--jp-icon-add-below);
+    }
+
+    .jp-AddIcon {
+      background-image: var(--jp-icon-add);
+    }
+
+    .jp-BellIcon {
+      background-image: var(--jp-icon-bell);
+    }
+
+    .jp-BugDotIcon {
+      background-image: var(--jp-icon-bug-dot);
+    }
+
+    .jp-BugIcon {
+      background-image: var(--jp-icon-bug);
+    }
+
+    .jp-BuildIcon {
+      background-image: var(--jp-icon-build);
+    }
+
+    .jp-CaretDownEmptyIcon {
+      background-image: var(--jp-icon-caret-down-empty);
+    }
+
+    .jp-CaretDownEmptyThinIcon {
+      background-image: var(--jp-icon-caret-down-empty-thin);
+    }
+
+    .jp-CaretDownIcon {
+      background-image: var(--jp-icon-caret-down);
+    }
+
+    .jp-CaretLeftIcon {
+      background-image: var(--jp-icon-caret-left);
+    }
+
+    .jp-CaretRightIcon {
+      background-image: var(--jp-icon-caret-right);
+    }
+
+    .jp-CaretUpEmptyThinIcon {
+      background-image: var(--jp-icon-caret-up-empty-thin);
+    }
+
+    .jp-CaretUpIcon {
+      background-image: var(--jp-icon-caret-up);
+    }
+
+    .jp-CaseSensitiveIcon {
+      background-image: var(--jp-icon-case-sensitive);
+    }
+
+    .jp-CheckIcon {
+      background-image: var(--jp-icon-check);
+    }
+
+    .jp-CircleEmptyIcon {
+      background-image: var(--jp-icon-circle-empty);
+    }
+
+    .jp-CircleIcon {
+      background-image: var(--jp-icon-circle);
+    }
+
+    .jp-ClearIcon {
+      background-image: var(--jp-icon-clear);
+    }
+
+    .jp-CloseIcon {
+      background-image: var(--jp-icon-close);
+    }
+
+    .jp-CodeCheckIcon {
+      background-image: var(--jp-icon-code-check);
+    }
+
+    .jp-CodeIcon {
+      background-image: var(--jp-icon-code);
+    }
+
+    .jp-CollapseAllIcon {
+      background-image: var(--jp-icon-collapse-all);
+    }
 
-.jp-ConsoleIcon {
-  background-image: var(--jp-icon-console);
-}
+    .jp-ConsoleIcon {
+      background-image: var(--jp-icon-console);
+    }
 
-.jp-CopyIcon {
-  background-image: var(--jp-icon-copy);
-}
+    .jp-CopyIcon {
+      background-image: var(--jp-icon-copy);
+    }
 
-.jp-CopyrightIcon {
-  background-image: var(--jp-icon-copyright);
-}
+    .jp-CopyrightIcon {
+      background-image: var(--jp-icon-copyright);
+    }
 
-.jp-CutIcon {
-  background-image: var(--jp-icon-cut);
-}
+    .jp-CutIcon {
+      background-image: var(--jp-icon-cut);
+    }
 
-.jp-DeleteIcon {
-  background-image: var(--jp-icon-delete);
-}
+    .jp-DeleteIcon {
+      background-image: var(--jp-icon-delete);
+    }
 
-.jp-DownloadIcon {
-  background-image: var(--jp-icon-download);
-}
+    .jp-DownloadIcon {
+      background-image: var(--jp-icon-download);
+    }
 
-.jp-DuplicateIcon {
-  background-image: var(--jp-icon-duplicate);
-}
+    .jp-DuplicateIcon {
+      background-image: var(--jp-icon-duplicate);
+    }
 
-.jp-EditIcon {
-  background-image: var(--jp-icon-edit);
-}
+    .jp-EditIcon {
+      background-image: var(--jp-icon-edit);
+    }
 
-.jp-EllipsesIcon {
-  background-image: var(--jp-icon-ellipses);
-}
+    .jp-EllipsesIcon {
+      background-image: var(--jp-icon-ellipses);
+    }
 
-.jp-ErrorIcon {
-  background-image: var(--jp-icon-error);
-}
+    .jp-ErrorIcon {
+      background-image: var(--jp-icon-error);
+    }
 
-.jp-ExpandAllIcon {
-  background-image: var(--jp-icon-expand-all);
-}
+    .jp-ExpandAllIcon {
+      background-image: var(--jp-icon-expand-all);
+    }
 
-.jp-ExtensionIcon {
-  background-image: var(--jp-icon-extension);
-}
+    .jp-ExtensionIcon {
+      background-image: var(--jp-icon-extension);
+    }
 
-.jp-FastForwardIcon {
-  background-image: var(--jp-icon-fast-forward);
-}
+    .jp-FastForwardIcon {
+      background-image: var(--jp-icon-fast-forward);
+    }
 
-.jp-FileIcon {
-  background-image: var(--jp-icon-file);
-}
+    .jp-FileIcon {
+      background-image: var(--jp-icon-file);
+    }
 
-.jp-FileUploadIcon {
-  background-image: var(--jp-icon-file-upload);
-}
+    .jp-FileUploadIcon {
+      background-image: var(--jp-icon-file-upload);
+    }
 
-.jp-FilterDotIcon {
-  background-image: var(--jp-icon-filter-dot);
-}
+    .jp-FilterDotIcon {
+      background-image: var(--jp-icon-filter-dot);
+    }
 
-.jp-FilterIcon {
-  background-image: var(--jp-icon-filter);
-}
+    .jp-FilterIcon {
+      background-image: var(--jp-icon-filter);
+    }
 
-.jp-FilterListIcon {
-  background-image: var(--jp-icon-filter-list);
-}
+    .jp-FilterListIcon {
+      background-image: var(--jp-icon-filter-list);
+    }
 
-.jp-FolderFavoriteIcon {
-  background-image: var(--jp-icon-folder-favorite);
-}
+    .jp-FolderFavoriteIcon {
+      background-image: var(--jp-icon-folder-favorite);
+    }
 
-.jp-FolderIcon {
-  background-image: var(--jp-icon-folder);
-}
+    .jp-FolderIcon {
+      background-image: var(--jp-icon-folder);
+    }
 
-.jp-HomeIcon {
-  background-image: var(--jp-icon-home);
-}
+    .jp-HomeIcon {
+      background-image: var(--jp-icon-home);
+    }
 
-.jp-Html5Icon {
-  background-image: var(--jp-icon-html5);
-}
+    .jp-Html5Icon {
+      background-image: var(--jp-icon-html5);
+    }
 
-.jp-ImageIcon {
-  background-image: var(--jp-icon-image);
-}
+    .jp-ImageIcon {
+      background-image: var(--jp-icon-image);
+    }
 
-.jp-InfoIcon {
-  background-image: var(--jp-icon-info);
-}
+    .jp-InfoIcon {
+      background-image: var(--jp-icon-info);
+    }
 
-.jp-InspectorIcon {
-  background-image: var(--jp-icon-inspector);
-}
+    .jp-InspectorIcon {
+      background-image: var(--jp-icon-inspector);
+    }
 
-.jp-JsonIcon {
-  background-image: var(--jp-icon-json);
-}
+    .jp-JsonIcon {
+      background-image: var(--jp-icon-json);
+    }
 
-.jp-JuliaIcon {
-  background-image: var(--jp-icon-julia);
-}
+    .jp-JuliaIcon {
+      background-image: var(--jp-icon-julia);
+    }
 
-.jp-JupyterFaviconIcon {
-  background-image: var(--jp-icon-jupyter-favicon);
-}
+    .jp-JupyterFaviconIcon {
+      background-image: var(--jp-icon-jupyter-favicon);
+    }
 
-.jp-JupyterIcon {
-  background-image: var(--jp-icon-jupyter);
-}
+    .jp-JupyterIcon {
+      background-image: var(--jp-icon-jupyter);
+    }
 
-.jp-JupyterlabWordmarkIcon {
-  background-image: var(--jp-icon-jupyterlab-wordmark);
-}
+    .jp-JupyterlabWordmarkIcon {
+      background-image: var(--jp-icon-jupyterlab-wordmark);
+    }
 
-.jp-KernelIcon {
-  background-image: var(--jp-icon-kernel);
-}
+    .jp-KernelIcon {
+      background-image: var(--jp-icon-kernel);
+    }
 
-.jp-KeyboardIcon {
-  background-image: var(--jp-icon-keyboard);
-}
+    .jp-KeyboardIcon {
+      background-image: var(--jp-icon-keyboard);
+    }
 
-.jp-LaunchIcon {
-  background-image: var(--jp-icon-launch);
-}
+    .jp-LaunchIcon {
+      background-image: var(--jp-icon-launch);
+    }
 
-.jp-LauncherIcon {
-  background-image: var(--jp-icon-launcher);
-}
+    .jp-LauncherIcon {
+      background-image: var(--jp-icon-launcher);
+    }
 
-.jp-LineFormIcon {
-  background-image: var(--jp-icon-line-form);
-}
+    .jp-LineFormIcon {
+      background-image: var(--jp-icon-line-form);
+    }
 
-.jp-LinkIcon {
-  background-image: var(--jp-icon-link);
-}
+    .jp-LinkIcon {
+      background-image: var(--jp-icon-link);
+    }
 
-.jp-ListIcon {
-  background-image: var(--jp-icon-list);
-}
+    .jp-ListIcon {
+      background-image: var(--jp-icon-list);
+    }
 
-.jp-MarkdownIcon {
-  background-image: var(--jp-icon-markdown);
-}
+    .jp-MarkdownIcon {
+      background-image: var(--jp-icon-markdown);
+    }
 
-.jp-MoveDownIcon {
-  background-image: var(--jp-icon-move-down);
-}
+    .jp-MoveDownIcon {
+      background-image: var(--jp-icon-move-down);
+    }
 
-.jp-MoveUpIcon {
-  background-image: var(--jp-icon-move-up);
-}
+    .jp-MoveUpIcon {
+      background-image: var(--jp-icon-move-up);
+    }
 
-.jp-NewFolderIcon {
-  background-image: var(--jp-icon-new-folder);
-}
+    .jp-NewFolderIcon {
+      background-image: var(--jp-icon-new-folder);
+    }
 
-.jp-NotTrustedIcon {
-  background-image: var(--jp-icon-not-trusted);
-}
+    .jp-NotTrustedIcon {
+      background-image: var(--jp-icon-not-trusted);
+    }
 
-.jp-NotebookIcon {
-  background-image: var(--jp-icon-notebook);
-}
+    .jp-NotebookIcon {
+      background-image: var(--jp-icon-notebook);
+    }
 
-.jp-NumberingIcon {
-  background-image: var(--jp-icon-numbering);
-}
+    .jp-NumberingIcon {
+      background-image: var(--jp-icon-numbering);
+    }
 
-.jp-OfflineBoltIcon {
-  background-image: var(--jp-icon-offline-bolt);
-}
+    .jp-OfflineBoltIcon {
+      background-image: var(--jp-icon-offline-bolt);
+    }
 
-.jp-PaletteIcon {
-  background-image: var(--jp-icon-palette);
-}
+    .jp-PaletteIcon {
+      background-image: var(--jp-icon-palette);
+    }
 
-.jp-PasteIcon {
-  background-image: var(--jp-icon-paste);
-}
+    .jp-PasteIcon {
+      background-image: var(--jp-icon-paste);
+    }
 
-.jp-PdfIcon {
-  background-image: var(--jp-icon-pdf);
-}
+    .jp-PdfIcon {
+      background-image: var(--jp-icon-pdf);
+    }
 
-.jp-PythonIcon {
-  background-image: var(--jp-icon-python);
-}
+    .jp-PythonIcon {
+      background-image: var(--jp-icon-python);
+    }
 
-.jp-RKernelIcon {
-  background-image: var(--jp-icon-r-kernel);
-}
+    .jp-RKernelIcon {
+      background-image: var(--jp-icon-r-kernel);
+    }
 
-.jp-ReactIcon {
-  background-image: var(--jp-icon-react);
-}
+    .jp-ReactIcon {
+      background-image: var(--jp-icon-react);
+    }
 
-.jp-RedoIcon {
-  background-image: var(--jp-icon-redo);
-}
+    .jp-RedoIcon {
+      background-image: var(--jp-icon-redo);
+    }
 
-.jp-RefreshIcon {
-  background-image: var(--jp-icon-refresh);
-}
+    .jp-RefreshIcon {
+      background-image: var(--jp-icon-refresh);
+    }
 
-.jp-RegexIcon {
-  background-image: var(--jp-icon-regex);
-}
+    .jp-RegexIcon {
+      background-image: var(--jp-icon-regex);
+    }
 
-.jp-RunIcon {
-  background-image: var(--jp-icon-run);
-}
+    .jp-RunIcon {
+      background-image: var(--jp-icon-run);
+    }
 
-.jp-RunningIcon {
-  background-image: var(--jp-icon-running);
-}
+    .jp-RunningIcon {
+      background-image: var(--jp-icon-running);
+    }
 
-.jp-SaveIcon {
-  background-image: var(--jp-icon-save);
-}
+    .jp-SaveIcon {
+      background-image: var(--jp-icon-save);
+    }
 
-.jp-SearchIcon {
-  background-image: var(--jp-icon-search);
-}
+    .jp-SearchIcon {
+      background-image: var(--jp-icon-search);
+    }
 
-.jp-SettingsIcon {
-  background-image: var(--jp-icon-settings);
-}
+    .jp-SettingsIcon {
+      background-image: var(--jp-icon-settings);
+    }
 
-.jp-ShareIcon {
-  background-image: var(--jp-icon-share);
-}
+    .jp-ShareIcon {
+      background-image: var(--jp-icon-share);
+    }
 
-.jp-SpreadsheetIcon {
-  background-image: var(--jp-icon-spreadsheet);
-}
+    .jp-SpreadsheetIcon {
+      background-image: var(--jp-icon-spreadsheet);
+    }
 
-.jp-StopIcon {
-  background-image: var(--jp-icon-stop);
-}
+    .jp-StopIcon {
+      background-image: var(--jp-icon-stop);
+    }
 
-.jp-TabIcon {
-  background-image: var(--jp-icon-tab);
-}
+    .jp-TabIcon {
+      background-image: var(--jp-icon-tab);
+    }
 
-.jp-TableRowsIcon {
-  background-image: var(--jp-icon-table-rows);
-}
+    .jp-TableRowsIcon {
+      background-image: var(--jp-icon-table-rows);
+    }
 
-.jp-TagIcon {
-  background-image: var(--jp-icon-tag);
-}
+    .jp-TagIcon {
+      background-image: var(--jp-icon-tag);
+    }
 
-.jp-TerminalIcon {
-  background-image: var(--jp-icon-terminal);
-}
+    .jp-TerminalIcon {
+      background-image: var(--jp-icon-terminal);
+    }
 
-.jp-TextEditorIcon {
-  background-image: var(--jp-icon-text-editor);
-}
+    .jp-TextEditorIcon {
+      background-image: var(--jp-icon-text-editor);
+    }
 
-.jp-TocIcon {
-  background-image: var(--jp-icon-toc);
-}
+    .jp-TocIcon {
+      background-image: var(--jp-icon-toc);
+    }
 
-.jp-TreeViewIcon {
-  background-image: var(--jp-icon-tree-view);
-}
+    .jp-TreeViewIcon {
+      background-image: var(--jp-icon-tree-view);
+    }
 
-.jp-TrustedIcon {
-  background-image: var(--jp-icon-trusted);
-}
+    .jp-TrustedIcon {
+      background-image: var(--jp-icon-trusted);
+    }
 
-.jp-UndoIcon {
-  background-image: var(--jp-icon-undo);
-}
+    .jp-UndoIcon {
+      background-image: var(--jp-icon-undo);
+    }
 
-.jp-UserIcon {
-  background-image: var(--jp-icon-user);
-}
+    .jp-UserIcon {
+      background-image: var(--jp-icon-user);
+    }
 
-.jp-UsersIcon {
-  background-image: var(--jp-icon-users);
-}
+    .jp-UsersIcon {
+      background-image: var(--jp-icon-users);
+    }
 
-.jp-VegaIcon {
-  background-image: var(--jp-icon-vega);
-}
+    .jp-VegaIcon {
+      background-image: var(--jp-icon-vega);
+    }
 
-.jp-WordIcon {
-  background-image: var(--jp-icon-word);
-}
+    .jp-WordIcon {
+      background-image: var(--jp-icon-word);
+    }
 
-.jp-YamlIcon {
-  background-image: var(--jp-icon-yaml);
-}
+    .jp-YamlIcon {
+      background-image: var(--jp-icon-yaml);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/**
+    /**
  * (DEPRECATED) Support for consuming icons as CSS background images
  */
 
-.jp-Icon,
-.jp-MaterialIcon {
-  background-position: center;
-  background-repeat: no-repeat;
-  background-size: 16px;
-  min-width: 16px;
-  min-height: 16px;
-}
+    .jp-Icon,
+    .jp-MaterialIcon {
+      background-position: center;
+      background-repeat: no-repeat;
+      background-size: 16px;
+      min-width: 16px;
+      min-height: 16px;
+    }
 
-.jp-Icon-cover {
-  background-position: center;
-  background-repeat: no-repeat;
-  background-size: cover;
-}
+    .jp-Icon-cover {
+      background-position: center;
+      background-repeat: no-repeat;
+      background-size: cover;
+    }
 
-/**
+    /**
  * (DEPRECATED) Support for specific CSS icon sizes
  */
 
-.jp-Icon-16 {
-  background-size: 16px;
-  min-width: 16px;
-  min-height: 16px;
-}
+    .jp-Icon-16 {
+      background-size: 16px;
+      min-width: 16px;
+      min-height: 16px;
+    }
 
-.jp-Icon-18 {
-  background-size: 18px;
-  min-width: 18px;
-  min-height: 18px;
-}
+    .jp-Icon-18 {
+      background-size: 18px;
+      min-width: 18px;
+      min-height: 18px;
+    }
 
-.jp-Icon-20 {
-  background-size: 20px;
-  min-width: 20px;
-  min-height: 20px;
-}
+    .jp-Icon-20 {
+      background-size: 20px;
+      min-width: 20px;
+      min-height: 20px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.lm-TabBar .lm-TabBar-addButton {
-  align-items: center;
-  display: flex;
-  padding: 4px;
-  padding-bottom: 5px;
-  margin-right: 1px;
-  background-color: var(--jp-layout-color2);
-}
+    .lm-TabBar .lm-TabBar-addButton {
+      align-items: center;
+      display: flex;
+      padding: 4px;
+      padding-bottom: 5px;
+      margin-right: 1px;
+      background-color: var(--jp-layout-color2);
+    }
 
-.lm-TabBar .lm-TabBar-addButton:hover {
-  background-color: var(--jp-layout-color1);
-}
+    .lm-TabBar .lm-TabBar-addButton:hover {
+      background-color: var(--jp-layout-color1);
+    }
 
-.lm-DockPanel-tabBar .lm-TabBar-tab {
-  width: var(--jp-private-horizontal-tab-width);
-}
+    .lm-DockPanel-tabBar .lm-TabBar-tab {
+      width: var(--jp-private-horizontal-tab-width);
+    }
 
-.lm-DockPanel-tabBar .lm-TabBar-content {
-  flex: unset;
-}
+    .lm-DockPanel-tabBar .lm-TabBar-content {
+      flex: unset;
+    }
 
-.lm-DockPanel-tabBar[data-orientation='horizontal'] {
-  flex: 1 1 auto;
-}
+    .lm-DockPanel-tabBar[data-orientation='horizontal'] {
+      flex: 1 1 auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/**
+    /**
  * Support for icons as inline SVG HTMLElements
  */
 
-/* recolor the primary elements of an icon */
-.jp-icon0[fill] {
-  fill: var(--jp-inverse-layout-color0);
-}
+    /* recolor the primary elements of an icon */
+    .jp-icon0[fill] {
+      fill: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon1[fill] {
-  fill: var(--jp-inverse-layout-color1);
-}
+    .jp-icon1[fill] {
+      fill: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon2[fill] {
-  fill: var(--jp-inverse-layout-color2);
-}
+    .jp-icon2[fill] {
+      fill: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon3[fill] {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .jp-icon3[fill] {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon4[fill] {
-  fill: var(--jp-inverse-layout-color4);
-}
+    .jp-icon4[fill] {
+      fill: var(--jp-inverse-layout-color4);
+    }
 
-.jp-icon0[stroke] {
-  stroke: var(--jp-inverse-layout-color0);
-}
+    .jp-icon0[stroke] {
+      stroke: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon1[stroke] {
-  stroke: var(--jp-inverse-layout-color1);
-}
+    .jp-icon1[stroke] {
+      stroke: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon2[stroke] {
-  stroke: var(--jp-inverse-layout-color2);
-}
+    .jp-icon2[stroke] {
+      stroke: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon3[stroke] {
-  stroke: var(--jp-inverse-layout-color3);
-}
+    .jp-icon3[stroke] {
+      stroke: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon4[stroke] {
-  stroke: var(--jp-inverse-layout-color4);
-}
+    .jp-icon4[stroke] {
+      stroke: var(--jp-inverse-layout-color4);
+    }
 
-/* recolor the accent elements of an icon */
-.jp-icon-accent0[fill] {
-  fill: var(--jp-layout-color0);
-}
+    /* recolor the accent elements of an icon */
+    .jp-icon-accent0[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.jp-icon-accent1[fill] {
-  fill: var(--jp-layout-color1);
-}
+    .jp-icon-accent1[fill] {
+      fill: var(--jp-layout-color1);
+    }
 
-.jp-icon-accent2[fill] {
-  fill: var(--jp-layout-color2);
-}
+    .jp-icon-accent2[fill] {
+      fill: var(--jp-layout-color2);
+    }
 
-.jp-icon-accent3[fill] {
-  fill: var(--jp-layout-color3);
-}
+    .jp-icon-accent3[fill] {
+      fill: var(--jp-layout-color3);
+    }
 
-.jp-icon-accent4[fill] {
-  fill: var(--jp-layout-color4);
-}
+    .jp-icon-accent4[fill] {
+      fill: var(--jp-layout-color4);
+    }
 
-.jp-icon-accent0[stroke] {
-  stroke: var(--jp-layout-color0);
-}
+    .jp-icon-accent0[stroke] {
+      stroke: var(--jp-layout-color0);
+    }
 
-.jp-icon-accent1[stroke] {
-  stroke: var(--jp-layout-color1);
-}
+    .jp-icon-accent1[stroke] {
+      stroke: var(--jp-layout-color1);
+    }
 
-.jp-icon-accent2[stroke] {
-  stroke: var(--jp-layout-color2);
-}
+    .jp-icon-accent2[stroke] {
+      stroke: var(--jp-layout-color2);
+    }
 
-.jp-icon-accent3[stroke] {
-  stroke: var(--jp-layout-color3);
-}
+    .jp-icon-accent3[stroke] {
+      stroke: var(--jp-layout-color3);
+    }
 
-.jp-icon-accent4[stroke] {
-  stroke: var(--jp-layout-color4);
-}
+    .jp-icon-accent4[stroke] {
+      stroke: var(--jp-layout-color4);
+    }
 
-/* set the color of an icon to transparent */
-.jp-icon-none[fill] {
-  fill: none;
-}
+    /* set the color of an icon to transparent */
+    .jp-icon-none[fill] {
+      fill: none;
+    }
 
-.jp-icon-none[stroke] {
-  stroke: none;
-}
+    .jp-icon-none[stroke] {
+      stroke: none;
+    }
 
-/* brand icon colors. Same for light and dark */
-.jp-icon-brand0[fill] {
-  fill: var(--jp-brand-color0);
-}
+    /* brand icon colors. Same for light and dark */
+    .jp-icon-brand0[fill] {
+      fill: var(--jp-brand-color0);
+    }
 
-.jp-icon-brand1[fill] {
-  fill: var(--jp-brand-color1);
-}
+    .jp-icon-brand1[fill] {
+      fill: var(--jp-brand-color1);
+    }
 
-.jp-icon-brand2[fill] {
-  fill: var(--jp-brand-color2);
-}
+    .jp-icon-brand2[fill] {
+      fill: var(--jp-brand-color2);
+    }
 
-.jp-icon-brand3[fill] {
-  fill: var(--jp-brand-color3);
-}
+    .jp-icon-brand3[fill] {
+      fill: var(--jp-brand-color3);
+    }
 
-.jp-icon-brand4[fill] {
-  fill: var(--jp-brand-color4);
-}
+    .jp-icon-brand4[fill] {
+      fill: var(--jp-brand-color4);
+    }
 
-.jp-icon-brand0[stroke] {
-  stroke: var(--jp-brand-color0);
-}
+    .jp-icon-brand0[stroke] {
+      stroke: var(--jp-brand-color0);
+    }
 
-.jp-icon-brand1[stroke] {
-  stroke: var(--jp-brand-color1);
-}
+    .jp-icon-brand1[stroke] {
+      stroke: var(--jp-brand-color1);
+    }
 
-.jp-icon-brand2[stroke] {
-  stroke: var(--jp-brand-color2);
-}
+    .jp-icon-brand2[stroke] {
+      stroke: var(--jp-brand-color2);
+    }
 
-.jp-icon-brand3[stroke] {
-  stroke: var(--jp-brand-color3);
-}
+    .jp-icon-brand3[stroke] {
+      stroke: var(--jp-brand-color3);
+    }
 
-.jp-icon-brand4[stroke] {
-  stroke: var(--jp-brand-color4);
-}
+    .jp-icon-brand4[stroke] {
+      stroke: var(--jp-brand-color4);
+    }
 
-/* warn icon colors. Same for light and dark */
-.jp-icon-warn0[fill] {
-  fill: var(--jp-warn-color0);
-}
+    /* warn icon colors. Same for light and dark */
+    .jp-icon-warn0[fill] {
+      fill: var(--jp-warn-color0);
+    }
 
-.jp-icon-warn1[fill] {
-  fill: var(--jp-warn-color1);
-}
+    .jp-icon-warn1[fill] {
+      fill: var(--jp-warn-color1);
+    }
 
-.jp-icon-warn2[fill] {
-  fill: var(--jp-warn-color2);
-}
+    .jp-icon-warn2[fill] {
+      fill: var(--jp-warn-color2);
+    }
 
-.jp-icon-warn3[fill] {
-  fill: var(--jp-warn-color3);
-}
+    .jp-icon-warn3[fill] {
+      fill: var(--jp-warn-color3);
+    }
 
-.jp-icon-warn0[stroke] {
-  stroke: var(--jp-warn-color0);
-}
+    .jp-icon-warn0[stroke] {
+      stroke: var(--jp-warn-color0);
+    }
 
-.jp-icon-warn1[stroke] {
-  stroke: var(--jp-warn-color1);
-}
+    .jp-icon-warn1[stroke] {
+      stroke: var(--jp-warn-color1);
+    }
 
-.jp-icon-warn2[stroke] {
-  stroke: var(--jp-warn-color2);
-}
+    .jp-icon-warn2[stroke] {
+      stroke: var(--jp-warn-color2);
+    }
 
-.jp-icon-warn3[stroke] {
-  stroke: var(--jp-warn-color3);
-}
+    .jp-icon-warn3[stroke] {
+      stroke: var(--jp-warn-color3);
+    }
 
-/* icon colors that contrast well with each other and most backgrounds */
-.jp-icon-contrast0[fill] {
-  fill: var(--jp-icon-contrast-color0);
-}
+    /* icon colors that contrast well with each other and most backgrounds */
+    .jp-icon-contrast0[fill] {
+      fill: var(--jp-icon-contrast-color0);
+    }
 
-.jp-icon-contrast1[fill] {
-  fill: var(--jp-icon-contrast-color1);
-}
+    .jp-icon-contrast1[fill] {
+      fill: var(--jp-icon-contrast-color1);
+    }
 
-.jp-icon-contrast2[fill] {
-  fill: var(--jp-icon-contrast-color2);
-}
+    .jp-icon-contrast2[fill] {
+      fill: var(--jp-icon-contrast-color2);
+    }
 
-.jp-icon-contrast3[fill] {
-  fill: var(--jp-icon-contrast-color3);
-}
+    .jp-icon-contrast3[fill] {
+      fill: var(--jp-icon-contrast-color3);
+    }
 
-.jp-icon-contrast0[stroke] {
-  stroke: var(--jp-icon-contrast-color0);
-}
+    .jp-icon-contrast0[stroke] {
+      stroke: var(--jp-icon-contrast-color0);
+    }
 
-.jp-icon-contrast1[stroke] {
-  stroke: var(--jp-icon-contrast-color1);
-}
+    .jp-icon-contrast1[stroke] {
+      stroke: var(--jp-icon-contrast-color1);
+    }
 
-.jp-icon-contrast2[stroke] {
-  stroke: var(--jp-icon-contrast-color2);
-}
+    .jp-icon-contrast2[stroke] {
+      stroke: var(--jp-icon-contrast-color2);
+    }
 
-.jp-icon-contrast3[stroke] {
-  stroke: var(--jp-icon-contrast-color3);
-}
+    .jp-icon-contrast3[stroke] {
+      stroke: var(--jp-icon-contrast-color3);
+    }
 
-.jp-icon-dot[fill] {
-  fill: var(--jp-warn-color0);
-}
+    .jp-icon-dot[fill] {
+      fill: var(--jp-warn-color0);
+    }
 
-.jp-jupyter-icon-color[fill] {
-  fill: var(--jp-jupyter-icon-color, var(--jp-warn-color0));
-}
+    .jp-jupyter-icon-color[fill] {
+      fill: var(--jp-jupyter-icon-color, var(--jp-warn-color0));
+    }
 
-.jp-notebook-icon-color[fill] {
-  fill: var(--jp-notebook-icon-color, var(--jp-warn-color0));
-}
+    .jp-notebook-icon-color[fill] {
+      fill: var(--jp-notebook-icon-color, var(--jp-warn-color0));
+    }
 
-.jp-json-icon-color[fill] {
-  fill: var(--jp-json-icon-color, var(--jp-warn-color1));
-}
+    .jp-json-icon-color[fill] {
+      fill: var(--jp-json-icon-color, var(--jp-warn-color1));
+    }
 
-.jp-console-icon-color[fill] {
-  fill: var(--jp-console-icon-color, white);
-}
+    .jp-console-icon-color[fill] {
+      fill: var(--jp-console-icon-color, white);
+    }
 
-.jp-console-icon-background-color[fill] {
-  fill: var(--jp-console-icon-background-color, var(--jp-brand-color1));
-}
+    .jp-console-icon-background-color[fill] {
+      fill: var(--jp-console-icon-background-color, var(--jp-brand-color1));
+    }
 
-.jp-terminal-icon-color[fill] {
-  fill: var(--jp-terminal-icon-color, var(--jp-layout-color2));
-}
+    .jp-terminal-icon-color[fill] {
+      fill: var(--jp-terminal-icon-color, var(--jp-layout-color2));
+    }
 
-.jp-terminal-icon-background-color[fill] {
-  fill: var(
-    --jp-terminal-icon-background-color,
-    var(--jp-inverse-layout-color2)
-  );
-}
+    .jp-terminal-icon-background-color[fill] {
+      fill: var(--jp-terminal-icon-background-color,
+          var(--jp-inverse-layout-color2));
+    }
 
-.jp-text-editor-icon-color[fill] {
-  fill: var(--jp-text-editor-icon-color, var(--jp-inverse-layout-color3));
-}
+    .jp-text-editor-icon-color[fill] {
+      fill: var(--jp-text-editor-icon-color, var(--jp-inverse-layout-color3));
+    }
 
-.jp-inspector-icon-color[fill] {
-  fill: var(--jp-inspector-icon-color, var(--jp-inverse-layout-color3));
-}
+    .jp-inspector-icon-color[fill] {
+      fill: var(--jp-inspector-icon-color, var(--jp-inverse-layout-color3));
+    }
 
-/* CSS for icons in selected filebrowser listing items */
-.jp-DirListing-item.jp-mod-selected .jp-icon-selectable[fill] {
-  fill: #fff;
-}
+    /* CSS for icons in selected filebrowser listing items */
+    .jp-DirListing-item.jp-mod-selected .jp-icon-selectable[fill] {
+      fill: #fff;
+    }
 
-.jp-DirListing-item.jp-mod-selected .jp-icon-selectable-inverse[fill] {
-  fill: var(--jp-brand-color1);
-}
+    .jp-DirListing-item.jp-mod-selected .jp-icon-selectable-inverse[fill] {
+      fill: var(--jp-brand-color1);
+    }
 
-/* stylelint-disable selector-max-class, selector-max-compound-selectors */
+    /* stylelint-disable selector-max-class, selector-max-compound-selectors */
 
-/**
+    /**
 * TODO: come up with non css-hack solution for showing the busy icon on top
 *  of the close icon
 * CSS for complex behavior of close icon of tabs in the main area tabbar
 */
-.lm-DockPanel-tabBar
-  .lm-TabBar-tab.lm-mod-closable.jp-mod-dirty
-  > .lm-TabBar-tabCloseIcon
-  > :not(:hover)
-  > .jp-icon3[fill] {
-  fill: none;
-}
+    .lm-DockPanel-tabBar .lm-TabBar-tab.lm-mod-closable.jp-mod-dirty>.lm-TabBar-tabCloseIcon> :not(:hover)>.jp-icon3[fill] {
+      fill: none;
+    }
 
-.lm-DockPanel-tabBar
-  .lm-TabBar-tab.lm-mod-closable.jp-mod-dirty
-  > .lm-TabBar-tabCloseIcon
-  > :not(:hover)
-  > .jp-icon-busy[fill] {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .lm-DockPanel-tabBar .lm-TabBar-tab.lm-mod-closable.jp-mod-dirty>.lm-TabBar-tabCloseIcon> :not(:hover)>.jp-icon-busy[fill] {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-/* stylelint-enable selector-max-class, selector-max-compound-selectors */
+    /* stylelint-enable selector-max-class, selector-max-compound-selectors */
 
-/* CSS for icons in status bar */
-#jp-main-statusbar .jp-mod-selected .jp-icon-selectable[fill] {
-  fill: #fff;
-}
+    /* CSS for icons in status bar */
+    #jp-main-statusbar .jp-mod-selected .jp-icon-selectable[fill] {
+      fill: #fff;
+    }
 
-#jp-main-statusbar .jp-mod-selected .jp-icon-selectable-inverse[fill] {
-  fill: var(--jp-brand-color1);
-}
+    #jp-main-statusbar .jp-mod-selected .jp-icon-selectable-inverse[fill] {
+      fill: var(--jp-brand-color1);
+    }
 
-/* special handling for splash icon CSS. While the theme CSS reloads during
+    /* special handling for splash icon CSS. While the theme CSS reloads during
    splash, the splash icon can loose theming. To prevent that, we set a
    default for its color variable */
-:root {
-  --jp-warn-color0: var(--md-orange-700);
-}
+    :root {
+      --jp-warn-color0: var(--md-orange-700);
+    }
 
-/* not sure what to do with this one, used in filebrowser listing */
-.jp-DragIcon {
-  margin-right: 4px;
-}
+    /* not sure what to do with this one, used in filebrowser listing */
+    .jp-DragIcon {
+      margin-right: 4px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/**
+    /**
  * Support for alt colors for icons as inline SVG HTMLElements
  */
 
-/* alt recolor the primary elements of an icon */
-.jp-icon-alt .jp-icon0[fill] {
-  fill: var(--jp-layout-color0);
-}
+    /* alt recolor the primary elements of an icon */
+    .jp-icon-alt .jp-icon0[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.jp-icon-alt .jp-icon1[fill] {
-  fill: var(--jp-layout-color1);
-}
+    .jp-icon-alt .jp-icon1[fill] {
+      fill: var(--jp-layout-color1);
+    }
 
-.jp-icon-alt .jp-icon2[fill] {
-  fill: var(--jp-layout-color2);
-}
+    .jp-icon-alt .jp-icon2[fill] {
+      fill: var(--jp-layout-color2);
+    }
 
-.jp-icon-alt .jp-icon3[fill] {
-  fill: var(--jp-layout-color3);
-}
+    .jp-icon-alt .jp-icon3[fill] {
+      fill: var(--jp-layout-color3);
+    }
 
-.jp-icon-alt .jp-icon4[fill] {
-  fill: var(--jp-layout-color4);
-}
+    .jp-icon-alt .jp-icon4[fill] {
+      fill: var(--jp-layout-color4);
+    }
 
-.jp-icon-alt .jp-icon0[stroke] {
-  stroke: var(--jp-layout-color0);
-}
+    .jp-icon-alt .jp-icon0[stroke] {
+      stroke: var(--jp-layout-color0);
+    }
 
-.jp-icon-alt .jp-icon1[stroke] {
-  stroke: var(--jp-layout-color1);
-}
+    .jp-icon-alt .jp-icon1[stroke] {
+      stroke: var(--jp-layout-color1);
+    }
 
-.jp-icon-alt .jp-icon2[stroke] {
-  stroke: var(--jp-layout-color2);
-}
+    .jp-icon-alt .jp-icon2[stroke] {
+      stroke: var(--jp-layout-color2);
+    }
 
-.jp-icon-alt .jp-icon3[stroke] {
-  stroke: var(--jp-layout-color3);
-}
+    .jp-icon-alt .jp-icon3[stroke] {
+      stroke: var(--jp-layout-color3);
+    }
 
-.jp-icon-alt .jp-icon4[stroke] {
-  stroke: var(--jp-layout-color4);
-}
+    .jp-icon-alt .jp-icon4[stroke] {
+      stroke: var(--jp-layout-color4);
+    }
 
-/* alt recolor the accent elements of an icon */
-.jp-icon-alt .jp-icon-accent0[fill] {
-  fill: var(--jp-inverse-layout-color0);
-}
+    /* alt recolor the accent elements of an icon */
+    .jp-icon-alt .jp-icon-accent0[fill] {
+      fill: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-alt .jp-icon-accent1[fill] {
-  fill: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-alt .jp-icon-accent1[fill] {
+      fill: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-alt .jp-icon-accent2[fill] {
-  fill: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-alt .jp-icon-accent2[fill] {
+      fill: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-alt .jp-icon-accent3[fill] {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-alt .jp-icon-accent3[fill] {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-alt .jp-icon-accent4[fill] {
-  fill: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-alt .jp-icon-accent4[fill] {
+      fill: var(--jp-inverse-layout-color4);
+    }
 
-.jp-icon-alt .jp-icon-accent0[stroke] {
-  stroke: var(--jp-inverse-layout-color0);
-}
+    .jp-icon-alt .jp-icon-accent0[stroke] {
+      stroke: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-alt .jp-icon-accent1[stroke] {
-  stroke: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-alt .jp-icon-accent1[stroke] {
+      stroke: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-alt .jp-icon-accent2[stroke] {
-  stroke: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-alt .jp-icon-accent2[stroke] {
+      stroke: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-alt .jp-icon-accent3[stroke] {
-  stroke: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-alt .jp-icon-accent3[stroke] {
+      stroke: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-alt .jp-icon-accent4[stroke] {
-  stroke: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-alt .jp-icon-accent4[stroke] {
+      stroke: var(--jp-inverse-layout-color4);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-icon-hoverShow:not(:hover) .jp-icon-hoverShow-content {
-  display: none !important;
-}
+    .jp-icon-hoverShow:not(:hover) .jp-icon-hoverShow-content {
+      display: none !important;
+    }
 
-/**
+    /**
  * Support for hover colors for icons as inline SVG HTMLElements
  */
 
-/**
+    /**
  * regular colors
  */
 
-/* recolor the primary elements of an icon */
-.jp-icon-hover :hover .jp-icon0-hover[fill] {
-  fill: var(--jp-inverse-layout-color0);
-}
+    /* recolor the primary elements of an icon */
+    .jp-icon-hover :hover .jp-icon0-hover[fill] {
+      fill: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-hover :hover .jp-icon1-hover[fill] {
-  fill: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-hover :hover .jp-icon1-hover[fill] {
+      fill: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-hover :hover .jp-icon2-hover[fill] {
-  fill: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-hover :hover .jp-icon2-hover[fill] {
+      fill: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-hover :hover .jp-icon3-hover[fill] {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-hover :hover .jp-icon3-hover[fill] {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-hover :hover .jp-icon4-hover[fill] {
-  fill: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-hover :hover .jp-icon4-hover[fill] {
+      fill: var(--jp-inverse-layout-color4);
+    }
 
-.jp-icon-hover :hover .jp-icon0-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color0);
-}
+    .jp-icon-hover :hover .jp-icon0-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-hover :hover .jp-icon1-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-hover :hover .jp-icon1-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-hover :hover .jp-icon2-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-hover :hover .jp-icon2-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-hover :hover .jp-icon3-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-hover :hover .jp-icon3-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-hover :hover .jp-icon4-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-hover :hover .jp-icon4-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color4);
+    }
 
-/* recolor the accent elements of an icon */
-.jp-icon-hover :hover .jp-icon-accent0-hover[fill] {
-  fill: var(--jp-layout-color0);
-}
+    /* recolor the accent elements of an icon */
+    .jp-icon-hover :hover .jp-icon-accent0-hover[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent1-hover[fill] {
-  fill: var(--jp-layout-color1);
-}
+    .jp-icon-hover :hover .jp-icon-accent1-hover[fill] {
+      fill: var(--jp-layout-color1);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent2-hover[fill] {
-  fill: var(--jp-layout-color2);
-}
+    .jp-icon-hover :hover .jp-icon-accent2-hover[fill] {
+      fill: var(--jp-layout-color2);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent3-hover[fill] {
-  fill: var(--jp-layout-color3);
-}
+    .jp-icon-hover :hover .jp-icon-accent3-hover[fill] {
+      fill: var(--jp-layout-color3);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent4-hover[fill] {
-  fill: var(--jp-layout-color4);
-}
+    .jp-icon-hover :hover .jp-icon-accent4-hover[fill] {
+      fill: var(--jp-layout-color4);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent0-hover[stroke] {
-  stroke: var(--jp-layout-color0);
-}
+    .jp-icon-hover :hover .jp-icon-accent0-hover[stroke] {
+      stroke: var(--jp-layout-color0);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent1-hover[stroke] {
-  stroke: var(--jp-layout-color1);
-}
+    .jp-icon-hover :hover .jp-icon-accent1-hover[stroke] {
+      stroke: var(--jp-layout-color1);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent2-hover[stroke] {
-  stroke: var(--jp-layout-color2);
-}
+    .jp-icon-hover :hover .jp-icon-accent2-hover[stroke] {
+      stroke: var(--jp-layout-color2);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent3-hover[stroke] {
-  stroke: var(--jp-layout-color3);
-}
+    .jp-icon-hover :hover .jp-icon-accent3-hover[stroke] {
+      stroke: var(--jp-layout-color3);
+    }
 
-.jp-icon-hover :hover .jp-icon-accent4-hover[stroke] {
-  stroke: var(--jp-layout-color4);
-}
+    .jp-icon-hover :hover .jp-icon-accent4-hover[stroke] {
+      stroke: var(--jp-layout-color4);
+    }
 
-/* set the color of an icon to transparent */
-.jp-icon-hover :hover .jp-icon-none-hover[fill] {
-  fill: none;
-}
+    /* set the color of an icon to transparent */
+    .jp-icon-hover :hover .jp-icon-none-hover[fill] {
+      fill: none;
+    }
 
-.jp-icon-hover :hover .jp-icon-none-hover[stroke] {
-  stroke: none;
-}
+    .jp-icon-hover :hover .jp-icon-none-hover[stroke] {
+      stroke: none;
+    }
 
-/**
+    /**
  * inverse colors
  */
 
-/* inverse recolor the primary elements of an icon */
-.jp-icon-hover.jp-icon-alt :hover .jp-icon0-hover[fill] {
-  fill: var(--jp-layout-color0);
-}
+    /* inverse recolor the primary elements of an icon */
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon0-hover[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon1-hover[fill] {
-  fill: var(--jp-layout-color1);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon1-hover[fill] {
+      fill: var(--jp-layout-color1);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon2-hover[fill] {
-  fill: var(--jp-layout-color2);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon2-hover[fill] {
+      fill: var(--jp-layout-color2);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon3-hover[fill] {
-  fill: var(--jp-layout-color3);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon3-hover[fill] {
+      fill: var(--jp-layout-color3);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon4-hover[fill] {
-  fill: var(--jp-layout-color4);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon4-hover[fill] {
+      fill: var(--jp-layout-color4);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon0-hover[stroke] {
-  stroke: var(--jp-layout-color0);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon0-hover[stroke] {
+      stroke: var(--jp-layout-color0);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon1-hover[stroke] {
-  stroke: var(--jp-layout-color1);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon1-hover[stroke] {
+      stroke: var(--jp-layout-color1);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon2-hover[stroke] {
-  stroke: var(--jp-layout-color2);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon2-hover[stroke] {
+      stroke: var(--jp-layout-color2);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon3-hover[stroke] {
-  stroke: var(--jp-layout-color3);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon3-hover[stroke] {
+      stroke: var(--jp-layout-color3);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon4-hover[stroke] {
-  stroke: var(--jp-layout-color4);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon4-hover[stroke] {
+      stroke: var(--jp-layout-color4);
+    }
 
-/* inverse recolor the accent elements of an icon */
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent0-hover[fill] {
-  fill: var(--jp-inverse-layout-color0);
-}
+    /* inverse recolor the accent elements of an icon */
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent0-hover[fill] {
+      fill: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent1-hover[fill] {
-  fill: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent1-hover[fill] {
+      fill: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent2-hover[fill] {
-  fill: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent2-hover[fill] {
+      fill: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent3-hover[fill] {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent3-hover[fill] {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent4-hover[fill] {
-  fill: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent4-hover[fill] {
+      fill: var(--jp-inverse-layout-color4);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent0-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color0);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent0-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color0);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent1-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color1);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent1-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color1);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent2-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color2);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent2-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color2);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent3-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color3);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent3-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color3);
+    }
 
-.jp-icon-hover.jp-icon-alt :hover .jp-icon-accent4-hover[stroke] {
-  stroke: var(--jp-inverse-layout-color4);
-}
+    .jp-icon-hover.jp-icon-alt :hover .jp-icon-accent4-hover[stroke] {
+      stroke: var(--jp-inverse-layout-color4);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-IFrame {
-  width: 100%;
-  height: 100%;
-}
+    .jp-IFrame {
+      width: 100%;
+      height: 100%;
+    }
 
-.jp-IFrame > iframe {
-  border: none;
-}
+    .jp-IFrame>iframe {
+      border: none;
+    }
 
-/*
+    /*
 When drag events occur, `lm-mod-override-cursor` is added to the body.
 Because iframes steal all cursor events, the following two rules are necessary
 to suppress pointer events while resize drags are occurring. There may be a
 better solution to this problem.
 */
-body.lm-mod-override-cursor .jp-IFrame {
-  position: relative;
-}
+    body.lm-mod-override-cursor .jp-IFrame {
+      position: relative;
+    }
 
-body.lm-mod-override-cursor .jp-IFrame::before {
-  content: '';
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: transparent;
-}
+    body.lm-mod-override-cursor .jp-IFrame::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: transparent;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2016, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-HoverBox {
-  position: fixed;
-}
+    .jp-HoverBox {
+      position: fixed;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-FormGroup-content fieldset {
-  border: none;
-  padding: 0;
-  min-width: 0;
-  width: 100%;
-}
+    .jp-FormGroup-content fieldset {
+      border: none;
+      padding: 0;
+      min-width: 0;
+      width: 100%;
+    }
 
-/* stylelint-disable selector-max-type */
+    /* stylelint-disable selector-max-type */
 
-.jp-FormGroup-content fieldset .jp-inputFieldWrapper input,
-.jp-FormGroup-content fieldset .jp-inputFieldWrapper select,
-.jp-FormGroup-content fieldset .jp-inputFieldWrapper textarea {
-  font-size: var(--jp-content-font-size2);
-  border-color: var(--jp-input-border-color);
-  border-style: solid;
-  border-radius: var(--jp-border-radius);
-  border-width: 1px;
-  padding: 6px 8px;
-  background: none;
-  color: var(--jp-ui-font-color0);
-  height: inherit;
-}
+    .jp-FormGroup-content fieldset .jp-inputFieldWrapper input,
+    .jp-FormGroup-content fieldset .jp-inputFieldWrapper select,
+    .jp-FormGroup-content fieldset .jp-inputFieldWrapper textarea {
+      font-size: var(--jp-content-font-size2);
+      border-color: var(--jp-input-border-color);
+      border-style: solid;
+      border-radius: var(--jp-border-radius);
+      border-width: 1px;
+      padding: 6px 8px;
+      background: none;
+      color: var(--jp-ui-font-color0);
+      height: inherit;
+    }
 
-.jp-FormGroup-content fieldset input[type='checkbox'] {
-  position: relative;
-  top: 2px;
-  margin-left: 0;
-}
+    .jp-FormGroup-content fieldset input[type='checkbox'] {
+      position: relative;
+      top: 2px;
+      margin-left: 0;
+    }
 
-.jp-FormGroup-content button.jp-mod-styled {
-  cursor: pointer;
-}
+    .jp-FormGroup-content button.jp-mod-styled {
+      cursor: pointer;
+    }
 
-.jp-FormGroup-content .checkbox label {
-  cursor: pointer;
-  font-size: var(--jp-content-font-size1);
-}
+    .jp-FormGroup-content .checkbox label {
+      cursor: pointer;
+      font-size: var(--jp-content-font-size1);
+    }
 
-.jp-FormGroup-content .jp-root > fieldset > legend {
-  display: none;
-}
+    .jp-FormGroup-content .jp-root>fieldset>legend {
+      display: none;
+    }
 
-.jp-FormGroup-content .jp-root > fieldset > p {
-  display: none;
-}
+    .jp-FormGroup-content .jp-root>fieldset>p {
+      display: none;
+    }
 
-/** copy of `input.jp-mod-styled:focus` style */
-.jp-FormGroup-content fieldset input:focus,
-.jp-FormGroup-content fieldset select:focus {
-  -moz-outline-radius: unset;
-  outline: var(--jp-border-width) solid var(--md-blue-500);
-  outline-offset: -1px;
-  box-shadow: inset 0 0 4px var(--md-blue-300);
-}
+    /** copy of `input.jp-mod-styled:focus` style */
+    .jp-FormGroup-content fieldset input:focus,
+    .jp-FormGroup-content fieldset select:focus {
+      -moz-outline-radius: unset;
+      outline: var(--jp-border-width) solid var(--md-blue-500);
+      outline-offset: -1px;
+      box-shadow: inset 0 0 4px var(--md-blue-300);
+    }
 
-.jp-FormGroup-content fieldset input:hover:not(:focus),
-.jp-FormGroup-content fieldset select:hover:not(:focus) {
-  background-color: var(--jp-border-color2);
-}
+    .jp-FormGroup-content fieldset input:hover:not(:focus),
+    .jp-FormGroup-content fieldset select:hover:not(:focus) {
+      background-color: var(--jp-border-color2);
+    }
 
-/* stylelint-enable selector-max-type */
+    /* stylelint-enable selector-max-type */
 
-.jp-FormGroup-content .checkbox .field-description {
-  /* Disable default description field for checkbox:
+    .jp-FormGroup-content .checkbox .field-description {
+      /* Disable default description field for checkbox:
    because other widgets do not have description fields,
    we add descriptions to each widget on the field level.
   */
-  display: none;
-}
+      display: none;
+    }
 
-.jp-FormGroup-content #root__description {
-  display: none;
-}
+    .jp-FormGroup-content #root__description {
+      display: none;
+    }
 
-.jp-FormGroup-content .jp-modifiedIndicator {
-  width: 5px;
-  background-color: var(--jp-brand-color2);
-  margin-top: 0;
-  margin-left: calc(var(--jp-private-settingeditor-modifier-indent) * -1);
-  flex-shrink: 0;
-}
+    .jp-FormGroup-content .jp-modifiedIndicator {
+      width: 5px;
+      background-color: var(--jp-brand-color2);
+      margin-top: 0;
+      margin-left: calc(var(--jp-private-settingeditor-modifier-indent) * -1);
+      flex-shrink: 0;
+    }
 
-.jp-FormGroup-content .jp-modifiedIndicator.jp-errorIndicator {
-  background-color: var(--jp-error-color0);
-  margin-right: 0.5em;
-}
+    .jp-FormGroup-content .jp-modifiedIndicator.jp-errorIndicator {
+      background-color: var(--jp-error-color0);
+      margin-right: 0.5em;
+    }
 
-/* RJSF ARRAY style */
+    /* RJSF ARRAY style */
 
-.jp-arrayFieldWrapper legend {
-  font-size: var(--jp-content-font-size2);
-  color: var(--jp-ui-font-color0);
-  flex-basis: 100%;
-  padding: 4px 0;
-  font-weight: var(--jp-content-heading-font-weight);
-  border-bottom: 1px solid var(--jp-border-color2);
-}
+    .jp-arrayFieldWrapper legend {
+      font-size: var(--jp-content-font-size2);
+      color: var(--jp-ui-font-color0);
+      flex-basis: 100%;
+      padding: 4px 0;
+      font-weight: var(--jp-content-heading-font-weight);
+      border-bottom: 1px solid var(--jp-border-color2);
+    }
 
-.jp-arrayFieldWrapper .field-description {
-  padding: 4px 0;
-  white-space: pre-wrap;
-}
+    .jp-arrayFieldWrapper .field-description {
+      padding: 4px 0;
+      white-space: pre-wrap;
+    }
 
-.jp-arrayFieldWrapper .array-item {
-  width: 100%;
-  border: 1px solid var(--jp-border-color2);
-  border-radius: 4px;
-  margin: 4px;
-}
+    .jp-arrayFieldWrapper .array-item {
+      width: 100%;
+      border: 1px solid var(--jp-border-color2);
+      border-radius: 4px;
+      margin: 4px;
+    }
 
-.jp-ArrayOperations {
-  display: flex;
-  margin-left: 8px;
-}
+    .jp-ArrayOperations {
+      display: flex;
+      margin-left: 8px;
+    }
 
-.jp-ArrayOperationsButton {
-  margin: 2px;
-}
+    .jp-ArrayOperationsButton {
+      margin: 2px;
+    }
 
-.jp-ArrayOperationsButton .jp-icon3[fill] {
-  fill: var(--jp-ui-font-color0);
-}
+    .jp-ArrayOperationsButton .jp-icon3[fill] {
+      fill: var(--jp-ui-font-color0);
+    }
 
-button.jp-ArrayOperationsButton.jp-mod-styled:disabled {
-  cursor: not-allowed;
-  opacity: 0.5;
-}
+    button.jp-ArrayOperationsButton.jp-mod-styled:disabled {
+      cursor: not-allowed;
+      opacity: 0.5;
+    }
 
-/* RJSF form validation error */
+    /* RJSF form validation error */
 
-.jp-FormGroup-content .validationErrors {
-  color: var(--jp-error-color0);
-}
+    .jp-FormGroup-content .validationErrors {
+      color: var(--jp-error-color0);
+    }
 
-/* Hide panel level error as duplicated the field level error */
-.jp-FormGroup-content .panel.errors {
-  display: none;
-}
+    /* Hide panel level error as duplicated the field level error */
+    .jp-FormGroup-content .panel.errors {
+      display: none;
+    }
 
-/* RJSF normal content (settings-editor) */
+    /* RJSF normal content (settings-editor) */
 
-.jp-FormGroup-contentNormal {
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-}
+    .jp-FormGroup-contentNormal {
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+    }
 
-.jp-FormGroup-contentNormal .jp-FormGroup-contentItem {
-  margin-left: 7px;
-  color: var(--jp-ui-font-color0);
-}
+    .jp-FormGroup-contentNormal .jp-FormGroup-contentItem {
+      margin-left: 7px;
+      color: var(--jp-ui-font-color0);
+    }
 
-.jp-FormGroup-contentNormal .jp-FormGroup-description {
-  flex-basis: 100%;
-  padding: 4px 7px;
-}
+    .jp-FormGroup-contentNormal .jp-FormGroup-description {
+      flex-basis: 100%;
+      padding: 4px 7px;
+    }
 
-.jp-FormGroup-contentNormal .jp-FormGroup-default {
-  flex-basis: 100%;
-  padding: 4px 7px;
-}
+    .jp-FormGroup-contentNormal .jp-FormGroup-default {
+      flex-basis: 100%;
+      padding: 4px 7px;
+    }
 
-.jp-FormGroup-contentNormal .jp-FormGroup-fieldLabel {
-  font-size: var(--jp-content-font-size1);
-  font-weight: normal;
-  min-width: 120px;
-}
+    .jp-FormGroup-contentNormal .jp-FormGroup-fieldLabel {
+      font-size: var(--jp-content-font-size1);
+      font-weight: normal;
+      min-width: 120px;
+    }
 
-.jp-FormGroup-contentNormal fieldset:not(:first-child) {
-  margin-left: 7px;
-}
+    .jp-FormGroup-contentNormal fieldset:not(:first-child) {
+      margin-left: 7px;
+    }
 
-.jp-FormGroup-contentNormal .field-array-of-string .array-item {
-  /* Display `jp-ArrayOperations` buttons side-by-side with content except
+    .jp-FormGroup-contentNormal .field-array-of-string .array-item {
+      /* Display `jp-ArrayOperations` buttons side-by-side with content except
     for small screens where flex-wrap will place them one below the other.
   */
-  display: flex;
-  align-items: center;
-  flex-wrap: wrap;
-}
+      display: flex;
+      align-items: center;
+      flex-wrap: wrap;
+    }
 
-.jp-FormGroup-contentNormal .jp-objectFieldWrapper .form-group {
-  padding: 2px 8px 2px var(--jp-private-settingeditor-modifier-indent);
-  margin-top: 2px;
-}
+    .jp-FormGroup-contentNormal .jp-objectFieldWrapper .form-group {
+      padding: 2px 8px 2px var(--jp-private-settingeditor-modifier-indent);
+      margin-top: 2px;
+    }
 
-/* RJSF compact content (metadata-form) */
+    /* RJSF compact content (metadata-form) */
 
-.jp-FormGroup-content.jp-FormGroup-contentCompact {
-  width: 100%;
-}
+    .jp-FormGroup-content.jp-FormGroup-contentCompact {
+      width: 100%;
+    }
 
-.jp-FormGroup-contentCompact .form-group {
-  display: flex;
-  padding: 0.5em 0.2em 0.5em 0;
-}
+    .jp-FormGroup-contentCompact .form-group {
+      display: flex;
+      padding: 0.5em 0.2em 0.5em 0;
+    }
 
-.jp-FormGroup-contentCompact
-  .jp-FormGroup-compactTitle
-  .jp-FormGroup-description {
-  font-size: var(--jp-ui-font-size1);
-  color: var(--jp-ui-font-color2);
-}
+    .jp-FormGroup-contentCompact .jp-FormGroup-compactTitle .jp-FormGroup-description {
+      font-size: var(--jp-ui-font-size1);
+      color: var(--jp-ui-font-color2);
+    }
 
-.jp-FormGroup-contentCompact .jp-FormGroup-fieldLabel {
-  padding-bottom: 0.3em;
-}
+    .jp-FormGroup-contentCompact .jp-FormGroup-fieldLabel {
+      padding-bottom: 0.3em;
+    }
 
-.jp-FormGroup-contentCompact .jp-inputFieldWrapper .form-control {
-  width: 100%;
-  box-sizing: border-box;
-}
+    .jp-FormGroup-contentCompact .jp-inputFieldWrapper .form-control {
+      width: 100%;
+      box-sizing: border-box;
+    }
 
-.jp-FormGroup-contentCompact .jp-arrayFieldWrapper .jp-FormGroup-compactTitle {
-  padding-bottom: 7px;
-}
+    .jp-FormGroup-contentCompact .jp-arrayFieldWrapper .jp-FormGroup-compactTitle {
+      padding-bottom: 7px;
+    }
 
-.jp-FormGroup-contentCompact
-  .jp-objectFieldWrapper
-  .jp-objectFieldWrapper
-  .form-group {
-  padding: 2px 8px 2px var(--jp-private-settingeditor-modifier-indent);
-  margin-top: 2px;
-}
+    .jp-FormGroup-contentCompact .jp-objectFieldWrapper .jp-objectFieldWrapper .form-group {
+      padding: 2px 8px 2px var(--jp-private-settingeditor-modifier-indent);
+      margin-top: 2px;
+    }
 
-.jp-FormGroup-contentCompact ul.error-detail {
-  margin-block-start: 0.5em;
-  margin-block-end: 0.5em;
-  padding-inline-start: 1em;
-}
+    .jp-FormGroup-contentCompact ul.error-detail {
+      margin-block-start: 0.5em;
+      margin-block-end: 0.5em;
+      padding-inline-start: 1em;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.jp-SidePanel {
-  display: flex;
-  flex-direction: column;
-  min-width: var(--jp-sidebar-min-width);
-  overflow-y: auto;
-  color: var(--jp-ui-font-color1);
-  background: var(--jp-layout-color1);
-  font-size: var(--jp-ui-font-size1);
-}
+    .jp-SidePanel {
+      display: flex;
+      flex-direction: column;
+      min-width: var(--jp-sidebar-min-width);
+      overflow-y: auto;
+      color: var(--jp-ui-font-color1);
+      background: var(--jp-layout-color1);
+      font-size: var(--jp-ui-font-size1);
+    }
 
-.jp-SidePanel-header {
-  flex: 0 0 auto;
-  display: flex;
-  border-bottom: var(--jp-border-width) solid var(--jp-border-color2);
-  font-size: var(--jp-ui-font-size0);
-  font-weight: 600;
-  letter-spacing: 1px;
-  margin: 0;
-  padding: 2px;
-  text-transform: uppercase;
-}
+    .jp-SidePanel-header {
+      flex: 0 0 auto;
+      display: flex;
+      border-bottom: var(--jp-border-width) solid var(--jp-border-color2);
+      font-size: var(--jp-ui-font-size0);
+      font-weight: 600;
+      letter-spacing: 1px;
+      margin: 0;
+      padding: 2px;
+      text-transform: uppercase;
+    }
 
-.jp-SidePanel-toolbar {
-  flex: 0 0 auto;
-}
+    .jp-SidePanel-toolbar {
+      flex: 0 0 auto;
+    }
 
-.jp-SidePanel-content {
-  flex: 1 1 auto;
-}
+    .jp-SidePanel-content {
+      flex: 1 1 auto;
+    }
 
-.jp-SidePanel-toolbar,
-.jp-AccordionPanel-toolbar {
-  height: var(--jp-private-toolbar-height);
-}
+    .jp-SidePanel-toolbar,
+    .jp-AccordionPanel-toolbar {
+      height: var(--jp-private-toolbar-height);
+    }
 
-.jp-SidePanel-toolbar.jp-Toolbar-micro {
-  display: none;
-}
+    .jp-SidePanel-toolbar.jp-Toolbar-micro {
+      display: none;
+    }
 
-.lm-AccordionPanel .jp-AccordionPanel-title {
-  box-sizing: border-box;
-  line-height: 25px;
-  margin: 0;
-  display: flex;
-  align-items: center;
-  background: var(--jp-layout-color1);
-  color: var(--jp-ui-font-color1);
-  border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
-  box-shadow: var(--jp-toolbar-box-shadow);
-  font-size: var(--jp-ui-font-size0);
-}
+    .lm-AccordionPanel .jp-AccordionPanel-title {
+      box-sizing: border-box;
+      line-height: 25px;
+      margin: 0;
+      display: flex;
+      align-items: center;
+      background: var(--jp-layout-color1);
+      color: var(--jp-ui-font-color1);
+      border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
+      box-shadow: var(--jp-toolbar-box-shadow);
+      font-size: var(--jp-ui-font-size0);
+    }
 
-.jp-AccordionPanel-title {
-  cursor: pointer;
-  user-select: none;
-  -moz-user-select: none;
-  -webkit-user-select: none;
-  text-transform: uppercase;
-}
+    .jp-AccordionPanel-title {
+      cursor: pointer;
+      user-select: none;
+      -moz-user-select: none;
+      -webkit-user-select: none;
+      text-transform: uppercase;
+    }
 
-.lm-AccordionPanel[data-orientation='horizontal'] > .jp-AccordionPanel-title {
-  /* Title is rotated for horizontal accordion panel using CSS */
-  display: block;
-  transform-origin: top left;
-  transform: rotate(-90deg) translate(-100%);
-}
+    .lm-AccordionPanel[data-orientation='horizontal']>.jp-AccordionPanel-title {
+      /* Title is rotated for horizontal accordion panel using CSS */
+      display: block;
+      transform-origin: top left;
+      transform: rotate(-90deg) translate(-100%);
+    }
 
-.jp-AccordionPanel-title .lm-AccordionPanel-titleLabel {
-  user-select: none;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-  overflow: hidden;
-}
+    .jp-AccordionPanel-title .lm-AccordionPanel-titleLabel {
+      user-select: none;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+      overflow: hidden;
+    }
 
-.jp-AccordionPanel-title .lm-AccordionPanel-titleCollapser {
-  transform: rotate(-90deg);
-  margin: auto 0;
-  height: 16px;
-}
+    .jp-AccordionPanel-title .lm-AccordionPanel-titleCollapser {
+      transform: rotate(-90deg);
+      margin: auto 0;
+      height: 16px;
+    }
 
-.jp-AccordionPanel-title.lm-mod-expanded .lm-AccordionPanel-titleCollapser {
-  transform: rotate(0deg);
-}
+    .jp-AccordionPanel-title.lm-mod-expanded .lm-AccordionPanel-titleCollapser {
+      transform: rotate(0deg);
+    }
 
-.lm-AccordionPanel .jp-AccordionPanel-toolbar {
-  background: none;
-  box-shadow: none;
-  border: none;
-  margin-left: auto;
-}
+    .lm-AccordionPanel .jp-AccordionPanel-toolbar {
+      background: none;
+      box-shadow: none;
+      border: none;
+      margin-left: auto;
+    }
 
-.lm-AccordionPanel .lm-SplitPanel-handle:hover {
-  background: var(--jp-layout-color3);
-}
+    .lm-AccordionPanel .lm-SplitPanel-handle:hover {
+      background: var(--jp-layout-color3);
+    }
 
-.jp-text-truncated {
-  overflow: hidden;
-  text-overflow: ellipsis;
-  white-space: nowrap;
-}
+    .jp-text-truncated {
+      overflow: hidden;
+      text-overflow: ellipsis;
+      white-space: nowrap;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2017, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-Spinner {
-  position: absolute;
-  display: flex;
-  justify-content: center;
-  align-items: center;
-  z-index: 10;
-  left: 0;
-  top: 0;
-  width: 100%;
-  height: 100%;
-  background: var(--jp-layout-color0);
-  outline: none;
-}
+    .jp-Spinner {
+      position: absolute;
+      display: flex;
+      justify-content: center;
+      align-items: center;
+      z-index: 10;
+      left: 0;
+      top: 0;
+      width: 100%;
+      height: 100%;
+      background: var(--jp-layout-color0);
+      outline: none;
+    }
 
-.jp-SpinnerContent {
-  font-size: 10px;
-  margin: 50px auto;
-  text-indent: -9999em;
-  width: 3em;
-  height: 3em;
-  border-radius: 50%;
-  background: var(--jp-brand-color3);
-  background: linear-gradient(
-    to right,
-    #f37626 10%,
-    rgba(255, 255, 255, 0) 42%
-  );
-  position: relative;
-  animation: load3 1s infinite linear, fadeIn 1s;
-}
+    .jp-SpinnerContent {
+      font-size: 10px;
+      margin: 50px auto;
+      text-indent: -9999em;
+      width: 3em;
+      height: 3em;
+      border-radius: 50%;
+      background: var(--jp-brand-color3);
+      background: linear-gradient(to right,
+          #f37626 10%,
+          rgba(255, 255, 255, 0) 42%);
+      position: relative;
+      animation: load3 1s infinite linear, fadeIn 1s;
+    }
 
-.jp-SpinnerContent::before {
-  width: 50%;
-  height: 50%;
-  background: #f37626;
-  border-radius: 100% 0 0;
-  position: absolute;
-  top: 0;
-  left: 0;
-  content: '';
-}
+    .jp-SpinnerContent::before {
+      width: 50%;
+      height: 50%;
+      background: #f37626;
+      border-radius: 100% 0 0;
+      position: absolute;
+      top: 0;
+      left: 0;
+      content: '';
+    }
 
-.jp-SpinnerContent::after {
-  background: var(--jp-layout-color0);
-  width: 75%;
-  height: 75%;
-  border-radius: 50%;
-  content: '';
-  margin: auto;
-  position: absolute;
-  top: 0;
-  left: 0;
-  bottom: 0;
-  right: 0;
-}
+    .jp-SpinnerContent::after {
+      background: var(--jp-layout-color0);
+      width: 75%;
+      height: 75%;
+      border-radius: 50%;
+      content: '';
+      margin: auto;
+      position: absolute;
+      top: 0;
+      left: 0;
+      bottom: 0;
+      right: 0;
+    }
 
-@keyframes fadeIn {
-  0% {
-    opacity: 0;
-  }
+    @keyframes fadeIn {
+      0% {
+        opacity: 0;
+      }
 
-  100% {
-    opacity: 1;
-  }
-}
+      100% {
+        opacity: 1;
+      }
+    }
 
-@keyframes load3 {
-  0% {
-    transform: rotate(0deg);
-  }
+    @keyframes load3 {
+      0% {
+        transform: rotate(0deg);
+      }
 
-  100% {
-    transform: rotate(360deg);
-  }
-}
+      100% {
+        transform: rotate(360deg);
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2017, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-button.jp-mod-styled {
-  font-size: var(--jp-ui-font-size1);
-  color: var(--jp-ui-font-color0);
-  border: none;
-  box-sizing: border-box;
-  text-align: center;
-  line-height: 32px;
-  height: 32px;
-  padding: 0 12px;
-  letter-spacing: 0.8px;
-  outline: none;
-  appearance: none;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-}
+    button.jp-mod-styled {
+      font-size: var(--jp-ui-font-size1);
+      color: var(--jp-ui-font-color0);
+      border: none;
+      box-sizing: border-box;
+      text-align: center;
+      line-height: 32px;
+      height: 32px;
+      padding: 0 12px;
+      letter-spacing: 0.8px;
+      outline: none;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+    }
 
-input.jp-mod-styled {
-  background: var(--jp-input-background);
-  height: 28px;
-  box-sizing: border-box;
-  border: var(--jp-border-width) solid var(--jp-border-color1);
-  padding-left: 7px;
-  padding-right: 7px;
-  font-size: var(--jp-ui-font-size2);
-  color: var(--jp-ui-font-color0);
-  outline: none;
-  appearance: none;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-}
+    input.jp-mod-styled {
+      background: var(--jp-input-background);
+      height: 28px;
+      box-sizing: border-box;
+      border: var(--jp-border-width) solid var(--jp-border-color1);
+      padding-left: 7px;
+      padding-right: 7px;
+      font-size: var(--jp-ui-font-size2);
+      color: var(--jp-ui-font-color0);
+      outline: none;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+    }
 
-input[type='checkbox'].jp-mod-styled {
-  appearance: checkbox;
-  -webkit-appearance: checkbox;
-  -moz-appearance: checkbox;
-  height: auto;
-}
+    input[type='checkbox'].jp-mod-styled {
+      appearance: checkbox;
+      -webkit-appearance: checkbox;
+      -moz-appearance: checkbox;
+      height: auto;
+    }
 
-input.jp-mod-styled:focus {
-  border: var(--jp-border-width) solid var(--md-blue-500);
-  box-shadow: inset 0 0 4px var(--md-blue-300);
-}
+    input.jp-mod-styled:focus {
+      border: var(--jp-border-width) solid var(--md-blue-500);
+      box-shadow: inset 0 0 4px var(--md-blue-300);
+    }
 
-.jp-select-wrapper {
-  display: flex;
-  position: relative;
-  flex-direction: column;
-  padding: 1px;
-  background-color: var(--jp-layout-color1);
-  box-sizing: border-box;
-  margin-bottom: 12px;
-}
+    .jp-select-wrapper {
+      display: flex;
+      position: relative;
+      flex-direction: column;
+      padding: 1px;
+      background-color: var(--jp-layout-color1);
+      box-sizing: border-box;
+      margin-bottom: 12px;
+    }
 
-.jp-select-wrapper:not(.multiple) {
-  height: 28px;
-}
+    .jp-select-wrapper:not(.multiple) {
+      height: 28px;
+    }
 
-.jp-select-wrapper.jp-mod-focused select.jp-mod-styled {
-  border: var(--jp-border-width) solid var(--jp-input-active-border-color);
-  box-shadow: var(--jp-input-box-shadow);
-  background-color: var(--jp-input-active-background);
-}
+    .jp-select-wrapper.jp-mod-focused select.jp-mod-styled {
+      border: var(--jp-border-width) solid var(--jp-input-active-border-color);
+      box-shadow: var(--jp-input-box-shadow);
+      background-color: var(--jp-input-active-background);
+    }
 
-select.jp-mod-styled:hover {
-  cursor: pointer;
-  color: var(--jp-ui-font-color0);
-  background-color: var(--jp-input-hover-background);
-  box-shadow: inset 0 0 1px rgba(0, 0, 0, 0.5);
-}
+    select.jp-mod-styled:hover {
+      cursor: pointer;
+      color: var(--jp-ui-font-color0);
+      background-color: var(--jp-input-hover-background);
+      box-shadow: inset 0 0 1px rgba(0, 0, 0, 0.5);
+    }
 
-select.jp-mod-styled {
-  flex: 1 1 auto;
-  width: 100%;
-  font-size: var(--jp-ui-font-size2);
-  background: var(--jp-input-background);
-  color: var(--jp-ui-font-color0);
-  padding: 0 25px 0 8px;
-  border: var(--jp-border-width) solid var(--jp-input-border-color);
-  border-radius: 0;
-  outline: none;
-  appearance: none;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-}
+    select.jp-mod-styled {
+      flex: 1 1 auto;
+      width: 100%;
+      font-size: var(--jp-ui-font-size2);
+      background: var(--jp-input-background);
+      color: var(--jp-ui-font-color0);
+      padding: 0 25px 0 8px;
+      border: var(--jp-border-width) solid var(--jp-input-border-color);
+      border-radius: 0;
+      outline: none;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+    }
 
-select.jp-mod-styled:not([multiple]) {
-  height: 32px;
-}
+    select.jp-mod-styled:not([multiple]) {
+      height: 32px;
+    }
 
-select.jp-mod-styled[multiple] {
-  max-height: 200px;
-  overflow-y: auto;
-}
+    select.jp-mod-styled[multiple] {
+      max-height: 200px;
+      overflow-y: auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-switch {
-  display: flex;
-  align-items: center;
-  padding-left: 4px;
-  padding-right: 4px;
-  font-size: var(--jp-ui-font-size1);
-  background-color: transparent;
-  color: var(--jp-ui-font-color1);
-  border: none;
-  height: 20px;
-}
+    .jp-switch {
+      display: flex;
+      align-items: center;
+      padding-left: 4px;
+      padding-right: 4px;
+      font-size: var(--jp-ui-font-size1);
+      background-color: transparent;
+      color: var(--jp-ui-font-color1);
+      border: none;
+      height: 20px;
+    }
 
-.jp-switch:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-switch:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-switch-label {
-  margin-right: 5px;
-  font-family: var(--jp-ui-font-family);
-}
+    .jp-switch-label {
+      margin-right: 5px;
+      font-family: var(--jp-ui-font-family);
+    }
 
-.jp-switch-track {
-  cursor: pointer;
-  background-color: var(--jp-switch-color, var(--jp-border-color1));
-  -webkit-transition: 0.4s;
-  transition: 0.4s;
-  border-radius: 34px;
-  height: 16px;
-  width: 35px;
-  position: relative;
-}
+    .jp-switch-track {
+      cursor: pointer;
+      background-color: var(--jp-switch-color, var(--jp-border-color1));
+      -webkit-transition: 0.4s;
+      transition: 0.4s;
+      border-radius: 34px;
+      height: 16px;
+      width: 35px;
+      position: relative;
+    }
 
-.jp-switch-track::before {
-  content: '';
-  position: absolute;
-  height: 10px;
-  width: 10px;
-  margin: 3px;
-  left: 0;
-  background-color: var(--jp-ui-inverse-font-color1);
-  -webkit-transition: 0.4s;
-  transition: 0.4s;
-  border-radius: 50%;
-}
+    .jp-switch-track::before {
+      content: '';
+      position: absolute;
+      height: 10px;
+      width: 10px;
+      margin: 3px;
+      left: 0;
+      background-color: var(--jp-ui-inverse-font-color1);
+      -webkit-transition: 0.4s;
+      transition: 0.4s;
+      border-radius: 50%;
+    }
 
-.jp-switch[aria-checked='true'] .jp-switch-track {
-  background-color: var(--jp-switch-true-position-color, var(--jp-warn-color0));
-}
+    .jp-switch[aria-checked='true'] .jp-switch-track {
+      background-color: var(--jp-switch-true-position-color, var(--jp-warn-color0));
+    }
 
-.jp-switch[aria-checked='true'] .jp-switch-track::before {
-  /* track width (35) - margins (3 + 3) - thumb width (10) */
-  left: 19px;
-}
+    .jp-switch[aria-checked='true'] .jp-switch-track::before {
+      /* track width (35) - margins (3 + 3) - thumb width (10) */
+      left: 19px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2016, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-private-toolbar-height: calc(
-    28px + var(--jp-border-width)
-  ); /* leave 28px for content */
-}
+    :root {
+      --jp-private-toolbar-height: calc(28px + var(--jp-border-width));
+      /* leave 28px for content */
+    }
 
-.jp-Toolbar {
-  color: var(--jp-ui-font-color1);
-  flex: 0 0 auto;
-  display: flex;
-  flex-direction: row;
-  border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
-  box-shadow: var(--jp-toolbar-box-shadow);
-  background: var(--jp-toolbar-background);
-  min-height: var(--jp-toolbar-micro-height);
-  padding: 2px;
-  z-index: 8;
-  overflow-x: hidden;
-}
+    .jp-Toolbar {
+      color: var(--jp-ui-font-color1);
+      flex: 0 0 auto;
+      display: flex;
+      flex-direction: row;
+      border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
+      box-shadow: var(--jp-toolbar-box-shadow);
+      background: var(--jp-toolbar-background);
+      min-height: var(--jp-toolbar-micro-height);
+      padding: 2px;
+      z-index: 8;
+      overflow-x: hidden;
+    }
 
-/* Toolbar items */
+    /* Toolbar items */
 
-.jp-Toolbar > .jp-Toolbar-item.jp-Toolbar-spacer {
-  flex-grow: 1;
-  flex-shrink: 1;
-}
+    .jp-Toolbar>.jp-Toolbar-item.jp-Toolbar-spacer {
+      flex-grow: 1;
+      flex-shrink: 1;
+    }
 
-.jp-Toolbar-item.jp-Toolbar-kernelStatus {
-  display: inline-block;
-  width: 32px;
-  background-repeat: no-repeat;
-  background-position: center;
-  background-size: 16px;
-}
+    .jp-Toolbar-item.jp-Toolbar-kernelStatus {
+      display: inline-block;
+      width: 32px;
+      background-repeat: no-repeat;
+      background-position: center;
+      background-size: 16px;
+    }
 
-.jp-Toolbar > .jp-Toolbar-item {
-  flex: 0 0 auto;
-  display: flex;
-  padding-left: 1px;
-  padding-right: 1px;
-  font-size: var(--jp-ui-font-size1);
-  line-height: var(--jp-private-toolbar-height);
-  height: 100%;
-}
+    .jp-Toolbar>.jp-Toolbar-item {
+      flex: 0 0 auto;
+      display: flex;
+      padding-left: 1px;
+      padding-right: 1px;
+      font-size: var(--jp-ui-font-size1);
+      line-height: var(--jp-private-toolbar-height);
+      height: 100%;
+    }
 
-/* Toolbar buttons */
+    /* Toolbar buttons */
 
-/* This is the div we use to wrap the react component into a Widget */
-div.jp-ToolbarButton {
-  color: transparent;
-  border: none;
-  box-sizing: border-box;
-  outline: none;
-  appearance: none;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-  padding: 0;
-  margin: 0;
-}
+    /* This is the div we use to wrap the react component into a Widget */
+    div.jp-ToolbarButton {
+      color: transparent;
+      border: none;
+      box-sizing: border-box;
+      outline: none;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      padding: 0;
+      margin: 0;
+    }
 
-button.jp-ToolbarButtonComponent {
-  background: var(--jp-layout-color1);
-  border: none;
-  box-sizing: border-box;
-  outline: none;
-  appearance: none;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-  padding: 0 6px;
-  margin: 0;
-  height: 24px;
-  border-radius: var(--jp-border-radius);
-  display: flex;
-  align-items: center;
-  text-align: center;
-  font-size: 14px;
-  min-width: unset;
-  min-height: unset;
-}
+    button.jp-ToolbarButtonComponent {
+      background: var(--jp-layout-color1);
+      border: none;
+      box-sizing: border-box;
+      outline: none;
+      appearance: none;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      padding: 0 6px;
+      margin: 0;
+      height: 24px;
+      border-radius: var(--jp-border-radius);
+      display: flex;
+      align-items: center;
+      text-align: center;
+      font-size: 14px;
+      min-width: unset;
+      min-height: unset;
+    }
 
-button.jp-ToolbarButtonComponent:disabled {
-  opacity: 0.4;
-}
+    button.jp-ToolbarButtonComponent:disabled {
+      opacity: 0.4;
+    }
 
-button.jp-ToolbarButtonComponent > span {
-  padding: 0;
-  flex: 0 0 auto;
-}
+    button.jp-ToolbarButtonComponent>span {
+      padding: 0;
+      flex: 0 0 auto;
+    }
 
-button.jp-ToolbarButtonComponent .jp-ToolbarButtonComponent-label {
-  font-size: var(--jp-ui-font-size1);
-  line-height: 100%;
-  padding-left: 2px;
-  color: var(--jp-ui-font-color1);
-  font-family: var(--jp-ui-font-family);
-}
+    button.jp-ToolbarButtonComponent .jp-ToolbarButtonComponent-label {
+      font-size: var(--jp-ui-font-size1);
+      line-height: 100%;
+      padding-left: 2px;
+      color: var(--jp-ui-font-color1);
+      font-family: var(--jp-ui-font-family);
+    }
 
-#jp-main-dock-panel[data-mode='single-document']
-  .jp-MainAreaWidget
-  > .jp-Toolbar.jp-Toolbar-micro {
-  padding: 0;
-  min-height: 0;
-}
+    #jp-main-dock-panel[data-mode='single-document'] .jp-MainAreaWidget>.jp-Toolbar.jp-Toolbar-micro {
+      padding: 0;
+      min-height: 0;
+    }
 
-#jp-main-dock-panel[data-mode='single-document']
-  .jp-MainAreaWidget
-  > .jp-Toolbar {
-  border: none;
-  box-shadow: none;
-}
+    #jp-main-dock-panel[data-mode='single-document'] .jp-MainAreaWidget>.jp-Toolbar {
+      border: none;
+      box-shadow: none;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.jp-WindowedPanel-outer {
-  position: relative;
-  overflow-y: auto;
-}
+    .jp-WindowedPanel-outer {
+      position: relative;
+      overflow-y: auto;
+    }
 
-.jp-WindowedPanel-inner {
-  position: relative;
-}
+    .jp-WindowedPanel-inner {
+      position: relative;
+    }
 
-.jp-WindowedPanel-window {
-  position: absolute;
-  left: 0;
-  right: 0;
-  overflow: visible;
-}
+    .jp-WindowedPanel-window {
+      position: absolute;
+      left: 0;
+      right: 0;
+      overflow: visible;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/* Sibling imports */
+    /* Sibling imports */
 
-body {
-  color: var(--jp-ui-font-color1);
-  font-size: var(--jp-ui-font-size1);
-}
+    body {
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+    }
 
-/* Disable native link decoration styles everywhere outside of dialog boxes */
-a {
-  text-decoration: unset;
-  color: unset;
-}
+    /* Disable native link decoration styles everywhere outside of dialog boxes */
+    a {
+      text-decoration: unset;
+      color: unset;
+    }
 
-a:hover {
-  text-decoration: unset;
-  color: unset;
-}
+    a:hover {
+      text-decoration: unset;
+      color: unset;
+    }
 
-/* Accessibility for links inside dialog box text */
-.jp-Dialog-content a {
-  text-decoration: revert;
-  color: var(--jp-content-link-color);
-}
+    /* Accessibility for links inside dialog box text */
+    .jp-Dialog-content a {
+      text-decoration: revert;
+      color: var(--jp-content-link-color);
+    }
 
-.jp-Dialog-content a:hover {
-  text-decoration: revert;
-}
+    .jp-Dialog-content a:hover {
+      text-decoration: revert;
+    }
 
-/* Styles for ui-components */
-.jp-Button {
-  color: var(--jp-ui-font-color2);
-  border-radius: var(--jp-border-radius);
-  padding: 0 12px;
-  font-size: var(--jp-ui-font-size1);
+    /* Styles for ui-components */
+    .jp-Button {
+      color: var(--jp-ui-font-color2);
+      border-radius: var(--jp-border-radius);
+      padding: 0 12px;
+      font-size: var(--jp-ui-font-size1);
 
-  /* Copy from blueprint 3 */
-  display: inline-flex;
-  flex-direction: row;
-  border: none;
-  cursor: pointer;
-  align-items: center;
-  justify-content: center;
-  text-align: left;
-  vertical-align: middle;
-  min-height: 30px;
-  min-width: 30px;
-}
+      /* Copy from blueprint 3 */
+      display: inline-flex;
+      flex-direction: row;
+      border: none;
+      cursor: pointer;
+      align-items: center;
+      justify-content: center;
+      text-align: left;
+      vertical-align: middle;
+      min-height: 30px;
+      min-width: 30px;
+    }
 
-.jp-Button:disabled {
-  cursor: not-allowed;
-}
+    .jp-Button:disabled {
+      cursor: not-allowed;
+    }
 
-.jp-Button:empty {
-  padding: 0 !important;
-}
+    .jp-Button:empty {
+      padding: 0 !important;
+    }
 
-.jp-Button.jp-mod-small {
-  min-height: 24px;
-  min-width: 24px;
-  font-size: 12px;
-  padding: 0 7px;
-}
+    .jp-Button.jp-mod-small {
+      min-height: 24px;
+      min-width: 24px;
+      font-size: 12px;
+      padding: 0 7px;
+    }
 
-/* Use our own theme for hover styles */
-.jp-Button.jp-mod-minimal:hover {
-  background-color: var(--jp-layout-color2);
-}
+    /* Use our own theme for hover styles */
+    .jp-Button.jp-mod-minimal:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-Button.jp-mod-minimal {
-  background: none;
-}
+    .jp-Button.jp-mod-minimal {
+      background: none;
+    }
 
-.jp-InputGroup {
-  display: block;
-  position: relative;
-}
+    .jp-InputGroup {
+      display: block;
+      position: relative;
+    }
 
-.jp-InputGroup input {
-  box-sizing: border-box;
-  border: none;
-  border-radius: 0;
-  background-color: transparent;
-  color: var(--jp-ui-font-color0);
-  box-shadow: inset 0 0 0 var(--jp-border-width) var(--jp-input-border-color);
-  padding-bottom: 0;
-  padding-top: 0;
-  padding-left: 10px;
-  padding-right: 28px;
-  position: relative;
-  width: 100%;
-  -webkit-appearance: none;
-  -moz-appearance: none;
-  appearance: none;
-  font-size: 14px;
-  font-weight: 400;
-  height: 30px;
-  line-height: 30px;
-  outline: none;
-  vertical-align: middle;
-}
+    .jp-InputGroup input {
+      box-sizing: border-box;
+      border: none;
+      border-radius: 0;
+      background-color: transparent;
+      color: var(--jp-ui-font-color0);
+      box-shadow: inset 0 0 0 var(--jp-border-width) var(--jp-input-border-color);
+      padding-bottom: 0;
+      padding-top: 0;
+      padding-left: 10px;
+      padding-right: 28px;
+      position: relative;
+      width: 100%;
+      -webkit-appearance: none;
+      -moz-appearance: none;
+      appearance: none;
+      font-size: 14px;
+      font-weight: 400;
+      height: 30px;
+      line-height: 30px;
+      outline: none;
+      vertical-align: middle;
+    }
 
-.jp-InputGroup input:focus {
-  box-shadow: inset 0 0 0 var(--jp-border-width)
-      var(--jp-input-active-box-shadow-color),
-    inset 0 0 0 3px var(--jp-input-active-box-shadow-color);
-}
+    .jp-InputGroup input:focus {
+      box-shadow: inset 0 0 0 var(--jp-border-width) var(--jp-input-active-box-shadow-color),
+        inset 0 0 0 3px var(--jp-input-active-box-shadow-color);
+    }
 
-.jp-InputGroup input:disabled {
-  cursor: not-allowed;
-  resize: block;
-  background-color: var(--jp-layout-color2);
-  color: var(--jp-ui-font-color2);
-}
+    .jp-InputGroup input:disabled {
+      cursor: not-allowed;
+      resize: block;
+      background-color: var(--jp-layout-color2);
+      color: var(--jp-ui-font-color2);
+    }
 
-.jp-InputGroup input:disabled ~ span {
-  cursor: not-allowed;
-  color: var(--jp-ui-font-color2);
-}
+    .jp-InputGroup input:disabled~span {
+      cursor: not-allowed;
+      color: var(--jp-ui-font-color2);
+    }
 
-.jp-InputGroup input::placeholder,
-input::placeholder {
-  color: var(--jp-ui-font-color2);
-}
+    .jp-InputGroup input::placeholder,
+    input::placeholder {
+      color: var(--jp-ui-font-color2);
+    }
 
-.jp-InputGroupAction {
-  position: absolute;
-  bottom: 1px;
-  right: 0;
-  padding: 6px;
-}
+    .jp-InputGroupAction {
+      position: absolute;
+      bottom: 1px;
+      right: 0;
+      padding: 6px;
+    }
 
-.jp-HTMLSelect.jp-DefaultStyle select {
-  background-color: initial;
-  border: none;
-  border-radius: 0;
-  box-shadow: none;
-  color: var(--jp-ui-font-color0);
-  display: block;
-  font-size: var(--jp-ui-font-size1);
-  font-family: var(--jp-ui-font-family);
-  height: 24px;
-  line-height: 14px;
-  padding: 0 25px 0 10px;
-  text-align: left;
-  -moz-appearance: none;
-  -webkit-appearance: none;
-}
+    .jp-HTMLSelect.jp-DefaultStyle select {
+      background-color: initial;
+      border: none;
+      border-radius: 0;
+      box-shadow: none;
+      color: var(--jp-ui-font-color0);
+      display: block;
+      font-size: var(--jp-ui-font-size1);
+      font-family: var(--jp-ui-font-family);
+      height: 24px;
+      line-height: 14px;
+      padding: 0 25px 0 10px;
+      text-align: left;
+      -moz-appearance: none;
+      -webkit-appearance: none;
+    }
 
-.jp-HTMLSelect.jp-DefaultStyle select:disabled {
-  background-color: var(--jp-layout-color2);
-  color: var(--jp-ui-font-color2);
-  cursor: not-allowed;
-  resize: block;
-}
+    .jp-HTMLSelect.jp-DefaultStyle select:disabled {
+      background-color: var(--jp-layout-color2);
+      color: var(--jp-ui-font-color2);
+      cursor: not-allowed;
+      resize: block;
+    }
 
-.jp-HTMLSelect.jp-DefaultStyle select:disabled ~ span {
-  cursor: not-allowed;
-}
+    .jp-HTMLSelect.jp-DefaultStyle select:disabled~span {
+      cursor: not-allowed;
+    }
 
-/* Use our own theme for hover and option styles */
-/* stylelint-disable-next-line selector-max-type */
-.jp-HTMLSelect.jp-DefaultStyle select:hover,
-.jp-HTMLSelect.jp-DefaultStyle select > option {
-  background-color: var(--jp-layout-color2);
-  color: var(--jp-ui-font-color0);
-}
+    /* Use our own theme for hover and option styles */
+    /* stylelint-disable-next-line selector-max-type */
+    .jp-HTMLSelect.jp-DefaultStyle select:hover,
+    .jp-HTMLSelect.jp-DefaultStyle select>option {
+      background-color: var(--jp-layout-color2);
+      color: var(--jp-ui-font-color0);
+    }
 
-select {
-  box-sizing: border-box;
-}
+    select {
+      box-sizing: border-box;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Styles
 |----------------------------------------------------------------------------*/
 
-.jp-StatusBar-Widget {
-  display: flex;
-  align-items: center;
-  background: var(--jp-layout-color2);
-  min-height: var(--jp-statusbar-height);
-  justify-content: space-between;
-  padding: 0 10px;
-}
+    .jp-StatusBar-Widget {
+      display: flex;
+      align-items: center;
+      background: var(--jp-layout-color2);
+      min-height: var(--jp-statusbar-height);
+      justify-content: space-between;
+      padding: 0 10px;
+    }
 
-.jp-StatusBar-Left {
-  display: flex;
-  align-items: center;
-  flex-direction: row;
-}
+    .jp-StatusBar-Left {
+      display: flex;
+      align-items: center;
+      flex-direction: row;
+    }
 
-.jp-StatusBar-Middle {
-  display: flex;
-  align-items: center;
-}
+    .jp-StatusBar-Middle {
+      display: flex;
+      align-items: center;
+    }
 
-.jp-StatusBar-Right {
-  display: flex;
-  align-items: center;
-  flex-direction: row-reverse;
-}
+    .jp-StatusBar-Right {
+      display: flex;
+      align-items: center;
+      flex-direction: row-reverse;
+    }
 
-.jp-StatusBar-Item {
-  max-height: var(--jp-statusbar-height);
-  margin: 0 2px;
-  height: var(--jp-statusbar-height);
-  white-space: nowrap;
-  text-overflow: ellipsis;
-  color: var(--jp-ui-font-color1);
-  padding: 0 6px;
-}
+    .jp-StatusBar-Item {
+      max-height: var(--jp-statusbar-height);
+      margin: 0 2px;
+      height: var(--jp-statusbar-height);
+      white-space: nowrap;
+      text-overflow: ellipsis;
+      color: var(--jp-ui-font-color1);
+      padding: 0 6px;
+    }
 
-.jp-mod-highlighted:hover {
-  background-color: var(--jp-layout-color3);
-}
+    .jp-mod-highlighted:hover {
+      background-color: var(--jp-layout-color3);
+    }
 
-.jp-mod-clicked {
-  background-color: var(--jp-brand-color1);
-}
+    .jp-mod-clicked {
+      background-color: var(--jp-brand-color1);
+    }
 
-.jp-mod-clicked:hover {
-  background-color: var(--jp-brand-color0);
-}
+    .jp-mod-clicked:hover {
+      background-color: var(--jp-brand-color0);
+    }
 
-.jp-mod-clicked .jp-StatusBar-TextItem {
-  color: var(--jp-ui-inverse-font-color1);
-}
+    .jp-mod-clicked .jp-StatusBar-TextItem {
+      color: var(--jp-ui-inverse-font-color1);
+    }
 
-.jp-StatusBar-HoverItem {
-  box-shadow: '0px 4px 4px rgba(0, 0, 0, 0.25)';
-}
+    .jp-StatusBar-HoverItem {
+      box-shadow: '0px 4px 4px rgba(0, 0, 0, 0.25)';
+    }
 
-.jp-StatusBar-TextItem {
-  font-size: var(--jp-ui-font-size1);
-  font-family: var(--jp-ui-font-family);
-  line-height: 24px;
-  color: var(--jp-ui-font-color1);
-}
+    .jp-StatusBar-TextItem {
+      font-size: var(--jp-ui-font-size1);
+      font-family: var(--jp-ui-font-family);
+      line-height: 24px;
+      color: var(--jp-ui-font-color1);
+    }
 
-.jp-StatusBar-GroupItem {
-  display: flex;
-  align-items: center;
-  flex-direction: row;
-}
+    .jp-StatusBar-GroupItem {
+      display: flex;
+      align-items: center;
+      flex-direction: row;
+    }
 
-.jp-Statusbar-ProgressCircle svg {
-  display: block;
-  margin: 0 auto;
-  width: 16px;
-  height: 24px;
-  align-self: normal;
-}
+    .jp-Statusbar-ProgressCircle svg {
+      display: block;
+      margin: 0 auto;
+      width: 16px;
+      height: 24px;
+      align-self: normal;
+    }
 
-.jp-Statusbar-ProgressCircle path {
-  fill: var(--jp-inverse-layout-color3);
-}
+    .jp-Statusbar-ProgressCircle path {
+      fill: var(--jp-inverse-layout-color3);
+    }
 
-.jp-Statusbar-ProgressBar-progress-bar {
-  height: 10px;
-  width: 100px;
-  border: solid 0.25px var(--jp-brand-color2);
-  border-radius: 3px;
-  overflow: hidden;
-  align-self: center;
-}
+    .jp-Statusbar-ProgressBar-progress-bar {
+      height: 10px;
+      width: 100px;
+      border: solid 0.25px var(--jp-brand-color2);
+      border-radius: 3px;
+      overflow: hidden;
+      align-self: center;
+    }
 
-.jp-Statusbar-ProgressBar-progress-bar > div {
-  background-color: var(--jp-brand-color2);
-  background-image: linear-gradient(
-    -45deg,
-    rgba(255, 255, 255, 0.2) 25%,
-    transparent 25%,
-    transparent 50%,
-    rgba(255, 255, 255, 0.2) 50%,
-    rgba(255, 255, 255, 0.2) 75%,
-    transparent 75%,
-    transparent
-  );
-  background-size: 40px 40px;
-  float: left;
-  width: 0%;
-  height: 100%;
-  font-size: 12px;
-  line-height: 14px;
-  color: #fff;
-  text-align: center;
-  animation: jp-Statusbar-ExecutionTime-progress-bar 2s linear infinite;
-}
+    .jp-Statusbar-ProgressBar-progress-bar>div {
+      background-color: var(--jp-brand-color2);
+      background-image: linear-gradient(-45deg,
+          rgba(255, 255, 255, 0.2) 25%,
+          transparent 25%,
+          transparent 50%,
+          rgba(255, 255, 255, 0.2) 50%,
+          rgba(255, 255, 255, 0.2) 75%,
+          transparent 75%,
+          transparent);
+      background-size: 40px 40px;
+      float: left;
+      width: 0%;
+      height: 100%;
+      font-size: 12px;
+      line-height: 14px;
+      color: #fff;
+      text-align: center;
+      animation: jp-Statusbar-ExecutionTime-progress-bar 2s linear infinite;
+    }
 
-.jp-Statusbar-ProgressBar-progress-bar p {
-  color: var(--jp-ui-font-color1);
-  font-family: var(--jp-ui-font-family);
-  font-size: var(--jp-ui-font-size1);
-  line-height: 10px;
-  width: 100px;
-}
+    .jp-Statusbar-ProgressBar-progress-bar p {
+      color: var(--jp-ui-font-color1);
+      font-family: var(--jp-ui-font-family);
+      font-size: var(--jp-ui-font-size1);
+      line-height: 10px;
+      width: 100px;
+    }
 
-@keyframes jp-Statusbar-ExecutionTime-progress-bar {
-  0% {
-    background-position: 0 0;
-  }
+    @keyframes jp-Statusbar-ExecutionTime-progress-bar {
+      0% {
+        background-position: 0 0;
+      }
 
-  100% {
-    background-position: 40px 40px;
-  }
-}
+      100% {
+        background-position: 40px 40px;
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Variables
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-private-commandpalette-search-height: 28px;
-}
+    :root {
+      --jp-private-commandpalette-search-height: 28px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Overall styles
 |----------------------------------------------------------------------------*/
 
-.lm-CommandPalette {
-  padding-bottom: 0;
-  color: var(--jp-ui-font-color1);
-  background: var(--jp-layout-color1);
+    .lm-CommandPalette {
+      padding-bottom: 0;
+      color: var(--jp-ui-font-color1);
+      background: var(--jp-layout-color1);
 
-  /* This is needed so that all font sizing of children done in ems is
+      /* This is needed so that all font sizing of children done in ems is
    * relative to this base size */
-  font-size: var(--jp-ui-font-size1);
-}
+      font-size: var(--jp-ui-font-size1);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Modal variant
 |----------------------------------------------------------------------------*/
 
-.jp-ModalCommandPalette {
-  position: absolute;
-  z-index: 10000;
-  top: 38px;
-  left: 30%;
-  margin: 0;
-  padding: 4px;
-  width: 40%;
-  box-shadow: var(--jp-elevation-z4);
-  border-radius: 4px;
-  background: var(--jp-layout-color0);
-}
+    .jp-ModalCommandPalette {
+      position: absolute;
+      z-index: 10000;
+      top: 38px;
+      left: 30%;
+      margin: 0;
+      padding: 4px;
+      width: 40%;
+      box-shadow: var(--jp-elevation-z4);
+      border-radius: 4px;
+      background: var(--jp-layout-color0);
+    }
 
-.jp-ModalCommandPalette .lm-CommandPalette {
-  max-height: 40vh;
-}
+    .jp-ModalCommandPalette .lm-CommandPalette {
+      max-height: 40vh;
+    }
 
-.jp-ModalCommandPalette .lm-CommandPalette .lm-close-icon::after {
-  display: none;
-}
+    .jp-ModalCommandPalette .lm-CommandPalette .lm-close-icon::after {
+      display: none;
+    }
 
-.jp-ModalCommandPalette .lm-CommandPalette .lm-CommandPalette-header {
-  display: none;
-}
+    .jp-ModalCommandPalette .lm-CommandPalette .lm-CommandPalette-header {
+      display: none;
+    }
 
-.jp-ModalCommandPalette .lm-CommandPalette .lm-CommandPalette-item {
-  margin-left: 4px;
-  margin-right: 4px;
-}
+    .jp-ModalCommandPalette .lm-CommandPalette .lm-CommandPalette-item {
+      margin-left: 4px;
+      margin-right: 4px;
+    }
 
-.jp-ModalCommandPalette
-  .lm-CommandPalette
-  .lm-CommandPalette-item.lm-mod-disabled {
-  display: none;
-}
+    .jp-ModalCommandPalette .lm-CommandPalette .lm-CommandPalette-item.lm-mod-disabled {
+      display: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Search
 |----------------------------------------------------------------------------*/
 
-.lm-CommandPalette-search {
-  padding: 4px;
-  background-color: var(--jp-layout-color1);
-  z-index: 2;
-}
+    .lm-CommandPalette-search {
+      padding: 4px;
+      background-color: var(--jp-layout-color1);
+      z-index: 2;
+    }
 
-.lm-CommandPalette-wrapper {
-  overflow: overlay;
-  padding: 0 9px;
-  background-color: var(--jp-input-active-background);
-  height: 30px;
-  box-shadow: inset 0 0 0 var(--jp-border-width) var(--jp-input-border-color);
-}
+    .lm-CommandPalette-wrapper {
+      overflow: overlay;
+      padding: 0 9px;
+      background-color: var(--jp-input-active-background);
+      height: 30px;
+      box-shadow: inset 0 0 0 var(--jp-border-width) var(--jp-input-border-color);
+    }
 
-.lm-CommandPalette.lm-mod-focused .lm-CommandPalette-wrapper {
-  box-shadow: inset 0 0 0 1px var(--jp-input-active-box-shadow-color),
-    inset 0 0 0 3px var(--jp-input-active-box-shadow-color);
-}
+    .lm-CommandPalette.lm-mod-focused .lm-CommandPalette-wrapper {
+      box-shadow: inset 0 0 0 1px var(--jp-input-active-box-shadow-color),
+        inset 0 0 0 3px var(--jp-input-active-box-shadow-color);
+    }
 
-.jp-SearchIconGroup {
-  color: white;
-  background-color: var(--jp-brand-color1);
-  position: absolute;
-  top: 4px;
-  right: 4px;
-  padding: 5px 5px 1px;
-}
+    .jp-SearchIconGroup {
+      color: white;
+      background-color: var(--jp-brand-color1);
+      position: absolute;
+      top: 4px;
+      right: 4px;
+      padding: 5px 5px 1px;
+    }
 
-.jp-SearchIconGroup svg {
-  height: 20px;
-  width: 20px;
-}
+    .jp-SearchIconGroup svg {
+      height: 20px;
+      width: 20px;
+    }
 
-.jp-SearchIconGroup .jp-icon3[fill] {
-  fill: var(--jp-layout-color0);
-}
+    .jp-SearchIconGroup .jp-icon3[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.lm-CommandPalette-input {
-  background: transparent;
-  width: calc(100% - 18px);
-  float: left;
-  border: none;
-  outline: none;
-  font-size: var(--jp-ui-font-size1);
-  color: var(--jp-ui-font-color0);
-  line-height: var(--jp-private-commandpalette-search-height);
-}
+    .lm-CommandPalette-input {
+      background: transparent;
+      width: calc(100% - 18px);
+      float: left;
+      border: none;
+      outline: none;
+      font-size: var(--jp-ui-font-size1);
+      color: var(--jp-ui-font-color0);
+      line-height: var(--jp-private-commandpalette-search-height);
+    }
 
-.lm-CommandPalette-input::-webkit-input-placeholder,
-.lm-CommandPalette-input::-moz-placeholder,
-.lm-CommandPalette-input:-ms-input-placeholder {
-  color: var(--jp-ui-font-color2);
-  font-size: var(--jp-ui-font-size1);
-}
+    .lm-CommandPalette-input::-webkit-input-placeholder,
+    .lm-CommandPalette-input::-moz-placeholder,
+    .lm-CommandPalette-input:-ms-input-placeholder {
+      color: var(--jp-ui-font-color2);
+      font-size: var(--jp-ui-font-size1);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Results
 |----------------------------------------------------------------------------*/
 
-.lm-CommandPalette-header:first-child {
-  margin-top: 0;
-}
+    .lm-CommandPalette-header:first-child {
+      margin-top: 0;
+    }
 
-.lm-CommandPalette-header {
-  border-bottom: solid var(--jp-border-width) var(--jp-border-color2);
-  color: var(--jp-ui-font-color1);
-  cursor: pointer;
-  display: flex;
-  font-size: var(--jp-ui-font-size0);
-  font-weight: 600;
-  letter-spacing: 1px;
-  margin-top: 8px;
-  padding: 8px 0 8px 12px;
-  text-transform: uppercase;
-}
+    .lm-CommandPalette-header {
+      border-bottom: solid var(--jp-border-width) var(--jp-border-color2);
+      color: var(--jp-ui-font-color1);
+      cursor: pointer;
+      display: flex;
+      font-size: var(--jp-ui-font-size0);
+      font-weight: 600;
+      letter-spacing: 1px;
+      margin-top: 8px;
+      padding: 8px 0 8px 12px;
+      text-transform: uppercase;
+    }
 
-.lm-CommandPalette-header.lm-mod-active {
-  background: var(--jp-layout-color2);
-}
+    .lm-CommandPalette-header.lm-mod-active {
+      background: var(--jp-layout-color2);
+    }
 
-.lm-CommandPalette-header > mark {
-  background-color: transparent;
-  font-weight: bold;
-  color: var(--jp-ui-font-color1);
-}
+    .lm-CommandPalette-header>mark {
+      background-color: transparent;
+      font-weight: bold;
+      color: var(--jp-ui-font-color1);
+    }
 
-.lm-CommandPalette-item {
-  padding: 4px 12px 4px 4px;
-  color: var(--jp-ui-font-color1);
-  font-size: var(--jp-ui-font-size1);
-  font-weight: 400;
-  display: flex;
-}
+    .lm-CommandPalette-item {
+      padding: 4px 12px 4px 4px;
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+      font-weight: 400;
+      display: flex;
+    }
 
-.lm-CommandPalette-item.lm-mod-disabled {
-  color: var(--jp-ui-font-color2);
-}
+    .lm-CommandPalette-item.lm-mod-disabled {
+      color: var(--jp-ui-font-color2);
+    }
 
-.lm-CommandPalette-item.lm-mod-active {
-  color: var(--jp-ui-inverse-font-color1);
-  background: var(--jp-brand-color1);
-}
+    .lm-CommandPalette-item.lm-mod-active {
+      color: var(--jp-ui-inverse-font-color1);
+      background: var(--jp-brand-color1);
+    }
 
-.lm-CommandPalette-item.lm-mod-active .lm-CommandPalette-itemLabel > mark {
-  color: var(--jp-ui-inverse-font-color0);
-}
+    .lm-CommandPalette-item.lm-mod-active .lm-CommandPalette-itemLabel>mark {
+      color: var(--jp-ui-inverse-font-color0);
+    }
 
-.lm-CommandPalette-item.lm-mod-active .jp-icon-selectable[fill] {
-  fill: var(--jp-layout-color0);
-}
+    .lm-CommandPalette-item.lm-mod-active .jp-icon-selectable[fill] {
+      fill: var(--jp-layout-color0);
+    }
 
-.lm-CommandPalette-item.lm-mod-active:hover:not(.lm-mod-disabled) {
-  color: var(--jp-ui-inverse-font-color1);
-  background: var(--jp-brand-color1);
-}
+    .lm-CommandPalette-item.lm-mod-active:hover:not(.lm-mod-disabled) {
+      color: var(--jp-ui-inverse-font-color1);
+      background: var(--jp-brand-color1);
+    }
 
-.lm-CommandPalette-item:hover:not(.lm-mod-active):not(.lm-mod-disabled) {
-  background: var(--jp-layout-color2);
-}
+    .lm-CommandPalette-item:hover:not(.lm-mod-active):not(.lm-mod-disabled) {
+      background: var(--jp-layout-color2);
+    }
 
-.lm-CommandPalette-itemContent {
-  overflow: hidden;
-}
+    .lm-CommandPalette-itemContent {
+      overflow: hidden;
+    }
 
-.lm-CommandPalette-itemLabel > mark {
-  color: var(--jp-ui-font-color0);
-  background-color: transparent;
-  font-weight: bold;
-}
+    .lm-CommandPalette-itemLabel>mark {
+      color: var(--jp-ui-font-color0);
+      background-color: transparent;
+      font-weight: bold;
+    }
 
-.lm-CommandPalette-item.lm-mod-disabled mark {
-  color: var(--jp-ui-font-color2);
-}
+    .lm-CommandPalette-item.lm-mod-disabled mark {
+      color: var(--jp-ui-font-color2);
+    }
 
-.lm-CommandPalette-item .lm-CommandPalette-itemIcon {
-  margin: 0 4px 0 0;
-  position: relative;
-  width: 16px;
-  top: 2px;
-  flex: 0 0 auto;
-}
+    .lm-CommandPalette-item .lm-CommandPalette-itemIcon {
+      margin: 0 4px 0 0;
+      position: relative;
+      width: 16px;
+      top: 2px;
+      flex: 0 0 auto;
+    }
 
-.lm-CommandPalette-item.lm-mod-disabled .lm-CommandPalette-itemIcon {
-  opacity: 0.6;
-}
+    .lm-CommandPalette-item.lm-mod-disabled .lm-CommandPalette-itemIcon {
+      opacity: 0.6;
+    }
 
-.lm-CommandPalette-item .lm-CommandPalette-itemShortcut {
-  flex: 0 0 auto;
-}
+    .lm-CommandPalette-item .lm-CommandPalette-itemShortcut {
+      flex: 0 0 auto;
+    }
 
-.lm-CommandPalette-itemCaption {
-  display: none;
-}
+    .lm-CommandPalette-itemCaption {
+      display: none;
+    }
 
-.lm-CommandPalette-content {
-  background-color: var(--jp-layout-color1);
-}
+    .lm-CommandPalette-content {
+      background-color: var(--jp-layout-color1);
+    }
 
-.lm-CommandPalette-content:empty::after {
-  content: 'No results';
-  margin: auto;
-  margin-top: 20px;
-  width: 100px;
-  display: block;
-  font-size: var(--jp-ui-font-size2);
-  font-family: var(--jp-ui-font-family);
-  font-weight: lighter;
-}
+    .lm-CommandPalette-content:empty::after {
+      content: 'No results';
+      margin: auto;
+      margin-top: 20px;
+      width: 100px;
+      display: block;
+      font-size: var(--jp-ui-font-size2);
+      font-family: var(--jp-ui-font-family);
+      font-weight: lighter;
+    }
 
-.lm-CommandPalette-emptyMessage {
-  text-align: center;
-  margin-top: 24px;
-  line-height: 1.32;
-  padding: 0 8px;
-  color: var(--jp-content-font-color3);
-}
+    .lm-CommandPalette-emptyMessage {
+      text-align: center;
+      margin-top: 24px;
+      line-height: 1.32;
+      padding: 0 8px;
+      color: var(--jp-content-font-color3);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2017, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-Dialog {
-  position: absolute;
-  z-index: 10000;
-  display: flex;
-  flex-direction: column;
-  align-items: center;
-  justify-content: center;
-  top: 0;
-  left: 0;
-  margin: 0;
-  padding: 0;
-  width: 100%;
-  height: 100%;
-  background: var(--jp-dialog-background);
-}
+    .jp-Dialog {
+      position: absolute;
+      z-index: 10000;
+      display: flex;
+      flex-direction: column;
+      align-items: center;
+      justify-content: center;
+      top: 0;
+      left: 0;
+      margin: 0;
+      padding: 0;
+      width: 100%;
+      height: 100%;
+      background: var(--jp-dialog-background);
+    }
 
-.jp-Dialog-content {
-  display: flex;
-  flex-direction: column;
-  margin-left: auto;
-  margin-right: auto;
-  background: var(--jp-layout-color1);
-  padding: 24px 24px 12px;
-  min-width: 300px;
-  min-height: 150px;
-  max-width: 1000px;
-  max-height: 500px;
-  box-sizing: border-box;
-  box-shadow: var(--jp-elevation-z20);
-  word-wrap: break-word;
-  border-radius: var(--jp-border-radius);
+    .jp-Dialog-content {
+      display: flex;
+      flex-direction: column;
+      margin-left: auto;
+      margin-right: auto;
+      background: var(--jp-layout-color1);
+      padding: 24px 24px 12px;
+      min-width: 300px;
+      min-height: 150px;
+      max-width: 1000px;
+      max-height: 500px;
+      box-sizing: border-box;
+      box-shadow: var(--jp-elevation-z20);
+      word-wrap: break-word;
+      border-radius: var(--jp-border-radius);
 
-  /* This is needed so that all font sizing of children done in ems is
+      /* This is needed so that all font sizing of children done in ems is
    * relative to this base size */
-  font-size: var(--jp-ui-font-size1);
-  color: var(--jp-ui-font-color1);
-  resize: both;
-}
+      font-size: var(--jp-ui-font-size1);
+      color: var(--jp-ui-font-color1);
+      resize: both;
+    }
 
-.jp-Dialog-content.jp-Dialog-content-small {
-  max-width: 500px;
-}
+    .jp-Dialog-content.jp-Dialog-content-small {
+      max-width: 500px;
+    }
 
-.jp-Dialog-button {
-  overflow: visible;
-}
+    .jp-Dialog-button {
+      overflow: visible;
+    }
 
-button.jp-Dialog-button:focus {
-  outline: 1px solid var(--jp-brand-color1);
-  outline-offset: 4px;
-  -moz-outline-radius: 0;
-}
+    button.jp-Dialog-button:focus {
+      outline: 1px solid var(--jp-brand-color1);
+      outline-offset: 4px;
+      -moz-outline-radius: 0;
+    }
 
-button.jp-Dialog-button:focus::-moz-focus-inner {
-  border: 0;
-}
+    button.jp-Dialog-button:focus::-moz-focus-inner {
+      border: 0;
+    }
 
-button.jp-Dialog-button.jp-mod-styled.jp-mod-accept:focus,
-button.jp-Dialog-button.jp-mod-styled.jp-mod-warn:focus,
-button.jp-Dialog-button.jp-mod-styled.jp-mod-reject:focus {
-  outline-offset: 4px;
-  -moz-outline-radius: 0;
-}
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-accept:focus,
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-warn:focus,
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-reject:focus {
+      outline-offset: 4px;
+      -moz-outline-radius: 0;
+    }
 
-button.jp-Dialog-button.jp-mod-styled.jp-mod-accept:focus {
-  outline: 1px solid var(--jp-accept-color-normal, var(--jp-brand-color1));
-}
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-accept:focus {
+      outline: 1px solid var(--jp-accept-color-normal, var(--jp-brand-color1));
+    }
 
-button.jp-Dialog-button.jp-mod-styled.jp-mod-warn:focus {
-  outline: 1px solid var(--jp-warn-color-normal, var(--jp-error-color1));
-}
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-warn:focus {
+      outline: 1px solid var(--jp-warn-color-normal, var(--jp-error-color1));
+    }
 
-button.jp-Dialog-button.jp-mod-styled.jp-mod-reject:focus {
-  outline: 1px solid var(--jp-reject-color-normal, var(--md-grey-600));
-}
+    button.jp-Dialog-button.jp-mod-styled.jp-mod-reject:focus {
+      outline: 1px solid var(--jp-reject-color-normal, var(--md-grey-600));
+    }
 
-button.jp-Dialog-close-button {
-  padding: 0;
-  height: 100%;
-  min-width: unset;
-  min-height: unset;
-}
+    button.jp-Dialog-close-button {
+      padding: 0;
+      height: 100%;
+      min-width: unset;
+      min-height: unset;
+    }
 
-.jp-Dialog-header {
-  display: flex;
-  justify-content: space-between;
-  flex: 0 0 auto;
-  padding-bottom: 12px;
-  font-size: var(--jp-ui-font-size3);
-  font-weight: 400;
-  color: var(--jp-ui-font-color1);
-}
+    .jp-Dialog-header {
+      display: flex;
+      justify-content: space-between;
+      flex: 0 0 auto;
+      padding-bottom: 12px;
+      font-size: var(--jp-ui-font-size3);
+      font-weight: 400;
+      color: var(--jp-ui-font-color1);
+    }
 
-.jp-Dialog-body {
-  display: flex;
-  flex-direction: column;
-  flex: 1 1 auto;
-  font-size: var(--jp-ui-font-size1);
-  background: var(--jp-layout-color1);
-  color: var(--jp-ui-font-color1);
-  overflow: auto;
-}
+    .jp-Dialog-body {
+      display: flex;
+      flex-direction: column;
+      flex: 1 1 auto;
+      font-size: var(--jp-ui-font-size1);
+      background: var(--jp-layout-color1);
+      color: var(--jp-ui-font-color1);
+      overflow: auto;
+    }
 
-.jp-Dialog-footer {
-  display: flex;
-  flex-direction: row;
-  justify-content: flex-end;
-  align-items: center;
-  flex: 0 0 auto;
-  margin-left: -12px;
-  margin-right: -12px;
-  padding: 12px;
-}
+    .jp-Dialog-footer {
+      display: flex;
+      flex-direction: row;
+      justify-content: flex-end;
+      align-items: center;
+      flex: 0 0 auto;
+      margin-left: -12px;
+      margin-right: -12px;
+      padding: 12px;
+    }
 
-.jp-Dialog-checkbox {
-  padding-right: 5px;
-}
+    .jp-Dialog-checkbox {
+      padding-right: 5px;
+    }
 
-.jp-Dialog-checkbox > input:focus-visible {
-  outline: 1px solid var(--jp-input-active-border-color);
-  outline-offset: 1px;
-}
+    .jp-Dialog-checkbox>input:focus-visible {
+      outline: 1px solid var(--jp-input-active-border-color);
+      outline-offset: 1px;
+    }
 
-.jp-Dialog-spacer {
-  flex: 1 1 auto;
-}
+    .jp-Dialog-spacer {
+      flex: 1 1 auto;
+    }
 
-.jp-Dialog-title {
-  overflow: hidden;
-  white-space: nowrap;
-  text-overflow: ellipsis;
-}
+    .jp-Dialog-title {
+      overflow: hidden;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+    }
 
-.jp-Dialog-body > .jp-select-wrapper {
-  width: 100%;
-}
+    .jp-Dialog-body>.jp-select-wrapper {
+      width: 100%;
+    }
 
-.jp-Dialog-body > button {
-  padding: 0 16px;
-}
+    .jp-Dialog-body>button {
+      padding: 0 16px;
+    }
 
-.jp-Dialog-body > label {
-  line-height: 1.4;
-  color: var(--jp-ui-font-color0);
-}
+    .jp-Dialog-body>label {
+      line-height: 1.4;
+      color: var(--jp-ui-font-color0);
+    }
 
-.jp-Dialog-button.jp-mod-styled:not(:last-child) {
-  margin-right: 12px;
-}
+    .jp-Dialog-button.jp-mod-styled:not(:last-child) {
+      margin-right: 12px;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.jp-Input-Boolean-Dialog {
-  flex-direction: row-reverse;
-  align-items: end;
-  width: 100%;
-}
+    .jp-Input-Boolean-Dialog {
+      flex-direction: row-reverse;
+      align-items: end;
+      width: 100%;
+    }
 
-.jp-Input-Boolean-Dialog > label {
-  flex: 1 1 auto;
-}
+    .jp-Input-Boolean-Dialog>label {
+      flex: 1 1 auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2016, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-MainAreaWidget > :focus {
-  outline: none;
-}
+    .jp-MainAreaWidget> :focus {
+      outline: none;
+    }
 
-.jp-MainAreaWidget .jp-MainAreaWidget-error {
-  padding: 6px;
-}
+    .jp-MainAreaWidget .jp-MainAreaWidget-error {
+      padding: 6px;
+    }
 
-.jp-MainAreaWidget .jp-MainAreaWidget-error > pre {
-  width: auto;
-  padding: 10px;
-  background: var(--jp-error-color3);
-  border: var(--jp-border-width) solid var(--jp-error-color1);
-  border-radius: var(--jp-border-radius);
-  color: var(--jp-ui-font-color1);
-  font-size: var(--jp-ui-font-size1);
-  white-space: pre-wrap;
-  word-wrap: break-word;
-}
+    .jp-MainAreaWidget .jp-MainAreaWidget-error>pre {
+      width: auto;
+      padding: 10px;
+      background: var(--jp-error-color3);
+      border: var(--jp-border-width) solid var(--jp-error-color1);
+      border-radius: var(--jp-border-radius);
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+      white-space: pre-wrap;
+      word-wrap: break-word;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/**
+    /**
  * google-material-color v1.2.6
  * https://github.com/danlevan/google-material-color
  */
-:root {
-  --md-red-50: #ffebee;
-  --md-red-100: #ffcdd2;
-  --md-red-200: #ef9a9a;
-  --md-red-300: #e57373;
-  --md-red-400: #ef5350;
-  --md-red-500: #f44336;
-  --md-red-600: #e53935;
-  --md-red-700: #d32f2f;
-  --md-red-800: #c62828;
-  --md-red-900: #b71c1c;
-  --md-red-A100: #ff8a80;
-  --md-red-A200: #ff5252;
-  --md-red-A400: #ff1744;
-  --md-red-A700: #d50000;
-  --md-pink-50: #fce4ec;
-  --md-pink-100: #f8bbd0;
-  --md-pink-200: #f48fb1;
-  --md-pink-300: #f06292;
-  --md-pink-400: #ec407a;
-  --md-pink-500: #e91e63;
-  --md-pink-600: #d81b60;
-  --md-pink-700: #c2185b;
-  --md-pink-800: #ad1457;
-  --md-pink-900: #880e4f;
-  --md-pink-A100: #ff80ab;
-  --md-pink-A200: #ff4081;
-  --md-pink-A400: #f50057;
-  --md-pink-A700: #c51162;
-  --md-purple-50: #f3e5f5;
-  --md-purple-100: #e1bee7;
-  --md-purple-200: #ce93d8;
-  --md-purple-300: #ba68c8;
-  --md-purple-400: #ab47bc;
-  --md-purple-500: #9c27b0;
-  --md-purple-600: #8e24aa;
-  --md-purple-700: #7b1fa2;
-  --md-purple-800: #6a1b9a;
-  --md-purple-900: #4a148c;
-  --md-purple-A100: #ea80fc;
-  --md-purple-A200: #e040fb;
-  --md-purple-A400: #d500f9;
-  --md-purple-A700: #a0f;
-  --md-deep-purple-50: #ede7f6;
-  --md-deep-purple-100: #d1c4e9;
-  --md-deep-purple-200: #b39ddb;
-  --md-deep-purple-300: #9575cd;
-  --md-deep-purple-400: #7e57c2;
-  --md-deep-purple-500: #673ab7;
-  --md-deep-purple-600: #5e35b1;
-  --md-deep-purple-700: #512da8;
-  --md-deep-purple-800: #4527a0;
-  --md-deep-purple-900: #311b92;
-  --md-deep-purple-A100: #b388ff;
-  --md-deep-purple-A200: #7c4dff;
-  --md-deep-purple-A400: #651fff;
-  --md-deep-purple-A700: #6200ea;
-  --md-indigo-50: #e8eaf6;
-  --md-indigo-100: #c5cae9;
-  --md-indigo-200: #9fa8da;
-  --md-indigo-300: #7986cb;
-  --md-indigo-400: #5c6bc0;
-  --md-indigo-500: #3f51b5;
-  --md-indigo-600: #3949ab;
-  --md-indigo-700: #303f9f;
-  --md-indigo-800: #283593;
-  --md-indigo-900: #1a237e;
-  --md-indigo-A100: #8c9eff;
-  --md-indigo-A200: #536dfe;
-  --md-indigo-A400: #3d5afe;
-  --md-indigo-A700: #304ffe;
-  --md-blue-50: #e3f2fd;
-  --md-blue-100: #bbdefb;
-  --md-blue-200: #90caf9;
-  --md-blue-300: #64b5f6;
-  --md-blue-400: #42a5f5;
-  --md-blue-500: #2196f3;
-  --md-blue-600: #1e88e5;
-  --md-blue-700: #1976d2;
-  --md-blue-800: #1565c0;
-  --md-blue-900: #0d47a1;
-  --md-blue-A100: #82b1ff;
-  --md-blue-A200: #448aff;
-  --md-blue-A400: #2979ff;
-  --md-blue-A700: #2962ff;
-  --md-light-blue-50: #e1f5fe;
-  --md-light-blue-100: #b3e5fc;
-  --md-light-blue-200: #81d4fa;
-  --md-light-blue-300: #4fc3f7;
-  --md-light-blue-400: #29b6f6;
-  --md-light-blue-500: #03a9f4;
-  --md-light-blue-600: #039be5;
-  --md-light-blue-700: #0288d1;
-  --md-light-blue-800: #0277bd;
-  --md-light-blue-900: #01579b;
-  --md-light-blue-A100: #80d8ff;
-  --md-light-blue-A200: #40c4ff;
-  --md-light-blue-A400: #00b0ff;
-  --md-light-blue-A700: #0091ea;
-  --md-cyan-50: #e0f7fa;
-  --md-cyan-100: #b2ebf2;
-  --md-cyan-200: #80deea;
-  --md-cyan-300: #4dd0e1;
-  --md-cyan-400: #26c6da;
-  --md-cyan-500: #00bcd4;
-  --md-cyan-600: #00acc1;
-  --md-cyan-700: #0097a7;
-  --md-cyan-800: #00838f;
-  --md-cyan-900: #006064;
-  --md-cyan-A100: #84ffff;
-  --md-cyan-A200: #18ffff;
-  --md-cyan-A400: #00e5ff;
-  --md-cyan-A700: #00b8d4;
-  --md-teal-50: #e0f2f1;
-  --md-teal-100: #b2dfdb;
-  --md-teal-200: #80cbc4;
-  --md-teal-300: #4db6ac;
-  --md-teal-400: #26a69a;
-  --md-teal-500: #009688;
-  --md-teal-600: #00897b;
-  --md-teal-700: #00796b;
-  --md-teal-800: #00695c;
-  --md-teal-900: #004d40;
-  --md-teal-A100: #a7ffeb;
-  --md-teal-A200: #64ffda;
-  --md-teal-A400: #1de9b6;
-  --md-teal-A700: #00bfa5;
-  --md-green-50: #e8f5e9;
-  --md-green-100: #c8e6c9;
-  --md-green-200: #a5d6a7;
-  --md-green-300: #81c784;
-  --md-green-400: #66bb6a;
-  --md-green-500: #4caf50;
-  --md-green-600: #43a047;
-  --md-green-700: #388e3c;
-  --md-green-800: #2e7d32;
-  --md-green-900: #1b5e20;
-  --md-green-A100: #b9f6ca;
-  --md-green-A200: #69f0ae;
-  --md-green-A400: #00e676;
-  --md-green-A700: #00c853;
-  --md-light-green-50: #f1f8e9;
-  --md-light-green-100: #dcedc8;
-  --md-light-green-200: #c5e1a5;
-  --md-light-green-300: #aed581;
-  --md-light-green-400: #9ccc65;
-  --md-light-green-500: #8bc34a;
-  --md-light-green-600: #7cb342;
-  --md-light-green-700: #689f38;
-  --md-light-green-800: #558b2f;
-  --md-light-green-900: #33691e;
-  --md-light-green-A100: #ccff90;
-  --md-light-green-A200: #b2ff59;
-  --md-light-green-A400: #76ff03;
-  --md-light-green-A700: #64dd17;
-  --md-lime-50: #f9fbe7;
-  --md-lime-100: #f0f4c3;
-  --md-lime-200: #e6ee9c;
-  --md-lime-300: #dce775;
-  --md-lime-400: #d4e157;
-  --md-lime-500: #cddc39;
-  --md-lime-600: #c0ca33;
-  --md-lime-700: #afb42b;
-  --md-lime-800: #9e9d24;
-  --md-lime-900: #827717;
-  --md-lime-A100: #f4ff81;
-  --md-lime-A200: #eeff41;
-  --md-lime-A400: #c6ff00;
-  --md-lime-A700: #aeea00;
-  --md-yellow-50: #fffde7;
-  --md-yellow-100: #fff9c4;
-  --md-yellow-200: #fff59d;
-  --md-yellow-300: #fff176;
-  --md-yellow-400: #ffee58;
-  --md-yellow-500: #ffeb3b;
-  --md-yellow-600: #fdd835;
-  --md-yellow-700: #fbc02d;
-  --md-yellow-800: #f9a825;
-  --md-yellow-900: #f57f17;
-  --md-yellow-A100: #ffff8d;
-  --md-yellow-A200: #ff0;
-  --md-yellow-A400: #ffea00;
-  --md-yellow-A700: #ffd600;
-  --md-amber-50: #fff8e1;
-  --md-amber-100: #ffecb3;
-  --md-amber-200: #ffe082;
-  --md-amber-300: #ffd54f;
-  --md-amber-400: #ffca28;
-  --md-amber-500: #ffc107;
-  --md-amber-600: #ffb300;
-  --md-amber-700: #ffa000;
-  --md-amber-800: #ff8f00;
-  --md-amber-900: #ff6f00;
-  --md-amber-A100: #ffe57f;
-  --md-amber-A200: #ffd740;
-  --md-amber-A400: #ffc400;
-  --md-amber-A700: #ffab00;
-  --md-orange-50: #fff3e0;
-  --md-orange-100: #ffe0b2;
-  --md-orange-200: #ffcc80;
-  --md-orange-300: #ffb74d;
-  --md-orange-400: #ffa726;
-  --md-orange-500: #ff9800;
-  --md-orange-600: #fb8c00;
-  --md-orange-700: #f57c00;
-  --md-orange-800: #ef6c00;
-  --md-orange-900: #e65100;
-  --md-orange-A100: #ffd180;
-  --md-orange-A200: #ffab40;
-  --md-orange-A400: #ff9100;
-  --md-orange-A700: #ff6d00;
-  --md-deep-orange-50: #fbe9e7;
-  --md-deep-orange-100: #ffccbc;
-  --md-deep-orange-200: #ffab91;
-  --md-deep-orange-300: #ff8a65;
-  --md-deep-orange-400: #ff7043;
-  --md-deep-orange-500: #ff5722;
-  --md-deep-orange-600: #f4511e;
-  --md-deep-orange-700: #e64a19;
-  --md-deep-orange-800: #d84315;
-  --md-deep-orange-900: #bf360c;
-  --md-deep-orange-A100: #ff9e80;
-  --md-deep-orange-A200: #ff6e40;
-  --md-deep-orange-A400: #ff3d00;
-  --md-deep-orange-A700: #dd2c00;
-  --md-brown-50: #efebe9;
-  --md-brown-100: #d7ccc8;
-  --md-brown-200: #bcaaa4;
-  --md-brown-300: #a1887f;
-  --md-brown-400: #8d6e63;
-  --md-brown-500: #795548;
-  --md-brown-600: #6d4c41;
-  --md-brown-700: #5d4037;
-  --md-brown-800: #4e342e;
-  --md-brown-900: #3e2723;
-  --md-grey-50: #fafafa;
-  --md-grey-100: #f5f5f5;
-  --md-grey-200: #eee;
-  --md-grey-300: #e0e0e0;
-  --md-grey-400: #bdbdbd;
-  --md-grey-500: #9e9e9e;
-  --md-grey-600: #757575;
-  --md-grey-700: #616161;
-  --md-grey-800: #424242;
-  --md-grey-900: #212121;
-  --md-blue-grey-50: #eceff1;
-  --md-blue-grey-100: #cfd8dc;
-  --md-blue-grey-200: #b0bec5;
-  --md-blue-grey-300: #90a4ae;
-  --md-blue-grey-400: #78909c;
-  --md-blue-grey-500: #607d8b;
-  --md-blue-grey-600: #546e7a;
-  --md-blue-grey-700: #455a64;
-  --md-blue-grey-800: #37474f;
-  --md-blue-grey-900: #263238;
-}
+    :root {
+      --md-red-50: #ffebee;
+      --md-red-100: #ffcdd2;
+      --md-red-200: #ef9a9a;
+      --md-red-300: #e57373;
+      --md-red-400: #ef5350;
+      --md-red-500: #f44336;
+      --md-red-600: #e53935;
+      --md-red-700: #d32f2f;
+      --md-red-800: #c62828;
+      --md-red-900: #b71c1c;
+      --md-red-A100: #ff8a80;
+      --md-red-A200: #ff5252;
+      --md-red-A400: #ff1744;
+      --md-red-A700: #d50000;
+      --md-pink-50: #fce4ec;
+      --md-pink-100: #f8bbd0;
+      --md-pink-200: #f48fb1;
+      --md-pink-300: #f06292;
+      --md-pink-400: #ec407a;
+      --md-pink-500: #e91e63;
+      --md-pink-600: #d81b60;
+      --md-pink-700: #c2185b;
+      --md-pink-800: #ad1457;
+      --md-pink-900: #880e4f;
+      --md-pink-A100: #ff80ab;
+      --md-pink-A200: #ff4081;
+      --md-pink-A400: #f50057;
+      --md-pink-A700: #c51162;
+      --md-purple-50: #f3e5f5;
+      --md-purple-100: #e1bee7;
+      --md-purple-200: #ce93d8;
+      --md-purple-300: #ba68c8;
+      --md-purple-400: #ab47bc;
+      --md-purple-500: #9c27b0;
+      --md-purple-600: #8e24aa;
+      --md-purple-700: #7b1fa2;
+      --md-purple-800: #6a1b9a;
+      --md-purple-900: #4a148c;
+      --md-purple-A100: #ea80fc;
+      --md-purple-A200: #e040fb;
+      --md-purple-A400: #d500f9;
+      --md-purple-A700: #a0f;
+      --md-deep-purple-50: #ede7f6;
+      --md-deep-purple-100: #d1c4e9;
+      --md-deep-purple-200: #b39ddb;
+      --md-deep-purple-300: #9575cd;
+      --md-deep-purple-400: #7e57c2;
+      --md-deep-purple-500: #673ab7;
+      --md-deep-purple-600: #5e35b1;
+      --md-deep-purple-700: #512da8;
+      --md-deep-purple-800: #4527a0;
+      --md-deep-purple-900: #311b92;
+      --md-deep-purple-A100: #b388ff;
+      --md-deep-purple-A200: #7c4dff;
+      --md-deep-purple-A400: #651fff;
+      --md-deep-purple-A700: #6200ea;
+      --md-indigo-50: #e8eaf6;
+      --md-indigo-100: #c5cae9;
+      --md-indigo-200: #9fa8da;
+      --md-indigo-300: #7986cb;
+      --md-indigo-400: #5c6bc0;
+      --md-indigo-500: #3f51b5;
+      --md-indigo-600: #3949ab;
+      --md-indigo-700: #303f9f;
+      --md-indigo-800: #283593;
+      --md-indigo-900: #1a237e;
+      --md-indigo-A100: #8c9eff;
+      --md-indigo-A200: #536dfe;
+      --md-indigo-A400: #3d5afe;
+      --md-indigo-A700: #304ffe;
+      --md-blue-50: #e3f2fd;
+      --md-blue-100: #bbdefb;
+      --md-blue-200: #90caf9;
+      --md-blue-300: #64b5f6;
+      --md-blue-400: #42a5f5;
+      --md-blue-500: #2196f3;
+      --md-blue-600: #1e88e5;
+      --md-blue-700: #1976d2;
+      --md-blue-800: #1565c0;
+      --md-blue-900: #0d47a1;
+      --md-blue-A100: #82b1ff;
+      --md-blue-A200: #448aff;
+      --md-blue-A400: #2979ff;
+      --md-blue-A700: #2962ff;
+      --md-light-blue-50: #e1f5fe;
+      --md-light-blue-100: #b3e5fc;
+      --md-light-blue-200: #81d4fa;
+      --md-light-blue-300: #4fc3f7;
+      --md-light-blue-400: #29b6f6;
+      --md-light-blue-500: #03a9f4;
+      --md-light-blue-600: #039be5;
+      --md-light-blue-700: #0288d1;
+      --md-light-blue-800: #0277bd;
+      --md-light-blue-900: #01579b;
+      --md-light-blue-A100: #80d8ff;
+      --md-light-blue-A200: #40c4ff;
+      --md-light-blue-A400: #00b0ff;
+      --md-light-blue-A700: #0091ea;
+      --md-cyan-50: #e0f7fa;
+      --md-cyan-100: #b2ebf2;
+      --md-cyan-200: #80deea;
+      --md-cyan-300: #4dd0e1;
+      --md-cyan-400: #26c6da;
+      --md-cyan-500: #00bcd4;
+      --md-cyan-600: #00acc1;
+      --md-cyan-700: #0097a7;
+      --md-cyan-800: #00838f;
+      --md-cyan-900: #006064;
+      --md-cyan-A100: #84ffff;
+      --md-cyan-A200: #18ffff;
+      --md-cyan-A400: #00e5ff;
+      --md-cyan-A700: #00b8d4;
+      --md-teal-50: #e0f2f1;
+      --md-teal-100: #b2dfdb;
+      --md-teal-200: #80cbc4;
+      --md-teal-300: #4db6ac;
+      --md-teal-400: #26a69a;
+      --md-teal-500: #009688;
+      --md-teal-600: #00897b;
+      --md-teal-700: #00796b;
+      --md-teal-800: #00695c;
+      --md-teal-900: #004d40;
+      --md-teal-A100: #a7ffeb;
+      --md-teal-A200: #64ffda;
+      --md-teal-A400: #1de9b6;
+      --md-teal-A700: #00bfa5;
+      --md-green-50: #e8f5e9;
+      --md-green-100: #c8e6c9;
+      --md-green-200: #a5d6a7;
+      --md-green-300: #81c784;
+      --md-green-400: #66bb6a;
+      --md-green-500: #4caf50;
+      --md-green-600: #43a047;
+      --md-green-700: #388e3c;
+      --md-green-800: #2e7d32;
+      --md-green-900: #1b5e20;
+      --md-green-A100: #b9f6ca;
+      --md-green-A200: #69f0ae;
+      --md-green-A400: #00e676;
+      --md-green-A700: #00c853;
+      --md-light-green-50: #f1f8e9;
+      --md-light-green-100: #dcedc8;
+      --md-light-green-200: #c5e1a5;
+      --md-light-green-300: #aed581;
+      --md-light-green-400: #9ccc65;
+      --md-light-green-500: #8bc34a;
+      --md-light-green-600: #7cb342;
+      --md-light-green-700: #689f38;
+      --md-light-green-800: #558b2f;
+      --md-light-green-900: #33691e;
+      --md-light-green-A100: #ccff90;
+      --md-light-green-A200: #b2ff59;
+      --md-light-green-A400: #76ff03;
+      --md-light-green-A700: #64dd17;
+      --md-lime-50: #f9fbe7;
+      --md-lime-100: #f0f4c3;
+      --md-lime-200: #e6ee9c;
+      --md-lime-300: #dce775;
+      --md-lime-400: #d4e157;
+      --md-lime-500: #cddc39;
+      --md-lime-600: #c0ca33;
+      --md-lime-700: #afb42b;
+      --md-lime-800: #9e9d24;
+      --md-lime-900: #827717;
+      --md-lime-A100: #f4ff81;
+      --md-lime-A200: #eeff41;
+      --md-lime-A400: #c6ff00;
+      --md-lime-A700: #aeea00;
+      --md-yellow-50: #fffde7;
+      --md-yellow-100: #fff9c4;
+      --md-yellow-200: #fff59d;
+      --md-yellow-300: #fff176;
+      --md-yellow-400: #ffee58;
+      --md-yellow-500: #ffeb3b;
+      --md-yellow-600: #fdd835;
+      --md-yellow-700: #fbc02d;
+      --md-yellow-800: #f9a825;
+      --md-yellow-900: #f57f17;
+      --md-yellow-A100: #ffff8d;
+      --md-yellow-A200: #ff0;
+      --md-yellow-A400: #ffea00;
+      --md-yellow-A700: #ffd600;
+      --md-amber-50: #fff8e1;
+      --md-amber-100: #ffecb3;
+      --md-amber-200: #ffe082;
+      --md-amber-300: #ffd54f;
+      --md-amber-400: #ffca28;
+      --md-amber-500: #ffc107;
+      --md-amber-600: #ffb300;
+      --md-amber-700: #ffa000;
+      --md-amber-800: #ff8f00;
+      --md-amber-900: #ff6f00;
+      --md-amber-A100: #ffe57f;
+      --md-amber-A200: #ffd740;
+      --md-amber-A400: #ffc400;
+      --md-amber-A700: #ffab00;
+      --md-orange-50: #fff3e0;
+      --md-orange-100: #ffe0b2;
+      --md-orange-200: #ffcc80;
+      --md-orange-300: #ffb74d;
+      --md-orange-400: #ffa726;
+      --md-orange-500: #ff9800;
+      --md-orange-600: #fb8c00;
+      --md-orange-700: #f57c00;
+      --md-orange-800: #ef6c00;
+      --md-orange-900: #e65100;
+      --md-orange-A100: #ffd180;
+      --md-orange-A200: #ffab40;
+      --md-orange-A400: #ff9100;
+      --md-orange-A700: #ff6d00;
+      --md-deep-orange-50: #fbe9e7;
+      --md-deep-orange-100: #ffccbc;
+      --md-deep-orange-200: #ffab91;
+      --md-deep-orange-300: #ff8a65;
+      --md-deep-orange-400: #ff7043;
+      --md-deep-orange-500: #ff5722;
+      --md-deep-orange-600: #f4511e;
+      --md-deep-orange-700: #e64a19;
+      --md-deep-orange-800: #d84315;
+      --md-deep-orange-900: #bf360c;
+      --md-deep-orange-A100: #ff9e80;
+      --md-deep-orange-A200: #ff6e40;
+      --md-deep-orange-A400: #ff3d00;
+      --md-deep-orange-A700: #dd2c00;
+      --md-brown-50: #efebe9;
+      --md-brown-100: #d7ccc8;
+      --md-brown-200: #bcaaa4;
+      --md-brown-300: #a1887f;
+      --md-brown-400: #8d6e63;
+      --md-brown-500: #795548;
+      --md-brown-600: #6d4c41;
+      --md-brown-700: #5d4037;
+      --md-brown-800: #4e342e;
+      --md-brown-900: #3e2723;
+      --md-grey-50: #fafafa;
+      --md-grey-100: #f5f5f5;
+      --md-grey-200: #eee;
+      --md-grey-300: #e0e0e0;
+      --md-grey-400: #bdbdbd;
+      --md-grey-500: #9e9e9e;
+      --md-grey-600: #757575;
+      --md-grey-700: #616161;
+      --md-grey-800: #424242;
+      --md-grey-900: #212121;
+      --md-blue-grey-50: #eceff1;
+      --md-blue-grey-100: #cfd8dc;
+      --md-blue-grey-200: #b0bec5;
+      --md-blue-grey-300: #90a4ae;
+      --md-blue-grey-400: #78909c;
+      --md-blue-grey-500: #607d8b;
+      --md-blue-grey-600: #546e7a;
+      --md-blue-grey-700: #455a64;
+      --md-blue-grey-800: #37474f;
+      --md-blue-grey-900: #263238;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2017, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | RenderedText
 |----------------------------------------------------------------------------*/
 
-:root {
-  /* This is the padding value to fill the gaps between lines containing spans with background color. */
-  --jp-private-code-span-padding: calc(
-    (var(--jp-code-line-height) - 1) * var(--jp-code-font-size) / 2
-  );
-}
+    :root {
+      /* This is the padding value to fill the gaps between lines containing spans with background color. */
+      --jp-private-code-span-padding: calc((var(--jp-code-line-height) - 1) * var(--jp-code-font-size) / 2);
+    }
 
-.jp-RenderedText {
-  text-align: left;
-  padding-left: var(--jp-code-padding);
-  line-height: var(--jp-code-line-height);
-  font-family: var(--jp-code-font-family);
-}
+    .jp-RenderedText {
+      text-align: left;
+      padding-left: var(--jp-code-padding);
+      line-height: var(--jp-code-line-height);
+      font-family: var(--jp-code-font-family);
+    }
 
-.jp-RenderedText pre,
-.jp-RenderedJavaScript pre,
-.jp-RenderedHTMLCommon pre {
-  color: var(--jp-content-font-color1);
-  font-size: var(--jp-code-font-size);
-  border: none;
-  margin: 0;
-  padding: 0;
-}
+    .jp-RenderedText pre,
+    .jp-RenderedJavaScript pre,
+    .jp-RenderedHTMLCommon pre {
+      color: var(--jp-content-font-color1);
+      font-size: var(--jp-code-font-size);
+      border: none;
+      margin: 0;
+      padding: 0;
+    }
 
-.jp-RenderedText pre a:link {
-  text-decoration: none;
-  color: var(--jp-content-link-color);
-}
+    .jp-RenderedText pre a:link {
+      text-decoration: none;
+      color: var(--jp-content-link-color);
+    }
 
-.jp-RenderedText pre a:hover {
-  text-decoration: underline;
-  color: var(--jp-content-link-color);
-}
+    .jp-RenderedText pre a:hover {
+      text-decoration: underline;
+      color: var(--jp-content-link-color);
+    }
 
-.jp-RenderedText pre a:visited {
-  text-decoration: none;
-  color: var(--jp-content-link-color);
-}
+    .jp-RenderedText pre a:visited {
+      text-decoration: none;
+      color: var(--jp-content-link-color);
+    }
 
-/* console foregrounds and backgrounds */
-.jp-RenderedText pre .ansi-black-fg {
-  color: #3e424d;
-}
+    /* console foregrounds and backgrounds */
+    .jp-RenderedText pre .ansi-black-fg {
+      color: #3e424d;
+    }
 
-.jp-RenderedText pre .ansi-red-fg {
-  color: #e75c58;
-}
+    .jp-RenderedText pre .ansi-red-fg {
+      color: #e75c58;
+    }
 
-.jp-RenderedText pre .ansi-green-fg {
-  color: #00a250;
-}
+    .jp-RenderedText pre .ansi-green-fg {
+      color: #00a250;
+    }
 
-.jp-RenderedText pre .ansi-yellow-fg {
-  color: #ddb62b;
-}
+    .jp-RenderedText pre .ansi-yellow-fg {
+      color: #ddb62b;
+    }
 
-.jp-RenderedText pre .ansi-blue-fg {
-  color: #208ffb;
-}
+    .jp-RenderedText pre .ansi-blue-fg {
+      color: #208ffb;
+    }
 
-.jp-RenderedText pre .ansi-magenta-fg {
-  color: #d160c4;
-}
+    .jp-RenderedText pre .ansi-magenta-fg {
+      color: #d160c4;
+    }
 
-.jp-RenderedText pre .ansi-cyan-fg {
-  color: #60c6c8;
-}
+    .jp-RenderedText pre .ansi-cyan-fg {
+      color: #60c6c8;
+    }
 
-.jp-RenderedText pre .ansi-white-fg {
-  color: #c5c1b4;
-}
+    .jp-RenderedText pre .ansi-white-fg {
+      color: #c5c1b4;
+    }
 
-.jp-RenderedText pre .ansi-black-bg {
-  background-color: #3e424d;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-black-bg {
+      background-color: #3e424d;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-red-bg {
-  background-color: #e75c58;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-red-bg {
+      background-color: #e75c58;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-green-bg {
-  background-color: #00a250;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-green-bg {
+      background-color: #00a250;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-yellow-bg {
-  background-color: #ddb62b;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-yellow-bg {
+      background-color: #ddb62b;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-blue-bg {
-  background-color: #208ffb;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-blue-bg {
+      background-color: #208ffb;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-magenta-bg {
-  background-color: #d160c4;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-magenta-bg {
+      background-color: #d160c4;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-cyan-bg {
-  background-color: #60c6c8;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-cyan-bg {
+      background-color: #60c6c8;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-white-bg {
-  background-color: #c5c1b4;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-white-bg {
+      background-color: #c5c1b4;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-black-intense-fg {
-  color: #282c36;
-}
+    .jp-RenderedText pre .ansi-black-intense-fg {
+      color: #282c36;
+    }
 
-.jp-RenderedText pre .ansi-red-intense-fg {
-  color: #b22b31;
-}
+    .jp-RenderedText pre .ansi-red-intense-fg {
+      color: #b22b31;
+    }
 
-.jp-RenderedText pre .ansi-green-intense-fg {
-  color: #007427;
-}
+    .jp-RenderedText pre .ansi-green-intense-fg {
+      color: #007427;
+    }
 
-.jp-RenderedText pre .ansi-yellow-intense-fg {
-  color: #b27d12;
-}
+    .jp-RenderedText pre .ansi-yellow-intense-fg {
+      color: #b27d12;
+    }
 
-.jp-RenderedText pre .ansi-blue-intense-fg {
-  color: #0065ca;
-}
+    .jp-RenderedText pre .ansi-blue-intense-fg {
+      color: #0065ca;
+    }
 
-.jp-RenderedText pre .ansi-magenta-intense-fg {
-  color: #a03196;
-}
+    .jp-RenderedText pre .ansi-magenta-intense-fg {
+      color: #a03196;
+    }
 
-.jp-RenderedText pre .ansi-cyan-intense-fg {
-  color: #258f8f;
-}
+    .jp-RenderedText pre .ansi-cyan-intense-fg {
+      color: #258f8f;
+    }
 
-.jp-RenderedText pre .ansi-white-intense-fg {
-  color: #a1a6b2;
-}
+    .jp-RenderedText pre .ansi-white-intense-fg {
+      color: #a1a6b2;
+    }
 
-.jp-RenderedText pre .ansi-black-intense-bg {
-  background-color: #282c36;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-black-intense-bg {
+      background-color: #282c36;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-red-intense-bg {
-  background-color: #b22b31;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-red-intense-bg {
+      background-color: #b22b31;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-green-intense-bg {
-  background-color: #007427;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-green-intense-bg {
+      background-color: #007427;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-yellow-intense-bg {
-  background-color: #b27d12;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-yellow-intense-bg {
+      background-color: #b27d12;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-blue-intense-bg {
-  background-color: #0065ca;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-blue-intense-bg {
+      background-color: #0065ca;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-magenta-intense-bg {
-  background-color: #a03196;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-magenta-intense-bg {
+      background-color: #a03196;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-cyan-intense-bg {
-  background-color: #258f8f;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-cyan-intense-bg {
+      background-color: #258f8f;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-white-intense-bg {
-  background-color: #a1a6b2;
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-white-intense-bg {
+      background-color: #a1a6b2;
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-default-inverse-fg {
-  color: var(--jp-ui-inverse-font-color0);
-}
+    .jp-RenderedText pre .ansi-default-inverse-fg {
+      color: var(--jp-ui-inverse-font-color0);
+    }
 
-.jp-RenderedText pre .ansi-default-inverse-bg {
-  background-color: var(--jp-inverse-layout-color0);
-  padding: var(--jp-private-code-span-padding) 0;
-}
+    .jp-RenderedText pre .ansi-default-inverse-bg {
+      background-color: var(--jp-inverse-layout-color0);
+      padding: var(--jp-private-code-span-padding) 0;
+    }
 
-.jp-RenderedText pre .ansi-bold {
-  font-weight: bold;
-}
+    .jp-RenderedText pre .ansi-bold {
+      font-weight: bold;
+    }
 
-.jp-RenderedText pre .ansi-underline {
-  text-decoration: underline;
-}
+    .jp-RenderedText pre .ansi-underline {
+      text-decoration: underline;
+    }
 
-.jp-RenderedText[data-mime-type='application/vnd.jupyter.stderr'] {
-  background: var(--jp-rendermime-error-background);
-  padding-top: var(--jp-code-padding);
-}
+    .jp-RenderedText[data-mime-type='application/vnd.jupyter.stderr'] {
+      background: var(--jp-rendermime-error-background);
+      padding-top: var(--jp-code-padding);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | RenderedLatex
 |----------------------------------------------------------------------------*/
 
-.jp-RenderedLatex {
-  color: var(--jp-content-font-color1);
-  font-size: var(--jp-content-font-size1);
-  line-height: var(--jp-content-line-height);
-}
+    .jp-RenderedLatex {
+      color: var(--jp-content-font-color1);
+      font-size: var(--jp-content-font-size1);
+      line-height: var(--jp-content-line-height);
+    }
 
-/* Left-justify outputs.*/
-.jp-OutputArea-output.jp-RenderedLatex {
-  padding: var(--jp-code-padding);
-  text-align: left;
-}
+    /* Left-justify outputs.*/
+    .jp-OutputArea-output.jp-RenderedLatex {
+      padding: var(--jp-code-padding);
+      text-align: left;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | RenderedHTML
 |----------------------------------------------------------------------------*/
 
-.jp-RenderedHTMLCommon {
-  color: var(--jp-content-font-color1);
-  font-family: var(--jp-content-font-family);
-  font-size: var(--jp-content-font-size1);
-  line-height: var(--jp-content-line-height);
-
-  /* Give a bit more R padding on Markdown text to keep line lengths reasonable */
-  padding-right: 20px;
-}
-
-.jp-RenderedHTMLCommon em {
-  font-style: italic;
-}
-
-.jp-RenderedHTMLCommon strong {
-  font-weight: bold;
-}
-
-.jp-RenderedHTMLCommon u {
-  text-decoration: underline;
-}
-
-.jp-RenderedHTMLCommon a:link {
-  text-decoration: none;
-  color: var(--jp-content-link-color);
-}
-
-.jp-RenderedHTMLCommon a:hover {
-  text-decoration: underline;
-  color: var(--jp-content-link-color);
-}
-
-.jp-RenderedHTMLCommon a:visited {
-  text-decoration: none;
-  color: var(--jp-content-link-color);
-}
-
-/* Headings */
-
-.jp-RenderedHTMLCommon h1,
-.jp-RenderedHTMLCommon h2,
-.jp-RenderedHTMLCommon h3,
-.jp-RenderedHTMLCommon h4,
-.jp-RenderedHTMLCommon h5,
-.jp-RenderedHTMLCommon h6 {
-  line-height: var(--jp-content-heading-line-height);
-  font-weight: var(--jp-content-heading-font-weight);
-  font-style: normal;
-  margin: var(--jp-content-heading-margin-top) 0
-    var(--jp-content-heading-margin-bottom) 0;
-}
-
-.jp-RenderedHTMLCommon h1:first-child,
-.jp-RenderedHTMLCommon h2:first-child,
-.jp-RenderedHTMLCommon h3:first-child,
-.jp-RenderedHTMLCommon h4:first-child,
-.jp-RenderedHTMLCommon h5:first-child,
-.jp-RenderedHTMLCommon h6:first-child {
-  margin-top: calc(0.5 * var(--jp-content-heading-margin-top));
-}
-
-.jp-RenderedHTMLCommon h1:last-child,
-.jp-RenderedHTMLCommon h2:last-child,
-.jp-RenderedHTMLCommon h3:last-child,
-.jp-RenderedHTMLCommon h4:last-child,
-.jp-RenderedHTMLCommon h5:last-child,
-.jp-RenderedHTMLCommon h6:last-child {
-  margin-bottom: calc(0.5 * var(--jp-content-heading-margin-bottom));
-}
-
-.jp-RenderedHTMLCommon h1 {
-  font-size: var(--jp-content-font-size5);
-}
-
-.jp-RenderedHTMLCommon h2 {
-  font-size: var(--jp-content-font-size4);
-}
-
-.jp-RenderedHTMLCommon h3 {
-  font-size: var(--jp-content-font-size3);
-}
-
-.jp-RenderedHTMLCommon h4 {
-  font-size: var(--jp-content-font-size2);
-}
-
-.jp-RenderedHTMLCommon h5 {
-  font-size: var(--jp-content-font-size1);
-}
-
-.jp-RenderedHTMLCommon h6 {
-  font-size: var(--jp-content-font-size0);
-}
-
-/* Lists */
-
-/* stylelint-disable selector-max-type, selector-max-compound-selectors */
-
-.jp-RenderedHTMLCommon ul:not(.list-inline),
-.jp-RenderedHTMLCommon ol:not(.list-inline) {
-  padding-left: 2em;
-}
-
-.jp-RenderedHTMLCommon ul {
-  list-style: disc;
-}
-
-.jp-RenderedHTMLCommon ul ul {
-  list-style: square;
-}
-
-.jp-RenderedHTMLCommon ul ul ul {
-  list-style: circle;
-}
-
-.jp-RenderedHTMLCommon ol {
-  list-style: decimal;
-}
-
-.jp-RenderedHTMLCommon ol ol {
-  list-style: upper-alpha;
-}
-
-.jp-RenderedHTMLCommon ol ol ol {
-  list-style: lower-alpha;
-}
-
-.jp-RenderedHTMLCommon ol ol ol ol {
-  list-style: lower-roman;
-}
-
-.jp-RenderedHTMLCommon ol ol ol ol ol {
-  list-style: decimal;
-}
-
-.jp-RenderedHTMLCommon ol,
-.jp-RenderedHTMLCommon ul {
-  margin-bottom: 1em;
-}
-
-.jp-RenderedHTMLCommon ul ul,
-.jp-RenderedHTMLCommon ul ol,
-.jp-RenderedHTMLCommon ol ul,
-.jp-RenderedHTMLCommon ol ol {
-  margin-bottom: 0;
-}
-
-/* stylelint-enable selector-max-type, selector-max-compound-selectors */
-
-.jp-RenderedHTMLCommon hr {
-  color: var(--jp-border-color2);
-  background-color: var(--jp-border-color1);
-  margin-top: 1em;
-  margin-bottom: 1em;
-}
-
-.jp-RenderedHTMLCommon > pre {
-  margin: 1.5em 2em;
-}
-
-.jp-RenderedHTMLCommon pre,
-.jp-RenderedHTMLCommon code {
-  border: 0;
-  background-color: var(--jp-layout-color0);
-  color: var(--jp-content-font-color1);
-  font-family: var(--jp-code-font-family);
-  font-size: inherit;
-  line-height: var(--jp-code-line-height);
-  padding: 0;
-  white-space: pre-wrap;
-}
-
-.jp-RenderedHTMLCommon :not(pre) > code {
-  background-color: var(--jp-layout-color2);
-  padding: 1px 5px;
-}
-
-/* Tables */
-
-.jp-RenderedHTMLCommon table {
-  border-collapse: collapse;
-  border-spacing: 0;
-  border: none;
-  color: var(--jp-ui-font-color1);
-  font-size: var(--jp-ui-font-size1);
-  table-layout: fixed;
-  margin-left: auto;
-  margin-bottom: 1em;
-  margin-right: auto;
-}
-
-.jp-RenderedHTMLCommon thead {
-  border-bottom: var(--jp-border-width) solid var(--jp-border-color1);
-  vertical-align: bottom;
-}
-
-.jp-RenderedHTMLCommon td,
-.jp-RenderedHTMLCommon th,
-.jp-RenderedHTMLCommon tr {
-  vertical-align: middle;
-  padding: 0.5em;
-  line-height: normal;
-  white-space: normal;
-  max-width: none;
-  border: none;
-}
-
-.jp-RenderedMarkdown.jp-RenderedHTMLCommon td,
-.jp-RenderedMarkdown.jp-RenderedHTMLCommon th {
-  max-width: none;
-}
-
-:not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon td,
-:not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon th,
-:not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon tr {
-  text-align: right;
-}
-
-.jp-RenderedHTMLCommon th {
-  font-weight: bold;
-}
-
-.jp-RenderedHTMLCommon tbody tr:nth-child(odd) {
-  background: var(--jp-layout-color0);
-}
-
-.jp-RenderedHTMLCommon tbody tr:nth-child(even) {
-  background: var(--jp-rendermime-table-row-background);
-}
-
-.jp-RenderedHTMLCommon tbody tr:hover {
-  background: var(--jp-rendermime-table-row-hover-background);
-}
-
-.jp-RenderedHTMLCommon p {
-  text-align: left;
-  margin: 0;
-  margin-bottom: 1em;
-}
-
-.jp-RenderedHTMLCommon img {
-  -moz-force-broken-image-icon: 1;
-}
-
-/* Restrict to direct children as other images could be nested in other content. */
-.jp-RenderedHTMLCommon > img {
-  display: block;
-  margin-left: 0;
-  margin-right: 0;
-  margin-bottom: 1em;
-}
-
-/* Change color behind transparent images if they need it... */
-[data-jp-theme-light='false'] .jp-RenderedImage img.jp-needs-light-background {
-  background-color: var(--jp-inverse-layout-color1);
-}
-
-[data-jp-theme-light='true'] .jp-RenderedImage img.jp-needs-dark-background {
-  background-color: var(--jp-inverse-layout-color1);
-}
-
-.jp-RenderedHTMLCommon img,
-.jp-RenderedImage img,
-.jp-RenderedHTMLCommon svg,
-.jp-RenderedSVG svg {
-  max-width: 100%;
-  height: auto;
-}
-
-.jp-RenderedHTMLCommon img.jp-mod-unconfined,
-.jp-RenderedImage img.jp-mod-unconfined,
-.jp-RenderedHTMLCommon svg.jp-mod-unconfined,
-.jp-RenderedSVG svg.jp-mod-unconfined {
-  max-width: none;
-}
-
-.jp-RenderedHTMLCommon .alert {
-  padding: var(--jp-notebook-padding);
-  border: var(--jp-border-width) solid transparent;
-  border-radius: var(--jp-border-radius);
-  margin-bottom: 1em;
-}
-
-.jp-RenderedHTMLCommon .alert-info {
-  color: var(--jp-info-color0);
-  background-color: var(--jp-info-color3);
-  border-color: var(--jp-info-color2);
-}
-
-.jp-RenderedHTMLCommon .alert-info hr {
-  border-color: var(--jp-info-color3);
-}
-
-.jp-RenderedHTMLCommon .alert-info > p:last-child,
-.jp-RenderedHTMLCommon .alert-info > ul:last-child {
-  margin-bottom: 0;
-}
-
-.jp-RenderedHTMLCommon .alert-warning {
-  color: var(--jp-warn-color0);
-  background-color: var(--jp-warn-color3);
-  border-color: var(--jp-warn-color2);
-}
-
-.jp-RenderedHTMLCommon .alert-warning hr {
-  border-color: var(--jp-warn-color3);
-}
-
-.jp-RenderedHTMLCommon .alert-warning > p:last-child,
-.jp-RenderedHTMLCommon .alert-warning > ul:last-child {
-  margin-bottom: 0;
-}
-
-.jp-RenderedHTMLCommon .alert-success {
-  color: var(--jp-success-color0);
-  background-color: var(--jp-success-color3);
-  border-color: var(--jp-success-color2);
-}
-
-.jp-RenderedHTMLCommon .alert-success hr {
-  border-color: var(--jp-success-color3);
-}
-
-.jp-RenderedHTMLCommon .alert-success > p:last-child,
-.jp-RenderedHTMLCommon .alert-success > ul:last-child {
-  margin-bottom: 0;
-}
-
-.jp-RenderedHTMLCommon .alert-danger {
-  color: var(--jp-error-color0);
-  background-color: var(--jp-error-color3);
-  border-color: var(--jp-error-color2);
-}
-
-.jp-RenderedHTMLCommon .alert-danger hr {
-  border-color: var(--jp-error-color3);
-}
-
-.jp-RenderedHTMLCommon .alert-danger > p:last-child,
-.jp-RenderedHTMLCommon .alert-danger > ul:last-child {
-  margin-bottom: 0;
-}
-
-.jp-RenderedHTMLCommon blockquote {
-  margin: 1em 2em;
-  padding: 0 1em;
-  border-left: 5px solid var(--jp-border-color2);
-}
-
-a.jp-InternalAnchorLink {
-  visibility: hidden;
-  margin-left: 8px;
-  color: var(--md-blue-800);
-}
-
-h1:hover .jp-InternalAnchorLink,
-h2:hover .jp-InternalAnchorLink,
-h3:hover .jp-InternalAnchorLink,
-h4:hover .jp-InternalAnchorLink,
-h5:hover .jp-InternalAnchorLink,
-h6:hover .jp-InternalAnchorLink {
-  visibility: visible;
-}
-
-.jp-RenderedHTMLCommon kbd {
-  background-color: var(--jp-rendermime-table-row-background);
-  border: 1px solid var(--jp-border-color0);
-  border-bottom-color: var(--jp-border-color2);
-  border-radius: 3px;
-  box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.25);
-  display: inline-block;
-  font-size: var(--jp-ui-font-size0);
-  line-height: 1em;
-  padding: 0.2em 0.5em;
-}
-
-/* Most direct children of .jp-RenderedHTMLCommon have a margin-bottom of 1.0.
+    .jp-RenderedHTMLCommon {
+      color: var(--jp-content-font-color1);
+      font-family: var(--jp-content-font-family);
+      font-size: var(--jp-content-font-size1);
+      line-height: var(--jp-content-line-height);
+
+      /* Give a bit more R padding on Markdown text to keep line lengths reasonable */
+      padding-right: 20px;
+    }
+
+    .jp-RenderedHTMLCommon em {
+      font-style: italic;
+    }
+
+    .jp-RenderedHTMLCommon strong {
+      font-weight: bold;
+    }
+
+    .jp-RenderedHTMLCommon u {
+      text-decoration: underline;
+    }
+
+    .jp-RenderedHTMLCommon a:link {
+      text-decoration: none;
+      color: var(--jp-content-link-color);
+    }
+
+    .jp-RenderedHTMLCommon a:hover {
+      text-decoration: underline;
+      color: var(--jp-content-link-color);
+    }
+
+    .jp-RenderedHTMLCommon a:visited {
+      text-decoration: none;
+      color: var(--jp-content-link-color);
+    }
+
+    /* Headings */
+
+    .jp-RenderedHTMLCommon h1,
+    .jp-RenderedHTMLCommon h2,
+    .jp-RenderedHTMLCommon h3,
+    .jp-RenderedHTMLCommon h4,
+    .jp-RenderedHTMLCommon h5,
+    .jp-RenderedHTMLCommon h6 {
+      line-height: var(--jp-content-heading-line-height);
+      font-weight: var(--jp-content-heading-font-weight);
+      font-style: normal;
+      margin: var(--jp-content-heading-margin-top) 0 var(--jp-content-heading-margin-bottom) 0;
+    }
+
+    .jp-RenderedHTMLCommon h1:first-child,
+    .jp-RenderedHTMLCommon h2:first-child,
+    .jp-RenderedHTMLCommon h3:first-child,
+    .jp-RenderedHTMLCommon h4:first-child,
+    .jp-RenderedHTMLCommon h5:first-child,
+    .jp-RenderedHTMLCommon h6:first-child {
+      margin-top: calc(0.5 * var(--jp-content-heading-margin-top));
+    }
+
+    .jp-RenderedHTMLCommon h1:last-child,
+    .jp-RenderedHTMLCommon h2:last-child,
+    .jp-RenderedHTMLCommon h3:last-child,
+    .jp-RenderedHTMLCommon h4:last-child,
+    .jp-RenderedHTMLCommon h5:last-child,
+    .jp-RenderedHTMLCommon h6:last-child {
+      margin-bottom: calc(0.5 * var(--jp-content-heading-margin-bottom));
+    }
+
+    .jp-RenderedHTMLCommon h1 {
+      font-size: var(--jp-content-font-size5);
+    }
+
+    .jp-RenderedHTMLCommon h2 {
+      font-size: var(--jp-content-font-size4);
+    }
+
+    .jp-RenderedHTMLCommon h3 {
+      font-size: var(--jp-content-font-size3);
+    }
+
+    .jp-RenderedHTMLCommon h4 {
+      font-size: var(--jp-content-font-size2);
+    }
+
+    .jp-RenderedHTMLCommon h5 {
+      font-size: var(--jp-content-font-size1);
+    }
+
+    .jp-RenderedHTMLCommon h6 {
+      font-size: var(--jp-content-font-size0);
+    }
+
+    /* Lists */
+
+    /* stylelint-disable selector-max-type, selector-max-compound-selectors */
+
+    .jp-RenderedHTMLCommon ul:not(.list-inline),
+    .jp-RenderedHTMLCommon ol:not(.list-inline) {
+      padding-left: 2em;
+    }
+
+    .jp-RenderedHTMLCommon ul {
+      list-style: disc;
+    }
+
+    .jp-RenderedHTMLCommon ul ul {
+      list-style: square;
+    }
+
+    .jp-RenderedHTMLCommon ul ul ul {
+      list-style: circle;
+    }
+
+    .jp-RenderedHTMLCommon ol {
+      list-style: decimal;
+    }
+
+    .jp-RenderedHTMLCommon ol ol {
+      list-style: upper-alpha;
+    }
+
+    .jp-RenderedHTMLCommon ol ol ol {
+      list-style: lower-alpha;
+    }
+
+    .jp-RenderedHTMLCommon ol ol ol ol {
+      list-style: lower-roman;
+    }
+
+    .jp-RenderedHTMLCommon ol ol ol ol ol {
+      list-style: decimal;
+    }
+
+    .jp-RenderedHTMLCommon ol,
+    .jp-RenderedHTMLCommon ul {
+      margin-bottom: 1em;
+    }
+
+    .jp-RenderedHTMLCommon ul ul,
+    .jp-RenderedHTMLCommon ul ol,
+    .jp-RenderedHTMLCommon ol ul,
+    .jp-RenderedHTMLCommon ol ol {
+      margin-bottom: 0;
+    }
+
+    /* stylelint-enable selector-max-type, selector-max-compound-selectors */
+
+    .jp-RenderedHTMLCommon hr {
+      color: var(--jp-border-color2);
+      background-color: var(--jp-border-color1);
+      margin-top: 1em;
+      margin-bottom: 1em;
+    }
+
+    .jp-RenderedHTMLCommon>pre {
+      margin: 1.5em 2em;
+    }
+
+    .jp-RenderedHTMLCommon pre,
+    .jp-RenderedHTMLCommon code {
+      border: 0;
+      background-color: var(--jp-layout-color0);
+      color: var(--jp-content-font-color1);
+      font-family: var(--jp-code-font-family);
+      font-size: inherit;
+      line-height: var(--jp-code-line-height);
+      padding: 0;
+      white-space: pre-wrap;
+    }
+
+    .jp-RenderedHTMLCommon :not(pre)>code {
+      background-color: var(--jp-layout-color2);
+      padding: 1px 5px;
+    }
+
+    /* Tables */
+
+    .jp-RenderedHTMLCommon table {
+      border-collapse: collapse;
+      border-spacing: 0;
+      border: none;
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+      table-layout: fixed;
+      margin-left: auto;
+      margin-bottom: 1em;
+      margin-right: auto;
+    }
+
+    .jp-RenderedHTMLCommon thead {
+      border-bottom: var(--jp-border-width) solid var(--jp-border-color1);
+      vertical-align: bottom;
+    }
+
+    .jp-RenderedHTMLCommon td,
+    .jp-RenderedHTMLCommon th,
+    .jp-RenderedHTMLCommon tr {
+      vertical-align: middle;
+      padding: 0.5em;
+      line-height: normal;
+      white-space: normal;
+      max-width: none;
+      border: none;
+    }
+
+    .jp-RenderedMarkdown.jp-RenderedHTMLCommon td,
+    .jp-RenderedMarkdown.jp-RenderedHTMLCommon th {
+      max-width: none;
+    }
+
+    :not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon td,
+    :not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon th,
+    :not(.jp-RenderedMarkdown).jp-RenderedHTMLCommon tr {
+      text-align: right;
+    }
+
+    .jp-RenderedHTMLCommon th {
+      font-weight: bold;
+    }
+
+    .jp-RenderedHTMLCommon tbody tr:nth-child(odd) {
+      background: var(--jp-layout-color0);
+    }
+
+    .jp-RenderedHTMLCommon tbody tr:nth-child(even) {
+      background: var(--jp-rendermime-table-row-background);
+    }
+
+    .jp-RenderedHTMLCommon tbody tr:hover {
+      background: var(--jp-rendermime-table-row-hover-background);
+    }
+
+    .jp-RenderedHTMLCommon p {
+      text-align: left;
+      margin: 0;
+      margin-bottom: 1em;
+    }
+
+    .jp-RenderedHTMLCommon img {
+      -moz-force-broken-image-icon: 1;
+    }
+
+    /* Restrict to direct children as other images could be nested in other content. */
+    .jp-RenderedHTMLCommon>img {
+      display: block;
+      margin-left: 0;
+      margin-right: 0;
+      margin-bottom: 1em;
+    }
+
+    /* Change color behind transparent images if they need it... */
+    [data-jp-theme-light='false'] .jp-RenderedImage img.jp-needs-light-background {
+      background-color: var(--jp-inverse-layout-color1);
+    }
+
+    [data-jp-theme-light='true'] .jp-RenderedImage img.jp-needs-dark-background {
+      background-color: var(--jp-inverse-layout-color1);
+    }
+
+    .jp-RenderedHTMLCommon img,
+    .jp-RenderedImage img,
+    .jp-RenderedHTMLCommon svg,
+    .jp-RenderedSVG svg {
+      max-width: 100%;
+      height: auto;
+    }
+
+    .jp-RenderedHTMLCommon img.jp-mod-unconfined,
+    .jp-RenderedImage img.jp-mod-unconfined,
+    .jp-RenderedHTMLCommon svg.jp-mod-unconfined,
+    .jp-RenderedSVG svg.jp-mod-unconfined {
+      max-width: none;
+    }
+
+    .jp-RenderedHTMLCommon .alert {
+      padding: var(--jp-notebook-padding);
+      border: var(--jp-border-width) solid transparent;
+      border-radius: var(--jp-border-radius);
+      margin-bottom: 1em;
+    }
+
+    .jp-RenderedHTMLCommon .alert-info {
+      color: var(--jp-info-color0);
+      background-color: var(--jp-info-color3);
+      border-color: var(--jp-info-color2);
+    }
+
+    .jp-RenderedHTMLCommon .alert-info hr {
+      border-color: var(--jp-info-color3);
+    }
+
+    .jp-RenderedHTMLCommon .alert-info>p:last-child,
+    .jp-RenderedHTMLCommon .alert-info>ul:last-child {
+      margin-bottom: 0;
+    }
+
+    .jp-RenderedHTMLCommon .alert-warning {
+      color: var(--jp-warn-color0);
+      background-color: var(--jp-warn-color3);
+      border-color: var(--jp-warn-color2);
+    }
+
+    .jp-RenderedHTMLCommon .alert-warning hr {
+      border-color: var(--jp-warn-color3);
+    }
+
+    .jp-RenderedHTMLCommon .alert-warning>p:last-child,
+    .jp-RenderedHTMLCommon .alert-warning>ul:last-child {
+      margin-bottom: 0;
+    }
+
+    .jp-RenderedHTMLCommon .alert-success {
+      color: var(--jp-success-color0);
+      background-color: var(--jp-success-color3);
+      border-color: var(--jp-success-color2);
+    }
+
+    .jp-RenderedHTMLCommon .alert-success hr {
+      border-color: var(--jp-success-color3);
+    }
+
+    .jp-RenderedHTMLCommon .alert-success>p:last-child,
+    .jp-RenderedHTMLCommon .alert-success>ul:last-child {
+      margin-bottom: 0;
+    }
+
+    .jp-RenderedHTMLCommon .alert-danger {
+      color: var(--jp-error-color0);
+      background-color: var(--jp-error-color3);
+      border-color: var(--jp-error-color2);
+    }
+
+    .jp-RenderedHTMLCommon .alert-danger hr {
+      border-color: var(--jp-error-color3);
+    }
+
+    .jp-RenderedHTMLCommon .alert-danger>p:last-child,
+    .jp-RenderedHTMLCommon .alert-danger>ul:last-child {
+      margin-bottom: 0;
+    }
+
+    .jp-RenderedHTMLCommon blockquote {
+      margin: 1em 2em;
+      padding: 0 1em;
+      border-left: 5px solid var(--jp-border-color2);
+    }
+
+    a.jp-InternalAnchorLink {
+      visibility: hidden;
+      margin-left: 8px;
+      color: var(--md-blue-800);
+    }
+
+    h1:hover .jp-InternalAnchorLink,
+    h2:hover .jp-InternalAnchorLink,
+    h3:hover .jp-InternalAnchorLink,
+    h4:hover .jp-InternalAnchorLink,
+    h5:hover .jp-InternalAnchorLink,
+    h6:hover .jp-InternalAnchorLink {
+      visibility: visible;
+    }
+
+    .jp-RenderedHTMLCommon kbd {
+      background-color: var(--jp-rendermime-table-row-background);
+      border: 1px solid var(--jp-border-color0);
+      border-bottom-color: var(--jp-border-color2);
+      border-radius: 3px;
+      box-shadow: inset 0 -1px 0 rgba(0, 0, 0, 0.25);
+      display: inline-block;
+      font-size: var(--jp-ui-font-size0);
+      line-height: 1em;
+      padding: 0.2em 0.5em;
+    }
+
+    /* Most direct children of .jp-RenderedHTMLCommon have a margin-bottom of 1.0.
  * At the bottom of cells this is a bit too much as there is also spacing
  * between cells. Going all the way to 0 gets too tight between markdown and
  * code cells.
  */
-.jp-RenderedHTMLCommon > *:last-child {
-  margin-bottom: 0.5em;
-}
+    .jp-RenderedHTMLCommon>*:last-child {
+      margin-bottom: 0.5em;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Copyright (c) 2014-2017, PhosphorJS Contributors
 |
@@ -4396,2025 +4580,2007 @@ h6:hover .jp-InternalAnchorLink {
 | The full license is in the file LICENSE, distributed with this software.
 |----------------------------------------------------------------------------*/
 
-.lm-cursor-backdrop {
-  position: fixed;
-  width: 200px;
-  height: 200px;
-  margin-top: -100px;
-  margin-left: -100px;
-  will-change: transform;
-  z-index: 100;
-}
+    .lm-cursor-backdrop {
+      position: fixed;
+      width: 200px;
+      height: 200px;
+      margin-top: -100px;
+      margin-left: -100px;
+      will-change: transform;
+      z-index: 100;
+    }
 
-.lm-mod-drag-image {
-  will-change: transform;
-}
+    .lm-mod-drag-image {
+      will-change: transform;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.jp-lineFormSearch {
-  padding: 4px 12px;
-  background-color: var(--jp-layout-color2);
-  box-shadow: var(--jp-toolbar-box-shadow);
-  z-index: 2;
-  font-size: var(--jp-ui-font-size1);
-}
+    .jp-lineFormSearch {
+      padding: 4px 12px;
+      background-color: var(--jp-layout-color2);
+      box-shadow: var(--jp-toolbar-box-shadow);
+      z-index: 2;
+      font-size: var(--jp-ui-font-size1);
+    }
 
-.jp-lineFormCaption {
-  font-size: var(--jp-ui-font-size0);
-  line-height: var(--jp-ui-font-size1);
-  margin-top: 4px;
-  color: var(--jp-ui-font-color0);
-}
+    .jp-lineFormCaption {
+      font-size: var(--jp-ui-font-size0);
+      line-height: var(--jp-ui-font-size1);
+      margin-top: 4px;
+      color: var(--jp-ui-font-color0);
+    }
 
-.jp-baseLineForm {
-  border: none;
-  border-radius: 0;
-  position: absolute;
-  background-size: 16px;
-  background-repeat: no-repeat;
-  background-position: center;
-  outline: none;
-}
+    .jp-baseLineForm {
+      border: none;
+      border-radius: 0;
+      position: absolute;
+      background-size: 16px;
+      background-repeat: no-repeat;
+      background-position: center;
+      outline: none;
+    }
 
-.jp-lineFormButtonContainer {
-  top: 4px;
-  right: 8px;
-  height: 24px;
-  padding: 0 12px;
-  width: 12px;
-}
+    .jp-lineFormButtonContainer {
+      top: 4px;
+      right: 8px;
+      height: 24px;
+      padding: 0 12px;
+      width: 12px;
+    }
 
-.jp-lineFormButtonIcon {
-  top: 0;
-  right: 0;
-  background-color: var(--jp-brand-color1);
-  height: 100%;
-  width: 100%;
-  box-sizing: border-box;
-  padding: 4px 6px;
-}
+    .jp-lineFormButtonIcon {
+      top: 0;
+      right: 0;
+      background-color: var(--jp-brand-color1);
+      height: 100%;
+      width: 100%;
+      box-sizing: border-box;
+      padding: 4px 6px;
+    }
 
-.jp-lineFormButton {
-  top: 0;
-  right: 0;
-  background-color: transparent;
-  height: 100%;
-  width: 100%;
-  box-sizing: border-box;
-}
+    .jp-lineFormButton {
+      top: 0;
+      right: 0;
+      background-color: transparent;
+      height: 100%;
+      width: 100%;
+      box-sizing: border-box;
+    }
 
-.jp-lineFormWrapper {
-  overflow: hidden;
-  padding: 0 8px;
-  border: 1px solid var(--jp-border-color0);
-  background-color: var(--jp-input-active-background);
-  height: 22px;
-}
+    .jp-lineFormWrapper {
+      overflow: hidden;
+      padding: 0 8px;
+      border: 1px solid var(--jp-border-color0);
+      background-color: var(--jp-input-active-background);
+      height: 22px;
+    }
 
-.jp-lineFormWrapperFocusWithin {
-  border: var(--jp-border-width) solid var(--md-blue-500);
-  box-shadow: inset 0 0 4px var(--md-blue-300);
-}
+    .jp-lineFormWrapperFocusWithin {
+      border: var(--jp-border-width) solid var(--md-blue-500);
+      box-shadow: inset 0 0 4px var(--md-blue-300);
+    }
 
-.jp-lineFormInput {
-  background: transparent;
-  width: 200px;
-  height: 100%;
-  border: none;
-  outline: none;
-  color: var(--jp-ui-font-color0);
-  line-height: 28px;
-}
+    .jp-lineFormInput {
+      background: transparent;
+      width: 200px;
+      height: 100%;
+      border: none;
+      outline: none;
+      color: var(--jp-ui-font-color0);
+      line-height: 28px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) 2014-2016, Jupyter Development Team.
 |
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-JSONEditor {
-  display: flex;
-  flex-direction: column;
-  width: 100%;
-}
+    .jp-JSONEditor {
+      display: flex;
+      flex-direction: column;
+      width: 100%;
+    }
 
-.jp-JSONEditor-host {
-  flex: 1 1 auto;
-  border: var(--jp-border-width) solid var(--jp-input-border-color);
-  border-radius: 0;
-  background: var(--jp-layout-color0);
-  min-height: 50px;
-  padding: 1px;
-}
+    .jp-JSONEditor-host {
+      flex: 1 1 auto;
+      border: var(--jp-border-width) solid var(--jp-input-border-color);
+      border-radius: 0;
+      background: var(--jp-layout-color0);
+      min-height: 50px;
+      padding: 1px;
+    }
 
-.jp-JSONEditor.jp-mod-error .jp-JSONEditor-host {
-  border-color: red;
-  outline-color: red;
-}
+    .jp-JSONEditor.jp-mod-error .jp-JSONEditor-host {
+      border-color: red;
+      outline-color: red;
+    }
 
-.jp-JSONEditor-header {
-  display: flex;
-  flex: 1 0 auto;
-  padding: 0 0 0 12px;
-}
+    .jp-JSONEditor-header {
+      display: flex;
+      flex: 1 0 auto;
+      padding: 0 0 0 12px;
+    }
 
-.jp-JSONEditor-header label {
-  flex: 0 0 auto;
-}
+    .jp-JSONEditor-header label {
+      flex: 0 0 auto;
+    }
 
-.jp-JSONEditor-commitButton {
-  height: 16px;
-  width: 16px;
-  background-size: 18px;
-  background-repeat: no-repeat;
-  background-position: center;
-}
+    .jp-JSONEditor-commitButton {
+      height: 16px;
+      width: 16px;
+      background-size: 18px;
+      background-repeat: no-repeat;
+      background-position: center;
+    }
 
-.jp-JSONEditor-host.jp-mod-focused {
-  background-color: var(--jp-input-active-background);
-  border: 1px solid var(--jp-input-active-border-color);
-  box-shadow: var(--jp-input-box-shadow);
-}
+    .jp-JSONEditor-host.jp-mod-focused {
+      background-color: var(--jp-input-active-background);
+      border: 1px solid var(--jp-input-active-border-color);
+      box-shadow: var(--jp-input-box-shadow);
+    }
 
-.jp-Editor.jp-mod-dropTarget {
-  border: var(--jp-border-width) solid var(--jp-input-active-border-color);
-  box-shadow: var(--jp-input-box-shadow);
-}
+    .jp-Editor.jp-mod-dropTarget {
+      border: var(--jp-border-width) solid var(--jp-input-active-border-color);
+      box-shadow: var(--jp-input-box-shadow);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
-.jp-DocumentSearch-input {
-  border: none;
-  outline: none;
-  color: var(--jp-ui-font-color0);
-  font-size: var(--jp-ui-font-size1);
-  background-color: var(--jp-layout-color0);
-  font-family: var(--jp-ui-font-family);
-  padding: 2px 1px;
-  resize: none;
-}
+    .jp-DocumentSearch-input {
+      border: none;
+      outline: none;
+      color: var(--jp-ui-font-color0);
+      font-size: var(--jp-ui-font-size1);
+      background-color: var(--jp-layout-color0);
+      font-family: var(--jp-ui-font-family);
+      padding: 2px 1px;
+      resize: none;
+    }
 
-.jp-DocumentSearch-overlay {
-  position: absolute;
-  background-color: var(--jp-toolbar-background);
-  border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
-  border-left: var(--jp-border-width) solid var(--jp-toolbar-border-color);
-  top: 0;
-  right: 0;
-  z-index: 7;
-  min-width: 405px;
-  padding: 2px;
-  font-size: var(--jp-ui-font-size1);
+    .jp-DocumentSearch-overlay {
+      position: absolute;
+      background-color: var(--jp-toolbar-background);
+      border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
+      border-left: var(--jp-border-width) solid var(--jp-toolbar-border-color);
+      top: 0;
+      right: 0;
+      z-index: 7;
+      min-width: 405px;
+      padding: 2px;
+      font-size: var(--jp-ui-font-size1);
 
-  --jp-private-document-search-button-height: 20px;
-}
+      --jp-private-document-search-button-height: 20px;
+    }
 
-.jp-DocumentSearch-overlay button {
-  background-color: var(--jp-toolbar-background);
-  outline: 0;
-}
+    .jp-DocumentSearch-overlay button {
+      background-color: var(--jp-toolbar-background);
+      outline: 0;
+    }
 
-.jp-DocumentSearch-overlay button:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-DocumentSearch-overlay button:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-DocumentSearch-overlay button:active {
-  background-color: var(--jp-layout-color3);
-}
+    .jp-DocumentSearch-overlay button:active {
+      background-color: var(--jp-layout-color3);
+    }
 
-.jp-DocumentSearch-overlay-row {
-  display: flex;
-  align-items: center;
-  margin-bottom: 2px;
-}
+    .jp-DocumentSearch-overlay-row {
+      display: flex;
+      align-items: center;
+      margin-bottom: 2px;
+    }
 
-.jp-DocumentSearch-button-content {
-  display: inline-block;
-  cursor: pointer;
-  box-sizing: border-box;
-  width: 100%;
-  height: 100%;
-}
+    .jp-DocumentSearch-button-content {
+      display: inline-block;
+      cursor: pointer;
+      box-sizing: border-box;
+      width: 100%;
+      height: 100%;
+    }
 
-.jp-DocumentSearch-button-content svg {
-  width: 100%;
-  height: 100%;
-}
+    .jp-DocumentSearch-button-content svg {
+      width: 100%;
+      height: 100%;
+    }
 
-.jp-DocumentSearch-input-wrapper {
-  border: var(--jp-border-width) solid var(--jp-border-color0);
-  display: flex;
-  background-color: var(--jp-layout-color0);
-  margin: 2px;
-}
+    .jp-DocumentSearch-input-wrapper {
+      border: var(--jp-border-width) solid var(--jp-border-color0);
+      display: flex;
+      background-color: var(--jp-layout-color0);
+      margin: 2px;
+    }
 
-.jp-DocumentSearch-input-wrapper:focus-within {
-  border-color: var(--jp-cell-editor-active-border-color);
-}
+    .jp-DocumentSearch-input-wrapper:focus-within {
+      border-color: var(--jp-cell-editor-active-border-color);
+    }
 
-.jp-DocumentSearch-toggle-wrapper,
-.jp-DocumentSearch-button-wrapper {
-  all: initial;
-  overflow: hidden;
-  display: inline-block;
-  border: none;
-  box-sizing: border-box;
-}
+    .jp-DocumentSearch-toggle-wrapper,
+    .jp-DocumentSearch-button-wrapper {
+      all: initial;
+      overflow: hidden;
+      display: inline-block;
+      border: none;
+      box-sizing: border-box;
+    }
 
-.jp-DocumentSearch-toggle-wrapper {
-  width: 14px;
-  height: 14px;
-}
+    .jp-DocumentSearch-toggle-wrapper {
+      width: 14px;
+      height: 14px;
+    }
 
-.jp-DocumentSearch-button-wrapper {
-  width: var(--jp-private-document-search-button-height);
-  height: var(--jp-private-document-search-button-height);
-}
+    .jp-DocumentSearch-button-wrapper {
+      width: var(--jp-private-document-search-button-height);
+      height: var(--jp-private-document-search-button-height);
+    }
 
-.jp-DocumentSearch-toggle-wrapper:focus,
-.jp-DocumentSearch-button-wrapper:focus {
-  outline: var(--jp-border-width) solid
-    var(--jp-cell-editor-active-border-color);
-  outline-offset: -1px;
-}
+    .jp-DocumentSearch-toggle-wrapper:focus,
+    .jp-DocumentSearch-button-wrapper:focus {
+      outline: var(--jp-border-width) solid var(--jp-cell-editor-active-border-color);
+      outline-offset: -1px;
+    }
 
-.jp-DocumentSearch-toggle-wrapper,
-.jp-DocumentSearch-button-wrapper,
-.jp-DocumentSearch-button-content:focus {
-  outline: none;
-}
+    .jp-DocumentSearch-toggle-wrapper,
+    .jp-DocumentSearch-button-wrapper,
+    .jp-DocumentSearch-button-content:focus {
+      outline: none;
+    }
 
-.jp-DocumentSearch-toggle-placeholder {
-  width: 5px;
-}
+    .jp-DocumentSearch-toggle-placeholder {
+      width: 5px;
+    }
 
-.jp-DocumentSearch-input-button::before {
-  display: block;
-  padding-top: 100%;
-}
+    .jp-DocumentSearch-input-button::before {
+      display: block;
+      padding-top: 100%;
+    }
 
-.jp-DocumentSearch-input-button-off {
-  opacity: var(--jp-search-toggle-off-opacity);
-}
+    .jp-DocumentSearch-input-button-off {
+      opacity: var(--jp-search-toggle-off-opacity);
+    }
 
-.jp-DocumentSearch-input-button-off:hover {
-  opacity: var(--jp-search-toggle-hover-opacity);
-}
+    .jp-DocumentSearch-input-button-off:hover {
+      opacity: var(--jp-search-toggle-hover-opacity);
+    }
 
-.jp-DocumentSearch-input-button-on {
-  opacity: var(--jp-search-toggle-on-opacity);
-}
+    .jp-DocumentSearch-input-button-on {
+      opacity: var(--jp-search-toggle-on-opacity);
+    }
 
-.jp-DocumentSearch-index-counter {
-  padding-left: 10px;
-  padding-right: 10px;
-  user-select: none;
-  min-width: 35px;
-  display: inline-block;
-}
+    .jp-DocumentSearch-index-counter {
+      padding-left: 10px;
+      padding-right: 10px;
+      user-select: none;
+      min-width: 35px;
+      display: inline-block;
+    }
 
-.jp-DocumentSearch-up-down-wrapper {
-  display: inline-block;
-  padding-right: 2px;
-  margin-left: auto;
-  white-space: nowrap;
-}
+    .jp-DocumentSearch-up-down-wrapper {
+      display: inline-block;
+      padding-right: 2px;
+      margin-left: auto;
+      white-space: nowrap;
+    }
 
-.jp-DocumentSearch-spacer {
-  margin-left: auto;
-}
+    .jp-DocumentSearch-spacer {
+      margin-left: auto;
+    }
 
-.jp-DocumentSearch-up-down-wrapper button {
-  outline: 0;
-  border: none;
-  width: var(--jp-private-document-search-button-height);
-  height: var(--jp-private-document-search-button-height);
-  vertical-align: middle;
-  margin: 1px 5px 2px;
-}
+    .jp-DocumentSearch-up-down-wrapper button {
+      outline: 0;
+      border: none;
+      width: var(--jp-private-document-search-button-height);
+      height: var(--jp-private-document-search-button-height);
+      vertical-align: middle;
+      margin: 1px 5px 2px;
+    }
 
-.jp-DocumentSearch-up-down-button:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-DocumentSearch-up-down-button:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-DocumentSearch-up-down-button:active {
-  background-color: var(--jp-layout-color3);
-}
+    .jp-DocumentSearch-up-down-button:active {
+      background-color: var(--jp-layout-color3);
+    }
 
-.jp-DocumentSearch-filter-button {
-  border-radius: var(--jp-border-radius);
-}
+    .jp-DocumentSearch-filter-button {
+      border-radius: var(--jp-border-radius);
+    }
 
-.jp-DocumentSearch-filter-button:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-DocumentSearch-filter-button:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-DocumentSearch-filter-button-enabled {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-DocumentSearch-filter-button-enabled {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-DocumentSearch-filter-button-enabled:hover {
-  background-color: var(--jp-layout-color3);
-}
+    .jp-DocumentSearch-filter-button-enabled:hover {
+      background-color: var(--jp-layout-color3);
+    }
 
-.jp-DocumentSearch-search-options {
-  padding: 0 8px;
-  margin-left: 3px;
-  width: 100%;
-  display: grid;
-  justify-content: start;
-  grid-template-columns: 1fr 1fr;
-  align-items: center;
-  justify-items: stretch;
-}
+    .jp-DocumentSearch-search-options {
+      padding: 0 8px;
+      margin-left: 3px;
+      width: 100%;
+      display: grid;
+      justify-content: start;
+      grid-template-columns: 1fr 1fr;
+      align-items: center;
+      justify-items: stretch;
+    }
 
-.jp-DocumentSearch-search-filter-disabled {
-  color: var(--jp-ui-font-color2);
-}
+    .jp-DocumentSearch-search-filter-disabled {
+      color: var(--jp-ui-font-color2);
+    }
 
-.jp-DocumentSearch-search-filter {
-  display: flex;
-  align-items: center;
-  user-select: none;
-}
+    .jp-DocumentSearch-search-filter {
+      display: flex;
+      align-items: center;
+      user-select: none;
+    }
 
-.jp-DocumentSearch-regex-error {
-  color: var(--jp-error-color0);
-}
+    .jp-DocumentSearch-regex-error {
+      color: var(--jp-error-color0);
+    }
 
-.jp-DocumentSearch-replace-button-wrapper {
-  overflow: hidden;
-  display: inline-block;
-  box-sizing: border-box;
-  border: var(--jp-border-width) solid var(--jp-border-color0);
-  margin: auto 2px;
-  padding: 1px 4px;
-  height: calc(var(--jp-private-document-search-button-height) + 2px);
-}
+    .jp-DocumentSearch-replace-button-wrapper {
+      overflow: hidden;
+      display: inline-block;
+      box-sizing: border-box;
+      border: var(--jp-border-width) solid var(--jp-border-color0);
+      margin: auto 2px;
+      padding: 1px 4px;
+      height: calc(var(--jp-private-document-search-button-height) + 2px);
+    }
 
-.jp-DocumentSearch-replace-button-wrapper:focus {
-  border: var(--jp-border-width) solid var(--jp-cell-editor-active-border-color);
-}
+    .jp-DocumentSearch-replace-button-wrapper:focus {
+      border: var(--jp-border-width) solid var(--jp-cell-editor-active-border-color);
+    }
 
-.jp-DocumentSearch-replace-button {
-  display: inline-block;
-  text-align: center;
-  cursor: pointer;
-  box-sizing: border-box;
-  color: var(--jp-ui-font-color1);
+    .jp-DocumentSearch-replace-button {
+      display: inline-block;
+      text-align: center;
+      cursor: pointer;
+      box-sizing: border-box;
+      color: var(--jp-ui-font-color1);
 
-  /* height - 2 * (padding of wrapper) */
-  line-height: calc(var(--jp-private-document-search-button-height) - 2px);
-  width: 100%;
-  height: 100%;
-}
+      /* height - 2 * (padding of wrapper) */
+      line-height: calc(var(--jp-private-document-search-button-height) - 2px);
+      width: 100%;
+      height: 100%;
+    }
 
-.jp-DocumentSearch-replace-button:focus {
-  outline: none;
-}
+    .jp-DocumentSearch-replace-button:focus {
+      outline: none;
+    }
 
-.jp-DocumentSearch-replace-wrapper-class {
-  margin-left: 14px;
-  display: flex;
-}
+    .jp-DocumentSearch-replace-wrapper-class {
+      margin-left: 14px;
+      display: flex;
+    }
 
-.jp-DocumentSearch-replace-toggle {
-  border: none;
-  background-color: var(--jp-toolbar-background);
-  border-radius: var(--jp-border-radius);
-}
+    .jp-DocumentSearch-replace-toggle {
+      border: none;
+      background-color: var(--jp-toolbar-background);
+      border-radius: var(--jp-border-radius);
+    }
 
-.jp-DocumentSearch-replace-toggle:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-DocumentSearch-replace-toggle:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.cm-editor {
-  line-height: var(--jp-code-line-height);
-  font-size: var(--jp-code-font-size);
-  font-family: var(--jp-code-font-family);
-  border: 0;
-  border-radius: 0;
-  height: auto;
+    .cm-editor {
+      line-height: var(--jp-code-line-height);
+      font-size: var(--jp-code-font-size);
+      font-family: var(--jp-code-font-family);
+      border: 0;
+      border-radius: 0;
+      height: auto;
 
-  /* Changed to auto to autogrow */
-}
+      /* Changed to auto to autogrow */
+    }
 
-.cm-editor pre {
-  padding: 0 var(--jp-code-padding);
-}
+    .cm-editor pre {
+      padding: 0 var(--jp-code-padding);
+    }
 
-.jp-CodeMirrorEditor[data-type='inline'] .cm-dialog {
-  background-color: var(--jp-layout-color0);
-  color: var(--jp-content-font-color1);
-}
+    .jp-CodeMirrorEditor[data-type='inline'] .cm-dialog {
+      background-color: var(--jp-layout-color0);
+      color: var(--jp-content-font-color1);
+    }
 
-.jp-CodeMirrorEditor {
-  cursor: text;
-}
+    .jp-CodeMirrorEditor {
+      cursor: text;
+    }
 
-/* When zoomed out 67% and 33% on a screen of 1440 width x 900 height */
-@media screen and (min-width: 2138px) and (max-width: 4319px) {
-  .jp-CodeMirrorEditor[data-type='inline'] .cm-cursor {
-    border-left: var(--jp-code-cursor-width1) solid
-      var(--jp-editor-cursor-color);
-  }
-}
+    /* When zoomed out 67% and 33% on a screen of 1440 width x 900 height */
+    @media screen and (min-width: 2138px) and (max-width: 4319px) {
+      .jp-CodeMirrorEditor[data-type='inline'] .cm-cursor {
+        border-left: var(--jp-code-cursor-width1) solid var(--jp-editor-cursor-color);
+      }
+    }
 
-/* When zoomed out less than 33% */
-@media screen and (min-width: 4320px) {
-  .jp-CodeMirrorEditor[data-type='inline'] .cm-cursor {
-    border-left: var(--jp-code-cursor-width2) solid
-      var(--jp-editor-cursor-color);
-  }
-}
+    /* When zoomed out less than 33% */
+    @media screen and (min-width: 4320px) {
+      .jp-CodeMirrorEditor[data-type='inline'] .cm-cursor {
+        border-left: var(--jp-code-cursor-width2) solid var(--jp-editor-cursor-color);
+      }
+    }
 
-.cm-editor.jp-mod-readOnly .cm-cursor {
-  display: none;
-}
+    .cm-editor.jp-mod-readOnly .cm-cursor {
+      display: none;
+    }
 
-.jp-CollaboratorCursor {
-  border-left: 5px solid transparent;
-  border-right: 5px solid transparent;
-  border-top: none;
-  border-bottom: 3px solid;
-  background-clip: content-box;
-  margin-left: -5px;
-  margin-right: -5px;
-}
+    .jp-CollaboratorCursor {
+      border-left: 5px solid transparent;
+      border-right: 5px solid transparent;
+      border-top: none;
+      border-bottom: 3px solid;
+      background-clip: content-box;
+      margin-left: -5px;
+      margin-right: -5px;
+    }
 
-.cm-searching,
-.cm-searching span {
-  /* `.cm-searching span`: we need to override syntax highlighting */
-  background-color: var(--jp-search-unselected-match-background-color);
-  color: var(--jp-search-unselected-match-color);
-}
+    .cm-searching,
+    .cm-searching span {
+      /* `.cm-searching span`: we need to override syntax highlighting */
+      background-color: var(--jp-search-unselected-match-background-color);
+      color: var(--jp-search-unselected-match-color);
+    }
 
-.cm-searching::selection,
-.cm-searching span::selection {
-  background-color: var(--jp-search-unselected-match-background-color);
-  color: var(--jp-search-unselected-match-color);
-}
+    .cm-searching::selection,
+    .cm-searching span::selection {
+      background-color: var(--jp-search-unselected-match-background-color);
+      color: var(--jp-search-unselected-match-color);
+    }
 
-.jp-current-match > .cm-searching,
-.jp-current-match > .cm-searching span,
-.cm-searching > .jp-current-match,
-.cm-searching > .jp-current-match span {
-  background-color: var(--jp-search-selected-match-background-color);
-  color: var(--jp-search-selected-match-color);
-}
+    .jp-current-match>.cm-searching,
+    .jp-current-match>.cm-searching span,
+    .cm-searching>.jp-current-match,
+    .cm-searching>.jp-current-match span {
+      background-color: var(--jp-search-selected-match-background-color);
+      color: var(--jp-search-selected-match-color);
+    }
 
-.jp-current-match > .cm-searching::selection,
-.cm-searching > .jp-current-match::selection,
-.jp-current-match > .cm-searching span::selection {
-  background-color: var(--jp-search-selected-match-background-color);
-  color: var(--jp-search-selected-match-color);
-}
+    .jp-current-match>.cm-searching::selection,
+    .cm-searching>.jp-current-match::selection,
+    .jp-current-match>.cm-searching span::selection {
+      background-color: var(--jp-search-selected-match-background-color);
+      color: var(--jp-search-selected-match-color);
+    }
 
-.cm-trailingspace {
-  background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAFCAYAAAB4ka1VAAAAsElEQVQIHQGlAFr/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7+r3zKmT0/+pk9P/7+r3zAAAAAAAAAAABAAAAAAAAAAA6OPzM+/q9wAAAAAA6OPzMwAAAAAAAAAAAgAAAAAAAAAAGR8NiRQaCgAZIA0AGR8NiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQyoYJ/SY80UAAAAASUVORK5CYII=);
-  background-position: center left;
-  background-repeat: repeat-x;
-}
+    .cm-trailingspace {
+      background-image: url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAgAAAAFCAYAAAB4ka1VAAAAsElEQVQIHQGlAFr/AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA7+r3zKmT0/+pk9P/7+r3zAAAAAAAAAAABAAAAAAAAAAA6OPzM+/q9wAAAAAA6OPzMwAAAAAAAAAAAgAAAAAAAAAAGR8NiRQaCgAZIA0AGR8NiQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAQyoYJ/SY80UAAAAASUVORK5CYII=);
+      background-position: center left;
+      background-repeat: repeat-x;
+    }
 
-.jp-CollaboratorCursor-hover {
-  position: absolute;
-  z-index: 1;
-  transform: translateX(-50%);
-  color: white;
-  border-radius: 3px;
-  padding-left: 4px;
-  padding-right: 4px;
-  padding-top: 1px;
-  padding-bottom: 1px;
-  text-align: center;
-  font-size: var(--jp-ui-font-size1);
-  white-space: nowrap;
-}
+    .jp-CollaboratorCursor-hover {
+      position: absolute;
+      z-index: 1;
+      transform: translateX(-50%);
+      color: white;
+      border-radius: 3px;
+      padding-left: 4px;
+      padding-right: 4px;
+      padding-top: 1px;
+      padding-bottom: 1px;
+      text-align: center;
+      font-size: var(--jp-ui-font-size1);
+      white-space: nowrap;
+    }
 
-.jp-CodeMirror-ruler {
-  border-left: 1px dashed var(--jp-border-color2);
-}
+    .jp-CodeMirror-ruler {
+      border-left: 1px dashed var(--jp-border-color2);
+    }
 
-/* Styles for shared cursors (remote cursor locations and selected ranges) */
-.jp-CodeMirrorEditor .cm-ySelectionCaret {
-  position: relative;
-  border-left: 1px solid black;
-  margin-left: -1px;
-  margin-right: -1px;
-  box-sizing: border-box;
-}
+    /* Styles for shared cursors (remote cursor locations and selected ranges) */
+    .jp-CodeMirrorEditor .cm-ySelectionCaret {
+      position: relative;
+      border-left: 1px solid black;
+      margin-left: -1px;
+      margin-right: -1px;
+      box-sizing: border-box;
+    }
 
-.jp-CodeMirrorEditor .cm-ySelectionCaret > .cm-ySelectionInfo {
-  white-space: nowrap;
-  position: absolute;
-  top: -1.15em;
-  padding-bottom: 0.05em;
-  left: -1px;
-  font-size: 0.95em;
-  font-family: var(--jp-ui-font-family);
-  font-weight: bold;
-  line-height: normal;
-  user-select: none;
-  color: white;
-  padding-left: 2px;
-  padding-right: 2px;
-  z-index: 101;
-  transition: opacity 0.3s ease-in-out;
-}
+    .jp-CodeMirrorEditor .cm-ySelectionCaret>.cm-ySelectionInfo {
+      white-space: nowrap;
+      position: absolute;
+      top: -1.15em;
+      padding-bottom: 0.05em;
+      left: -1px;
+      font-size: 0.95em;
+      font-family: var(--jp-ui-font-family);
+      font-weight: bold;
+      line-height: normal;
+      user-select: none;
+      color: white;
+      padding-left: 2px;
+      padding-right: 2px;
+      z-index: 101;
+      transition: opacity 0.3s ease-in-out;
+    }
 
-.jp-CodeMirrorEditor .cm-ySelectionInfo {
-  transition-delay: 0.7s;
-  opacity: 0;
-}
+    .jp-CodeMirrorEditor .cm-ySelectionInfo {
+      transition-delay: 0.7s;
+      opacity: 0;
+    }
 
-.jp-CodeMirrorEditor .cm-ySelectionCaret:hover > .cm-ySelectionInfo {
-  opacity: 1;
-  transition-delay: 0s;
-}
+    .jp-CodeMirrorEditor .cm-ySelectionCaret:hover>.cm-ySelectionInfo {
+      opacity: 1;
+      transition-delay: 0s;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-MimeDocument {
-  outline: none;
-}
+    .jp-MimeDocument {
+      outline: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Variables
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-private-filebrowser-button-height: 28px;
-  --jp-private-filebrowser-button-width: 48px;
-}
+    :root {
+      --jp-private-filebrowser-button-height: 28px;
+      --jp-private-filebrowser-button-width: 48px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-FileBrowser .jp-SidePanel-content {
-  display: flex;
-  flex-direction: column;
-}
+    .jp-FileBrowser .jp-SidePanel-content {
+      display: flex;
+      flex-direction: column;
+    }
 
-.jp-FileBrowser-toolbar.jp-Toolbar {
-  flex-wrap: wrap;
-  row-gap: 12px;
-  border-bottom: none;
-  height: auto;
-  margin: 8px 12px 0;
-  box-shadow: none;
-  padding: 0;
-  justify-content: flex-start;
-}
+    .jp-FileBrowser-toolbar.jp-Toolbar {
+      flex-wrap: wrap;
+      row-gap: 12px;
+      border-bottom: none;
+      height: auto;
+      margin: 8px 12px 0;
+      box-shadow: none;
+      padding: 0;
+      justify-content: flex-start;
+    }
 
-.jp-FileBrowser-Panel {
-  flex: 1 1 auto;
-  display: flex;
-  flex-direction: column;
-}
+    .jp-FileBrowser-Panel {
+      flex: 1 1 auto;
+      display: flex;
+      flex-direction: column;
+    }
 
-.jp-BreadCrumbs {
-  flex: 0 0 auto;
-  margin: 8px 12px;
-}
+    .jp-BreadCrumbs {
+      flex: 0 0 auto;
+      margin: 8px 12px;
+    }
 
-.jp-BreadCrumbs-item {
-  margin: 0 2px;
-  padding: 0 2px;
-  border-radius: var(--jp-border-radius);
-  cursor: pointer;
-}
+    .jp-BreadCrumbs-item {
+      margin: 0 2px;
+      padding: 0 2px;
+      border-radius: var(--jp-border-radius);
+      cursor: pointer;
+    }
 
-.jp-BreadCrumbs-item:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-BreadCrumbs-item:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-BreadCrumbs-item:first-child {
-  margin-left: 0;
-}
+    .jp-BreadCrumbs-item:first-child {
+      margin-left: 0;
+    }
 
-.jp-BreadCrumbs-item.jp-mod-dropTarget {
-  background-color: var(--jp-brand-color2);
-  opacity: 0.7;
-}
+    .jp-BreadCrumbs-item.jp-mod-dropTarget {
+      background-color: var(--jp-brand-color2);
+      opacity: 0.7;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Buttons
 |----------------------------------------------------------------------------*/
 
-.jp-FileBrowser-toolbar > .jp-Toolbar-item {
-  flex: 0 0 auto;
-  padding-left: 0;
-  padding-right: 2px;
-  align-items: center;
-  height: unset;
-}
+    .jp-FileBrowser-toolbar>.jp-Toolbar-item {
+      flex: 0 0 auto;
+      padding-left: 0;
+      padding-right: 2px;
+      align-items: center;
+      height: unset;
+    }
 
-.jp-FileBrowser-toolbar > .jp-Toolbar-item .jp-ToolbarButtonComponent {
-  width: 40px;
-}
+    .jp-FileBrowser-toolbar>.jp-Toolbar-item .jp-ToolbarButtonComponent {
+      width: 40px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Other styles
 |----------------------------------------------------------------------------*/
 
-.jp-FileDialog.jp-mod-conflict input {
-  color: var(--jp-error-color1);
-}
+    .jp-FileDialog.jp-mod-conflict input {
+      color: var(--jp-error-color1);
+    }
 
-.jp-FileDialog .jp-new-name-title {
-  margin-top: 12px;
-}
+    .jp-FileDialog .jp-new-name-title {
+      margin-top: 12px;
+    }
 
-.jp-LastModified-hidden {
-  display: none;
-}
+    .jp-LastModified-hidden {
+      display: none;
+    }
 
-.jp-FileSize-hidden {
-  display: none;
-}
+    .jp-FileSize-hidden {
+      display: none;
+    }
 
-.jp-FileBrowser .lm-AccordionPanel > h3:first-child {
-  display: none;
-}
+    .jp-FileBrowser .lm-AccordionPanel>h3:first-child {
+      display: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | DirListing
 |----------------------------------------------------------------------------*/
 
-.jp-DirListing {
-  flex: 1 1 auto;
-  display: flex;
-  flex-direction: column;
-  outline: 0;
-}
+    .jp-DirListing {
+      flex: 1 1 auto;
+      display: flex;
+      flex-direction: column;
+      outline: 0;
+    }
 
-.jp-DirListing-header {
-  flex: 0 0 auto;
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  overflow: hidden;
-  border-top: var(--jp-border-width) solid var(--jp-border-color2);
-  border-bottom: var(--jp-border-width) solid var(--jp-border-color1);
-  box-shadow: var(--jp-toolbar-box-shadow);
-  z-index: 2;
-}
+    .jp-DirListing-header {
+      flex: 0 0 auto;
+      display: flex;
+      flex-direction: row;
+      align-items: center;
+      overflow: hidden;
+      border-top: var(--jp-border-width) solid var(--jp-border-color2);
+      border-bottom: var(--jp-border-width) solid var(--jp-border-color1);
+      box-shadow: var(--jp-toolbar-box-shadow);
+      z-index: 2;
+    }
 
-.jp-DirListing-headerItem {
-  padding: 4px 12px 2px;
-  font-weight: 500;
-}
+    .jp-DirListing-headerItem {
+      padding: 4px 12px 2px;
+      font-weight: 500;
+    }
 
-.jp-DirListing-headerItem:hover {
-  background: var(--jp-layout-color2);
-}
+    .jp-DirListing-headerItem:hover {
+      background: var(--jp-layout-color2);
+    }
 
-.jp-DirListing-headerItem.jp-id-name {
-  flex: 1 0 84px;
-}
+    .jp-DirListing-headerItem.jp-id-name {
+      flex: 1 0 84px;
+    }
 
-.jp-DirListing-headerItem.jp-id-modified {
-  flex: 0 0 112px;
-  border-left: var(--jp-border-width) solid var(--jp-border-color2);
-  text-align: right;
-}
+    .jp-DirListing-headerItem.jp-id-modified {
+      flex: 0 0 112px;
+      border-left: var(--jp-border-width) solid var(--jp-border-color2);
+      text-align: right;
+    }
 
-.jp-DirListing-headerItem.jp-id-filesize {
-  flex: 0 0 75px;
-  border-left: var(--jp-border-width) solid var(--jp-border-color2);
-  text-align: right;
-}
+    .jp-DirListing-headerItem.jp-id-filesize {
+      flex: 0 0 75px;
+      border-left: var(--jp-border-width) solid var(--jp-border-color2);
+      text-align: right;
+    }
 
-.jp-id-narrow {
-  display: none;
-  flex: 0 0 5px;
-  padding: 4px;
-  border-left: var(--jp-border-width) solid var(--jp-border-color2);
-  text-align: right;
-  color: var(--jp-border-color2);
-}
+    .jp-id-narrow {
+      display: none;
+      flex: 0 0 5px;
+      padding: 4px;
+      border-left: var(--jp-border-width) solid var(--jp-border-color2);
+      text-align: right;
+      color: var(--jp-border-color2);
+    }
 
-.jp-DirListing-narrow .jp-id-narrow {
-  display: block;
-}
+    .jp-DirListing-narrow .jp-id-narrow {
+      display: block;
+    }
 
-.jp-DirListing-narrow .jp-id-modified,
-.jp-DirListing-narrow .jp-DirListing-itemModified {
-  display: none;
-}
+    .jp-DirListing-narrow .jp-id-modified,
+    .jp-DirListing-narrow .jp-DirListing-itemModified {
+      display: none;
+    }
 
-.jp-DirListing-headerItem.jp-mod-selected {
-  font-weight: 600;
-}
+    .jp-DirListing-headerItem.jp-mod-selected {
+      font-weight: 600;
+    }
 
-/* increase specificity to override bundled default */
-.jp-DirListing-content {
-  flex: 1 1 auto;
-  margin: 0;
-  padding: 0;
-  list-style-type: none;
-  overflow: auto;
-  background-color: var(--jp-layout-color1);
-}
+    /* increase specificity to override bundled default */
+    .jp-DirListing-content {
+      flex: 1 1 auto;
+      margin: 0;
+      padding: 0;
+      list-style-type: none;
+      overflow: auto;
+      background-color: var(--jp-layout-color1);
+    }
 
-.jp-DirListing-content mark {
-  color: var(--jp-ui-font-color0);
-  background-color: transparent;
-  font-weight: bold;
-}
+    .jp-DirListing-content mark {
+      color: var(--jp-ui-font-color0);
+      background-color: transparent;
+      font-weight: bold;
+    }
 
-.jp-DirListing-content .jp-DirListing-item.jp-mod-selected mark {
-  color: var(--jp-ui-inverse-font-color0);
-}
+    .jp-DirListing-content .jp-DirListing-item.jp-mod-selected mark {
+      color: var(--jp-ui-inverse-font-color0);
+    }
 
-/* Style the directory listing content when a user drops a file to upload */
-.jp-DirListing.jp-mod-native-drop .jp-DirListing-content {
-  outline: 5px dashed rgba(128, 128, 128, 0.5);
-  outline-offset: -10px;
-  cursor: copy;
-}
+    /* Style the directory listing content when a user drops a file to upload */
+    .jp-DirListing.jp-mod-native-drop .jp-DirListing-content {
+      outline: 5px dashed rgba(128, 128, 128, 0.5);
+      outline-offset: -10px;
+      cursor: copy;
+    }
 
-.jp-DirListing-item {
-  display: flex;
-  flex-direction: row;
-  align-items: center;
-  padding: 4px 12px;
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .jp-DirListing-item {
+      display: flex;
+      flex-direction: row;
+      align-items: center;
+      padding: 4px 12px;
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.jp-DirListing-checkboxWrapper {
-  /* Increases hit area of checkbox. */
-  padding: 4px;
-}
+    .jp-DirListing-checkboxWrapper {
+      /* Increases hit area of checkbox. */
+      padding: 4px;
+    }
 
-.jp-DirListing-header
-  .jp-DirListing-checkboxWrapper
-  + .jp-DirListing-headerItem {
-  padding-left: 4px;
-}
+    .jp-DirListing-header .jp-DirListing-checkboxWrapper+.jp-DirListing-headerItem {
+      padding-left: 4px;
+    }
 
-.jp-DirListing-content .jp-DirListing-checkboxWrapper {
-  position: relative;
-  left: -4px;
-  margin: -4px 0 -4px -8px;
-}
+    .jp-DirListing-content .jp-DirListing-checkboxWrapper {
+      position: relative;
+      left: -4px;
+      margin: -4px 0 -4px -8px;
+    }
 
-.jp-DirListing-checkboxWrapper.jp-mod-visible {
-  visibility: visible;
-}
+    .jp-DirListing-checkboxWrapper.jp-mod-visible {
+      visibility: visible;
+    }
 
-/* For devices that support hovering, hide checkboxes until hovered, selected...
+    /* For devices that support hovering, hide checkboxes until hovered, selected...
 */
-@media (hover: hover) {
-  .jp-DirListing-checkboxWrapper {
-    visibility: hidden;
-  }
+    @media (hover: hover) {
+      .jp-DirListing-checkboxWrapper {
+        visibility: hidden;
+      }
 
-  .jp-DirListing-item:hover .jp-DirListing-checkboxWrapper,
-  .jp-DirListing-item.jp-mod-selected .jp-DirListing-checkboxWrapper {
-    visibility: visible;
-  }
-}
+      .jp-DirListing-item:hover .jp-DirListing-checkboxWrapper,
+      .jp-DirListing-item.jp-mod-selected .jp-DirListing-checkboxWrapper {
+        visibility: visible;
+      }
+    }
 
-.jp-DirListing-item[data-is-dot] {
-  opacity: 75%;
-}
+    .jp-DirListing-item[data-is-dot] {
+      opacity: 75%;
+    }
 
-.jp-DirListing-item.jp-mod-selected {
-  color: var(--jp-ui-inverse-font-color1);
-  background: var(--jp-brand-color1);
-}
+    .jp-DirListing-item.jp-mod-selected {
+      color: var(--jp-ui-inverse-font-color1);
+      background: var(--jp-brand-color1);
+    }
 
-.jp-DirListing-item.jp-mod-dropTarget {
-  background: var(--jp-brand-color3);
-}
+    .jp-DirListing-item.jp-mod-dropTarget {
+      background: var(--jp-brand-color3);
+    }
 
-.jp-DirListing-item:hover:not(.jp-mod-selected) {
-  background: var(--jp-layout-color2);
-}
+    .jp-DirListing-item:hover:not(.jp-mod-selected) {
+      background: var(--jp-layout-color2);
+    }
 
-.jp-DirListing-itemIcon {
-  flex: 0 0 20px;
-  margin-right: 4px;
-}
+    .jp-DirListing-itemIcon {
+      flex: 0 0 20px;
+      margin-right: 4px;
+    }
 
-.jp-DirListing-itemText {
-  flex: 1 0 64px;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
-  user-select: none;
-}
+    .jp-DirListing-itemText {
+      flex: 1 0 64px;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
+      user-select: none;
+    }
 
-.jp-DirListing-itemText:focus {
-  outline-width: 2px;
-  outline-color: var(--jp-inverse-layout-color1);
-  outline-style: solid;
-  outline-offset: 1px;
-}
+    .jp-DirListing-itemText:focus {
+      outline-width: 2px;
+      outline-color: var(--jp-inverse-layout-color1);
+      outline-style: solid;
+      outline-offset: 1px;
+    }
 
-.jp-DirListing-item.jp-mod-selected .jp-DirListing-itemText:focus {
-  outline-color: var(--jp-layout-color1);
-}
+    .jp-DirListing-item.jp-mod-selected .jp-DirListing-itemText:focus {
+      outline-color: var(--jp-layout-color1);
+    }
 
-.jp-DirListing-itemModified {
-  flex: 0 0 125px;
-  text-align: right;
-}
+    .jp-DirListing-itemModified {
+      flex: 0 0 125px;
+      text-align: right;
+    }
 
-.jp-DirListing-itemFileSize {
-  flex: 0 0 90px;
-  text-align: right;
-}
+    .jp-DirListing-itemFileSize {
+      flex: 0 0 90px;
+      text-align: right;
+    }
 
-.jp-DirListing-editor {
-  flex: 1 0 64px;
-  outline: none;
-  border: none;
-  color: var(--jp-ui-font-color1);
-  background-color: var(--jp-layout-color1);
-}
+    .jp-DirListing-editor {
+      flex: 1 0 64px;
+      outline: none;
+      border: none;
+      color: var(--jp-ui-font-color1);
+      background-color: var(--jp-layout-color1);
+    }
 
-.jp-DirListing-item.jp-mod-running .jp-DirListing-itemIcon::before {
-  color: var(--jp-success-color1);
-  content: '\25CF';
-  font-size: 8px;
-  position: absolute;
-  left: -8px;
-}
+    .jp-DirListing-item.jp-mod-running .jp-DirListing-itemIcon::before {
+      color: var(--jp-success-color1);
+      content: '\25CF';
+      font-size: 8px;
+      position: absolute;
+      left: -8px;
+    }
 
-.jp-DirListing-item.jp-mod-running.jp-mod-selected
-  .jp-DirListing-itemIcon::before {
-  color: var(--jp-ui-inverse-font-color1);
-}
+    .jp-DirListing-item.jp-mod-running.jp-mod-selected .jp-DirListing-itemIcon::before {
+      color: var(--jp-ui-inverse-font-color1);
+    }
 
-.jp-DirListing-item.lm-mod-drag-image,
-.jp-DirListing-item.jp-mod-selected.lm-mod-drag-image {
-  font-size: var(--jp-ui-font-size1);
-  padding-left: 4px;
-  margin-left: 4px;
-  width: 160px;
-  background-color: var(--jp-ui-inverse-font-color2);
-  box-shadow: var(--jp-elevation-z2);
-  border-radius: 0;
-  color: var(--jp-ui-font-color1);
-  transform: translateX(-40%) translateY(-58%);
-}
+    .jp-DirListing-item.lm-mod-drag-image,
+    .jp-DirListing-item.jp-mod-selected.lm-mod-drag-image {
+      font-size: var(--jp-ui-font-size1);
+      padding-left: 4px;
+      margin-left: 4px;
+      width: 160px;
+      background-color: var(--jp-ui-inverse-font-color2);
+      box-shadow: var(--jp-elevation-z2);
+      border-radius: 0;
+      color: var(--jp-ui-font-color1);
+      transform: translateX(-40%) translateY(-58%);
+    }
 
-.jp-Document {
-  min-width: 120px;
-  min-height: 120px;
-  outline: none;
-}
+    .jp-Document {
+      min-width: 120px;
+      min-height: 120px;
+      outline: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Main OutputArea
 | OutputArea has a list of Outputs
 |----------------------------------------------------------------------------*/
 
-.jp-OutputArea {
-  overflow-y: auto;
-}
+    .jp-OutputArea {
+      overflow-y: auto;
+    }
 
-.jp-OutputArea-child {
-  display: table;
-  table-layout: fixed;
-  width: 100%;
-  overflow: hidden;
-}
+    .jp-OutputArea-child {
+      display: table;
+      table-layout: fixed;
+      width: 100%;
+      overflow: hidden;
+    }
 
-.jp-OutputPrompt {
-  width: var(--jp-cell-prompt-width);
-  color: var(--jp-cell-outprompt-font-color);
-  font-family: var(--jp-cell-prompt-font-family);
-  padding: var(--jp-code-padding);
-  letter-spacing: var(--jp-cell-prompt-letter-spacing);
-  line-height: var(--jp-code-line-height);
-  font-size: var(--jp-code-font-size);
-  border: var(--jp-border-width) solid transparent;
-  opacity: var(--jp-cell-prompt-opacity);
+    .jp-OutputPrompt {
+      width: var(--jp-cell-prompt-width);
+      color: var(--jp-cell-outprompt-font-color);
+      font-family: var(--jp-cell-prompt-font-family);
+      padding: var(--jp-code-padding);
+      letter-spacing: var(--jp-cell-prompt-letter-spacing);
+      line-height: var(--jp-code-line-height);
+      font-size: var(--jp-code-font-size);
+      border: var(--jp-border-width) solid transparent;
+      opacity: var(--jp-cell-prompt-opacity);
 
-  /* Right align prompt text, don't wrap to handle large prompt numbers */
-  text-align: right;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+      /* Right align prompt text, don't wrap to handle large prompt numbers */
+      text-align: right;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
 
-  /* Disable text selection */
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+      /* Disable text selection */
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.jp-OutputArea-prompt {
-  display: table-cell;
-  vertical-align: top;
-}
+    .jp-OutputArea-prompt {
+      display: table-cell;
+      vertical-align: top;
+    }
 
-.jp-OutputArea-output {
-  display: table-cell;
-  width: 100%;
-  height: auto;
-  overflow: auto;
-  user-select: text;
-  -moz-user-select: text;
-  -webkit-user-select: text;
-  -ms-user-select: text;
-}
+    .jp-OutputArea-output {
+      display: table-cell;
+      width: 100%;
+      height: auto;
+      overflow: auto;
+      user-select: text;
+      -moz-user-select: text;
+      -webkit-user-select: text;
+      -ms-user-select: text;
+    }
 
-.jp-OutputArea .jp-RenderedText {
-  padding-left: 1ch;
-}
+    .jp-OutputArea .jp-RenderedText {
+      padding-left: 1ch;
+    }
 
-/**
+    /**
  * Prompt overlay.
  */
 
-.jp-OutputArea-promptOverlay {
-  position: absolute;
-  top: 0;
-  width: var(--jp-cell-prompt-width);
-  height: 100%;
-  opacity: 0.5;
-}
+    .jp-OutputArea-promptOverlay {
+      position: absolute;
+      top: 0;
+      width: var(--jp-cell-prompt-width);
+      height: 100%;
+      opacity: 0.5;
+    }
 
-.jp-OutputArea-promptOverlay:hover {
-  background: var(--jp-layout-color2);
-  box-shadow: inset 0 0 1px var(--jp-inverse-layout-color0);
-  cursor: zoom-out;
-}
+    .jp-OutputArea-promptOverlay:hover {
+      background: var(--jp-layout-color2);
+      box-shadow: inset 0 0 1px var(--jp-inverse-layout-color0);
+      cursor: zoom-out;
+    }
 
-.jp-mod-outputsScrolled .jp-OutputArea-promptOverlay:hover {
-  cursor: zoom-in;
-}
+    .jp-mod-outputsScrolled .jp-OutputArea-promptOverlay:hover {
+      cursor: zoom-in;
+    }
 
-/**
+    /**
  * Isolated output.
  */
-.jp-OutputArea-output.jp-mod-isolated {
-  width: 100%;
-  display: block;
-}
+    .jp-OutputArea-output.jp-mod-isolated {
+      width: 100%;
+      display: block;
+    }
 
-/*
+    /*
 When drag events occur, `lm-mod-override-cursor` is added to the body.
 Because iframes steal all cursor events, the following two rules are necessary
 to suppress pointer events while resize drags are occurring. There may be a
 better solution to this problem.
 */
-body.lm-mod-override-cursor .jp-OutputArea-output.jp-mod-isolated {
-  position: relative;
-}
+    body.lm-mod-override-cursor .jp-OutputArea-output.jp-mod-isolated {
+      position: relative;
+    }
 
-body.lm-mod-override-cursor .jp-OutputArea-output.jp-mod-isolated::before {
-  content: '';
-  position: absolute;
-  top: 0;
-  left: 0;
-  right: 0;
-  bottom: 0;
-  background: transparent;
-}
+    body.lm-mod-override-cursor .jp-OutputArea-output.jp-mod-isolated::before {
+      content: '';
+      position: absolute;
+      top: 0;
+      left: 0;
+      right: 0;
+      bottom: 0;
+      background: transparent;
+    }
 
-/* pre */
+    /* pre */
 
-.jp-OutputArea-output pre {
-  border: none;
-  margin: 0;
-  padding: 0;
-  overflow-x: auto;
-  overflow-y: auto;
-  word-break: break-all;
-  word-wrap: break-word;
-  white-space: pre-wrap;
-}
+    .jp-OutputArea-output pre {
+      border: none;
+      margin: 0;
+      padding: 0;
+      overflow-x: auto;
+      overflow-y: auto;
+      word-break: break-all;
+      word-wrap: break-word;
+      white-space: pre-wrap;
+    }
 
-/* tables */
+    /* tables */
 
-.jp-OutputArea-output.jp-RenderedHTMLCommon table {
-  margin-left: 0;
-  margin-right: 0;
-}
+    .jp-OutputArea-output.jp-RenderedHTMLCommon table {
+      margin-left: 0;
+      margin-right: 0;
+    }
 
-/* description lists */
+    /* description lists */
 
-.jp-OutputArea-output dl,
-.jp-OutputArea-output dt,
-.jp-OutputArea-output dd {
-  display: block;
-}
+    .jp-OutputArea-output dl,
+    .jp-OutputArea-output dt,
+    .jp-OutputArea-output dd {
+      display: block;
+    }
 
-.jp-OutputArea-output dl {
-  width: 100%;
-  overflow: hidden;
-  padding: 0;
-  margin: 0;
-}
+    .jp-OutputArea-output dl {
+      width: 100%;
+      overflow: hidden;
+      padding: 0;
+      margin: 0;
+    }
 
-.jp-OutputArea-output dt {
-  font-weight: bold;
-  float: left;
-  width: 20%;
-  padding: 0;
-  margin: 0;
-}
+    .jp-OutputArea-output dt {
+      font-weight: bold;
+      float: left;
+      width: 20%;
+      padding: 0;
+      margin: 0;
+    }
 
-.jp-OutputArea-output dd {
-  float: left;
-  width: 80%;
-  padding: 0;
-  margin: 0;
-}
+    .jp-OutputArea-output dd {
+      float: left;
+      width: 80%;
+      padding: 0;
+      margin: 0;
+    }
 
-.jp-TrimmedOutputs pre {
-  background: var(--jp-layout-color3);
-  font-size: calc(var(--jp-code-font-size) * 1.4);
-  text-align: center;
-  text-transform: uppercase;
-}
+    .jp-TrimmedOutputs pre {
+      background: var(--jp-layout-color3);
+      font-size: calc(var(--jp-code-font-size) * 1.4);
+      text-align: center;
+      text-transform: uppercase;
+    }
 
-/* Hide the gutter in case of
+    /* Hide the gutter in case of
  *  - nested output areas (e.g. in the case of output widgets)
  *  - mirrored output areas
  */
-.jp-OutputArea .jp-OutputArea .jp-OutputArea-prompt {
-  display: none;
-}
+    .jp-OutputArea .jp-OutputArea .jp-OutputArea-prompt {
+      display: none;
+    }
 
-/* Hide empty lines in the output area, for instance due to cleared widgets */
-.jp-OutputArea-prompt:empty {
-  padding: 0;
-  border: 0;
-}
+    /* Hide empty lines in the output area, for instance due to cleared widgets */
+    .jp-OutputArea-prompt:empty {
+      padding: 0;
+      border: 0;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | executeResult is added to any Output-result for the display of the object
 | returned by a cell
 |----------------------------------------------------------------------------*/
 
-.jp-OutputArea-output.jp-OutputArea-executeResult {
-  margin-left: 0;
-  width: 100%;
-}
+    .jp-OutputArea-output.jp-OutputArea-executeResult {
+      margin-left: 0;
+      width: 100%;
+    }
 
-/* Text output with the Out[] prompt needs a top padding to match the
+    /* Text output with the Out[] prompt needs a top padding to match the
  * alignment of the Out[] prompt itself.
  */
-.jp-OutputArea-executeResult .jp-RenderedText.jp-OutputArea-output {
-  padding-top: var(--jp-code-padding);
-  border-top: var(--jp-border-width) solid transparent;
-}
+    .jp-OutputArea-executeResult .jp-RenderedText.jp-OutputArea-output {
+      padding-top: var(--jp-code-padding);
+      border-top: var(--jp-border-width) solid transparent;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | The Stdin output
 |----------------------------------------------------------------------------*/
 
-.jp-Stdin-prompt {
-  color: var(--jp-content-font-color0);
-  padding-right: var(--jp-code-padding);
-  vertical-align: baseline;
-  flex: 0 0 auto;
-}
+    .jp-Stdin-prompt {
+      color: var(--jp-content-font-color0);
+      padding-right: var(--jp-code-padding);
+      vertical-align: baseline;
+      flex: 0 0 auto;
+    }
 
-.jp-Stdin-input {
-  font-family: var(--jp-code-font-family);
-  font-size: inherit;
-  color: inherit;
-  background-color: inherit;
-  width: 42%;
-  min-width: 200px;
+    .jp-Stdin-input {
+      font-family: var(--jp-code-font-family);
+      font-size: inherit;
+      color: inherit;
+      background-color: inherit;
+      width: 42%;
+      min-width: 200px;
 
-  /* make sure input baseline aligns with prompt */
-  vertical-align: baseline;
+      /* make sure input baseline aligns with prompt */
+      vertical-align: baseline;
 
-  /* padding + margin = 0.5em between prompt and cursor */
-  padding: 0 0.25em;
-  margin: 0 0.25em;
-  flex: 0 0 70%;
-}
+      /* padding + margin = 0.5em between prompt and cursor */
+      padding: 0 0.25em;
+      margin: 0 0.25em;
+      flex: 0 0 70%;
+    }
 
-.jp-Stdin-input::placeholder {
-  opacity: 0;
-}
+    .jp-Stdin-input::placeholder {
+      opacity: 0;
+    }
 
-.jp-Stdin-input:focus {
-  box-shadow: none;
-}
+    .jp-Stdin-input:focus {
+      box-shadow: none;
+    }
 
-.jp-Stdin-input:focus::placeholder {
-  opacity: 1;
-}
+    .jp-Stdin-input:focus::placeholder {
+      opacity: 1;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Output Area View
 |----------------------------------------------------------------------------*/
 
-.jp-LinkedOutputView .jp-OutputArea {
-  height: 100%;
-  display: block;
-}
+    .jp-LinkedOutputView .jp-OutputArea {
+      height: 100%;
+      display: block;
+    }
 
-.jp-LinkedOutputView .jp-OutputArea-output:only-child {
-  height: 100%;
-}
+    .jp-LinkedOutputView .jp-OutputArea-output:only-child {
+      height: 100%;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Printing
 |----------------------------------------------------------------------------*/
 
-@media print {
-  .jp-OutputArea-child {
-    break-inside: avoid-page;
-  }
-}
+    @media print {
+      .jp-OutputArea-child {
+        break-inside: avoid-page;
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Mobile
 |----------------------------------------------------------------------------*/
-@media only screen and (max-width: 760px) {
-  .jp-OutputPrompt {
-    display: table-row;
-    text-align: left;
-  }
+    @media only screen and (max-width: 760px) {
+      .jp-OutputPrompt {
+        display: table-row;
+        text-align: left;
+      }
 
-  .jp-OutputArea-child .jp-OutputArea-output {
-    display: table-row;
-    margin-left: var(--jp-notebook-padding);
-  }
-}
+      .jp-OutputArea-child .jp-OutputArea-output {
+        display: table-row;
+        margin-left: var(--jp-notebook-padding);
+      }
+    }
 
-/* Trimmed outputs warning */
-.jp-TrimmedOutputs > a {
-  margin: 10px;
-  text-decoration: none;
-  cursor: pointer;
-}
+    /* Trimmed outputs warning */
+    .jp-TrimmedOutputs>a {
+      margin: 10px;
+      text-decoration: none;
+      cursor: pointer;
+    }
 
-.jp-TrimmedOutputs > a:hover {
-  text-decoration: none;
-}
+    .jp-TrimmedOutputs>a:hover {
+      text-decoration: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Table of Contents
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-private-toc-active-width: 4px;
-}
+    :root {
+      --jp-private-toc-active-width: 4px;
+    }
 
-.jp-TableOfContents {
-  display: flex;
-  flex-direction: column;
-  background: var(--jp-layout-color1);
-  color: var(--jp-ui-font-color1);
-  font-size: var(--jp-ui-font-size1);
-  height: 100%;
-}
+    .jp-TableOfContents {
+      display: flex;
+      flex-direction: column;
+      background: var(--jp-layout-color1);
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+      height: 100%;
+    }
 
-.jp-TableOfContents-placeholder {
-  text-align: center;
-}
+    .jp-TableOfContents-placeholder {
+      text-align: center;
+    }
 
-.jp-TableOfContents-placeholderContent {
-  color: var(--jp-content-font-color2);
-  padding: 8px;
-}
+    .jp-TableOfContents-placeholderContent {
+      color: var(--jp-content-font-color2);
+      padding: 8px;
+    }
 
-.jp-TableOfContents-placeholderContent > h3 {
-  margin-bottom: var(--jp-content-heading-margin-bottom);
-}
+    .jp-TableOfContents-placeholderContent>h3 {
+      margin-bottom: var(--jp-content-heading-margin-bottom);
+    }
 
-.jp-TableOfContents .jp-SidePanel-content {
-  overflow-y: auto;
-}
+    .jp-TableOfContents .jp-SidePanel-content {
+      overflow-y: auto;
+    }
 
-.jp-TableOfContents-tree {
-  margin: 4px;
-}
+    .jp-TableOfContents-tree {
+      margin: 4px;
+    }
 
-.jp-TableOfContents ol {
-  list-style-type: none;
-}
+    .jp-TableOfContents ol {
+      list-style-type: none;
+    }
 
-/* stylelint-disable-next-line selector-max-type */
-.jp-TableOfContents li > ol {
-  /* Align left border with triangle icon center */
-  padding-left: 11px;
-}
+    /* stylelint-disable-next-line selector-max-type */
+    .jp-TableOfContents li>ol {
+      /* Align left border with triangle icon center */
+      padding-left: 11px;
+    }
 
-.jp-TableOfContents-content {
-  /* left margin for the active heading indicator */
-  margin: 0 0 0 var(--jp-private-toc-active-width);
-  padding: 0;
-  background-color: var(--jp-layout-color1);
-}
+    .jp-TableOfContents-content {
+      /* left margin for the active heading indicator */
+      margin: 0 0 0 var(--jp-private-toc-active-width);
+      padding: 0;
+      background-color: var(--jp-layout-color1);
+    }
 
-.jp-tocItem {
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+    .jp-tocItem {
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-.jp-tocItem-heading {
-  display: flex;
-  cursor: pointer;
-}
+    .jp-tocItem-heading {
+      display: flex;
+      cursor: pointer;
+    }
 
-.jp-tocItem-heading:hover {
-  background-color: var(--jp-layout-color2);
-}
+    .jp-tocItem-heading:hover {
+      background-color: var(--jp-layout-color2);
+    }
 
-.jp-tocItem-content {
-  display: block;
-  padding: 4px 0;
-  white-space: nowrap;
-  text-overflow: ellipsis;
-  overflow-x: hidden;
-}
+    .jp-tocItem-content {
+      display: block;
+      padding: 4px 0;
+      white-space: nowrap;
+      text-overflow: ellipsis;
+      overflow-x: hidden;
+    }
 
-.jp-tocItem-collapser {
-  height: 20px;
-  margin: 2px 2px 0;
-  padding: 0;
-  background: none;
-  border: none;
-  cursor: pointer;
-}
+    .jp-tocItem-collapser {
+      height: 20px;
+      margin: 2px 2px 0;
+      padding: 0;
+      background: none;
+      border: none;
+      cursor: pointer;
+    }
 
-.jp-tocItem-collapser:hover {
-  background-color: var(--jp-layout-color3);
-}
+    .jp-tocItem-collapser:hover {
+      background-color: var(--jp-layout-color3);
+    }
 
-/* Active heading indicator */
+    /* Active heading indicator */
 
-.jp-tocItem-heading::before {
-  content: ' ';
-  background: transparent;
-  width: var(--jp-private-toc-active-width);
-  height: 24px;
-  position: absolute;
-  left: 0;
-  border-radius: var(--jp-border-radius);
-}
+    .jp-tocItem-heading::before {
+      content: ' ';
+      background: transparent;
+      width: var(--jp-private-toc-active-width);
+      height: 24px;
+      position: absolute;
+      left: 0;
+      border-radius: var(--jp-border-radius);
+    }
 
-.jp-tocItem-heading.jp-tocItem-active::before {
-  background-color: var(--jp-brand-color1);
-}
+    .jp-tocItem-heading.jp-tocItem-active::before {
+      background-color: var(--jp-brand-color1);
+    }
 
-.jp-tocItem-heading:hover.jp-tocItem-active::before {
-  background: var(--jp-brand-color0);
-  opacity: 1;
-}
+    .jp-tocItem-heading:hover.jp-tocItem-active::before {
+      background: var(--jp-brand-color0);
+      opacity: 1;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-.jp-Collapser {
-  flex: 0 0 var(--jp-cell-collapser-width);
-  padding: 0;
-  margin: 0;
-  border: none;
-  outline: none;
-  background: transparent;
-  border-radius: var(--jp-border-radius);
-  opacity: 1;
-}
+    .jp-Collapser {
+      flex: 0 0 var(--jp-cell-collapser-width);
+      padding: 0;
+      margin: 0;
+      border: none;
+      outline: none;
+      background: transparent;
+      border-radius: var(--jp-border-radius);
+      opacity: 1;
+    }
 
-.jp-Collapser-child {
-  display: block;
-  width: 100%;
-  box-sizing: border-box;
+    .jp-Collapser-child {
+      display: block;
+      width: 100%;
+      box-sizing: border-box;
 
-  /* height: 100% doesn't work because the height of its parent is computed from content */
-  position: absolute;
-  top: 0;
-  bottom: 0;
-}
+      /* height: 100% doesn't work because the height of its parent is computed from content */
+      position: absolute;
+      top: 0;
+      bottom: 0;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Printing
 |----------------------------------------------------------------------------*/
 
-/*
+    /*
 Hiding collapsers in print mode.
 
 Note: input and output wrappers have "display: block" propery in print mode.
 */
 
-@media print {
-  .jp-Collapser {
-    display: none;
-  }
-}
+    @media print {
+      .jp-Collapser {
+        display: none;
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Header/Footer
 |----------------------------------------------------------------------------*/
 
-/* Hidden by zero height by default */
-.jp-CellHeader,
-.jp-CellFooter {
-  height: 0;
-  width: 100%;
-  padding: 0;
-  margin: 0;
-  border: none;
-  outline: none;
-  background: transparent;
-}
+    /* Hidden by zero height by default */
+    .jp-CellHeader,
+    .jp-CellFooter {
+      height: 0;
+      width: 100%;
+      padding: 0;
+      margin: 0;
+      border: none;
+      outline: none;
+      background: transparent;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Input
 |----------------------------------------------------------------------------*/
 
-/* All input areas */
-.jp-InputArea {
-  display: table;
-  table-layout: fixed;
-  width: 100%;
-  overflow: hidden;
-}
+    /* All input areas */
+    .jp-InputArea {
+      display: table;
+      table-layout: fixed;
+      width: 100%;
+      overflow: hidden;
+    }
 
-.jp-InputArea-editor {
-  display: table-cell;
-  overflow: hidden;
-  vertical-align: top;
+    .jp-InputArea-editor {
+      display: table-cell;
+      overflow: hidden;
+      vertical-align: top;
 
-  /* This is the non-active, default styling */
-  border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
-  border-radius: 0;
-  background: var(--jp-cell-editor-background);
-}
+      /* This is the non-active, default styling */
+      border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
+      border-radius: 0;
+      background: var(--jp-cell-editor-background);
+    }
 
-.jp-InputPrompt {
-  display: table-cell;
-  vertical-align: top;
-  width: var(--jp-cell-prompt-width);
-  color: var(--jp-cell-inprompt-font-color);
-  font-family: var(--jp-cell-prompt-font-family);
-  padding: var(--jp-code-padding);
-  letter-spacing: var(--jp-cell-prompt-letter-spacing);
-  opacity: var(--jp-cell-prompt-opacity);
-  line-height: var(--jp-code-line-height);
-  font-size: var(--jp-code-font-size);
-  border: var(--jp-border-width) solid transparent;
+    .jp-InputPrompt {
+      display: table-cell;
+      vertical-align: top;
+      width: var(--jp-cell-prompt-width);
+      color: var(--jp-cell-inprompt-font-color);
+      font-family: var(--jp-cell-prompt-font-family);
+      padding: var(--jp-code-padding);
+      letter-spacing: var(--jp-cell-prompt-letter-spacing);
+      opacity: var(--jp-cell-prompt-opacity);
+      line-height: var(--jp-code-line-height);
+      font-size: var(--jp-code-font-size);
+      border: var(--jp-border-width) solid transparent;
 
-  /* Right align prompt text, don't wrap to handle large prompt numbers */
-  text-align: right;
-  white-space: nowrap;
-  overflow: hidden;
-  text-overflow: ellipsis;
+      /* Right align prompt text, don't wrap to handle large prompt numbers */
+      text-align: right;
+      white-space: nowrap;
+      overflow: hidden;
+      text-overflow: ellipsis;
 
-  /* Disable text selection */
-  -webkit-user-select: none;
-  -moz-user-select: none;
-  -ms-user-select: none;
-  user-select: none;
-}
+      /* Disable text selection */
+      -webkit-user-select: none;
+      -moz-user-select: none;
+      -ms-user-select: none;
+      user-select: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Mobile
 |----------------------------------------------------------------------------*/
-@media only screen and (max-width: 760px) {
-  .jp-InputArea-editor {
-    display: table-row;
-    margin-left: var(--jp-notebook-padding);
-  }
+    @media only screen and (max-width: 760px) {
+      .jp-InputArea-editor {
+        display: table-row;
+        margin-left: var(--jp-notebook-padding);
+      }
 
-  .jp-InputPrompt {
-    display: table-row;
-    text-align: left;
-  }
-}
+      .jp-InputPrompt {
+        display: table-row;
+        text-align: left;
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Placeholder
 |----------------------------------------------------------------------------*/
 
-.jp-Placeholder {
-  display: table;
-  table-layout: fixed;
-  width: 100%;
-}
+    .jp-Placeholder {
+      display: table;
+      table-layout: fixed;
+      width: 100%;
+    }
 
-.jp-Placeholder-prompt {
-  display: table-cell;
-  box-sizing: border-box;
-}
+    .jp-Placeholder-prompt {
+      display: table-cell;
+      box-sizing: border-box;
+    }
 
-.jp-Placeholder-content {
-  display: table-cell;
-  padding: 4px 6px;
-  border: 1px solid transparent;
-  border-radius: 0;
-  background: none;
-  box-sizing: border-box;
-  cursor: pointer;
-}
+    .jp-Placeholder-content {
+      display: table-cell;
+      padding: 4px 6px;
+      border: 1px solid transparent;
+      border-radius: 0;
+      background: none;
+      box-sizing: border-box;
+      cursor: pointer;
+    }
 
-.jp-Placeholder-contentContainer {
-  display: flex;
-}
+    .jp-Placeholder-contentContainer {
+      display: flex;
+    }
 
-.jp-Placeholder-content:hover,
-.jp-InputPlaceholder > .jp-Placeholder-content:hover {
-  border-color: var(--jp-layout-color3);
-}
+    .jp-Placeholder-content:hover,
+    .jp-InputPlaceholder>.jp-Placeholder-content:hover {
+      border-color: var(--jp-layout-color3);
+    }
 
-.jp-Placeholder-content .jp-MoreHorizIcon {
-  width: 32px;
-  height: 16px;
-  border: 1px solid transparent;
-  border-radius: var(--jp-border-radius);
-}
+    .jp-Placeholder-content .jp-MoreHorizIcon {
+      width: 32px;
+      height: 16px;
+      border: 1px solid transparent;
+      border-radius: var(--jp-border-radius);
+    }
 
-.jp-Placeholder-content .jp-MoreHorizIcon:hover {
-  border: 1px solid var(--jp-border-color1);
-  box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.25);
-  background-color: var(--jp-layout-color0);
-}
+    .jp-Placeholder-content .jp-MoreHorizIcon:hover {
+      border: 1px solid var(--jp-border-color1);
+      box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.25);
+      background-color: var(--jp-layout-color0);
+    }
 
-.jp-PlaceholderText {
-  white-space: nowrap;
-  overflow-x: hidden;
-  color: var(--jp-inverse-layout-color3);
-  font-family: var(--jp-code-font-family);
-}
+    .jp-PlaceholderText {
+      white-space: nowrap;
+      overflow-x: hidden;
+      color: var(--jp-inverse-layout-color3);
+      font-family: var(--jp-code-font-family);
+    }
 
-.jp-InputPlaceholder > .jp-Placeholder-content {
-  border-color: var(--jp-cell-editor-border-color);
-  background: var(--jp-cell-editor-background);
-}
+    .jp-InputPlaceholder>.jp-Placeholder-content {
+      border-color: var(--jp-cell-editor-border-color);
+      background: var(--jp-cell-editor-background);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Private CSS variables
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-private-cell-scrolling-output-offset: 5px;
-}
+    :root {
+      --jp-private-cell-scrolling-output-offset: 5px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Cell
 |----------------------------------------------------------------------------*/
 
-.jp-Cell {
-  padding: var(--jp-cell-padding);
-  margin: 0;
-  border: none;
-  outline: none;
-  background: transparent;
-}
+    .jp-Cell {
+      padding: var(--jp-cell-padding);
+      margin: 0;
+      border: none;
+      outline: none;
+      background: transparent;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Common input/output
 |----------------------------------------------------------------------------*/
 
-.jp-Cell-inputWrapper,
-.jp-Cell-outputWrapper {
-  display: flex;
-  flex-direction: row;
-  padding: 0;
-  margin: 0;
+    .jp-Cell-inputWrapper,
+    .jp-Cell-outputWrapper {
+      display: flex;
+      flex-direction: row;
+      padding: 0;
+      margin: 0;
 
-  /* Added to reveal the box-shadow on the input and output collapsers. */
-  overflow: visible;
-}
+      /* Added to reveal the box-shadow on the input and output collapsers. */
+      overflow: visible;
+    }
 
-/* Only input/output areas inside cells */
-.jp-Cell-inputArea,
-.jp-Cell-outputArea {
-  flex: 1 1 auto;
-}
+    /* Only input/output areas inside cells */
+    .jp-Cell-inputArea,
+    .jp-Cell-outputArea {
+      flex: 1 1 auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Collapser
 |----------------------------------------------------------------------------*/
 
-/* Make the output collapser disappear when there is not output, but do so
+    /* Make the output collapser disappear when there is not output, but do so
  * in a manner that leaves it in the layout and preserves its width.
  */
-.jp-Cell.jp-mod-noOutputs .jp-Cell-outputCollapser {
-  border: none !important;
-  background: transparent !important;
-}
+    .jp-Cell.jp-mod-noOutputs .jp-Cell-outputCollapser {
+      border: none !important;
+      background: transparent !important;
+    }
 
-.jp-Cell:not(.jp-mod-noOutputs) .jp-Cell-outputCollapser {
-  min-height: var(--jp-cell-collapser-min-height);
-}
+    .jp-Cell:not(.jp-mod-noOutputs) .jp-Cell-outputCollapser {
+      min-height: var(--jp-cell-collapser-min-height);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Output
 |----------------------------------------------------------------------------*/
 
-/* Put a space between input and output when there IS output */
-.jp-Cell:not(.jp-mod-noOutputs) .jp-Cell-outputWrapper {
-  margin-top: 5px;
-}
+    /* Put a space between input and output when there IS output */
+    .jp-Cell:not(.jp-mod-noOutputs) .jp-Cell-outputWrapper {
+      margin-top: 5px;
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea {
-  overflow-y: auto;
-  max-height: 24em;
-  margin-left: var(--jp-private-cell-scrolling-output-offset);
-  resize: vertical;
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea {
+      overflow-y: auto;
+      max-height: 24em;
+      margin-left: var(--jp-private-cell-scrolling-output-offset);
+      resize: vertical;
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea[style*='height'] {
-  max-height: unset;
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea[style*='height'] {
+      max-height: unset;
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea::after {
-  content: ' ';
-  box-shadow: inset 0 0 6px 2px rgb(0 0 0 / 30%);
-  width: 100%;
-  height: 100%;
-  position: sticky;
-  bottom: 0;
-  top: 0;
-  margin-top: -50%;
-  float: left;
-  display: block;
-  pointer-events: none;
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-Cell-outputArea::after {
+      content: ' ';
+      box-shadow: inset 0 0 6px 2px rgb(0 0 0 / 30%);
+      width: 100%;
+      height: 100%;
+      position: sticky;
+      bottom: 0;
+      top: 0;
+      margin-top: -50%;
+      float: left;
+      display: block;
+      pointer-events: none;
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-child {
-  padding-top: 6px;
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-child {
+      padding-top: 6px;
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-prompt {
-  width: calc(
-    var(--jp-cell-prompt-width) - var(--jp-private-cell-scrolling-output-offset)
-  );
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-prompt {
+      width: calc(var(--jp-cell-prompt-width) - var(--jp-private-cell-scrolling-output-offset));
+    }
 
-.jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-promptOverlay {
-  left: calc(-1 * var(--jp-private-cell-scrolling-output-offset));
-}
+    .jp-CodeCell.jp-mod-outputsScrolled .jp-OutputArea-promptOverlay {
+      left: calc(-1 * var(--jp-private-cell-scrolling-output-offset));
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | CodeCell
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | MarkdownCell
 |----------------------------------------------------------------------------*/
 
-.jp-MarkdownOutput {
-  display: table-cell;
-  width: 100%;
-  margin-top: 0;
-  margin-bottom: 0;
-  padding-left: var(--jp-code-padding);
-}
+    .jp-MarkdownOutput {
+      display: table-cell;
+      width: 100%;
+      margin-top: 0;
+      margin-bottom: 0;
+      padding-left: var(--jp-code-padding);
+    }
 
-.jp-MarkdownOutput.jp-RenderedHTMLCommon {
-  overflow: auto;
-}
+    .jp-MarkdownOutput.jp-RenderedHTMLCommon {
+      overflow: auto;
+    }
 
-/* collapseHeadingButton (show always if hiddenCellsButton is _not_ shown) */
-.jp-collapseHeadingButton {
-  display: flex;
-  min-height: var(--jp-cell-collapser-min-height);
-  font-size: var(--jp-code-font-size);
-  position: absolute;
-  background-color: transparent;
-  background-size: 25px;
-  background-repeat: no-repeat;
-  background-position-x: center;
-  background-position-y: top;
-  background-image: var(--jp-icon-caret-down);
-  right: 0;
-  top: 0;
-  bottom: 0;
-}
+    /* collapseHeadingButton (show always if hiddenCellsButton is _not_ shown) */
+    .jp-collapseHeadingButton {
+      display: flex;
+      min-height: var(--jp-cell-collapser-min-height);
+      font-size: var(--jp-code-font-size);
+      position: absolute;
+      background-color: transparent;
+      background-size: 25px;
+      background-repeat: no-repeat;
+      background-position-x: center;
+      background-position-y: top;
+      background-image: var(--jp-icon-caret-down);
+      right: 0;
+      top: 0;
+      bottom: 0;
+    }
 
-.jp-collapseHeadingButton.jp-mod-collapsed {
-  background-image: var(--jp-icon-caret-right);
-}
+    .jp-collapseHeadingButton.jp-mod-collapsed {
+      background-image: var(--jp-icon-caret-right);
+    }
 
-/*
+    /*
  set the container font size to match that of content
  so that the nested collapse buttons have the right size
 */
-.jp-MarkdownCell .jp-InputPrompt {
-  font-size: var(--jp-content-font-size1);
-}
+    .jp-MarkdownCell .jp-InputPrompt {
+      font-size: var(--jp-content-font-size1);
+    }
 
-/*
+    /*
   Align collapseHeadingButton with cell top header
   The font sizes are identical to the ones in packages/rendermime/style/base.css
 */
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='1'] {
-  font-size: var(--jp-content-font-size5);
-  background-position-y: calc(0.3 * var(--jp-content-font-size5));
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='1'] {
+      font-size: var(--jp-content-font-size5);
+      background-position-y: calc(0.3 * var(--jp-content-font-size5));
+    }
 
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='2'] {
-  font-size: var(--jp-content-font-size4);
-  background-position-y: calc(0.3 * var(--jp-content-font-size4));
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='2'] {
+      font-size: var(--jp-content-font-size4);
+      background-position-y: calc(0.3 * var(--jp-content-font-size4));
+    }
 
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='3'] {
-  font-size: var(--jp-content-font-size3);
-  background-position-y: calc(0.3 * var(--jp-content-font-size3));
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='3'] {
+      font-size: var(--jp-content-font-size3);
+      background-position-y: calc(0.3 * var(--jp-content-font-size3));
+    }
 
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='4'] {
-  font-size: var(--jp-content-font-size2);
-  background-position-y: calc(0.3 * var(--jp-content-font-size2));
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='4'] {
+      font-size: var(--jp-content-font-size2);
+      background-position-y: calc(0.3 * var(--jp-content-font-size2));
+    }
 
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='5'] {
-  font-size: var(--jp-content-font-size1);
-  background-position-y: top;
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='5'] {
+      font-size: var(--jp-content-font-size1);
+      background-position-y: top;
+    }
 
-.jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='6'] {
-  font-size: var(--jp-content-font-size0);
-  background-position-y: top;
-}
+    .jp-mod-rendered .jp-collapseHeadingButton[data-heading-level='6'] {
+      font-size: var(--jp-content-font-size0);
+      background-position-y: top;
+    }
 
-/* collapseHeadingButton (show only on (hover,active) if hiddenCellsButton is shown) */
-.jp-Notebook.jp-mod-showHiddenCellsButton .jp-collapseHeadingButton {
-  display: none;
-}
+    /* collapseHeadingButton (show only on (hover,active) if hiddenCellsButton is shown) */
+    .jp-Notebook.jp-mod-showHiddenCellsButton .jp-collapseHeadingButton {
+      display: none;
+    }
 
-.jp-Notebook.jp-mod-showHiddenCellsButton
-  :is(.jp-MarkdownCell:hover, .jp-mod-active)
-  .jp-collapseHeadingButton {
-  display: flex;
-}
+    .jp-Notebook.jp-mod-showHiddenCellsButton :is(.jp-MarkdownCell:hover, .jp-mod-active) .jp-collapseHeadingButton {
+      display: flex;
+    }
 
-/* showHiddenCellsButton (only show if jp-mod-showHiddenCellsButton is set, which
+    /* showHiddenCellsButton (only show if jp-mod-showHiddenCellsButton is set, which
 is a consequence of the showHiddenCellsButton option in Notebook Settings)*/
-.jp-Notebook.jp-mod-showHiddenCellsButton .jp-showHiddenCellsButton {
-  margin-left: calc(var(--jp-cell-prompt-width) + 2 * var(--jp-code-padding));
-  margin-top: var(--jp-code-padding);
-  border: 1px solid var(--jp-border-color2);
-  background-color: var(--jp-border-color3) !important;
-  color: var(--jp-content-font-color0) !important;
-  display: flex;
-}
+    .jp-Notebook.jp-mod-showHiddenCellsButton .jp-showHiddenCellsButton {
+      margin-left: calc(var(--jp-cell-prompt-width) + 2 * var(--jp-code-padding));
+      margin-top: var(--jp-code-padding);
+      border: 1px solid var(--jp-border-color2);
+      background-color: var(--jp-border-color3) !important;
+      color: var(--jp-content-font-color0) !important;
+      display: flex;
+    }
 
-.jp-Notebook.jp-mod-showHiddenCellsButton .jp-showHiddenCellsButton:hover {
-  background-color: var(--jp-border-color2) !important;
-}
+    .jp-Notebook.jp-mod-showHiddenCellsButton .jp-showHiddenCellsButton:hover {
+      background-color: var(--jp-border-color2) !important;
+    }
 
-.jp-showHiddenCellsButton {
-  display: none;
-}
+    .jp-showHiddenCellsButton {
+      display: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Printing
 |----------------------------------------------------------------------------*/
 
-/*
+    /*
 Using block instead of flex to allow the use of the break-inside CSS property for
 cell outputs.
 */
 
-@media print {
-  .jp-Cell-inputWrapper,
-  .jp-Cell-outputWrapper {
-    display: block;
-  }
-}
+    @media print {
 
-/*-----------------------------------------------------------------------------
+      .jp-Cell-inputWrapper,
+      .jp-Cell-outputWrapper {
+        display: block;
+      }
+    }
+
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Variables
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-notebook-toolbar-padding: 2px 5px 2px 2px;
-}
+    :root {
+      --jp-notebook-toolbar-padding: 2px 5px 2px 2px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 
 /*-----------------------------------------------------------------------------
 | Styles
 |----------------------------------------------------------------------------*/
 
-.jp-NotebookPanel-toolbar {
-  padding: var(--jp-notebook-toolbar-padding);
+    .jp-NotebookPanel-toolbar {
+      padding: var(--jp-notebook-toolbar-padding);
 
-  /* disable paint containment from lumino 2.0 default strict CSS containment */
-  contain: style size !important;
-}
+      /* disable paint containment from lumino 2.0 default strict CSS containment */
+      contain: style size !important;
+    }
 
-.jp-Toolbar-item.jp-Notebook-toolbarCellType .jp-select-wrapper.jp-mod-focused {
-  border: none;
-  box-shadow: none;
-}
+    .jp-Toolbar-item.jp-Notebook-toolbarCellType .jp-select-wrapper.jp-mod-focused {
+      border: none;
+      box-shadow: none;
+    }
 
-.jp-Notebook-toolbarCellTypeDropdown select {
-  height: 24px;
-  font-size: var(--jp-ui-font-size1);
-  line-height: 14px;
-  border-radius: 0;
-  display: block;
-}
+    .jp-Notebook-toolbarCellTypeDropdown select {
+      height: 24px;
+      font-size: var(--jp-ui-font-size1);
+      line-height: 14px;
+      border-radius: 0;
+      display: block;
+    }
 
-.jp-Notebook-toolbarCellTypeDropdown span {
-  top: 5px !important;
-}
+    .jp-Notebook-toolbarCellTypeDropdown span {
+      top: 5px !important;
+    }
 
-.jp-Toolbar-responsive-popup {
-  position: absolute;
-  height: fit-content;
-  display: flex;
-  flex-direction: row;
-  flex-wrap: wrap;
-  justify-content: flex-end;
-  border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
-  box-shadow: var(--jp-toolbar-box-shadow);
-  background: var(--jp-toolbar-background);
-  min-height: var(--jp-toolbar-micro-height);
-  padding: var(--jp-notebook-toolbar-padding);
-  z-index: 1;
-  right: 0;
-  top: 0;
-}
+    .jp-Toolbar-responsive-popup {
+      position: absolute;
+      height: fit-content;
+      display: flex;
+      flex-direction: row;
+      flex-wrap: wrap;
+      justify-content: flex-end;
+      border-bottom: var(--jp-border-width) solid var(--jp-toolbar-border-color);
+      box-shadow: var(--jp-toolbar-box-shadow);
+      background: var(--jp-toolbar-background);
+      min-height: var(--jp-toolbar-micro-height);
+      padding: var(--jp-notebook-toolbar-padding);
+      z-index: 1;
+      right: 0;
+      top: 0;
+    }
 
-.jp-Toolbar > .jp-Toolbar-responsive-opener {
-  margin-left: auto;
-}
+    .jp-Toolbar>.jp-Toolbar-responsive-opener {
+      margin-left: auto;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Variables
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 
 /*-----------------------------------------------------------------------------
 | Styles
 |----------------------------------------------------------------------------*/
 
-.jp-Notebook-ExecutionIndicator {
-  position: relative;
-  display: inline-block;
-  height: 100%;
-  z-index: 9997;
-}
+    .jp-Notebook-ExecutionIndicator {
+      position: relative;
+      display: inline-block;
+      height: 100%;
+      z-index: 9997;
+    }
 
-.jp-Notebook-ExecutionIndicator-tooltip {
-  visibility: hidden;
-  height: auto;
-  width: max-content;
-  width: -moz-max-content;
-  background-color: var(--jp-layout-color2);
-  color: var(--jp-ui-font-color1);
-  text-align: justify;
-  border-radius: 6px;
-  padding: 0 5px;
-  position: fixed;
-  display: table;
-}
+    .jp-Notebook-ExecutionIndicator-tooltip {
+      visibility: hidden;
+      height: auto;
+      width: max-content;
+      width: -moz-max-content;
+      background-color: var(--jp-layout-color2);
+      color: var(--jp-ui-font-color1);
+      text-align: justify;
+      border-radius: 6px;
+      padding: 0 5px;
+      position: fixed;
+      display: table;
+    }
 
-.jp-Notebook-ExecutionIndicator-tooltip.up {
-  transform: translateX(-50%) translateY(-100%) translateY(-32px);
-}
+    .jp-Notebook-ExecutionIndicator-tooltip.up {
+      transform: translateX(-50%) translateY(-100%) translateY(-32px);
+    }
 
-.jp-Notebook-ExecutionIndicator-tooltip.down {
-  transform: translateX(calc(-100% + 16px)) translateY(5px);
-}
+    .jp-Notebook-ExecutionIndicator-tooltip.down {
+      transform: translateX(calc(-100% + 16px)) translateY(5px);
+    }
 
-.jp-Notebook-ExecutionIndicator-tooltip.hidden {
-  display: none;
-}
+    .jp-Notebook-ExecutionIndicator-tooltip.hidden {
+      display: none;
+    }
 
-.jp-Notebook-ExecutionIndicator:hover .jp-Notebook-ExecutionIndicator-tooltip {
-  visibility: visible;
-}
+    .jp-Notebook-ExecutionIndicator:hover .jp-Notebook-ExecutionIndicator-tooltip {
+      visibility: visible;
+    }
 
-.jp-Notebook-ExecutionIndicator span {
-  font-size: var(--jp-ui-font-size1);
-  font-family: var(--jp-ui-font-family);
-  color: var(--jp-ui-font-color1);
-  line-height: 24px;
-  display: block;
-}
+    .jp-Notebook-ExecutionIndicator span {
+      font-size: var(--jp-ui-font-size1);
+      font-family: var(--jp-ui-font-family);
+      color: var(--jp-ui-font-color1);
+      line-height: 24px;
+      display: block;
+    }
 
-.jp-Notebook-ExecutionIndicator-progress-bar {
-  display: flex;
-  justify-content: center;
-  height: 100%;
-}
+    .jp-Notebook-ExecutionIndicator-progress-bar {
+      display: flex;
+      justify-content: center;
+      height: 100%;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-/*
+    /*
  * Execution indicator
  */
-.jp-tocItem-content::after {
-  content: '';
+    .jp-tocItem-content::after {
+      content: '';
 
-  /* Must be identical to form a circle */
-  width: 12px;
-  height: 12px;
-  background: none;
-  border: none;
-  position: absolute;
-  right: 0;
-}
+      /* Must be identical to form a circle */
+      width: 12px;
+      height: 12px;
+      background: none;
+      border: none;
+      position: absolute;
+      right: 0;
+    }
 
-.jp-tocItem-content[data-running='0']::after {
-  border-radius: 50%;
-  border: var(--jp-border-width) solid var(--jp-inverse-layout-color3);
-  background: none;
-}
+    .jp-tocItem-content[data-running='0']::after {
+      border-radius: 50%;
+      border: var(--jp-border-width) solid var(--jp-inverse-layout-color3);
+      background: none;
+    }
 
-.jp-tocItem-content[data-running='1']::after {
-  border-radius: 50%;
-  border: var(--jp-border-width) solid var(--jp-inverse-layout-color3);
-  background-color: var(--jp-inverse-layout-color3);
-}
+    .jp-tocItem-content[data-running='1']::after {
+      border-radius: 50%;
+      border: var(--jp-border-width) solid var(--jp-inverse-layout-color3);
+      background-color: var(--jp-inverse-layout-color3);
+    }
 
-.jp-tocItem-content[data-running='0'],
-.jp-tocItem-content[data-running='1'] {
-  margin-right: 12px;
-}
+    .jp-tocItem-content[data-running='0'],
+    .jp-tocItem-content[data-running='1'] {
+      margin-right: 12px;
+    }
 
-/*
+    /*
  * Copyright (c) Jupyter Development Team.
  * Distributed under the terms of the Modified BSD License.
  */
 
-.jp-Notebook-footer {
-  height: 27px;
-  margin-left: calc(
-    var(--jp-cell-prompt-width) + var(--jp-cell-collapser-width) +
-      var(--jp-cell-padding)
-  );
-  width: calc(
-    100% -
-      (
-        var(--jp-cell-prompt-width) + var(--jp-cell-collapser-width) +
-          var(--jp-cell-padding) + var(--jp-cell-padding)
-      )
-  );
-  border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
-  color: var(--jp-ui-font-color3);
-  margin-top: 6px;
-  background: none;
-  cursor: pointer;
-}
+    .jp-Notebook-footer {
+      height: 27px;
+      margin-left: calc(var(--jp-cell-prompt-width) + var(--jp-cell-collapser-width) + var(--jp-cell-padding));
+      width: calc(100% - (var(--jp-cell-prompt-width) + var(--jp-cell-collapser-width) + var(--jp-cell-padding) + var(--jp-cell-padding)));
+      border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
+      color: var(--jp-ui-font-color3);
+      margin-top: 6px;
+      background: none;
+      cursor: pointer;
+    }
 
-.jp-Notebook-footer:focus {
-  border-color: var(--jp-cell-editor-active-border-color);
-}
+    .jp-Notebook-footer:focus {
+      border-color: var(--jp-cell-editor-active-border-color);
+    }
 
-/* For devices that support hovering, hide footer until hover */
-@media (hover: hover) {
-  .jp-Notebook-footer {
-    opacity: 0;
-  }
+    /* For devices that support hovering, hide footer until hover */
+    @media (hover: hover) {
+      .jp-Notebook-footer {
+        opacity: 0;
+      }
 
-  .jp-Notebook-footer:focus,
-  .jp-Notebook-footer:hover {
-    opacity: 1;
-  }
-}
+      .jp-Notebook-footer:focus,
+      .jp-Notebook-footer:hover {
+        opacity: 1;
+      }
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Imports
 |----------------------------------------------------------------------------*/
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | CSS variables
 |----------------------------------------------------------------------------*/
 
-:root {
-  --jp-side-by-side-output-size: 1fr;
-  --jp-side-by-side-resized-cell: var(--jp-side-by-side-output-size);
-  --jp-private-notebook-dragImage-width: 304px;
-  --jp-private-notebook-dragImage-height: 36px;
-  --jp-private-notebook-selected-color: var(--md-blue-400);
-  --jp-private-notebook-active-color: var(--md-green-400);
-}
+    :root {
+      --jp-side-by-side-output-size: 1fr;
+      --jp-side-by-side-resized-cell: var(--jp-side-by-side-output-size);
+      --jp-private-notebook-dragImage-width: 304px;
+      --jp-private-notebook-dragImage-height: 36px;
+      --jp-private-notebook-selected-color: var(--md-blue-400);
+      --jp-private-notebook-active-color: var(--md-green-400);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Notebook
 |----------------------------------------------------------------------------*/
 
-/* stylelint-disable selector-max-class */
+    /* stylelint-disable selector-max-class */
 
-.jp-NotebookPanel {
-  display: block;
-  height: 100%;
-}
+    .jp-NotebookPanel {
+      display: block;
+      height: 100%;
+    }
 
-.jp-NotebookPanel.jp-Document {
-  min-width: 240px;
-  min-height: 120px;
-}
+    .jp-NotebookPanel.jp-Document {
+      min-width: 240px;
+      min-height: 120px;
+    }
 
-.jp-Notebook {
-  padding: var(--jp-notebook-padding);
-  outline: none;
-  overflow: auto;
-  background: var(--jp-layout-color0);
-}
+    .jp-Notebook {
+      padding: var(--jp-notebook-padding);
+      outline: none;
+      overflow: auto;
+      background: var(--jp-layout-color0);
+    }
 
-.jp-Notebook.jp-mod-scrollPastEnd::after {
-  display: block;
-  content: '';
-  min-height: var(--jp-notebook-scroll-padding);
-}
+    .jp-Notebook.jp-mod-scrollPastEnd::after {
+      display: block;
+      content: '';
+      min-height: var(--jp-notebook-scroll-padding);
+    }
 
-.jp-MainAreaWidget-ContainStrict .jp-Notebook * {
-  contain: strict;
-}
+    .jp-MainAreaWidget-ContainStrict .jp-Notebook * {
+      contain: strict;
+    }
 
-.jp-Notebook .jp-Cell {
-  overflow: visible;
-}
+    .jp-Notebook .jp-Cell {
+      overflow: visible;
+    }
 
-.jp-Notebook .jp-Cell .jp-InputPrompt {
-  cursor: move;
-}
+    .jp-Notebook .jp-Cell .jp-InputPrompt {
+      cursor: move;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Notebook state related styling
 |
 | The notebook and cells each have states, here are the possibilities:
@@ -6430,391 +6596,380 @@ cell outputs.
 |   - No outputs
 |----------------------------------------------------------------------------*/
 
-/* Command or edit modes */
+    /* Command or edit modes */
 
-.jp-Notebook .jp-Cell:not(.jp-mod-active) .jp-InputPrompt {
-  opacity: var(--jp-cell-prompt-not-active-opacity);
-  color: var(--jp-cell-prompt-not-active-font-color);
-}
+    .jp-Notebook .jp-Cell:not(.jp-mod-active) .jp-InputPrompt {
+      opacity: var(--jp-cell-prompt-not-active-opacity);
+      color: var(--jp-cell-prompt-not-active-font-color);
+    }
 
-.jp-Notebook .jp-Cell:not(.jp-mod-active) .jp-OutputPrompt {
-  opacity: var(--jp-cell-prompt-not-active-opacity);
-  color: var(--jp-cell-prompt-not-active-font-color);
-}
+    .jp-Notebook .jp-Cell:not(.jp-mod-active) .jp-OutputPrompt {
+      opacity: var(--jp-cell-prompt-not-active-opacity);
+      color: var(--jp-cell-prompt-not-active-font-color);
+    }
 
-/* cell is active */
-.jp-Notebook .jp-Cell.jp-mod-active .jp-Collapser {
-  background: var(--jp-brand-color1);
-}
+    /* cell is active */
+    .jp-Notebook .jp-Cell.jp-mod-active .jp-Collapser {
+      background: var(--jp-brand-color1);
+    }
 
-/* cell is dirty */
-.jp-Notebook .jp-Cell.jp-mod-dirty .jp-InputPrompt {
-  color: var(--jp-warn-color1);
-}
+    /* cell is dirty */
+    .jp-Notebook .jp-Cell.jp-mod-dirty .jp-InputPrompt {
+      color: var(--jp-warn-color1);
+    }
 
-.jp-Notebook .jp-Cell.jp-mod-dirty .jp-InputPrompt::before {
-  color: var(--jp-warn-color1);
-  content: '•';
-}
+    .jp-Notebook .jp-Cell.jp-mod-dirty .jp-InputPrompt::before {
+      color: var(--jp-warn-color1);
+      content: '•';
+    }
 
-.jp-Notebook .jp-Cell.jp-mod-active.jp-mod-dirty .jp-Collapser {
-  background: var(--jp-warn-color1);
-}
+    .jp-Notebook .jp-Cell.jp-mod-active.jp-mod-dirty .jp-Collapser {
+      background: var(--jp-warn-color1);
+    }
 
-/* collapser is hovered */
-.jp-Notebook .jp-Cell .jp-Collapser:hover {
-  box-shadow: var(--jp-elevation-z2);
-  background: var(--jp-brand-color1);
-  opacity: var(--jp-cell-collapser-not-active-hover-opacity);
-}
+    /* collapser is hovered */
+    .jp-Notebook .jp-Cell .jp-Collapser:hover {
+      box-shadow: var(--jp-elevation-z2);
+      background: var(--jp-brand-color1);
+      opacity: var(--jp-cell-collapser-not-active-hover-opacity);
+    }
 
-/* cell is active and collapser is hovered */
-.jp-Notebook .jp-Cell.jp-mod-active .jp-Collapser:hover {
-  background: var(--jp-brand-color0);
-  opacity: 1;
-}
+    /* cell is active and collapser is hovered */
+    .jp-Notebook .jp-Cell.jp-mod-active .jp-Collapser:hover {
+      background: var(--jp-brand-color0);
+      opacity: 1;
+    }
 
-/* Command mode */
+    /* Command mode */
 
-.jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-selected {
-  background: var(--jp-notebook-multiselected-color);
-}
+    .jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-selected {
+      background: var(--jp-notebook-multiselected-color);
+    }
 
-.jp-Notebook.jp-mod-commandMode
-  .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) {
-  background: transparent;
-}
+    .jp-Notebook.jp-mod-commandMode .jp-Cell.jp-mod-active.jp-mod-selected:not(.jp-mod-multiSelected) {
+      background: transparent;
+    }
 
-/* Edit mode */
+    /* Edit mode */
 
-.jp-Notebook.jp-mod-editMode .jp-Cell.jp-mod-active .jp-InputArea-editor {
-  border: var(--jp-border-width) solid var(--jp-cell-editor-active-border-color);
-  box-shadow: var(--jp-input-box-shadow);
-  background-color: var(--jp-cell-editor-active-background);
-}
+    .jp-Notebook.jp-mod-editMode .jp-Cell.jp-mod-active .jp-InputArea-editor {
+      border: var(--jp-border-width) solid var(--jp-cell-editor-active-border-color);
+      box-shadow: var(--jp-input-box-shadow);
+      background-color: var(--jp-cell-editor-active-background);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Notebook drag and drop
 |----------------------------------------------------------------------------*/
 
-.jp-Notebook-cell.jp-mod-dropSource {
-  opacity: 0.5;
-}
+    .jp-Notebook-cell.jp-mod-dropSource {
+      opacity: 0.5;
+    }
 
-.jp-Notebook-cell.jp-mod-dropTarget,
-.jp-Notebook.jp-mod-commandMode
-  .jp-Notebook-cell.jp-mod-active.jp-mod-selected.jp-mod-dropTarget {
-  border-top-color: var(--jp-private-notebook-selected-color);
-  border-top-style: solid;
-  border-top-width: 2px;
-}
+    .jp-Notebook-cell.jp-mod-dropTarget,
+    .jp-Notebook.jp-mod-commandMode .jp-Notebook-cell.jp-mod-active.jp-mod-selected.jp-mod-dropTarget {
+      border-top-color: var(--jp-private-notebook-selected-color);
+      border-top-style: solid;
+      border-top-width: 2px;
+    }
 
-.jp-dragImage {
-  display: block;
-  flex-direction: row;
-  width: var(--jp-private-notebook-dragImage-width);
-  height: var(--jp-private-notebook-dragImage-height);
-  border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
-  background: var(--jp-cell-editor-background);
-  overflow: visible;
-}
+    .jp-dragImage {
+      display: block;
+      flex-direction: row;
+      width: var(--jp-private-notebook-dragImage-width);
+      height: var(--jp-private-notebook-dragImage-height);
+      border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
+      background: var(--jp-cell-editor-background);
+      overflow: visible;
+    }
 
-.jp-dragImage-singlePrompt {
-  box-shadow: 2px 2px 4px 0 rgba(0, 0, 0, 0.12);
-}
+    .jp-dragImage-singlePrompt {
+      box-shadow: 2px 2px 4px 0 rgba(0, 0, 0, 0.12);
+    }
 
-.jp-dragImage .jp-dragImage-content {
-  flex: 1 1 auto;
-  z-index: 2;
-  font-size: var(--jp-code-font-size);
-  font-family: var(--jp-code-font-family);
-  line-height: var(--jp-code-line-height);
-  padding: var(--jp-code-padding);
-  border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
-  background: var(--jp-cell-editor-background-color);
-  color: var(--jp-content-font-color3);
-  text-align: left;
-  margin: 4px 4px 4px 0;
-}
+    .jp-dragImage .jp-dragImage-content {
+      flex: 1 1 auto;
+      z-index: 2;
+      font-size: var(--jp-code-font-size);
+      font-family: var(--jp-code-font-family);
+      line-height: var(--jp-code-line-height);
+      padding: var(--jp-code-padding);
+      border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
+      background: var(--jp-cell-editor-background-color);
+      color: var(--jp-content-font-color3);
+      text-align: left;
+      margin: 4px 4px 4px 0;
+    }
 
-.jp-dragImage .jp-dragImage-prompt {
-  flex: 0 0 auto;
-  min-width: 36px;
-  color: var(--jp-cell-inprompt-font-color);
-  padding: var(--jp-code-padding);
-  padding-left: 12px;
-  font-family: var(--jp-cell-prompt-font-family);
-  letter-spacing: var(--jp-cell-prompt-letter-spacing);
-  line-height: 1.9;
-  font-size: var(--jp-code-font-size);
-  border: var(--jp-border-width) solid transparent;
-}
+    .jp-dragImage .jp-dragImage-prompt {
+      flex: 0 0 auto;
+      min-width: 36px;
+      color: var(--jp-cell-inprompt-font-color);
+      padding: var(--jp-code-padding);
+      padding-left: 12px;
+      font-family: var(--jp-cell-prompt-font-family);
+      letter-spacing: var(--jp-cell-prompt-letter-spacing);
+      line-height: 1.9;
+      font-size: var(--jp-code-font-size);
+      border: var(--jp-border-width) solid transparent;
+    }
 
-.jp-dragImage-multipleBack {
-  z-index: -1;
-  position: absolute;
-  height: 32px;
-  width: 300px;
-  top: 8px;
-  left: 8px;
-  background: var(--jp-layout-color2);
-  border: var(--jp-border-width) solid var(--jp-input-border-color);
-  box-shadow: 2px 2px 4px 0 rgba(0, 0, 0, 0.12);
-}
+    .jp-dragImage-multipleBack {
+      z-index: -1;
+      position: absolute;
+      height: 32px;
+      width: 300px;
+      top: 8px;
+      left: 8px;
+      background: var(--jp-layout-color2);
+      border: var(--jp-border-width) solid var(--jp-input-border-color);
+      box-shadow: 2px 2px 4px 0 rgba(0, 0, 0, 0.12);
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Cell toolbar
 |----------------------------------------------------------------------------*/
 
-.jp-NotebookTools {
-  display: block;
-  min-width: var(--jp-sidebar-min-width);
-  color: var(--jp-ui-font-color1);
-  background: var(--jp-layout-color1);
+    .jp-NotebookTools {
+      display: block;
+      min-width: var(--jp-sidebar-min-width);
+      color: var(--jp-ui-font-color1);
+      background: var(--jp-layout-color1);
 
-  /* This is needed so that all font sizing of children done in ems is
+      /* This is needed so that all font sizing of children done in ems is
     * relative to this base size */
-  font-size: var(--jp-ui-font-size1);
-  overflow: auto;
-}
+      font-size: var(--jp-ui-font-size1);
+      overflow: auto;
+    }
 
-.jp-ActiveCellTool {
-  padding: 12px 0;
-  display: flex;
-}
+    .jp-ActiveCellTool {
+      padding: 12px 0;
+      display: flex;
+    }
 
-.jp-ActiveCellTool-Content {
-  flex: 1 1 auto;
-}
+    .jp-ActiveCellTool-Content {
+      flex: 1 1 auto;
+    }
 
-.jp-ActiveCellTool .jp-ActiveCellTool-CellContent {
-  background: var(--jp-cell-editor-background);
-  border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
-  border-radius: 0;
-  min-height: 29px;
-}
+    .jp-ActiveCellTool .jp-ActiveCellTool-CellContent {
+      background: var(--jp-cell-editor-background);
+      border: var(--jp-border-width) solid var(--jp-cell-editor-border-color);
+      border-radius: 0;
+      min-height: 29px;
+    }
 
-.jp-ActiveCellTool .jp-InputPrompt {
-  min-width: calc(var(--jp-cell-prompt-width) * 0.75);
-}
+    .jp-ActiveCellTool .jp-InputPrompt {
+      min-width: calc(var(--jp-cell-prompt-width) * 0.75);
+    }
 
-.jp-ActiveCellTool-CellContent > pre {
-  padding: 5px 4px;
-  margin: 0;
-  white-space: normal;
-}
+    .jp-ActiveCellTool-CellContent>pre {
+      padding: 5px 4px;
+      margin: 0;
+      white-space: normal;
+    }
 
-.jp-MetadataEditorTool {
-  flex-direction: column;
-  padding: 12px 0;
-}
+    .jp-MetadataEditorTool {
+      flex-direction: column;
+      padding: 12px 0;
+    }
 
-.jp-RankedPanel > :not(:first-child) {
-  margin-top: 12px;
-}
+    .jp-RankedPanel> :not(:first-child) {
+      margin-top: 12px;
+    }
 
-.jp-KeySelector select.jp-mod-styled {
-  font-size: var(--jp-ui-font-size1);
-  color: var(--jp-ui-font-color0);
-  border: var(--jp-border-width) solid var(--jp-border-color1);
-}
+    .jp-KeySelector select.jp-mod-styled {
+      font-size: var(--jp-ui-font-size1);
+      color: var(--jp-ui-font-color0);
+      border: var(--jp-border-width) solid var(--jp-border-color1);
+    }
 
-.jp-KeySelector label,
-.jp-MetadataEditorTool label,
-.jp-NumberSetter label {
-  line-height: 1.4;
-}
+    .jp-KeySelector label,
+    .jp-MetadataEditorTool label,
+    .jp-NumberSetter label {
+      line-height: 1.4;
+    }
 
-.jp-NotebookTools .jp-select-wrapper {
-  margin-top: 4px;
-  margin-bottom: 0;
-}
+    .jp-NotebookTools .jp-select-wrapper {
+      margin-top: 4px;
+      margin-bottom: 0;
+    }
 
-.jp-NumberSetter input {
-  width: 100%;
-  margin-top: 4px;
-}
+    .jp-NumberSetter input {
+      width: 100%;
+      margin-top: 4px;
+    }
 
-.jp-NotebookTools .jp-Collapse {
-  margin-top: 16px;
-}
+    .jp-NotebookTools .jp-Collapse {
+      margin-top: 16px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Presentation Mode (.jp-mod-presentationMode)
 |----------------------------------------------------------------------------*/
 
-.jp-mod-presentationMode .jp-Notebook {
-  --jp-content-font-size1: var(--jp-content-presentation-font-size1);
-  --jp-code-font-size: var(--jp-code-presentation-font-size);
-}
+    .jp-mod-presentationMode .jp-Notebook {
+      --jp-content-font-size1: var(--jp-content-presentation-font-size1);
+      --jp-code-font-size: var(--jp-code-presentation-font-size);
+    }
 
-.jp-mod-presentationMode .jp-Notebook .jp-Cell .jp-InputPrompt,
-.jp-mod-presentationMode .jp-Notebook .jp-Cell .jp-OutputPrompt {
-  flex: 0 0 110px;
-}
+    .jp-mod-presentationMode .jp-Notebook .jp-Cell .jp-InputPrompt,
+    .jp-mod-presentationMode .jp-Notebook .jp-Cell .jp-OutputPrompt {
+      flex: 0 0 110px;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Side-by-side Mode (.jp-mod-sideBySide)
 |----------------------------------------------------------------------------*/
-.jp-mod-sideBySide.jp-Notebook .jp-Notebook-cell {
-  margin-top: 3em;
-  margin-bottom: 3em;
-  margin-left: 5%;
-  margin-right: 5%;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-Notebook-cell {
+      margin-top: 3em;
+      margin-bottom: 3em;
+      margin-left: 5%;
+      margin-right: 5%;
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell {
-  display: grid;
-  grid-template-columns: minmax(0, 1fr) min-content minmax(
-      0,
-      var(--jp-side-by-side-output-size)
-    );
-  grid-template-rows: auto minmax(0, 1fr) auto;
-  grid-template-areas:
-    'header header header'
-    'input handle output'
-    'footer footer footer';
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell {
+      display: grid;
+      grid-template-columns: minmax(0, 1fr) min-content minmax(0,
+          var(--jp-side-by-side-output-size));
+      grid-template-rows: auto minmax(0, 1fr) auto;
+      grid-template-areas:
+        'header header header'
+        'input handle output'
+        'footer footer footer';
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell.jp-mod-resizedCell {
-  grid-template-columns: minmax(0, 1fr) min-content minmax(
-      0,
-      var(--jp-side-by-side-resized-cell)
-    );
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell.jp-mod-resizedCell {
+      grid-template-columns: minmax(0, 1fr) min-content minmax(0,
+          var(--jp-side-by-side-resized-cell));
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellHeader {
-  grid-area: header;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellHeader {
+      grid-area: header;
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-Cell-inputWrapper {
-  grid-area: input;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-Cell-inputWrapper {
+      grid-area: input;
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-Cell-outputWrapper {
-  /* overwrite the default margin (no vertical separation needed in side by side move */
-  margin-top: 0;
-  grid-area: output;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-Cell-outputWrapper {
+      /* overwrite the default margin (no vertical separation needed in side by side move */
+      margin-top: 0;
+      grid-area: output;
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellFooter {
-  grid-area: footer;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellFooter {
+      grid-area: footer;
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellResizeHandle {
-  grid-area: handle;
-  user-select: none;
-  display: block;
-  height: 100%;
-  cursor: ew-resize;
-  padding: 0 var(--jp-cell-padding);
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellResizeHandle {
+      grid-area: handle;
+      user-select: none;
+      display: block;
+      height: 100%;
+      cursor: ew-resize;
+      padding: 0 var(--jp-cell-padding);
+    }
 
-.jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellResizeHandle::after {
-  content: '';
-  display: block;
-  background: var(--jp-border-color2);
-  height: 100%;
-  width: 5px;
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell .jp-CellResizeHandle::after {
+      content: '';
+      display: block;
+      background: var(--jp-border-color2);
+      height: 100%;
+      width: 5px;
+    }
 
-.jp-mod-sideBySide.jp-Notebook
-  .jp-CodeCell.jp-mod-resizedCell
-  .jp-CellResizeHandle::after {
-  background: var(--jp-border-color0);
-}
+    .jp-mod-sideBySide.jp-Notebook .jp-CodeCell.jp-mod-resizedCell .jp-CellResizeHandle::after {
+      background: var(--jp-border-color0);
+    }
 
-.jp-CellResizeHandle {
-  display: none;
-}
+    .jp-CellResizeHandle {
+      display: none;
+    }
 
-/*-----------------------------------------------------------------------------
+    /*-----------------------------------------------------------------------------
 | Placeholder
 |----------------------------------------------------------------------------*/
 
-.jp-Cell-Placeholder {
-  padding-left: 55px;
-}
+    .jp-Cell-Placeholder {
+      padding-left: 55px;
+    }
 
-.jp-Cell-Placeholder-wrapper {
-  background: #fff;
-  border: 1px solid;
-  border-color: #e5e6e9 #dfe0e4 #d0d1d5;
-  border-radius: 4px;
-  -webkit-border-radius: 4px;
-  margin: 10px 15px;
-}
+    .jp-Cell-Placeholder-wrapper {
+      background: #fff;
+      border: 1px solid;
+      border-color: #e5e6e9 #dfe0e4 #d0d1d5;
+      border-radius: 4px;
+      -webkit-border-radius: 4px;
+      margin: 10px 15px;
+    }
 
-.jp-Cell-Placeholder-wrapper-inner {
-  padding: 15px;
-  position: relative;
-}
+    .jp-Cell-Placeholder-wrapper-inner {
+      padding: 15px;
+      position: relative;
+    }
 
-.jp-Cell-Placeholder-wrapper-body {
-  background-repeat: repeat;
-  background-size: 50% auto;
-}
+    .jp-Cell-Placeholder-wrapper-body {
+      background-repeat: repeat;
+      background-size: 50% auto;
+    }
 
-.jp-Cell-Placeholder-wrapper-body div {
-  background: #f6f7f8;
-  background-image: -webkit-linear-gradient(
-    left,
-    #f6f7f8 0%,
-    #edeef1 20%,
-    #f6f7f8 40%,
-    #f6f7f8 100%
-  );
-  background-repeat: no-repeat;
-  background-size: 800px 104px;
-  height: 104px;
-  position: absolute;
-  right: 15px;
-  left: 15px;
-  top: 15px;
-}
+    .jp-Cell-Placeholder-wrapper-body div {
+      background: #f6f7f8;
+      background-image: -webkit-linear-gradient(left,
+          #f6f7f8 0%,
+          #edeef1 20%,
+          #f6f7f8 40%,
+          #f6f7f8 100%);
+      background-repeat: no-repeat;
+      background-size: 800px 104px;
+      height: 104px;
+      position: absolute;
+      right: 15px;
+      left: 15px;
+      top: 15px;
+    }
 
-div.jp-Cell-Placeholder-h1 {
-  top: 20px;
-  height: 20px;
-  left: 15px;
-  width: 150px;
-}
+    div.jp-Cell-Placeholder-h1 {
+      top: 20px;
+      height: 20px;
+      left: 15px;
+      width: 150px;
+    }
 
-div.jp-Cell-Placeholder-h2 {
-  left: 15px;
-  top: 50px;
-  height: 10px;
-  width: 100px;
-}
+    div.jp-Cell-Placeholder-h2 {
+      left: 15px;
+      top: 50px;
+      height: 10px;
+      width: 100px;
+    }
 
-div.jp-Cell-Placeholder-content-1,
-div.jp-Cell-Placeholder-content-2,
-div.jp-Cell-Placeholder-content-3 {
-  left: 15px;
-  right: 15px;
-  height: 10px;
-}
+    div.jp-Cell-Placeholder-content-1,
+    div.jp-Cell-Placeholder-content-2,
+    div.jp-Cell-Placeholder-content-3 {
+      left: 15px;
+      right: 15px;
+      height: 10px;
+    }
 
-div.jp-Cell-Placeholder-content-1 {
-  top: 100px;
-}
+    div.jp-Cell-Placeholder-content-1 {
+      top: 100px;
+    }
 
-div.jp-Cell-Placeholder-content-2 {
-  top: 120px;
-}
+    div.jp-Cell-Placeholder-content-2 {
+      top: 120px;
+    }
 
-div.jp-Cell-Placeholder-content-3 {
-  top: 140px;
-}
-
-</style>
-<style type="text/css">
-/*-----------------------------------------------------------------------------
+    div.jp-Cell-Placeholder-content-3 {
+      top: 140px;
+    }
+  </style>
+  <style type="text/css">
+    /*-----------------------------------------------------------------------------
 | Copyright (c) Jupyter Development Team.
 | Distributed under the terms of the Modified BSD License.
 |----------------------------------------------------------------------------*/
 
-/*
+    /*
 The following CSS variables define the main, public API for styling JupyterLab.
 These variables should be used by all plugins wherever possible. In other
 words, plugins should not define custom colors, sizes, etc unless absolutely
@@ -6835,8 +6990,8 @@ Material Design when selecting colors. We are not, however, following
 all of MD as it is not optimized for dense, information rich UIs.
 */
 
-:root {
-  /* Elevation
+    :root {
+      /* Elevation
    *
    * We style box-shadows using Material Design's idea of elevation. These particular numbers are taken from here:
    *
@@ -6844,68 +6999,62 @@ all of MD as it is not optimized for dense, information rich UIs.
    * https://material-components-web.appspot.com/elevation.html
    */
 
-  --jp-shadow-base-lightness: 0;
-  --jp-shadow-umbra-color: rgba(
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    0.2
-  );
-  --jp-shadow-penumbra-color: rgba(
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    0.14
-  );
-  --jp-shadow-ambient-color: rgba(
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    var(--jp-shadow-base-lightness),
-    0.12
-  );
-  --jp-elevation-z0: none;
-  --jp-elevation-z1: 0 2px 1px -1px var(--jp-shadow-umbra-color),
-    0 1px 1px 0 var(--jp-shadow-penumbra-color),
-    0 1px 3px 0 var(--jp-shadow-ambient-color);
-  --jp-elevation-z2: 0 3px 1px -2px var(--jp-shadow-umbra-color),
-    0 2px 2px 0 var(--jp-shadow-penumbra-color),
-    0 1px 5px 0 var(--jp-shadow-ambient-color);
-  --jp-elevation-z4: 0 2px 4px -1px var(--jp-shadow-umbra-color),
-    0 4px 5px 0 var(--jp-shadow-penumbra-color),
-    0 1px 10px 0 var(--jp-shadow-ambient-color);
-  --jp-elevation-z6: 0 3px 5px -1px var(--jp-shadow-umbra-color),
-    0 6px 10px 0 var(--jp-shadow-penumbra-color),
-    0 1px 18px 0 var(--jp-shadow-ambient-color);
-  --jp-elevation-z8: 0 5px 5px -3px var(--jp-shadow-umbra-color),
-    0 8px 10px 1px var(--jp-shadow-penumbra-color),
-    0 3px 14px 2px var(--jp-shadow-ambient-color);
-  --jp-elevation-z12: 0 7px 8px -4px var(--jp-shadow-umbra-color),
-    0 12px 17px 2px var(--jp-shadow-penumbra-color),
-    0 5px 22px 4px var(--jp-shadow-ambient-color);
-  --jp-elevation-z16: 0 8px 10px -5px var(--jp-shadow-umbra-color),
-    0 16px 24px 2px var(--jp-shadow-penumbra-color),
-    0 6px 30px 5px var(--jp-shadow-ambient-color);
-  --jp-elevation-z20: 0 10px 13px -6px var(--jp-shadow-umbra-color),
-    0 20px 31px 3px var(--jp-shadow-penumbra-color),
-    0 8px 38px 7px var(--jp-shadow-ambient-color);
-  --jp-elevation-z24: 0 11px 15px -7px var(--jp-shadow-umbra-color),
-    0 24px 38px 3px var(--jp-shadow-penumbra-color),
-    0 9px 46px 8px var(--jp-shadow-ambient-color);
+      --jp-shadow-base-lightness: 0;
+      --jp-shadow-umbra-color: rgba(var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          0.2);
+      --jp-shadow-penumbra-color: rgba(var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          0.14);
+      --jp-shadow-ambient-color: rgba(var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          var(--jp-shadow-base-lightness),
+          0.12);
+      --jp-elevation-z0: none;
+      --jp-elevation-z1: 0 2px 1px -1px var(--jp-shadow-umbra-color),
+        0 1px 1px 0 var(--jp-shadow-penumbra-color),
+        0 1px 3px 0 var(--jp-shadow-ambient-color);
+      --jp-elevation-z2: 0 3px 1px -2px var(--jp-shadow-umbra-color),
+        0 2px 2px 0 var(--jp-shadow-penumbra-color),
+        0 1px 5px 0 var(--jp-shadow-ambient-color);
+      --jp-elevation-z4: 0 2px 4px -1px var(--jp-shadow-umbra-color),
+        0 4px 5px 0 var(--jp-shadow-penumbra-color),
+        0 1px 10px 0 var(--jp-shadow-ambient-color);
+      --jp-elevation-z6: 0 3px 5px -1px var(--jp-shadow-umbra-color),
+        0 6px 10px 0 var(--jp-shadow-penumbra-color),
+        0 1px 18px 0 var(--jp-shadow-ambient-color);
+      --jp-elevation-z8: 0 5px 5px -3px var(--jp-shadow-umbra-color),
+        0 8px 10px 1px var(--jp-shadow-penumbra-color),
+        0 3px 14px 2px var(--jp-shadow-ambient-color);
+      --jp-elevation-z12: 0 7px 8px -4px var(--jp-shadow-umbra-color),
+        0 12px 17px 2px var(--jp-shadow-penumbra-color),
+        0 5px 22px 4px var(--jp-shadow-ambient-color);
+      --jp-elevation-z16: 0 8px 10px -5px var(--jp-shadow-umbra-color),
+        0 16px 24px 2px var(--jp-shadow-penumbra-color),
+        0 6px 30px 5px var(--jp-shadow-ambient-color);
+      --jp-elevation-z20: 0 10px 13px -6px var(--jp-shadow-umbra-color),
+        0 20px 31px 3px var(--jp-shadow-penumbra-color),
+        0 8px 38px 7px var(--jp-shadow-ambient-color);
+      --jp-elevation-z24: 0 11px 15px -7px var(--jp-shadow-umbra-color),
+        0 24px 38px 3px var(--jp-shadow-penumbra-color),
+        0 9px 46px 8px var(--jp-shadow-ambient-color);
 
-  /* Borders
+      /* Borders
    *
    * The following variables, specify the visual styling of borders in JupyterLab.
    */
 
-  --jp-border-width: 1px;
-  --jp-border-color0: var(--md-grey-400);
-  --jp-border-color1: var(--md-grey-400);
-  --jp-border-color2: var(--md-grey-300);
-  --jp-border-color3: var(--md-grey-200);
-  --jp-inverse-border-color: var(--md-grey-600);
-  --jp-border-radius: 2px;
+      --jp-border-width: 1px;
+      --jp-border-color0: var(--md-grey-400);
+      --jp-border-color1: var(--md-grey-400);
+      --jp-border-color2: var(--md-grey-300);
+      --jp-border-color3: var(--md-grey-200);
+      --jp-inverse-border-color: var(--md-grey-600);
+      --jp-border-radius: 2px;
 
-  /* UI Fonts
+      /* UI Fonts
    *
    * The UI font CSS variables are used for the typography all of the JupyterLab
    * user interface elements that are not directly user generated content.
@@ -6915,37 +7064,38 @@ all of MD as it is not optimized for dense, information rich UIs.
    * in em all things will be computed relative to that body size.
    */
 
-  --jp-ui-font-scale-factor: 1.2;
-  --jp-ui-font-size0: 0.83333em;
-  --jp-ui-font-size1: 13px; /* Base font size */
-  --jp-ui-font-size2: 1.2em;
-  --jp-ui-font-size3: 1.44em;
-  --jp-ui-font-family: system-ui, -apple-system, blinkmacsystemfont, 'Segoe UI',
-    helvetica, arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
-    'Segoe UI Symbol';
+      --jp-ui-font-scale-factor: 1.2;
+      --jp-ui-font-size0: 0.83333em;
+      --jp-ui-font-size1: 13px;
+      /* Base font size */
+      --jp-ui-font-size2: 1.2em;
+      --jp-ui-font-size3: 1.44em;
+      --jp-ui-font-family: system-ui, -apple-system, blinkmacsystemfont, 'Segoe UI',
+        helvetica, arial, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji',
+        'Segoe UI Symbol';
 
-  /*
+      /*
    * Use these font colors against the corresponding main layout colors.
    * In a light theme, these go from dark to light.
    */
 
-  /* Defaults use Material Design specification */
-  --jp-ui-font-color0: rgba(0, 0, 0, 1);
-  --jp-ui-font-color1: rgba(0, 0, 0, 0.87);
-  --jp-ui-font-color2: rgba(0, 0, 0, 0.54);
-  --jp-ui-font-color3: rgba(0, 0, 0, 0.38);
+      /* Defaults use Material Design specification */
+      --jp-ui-font-color0: rgba(0, 0, 0, 1);
+      --jp-ui-font-color1: rgba(0, 0, 0, 0.87);
+      --jp-ui-font-color2: rgba(0, 0, 0, 0.54);
+      --jp-ui-font-color3: rgba(0, 0, 0, 0.38);
 
-  /*
+      /*
    * Use these against the brand/accent/warn/error colors.
    * These will typically go from light to darker, in both a dark and light theme.
    */
 
-  --jp-ui-inverse-font-color0: rgba(255, 255, 255, 1);
-  --jp-ui-inverse-font-color1: rgba(255, 255, 255, 1);
-  --jp-ui-inverse-font-color2: rgba(255, 255, 255, 0.7);
-  --jp-ui-inverse-font-color3: rgba(255, 255, 255, 0.5);
+      --jp-ui-inverse-font-color0: rgba(255, 255, 255, 1);
+      --jp-ui-inverse-font-color1: rgba(255, 255, 255, 1);
+      --jp-ui-inverse-font-color2: rgba(255, 255, 255, 0.7);
+      --jp-ui-inverse-font-color3: rgba(255, 255, 255, 0.5);
 
-  /* Content Fonts
+      /* Content Fonts
    *
    * Content font variables are used for typography of user generated content.
    *
@@ -6954,347 +7104,347 @@ all of MD as it is not optimized for dense, information rich UIs.
    * in em all things will be computed relative to that body size.
    */
 
-  --jp-content-line-height: 1.6;
-  --jp-content-font-scale-factor: 1.2;
-  --jp-content-font-size0: 0.83333em;
-  --jp-content-font-size1: 14px; /* Base font size */
-  --jp-content-font-size2: 1.2em;
-  --jp-content-font-size3: 1.44em;
-  --jp-content-font-size4: 1.728em;
-  --jp-content-font-size5: 2.0736em;
+      --jp-content-line-height: 1.6;
+      --jp-content-font-scale-factor: 1.2;
+      --jp-content-font-size0: 0.83333em;
+      --jp-content-font-size1: 14px;
+      /* Base font size */
+      --jp-content-font-size2: 1.2em;
+      --jp-content-font-size3: 1.44em;
+      --jp-content-font-size4: 1.728em;
+      --jp-content-font-size5: 2.0736em;
 
-  /* This gives a magnification of about 125% in presentation mode over normal. */
-  --jp-content-presentation-font-size1: 17px;
-  --jp-content-heading-line-height: 1;
-  --jp-content-heading-margin-top: 1.2em;
-  --jp-content-heading-margin-bottom: 0.8em;
-  --jp-content-heading-font-weight: 500;
+      /* This gives a magnification of about 125% in presentation mode over normal. */
+      --jp-content-presentation-font-size1: 17px;
+      --jp-content-heading-line-height: 1;
+      --jp-content-heading-margin-top: 1.2em;
+      --jp-content-heading-margin-bottom: 0.8em;
+      --jp-content-heading-font-weight: 500;
 
-  /* Defaults use Material Design specification */
-  --jp-content-font-color0: rgba(0, 0, 0, 1);
-  --jp-content-font-color1: rgba(0, 0, 0, 0.87);
-  --jp-content-font-color2: rgba(0, 0, 0, 0.54);
-  --jp-content-font-color3: rgba(0, 0, 0, 0.38);
-  --jp-content-link-color: var(--md-blue-900);
-  --jp-content-font-family: system-ui, -apple-system, blinkmacsystemfont,
-    'Segoe UI', helvetica, arial, sans-serif, 'Apple Color Emoji',
-    'Segoe UI Emoji', 'Segoe UI Symbol';
+      /* Defaults use Material Design specification */
+      --jp-content-font-color0: rgba(0, 0, 0, 1);
+      --jp-content-font-color1: rgba(0, 0, 0, 0.87);
+      --jp-content-font-color2: rgba(0, 0, 0, 0.54);
+      --jp-content-font-color3: rgba(0, 0, 0, 0.38);
+      --jp-content-link-color: var(--md-blue-900);
+      --jp-content-font-family: system-ui, -apple-system, blinkmacsystemfont,
+        'Segoe UI', helvetica, arial, sans-serif, 'Apple Color Emoji',
+        'Segoe UI Emoji', 'Segoe UI Symbol';
 
-  /*
+      /*
    * Code Fonts
    *
    * Code font variables are used for typography of code and other monospaces content.
    */
 
-  --jp-code-font-size: 13px;
-  --jp-code-line-height: 1.3077; /* 17px for 13px base */
-  --jp-code-padding: 5px; /* 5px for 13px base, codemirror highlighting needs integer px value */
-  --jp-code-font-family-default: menlo, consolas, 'DejaVu Sans Mono', monospace;
-  --jp-code-font-family: var(--jp-code-font-family-default);
+      --jp-code-font-size: 13px;
+      --jp-code-line-height: 1.3077;
+      /* 17px for 13px base */
+      --jp-code-padding: 5px;
+      /* 5px for 13px base, codemirror highlighting needs integer px value */
+      --jp-code-font-family-default: menlo, consolas, 'DejaVu Sans Mono', monospace;
+      --jp-code-font-family: var(--jp-code-font-family-default);
 
-  /* This gives a magnification of about 125% in presentation mode over normal. */
-  --jp-code-presentation-font-size: 16px;
+      /* This gives a magnification of about 125% in presentation mode over normal. */
+      --jp-code-presentation-font-size: 16px;
 
-  /* may need to tweak cursor width if you change font size */
-  --jp-code-cursor-width0: 1.4px;
-  --jp-code-cursor-width1: 2px;
-  --jp-code-cursor-width2: 4px;
+      /* may need to tweak cursor width if you change font size */
+      --jp-code-cursor-width0: 1.4px;
+      --jp-code-cursor-width1: 2px;
+      --jp-code-cursor-width2: 4px;
 
-  /* Layout
+      /* Layout
    *
    * The following are the main layout colors use in JupyterLab. In a light
    * theme these would go from light to dark.
    */
 
-  --jp-layout-color0: white;
-  --jp-layout-color1: white;
-  --jp-layout-color2: var(--md-grey-200);
-  --jp-layout-color3: var(--md-grey-400);
-  --jp-layout-color4: var(--md-grey-600);
+      --jp-layout-color0: white;
+      --jp-layout-color1: white;
+      --jp-layout-color2: var(--md-grey-200);
+      --jp-layout-color3: var(--md-grey-400);
+      --jp-layout-color4: var(--md-grey-600);
 
-  /* Inverse Layout
+      /* Inverse Layout
    *
    * The following are the inverse layout colors use in JupyterLab. In a light
    * theme these would go from dark to light.
    */
 
-  --jp-inverse-layout-color0: #111;
-  --jp-inverse-layout-color1: var(--md-grey-900);
-  --jp-inverse-layout-color2: var(--md-grey-800);
-  --jp-inverse-layout-color3: var(--md-grey-700);
-  --jp-inverse-layout-color4: var(--md-grey-600);
+      --jp-inverse-layout-color0: #111;
+      --jp-inverse-layout-color1: var(--md-grey-900);
+      --jp-inverse-layout-color2: var(--md-grey-800);
+      --jp-inverse-layout-color3: var(--md-grey-700);
+      --jp-inverse-layout-color4: var(--md-grey-600);
 
-  /* Brand/accent */
+      /* Brand/accent */
 
-  --jp-brand-color0: var(--md-blue-900);
-  --jp-brand-color1: var(--md-blue-700);
-  --jp-brand-color2: var(--md-blue-300);
-  --jp-brand-color3: var(--md-blue-100);
-  --jp-brand-color4: var(--md-blue-50);
-  --jp-accent-color0: var(--md-green-900);
-  --jp-accent-color1: var(--md-green-700);
-  --jp-accent-color2: var(--md-green-300);
-  --jp-accent-color3: var(--md-green-100);
+      --jp-brand-color0: var(--md-blue-900);
+      --jp-brand-color1: var(--md-blue-700);
+      --jp-brand-color2: var(--md-blue-300);
+      --jp-brand-color3: var(--md-blue-100);
+      --jp-brand-color4: var(--md-blue-50);
+      --jp-accent-color0: var(--md-green-900);
+      --jp-accent-color1: var(--md-green-700);
+      --jp-accent-color2: var(--md-green-300);
+      --jp-accent-color3: var(--md-green-100);
 
-  /* State colors (warn, error, success, info) */
+      /* State colors (warn, error, success, info) */
 
-  --jp-warn-color0: var(--md-orange-900);
-  --jp-warn-color1: var(--md-orange-700);
-  --jp-warn-color2: var(--md-orange-300);
-  --jp-warn-color3: var(--md-orange-100);
-  --jp-error-color0: var(--md-red-900);
-  --jp-error-color1: var(--md-red-700);
-  --jp-error-color2: var(--md-red-300);
-  --jp-error-color3: var(--md-red-100);
-  --jp-success-color0: var(--md-green-900);
-  --jp-success-color1: var(--md-green-700);
-  --jp-success-color2: var(--md-green-300);
-  --jp-success-color3: var(--md-green-100);
-  --jp-info-color0: var(--md-cyan-900);
-  --jp-info-color1: var(--md-cyan-700);
-  --jp-info-color2: var(--md-cyan-300);
-  --jp-info-color3: var(--md-cyan-100);
+      --jp-warn-color0: var(--md-orange-900);
+      --jp-warn-color1: var(--md-orange-700);
+      --jp-warn-color2: var(--md-orange-300);
+      --jp-warn-color3: var(--md-orange-100);
+      --jp-error-color0: var(--md-red-900);
+      --jp-error-color1: var(--md-red-700);
+      --jp-error-color2: var(--md-red-300);
+      --jp-error-color3: var(--md-red-100);
+      --jp-success-color0: var(--md-green-900);
+      --jp-success-color1: var(--md-green-700);
+      --jp-success-color2: var(--md-green-300);
+      --jp-success-color3: var(--md-green-100);
+      --jp-info-color0: var(--md-cyan-900);
+      --jp-info-color1: var(--md-cyan-700);
+      --jp-info-color2: var(--md-cyan-300);
+      --jp-info-color3: var(--md-cyan-100);
 
-  /* Cell specific styles */
+      /* Cell specific styles */
 
-  --jp-cell-padding: 5px;
-  --jp-cell-collapser-width: 8px;
-  --jp-cell-collapser-min-height: 20px;
-  --jp-cell-collapser-not-active-hover-opacity: 0.6;
-  --jp-cell-editor-background: var(--md-grey-100);
-  --jp-cell-editor-border-color: var(--md-grey-300);
-  --jp-cell-editor-box-shadow: inset 0 0 2px var(--md-blue-300);
-  --jp-cell-editor-active-background: var(--jp-layout-color0);
-  --jp-cell-editor-active-border-color: var(--jp-brand-color1);
-  --jp-cell-prompt-width: 64px;
-  --jp-cell-prompt-font-family: var(--jp-code-font-family-default);
-  --jp-cell-prompt-letter-spacing: 0;
-  --jp-cell-prompt-opacity: 1;
-  --jp-cell-prompt-not-active-opacity: 0.5;
-  --jp-cell-prompt-not-active-font-color: var(--md-grey-700);
+      --jp-cell-padding: 5px;
+      --jp-cell-collapser-width: 8px;
+      --jp-cell-collapser-min-height: 20px;
+      --jp-cell-collapser-not-active-hover-opacity: 0.6;
+      --jp-cell-editor-background: var(--md-grey-100);
+      --jp-cell-editor-border-color: var(--md-grey-300);
+      --jp-cell-editor-box-shadow: inset 0 0 2px var(--md-blue-300);
+      --jp-cell-editor-active-background: var(--jp-layout-color0);
+      --jp-cell-editor-active-border-color: var(--jp-brand-color1);
+      --jp-cell-prompt-width: 64px;
+      --jp-cell-prompt-font-family: var(--jp-code-font-family-default);
+      --jp-cell-prompt-letter-spacing: 0;
+      --jp-cell-prompt-opacity: 1;
+      --jp-cell-prompt-not-active-opacity: 0.5;
+      --jp-cell-prompt-not-active-font-color: var(--md-grey-700);
 
-  /* A custom blend of MD grey and blue 600
+      /* A custom blend of MD grey and blue 600
    * See https://meyerweb.com/eric/tools/color-blend/#546E7A:1E88E5:5:hex */
-  --jp-cell-inprompt-font-color: #307fc1;
+      --jp-cell-inprompt-font-color: #307fc1;
 
-  /* A custom blend of MD grey and orange 600
+      /* A custom blend of MD grey and orange 600
    * https://meyerweb.com/eric/tools/color-blend/#546E7A:F4511E:5:hex */
-  --jp-cell-outprompt-font-color: #bf5b3d;
+      --jp-cell-outprompt-font-color: #bf5b3d;
 
-  /* Notebook specific styles */
+      /* Notebook specific styles */
 
-  --jp-notebook-padding: 10px;
-  --jp-notebook-select-background: var(--jp-layout-color1);
-  --jp-notebook-multiselected-color: var(--md-blue-50);
+      --jp-notebook-padding: 10px;
+      --jp-notebook-select-background: var(--jp-layout-color1);
+      --jp-notebook-multiselected-color: var(--md-blue-50);
 
-  /* The scroll padding is calculated to fill enough space at the bottom of the
+      /* The scroll padding is calculated to fill enough space at the bottom of the
   notebook to show one single-line cell (with appropriate padding) at the top
   when the notebook is scrolled all the way to the bottom. We also subtract one
   pixel so that no scrollbar appears if we have just one single-line cell in the
   notebook. This padding is to enable a 'scroll past end' feature in a notebook.
   */
-  --jp-notebook-scroll-padding: calc(
-    100% - var(--jp-code-font-size) * var(--jp-code-line-height) -
-      var(--jp-code-padding) - var(--jp-cell-padding) - 1px
-  );
+      --jp-notebook-scroll-padding: calc(100% - var(--jp-code-font-size) * var(--jp-code-line-height) - var(--jp-code-padding) - var(--jp-cell-padding) - 1px);
 
-  /* Rendermime styles */
+      /* Rendermime styles */
 
-  --jp-rendermime-error-background: #fdd;
-  --jp-rendermime-table-row-background: var(--md-grey-100);
-  --jp-rendermime-table-row-hover-background: var(--md-light-blue-50);
+      --jp-rendermime-error-background: #fdd;
+      --jp-rendermime-table-row-background: var(--md-grey-100);
+      --jp-rendermime-table-row-hover-background: var(--md-light-blue-50);
 
-  /* Dialog specific styles */
+      /* Dialog specific styles */
 
-  --jp-dialog-background: rgba(0, 0, 0, 0.25);
+      --jp-dialog-background: rgba(0, 0, 0, 0.25);
 
-  /* Console specific styles */
+      /* Console specific styles */
 
-  --jp-console-padding: 10px;
+      --jp-console-padding: 10px;
 
-  /* Toolbar specific styles */
+      /* Toolbar specific styles */
 
-  --jp-toolbar-border-color: var(--jp-border-color1);
-  --jp-toolbar-micro-height: 8px;
-  --jp-toolbar-background: var(--jp-layout-color1);
-  --jp-toolbar-box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.24);
-  --jp-toolbar-header-margin: 4px 4px 0 4px;
-  --jp-toolbar-active-background: var(--md-grey-300);
+      --jp-toolbar-border-color: var(--jp-border-color1);
+      --jp-toolbar-micro-height: 8px;
+      --jp-toolbar-background: var(--jp-layout-color1);
+      --jp-toolbar-box-shadow: 0 0 2px 0 rgba(0, 0, 0, 0.24);
+      --jp-toolbar-header-margin: 4px 4px 0 4px;
+      --jp-toolbar-active-background: var(--md-grey-300);
 
-  /* Statusbar specific styles */
+      /* Statusbar specific styles */
 
-  --jp-statusbar-height: 24px;
+      --jp-statusbar-height: 24px;
 
-  /* Input field styles */
+      /* Input field styles */
 
-  --jp-input-box-shadow: inset 0 0 2px var(--md-blue-300);
-  --jp-input-active-background: var(--jp-layout-color1);
-  --jp-input-hover-background: var(--jp-layout-color1);
-  --jp-input-background: var(--md-grey-100);
-  --jp-input-border-color: var(--jp-inverse-border-color);
-  --jp-input-active-border-color: var(--jp-brand-color1);
-  --jp-input-active-box-shadow-color: rgba(19, 124, 189, 0.3);
+      --jp-input-box-shadow: inset 0 0 2px var(--md-blue-300);
+      --jp-input-active-background: var(--jp-layout-color1);
+      --jp-input-hover-background: var(--jp-layout-color1);
+      --jp-input-background: var(--md-grey-100);
+      --jp-input-border-color: var(--jp-inverse-border-color);
+      --jp-input-active-border-color: var(--jp-brand-color1);
+      --jp-input-active-box-shadow-color: rgba(19, 124, 189, 0.3);
 
-  /* General editor styles */
+      /* General editor styles */
 
-  --jp-editor-selected-background: #d9d9d9;
-  --jp-editor-selected-focused-background: #d7d4f0;
-  --jp-editor-cursor-color: var(--jp-ui-font-color0);
+      --jp-editor-selected-background: #d9d9d9;
+      --jp-editor-selected-focused-background: #d7d4f0;
+      --jp-editor-cursor-color: var(--jp-ui-font-color0);
 
-  /* Code mirror specific styles */
+      /* Code mirror specific styles */
 
-  --jp-mirror-editor-keyword-color: #008000;
-  --jp-mirror-editor-atom-color: #88f;
-  --jp-mirror-editor-number-color: #080;
-  --jp-mirror-editor-def-color: #00f;
-  --jp-mirror-editor-variable-color: var(--md-grey-900);
-  --jp-mirror-editor-variable-2-color: rgb(0, 54, 109);
-  --jp-mirror-editor-variable-3-color: #085;
-  --jp-mirror-editor-punctuation-color: #05a;
-  --jp-mirror-editor-property-color: #05a;
-  --jp-mirror-editor-operator-color: #a2f;
-  --jp-mirror-editor-comment-color: #408080;
-  --jp-mirror-editor-string-color: #ba2121;
-  --jp-mirror-editor-string-2-color: #708;
-  --jp-mirror-editor-meta-color: #a2f;
-  --jp-mirror-editor-qualifier-color: #555;
-  --jp-mirror-editor-builtin-color: #008000;
-  --jp-mirror-editor-bracket-color: #997;
-  --jp-mirror-editor-tag-color: #170;
-  --jp-mirror-editor-attribute-color: #00c;
-  --jp-mirror-editor-header-color: blue;
-  --jp-mirror-editor-quote-color: #090;
-  --jp-mirror-editor-link-color: #00c;
-  --jp-mirror-editor-error-color: #f00;
-  --jp-mirror-editor-hr-color: #999;
+      --jp-mirror-editor-keyword-color: #008000;
+      --jp-mirror-editor-atom-color: #88f;
+      --jp-mirror-editor-number-color: #080;
+      --jp-mirror-editor-def-color: #00f;
+      --jp-mirror-editor-variable-color: var(--md-grey-900);
+      --jp-mirror-editor-variable-2-color: rgb(0, 54, 109);
+      --jp-mirror-editor-variable-3-color: #085;
+      --jp-mirror-editor-punctuation-color: #05a;
+      --jp-mirror-editor-property-color: #05a;
+      --jp-mirror-editor-operator-color: #a2f;
+      --jp-mirror-editor-comment-color: #408080;
+      --jp-mirror-editor-string-color: #ba2121;
+      --jp-mirror-editor-string-2-color: #708;
+      --jp-mirror-editor-meta-color: #a2f;
+      --jp-mirror-editor-qualifier-color: #555;
+      --jp-mirror-editor-builtin-color: #008000;
+      --jp-mirror-editor-bracket-color: #997;
+      --jp-mirror-editor-tag-color: #170;
+      --jp-mirror-editor-attribute-color: #00c;
+      --jp-mirror-editor-header-color: blue;
+      --jp-mirror-editor-quote-color: #090;
+      --jp-mirror-editor-link-color: #00c;
+      --jp-mirror-editor-error-color: #f00;
+      --jp-mirror-editor-hr-color: #999;
 
-  /*
+      /*
     RTC user specific colors.
     These colors are used for the cursor, username in the editor,
     and the icon of the user.
   */
 
-  --jp-collaborator-color1: #ffad8e;
-  --jp-collaborator-color2: #dac83d;
-  --jp-collaborator-color3: #72dd76;
-  --jp-collaborator-color4: #00e4d0;
-  --jp-collaborator-color5: #45d4ff;
-  --jp-collaborator-color6: #e2b1ff;
-  --jp-collaborator-color7: #ff9de6;
+      --jp-collaborator-color1: #ffad8e;
+      --jp-collaborator-color2: #dac83d;
+      --jp-collaborator-color3: #72dd76;
+      --jp-collaborator-color4: #00e4d0;
+      --jp-collaborator-color5: #45d4ff;
+      --jp-collaborator-color6: #e2b1ff;
+      --jp-collaborator-color7: #ff9de6;
 
-  /* Vega extension styles */
+      /* Vega extension styles */
 
-  --jp-vega-background: white;
+      --jp-vega-background: white;
 
-  /* Sidebar-related styles */
+      /* Sidebar-related styles */
 
-  --jp-sidebar-min-width: 250px;
+      --jp-sidebar-min-width: 250px;
 
-  /* Search-related styles */
+      /* Search-related styles */
 
-  --jp-search-toggle-off-opacity: 0.5;
-  --jp-search-toggle-hover-opacity: 0.8;
-  --jp-search-toggle-on-opacity: 1;
-  --jp-search-selected-match-background-color: rgb(245, 200, 0);
-  --jp-search-selected-match-color: black;
-  --jp-search-unselected-match-background-color: var(
-    --jp-inverse-layout-color0
-  );
-  --jp-search-unselected-match-color: var(--jp-ui-inverse-font-color0);
+      --jp-search-toggle-off-opacity: 0.5;
+      --jp-search-toggle-hover-opacity: 0.8;
+      --jp-search-toggle-on-opacity: 1;
+      --jp-search-selected-match-background-color: rgb(245, 200, 0);
+      --jp-search-selected-match-color: black;
+      --jp-search-unselected-match-background-color: var(--jp-inverse-layout-color0);
+      --jp-search-unselected-match-color: var(--jp-ui-inverse-font-color0);
 
-  /* Icon colors that work well with light or dark backgrounds */
-  --jp-icon-contrast-color0: var(--md-purple-600);
-  --jp-icon-contrast-color1: var(--md-green-600);
-  --jp-icon-contrast-color2: var(--md-pink-600);
-  --jp-icon-contrast-color3: var(--md-blue-600);
+      /* Icon colors that work well with light or dark backgrounds */
+      --jp-icon-contrast-color0: var(--md-purple-600);
+      --jp-icon-contrast-color1: var(--md-green-600);
+      --jp-icon-contrast-color2: var(--md-pink-600);
+      --jp-icon-contrast-color3: var(--md-blue-600);
 
-  /* Button colors */
-  --jp-accept-color-normal: var(--md-blue-700);
-  --jp-accept-color-hover: var(--md-blue-800);
-  --jp-accept-color-active: var(--md-blue-900);
-  --jp-warn-color-normal: var(--md-red-700);
-  --jp-warn-color-hover: var(--md-red-800);
-  --jp-warn-color-active: var(--md-red-900);
-  --jp-reject-color-normal: var(--md-grey-600);
-  --jp-reject-color-hover: var(--md-grey-700);
-  --jp-reject-color-active: var(--md-grey-800);
+      /* Button colors */
+      --jp-accept-color-normal: var(--md-blue-700);
+      --jp-accept-color-hover: var(--md-blue-800);
+      --jp-accept-color-active: var(--md-blue-900);
+      --jp-warn-color-normal: var(--md-red-700);
+      --jp-warn-color-hover: var(--md-red-800);
+      --jp-warn-color-active: var(--md-red-900);
+      --jp-reject-color-normal: var(--md-grey-600);
+      --jp-reject-color-hover: var(--md-grey-700);
+      --jp-reject-color-active: var(--md-grey-800);
 
-  /* File or activity icons and switch semantic variables */
-  --jp-jupyter-icon-color: #f37626;
-  --jp-notebook-icon-color: #f37626;
-  --jp-json-icon-color: var(--md-orange-700);
-  --jp-console-icon-background-color: var(--md-blue-700);
-  --jp-console-icon-color: white;
-  --jp-terminal-icon-background-color: var(--md-grey-800);
-  --jp-terminal-icon-color: var(--md-grey-200);
-  --jp-text-editor-icon-color: var(--md-grey-700);
-  --jp-inspector-icon-color: var(--md-grey-700);
-  --jp-switch-color: var(--md-grey-400);
-  --jp-switch-true-position-color: var(--md-orange-900);
-}
-</style>
-<style type="text/css">
-/* Force rendering true colors when outputing to pdf */
-* {
-  -webkit-print-color-adjust: exact;
-}
+      /* File or activity icons and switch semantic variables */
+      --jp-jupyter-icon-color: #f37626;
+      --jp-notebook-icon-color: #f37626;
+      --jp-json-icon-color: var(--md-orange-700);
+      --jp-console-icon-background-color: var(--md-blue-700);
+      --jp-console-icon-color: white;
+      --jp-terminal-icon-background-color: var(--md-grey-800);
+      --jp-terminal-icon-color: var(--md-grey-200);
+      --jp-text-editor-icon-color: var(--md-grey-700);
+      --jp-inspector-icon-color: var(--md-grey-700);
+      --jp-switch-color: var(--md-grey-400);
+      --jp-switch-true-position-color: var(--md-orange-900);
+    }
+  </style>
+  <style type="text/css">
+    /* Force rendering true colors when outputing to pdf */
+    * {
+      -webkit-print-color-adjust: exact;
+    }
 
-/* Misc */
-a.anchor-link {
-  display: none;
-}
+    /* Misc */
+    a.anchor-link {
+      display: none;
+    }
 
-/* Input area styling */
-.jp-InputArea {
-  overflow: hidden;
-}
+    /* Input area styling */
+    .jp-InputArea {
+      overflow: hidden;
+    }
 
-.jp-InputArea-editor {
-  overflow: hidden;
-}
+    .jp-InputArea-editor {
+      overflow: hidden;
+    }
 
-.cm-editor.cm-s-jupyter .highlight pre {
-/* weird, but --jp-code-padding defined to be 5px but 4px horizontal padding is hardcoded for pre.cm-line */
-  padding: var(--jp-code-padding) 4px;
-  margin: 0;
+    .cm-editor.cm-s-jupyter .highlight pre {
+      /* weird, but --jp-code-padding defined to be 5px but 4px horizontal padding is hardcoded for pre.cm-line */
+      padding: var(--jp-code-padding) 4px;
+      margin: 0;
 
-  font-family: inherit;
-  font-size: inherit;
-  line-height: inherit;
-  color: inherit;
+      font-family: inherit;
+      font-size: inherit;
+      line-height: inherit;
+      color: inherit;
 
-}
+    }
 
-.jp-OutputArea-output pre {
-  line-height: inherit;
-  font-family: inherit;
-}
+    .jp-OutputArea-output pre {
+      line-height: inherit;
+      font-family: inherit;
+    }
 
-.jp-RenderedText pre {
-  color: var(--jp-content-font-color1);
-  font-size: var(--jp-code-font-size);
-}
+    .jp-RenderedText pre {
+      color: var(--jp-content-font-color1);
+      font-size: var(--jp-code-font-size);
+    }
 
-/* Hiding the collapser by default */
-.jp-Collapser {
-  display: none;
-}
+    /* Hiding the collapser by default */
+    .jp-Collapser {
+      display: none;
+    }
 
-@page {
-    margin: 0.5in; /* Margin for each printed piece of paper */
-}
+    @page {
+      margin: 0.5in;
+      /* Margin for each printed piece of paper */
+    }
 
-@media print {
-  .jp-Cell-inputWrapper,
-  .jp-Cell-outputWrapper {
-    display: block;
-  }
-}
-</style>
-<!-- Load mathjax -->
-<script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS_CHTML-full,Safe"> </script>
-<!-- MathJax configuration -->
-<script type="text/x-mathjax-config">
+    @media print {
+
+      .jp-Cell-inputWrapper,
+      .jp-Cell-outputWrapper {
+        display: block;
+      }
+    }
+  </style>
+  <!-- Load mathjax -->
+  <script src="https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.7/latest.js?config=TeX-AMS_CHTML-full,Safe"> </script>
+  <!-- MathJax configuration -->
+  <script type="text/x-mathjax-config">
     init_mathjax = function() {
         if (window.MathJax) {
         // MathJax loaded
@@ -7325,200 +7475,205 @@ a.anchor-link {
     }
     init_mathjax();
     </script>
-<!-- End of mathjax configuration --><script type="module">
-  document.addEventListener("DOMContentLoaded", async () => {
-    const diagrams = document.querySelectorAll(".jp-Mermaid > pre.mermaid");
-    // do not load mermaidjs if not needed
-    if (!diagrams.length) {
-      return;
-    }
-    const mermaid = (await import("https://cdnjs.cloudflare.com/ajax/libs/mermaid/10.7.0/mermaid.esm.min.mjs")).default;
-    const parser = new DOMParser();
+  <!-- End of mathjax configuration -->
+  <script type="module">
+    document.addEventListener("DOMContentLoaded", async () => {
+      const diagrams = document.querySelectorAll(".jp-Mermaid > pre.mermaid");
+      // do not load mermaidjs if not needed
+      if (!diagrams.length) {
+        return;
+      }
+      const mermaid = (await import("https://cdnjs.cloudflare.com/ajax/libs/mermaid/10.7.0/mermaid.esm.min.mjs")).default;
+      const parser = new DOMParser();
 
-    mermaid.initialize({
-      maxTextSize: 100000,
-      maxEdges: 100000,
-      startOnLoad: false,
-      fontFamily: window
-        .getComputedStyle(document.body)
-        .getPropertyValue("--jp-ui-font-family"),
-      theme: document.querySelector("body[data-jp-theme-light='true']")
-        ? "default"
-        : "dark",
+      mermaid.initialize({
+        maxTextSize: 100000,
+        maxEdges: 100000,
+        startOnLoad: false,
+        fontFamily: window
+          .getComputedStyle(document.body)
+          .getPropertyValue("--jp-ui-font-family"),
+        theme: document.querySelector("body[data-jp-theme-light='true']")
+          ? "default"
+          : "dark",
+      });
+
+      let _nextMermaidId = 0;
+
+      function makeMermaidImage(svg) {
+        const img = document.createElement("img");
+        const doc = parser.parseFromString(svg, "image/svg+xml");
+        const svgEl = doc.querySelector("svg");
+        const { maxWidth } = svgEl?.style || {};
+        const firstTitle = doc.querySelector("title");
+        const firstDesc = doc.querySelector("desc");
+
+        img.setAttribute("src", `data:image/svg+xml,${encodeURIComponent(svg)}`);
+        if (maxWidth) {
+          img.width = parseInt(maxWidth);
+        }
+        if (firstTitle) {
+          img.setAttribute("alt", firstTitle.textContent);
+        }
+        if (firstDesc) {
+          const caption = document.createElement("figcaption");
+          caption.className = "sr-only";
+          caption.textContent = firstDesc.textContent;
+          return [img, caption];
+        }
+        return [img];
+      }
+
+      async function makeMermaidError(text) {
+        let errorMessage = "";
+        try {
+          await mermaid.parse(text);
+        } catch (err) {
+          errorMessage = `${err}`;
+        }
+
+        const result = document.createElement("details");
+        result.className = 'jp-RenderedMermaid-Details';
+        const summary = document.createElement("summary");
+        summary.className = 'jp-RenderedMermaid-Summary';
+        const pre = document.createElement("pre");
+        const code = document.createElement("code");
+        code.innerText = text;
+        pre.appendChild(code);
+        summary.appendChild(pre);
+        result.appendChild(summary);
+
+        const warning = document.createElement("pre");
+        warning.innerText = errorMessage;
+        result.appendChild(warning);
+        return [result];
+      }
+
+      async function renderOneMarmaid(src) {
+        const id = `jp-mermaid-${_nextMermaidId++}`;
+        const parent = src.parentNode;
+        let raw = src.textContent.trim();
+        const el = document.createElement("div");
+        el.style.visibility = "hidden";
+        document.body.appendChild(el);
+        let results = null;
+        let output = null;
+        try {
+          let { svg } = await mermaid.render(id, raw, el);
+          svg = cleanMermaidSvg(svg);
+          results = makeMermaidImage(svg);
+          output = document.createElement("figure");
+          results.map(output.appendChild, output);
+        } catch (err) {
+          parent.classList.add("jp-mod-warning");
+          results = await makeMermaidError(raw);
+          output = results[0];
+        } finally {
+          el.remove();
+        }
+        parent.classList.add("jp-RenderedMermaid");
+        parent.appendChild(output);
+      }
+
+
+      /**
+       * Post-process to ensure mermaid diagrams contain only valid SVG and XHTML.
+       */
+      function cleanMermaidSvg(svg) {
+        return svg.replace(RE_VOID_ELEMENT, replaceVoidElement);
+      }
+
+
+      /**
+       * A regular expression for all void elements, which may include attributes and
+       * a slash.
+       *
+       * @see https://developer.mozilla.org/en-US/docs/Glossary/Void_element
+       *
+       * Of these, only `<br>` is generated by Mermaid in place of `\n`,
+       * but _any_ "malformed" tag will break the SVG rendering entirely.
+       */
+      const RE_VOID_ELEMENT =
+        /<\s*(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)\s*([^>]*?)\s*>/gi;
+
+      /**
+       * Ensure a void element is closed with a slash, preserving any attributes.
+       */
+      function replaceVoidElement(match, tag, rest) {
+        rest = rest.trim();
+        if (!rest.endsWith('/')) {
+          rest = `${rest} /`;
+        }
+        return `<${tag} ${rest}>`;
+      }
+
+      void Promise.all([...diagrams].map(renderOneMarmaid));
     });
-
-    let _nextMermaidId = 0;
-
-    function makeMermaidImage(svg) {
-      const img = document.createElement("img");
-      const doc = parser.parseFromString(svg, "image/svg+xml");
-      const svgEl = doc.querySelector("svg");
-      const { maxWidth } = svgEl?.style || {};
-      const firstTitle = doc.querySelector("title");
-      const firstDesc = doc.querySelector("desc");
-
-      img.setAttribute("src", `data:image/svg+xml,${encodeURIComponent(svg)}`);
-      if (maxWidth) {
-        img.width = parseInt(maxWidth);
-      }
-      if (firstTitle) {
-        img.setAttribute("alt", firstTitle.textContent);
-      }
-      if (firstDesc) {
-        const caption = document.createElement("figcaption");
-        caption.className = "sr-only";
-        caption.textContent = firstDesc.textContent;
-        return [img, caption];
-      }
-      return [img];
+  </script>
+  <style>
+    .jp-Mermaid:not(.jp-RenderedMermaid) {
+      display: none;
     }
 
-    async function makeMermaidError(text) {
-      let errorMessage = "";
-      try {
-        await mermaid.parse(text);
-      } catch (err) {
-        errorMessage = `${err}`;
-      }
-
-      const result = document.createElement("details");
-      result.className = 'jp-RenderedMermaid-Details';
-      const summary = document.createElement("summary");
-      summary.className = 'jp-RenderedMermaid-Summary';
-      const pre = document.createElement("pre");
-      const code = document.createElement("code");
-      code.innerText = text;
-      pre.appendChild(code);
-      summary.appendChild(pre);
-      result.appendChild(summary);
-
-      const warning = document.createElement("pre");
-      warning.innerText = errorMessage;
-      result.appendChild(warning);
-      return [result];
+    .jp-RenderedMermaid {
+      overflow: auto;
+      display: flex;
     }
 
-    async function renderOneMarmaid(src) {
-      const id = `jp-mermaid-${_nextMermaidId++}`;
-      const parent = src.parentNode;
-      let raw = src.textContent.trim();
-      const el = document.createElement("div");
-      el.style.visibility = "hidden";
-      document.body.appendChild(el);
-      let results = null;
-      let output = null;
-      try {
-        let { svg } = await mermaid.render(id, raw, el);
-        svg = cleanMermaidSvg(svg);
-        results = makeMermaidImage(svg);
-        output = document.createElement("figure");
-        results.map(output.appendChild, output);
-      } catch (err) {
-        parent.classList.add("jp-mod-warning");
-        results = await makeMermaidError(raw);
-        output = results[0];
-      } finally {
-        el.remove();
-      }
-      parent.classList.add("jp-RenderedMermaid");
-      parent.appendChild(output);
+    .jp-RenderedMermaid.jp-mod-warning {
+      width: auto;
+      padding: 0.5em;
+      margin-top: 0.5em;
+      border: var(--jp-border-width) solid var(--jp-warn-color2);
+      border-radius: var(--jp-border-radius);
+      color: var(--jp-ui-font-color1);
+      font-size: var(--jp-ui-font-size1);
+      white-space: pre-wrap;
+      word-wrap: break-word;
     }
 
-
-    /**
-     * Post-process to ensure mermaid diagrams contain only valid SVG and XHTML.
-     */
-    function cleanMermaidSvg(svg) {
-      return svg.replace(RE_VOID_ELEMENT, replaceVoidElement);
+    .jp-RenderedMermaid figure {
+      margin: 0;
+      overflow: auto;
+      max-width: 100%;
     }
 
-
-    /**
-     * A regular expression for all void elements, which may include attributes and
-     * a slash.
-     *
-     * @see https://developer.mozilla.org/en-US/docs/Glossary/Void_element
-     *
-     * Of these, only `<br>` is generated by Mermaid in place of `\n`,
-     * but _any_ "malformed" tag will break the SVG rendering entirely.
-     */
-    const RE_VOID_ELEMENT =
-      /<\s*(area|base|br|col|embed|hr|img|input|link|meta|param|source|track|wbr)\s*([^>]*?)\s*>/gi;
-
-    /**
-     * Ensure a void element is closed with a slash, preserving any attributes.
-     */
-    function replaceVoidElement(match, tag, rest) {
-      rest = rest.trim();
-      if (!rest.endsWith('/')) {
-        rest = `${rest} /`;
-      }
-      return `<${tag} ${rest}>`;
+    .jp-RenderedMermaid img {
+      max-width: 100%;
     }
 
-    void Promise.all([...diagrams].map(renderOneMarmaid));
-  });
-</script>
-<style>
-  .jp-Mermaid:not(.jp-RenderedMermaid) {
-    display: none;
-  }
+    .jp-RenderedMermaid-Details>pre {
+      margin-top: 1em;
+    }
 
-  .jp-RenderedMermaid {
-    overflow: auto;
-    display: flex;
-  }
+    .jp-RenderedMermaid-Summary {
+      color: var(--jp-warn-color2);
+    }
 
-  .jp-RenderedMermaid.jp-mod-warning {
-    width: auto;
-    padding: 0.5em;
-    margin-top: 0.5em;
-    border: var(--jp-border-width) solid var(--jp-warn-color2);
-    border-radius: var(--jp-border-radius);
-    color: var(--jp-ui-font-color1);
-    font-size: var(--jp-ui-font-size1);
-    white-space: pre-wrap;
-    word-wrap: break-word;
-  }
+    .jp-RenderedMermaid:not(.jp-mod-warning) pre {
+      display: none;
+    }
 
-  .jp-RenderedMermaid figure {
-    margin: 0;
-    overflow: auto;
-    max-width: 100%;
-  }
+    .jp-RenderedMermaid-Summary>pre {
+      display: inline-block;
+      white-space: normal;
+    }
+  </style>
+  <!-- End of mermaid configuration -->
+</head>
 
-  .jp-RenderedMermaid img {
-    max-width: 100%;
-  }
-
-  .jp-RenderedMermaid-Details > pre {
-    margin-top: 1em;
-  }
-
-  .jp-RenderedMermaid-Summary {
-    color: var(--jp-warn-color2);
-  }
-
-  .jp-RenderedMermaid:not(.jp-mod-warning) pre {
-    display: none;
-  }
-
-  .jp-RenderedMermaid-Summary > pre {
-    display: inline-block;
-    white-space: normal;
-  }
-</style>
-<!-- End of mermaid configuration --></head>
 <body class="jp-Notebook" data-jp-theme-light="true" data-jp-theme-name="JupyterLab Light">
-<main><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=d2aa2997">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [1]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="c1"># pip install rapidfuzz scikit-learn numpy</span>
+  <main>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=d2aa2997">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [1]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="c1"># pip install rapidfuzz scikit-learn numpy</span>
 
 <span class="kn">import</span><span class="w"> </span><span class="nn">numpy</span><span class="w"> </span><span class="k">as</span><span class="w"> </span><span class="nn">np</span>
 <span class="kn">from</span><span class="w"> </span><span class="nn">collections</span><span class="w"> </span><span class="kn">import</span> <span class="n">Counter</span>
@@ -7547,44 +7702,49 @@ a.anchor-link {
     <span class="p">(</span><span class="s2">""</span><span class="p">,</span> <span class="s2">""</span><span class="p">),</span>                                                         <span class="c1"># Empty strings</span>
 <span class="p">]</span>
 <span class="nb">print</span><span class="p">(</span><span class="s2">"done"</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>done
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=b06d10d0">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="Jaccard-Similarity">Jaccard Similarity<a class="anchor-link" href="#Jaccard-Similarity">¶</a></h3>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=e60d024e969254a">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [58]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">jaccard_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>done
+</pre>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=b06d10d0">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="Jaccard-Similarity">Jaccard Similarity<a class="anchor-link" href="#Jaccard-Similarity">¶</a></h3>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=e60d024e969254a">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [58]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">jaccard_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
     <span class="c1"># make lowercase and split into words</span>
     <span class="n">words1</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">sent1</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span><span class="o">.</span><span class="n">split</span><span class="p">())</span>
     <span class="n">words2</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">sent2</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span><span class="o">.</span><span class="n">split</span><span class="p">())</span>
@@ -7605,19 +7765,20 @@ a.anchor-link {
     <span class="n">similarity</span> <span class="o">=</span> <span class="n">jaccard_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">)</span>
     <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">sent1</span><span class="si">:</span><span class="s2">&lt;30</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="s1">'vs'</span><span class="si">:</span><span class="s2">&lt;10</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">sent2</span><span class="si">:</span><span class="s2">&lt;40</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">similarity</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span> <span class="c1"># 3 decimal places</span>
     <span class="c1">#print("-"* 50)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Sentence 1                                Sentence 2:                              Similarity Score:
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Sentence 1                                Sentence 2:                              Similarity Score:
 ====================================================================================================
 The cat sat on the mat.        vs         The cat sat on the mat.                  1.000
 The cat sat on the mat.        vs         The cat sat on the mat                   0.667
@@ -7632,30 +7793,36 @@ Short.                         vs         Short.
 A B C D E F G                  vs         A B C D E F G                            1.000
                                vs                                                  0.000
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=337a1072">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="----Leneshtein-Similarity----">--- Leneshtein Similarity ---<a class="anchor-link" href="#----Leneshtein-Similarity----">¶</a></h3><p>Character &amp; Word</p>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=0b68fdcd">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [57]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">char_levenshtein_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=337a1072">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="----Leneshtein-Similarity----">--- Leneshtein Similarity ---<a class="anchor-link"
+                href="#----Leneshtein-Similarity----">¶</a></h3>
+            <p>Character &amp; Word</p>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=0b68fdcd">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [57]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">char_levenshtein_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">""" Character based edit-distance similarity """</span>
     <span class="k">if</span> <span class="ow">not</span> <span class="n">sent1</span> <span class="ow">and</span> <span class="ow">not</span> <span class="n">sent2</span><span class="p">:</span>
         <span class="k">return</span> <span class="mf">1.0</span>
@@ -7690,19 +7857,20 @@ A B C D E F G                  vs         A B C D E F G
     <span class="n">word_similarity</span> <span class="o">=</span> <span class="n">word_levenshtein_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">)</span>
     <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">sent1</span><span class="si">:</span><span class="s2">&lt;30</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="s1">'vs'</span><span class="si">:</span><span class="s2">&lt;10</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">sent2</span><span class="si">:</span><span class="s2">&lt;40</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">char_similarity</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}{</span><span class="s1">''</span><span class="si">:</span><span class="s2">&lt;5</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">word_similarity</span><span class="si">:</span><span class="s2">.3F</span><span class="si">}</span><span class="s2"> "</span><span class="p">)</span> <span class="c1"># 3 decimal places</span>
     <span class="c1">#print("-"* 50</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Sentence 1                                Sentence 2:          Similarities -&gt;     Char:      Word:
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Sentence 1                                Sentence 2:          Similarities -&gt;     Char:      Word:
 ====================================================================================================
 The cat sat on the mat.        vs         The cat sat on the mat.                  1.000      1.000 
 The cat sat on the mat.        vs         The cat sat on the mat                   0.957      0.833 
@@ -7717,30 +7885,35 @@ Short.                         vs         Short.
 A B C D E F G                  vs         A B C D E F G                            1.000      1.000 
                                vs                                                  1.000      1.000 
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=bae45c9a">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="----Cosine-Similarity----">--- Cosine Similarity ---<a class="anchor-link" href="#----Cosine-Similarity----">¶</a></h3>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=46a985b4">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [38]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">cosine_similarity_bow</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=bae45c9a">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="----Cosine-Similarity----">--- Cosine Similarity ---<a class="anchor-link"
+                href="#----Cosine-Similarity----">¶</a></h3>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=46a985b4">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [38]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">cosine_similarity_bow</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">""" dosine similarity using bag-of-words """</span>
     <span class="n">words1</span> <span class="o">=</span> <span class="n">sent1</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span><span class="o">.</span><span class="n">translate</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">maketrans</span><span class="p">(</span><span class="s1">''</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="n">string</span><span class="o">.</span><span class="n">punctuation</span><span class="p">))</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
     <span class="n">words2</span> <span class="o">=</span> <span class="n">sent2</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span><span class="o">.</span><span class="n">translate</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">maketrans</span><span class="p">(</span><span class="s1">''</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="n">string</span><span class="o">.</span><span class="n">punctuation</span><span class="p">))</span><span class="o">.</span><span class="n">split</span><span class="p">()</span>
@@ -7777,19 +7950,20 @@ A B C D E F G                  vs         A B C D E F G
     <span class="n">similarity</span> <span class="o">=</span> <span class="n">cosine_similarity_bow</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">)</span>
     <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">sent1</span><span class="si">:</span><span class="s2">&lt;30</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="s1">'vs'</span><span class="si">:</span><span class="s2">&lt;10</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">sent2</span><span class="si">:</span><span class="s2">&lt;40</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">similarity</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span> <span class="c1"># 3 decimal places</span>
     <span class="c1">#print("-"* 50)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Sentence 1                                Sentence 2:                              Similarity Score:
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Sentence 1                                Sentence 2:                              Similarity Score:
 ====================================================================================================
 The cat sat on the mat.        vs         The cat sat on the mat.                  1.000
 The cat sat on the mat.        vs         The cat sat on the mat                   1.000
@@ -7804,30 +7978,35 @@ Short.                         vs         Short.
 A B C D E F G                  vs         A B C D E F G                            1.000
                                vs                                                  1.000
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=658276dc">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="----Fuzzy-ratios----">--- Fuzzy ratios ---<a class="anchor-link" href="#----Fuzzy-ratios----">¶</a></h3>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=7dc7ac2e">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [5]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">fuzzy_ratio_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=658276dc">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="----Fuzzy-ratios----">--- Fuzzy ratios ---<a class="anchor-link" href="#----Fuzzy-ratios----">¶</a>
+            </h3>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=7dc7ac2e">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [5]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">fuzzy_ratio_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">"""Fuzzy string matching ratio"""</span>
     <span class="k">return</span> <span class="n">fuzz</span><span class="o">.</span><span class="n">ratio</span><span class="p">(</span><span class="n">sent1</span><span class="o">.</span><span class="n">lower</span><span class="p">(),</span> <span class="n">sent2</span><span class="o">.</span><span class="n">lower</span><span class="p">())</span> <span class="o">/</span> <span class="mf">100.0</span>
 
@@ -7865,19 +8044,20 @@ A B C D E F G                  vs         A B C D E F G
             <span class="n">desc</span> <span class="o">=</span> <span class="s2">"Different content"</span>
             
         <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">sent1</span><span class="p">[:</span><span class="mi">28</span><span class="p">]</span><span class="si">:</span><span class="s2">&lt;30</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">ratio</span><span class="si">:</span><span class="s2">&lt;8</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">partial</span><span class="si">:</span><span class="s2">&lt;8</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">token_sort</span><span class="si">:</span><span class="s2">&lt;12</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">token_set</span><span class="si">:</span><span class="s2">&lt;8</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">desc</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Fuzzy ratio Examples
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Fuzzy ratio Examples
 ==========================================================================================
 Case                           Ratio    Partial  Token Sort   Token Set Description
 ==========================================================================================
@@ -7894,30 +8074,35 @@ Short.                         100      100      100          100      Exact cop
 A B C D E F G                  100      100      100          100      Exact copy
                                100      100      100          0        Exact copy
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=a48774d4">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="----Longest-common-sub-sequence-----">--- Longest common sub-sequence ----<a class="anchor-link" href="#----Longest-common-sub-sequence-----">¶</a></h3>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=e6a4d4e2">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [37]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">longest_common_subsequence</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=a48774d4">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="----Longest-common-sub-sequence-----">--- Longest common sub-sequence ----<a class="anchor-link"
+                href="#----Longest-common-sub-sequence-----">¶</a></h3>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=e6a4d4e2">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [37]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">longest_common_subsequence</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">""" Longest common subsequence similarity """</span>
     <span class="k">if</span> <span class="ow">not</span> <span class="n">sent1</span> <span class="ow">or</span> <span class="ow">not</span> <span class="n">sent2</span><span class="p">:</span>
         <span class="k">return</span> <span class="mf">0.0</span>
@@ -7946,19 +8131,20 @@ A B C D E F G                  100      100      100          100      Exact cop
     <span class="n">similarity</span> <span class="o">=</span> <span class="n">longest_common_subsequence</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">)</span>
     <span class="nb">print</span><span class="p">(</span><span class="sa">f</span><span class="s2">"</span><span class="si">{</span><span class="n">sent1</span><span class="si">:</span><span class="s2">&lt;30</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="s1">'vs'</span><span class="si">:</span><span class="s2">&lt;10</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">sent2</span><span class="si">:</span><span class="s2">&lt;40</span><span class="si">}</span><span class="s2"> </span><span class="si">{</span><span class="n">similarity</span><span class="si">:</span><span class="s2">.3f</span><span class="si">}</span><span class="s2">"</span><span class="p">)</span> <span class="c1"># 3 decimal places</span>
     <span class="c1">#print("-"* 50)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Sentence 1                                Sentence 2:                              Similarity Score:
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Sentence 1                                Sentence 2:                              Similarity Score:
 ====================================================================================================
 The cat sat on the mat.        vs         The cat sat on the mat.                  1.000
 The cat sat on the mat.        vs         The cat sat on the mat                   1.000
@@ -7973,31 +8159,37 @@ Short.                         vs         Short.
 A B C D E F G                  vs         A B C D E F G                            1.000
                                vs                                                  0.000
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=1a532335">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="----Containment-Similarity----">--- Containment Similarity ---<a class="anchor-link" href="#----Containment-Similarity----">¶</a></h3><p>Percentage of Sentance A in Sentance B <br/>
-containment(A, B) = |words(A) ∩ words(B)| / |words(A)|</p>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs" id="cell-id=493979a4">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [ ]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">containment_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=1a532335">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="----Containment-Similarity----">--- Containment Similarity ---<a class="anchor-link"
+                href="#----Containment-Similarity----">¶</a></h3>
+            <p>Percentage of Sentance A in Sentance B <br />
+              containment(A, B) = |words(A) ∩ words(B)| / |words(A)|</p>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell jp-mod-noOutputs" id="cell-id=493979a4">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [ ]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">containment_similarity</span><span class="p">(</span><span class="n">sent1</span><span class="p">,</span> <span class="n">sent2</span><span class="p">):</span>
     <span class="c1"># sent1 in sent2 (asymmetric)</span>
 <span class="w">    </span><span class="sd">""" What percentage of sent1's words are in sent2 """</span>
     <span class="n">words1</span> <span class="o">=</span> <span class="nb">set</span><span class="p">(</span><span class="n">sent1</span><span class="o">.</span><span class="n">lower</span><span class="p">()</span><span class="o">.</span><span class="n">translate</span><span class="p">(</span><span class="nb">str</span><span class="o">.</span><span class="n">maketrans</span><span class="p">(</span><span class="s1">''</span><span class="p">,</span> <span class="s1">''</span><span class="p">,</span> <span class="n">string</span><span class="o">.</span><span class="n">punctuation</span><span class="p">))</span><span class="o">.</span><span class="n">split</span><span class="p">())</span>
@@ -8008,31 +8200,37 @@ containment(A, B) = |words(A) ∩ words(B)| / |words(A)|</p>
     
     <span class="n">common</span> <span class="o">=</span> <span class="n">words1</span><span class="o">.</span><span class="n">intersection</span><span class="p">(</span><span class="n">words2</span><span class="p">)</span>
     <span class="k">return</span> <span class="nb">len</span><span class="p">(</span><span class="n">common</span><span class="p">)</span> <span class="o">/</span> <span class="nb">len</span><span class="p">(</span><span class="n">words1</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=912a9c7c">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea"><div class="jp-InputPrompt jp-InputArea-prompt">
-</div><div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
-<h3 id="Evaluate-BaseLine-Methods">Evaluate BaseLine Methods<a class="anchor-link" href="#Evaluate-BaseLine-Methods">¶</a></h3>
-</div>
-</div>
-</div>
-</div><div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=b3d07562">
-<div class="jp-Cell-inputWrapper" tabindex="0">
-<div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
-</div>
-<div class="jp-InputArea jp-Cell-inputArea">
-<div class="jp-InputPrompt jp-InputArea-prompt">In [25]:</div>
-<div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
-<div class="cm-editor cm-s-jupyter">
-<div class="highlight hl-ipython3"><pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">evaluate_baseline_methods</span><span class="p">(</span><span class="n">pairs</span><span class="p">):</span>
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-MarkdownCell jp-Notebook-cell" id="cell-id=912a9c7c">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">
+          </div>
+          <div class="jp-RenderedHTMLCommon jp-RenderedMarkdown jp-MarkdownOutput" data-mime-type="text/markdown">
+            <h3 id="Evaluate-BaseLine-Methods">Evaluate BaseLine Methods<a class="anchor-link"
+                href="#Evaluate-BaseLine-Methods">¶</a></h3>
+          </div>
+        </div>
+      </div>
+    </div>
+    <div class="jp-Cell jp-CodeCell jp-Notebook-cell" id="cell-id=b3d07562">
+      <div class="jp-Cell-inputWrapper" tabindex="0">
+        <div class="jp-Collapser jp-InputCollapser jp-Cell-inputCollapser">
+        </div>
+        <div class="jp-InputArea jp-Cell-inputArea">
+          <div class="jp-InputPrompt jp-InputArea-prompt">In [25]:</div>
+          <div class="jp-CodeMirrorEditor jp-Editor jp-InputArea-editor" data-type="inline">
+            <div class="cm-editor cm-s-jupyter">
+              <div class="highlight hl-ipython3">
+                <pre><span></span><span class="k">def</span><span class="w"> </span><span class="nf">evaluate_baseline_methods</span><span class="p">(</span><span class="n">pairs</span><span class="p">):</span>
 <span class="w">    </span><span class="sd">""" Evaluate all baseline methods on test pairs"""</span>
     <span class="n">methods</span> <span class="o">=</span> <span class="p">{</span>
         <span class="s1">'Jaccard'</span><span class="p">:</span> <span class="n">jaccard_similarity</span><span class="p">,</span>
@@ -8076,19 +8274,20 @@ containment(A, B) = |words(A) ∩ words(B)| / |words(A)|</p>
 
 <span class="n">results</span><span class="p">,</span> <span class="n">methods</span> <span class="o">=</span> <span class="n">evaluate_baseline_methods</span><span class="p">(</span><span class="n">test_pairs</span><span class="p">)</span>
 <span class="n">print_comparison_table</span><span class="p">(</span><span class="n">results</span><span class="p">,</span> <span class="n">test_pairs</span><span class="p">)</span>
-</pre></div>
-</div>
-</div>
-</div>
-</div>
-<div class="jp-Cell-outputWrapper">
-<div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
-</div>
-<div class="jp-OutputArea jp-Cell-outputArea">
-<div class="jp-OutputArea-child">
-<div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
-<div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
-<pre>Pair                           Sentence 1                     Sentence 2                    
+</pre>
+              </div>
+            </div>
+          </div>
+        </div>
+      </div>
+      <div class="jp-Cell-outputWrapper">
+        <div class="jp-Collapser jp-OutputCollapser jp-Cell-outputCollapser">
+        </div>
+        <div class="jp-OutputArea jp-Cell-outputArea">
+          <div class="jp-OutputArea-child">
+            <div class="jp-OutputPrompt jp-OutputArea-prompt"></div>
+            <div class="jp-RenderedText jp-OutputArea-output" data-mime-type="text/plain" tabindex="0">
+              <pre>Pair                           Sentence 1                     Sentence 2                    
 ====================================================================================================
 Pair 1:                        The cat sat on the mat.        The cat sat on the mat.       
                                Jaccard:             1.000
@@ -8235,11 +8434,12 @@ Pair 12:
                                Containment:         0.000
 ----------------------------------------------------------------------------------------------------
 </pre>
-</div>
-</div>
-</div>
-</div>
-</div>
-</main>
+            </div>
+          </div>
+        </div>
+      </div>
+    </div>
+  </main>
 </body>
-</html>
+
+</html>
\ No newline at end of file
diff --git a/requirments.txt b/requirments.txt
index 349dea1..5803763 100644
--- a/requirments.txt
+++ b/requirments.txt
@@ -5,6 +5,8 @@ matplotlib
 sentence-transformers
 rapidfuzz
 
+statsmodels
+
 spacy
 tensor
 datasets