diff --git a/sheets/03_card_sat/DBST/cardinality_sat.ipynb b/sheets/03_card_sat/DBST/cardinality_sat.ipynb
index 969cd3864d0dc716ce76f1edbfedb2e044c4946b..c9fc0efec0f4319faba9fd1d902afdf7fc413a0d 100644
--- a/sheets/03_card_sat/DBST/cardinality_sat.ipynb
+++ b/sheets/03_card_sat/DBST/cardinality_sat.ipynb
@@ -13,30 +13,14 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 1,
+   "execution_count": 5,
    "id": "acf228f8-9e16-423e-94ef-b6ec82bc540f",
    "metadata": {},
    "outputs": [],
    "source": [
-    "# Importiere den SAT-Solver mit Cardinality Constraints \"Gluecard4\" aus python-sat\n",
-    "from pysat.solvers import Solver, Gluecard4\n",
-    "\n",
-    "# Eine Menge nützlicher Routinen zu Iteratoren (erlaubt z.B. Iteration über alle Kombinationen)\n",
-    "import itertools\n",
-    "\n",
-    "# Graphen\n",
-    "import networkx as nx\n",
-    "from networkx.classes.graphviews import subgraph_view\n",
-    "\n",
-    "# Generation von zufälligen Zahlen für Instanzen/Punktmengen\n",
     "import random\n",
     "\n",
-    "# Fürs Wurzelziehen\n",
-    "import math\n",
-    "\n",
-    "# Fürs Zeichnen (hier von Graphen, kann aber auch Daten visualisieren)\n",
-    "import matplotlib\n",
-    "import matplotlib.pyplot as plt"
+    "from dbst_sat import DBSTSolverSAT, GreedyDBST, draw_edges"
    ]
   },
   {
@@ -51,7 +35,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 2,
+   "execution_count": 6,
    "id": "a9a0b9a0-2559-403c-8597-f589b68db83e",
    "metadata": {},
    "outputs": [],
@@ -64,238 +48,7 @@
     "    :param h: Höhe des Rechtecks.\n",
     "    :return: Eine Liste von Punkten als (x,y)-Tupel.\n",
     "    \"\"\"\n",
-    "    return [(random.randint(0,w), random.randint(0,h)) for _ in range(n)]\n",
-    "\n",
-    "def squared_distance(p1, p2):\n",
-    "    \"\"\"\n",
-    "    Berechne die (quadrierte) euklidische Distanz zwischen Punkten p1 und p2.\n",
-    "    \"\"\"\n",
-    "    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2\n",
-    "\n",
-    "def all_edges(points):\n",
-    "    \"\"\"\n",
-    "    Erzeuge eine Liste aller Kanten zwischen den\n",
-    "    gegebenen Punkten und sortiere sie (aufsteigend) nach Länge.\n",
-    "    \"\"\"\n",
-    "    edges = [(v,w) for v, w in itertools.combinations(points, 2)]\n",
-    "    edges.sort(key=lambda p: squared_distance(*p))  # *p ist hier wie p[0], p[1]\n",
-    "    return edges"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "77229487-82c1-439d-826b-13663b5a01ce",
-   "metadata": {},
-   "source": [
-    "## Zeichnen von Lösungen"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 3,
-   "id": "26e55971-24e3-44ad-9dc3-e474c508fd79",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def draw_edges(edges):\n",
-    "    \"\"\"\n",
-    "    Malt eine gegebene Liste von Kanten als Graph.\n",
-    "    Die längste Kante wird dabei hervorgehoben (rot, dicker) dargestellt.\n",
-    "    \"\"\"\n",
-    "    points = set([e[0] for e in edges] + [e[1] for e in edges])\n",
-    "    draw_graph = nx.empty_graph()\n",
-    "    draw_graph.add_nodes_from(points)\n",
-    "    draw_graph.add_edges_from(edges)\n",
-    "    g_edges = draw_graph.edges()\n",
-    "    max_length = max((squared_distance(*e) for e in g_edges))\n",
-    "    color = [('red' if squared_distance(*e) == max_length else 'black') for e in g_edges]\n",
-    "    width = [(1.0 if squared_distance(*e) == max_length else 0.5) for e in g_edges]\n",
-    "    plt.clf()\n",
-    "    fig, ax = plt.gcf(), plt.gca()\n",
-    "    fig.set_size_inches(8,6)\n",
-    "    nx.draw_networkx(draw_graph, pos={p: p for p in points}, node_size=8,\n",
-    "                     with_labels=False, edgelist=g_edges, edge_color=color, width=width, ax=ax)\n",
-    "    plt.show()"
-   ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "eee15b53-6e3c-4ca8-84b8-02abe664b85e",
-   "metadata": {},
-   "source": [
-    "## Eigentliche Solverklasse"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 4,
-   "id": "c96066d2-5c94-4579-b1e1-7421995c30e4",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class DBSTSolverSAT:\n",
-    "    def __make_edge_variables(self):\n",
-    "        \"\"\"\n",
-    "        Erzeuge Mappings von Kanten zu Variablen und umgekehrt.\n",
-    "        \"\"\"\n",
-    "        self.edge_to_var = {edge: i+1 for i, edge in enumerate(self.all_edges)}\n",
-    "        self.edge_to_var.update({(w,v): i for (v,w), i in self.edge_to_var.items()})\n",
-    "        self.var_to_edge = {v: e for e, v in self.edge_to_var.items()}\n",
-    "        \n",
-    "    def __make_graph(self):\n",
-    "        \"\"\"\n",
-    "        Erzeuge einen vollständigen Graphen sowie eine Abbildung Kante -> Index in self.all_edges\n",
-    "        (d.h. Position in der sortierten Reihenfolge).\n",
-    "        \"\"\"\n",
-    "        self.graph = nx.empty_graph()\n",
-    "        self.graph.add_nodes_from(self.points)\n",
-    "        self.graph.add_edges_from(self.all_edges)\n",
-    "        self.edge_to_index = {edge: index for index, edge in enumerate(self.all_edges)}\n",
-    "        self.edge_to_index.update({(w,v): i for (v,w), i in self.edge_to_index.items()})\n",
-    "        \n",
-    "    def __add_node_constraints(self):\n",
-    "        \"\"\"\n",
-    "        Führe für jeden Knoten ein Constraint ein, das sicherstellt,\n",
-    "        das wenigstens eine und höchstens d Kanten genutzt werden.\n",
-    "        \"\"\"\n",
-    "        for v in self.graph.nodes:\n",
-    "            edge_vars = [self.edge_to_var[v,w] for w in self.graph.neighbors(v)]\n",
-    "            self.solver.add_clause(edge_vars)  # at least one must be there\n",
-    "            self.solver.add_atmost(edge_vars, self.degree)  # at most d must be used\n",
-    "    \n",
-    "    def __add_edge_count_constraint(self):\n",
-    "        \"\"\"\n",
-    "        Stelle sicher, dass wir insgesamt genau n-1 Kanten haben.\n",
-    "        \"\"\"\n",
-    "        positive_edges = [self.edge_to_var[e] for e in self.all_edges]\n",
-    "        negative_edges = [-v for v in positive_edges]\n",
-    "        n = len(self.points)\n",
-    "        self.solver.add_atmost(positive_edges, n-1)  # at most n-1 edges\n",
-    "        self.solver.add_atmost(negative_edges, len(self.all_edges) - n + 1)  # at most |E| - (n-1) non-edges\n",
-    "    \n",
-    "    def __init__(self, points, degree, solution=None):\n",
-    "        \"\"\"\n",
-    "        Initialisiere den Solver.\n",
-    "        :param points: Die Punktmenge als Liste von (x,y)-Tupeln.\n",
-    "        :param degree: Die Gradschranke.\n",
-    "        :param solution: Optionaler Parameter. Entweder None oder eine Liste von Kanten, die eine gültige Lösung darstellt.\n",
-    "        \"\"\"\n",
-    "        self.points = points\n",
-    "        self.degree = degree\n",
-    "        self.all_edges = all_edges(points)\n",
-    "        self.best_solution = solution\n",
-    "        self.solver = Gluecard4(with_proof=False)\n",
-    "        self.__make_graph()\n",
-    "        self.__make_edge_variables()\n",
-    "        self.__add_node_constraints()\n",
-    "        self.__add_edge_count_constraint()\n",
-    "\n",
-    "    def __del__(self):\n",
-    "        \"\"\"\n",
-    "        Die Solver aus python-sat brauchen ein spezielles Cleanup,\n",
-    "        das bei normalem Python-Code nicht notwendig ist.\n",
-    "        Es scheint nur Resource-Leaks zu geben, wenn man das weglässt,\n",
-    "        von daher sollte es ausreichen, die Solver bei der Garbage Collection\n",
-    "        aufräumen zu lassen.\n",
-    "        \"\"\"\n",
-    "        self.solver.delete()\n",
-    "\n",
-    "    def __threshold_assumptions(self, threshold):\n",
-    "        \"\"\"\n",
-    "        Erzeuge eine Liste von assumptions (negative Literale),\n",
-    "        die alle Kanten entfernen, die länger sind als die Kante,\n",
-    "        deren Index als threshold gegeben wird.\n",
-    "        \"\"\"\n",
-    "        return [-self.edge_to_var[e] for e in self.all_edges[threshold+1:]]\n",
-    "    \n",
-    "    def __handle_components(self, components):\n",
-    "        \"\"\"\n",
-    "        Füge Klauseln hinzu, die die gegebene Liste von\n",
-    "        Zusammenhangskomponenten ausschließt, indem verlangt wird,\n",
-    "        dass aus jeder der Komponenten wenigstens eine Kante hinausführt.\n",
-    "        \"\"\"\n",
-    "        for component in components:\n",
-    "            crossing_edges = []\n",
-    "            vset = set(component)\n",
-    "            for v in component:\n",
-    "                for w in self.points:\n",
-    "                    if w not in vset:\n",
-    "                        crossing_edges.append(self.edge_to_var[v, w])\n",
-    "            self.solver.add_clause(crossing_edges)\n",
-    "\n",
-    "    def __solve_with_threshold(self, threshold):\n",
-    "        \"\"\"\n",
-    "        Löse die Frage (F): Gibt es einen Spannbaum mit Gradschranke self.degree,\n",
-    "        dessen längste Kante nicht länger ist als self.all_edges[threshold]?\n",
-    "        Gibt den höchsten tatsächlich verwendeten Kantenindex zurück\n",
-    "        (oder None, falls es keinen solchen Spannbaum gibt).\n",
-    "        \"\"\"\n",
-    "        assumptions = self.__threshold_assumptions(threshold)\n",
-    "        while True:\n",
-    "            if not self.solver.solve(assumptions=assumptions):\n",
-    "                print(f\"Mit Bottleneck {math.sqrt(squared_distance(*self.all_edges[threshold]))} geht es nicht!\")\n",
-    "                return None\n",
-    "            edges = self.__model_to_solution()\n",
-    "            #draw_edges(edges)\n",
-    "            #plt.show()\n",
-    "            edge_set = set(edges)\n",
-    "            edge_set.update({(w,v) for (v,w) in edge_set})\n",
-    "            g = subgraph_view(self.graph, filter_edge=(lambda v,w: (v,w) in edge_set))\n",
-    "            components = list(nx.connected_components(g))\n",
-    "            if len(components) > 1:\n",
-    "                self.__handle_components(components)\n",
-    "            else:\n",
-    "                threshold = self.__max_index(edges)\n",
-    "                print(f\"Neues bestes Bottleneck: {math.sqrt(squared_distance(*self.all_edges[threshold]))}!\")\n",
-    "                self.best_solution = edges\n",
-    "                return threshold\n",
-    "    \n",
-    "    def __model_to_solution(self):\n",
-    "        \"\"\"\n",
-    "        Mach aus einer SAT-Solver-Lösung eine Liste von Kanten.\n",
-    "        \"\"\"\n",
-    "        model = self.solver.get_model()\n",
-    "        return [self.var_to_edge[lit] for lit in model if lit > 0]\n",
-    "    \n",
-    "    def __index_of_solution_with_threshold(self, threshold):\n",
-    "        \"\"\"\n",
-    "        Gebe den Index der längsten Kante in einer Lösung zurück,\n",
-    "        wenn nur Kanten mit Index <= threshold erlaubt sind.\n",
-    "        Falls es keine Lösung gibt, gebe None zurück.\n",
-    "        Überprüft vor Benutzung des SAT-Solvers, ob der Graph mit allen Kanten\n",
-    "        unter der Schranke überhaupt zusammenhängend ist.\n",
-    "        \"\"\"\n",
-    "        g = subgraph_view(self.graph, filter_edge=(lambda v,w: self.edge_to_index[v,w] <= threshold))\n",
-    "        if not nx.is_connected(g):\n",
-    "            print(f\"Mit Bottleneck {math.sqrt(squared_distance(*self.all_edges[threshold]))}: Unzusammenhängender Graph!\")\n",
-    "            return None\n",
-    "        return self.__solve_with_threshold(threshold)\n",
-    "\n",
-    "    def __max_index(self, solution):\n",
-    "        \"\"\"\n",
-    "        Finde maximalen benutzten Kantenindex in einer Liste von Kanten (einer Lösung).\n",
-    "        \"\"\"\n",
-    "        return max((self.edge_to_index[e] for e in solution))\n",
-    "        \n",
-    "    def solve(self):\n",
-    "        \"\"\"\n",
-    "        Binäre Suche nach dem kleinsten Knotenindex in \n",
-    "        self.all_edges, mit dem sich ein Grad-d-beschränkter Spannbaum finden lässt.\n",
-    "        \"\"\"\n",
-    "        lb = len(self.points) - 2  # Der größte Kantenindex von dem wir wissen dass er nicht reicht\n",
-    "        ub = len(self.all_edges) - 1  # Der kleinste Kantenindex von dem wir wissen dass er reicht\n",
-    "        if self.best_solution is not None:\n",
-    "            ub = self.__max_index(self.best_solution)\n",
-    "        while lb < ub - 1:\n",
-    "            mid = (lb + ub) // 2  # Ganzzahldivision in Python: //\n",
-    "            actual_index = self.__index_of_solution_with_threshold(mid)\n",
-    "            if actual_index:\n",
-    "                ub = actual_index\n",
-    "            else:\n",
-    "                lb = mid\n",
-    "        return self.best_solution"
+    "    return [(random.randint(0,w), random.randint(0,h)) for _ in range(n)]"
    ]
   },
   {
@@ -310,7 +63,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 7,
    "id": "bc4a9583-41d0-4d94-86c9-bfef164d5700",
    "metadata": {
     "tags": []
@@ -320,20 +73,20 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Neues bestes Bottleneck: 5307.554710033614!\n",
-      "Neues bestes Bottleneck: 3420.8037067332584!\n",
-      "Mit Bottleneck 2405.7348149785753: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 2883.950415662516: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3070.5740505644867: Unzusammenhängender Graph!\n",
-      "Neues bestes Bottleneck: 3181.257612957492!\n",
-      "Mit Bottleneck 3095.155246510262: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3176.0077140964254: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3179.88254500068: Unzusammenhängender Graph!\n"
+      "New best bottleneck: 4705.376180498218!\n",
+      "New best bottleneck: 2958.6841669904547!\n",
+      "The bottleneck 2238.626811239426 is infeasible!\n",
+      "New best bottleneck: 2646.000755857791!\n",
+      "The bottleneck 2449.3664486964785 is infeasible!\n",
+      "New best bottleneck: 2560.517330540842!\n",
+      "The bottleneck 2486.633467159967 is infeasible!\n",
+      "The bottleneck 2545.9006264974287 is infeasible!\n",
+      "The bottleneck 2557.4512703079995 is infeasible!\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -362,60 +115,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
-   "id": "9aae8091-63a0-4fa2-aa95-0fe650578090",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "class GreedyDBST:\n",
-    "    \"\"\"\n",
-    "    Löse Degree-Constrained Bottleneck Spanning Tree mit einer Greedy-Heuristik.\n",
-    "    Geht durch die (aufsteigend nach Länge sortierte) Liste der möglichen Kanten,\n",
-    "    und fügt eine Kante ein, wenn das vom Grad her noch geht und die Endpunkte\n",
-    "    noch nicht in derselben Zusammenhangskomponente sind (im Prinzip wie Kruskal).\n",
-    "    \"\"\"\n",
-    "    def __init__(self, points, degree):\n",
-    "        self.points = points\n",
-    "        self.all_edges = all_edges(points)\n",
-    "        self._component_of = {v: v for v in points}\n",
-    "        self.degree = degree\n",
-    "        \n",
-    "    def __component_root(self, v):\n",
-    "        cof = self._component_of[v]\n",
-    "        if cof != v:\n",
-    "            cof = self.__component_root(cof)\n",
-    "            self._component_of[v] = cof\n",
-    "        return cof\n",
-    "        \n",
-    "    def __merge_if_not_same_component(self, v, w):\n",
-    "        cv = self.__component_root(v)\n",
-    "        cw = self.__component_root(w)\n",
-    "        if cv != cw:\n",
-    "            self._component_of[cw] = cv\n",
-    "            return True\n",
-    "        return False\n",
-    "    \n",
-    "    def solve(self):\n",
-    "        edges = []\n",
-    "        degree = {v: 0 for v in self.points}\n",
-    "        n = len(self.points)\n",
-    "        m = 0\n",
-    "        for v,w in self.all_edges:\n",
-    "            if degree[v] < self.degree and degree[w] < self.degree:\n",
-    "                if self.__merge_if_not_same_component(v,w):\n",
-    "                    edges.append((v,w))\n",
-    "                    degree[v] += 1\n",
-    "                    degree[w] += 1\n",
-    "                    m += 1\n",
-    "                    if m == n-1:\n",
-    "                        print(f\"Bottleneck bei Greedy: {math.sqrt(squared_distance(v,w))}\")\n",
-    "                        break\n",
-    "        return edges"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 8,
    "id": "cbeba604-32fa-4d67-b16f-6645742cb0e8",
    "metadata": {},
    "outputs": [
@@ -423,12 +123,12 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Bottleneck bei Greedy: 3181.257612957492\n"
+      "Greedy bottleneck: 2560.517330540842\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAoAAAAHiCAYAAAB4GX3vAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMSwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/bCgiHAAAACXBIWXMAAA9hAAAPYQGoP6dpAABYzUlEQVR4nO3dd3zM9+MH8Nfn7nIXGUKQoKSo0WH1a1VTpfjaWzRmrZLybdWvqFWCIlbNFtHaoVTEFkqs2hLVUq1WaaNWxMi+y43P749IakYSd/e+u8/r+Xjk0dJzeZ1mvPKekizLMoiIiIhIMVSiAxARERGRfbEAEhERESkMCyARERGRwrAAEhERESkMCyARERGRwrAAEhERESkMCyARERGRwrAAEhERESmMJi8PslgsuHbtGry9vSFJkq0zEREREVE+ybKMlJQUlC5dGipV7mN8eSqA165dQ9myZa0SjoiIiIhs58qVKyhTpkyuj8lTAfT29s55wsKFCz9/MiIiIiKyquTkZJQtWzant+UmTwUwe9q3cOHCLIBEREREDiwvy/W4CYSIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZCIiIhIYVgAiYiIiBSGBZDoPr3RjPg76dAbzaKjEBER2ZRGdAAiR3DkYiJCIuKQajDBS6dBeM9aCKxYXHQsIiIim+AIICme3mhGSEQc0gwmAEBapgkhEXEcCSQiIpfFAkiKl5BiQKrBBPn+r2UZSDWYkJBiEJqLiIjIVlgASfH2btsIldkA6f6vJQnw0mng560TmouIiMhWWABJsVJSUtC3b19c+esSVrz/Fjx1WUtiPbVZawDd3dSCExIREdkGN4GQIp0+fRrDhw/HhAkT8PbbbwMAYsc2RUKKAX7eOpY/IiJyaSyApCiyLGP+/Pk4fPgwNmzYgGLFiuX8N3c3NQJ8PQSmIyIisg9OAZNiJCYm4t1334VKpcJ33333UPkjIiJSEo4AkiIcOHAAkyZNwuzZs1GzZk3RcYiIiIRiASSXZjKZMGnSJFy9ehVbt26Fl5eX6EhERETCcQqYXNaVK1fQvn17VKlSBUuXLmX5IyIiuo8jgOSSNm/ejIULF+Krr75CpUqVRMchIiJyKCyA5FL0ej1GjBgBnU6H7du3Q6vVio5ERETkcDgFTC7j119/RZs2bdCyZUvMmjWL5Y+IiOgpOAJITk+WZaxYsQJRUVFYtWoVSpcuLToSERGRQ+MIIDm15ORk9O7dG9euXcPmzZtZ/oiIiPKAI4DktE6dOoWRI0fi888/R2BgoOg4REREToMFkJyOxWLB7NmzERcXh40bN6Jo0aKiIxERETkVTgGTU0lISEBQUBA8PT2xdu1alj8iIqIC4AggOY29e/ciLCwMc+bMQfXq1UXHISIiclosgOTwjEYjQkNDcfv2bWzduhWenp6iIxERETk1TgGTQ/vrr7/Qrl071KhRA+Hh4Sx/REREVsARQHJYkZGR+Oabb7Bw4UJUqFBBdBwiIiKXwQJIDicjIwOffPIJChcujG3btsHNzU10JCIiIpfCKWByKL/88gvatm2Ljh07Yvr06Sx/RERENsARQHIIsizj66+/xs6dOxEREYGSJUuKjkREROSyOAJIwt27dw89e/bEvXv3EBUVxfJHRERkYxwBJKGOHz+OMWPGYOrUqXjjjTdExyEiIlIEFkCyK73RjIQUA0p4umHenC9w7tw5REVFoUiRIqKjERERKQYLINnNkYuJCImIQ6rBBJU5E93KlMbq1SMhSZLoaERERIrCAkg2Yzabcf36dcTHx+PPv+Lx+VkPZMoqQJIgq7XYcscf40wWuLupRUclIiJSFBZAKrCkpCTEx8c/9paUlARJkqBSqVCqVCkEBATAq2Q5ZEIN3B/skwGkGkxISDEgwNdD6OsgIiJSGhZAeqLMzExcvXoV8fHxuHLlSk65u3btGiwWCwCgSJEiCAgIQNmyZREQEIC33noLAQEB8PHxeez59EYzlkzZi7RME2QZkCTAU6uBn7fO3i+NiIhI8VgAFUiWZdy+ffuxkbsrV64gPT0dsizDzc0NZcqUQUBAAAICAvDOO++gbNmyKFWqFNTq/E/ZurupEd6zVs4aQE+tBuE9a3H6l4iISABJlmX5WQ9KTk6Gj48PkpKSULhwYXvkUqzsXbJ+3roCl6OMjAxcuXLloZG7+Ph43Lx5EwAgSRKKFy+eM3KX/Va2bFl4enpa8+U8xhqvj4iIiB6Xn77GEUAH8uAuWS9d1ghZYMXiDz3GYrHg5s2bD43aZf/TYDAAANzd3R8qdq1atUJAQABKlCgBlUrs2d/ubmqu+SMiIhKMI4AOQm80o/aDa+QAuEkWdJZO4uqVv3Hnzh1IkgRJkuDv7/9QwQsICECZMmWg03E9HRERkVJxBNAJJaQYkGow5fxaBpApq9CwVXvUfbUCihYtyvPyiIiIyCpYAB2En7cOXjo1UvVGQFLl7JJtVO91rpUjIiIiqxK7IIxyuLup8Zb8K9w1WaN83CVLREREtsIRQAdx48YNXD29D2c2foSE1EzukiUip8Nd/kTOgwXQQUycOBHjx4+Hu1aDAF/+byEi55KXUwyIyHFwCtgB/Prrr0hNTUWdOnVERyEiyje90YyQiDikZWZtZEvLNCEkIg56o1lwMiJ6GhZABxAaGoqJEyeKjkFEVCDZpxhkHyomy//e9U1EjokFULBDhw6hTJkyqFChgugoREQFknWKgQbS/XvCJQnw0vGubyJHxgIokCzLmDp1Kj777DPRUYiICiz7rm9Pc9aIH08xIHJ83G0g0IYNG9CkSRP4+vqKjkJE9FwCKxZH7MkvkVDhZfh9/RXLH5GDYwEUxGAwYPHixdi5c6foKEREVuHuVxwB1y8DLH9EDo9TwIIsWrQI/fr1g7u7u+goRETW4e8P3LwpOgUR5QFHAAW4d+8edu7ciV27domOQkRkPX5+LIBEToIjgAKEhYVh5MiRUKn4109ELsTfH7h1C7i/G5iIHBcbiJ3Fx8fj4sWLaNKkiegoRETW5e8PmM3AnTuikxDRM7AA2hkPfSYil+Xvn/VPTgMTOTwWQDv68ccfodFoULVqVdFRiIisz88v658sgEQOj5tA7ESWZUyYMAELFy4UHYWIyDY4AkjkNDgCaCe7d+9GtWrV8MILL4iOQkRkG15eQKFCQEKC6CRE9AwcAbQDs9mMWbNmISoqSnQUIiLbkSSeBUjkJDgCaAerVq1Cx44dUbhwYdFRiIhsi2cBEjkFjgDaWHp6OiIiInjoMxEpA0cAiZwCRwBtbO7cufjwww/h5uYmOgoRke35+3MNIJETYAG0oVu3buHw4cPo0KGD6ChERPbBEUAip8ACaEOff/45xo0bB0mSREchIrKP7DWAsiw6CRHlggXQRn7//XfcunUL9evXFx2FiMh+/P0BgwFIThadhIhywQJoI6GhoZg0aZLoGERE9pV9GDTXARI5NBZAGzh69ChKlCiBSpUqiY5CRGRfvA2EyCnwGBgrk2UZkydPxsqVK0VHISKyP94HTOQUOAJoZZs2bUKDBg1QokQJ0VGIiOyvaFFAo2EBJHJwHAG0IqPRiK+++grbtm0THYWISAyVKmsUkGsAiRwaRwCtaMmSJejVqxc8PDxERyEiEofXwRE5PI4AWklycjI2b97MK9+IiHgYNJHD4wiglcyYMQPDhw+HWq0WHYWISCwWQCKHxwJoBVevXsW5c+fQrFkz0VGIiMTjfcBEDo8F0AomTJiACRMm8Mo3IiKAawCJnAAL4HM6e/YsTCYTatasKToKEZFj8PcHUlKAjAzRSYjoKVgAn1NoaCgmTpwoOgYRkePgdXBEDo8F8DnExMSgcuXKCAgIEB2FiMhx8Do4IofHY2AKyGKxYPr06fjuu+9ERyEiciy8Do7I4XEEsIDWrl2L1q1bo0iRIqKjEBE5lhIlAEliASRyYBwBLAC9Xo9ly5bx0GcioifRaIBixbgGkMiBcQSwABYsWIAPPvgAWq1WdBQiIsfEw6CJHBpHAPPp9u3biImJQXR0tOgoRESOi2cBEjk0jgDm05QpUzB27Fge+kxElBuOABI5NBbAfLh06RL++ecfNGjQQHQUIiLHxuvgiBwaC2A+hIaGYtKkSaJjEBE5Po4AEjk0FsA8OnXqFLy9vfHyyy+LjkJE5Pj8/IDbtwGjUXQSInoCbgLJA1mWMXHiRHzzzTeioxAROYfs20Bu3QJKlxabhYgewxHAPNi+fTvq1q2LkiVLio5CROQceB8wkUPjCOAzmEwmzJ07F1u3bhUdhYjIefA+YCKHxhHAZ1i2bBm6du0KT09P0VGIiJwH7wMmcmgcAcxFamoqvvvuO175RkSUX+7uQOHCLIBEDoojgLn44osvMHToUGg07MlERPnGswCJHBYL4FPcuHEDsbGxaN26tegoRETOiWcBEjksFsCnmDBhAkJDQ3nlGxFRQfE+YCKHxQL4BL/++ivS0tJQu3Zt0VGIiJwXRwCJHBYXtz3B+PHjMWPGDNExiIicG9cAEjksjgA+4uDBgwgICED58uVFRyEicm7ZBdBiEZ2EiB7BEcAHWCwWTJ06Fd9++63oKEREzs/PDzCbgTt3gOLFRachogdwBPABGzZswH//+1/4+vqKjkJE5Px4GwiRw+II4H0GgwHh4eHYuXOn6ChERK7hwfuAX3tNbBYieghHAO9buHAh+vfvD3d3d9FRiIhcA6+DIwelN5oRfycdeqNZdBRhOAII4O7du4iOjuaVb0RE1uTtnXUlHAsgOZAjFxMREhGHVIMJXjoNwnvWQmBF5a1R5QgggLCwMIwaNQoqFf86iIisRpJ4FiA5FL3RjJCIOKQZTACAtEwTQiLiFDkSqOjGozeacezsH/jj0l9o3Lix6DhERK6HZwGSA0lIMSDVYIJ8/9eyDKQaTEhIMQjNJYJip4AfHAL2eLUPjlxMVOQQMBGRTfE6OHIgft46eOk0SNUbAUmCJAGeWg38vHWio9mdIkcAHx0CzjDJih0CJiKyKU4BkwNxd1MjvGctqCyZALLKX3jPWnB3UwtOZn+KHAHMHgLO9uAQcICvh8BkRPQseqMZCSkG+HnrFPlF2+lwCpgcTL1yRfDKb6uwaMVaRX8dUWQBzB4CTru/DkDJQ8BEzoS795xQ9gigLGd9sSUS7JdffkH1115R/ICPIqeAs4eAPXVZ/beQRqXYIWAiZ5GzdCOTu/ecip8foNcDKSmikxABAE6ePIm6deuKjiGcIgsgAARWLI7YsU0xr2kRtNQf4CgCkYPL2b13f/ueknfvORVeB0cO5sSJEyyAUHABBLJGAts1fhPnfjqDjIwM0XGIKBd+3jp4uKmQ3QAlCfDScemGw3vwOjgiB3Dt2jW88MILomMIp+gCCACSJCE4OBjr168XHYWIcuHupkbdzJ9QyC1rHZmSd+85FY4AkgNJTU2Fp6en6BgOQZGbQB7VtWtXdOrUCX369BEdhYieQq/X49rpffhx+3AkpGYqeveeUylaFFCrWQDJIcTFxaF27dqiYzgExY8AAoCHhweqVauGkydPio5CRE+xYcMGdOnSBe5aDQJ8PVj+nIVKxcOgyWFwA8i/WADvGzRoEBYtWiQ6BhE9xdq1a9G9e3fRMaggeBYgOYjY2FiOAN7HAnhfhQoVkJycjFu3bomOQkSPOH36NKpUqcK1O86Kt4GQg0hJSYG3t7foGA6BBfAB/fv3x9KlS0XHIKJHLF68GIMGDRIdgwqKU8DkAK5fv46SJUuKjuEwWAAf0KJFC+zZswdmMw+WJXIUd+/exc2bN1GlShXRUaigOAJIDuDkyZOoV6+e6BgOgwXwASqVCq1atcKOHTtERyGi+1auXMkd+s6OawDJAfAA6IexAD6ib9++WLZsmegYRATAYrFg27ZtaNu2rego9Dz8/YHk5Kwr4YgEOXfuHKpWrSo6hsNgAXyEr68vihcvjt9//110FCLF27dvHxo1agSNhkeWOjU/v6x/chqYBLFYLLBYLHBzcxMdxWGwAD7B4MGDsXDhQtExiBTv66+/xvvvvy86Bj0v3gZCgl24cIHriB/BAvgE//nPf3DhwgWkpaWJjkKkWFeuXIFGo0GpUqVER6HnxfuASTAeAP04FsCn6NmzJ9asWSM6BpFiLVmyBCEhIaJjkDWUKJH1T44AkiDcAPI4FsCnCAoKQmRkJGRZFh2FSHEyMzNx7NgxNGjQQHQUsgaNBihWjAWQhPnrr79Qrlw50TEcCgvgU+h0OtSpUweHDx8WHYVIcaKiotCpUydIkiQ6ClkLzwIkQTIyMuDu7s6vJ49gAcxFSEgIwsPDRccgUpzVq1ejV69eomOQNfEsQBLkzJkzeP3110XHcDgsgLkICAiA0WjE9evXRUchUoyzZ8+iXLlyvK/T1XAEkAThBpAnYwF8hoEDB+Lrr78WHYNIMRYtWsR7f10R7wMmQU6ePIk6deqIjuFwWACfoXHjxjh06BCMRqPoKEQuLzk5GfHx8Tyt3xVxBJAEuXv3Lnx9fUXHcDgsgM8gSRLat2+PzZs3i45C5PJWr16N9957T3QMsgV/f+D2bcBkEp2EFCQxMRHFihUTHcMhsQDmwXvvvYdVq1aJjkHk0mRZxqZNm9ChQwfRUcgWsq+Du3VLbA5SlFOnTnH931OwAOaBj48PypYti3PnzomOQuSyDh06hDfffBNarVZ0FLIFXgdHAvAA6KdjAcyjwYMHY9GiRaJjELmsJUuWYODAgaJjkK3wOjgS4MyZM6hZs6boGA6JBTCPqlativj4eCQlJYmOQuRyrl+/DrPZjDJlyoiOQraSPQXMEUCyE1mWkZmZCZ1OJzqKQ2IBzAeuBSSyja+//hoDBgwQHYNsqVAhwNubBZDs5tKlS6hQoYLoGA6LBTAfOnTogC1btvB+YCIrMhqNOHjwIBo3biw6Ctkaj4IhOzpy/CQqvV4feqNZdBSHxAKYD25ubmjQoAH27dsnOgqRy9i2bRvatWvHezqVgNfBkZ0cuZiISWc9MOdiEdSeshdHLiaKjuRwWADziTeDEFnXihUr0Lt3b9ExyB44Akh2oDeaERIRBxPUAIC0TBNCIuI4EvgIFsB8KlWqFDQaDa5cuSI6CpHT+/XXX1GyZEkUKVJEdBSyB14HR3aQkGJAqsEE3J9VkGUg1WBCQopBcDLHwgJYACEhIQgPDxcdg8jpLV68GIMHDxYdg+yFI4BkB37eOnjpNIBsAZDVA710Gvh5czfwg1gAC+Ctt97CiRMnYDDwpwmigkpLS8Mff/zBM7oURO/nj/hMFfQG3q1OtuPupkZ4z1pQWbKuHfTUahDesxbc3dSCkzkWFsACkCQJQUFBiIyMFB2FyGmtWbMGPXr0EB2D7OTIxUTUvlYWbw8IR+2pMVyUTzYVWLE4Xr2wCodGvIPYsU0RWLG46EgOhwWwgHr06IE1a9aIjkHklGRZxoYNGxAUFCQ6CtlB9qL8NHPWmqy0TDMX5ZPNqWQzAnw9OPL3FCyABeTl5YXKlSvjxx9/FB2FyOkcO3YMtWvX5gn9CpG9KD/7BFUZXJRPJBoL4HMYPHgwFi5cKDoGkdNZvHgxQkJCRMcgO/Hz1qGQRsrajomsRfka2YSp40ZCr9cLTkekTCyAz6Fy5cq4desW7ty5IzoKkdNISEhARkYGypUrJzoK2YlKNsP3l0h46jQAshblr3w/EO1at0Tbtm3x+++/C05IpDwa0QGcXd++fbF8+XIMGzZMdBQip7B06VL0799fdAyyo+nTp+Ojd5uhQ+f/IiHFAD9vXda6rIqtUL16dYSEhKB79+7cFERWJ8sybxl6Co4APqc2bdogOjoaFotFdBQih2c2m7F37140a9ZMdBSyk19++QVnz55FcHAw3N3Ujy3KL1OmDLZs2YLffvsNAwYMQHp6usC05ErUajW/N+eCBfA5qdVqNG3aFLt37xYdhcjh7dy5Ey1btoRKxS89SmA2mzFs2DDMnTs311EYjUaDzz//HMHBwWjbti1++eUXO6YkV6VWq2EymUTHcFj8KmwF/fv3xzfffCM6BpHDW7ZsGfr27Ss6BtnJ3Llz8e6776J06dJ5enzTpk2xZs0ajBkzBsuWLYMsy8/+Q0RPoVarYTbzqKGnYQG0ghIlSsDb2xuXLl0SHYXIYV28eBFFixZFsWLFREchO7h48SJ++OGHfBf+kiVLIioqCteuXUOfPn2QkpJio4Tk6jQaDQtgLlgArWTQoEFYtGiR6BhEDmvx4sUYNGiQ6BhkBxaLBUOHDn3m1O/TqNVqfPbZZ+jfvz/at2+PM2fOWD8kuTxOAeeOBdBK6tati7NnzyIjI0N0FCKHk5GRgXPnzqFOnTqio5AdhIeHo0WLFs991M/bb7+N9evXY9KkSVi0aBGnhClfOAWcOxZAK5EkCV27dsW6detERyFyOOvXr0fXrl1FxyA7iI+Px/bt2zF48GCrPF+JEiUQGRmJ1NRU9OjRA/fu3bPK85Lr4xRw7lgArSg4OBjr1q3jT6lEj1i3bh2Cg4NFxyAbk2UZH3/8MebMmWPVnd4qlQojRozARx99hE6dOuHUqVNWe25yXZwCzh0LoBUVKlQINWrUwIkTJ0RHIXIYp06dQtWqVVGoUCHRUcjGVq1ahfr166Ny5co2ef769etj48aNmDVrFubMmcMftilXnALOHQuglQ0aNAiLFy8WHYPIYSxatAgffPCB6BhkY9evX8eaNWvwySef2PT9FC1aFOvWrYNGo8G7777LqzjpqTgFnDsWQCsrX748UlNTkZCQIDoKkXC3b9/GvXv3ULFiRdFRyIZkWcb//d//4YsvvoBGY/sbRiVJwkcffYRRo0YhKCgIR44csfn7JOfDKeDcsQDawPvvv4+lS5eKjkEk3PLly3nwswJERkbi5ZdfRrVq1ez6fmvVqoVNmzZh0aJFmDZtGq/9oodwCjh3LIA20KxZM8TExPADjxTNYrEgOjoarVq1Eh2FbCgxMRHh4eEYM2aMkPfv4+OD1atXw9fXF507d+bsC+XgFHDuWABtQKVSoVWrVti+fbvoKETCfP/99/jvf/8LtVotOgrZ0PDhwxEWFgatVissgyRJGDhwICZOnIiuXbviwIEDwrKQ4+AUcO5YAG2kb9++WLZsmegYRMIsXboU/fr1Ex2DbGj79u3w8/NzmAO+q1evjq1bt2LVqlWYOHEiR38UjlPAuWMBtJGiRYvC398fFy5cEB2FyO7++usvFCpUCH5+fqKjkI0kJSVh9uzZmDhxougoD/Hy8sKyZctQrlw5dOjQAdeuXRMdiQThFHDuWABtaPDgwVi4cKHoGER2Fx4ezqNfXNzIkSMxceJEhz3fsXfv3pgxYwbee+89fP/996LjkACcAs4dC6AN1axZExcvXkRqaqroKER2YzAYEBcXh/r164uOQjYSExMDNzc3NGjQQHSUXL3yyivYtm0boqKiMGbMGJYBheEUcO5YAG2sR48eWLNmjegYRHYTGRmJLl26QJIk0VHIBtLS0jBlyhRMnTpVdJQ8KVSoEBYvXoxq1aqhXbt2uHLliuhIZCecAs4dC6CNde7cGZGRkbyyiBRjzZo16N69u+gYZCOfffYZRo0aBW9vb9FR8qVbt26YN28e+vXrh23btomOQ3bAKeDcsQDamE6nwxtvvIEffvhBdBQim/vxxx9RqVIleHp6io5CNnD06FGkpKSgWbNmoqMUSKVKlbB9+3bs3bsXw4YNQ2ZmpuhIZEOcAs4dC6AdhISEIDw8XHQMIptbvHgxBg8eLDoG2YBer8e4ceMwc+ZM0VGei06nw7x58xAYGIi2bdvi8uXLoiORjXAKOHcsgHZQpkwZmM1mXL9+XXQUIpvQG80499cNXLt5C1WqVBEdh2xg0qRJGDJkCIoWLSo6ilV06tQJixcvxqBBg7Bx40bRccgGOAWcOxZAOxk4cCCWLFkiOgaR1R25mIjaU/aiTXgc/qjaD0cuJoqORFZ2+vRpxMfHo3379qKjWFX58uWxdetWHD9+HB999BH0er3oSGRFnALOHQugnbzzzjs4ePgo/ryZBL2RH5DkGvRGM0Ii4pCWmfVTtsEiISQijh/jLsRoNGLkyJGYM2eO6Cg2odVqMXPmTLRo0QJt27bF77//LjoSWQmngHPHAmgnR/+8jX/qfIgmcw+j9pS9HCUhl5CQYkCqwYTsTe6yDKQaTEhIMYgNRlYzffp09OvXDyVKlBAdxaZat26N5cuXY+jQoVi7dq3oOGQFnALOHQugHWSPkhjlrL/uNIOJoyTkEny0MtQWI4CsBihJgJdOAz9vndhgZBW//PILfvrpJ3Tt2lV0FLsoU6YMtm7divPnz2PgwIFIT08XHYmeA6eAc8cCaAc5oyT3fy0ja5Tk18tXRcYiei4JCQno2iUIH9XUwUvnBgDw1GoQ3rMW3N3UgtPR8zKbzRg2bBjmzp2rqEO9NRoNJk+ejC5duqBt27Y4f/686EhUQJwCzp1GdAAl8PPWwUunQVpm1lSZJAHuamDssI9Qq2Z1DB8+HD4+PqJjEuXZuXPnMGTIEMyfPx9Vq1bFB0YzElIM8PPWsfy5iHnz5qFLly544YUXREcR4r///S+qVq2KkJAQdOzYEX369FFUEXYFnALOHUcA7cDdTY3wnrXgqc3q255aDb7pXQ87tm7GW2+9hS5dumDGjBmcbiCnEB0djREjRmDdunWoWrUqgKyP8QBfD5Y/F3Hx4kUcPHgQ/fr1Ex1FqFKlSmHTpk34559/0K9fP97r7mQ4BZw7jgDaSWDF4ogd2/SxUZLmzZujWbNm2LhxI9q2bYugoCD0798fWq1WcGKih8myjC+//BJxcXHYtGkT3N3dRUciG7BYLBg6dCi+/PJLjnghq0SMGzcOBw8eRLt27TBnzhzUqFFDdCzKA04B544jgHb0tFESSZIQFBSE3bt3w93dHS1atEBERAQ/cMlhmEwmfPTRR0hKSsLy5ctZ/lzYkiVL0Lx5c5QrV050FIfSsGFDrF+/HhMmTMDixYt5v7sT4BRw7lgAHYhGo0Hfvn0RHR2NO3fuoHnz5tiyZQu/0JBQ9+7dQ1BQEN5++2189tlnHBVyYfHx8di6dSv+97//iY7ikEqUKIGNGzciOTkZPXv2RFJSkuhIlAtOAeeOBdAB6XQ6DBkyBJs3b8Yvv/yCli1bYt++faJjkQJdunQJnTt3xpgxY/Duu++KjkM2JMsyhg4dijlz5kCl4reGp1GpVPj000/x4YcfomPHjjh16pToSPQUnALOHT/LHZiXlxfGjBmDtWvXYs+ePWjXrh1OnDghOhYpxA8//ICBAwdi+fLlqFu3rug4ZGOrV69GvXr1eJdzHtWvXx+RkZGYOXMm5s6dy5kaB8Qp4NyxADoBX19fhIWFITw8HKtXr0ZwcDDOnTsnOha5sFWrVmH+/PnYtGkTAgICRMchG7tx4wYiIiIwbNgw0VGciq+vL9avXw9JkhAcHIw7d+6IjkQP4BRw7rgL2ImUKlUKX375JS5fvoxJkyZBlmWMHz8eFSpUEB2NXITFYsG4ceNgMBiwbt06qNU81sXVZU/9zpo1CxoNvyXklyRJ+PjjjxEYGIigoCBMnjwZb775puhYBE4BPwtHAJ1Q+fLlsXz5cowYMQKjR4/G//73P1y/fl10LHJy6enp6NmzJ8qVK4dZs2ax/ClEZGQkXn75ZVSvXl10FKdWu3ZtbNq0CV999RWmT58Oi8UiOpLicQo4dyyATuy1117D+vXr0adPH3zwwQcYOXIkpyCoQK5du4YOHTrg/fffx4ABA0THITu5ffs2wsPDMWbMGNFRXIKPjw8iIiJQpEgRBAUF4datW6IjKRqngHPHAugC6tSpgy1btqB58+bo3r07Jk+ezBPrKc9+/PFH9OzZE19++SUaN24sOg7Z0bBhwxAWFsaD561IkiSEhIQgNDQUXbt2xcGDB0VHUixOAeeOBdCFNG7cGNHR0ahevTo6dOiAefPmQa/Xi45FDmzz5s0YP348IiMjUblyZdFxyI527NgBPz8/1KlTR3QUl1SjRg1s2bIFK1aswKRJk1hEBOAUcO5YAF2MJElo164ddu/ejeLFi6NVq1ZYtmwZPwnoIbIsY8aMGdi5cyc2btwIX19f0ZHIjpKSkjB79mxMnDhRdBSX5uXlhWXLliEgIAAdO3bkWm074xRw7lgAXZRarUaPHj2we/duZGZmonnz5tiwYQMXJhMyMzMxcOBAqNVqhIeHc/pPgUaOHInQ0FAUKlRIdBSXJ0kS+vTpg2nTpqFXr17Ys2eP6EiKwSng3LEAujg3Nzd88MEH2LZtG/766y+0aNECu3bt4qGlCnX79m106tQJbdq0wbBhw3itmwLt27cPbm5uePvtt0VHUZRXX30VW7duRWRkJMaOHctZGTvgFHDuWAAVwsPDAyNGjMCGDRtw9OhRtGnTBocPHxYdi+zowoUL6NKlCz7//HO0b99edBwSIC0tDZMnT8bUqVNFR1EkDw8PhIeH47XXXkO7du1w5coV0ZFcGqeAc8cCqDA+Pj6YNGkSli9fjqioKHTu3BlnzpwRHYtsLCYmBkOGDMGaNWvw+uuvi45Dgnz22WcYNWoUvL29RUdRtO7du2PevHno168fduzYITqOy+IUcO5YABXKz88Ps2fPxty5c7Fw4UL07NkTv//+u+hYZANLlizB0qVLsWnTJpQqVUp0HBLk6NGjSElJQbNmzURHIQCVKlXCtm3bsGvXLgwfPhyZmZmiI7kcTgHnjgVQ4cqWLYslS5Zg3LhxmDhxIgYOHMhpCRdhNpsxbNgwXLlyBREREfDw8BAdiQTR6/UYN24cZs6cKToKPcDd3R0LFixA/fr10bZtW1y+fFl0JJfCKeDcsQASAKBKlSpYs2YNBg0ahKFDh+KTTz7hKfZOLCUlBcHBwahZsyY+//xzqFT8VFeySZMmYciQIShatKjoKPQEnTt3xuLFizFo0CBERUWJjuMyOAWcO35XoIe8/vrr2LhxIzp27IjevXtj/PjxSEpKEh2L8iE+Ph4dO3bE//3f/6FXr16i45Bgp0+fRnx8PDf+OLjy5ctj69atOHr0KIYMGcJD/K2AU8C5YwGkJ2rQoAF27NiB+vXrIygoCDNnzkRGRoboWPQMJ06cQN++fbFkyRIEBgaKjkOCGY1GjBw5EnPmzBEdhfJAq9Vi1qxZaNasGdq2bYs//vhDdCSnxing3LEA0lNJkoSWLVti9+7dKFeuHFq3bo3FixfDaDQCAPRGM+LvpENvVNYnmKO+7vXr12PatGmIiopChQoVRMchBzB9+nT069cPJUqUEB2F8qFNmzZYtmwZPv74Y3z77bei4zgtTgHnjgWQnkmlUqFLly74/vvvodVq0bx5c0wKX4/aU/bi7Zn7UXvKXhy5mCg6pl0cuZjocK9blmVMmjQJhw8fxoYNG+Dj4yM6EjmA8+fP46effkLXrl1FR6ECKFu2LLZu3Ypz584hJCQE6enpoiM5HU4B544FkPJMo9GgX79+2LR1GyL+LoRUfdaxBWkGE0Ii4hxuRMza9EYzQiLikGbIGgF1hNet1+vRu3dv+Pr6YsGCBdBoNMKykOMwm8345JNPMHfuXN724sQ0Gg2mTJmCzp07o127djh//jwAx52FcDQqlYq3XuWC3y0o35IyJWTKauD+9xUZQKrBhOA+A9H0jZpo2LAhqlat6nI7Ty9dS0SqwYTsF579uvcdi0PLBnXs/o325s2b6NOnDz7++GO0aNHCru+bHNu8efPQpUsXvPDCC6KjkBU0a9YM1apVw8CBA/F6i66IulUcqQYTvHQahPeshcCKxUVHJCfkWt+hyS78vHXw0mmQ3XckCfDSafD1/Fl46aWXsGbNGrRt2xZdunTBvHnzcObMGVgsFrGhn9OFCxfwv/69UEiDh163h5uEPVsj0bx5c8yZMwcJCQl2yXPu3Dl069YNs2bNYvmjh1y8eBEHDx5Ev379REchKypVqhTWb9iIb//xRqr+/ixEpvhZCHJekpyH8dHk5GT4+PggKSkJhQsXtkcucnBHLiYiJCIu159CU1JScOTIERw8eBA///wzChUqhMDAQDRs2BA1atSAWq0WlD5/tm3bhoULF2Lp0qW4nK594us2Go3YtWsX1qxZA7PZjB49eqBVq1bQarVWz7Nz504sWLAAq1at4uJ+eojFYkG7du2wYMEClC9fXnQcsrL4O+l4e+b+x37/zcRdKO9XGCVLlnzszcvLS9HLANq1a4etW7eKjmE3+elrLIBUYHqjGQkpBvh56+Du9uwyl5qaiqNHj+LgwYP46aefoNPp8Oabb6Jhw4aoWbOmw61fs1gs+Pzzz3H9+nXMmzcPOp0OwLNfd2JiItauXYsdO3bglVdeQd++fVGjRo3nziPLMhYsWIDTp09j8eLFcHd3f+7nJNeSvUv/o48+Eh2FbEBvNKP2lL1IyzRBlrNmITy1GkQPrIG7iQm4cePGY28pKSk5f16r1T6xJJYsWRL+/v42+YFVNBbAp2MBJGHS0tJw7NgxHDhwAGfOnIFWq0X9+vXRsGFD/Oc//xFaCJOSkjBgwAA0bdoUAwcOLPDz/PTTT1ixYgV++eUXtG7dGt27dy/QqJ3RaMTQoUNRunRpjBkzRtE/0dOTxcfH44MPPsD27dtdbv0t/Ssvsy9PYzAYcPPmzScWxZs3bz50H3Hhwk8eUSxZsiSKFSvmNB9jLIBPxwJIDiM9PR3Hjx/HgQMHcPr0abi5ueGNN95Aw4YNUatWLbi5udklx2+//YbBgwdjypQpqF+/vlWeMzMzEzt37sTatWshSRJ69OiBli1b5uk13bt3D3369EGPHj3QpUsXq+Qh1yLLMjp37oywsDBUqVJFdByysfzOvuSXLMtISUl5YlG8ceMGEhMTc3bXqlQqFC9e/KllUfQUNAvg07EAksPKyMjAiRMncODAAcTFxUGlUqFevXpo1KgRateubZPpii1btiA8PBxLly5FqVKlrP78AJCQkIA1a9YgOjoa1apVQ58+fVCtWrWHHpP9BT7t1lV8OPgDTJs2DXXq1LFJHnJe2R8ne7ZGIvHmdYwcOVJ0JFIYs9mM27dvP7UsipyC1hvNaN/1PWxZt8omRdkRsQCSS9Lr9Th58iQOHDiA2NhYAEDdunXRqFEj1KlTJ2eNXkFYLBZMnDgRiYmJmDNnjl3WwsiyjDNnzmD58uW4cOEC2rZti27duuG3u3LOFI/KZMAXnV5Gx/qv2jwPOZcHpwJVZgNW9A/E21X8Rccieip7TkE/z1S5M2MBJEUwGAw4deoUDhw4gJMnT0KWZdSpUweNGjVCvXr1ci2ED06hGNJT8f7776N58+Z4//337fgK/mUwGLB9+3ZEfLseP7/UDWaVGwAJEgBPnQaxY5sq5idYerbHNgOAHyfkOp53Ctq3hD8+2peGDKMFMv7dLKOEzw8WQFKkzMxMnDp1CgcPHsSJEydgNptRu3ZtNGrUCG+88UbOrtkHfzL0cJPg8/N3mDt6EOrVqyf4FTz9mIdDI95BgK+HgETkiA7EnkOfjX8/9vv8OCGledIU9IWrt7EmufJjj1XC50d++ppjnbtB9By0Wi0CAwMRGBgIIGvnbGxsLA4ePIi5c+fCZDKh5n9qI9JSB4b756amZ5oh1QhGjf/UFpj8X9mHbD96zIOfd8Gnt8k1JCUlYf369di8eTPKvFgehYq3ht4s8+OEFE2tVsPPzw9+fn6oXr06gKwR8i1POC6Hnx8PYwEkl+Xm5ob69evn7OQ1Go2I/uEUIvbc/fdBkgppmRYkpBgc4idDdzc1wnvWyhmh9NRmrV1x9WkLejKLxYL9+/dj5cqVSE5ORnBwMDZu3IhChQo9NJLNjxOif/HraN5wCpgUxVnWTtn6mAdybJcuXcKKFStw9OhRvPPOO+jVqxcCAgIeexw/ToieTomfH1wDSJSLB0dOJJMBS/vUQ+PXXhAdixQuNTUVkZGRiIyMhL+/P/r06YO33nqLh34TUZ6xABI9Q/ZPhj8dP4i9u3dh3rx5oiORAjw6IiHLMn744QesXLkSCQkJCAoKQufOneHl5SU6KhE5IW4CIXoGdzc1Anw9ENCqJXbt2I49e/bgv//9r+hY5MIeWrPnpsLb6gv4/dA2BAYGYsyYMXjppZdERyQiBWEBJMWbMWMG2rZti9q1a6No0aKi45AL0hvNCImIQ1qmCQCQlmnGfk0l/LhzFwrp7HPFIRHRg5zjNmciG/L09ERYWBiGDh0qOgq5qIQUA1INWRuPAACSBL0ZuJVmFJqLiJSLBZAIQL169fDiiy9i/fr1oqOQC8o+3/Hf/RwytJKF55IRkTAsgET3jRs3DkuXLsXVq1dFRyEXk30umac2a9WNl84N5a/uwY+xJwUnIyKl4i5gogf8+uuvGDNmDKKionj8Blndg7uAMzPS0LFjR6xevRqlS5cWHY2IXEB++hpHAIke8Morr+Cdd97BwoULRUchF5S9+9zdTY3ChQvjq6++Qv/+/ZGZmSk6GhEpDAsg0SM+/PBDfP/997hw4YLoKOTiXn75ZXzwwQfcgEREdscCSPQIlUqFL7/8EkOGDIHRyF2aZFvt27dHiRIl8M0334iOQkQKwgJI9ARly5ZF7969MXXqVNFRSAFCQ0Oxe/duHD9+XHQUIlIIFkCip+jWrRv++OMPnDp1SnQUcnEqlQrffPMNxowZgxs3boiOQ0QKwAJI9BSSJGH+/PkYNWoU0tPTRcchF+fj44Mvv/wS/fr146YQIrI5FkCiXPj6+mLEiBEYNWqU6CikAK+++ioGDBiAYcOGiY5CRC6OBZDoGVq0aAGLxYI9e/aIjkIK0LFjRxQpUgTLly8XHYWIXBgLIFEeTJ8+HWFhYbhz547oKKQAEyZMwPbt23HyJG8KISLbYAEkygNPT0+EhYXh448/Fh2FFECtVmPp0qUYNWoUbt68KToOEbkgFkCiPKpXrx4qVKiAdevWiY5CClCkSBEsWLAA/fv353mURGR1LIBE+fDZZ59h+fLluHr1qugopACvvfYa+vbti+HDh4uOQkQuhgWQKB/c3Nwwb948/O9//4PFYhEdhxSgc+fO8PT0xMqVK0VHISIXwgJIlE8vv/wyGjdujIULF4qOQgrx+eefY8uWLYiLixMdhYhcBAsgUQF8+OGH2LNnD87+8ivi76RDbzSLjkQuLHtTyIgRI5CQkCA6DhG5ABZAogJQqVToO2oa2q/8FW/P3I/aU/biyMVE0bHIhRUtWhTz5s1Dv379uCmEiJ4bCyBRAeiNZny2Ox4WtRYAkJZpQkhEHEcCyaaqVauG9957D59++qnoKETk5FgAiQogIcWAVIMJgAQAkGUg1WBCQopBbDByee+++y50Oh0iIiJERyEiJ8YCSFQAft46eOk0AGQAgCQBXjoN/Lx1YoORIkyZMgWRkZE4ffq06ChE5KRYAIkKwN1NjQVdX4fKYgIAeGo1CO9ZC+5uasHJSAnUajWWLVuG4cOHIzGRa0+JKP9YAIkK4MjFRHy07kdYVG7w0GaVwcCKxUXHIgXx9fXFnDlz0K9fP5hMJtFxiMjJsAAS5ZPeaEZIRBzSDFnfdDMyTfjw29PcAEJ2V6NGDXTv3h2jRo0SHYWInAwLIFE+ZW8Ake//WoaEtEwzWgd1x6effopdu3YhLS1NaEZSjq5du0KSJKxdu1Z0FCJyIhrRAYicjZ+3Du5qGXoTAEmCJGWtAdz+XQT+uPArYmJisGTJEmRmZqJOnTpo3Lgx6tWrB61WKzo6uaiwsDB07twZr776KmrWrCk6DhE5AUmWZflZD0pOToaPjw+SkpJQuHBhe+QiclhXr17Fux+NQ1L1d5FqMMNLl7UB5NE1gEajEbGxsYiJicHJkyehVqsRGBiIxo0bo2bNmlCpOABP1nP79m106dIFGzZsQLFixUTHISIB8tPXWACJ8sFsNqNDhw6YOXMmyr1UCQkphqwRwTzs/s3IyMCRI0cQExODn376Cd7e3mjYsCGaNGmCypUrQ5IkO7wCcmVnzpxBaGgoNm7cCI2GEzxESsMCSGQj06dPR9GiRTFw4MDnfq579+7h4MGDiImJwe+//w5/f380btwYTZo0QZkyZayQlpRo7dq1OHPmDGbMmCE6ChHZGQsgkQ3ExsZi1qxZ+Pbbb20yWnfjxg3s27cPMTEx+Oeff1ChQgU0adIE77zzDqf0KF+GDRuGunXrIjg4WHQUIrIjFkAiK0tNTUW7du3sur7q0qVLiImJwYEDB3Dnzh289tpraNKkCRo0aAAvLy+7ZCDnZDKZ0KlTJ0yePBnVq1cXHYeI7IQFkMjKBgwYgG7duqFx48ZC3r8syzh37hxiYmLwww8/QK/Xo3bt2mjSpAneeOMN7jCmx9y6dQvBwcGIjIyEr6+v6DhEZAcsgERWFBkZidjYWEybNk10lBwmkwmxsbHYt28fjh8/DpVKhTfffBNNmjRBzZo1oVbzSjoCTp8+jUmTJmHjxo38mCBSABZAIiu5cuUK+vfvj+3btzv0KFtGRgaOHj2Kffv24ccff4SXl1fODuMqVapwh7GCrV69GufPn0dYWJjoKERkYyyARFZgNpvRrl07zJkzB5UrVxYdJ1+SkpJw8OBB7Nu3D7/99hv8/PxydhiXLVtWdDyys6FDhyIwMBBdunQRHYWIbIgFkMgKpk6dipIlS6Jfv36iozy3mzdvYt++fdi3bx+uXLmCcuXK5ewwLl68+LOfgJya0WhEx44dERYWhmrVqomOQ0Q2wgJI9JxOnDiBefPmYc2aNS45fXr58mXs27cP+/fvR2Ji4kM7jL29vUXHIxtISEhA165dsXHjRhQtWlR0HCKyARZAoueQkpKCdu3aISoqShHfKGVZxvnz5xETE4NDhw4hIyMDtWrVytlhrNPpREckK4mNjcXUqVOxYcOG594Uojea83UTDhHZHgsg0XPo378/3nvvPTRs2FB0FCFMJhNOnz6NmJgYHDt2DJIk5ewwfv3117mb1MmtWLECf/zxB6ZMmVLg5zhyMREhEXFINZieehc2EdkfCyBRAa1btw5nz559rm+Orkav1+PYsWOIiYnB6dOn4enpiYYNG6Jx48Z45ZVXnjhFztEhxzZkyBA0bNgQnTt3zvef1RvNqD1lL9IyTZBlQJIAT60GsWOb8v81kWD56Wu8LZzovr///hvLly/H9u3bRUdxKO7u7njnnXfwzjvvAMj6AnPo0CF8/fXX+O2331C8eHE0btwYjRs3xosvvsjRISfwxRdfoEOHDnj55Zfx2muv5fnPpaenI3LXAaQa/h03kGUg1WBCQooBAb4etohLRDbAEUBSPL3RjGt30zC4bw98OW8OKlasKDqSU0lISMD+/fsRExODv65cxZ/VB8Ci0kCGxNEhB3bz5k1069YNUVFRcPf0fuKIbfb60F27duHQoUNQqVQIfLsRlt2thAyTDFkGIFvgodXg9Lhm/H9MJBingIny6MHRKp3KgmV963O06jnE30nH2zP3P/b7Oz+ojVdf9BeQiHJz8uRJjJ2/Ctcrts0ZsZ3VoTJS/ojF7t278c8//+DVV19FixYt0KBBAxQqVAjAw583nloVCv+0Htu+mcUjhYgEYwEkyoOctUwGE2RwLZM1PLY+DIBWZcHLv66Eu5sanTt3Rps2beDhwalCR6A3mlE9dCcyLVLWJ4BsgVo2YcRLt9G6ZfNcDw1/cJ3nH7+dx4gRIxAVFcX/t0QCsQCSSzGZTEhPT8/1LSMj45mPyczMfGjDgsHNGxcqd3/s/R0a8Q7XMj2Hp60BTExMRFRUFLZv347ChQsjKCgILVq0gLu7u+jIimI0GnH69GkcOHAAB2LP4deKXR97TEE+B/bt24fFixfj22+/5U5xIkFYAJ2Ms+6YNJvNBSpijz5Or9fnFLNHPxwlSYJGo4GHh8dDb4UKFXrs95709uDj3NzcHiqA3M1oO8/6mL5+/ToiIyOxe/dulChRAu+++y6aNm0KNzc3AWld24OF7/jx4zCZTKhVqxYaNWqEmrVq460vjljtc2Dt2rU4evQoFixY4JIHqBM5OhZAJ2KLHZNmsxkZGRkFKmOP/n62J30xV6vVBSpij75ptVph3yy4Y1W8K1eu4LvvvsPevXtRtmxZBAcHo1GjRhxFKiCj0Yi4uLicwmc2m1G7dm00atQI9erVe2zE1dqfAzNmzIDFYsGoUaOe96UQUT6xADqJx9dLydCqgE/K3USm/umFTa/XPzZSBvw7eqZSqQpcxh580+l0ivgp3llHYF3Rn3/+ie+++w4HDhxApUqVEBwcjMDAQKhUKtHRHFZ+C9+TWPNzQJZlfPzxx6hTpw569er1XM9FRPnDAugknrZjclxNEwJ8n17Y3N3d+Q2RXN5vv/2G9evX4/Dhw6hWrRqCg4NRt25dRfxQkhuj0YjY2NicwmexWPJd+GzNbDajR48eeP/999G0aVPRcYgUgwXQSXANGtGzybKMs2fPYt26dTh16hRq1aqF4OBg1KxZUxFl8NHCJ8tyTuGrW7euQxS+J8nIyECnTp0wbdo01KhRQ3QcIkVgAXQiXINGlHeyLCM2Nhbr16/HTz/9hPr166Nr16549dVXRUezmszMzJzCd+LECVgsFtSpU8fhC9+T3L59G126dMGKFSsQEBAgOg6Ry2MBdDJcg0aUfxaLBceOHcP69evx22+/oWHDhggODna6m1weLXzOMsKXV5cvX8b777+PyMhIFC1aVHQcIpfGAkhEimI2m3Ho0CGsW7cOf/31F5o2bYp3330XL774ouhoj8nMzMSpU6dw4MABnDx5ErIsPzTCp9PpREe0uri4OIwfPx4bN250+kJL5MhYAIlIsYxGI/bt24f169fjxo0baN68Obp06YLSpUsLyfNg4cse4atbt65LF74n2bVrFyIiIrBq1SpuYiOyERZAIiIABoMBu3fvxoYNG3D37l20bt0anTt3hp+fn83e56OFD0BO4atTp45iCt+TLF++HOfOncMXX3whOgqRS2IBJCJ6RHp6Onbu3InIyEhkZGSgXbt26NixI3x9fZ/reQ0Gw0NTugALX24mTZoEb29vDPpwCNc+E1kZCyARUS5SUlKwbds2REVFQZZldOzYEe3atXvo69vTNmex8D0fWZbR5cPPcLZIfRgsEk8/ILIiFkAiojy6d+8eNm/ejC1btkCr1aJz584o9uqb+Djyl/vHM6nxYQ0dbp07jJMnT0KSJNSrVy+n8Gm1WtEvwalknX+6B6l6EyBJkAB46nj+KZE1sAASERXArVu38F1kFL647AeLyi3rdHbZAjdJxpKWvgh8oy4L33N62g1I0YPr4pWyJQQkInId+elr3IpFRHRfiRIl0Da4FyxqbVb5AwBJBSPUeKnqf1j+rMDPWwcvnebfv14JcFfL+Oj99xAWFoaUlBSxAYkUggWQiOgBTyooXjoN/Ly5ts8a3N3UCO9ZC55aDYCs6y+X9nkDe3btxGuvvYagoCBMmTIFycnJgpMSuTZOARMRPYJXNNre0zbZyLKMHTt24Msvv0RgYCCGDBkCHx8fgUmJnAfXABIRPSde0SiWLMuIjo7G/Pnz8cYbb2Do0KEoUqSI6FhEDo1rAImInpO7mxoBvh4sf4JIkoRWrVohOjoab7zxBrp164bQ0FDcvXtXdDQil8ACSEREDkuSJLRo0QI7d+5EYGAgevTogXHjxuHOnTuioxE5NRZAIiJyeJIkoVmzZtixYwcaNmyIXr16YezYsbh9+7boaEROiQWQiIichiRJaNq0KbZv344mTZqgd+/eGD16NBITE0VHI3IqLIBEROR0JElC48aNsX37djRv3hx9+/bFyJEjcevWLdHRiJwCCyARETm1Ro0aYdu2bWjdujX69++PESNG4ObNm6JjETk0FkAiInIJb7/9NrZu3Yr27dsjJCQEw4YNw40bN0THInJIGtEBiIiIrOmtt97CW2+9haNHj2LQoEEoV64cPv30U5QqVUp0NCKHwYOgiYjIpR07dgwzZ85E2bJlMXLkSJQuXVp0JCKb4E0gREREjzhx4gRmzJiBF154AZ9++inKlCkjOhKRVbEAEhERPcWpU6cwY8YM+Pv7Y+TIkShbtqzoSERWwQJIRET0DHFxcZg+fTqKFy+OUaNGISAgQHQkoufCAkhERJRHP/74I6ZNm4aiRYti1KhRKFeunOhIRAXCAkhERJRPP/30E6ZNm4bChQtj1KhRKF++fM5/0xvNSEgxwM9bB3c3tcCURE/HAkhERFRAP//8M6ZNmwZPT0+MHj0a1y2FERIRh1SDCV46DcJ71kJgxeKiYxI9hgWQiIjoOZ07dw5Tp83AiRc6waJygwxAkgBPrQaxY5tyJJAcTn76Gm8CISIieoKqVati6tyFMN8vfwAgy0CqwYSEFIPQbETPiwWQiIjoCfbt24cBPd+FVjJDyvldGV46Dfy8dUIy6Y1mxN9Jh95oFvL+yXXwKjgiIqIH/Pzzz5gwYQIqVaqE775dg/O3zTlrALWwoHrScWjV/7V7riMXE7kWkayGawCJiIgA/P3335gwYQLUajVCQ0MfOiD6wV3A30aswv79+/HNN99Aq9XaJVu6PhO1p8Ygw2jhWkR6qvz0NY4AEhGRot25cwdTp07FX3/9hQkTJqBq1aqPPcbdTY0AXw8AQN++fVGsWDEEBwdj9erV8PLysmqWCxcu5Lz98ccf0Ov1MLkXQXqlbjmPe3AtYnYuovxgASQiIkXKyMjA/PnzsX//fowePRoNGzbM859t164dihYtiqCgIERERMDLp2iezwk0Go24dOnSQ0Xvxo0bkCQJRYoUQZUqVVClShV069YNlSpVQqFChaA3mlF7yl6kZZogywBkGV7ubsLWIpLz4xQwEREpitlsxqpVqxAREYFBgwahc+fOkCTp2X/wCX7++WeEhM5GUrVgpBstOWvz3nypGBITEx8qeX/++ScMBgM0Gg0qVKiQU/SqVKmCkiVLPjPDg2sA1RYjxjXyR5+W9QuUm1wTzwEkIiJ6hCzL2LlzJ+bMmYNOnTphwIABcHNze67n1BvN+M/n3yM90wRIKkCWobJk4pXfVsGvWNGHSt5LL70Ene75Ruyy1yIiIwkD+/fFjh07oFZzDSBl4RpAIiKiB5w4cQKff/456tSpg02bNsHb29sqz5uQYkC60ZJV/gBAkmBR67BoxVqbrM37dy2iBzp06IAlS5Zg0KBBVn8/5PpYAImIyGX98ccfCA0Nha+vL5YuXQp/f3+rPr+ftw5eOk3O2rzs3bn2WJs3cOBAtGrVCp06dbL66yLXxwJIREQu5+bNm5g0aRLu3buHiRMnolKlSjZ5P+5uaoT3rJWzNs9Tm7UG0B5Hs6hUKoSFhWHkyJFYsWKFzd8fuRYWQCIichkpKSn44osvEBcXh3HjxqFu3bo2f5+BFYsjdmzTPO8CtqbXX38dRYoUwb59+9C4cWO7vV9yfrwKjoiInJ7RaMTChQvRsWNH1KlTB1u3brVL+cuWvTZPxKHMkyZNwpQpU2Aw8H5iyjsWQCIiclqyLGPDhg1o0aIFPDw8sHv3brRu3brAx7o4o8KFCyMkJAQzZ84UHYWcCAsgERE5pYMHD6Jly5a4fPkytm/fjj59+ij2SJQuXbogLi4Oly5dEh2FnATXABIRkVM5e/YsJk6ciPLly2Pt2rXw9fUVHUk4SZIwc+ZMDB8+HBs3blTUCCgVDAsgERE5hStXrmDChAmQZRlffPEFXnzxRdGRHErFihVRs2ZNbNy4EUFBQaLjkINjASQiIod29+5dTJs2LedMvxo1aoiO5LBGjhyJli1bonnz5lY77JpcE9cAEhGRQ9Lr9Zg1axa6du2K5s2bIyoqiuXvGXQ6HcaOHYvx48eLjmI3eqMZ8XfSoTeaRUdxKiyARETkUMxmM1atWoXWrVujbNmyiI6O5hl3+dCkSRPcvn0bZ86cER3F5o5cTETtKXvx9sz9qD1lL45cTBQdyWmwABIRkUOQZRnR0dFo0aIFkpOTER0djeDgYKhU/FaVXzNmzMCoUaNgsVhER7EZvdGMkIg4pGWaAABpmSaERMRxJDCP+FlFRETCxcbGon379jh27Bg2btyIDz/8EFqtVnQsp1WyZEm0bdsWX3/9tegoNhN3/iJSDVl3MAOALAOpBhMSUnggdl5wEwgREQnz559/IjQ0FIULF8aSJUtQsmRJ0ZFcxgcffIBWrVqhY8eO8PPzEx3HauLj4zF16lTcTU6BR8UeyDDJkGVAkgBPrQZ+3jrREZ0CCyAREdldQkICJk+ejFu3bmHChAmoUqWK6EguR61WY+rUqRg1ahSWLVsmOs5zu3r1KsLCwpCQkIAxY8agZs2aOHIxESERcUg1mOCp1SC8Zy0h1/E5IxZAIiKym7S0NMyePRvHjx/HZ599hvr164uO5NJq1aoFLy8vHDhwAI0aNRIdp0Bu3LiBadOm4cqVKxg9ejRq166d898CKxZH7NimSEgxwM9bx/KXD5IsZ8+eP11ycjJ8fHyQlJSEwoUL2yMXERG5EKPRiGXLlmHDhg34+OOP0aZNG95WYSdJSUno1KkToqOjnWpd5a1btzBjxgz88ccfGDlyJH9YyIP89DVuAiEiIpuRZRlRUVFo0aIFNBoNdu3ahbZt27L82ZGPjw8GDBiAWbNmiY6SJ3fu3MGYMWPQr18/tG3bFps3b2b5swEWQCIisokffvgBrVq1wu+//45t27ahf//+0Gi48kiE4OBgnDhxApcvXxYd5anu3buH0NBQ9OzZE02bNsXWrVvx9ttvi47lsviZSEQkmN5oduo1TI/mP3/+PEJDQ1G2bFlERESgWLFioiMqniRJmDVrFoYPH47IyEiHGoFNTk7G/PnzcfjwYfzf//0fJkyY4FD5XBULIBGRQA/uYvTSZe1iDKxYXHSsPHt4F6YKL9/6Ad7p1zBz5kyUK1dOdDx6QKVKlVCtWjVs2rQJnTp1Eh0HaWlp+PLLLxETE4MhQ4Zg7NixLH52xE0gRESC6I1m1J6yB2kGM2QAEoBCbiqsC34RGilr/dyDbxaL5Zm/Z8/HZJplhP1WGJkWCTIkQLbAw02N0+ObO+VIphLo9Xq0atUKW7Zsgbe3t5AMGRkZWLRoEaKjozF48GB06NCBxc9K8tPXOAJIRGRFsiwjKSkJCQkJuHnzJhISEh56u3nzJgwGAyRJgsHNG6mVu//7ZwGkGy1YvHIdvKWsx2S/qVSqh379pN+z52MkSUK6rIHB8sBSckmFdJOMhBQDAnw97P+XT8/k7u6OUaNGYcKECfjiiy/s+r71ej2+/vprbNmyBQMHDsTu3bt5zZ9ALIBERM9gMBhw69ath0rcg6Xu7t27yJ5MkSQJRYoUgZ+fX85buXLlULduXfj5+aFEiRJwd3cHkD0CuBepBiMAKecmg9ljQ51iBE1vNGPhlL1IyzTxJgYn0qxZM6xatQo///wzqlevbvP3l5mZmXMEUL9+/bB7926o1Y7/8e3qOAVMRIojyzLu3bv31BG6hIQEGI3GnMdqtVr4+fnB39//oWKX/XtFihQp8BTWkYuJ6Lf8GAwWldOvAXTG/Ep17do19O/fHzt27LDZKJzRaMSqVauwdu1a9OrVCz179uQucBvLT19jASQil6DX63NG6Z5U7O7evQsAOUWtaNGiD5W4B0tdiRIloNPZbxTr2+8icSMpA4P6dHeKkb9HOfsuZqVasGAB3N3dMWDAAKs+r8lkwtq1a7Fy5Up069YNvXv3hpubm1XfBz0Z1wASkV3ZogBYLBbcvXv3qSN0CQkJMJlMOVOvOp3usSL30ksv5fyej4+Pwy40L+LtibuJCU5bntzd1Fzz54QGDx6Mli1bokOHDihRosRzP5/ZbMb69euxdOlSBAUFYefOnXb9QYryhwWQiJ5LfqYA9Xp9rpsjkpKSACBnk8Gjo3QVK1bEm2++mTNK50zXWuXG09MTaWlpomOQwqjVakyZMgWjRo3C0qVLC/w8FosFGzduRHh4ONq1a4cdO3bkrHMlx8UCSEQFpjeaERIRhzSDCQCQZjCi77JjCFKdwu1bN3Hr1q2HRukKFSr02Bq6ypUr5/x74cKFHXaUzpZYAEmUOnXqYOXKlTh06FC+b92QZRlbtmzBV199hRYtWmDr1q3w8OBIsLNgASSiAou/lYTU++UPAGRIyJQlvN2iHWq89AKKFy/OtT954OnpidTUVNExSKEmT56Mzp07Izo6Ok+j6rIsY+fOnZg/fz7eeecdbNq0CV5eXnZIStbEA3iIKN9kWUZUVBQG9gqGu1pG9qCdJAFeOg0a1XsdpUqVYvnLIy8vL44AkjBFihRBv379MHv27FwfJ8syvv/+e7Rq1QqnT5/Ghg0bMGrUKJY/J8UCSET5cv78eXTo0AHnz59H9PatWNrnDXhqsyYTPLVZawCddTODKJwCJtG6d++Oo0eP4q+//nrif9+/fz/atGmDw4cP49tvv8W4ceN4KoiT4xQwEeXJvXv3MHHiRNy6dQsLFixAQEAAACCwYiHEjm3KY0CeAwsgiSZJEmbOnInhw4cjYu06JKRmws9bh9gTxzB9+nRUrVoVq1atQrFixURHJSthASSiXFksFixfvhzffvstPvvsMzRq1Oixx/AYkOej1WpzDp4mEqVKlSooUqUeak7aBb1ZgsqciUD5PJYuXQo/Pz/R8cjKOAVMRE91/PhxtGzZEnq9Hrt27Xpi+SMi16A3mnHcrRr09/d1yWotfvSsjcJFOernijgCSESPuXHjBsaMGQN3d3esWbMGxYvzai8iV5eQYkCqwYzsXV0ygFSDCQkpBo7wuyAWQCLKkZmZifnz52P//v2YPHkyXn/9ddGRiMhO/Lx18NJpkJZpgixn9UBPrQZ+3rzNwxVxCpiIAAC7du1Cy5YtUbp0aWzfvp3lj0hh3N3UCO9Zi7v6FYIjgEQK9+eff2L06NGoWLEitmzZwjO9iBQssGJx7upXCBZAIoVKTU1FWFgYfv/9d4SFhaFixYqiIxGRA+CufmXgFDCRwsiyjG+//Rbt27dHYGAgNmzYwPLnADQaDY+CISK7YQEkUpAzZ86gTZs2+OeffxAdHY1WrVqJjkT38TBoIrInTgETKcDt27cxfvx4ZGRk4JtvvkGpUqVER6JHZBfAIkWKiI5CRArAAkjkwkwmE5YsWYItW7ZgwoQJqF+/vuhI9BQcASQie+IUMJGLOnjwIFq2bAmtVoudO3ey/Dk4FkAisieOABK5mCtXrmD06NEoXrw4NmzYwClFJ8ECSET2xAJI5CL0ej1mzZqFkydPIiwsDK+99proSJQPXl5eLIBEZDecAiZycrIsY8uWLWjVqhVeffVVbNmyheXPCXEEkIjsiSOARE7s119/xejRo/H6669j+/bt8PDg4a3OigWQiOyJBZAAAHqjmVf/OJGkpCRMmjQJ169fx7x58/Diiy+KjkTPydPTE7dv3xYdg4gUggWQcORiIkIi4pBqMMFLl3X5d2DF4qJj0RNYLBasXLkSa9aswZgxY9C4cWPRkchKOAJIRPbENYAKpzeaERIRh7RMEwAgzWBCSEQs9Eaz4GT0qJMnT6JVq1ZITU3Frl27WP5cjJu7B66nGPm5R0R2wRFAhUtIMSDVYMr5tQwg1WBG++Be0BpT4OHhgYCAALz44osPvfn4+IgLrTA3b97E2LFjoVarsXr1apQoUUJ0JLKyIxcTMWDHLaQbq2HXlL0chScim2MBVDg/bx28dBqkZZogy4AkAZ5aDbasXw13NzXS0tIQHx+Pv//+G/Hx8Th+/Dj+/vtvJCUlAci6wP6FF154rCD6+flBpeIA8/MwGo1YsGAB9uzZg8mTJ6NWrVqiI5ENZI/CZxhlAEBapgkhEXGIHduU63GJyGZYABXO3U2N8J61ctYAemqz1gBmf+Px9PTEK6+8gldeeeWJf95oNOLq1av4+++/8ffff2PPnj34+++/cfPmTchy1jc0Pz+/xwpimTJl4ObmZrfX6Wz27NmD6dOno0+fPti5cyckSRIdiWzksVF4GUg1mJCQYkCAL3d1E5FtsAASAisWR+zYpgXaBezm5oZy5cqhXLlyT/zvsiwjISEhpyDGxsYiKioK//zzD4xGIwDA29v7sYL44osvwtPT0xovz6lcunQJo0ePRvny5bFp0yZ4e3uLjkQ29ugoPCBDI5tRwpM/IBGR7Uhy9jBNLpKTk+Hj44OkpCQULlzYHrlIQZKTk3MK4oNv6enpAACtVouyZcs+VhCLFSvmMiNjaWlpmDZtGs6fP4+wsDBUrlxZdCSyo0d34rctch0JZ39AeHg4NBr+nE5EeZOfvsYCSA7PYDDgypUrjxXE27dvQ5ZlqFQqlCpV6rGCWLp0aajVjr2GSpZlfPfdd1iyZAk++eQTtG7dWnQkEuTRszgjIyOxfv16rFq1CoUKFRIdj4icAAsgKYrZbMaNGzceK4jXrl2D2Zx1pIavr+9jBTEgIADu7u7Ccv/8888YM2YMGjRogKFDh0Kn0wnLQo4pJiYGs2fPxpo1a1CkSBHRcYjIwbEAEj1AlmXcuXMnZzdz9lt8fDwMBgNkWX7qcTe2+KZ7584djB8/HikpKZg6dSpeeOEFq78Pch2xsbEYPXo0Vq9ejZIlS4qOQ0QOjAWQKJ8ePe4muyQ+etzNoyXR39//mcfdZE/tFffQYNWKZYiKikJoaCgCAwPt8dLIBVy4cAGDBg3C119/jZdeekl0HCJyUCyARFb26HE32SXx0eNuHi2I8ZmF8OG6n5FqMEFlMiC4TAomf9jT4dcmkuP5559/0Lt3b8yePRs1atQQHYeIHBALIJGdPXrczd9//43L8f8g2r0hLCoNIKkgAfDUaXjALxXY7du30aNHD4wdOxYNGjQQHYeIHEx++hrPFyCyAkmS4O/vD39/f9StWxcAEH8nHTtm7s95TNY1ezzglwquWLFiiIyMRK9evXDv3j20bdtWdCQiclK8q4vIRrIP+M0+qlCSAC+dBn7e3O1LBefl5YX169fju+++w4oVK0THISInxQJIZCPZ1+x5arMG2h+9Zo+ooLRaLVauXIm4uDjMmjVLdBwickJcA0hkY48e8EtkLbIsY9KkSUhPT8e0adNc5mYcIiqY/PQ1jgAS2Zi7mxoBvh4sf2R1kiQhNDQUL774IgYOHAiTySQ6EhE5CRZAIiInN3jwYDRt2hQ9evSAXq8XHYeInAALIBGRCwgODkb//v0RFBSUc4A5EdHT8BgYIiIX0axZM/j4+CAoKAgRERHw9/cXHYmIHBRHAImIXEi9evUwf/58dOvWDZcvXxYdh4gcFAsgEZGLeeWVV7BixQq8//77OHv2rOg4ROSAWACJiFxQQEAA1q9fj+HDh+Pw4cPQG82Iv5MOvdEsOhoROQCuASQiclHFixdHZGQk2od8imu7kqA3Z91GE96zFgIrFhcdj4gE4gggEZELc3P3QELl9tCbss78T8s0ISQijiOBRArHAkhE5MISUgxINZiRfSm1LAOpBhMSUgyCkxGRSCyAREQuzM9bBy+dJrv/QZKypoH9vHVigxGRUCyAREQuzN1NjfCeteCpzVry7anNWgPIqwmJlI2bQIiIXFxgxeKIHdsUCSkG+HnrWP6IiAWQiEgJ3N3UCPD1EB2DiBwEp4CJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhWACJiIiIFIYFkIiIiEhhNHl5kCzLAIDk5GSbhiEiIiKigsnuadm9LTd5KoApKSkAgLJlyz5HLCIiIiKytZSUFPj4+OT6GEnOQ020WCy4du0avL29IUmS1QISERERkXXIsoyUlBSULl0aKlXuq/zyVACJiIiIyHVwEwgRERGRwrAAEhERESkMCyARERGRwrAAEhERESkMCyARERGRwrAAEhERESkMCyARERGRwvw/LzOR7paNq94AAAAASUVORK5CYII=",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -440,19 +140,18 @@
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Mit Bottleneck 2324.2179329830496: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 2828.4287157360004: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 2947.25499405803: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3040.6546992383073: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3092.3421544195267: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3148.7295850866585: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3176.0077140964254: Unzusammenhängender Graph!\n",
-      "Mit Bottleneck 3179.88254500068: Unzusammenhängender Graph!\n"
+      "The bottleneck 1906.4713478046294 created an unconnected graph!\n",
+      "The bottleneck 2234.9715881863017 is infeasible!\n",
+      "The bottleneck 2326.553244608857 is infeasible!\n",
+      "The bottleneck 2448.588368836216 is infeasible!\n",
+      "The bottleneck 2456.9747658451847 is infeasible!\n",
+      "The bottleneck 2545.9006264974287 is infeasible!\n",
+      "The bottleneck 2557.4512703079995 is infeasible!\n"
      ]
     },
     {
      "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 800x600 with 1 Axes>"
       ]
@@ -469,76 +168,6 @@
     "edges = solver.solve()\n",
     "draw_edges(edges)"
    ]
-  },
-  {
-   "attachments": {},
-   "cell_type": "markdown",
-   "id": "c9146e88-1246-4805-b0fd-a6d2a74717dd",
-   "metadata": {},
-   "source": [
-    "## Code zum Speichern und Laden von Instanzen"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 8,
-   "id": "1d230be6-9e2a-461a-b7cc-dfceb699a0da",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "import json  # JSON\n",
-    "import atomicwrites  # Damit bei Abstürzen/Interrupts/Power Outage/... die Dateien konsistent bleiben.\n",
-    "                     # Wichtig vor allem, wenn man eine Art Datenbankdatei hat,\n",
-    "                     # die wiederholt geladen, modifiziert und gespeichert wird.\n",
-    "                     # Lässt sich über conda oder pip install atomicwrites installieren.\n",
-    "import os"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 9,
-   "id": "bb51ce73-a7f9-431a-9c12-8a2cfa40d613",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "def save_instance(file_or_path, points, metadata):\n",
-    "    if isinstance(file_or_path, (str, os.PathLike)):\n",
-    "        with atomicwrites.atomic_write(file_or_path, overwrite=True) as open_file:\n",
-    "            save_instance(open_file, points, metadata)\n",
-    "    else:\n",
-    "        json_data = {'format': 'alg-tp-points', 'meta': metadata, 'points': points}\n",
-    "        json.dump(json_data, file_or_path)\n",
-    "        \n",
-    "def load_instance(file_or_path):\n",
-    "    if isinstance(file_or_path, (str, os.PathLike)):\n",
-    "        with open(file_or_path, 'r') as f:\n",
-    "            return load_instance(f)\n",
-    "    json_data = json.load(file_or_path)\n",
-    "    if json_data.get('format', None) != 'alg-tp-points':\n",
-    "        raise ValueError(\"Not an instance file!\")\n",
-    "    return {'meta': json_data.get('meta', {}), 'points': [(x,y) for x,y in json_data['points']]}"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 10,
-   "id": "dd75e5a6-ed91-471c-be28-c91cb9335f56",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "save_instance('test_instance.json', points, {'test_size': 40})"
-   ]
-  },
-  {
-   "cell_type": "code",
-   "execution_count": 11,
-   "id": "c7ca8a98-c8f3-4d8d-9547-cb0d851c268d",
-   "metadata": {},
-   "outputs": [],
-   "source": [
-    "instance = load_instance('test_instance.json')\n",
-    "metadata, points = instance['meta'], instance['points']"
-   ]
   }
  ],
  "metadata": {
@@ -557,7 +186,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.6"
+   "version": "3.11.3"
   }
  },
  "nbformat": 4,
diff --git a/sheets/03_card_sat/DBST/dbst_sat/__init__.py b/sheets/03_card_sat/DBST/dbst_sat/__init__.py
new file mode 100644
index 0000000000000000000000000000000000000000..b662972b879be9786258797a7f40c47f4c29068b
--- /dev/null
+++ b/sheets/03_card_sat/DBST/dbst_sat/__init__.py
@@ -0,0 +1,5 @@
+from .util import Node, Edge, draw_edges
+
+from .greedy import GreedyDBST
+
+from .solver import DBSTSolverSAT
\ No newline at end of file
diff --git a/sheets/03_card_sat/DBST/dbst_sat/greedy.py b/sheets/03_card_sat/DBST/dbst_sat/greedy.py
new file mode 100644
index 0000000000000000000000000000000000000000..ae4872f5245e1a9edf3a2453365929e7105d8b41
--- /dev/null
+++ b/sheets/03_card_sat/DBST/dbst_sat/greedy.py
@@ -0,0 +1,50 @@
+from .util import all_edges_sorted
+import math
+
+class GreedyDBST:
+    """
+    Solve DBST using a greedy heuristic, similar to Kruskal's algorithm for MST.
+    Sort all edges of the graph, iteratively pick the shortest viable edge
+    (That does not create a cycle or violates the degree constraint of a node)
+    and add it to the tree, until all nodes are connected (n-1 edges needed).
+    The connected components are managed in a 'disjoint-set' or 'union-find'
+    datastructure, which is used to efficiently check whether two vertices are
+    partof the same component (adding an edge would create a cycle).
+    """
+    def __init__(self, points, degree):
+        self.points = points
+        self.all_edges = all_edges_sorted(points)
+        self._component_of = {v: v for v in points}
+        self.degree = degree
+        
+    def __component_root(self, v):
+        cof = self._component_of[v]
+        if cof != v:
+            cof = self.__component_root(cof)
+            self._component_of[v] = cof
+        return cof
+        
+    def __merge_if_not_same_component(self, v, w):
+        cv = self.__component_root(v)
+        cw = self.__component_root(w)
+        if cv != cw:
+            self._component_of[cw] = cv
+            return True
+        return False
+    
+    def solve(self):
+        edges = []
+        degree = {v: 0 for v in self.points}
+        n = len(self.points)
+        m = 0
+        for v,w in self.all_edges:
+            if degree[v] < self.degree and degree[w] < self.degree:
+                if self.__merge_if_not_same_component(v,w):
+                    edges.append((v,w))
+                    degree[v] += 1
+                    degree[w] += 1
+                    m += 1
+                    if m == n-1:
+                        print(f"Greedy bottleneck: {math.dist(v,w)}")
+                        break
+        return edges
\ No newline at end of file
diff --git a/sheets/03_card_sat/DBST/dbst_sat/solver.py b/sheets/03_card_sat/DBST/dbst_sat/solver.py
new file mode 100644
index 0000000000000000000000000000000000000000..67211147ef497ec6a07c43f12bd0d1d363e2382c
--- /dev/null
+++ b/sheets/03_card_sat/DBST/dbst_sat/solver.py
@@ -0,0 +1,161 @@
+from pysat.solvers import Solver
+import networkx as nx
+import math
+
+from .util import Node, Edge, Iterable, List, Set, Optional, all_edges_sorted
+
+class DBSTSolverSAT:
+    def __make_edge_variables(self):
+        """
+        Create mappings from edges to corresponding variables and back.
+        """
+
+        # Map every undirected edge to an integer >= 1. This integer is both
+        # used for encoding SAT clauses and for fetching the index/position
+        # in the sorted edges (+1). The latter is important when handling the
+        # bottleneck
+        self.edge_to_var = {edge: i for i, edge in enumerate(self.all_edges, start=1)}
+
+        # other way around
+        self.var_to_edge = {v: e for e, v in self.edge_to_var.items()}
+
+        # as edges are undirected, the swapped version of the edge should point to the same variable
+        self.edge_to_var.update({(w,v): i for (v,w), i in self.edge_to_var.items()})
+        
+    def __add_degree_constraints(self):
+        """
+        Add constraints that assure 1 <= |N(v)| <= d for all v in V.
+        """
+        for v in self.graph.nodes:
+            edge_vars = [self.edge_to_var[v,w] for w in self.graph.neighbors(v)]
+            self.solver.add_clause(edge_vars)  # at least one edge must be selected
+            self.solver.add_atmost(edge_vars, self.degree)  # at most d can be selected
+    
+    def __add_edge_count_constraint(self):
+        """
+        Add constraint that exactly n-1 edges are selected.
+        """
+        positive_edges = [self.edge_to_var[e] for e in self.all_edges]
+        negative_edges = [-v for v in positive_edges]
+        n = len(self.points)
+        self.solver.add_atmost(positive_edges, n-1)  # at most n-1 edges
+        self.solver.add_atmost(negative_edges, len(self.all_edges) - (n-1))  # at most |E| - (n-1) non-edges
+    
+    def __init__(self, points: Iterable[Node], degree: int, solver: str = "Gluecard4", solution: List[Edge] = None):
+        """
+        Initialize the solver.
+        :param points: The set of points as (x,y)-tuples.
+        :param degree: The maximum degree of a node.
+        :param solution: Optional parameter. Either 'None' or a valid starting solutin (as list of edges).
+        """
+        self.points = set(points)
+        self.degree = degree
+        self.all_edges = all_edges_sorted(points)
+        self.graph = nx.Graph(self.all_edges)
+        self.best_solution = solution
+        self.solver = Solver(solver, with_proof=False)
+        self.__make_edge_variables()
+        self.__add_degree_constraints()
+        self.__add_edge_count_constraint()
+
+    def __del__(self):
+        """
+        The solvers from python-sat need a special cleanup,
+        which is not necessary for normal Python code.
+        There seem to occur resource leaks when you leave this out,
+        so it should be sufficient to let the solvers clean up at the garbage collection.
+        """
+        self.solver.delete()
+
+    def __threshold_assumptions(self, threshold: int):
+        """
+        Create list of assumptions, which deactivate all edges longer than the
+        edge at a given threshold index.
+        """
+        return [-self.edge_to_var[e] for e in self.all_edges[threshold+1:]]
+    
+    def __handle_components(self, components):
+        """
+        Add 'lazy constraints' for solutions which feature more than one connected component.
+        This forces the solver to select at least one edge that leaves the component
+        for every component in the graph.
+        """
+        for component in components:
+            crossing_edges = []
+            vset = set(component)
+            for v in component:
+                for w in self.points - vset:
+                    crossing_edges.append(self.edge_to_var[v, w])
+            self.solver.add_clause(crossing_edges)
+
+    def __solve_with_threshold(self, threshold: int) -> Optional[int]:
+        """
+        Solves the decision problem:
+        'Does there exist a spanning tree with degree constraint self.degree,
+        such that no edge in the tree is longer than the edge at self.all_edges[threshold]'?
+
+        This method returns 'None' if no valid solution is found.
+        Otherwise, the highest utilized edge index is returned.
+        """
+
+        # Create so called 'assumptions', which force the solver to deactivate all
+        # edges longer than the given threshold index edge.
+        assumptions = self.__threshold_assumptions(threshold)
+        while True:
+            if not self.solver.solve(assumptions=assumptions):
+                print(f"The bottleneck {math.dist(*self.all_edges[threshold])} is infeasible!")
+                return None
+            edges = self.__model_to_solution()
+            #draw_edges(edges)
+            #plt.show()
+            edge_set = set(edges)
+            g = self.graph.edge_subgraph(edges)
+            components = list(nx.connected_components(g))
+            if len(components) > 1:
+                self.__handle_components(components)
+            else:
+                threshold = self.__max_index(edges)
+                print(f"New best bottleneck: {math.dist(*self.all_edges[threshold])}!")
+                self.best_solution = edges
+                return threshold
+    
+    def __model_to_solution(self) -> List[Edge]:
+        """
+        Turn a valid SAT-assignment (solution) to a list of edges.
+        """
+        model = self.solver.get_model()
+        return [self.var_to_edge[lit] for lit in model if lit > 0]
+    
+    def __index_of_solution_with_threshold(self, threshold: int) -> Optional[int]:
+        """
+        Return the index of the longest used edge in the solution.
+        If the solution is invalid (graph unconnected), 'None' is returned.
+        """
+        g = self.graph.edge_subgraph(self.all_edges[:threshold + 1])
+        if not nx.is_connected(g):
+            print(f"The bottleneck {math.dist(*self.all_edges[threshold])} created an unconnected graph!")
+            return None
+        return self.__solve_with_threshold(threshold)
+
+    def __max_index(self, solution: List[Edge]):
+        """
+        Return the index of the longest edge in a given solution.
+        """
+        return max((self.edge_to_var[e] - 1 for e in solution))
+        
+    def solve(self):
+        """
+        Binary search for the shortest bottleneck edge under degree constraint self.degree
+        """
+        lb = len(self.points) - 2  # The largest index that we know of to be essential
+        ub = len(self.all_edges) - 1  # The smallest valid bottleneck we found
+        if self.best_solution is not None:
+            ub = self.__max_index(self.best_solution)
+        while lb < ub - 1:
+            mid = (lb + ub) // 2  # Integer division in Python: //
+            actual_index = self.__index_of_solution_with_threshold(mid)
+            if actual_index:
+                ub = actual_index
+            else:
+                lb = mid
+        return self.best_solution
\ No newline at end of file
diff --git a/sheets/03_card_sat/DBST/dbst_sat/util.py b/sheets/03_card_sat/DBST/dbst_sat/util.py
new file mode 100644
index 0000000000000000000000000000000000000000..30d7e8643c1815932114eab0071b7348e349f6ee
--- /dev/null
+++ b/sheets/03_card_sat/DBST/dbst_sat/util.py
@@ -0,0 +1,39 @@
+from typing import List, Set, Tuple, Iterable, Optional
+import matplotlib.pyplot as plt
+import networkx as nx
+import itertools
+
+Node = Tuple[int, int]
+Edge = Tuple[Node, Node]
+
+def squared_distance(p1: Node, p2: Node):
+    """
+    Calculate the squared euclidian distance between two points p1, p2.
+    """
+    return (p1[0]-p2[0])**2 + (p1[1]-p2[1])**2
+
+def all_edges_sorted(points: Iterable[Node]) -> List[Node]:
+    """
+    Create a list containing all edges between each two points of the given
+    point set/list and returns them in sorted, ascending order. 
+    """
+    edges = [(v,w) for v, w in itertools.combinations(points, 2)]
+    edges.sort(key=lambda e: squared_distance(*e))  # *e is like e[0], e[1]
+    return edges
+
+def draw_edges(edges):
+    """
+    Draws the list of edges as a graph using networkx. The bottleneck
+    edge is highlighted using a thicker stroke and red color.
+    """
+    draw_graph = nx.Graph(edges)
+    g_edges = draw_graph.edges()
+    max_length = max((squared_distance(*e) for e in g_edges))
+    color = [('red' if squared_distance(*e) == max_length else 'black') for e in g_edges]
+    width = [(1.0 if squared_distance(*e) == max_length else 0.5) for e in g_edges]
+    plt.clf()
+    fig, ax = plt.gcf(), plt.gca()
+    fig.set_size_inches(8,6)
+    nx.draw_networkx(draw_graph, pos={p: p for p in draw_graph.nodes}, node_size=8,
+                     with_labels=False, edgelist=g_edges, edge_color=color, width=width, ax=ax)
+    plt.show()
\ No newline at end of file