diff --git a/sheets/03_card_sat/DBST/README.md b/sheets/03_card_sat/DBST/README.md
index c1c557498be38b456368e7e6176a874bfcdd3d71..64d636733a4563fb897367beb7433e15af991d15 100644
--- a/sheets/03_card_sat/DBST/README.md
+++ b/sheets/03_card_sat/DBST/README.md
@@ -57,29 +57,31 @@ Using a cardinality constraint, this is straight-forward:
 
 ### Spanning tree
 
-Abschließend müssen wir noch erzwingen, dass der durch $E'$ aufgespannte Graph ein Baum ist.
-Wir wollen also sicherstellen, dass der Graph zusammenhängend und kreisfrei ist.
-
-Dazu beobachten wir, dass alle Bäume auf $n$ Knoten genau $n-1$ Kanten haben.
-Wir können also die Kardinalitätsbedingungen 
-\[\sum\limits_{e \in E(x)} x_e \leq n-1\text{ und } \sum\limits_{e \in E(x)}\bar{x}_e \leq |E(x)| - n + 1\]
-einführen, um sicherzustellen, dass die gewählte Kantenmenge genau $n-1$ Kanten enthält.
-Außerdem gilt, dass Graphen mit $n-1$ Kanten genau dann kreisfrei sind, wenn sie zusammenhängend sind.
-
-Daher brauchen wir nur eine dieser Eigenschaften zu modellieren.
-Es gibt grundsätzlich verschiedene Möglichkeiten, Zusammenhang zu modellieren; siehe dazu auch den Abschnitt \nameref{sec:aufgaben}.
-
-Die einfachste Methode, die wir in unserem Beispiel verwenden, funktioniert wie folgt.
-Für jede echte, nicht-leere Teilmenge $S \subsetneq V$ der Knoten fügen wir eine Klausel hinzu,
-die sicherstellt, dass wenigstens eine Kante von einem Knoten in $S$ zu einem Knoten in $V \setminus S$ führt:
-\[ \forall \emptyset \subsetneq S \subsetneq V: \bigvee\limits_{v \in S, w \notin S} x_{vw}. \]
-Es gibt allerdings exponentiell viele solche Teilmengen $S$.
-Daher ist es keine Option, diese einfach alle bei der Erzeugung der SAT-Formel hinzuzufügen.
-In der Hoffnung, dass nur wenige dieser Teilmengen tatsächlich benötigt werden,
-kann man allerdings wie folgt vorgehen.
-Man löst zunächst ohne solche Bedingungen.
-Falls dabei eine nicht zusammenhängende Lösung herauskommt, kann man die Zusammenhangskomponenten $V_1,\ldots,V_k$ dieser Lösung bestimmen.
-Für jede Zusammenhangskomponente $S \in \{V_1,\ldots,V_k\}$ kann man dann eine Klausel der obigen Form hinzufügen, um sie in Zukunft zu verbieten, und daraufhin erneut lösen.
-Dies wiederholt man so lange, bis eine zusammenhängende Lösung gefunden wird oder keine Lösung mehr existiert;
-das geht in der Regel relativ schnell, weil der SAT-Solver einige Informationen zwischen den einzelnen Aufrufen zwischenspeichert.
+Finally,  we  have to enforce that the graph induced by $E'$ is a spanning tree on $V$.
+Thus, we want to ensure that the graph is connected and free of cycles.
 
+A fundamental observation is that every tree on $n$ vertices has exactly $n-1$ edges.
+Thus, we can define the cardinality constraint
+```math
+\sum\limits_{e \in E(b)} x_e \leq n-1\text{ und } \sum\limits_{e \in E(b)}\bar{x}_e \leq |E(b)| - n + 1
+```
+to deal with that.
+
+Additionally, it is well known that a graph with $n$ vertices and $n-1$ edges is free of cycles if and only if it is connected.
+Instead of prohibiting cycles we can alternatively enforce the graph to be connected.
+In general, there are multiple options to model connectivity.
+
+The simplest method, we are going to use in this example, is as follows.
+For every real and non-empty subset $S \subsetneq V$ of vertices, we introduce a clause that enforces to have at least on edge connecting $S$ with $V\setminus S$.
+```math
+ \forall \emptyset \subsetneq S \subsetneq V: \bigvee\limits_{v \in S, w \notin S} x_{vw}.
+```
+
+Unfortunately, there are exponentially many such subsets $S$ and it is no option to just add all of them directly to the SAT-formula.
+However, only a small amount of these subsets will  actually be relevant and we can instead do  the following:
+Start without these constraints and look onto the assignment returned by the SAT-solver.
+If is is connected, we are fine.
+If it is not connected, we can easily add the clause for any connected component $S \in \{V_1,\ldots,V_k\}$  in the solution and run the SAT-solver again.
+We can repeat this until the returned solution is connected or the SAT-solver tells us that the formula has become infeasible.
+This may sound inefficient but many SAT-solvers allow incremental formula building and will save the insights the gained on the previous formula.
+No assignment that has already been discarded by the previous runs can become feasible ever again, making solving the slightly refined formula (often) very fast to solve.
diff --git a/sheets/03_card_sat/DBST/cardinality_sat.ipynb b/sheets/03_card_sat/DBST/cardinality_sat.ipynb
new file mode 100644
index 0000000000000000000000000000000000000000..dd4160f28c34b41de9b51c2f91f67eba9f8d21d7
--- /dev/null
+++ b/sheets/03_card_sat/DBST/cardinality_sat.ipynb
@@ -0,0 +1,556 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "1b7a9cd7-d806-4be8-a41a-fe4f11d109ff",
+   "metadata": {},
+   "source": [
+    "## Import von Python-Paketen\n",
+    "Installiert sein sollten `python-sat`, `networkx` und `matplotlib`,\n",
+    "sonst wird es im folgenden zu Fehlern kommen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "28cb4208-79a4-46f0-9dd7-fab8b9751b94",
+   "metadata": {},
+   "source": [
+    "## Hilfsroutinen\n",
+    "Zur Generierung von Instanzen und Erzeugung/Sortierung der Kantenmenge."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "a9a0b9a0-2559-403c-8597-f589b68db83e",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def random_points(n, w=10_000, h=10_000):\n",
+    "    \"\"\"\n",
+    "    n zufällige Punkte mit ganzzahligen Koordinaten in einem w * h-Rechteck.\n",
+    "    :param n: Anzahl der Punkte\n",
+    "    :param w: Breite des Rechtecks.\n",
+    "    :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"
+   ]
+  },
+  {
+   "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, edges=g_edges, edge_color=color, width=width, ax=ax)\n",
+    "    plt.show()"
+   ]
+  },
+  {
+   "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"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "febaee00-7379-4ea0-abd7-2f328eeb7364",
+   "metadata": {},
+   "source": [
+    "## Ausführung des Solvers\n",
+    "Hier generieren wir 40 zufällige Punkte und lassen den Solver mit einer Gradschranke von 3 darauf laufen."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "bc4a9583-41d0-4d94-86c9-bfef164d5700",
+   "metadata": {
+    "tags": []
+   },
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Neues bestes Bottleneck: 5269.649419079034!\n",
+      "Neues bestes Bottleneck: 3517.966031672279!\n",
+      "Neues bestes Bottleneck: 2501.2087078050886!\n",
+      "Mit Bottleneck 2034.0651415330829: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2295.409767340028: Unzusammenhängender Graph!\n",
+      "Neues bestes Bottleneck: 2386.593388074307!\n",
+      "Mit Bottleneck 2319.200293204535: Unzusammenhängender Graph!\n",
+      "Neues bestes Bottleneck: 2327.513050446764!\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAAFUCAYAAACp7gyoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABSPUlEQVR4nO3dZ0BU19YG4PcwQ1OUohgRC2JDxQ5WUKOxxIKxoTFYEhNvNFhAighIEUWKYIwmphhvbFHsgoXYERtYUDGKIhJUoqJ0BKad7wdXPhsKMjN7ynr+OTPMeU1k1ux99l6b43kehBBCCHk3HdYBCCGEEHVABZMQQgipBiqYhBBCSDVQwSSEEEKqgQomIYQQUg1UMAkhhJBqEL7ryYYNG/JWVlZKikIIIYSwd+nSpac8z5u//vg7C6aVlRUuXryouFSEEEKIiuE47p+3PU5TsoQQQkg1UMEkhBBCqoEKJiGEEFINVDAJIYSQaqCCSQghhFQDFUxCCCGkGqhgEkIIIdVABZMQQgipBiqYhBBCSDVQwSSEEEKqgQomIYSQN2TkFGN7chYycopZR1EZ7+wlSwghRPtk5BRj1JpE8DzAcUCcqwOszY1Yx2KORpiEEEJekZyZC57nUSqWgucr/kxohEkIIeQ19lZm4DgOQsjAyzjYW5mxjqQSaIRJCCHkFdbmRohzdcDSsZ3hUJIIU6GYdSSVQAWTEELIG6zNjfB5zxaIWOKJoKAgyGQy1pGYo4JJCCGkSqamppgxYwaio6NZR2GOCiYhhJB36tq1Kxo1aoQjR46wjsIUFUxCCCHvNXXqVJw8eRJZWVmsozBDBZMQQki1+Pv7Izw8HOXl5ayjMEEFkxBCSLUYGBjA09MTy5YtYx2FCSqYhBBCqq1Fixbo27cvtmzZwjqK0lHBJIQQUiPDhw9HdnY2rl27xjqKUlHBJIQQUmMLFy7E+vXrkZ+fzzqK0lDBJIQQUmM6OjpYsmSJVjU1oIJJCCHkgzRo0AAuLi744YcfWEdRCiqYhBBCPliPHj1Qv359HD9+nHUUhaOCSQghpFZmzJiBI0eO4OHDh6yjKBQVTEIIIbXCcRyWLFmC0NBQiEQi1nEUhgomIYSQWjM0NIS7uzuWL1/OOorCUMEkpJoycoqxPTkLGTnFrKMQopKsra1hb2+P7du3s46iEFQwCamGjMeFGPX9KQTuu45RaxKpaBJShZEjR+LevXu4ceMG6yhyRwWTkKrwPHD1KuDpiWTnr8GXi1AqrXg4OTOXdTpCVJanpyfWrVuHwsJC1lHkigomIa+7fx8ICwM6dwacnAA9PdiH+YKrYwhDXQE4DrC3MmOdkhCVJRAIEBAQgMDAQPA8zzqO3HDv+svY2dnxFy9eVGIcQhgpKAB27QI2b64YVY4fD7i4AA4OgE7F98qMnGIkZ+bC3soM1uZGjAMTovqSkpKQlJQEV1dX1lFqhOO4SzzP273+uJBFGEJUgkgEHD5cUSTj44HBgwFXV2DECMDA4I2XW5sbUaEkpAZ69uyJq1evIiEhAf3792cdp9ZoSpZoF54Hzp0DvvsOsLQEIiIqCuW9e8Du3cC4cW8tloSQD/P111/jwIED+Pfff1lHqTUqmEQ73LkDBAQArVsDX34JNGkCJCUBp08D//kPYEb3JAlRBI7jEBAQgGXLlkEsFrOOUytUMInmyskB1qwBevcGHB0r7lPGxAA3bwK+vkDLlqwTEqIV6tSpg/nz5yM0NJR1lFqhgkk0y/PnwLZtwKhRQJs2wPnzQGAg8OABsGoV0KMHwHGsUxKiddq0aYMuXbpg586drKN8MCqYRP1JpcCxYxVTrZaWwIYNwOTJFUVy82Zg+HBASOvbCGFtzJgxSEtLw82bN1lH+SBUMIn6+l9TATRvDnh5Veyb/PvvihWvLi6AEa1oJUTVeHt748cff0Rxsfp1y6KCSdTL/ftAePj/NxXQ1QWOHAEuXQLc3AALC9YJCSHvIBQK4e/vr5ZNDahgEtVXUAD8/jswaBDQtSuQnl6xmOfePWD5cqBDB9YJCSE10KhRI4wbNw7r1q1jHaVGqGAS1SQSAfv3A87OFVOusbEVTQUePgR++QXo37+yAw8hRP307dsXOjo6OHPmDOso1UafOER1vKupwJ491FSAEA0za9Ys7N27F48fP2YdpVqoYBL2qKkAIVrpRVODkJAQSCQS1nHeiwomYeNtTQW2b6emAoRoGSMjI7i6uiIsLIx1lPeigkmU531NBezsqKkAIVqoXbt2sLGxwZ49e1hHeScqmESx3tZUYNKkiu0h1FSAEPI/48ePR2pqKm7fvs06SpWoYBLFeFdTgalTgXr1WCckhKgYHx8frF69GiUlJayjvBUVTCI/Dx5QUwFCyAcTCoXw9fVFUFCQSjY1oIJJauflpgJdulBTAUJIrVhYWGD06NH47bffWEd5AxVMUnMiUUUjgUmTqKkAIUTuHB0dIRKJcP78edZRXkGfaqR6Xm8qEB5eMaqkpgKEEAWYM2cOduzYgZycHNZRKlHBJO92507F1o82baipACFEaTiOQ2BgIIKDgyGVSlnHAUAFk7zN600F8vMr9k9SUwFCiBLVq1cPs2fPRnh4OOsoAKhgkheeP6/otENNBQghKqRDhw5o1aoVYmNjWUehgqnVXm8q8Pvv1FSAEKJynJ2dcenSJdy9e5dpDiqY2ujlpgKentRUgBCi8hYvXozo6Gg8f/6cWQYqmNribU0F/voLuHyZmgoQQlSenp4efHx8EBwczKypARVMDZSRU4ztyVnIuPfo/5sKdO78ZlOBjh1ZRyWEkGqztLTE8OHDsWHDBibXV4kbVBk5xUjOzIW9lRmszY1Yx1FrGTnFGPXDafDl5eCkUsRlnYL1d98BI0fSPklCiNobOHAgrl27hosXL8LOzk6p12ZeMDNyijFqTSLEYjEAYMVAE3zSqzOMjY0ZJ1NPiWmPUFYugkxHF/q6ukj2XApr++asYxFCiNzMnTsX7u7uaNmyJRo0aKC06zIvmMmZueB5QMzrwEDIIeVhETJ/+w2FhYXgeR4cx8Ha2hodO3ZE+/btUbduXdaRVVZpaSmOb/8F+qYfAwDEYjEK0i8DVDAJIRrkRVMDtyWhGDJlNnpZN1DK7CTzgmlvZQaOAwx1BeA44MtRDrA2H1H5vEwmQ2ZmJlJTU3H06NHKFVJCoRBt2rRBx44d0a5dO+jr67P6K6iEsrIyeHl5YbmPD8p061dOcV9JiMeyZcvg7e0NIW0RIYRoiGciAc7Uc8Tpfdegq6uLOFcHhRdN7l2rjezs7PiLFy8qNADwYfcwxWIx0tPTcePGDdy6dQsikQgcx0FPTw82NjawtbVFq1attKJIlJeXw9PTE56enmjWrNkbz9+8eRNr165FQEAAzM3NGSQkhBD52p6cBd/dKZBAAENdAQJHd8AkOc2mcRx3ief5N26QqkTBlKeysjKkpaXhxo0buHPnTmUPwrp166JDhw6wtbVFixYtoKMhp2mIxWJ4enrCzc0NLVq0qPJ1RUVFCAgIwOTJk9GzZ08lJiSEEPn761wKvou9D6FQFxwHuY4wtaZgVqW4uBg3b95Eamoq/vnnH8hkMgCAiYkJOnbsCFtbWzRp0gScGrV/k0gk8PLygqurK6ytrd/7ep7nsWbNGtSpUwdfffWVWv1dCSHkBZlMhgULFmDu4qW4fL9A7jsstL5gViU/Px83btxAamoqsrOzKzfENmrUqLKQquI0plQqhbe3N/7zn/+gTZs2NfrZEydOID4+HgEBATA0NFRQQkIIUYz169ejS5cuCttWQgWzhp48eVJZSF8+j61p06bo2LEjOnbsCBMTEybZpFIpfHx88NVXX8HGxuaD3uPBgwcIDQ2Fh4cHWtLpI4QQNfHo0SOsW7cOgYGBCrsGFUw54HkeDx8+rCykBQUF4DgOHMfBysoKtra2Ct/6IpPJ4OvrCxcXF3SsZaee8vJyhISEoF+/fhg+fLicEhJCiOJ4eXnB398f9RTY85oKpgK92Ppy48YN/P333ygpKQFQsfWldevWsLW1lcvWF57n4efnB2dnZ3Tp0kUe0QEAmzdvxqNHj+Du7q4xi6EIIZrn8OHDKC8vx5gxYxR6HSqYDEgkEqSnpyM1NRVpaWkoLy8HAOjr66Ndu3awtbVF69atq7X1hed5BAQE4LPPPkP37t3lnjUlJQUbNmxAYGAgTE1N5f7+hBBSGyUlJViyZAlWrlyp8GtRwVQh5eXlSEtLQ2pqKtLT0yGRSAAAderUqdz6YmVlVTnau5tThCWrN8L54+4YM6iPwnLl5eUhMDAQX331lVxHsIQQUlvLli3D9OnT0bRpU4VfiwqmGigpKanc+pKZmQmZTIZC3gCx4o4QCoUQCAQK72Yhk8mwcuVKWFpaYsqUKQq7DiGEVNfVq1dx9uxZzJ49WynXo4KpprYnZ2Hx7hRIFdDN4l0OHTqEc+fOwc/PD3p6egq/HiGEvI1UKsWCBQuwatUqCAQCpVyzqoJJKzxUnL2VGTj8f69deyszpVz3008/xYwZM+Dm5oaHDx8q5ZqEEPK63377DTNnzlRasXwXKpgqztrcCKN1byBwdAelNBd+5drW1oiMjMQPP/yAkydPKu26hBACAA8fPsSTJ0/QtWtX1lEAUMFUC/W5Mkyyb87kcG1DQ0OEhoYiPT0dP/zwA941hU8IIfIUFRUFd3d31jEqUcEk78VxHL7++mv07NkTHh4eKCoqYh2JEKLh9u/fj8GDB6vUGchUMFWcTCZTmWYCvXr1gre3NxYvXoxbt26xjkMI0VDFxcU4ffo0RowY8f4XK5FqfBKTKpWWlqJOnTqsY1Rq1KgRoqOjsWvXLuzevZt1HEKIBlq5cqVKTcW+QAVTxRUXF6vUlARQ0fLP19cXABASElLZeIEQQmrr0qVLaNKkCSwsLFhHeQMVTBVXUlICIyPlL/apjnHjxmHChAlYsGABnjx5wjoOIUTNSSQS/PHHH5g5cybrKG9FBVPFFRcXq2zBBAAbGxuEhoYiLCwM58+fZx2HEKLG1q1bh1mzZqnMuo3XqWYqUkkVp2RfV69ePURGRuLixYv49ddfaesJIaTGsrKyUFhYCFtbW9ZRqkQFU8Wp8pTsyziOg6urK9q2bYtFixahtLSUdSRCiJrgeR6rVq2Cm5sb6yjvRAVTxan6lOzrBgwYgHnz5sHDwwMZGRms4xBC1MDu3bvx6aefwtDQkHWUd6KCqeLUrWACgKWlJaKjo/Hf//4XBw8eZB2HEKLCCgoKkJSUhCFDhrCO8l5UMFVcSUmJyt/DfBs9PT0EBwcjPz8f4eHhkMlkrCMRQlRQVFQUFi5cyDpGtVDBVHHqOMJ82ZQpUzBs2DAsWLAAubm5rOMQQlTI+fPnYWVlhUaNGrGOUi1UMFXc8+fPVarTz4fo0qULgoKCEBQUhCtXrrCOQwhRAWKxGFu3bsWMGTNYR6k2KpgqTpV6ydaGqakpoqOjcfz4cWzevJl1HEIIYz/++CPmzJkDjuNYR6k29f8kJmpDR0cHCxcuRMOGDeHn54fy8nLWkQghDNy7dw9lZWWwsbFhHaVGqGASpRs+fDhmzpwJd3d3PHjwgHUcQogS8TyP77//HvPnz2cdpcaoYKo4dZquqImWLVsiMjISa9aswYkTJ1jHIYQoSUxMDD777DMYGBiwjlJjVDBVnCa3mTM0NERoaCgyMjKwevVqjf67EkKAvLw8pKSkYODAgayjfBAqmIQpjuMwc+ZM9O7dGwsXLkRhYSHrSIQQOcvIKcb25CwERK6Fh4cH6zgfTMg6AHk3TZ2SfV3Pnj3RsmVL+Pr6Ys6cOWjfvj3rSIQQOcjIKcaoNYmQSKUA3xULZPpowDrUB6IRpgrLyClGmqQBMnKKWUdRCnNzc0RHR2PPnj3YuXMn6ziEkFoqLCzE+v2nUC4SQSQFBEIBkjPVt4EJ9677RnZ2dvzFixeVGIe8kJFTjJE/JEIkKoeenj4OzHWAtbn6dvypqb179+LatWtYvHgxhEKaCCFEHZSUlCAxMREXLlyASCRCvXr10LpbX/gllgAAOA6Ic1X9zzKO4y7xPG/3xuNUMFXTprN3Ebg/FVJOCAGkcKzzCOH/+UxtWkjJw+3bt7F69Wr4+/vjo48+Yh2HEPKa0tJSnD17FufOnUNZWRnq1q2Lfv36oVevXtDX1698XUZOMZIzc2FvZabyxRKggqlWCgsLMdc3BBdMPgbHceA44L+TbXBi/3bk5+dj4sSJ6N69O+uYSlFcXIyAgABMmDABffr0ee/r1e0XkxB1Ul5ejvPnz+PMmTN4/vw5DA0N0adPH/Tp00flj+aqCSqYauLp06dYsmQJli5digKZ/hsf/iKRCDt37sTly5fRq1cvfPbZZ9DV1WWcWrF4nsdPP/0EgUCAWbNmVbkQ6sXiApmMh44OpxZTP4SoMpFIhOTkZJw+fRrFxcXQ19dHr1690K9fP7U8Ram6qGCqgYcPHyI0NBTLly9H/fr13/v6CxcuYM+ePWjYsCFmzJiBhg0bKiElO6dPn0ZsbCwCAwPf2pB+e3IWAmNvoFQsg6GuAIGjO2CSfXMGSQlRTxKJBJcuXUJCQgIKCgqgq6sLe3t7ODg4VOszSVNUVTBpNYWKuHv3LlavXo2IiIhqT2306tULvXr1QnZ2Nn799VcUFRVh0qRJ6NKli4LTsuHo6IhWrVrBy8sLbm5uaNWq1SvP21uZgeM4CCAFxwlgb2XGKCkhquF9tyikUilSUlJw6tQp5ObmQiAQoEePHvjmm29gYmKi/MAqjkaYKuD69evYuHEjli9fXqvp1fLycsTExODq1avo27cvnJycNHKFqUgkwrJly9CzZ0+MHDnylecycoqxbtdRONpYYPTAXowSEsLei1sUPP//q1OtGtTB9evXcfLkSTx58gQCgQBdu3bFgAED0KCBuu6OlD+aklVRFy5cQGxsLIKDg+V2jBfP8zh37hz27duHjz76CDNmzICZmeaNtrZt24asrCwsXLgQAoGg8vH8/Hz88ssv8PLyYpiOELa2J2fBb89ViHkdCDkZeiADbQVP0alTJwwcOFCrVtzXFE3JqqBjx47hwoULWLp0qVw7+nAch759+6Jv37548OAB1q1bh5KSEkyePBmdOnWS23VYmzx5Mq5fvw43NzcEBgZWfikwMTFBQUEB43SEKB/P80hLS8OJEyfw9/2nkEo6QSgAdAVChM6bSYvgaolGmIzs27cPWVlZmDt3rlKuV1ZWhm3btiE1NRWOjo4YNWrUK6MydZafn4/AwEBMmzatcrtNaGgovvvuO61aqEC0x4t7k3ZWpuALHuPEiRO4d+8eOI5Du3bt8PHHH6NZs2Y4c+0Otvx1Hh7Tx1KxrAGaklUhW7ZsgUgkwpdffqn0a/M8j8TERMTGxsLS0hLTpk2Dqamp0nPIm0wmw6pVq2Bubo6pU6fiwoULePToEcaMGcM6GiFy9eLeZHl5OTiOw39a5GHCsP5o2bLlW1/v5+eHkJAQJadUb1UVTOolq2Q///wz9PT0mBRLoGK61tHREeHh4Rg7dizWrl0LPz8//P3330zyyIuOjg7c3d3x0UcfwdfXF506dQJ92SOaKDkzF1KptKILmECI5j0+rrJYAhW/8zKZTIkJNRfdw1QSnucRFRWFDh064NNPP2UdBwDQvHlz+Pn5obS0FH/++Sc2bNiAAQMGYMSIEXJbgKRsQ4cORbt27eDp6YnnAiNsT86irj9Eo9hbmUEqlcJAqAuxWIRuTd9926Fz5864du0aunbtqpyAGoymZJWA53ksXboUH3/8MRwdHVnHqRLP80hISMDBgwfRtGlTTJs2DcbGxqxjfZCbD3MxavVp6OnrgeOo6w/RLHMXL4XD2OloIMtHyum/3nnGZE5ODjZv3gw3NzclJlRvtEqWEalUCj8/P7Xo/8pxHAYMGIABAwYgMzMT33//PcRiMb744gvY2Niwjlcj17KLoaevj1KxFIa6FUcKUcHUXNrUQ7i4uBgWRoL/dbFqjrSLp3HlyhV069btra83NzfHs2fPlBtSQ6nnvJuaKC8vh6enJ6ZPn67yxfJ1VlZWWLJkCRYtWoTTp0/Dw8MDBw8eVJt7IRVdfwBDXQE4DtT1R4NVHIV3GoGxNzBqTaLGnx976tQpDBw4sPLPs2fPxu+//47y8vIqf0YoFEIsFishnWajgqkgJSUl8PDwwPz589VudPayunXr4ptvvkFERAQMDAywaNEirF27FoWFhayjvZO1uRHiXB0QOLoDTcdquOTMXIhEYpSKZeB5qPUBxdVx4cIF9OzZs/LPLxa8RUZGVvkzPXv2RFJSkjLiaTSaklWA/Px8+Pr6wt/fH40bN2YdRy44jsOgQYMwaNAgZGRkIDo6GjKZDC4uLmjTpg3reG9lbW5EhVILPPn7HIQCI+gJtGM2QSqVvtHysmXLlrCwsMDZs2fRt2/fN37G0dERa9euRb9+/ZQVUyNRwZSzx48fIzg4GCEhIRqxv/FtrK2tERAQgOLiYmzevBk///wzhgwZgiFDhqjt6lqinjIyMpCfdRuHFrhpxT3MBw8ewNLS8q3Pffnll1iwYAG6dOnyxtFb9erVQ3GxZk9VKwN9uslRVlYWQkJCEB4errHF8mVGRkb49ttvERERAR0dHSxatAjr1q2jX0yiFGKxGFFRUfD29oa1uREm2TfX6GIJAEeOHMHQoUPf+hzHcfDy8kJ4ePhbnzc0NMTz588VGU/jUcGUk7S0NERHRyMyMlKjD1Z9G47jMGTIEISHh+OTTz5BREQEAgMDcffuXdbRiAaLjIzEvHnzoKenxzqK0qSnp79xrN3LLC0tYWNjg2PHjr3xnIODAxITExUZT+NRwZSDK1euYMOGDYiIiIC+vj7rOEy1bt0aQUFBWLhwIeLj4+Hp6YmjR4/iXft9CampEydOoEmTJmjbti3rKEojk8nAcdx7D2qYPHkyDh48+MYBBL1798b58+cVGVHjUcGspcTEROzbtw/Lly/XyLMnP1S9evUwZ84chIWFQSKRwMvLC7/88gtKSkpYRyNq7tmzZ4iLi8O0adNYR1Gqq1evVqtbD8dxWLRoEVasWPHK4/r6+hCJRApKpx2oYNZCfHw8zp8/j4CAAFrsUgUdHR0MHz4cERERGDBgAMLDwxEcHIzMzEzW0Yga4nkeISEh8Pf3l+uReOrg2LFjGDRoULVea25ujl69eiEuLu6Vx01MTJCXl6eIeFqBPuU/0M6dO5GRkQEPDw+t+8X9UO3atUNQUBAWLFiAuLg4eHp64sSJEzRdS6pt/fr1mDBhAkxMTFhHUbq8vLwaHQT/2WefITEx8ZUuPwMHDsTJkycVkE47UMH8AP/9739RWlqK2bNns46ilurXrw9XV1eEhYXh+fPn8PLywvr162kFH6lSRk4xovadx71nz7VyL+Hz589haGhY4597fWq2W7duuHLlijyjaRW66VZDa9asgaWlJcaOHcs6itrT0dHByJEjMXLkSNy8eRMrVqyAnp4epk2bhubNm7OOR1REReu7RIhE5dDXb4uZOcUav33kdadPn0b//v1r/HMmJiYYMmQIYmJi4OzsDIFAQDM6tUAjzGrieR4rVqxAu3btqFgqQPv27REcHAxXV1fs3bsXXl5eSEhIoF9uLff8+XOs3LgPIlE5pJwQPM9rfOu7tzl37hx69+79QT87dOhQXL9+HY8ePQIANG7cGNnZ2fKMpzWoYFaDTCZDQEAABgwYgCFDhrCOo9FMTEwwb948hIaGIj8/H15eXtiwYQPKyspYRyNKlJmZiaVLlyIsLAzjHDtDX18f+oKKZgU9mpuwjqd0YrG4VvtNvb29ERYWBp7nMWjQIBw/flyO6bQHTcm+h0QiweLFi+Hi4oLOnTuzjqM1BAIBnJyc4OTkhNTUVCxbtgwGBgaYPn06mjZtyjoeUQCe53H8+HHEx8ejRYsWmD9/PurXrzgcOa5lSyRn5sJUkot1EcFYvny51jQs+Pfff2vdk9rIyAjjxo3Dpk2bMHXqVGzZskVO6bQLFcx3KCsrw6JFi/Ddd9+pbINxbWBrawtbW1vk5uZi48aNyM7OxpgxY9C3b19aoawBSkpKsGXLFqSnp2PQoEFYsWLFG9u0/r+RfnO0tTCBh4cHQkNDtaKr1tGjR/HJJ5/U+n0cHR1x8uRJ3L9/H0DFFxT6/akZ7l33iOzs7PiLFy8qMY7qKCoqgo+PDxYtWkQjGhUjkUgQGxuLM2fOoFOnTpg0aRKyiyRa0Xxbk2RkZGDz5s2QyWSYMmVKjbr2PHnyBEFBQVi6dGmNtlqoI19fX4SEhMiluJWVlcHLywtdu3ZF//790bp1azkk1Dwcx13ied7u9cdphPkWubm58PPzQ1BQEMzNzVnHIa8RCoUYO3Ysxo4di2vXrsEzOAKH+K7Q1RWC4zg6/1KF8TyPo0eP4siRI2jZsiXc3NxQr169Gr9Po0aNsHz5cvj6+sLHx6fKEzzU3YtRoLxGggYGBpg2bRqOHDmCY8eOUcGsIVr085rs7Gz4+/sjNDSUiqUa6Ny5MxzGTodQKESpWAaJRKqVqyhVXXFxMdatWwdvb+/KFeezZ8/+oGL5grGxMSIjIxEZGYk7d+7IMa3qSE1Nha2trVzf087ODgKBAGeup2N7chYycuh0oeqiEeZL7t27h+joaERERKBOnTqs45Bqsrcyg44OB0NdHUilUpzdtwkj28+HkRGNMllLT0/H5s2bwXEcvvjiC7mPaAwMDBAREQE/Pz9MmjQJ3bp1k+v7s3b06FG4uLjI/X3HuHyDn6JPImn/Dejo0KxMdVHB/J8bN27g999/R2RkpNasvtMU1uZGiHN1qLyHaSjpAT8/P4wfPx6Ojo6s42kdmUxWOe3aqlUreHh4KPTLi1AoRGhoKEJCQlBQUICBAwcq7FrK9vTpU4XMdKU8LIK+gQHKJDIIeCnW7z+FoOnD6ACJ96D/OgCSk5Oxd+9ehIeHQyAQsI5DPsD/r6IEACNER0dj48aNOH78OLy8vD6orRipmaKiImzevBmZmZn45JNPEB4errRVmBzHwc/PD6tXr0ZhYSGcnJyUcl1FKisrU9hxgf8/KyMAxwnQ2UIfS5YsgaGhIZydndGuXTuFXFfdaf0q2ZMnT+LMmTNYvHgxLbHWQFlZWYiMjISLiwt69uzJOo5GunPnDrZs2QIdHR24uLjA2tqaaZ7//ve/EAgEmDp1KtMctXXs2DFwHFftE0pqKiOn+I2V5UVFRdixYwfS0tLQpk0bODs7V+6F1SZVrZLV6oIZFxeH9PR0LFiwgHUUokA8z+O3337D06dP4e7urvWHfMuDTCZDfHw8Tpw4gdatW2PKlCkqdc949+7dyM7OhqurK+soHyw4OBje3t7M/r3evn0bMTExKCkpwdChQzFgwACtOcaQCuZr/vzzT5SUlODrr79mHYUoyd27d7Fq1SrMnDmzWgfxkjcVFhZi06ZNyMrKwrBhw/Dxxx+r7MzM8ePHcf78efj4+Khsxnfx9fXFsmXLWMeAVCrFX3/9hVOnTsHExASff/45WrRowTqWQlHBfMmvv/6KevXqYfLkyayjECWTSqX46aefUFZWhgULFtAih2pKS0vD1q1bIRQK4eLigpYtW7KOVC3JycnYs2cPli5dqlbrE3JycrB582a4ubmxjvKKZ8+eYdu2bcjKykLnzp0xbtw4jVwfoPUFMyOnGEmZufj75H70bG+FUaNGsY5EGLp16xbWrl2L2bNno0OHDqzjqCSZTIZDhw7h5MmTaNu2LaZMmaKWrehu3bqFn3/+GStWrFCb6fht27ahY8eO6NSpE+soVbp69Sr27NkDiUSC0aNHo2fPnmo5kn8brS6YGTnFGLUmESKRCAKBAIfmD6A9RwQSiQSrV6+Grq4u5syZo1YjEEUqKCjAxo0b8eDBAwwfPhwDBw5U+w/C+/fvIzw8HMuXL69VswRl8fPzw9KlS9Xiv3t5eTni4uKQlJSExo0b4/PPP691s3jWtLo1XlJmLkQiESQQQFdHgOTMXCqYBEKhEO7u7rh27Rrmz5+PBQsWaHWrsJs3b+LPP/+Enp4epk6dqlH3qZo1a4aAgAAsWrQIQUFBaNiwIetIVeJ5Xq0ao+vr62P8+PEYP348srOzsXXrVjx+/Bi9e/fGyJEjNWpfu8aPMHmeh0dQOOIkttDREYDjQF0tyBtEIhGioqJgamqKb775RmtWA0qlUhw8eBAJCQmwsbHB559/rtFdroqKirB48WJ4enqiefPmrOO81c2bN3Hp0iWFdPhRFp7ncf78eRw4cABCoRDjx49X6enl12nllCzP8wgNDcXAgQPRuE1nOs2CvFdycjI2bdqEhQsXatQI63X5+fnYuHEjHj58iBEjRqB///5qM6KprfLycixatAizZs1C+/btWcd5ww8//ICJEyeq/bTmCyUlJdi9ezdSU1NhZWWFyZMnw9TUlHWsd9LKghkeHo7evXujf//+rKMQNVJWVobIyEg0bdoU06dP16hC8vfff+PPP/+EgYEBpk6dqrKjLEWTSqXw9/fH2LFjYW9vzzrOK/z8/BASEsI6hkLcu3cP27ZtQ0FBAQYNGoTBgwer5NoBrSuY0dHR6Ny5MwYPHsw6ClFTZ86cQUxMDLy9vdGkSRPWcT6YVCpFXFwcTp8+jY4dO2Ly5MkauRWgpl6cmtKzZ0+V+ZwQiUQIDQ1FQEAA6ygKJZPJcOLECRw9ehRGRkaYNGmSSq0f0KqCuWbNGrRu3RrDhw9nHYWouZKSEoSHh8PGxgaTJ09Wq9FmXl4e/vjjD/z7778YNWoUHBwc1Cq/sqxduxYWFhYYN24c6yhISEhAaWkphg0bxjqK0uTn5yMmJgZ3795F+/btMWHCBOZdo7SmYP7888+wtLSkfZZEro4dO4aDBw/C29sbjRo1Yh3nnVJTU7Ft2zYYGhpi2rRpaNasGetIKm/Tpk2QSCT48ssvmeYICQmBu7u7Ri+8epe///4bO3fuRFlZGT799FNmX/K0omCuX78eZmZmGDt2LOsoRAMVFhZixYoVsLe3V7l/Y1KpFPv378eZM2fQqVMnTJo0CQYGBqxjqZX9+/fj3r17mDdvHrORuKq0w2NNLBbj8OHDSExMhLm5OSZPnoymTZsq7foaXzA3btwIQ0NDTJw4kXUUouEOHjyIEydOwMfHB2ZmZkyz5Obm4o8//sDjx48xevRo9O3bl6Zda+HUqVNISEiAn5+f0v875ubm4vfff4eHh4dSr6vqnjx5gm3btuHBgwews7ODk5MTsoskCt31oNEF888//wTP85gyZQrrKERL5ObmYsWKFRg4cCBGjBih9Otfu3YNMTExqFu3LqZNmwZLS0ulZ9BUV65cwfbt2xESEqLUXsM7d+5Eq1at0K1bN6VdU53wPI9Lly5h876/ECexhVAohI6OjkL21VdVMNV+d/aOHTsgEomoWBKlMjMzQ3h4OMrKyrB48WIUFhYq/JoSiQS7du2Ch4cHUlJS4OfnBx8fHyqWctatWzfMnDkTHh4eKC0tVdp1r169ii5duijteuqG4zjY2dmhj5MLdHV1USbhwfNAcmau0jKodWu8vXv3oqCggI7oIsyMGzcODg4OCAwMxMiRIxWyPeHp06fYuHEjnjx5gjFjxiAiIoKmXRWsTZs28PT0hKenJ5YtWwZjY2OFXo/nechkMq3pMFUb9lZm4DgOhroVndvsrZR3W0Rtp2QPHDiA+/fv49tvv2UdhRDwPI8///wTt27dgre3t1xO9UhJSUFMTAzq16+PadOmqfVeUHWVm5sLf39/BAQEKHR1dHp6OhITEzFjxgyFXUOTZOQU0z3M6oqPj8ft27cxd+5c1lEIeUV2djbCw8MxceJE9OvXr8Y/LxaLsXfvXly4cAFdu3bFxIkT1eZIKk1VUlICHx8fuLu7w8rKSiHX+PHHHzFmzBiaXlcRGnMP8/jx47hx4wYVS6KSmjRpgujoaNy5cwdLly5FWVlZtX4uJycHkZGR8Pf3R/PmzREZGQkXFxcqliqgbt26iIyMxJo1a3Djxg2FXOPhw4dULNWAWt3DPH36NJKTk+Ht7c06CiFV4jgOM2bMwD///ANPT09Mmzatyn6lly9fxs6dO2FsbIzp06drTMNtTaOnp4ewsDAEBARg5MiR6NOnj9zeWyKRKHU1LvlwajMle+7cORw/fhyLFy+mBQ9EbchkMvz666/Iy8vD2Gn/QcrDInRrWh9XEuKRnJyM7t27Y8KECRp1ZqAm43keERER6NKli9za1509exZ5eXkYOXKkXN6P1J5a38O8ePEiDhw4gCVLllCxJGrp5KW/MXPHncp/vyuHmGPMIPmNUohyrVu3DmZmZnB2dq71e4WGhmLu3LnM+6eS/6e29zBTUlKwb98+KpZErT2WGUFPTw8SCKCrq4eyenS/Sp19++23kEql+O2332r9XiUlJVQs1YRKF8zU1FTExMQgKCiIiiVRayz3jhHF+Pzzz9GkSRNERkbiXTN171JQUID69evLORlRFJW903zr1i1s2rQJoaGhtJmXqD1rcyPEuToodO8YUb4RI0agfv36CAoKwpIlS2r8WXXixAl8/PHHCkpH5E0lK9GdO3fw22+/Yfny5VQsicawNjfCJPvmVCw1jIODA8aNGwdvb2+IxeJq/1xGTjG2X7wP0+btFJiOyJPKVaN79+7hxx9/xIoVKyAQCFjHIYSQ9+rcuTO+/fZbLFy4EM+fP3/v6zNyijFqTSKSpS3g9ONZZOQUKyElqS2VKphZWVn4/vvvERYWRvuSCCFqpVWrVvDx8YGnpyfy8/Pf+drkzFzwPA8JBEpvIE4+nMoUzIcPHyIyMhJhYWG0J40QopYsLCwQEhICX19f/Pvvv1W+zt7KDDKZDHo6oEVgakQlCuajR4+wYsUKhIWFUSswQohaMzU1RUREBEJDQ3H37t23vsba3Aifm/4D7yHWCjnPkSgG84KZk5ODkJAQhIWFwdDQkHUcQgiptTp16mDlypVYt24drl69+tbXyAoeYebA9lQs1QjTgvns2TMEBgZixYoVqFOnDssohBAiV7q6uggLC8OePXuQmJjIOg6RA2YFMz8/H0uWLEFoaCh1uSCEaCQdHR0EBATgwoULOHjwYOXjIpGI1mqoISYFs7CwEL6+vggJCaEuF4QQjcZxHBYuXIjs7Gxs3boVQEVjlvbt2zNORmpK6QWzuLgYPj4+CA4OhqmpqbIvTwghTHz99dcQCoVYt24dUlJS0LVrV9aRSA0prWBm5BRj05l0uPoEIyAgAA0aNFDWpQkhRCU4OzujZcuW2LhxI6ysrFjHITWklIL5oqtFYNzfSDRywOmUtGqfRE8IIZpk2LBhaN68OQICAiCVSlnHITWglHY6FV0tACkEMBDq4PKDQtxaubKyaLZp0wa9evVCmzZtqHcsIUSj8TyPpk2bYtKkSfDy8kJoaCgtAFITSimYFUcbofJoo5mjB8DavOJ0cZ7ncefOHVy4cAFbtmwBz/PQ09NDt27d0KtXL5ibmysjIiGEKMWDBw/QvHlzdOzYEXPnzsXChQuxYsUK1K1bV6HXzcgpptNyaol71zludnZ2/MWLF+VyoZr8zyorK0NKSgouXLiAp0+fAgAaNmyInj17olu3bjAwMJBLJkIIUbbY2FhYWFjAzs4OAPD48WMEBQVh6dKlClvbkZFTjBGrT4PjKlbtUnehd+M47hLP83avP660DufW5kbV/h9kYGCA3r17o3fv3pWPPX36FElJSVhJU7mEEDWWmpqKTz75pPLPH330EUJDQ+Hr6wsfHx9YWlrK/Zovmr2XSXgY6uogOTOXCuYHUJsjQRo2bIgRI0ZgxIgRAF6dyt28eTN4noe+vj5N5RJCVFppaekbbUCNjY0RGRmJRYsWYYzLN3jC15Pr1Km9lRkEAh3o8VJIJBJq9v6B1KZgvo7jOLRt2xZt27atfOzFVO7WrVsrp3IbNGiAnj17onv37jSVSwhRWQYGBvhuURCGrzoJPT09uU6dWpsbIc7VAcmZuXiYkoC/L5yE9ahRckitXdS2YL7N26Zyc3JykJycTFO5hBDmCgsL39nd7NL9AgBAqVgGQ12BXKdOK2+L2btg2bJlaNasGbp06SKX99YWGlUw38bc3JymcgkhKuHatWvvLFLSf9MgEAigJxAo9JxMHx8fLFy4EF5eXrCwsFDINTSRxhfM11VnKpfn+VdW5dKxY4QQeUhJSYGzs/Nbn+N5HsnHD+CQ71JczMxT6PYPHR0dLFu2DJ6enoiIiKDToqpJ6wrm21Q1lftiVW55eTkAmsolhNROTk4OGjVq9NbnDhw4gJEjR6KVeT20Mq+n8Cx16tSBr68v/Pz8EBkZSZ9p1UAFswrm5uYYOXIkRo58s8ECTeUSQj5EVfveZTIZjh49iujoaKXmadKkCaZOnYrw8HAsWrRIqddWR1Qwq4mmcgkhtSEWiyEUvv0jd/fu3Rg/fjw4jlNyKqBbt264f/8+tmzZgi+++ELp11cnVDBr4X1TuWVlZeA4jqZyCSFIS0uDjY3NG49LpVKcPXsWUVFRDFJVcHJywg8//IDTp0/D0dGRWQ5Vp7TWeNrq5anc27dvv3cql/o9EqKZNm/ejJ49e74yS/Xi8Xbt2sHe3p5Rsgo8z8PX1xczZ85Eq1atmGZhjXlrPG1V1VTulStX3pjKbdahB/wSS/73c6B+j4RokLt37+Lzzz9/5TGxWIyUlBS4uLgwSvX/OI5DUFAQ3NzcEBISAhMTE9aRVA4VTAYMDAzQp08f9OnTp/KxnJwcrNqfBLFYCgkE1O+REA0jk8kgEAheeWzjxo2YPn06o0Rv0tXVxdKlS+Hv74+oqCjo6uqyjqRS6IaaijA3N8dMpwHQ09ODgZCDSCRC2f0brGMRQuSA5/k3VsiWlZUhLS0NnTp1YpTq7UxNTTF//nwEBgZWuapXW1HBVCEv+j0GOdniyMLBqM+VwcvLC48fP2YdjRBSC9nZ2W+cQvL7779j5syZjBK9W+vWrTFs2DD89NNPrKOoFCqYKsba3AiT7JvD2twIY8eOhZ+fH3788Uds2LCBvu0RoqZSUlLQtWvXyj+XlJTgwYMHaNeuHbtQ79G/f3/Ur18fcXFxrKOoDCqYKq5+/foICgpC+/btMX/+fNy6dYt1JEJIDV2/fv2Vqddff/0Vs2bNYpioelxcXHDt2jVcvXqVdRSVQAVTTfTu3RsrV67EoUOHEBERUdmujxCi+kpLSyv7tRYWFuLZs2ewsrJiG6qaFi1ahD/++AP//vsv6yjMUcFUI7q6unBzc8O4cePg5eWF06dPs45ECKmhdevW4dtvv2Udo9p0dHQQEhKCkJAQPH/+nHUcpqhgqqFWrVph1apVyMrKgq+vL/Ly8lhHIoRUoaioCHXr1gUA5Obmoqys7I0FQKquTp068PPzg5+fH2QyGes4zFDBVFMcx+GLL76Au7s7wsPDsX37dloURIgKun79Ojp37gwA+Omnn9RqdPkyCwsLTJs2DWFhYayjMEMFU801aNAAoaGhMDc3h5ubGzIzM1lHIoS85MUK2cePH4PjuCqP91IHXbt2ha2tLTZv3sw6ChNUMDXEoEGDsGLFCmzbtg2rV6+GRCJhHYkQAuDRo0do3Lgx1q1bh9mzZ7OOU2ujR49GQUEBEhISWEdROiqYGsTAwACLFi3C4MGD4ebmBmqcTwh7HMfhwYMHqFOnDkxNTVnHkYs5c+YgPj4e6enprKMoFRVMDdSxY0d8//33SElJQVBQEIqLi1lHIkQrSSQS6Ojo4Oeff1bbe5dvw3EcAgMDsWrVKq1adEgFU0Pp6Ojg66+/xqxZsxAUFETdOghh4M6dOzA2NkbDhg1Rr1491nHk6uVG7WKxmHUcpaCCqeEsLCwQEREBAPDw8KDNx4QoUUpKCm7cuIFvvvmGdRSFMDU1hZubm9Y0aqeCqSVGjRqFwMBA/PLLL/j111+1ei8VIcqQkVOMP5P+QfOOdpVdfjRRq1atMHz4cPz444+soygcFUwtYmRkhICAAHTv3h3z58/HjRt0fBghipCRU4xRaxJxXbcdNj9thrs5RawjKZSjoyOMjY0RGxvLOopCUcHUQj169EB0dDSOHz+O0NBQlJWVsY5EiEZJzswFzwO8QA8ymQyLo39HUFAQEhISIJVKWcdTCBcXF6SmpiIlJYV1FIXh3jXvbGdnx9PWBM2WmZmJVatWwcnJCYMGDWIdhxCN8GKEyfMAxwFxrg6wrK+LEydO4MyZM5DJZLC3t8fQoUM1arpWJpPBw8MDnp6esLCwYB3ng3Ecd4nnebs3HqeCSXiex44dO3D58mV4eHigYcOGrCMRovYycoqRnJkLeyszWJsbvfKcTCbDxYsX8ddff+H58+do3bo1Ro0apdZdgF54/vw5PD09ERERobZfBqhgkvfKy8tDZGQk2rdvjy+++AIcx7GORIhWSE9PR2xsLHJyctCwYUOMHj0abdq0YR3rg/37778IDw/HypUroaOjfnf+qGCSajt9+jR27tyJefPmoVWrVqzjEKJVcnJyEBcXhzt37qBOnToYMmQI7O3t1a7wXL16FQcPHoSPjw/rKDVGBZPUSHl5OVavXg2hUAhXV1fo6uqyjkSI1nn+/DmOHDmCpKQkcByHfv36YdCgQdDX12cdrVri4uKQl5eHqVOnso5SI1QwyQdJS0vD2rVrMWXKFPTu3Zt1HEK0llQqxdmzZ3Hs2DGUl5fD1tYWI0aMUPn+tGvXroWtrS0GDBjAOkq1UcEkH4znefzxxx/IyMiAh4cH6tevzzoSIVqN53n8/fffOHjwIPLy8mBhYQEnJye0aNGCdbQ38DwPf39/zJgxA61bt2Ydp1qoYJJae/LkCVauXInevXtj7NixrOMQQv7n4cOHiI2NRVZWFurVq4dPP/0UXbp0UZmFe2KxGO7u7ggODlb5ETFABZPIUXx8POLj4+Hu7g6RvkmVS+cJIcpXWFiIw4cPIyUlBUKhEAMGDED//v2Zr0PIz8+Hn58foqOjmWd5HyqYRK6eP3+OgMi12FtmA6FQCI7jEOfqQEWTEBUiEomQkJCAhIQESCQSdOvWDcOHD2d2csrdu3exfv16LFu2TGVGv29DBZPI3arYJPxw5l9IOSEMdXUQOLojJtk3Zx2LEPIWPM/jypUrOHz4MIqLi9GiRQs4OTkpvSNPYmIiUlJS4OrqqtTr1kRVBVPIIgxRX48fP0ZMTAyys7PRoGUH6Ok1hFQqg1Qqhb2VGet4hJAqcByH7t27o3v37gCAe/fuYceOHXj06BFMTU0xcuRItG/fXuEjPwcHB/zzzz/Yv38/nJycFHoteaMRJnmv4uJi7N27F6mpqfjoo4/g7OwMS0tLAP/f/uvUrg0I9VkAY2NjxmkJITWVm5uLAwcO4ObNm9DX18fgwYPRp08fCAQChV1zxYoVGDZsGLp166awa3wompIlNSKRSHD06FGcOnUKderUwWeffYZOnTpV+fonT55g7dq1CAoKUmJKQoi8lZWV4dixYzh37hx4nkevXr0wZMgQGBoayvU6MpkMnp6eWLhwIZo0aSLX964tKpjkvXiex6VLlxAbGwuJRIIhQ4agf//+1W7J9dtvv6Fbt27o0aOHgpMSQpRBJpPhwoULOHLkCEpLS9GuXTuMGjVKbgc0lJaWwsPDA+Hh4ahbt65c3lMeqGCSKr24l5GXl4cePXpg1KhRMDAwqPH7yGQyzJ8/H6tWrVLoVA4hhI20tDTExcXh6dOn+OijjzB69Oha95t+9OgRwsLCVKpROxVM8opnz55h586dyMzMRMuWLTFhwgSYmdV+0c6VK1eQnJyMWbNmySElIURVPX78GLGxsbh79y7q1q2LYcOGoUePHh9U9K5du4a4uDgsXrxYAUlrjgomQVlZGeLi4nDx4kU0aNAAEyZMQMuWLeV+naCgIPznP/9B48aN5f7ehBDVU1xcjL/++gsXL16EQCCAg4MDPv74Y+jp6VX7PQ4cOIDc3FyVaNROBVNLyWQyJCQk4OjRoxAKhRg9ejS6d++u0KXjRUVFCAkJQVhY2Htf+65Ddgkh6kcikSAxMREnTpyASCRC586d8emnn8LExOS9P/vTTz+hQ4cOzBu1U8HUMtevX8eePXtQVlaGAQMGYPDgwRAKlbftdufOnTA1NcXgwYOrfE1GTjFGrUkEzwMcB+oURIiG4Xke169fx6FDh5Cfn4+mTZvCyckJzZo1q/L1/v7+mD59OtMDtKlxgRZ48OABYmJi8OTJE3Tq1Anu7u4wMmJTgMaPHw83Nzc4ODhUeXZfUmYuysrLIeOEMBBySM7MpYJJiAbhOA6dO3dG586dAQD3799HbGws7t+/D2NjY4wYMQKdOnWqnPHiOA4BAQFYuHAhAgMD5bKuQp5ohKnmCgsLsWvXLqSlpcHS0hITJ05UmXuHd+/exZ49e+Dh4fHW53ccPgXf00UQCAQQi8WYav4Qi+d+rfKNmQkhtZefn49Dhw7h2rVr0NXVxaBBg+Dg4AChUIj8/Hz4+/tj5cqVNboPKi80JatBRCIR4uPjcebMGdSvXx/jxo2DjY0N61hvFRkZibFjx7516bmnpyf+4+GPS1n5sLcyQ1lOFn7++Wc4OzujX79+DNISQlgoLy/HyZMnkZiYCIlEAjs7O7Rt2xbrtu6G47gv0VPJaxyoYKo5nudx/vx5HDp0CAAwfPhw9OnTR6U7/gMVvwje3t6Ijo5+JeudO3dw9OhRzJ49+5XX8zyPrVu3IjU1FQsXLpTbBmlCiHqQyWS4dOkSYg6dxK6SNtDR0YGenp5S1zjQPUw1dfv2bezatQuFhYXo06cP/Pz8mExRfCh9fX04OTlh165dmDBhQuXjmzZtgre39xuv5zgOX3zxBfLy8hAVFQUrKyt8+eWXr+ztopW1hGguHR0d2NvbIwMfIS72b5SKpdDloRJrHKhgqqAnT55gx44dePDgAdq0aYM5c+aodVPzQYMGwcvLC0OHDkX9+vXx7NkzGBgYvLMVlqmpKZYuXYqkpCTMnz8fX3/9Nbp06fLSylqezuAkRIPZW5mB4wBDXQE4DipxGhJNyaqIkpIS7Nu3D9euXUOjRo0wceLEKpdeq6NHjx7h559/RkBAACIjI/HFF19U+xw+qVSKX3/9FdnZ2Shs2BGx2YaQcgIY6goQOLoDncFJiIZiNZtEU7IqSCKR4Pjx4zhx4gQMDQ3x2WefYcqUKaxjKUTjxo1hYWGBPcfOIjlXF+OE1T/x/fHjxygoKEB+fj4eZp2ETpORkPEy8NBRiW+dhBDFsDY3UqkZJCqYSvbi1PP9+/dDLBZj8ODBCAkJ0Ypm5YPGTMbQqOPQ1W2DUWsS3zmdyvM8Tp06hUOHDqFx48aYOXMmGjZsiIycYgxfdQq8VKrk9IQQbUcFU0kyMzOxY8cOPHv2DN27d4e3t7fcz5dTdZey8qGvr49SsQyGOm+/iV9YWIgtW7bg3r17GDBgAJYvX/7Kl4nkzNyKP8sAsVisEgsBCCHagQqmAuXl5WHHjh24d+8eWrRogS+//FKrt0lU3MTn3noTPzU1Fdu3b4eenh6mTJlS5ZFBLy8EkMmArEsnAPvpyvorEEK0GC36kbPy8nIcOHAASUlJMDMzw/jx42t9XpwmefkmflNjPezZswcXL16Era0tnJ2dqzXqfvk9ju7ZitatW2PQoEFKSE8I0QbUuECBZDIZEhMT8ddff0EoFGLkyJGws7NT+aYCrDx48ACbNm1CcXExxo4dCzu7N/5d1oi/vz+mTZvGtFkzIURzUMFUgBs3bmDPnj14/vw5HB0d8cknn1Af1CrwPI/jx48jPj4elpaWmDp1qtwaK4vFYri7uyM4OBimpqZyeU9CiPaigikn2dnZiImJwaNHj9CxY0d89tlnqFev+lsktE1+fj42b96MrKwsDBo0CEOHDv2gE9nfJy8vD0uWLEFUVBR9aSGE1Artw6yFoqIi7N69Gzdv3oSFhQUmTZpU7U332urq1avYsWMHDAwM4OLiAisrK4Vez9TUFPPmzUNwcDCWLl2q0GsRQrQTjTCrIBaL8ddffyExMRFGRkYYO3YsOnTowDqWSisvL8euXbtw5coVdOnSBRMnTqzyLExFOXHiBO7cuYNZs2Yp9bqEEM1BU7LVwPM8kpKScPDgQchkMgwdOhT9+vVTyBSiJsnKysKmTZtQWlqK8ePHo1u3bkzz/P7772jatCmGDh3KNAchRD3RlOxrXt6aICt4hJ07d6KgoAC9evXC4sWLlT4yUjcymQxHjhzBsWPH0Lx5c3z33XcwMTFhHQsA8NVXXyEoKAjNmzdX2XNCCSHqRytHmBk5xRj5w2lIJBLwPI9vmj3DrM8/oxWW1ZCXl4dNmzbh4cOHGDJkCAYNGqSSI3CJRAJ3d3cEBASgQYMGrOMQQtQIjTBfkpyZC5FYDCkqTrywsh9MxfI9Ll26hN27d8PIyAguLi4qf5KKUCjE0qVL4evri6ioKLU6Q5QQopq0smC2MxOCg2qds6aKysrKEBMTg+vXr6NHjx4ICAhQq8JjbGwMd3d3BAYGYtmyZdRIghBSK1o5JbtlyxaYW3dEntBM6eesqYN79+5h8+bNEIlEmDhxIjp37sw6Uq2cPn0a169fx5w5c1hHIYSoAZqSfcmNGzewbMoUGnG8RCaT4fDhwzh58iSsrKwwb948GBsbs44lF46OjsjMzMTBgwcxYsQI1nEIIWpK6wpmWVkZ9PX1qVj+z7Nnz7Bx40Y8evQIw4cPR1hYmEb+t5k6dSpCQkLQvHlz2Nraso5DVNzLq+hpBoq8oHUF8+jRo/jkk09Yx2AuKSkJe/fuRf369TF16lRYWlqyjqRwPj4+cHd3h5+fH8zNzVnHISrqyIWrmL03C0KhADo6Ou886JxoF60rmOfPn0dQUBDrGEyUlpZi27ZtuHnzJuzt7REUFKRVfVcFAgFCQkKwaNEiREVF0V5bUunJkyeIiYnBgwcP8LxxVwiFxiiTyKAvkNIh5aSSVhVMqVQKoOKDU5ukp6dj69atkEgkmDRpEr788kvWkZipV68evLy8sGTJEqxYsUIjp59J9ZSWlmL//v24fPkyGjVqBGdnZzRr1gwZOcU4uiYRhro6EIslyLtzCbBvzjouUQFatUr29OnTKCoq0oqFH1KpFAcPHkRCQgJat26NKVOm0KkqLzl37hySkpIwf/581lGIEr04uzY+Ph66urpwcnJCt27d3vji9PI9zKRjcXjy5Anmzp1LX7C0BPWSBRAYGAgfHx+NnorLycnBxo0bkZOTgxEjRsDR0ZF+yauwdetWGBkZwcnJiXUUomBpaWnYuXMniouL4ejoiCFDhtTodkRiYiIOHTqEwMBArbqNoa20flvJ3Zwi3Cw3wcNCMazNNatg8jyP8+fPY9++fTAzM8O0adPQuHFj1rFU3pQpUxAaGooWLVqgS5curOMQOXv69CliYmKQlZWFtm3bwtXV9YO3Sjk4OKBx48Zwd3dHSEiIxmy5IjWjFSPMjJxijFh9GjKZFEKhUGNWvZWUlGDbtm24desW+vTpAycnJwiFWvMdSC5kMhk8PDzg5eVFXzI0QFlZGeLi4pCcnIyGDRvC2dkZLVq0kNv75+bmwt/fH56engo/45Wwo9UjzOTMXHAcB5GMg4CH2q96u337NrZu3QoAmDx5MmbOnMk4kfrS0dHB0qVL4eXlhZUrV8LAwIB1JFJDPM/jzJkzOHz4MAQCAUaNGoXx48cr5FaEmZkZoqOj4e/vj3HjxqFXr15yvwZRXVozwhy1JhE8D3Ac1HKEKZFIEBcXhzNnzqBt27aYMmUK6tatyzqWxnjw4AG+//57hIeH0z1fNZGeno4dO3agoKAA/fr1w/Dhw5V2f5HneURHR6NFixYYP368Uq5JlEfrF/2oU+eOl7PWlZVg48aNyM3NxejRo9GnTx/6QFeQpKQkJCYmwt3dnXUUUoXc3FzExMQgMzMTrVu3xoQJE5iew7p9+3Y8evQI8+bNo99LDaL1BVNdvBgNS6VSSCVSTDbLxLwZk9GoUSPW0bRCTEwMhEIhxo0bxzoK+Z/y8nIcPHgQFy5cgJmZGSZOnIiWLVuyjlXpzJkziIuLQ3BwMK2g1RBafQ9TnSRn5oLngXIpYKini04ff0bFUomcnZ0RERGBS5cuoUePHqzjaK0XK78PHjwIjuMwYsQIhIaGquQorl+/fmjcuDHc3NwQEhLCdMRLFIsKpoqxtzIDx9FZnSx5eHjAw8MDFhYWaNKkCes4WiUjIwM7duxAXl4eevfuDX9/f7U4g7VVq1aVB5Z7eHio1AiYyA9NyaogdbrfqqlKS0vh4eGBiIgI1KlTh3UcjZaXl4cdO3YgIyMDLVu2xMSJE2Fmpp5fFEUiEfz9/TF27Fj07t2bdRzygegeJiE1lJ2djZUrVyIiIgI6Ojqs42gUkUiEw4cP4+zZszAxMcGECRPQunVr1rHk4sUK2ubNm2PChAms45APQAWTkA9w+fJlHD16FF5eXqyjqD2e55GcnIy4uDjwPI/hw4ejb9++KnlfUh62b9+O7OxsLFiwQGP/jpqKCiYhH2jPnj0QiUSYNGkS6yhqKTMzEzExMcjNzUXPnj0xcuRIje7n/LKzZ89i//79CA4OVot7saQCrZIl5AONHTsWUVFRuHDhAnV2qaaCggLs3LkTd+7cQYsWLTBz5kw0aNCAdSyl69u3Lz766CO4u7tj6dKlMDU1ZR2J1AKNMAmpBp7n4e3tjblz56JZs2as46gksViM+Ph4JCYmwtjYGOPHj0fbtm1Zx1IJeXl58Pf3h7u7O6ytrVnHIe9BU7KE1FJZWRkWLlyI8PBwakv4PzzP49KlS4iNjYVUKsWwYcPQr18/WiT1FiKRCEuWLMGYMWPQp08f1nHIO1DBJEQOHj9+jBUrVmDlypVaXRSysrIQExODp0+fokePHhg9ejQ1rq8GnuexatUqWFpawtnZmXUcUgUqmITIybVr1xAXF4fFixezjqJUhYWF2LVrF9LS0tCsWTM4OzvD3NycdSy1tGPHDty/fx9ubm60glYFUcEkRI5iY2NRWFiIL774gnUUhXjRPKN7M2OkXzmLhIQEGBkZYfz48bCxsWEdTyOcO3cO+/btoxW0KogKJiFytnr1atjZ2aFv376so8hVxYHrCRBLJOAAhDgYwfnTgVo9Ba0oGRkZiIqKohW0Kqaqgkm/AYR8oLlz52L//v3IzMxkHUVu/v33X/hEr684LQcC6OrqgWvUmoqlglhbWyMkJAT+/v64e/cu6zjkPei3gJAPxHEcgoKCEBERgaKiItZxaqW4uBjh4eHYsGEDFn8zCbq6unQAgJKYmJggKioKv/76K86cOcM6DnkHmpIlpJZycnIQEhKCqKgoCAQC1nFqRCqV4o8//sDt27fx3XffVe4xpQMAlI/neXz//fewsLCgrlKM0T1MQhToxo0b2L17N/z9/VlHqRae53H48GHEx8dj+vTp6NatG+tI5H927tyJf/75B+7u7rSClhG6h0mIAnXs2BF2dnb4448/WEd5r5SUFLi5uVWeqkHFUrVMmDAB/fr1w6JFiyASiVjHIS+hgkmInHz66acoKSnBqVOnWEd5q/v372PRokW4fPkyIiMjMWLECBrBqKjevXvj22+/hZubG3Jzc1nHIf9DU7KEyBHP8/Dz88NXX32FVq1asY4DoKLhwJo1ayAUCjFnzhwYGdE9SXWRn58PPz8/uLm5qcy/J21A9zAJURKxWAw3NzcsW7YMxsbGTHOsX78e9+/fh6urKywsLJhlIR9OLBZjyZIlGDVqFPr168c6jlaggkmIEj179gxBQUGIioqCUKjcU/R4nse+ffuQkJCAr776Cra2tkq9PpE/nuexevVqNG7cmFbQKgEt+iFEiRo0aIA5c+YgJCREqddNSkqCm5sb6tWrh6ioKCqWGoLjOMyfPx9CoRArV67EuwY6RHGoYBKiIDY2NujXrx/Wr1+v8Gvdu3cPXl5eSEtLQ1RUFAYPHqzwaxLlGz9+PBwcHODt7Y3y8nLWcbQOFUxCFGjIkCGQyWQ4fvy4Qt4/Ly8PwcHB2LNnD4KCgjB16lSVa2OXkVOM7clZyMgpZh1FI/Tq1Qtz5syBu7s7raBVMrqHSYgSLFmyBC4uLmjbtq1c3q+8vBy//PILcnJy4OrqikaNGsnlfeUtI6cYo9YkgucBjgPiXB2oc5CcvFhBu2DBArRu3Zp1HI1C9zAJYWjJkiX44YcfkJeXV6v34XkeMTExWLx4MYYOHYrg4GCVLZYAkJyZC54HSsVS8HzFn4l8mJiYIDo6Gr///jsSExNZx9EKVDAJUQKhUIjg4GD4+/tDLBZ/0HskJiZiwYIFsLCwwMqVK9GuXTs5p5Q/eyszcBwggJQauSuArq4uli1bhsuXL+PPP/9kHUfjUcEkRElMTU0xf/58BAUF1WiV4+3bt+Hh4YGHDx8iOjoajo6OCkwpX9bmRohzdYBTk3KsHtGEpmMVgOM4zJs3D/r6+oiIiKAVtApEBZMQJWrTpg0GDx6MX3755b2vzcnJQUBAAOLj47Fs2TJMmjRJ5Rb0VIe1uRFmfWKLx+nXWUfRaOPGjcOAAQPg5eVFK2gVRLk7qgkh+Pjjj5GZmYn4+HgMGzbsjedLS0uxbt06FBUVYf78+TAzU/9pzLZt22Lbtm2sY2i8nj174qOPPoK7uzuCg4PRoEED1pE0ivp9XSVEA3z55Zc4d+4cbt68WfmYTCbDpk2bEBAQgDFjxmDJkiUaUSwBQCAQQCaTsY6hFVq0aIHly5cjMDAQd+7cYR1Ho1DBJIQRf39//PTTT7h85wECN/2Fb9x90bZtW4SHh8Pa2pp1PLnjOI6KppIYGxsjKioK//3vf5GQkMA6jsaggkkIIwKBAF+7LcaE3y5iY+pzJNTph3+LpSgoKGAdTSFatWqFu3fvso6hNXR1dRESEoKrV69i69atrONoBLqHSQhDN5+KoK9vgFKxFLo6HJIyc5F+5VcUFhYCqNh3aW5uDhsbG9jY2KBp06ZqufAHAHr06IHLly+jTZs2rKNoDY7jMHfuXOzZswfh4eHw9PSkM1BrgQomIQy92KdoqCsAxwFfO/WHtfmoV17z9OlT3Lp1C3/99Rfu378PnufB8zz09fXRpk0b2NjYoG3btjA0NGT0t6geGxsb7Ny5k3UMrTR27FgkJyfD09MTy5Ytg76+PutIaokKJiEMvdinmJyZC3srs7fuU2zYsCEcHBzg4ODwyuNlZWVIT09HWloaDh48iNLS0srnLC0tK0eljRo1UolRhVAohFQqZR1Da9nb26NRo0Zwc3NDcHAwCnmDd/67I2+igkkIY9bmRh/0gWVgYABbW9s3jvDieR7Z2dm4desWdu7cicePH1c+bmRkhHbt2sHGxgatWrWCrq6uXP4ONcHzvEoUcG3UokULhIaGYr7fMpw3GQiO06EevzVABZMQDcNxHCwtLWFpafnGMV9FRUW4ffs2Ll++jB07dlS26dPR0YGVlRVsbGzQrl07mJqaKiRby5YtkZmZiZYtWyrk/cn7GRsbY6jLHJzdfwMimRSGugIkZ+ZSwawGKpiEaJF69eqhR48e6NGjxyuPS6VS/PPPP7h16xY2bNjwSpN4MzOzyund5s2bQyAQfPD1u3fvjkuXLlHBZKy3dUMIhQII/neKDPX4rR463osQ8k65ublIS0vDrVu38M8//1TupdTV1UXr1q0rFx3VrVv3ve8lFouxfPlyBAQEKDo2eY+MnGK6h1mFqo73ohEmIeSdzMzM0KdPH/Tp0+eVx0UiEe7evYtbt24hPj4eJSUllc9ZWFhUjkotLCwq71nq6uoiVyzE9uQs+qBm7EPvnWszGmESQuSK53k8fvwYt27dwq1bt5CdnV35XLmeMXYUtYK+vj44jqPFJkQl0QiTEKIUHMehcePGaNy4MQYOHPjKc5vOpGPf4dsoFctosQlRO+rZMoQQopb6tW0MHR2dykYNtNiEqBMaYRJClKY6jRoIUVVUMAkhSkWLTYi6oilZQgghpBqoYBJCCCHVQAWTEEIIqQYqmIQQQkg1UMEkhBBCqoEKJiGEEFINVDAJIYSQaqCCSQghhFQDFUxCCCGkGqhgEkIIIdVABZMQQgiphneeh8lxXA6Af5QXhxBCCGGuBc/z5q8/+M6CSQghhJAKNCVLCCGEVAMVTEIIIaQaqGASQggh1UAFkxBCCKkGKpiEEEJINfwf+zIZRT5uecYAAAAASUVORK5CYII=\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "points = random_points(40)\n",
+    "solver = DBSTSolverSAT(points, 3)\n",
+    "edges = solver.solve()\n",
+    "draw_edges(edges)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "97a7f6ff-7745-4382-b379-554b2f12505e",
+   "metadata": {},
+   "source": [
+    "## Greedy-Heuristik\n",
+    "Man kann den Solver mit einer (heuristischen) Startlösung füttern.\n",
+    "Dies verstärkt die zu Beginn bekannte untere Schranke und kann den Lösungsprozess je nach Instanz stark beschleunigen."
+   ]
+  },
+  {
+   "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,
+   "id": "cbeba604-32fa-4d67-b16f-6645742cb0e8",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Bottleneck bei Greedy: 2327.513050446764\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAcwAAAFUCAYAAACp7gyoAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAABCaUlEQVR4nO3de1yO9/8H8Nd1HzoJldWETXKW06jZhmEMc9oPs9hi87UTYyl0UEkpJSnMfO1ojDkNQ4w5zBzGJDNzPlTLMSWkdLzv6/dHq++cb+m+P/fh9Xw8PL6PbnXfL9/V/er6XJ/rfUmyLIOIiIgeTiE6ABERkSlgYRIREemAhUlERKQDFiYREZEOWJhEREQ6YGESERHpQPWwv3zqqadkNzc3A0UhIiISLyUlJVuWZee7H39oYbq5ueHgwYP6S0VERGRkJEn6+36Pc0mWiIhIByxMIiIiHbAwiYiIdMDCJCIi0gELk4iISAcsTCIiIh2wMImIiHTAwiQiItIBC5OIiEgHLEwiIiIdsDCJiOgeqVl5WJGcgdSsPNFRjMZDZ8kSEZHlSc3KQ795eyDLgCQBSWM7wd3ZXnQs4XiESUREd0hOz4Esyygo0UCWyz4mHmESEdFdvNycIEkSVNBC1krwcnMSHcko8AiTiIju4O5sj6SxnTBtYGt0yt8DR1WJ6EhGgYVJRET3cHe2x7Dn62PmlEmIiIiAVqsVHUk4FiYRET2Qo6Mj3n33XSQmJoqOIhwLk4iIHqpt27ZwcXHB1q1bRUcRioVJRESPNHz4cOzcuRMZGRmiowjDwiQiIp2EhYUhLi4ORUVFoqMIwcIkIiKd2NjYYNKkSYiOjhYdRQgWJhER6ax+/fp46aWXsHTpUtFRDI6FSUREj6V37964dOkSjhw5IjqKQbEwiYjosU2YMAFff/01bty4ITqKwbAwiYjosSkUCkyZMsWihhqwMImIqFJq1aoFHx8ffPrpp6KjGAQLk4iIKq19+/aoUaMGduzYITqK3rEwiYjoibz77rvYunUrLl68KDqKXrEwiYjoiUiShClTpiAmJgbFxcWi4+gNC5OIiJ6Yra0t/P39MX36dNFR9IaFSaSj1Kw8rEjOQGpWnugoREbJ3d0dXl5eWLFihegoesHCJNJBamYu+s35FVPX/YV+8/awNIkeoG/fvkhLS8OxY8dER6lyLEyiB5Fl4M8/gUmTkPzme5CLilGgKXs4OT1HdDoiozVp0iQsWLAAubm5oqNUKRYm0d3OnwdmzABatwYGDACsrOA1IwSSnS1s1UpIEuDl5iQ6JZHRUiqVCA8Px9SpUyHLsug4VUZ62D/G09NTPnjwoAHjEAly8yawejWwZEnZUeXgwYCPD9CpE6Ao+70yNSsPyek58HJzgruzveDARMbvwIEDOHDgAMaOHSs6ymORJClFlmXPux9XiQhDZBSKi4HNm8tKcssWoHt3YOxYoE8fwMbmnk93d7ZnURI9hueffx5//vkndu3ahZdffll0nCfGJVmyLLIM7NsHfPwxULcuMHNmWVGmpQFr1gCDBt23LImoct577z1s3LgRly9fFh3libEwyTKcOQOEhwONGgEjRwJ16gAHDgC7dwMffgg48ZwkkT5IkoTw8HBER0ejpKREdJwnwsIk85WVBcybB7zwAtC5c9l5ypUrgRMngJAQoEED0QmJLIKdnR18fX0RExMjOsoTYWGSebl9G1i+HOjXD2jcGNi/H5g6FbhwAZg9G2jfHpAk0SmJLE7jxo3Rpk0b/PDDD6KjVBoLk0yfRgNs31621Fq3LrBwITB0aFlJLlkC9O4NqLi/jUi0119/HadOncKJEydER6kUFiaZrn+GCuDZZ4GAgLLrJo8fL9vx6uMD2HNHK5GxCQwMxPz585GXZ3rTsliYZFrOnwfi4v43VECtBrZuBVJSAD8/wNVVdEIiegiVSoWwsDCTHGrAwiTjd/Mm8M03wCuvAG3bAmfPlm3mSUsDpk8HWrQQnZCIHoOLiwsGDRqEBQsWiI7yWFiYZJyKi4H164E33yxbct2woWyowMWLwBdfAC+/XDGBh4hMz0svvQSFQoG9e/eKjqIzvuOQ8XjYUIG1azlUgMjMfPDBB/jxxx+RmZkpOopOWJgkHocKEFmk8qEGUVFRKC0tFR3nkViYJMb9hgqsWMGhAkQWxt7eHmPHjsWMGTNER3kkFiYZzqOGCnh6cqgAkQVq2rQpmjVrhrVr14qO8lAsTNKv+w0V8PYuuzyEQwWI6B+DBw/G0aNHcfr0adFRHoiFSfrxsKECw4cD1auLTkhERiY4OBhz585Ffn6+6Cj3xcKkqnPhAocKEFGlqVQqhISEICIiwiiHGrAw6cn8e6hAmzYcKkBET8TV1RX9+/fHV199JTrKPViY9PiKi8sGCXh7c6gAEVW5zp07o7i4GPv37xcd5Q58VyPd3D1UIC6u7KiSQwWISA/GjBmDVatWISsrS3SUCixMergzZ8ou/WjcmEMFiMhgJEnC1KlTERkZCY1GIzoOABYm3c/dQwVu3Ci7fpJDBYjIgKpXr47Ro0cjLi5OdBQALEwqd/t22aQdDhUgIiPSokULNGzYEBs2bBAdhYVp0e4eKvDNNxwqQERG580330RKSgrOnTsnNAcL0xL9e6jApEkcKkBERm/y5MlITEzE7du3hWVgYVqK+w0V+Pln4NAhDhUgIqNnZWWF4OBgREZGChtqwMI0Q6lZeViRnIHUtCv/GyrQuvW9QwU8PERHJSLSWd26ddG7d28sXLhQyOsbxQmq1Kw8JKfnwMvNCe7O9qLjmLTUrDz0+3Q35KIiSBoNkjJ+hfvHHwN9+/I6SSIyeV27dsWRI0dw8OBBeHp6GvS1hRdmalYe+s3bg5KSEgBAbFcH9OjQGjVr1hSczDTtOXUFRcXF0CjUsLW2RvKkaXD3elZ0LCKiKjNu3Dj4+/ujQYMGqFWrlsFeV3hhJqfnQJaBElkBG5WEwxdvIf2rr5CbmwtZliFJEtzd3eHh4YHmzZujWrVqoiMbrYKCAuxY8QWsHLsBkCBJgJcbBwsQkXkpH2rgNyUGr741Gh3caxlkdVJ4YXq5OUGSAFu1EpIEjOzXCe7OfSr+XqvVIj09HUePHsW2bdsqdkipVCo0btwYHh4eaNq0KaytrUX9E4xCYWEhAgICMD04GIXqGlziJiKzdq1Yib3VO2P3uiNQq9VIGttJ7+93wgvT3dkeSWM7PfANXqFQwN3dHe7u7hgwYEDF4yUlJTh79iyOHTuG9evXo7i4GJIkwcrKCs2aNUPLli3RsGFDqCzgOsKioiIEBAQgICAAderUAQAWJRGZteT0HGg0GpRCCZVc9rHZFyZQ9ub+uP9QtVqN5s2bo3nz5nc8XlhYiFOnTiElJQXLly+vmEFYrVo1tGjRAi1btkT9+vWhMJO7aZSUlCAwMBATJkzAM888IzoOEZFBOJbmQJIk2KqUBjv9ZBSFWZVsbGzQpk0btGnT5o7H8/LycOLECezcuRN///03tFotAMDBwQEeHh5o2bIl6tSpA8mExr+VlpYiMDAQn3zyCerXry86DhGRQWi1WiQt+wabJk/DofM3DXb6SXrYBaCenp7ywYMH9R5CpBs3buDYsWM4evQoLl26VHFBrIuLS0WROjs7C055L41Gg8DAQHz44Ydo3Lix6DhERAbz9ddfo02bNnq7rESSpBRZlu95crM7wnxcDg4O6NixIzp27HjH41evXsWxY8ewfPnyO+7HVq9ePXh4eMDDwwMODg4GTltGo9EgODgY7733HsuSiCzKlStXcP78eYwaNcrgr23xR5iPQ5ZlXLx4seKI9ObNm5AkCZIkwc3NDS1bttT7pS9arRYhISHw8fGBByf1EJGFCQgIQFhYGKrrceY1jzCrgCRJqFevHurVq4devXpVPF5+6cuxY8ewfft25OfnAyi79KVRo0Zo2bJllVz6IssywsLCMHToUJYlEVmczZs3o2PHjnoty4dhYVaBf1/60r9//4rHS0tLcfbsWRw9ehQbNmxAUVERAMDa2hpNmzZFy5Yt0ahRI50ufZFlGeHh4Rg8ePA9G5qIiMxdfn4+tm7dilmzZgnLwMLUI5VKhWbNmqFZs2Z3PF5UVIRTp07h0KFDWLlyJUpLSwEAdnZ2FZe+uLm5VVz6ci7rFqbMXYw3u72Gdu3aGfzfQUQk2uzZs+Hn5yc0AwtTAGtra7Ru3RqtW7e+4/H8/HycOHECu3btwuLFi6HVapEr22BDiQdUKjf88etNtGqVx6EERGRR/vzzTzg5OaFevXpCc7AwjUi1atXg6el5x1bpFckZ2LDmMIo0gK3CMNMsiIiMhUajwVdffYXZs2eLjsL7YRo7LzcnSPjfrF0OUyciS/LVV19h1KhRUCqVoqPwCNPYuTvbo7/6GF7o/zaHqRORRbl48SKuXr2Ktm3bio4CgIVpEmpIhfDmPS2JyMIkJCQgMjJSdIwKXJIlIiKjs379enTv3t2o7oHMwjRyWq3WbO6sQkSki7y8POzevRt9+vR59CcbEN+JjVxBQQHs7OxExyAiMphZs2bB399fdIx7sDCNXF5enlEtSRAR6VNKSgrq1KkDV1dX0VHuwcI0cvn5+bC3585YIjJ/paWlWLRokZA7keiChWnk8vLyWJhEZBEWLFiADz74wGj3bRhnKqrAJVkisgQZGRnIzc1Fy5YtRUd5IBamkeOSLBGZO1mWjWK4+qOwMI0cl2SJyNytWbMGr732GmxtbUVHeSgWppFjYRKRObt58yYOHDiAV199VXSUR2JhGrn8/HyewyQis5WQkIAJEyaIjqETFqaR4xEmEZmr/fv3w83NDS4uLqKj6ISFaeRu377NST9EZHZKSkrw/fff49133xUdRWcsTCPHWbJEZI7mz5+PMWPGQJIk0VF0xndiIiIyqLS0NBQWFqJZs2aiozwWFiYRERmMLMuYM2cOfH19RUd5bCxMI2dKyxVERI+ycuVK/N///R9sbGxER3lsLEwjJ8uy6AhERFXi+vXrOHz4MLp27So6SqWoRAcgIiLzlpqVh+T0HOz9cTHCJ04UHafSWJhGjkuyRGTKUrPy0G/eHpRqNIDcFuO11qglOlQlcUnWiKVm5eFUaS2kZuWJjkJE9FhkWUZqairmrfgJRcXFKNYASpUSyek5oqNVGo8wjVRqVh76froHRcXPoPfsnZjYshRutexgZ3f/PzY2Nrxek4iEuX37Ng4ePIjff/8dubm5AIAGDRqgt2d7bM66DFkGJAnwcnMSnLTyWJhGau+ZTBQXF0GrUEGSJNy0doa9vYTbt28jJycHt2/fvuNPQUEBtFrtHc/xqOVcSZLuKF1bW9sHFnL5H2tray4TE1k4WZaRnp6Offv24eTJk5BlGba2tvD09MT7778PBweHOz4/qWFDJKfnwMvNCe7Opjvqk4VphHJzc7Ft2edQO3SDlSRBkoDBndtU+TeaVqtFQUHBPeV7+/Zt3Lp1C1evXr3n8cLCwgc+3907esuLValUPrKI7y5stVpdqWIu31xg6j+YRMbk30ePN2/eBFB29Pjiiy9i6NChj1zdcne2N4ufRxamkcnOzsaUKVOQMG0abmqt9frmr1AoUK1aNb3fDaW0tPSBxZyTk4MLFy7c83hxcfFjFaYsy7itqo61t5tCqVRCqVQgaWwns/ghJTKkxz16tCQsTCNy8eJFxMTEIDY2FjVq1EAtwCze8FUqFapXr47q1avr7TVkWcb3+9Ox4aeTKCzRwlYBJKfnmMX/f0T6VFBQcM/Ro5ubm85Hj5aEhWkkzp07h7lz52LmzJlGf9dxYyRJEl5s5AyFdApKaCBJSpPeXEBUFe4+RfGgo8f27dvjvffes+ijR12wMI3AX3/9hcWLFyM+Ph5qtVp0HJPl7myPpLGdsGD1NnRu5sijS7Jo5TvtNRoNtFot+iqPoIZUyKPHJ8DCFOz333/Hhg0bMGPGDH7zVgF3Z3tMHtoVX3zxBfp37SA6DpHBaTQabN++HV/9chwlaIhSKGCrVuGl/sPh7fWs6HgmjYUp0Pbt2/H7779j2rRpvFSjCjk4OFSciyGyFCdPnsQPP/yA27dv45VXXsH08f/BgPm/QW0G1z8aCxamIOvWrUNGRgYmT54sOopZsre3R25uLmrUqCE6ClGVKz832cRRid+3bUBaWhqaNWsGX1/fOzbXJY3txMusqpD0sLtheHp6ygcPHjRgHMuwdOlSFBcXY+TIkaKjmK3ff/8dV65cweuvvy46ClGlybKMmzdv4urVqxV/Tly4hoWXn4Ysy5AkCV8PaYwu7ZqLjmpWJElKkWXZ8+7HeYRpYJ9//jmcnJzw9ttvi45i1jw9PTF16lQWJhmdoqIiZGVl3VGCmZmZyMvLu++pGQcHB7i4uMDFxQWNGjXCtZpNoM4+j4ISLayVEq5o9HsdNf0PC9NAZFlGQkICWrRogddee010HLOnVCpxQ2OFFckZXI4ivZJlGdevX7+jAK9evYrs7Ox7xlUCgJWVVUUBuri4oEmTJnj66ad1HiBin5WHxF0XYKtWoLi4GM/V42kHQ+GSrAHIsoxp06ahW7du6Ny5s+g4FiE1Kw+9En+BUqmCQiFx6g89lsLCwnsKsHxU5P04Ojri6aefvqMIa9WqBaVSqZd85ecwa2lv4PDunzHRhO8xaYy4JCuIRqNBaGgohgwZgnbt2omOYzGS03OglWWUlGphq1Zy6o+Ze9QMYa1WW3EUmJmZWVGA165du2cGMgBYW1vDxcWlogRbtGgBZ2dnvY+R1NX/ZrM+i1MHd+OPP/7Ac889JzqW2WNh6lFRURGCg4PxwQcfoFmzZqLjWBQvNydIAGzVSm6pN3NlF+jvRmlpKWRZRn/1MdRUFN3xOZIkwcnJqeLor2XLlnBxcYGTk5PJX/88evRo+Pr6Ij4+HtbW1qLjmDUWpp7k5+cjKCgIEydORP369UXHsTjqwusY6ZqJRi/24jlMM5ecnoPi4hJoJCVs1Qq80P9ti7pAX6FQwN/fH/Hx8QgJCREdx6yZ9q9WRurGjRsICAhASEgIy1KQ7du3483XusLb61mWpZm7enwfVErlP6sJkkWuJjRo0ACurq747bffREcxayzMKpaZmYmQkBBERUWhdu3aouNYrDNnzqBRo0aiY5Cepaam4kbGafw0vgum9m9h0Zu7Ro4ciRUrViA/P190FLPFwqxCGRkZiIqKQlxcHBwdHUXHsVjlmzg4btC8lZSUICEhAYGBgXB3trf41QRJkhAQEIC4uDjRUcwWC7OKnDp1ComJiYiPjzeanXSW6vjx4/Dw8BAdg/QsPj4en3zyCaysrERHMRp169ZFs2bNsH37dtFRzBILswr88ccfWLhwIWbOnMldakZg+/bteOWVV0THID365ZdfUKdOHTRp0kR0FKMzdOhQbNq0iTcg0AMW5hPas2cP1q1bh+nTp0Ol4qZjY5CZmcnzx2bs2rVrSEpKwogRI0RHMUqSJCEoKAixsbGio5gdFuYT2LJlC/bv34/w8HCTv5bLXJSWlvIXFzMmyzKioqIQFhbGc9QP4ezsjA4dOiApKUl0FLPCd/lK+uGHH5CamoqJEyfyB9eIJCcnw8vLS3QM0pOvv/4ab7zxBhwcHERHMXr/93//hz179uDatWuio5gNFmYlfPvttygoKMDo0aNFR6G7/Prrr3j55ZdFx6AqlpqVh4R1+5F27TY6duwoOo7J4NJs1WJhPqZ58+ahZs2aGD58uOgodB+3bt3iTaPNTNnouz34bF8m1t5ugtSsPNGRTIaDgwNeffVVrFy5UnQUs8DC1JEsy4iNjUXTpk0xcOBA0XHoPvLz82FnZyc6BlWh27dvY9bidSguKYZGUkGWy0bhke569uyJv/76C1euXBEdxeSxMHWg1WoRHh6OLl264NVXXxUdhx5gz549vH2amUhPT8e0adMwY8YMDOrcGtZWVhyk/wQCAwMxY8aM+96ZhXTH7YSPUFpaismTJ8PHxwetW7cWHYceYt++fZg8ebLoGFRJsixjx44d2LJlC+rXrw9fX9+K5fWkBg0eevsuejh7e3sMGjQI3333HS/HeQIszIcoLCxEUFAQPv74YzRu3Fh0HHqEkpISTn0xQfn5+Vi6dCnOnj2LV155BbGxsfdcpvW/+z9SZXXu3Bk7d+5ERkYGnn3Wcu7mUpVYmA9w69YtBAcHIygoCPXq1RMdhx4h5fR5XLFzR2pWHt9YTURqaiqWLFkCrVaLt956Cx988IHoSGZv0qRJCAgIwOzZs3nteCVID1vT9vT0lA8ePGjAOMYhJycHoaGhiIiIgLOzs+g49AipWXnoPXsnIElQKZUWfccKYyfLMrZt24atW7eiQYMG8PHxQfXq1UXHsigHDx5ESkoKPvzwQ9FRjJYkSSmyLHve/TiPMO9y6dIlREdHIyYmBjVr1hQdh3SQnJ4DhVKJwhItIGuQnJ7DwjQyeXl5WLJkCVJTU9GjR4/7LruSYXh6emLHjh345eAxXJWr87zwY2Bh/ktaWhoSExMxc+ZMXp5gQrzcnKCQJNiqFdBoNPht3Xfo29wX9vZ8ExDt7NmzWLJkCSRJwttvv817lBqJ133eR5+5u6BWW0GhkLgqoyMW5j+OHTuGb775BvHx8dw4YmLcne2RNLZTxS5K29L2CA0NxeDBg3mZiQBarbZi2bVhw4aYOHEif3kxMmv3HAEgobBUC6Wswdfrf0XEO704h/kReA4TZfNHf/zxR0RGRkKpVIqOQ1VAlmUsXrwY6enpCAgIgK2trehIZu/WrVtYsmQJ0tPT0aNHD/To0YNzlo3Qvn378MOWXfhJbgNZBiQJCO9gjT/3bIWtrS3efPNNNG3aVHRMoR50DtPiC3Pnzp3Yu3cvJk+ezB9uM5SRkYH4+Hj4+Pjg+eefFx3HLJ05cwZLly6FQqGAj48P3N3dRUeiB9i9ezd27dqFyZMnIy07/55rW2/duoVVq1bh1KlTaNy4Md58802LHDXJwryPpKQknD17FuPHjxcdhfRIlmV89dVXyM7Ohr+/P2/yXQW0Wi22bNmCX375BY0aNcJbb73FZVcjt3PnTuzfvx+BgYE6HRycPn0aK1euRH5+Pnr27IkuXbpYzEYtFuZdli1bhvz8fLz33nuio5CBnDt3DrNnz8aoUaPQtm1b0XFMUm5uLr777jtkZGSgV69e6NatG1dmTMC2bdtw+PBhTJw48bG/VqPR4Oeff8avv/4KBwcHDBs2DPXr19dDSuPBwvyXL7/8EtWrV8fQoUNFRyED02g0+O9//4vCwkKMHz+emxx0dOrUKXz//fdQqVTw8fFBgwYNREciHW3ZsgXHjx+Hn5/fEz/XtWvXsHz5cmRkZKB169YYNGiQWe4PsPjCTM3Kw4H0HBzfuR7PN3dDv379REcigU6ePInPPvsMo0ePRosWLUTHMUparRY//fQTdu7ciSZNmuCtt95CtWrVRMeix7Bx40akpqZi3LhxVf7cf/75J9auXYvS0lL0798fzz//vNmsNlh0YaZm5aHfvD0oLi6GUqnET75deM0RobS0FHPnzoVarcaYMWO4Q/ofN2/exOLFi3HhwgX07t0bXbt2NZs3Qkuyfv16XLhwAWPGjNHr6xQVFSEpKQkHDhxA7dq1MWzYMNSuXVuvr6lvFj3p50B6DoqKi6GBEmqFkpNgCACgUqng7++PI0eOwNfXF+PHj7foC+tPnDiBZcuWwcrKCsOHDzf781TmbM2aNcjOztZ7WQKAtbU1Bg8ejMGDB+PSpUv4/vvvkZmZiRdeeAF9+/Y1q+vazf4IU5ZlTIyIQ1JpS2i1WigUCh5h0j2Ki4uRkJAAR0dHvP/++xazG1Cj0WDTpk3YtWsXmjVrhmHDhnHKlYlbtWoVcnNzMWrUKGEZZFnG/v37sXHjRqhUKgwePBitWrUSludxWeSSrCzLiImJQdeuXVG7cWskp+dg/4aleM97ADw8PETHIyOUnJyM7777DhMmTDDrI6wbN25g8eLFuHjxIvr06YOXX36Zy65mYNmyZSguLsY777wjOkqF/Px8rFmzBkePHoWbmxuGDh0KR0dH0bEeyiILMy4uDi+88AJefvnlisc0Gg0mTpyIgIAAuLq6CkxHxqqwsBDx8fGoV68e3nnnHbMqkuPHj2PZsmWwsbHB8OHDeV9EM7JkyRIAgI+Pj+AkD5aWlobly5fj5s2beOWVV9C9e3ej3DtgcYWZmJiI1q1bo3v37vf83e3btzFp0iTMmDGDF1vTA+3duxcrV65EYGAg6tSpIzpOpWk0GiQlJWH37t3w8PDA0KFDzfJSAEv27bffwsbGxmQuldNqtfjll1+wbds22Nvbw9vb26j2D1hUYc6bNw+NGjVC7969H/g5WVlZiIqKwqxZs3gtHj1Qfn4+4uLi0KxZMwwdOtSkjjavX7+ORYsW4fLly+jXrx86depkUvlJN19//TVq1KiBIUOGiI5SKTdu3MDKlStx7tw5NG/eHG+88YbwAxmLKczPP/8cdevW1ek6y9OnT2PRokWIioriGwk91Pbt27Fp0yYEBgbCxcVFdJyHOnr0KJYvXw5bW1uMGDECzzzzjOhIpCeff/45XFxcMHDgQNFRqsTx48fxww8/oLCwEK+99pqwX/IsojC//vprODk5PdY3z969e3Hw4EH4+vrqMRmZg9zcXMTGxsLLy8vo3qA0Gg3Wr1+PvXv3olWrVvD29oaNjY3oWKRH8+fPR7169TBgwADRUapcSUkJNm/ejD179sDZ2RlDhw5FvXr1DPb6Zl+Yixcvhq2tbaWWJVavXo3S0lJ4e3vrIRmZm02bNuGXX35BcHAwnJychGbJycnBokWLkJmZif79++Oll17iaokFmDt3Lho1aoQ+ffqIjqJ3V69exfLly3HhwgV4enpiwIABuHSr9J47rVQlsy7MZcuWQZZlvPXWW5V+jnnz5qFVq1bo0qVLFSYjc5WTk4PY2Fh07dpVyJvWkSNHsHLlSlSrVg0jRoxA3bp1DZ6BxEhMTESLFi3Qq1cv0VEMSpZlpKSkYMm6n5FU2hIqlQoKhQJJYztVeWk+qDBN/ursVatWobi4+InKEgA+/vhjbN++HSdOnKiiZGTOnJycEBcXh8LCQkyePBm5ubl6f83S0lKsXr0aEydOxOHDhxEaGorg4GCWpQWJj49H69atLa4sAUCSJHh6euLFAT5Qq9UoLJUhy0Byeo7hMpjyEeaPP/6I7OzsKrtFl0ajwYQJExAUFGTysxDJcK5evYrY2Fj07dv3vpcxPans7GwsXrwYV69exeuvv44XXniBy64WRpZlxMXFoUOHDujatavoOEKVzwaXZUCSYNAjTJMtzI0bN+L8+fP46KOPqvR58/PzERAQgLi4ON6ZgXQmyzKWLVuGkydPIjAwsEq+dw4fPoyVK1eiRo0aGDFihElfC0qVVz6x7OWXX0anTp1ExzEKqVl5PIepqy1btuD06dN6uWUNAGRmZmL69Om8RpMe26VLlxAXF4chQ4agY8eOj/31JSUl+PHHH/H777+jbdu2GDJkCKytrfWQlEyBLMuIiopCjx498OKLL4qOYzHMpjB37NiBw4cPw9/fX6+vc+rUKSxZsgSRkZFc/qLHIssyFi1ahPPnz2PSpEk6Xd6RlZWFRYsWITs7GwMHDkSHDh0MkJSMmSzLiIiIQJ8+ffD888+LjmNRzKIwd+/ejd9++w2BgYEGe70//vgDn3zyiUFej8zL33//jfj4eIwYMQJeXl73/ZxDhw7hhx9+QM2aNfHOO+/w3DkBKBsdFx4ejoEDB6Jdu3ai41gcky/Mffv2YceOHZg8ebJBj/hWrVoFACY7dorE0mq1+PLLL3H9+nUMHPEhDl+8hefq1cAfu7YgOTkZ7dq1wxtvvGFW9wykJ6PVahEaGgpvb2+0adNGdByLZNKFefDgQWzcuBFTpkwRsjw6d+5cPPfcc+jcubPBX5vMw86U4xi16kzF9++sV53x+is8J0V30mg0CAkJwdtvv21S9480NyZ7Hebhw4exbt06YWUJAOPGjcPPP/+MU6dOCXl9Mn2ZWntYWVmhFEqo1VYorM5rJ+lOpaWlCA4OxogRI1iWRsqoC/Po0aNYuXIlIiIihG68kSQJ4eHhmD9/PjIzM4XlINPl5eYESZJgq1ZCkso+JipXWlqKoKAgjBo1Ci1atBAdhx7AaJdkT548iYULFyImJgYKhXH0Oq/RpCeh72vHyDSVlJQgMDAQY8aMMap7QloykzqHeebMGXz++eeYMWOG0d2N+8qVK4iNjcWsWbOMLhsRmY7UrDzsO5uFX1Z9hZBx76FBgwaiI9E/TOYcZlpaGubPn4/Y2FijLKTatWvjww8/REREBB72ywYR0YOUj3ebsv4v7KnWEbK9s+hIpAOjKsyMjAzMmTMHM2bMMOoJO82bN0f37t3x2WefiY5CRCYoOT0HsgxooIQkSQYdIE6VZzSFefHiRcTHx2PGjBkmcU1aly5d8NRTT2H16tWioxCRiSnbBAaoJRmyVuYmMBNhFIVZfl5wxowZJjU3c+jQoTh//jz27t0rOgoRmRB3Z3skje2EKX2boY/yCDeBmQjhhZmVlYWoqCjMmDEDtra2ouM8Nl9fX2zatAmnT58WHYWITIi7sz2Gd2wE6+Kb0Gg0ouOQDoQW5rVr1zB16lTExsbCzs5OZJRKkyQJERER+Oyzz3D16lXRcYjIxHTp0gW7du0SHYN0IKwwb9y4gSlTpiAmJgb29qa9HKFSqRAdHY2IiAjcvn1bdBwiMiE9evTAtm3bRMcgHQgpzNzcXISEhCAqKgo1atQQEaHK2dvbIzQ0FCEhIVxeISKdqVQqKJVKFBUViY5Cj2DwwszLy0NwcDAiIyPh6Oho6JfXK1dXV7z33nuYNm2a6ChEZEL69OmDTZs2iY5Bj2CwwkzNysN3e89ibHAkwsPDUatWLUO9tEF5eHigS5cumD9/vugoRGQiOnTogN9//110DHoEgxRm+VSLyE0n8btjN+RJprnBR1fdunWDo6Mj1qxZIzoKEZkASZJQvXp13Lx5U3QUegiDFGb5VIsSrQTAMqZaDBs2DOnp6di3b5/oKERkAgYNGsRfso2cQQqzfKqFpd3ayM/PD+vXr8eZM2dERyEiI9e8eXOcPHlSb8+fmpWHFckZSM3K09trmDuDDGwtn2phabc2kiQJkZGR8Pf3R3h4OJ566inRkYjIiLm6uuLy5ctwdXWtkucrLCxEWloa9h1LRewhGUpV2ezapLGdLOZ9uCoZbMK5u7O9Rf4HUqvVmD59OoKCghAfH2+S04yIyDCGDBmCVatW4ZNPPtHp82VZRmZmJlJTU5Gamor09HSUlJRU/L21tTUaNGiATEUdSIo8FJRoYatWIDk9xyLfj5+U8d4SxIxUr14dISEhmDx5MuLj443ytmVEJF7dunVx8tJ1rEjOqFiNKygoQFpaWkUpZmdnQ5Kkiq+pXbs23N3d0aFDBwwZMuS+87hTs/Lw3fE9sJI1KC0ttZjTYlXNKG8gba7++usvrFmzBuHh4aKjEJERSs3KQ6/EX6DVypAkoJ/qKJ62k9CgQQO4u7vD3d0dtWrVuqMwH+e5k9NzcPHwLjRxdUC/fv308C8wDw+6gTSPMA2oVatWuHr1KhYsWICPPvpIdBwiMjIH0nOg1WqhkVSwVSvxYn8feHs9WyXPXXFazMsH0dHReOaZZ9CmTZsqeW5LIfxuJZame/fusLe3x7p160RHISIjo7l8CkqlUu9XFAQHB+Pbb7/F5cuX9fL85oqFKYCPjw9Onz7NyR5EVEGWZSTv2IifxnfB1P4t9LqTVaFQIDo6GlFRUbxhxGNgYQoyceJErF27FufOnRMdhYiMwMaNG9G3b180dK4Ob69n9b6L1c7ODiEhIQgNDYVWq9Xra5kLFqYgkiRh2rRpmD17NrKzs0XHISKBtFottm3bhh49ehj0devUqYPhw4cjLi7OoK9rqliYAqnVakRHRyM8PByFhYWi4xCRIGvWrMHgwYMrtfv1ST333HNo0aIFli5davDXNjUsTMFq1KiB4OBghISEcFmEyAJpNBr89ttv6Ny5s7AMAwYMQE5ODnbv3i0sgylgYRqBevXq4Z133kF0dDTnPRJZmGXLlmHYsGGiY2Ds2LH46aefuK/iIViYRqJ169Zwa/U8eiX+gqkbjqPfvD0sTSIzV1JSgsOHD8PLy0t0FEiShIiICCQmJuLGjRui4xglFqYRsarbHJIkoaBEU7bF3AJug0ZkyRYvXox33nlHdIwKarUa06ZNQ1hY2B0zaakMC9OIeLk5QaVSwUYlobi4GIXnj4mORER6UlhYiFOnTqFVq1aio9zB0dERvr6+mDp1Kh42OtUSsTCNSPlt0CIGtMTWCd1RQypEQEAAMjMzRUcjoir2zTffYNSoUaJj3FejRo3Qq1cv/Pe//xUdxaiwMI2Mu7N9xUXLAwcORGhoKObPn4+FCxfytz0iM5Gfn48LFy6gadOmoqM80Msvv4waNWogKSlJdBSjwcI0cjVq1EBERASaN28OX19fvd6RnYgM48svv8QHH3wgOsYj+fj44MiRI/jzzz9FRzEKLEwT8cILL2DWrFn46aefMHPmTBQVFYmORESVkJubi2vXrsHNzU10FJ0EBQVh0aJFHNQOFqZJUavV8PPzw6BBgxAQEMCLjIlMkKnd3k+hUCAqKoqD2sHCNEkNGzbE7NmzkZGRgZCQEFy/fl10JCLSQU5ODgoLC1G3bl3RUR6LnZ0dQkNDLX5QOwvTREmShLfffhv+/v6Ii4vDihUruCmIyMj997//Namjy39zdXXFiBEjMGPGDNFRhGFhmrhatWohJiYGzs7O8PPzQ3p6uuhIRHQfmZmZkCQJLi4uoqNUWtu2bdGyZUssWbJEdBQhWJhm4pVXXkFsbCyWL1+OuXPnorS0VHQkIvqXBQsWYPTo0aJjPLH+/fvj5s2b2LVrl+goBsfCNCM2NjYICgpC9+7d4efnh4MHD4qOREQALly4ADs7Ozg6OoqOUiXGjBmDLVu24OzZs6KjGBQL0wx5eHhgzpw5OHz4MCIiIpCXxyHuRCJ9/vnnJnvu8n4kScLUqVMxe/Zsi9p0yMI0UwqFAu+99x4++OADREREcFoHkSCpqal46qmnUL16ddFRqpQlDmpnYZo5V1dXzJw5EwAwceJEXnxMZGBffvkl3n//fdEx9MLR0RF+fn4WM6idhWkh+vXrh6lTp+KLL77Al19+adHXUhEZQmpWHmZvOAB7V3fY2dmJjqM3DRs2RO/evTF//nzRUfSOhWlB7O3tER4ejnbt2sHX1xfHjvH2YUT6kJqVh37z9mDeb1ewJPsZs78ZfOfOnVGzZk1s2LBBdBS9YmFaoPbt2yMxMRE7duxATEwMCgsLRUciMivJ6TnQamWUQlnxsbnz8fHB0aNHcfjwYdFR9IaFaaFUKhXGjRuHYcOGISgoCDt27BAdichseLk5QaMphY1KgiSVfWwJAgMDsXjxYrPdK8HCtHBubm5ITExEdnY2goKCkJ2dLToSkclr8FQ1vKpJQcSAlkga2wnuzvaiIxmEuQ9qlx62s8nT01Pmxe+W4/r164iPj0fz5s3x9ttvQ5Ik0ZGITNKhQ4dw5swZeHt7i44ixOXLlxEXF4dZs2ZBoTC94zJJklJkWfa8+3HT+5eQ3jg6OiI6Ohr169fH+PHjce7cOdGRiEzSunXr8Prrr4uOIYyrqyveffddsxvUzsKke3Tu3BlxcXFYs2YNEhMTLeaiZKKqUFRUBFmWYWNjIzqKUG3atEGrVq3w3XffiY5SZViYdF/W1taYNGkS+vTpgwkTJmD//v2iIxGZhPXr12PAgAGiYxiFfv36ITc3F7/++qvoKFWChUkP1bRpU8yZMwcnT57ElClTkJubKzoSkVFLSUlB+/btRccwGmPGjMHWrVvNYlA7C5MeSZIkvPvuuxg7diyio6Oxdu1a0ZGIjNLFixfh6urKDXP/IkkSwsPDMWfOHJMf1M7CJJ25uLhgxowZsLOzg7+/Py5cuIDUrDysSM4w+0kmRLpYvnw5hg0bJjqG0TGXQe0q0QHI9PTq1QudO3dGePxn+LGwGVQqFSRJsqjrzYjuJssyrl69ChcXF9FRjJKDgwP8/PwQHh6O6OhokzwK5xEmVYqdnR08X/OGQqFEQYkWGo3WIsZ/ET3I/v378eKLL4qOYdQaNmyIPn364LPPPhMdpVJYmFRpXm5OUCoVsFUroNVqcHDzShQUFIiORSTEpk2b0LdvX9ExjF6nTp3g6OiI9evXi47y2FiYVGnuzvZIGtsJU/t7YItfN4x7501MnjwZ27ZtEx2NyKBu374NlUoFtVotOopJePvtt3H8+HH88ccfoqM8FhYmPRF3Z3t4ez0Ld2d7PPvss0hISMCNGzcQGBjIubRkMdasWYNBgwaJjmFSAgICsGTJEly6dEl0FJ2xMKlKSZKEN954A0FBQUhMTMSSJUss4k7sZNmOHj2KVq1aiY5hUsoHtUdHRyM/P190HJ2wMEkv/j2X1tfXl3NpyWylp6fj2WefFR3DJNna2iIsLAyhoaHQarWi4zwSC5P0qnPnzpg5cyZWr16N2bNnm/Q1WET3s3z5cgwdOlR0DJNVu3ZtjBw5ErGxsaKjPBILk/TO2toaAQEB6NWrF/z9/ZGcnCw6ElGV0Gq1uHHjBpycLOMG0frSunVrtGnTxugHtbMwyWCaN2+OOXPm4MiRI5g6dSpu3brFSUFk0n799Vd06dJFdAyz0LdvX+Tl5Rn1oHZO+iGDUigUGDVqFC5fvoyJEXH4xboDlEolJwWRSdq6dSumTZsmOobZ+OijjxAWFoY6deqgcePGouPcg0eYJISrqyu6eb+P0lINCkq0KCkpwb6zWaJjEens1q1bsLOzg1KpFB3FbJQPav/000+Rk2N8k8NYmCSM8loaVColbNVKKBVK7Fv/HWbOnImsLBYnGb9Vq1bhzTffFB3D7KjVakRGRiI8PBzFxcWi49yBS7IkzIHtSdg0MQwpGTfg5eYEd+c+uHLlCr755hvk5uZi2LBhaNmypeiYRPd1+vRp/Oc//xEdwyyVD2r3C49B50Ej8bybk1GcrmFhkhBnzpyBu7s7Gj1dA42erlHxeO3atREYGIjCwkIsW7YM3377Lbp164bXXnsNCgUXRMg4nD59Go0aNRIdw7xVd8E2pSd+/vEI1CqVUexx4DsQCfHdd99hxIgRD/x7GxsbjBw5EjNnzoSdnR0CAwOxYMEC5OXlcWctCbdy5Uoux+pZcnoOFAolSrQSZBlGcTckHmGSwV27dg02NjaoVq3aIz9XkiR069YN3bp1w5kzZxAa9ymSSjygUqmgUCiM4rdOsiwajQb5+fmoUaPGoz+ZKs3LzQmSBNiqlZCkso9FY2GSwS1cuBAjR4587K9r3LgxXuz/NrZsOIaCEi1s1WW/dbIwyZC2bt2KV199VXQMs1d+N6Tk9Jx/9jiI/znnkiwZ1MmLOUjOUaNAVb1SX+/l5gQZgAQtZMhG8VsnWZadO3eia9euomNYhH/fDckYsDDJYM5l3UL/z/bisKIx+s3b80TnIKUqzEWkq+vXr8PBwYEb0CwU/6uT3smyjI0bN2JC7H8hSQoUaeRKn8RPTs+BBAlaKCBBMoqNAGQ5VqxYAW9vb9ExSBAWJulNeVH6+fnBysoKs4JGVwwqqOxJfGPcCECWIy0tDQ0aNBAdgwThph+qcrIs46effsLWrVvRp08fJCYmQpLKFlGf9CS+MW4EIMtw9OhReHh4iI5BArEwqcqUF+XPP/+MPn36ICEhoaIoy7k72z9xyVXFcxA9rtWrV2PixImiY5BALEx6YncX5b+PKInMQUlJCYqLi3W6dpjMFwuTKo1FSZZi06ZN6NOnj+gYJBg3/dBjKy9Kf39/qFQqJCYmomfPnixLMlu//fYbXnrpJdExSDAeYZLOZFnG5s2bsWXLlgeeoyQyN1evXoWzszO/14mFSY/276J87bXXuPRKFmX58uUYNmyY6BhkBCy2MFOz8nhpwiOwKMnSybKMixcvom7duqKjkBGwyMJMzcpDv3l7IMuAJIF3vLiLLMvYsmULtmzZgt69e7MoyWIdOnQI7dq1Ex2DjIRFbvpJTs9BcXEJCko0RnOfNWNQfkTp7+8PSZKQkJCAXr16sSzJYq1btw6vv/666BhkJCzyCLOpkwqAzPFq/7j7iJKbeYiAwsJCAGU3MycCLLQwj+3/BfMHeOC6ysmiz2GWF+XmzZtZlER3Wb9+PQYMGCA6BhkRyyzMY8cQ/dZbFlsOsizj559/xubNm9GrVy+eoyS6j5SUFAwZMkR0DDIiFleYhYWFsLa2tsiCuLsoeURJdH/7jp5DjkNTpGXnW+wKFN3L4jb9bNu2DT169BAdw6DKl179/f0hyzISEhLQu3dvliXRfZzLugWfJUexK//pJ77ROZkXiyvM/fv344UXXhAdwyBYlESPp6CgAIEzv4BSpUKRBtBoNNxFTxUsqjA1Gg0AQKlUCk6iX+VLr/7+/tBqtSxKIh1cvnwZEydOhP+I/4NKqYStWgGNRovrZ1JERyMjYVHnMM19gLIsy9i6dSt++ukn9OzZk+coiXSUkpKC77//HjNnzoSdnR2Snn66YhLYge1JmDt3LsaNG8efJwtnUUeY27dvR/fu3UXHqHL/PqLUaDRISEjAa6+9xh9uIh2sWrUKO3fuRHx8POzs7ACU3aTc2+tZuDvbY+jQoWjXrh1CQ0NRUlIiOC2JZDGFeS7rFk4UOeBirvl8w7MoiSpPq9VixowZUCgUmDBhwkN/bjp16oSRI0fC398fN2/eNGBKMiaSLMsP/EtPT0/54MGDBoyjH6lZeegzdzdKSoqhVKqQ2NsFXk3r46mnnoJCYXq/M8iyjG3btmHTpk3o2bMnz08SPab8/HyEhYVh+PDheO6553T+upycHISFhWHSpElwc3PTX0ASSpKkFFmWPe9+3CLOYSan50CSAI2kgkoCdp24hL//SkZWVha0Wi0kSUL5Lw5WVlaoXbs26tSpgzp16sDV1dVoivXfRfnqq6/yHCVRJWRkZCA2NhZTpkxB7dq1H+trnZyckJiYiLCwMAwaNAgdOnTQU0oyRhZRmF5uTpAkqWJ27IcDuzzwYuTi4mJcuXIFly5dQmpqKvbs2YPs7GzIsox/H41bWVnB1dX1jmKtVauWXoqVRUlUNfbt24e1a9ciISGh0jNiraysEBsbi8TERFy4cAGDBw+u4pRkrCxiSRao+vtfFhUVVRTr5cuXcenSJWRnZwNARbFKknRHsZb/b61atR5aeOVZPd0ckfbn79i0aRN69OjB85NET2Dp0qXIzs7GJ598UmU/RytWrMCVK1eq9DlJvActyVpMYYpSWFiIK1euVJTqpUuXkJOTA61WCwAVy8HW1taoU6cOFDVrY/ohLbRaGRpNKUI9VXh3cB/+MBJVkkajQUxMDNq0aYP+/ftX+fPv3bsXSUlJiIyMhFqtrvLnJ8Oz6HOYItnY2MDNze2RGwTKi3Xp/jRotPko0UqwtbKCXX0PliVRJeXm5iIsLAzvv/8+WrZsqZfX6NixI2rXrg0/Pz9ERUXBwcFBL69D4onfyUIA/lesw7p7Qa1S/XO+VbL4e3USVVZqaiqCg4MRGhqqt7Is17BhQ0ybNg0hISFIS0vT62uROFySNUJVfb6VyNL8+uuv2LJlC6ZOnQorKyuDvW5xcTHCwsIwcOBAi5lZbY54DpOILMLChQtRWFiIjz76SMjpDFmWkZiYiGeffRZvvPGGwV+fntyDCpNLskRkFkpLSxEeHo66deti9OjRws79S5JUMX0rMTERDzsoIdPCwiQik3f9+nX4+fnhrbfeQs+ePUXHAQB4e3ujQ4cOCA4ORnFxseg4VAVYmERk0k6fPo0pU6YgMjISTZs2FR3nDi+99BLef/99+Pv74/r166Lj0BNiYRKRydq6dSuWLl2KxMREODo6io5zX+U7aMPCwpCamio6Dj0BFiYRmRxZlvH5558jIyMDERERUKmM+5JyR0dHJCQk4IsvvsC+fftEx6FKYmESkUkpLi5GaGgomjZtilGjRomOozMrKyvExMRg//79WLlypeg4VAksTCIyGdnZ2fDz88N//vMfdO3aVXScxyZJEvz8/CBJEhISEriD1sSwMInoHqlZeViRnIHUrDzRUSocO3YMkZGRiImJQcOGDUXHeSJDhgzBiy++yB20Jsa4F/6JyODKb7guSWVHREljOwmfOLVx40YcOnQIiYmJUCqVQrNUlRdffBFPP/00/P39MW3aNKPdtET/wyNMIqpw+fJlBCd+jdLSUhSUaKHRaJCcniMsjyzLmDt3LnJychAWFmY2ZVnO3d0dUVFRCAsLw7lz50THoUdgYRIR8vLyEBcXh4ULF2Ly+96wslLDVq2AVqvF4a2rhSwbFhUVISgoCO3bt8fw4cMN/vqG4uDggISEBHz55ZfYu3ev6Dj0EJwlS2TBNBoNFi1ahNOnT+Pjjz/GM888A+DOGwBoblzGnDlz8OGHH6JVq1YGyZWZmYmIiAgEBgaifv36BnlN0WRZxpw5c+Dq6gpvb2/RcSwah68TUQVZlrF582Zs2bIF77zzDp577rmHfr5Go8G8efMgyzLGjRun16XRw4cP49tvv0VUVBTs7S3vbj0//PAD/v77b/j7+/NeuIJw+DoRASgrJD8/v4q7ajyqLAFAqVTC19cXPXr0gK+vL06fPq2XbGvXrsXmzZuRkJBgkWUJAG+88QY6duyIoKAg7qA1MjzCJLIQ58+fx2effYYmTZpgxIgRlZ6OU1JSgtmzZ8Pe3h4ffvghFIon/71blmUkJCSgXr16XI78R1paGuLj4zFt2jQ4OfFG8obEJVkiC5Wbm4t58+ZBpVJhzJgxVXbklpKSgm+//RYTJkyAm5tbpZ+noKAAYWFh8Pb2hpeXV5VkMxc3btxAaGgo/Pz8TP7aU1PCwiSyMCUlJfj6669x/vx5jB07Fq6urlX+GoWFhYiPj0edOnUwcuTIxz7ndvHiRURHRyMkJAR169at8nzmoKSkBFOmTEG/fv3QsWNH0XEsAguTyELIsox169Zh165d+M9//oOWLVvq/TV/++03rFixAgEBAToXX3JyMlasWIFp06bB1tZWzwlNW/n1qLVr1+aStQGwMIkswIEDB/D999+jf//+6N69u0FfOz8/HzNnzkSTJk0wbNiwhx5trlixAhcvXqyYq0q6Wb16NdLT07mDVs+4S5bIjKWlpSEgIACnTp1CQkKCwcsSAKpVq4apU6eidu3amDBhAq5evXrP52i1WsTExMDKyopv+pUwePBgdOrUCYGBgSgqKhIdx+LwCJPIhF2/fh2ffvop7O3tMXr0aKNZ2szNzUVsbCw8PT3RtnNPJKfnwMPFBl8lTse7776Ltm3bio5o0tLT0zFz5kzuoNUTLskSmZGioiJ88cUXyMrKwtixY+Hi4iI60n0t/GEjog5qoFKpUFpaguXvtoVXM8uY3KNv5Ttox48fj0aNGomOY1a4JEtkBmRZxsqVKzF58mT07NkTkZGRRluWAGBXvxXUVmoUaWRYWVkh9RaXYKuKg4MDEhMT8c0332DPnj2i41gEFiaRidizZw/Gjx8PV1dXzJo1C02bNhUd6ZG83JygkCQooYEkSfBy4/JhVVKr1YiOjsahQ4ewbNky0XHMHguTyMidPn0aEydOxMWLF5GYmIjOnTuLjqQzd2d7JI3thAF1ijC3Tx3h99U0R5Ik4ZNPPoG1tTVmzpyJh51moyfDwiQyUllZWQgPD8eWLVsQHR0Nb2/vKhlDZ2juzvb4oEdLZJ79S3QUszZo0CB06dIFAQEB3EGrJ5UbJklEelNQUIAFCxbg1q1b8PX1NYtdkE2aNMHy5ctFxzB7zz//PJ5++mn4+/sjMjIStWrVEh3JrLAwiYyEVqvF0qVL8ddff+Gjjz6Cu7u76EhVRqlUQqvVio5hEerXr4/p06cjNDQUn3zyCRo3biw6ktkwvfUdIjOTmpWHqd/9jPf9Q9CkSRPExcWZVVmWkySJpWkgNWvWREJCAr799lvs2rVLdByzwcIkEig1Kw+9Z/+K708WY1/NLnB29xAdSW8aNmyIc+fOiY5hMdRqNaKiovDnn3/i+++/Fx3HLLAwiQRKTs+BUqlEsVaCLJd9bK7at2+PQ4cOiY5hUSRJwrhx42Bra4u4uDjuoH1CLEwigbzcnCBJgK1aCUmCWV+n2KxZM5w4cUJ0DIs0cOBAdOvWDZMmTeIO2ifATT9EApVfp5icngMvNyezvk5RpVJBo9GIjmGxvLy84OLiAj8/P0RGRiJXtrGI77uqxMIkEszd2d6i3rBkWeZdSgSpX78+YmJi4Bsajf0OXSFJCkgSkDS2k0V9D1YWl2SJyGAaNGiA9PR00TEsWs2aNdHTZwy0WhkFJRqzP3delViYRGQw7dq1Q0pKiugYFu8F96egUikt4tx5VWJhEpHBeHh44NixY6JjWLzyc+dT+7fgcuxj4DlMIjIYtVqNnBIVViRncLOJYJZ27rwqsDCJyGBSs/KwUdMKP284BkmSeHRDJoVLskRkMMnpOVCr1Sgo0XKzCZkcFiYRGUzZoAaJm03IJHFJlogMxpIGNZD5YWESkUFxswmZKi7JEhER6YCFSUREpAMWJhERkQ5YmERERDpgYRIREemAhUlERKQDFiYREZEOWJhEREQ6YGESERHpgIVJRESkAxYmERGRDiRZlh/8l5KUBeBvw8UhIiISrr4sy853P/jQwiQiIqIyXJIlIiLSAQuTiIhIByxMIiIiHbAwiYiIdMDCJCIi0sH/A5mXk1iuYO8cAAAAAElFTkSuQmCC\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Mit Bottleneck 1968.7084598792173: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2081.351724240764: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2271.371612044141: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2295.409767340028: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2312.970600764307: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2318.9570931778794: Unzusammenhängender Graph!\n",
+      "Mit Bottleneck 2319.200293204535: Unzusammenhängender Graph!\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 576x432 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "greedy = GreedyDBST(points, 3)\n",
+    "greedy_edges = greedy.solve()\n",
+    "draw_edges(greedy_edges)\n",
+    "solver = DBSTSolverSAT(points, 3, solution=greedy_edges)\n",
+    "edges = solver.solve()\n",
+    "draw_edges(edges)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "c9146e88-1246-4805-b0fd-a6d2a74717dd",
+   "metadata": {},
+   "source": [
+    "## Code zum Speichern und Laden von Instanzen"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "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": 15,
+   "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": 16,
+   "id": "dd75e5a6-ed91-471c-be28-c91cb9335f56",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "save_instance('test_instance.json', points, {'test_size': 40})"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 20,
+   "id": "c7ca8a98-c8f3-4d8d-9547-cb0d851c268d",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "instance = load_instance('test_instance.json')\n",
+    "metadata, points = instance['meta'], instance['points']"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.7.12"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}